Module Contents

AbstractCashFlow(progressTracker:

Module Contents

abstract class AbstractRequest

)

Module Contents

AbstractRequest(amount:

)

@Suspendable protected fun finaliseTx(tx:

sessions

message

)

object FINALISING_TX : Step

object GENERATING_TX : Step

Module Contents

recipient

)

object SIGNING_TX : Step

abstract class AbstractCashSelection

Module Contents

AbstractCashSelection(maxRetries:

retrySleep

retryCap

protected abstract fun executeQuery(connection:

)

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

fun getInstance(metadata: () ->

)

val instance:

AtomicReference

protected abstract fun isCompatible(metadata:

)

abstract fun toString():

@Suspendable fun unconsumedCashStatesForSpending(services:

amount

@DoNotImplement abstract class AbstractParty :

onlyFromIssuerParties

notary

lockId

withIssuerRefs

)

State

Module Contents

AbstractParty(owningKey:

@CordaInternal companion object Companion : Internable<

)

Module Contents

)

abstract fun nameOrNull():

val owningKey:

abstract fun ref(bytes:

)

fun ref(vararg bytes:

)

abstract class AbstractStateReplacementFlow

Module Contents

AbstractStateReplacementFlow()

abstract class Acceptor<in T> :

Module Contents

)

progressTracker

)

object APPROVING : Step

val initiatingSession:

protected abstract fun verifyProposal(stx:

proposal

Proposal

)

abstract class Instigator<out S :

out

out

Module Contents

Instigator(originalState:

modification

progressTracker

protected abstract fun assembleTx(): UpgradeTx

)

open fun getParticipantSessions():

data class Proposal<out M>

Module Contents

Proposal(stateRef:

enum class AccrualAdjustment

modification

)

Module Contents

)

Module Contents

Adjusted

Unadjusted

data class Actor

Module Contents

Actor(id: Id, serviceId:

owningLegalIdentity

)

Module Contents

)

enum class AggregateFunctionType

owningLegalIdentity

)

Module Contents

interface AllPossibleRecipients :

object AlwaysAcceptAttachmentConstraint :

Module Contents

)

data class Amount<T :

Module Contents

Amount(tokenQuantity:

token

)

Amount(quantity:

displayTokenSize

token

)

fromDecimal

(

displayQuantity

token

rounding

RoundingMode

)

@JvmStatic fun getDisplayTokenSize(token:

)

operator fun minus(other:

)

@JvmStatic fun parseCurrency(input:

)

fun splitEvenly(partitions:

)

)

sumOrNull

(

)

sumOrThrow

(

)

sumOrZero

(

token

)

)

)

zero

(

token

)

class AmountTransfer<T :

AmountTransfer(quantityDelta:

Module Contents

token

source

destination

)

newRef

)

)

fromDecimal

(

displayQuantityDelta

fun novate(centralParty: P):

token

source

destination

rounding

)

)

zero

(

token

source

destination

)

class AnonymousParty :

AnonymousParty(owningKey:

Module Contents

interface AppServiceHub :

)

fun create(owningKey:

)

)

abstract fun register(priority:

Module Contents

abstract val database:

CordaTransactionSupport

observer

ServiceLifecycleObserver

)

open fun <T> register(priority:

func

(

)

const val SERVICE_PRIORITY_HIGH:

const val SERVICE_PRIORITY_LOW:

const val SERVICE_PRIORITY_NORMAL:

abstract fun <T> startFlow(flow:

)

abstract fun <T> startTrackedFlow(flow:

)

@DoNotImplement interface Attachment :

open fun extractFile(path:

Module Contents

outputTo

)

open fun openAsJAR():

JarInputStream

abstract val signerKeys:

@DoNotImplement interface AttachmentConstraint

abstract val ~~signers~~:

Module Contents

abstract fun isSatisfiedBy(attachment:

)

typealias AttachmentFixup =

typealias AttachmentId =

sealed class AttachmentQueryCriteria :

ChainableQueryCriteria

Module Contents

)

AndVisitor

Module Contents

AndComposition(a:

)

data class AttachmentsQueryCriteria :

Module Contents

filenameCondition

uploadDateCondition

)

)

filenameCondition

)

val contractClassNamesCondition:

filenameCondition

uploadDateCondition

contractClassNamesCondition

signersCondition

isSignedCondition

versionCondition

)

fun copy(uploaderCondition:

filenameCondition

uploadDateCondition

)

AttachmentsQueryCriteria

val filenameCondition:

fun isSigned(isSignedPredicate:

)

AttachmentsQueryCriteria

val isSignedCondition:

val signersCondition:

val uploadDateCondition:

val uploaderCondition:

val versionCondition:

)

fun withContractClassNames(contractClassNamesPredicate:

Predicate

fun withFilename(filenamePredicate:

)

AttachmentsQueryCriteria

fun withSigners(signersPredicate:

)

AttachmentsQueryCriteria

fun withUploadDate(uploadDatePredicate:

)

AttachmentsQueryCriteria

fun withUploader(uploaderPredicate:

)

AttachmentsQueryCriteria

fun withVersion(versionPredicate:

)

AttachmentsQueryCriteria

)

AttachmentsQueryCriteria

)

OrVisitor

Module Contents

OrComposition(a:

)

AttachmentResolutionException(hash:

Module Contents

)

AttachmentResolutionException(attachmentId:

Module Contents

data class AttachmentSort :

)

Module Contents

AttachmentSort(columns:

enum class AttachmentSortAttribute

AttachmentSortColumn

)

Module Contents

data class AttachmentSortColumn

Module Contents

AttachmentSortColumn(sortAttribute: AttachmentSortAttribute, direction: Direction = Sort.Direction.ASC)

val sortAttribute: AttachmentSortAttribute

interface AttachmentsQueryCriteriaParser :

AttachmentSortColumn

abstract fun parseCriteria(criteria: AttachmentsQueryCriteria):

Module Contents

@DoNotImplement interface AttachmentStorage

Predicate

Module Contents

abstract fun getLatestContractAttachments(contractClassName:

minContractVersion

)

abstract fun hasAttachment(attachmentId:

)

abstract fun ~~importAttachment~~(jar:

)

abstract fun importAttachment(jar:

uploader

filename

)

abstract fun ~~importOrGetAttachment~~(jar:

)

)

abstract fun queryAttachments(criteria:

sorting

)

open fun queryAttachments(criteria:

)

@Target([AnnotationTarget.PROPERTY]) annotation class AutoAcceptable

data class AuthServiceId

Module Contents

)

Module Contents

AutoAcceptable()

object ~~AutomaticHashConstraint~~ :

Module Contents

)

object AutomaticPlaceholderConstraint :

Module Contents

)

interface BaseQueryCriteriaParser<Q :

abstract fun parse(criteria: Q, sorting: S? = null):

Module Contents

abstract fun parseAnd(left: Q, right: Q):

Predicate

abstract fun parseOr(left: Q, right: Q):

Predicate

@DoNotImplement abstract class BaseTransaction :

Predicate

abstract class BaseSort

Module Contents

BaseSort()

Module Contents

BaseTransaction()

filterOutputs

(

clazz

predicate

)

filterOutputs

(

crossinline

predicate

(

)

)

filterOutRefs

(

clazz

predicate

)

filterOutRefs

(

crossinline

predicate

(

)

)

findOutput

(

clazz

predicate

)

findOutput

(

crossinline

predicate

(

)

)

findOutRef

(

clazz

predicate

)

findOutRef

(

crossinline

predicate

(

)

)

)

abstract val outputs:

outputsOfType

(

clazz

)

outputsOfType

(

)

outRef

(

index

)

outRef

(

state

)

outRefsOfType

(

clazz

)

outRefsOfType

(

)

@Target([AnnotationTarget.CLASS]) annotation class BelongsToContract

Module Contents

BelongsToContract(value:

out

)

out

data class BilateralNetState<P :

BilateralNetState(partyKeys:

Module Contents

interface BilateralNettableState<N :

template

Terms

)

abstract val bilateralNetState:

Module Contents

abstract fun net(other: N): N

enum class BinaryComparisonOperator :

enum class BinaryLogicalOperator :

Module Contents

GREATER_THAN

GREATER_THAN_OR_EQUAL

LESS_THAN

LESS_THAN_OR_EQUAL

class BrokenAttachmentException :

Module Contents

AND

BrokenAttachmentException(attachmentId:

Module Contents

message

cause

)

Module Contents

avg

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~avg~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

avg

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

between

(

from

)

ColumnPredicateExpression

~~between~~

(

from

)

ColumnPredicateExpression

between

(

from

)

ColumnPredicateExpression

between

(

from

)

Between

compare

(

operator

value

)

BinaryComparison

comparePredicate

(

operator

value

)

ColumnPredicateExpression

~~comparePredicate~~

(

operator

value

)

ColumnPredicateExpression

comparePredicate

(

operator

value

)

ColumnPredicateExpression

count

(

)

AggregateFunctionExpression

~~count~~

(

)

AggregateFunctionExpression

count

(

)

AggregateFunctionExpression

equal

(

value

exactMatch

)

ColumnPredicateExpression

~~equal~~

(

value

exactMatch

)

ColumnPredicateExpression

equal

(

value

exactMatch

)

ColumnPredicateExpression

@JvmOverloads fun <R> equal(value: R, exactMatch:

)

EqualityComparison

functionPredicate

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~functionPredicate~~

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

functionPredicate

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

greaterThan

(

value

)

ColumnPredicateExpression

~~greaterThan~~

(

value

)

ColumnPredicateExpression

greaterThan

(

value

)

ColumnPredicateExpression

greaterThan

(

value

)

BinaryComparison

greaterThanOrEqual

(

value

)

ColumnPredicateExpression

~~greaterThanOrEqual~~

(

value

)

ColumnPredicateExpression

greaterThanOrEqual

(

value

)

ColumnPredicateExpression

greaterThanOrEqual

(

value

)

BinaryComparison

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

fun <R> isNotNull(): NullExpression<R>

)

CollectionExpression

fun <R> isNull(): NullExpression<R>

isNull

(

)

ColumnPredicateExpression

~~isNull~~

(

)

ColumnPredicateExpression

isNull

(

)

ColumnPredicateExpression

lessThan

(

value

)

ColumnPredicateExpression

~~lessThan~~

(

value

)

ColumnPredicateExpression

lessThan

(

value

)

ColumnPredicateExpression

lessThan

(

value

)

BinaryComparison

lessThanOrEqual

(

value

)

ColumnPredicateExpression

~~lessThanOrEqual~~

(

value

)

ColumnPredicateExpression

lessThanOrEqual

(

value

)

ColumnPredicateExpression

@JvmOverloads fun like(string:

lessThanOrEqual

(

value

)

BinaryComparison

exactMatch

)

Likeness

(

string

exactMatch

)

ColumnPredicateExpression

~~like~~

(

string

exactMatch

)

ColumnPredicateExpression

(

string

exactMatch

)

ColumnPredicateExpression

max

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~max~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

max

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

min

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~min~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

min

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

notEqual

(

value

exactMatch

)

ColumnPredicateExpression

~~notEqual~~

(

value

exactMatch

)

ColumnPredicateExpression

notEqual

(

value

exactMatch

)

ColumnPredicateExpression

@JvmOverloads fun <R> notEqual(value: R, exactMatch:

)

EqualityComparison

notIn

(

collection

exactMatch

)

ColumnPredicateExpression

~~notIn~~

(

collection

exactMatch

)

ColumnPredicateExpression

notIn

(

collection

exactMatch

)

ColumnPredicateExpression

notIn

(

collection

exactMatch

@JvmOverloads fun notLike(string:

)

CollectionExpression

exactMatch

)

Likeness

notLike

(

string

exactMatch

)

ColumnPredicateExpression

~~notLike~~

(

string

exactMatch

)

ColumnPredicateExpression

notLike

(

string

exactMatch

)

ColumnPredicateExpression

notNull

(

)

ColumnPredicateExpression

~~notNull~~

(

)

ColumnPredicateExpression

notNull

(

)

ColumnPredicateExpression

predicate

(

predicate

)

ColumnPredicateExpression

~~predicate~~

(

predicate

)

ColumnPredicateExpression

predicate

(

predicate

)

ColumnPredicateExpression

sum

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~sum~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

sum

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

open class BusinessCalendar

Module Contents

BusinessCalendar(holidayDates:

SortedSet

open fun applyRollConvention(testDate:

)

dateRollConvention

DateRollConvention

)

@JvmStatic fun calculateDaysBetween(startDate:

endDate

dcbYear

dcbDay

)

@JvmStatic fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

endDate

periodOffset

)

)

@JvmStatic fun getOffsetDate(startDate:

period

steps

)

open fun isWorkingDay(date:

)

fun moveBusinessDays(date:

direction

)

@JvmStatic fun parseDateFromString(it:

)

sealed class ByteSequence :

)

Module Contents

open fun compareTo(other:

)

@JvmStatic @JvmOverloads fun of(bytes:

)

offset

size

)

)

end

)

fun subSequence(offset:

size

)

)

)

Commands

State

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

fun deriveState(txState:

fun extractCommands(commands:

State

amount

owner

)

State

)

Commands

fun generateExitCommand(amount:

)

Exit

tokenDef

pennies

owner

notary

)

fun generateMoveCommand(): Move

amount

owner

notary

)

Module Contents

amount

owner

)

owner

)

)

infix fun issuedBy(party:

infix fun issuedBy(deposit:

)

State

)

State

infix fun ownedBy(owner:

)

State

infix fun withDeposit(deposit:

)

State

)

newOwner

)

)

class CashException :

Module Contents

CashException(message:

cause

@InitiatingFlow @StartableByRPC class CashExitFlow :

)

CashExitFlow(request: ExitRequest)

Result

Module Contents

issuerRef

)

issuerRef

progressTracker

)

class ExitRequest : AbstractRequest

Module Contents

issuerRef

)

@InitiatedBy(NormalClass(value=net/corda/finance/flows/CashExitFlow)) class CashExitResponderFlow :

CashExitResponderFlow(otherSide:

Module Contents

)

@StartableByRPC class CashIssueAndPaymentFlow :

Result

Module Contents

CashIssueAndPaymentFlow(request: IssueAndPaymentRequest)

issueRef

recipient

anonymous

notary

)

issueRef

recipient

anonymous

notary

progressTracker

)

class IssueAndPaymentRequest : AbstractRequest

Module Contents

IssueAndPaymentRequest(amount:

issueRef

recipient

notary

anonymous

)

val ISSUING_CASH: Step

val PAYING_RECIPIENT: Step

@StartableByRPC class CashIssueFlow :

Result

Module Contents

CashIssueFlow(request: IssueRequest)

issuerBankPartyRef

notary

)

issuerBankPartyRef

notary

progressTracker

)

class IssueRequest : AbstractRequest

Module Contents

issueRef

notary

)

@StartableByRPC @InitiatingFlow open class CashPaymentFlow :

Result

Module Contents

recipient

)

recipient

anonymous

)

CashPaymentFlow(request: PaymentRequest)

recipient

anonymous

notary

)

@Suspendable open fun call(): Result

recipient

anonymous

progressTracker

issuerConstraint

notary

)

class PaymentRequest : AbstractRequest

Module Contents

PaymentRequest(amount:

recipient

anonymous

issuerConstraint

notary

)

@InitiatedBy(NormalClass(value=net/corda/finance/flows/CashPaymentFlow)) class CashPaymentReceiverFlow :

CashPaymentReceiverFlow(otherSide:

Module Contents

)

object CashSchema

object CashSchemaV1 :

Module Contents

PersistentCashState(owner:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

class CashSelectionH2Impl :

Module Contents

CashSelectionH2Impl()

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

class CashSelectionPostgreSQLImpl :

CashSelectionPostgreSQLImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

class CashSelectionSQLServerImpl :

CashSelectionSQLServerImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

val JDBC_DRIVER_NAME_REGEX:

Module Contents

@JvmStatic @Suspendable fun ~~generateSpend~~(services:

amount

onlyFromParties

)

@JvmStatic @JvmOverloads @Suspendable fun generateSpend(services:

amount

ourIdentity

onlyFromParties

anonymous

)

@JvmStatic @Suspendable fun ~~generateSpend~~(services:

payments

onlyFromParties

)

@JvmStatic @JvmOverloads @Suspendable fun generateSpend(services:

payments

ourIdentity

onlyFromParties

anonymous

)

interface CheckpointCustomSerializer<OBJ, PROXY>

Module Contents

abstract fun hasListed(type:

interface ClassWhitelist

Module Contents

)

data class ClientRpcSslOptions

interface ~~ClientRelevantError~~

Module Contents

ClientRpcSslOptions(trustStorePath:

trustStorePassword

trustStoreProvider

)

val trustStorePassword:

val trustStorePath:

val trustStoreProvider:

@DoNotImplement abstract class ClusterSpec

Module Contents

ClusterSpec()

abstract val clusterSize:

Module Contents

)

enum class CollectionOperator :

Module Contents

@Suspendable class CollectSignatureFlow :

Module Contents

session

vararg

signingKeys

)

session

signingKeys

)

class CollectSignaturesFlow :

Module Contents

sessionsToCollectFrom

progressTracker

)

sessionsToCollectFrom

myOptionalKeys

progressTracker

)

object COLLECTING : Step

val myOptionalKeys:

val sessionsToCollectFrom:

sealed class ColumnPredicate<C>

class Column<O, out C>

Module Contents

)

)

)

declaringClass

)

Module Contents

data class AggregateFunction<C> :

Module Contents

AggregateFunction(type:

)

val type:

data class Between<C :

Between(rightFromLiteral: C, rightToLiteral: C)

Module Contents

val rightFromLiteral: C

val rightToLiteral: C

data class BinaryComparison<C :

BinaryComparison(operator:

Module Contents

rightLiteral

)

data class CollectionExpression<C> :

CollectionExpression(operator:

Module Contents

rightLiteral

)

data class EqualityComparison<C> :

EqualityComparison(operator:

Module Contents

rightLiteral

)

data class NullExpression<C> :

data class Likeness :

Module Contents

rightLiteral

)

Module Contents

NullExpression(operator:

)

data class Command<T :

Module Contents

Command(data: T, key:

Command(value: T, signers:

)

)

data class CommandAndState

Module Contents

CommandAndState(command:

ownableState

)

interface CommandData

data class CommandWithParties<out T :

CommandWithParties(signers:

Module Contents

signingParties

value

)

val signers:

val ~~signingParties~~:

val value: T

class CommercialPaper :

Module Contents

Module Contents

Commands

Module Contents

Issue()

class Move :

Commands

Module Contents

Move()

class Redeem :

Commands

Module Contents

Redeem()

const val CP_PROGRAM_ID:

ICommercialPaperState

Module Contents

owner

faceValue

maturityDate

)

)

fun withFaceValue(newFaceValue:

fun withMaturityDate(newMaturityDate:

)

ICommercialPaperState

)

ICommercialPaperState

)

fun withoutOwner(): State

fun withOwner(newOwner:

)

ICommercialPaperState

fun verify(tx:

)

object CommercialPaperSchema

object CommercialPaperSchemaV1 :

Module Contents

@Entity class PersistentCommercialPaperState :

PersistentCommercialPaperState(issuancePartyHash:

Module Contents

issuanceRef

ownerHash

maturity

faceValue

currency

faceValueIssuerPartyHash

faceValueIssuerRef

)

var faceValueIssuerPartyHash:

var faceValueIssuerRef:

object CommercialPaperUtils

var issuancePartyHash:

Module Contents

@JvmStatic fun generateIssue(issuance:

faceValue

maturityDate

notary

)

@JvmStatic fun generateMove(tx:

paper

State

newOwner

)

@JvmStatic @Suspendable fun generateRedeem(tx:

paper

State

services

ourIdentity

)

data class Commodity :

TokenizableAssetInfo

Module Contents

Commodity(commodityCode:

displayName

defaultFractionDigits

)

val commodityCode:

val defaultFractionDigits:

val displayName:

fun getInstance(commodityCode:

)

Commodity

object CommonSchema

object CommonSchemaV1 :

@MappedSuperclass class FungibleState :

Module Contents

FungibleState(participants:

Module Contents

owner

quantity

issuer

issuerRef

)

@MappedSuperclass class LinearState :

Module Contents

_participants

)

LinearState(participants:

externalId

uuid

)

data class ComparableRecoveryTimeWindow

Module Contents

ComparableRecoveryTimeWindow(fromTime:

fromTimestampDiscriminator

untilTime

untilTimestampDiscriminator

)

fun from(timeWindow:

ComparableRecoveryTimeWindow

)

val fromTime:

val fromTimestampDiscriminator:

val untilTime:

val untilTimestampDiscriminator:

open class ComponentGroup

Module Contents

ComponentGroup(groupIndex:

components

)

enum class ComponentGroupEnum

Module Contents

class ComponentVisibilityException :

ComponentVisibilityException(id:

Module Contents

reason

)

Module Contents

Module Contents

weight

)

Builder

fun addKeys(vararg keys:

)

Builder

fun addKeys(keys:

)

Builder

)

NodeAndWeight

)

fun getInstance(encoded:

)

fun getInstance(asn1:

)

fun isFulfilledBy(key:

)

fun isFulfilledBy(keysToCheck:

)

data class NodeAndWeight :

const val KEY_ALGORITHM:

NodeAndWeight

Module Contents

weight

)

fun compareTo(other: NodeAndWeight):

val node:

class CompositeKeyFactory :

fun toASN1Primitive():

KeyFactorySpi

Module Contents

CompositeKeyFactory()

protected fun engineGeneratePrivate(keySpec:

KeySpec

)

protected fun engineGeneratePublic(keySpec:

)

engineGetKeySpec

(

key

keySpec

protected fun engineTranslateKey(key:

)

)

class CompositeSignature :

Signature

Module Contents

CompositeSignature()

protected fun ~~engineGetParameter~~(param:

)

protected fun engineInitSign(privateKey:

)

protected fun engineInitVerify(publicKey:

)

protected fun ~~engineSetParameter~~(param:

value

)

protected fun engineSetParameter(params:

)

protected fun engineSign():

)

protected fun engineVerify(sigBytes:

off

len

)

)

@JvmStatic fun getService(provider:

const val SIGNATURE_ALGORITHM:

)

Service

data class State

Module Contents

State(buffer:

verifyKey

CompositeKey

)

val buffer:

fun engineVerify(sigBytes:

)

data class CompositeSignaturesWithKeys

Module Contents

CompositeSignaturesWithKeys(sigs:

CompositeSignaturesWithKeys

)

val EMPTY:

val sigs:

open class ConnectionFailureException :

ConnectionFailureException(cause:

Module Contents

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class ConstructorForDeserialization

)

Module Contents

ConstructorForDeserialization()

enum class ContextPropertyKeys

Module Contents

SERIALIZERS

interface Contract

Module Contents

abstract fun verify(tx:

)

class ContractAttachment :

ContractAttachment(attachment:

Module Contents

contract

additionalContracts

uploader

)

val additionalContracts:

@CordaInternal fun create(attachment:

contract

additionalContracts

uploader

signerKeys

version

)

typealias ContractClassName =

abstract val participants:

interface ContractState

Module Contents

data class ContractUpgradeFilteredTransaction :

ContractUpgradeFilteredTransaction(visibleComponents:

Module Contents

FilteredComponent

hiddenComponents

ContractUpgradeFilteredTransaction(visibleComponents:

)

fun copy(visibleComponents:

FilteredComponent

hiddenComponents

digestService

)

FilteredComponent

hiddenComponents

)

FilteredComponent(component:

val digestService:

DigestService

class FilteredComponent

Module Contents

nonce

)

val hiddenComponents:

val visibleComponents:

object ContractUpgradeFlow

FilteredComponent

Module Contents

@StartableByRPC class Authorise :

Module Contents

Authorise(stateAndRef:

upgradedContractClass

out

)

val stateAndRef:

@StartableByRPC class Deauthorise :

Module Contents

Deauthorise(stateRef:

)

val stateRef:

@InitiatingFlow @StartableByRPC class Initiate<OldState :

out

NewState

Instigator

OldState

NewState

out

OldState

NewState

Module Contents

Initiate(originalState:

OldState

newContractClass

out

@Suspendable protected fun assembleTx(): UpgradeTx

OldState

NewState

)

class ContractUpgradeLedgerTransaction :

ContractUpgradeLedgerTransaction(inputs:

Module Contents

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

)

val legacyContractAttachment:

)

val upgradedContractAttachment:

@DoNotImplement interface ContractUpgradeService

Module Contents

abstract fun getAuthorisedContractUpgrade(ref:

)

abstract fun removeAuthorisedContractUpgrade(ref:

)

abstract fun storeAuthorisedContractUpgrade(ref:

upgradedContractClass

out

)

data class ContractUpgradeWireTransaction :

ContractUpgradeWireTransaction(serializedComponents:

Module Contents

privacySalt

ContractUpgradeWireTransaction(serializedComponents:

)

privacySalt

digestService

)

fun buildFilteredTransaction():

Module Contents

privacySalt

ContractUpgradeWireTransaction

)

val legacyContractAttachmentId:

sigs

)

val upgradedContractAttachmentId:

open class CordaException :

Module Contents

cause

)

)

)

)

)

)

interface CordaFuture<V> :

abstract fun <W> then(callback: (

Module Contents

)

abstract fun toCompletableFuture():

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS]) annotation class CordaInternal

Module Contents

CordaInternal()

object CordaObjectIdentifier

Module Contents

val COMPOSITE_KEY:

val COMPOSITE_SIGNATURE:

const val ALIAS_PRIVATE_KEY:

object CordaOID

Module Contents

const val CORDA_PLATFORM:

const val R3_ROOT:

const val X509_EXTENSION_CORDA_ROLE:

@DoNotImplement interface Cordapp

Module Contents

abstract val allFlows:

out

abstract val checkpointCustomSerializers:

CheckpointCustomSerializer

abstract val contractClassNames:

abstract val cordappClasses:

abstract val customSchemas:

@DoNotImplement interface Info

abstract val info: Info

Module Contents

data class Contract : Info

Module Contents

vendor

versionId

licence

)

data class ContractAndWorkflow : Info

Module Contents

ContractAndWorkflow(contract: Contract, workflow: Workflow)

val contract: Contract

data class Default : Info

val workflow: Workflow

Module Contents

vendor

version

licence

)

abstract fun hasUnknownFields():

abstract val licence:

abstract val shortName:

abstract val vendor:

abstract val version:

data class Workflow : Info

Module Contents

vendor

versionId

licence

)

abstract val initiatedFlows:

out

abstract val jarHash: SHA256

abstract val jarPath:

abstract val minimumPlatformVersion:

abstract val name:

abstract val rpcFlows:

out

abstract val schedulableFlows:

out

abstract val serializationCustomSerializers:

abstract val serializationWhitelists:

abstract val serviceFlows:

SerializationWhitelist

out

out

abstract val targetPlatformVersion:

abstract val telemetryComponents:

@DoNotImplement interface CordappConfig

out

TelemetryComponent

Module Contents

abstract fun exists(path:

)

abstract fun get(path:

)

abstract fun getBoolean(path:

)

abstract fun getDouble(path:

)

abstract fun getFloat(path:

abstract fun getInt(path:

)

Float

)

abstract fun getLong(path:

)

abstract fun getNumber(path:

abstract fun getString(path:

)

Number

)

class CordappConfigException :

CordappConfigException(msg:

Module Contents

@CordaInternal fun create(cordapp:

)

class CordappContext

Module Contents

CordappContext(cordapp:

attachmentId

classLoader

)

attachmentId

classLoader

config

)

data class CordappInfo

Module Contents

name

shortName

minimumPlatformVersion

targetPlatformVersion

version

vendor

licence

jarHash

SHA256

)

val jarHash: SHA256

val licence:

val targetPlatformVersion:

@DoNotImplement interface CordappProvider

Module Contents

abstract fun getAppContext():

abstract fun getContractAttachmentID(contractClassName:

)

class CordaRPCClient

Module Contents

configuration

)

configuration

classLoader

)

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

customSerializers

)

configuration

sslConfiguration

classLoader

customSerializers

@CordaInternal @VisibleForTesting fun getRegisteredCustomSerializers():

)

password

gracefulReconnect

)

password

targetLegalIdentity

gracefulReconnect

)

password

externalTrace

impersonatedActor

gracefulReconnect

)

inline fun <A> use(username:

password

externalTrace

impersonatedActor

targetLegalIdentity

gracefulReconnect

)

password

open class CordaRPCClientConfiguration

block

(

CordaRPCConnection

)

Module Contents

CordaRPCClientConfiguration(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

openTelemetryEnabled

simpleLogTelemetryEnabled

spanStartEndEventsEnabled

copyBaggageToTags

)

operator fun ~~component1~~():

open val connectionMaxRetryInterval:

open val connectionRetryInterval:

open val connectionRetryIntervalMultiplier:

fun copy(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

cacheConcurrencyLevel

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

openTelemetryEnabled

simpleLogTelemetryEnabled

spanStartEndEventsEnabled

copyBaggageToTags

)

open val copyBaggageToTags:

open val deduplicationCacheExpiry:

val DEFAULT:

)

open val maxFileSize:

open val maxReconnectAttempts:

open val minimumServerProtocolVersion:

open val observationExecutorPoolSize:

open val openTelemetryEnabled:

open val reapInterval:

open val simpleLogTelemetryEnabled:

open val spanStartEndEventsEnabled:

open val trackRpcCallSites:

class CordaRPCConnection :

Module Contents

fun <T> getTelemetryHandle(telemetryClass:

fun notifyServerAndClose():

)

val proxy:

val serverProtocolVersion:

interface CordaRPCOps :

abstract fun acceptNewNetworkParameters(parametersHash:

Module Contents

)

abstract fun addVaultTransactionNote(txnId:

txnNote

)

abstract fun attachmentExists(id:

)

abstract fun currentNodeTime():

abstract fun finishedFlowsWithClientIds():

abstract fun finishedFlowsWithClientIdsAsAdmin():

abstract fun getVaultTransactionNotes(txnId:

)

abstract fun isFlowsDrainingModeEnabled():

abstract fun isWaitingForShutdown():

abstract fun killFlow(id:

)

@RPCReturnsObservables abstract fun networkMapFeed():

abstract fun networkMapSnapshot():

MapChange

@RPCReturnsObservables abstract fun networkParametersFeed():

abstract fun nodeDiagnosticInfo():

ParametersUpdateInfo

NodeDiagnosticInfo

abstract fun nodeInfo():

)

abstract fun notaryIdentities():

abstract fun notaryPartyFromX500Name(x500Name:

)

)

exactMatch

)

)

abstract fun queryAttachments(query:

sorting

)

@RPCReturnsObservables abstract fun <T> reattachFlowWithClientId(clientId:

)

abstract fun refreshNetworkMapCache():

abstract fun registeredFlows():

abstract fun removeClientId(clientId:

)

abstract fun removeClientIdAsAdmin(clientId:

)

abstract fun setFlowsDrainingModeEnabled(enabled:

)

abstract fun shutdown():

@RPCReturnsObservables abstract fun <T> startFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startFlowDynamicWithClientId(clientId:

logicType

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startTrackedFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMappingFeed():

abstract fun stateMachineRecordedTransactionMappingSnapshot():

@RPCReturnsObservables abstract fun stateMachinesFeed():

abstract fun stateMachinesSnapshot():

abstract fun terminate(drainPendingFlows:

)

abstract fun uploadAttachment(jar:

)

abstract fun uploadAttachmentWithMetadata(jar:

uploader

filename

)

vaultQuery

(

contractStateType

out

)

Page

vaultQueryBy

(

criteria

paging

sorting

contractStateType

out

)

Page

vaultQueryByCriteria

(

criteria

contractStateType

out

)

Page

vaultQueryByWithPagingSpec

(

contractStateType

out

criteria

paging

)

Page

vaultQueryByWithSorting

(

contractStateType

out

criteria

sorting

)

Page

vaultTrack

(

contractStateType

out

)

Page

Update

vaultTrackBy

(

criteria

paging

sorting

contractStateType

out

)

Page

Update

vaultTrackByCriteria

(

contractStateType

out

criteria

)

Page

Update

vaultTrackByWithPagingSpec

(

contractStateType

out

criteria

paging

)

Page

Update

vaultTrackByWithSorting

(

contractStateType

out

criteria

sorting

)

@RPCReturnsObservables abstract fun waitUntilNetworkReady():

Page

Update

abstract fun wellKnownPartyFromAnonymous(party:

)

abstract fun wellKnownPartyFromX500Name(x500Name:

)

open class CordaRuntimeException :

RuntimeException

Module Contents

cause

)

CordaRuntimeException(originalExceptionClassName:

)

_message

_cause

)

)

)

)

)

class CordaSecurityProvider :

Module Contents

CordaSecurityProvider()

algorithm

)

const val PROVIDER_NAME:

@Target([AnnotationTarget.CLASS]) @Inherited annotation class CordaSerializable

Module Contents

CordaSerializable()

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefault

Module Contents

CordaSerializationTransformEnumDefault(new:

old

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefaults

Module Contents

CordaSerializationTransformEnumDefaults(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRename

Module Contents

CordaSerializationTransformRename(to:

from

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRenames

Module Contents

CordaSerializationTransformRenames(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaService

Module Contents

CordaService()

class CordaServiceCriticalFailureException :

Module Contents

)

cause

abstract fun addSuppressed(suppressed:

)

interface CordaThrowable

Module Contents

)

abstract var originalExceptionClassName:

abstract val originalMessage:

abstract fun setCause(cause:

)

abstract fun setMessage(message:

)

@DoNotImplement interface CordaTransactionSupport

Module Contents

abstract fun <T> transaction(statement:

SessionScope

(

)

data class CordaX500Name

Module Contents

CordaX500Name(organisation:

organisation

locality

country

)

locality

country

)

organisationUnit

organisation

locality

state

country

)

)

Module Contents

X500Principal

)

)

val locality:

val organisation:

val organisationUnit:

abstract class CoreTransaction :

)

Module Contents

abstract val networkParametersHash:

class CouldNotStartFlowException :

CouldNotStartFlowException(cause:

Module Contents

sealed class CriteriaExpression<O, out T>

)

Module Contents

data class AggregateFunctionExpression<O, C> :

AggregateFunctionExpression(column:

Module Contents

predicate

groupByColumns

orderBy

Direction

)

val orderBy: Direction?

val predicate:

data class BinaryLogical<O> :

Module Contents

right

operator

)

val right:

data class ColumnPredicateExpression<O, C> :

ColumnPredicateExpression(column:

Module Contents

predicate

)

Module Contents

)

Module Contents

@JvmStatic fun decodePrivateKey(encodedKey:

)

@JvmStatic fun decodePrivateKey(schemeCodeName:

encodedKey

)

@JvmStatic fun decodePrivateKey(signatureScheme:

encodedKey

)

@JvmStatic fun decodePublicKey(encodedKey:

)

@JvmStatic fun decodePublicKey(schemeCodeName:

encodedKey

)

@JvmStatic fun decodePublicKey(signatureScheme:

encodedKey

)

val DEFAULT_SIGNATURE_SCHEME:

@JvmStatic fun deriveKeyPair(signatureScheme:

privateKey

seed

)

@JvmStatic fun deriveKeyPair(privateKey:

seed

)

@JvmStatic fun deriveKeyPairFromEntropy(signatureScheme:

entropy

)

@JvmStatic fun deriveKeyPairFromEntropy(entropy:

)

@JvmStatic fun doSign(privateKey:

clearData

)

@JvmStatic fun doSign(schemeCodeName:

privateKey

clearData

)

@JvmStatic fun doSign(signatureScheme:

privateKey

clearData

)

@JvmStatic fun doSign(keyPair:

signableData

)

@JvmStatic fun doVerify(schemeCodeName:

publicKey

signatureData

clearData

)

@JvmStatic fun doVerify(publicKey:

signatureData

clearData

)

@JvmStatic fun doVerify(signatureScheme:

publicKey

signatureData

clearData

)

@JvmStatic fun doVerify(txId:

transactionSignature

)

val ECDSA_SECP256K1_SHA256:

val ECDSA_SECP256R1_SHA256:

val EDDSA_ED25519_SHA512:

@JvmStatic fun encodePublicKey(key:

)

@JvmStatic fun findProvider(name:

)

@JvmStatic fun findSignatureScheme(algorithm:

AlgorithmIdentifier

)

@JvmStatic fun findSignatureScheme(schemeNumberID:

)

@JvmStatic fun findSignatureScheme(schemeCodeName:

)

)

)

@JvmStatic fun generateKeyPair(schemeCodeName:

)

@JvmOverloads @JvmStatic fun generateKeyPair(signatureScheme:

)

@JvmStatic fun isSupportedSignatureScheme(signatureScheme:

)

@JvmStatic fun isValid(txId:

transactionSignature

)

@JvmStatic fun isValid(publicKey:

signatureData

clearData

)

@JvmStatic fun isValid(signatureScheme:

publicKey

signatureData

clearData

)

@JvmStatic fun publicKeyOnCurve(signatureScheme:

publicKey

)

@JvmStatic fun registerProviders():

val SPHINCS256_SHA256:

@JvmStatic fun supportedSignatureSchemes():

@JvmStatic fun toSupportedPrivateKey(key:

)

SubjectPublicKeyInfo

)

)

@JvmStatic fun validatePublicKey(key:

)

interface CustomSerializationScheme

Module Contents

deserialize

(

bytes

clazz

context

abstract fun getSchemeId():

)

serialize

(

obj

context

)

fun copyDatabaseSnapshot(baseDirectory:

object DatabaseSnapshot

Module Contents

)

fun databaseFilename(baseDirectory:

)

data class DataFeed<out A, B>

Module Contents

DataFeed(snapshot: A, updates: Observable)

val snapshot: A

val updates: Observable

open class DataVendingFlow :

Module Contents

payload

txnMetadata

TransactionMetadata

)

payload

DataVendingFlow(otherSessions:

)

payload

txnMetadata

)

protected open fun isFinality():

val ~~otherSideSession~~:

val payload:

@Suspendable protected open fun sendPayloadAndReceiveDataRequest(otherSideSession:

payload

)

@Suspendable protected open fun verifyDataRequest(dataRequest: Data):

Request

enum class DateRollConvention

Module Contents

enum class DateRollDirection

Module Contents

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class DeprecatedConstructorForDeserialization

Module Contents

DeprecatedConstructorForDeserialization(version:

)

@DoNotImplement interface Destination

@DoNotImplement interface DiagnosticsService

Module Contents

abstract fun nodeVersionInfo():

NodeVersionInfo

interface DigestAlgorithm

Module Contents

abstract val algorithm:

open fun componentDigest(bytes:

)

abstract fun digest(bytes:

)

abstract val digestLength:

open fun nonceDigest(bytes:

)

DigestService(hashAlgorithm:

data class DigestService

Module Contents

)

val allOnesHash:

fun componentHash(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun componentHash(nonce:

opaqueBytes

)

fun computeNonce(privacySalt:

groupIndex

internalIndex

)

)

)

serializedHash

(

)

open class DigitalSignature :

interface DirectStatePersistable :

Module Contents

DigitalSignature(bytes:

)

Module Contents

bytes

)

)

)

)

Module Contents

abstract val stateRef:

@DoNotImplement sealed class DistributionList

Module Contents

data class ReceiverDistributionList :

ReceiverDistributionList(opaqueData:

Module Contents

receiverStatesToRecord

)

val opaqueData:

data class SenderDistributionList :

SenderDistributionList(senderStatesToRecord:

Module Contents

peersToStatesToRecord

val peersToStatesToRecord:

)

@DoNotImplement abstract class DistributionRecord :

abstract val peerPartyId:

Module Contents

DistributionRecord()

abstract val timestamp:

abstract val timestampDiscriminator:

abstract val txId:

data class DistributionRecordKey

Module Contents

DistributionRecordKey(txnId:

timestamp

timestampDiscriminator

)

val txnId:

class DistributionRecords

Module Contents

DistributionRecords(senderRecords:

receiverRecords

)

val receiverRecords:

val senderRecords:

val size:

enum class DistributionRecordType

Module Contents

@Target([AnnotationTarget.CLASS]) @Inherited annotation class DoNotImplement

RECEIVER

SENDER

Module Contents

DoNotImplement()

class DoubleSpentInputs :

Module Contents

DoubleSpentInputs(ids:

@DoNotImplement interface DriverDSL

)

Module Contents

abstract fun baseDirectory(nodeName:

)

open val defaultNotaryHandle:

open val defaultNotaryIdentity:

open val defaultNotaryNode:

abstract val notaryHandles:

open fun startNode():

abstract fun startNode(parameters:

)

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

logLevelOverride

)

open fun startWebserver(handle:

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

)

abstract fun startWebserver(handle:

WebserverHandle

maximumHeapSize

)

data class DriverParameters

Module Contents

DriverParameters(cordappsForAllNodes:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

notaryHandleTimeout

val allowHibernateToManageAppSchema:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

)

val debugPortAllocation:

val driverDirectory:

val environmentVariables:

val ~~extraCordappPackagesToScan~~:

val notaryCustomOverrides:

val premigrateH2Database:

val notaryHandleTimeout:

val startNodesInProcess:

val waitForAllNodesToFinish:

fun withAllowHibernateToManageAppSchema(value:

)

)

fun withDebugPortAllocation(debugPortAllocation:

)

fun withDriverDirectory(driverDirectory:

)

fun withEnvironmentVariables(variables:

)

fun ~~withExtraCordappPackagesToScan~~(extraCordappPackagesToScan:

)

fun withInMemoryDB(inMemoryDB:

)

fun withIsDebug(isDebug:

)

fun withJmxPolicy(jmxPolicy:

)

)

fun withNotaryCustomOverrides(notaryCustomOverrides:

)

fun withNotaryHandleTimeout(value:

)

)

fun withPortAllocation(portAllocation:

)

fun withStartNodesInProcess(startNodesInProcess:

)

fun withSystemProperties(systemProperties:

)

fun withUseTestClock(useTestClock:

)

fun withWaitForAllNodesToFinish(waitForAllNodesToFinish:

)

object DummySecureRandom :

SecureRandom

class DuplicateOutputLabel :

DuplicateOutputLabel(label:

Module Contents

@DoNotImplement interface EncodingWhitelist

)

Module Contents

abstract fun acceptEncoding(encoding:

)

@DoNotImplement sealed class EnforceVerifyOrFail

enum class EqualityComparisonOperator :

Module Contents

NOT_EQUAL_IGNORE_CASE

data class Expression

Module Contents

)

Module Contents

data class FilteredComponentGroup :

FilteredComponentGroup(groupIndex:

Module Contents

components

nonces

partialMerkleTree

)

class FilteredTransaction :

@JvmStatic fun buildFilteredTransaction(wtx:

Module Contents

filtering

)

fun checkAllComponentsVisible(componentGroupEnum:

ComponentGroupEnum

)

fun checkCommandVisibility(publicKey:

)

fun checkWithFun(checkingFun: (

)

)

val filteredComponentGroups:

class FilteredTransactionVerificationException :

FilteredComponentGroup

FilteredTransactionVerificationException(id:

Module Contents

reason

)

@InitiatingFlow class FinalityFlow :

Module Contents

extraRecipients

progressTracker

)

extraRecipients

)

)

progressTracker

)

firstSession

vararg

restSessions

)

sessions

progressTracker

)

sessions

statesToRecord

progressTracker

)

sessions

oldParticipants

progressTracker

)

object BROADCASTING : Step

sessions

observerSessions

)

object BROADCASTING_NOTARY_ERROR : Step

object BROADCASTING_POST_NOTARISATION : Step

object BROADCASTING_PRE_NOTARISATION : Step

ExtraConstructorArgs(oldParticipants:

Module Contents

sessions

newApi

statesToRecord

observerSessions

)

object FINALISING_TRANSACTION : Step

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

object NOTARISING : Step

Module Contents

object RECORD_UNNOTARISED : Step

@StartableByRPC @InitiatingFlow class FinalityRecoveryFlow :

Module Contents

FinalityRecoveryFlow(txId:

forceRecover

)

FinalityRecoveryFlow(flowId:

forceRecover

recoverAll

)

forceRecover

FinalityRecoveryFlow(flowIds:

)

forceRecover

FinalityRecoveryFlow(recoverAll:

)

forceRecover

FinalityRecoveryFlow(matchingCriteria:

)

FlowRecoveryQuery

forceRecover

)

flowIds

matchingCriteria

forceRecover

recoverAll

forceRecoverFlowIds

progressTracker

)

FlowTransactionInfo

ExtraConstructorArgs(txIds:

Module Contents

flowIds

matchingCriteria

forceRecover

recoverAll

forceRecoverFlowIds

)

val forceRecoverFlowIds:

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

val matchingCriteria:

Module Contents

value

)

interface FixableDealState :

abstract fun generateFix(ptx:

Module Contents

oldState

fix

)

abstract fun nextFixingOf():

Module Contents

forDay

ofTenor

)

open class FlowException :

IdentifiableException

Module Contents

cause

)

)

)

cause

originalErrorId

)

open fun getErrorId():

var originalErrorId:

interface FlowExternalAsyncOperation<R :

Module Contents

)

interface FlowExternalOperation<R :

Module Contents

@DoNotImplement interface FlowHandle<A> :

)

Module Contents

abstract val returnValue:

data class FlowHandleImpl<A> :

Module Contents

returnValue

)

interface FlowHandleWithClientId<A> :

Module Contents

abstract val clientId:

data class FlowHandleWithClientIdImpl<A> :

FlowHandleWithClientIdImpl(id:

Module Contents

returnValue

clientId

)

Module Contents

FlowInfo(flowVersion:

appName

)

sealed class FlowInitiator :

Module Contents

Module Contents

)

Module Contents

)

FlowInitiator

Module Contents

)

Module Contents

)

fun getName():

abstract class FlowLogic<out T>

Module Contents

Module Contents

FlowLogic()

FlowExternalAsyncOperation

await

(

operation

)

@Suspendable abstract fun call(): T

await

(

operation

FlowExternalOperation

)

fun checkFlowIsNotKilled():

fun checkFlowIsNotKilled(lazyMessage: () ->

)

fun checkFlowPermission(permissionName:

extraAuditData

)

@Suspendable fun close(sessions:

)

@JvmStatic val currentTopLevel:

@Suspendable fun flowStackSnapshot():

FlowStackSnapshot

@Suspendable fun ~~getFlowInfo~~(otherParty:

)

@Suspendable fun initiateFlow(destination:

)

@Suspendable fun initiateFlow(party:

)

val ourIdentityAndCert:

@Suspendable fun persistFlowStackSnapshot():

fun <reified R :

~~receive~~

(

otherParty

)

~~receive~~

(

receiveType

otherParty

)

@Suspendable @JvmOverloads open fun <R :

@Suspendable @JvmOverloads open fun receiveAllMap(sessions:

receiveAll

(

receiveType

sessions

maySkipCheckpoint

)

out

maySkipCheckpoint

)

fun recordAuditEvent(eventType:

comment

extraAuditData

)

@Suspendable open fun ~~send~~(otherParty:

payload

)

@Suspendable @JvmOverloads fun sendAll(payload:

sessions

maySkipCheckpoint

)

@Suspendable @JvmOverloads fun sendAllMap(payloadsPerSession:

maySkipCheckpoint

)

~~sendAndReceive~~

(

otherParty

payload

)

@Suspendable @JvmStatic @JvmOverloads fun sleep(duration:

~~sendAndReceive~~

(

receiveType

otherParty

payload

)

maySkipCheckpoint

)

@Suspendable open fun <R> subFlow(subLogic:

)

fun trackStepsTree():

fun trackStepsTreeIndex():

@Suspendable @JvmOverloads fun waitForLedgerCommit(hash:

maySkipCheckpoint

)

@Suspendable fun waitForStateConsumption(stateRefs:

)

@DoNotImplement interface FlowLogicRef

@DoNotImplement interface FlowLogicRefFactory

Module Contents

abstract fun create(flowClass:

out

vararg

args

)

abstract fun create(flowClassName:

vararg

args

)

abstract fun toFlowLogic(ref:

)

interface FlowManagerRPCOps :

abstract fun debugCheckpoints():

Module Contents

abstract fun dumpCheckpoints():

interface FlowProgressHandle<A> :

Module Contents

abstract val progress: Observable<

abstract val stepsTreeFeed:

abstract val stepsTreeIndexFeed:

data class FlowProgressHandleImpl<A> :

FlowProgressHandleImpl(id:

Module Contents

returnValue

progress

Observable

stepsTreeIndexFeed

stepsTreeFeed

)

returnValue

progress

Observable

)

FlowProgressHandleImpl

val progress: Observable<

val stepsTreeIndexFeed:

class FlowRecoveryException :

FlowRecoveryException(txnId:

Module Contents

message

cause

FlowRecoveryException(message:

)

cause

data class FlowRecoveryQuery

)

Module Contents

FlowRecoveryQuery(timeframe:

initiatedBy

counterParties

)

@DoNotImplement abstract class FlowSession

Module Contents

FlowSession()

@Suspendable abstract fun close():

abstract val counterparty:

abstract val destination:

@Suspendable abstract fun getCounterpartyFlowInfo(maySkipCheckpoint:

)

@Suspendable abstract fun getCounterpartyFlowInfo():

receive

(

)

receive

(

receiveType

maySkipCheckpoint

)

receive

(

receiveType

)

maySkipCheckpoint

)

)

sendAndReceive

(

payload

)

sendAndReceive

(

receiveType

payload

maySkipCheckpoint

)

sendAndReceive

(

receiveType

payload

)

data class FlowStackSnapshot

Module Contents

FlowStackSnapshot(time:

flowClass

stackFrames

Frame

)

val flowClass:

data class FlowTimeWindow

data class Frame

Module Contents

Frame(stackTraceElement:

stackObjects

)

val stackTraceElement:

Frame

Module Contents

FlowTimeWindow(fromTime:

untilTime

)

untilTime

)

FlowTimeWindow

)

data class FlowTransactionInfo

)

Module Contents

FlowTransactionInfo(stateMachineRunId:

txId

status

timestamp

metadata

)

fun isInitiator(myCordaX500Name:

)

abstract class FullTransaction :

Module Contents

val annualCompoundCount:

(

)

Module Contents

FullTransaction()

protected fun checkNotaryWhitelisted():

interface FungibleAsset<T :

Module Contents

abstract val exitKeys:

abstract fun withNewOwnerAndAmount(newAmount:

newOwner

)

interface FungibleState<T :

Module Contents

interface GenericQueryCriteria<Q :

interface ChainableQueryCriteria<Q :

Module Contents

abstract infix fun and(criteria: Q): Q

Module Contents

interface AndVisitor<Q :

Module Contents

abstract infix fun or(criteria: Q): Q

Predicate

interface OrVisitor<Q :

Module Contents

abstract fun visit(parser: P):

Predicate

GracefulReconnect(onDisconnect:

Predicate

class GracefulReconnect

Module Contents

onReconnect

maxAttempts

GracefulReconnect(onDisconnect: () ->

)

onReconnect

(

)

maxAttempts

)

val onDisconnect: () ->

val onReconnect: () ->

data class HashAttachmentConstraint :

HashAttachmentConstraint(attachmentId:

Module Contents

)

val attachmentId:

val disableHashConstraints:

)

open class HospitalizeFlowException :

Module Contents

HospitalizeFlowException(cause:

)

HospitalizeFlowException()

)

fun fromHostAndPort(hostAndPort:

cause

)

Module Contents

mapper

ObjectMapper

)

base

protocol

mapper

ObjectMapper

)

HttpApi

getJson

(

path

params

val defaultMapper: ObjectMapper

)

val mapper: ObjectMapper

data

)

data

)

data

)

Module Contents

getJson

(

url

params

open class Id<out VALUE :

mapper

ObjectMapper

)

data

)

data

)

data

)

Id(value: VALUE, entityType:

Module Contents

timestamp

)

)

newInstance

(

value

entityType

timestamp

)

@DoNotImplement interface IdentityService

Module Contents

open fun assertOwnership(party:

anonymousParty

)

abstract val caCertStore:

CertStore

abstract fun certificateFromKey(owningKey:

)

@Suspendable abstract fun externalIdForPublicKey(publicKey:

)

abstract fun getAllIdentities():

exactMatch

)

)

abstract fun publicKeysForExternalId(externalId:

)

abstract fun registerKey(publicKey:

party

externalId

)

open fun requireWellKnownPartyFromAnonymous(party:

)

abstract val trustAnchor:

abstract fun verifyAndRegisterIdentity(identity:

abstract val trustRoot:

X509Certificate

)

open fun wellKnownPartyFromAnonymous(party:

)

open fun wellKnownPartyFromAnonymous(partyRef:

)

)

class IllegalFlowLogicException :

IllegalArgumentException

Module Contents

msg

)

interface IndirectStatePersistable<T :

msg

)

abstract val compositeKey: T

Module Contents

@Target([AnnotationTarget.CLASS]) annotation class InitiatedBy

Module Contents

out

)

out

@Target([AnnotationTarget.CLASS]) @Inherited annotation class InitiatingFlow

Module Contents

InitiatingFlow(version:

)

@ThreadSafe class InMemoryMessagingNetwork :

data class DistributedServiceHandle :

Module Contents

MessageRecipientGroup

Module Contents

DistributedServiceHandle(party:

)

val endpointsExternal:

interface LatencyCalculator

MockMessagingService

Module Contents

abstract fun between(sender:

receiver

)

class MessageTransfer

Module Contents

val sender: PeerHandle

class MockMessagingService

Module Contents

)

MessageTransfer

data class PeerHandle :

val receivedMessages: Observable<MessageTransfer>

Module Contents

name

)

)

)

MessageTransfer

val sentMessages: Observable<MessageTransfer>

@DoNotImplement sealed class ServicePeerAllocationStrategy

Module Contents

abstract fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

class Random : ServicePeerAllocationStrategy

)

Module Contents

Random(random:

fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

)

)

val random:

class RoundRobin : ServicePeerAllocationStrategy

Module Contents

RoundRobin()

fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

)

fun stop():

@DoNotImplement interface InProcess :

Module Contents

registerInitiatedFlow

(

initiatedFlowClass

)

Observable

open fun <T> startFlow(logic:

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

data class InvocationContext

Module Contents

trace

actor

externalTrace

impersonatedActor

)

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

@JvmStatic @JvmOverloads fun newInstance(origin:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

serializedTelemetry

SerializedTelemetry

)

trace

actor

externalTrace

impersonatedActor

)

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

val impersonatedActor:

Actor

trace

actor

externalTrace

impersonatedActor

arguments

clientId

serializedTelemetry

SerializedTelemetry

)

val origin:

@JvmStatic fun peer(party:

trace

externalTrace

impersonatedActor

)

@JvmStatic @JvmOverloads fun rpc(actor:

trace

externalTrace

impersonatedActor

arguments

serializedTelemetry

SerializedTelemetry

)

@JvmStatic fun scheduled(scheduledState:

trace

externalTrace

)

val serializedTelemetry: SerializedTelemetry?

@JvmStatic fun shell(trace:

owningLegalIdentity

trace

externalTrace

)

externalTrace

)

sealed class InvocationOrigin

Module Contents

Module Contents

)

abstract fun principal():

Module Contents

)

Module Contents

)

Module Contents

owningLegalIdentity

)

fun principal():

@DoNotImplement interface IQueryCriteriaParser :

Module Contents

abstract fun parseCriteria(criteria: CommonQueryCriteria):

Module Contents

abstract fun parseCriteria(criteria: FungibleAssetQueryCriteria):

Predicate

abstract fun parseCriteria(criteria: LinearStateQueryCriteria):

Predicate

Predicate

abstract fun <L :

parseCriteria

(

criteria

VaultCustomQueryCriteria

)

abstract fun parseCriteria(criteria: VaultQueryCriteria):

Predicate

data class Issued<out P :

Predicate

Module Contents

Issued(issuer:

object ~~AmountDeserializer~~ : JsonDeserializer<

product

)

object JacksonSupport

Module Contents

Module Contents

context

DeserializationContext

)

object ~~AmountSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

object ~~AnonymousPartyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~AnonymousPartySerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

object ~~CordaX500NameDeserializer~~ : JsonDeserializer<

val ~~cordaModule~~: Module

Module Contents

context

DeserializationContext

)

object ~~CordaX500NameSerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

@JvmStatic @JvmOverloads fun createDefaultMapper(rpc:

factory

fuzzyIdentityMatch

fullParties

)

ObjectMapper

@JvmStatic @JvmOverloads fun createInMemoryMapper(identityService:

factory

fuzzyIdentityMatch

fullParties

)

ObjectMapper

@JvmStatic @JvmOverloads fun createNonRpcMapper(factory:

JsonFactory

fullParties

class ~~IdentityObjectMapper~~ : PartyObjectMapper, ObjectMapper

)

ObjectMapper

Module Contents

IdentityObjectMapper(identityService:

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

object ~~NodeInfoDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~NodeInfoSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

class ~~NoPartyObjectMapper~~ : PartyObjectMapper, ObjectMapper

Module Contents

NoPartyObjectMapper(factory:

isFullParties

)

)

)

)

)

object ~~OpaqueBytesDeserializer~~ : JsonDeserializer<

Module Contents

ctxt

DeserializationContext

)

object ~~OpaqueBytesSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

object ~~PartyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

@DoNotImplement interface PartyObjectMapper

Module Contents

abstract val isFullParties:

)

)

abstract fun partyFromKey(owningKey:

)

)

object ~~PartySerializer~~ : JsonSerializer<

Module Contents

gen

provider

SerializerProvider

)

object ~~PublicKeyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~PublicKeySerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

class ~~RpcObjectMapper~~ : PartyObjectMapper, ObjectMapper

Module Contents

factory

fuzzyIdentityMatch

isFullParties

)

val isFullParties:

)

)

)

)

class ~~SecureHashDeserializer~~<T :

JsonDeserializer

Module Contents

SecureHashDeserializer()

object ~~SecureHashSerializer~~ : JsonSerializer<

context

DeserializationContext

)

Module Contents

generator

provider

SerializerProvider

)

abstract class ~~SignedTransactionMixin~~

Module Contents

SignedTransactionMixin()

abstract fun getId():

abstract fun getInputs():

abstract fun getNotary():

abstract fun getNotaryChangeTx():

abstract fun getRequiredSigningKeys():

protected abstract fun getSigs():

protected abstract fun getTransaction():

abstract fun getTx():

abstract fun getTxBits():

object ~~ToStringSerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

abstract fun getAvailableComponentHashes():

abstract class ~~WireTransactionMixin~~

Module Contents

WireTransactionMixin()

abstract fun getAvailableComponents():

abstract fun getMerkleTree():

abstract fun getOutputStates():

java.lang.management.ThreadInfo

Module Contents

ThreadInfo

asString

(

maxFrames

)

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

sign

(

bytesToSign

)

WithKey

sign

(

bytesToSign

)

WithKey

sign

(

signableData

)

verify

(

signatureData

clearData

)

java.security.PrivateKey

Module Contents

sign

(

bytesToSign

)

sign

(

bytesToSign

publicKey

)

WithKey

Module Contents

containsAny

(

otherKeys

)

isFulfilledBy

(

otherKey

)

isFulfilledBy

(

otherKeys

)

isValid

(

content

signature

)

keys

toStringShort

(

)

verify

(

content

signature

)

verify

(

signatureData

clearData

)

Module Contents

toBase58String

(

)

toSHA256Bytes

(

)

Module Contents

deserialize

(

serializationFactory

context

)

Module Contents

fun <V, W>

match

(

success

(

)

failure

(

)

Module Contents

fun <V>

JmxPolicy(jmxHttpServerPortAllocation:

getOrThrow

(

timeout

)

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

JmxPolicy(startJmxHttpServer:

)

jmxHttpServerPortAllocation

@JvmStatic fun defaultEnabled():

)

val jmxHttpServerPortAllocation:

val startJmxHttpServer:

@DoNotImplement interface KeyManagementService

Module Contents

abstract fun filterMyKeys(candidateKeys:

)

@Suspendable abstract fun freshKey():

@Suspendable abstract fun freshKey(externalId:

)

@Suspendable abstract fun freshKeyAndCert(identity:

revocationEnabled

)

@Suspendable abstract fun freshKeyAndCert(identity:

revocationEnabled

externalId

)

@Suspendable abstract fun sign(bytes:

publicKey

@Suspendable abstract fun sign(signableData:

)

WithKey

publicKey

)

class KilledFlowException :

Module Contents

)

message

)

Module Contents

contextLogger

(

)

Logger

kotlin.ByteArray

Module Contents

hashAs

(

algorithm

)

sha256

(

)

SHA256

Module Contents

deserialize

(

serializationFactory

context

)

Module Contents

sequence

(

offset

size

)

toBase58

(

)

toBase64

(

)

toHex

(

)

toHexString

(

)

Module Contents

requireSingleCommand

(

)

requireSingleCommand

(

klass

)

select

(

signer

party

)

select

(

klass

signer

party

)

select

(

signers

parties

)

select

(

klass

signers

parties

)

Module Contents

fun <T>

toNonEmptySet

(

)

Module Contents

filterStatesOfType

(

)

Module Contents

byKeys

(

)

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

sumObligations

(

)

Terms

sumObligationsOrNull

(

)

Terms

sumObligationsOrZero

(

issuanceDef

Terms

)

Terms

kotlin.collections.Map

Module Contents

from

(

session

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

days

exactAdd

(

)

hours

millis

minutes

seconds

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

exactAdd

(

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

kotlin.reflect.KClass

Module Contents

from

(

session

)

Module Contents

base58toBase64

(

)

base58ToByteArray

(

)

base58toHex

(

)

base58ToRealString

(

)

base64toBase58

(

)

base64ToByteArray

(

)

base64toHex

(

)

base64ToRealString

(

)

hexToBase58

(

)

hexToBase64

(

)

hexToByteArray

(

)

hexToRealString

(

)

parseAsHex

(

)

class LedgerDSL<out T :

out

LedgerDSL(interpreter: L, notary:

Module Contents

)

output

(

)

fun <reified S :

outputStateAndRef

(

)

fun <S :

retrieveOutput

(

clazz

label

@JvmOverloads fun transaction(label:

)

transactionBuilder

dsl

(

)

)

(

)

)

@JvmOverloads fun unverifiedTransaction(label:

transactionBuilder

dsl

(

)

)

@DoNotImplement interface LedgerDSLInterpreter<out T :

abstract fun _transaction(transactionLabel:

Module Contents

transactionBuilder

dsl

(

)

)

(

)

)

abstract fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

abstract fun attachment(attachment:

)

class LedgerRecoveryException :

LedgerRecoveryException(message:

Module Contents

@StartableByRPC class LedgerRecoveryFlow :

)

Module Contents

)

)

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

alsoFinalize

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

alsoFinalize

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

recoveryBatchSize

alsoFinalize

)

timeWindow

dryRun

verboseLogging

recoveryBatchSize

)

timeWindow

useAllNetworkNodes

dryRun

useTimeWindowNarrowing

verboseLogging

recoveryBatchSize

LedgerRecoveryFlow(parameters:

)

progressTracker

)

ExtraConstructorArgs(parameters:

Module Contents

)

val parameters:

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

data class LedgerRecoveryParameters

Module Contents

LedgerRecoveryParameters(recoveryPeers:

timeWindow

useAllNetworkNodes

dryRun

useTimeWindowNarrowing

verboseLogging

recoveryBatchSize

alsoFinalize

)

val recoveryBatchSize:

val useAllNetworkNodes:

val useTimeWindowNarrowing:

val verboseLogging:

data class LedgerRecoveryResult

Module Contents

LedgerRecoveryResult(totalRecoveredRecords:

totalRecoveredTransactions

val totalRecoveredInFlightTransactions:

totalRecoveredInFlightTransactions

totalErrors

)

val totalRecoveredRecords:

val totalRecoveredTransactions:

class LedgerTransaction :

Module Contents

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

commandsOfType

(

clazz

)

commandsOfType

(

)

operator fun component10():

CommandWithParties

@CordaInternal fun createForContractVerify(inputs:

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

references

digestService

)

)

filterCommands

(

clazz

predicate

)

filterCommands

(

crossinline

predicate

(

)

)

filterInputs

(

clazz

predicate

)

filterInputs

(

crossinline

predicate

(

)

)

filterInRefs

(

clazz

predicate

)

filterInRefs

(

crossinline

predicate

(

)

)

filterReferenceInputRefs

(

clazz

predicate

)

filterReferenceInputRefs

(

crossinline

predicate

(

)

)

filterReferenceInputs

(

clazz

predicate

)

filterReferenceInputs

(

crossinline

predicate

(

)

)

findCommand

(

clazz

predicate

)

findCommand

(

crossinline

predicate

(

)

)

findInput

(

clazz

predicate

)

findInput

(

crossinline

predicate

(

)

)

findInRef

(

clazz

predicate

)

findInRef

(

crossinline

predicate

(

)

)

findReference

(

clazz

predicate

)

findReference

(

crossinline

predicate

(

)

)

findReferenceInputRef

(

clazz

predicate

)

findReferenceInputRef

(

crossinline

predicate

(

)

)

fun getAttachment(index:

)

fun getReferenceInput(index:

fun getAttachment(id:

)

getCommand

(

index

)

)

)

groupStates

(

ofType

selector

(

)

InOutGroup

data class InOutGroup<out T :

groupStates

(

noinline

selector

(

)

InOutGroup

out

Module Contents

outputs

groupingKey

)

inputsOfType

(

clazz

)

inputsOfType

(

)

inRef

(

index

)

inRefsOfType

(

clazz

)

inRefsOfType

(

)

@CordaInternal fun specialise(alternateVerifier: (

referenceInputRefsOfType

(

clazz

)

referenceInputRefsOfType

(

)

referenceInputsOfType

(

clazz

)

referenceInputsOfType

(

)

@CordaInternal fun <T> transform(transformer: (

)

Verifier

)

SerializedStateAndRef

SerializedStateAndRef

)

fun verify():

@Target([AnnotationTarget.CLASS]) annotation class LegalProseReference

Module Contents

LegalProseReference(uri:

)

val uri:

enum class LikenessOperator :

Module Contents

class LinearPointer<T :

Module Contents

type

)

type

isResolved

)

)

)

)

interface LinearState :

Module Contents

abstract val linearId:

MappedSchema(schemaFamily:

open class MappedSchema

Module Contents

version

mappedTypes

)

open val migrationResource:

)

object MappedSchemaValidator

Module Contents

fun crossReferencesToOtherMappedSchema(schema:

)

fun fieldsFromOtherMappedSchema(schema:

SchemaCrossReferenceReport

)

fun methodsFromOtherMappedSchema(schema:

SchemaCrossReferenceReport

)

class SchemaCrossReferenceReport

SchemaCrossReferenceReport

Module Contents

SchemaCrossReferenceReport(schema:

entity

referencedSchema

fieldOrMethod

fieldOrMethodType

)

class MaxRpcRetryException :

MaxRpcRetryException(maxNumberOfRetries:

Module Contents

method

cause

class MaybeSerializedSignedTransaction :

)

Module Contents

serialized

nonSerialised

)

fun payloadContentDescription():

serialized

nonSerialised

inFlight

)

fun serializedByteCount():

sealed class MerkleTree

Module Contents

)

class MerkleTreeException :

nodeDigestService

)

Module Contents

)

Module Contents

left

right

)

MerkleTreeException(reason:

Module Contents

)

val reason:

interface MessageRecipientGroup :

interface MessageRecipients

class MissingAttachmentsException :

Module Contents

)

class MissingAttachmentsRuntimeException :

message

)

Module Contents

message

)

)

class MissingContractAttachments :

message

cause

)

MissingContractAttachments(states:

Module Contents

contractsClassName

minimumRequiredContractClassVersion

Version

)

class MockAttachmentStorage :

fun getAttachmentIdAndBytes(jar:

Module Contents

MockAttachmentStorage()

)

fun getLatestContractAttachments(contractClassName:

minContractVersion

)

fun hasAttachment(attachmentId:

)

)

@JvmOverloads fun importContractAttachment(contractClassNames:

uploader

filename

)

uploader

jar

attachmentId

signers

)

fun importContractAttachment(attachmentId:

contractAttachment

ContractAttachment

)

fun importOrGetAttachment(jar:

)

fun openAttachment(id:

)

fun queryAttachments(criteria:

sorting

)

MockNetFlowTimeOut(timeout:

class MockNetFlowTimeOut

Module Contents

maxRestartCount

backoffBase

)

class MockNetNotaryConfig

Module Contents

MockNetNotaryConfig(validating:

extraConfig

Config

className

serviceLegalName

)

val extraConfig: Config?

val serviceLegalName:

val validating:

open class MockNetwork

Module Contents

parameters

)

MockNetwork(parameters:

)

defaultParameters

networkSendManuallyPumped

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

fun baseDirectory(nodeId:

)

)

val ~~cordappPackages~~:

fun createNode(parameters:

)

@JvmOverloads fun createNode(legalName:

forcedID

entropyRoot

configOverrides

)

fun createPartyNode(legalName:

)

fun createUnstartedNode(parameters:

)

@JvmOverloads fun createUnstartedNode(legalName:

forcedID

entropyRoot

configOverrides

)

val defaultNotaryIdentity:

val defaultNotaryNode:

val defaultParameters:

@JvmOverloads fun runNetwork(rounds:

)

val servicePeerAllocationStrategy: ServicePeerAllocationStrategy

data class MockNetworkNotarySpec

Module Contents

validating

className

)

data class MockNetworkParameters

validating

)

Module Contents

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

MockNetworkParameters(cordappsForAllNodes:

)

)

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

cordappsForAllNodes

fun copy(networkSendManuallyPumped:

)

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

)

val notarySpecs:

val servicePeerAllocationStrategy: ServicePeerAllocationStrategy

val threadPerNode:

)

)

fun withNetworkSendManuallyPumped(networkSendManuallyPumped:

)

)

fun withServicePeerAllocationStrategy(servicePeerAllocationStrategy: ServicePeerAllocationStrategy):

fun withThreadPerNode(threadPerNode:

)

class MockNodeConfigOverrides

Module Contents

MockNodeConfigOverrides(extraDataSourceProperties:

notary

flowTimeout

)

val extraDataSourceProperties:

data class MockNodeParameters

Module Contents

legalName

entropyRoot

configOverrides

)

legalName

entropyRoot

configOverrides

additionalCordapps

)

val configOverrides:

legalName

entropyRoot

configOverrides

)

)

fun withConfigOverrides(configOverrides:

)

fun withEntropyRoot(entropyRoot:

)

fun withForcedID(forcedID:

)

fun withLegalName(legalName:

)

open class MockServices :

Module Contents

initialIdentity

identityService

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

keyManagementService

)

initialIdentityName

identityService

key

vararg

moreKeys

)

initialIdentityName

identityService

)

)

identityService

key

vararg

moreKeys

)

identityService

)

initialIdentityName

identityService

networkParameters

)

MockServices(firstIdentity: <ERROR CLASS>, vararg moreIdentities: <ERROR CLASS>)

initialIdentityName

identityService

networkParameters

key

)

MockServices(firstIdentity: <ERROR CLASS>, networkParameters:

vararg

moreIdentities

)

firstIdentity

vararg

moreIdentities

)

firstIdentity

networkParameters

fun addMockCordapp(contractClassName:

vararg

moreIdentities

)

MockServices()

)

open val contractUpgradeService:

val attachments:

MockAttachmentStorage

open val clock:

TestClock

val cordappClassloader:

open val cordappProvider:

cordaService

(

type

open fun <T : TelemetryComponent> cordaTelemetryComponent(type:

)

open val diagnosticsService:

)

open val identityService:

open fun jdbcSession():

open val keyManagementService:

open fun loadContractAttachment(stateRef:

)

open fun loadState(stateRef:

)

open fun loadStates(stateRefs:

)

@JvmStatic @JvmOverloads fun makeTestDatabaseAndMockServices(cordappPackages:

identityService

initialIdentity

networkParameters

vararg

moreKeys

)

CordaPersistence

@JvmStatic @JvmOverloads fun makeTestDatabaseAndPersistentServices(cordappPackages:

initialIdentity

networkParameters

moreKeys

moreIdentities

cacheFactory

TestingNamedCacheFactory

)

CordaPersistence

@JvmStatic fun makeTestDataSourceProperties(nodeName:

)

open val networkMapCache:

open val networkParameters:

open var networkParametersService:

open fun recordTransactions(statesToRecord:

txs

)

@VisibleForTesting fun recordTransactions(txn:

disableSignatureVerification

)

@VisibleForTesting fun recordTransactions(txs:

disableSignatureVerification

)

open fun registerUnloadHandler(runOnStop: () ->

protected val servicesForResolution:

)

Nothing

open val telemetryService: TelemetryServiceImpl

open val validatedTransactions:

open val vaultService:

open fun <T> withEntityManager(block: EntityManager.() -> T): T

open fun withEntityManager(block:

EntityManager

)

interface MoveCommand :

Module Contents

abstract val contract:

out

data class MultilateralNetState<P :

MultilateralNetState(template: Terms)

Module Contents

val template: Terms

interface MultilateralNettableState<out T :

abstract val multilateralNetState: T

Module Contents

class MultiRPCClient<I :

Module Contents

rpcOpsClass

username

password

configuration

)

rpcOpsClass

username

password

classLoader

configuration

)

rpcOpsClass

username

password

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

customSerializers

configuration

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

rpcOpsClass

username

password

customSerializers

configuration

fun addConnectionListener(listener:

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

)

fun close():

fun removeConnectionListener(listener:

)

interface NamedByHash

Module Contents

net.corda.testing.node.internal.TestStartedNode

Module Contents

inline fun <reified P :

TestStartedNode

registerCordappFlowFactory

(

initiatingFlowClass

out

initiatedFlowVersion

noinline

flowFactory

(

)

TestStartedNode

registerCoreFlowFactory

(

initiatingFlowClass

out

initiatedFlowClass

flowFactory

(

)

track

)

Observable

interface NetCommand :

Module Contents

abstract val type:

NetType

interface NetState<P :

abstract val template: Terms

Module Contents

interface NettableState<N :

out

MultilateralNettableState

enum class NetType

Module Contents

CLOSE_OUT

PAYMENT

data class NetworkHostAndPort

Module Contents

NetworkHostAndPort(host:

port

)

interface NetworkMapCache :

)

NetworkMapCacheBase

Module Contents

abstract fun getNodeByLegalIdentity(party:

)

data class Added : MapChange

sealed class MapChange

Module Contents

Module Contents

)

data class Modified : MapChange

Module Contents

previousNode

)

data class Removed : MapChange

Module Contents

)

@DoNotImplement interface NetworkMapCacheBase

Module Contents

abstract val allNodes:

abstract val changed: Observable<MapChange>

abstract fun getNodeByAddress(address:

)

abstract fun getNodeByLegalName(name:

)

abstract fun getNodesByLegalIdentityKey(identityKey:

)

abstract fun getNodesByLegalName(name:

)

open fun getNotary(name:

)

abstract fun getPartyInfo(party:

)

open fun getPeerByLegalName(name:

)

abstract fun getPeerCertificateByLegalName(name:

)

abstract fun isNotary(party:

)

abstract fun isValidatingNotary(party:

)

abstract val nodeReady:

abstract val notaryIdentities:

data class NetworkParameters

MapChange

Module Contents

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

recoveryMaximumBackupInterval

confidentialIdentityMinimumBackupInterval

val confidentialIdentityMinimumBackupInterval:

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

val maxTransactionSize:

val packageOwnership:

val recoveryMaximumBackupInterval:

val whitelistedContractImplementations:

data class NetworkParametersHash

Module Contents

NetworkParametersHash(hash:

)

@DoNotImplement interface NetworkParametersService

Module Contents

abstract val currentHash:

abstract val defaultHash:

abstract fun lookup(hash:

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class NoConstraintPropagation

Module Contents

NoConstraintPropagation()

data class NodeDiagnosticInfo

Module Contents

NodeDiagnosticInfo(version:

revision

platformVersion

vendor

cordapps

)

@DoNotImplement interface NodeHandle :

abstract val baseDirectory:

Module Contents

abstract val jmxAddress:

abstract val nodeInfo:

abstract val p2pAddress:

abstract val rpc:

abstract val rpcAddress:

abstract val rpcAdminAddress:

fun identityAndCertFromX500Name(name:

abstract val rpcUsers:

Module Contents

legalIdentitiesAndCerts

platformVersion

serial

)

)

fun identityFromX500Name(name:

)

fun isLegalIdentity(party:

)

fun isLegalIdentity(name:

)

val legalIdentitiesAndCerts:

data class NodeParameters

Module Contents

NodeParameters()

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

systemProperties

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

out

out

out

val logLevelOverride:

val startInSameProcess:

)

fun withCustomOverrides(customOverrides:

)

fun withFlowOverrides(flowOverrides:

out

out

)

fun withLogLevelOverride(logLevelOverride:

)

fun withMaximumHeapSize(maximumHeapSize:

)

fun withProvidedName(providedName:

)

fun withRpcUsers(rpcUsers:

User

)

fun withStartInSameProcess(startInSameProcess:

)

fun withVerifierType(verifierType:

VerifierType

)

data class NodeVersionInfo

Module Contents

NodeVersionInfo(releaseVersion:

revision

platformVersion

vendor

)

class NonEmptySet<T> :

@JvmStatic fun <T> copyOf(elements:

Module Contents

)

)

)

@JvmStatic fun <T> of(element: T):

@JvmStatic fun <T> of(first: T, second: T, vararg rest: T):

data class NotarisationPayload

fun parallelStream():

Module Contents

NotarisationPayload(transaction:

requestSignature

)

val coreTransaction:

val requestSignature:

val signedTransaction:

class NotarisationRequest

Module Contents

NotarisationRequest(statesToConsume:

transactionId

)

data class NotarisationRequestSignature

Module Contents

NotarisationRequestSignature(digitalSignature: WithKey, platformVersion:

val digitalSignature: WithKey

)

val platformVersion:

data class NotarisationResponse

Module Contents

NotarisationResponse(signatures:

)

@InitiatingFlow class NotaryChangeFlow<out T :

Instigator

NotaryChangeFlow(originalState:

Module Contents

newNotary

progressTracker

protected fun assembleTx(): UpgradeTx

)

class NotaryChangeLedgerTransaction :

NotaryChangeLedgerTransaction(inputs:

Module Contents

notary

newNotary

sigs

)

notary

newNotary

sigs

)

)

)

data class NotaryChangeWireTransaction :

Module Contents

NotaryChangeWireTransaction(inputs:

)

notary

newNotary

)

digestService

)

Module Contents

)

sigs

)

sigs

)

sealed class NotaryError

Module Contents

data class Conflict :

Module Contents

consumedStates

)

val consumedStates:

Module Contents

)

const val NUM_STATES:

data class RequestSignatureInvalid :

RequestSignatureInvalid(cause:

Module Contents

)

data class TimeWindowInvalid :

TimeWindowInvalid(currentTime:

Module Contents

txTimeWindow

)

val ~~INSTANCE~~: TimeWindowInvalid

data class TransactionInvalid :

TransactionInvalid(cause:

Module Contents

)

object ~~WrongNotary~~ :

class NotaryException :

@DoNotImplement @InitiatingFlow class Client : BackpressureAwareTimedFlow<

Module Contents

NotaryException(error:

txId

)

Module Contents

Module Contents

skipVerification

)

progressTracker

)

progressTracker

skipVerification

)

protected fun checkTransaction():

open val isTimeoutEnabled:

@Suspendable protected fun notarise(notaryParty:

)

NotarisationResponse

object REQUESTING : Step

protected fun validateResponse(response:

notaryParty

)

object VALIDATING : Step

data class NotaryHandle

Module Contents

NotaryHandle(identity:

validating

nodeHandles

)

data class NotaryInfo

Module Contents

validating

)

object NotarySigCheck

Module Contents

fun needsNotarySignature(stx:

)

enum class NullOperator :

data class NotarySpec

Module Contents

validating

rpcUsers

verifierType

cluster

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

startInProcess

)

validating

rpcUsers

verifierType

cluster

startInProcess

)

validating

rpcUsers

verifierType

cluster

)

Module Contents

object NullPublicKey :

Module Contents

)

data class ObjectWithCompatibleContext<out T :

Module Contents

IS_NULL

NOT_NULL

ObjectWithCompatibleContext(obj: T, context:

Module Contents

)

Module Contents

Module Contents

Module Contents

Terms

)

Terms

Module Contents

Module Contents

out

)

out

Module Contents

)

data class SetLifecycle :

SetLifecycle(lifecycle: Lifecycle)

Module Contents

val inverse: Lifecycle

val lifecycle: Lifecycle

data class Settle<P :

Module Contents

Terms

)

Terms

Module Contents

State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor:

Terms

State

Module Contents

val multilateralNetState:

template

Terms

quantity

beneficiary

)

Terms

val bilateralNetState:

var lifecycle: Lifecycle

MultilateralNetState

fun net(other: State): State

)

Terms

newOwner

)

State

data class Terms<P :

Terms(acceptableContracts:

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

)

object ObligationUtils

Module Contents

@JvmStatic fun generateCashIssue(tx:

obligor

acceptableContract

amount

dueBefore

beneficiary

notary

)

generateCloseOutNetting

(

signer

vararg

inputs

State

)

generateExit

(

amountIssued

Terms

assetStates

State

)

generateIssue

(

obligor

issuanceDef

Terms

pennies

beneficiary

notary

)

generatePaymentNetting

(

issued

Terms

notary

vararg

inputs

State

)

generateSetLifecycle

(

statesAndRefs

State

lifecycle

Lifecycle

notary

)

generateSettle

(

statesAndRefs

abstract class OnLedgerAsset<T :

State

assetStatesAndRefs

moveCommand

notary

)

out

Module Contents

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands:

)

fun ~~generateExit~~(tx:

amountIssued

assetStates

)

amountIssued

assetStates

payChangeTo

)

~~generateExit~~

(

amountIssued

assetStates

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

generateExit

(

amountIssued

assetStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

abstract fun generateExitCommand(amount:

generateExitCommand

(

)

)

)

generateIssue

(

transactionState

issueCommand

)

abstract fun generateMoveCommand():

generateSpend

(

amount

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

generateSpend

(

payments

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

open class OpaqueBytes :

Module Contents

)

@JvmStatic fun of(vararg b:

)

class OpaqueBytesSubSequence :

OpaqueBytesSubSequence(bytes:

Module Contents

offset

size

)

@DoNotImplement interface Operator

org.slf4j.Logger

Module Contents

inline fun Logger.debug(msg: () ->

)

inline fun Logger.trace(msg: () ->

)

@DoNotImplement interface OutOfProcess :

@DoNotImplement interface OutputStateLookup

Module Contents

abstract val process:

Process

Module Contents

abstract fun <S :

retrieveOutputStateAndRef

(

clazz

label

)

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

data class PageSpecification

Module Contents

PageSpecification(pageNumber:

pageSize

)

data class ParametersUpdateInfo

Module Contents

ParametersUpdateInfo(hash:

parameters

description

updateDeadline

)

class PartialMerkleTree

Module Contents

PartialMerkleTree(root: PartialTree)

fun build(merkleRoot:

includeHashes

)

@CordaInternal fun leafIndex(leaf:

)

data class IncludedLeaf : PartialTree

sealed class PartialTree

Module Contents

Module Contents

)

data class Leaf : PartialTree

Module Contents

)

data class Node : PartialTree

Module Contents

Node(left: PartialTree, right: PartialTree)

Node(left: PartialTree, right: PartialTree, hashAlgorithm:

fun copy(left: PartialTree, right: PartialTree): Node

)

val hashAlgorithm:

fun rootAndUsedHashes(node: PartialTree, usedHashes:

val left: PartialTree

val right: PartialTree

val root: PartialTree

)

fun verify(merkleRootHash:

hashesToCheck

)

Module Contents

)

owningKey

)

owningKey

)

fun create(certificate:

)

)

data class PartyAndAmount<T :

class PartyAndCertificate

Module Contents

PartyAndAmount(party:

amount

)

Module Contents

PartyAndCertificate(certPath:

)

)

fun verify(trustAnchor:

)

fun verify(trustAnchors:

)

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

sealed class PartyInfo

Module Contents

data class DistributedNode :

class PermissionException :

Module Contents

DistributedNode(party:

)

data class SingleNode :

Module Contents

addresses

)

enum class PaymentRule

Module Contents

InAdvance

InArrears

RpcSerializableError

ClientRelevantError

Module Contents

PermissionException(msg:

)

val msg:

@MappedSuperclass class PersistentState :

PersistentState(stateRef:

Module Contents

)

var stateRef:

@Embeddable data class PersistentStateRef :

PersistentStateRef(stateRef:

Module Contents

@DoNotImplement abstract class PortAllocation

)

PersistentStateRef(txId:

index

)

Module Contents

PortAllocation()

const val DEFAULT_START_PORT:

@JvmStatic val defaultAllocator:

const val FIRST_EPHEMERAL_PORT:

@DoNotImplement open class ~~Incremental~~ :

Incremental(startingPort:

Module Contents

)

open fun ~~nextPort~~():

val ~~portCounter~~:

AtomicInteger

fun nextHostAndPort():

abstract fun nextPort():

class PrivacySalt :

@JvmStatic fun createFor(algorithm:

Module Contents

PrivacySalt(saltLength:

)

)

)

ProgressTracker(vararg inputSteps: Step)

class ProgressTracker

Module Contents

Step

Module Contents

data class Position : Change

Module Contents

Position(tracker:

data class Rendering : Change

newStep

Step

)

Module Contents

Rendering(tracker:

data class Structural : Change

ofStep

Step

)

Module Contents

Structural(tracker:

val changes: Observable<Change>

parent

Step

)

var currentStep: Step

val currentStepRecursive: Step

Module Contents

)

fun endWithError(error:

)

fun getChildProgressTracker(step: Step):

fun setChildProgressTracker(step: Step, childProgressTracker:

)

open val changes: Observable<Change>

object STARTING : Step

Module Contents

)

Module Contents

)

open fun childProgressTracker():

)

val stepsTreeChanges: Observable<

open val extraAuditData:

Step

val stepsTreeIndexChanges: Observable<

val topLevelTracker:

object UNSTARTED : Step

Module Contents

)

interface PropertyDelegate<out T>

Module Contents

abstract operator fun getValue(thisRef:

property

interface QueryableState :

)

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas():

sealed class QueryCriteria :

ChainableQueryCriteria

Module Contents

)

abstract class CommonQueryCriteria :

AndVisitor

Module Contents

)

Module Contents

CommonQueryCriteria()

open val constraints:

open val constraintTypes:

ConstraintInfo

abstract val contractStateTypes:

Type

out

open val exactParticipants:

open val externalIds:

open val participants:

open val relevancyStatus: RelevancyStatus

abstract val status: StateStatus

open fun visit(parser:

)

data class FungibleAssetQueryCriteria : CommonQueryCriteria

Predicate

Module Contents

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

)

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

exactParticipants

)

out

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

FungibleAssetQueryCriteria

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

)

FungibleAssetQueryCriteria

)

Predicate

out

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withIssuer(issuer:

fun withissuerRef(issuerRef:

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withOwner(owner:

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withStatus(status: StateStatus): FungibleAssetQueryCriteria

data class FungibleStateQueryCriteria : CommonQueryCriteria

Module Contents

FungibleStateQueryCriteria(participants:

quantity

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

out

)

Predicate

out

)

FungibleStateQueryCriteria

)

FungibleStateQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): FungibleStateQueryCriteria

)

FungibleStateQueryCriteria

fun withStatus(status: StateStatus): FungibleStateQueryCriteria

data class LinearStateQueryCriteria : CommonQueryCriteria

Module Contents

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

uuid

externalId

status

StateStatus

contractStateTypes

out

)

linearId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

linearId

status

StateStatus

contractStateTypes

out

)

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

exactParticipants

)

out

uuid

externalId

status

StateStatus

contractStateTypes

out

)

LinearStateQueryCriteria

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

LinearStateQueryCriteria

)

Predicate

out

)

LinearStateQueryCriteria

fun withExternalId(externalId:

)

LinearStateQueryCriteria

)

LinearStateQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): LinearStateQueryCriteria

)

LinearStateQueryCriteria

fun withStatus(status: StateStatus): LinearStateQueryCriteria

fun withUuid(uuid:

)

LinearStateQueryCriteria

)

data class SoftLockingCondition

OrVisitor

Module Contents

)

Module Contents

SoftLockingCondition(type: SoftLockingType, lockIds:

)

val type: SoftLockingType

enum class SoftLockingType

Module Contents

LOCKED_ONLY

SPECIFIED

UNLOCKED_AND_SPECIFIED

UNLOCKED_ONLY

data class TimeCondition

Module Contents

TimeCondition(type: TimeInstantType, predicate:

)

val type: TimeInstantType

enum class TimeInstantType

Module Contents

data class VaultCustomQueryCriteria<L :

RECORDED

CommonQueryCriteria

Module Contents

status

StateStatus

contractStateTypes

out

)

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

out

status

StateStatus

contractStateTypes

out

)

VaultCustomQueryCriteria

val expression:

)

Predicate

out

fun withExpression(expression:

)

VaultCustomQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): VaultCustomQueryCriteria<L>

)

VaultCustomQueryCriteria

fun withStatus(status: StateStatus): VaultCustomQueryCriteria<L>

data class VaultQueryCriteria : CommonQueryCriteria

Module Contents

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

ConstraintInfo

participants

externalIds

)

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

)

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

)

VaultQueryCriteria(status: StateStatus)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

VaultQueryCriteria(status: StateStatus, contractStateTypes:

)

out

stateRefs

)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

stateRefs

notary

)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

)

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

externalIds

exactParticipants

)

ConstraintInfo

Type

out

fun copy(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

fun copy(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

ConstraintInfo

participants

externalIds

)

VaultQueryCriteria

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

fun copy(status: StateStatus = this.status, contractStateTypes:

)

VaultQueryCriteria

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

)

VaultQueryCriteria

val softLockingCondition: SoftLockingCondition?

val stateRefs:

val timeCondition: TimeCondition?

)

fun withConstraints(constraints:

Predicate

fun withConstraintTypes(constraintTypes:

ConstraintInfo

)

VaultQueryCriteria

Type

)

VaultQueryCriteria

out

)

VaultQueryCriteria

fun withExternalIds(externalIds:

)

VaultQueryCriteria

)

VaultQueryCriteria

fun withNotary(notary:

)

VaultQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): VaultQueryCriteria

)

VaultQueryCriteria

fun withSoftLockingCondition(softLockingCondition: SoftLockingCondition): VaultQueryCriteria

fun withStateRefs(stateRefs:

fun withStatus(status: StateStatus): VaultQueryCriteria

)

VaultQueryCriteria

fun withTimeCondition(timeCondition: TimeCondition): VaultQueryCriteria

class ReceiveFinalityFlow :

Module Contents

expectedTxId

statesToRecord

)

expectedTxId

statesToRecord

handlePropagatedNotaryError

)

data class ReceiverDistributionRecord :

ReceiverDistributionRecord(txId:

Module Contents

peerPartyId

timestamp

timestampDiscriminator

encryptedDistributionList

receiverStatesToRecord

val encryptedDistributionList:

)

class ReceiveStateAndRefFlow<out T :

@JvmSuppressWildcards

ReceiveStateAndRefFlow(otherSideSession:

Module Contents

)

open class ReceiveTransactionFlow :

Module Contents

checkSufficientSignatures

statesToRecord

)

checkSufficientSignatures

statesToRecord

handlePropagatedNotaryError

)

@Suspendable protected open fun checkBeforeRecording(stx:

)

open fun resolvePayload(payload:

)

data class RecoveryTimeWindow

Module Contents

RecoveryTimeWindow(fromTime:

untilTime

)

untilTime

)

)

data class ReferencedStateAndRef<out T :

)

ReferencedStateAndRef(stateAndRef:

Module Contents

)

val stateAndRef:

data class ReferenceStateRef

Module Contents

ReferenceStateRef(stateRef:

)

Module Contents

using

(

expr

)

class ResultSerializationException :

ResultSerializationException(e: MissingSerializerException)

Module Contents

@DoNotImplement interface RPCConnection<out I :

Module Contents

abstract fun forceClose():

abstract fun <T> getTelemetryHandle(telemetryClass:

abstract fun notifyServerAndClose():

)

abstract val serverProtocolVersion:

abstract val proxy: I

interface RPCConnectionListener<I :

interface ConnectionContext<I :

Module Contents

abstract val connectionOpt:

Module Contents

RPCConnection

abstract val throwableOpt:

abstract val userName:

abstract fun onConnect(context: ConnectionContext):

abstract fun onDisconnect(context: ConnectionContext):

abstract fun onPermanentFailure(context: ConnectionContext):

open class RPCException :

Module Contents

RPCException(msg:

)

RPCException(message:

cause

@DoNotImplement interface RPCOps

)

Module Contents

abstract val protocolVersion:

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

Module Contents

RPCReturnsObservables()

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

Module Contents

RPCSinceVersion(version:

)

Module Contents

fun <T> Observable<T>.notUsed():

fun <ELEMENT> Observable<ELEMENT>.mapErrors(transform: (

Module Contents

)

fun <T> Observable<T>.toFuture():

)

Observable

ELEMENT

fun <T> Observable<T>.continueOnError(): Observable<T>

Module Contents

object SampleCashSchemaV1 :

Module Contents

PersistentCashState(ownerHash:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object SampleCashSchemaV2 :

@Entity class PersistentCashState : FungibleState

Module Contents

Module Contents

PersistentCashState(currency:

participants

owner

quantity

issuerParty

issuerRef

)

object SampleCashSchemaV3 :

Module Contents

PersistentCashState(participants:

Module Contents

owner

pennies

currency

issuer

issuerRef

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class SchedulableFlow

Module Contents

SchedulableFlow()

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 :

sealed class SecureHash :

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

Module Contents

)

Module Contents

)

bytes

)

)

)

SHA256

)

bytes

)

bytes

)

)

SHA256

)

)

SHA256

)

SHA256

)

SHA256

)

bytes

)

fun concatenate(other:

)

fun concatenateAs(concatAlgorithm:

other

)

)

)

SHA256

)

protected open fun generate(data:

)

Module Contents

bytes

)

)

)

bytes

)

fun hashConcat(other:

)

SHA256

bytes

)

fun prefixChars(prefixLen:

)

SHA256

)

)

Module Contents

)

)

)

)

SHA256

)

SHA256

)

SHA256

)

data class SenderDistributionRecord :

SenderDistributionRecord(txId:

Module Contents

peerPartyId

timestamp

timestampDiscriminator

senderStatesToRecord

receiverStatesToRecord

)

open class SendStateAndRefFlow :

SendStateAndRefFlow(otherSideSession:

Module Contents

stateAndRefs

open class SendTransactionFlow :

)

SendTransactionFlow(otherSide:

Module Contents

stx

)

SendTransactionFlow(stx:

participantSessions

observerSessions

senderStatesToRecord

recordMetaDataEvenIfNotFullySigned

val DUMMY_PARTICIPANT_NAME:

)

fun makeMetaData(stx:

recordMetaDataEvenIfNotFullySigned

senderStatesToRecord

participantSessions

observerSessions

)

val participantSessions:

val stx:

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.FUNCTION]) annotation class SerializableCalculatedProperty

Module Contents

SerializableCalculatedProperty()

@DoNotImplement interface SerializationContext

Module Contents

abstract val carpenterDisabled:

abstract val customSerializers:

abstract val encoding:

abstract val encodingWhitelist:

abstract val lenientCarpenterEnabled:

abstract val objectReferencesEnabled:

abstract val preferredSerializationVersion:

abstract val preventDataLoss:

abstract val useCase: UseCase

Module Contents

abstract fun ~~withAttachmentsClassLoader~~(attachmentHashes:

)

abstract fun withClassLoader(classLoader:

)

abstract fun withCustomSerializers(serializers:

)

abstract fun withEncoding(encoding:

)

abstract fun withEncodingWhitelist(encodingWhitelist:

)

abstract fun withLenientCarpenter():

abstract fun withoutCarpenter():

abstract fun withoutReferences():

abstract fun withPreferredSerializationVersion(magic:

)

abstract fun withPreventDataLoss():

abstract fun withProperties(extraProperties:

)

abstract fun withProperty(property:

value

)

abstract fun withWhitelisted(clazz:

)

interface SerializationCustomSerializer<OBJ, PROXY>

Module Contents

object SerializationDefaults

Module Contents

val P2P_CONTEXT:

val RPC_CLIENT_CONTEXT:

val RPC_SERVER_CONTEXT:

val SERIALIZATION_FACTORY:

val STORAGE_CONTEXT:

@DoNotImplement interface SerializationEncoding

abstract class SerializationFactory

Module Contents

SerializationFactory()

fun <T> asCurrent(block:

(

)

deserialize

(

byteSequence

clazz

context

)

deserializeWithCompatibleContext

(

byteSequence

clazz

context

ObjectWithCompatibleContext

)

serialize

(

obj

context

)

fun <T> withCurrentContext(context:

typealias SerializationMagic =

block

(

)

@DoNotImplement interface SerializationSchemeContext

Module Contents

interface SerializationToken

Module Contents

abstract fun fromToken(context:

)

interface SerializationWhitelist

Module Contents

interface SerializeAsToken

Module Contents

abstract fun toToken(context:

)

interface SerializeAsTokenContext

Module Contents

abstract fun getSingleton(className:

)

abstract fun putSingleton(toBeTokenized:

)

abstract val serviceHub:

class SerializedBytes<T :

Module Contents

SerializedBytes(bytes:

)

from

(

obj

serializationFactory

context

)

interface ServiceHub :

Module Contents

publicKey

)

abstract val contractUpgradeService:

)

cordaService

(

type

abstract fun <T : TelemetryComponent> cordaTelemetryComponent(type:

)

)

publicKey

)

)

publicKey

)

)

abstract val diagnosticsService:

open fun getAppContext():

abstract fun jdbcSession():

abstract val keyManagementService:

abstract val myInfo:

abstract val networkMapCache:

txs

)

first

vararg

remaining

)

abstract fun recordTransactions(statesToRecord:

txs

)

open fun recordTransactions(first:

vararg

remaining

)

open fun recordTransactions(txs:

)

abstract fun registerUnloadHandler(runOnStop: () ->

)

publicKey

)

)

abstract val telemetryService:

signingPubKeys

)

TelemetryService

toStateAndRef

(

stateRef

)

abstract val validatedTransactions:

abstract val vaultService:

abstract fun <T> withEntityManager(block: EntityManager.() -> T): T

abstract fun withEntityManager(block:

EntityManager

)

enum class ServiceLifecycleEvent

Module Contents

BEFORE_STATE_MACHINE_START

STATE_MACHINE_STARTED

@FunctionalInterface interface ServiceLifecycleObserver

Module Contents

abstract fun onServiceLifecycleEvent(event:

)

@DoNotImplement interface ServicesForResolution

Module Contents

abstract val attachments:

abstract val cordappProvider:

abstract val identityService:

abstract fun loadContractAttachment(stateRef:

)

abstract fun loadState(stateRef:

)

abstract fun loadStates(stateRefs:

)

abstract val networkParametersService:

open fun specialise(ltx:

)

@DoNotImplement interface SessionScope

Module Contents

abstract val session: Session

object SgxSupport

Module Contents

@JvmStatic val isInsideEnclave:

data class SignableData

Module Contents

SignableData(txId:

signatureMetadata

)

data class SignatureAttachmentConstraint :

SignatureAttachmentConstraint(key:

Module Contents

)

Module Contents

)

)

data class SignatureMetadata

)

Module Contents

SignatureMetadata(platformVersion:

schemeNumberID

)

data class SignatureScheme

Module Contents

SignatureScheme(schemeNumberID:

schemeCodeName

signatureOID

alternativeOIDs

providerName

algorithmName

signatureName

algSpec

keySize

desc

)

open class SignedData<T :

Module Contents

SignedData(raw:

protected open fun verifyData(data: T):

sig

WithKey

)

data class SignedTransaction :

Module Contents

SignedTransaction(ctx:

sigs

SignedTransaction(txBits:

)

sigs

)

)

)

fun ~~isNotaryChangeTransaction~~():

val ~~notaryChangeTx~~:

operator fun plus(sig:

)

operator fun plus(sigList:

)

fun resolveBaseTransaction(servicesForResolution:

)

fun resolveContractUpgradeTransaction(services:

)

)

)

fun resolveTransactionWithSignatures(services:

)

class SignaturesMissingException :

SignatureException

SignaturesMissingException(missing:

Module Contents

descriptions

)

@JvmOverloads fun toLedgerTransaction(services:

@JvmOverloads fun verify(services:

checkSufficientSignatures

)

checkSufficientSignatures

)

@VisibleForTesting fun withAdditionalSignature(keyPair:

signatureMetadata

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList:

)

data class SignedTransactionWithDistributionList

Module Contents

SignedTransactionWithDistributionList(stx:

distributionList

isFinality

)

data class SignedTransactionWithStatus :

SignedTransactionWithStatus(stx:

Module Contents

status

)

abstract class SignTransactionFlow :

SignTransactionFlow(otherSideSession:

Module Contents

progressTracker

)

@Suspendable protected abstract fun checkTransaction(stx:

)

val otherSideSession:

interface SingleMessageRecipient :

class SingletonSerializationToken :

Module Contents

fun fromToken(context:

)

fun registerWithContext(context:

toBeTokenized

)

singletonSerializationToken

(

toBeTokenized

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

)

@DoNotImplement interface Attribute

Module Contents

SortColumn

)

enum class CommonStateAttribute : Attribute

SortColumn

Module Contents

Module Contents

enum class FungibleStateAttribute : Attribute

Module Contents

enum class LinearStateAttribute : Attribute

Module Contents

data class SortColumn

Module Contents

SortColumn(sortAttribute:

direction

Direction

)

val sortAttribute:

enum class VaultStateAttribute : Attribute

Module Contents

sealed class SortAttribute

Module Contents

data class Custom :

Module Contents

Custom(entityStateClass:

out

entityStateColumnName

)

val entityStateClass:

out

val entityStateColumnName:

data class Standard :

Standard(attribute: Attribute)

Module Contents

val attribute: Attribute

data class SourceAndAmount<T :

out

SourceAndAmount(source: P, amount:

Module Contents

ref

)

data class StackFrameDataToken

Module Contents

StackFrameDataToken(className:

)

val className:

@Target([AnnotationTarget.CLASS]) annotation class StartableByRPC

Module Contents

StartableByRPC()

@Target([AnnotationTarget.CLASS]) annotation class StartableByService

Module Contents

StartableByService()

class StartedMockNode

Module Contents

findStateMachines

(

flowClass

)

)

MessageTransfer

registerInitiatedFlow

(

initiatedFlowClass

)

Observable

registerInitiatedFlow

(

initiatingFlowClass

out

initiatedFlowClass

)

Observable

fun <T> transaction(statement: () -> T): T

fun <T> startFlow(logic:

)

data class StateAndContract

Module Contents

StateAndContract(state:

contract

)

data class StateAndRef<out T :

Module Contents

ref

)

val state:

data class StateConsumptionDetails

Module Contents

)

enum class ConsumedStateType

type

ConsumedStateType

)

Module Contents

INPUT_STATE

REFERENCE_INPUT_STATE

fun copy(hashOfTransactionId:

)

val hashOfTransactionId:

val type: ConsumedStateType

data class StateMachineInfo

Module Contents

flowLogicClassName

initiator

progressTrackerStepAndUpdates

invocationContext

)

flowLogicClassName

initiator

progressTrackerStepAndUpdates

)

val flowLogicClassName:

val ~~initiator~~:

val progressTrackerStepAndUpdates:

data class StateMachineRunId

Module Contents

StateMachineRunId(uuid:

)

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val transactionId:

sealed class StateMachineUpdate

Module Contents

data class Added :

StateMachineUpdate

Module Contents

Added(stateMachineInfo:

)

interface StatePersistable

val stateMachineInfo:

Module Contents

result

)

@DoNotImplement sealed class StatePointer<T :

Module Contents

abstract val isResolved:

linearPointer

(

state

isResolved

)

LinearPointer

abstract val pointer:

abstract fun resolve(services:

)

abstract fun resolve(ltx:

)

staticPointer

(

stateAndRef

isResolved

)

Module Contents

index

)

open class StateReplacementException :

StateReplacementException(message:

Module Contents

cause

class StatesNotAvailableException :

)

StatesNotAvailableException(message:

Module Contents

cause

)

enum class StatesToRecord

Module Contents

ALL_VISIBLE

NONE

ONLY_RELEVANT

class StaticPointer<T :

Module Contents

type

)

type

isResolved

)

)

@ThreadSafe open class StringToMethodCallParser<in T :

)

)

Module Contents

out

)

out

ObjectMapper

)

val availableCommands:

protected val methodMap: Multimap<

open fun paramNamesFromConstructor(ctor:

val methodParamNames:

Constructor

)

open fun paramNamesFromMethod(method:

)

fun parse(target: T?, command:

fun parseArguments(methodNameHint:

)

ParsedMethodCall

parameters

args

)

inner class ParsedMethodCall<in T :

Callable

ParsedMethodCall(target: T?, method:

Module Contents

args

)

operator fun invoke():

val method:

open class UnparseableCallException :

UnparseableCallException(command:

Module Contents

cause

class FailedParse : UnparseableCallException

)

Module Contents

FailedParse(e:

class MissingParameter : UnparseableCallException

)

Module Contents

MissingParameter(methodName:

paramName

command

)

class NoSuchFile : UnparseableCallException

Module Contents

NoSuchFile(filename:

class ReflectionDataMissing : UnparseableCallException

)

Module Contents

ReflectionDataMissing(methodName:

argIndex

class TooManyParameters : UnparseableCallException

)

Module Contents

TooManyParameters(methodName:

command

class UnknownMethod : UnparseableCallException

)

Module Contents

UnknownMethod(methodName:

)

val methodName:

fun validateIsMatchingCtor(methodNameHint:

parameters

args

)

@DoNotImplement interface TelemetryService

Module Contents

abstract fun <T> getTelemetryHandle(telemetryClass:

)

Module Contents

)

fun daysToMaturity(startDate:

calendar

)

Module Contents

@ThreadSafe class TestClock : MutableClock

Module Contents

TestClock(delegateClock:

@Synchronized fun advanceBy(duration:

)

)

@Synchronized fun setTo(newInstant:

)

@DoNotImplement abstract class TestCordapp

Module Contents

@JvmStatic fun findCordapp(scanPackage:

)

abstract fun withConfig(config:

)

data class TestLedgerDSLInterpreter :

TestLedgerDSLInterpreter(services:

Module Contents

fun _transaction(transactionLabel:

)

transactionBuilder

dsl

(

)

)

(

)

)

fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

fun attachment(attachment:

)

fun transactionName(transactionHash:

fun outputToLabel(state:

)

retrieveOutputStateAndRef

(

clazz

label

)

)

val transactionsToVerify:

val transactionsUnverified:

Module Contents

TypeMismatch(requested:

actual

)

class VerifiesFailed :

VerifiesFailed(transactionName:

Module Contents

cause

)

val wireTransactions:

data class TestTransactionDSLInterpreter :

TestTransactionDSLInterpreter(ledgerInterpreter:

Module Contents

transactionBuilder

)

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

fun attachment(attachmentId:

)

commandData

)

)

val ledgerInterpreter:

label

notary

encumbrance

attachmentConstraint

contractState

)

fun reference(stateRef:

)

fun timeWindow(data:

)

val transactionBuilder:

fun verifies():

abstract class TimeWindow

Module Contents

TimeWindow()

untilTime

)

abstract operator fun contains(instant:

)

)

@JvmStatic fun fromStartAndDuration(fromTime:

duration

)

abstract val fromTime:

val length:

abstract val midpoint:

)

abstract val untilTime:

@JvmStatic fun withTolerance(instant:

tolerance

)

class ~~TimeWindowChecker~~

Module Contents

TimeWindowChecker(clock:

)

val clock:

fun isValid(timeWindow:

)

interface TokenizableAssetInfo

Module Contents

abstract val displayTokenSize:

Trace(invocationId: InvocationId, sessionId: SessionId)

data class Trace

Module Contents

Module Contents

timestamp

)

timestamp

val invocationId: InvocationId

)

InvocationId

@JvmStatic fun newInstance(invocationId: InvocationId = InvocationId.newInstance(), sessionId: SessionId = SessionId(invocationId.value, invocationId.timestamp)):

Module Contents

timestamp

)

timestamp

open class TransactionBuilder

)

SessionId

val sessionId: SessionId

Module Contents

lockId

inputs

attachments

outputs

commands

window

privacySalt

)

)

fun addAttachment(attachmentId:

lockId

inputs

attachments

outputs

commands

window

privacySalt

references

serviceHub

)

)

)

vararg

keys

)

keys

)

open fun addInputState(stateAndRef:

)

)

contract

notary

encumbrance

constraint

)

contract

constraint

)

constraint

)

open fun addReferenceState(referencedStateAndRef:

protected val attachments:

)

protected val commands:

protected val inputs:

protected val outputs:

protected var privacySalt:

protected val references:

fun referenceStates():

protected val serviceHub:

fun setPrivacySalt(privacySalt:

)

fun setTimeWindow(timeWindow:

)

fun setTimeWindow(time:

timeTolerance

)

)

fun toSignedTransaction(keyManagementService:

publicKey

signatureMetadata

services

)

)

schemeId

)

schemeId

properties

)

)

protected var window:

fun withItems(vararg items:

)

class TransactionDSL<out T :

TransactionDSL(interpreter: T, notary:

Module Contents

)

)

attachmentId

signers

jarManifestAttributes

)

attachmentId

)

fun attachments(vararg contractClassNames:

)

commandData

)

fun input(stateLabel:

)

stateLabel

)

state

)

label

notary

contractState

)

label

encumbrance

contractState

)

label

contractState

)

notary

contractState

)

encumbrance

contractState

)

contractState

)

fun reference(stateLabel:

)

fun reference(contractClassName:

state

)

@JvmOverloads fun timeWindow(time:

tolerance

)

(

)

)

@DoNotImplement interface TransactionDSLInterpreter :

Module Contents

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

abstract fun attachment(attachmentId:

)

abstract fun command(signers:

commandData

)

abstract fun input(stateRef:

)

abstract val ledgerInterpreter:

abstract fun output(contractClassName:

label

notary

encumbrance

attachmentConstraint

contractState

)

abstract fun reference(stateRef:

)

abstract fun timeWindow(data:

)

data class TransactionMetadata

Module Contents

TransactionMetadata(initiator:

distributionList

)

val initiator:

open class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

message

)

class UnknownParametersException :

TransactionResolutionException

Module Contents

UnknownParametersException(txId:

paramsHash

class TransactionSignature :

)

DigitalSignature

Module Contents

signatureMetadata

)

signatureMetadata

partialMerkleTree

)

)

)

data class TransactionState<out T :

)

TransactionState(data: T, contract:

Module Contents

notary

encumbrance

constraint

)

enum class TransactionStatus

Module Contents

IN_FLIGHT

UNVERIFIED

VERIFIED

@DoNotImplement interface TransactionStorage

Module Contents

abstract fun getTransaction(id:

)

abstract fun getTransactionWithStatus(id:

SignedTransactionWithStatus

)

abstract fun trackTransaction(id:

)

abstract val updates: Observable<

abstract class TransactionVerificationException :

TransactionVerificationException(txId:

Module Contents

message

cause

class AttachmentTooBigException :

)

AttachmentTooBigException(txId:

Module Contents

class BrokenTransactionException :

)

BrokenTransactionException(txId:

Module Contents

message

class ConflictingAttachmentsRejection :

)

ConflictingAttachmentsRejection(txId:

Module Contents

contractClass

)

class ConstraintPropagationRejection :

Module Contents

contractClass

inputConstraint

outputConstraint

)

class ContractConstraintRejection :

message

)

ContractConstraintRejection(txId:

Module Contents

contractClass

)

class ContractCreationError :

Module Contents

val contractClass:

class ContractRejection :

class DuplicateAttachmentsRejection :

Module Contents

Module Contents

DuplicateAttachmentsRejection(txId:

Module Contents

attachmentId

)

class InvalidAttachmentException :

InvalidAttachmentException(txId:

Module Contents

attachmentHash

)

class InvalidConstraintRejection :

InvalidConstraintRejection(txId:

Module Contents

contractClass

reason

)

class MissingAttachmentRejection :

MissingAttachmentRejection(txId:

Module Contents

contractClass

)

class MissingNetworkParametersException :

Module Contents

missingNetworkParametersHash

)

message

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(txId:

Module Contents

txNotary

outputNotary

)

class OverlappingAttachmentsException :

OverlappingAttachmentsException(txId:

Module Contents

path

)

class PackageOwnershipException :

PackageOwnershipException(txId:

Module Contents

attachmentHash

invalidClassName

packageName

)

val invalidClassName:

val packageName:

class TransactionContractConflictException :

Module Contents

state

requiredContractClassName

)

message

class TransactionDuplicateEncumbranceException :

)

Module Contents

index

)

message

class TransactionMissingEncumbranceException :

)

TransactionMissingEncumbranceException(txId:

Module Contents

missing

inOut

Direction

)

val inOut: Direction

val missing:

class TransactionNetworkParameterOrderingException :

Module Contents

inputStateRef

txnNetworkParameters

inputNetworkParameters

)

message

class TransactionNonMatchingEncumbranceException :

)

Module Contents

nonMatching

)

message

class TransactionNotaryMismatchEncumbranceException :

)

TransactionNotaryMismatchEncumbranceException(txId:

Module Contents

encumberedIndex

encumbranceIndex

encumberedNotary

encumbranceNotary

)

TransactionNotaryMismatchEncumbranceException(txId:

message

class TransactionRequiredContractUnspecifiedException :

)

TransactionRequiredContractUnspecifiedException(txId:

Module Contents

state

TransactionRequiredContractUnspecifiedException(txId:

)

message

)

class UnsupportedClassVersionError :

UnsupportedClassVersionError(txId:

Module Contents

message

cause

class UnsupportedHashTypeException :

)

UnsupportedHashTypeException(txId:

Module Contents

class UntrustedAttachmentsException :

)

UntrustedAttachmentsException(txId:

Module Contents

ids

)

@DoNotImplement interface TransactionWithSignatures :

open fun checkSignaturesAreValid():

Module Contents

abstract fun getKeyDescriptions(keys:

)

open fun getMissingSigners():

abstract val requiredSigningKeys:

open fun verifyRequiredSignatures():

open fun verifySignaturesExcept(vararg allowedToBeMissing:

)

open fun verifySignaturesExcept(allowedToBeMissing:

)

abstract class TraversableTransaction :

Module Contents

)

val availableComponentGroups:

digestService

)

open val componentGroups:

open val networkParametersHash:

sealed class Try<out A>

Module Contents

inline fun <B, C> combine(other:

function

(

)

fun doOnFailure(action:

)

fun doOnSuccess(action:

)

data class Failure<out A> :

Module Contents

)

inline fun flatMap(function: (A) ->

)

abstract fun getOrThrow(): A

abstract val isFailure:

abstract val isSuccess:

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

@JvmStatic inline fun <T> on(body: () -> T):

data class Success<out A> :

Module Contents

object TwoPartyDealFlow

Module Contents

class Acceptor : Secondary<AutoOffer>

Module Contents

Acceptor(otherSideSession:

progressTracker

protected open fun assembleSharedTX(handshake: Handshake<AutoOffer>):

)

protected open fun validateHandshake(handshake: Handshake<AutoOffer>): Handshake<AutoOffer>

Module Contents

dealBeingOffered

)

val dealBeingOffered:

data class Handshake<out T>

Module Contents

Handshake(payload: T, primaryIdentity:

secondaryIdentity

)

val secondaryIdentity:

class Instigator : Primary

Module Contents

Instigator(otherSideSession:

payload

AutoOffer

progressTracker

@Suspendable open fun checkProposal(stx:

)

)

open val notaryParty:

open val payload: AutoOffer

abstract class Primary :

Module Contents

Primary(progressTracker:

)

@Suspendable abstract fun checkProposal(stx:

)

abstract val notaryParty:

abstract val payload:

object SENDING_PROPOSAL : Step

abstract class Secondary :

Secondary(progressTracker:

Module Contents

@Suspendable protected abstract fun assembleSharedTX(handshake: Handshake):

)

@Suspendable protected abstract fun validateHandshake(handshake: Handshake): Handshake

class AssetMismatchException :

object TwoPartyTradeFlow

Module Contents

AssetMismatchException(expectedTypeName:

Module Contents

typeName

)

val expectedTypeName:

Module Contents

Buyer(otherSideSession:

notary

acceptablePrice

typeToBuy

out

)

notary

acceptablePrice

typeToBuy

out

anonymous

)

Module Contents

Module Contents

cashSigningPubKeys

)

val cashSigningPubKeys:

class Seller :

object AWAITING_PROPOSAL : Step

Module Contents

Seller(otherSideSession:

assetToSell

price

myParty

progressTracker

)

object VERIFYING_AND_SIGNING : Step

Module Contents

data class SellerTradeInfo

Module Contents

SellerTradeInfo(price:

payToIdentity

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

abstract class TypeOnlyCommandData :

)

Module Contents

TypeOnlyCommandData()

class UnexpectedFlowEndException :

)

IdentifiableException

Module Contents

cause

)

)

data class UniqueIdentifier :

cause

originalErrorId

)

UniqueIdentifier(externalId:

Module Contents

)

)

)

@VisibleForTesting fun fromString(name:

)

class UnknownAnonymousPartyException :

UnknownAnonymousPartyException(message:

Module Contents

)

class UnknownCalendar :

Module Contents

UnknownCalendar(name:

open class UnrecoverableRPCException :

)

UnrecoverableRPCException(message:

Module Contents

cause

class UntrustworthyData<out T>

)

class UnstartedMockNode

Module Contents

installCordaService

(

serviceClass

)

Module Contents

UntrustworthyData(fromUntrustedWorld: T)

@Suspendable fun <R> unwrap(validator: Validator<T, R>): R

@FunctionalInterface interface Validator<in T, out R> :

@Suspendable abstract fun validate(data: T): R

Module Contents

interface UpgradedContract<in OldState :

out

NewState

abstract val legacyContract:

Module Contents

abstract fun upgrade(state: OldState): NewState

interface UpgradedContractWithLegacyConstraint<in OldState :

out

NewState

abstract val legacyContractConstraint:

OldState

NewState

Module Contents

Module Contents

password

permissions

)

Module Contents

interface VariablePropertyDelegate<T> :

PropertyDelegate

Module Contents

abstract operator fun setValue(thisRef:

property

data class ConstraintInfo

value

)

Module Contents

)

Module Contents

ConstraintInfo(constraint:

)

val constraint:

fun constraintInfo(type: Type, data:

)

ConstraintInfo

Module Contents

val ~~NoNotaryUpdate~~: Update<

val ~~NoUpdate~~: Update<

Module Contents

statesMetadata

StateMetadata

totalStatesAvailable

stateTypes

StateStatus

otherResults

previousPageAnchor

)

statesMetadata

StateMetadata

totalStatesAvailable

stateTypes

StateStatus

otherResults

)

Page

val otherResults:

val stateTypes: StateStatus

val previousPageAnchor:

StateMetadata

val totalStatesAvailable:

enum class RelevancyStatus

Module Contents

NOT_RELEVANT

RELEVANT

data class StateMetadata

Module Contents

StateMetadata(ref:

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

val constraintInfo: ConstraintInfo?

relevancyStatus

RelevancyStatus

constraintInfo

ConstraintInfo

)

val consumedTime:

val contractStateClassName:

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

)

StateMetadata

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

val relevancyStatus: RelevancyStatus?

relevancyStatus

RelevancyStatus

)

StateMetadata

val states:

enum class StateStatus

Module Contents

UNCONSUMED

data class Update<U :

Module Contents

produced

flowId

type

UpdateType

references

)

produced

flowId

type

UpdateType

references

consumingTxIds

)

containsType

(

)

containsType

(

clazz

status

StateStatus

)

produced

flowId

type

UpdateType

)

Update

produced

flowId

type

UpdateType

references

operator fun plus(rhs: Update): Update

)

Update

enum class UpdateType

Module Contents

CONTRACT_UPGRADE

GENERAL

NOTARY_CHANGE

class VaultQueryException :

Module Contents

)

cause

@DoNotImplement interface VaultService

)

Module Contents

_queryBy

(

criteria

paging

sorting

contractStateType

out

)

Page

_trackBy

(

criteria

paging

sorting

contractStateType

out

)

abstract fun addNoteToTransaction(txnId:

Page

Update

noteText

)

abstract fun getTransactionNotes(txnId:

)

queryBy

(

contractStateType

out

)

Page

queryBy

(

contractStateType

out

criteria

)

Page

queryBy

(

contractStateType

out

paging

)

Page

queryBy

(

contractStateType

out

criteria

paging

)

Page

queryBy

(

contractStateType

out

criteria

sorting

)

Page

queryBy

(

contractStateType

out

criteria

paging

sorting

abstract val rawUpdates: Observable<Update<

)

Page

abstract fun softLockRelease(lockId:

stateRefs

)

abstract fun softLockReserve(lockId:

stateRefs

)

trackBy

(

contractStateType

out

)

Page

Update

trackBy

(

contractStateType

out

criteria

)

Page

Update

trackBy

(

contractStateType

out

paging

)

Page

Update

trackBy

(

contractStateType

out

criteria

paging

)

Page

Update

trackBy

(

contractStateType

out

criteria

sorting

)

Page

Update

trackBy

(

contractStateType

@Suspendable abstract fun <T :

out

criteria

paging

sorting

)

Page

Update

FungibleState

tryLockFungibleStatesForSpending

(

lockId

eligibleStatesQuery

amount

contractStateType

out

)

abstract val updates: Observable<Update<

open fun whenConsumed(ref:

)

Update

@DoNotImplement interface Verifies

enum class VerifierType

Module Contents

InMemory

Module Contents

open fun fails():

open infix fun fails with(msg:

)

open fun failsWith(expectedMessage:

)

abstract fun verifies():

data class WaitTimeUpdate

Module Contents

WaitTimeUpdate(waitTime:

)

val waitTime:

WebserverHandle(listenAddress:

data class ~~WebserverHandle~~

Module Contents

process

)

object WhitelistedByZoneAttachmentConstraint :

Module Contents

)

class WireTransaction :

Module Contents

)

privacySalt

)

WireTransaction(inputs:

attachments

outputs

commands

notary

timeWindow

privacySalt

)

privacySalt

digestService

)

)

fun checkSignature(sig:

)

@CordaInternal fun ~~createComponentGroups~~(inputs:

outputs

commands

attachments

notary

timeWindow

)

)

@CordaInternal fun resolveStateRefBinaryComponent(stateRef:

services

)

)

fun ~~toLedgerTransaction~~(resolveIdentity: (

)

resolveAttachment

(

)

resolveStateRef

(

)

class WithReferencedStatesFlow<T :

resolveContractAttachment

(

)

)

WithReferencedStatesFlow(progressTracker:

Module Contents

flowLogicProducer

(

)

@Suspendable fun call(): T

)

object ATTEMPT : Step

object RETRYING : Step

object SUCCESS : Step

class ZoneVersionTooLowException :

ZoneVersionTooLowException(message:

Module Contents

package net.corda.client.jackson

)

Module Contents

object JacksonSupport

Module Contents

object ~~AmountDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~AmountSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

object ~~AnonymousPartyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~AnonymousPartySerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

object ~~CordaX500NameDeserializer~~ : JsonDeserializer<

val ~~cordaModule~~: Module

Module Contents

context

DeserializationContext

)

object ~~CordaX500NameSerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

@JvmStatic @JvmOverloads fun createDefaultMapper(rpc:

factory

fuzzyIdentityMatch

fullParties

)

ObjectMapper

@JvmStatic @JvmOverloads fun createInMemoryMapper(identityService:

factory

fuzzyIdentityMatch

fullParties

)

ObjectMapper

@JvmStatic @JvmOverloads fun createNonRpcMapper(factory:

JsonFactory

fullParties

class ~~IdentityObjectMapper~~ : PartyObjectMapper, ObjectMapper

)

ObjectMapper

Module Contents

IdentityObjectMapper(identityService:

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

object ~~NodeInfoDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~NodeInfoSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

class ~~NoPartyObjectMapper~~ : PartyObjectMapper, ObjectMapper

Module Contents

NoPartyObjectMapper(factory:

isFullParties

)

)

)

)

)

object ~~OpaqueBytesDeserializer~~ : JsonDeserializer<

Module Contents

ctxt

DeserializationContext

)

object ~~OpaqueBytesSerializer~~ : JsonSerializer<

Module Contents

gen

serializers

SerializerProvider

)

object ~~PartyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

@DoNotImplement interface PartyObjectMapper

Module Contents

abstract val isFullParties:

)

)

abstract fun partyFromKey(owningKey:

)

)

object ~~PartySerializer~~ : JsonSerializer<

Module Contents

gen

provider

SerializerProvider

)

object ~~PublicKeyDeserializer~~ : JsonDeserializer<

Module Contents

context

DeserializationContext

)

object ~~PublicKeySerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

class ~~RpcObjectMapper~~ : PartyObjectMapper, ObjectMapper

Module Contents

factory

fuzzyIdentityMatch

isFullParties

)

val isFullParties:

)

)

)

)

class ~~SecureHashDeserializer~~<T :

JsonDeserializer

Module Contents

SecureHashDeserializer()

object ~~SecureHashSerializer~~ : JsonSerializer<

context

DeserializationContext

)

Module Contents

generator

provider

SerializerProvider

)

abstract class ~~SignedTransactionMixin~~

Module Contents

SignedTransactionMixin()

abstract fun getId():

abstract fun getInputs():

abstract fun getNotary():

abstract fun getNotaryChangeTx():

abstract fun getRequiredSigningKeys():

protected abstract fun getSigs():

protected abstract fun getTransaction():

abstract fun getTx():

abstract fun getTxBits():

object ~~ToStringSerializer~~ : JsonSerializer<

Module Contents

generator

provider

SerializerProvider

)

abstract fun getAvailableComponentHashes():

abstract class ~~WireTransactionMixin~~

Module Contents

WireTransactionMixin()

abstract fun getAvailableComponents():

abstract fun getMerkleTree():

abstract fun getOutputStates():

@ThreadSafe open class StringToMethodCallParser<in T :

Module Contents

out

)

out

ObjectMapper

)

val availableCommands:

protected val methodMap: Multimap<

open fun paramNamesFromConstructor(ctor:

val methodParamNames:

Constructor

)

open fun paramNamesFromMethod(method:

)

fun parse(target: T?, command:

fun parseArguments(methodNameHint:

)

ParsedMethodCall

parameters

args

)

inner class ParsedMethodCall<in T :

Callable

ParsedMethodCall(target: T?, method:

Module Contents

args

)

operator fun invoke():

val method:

open class UnparseableCallException :

UnparseableCallException(command:

Module Contents

cause

class FailedParse : UnparseableCallException

)

Module Contents

FailedParse(e:

class MissingParameter : UnparseableCallException

)

Module Contents

MissingParameter(methodName:

paramName

command

)

class NoSuchFile : UnparseableCallException

Module Contents

NoSuchFile(filename:

class ReflectionDataMissing : UnparseableCallException

)

Module Contents

ReflectionDataMissing(methodName:

argIndex

class TooManyParameters : UnparseableCallException

)

Module Contents

TooManyParameters(methodName:

command

class UnknownMethod : UnparseableCallException

)

Module Contents

UnknownMethod(methodName:

)

val methodName:

fun validateIsMatchingCtor(methodNameHint:

parameters

args

)

package net.corda.client.rpc

Module Contents

open class ConnectionFailureException :

ConnectionFailureException(cause:

Module Contents

)

class CordaRPCClient

Module Contents

configuration

)

configuration

classLoader

)

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

customSerializers

)

configuration

sslConfiguration

classLoader

customSerializers

@CordaInternal @VisibleForTesting fun getRegisteredCustomSerializers():

)

password

gracefulReconnect

)

password

targetLegalIdentity

gracefulReconnect

)

password

externalTrace

impersonatedActor

gracefulReconnect

)

inline fun <A> use(username:

password

externalTrace

impersonatedActor

targetLegalIdentity

gracefulReconnect

)

password

open class CordaRPCClientConfiguration

block

(

CordaRPCConnection

)

Module Contents

CordaRPCClientConfiguration(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

openTelemetryEnabled

simpleLogTelemetryEnabled

spanStartEndEventsEnabled

copyBaggageToTags

)

operator fun ~~component1~~():

open val connectionMaxRetryInterval:

open val connectionRetryInterval:

open val connectionRetryIntervalMultiplier:

fun copy(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

cacheConcurrencyLevel

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

openTelemetryEnabled

simpleLogTelemetryEnabled

spanStartEndEventsEnabled

copyBaggageToTags

)

open val copyBaggageToTags:

open val deduplicationCacheExpiry:

val DEFAULT:

)

open val maxFileSize:

open val maxReconnectAttempts:

open val minimumServerProtocolVersion:

open val observationExecutorPoolSize:

open val openTelemetryEnabled:

open val reapInterval:

open val simpleLogTelemetryEnabled:

open val spanStartEndEventsEnabled:

open val trackRpcCallSites:

class CordaRPCConnection :

Module Contents

fun <T> getTelemetryHandle(telemetryClass:

fun notifyServerAndClose():

)

val proxy:

val serverProtocolVersion:

GracefulReconnect(onDisconnect:

class GracefulReconnect

Module Contents

onReconnect

maxAttempts

GracefulReconnect(onDisconnect: () ->

)

onReconnect

(

)

maxAttempts

)

val onDisconnect: () ->

val onReconnect: () ->

class MaxRpcRetryException :

MaxRpcRetryException(maxNumberOfRetries:

Module Contents

method

cause

class PermissionException :

)

RpcSerializableError

ClientRelevantError

Module Contents

PermissionException(msg:

)

val msg:

@DoNotImplement interface RPCConnection<out I :

Module Contents

abstract fun forceClose():

abstract fun <T> getTelemetryHandle(telemetryClass:

abstract fun notifyServerAndClose():

)

abstract val serverProtocolVersion:

abstract val proxy: I

open class RPCException :

Module Contents

RPCException(msg:

)

RPCException(message:

cause

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

)

Module Contents

RPCSinceVersion(version:

)

Module Contents

fun <T> Observable<T>.notUsed():

open class UnrecoverableRPCException :

UnrecoverableRPCException(message:

Module Contents

cause

package net.corda.client.rpc.ext

)

Module Contents

class MultiRPCClient<I :

Module Contents

rpcOpsClass

username

password

configuration

)

rpcOpsClass

username

password

classLoader

configuration

)

rpcOpsClass

username

password

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

customSerializers

configuration

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

rpcOpsClass

username

password

customSerializers

configuration

fun addConnectionListener(listener:

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

)

fun close():

fun removeConnectionListener(listener:

interface RPCConnectionListener<I :

)

interface ConnectionContext<I :

Module Contents

abstract val connectionOpt:

Module Contents

RPCConnection

abstract val throwableOpt:

abstract val userName:

abstract fun onConnect(context: ConnectionContext):

abstract fun onDisconnect(context: ConnectionContext):

abstract fun onPermanentFailure(context: ConnectionContext):

package net.corda.client.rpc.reconnect

Module Contents

class CouldNotStartFlowException :

CouldNotStartFlowException(cause:

Module Contents

open class CordaException :

)

package net.corda.core

Module Contents

interface ~~ClientRelevantError~~

Module Contents

cause

)

)

)

)

)

const val ALIAS_PRIVATE_KEY:

)

Module Contents

Module Contents

const val CORDA_PLATFORM:

const val R3_ROOT:

const val X509_EXTENSION_CORDA_ROLE:

open class CordaRuntimeException :

RuntimeException

Module Contents

cause

)

CordaRuntimeException(originalExceptionClassName:

)

_message

_cause

)

)

)

)

)

abstract fun addSuppressed(suppressed:

interface CordaThrowable

Module Contents

)

abstract var originalExceptionClassName:

abstract val originalMessage:

abstract fun setCause(cause:

)

abstract fun setMessage(message:

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class DoNotImplement

Module Contents

DoNotImplement()

fun <SNAPSHOT, ELEMENT>

SNAPSHOT

ELEMENT

doOnError

(

action

(

)

)

SNAPSHOT

ELEMENT

fun <SNAPSHOT, ELEMENT>

SNAPSHOT

ELEMENT

mapErrors

(

transform

(

)

)

SNAPSHOT

ELEMENT

fun <ELEMENT> Observable<ELEMENT>.mapErrors(transform: (

Module Contents

)

fun <T> Observable<T>.toFuture():

)

Observable

ELEMENT

fun <A>

package net.corda.core.concurrent

out

toObservable

(

)

Observable

Module Contents

interface CordaFuture<V> :

abstract fun <W> then(callback: (

Module Contents

)

abstract fun toCompletableFuture():

fun <V, W> firstOf(vararg futures:

out

handler

(

out

)

Module Contents

fun <V, W>

match

(

success

(

)

failure

(

package net.corda.core.context

)

Module Contents

data class Actor

Module Contents

Actor(id: Id, serviceId:

owningLegalIdentity

)

Module Contents

)

data class InvocationContext

owningLegalIdentity

)

data class AuthServiceId

Module Contents

)

Module Contents

trace

actor

externalTrace

impersonatedActor

)

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

@JvmStatic @JvmOverloads fun newInstance(origin:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

serializedTelemetry

SerializedTelemetry

)

trace

actor

externalTrace

impersonatedActor

)

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

val impersonatedActor:

Actor

trace

actor

externalTrace

impersonatedActor

arguments

clientId

serializedTelemetry

SerializedTelemetry

)

val origin:

@JvmStatic fun peer(party:

trace

externalTrace

impersonatedActor

)

@JvmStatic @JvmOverloads fun rpc(actor:

trace

externalTrace

impersonatedActor

arguments

serializedTelemetry

SerializedTelemetry

)

@JvmStatic fun scheduled(scheduledState:

trace

externalTrace

)

val serializedTelemetry: SerializedTelemetry?

@JvmStatic fun shell(trace:

owningLegalIdentity

trace

externalTrace

)

externalTrace

)

sealed class InvocationOrigin

Module Contents

Module Contents

)

abstract fun principal():

Module Contents

)

Module Contents

)

Module Contents

owningLegalIdentity

)

fun principal():

Trace(invocationId: InvocationId, sessionId: SessionId)

Module Contents

Module Contents

Module Contents

timestamp

)

timestamp

val invocationId: InvocationId

)

InvocationId

@JvmStatic fun newInstance(invocationId: InvocationId = InvocationId.newInstance(), sessionId: SessionId = SessionId(invocationId.value, invocationId.timestamp)):

Module Contents

timestamp

)

timestamp

package net.corda.core.contracts

)

SessionId

val sessionId: SessionId

Module Contents

object AlwaysAcceptAttachmentConstraint :

Module Contents

)

data class Amount<T :

Module Contents

Amount(tokenQuantity:

token

)

Amount(quantity:

displayTokenSize

token

)

fromDecimal

(

displayQuantity

token

rounding

RoundingMode

)

@JvmStatic fun getDisplayTokenSize(token:

)

operator fun minus(other:

)

@JvmStatic fun parseCurrency(input:

)

fun splitEvenly(partitions:

)

)

sumOrNull

(

)

sumOrThrow

(

)

sumOrZero

(

token

)

)

)

zero

(

token

)

class AmountTransfer<T :

AmountTransfer(quantityDelta:

Module Contents

token

source

destination

)

newRef

)

)

fromDecimal

(

displayQuantityDelta

fun novate(centralParty: P):

token

source

destination

rounding

)

)

zero

(

token

source

destination

)

@DoNotImplement interface Attachment :

open fun extractFile(path:

Module Contents

outputTo

)

open fun openAsJAR():

JarInputStream

abstract val signerKeys:

@DoNotImplement interface AttachmentConstraint

abstract val ~~signers~~:

Module Contents

abstract fun isSatisfiedBy(attachment:

)

AttachmentResolutionException(hash:

Module Contents

)

object ~~AutomaticHashConstraint~~ :

Module Contents

)

object AutomaticPlaceholderConstraint :

Module Contents

)

@Target([AnnotationTarget.CLASS]) annotation class BelongsToContract

Module Contents

BelongsToContract(value:

out

)

out

class BrokenAttachmentException :

BrokenAttachmentException(attachmentId:

Module Contents

message

cause

)

data class Command<T :

Module Contents

Command(data: T, key:

Command(value: T, signers:

)

)

data class CommandAndState

Module Contents

CommandAndState(command:

ownableState

)

interface CommandData

data class CommandWithParties<out T :

CommandWithParties(signers:

Module Contents

signingParties

value

)

val signers:

val ~~signingParties~~:

enum class ComponentGroupEnum

val value: T

Module Contents

Module Contents

abstract fun verify(tx:

)

class ContractAttachment :

ContractAttachment(attachment:

Module Contents

contract

additionalContracts

uploader

)

val additionalContracts:

@CordaInternal fun create(attachment:

contract

additionalContracts

uploader

signerKeys

version

)

typealias ContractClassName =

abstract val participants:

interface ContractState

Module Contents

interface FungibleAsset<T :

Module Contents

abstract val exitKeys:

abstract fun withNewOwnerAndAmount(newAmount:

newOwner

)

interface FungibleState<T :

Module Contents

hash

(

)

hash

(

algorithm

)

data class HashAttachmentConstraint :

HashAttachmentConstraint(attachmentId:

Module Contents

)

val attachmentId:

val disableHashConstraints:

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

data class Issued<out P :

Module Contents

Issued(issuer:

product

)

Module Contents

requireSingleCommand

(

)

requireSingleCommand

(

klass

)

select

(

signer

party

)

select

(

klass

signer

party

)

select

(

signers

parties

)

select

(

klass

signers

parties

)

Module Contents

filterStatesOfType

(

)

@Target([AnnotationTarget.CLASS]) annotation class LegalProseReference

Module Contents

LegalProseReference(uri:

)

val uri:

class LinearPointer<T :

Module Contents

type

)

type

isResolved

)

)

)

)

interface LinearState :

Module Contents

abstract val linearId:

const val MAX_ISSUER_REF_SIZE:

interface MoveCommand :

Module Contents

abstract val contract:

out

interface NamedByHash

Module Contents

@Target([AnnotationTarget.CLASS]) @Inherited annotation class NoConstraintPropagation

Module Contents

NoConstraintPropagation()

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

Module Contents

PrivacySalt(saltLength:

)

)

@JvmStatic fun createFor(algorithm:

)

data class ReferencedStateAndRef<out T :

ReferencedStateAndRef(stateAndRef:

Module Contents

)

Module Contents

using

(

expr

)

inline fun <R> requireThat(body:

Requirements

(

)

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

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

SignatureAttachmentConstraint(key:

Module Contents

)

Module Contents

)

)

data class SourceAndAmount<T :

)

out

SourceAndAmount(source: P, amount:

Module Contents

ref

)

data class StateAndContract

Module Contents

StateAndContract(state:

contract

)

data class StateAndRef<out T :

Module Contents

ref

)

val state:

@DoNotImplement sealed class StatePointer<T :

Module Contents

abstract val isResolved:

linearPointer

(

state

isResolved

)

LinearPointer

abstract val pointer:

abstract fun resolve(services:

)

abstract fun resolve(ltx:

)

staticPointer

(

stateAndRef

isResolved

)

Module Contents

index

)

class StaticPointer<T :

Module Contents

type

)

type

isResolved

)

)

abstract class TimeWindow

)

)

Module Contents

TimeWindow()

untilTime

)

abstract operator fun contains(instant:

)

)

@JvmStatic fun fromStartAndDuration(fromTime:

duration

)

abstract val fromTime:

val length:

abstract val midpoint:

)

abstract val untilTime:

@JvmStatic fun withTolerance(instant:

tolerance

)

interface TokenizableAssetInfo

Module Contents

abstract val displayTokenSize:

open class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

message

)

class UnknownParametersException :

TransactionResolutionException

Module Contents

UnknownParametersException(txId:

paramsHash

data class TransactionState<out T :

)

TransactionState(data: T, contract:

Module Contents

notary

encumbrance

constraint

)

abstract class TransactionVerificationException :

TransactionVerificationException(txId:

Module Contents

message

cause

class AttachmentTooBigException :

)

AttachmentTooBigException(txId:

Module Contents

class BrokenTransactionException :

)

BrokenTransactionException(txId:

Module Contents

message

class ConflictingAttachmentsRejection :

)

ConflictingAttachmentsRejection(txId:

Module Contents

contractClass

)

class ConstraintPropagationRejection :

Module Contents

contractClass

inputConstraint

outputConstraint

)

class ContractConstraintRejection :

message

)

ContractConstraintRejection(txId:

Module Contents

contractClass

)

class ContractCreationError :

Module Contents

val contractClass:

class ContractRejection :

class DuplicateAttachmentsRejection :

Module Contents

Module Contents

DuplicateAttachmentsRejection(txId:

Module Contents

attachmentId

)

class InvalidAttachmentException :

InvalidAttachmentException(txId:

Module Contents

attachmentHash

)

class InvalidConstraintRejection :

InvalidConstraintRejection(txId:

Module Contents

contractClass

reason

)

class MissingAttachmentRejection :

MissingAttachmentRejection(txId:

Module Contents

contractClass

)

class MissingNetworkParametersException :

Module Contents

missingNetworkParametersHash

)

message

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(txId:

Module Contents

txNotary

outputNotary

)

class OverlappingAttachmentsException :

OverlappingAttachmentsException(txId:

Module Contents

path

)

class PackageOwnershipException :

PackageOwnershipException(txId:

Module Contents

attachmentHash

invalidClassName

packageName

)

val invalidClassName:

val packageName:

class TransactionContractConflictException :

Module Contents

state

requiredContractClassName

)

message

class TransactionDuplicateEncumbranceException :

)

Module Contents

index

)

message

class TransactionMissingEncumbranceException :

)

TransactionMissingEncumbranceException(txId:

Module Contents

missing

inOut

Direction

)

val inOut: Direction

val missing:

class TransactionNetworkParameterOrderingException :

Module Contents

inputStateRef

txnNetworkParameters

inputNetworkParameters

)

message

class TransactionNonMatchingEncumbranceException :

)

Module Contents

nonMatching

)

message

class TransactionNotaryMismatchEncumbranceException :

)

TransactionNotaryMismatchEncumbranceException(txId:

Module Contents

encumberedIndex

encumbranceIndex

encumberedNotary

encumbranceNotary

)

TransactionNotaryMismatchEncumbranceException(txId:

message

class TransactionRequiredContractUnspecifiedException :

)

TransactionRequiredContractUnspecifiedException(txId:

Module Contents

state

TransactionRequiredContractUnspecifiedException(txId:

)

message

)

class UnsupportedClassVersionError :

UnsupportedClassVersionError(txId:

Module Contents

message

cause

class UnsupportedHashTypeException :

)

UnsupportedHashTypeException(txId:

Module Contents

class UntrustedAttachmentsException :

)

UntrustedAttachmentsException(txId:

Module Contents

ids

)

abstract class TypeOnlyCommandData :

Module Contents

TypeOnlyCommandData()

data class UniqueIdentifier :

)

UniqueIdentifier(externalId:

Module Contents

)

)

)

@VisibleForTesting fun fromString(name:

)

interface UpgradedContract<in OldState :

out

NewState

abstract val legacyContract:

Module Contents

abstract fun upgrade(state: OldState): NewState

interface UpgradedContractWithLegacyConstraint<in OldState :

out

NewState

abstract val legacyContractConstraint:

OldState

NewState

Module Contents

object WhitelistedByZoneAttachmentConstraint :

MoveCommand

verifyMoveCommand

(

inputs

commands

)

Module Contents

)

withoutIssuer

(

)

package net.corda.core.cordapp

Module Contents

@DoNotImplement interface Cordapp

Module Contents

abstract val allFlows:

out

abstract val checkpointCustomSerializers:

CheckpointCustomSerializer

abstract val contractClassNames:

abstract val cordappClasses:

abstract val customSchemas:

@DoNotImplement interface Info

abstract val info: Info

Module Contents

data class Contract : Info

Module Contents

vendor

versionId

licence

)

data class ContractAndWorkflow : Info

Module Contents

ContractAndWorkflow(contract: Contract, workflow: Workflow)

val contract: Contract

data class Default : Info

val workflow: Workflow

Module Contents

vendor

version

licence

)

abstract fun hasUnknownFields():

abstract val licence:

abstract val shortName:

abstract val vendor:

abstract val version:

data class Workflow : Info

Module Contents

vendor

versionId

licence

)

abstract val initiatedFlows:

out

abstract val jarHash: SHA256

abstract val jarPath:

abstract val minimumPlatformVersion:

abstract val name:

abstract val rpcFlows:

out

abstract val schedulableFlows:

out

abstract val serializationCustomSerializers:

abstract val serializationWhitelists:

abstract val serviceFlows:

SerializationWhitelist

out

out

abstract val targetPlatformVersion:

abstract val telemetryComponents:

@DoNotImplement interface CordappConfig

out

TelemetryComponent

Module Contents

abstract fun exists(path:

)

abstract fun get(path:

)

abstract fun getBoolean(path:

)

abstract fun getDouble(path:

)

abstract fun getFloat(path:

abstract fun getInt(path:

)

Float

)

abstract fun getLong(path:

)

abstract fun getNumber(path:

abstract fun getString(path:

)

Number

)

class CordappConfigException :

CordappConfigException(msg:

Module Contents

@CordaInternal fun create(cordapp:

)

class CordappContext

Module Contents

CordappContext(cordapp:

attachmentId

classLoader

)

attachmentId

classLoader

config

)

data class CordappInfo

Module Contents

name

shortName

minimumPlatformVersion

targetPlatformVersion

version

vendor

licence

jarHash

SHA256

)

val jarHash: SHA256

val licence:

val targetPlatformVersion:

@DoNotImplement interface CordappProvider

Module Contents

abstract fun getAppContext():

abstract fun getContractAttachmentID(contractClassName:

)

package net.corda.core.crypto

Module Contents

val

algorithm

fun ~~componentHash~~(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun ~~componentHash~~(nonce:

opaqueBytes

)

Module Contents

Module Contents

weight

)

Builder

fun addKeys(vararg keys:

)

Builder

fun addKeys(keys:

)

Builder

)

NodeAndWeight

)

fun getInstance(encoded:

)

fun getInstance(asn1:

)

fun isFulfilledBy(key:

)

fun isFulfilledBy(keysToCheck:

)

data class NodeAndWeight :

const val KEY_ALGORITHM:

NodeAndWeight

Module Contents

weight

)

fun compareTo(other: NodeAndWeight):

val node:

class CompositeKeyFactory :

fun toASN1Primitive():

KeyFactorySpi

Module Contents

CompositeKeyFactory()

protected fun engineGeneratePrivate(keySpec:

KeySpec

)

protected fun engineGeneratePublic(keySpec:

)

engineGetKeySpec

(

key

keySpec

protected fun engineTranslateKey(key:

)

)

class CompositeSignature :

Signature

Module Contents

CompositeSignature()

protected fun ~~engineGetParameter~~(param:

)

protected fun engineInitSign(privateKey:

)

protected fun engineInitVerify(publicKey:

)

protected fun ~~engineSetParameter~~(param:

value

)

protected fun engineSetParameter(params:

)

protected fun engineSign():

)

protected fun engineVerify(sigBytes:

off

len

)

)

@JvmStatic fun getService(provider:

const val SIGNATURE_ALGORITHM:

)

Service

data class State

Module Contents

State(buffer:

verifyKey

CompositeKey

)

val buffer:

fun engineVerify(sigBytes:

)

data class CompositeSignaturesWithKeys

Module Contents

CompositeSignaturesWithKeys(sigs:

CompositeSignaturesWithKeys

)

val EMPTY:

val sigs:

fun ~~computeNonce~~(privacySalt:

groupIndex

internalIndex

object CordaObjectIdentifier

)

SHA256

Module Contents

val COMPOSITE_KEY:

val COMPOSITE_SIGNATURE:

class CordaSecurityProvider :

@JvmStatic fun decodePrivateKey(encodedKey:

Module Contents

CordaSecurityProvider()

algorithm

)

const val PROVIDER_NAME:

Module Contents

)

@JvmStatic fun decodePrivateKey(schemeCodeName:

encodedKey

)

@JvmStatic fun decodePrivateKey(signatureScheme:

encodedKey

)

@JvmStatic fun decodePublicKey(encodedKey:

)

@JvmStatic fun decodePublicKey(schemeCodeName:

encodedKey

)

@JvmStatic fun decodePublicKey(signatureScheme:

encodedKey

)

val DEFAULT_SIGNATURE_SCHEME:

@JvmStatic fun deriveKeyPair(signatureScheme:

privateKey

seed

)

@JvmStatic fun deriveKeyPair(privateKey:

seed

)

@JvmStatic fun deriveKeyPairFromEntropy(signatureScheme:

entropy

)

@JvmStatic fun deriveKeyPairFromEntropy(entropy:

)

@JvmStatic fun doSign(privateKey:

clearData

)

@JvmStatic fun doSign(schemeCodeName:

privateKey

clearData

)

@JvmStatic fun doSign(signatureScheme:

privateKey

clearData

)

@JvmStatic fun doSign(keyPair:

signableData

)

@JvmStatic fun doVerify(schemeCodeName:

publicKey

signatureData

clearData

)

@JvmStatic fun doVerify(publicKey:

signatureData

clearData

)

@JvmStatic fun doVerify(signatureScheme:

publicKey

signatureData

clearData

)

@JvmStatic fun doVerify(txId:

transactionSignature

)

val ECDSA_SECP256K1_SHA256:

val ECDSA_SECP256R1_SHA256:

val EDDSA_ED25519_SHA512:

@JvmStatic fun encodePublicKey(key:

)

@JvmStatic fun findProvider(name:

)

@JvmStatic fun findSignatureScheme(algorithm:

AlgorithmIdentifier

)

@JvmStatic fun findSignatureScheme(schemeNumberID:

)

@JvmStatic fun findSignatureScheme(schemeCodeName:

)

)

)

@JvmStatic fun generateKeyPair(schemeCodeName:

)

@JvmOverloads @JvmStatic fun generateKeyPair(signatureScheme:

)

@JvmStatic fun isSupportedSignatureScheme(signatureScheme:

)

@JvmStatic fun isValid(txId:

transactionSignature

)

@JvmStatic fun isValid(publicKey:

signatureData

clearData

)

@JvmStatic fun isValid(signatureScheme:

publicKey

signatureData

clearData

)

@JvmStatic fun publicKeyOnCurve(signatureScheme:

publicKey

)

@JvmStatic fun registerProviders():

val SPHINCS256_SHA256:

@JvmStatic fun supportedSignatureSchemes():

@JvmStatic fun toSupportedPrivateKey(key:

)

SubjectPublicKeyInfo

)

)

@JvmStatic fun validatePublicKey(key:

)

interface DigestAlgorithm

Module Contents

abstract val algorithm:

open fun componentDigest(bytes:

)

abstract fun digest(bytes:

)

abstract val digestLength:

open fun nonceDigest(bytes:

)

DigestService(hashAlgorithm:

data class DigestService

Module Contents

)

val allOnesHash:

fun componentHash(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun componentHash(nonce:

opaqueBytes

)

fun computeNonce(privacySalt:

groupIndex

internalIndex

)

)

)

serializedHash

(

)

open class DigitalSignature :

object DummySecureRandom :

Module Contents

DigitalSignature(bytes:

)

Module Contents

bytes

)

)

)

)

SecureRandom

fun entropyToKeyPair(entropy:

)

fun generateKeyPair():

hashAs

(

algorithm

)

isZero

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

sign

(

bytesToSign

)

WithKey

sign

(

bytesToSign

)

WithKey

sign

(

signableData

)

verify

(

signatureData

clearData

)

java.security.PrivateKey

Module Contents

sign

(

bytesToSign

)

sign

(

bytesToSign

publicKey

)

WithKey

Module Contents

containsAny

(

otherKeys

)

isFulfilledBy

(

otherKey

)

isFulfilledBy

(

otherKeys

)

isValid

(

content

signature

)

keys

toStringShort

(

)

verify

(

content

signature

)

verify

(

signatureData

clearData

)

Module Contents

hashAs

(

algorithm

)

sha256

(

)

SHA256

Module Contents

byKeys

(

)

sealed class MerkleTree

Module Contents

)

class MerkleTreeException :

nodeDigestService

)

Module Contents

)

Module Contents

left

right

)

MerkleTreeException(reason:

Module Contents

)

val reason:

PartialMerkleTree(root: PartialTree)

fun newSecureRandom():

Module Contents

object NullPublicKey :

Module Contents

)

class PartialMerkleTree

Module Contents

fun build(merkleRoot:

includeHashes

)

@CordaInternal fun leafIndex(leaf:

)

data class IncludedLeaf : PartialTree

sealed class PartialTree

Module Contents

Module Contents

)

data class Leaf : PartialTree

Module Contents

)

data class Node : PartialTree

Module Contents

Node(left: PartialTree, right: PartialTree)

Node(left: PartialTree, right: PartialTree, hashAlgorithm:

fun copy(left: PartialTree, right: PartialTree): Node

)

val hashAlgorithm:

fun rootAndUsedHashes(node: PartialTree, usedHashes:

val left: PartialTree

val right: PartialTree

val root: PartialTree

)

fun verify(merkleRootHash:

hashesToCheck

)

fun random63BitValue():

DigestService

randomHash

(

)

sealed class SecureHash :

Module Contents

)

Module Contents

)

bytes

)

)

)

SHA256

)

bytes

)

bytes

)

)

SHA256

)

)

SHA256

)

SHA256

)

SHA256

)

bytes

)

fun concatenate(other:

)

fun concatenateAs(concatAlgorithm:

other

)

)

)

SHA256

)

protected open fun generate(data:

)

Module Contents

bytes

)

)

)

bytes

)

fun hashConcat(other:

)

SHA256

bytes

)

fun prefixChars(prefixLen:

)

SHA256

)

)

Module Contents

)

)

)

)

SHA256

)

SHA256

)

SHA256

)

fun secureRandomBytes(numOfBytes:

)

~~serializedHash~~

(

)

sha256

(

)

SHA256

data class SignableData

Module Contents

SignableData(txId:

signatureMetadata

)

data class SignatureMetadata

Module Contents

SignatureMetadata(platformVersion:

schemeNumberID

)

data class SignatureScheme

Module Contents

SignatureScheme(schemeNumberID:

schemeCodeName

signatureOID

alternativeOIDs

providerName

algorithmName

signatureName

algSpec

keySize

desc

)

open class SignedData<T :

Module Contents

SignedData(raw:

protected open fun verifyData(data: T):

sig

WithKey

)

class TransactionSignature :

DigitalSignature

Module Contents

signatureMetadata

)

signatureMetadata

partialMerkleTree

)

)

)

package net.corda.core.flows

)

Module Contents

abstract class AbstractStateReplacementFlow

Module Contents

AbstractStateReplacementFlow()

abstract class Acceptor<in T> :

Module Contents

)

progressTracker

)

object APPROVING : Step

val initiatingSession:

protected abstract fun verifyProposal(stx:

proposal

Proposal

)

abstract class Instigator<out S :

out

out

Module Contents

Instigator(originalState:

modification

progressTracker

protected abstract fun assembleTx(): UpgradeTx

)

open fun getParticipantSessions():

data class Proposal<out M>

Module Contents

Proposal(stateRef:

@Suspendable class CollectSignatureFlow :

modification

)

Module Contents

)

Module Contents

session

vararg

signingKeys

)

session

signingKeys

)

class CollectSignaturesFlow :

Module Contents

sessionsToCollectFrom

progressTracker

)

sessionsToCollectFrom

myOptionalKeys

progressTracker

)

object COLLECTING : Step

val myOptionalKeys:

val sessionsToCollectFrom:

data class ComparableRecoveryTimeWindow

Module Contents

ComparableRecoveryTimeWindow(fromTime:

fromTimestampDiscriminator

untilTime

untilTimestampDiscriminator

)

fun from(timeWindow:

ComparableRecoveryTimeWindow

)

val fromTime:

val fromTimestampDiscriminator:

val untilTime:

val untilTimestampDiscriminator:

object ContractUpgradeFlow

Module Contents

@StartableByRPC class Authorise :

Module Contents

Authorise(stateAndRef:

upgradedContractClass

out

)

val stateAndRef:

@StartableByRPC class Deauthorise :

Module Contents

Deauthorise(stateRef:

)

val stateRef:

@InitiatingFlow @StartableByRPC class Initiate<OldState :

out

NewState

Instigator

OldState

NewState

out

OldState

NewState

Module Contents

Initiate(originalState:

OldState

newContractClass

out

@Suspendable protected fun assembleTx(): UpgradeTx

OldState

NewState

)

open class DataVendingFlow :

Module Contents

payload

txnMetadata

TransactionMetadata

)

payload

DataVendingFlow(otherSessions:

)

payload

txnMetadata

)

protected open fun isFinality():

val ~~otherSideSession~~:

val payload:

@Suspendable protected open fun sendPayloadAndReceiveDataRequest(otherSideSession:

payload

)

@Suspendable protected open fun verifyDataRequest(dataRequest: Data):

Request

@DoNotImplement interface Destination

@DoNotImplement sealed class DistributionList

Module Contents

data class ReceiverDistributionList :

ReceiverDistributionList(opaqueData:

Module Contents

receiverStatesToRecord

)

val opaqueData:

data class SenderDistributionList :

SenderDistributionList(senderStatesToRecord:

Module Contents

peersToStatesToRecord

val peersToStatesToRecord:

)

@DoNotImplement abstract class DistributionRecord :

abstract val peerPartyId:

Module Contents

DistributionRecord()

abstract val timestamp:

abstract val timestampDiscriminator:

abstract val txId:

data class DistributionRecordKey

Module Contents

DistributionRecordKey(txnId:

timestamp

timestampDiscriminator

)

val txnId:

class DistributionRecords

Module Contents

DistributionRecords(senderRecords:

receiverRecords

)

val receiverRecords:

val senderRecords:

val size:

enum class DistributionRecordType

Module Contents

@InitiatingFlow class FinalityFlow :

RECEIVER

SENDER

Module Contents

extraRecipients

progressTracker

)

extraRecipients

)

)

progressTracker

)

firstSession

vararg

restSessions

)

sessions

progressTracker

)

sessions

statesToRecord

progressTracker

)

sessions

oldParticipants

progressTracker

)

object BROADCASTING : Step

sessions

observerSessions

)

object BROADCASTING_NOTARY_ERROR : Step

object BROADCASTING_POST_NOTARISATION : Step

object BROADCASTING_PRE_NOTARISATION : Step

ExtraConstructorArgs(oldParticipants:

Module Contents

sessions

newApi

statesToRecord

observerSessions

)

object FINALISING_TRANSACTION : Step

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

object NOTARISING : Step

Module Contents

object RECORD_UNNOTARISED : Step

@StartableByRPC @InitiatingFlow class FinalityRecoveryFlow :

Module Contents

FinalityRecoveryFlow(txId:

forceRecover

)

FinalityRecoveryFlow(flowId:

forceRecover

recoverAll

)

forceRecover

FinalityRecoveryFlow(flowIds:

)

forceRecover

FinalityRecoveryFlow(recoverAll:

)

forceRecover

FinalityRecoveryFlow(matchingCriteria:

)

FlowRecoveryQuery

forceRecover

)

flowIds

matchingCriteria

forceRecover

recoverAll

forceRecoverFlowIds

progressTracker

)

FlowTransactionInfo

ExtraConstructorArgs(txIds:

Module Contents

flowIds

matchingCriteria

forceRecover

recoverAll

forceRecoverFlowIds

)

val forceRecoverFlowIds:

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

val matchingCriteria:

open class FlowException :

IdentifiableException

Module Contents

cause

)

)

)

cause

originalErrorId

)

open fun getErrorId():

var originalErrorId:

interface FlowExternalAsyncOperation<R :

Module Contents

)

interface FlowExternalOperation<R :

Module Contents

sealed class FlowInitiator :

)

data class FlowInfo

Module Contents

FlowInfo(flowVersion:

appName

)

Module Contents

Module Contents

)

Module Contents

)

FlowInitiator

Module Contents

)

Module Contents

)

fun getName():

abstract class FlowLogic<out T>

Module Contents

Module Contents

FlowLogic()

FlowExternalAsyncOperation

await

(

operation

)

@Suspendable abstract fun call(): T

await

(

operation

FlowExternalOperation

)

fun checkFlowIsNotKilled():

fun checkFlowIsNotKilled(lazyMessage: () ->

)

fun checkFlowPermission(permissionName:

extraAuditData

)

@Suspendable fun close(sessions:

)

@JvmStatic val currentTopLevel:

@Suspendable fun flowStackSnapshot():

FlowStackSnapshot

@Suspendable fun ~~getFlowInfo~~(otherParty:

)

@Suspendable fun initiateFlow(destination:

)

@Suspendable fun initiateFlow(party:

)

val ourIdentityAndCert:

@Suspendable fun persistFlowStackSnapshot():

fun <reified R :

~~receive~~

(

otherParty

)

~~receive~~

(

receiveType

otherParty

)

@Suspendable @JvmOverloads open fun <R :

@Suspendable @JvmOverloads open fun receiveAllMap(sessions:

receiveAll

(

receiveType

sessions

maySkipCheckpoint

)

out

maySkipCheckpoint

)

fun recordAuditEvent(eventType:

comment

extraAuditData

)

@Suspendable open fun ~~send~~(otherParty:

payload

)

@Suspendable @JvmOverloads fun sendAll(payload:

sessions

maySkipCheckpoint

)

@Suspendable @JvmOverloads fun sendAllMap(payloadsPerSession:

maySkipCheckpoint

)

~~sendAndReceive~~

(

otherParty

payload

)

@Suspendable @JvmStatic @JvmOverloads fun sleep(duration:

~~sendAndReceive~~

(

receiveType

otherParty

payload

)

maySkipCheckpoint

)

@Suspendable open fun <R> subFlow(subLogic:

)

fun trackStepsTree():

fun trackStepsTreeIndex():

@Suspendable @JvmOverloads fun waitForLedgerCommit(hash:

maySkipCheckpoint

)

@Suspendable fun waitForStateConsumption(stateRefs:

)

@DoNotImplement interface FlowLogicRef

@DoNotImplement interface FlowLogicRefFactory

Module Contents

abstract fun create(flowClass:

out

vararg

args

)

abstract fun create(flowClassName:

vararg

args

)

abstract fun toFlowLogic(ref:

)

class FlowRecoveryException :

FlowRecoveryException(txnId:

Module Contents

message

cause

FlowRecoveryException(message:

)

cause

data class FlowRecoveryQuery

)

Module Contents

FlowRecoveryQuery(timeframe:

initiatedBy

counterParties

)

@DoNotImplement abstract class FlowSession

Module Contents

FlowSession()

@Suspendable abstract fun close():

abstract val counterparty:

abstract val destination:

@Suspendable abstract fun getCounterpartyFlowInfo(maySkipCheckpoint:

)

@Suspendable abstract fun getCounterpartyFlowInfo():

receive

(

)

receive

(

receiveType

maySkipCheckpoint

)

receive

(

receiveType

)

maySkipCheckpoint

)

)

sendAndReceive

(

payload

)

sendAndReceive

(

receiveType

payload

maySkipCheckpoint

)

sendAndReceive

(

receiveType

payload

)

data class FlowStackSnapshot

Module Contents

FlowStackSnapshot(time:

flowClass

stackFrames

Frame

)

val flowClass:

data class FlowTimeWindow

data class Frame

Module Contents

Frame(stackTraceElement:

stackObjects

)

val stackTraceElement:

Frame

Module Contents

FlowTimeWindow(fromTime:

untilTime

)

untilTime

)

FlowTimeWindow

)

data class FlowTransactionInfo

)

Module Contents

FlowTransactionInfo(stateMachineRunId:

txId

status

timestamp

metadata

)

fun isInitiator(myCordaX500Name:

)

open class HospitalizeFlowException :

Module Contents

HospitalizeFlowException(cause:

)

HospitalizeFlowException()

)

cause

class IllegalFlowLogicException :

)

IllegalArgumentException

Module Contents

msg

)

@Target([AnnotationTarget.CLASS]) annotation class InitiatedBy

msg

)

Module Contents

out

)

out

@Target([AnnotationTarget.CLASS]) @Inherited annotation class InitiatingFlow

Module Contents

InitiatingFlow(version:

)

class KilledFlowException :

Module Contents

)

class LedgerRecoveryException :

message

)

LedgerRecoveryException(message:

Module Contents

@StartableByRPC class LedgerRecoveryFlow :

)

Module Contents

)

)

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

alsoFinalize

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

alsoFinalize

)

timeWindow

)

timeWindow

dryRun

)

timeWindow

dryRun

verboseLogging

)

timeWindow

dryRun

verboseLogging

recoveryBatchSize

alsoFinalize

)

timeWindow

dryRun

verboseLogging

recoveryBatchSize

)

timeWindow

useAllNetworkNodes

dryRun

useTimeWindowNarrowing

verboseLogging

recoveryBatchSize

LedgerRecoveryFlow(parameters:

)

progressTracker

)

ExtraConstructorArgs(parameters:

Module Contents

)

val parameters:

@CordaInternal fun getExtraConstructorArgs(): ExtraConstructorArgs

data class LedgerRecoveryParameters

Module Contents

LedgerRecoveryParameters(recoveryPeers:

timeWindow

useAllNetworkNodes

dryRun

useTimeWindowNarrowing

verboseLogging

recoveryBatchSize

alsoFinalize

)

val recoveryBatchSize:

val useAllNetworkNodes:

val useTimeWindowNarrowing:

val verboseLogging:

data class LedgerRecoveryResult

Module Contents

LedgerRecoveryResult(totalRecoveredRecords:

totalRecoveredTransactions

val totalRecoveredInFlightTransactions:

totalRecoveredInFlightTransactions

totalErrors

)

val totalRecoveredRecords:

val totalRecoveredTransactions:

class MaybeSerializedSignedTransaction :

Module Contents

serialized

nonSerialised

)

fun payloadContentDescription():

serialized

nonSerialised

inFlight

)

fun serializedByteCount():

data class NotarisationPayload

Module Contents

NotarisationPayload(transaction:

requestSignature

)

val coreTransaction:

val requestSignature:

val signedTransaction:

class NotarisationRequest

Module Contents

NotarisationRequest(statesToConsume:

transactionId

)

data class NotarisationRequestSignature

Module Contents

NotarisationRequestSignature(digitalSignature: WithKey, platformVersion:

val digitalSignature: WithKey

)

val platformVersion:

data class NotarisationResponse

Module Contents

NotarisationResponse(signatures:

)

@InitiatingFlow class NotaryChangeFlow<out T :

Instigator

NotaryChangeFlow(originalState:

Module Contents

newNotary

progressTracker

protected fun assembleTx(): UpgradeTx

)

sealed class NotaryError

Module Contents

data class Conflict :

Module Contents

consumedStates

)

val consumedStates:

Module Contents

)

const val NUM_STATES:

data class RequestSignatureInvalid :

RequestSignatureInvalid(cause:

Module Contents

)

data class TimeWindowInvalid :

TimeWindowInvalid(currentTime:

Module Contents

txTimeWindow

)

val ~~INSTANCE~~: TimeWindowInvalid

data class TransactionInvalid :

TransactionInvalid(cause:

Module Contents

)

object ~~WrongNotary~~ :

class NotaryException :

@DoNotImplement @InitiatingFlow class Client : BackpressureAwareTimedFlow<

Module Contents

NotaryException(error:

txId

)

Module Contents

Module Contents

skipVerification

)

progressTracker

)

progressTracker

skipVerification

)

protected fun checkTransaction():

open val isTimeoutEnabled:

@Suspendable protected fun notarise(notaryParty:

)

NotarisationResponse

object REQUESTING : Step

protected fun validateResponse(response:

notaryParty

)

object VALIDATING : Step

object NotarySigCheck

Module Contents

fun needsNotarySignature(stx:

)

class ReceiveFinalityFlow :

Module Contents

expectedTxId

statesToRecord

)

expectedTxId

statesToRecord

handlePropagatedNotaryError

)

data class ReceiverDistributionRecord :

ReceiverDistributionRecord(txId:

Module Contents

peerPartyId

timestamp

timestampDiscriminator

encryptedDistributionList

receiverStatesToRecord

val encryptedDistributionList:

)

class ReceiveStateAndRefFlow<out T :

@JvmSuppressWildcards

ReceiveStateAndRefFlow(otherSideSession:

Module Contents

)

open class ReceiveTransactionFlow :

Module Contents

checkSufficientSignatures

statesToRecord

)

checkSufficientSignatures

statesToRecord

handlePropagatedNotaryError

)

@Suspendable protected open fun checkBeforeRecording(stx:

)

open fun resolvePayload(payload:

)

data class RecoveryTimeWindow

Module Contents

RecoveryTimeWindow(fromTime:

untilTime

)

untilTime

)

)

class ResultSerializationException :

)

ResultSerializationException(e: MissingSerializerException)

Module Contents

@Target([AnnotationTarget.CLASS]) @Inherited annotation class SchedulableFlow

Module Contents

SchedulableFlow()

data class SenderDistributionRecord :

SenderDistributionRecord(txId:

Module Contents

peerPartyId

timestamp

timestampDiscriminator

senderStatesToRecord

receiverStatesToRecord

)

open class SendStateAndRefFlow :

SendStateAndRefFlow(otherSideSession:

Module Contents

stateAndRefs

open class SendTransactionFlow :

)

SendTransactionFlow(otherSide:

Module Contents

stx

)

SendTransactionFlow(stx:

participantSessions

observerSessions

senderStatesToRecord

recordMetaDataEvenIfNotFullySigned

val DUMMY_PARTICIPANT_NAME:

)

fun makeMetaData(stx:

recordMetaDataEvenIfNotFullySigned

senderStatesToRecord

participantSessions

observerSessions

)

val participantSessions:

val stx:

data class SignedTransactionWithDistributionList

Module Contents

SignedTransactionWithDistributionList(stx:

distributionList

isFinality

)

abstract class SignTransactionFlow :

SignTransactionFlow(otherSideSession:

Module Contents

progressTracker

)

@Suspendable protected abstract fun checkTransaction(stx:

)

val otherSideSession:

data class StackFrameDataToken

Module Contents

StackFrameDataToken(className:

)

val className:

@Target([AnnotationTarget.CLASS]) annotation class StartableByRPC

Module Contents

StartableByRPC()

@Target([AnnotationTarget.CLASS]) annotation class StartableByService

Module Contents

StartableByService()

data class StateConsumptionDetails

Module Contents

)

enum class ConsumedStateType

type

ConsumedStateType

)

Module Contents

INPUT_STATE

REFERENCE_INPUT_STATE

fun copy(hashOfTransactionId:

)

val hashOfTransactionId:

val type: ConsumedStateType

data class StateMachineRunId

Module Contents

StateMachineRunId(uuid:

)

open class StateReplacementException :

StateReplacementException(message:

Module Contents

cause

data class TransactionMetadata

)

Module Contents

TransactionMetadata(initiator:

distributionList

)

val initiator:

class UnexpectedFlowEndException :

IdentifiableException

Module Contents

cause

)

)

data class WaitTimeUpdate

cause

originalErrorId

)

Module Contents

WaitTimeUpdate(waitTime:

)

val waitTime:

class WithReferencedStatesFlow<T :

WithReferencedStatesFlow(progressTracker:

Module Contents

flowLogicProducer

(

)

@Suspendable fun call(): T

)

object ATTEMPT : Step

object RETRYING : Step

object SUCCESS : Step

package net.corda.core.identity

Module Contents

@DoNotImplement abstract class AbstractParty :

Module Contents

AbstractParty(owningKey:

@CordaInternal companion object Companion : Internable<

)

Module Contents

)

abstract fun nameOrNull():

val owningKey:

abstract fun ref(bytes:

)

fun ref(vararg bytes:

)

class AnonymousParty :

AnonymousParty(owningKey:

Module Contents

)

fun create(owningKey:

)

)

data class CordaX500Name

Module Contents

CordaX500Name(organisation:

organisation

locality

country

)

locality

country

)

organisationUnit

organisation

locality

state

country

)

)

Module Contents

X500Principal

)

)

val locality:

val organisation:

val organisationUnit:

fun <T> excludeHostNode(serviceHub:

)

map

)

fun <T> excludeNotary(map:

stx

)

fun groupAbstractPartyByWellKnownParty(serviceHub:

parties

fun groupAbstractPartyByWellKnownParty(serviceHub:

ignoreUnrecognisedParties

)

parties

)

fun groupPublicKeysByWellKnownParty(serviceHub:

publicKeys

fun groupPublicKeysByWellKnownParty(serviceHub:

ignoreUnrecognisedParties

)

publicKeys

)

Module Contents

)

owningKey

)

owningKey

)

fun create(certificate:

)

)

class PartyAndCertificate

Module Contents

PartyAndCertificate(certPath:

)

)

fun verify(trustAnchor:

)

fun verify(trustAnchors:

)

package net.corda.core.messaging

fun x500Matches(query:

exactMatch

x500name

)

Module Contents

interface AllPossibleRecipients :

data class ClientRpcSslOptions

Module Contents

ClientRpcSslOptions(trustStorePath:

trustStorePassword

trustStoreProvider

)

val trustStorePassword:

val trustStorePath:

val trustStoreProvider:

interface CordaRPCOps :

abstract fun acceptNewNetworkParameters(parametersHash:

Module Contents

)

abstract fun addVaultTransactionNote(txnId:

txnNote

)

abstract fun attachmentExists(id:

)

abstract fun currentNodeTime():

abstract fun finishedFlowsWithClientIds():

abstract fun finishedFlowsWithClientIdsAsAdmin():

abstract fun getVaultTransactionNotes(txnId:

)

abstract fun isFlowsDrainingModeEnabled():

abstract fun isWaitingForShutdown():

abstract fun killFlow(id:

)

@RPCReturnsObservables abstract fun networkMapFeed():

abstract fun networkMapSnapshot():

MapChange

@RPCReturnsObservables abstract fun networkParametersFeed():

abstract fun nodeDiagnosticInfo():

ParametersUpdateInfo

NodeDiagnosticInfo

abstract fun nodeInfo():

)

abstract fun notaryIdentities():

abstract fun notaryPartyFromX500Name(x500Name:

)

)

exactMatch

)

)

abstract fun queryAttachments(query:

sorting

)

@RPCReturnsObservables abstract fun <T> reattachFlowWithClientId(clientId:

)

abstract fun refreshNetworkMapCache():

abstract fun registeredFlows():

abstract fun removeClientId(clientId:

)

abstract fun removeClientIdAsAdmin(clientId:

)

abstract fun setFlowsDrainingModeEnabled(enabled:

)

abstract fun shutdown():

@RPCReturnsObservables abstract fun <T> startFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startFlowDynamicWithClientId(clientId:

logicType

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startTrackedFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMappingFeed():

abstract fun stateMachineRecordedTransactionMappingSnapshot():

@RPCReturnsObservables abstract fun stateMachinesFeed():

abstract fun stateMachinesSnapshot():

abstract fun terminate(drainPendingFlows:

)

abstract fun uploadAttachment(jar:

)

abstract fun uploadAttachmentWithMetadata(jar:

uploader

filename

)

vaultQuery

(

contractStateType

out

)

Page

vaultQueryBy

(

criteria

paging

sorting

contractStateType

out

)

Page

vaultQueryByCriteria

(

criteria

contractStateType

out

)

Page

vaultQueryByWithPagingSpec

(

contractStateType

out

criteria

paging

)

Page

vaultQueryByWithSorting

(

contractStateType

out

criteria

sorting

)

Page

vaultTrack

(

contractStateType

out

)

Page

Update

vaultTrackBy

(

criteria

paging

sorting

contractStateType

out

)

Page

Update

vaultTrackByCriteria

(

contractStateType

out

criteria

)

Page

Update

vaultTrackByWithPagingSpec

(

contractStateType

out

criteria

paging

)

Page

Update

vaultTrackByWithSorting

(

contractStateType

out

criteria

sorting

)

@RPCReturnsObservables abstract fun waitUntilNetworkReady():

Page

Update

abstract fun wellKnownPartyFromAnonymous(party:

)

abstract fun wellKnownPartyFromX500Name(x500Name:

)

data class DataFeed<out A, B>

Module Contents

DataFeed(snapshot: A, updates: Observable)

val snapshot: A

val updates: Observable

@DoNotImplement interface FlowHandle<A> :

Module Contents

abstract val returnValue:

data class FlowHandleImpl<A> :

Module Contents

returnValue

)

interface FlowHandleWithClientId<A> :

Module Contents

abstract val clientId:

data class FlowHandleWithClientIdImpl<A> :

FlowHandleWithClientIdImpl(id:

Module Contents

returnValue

clientId

)

interface FlowProgressHandle<A> :

Module Contents

abstract val progress: Observable<

abstract val stepsTreeFeed:

abstract val stepsTreeIndexFeed:

data class FlowProgressHandleImpl<A> :

FlowProgressHandleImpl(id:

Module Contents

returnValue

progress

Observable

stepsTreeIndexFeed

stepsTreeFeed

)

returnValue

progress

Observable

)

FlowProgressHandleImpl

val progress: Observable<

val stepsTreeIndexFeed:

interface MessageRecipientGroup :

interface MessageRecipients

data class ParametersUpdateInfo

Module Contents

ParametersUpdateInfo(hash:

parameters

description

updateDeadline

)

~~pendingFlowsCount~~

(

)

@DoNotImplement interface RPCOps

Module Contents

abstract val protocolVersion:

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

Module Contents

RPCReturnsObservables()

interface SingleMessageRecipient :

inline fun <T, reified R :

startFlow

(

flowConstructor

(

)

inline fun <T, A, reified R :

startFlow

(

flowConstructor

(

)

arg0

)

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

startFlow

(

flowConstructor

(

)

arg0

arg1

)

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

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

)

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

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

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

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

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

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

inline fun <T, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

inline fun <T, A, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

)

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

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

)

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

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

)

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

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

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

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

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

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

inline fun <T, reified R :

startTrackedFlow

(

flowConstructor

(

)

inline fun <T, A, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

)

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

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

)

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

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

)

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

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

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

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

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

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

data class StateMachineInfo

Module Contents

flowLogicClassName

initiator

progressTrackerStepAndUpdates

invocationContext

)

flowLogicClassName

initiator

progressTrackerStepAndUpdates

)

val flowLogicClassName:

val ~~initiator~~:

val progressTrackerStepAndUpdates:

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val transactionId:

sealed class StateMachineUpdate

Module Contents

data class Added :

StateMachineUpdate

Module Contents

Added(stateMachineInfo:

)

val stateMachineInfo:

Module Contents

result

)

vaultQueryBy

(

criteria

paging

sorting

)

Page

package net.corda.core.messaging.flows

vaultTrackBy

(

criteria

paging

sorting

)

Page

Update

Module Contents

interface FlowManagerRPCOps :

abstract fun debugCheckpoints():

Module Contents

abstract fun dumpCheckpoints():

package net.corda.core.node

Module Contents

interface AppServiceHub :

abstract fun register(priority:

Module Contents

abstract val database:

CordaTransactionSupport

observer

ServiceLifecycleObserver

)

open fun <T> register(priority:

func

(

)

const val SERVICE_PRIORITY_HIGH:

const val SERVICE_PRIORITY_LOW:

const val SERVICE_PRIORITY_NORMAL:

abstract fun <T> startFlow(flow:

)

abstract fun <T> startTrackedFlow(flow:

)

@Target([AnnotationTarget.PROPERTY]) annotation class AutoAcceptable

Module Contents

AutoAcceptable()

data class NetworkParameters

Module Contents

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

recoveryMaximumBackupInterval

confidentialIdentityMinimumBackupInterval

val confidentialIdentityMinimumBackupInterval:

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

val maxTransactionSize:

val packageOwnership:

val recoveryMaximumBackupInterval:

val whitelistedContractImplementations:

data class NodeDiagnosticInfo

Module Contents

NodeDiagnosticInfo(version:

revision

platformVersion

vendor

cordapps

)

Module Contents

legalIdentitiesAndCerts

platformVersion

serial

)

fun identityAndCertFromX500Name(name:

)

fun identityFromX500Name(name:

)

fun isLegalIdentity(party:

)

fun isLegalIdentity(name:

)

val legalIdentitiesAndCerts:

data class NotaryInfo

Module Contents

validating

)

interface ServiceHub :

Module Contents

publicKey

)

abstract val contractUpgradeService:

)

cordaService

(

type

abstract fun <T : TelemetryComponent> cordaTelemetryComponent(type:

)

)

publicKey

)

)

publicKey

)

)

abstract val diagnosticsService:

open fun getAppContext():

abstract fun jdbcSession():

abstract val keyManagementService:

abstract val myInfo:

abstract val networkMapCache:

txs

)

first

vararg

remaining

)

abstract fun recordTransactions(statesToRecord:

txs

)

open fun recordTransactions(first:

vararg

remaining

)

open fun recordTransactions(txs:

)

abstract fun registerUnloadHandler(runOnStop: () ->

)

publicKey

)

)

abstract val telemetryService:

signingPubKeys

)

TelemetryService

toStateAndRef

(

stateRef

)

abstract val validatedTransactions:

abstract val vaultService:

abstract fun <T> withEntityManager(block: EntityManager.() -> T): T

abstract fun withEntityManager(block:

EntityManager

)

@DoNotImplement interface ServicesForResolution

Module Contents

abstract val attachments:

abstract val cordappProvider:

abstract val identityService:

abstract fun loadContractAttachment(stateRef:

)

abstract fun loadState(stateRef:

)

abstract fun loadStates(stateRefs:

)

abstract val networkParametersService:

open fun specialise(ltx:

)

enum class StatesToRecord

Module Contents

ALL_VISIBLE

NONE

ONLY_RELEVANT

class ZoneVersionTooLowException :

ZoneVersionTooLowException(message:

Module Contents

package net.corda.core.node.services

)

Module Contents

typealias AttachmentFixup =

typealias AttachmentId =

@DoNotImplement interface AttachmentStorage

Module Contents

abstract fun getLatestContractAttachments(contractClassName:

minContractVersion

)

abstract fun hasAttachment(attachmentId:

)

abstract fun ~~importAttachment~~(jar:

)

abstract fun importAttachment(jar:

uploader

filename

)

abstract fun ~~importOrGetAttachment~~(jar:

)

)

abstract fun queryAttachments(criteria:

sorting

)

open fun queryAttachments(criteria:

)

@DoNotImplement interface ContractUpgradeService

Module Contents

abstract fun getAuthorisedContractUpgrade(ref:

)

abstract fun removeAuthorisedContractUpgrade(ref:

)

abstract fun storeAuthorisedContractUpgrade(ref:

upgradedContractClass

out

)

@Target([AnnotationTarget.CLASS]) annotation class CordaService

Module Contents

CordaService()

class CordaServiceCriticalFailureException :

Module Contents

)

cause

@DoNotImplement interface IdentityService

)

Module Contents

open fun assertOwnership(party:

anonymousParty

)

abstract val caCertStore:

CertStore

abstract fun certificateFromKey(owningKey:

)

@Suspendable abstract fun externalIdForPublicKey(publicKey:

)

abstract fun getAllIdentities():

exactMatch

)

)

abstract fun publicKeysForExternalId(externalId:

)

abstract fun registerKey(publicKey:

party

externalId

)

open fun requireWellKnownPartyFromAnonymous(party:

)

abstract val trustAnchor:

abstract fun verifyAndRegisterIdentity(identity:

abstract val trustRoot:

X509Certificate

)

open fun wellKnownPartyFromAnonymous(party:

)

open fun wellKnownPartyFromAnonymous(partyRef:

)

)

@DoNotImplement interface KeyManagementService

Module Contents

abstract fun filterMyKeys(candidateKeys:

)

@Suspendable abstract fun freshKey():

@Suspendable abstract fun freshKey(externalId:

)

@Suspendable abstract fun freshKeyAndCert(identity:

revocationEnabled

)

@Suspendable abstract fun freshKeyAndCert(identity:

revocationEnabled

externalId

)

@Suspendable abstract fun sign(bytes:

publicKey

@Suspendable abstract fun sign(signableData:

)

WithKey

publicKey

)

const val MAX_CONSTRAINT_DATA_SIZE:

interface NetworkMapCache :

NetworkMapCacheBase

Module Contents

abstract fun getNodeByLegalIdentity(party:

)

data class Added : MapChange

sealed class MapChange

Module Contents

Module Contents

)

data class Modified : MapChange

Module Contents

previousNode

)

data class Removed : MapChange

Module Contents

)

@DoNotImplement interface NetworkMapCacheBase

Module Contents

abstract val allNodes:

abstract val changed: Observable<MapChange>

abstract fun getNodeByAddress(address:

)

abstract fun getNodeByLegalName(name:

)

abstract fun getNodesByLegalIdentityKey(identityKey:

)

abstract fun getNodesByLegalName(name:

)

open fun getNotary(name:

)

abstract fun getPartyInfo(party:

)

open fun getPeerByLegalName(name:

)

abstract fun getPeerCertificateByLegalName(name:

)

abstract fun isNotary(party:

)

abstract fun isValidatingNotary(party:

)

abstract val nodeReady:

abstract val notaryIdentities:

@DoNotImplement interface NetworkParametersService

MapChange

Module Contents

abstract val currentHash:

abstract val defaultHash:

abstract fun lookup(hash:

)

data class DistributedNode :

sealed class PartyInfo

Module Contents

Module Contents

DistributedNode(party:

)

data class SingleNode :

Module Contents

addresses

)

queryBy

(

)

Page

queryBy

(

criteria

)

Page

queryBy

(

paging

)

Page

queryBy

(

criteria

paging

)

Page

queryBy

(

criteria

sorting

)

Page

queryBy

(

criteria

paging

sorting

enum class ServiceLifecycleEvent

)

Page

Module Contents

BEFORE_STATE_MACHINE_START

STATE_MACHINE_STARTED

@FunctionalInterface interface ServiceLifecycleObserver

Module Contents

abstract fun onServiceLifecycleEvent(event:

)

data class SignedTransactionWithStatus :

SignedTransactionWithStatus(stx:

Module Contents

status

)

class StatesNotAvailableException :

StatesNotAvailableException(message:

Module Contents

cause

)

@DoNotImplement interface TelemetryService

Module Contents

abstract fun <T> getTelemetryHandle(telemetryClass:

)

class ~~TimeWindowChecker~~

Module Contents

TimeWindowChecker(clock:

)

val clock:

fun isValid(timeWindow:

)

trackBy

(

)

Page

Update

trackBy

(

paging

)

Page

Update

trackBy

(

criteria

)

Page

Update

trackBy

(

criteria

paging

)

Page

Update

trackBy

(

criteria

sorting

)

Page

Update

enum class TransactionStatus

trackBy

(

criteria

paging

sorting

)

Page

Update

Module Contents

IN_FLIGHT

UNVERIFIED

VERIFIED

@DoNotImplement interface TransactionStorage

Module Contents

abstract fun getTransaction(id:

)

abstract fun getTransactionWithStatus(id:

SignedTransactionWithStatus

)

abstract fun trackTransaction(id:

)

abstract val updates: Observable<

class UnknownAnonymousPartyException :

UnknownAnonymousPartyException(message:

Module Contents

)

Module Contents

)

data class ConstraintInfo

Module Contents

ConstraintInfo(constraint:

)

val constraint:

fun constraintInfo(type: Type, data:

)

ConstraintInfo

Module Contents

val ~~NoNotaryUpdate~~: Update<

val ~~NoUpdate~~: Update<

Module Contents

statesMetadata

StateMetadata

totalStatesAvailable

stateTypes

StateStatus

otherResults

previousPageAnchor

)

statesMetadata

StateMetadata

totalStatesAvailable

stateTypes

StateStatus

otherResults

)

Page

val otherResults:

val stateTypes: StateStatus

val previousPageAnchor:

StateMetadata

val totalStatesAvailable:

enum class RelevancyStatus

Module Contents

NOT_RELEVANT

RELEVANT

data class StateMetadata

Module Contents

StateMetadata(ref:

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

val constraintInfo: ConstraintInfo?

relevancyStatus

RelevancyStatus

constraintInfo

ConstraintInfo

)

val consumedTime:

val contractStateClassName:

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

)

StateMetadata

contractStateClassName

recordedTime

consumedTime

status

StateStatus

notary

lockId

lockUpdateTime

val relevancyStatus: RelevancyStatus?

relevancyStatus

RelevancyStatus

)

StateMetadata

val states:

enum class StateStatus

Module Contents

UNCONSUMED

data class Update<U :

Module Contents

produced

flowId

type

UpdateType

references

)

produced

flowId

type

UpdateType

references

consumingTxIds

)

containsType

(

)

containsType

(

clazz

status

StateStatus

)

produced

flowId

type

UpdateType

)

Update

produced

flowId

type

UpdateType

references

operator fun plus(rhs: Update): Update

)

Update

enum class UpdateType

Module Contents

CONTRACT_UPGRADE

GENERAL

NOTARY_CHANGE

class VaultQueryException :

Module Contents

)

cause

@DoNotImplement interface VaultService

)

Module Contents

_queryBy

(

criteria

paging

sorting

contractStateType

out

)

Page

_trackBy

(

criteria

paging

sorting

contractStateType

out

)

abstract fun addNoteToTransaction(txnId:

Page

Update

noteText

)

abstract fun getTransactionNotes(txnId:

)

queryBy

(

contractStateType

out

)

Page

queryBy

(

contractStateType

out

criteria

)

Page

queryBy

(

contractStateType

out

paging

)

Page

queryBy

(

contractStateType

out

criteria

paging

)

Page

queryBy

(

contractStateType

out

criteria

sorting

)

Page

queryBy

(

contractStateType

out

criteria

paging

sorting

abstract val rawUpdates: Observable<Update<

)

Page

abstract fun softLockRelease(lockId:

stateRefs

)

abstract fun softLockReserve(lockId:

stateRefs

)

trackBy

(

contractStateType

out

)

Page

Update

trackBy

(

contractStateType

out

criteria

)

Page

Update

trackBy

(

contractStateType

out

paging

)

Page

Update

trackBy

(

contractStateType

out

criteria

paging

)

Page

Update

trackBy

(

contractStateType

out

criteria

sorting

)

Page

Update

trackBy

(

contractStateType

@Suspendable abstract fun <T :

out

criteria

paging

sorting

)

Page

Update

FungibleState

tryLockFungibleStatesForSpending

(

lockId

eligibleStatesQuery

amount

contractStateType

out

)

abstract val updates: Observable<Update<

open fun whenConsumed(ref:

)

Update

package net.corda.core.node.services.diagnostics

Module Contents

@DoNotImplement interface DiagnosticsService

Module Contents

abstract fun nodeVersionInfo():

NodeVersionInfo

data class NodeVersionInfo

Module Contents

NodeVersionInfo(releaseVersion:

revision

platformVersion

vendor

)

package net.corda.core.node.services.vault

Module Contents

enum class AggregateFunctionType

Module Contents

sealed class AttachmentQueryCriteria :

ChainableQueryCriteria

Module Contents

)

AndVisitor

Module Contents

AndComposition(a:

)

data class AttachmentsQueryCriteria :

Module Contents

filenameCondition

uploadDateCondition

)

)

filenameCondition

)

val contractClassNamesCondition:

filenameCondition

uploadDateCondition

contractClassNamesCondition

signersCondition

isSignedCondition

versionCondition

)

fun copy(uploaderCondition:

filenameCondition

uploadDateCondition

)

AttachmentsQueryCriteria

val filenameCondition:

fun isSigned(isSignedPredicate:

)

AttachmentsQueryCriteria

val isSignedCondition:

val signersCondition:

val uploadDateCondition:

val uploaderCondition:

val versionCondition:

)

fun withContractClassNames(contractClassNamesPredicate:

Predicate

fun withFilename(filenamePredicate:

)

AttachmentsQueryCriteria

fun withSigners(signersPredicate:

)

AttachmentsQueryCriteria

fun withUploadDate(uploadDatePredicate:

)

AttachmentsQueryCriteria

fun withUploader(uploaderPredicate:

)

AttachmentsQueryCriteria

fun withVersion(versionPredicate:

)

AttachmentsQueryCriteria

)

AttachmentsQueryCriteria

)

OrVisitor

Module Contents

OrComposition(a:

)

data class AttachmentSort :

Module Contents

AttachmentSort(columns:

enum class AttachmentSortAttribute

AttachmentSortColumn

)

Module Contents

data class AttachmentSortColumn

Module Contents

AttachmentSortColumn(sortAttribute: AttachmentSortAttribute, direction: Direction = Sort.Direction.ASC)

val sortAttribute: AttachmentSortAttribute

interface AttachmentsQueryCriteriaParser :

AttachmentSortColumn

abstract fun parseCriteria(criteria: AttachmentsQueryCriteria):

Module Contents

interface BaseQueryCriteriaParser<Q :

Predicate

abstract fun parse(criteria: Q, sorting: S? = null):

Module Contents

abstract fun parseAnd(left: Q, right: Q):

Predicate

abstract fun parseOr(left: Q, right: Q):

Predicate

enum class BinaryComparisonOperator :

Predicate

abstract class BaseSort

Module Contents

BaseSort()

enum class BinaryLogicalOperator :

Module Contents

GREATER_THAN

GREATER_THAN_OR_EQUAL

LESS_THAN

LESS_THAN_OR_EQUAL

Module Contents

Module Contents

avg

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~avg~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

avg

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

between

(

from

)

ColumnPredicateExpression

~~between~~

(

from

)

ColumnPredicateExpression

between

(

from

)

ColumnPredicateExpression

between

(

from

)

Between

compare

(

operator

value

)

BinaryComparison

comparePredicate

(

operator

value

)

ColumnPredicateExpression

~~comparePredicate~~

(

operator

value

)

ColumnPredicateExpression

comparePredicate

(

operator

value

)

ColumnPredicateExpression

count

(

)

AggregateFunctionExpression

~~count~~

(

)

AggregateFunctionExpression

count

(

)

AggregateFunctionExpression

equal

(

value

exactMatch

)

ColumnPredicateExpression

~~equal~~

(

value

exactMatch

)

ColumnPredicateExpression

equal

(

value

exactMatch

)

ColumnPredicateExpression

@JvmOverloads fun <R> equal(value: R, exactMatch:

)

EqualityComparison

functionPredicate

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~functionPredicate~~

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

functionPredicate

(

predicate

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

greaterThan

(

value

)

ColumnPredicateExpression

~~greaterThan~~

(

value

)

ColumnPredicateExpression

greaterThan

(

value

)

ColumnPredicateExpression

greaterThan

(

value

)

BinaryComparison

greaterThanOrEqual

(

value

)

ColumnPredicateExpression

~~greaterThanOrEqual~~

(

value

)

ColumnPredicateExpression

greaterThanOrEqual

(

value

)

ColumnPredicateExpression

greaterThanOrEqual

(

value

)

BinaryComparison

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

)

ColumnPredicateExpression

(

collection

exactMatch

fun <R> isNotNull(): NullExpression<R>

)

CollectionExpression

fun <R> isNull(): NullExpression<R>

isNull

(

)

ColumnPredicateExpression

~~isNull~~

(

)

ColumnPredicateExpression

isNull

(

)

ColumnPredicateExpression

lessThan

(

value

)

ColumnPredicateExpression

~~lessThan~~

(

value

)

ColumnPredicateExpression

lessThan

(

value

)

ColumnPredicateExpression

lessThan

(

value

)

BinaryComparison

lessThanOrEqual

(

value

)

ColumnPredicateExpression

~~lessThanOrEqual~~

(

value

)

ColumnPredicateExpression

lessThanOrEqual

(

value

)

ColumnPredicateExpression

@JvmOverloads fun like(string:

lessThanOrEqual

(

value

)

BinaryComparison

exactMatch

)

Likeness

(

string

exactMatch

)

ColumnPredicateExpression

~~like~~

(

string

exactMatch

)

ColumnPredicateExpression

(

string

exactMatch

)

ColumnPredicateExpression

max

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~max~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

max

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

min

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~min~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

min

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

notEqual

(

value

exactMatch

)

ColumnPredicateExpression

~~notEqual~~

(

value

exactMatch

)

ColumnPredicateExpression

notEqual

(

value

exactMatch

)

ColumnPredicateExpression

@JvmOverloads fun <R> notEqual(value: R, exactMatch:

)

EqualityComparison

notIn

(

collection

exactMatch

)

ColumnPredicateExpression

~~notIn~~

(

collection

exactMatch

)

ColumnPredicateExpression

notIn

(

collection

exactMatch

)

ColumnPredicateExpression

notIn

(

collection

exactMatch

@JvmOverloads fun notLike(string:

)

CollectionExpression

exactMatch

)

Likeness

notLike

(

string

exactMatch

)

ColumnPredicateExpression

~~notLike~~

(

string

exactMatch

)

ColumnPredicateExpression

notLike

(

string

exactMatch

)

ColumnPredicateExpression

notNull

(

)

ColumnPredicateExpression

~~notNull~~

(

)

ColumnPredicateExpression

notNull

(

)

ColumnPredicateExpression

predicate

(

predicate

)

ColumnPredicateExpression

~~predicate~~

(

predicate

)

ColumnPredicateExpression

predicate

(

predicate

)

ColumnPredicateExpression

sum

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

~~sum~~

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

sum

(

groupByColumns

orderBy

Direction

)

AggregateFunctionExpression

inline fun <A> builder(block:

Builder

(

)

enum class CollectionOperator :

Module Contents

class Column<O, out C>

Module Contents

)

)

)

declaringClass

)

sealed class ColumnPredicate<C>

Module Contents

data class AggregateFunction<C> :

Module Contents

AggregateFunction(type:

)

val type:

data class Between<C :

Between(rightFromLiteral: C, rightToLiteral: C)

Module Contents

val rightFromLiteral: C

val rightToLiteral: C

data class BinaryComparison<C :

BinaryComparison(operator:

Module Contents

rightLiteral

)

data class CollectionExpression<C> :

CollectionExpression(operator:

Module Contents

rightLiteral

)

data class EqualityComparison<C> :

EqualityComparison(operator:

Module Contents

rightLiteral

)

data class NullExpression<C> :

data class Likeness :

Module Contents

rightLiteral

)

Module Contents

NullExpression(operator:

)

@DoNotImplement interface CordaTransactionSupport

Module Contents

abstract fun <T> transaction(statement:

SessionScope

(

)

sealed class CriteriaExpression<O, out T>

Module Contents

data class AggregateFunctionExpression<O, C> :

AggregateFunctionExpression(column:

Module Contents

predicate

groupByColumns

orderBy

Direction

)

val orderBy: Direction?

val predicate:

data class BinaryLogical<O> :

Module Contents

right

operator

)

val right:

data class ColumnPredicateExpression<O, C> :

ColumnPredicateExpression(column:

Module Contents

predicate

)

Module Contents

)

const val DEFAULT_PAGE_NUM:

const val DEFAULT_PAGE_SIZE:

enum class EqualityComparisonOperator :

Module Contents

NOT_EQUAL_IGNORE_CASE

Module Contents

interface GenericQueryCriteria<Q :

interface ChainableQueryCriteria<Q :

Module Contents

abstract infix fun and(criteria: Q): Q

Module Contents

interface AndVisitor<Q :

Module Contents

abstract infix fun or(criteria: Q): Q

Predicate

interface OrVisitor<Q :

Module Contents

abstract fun visit(parser: P):

Predicate

fun <O, C> getColumnName(column:

Predicate

)

fun getField(fieldName:

entityClass

)

@DoNotImplement interface IQueryCriteriaParser :

abstract fun parseCriteria(criteria: CommonQueryCriteria):

Module Contents

abstract fun parseCriteria(criteria: FungibleAssetQueryCriteria):

Predicate

abstract fun parseCriteria(criteria: LinearStateQueryCriteria):

Predicate

Predicate

abstract fun <L :

parseCriteria

(

criteria

VaultCustomQueryCriteria

)

abstract fun parseCriteria(criteria: VaultQueryCriteria):

Predicate

enum class LikenessOperator :

Predicate

Module Contents

const val MAX_PAGE_SIZE:

enum class NullOperator :

@DoNotImplement interface Operator

Module Contents

IS_NULL

NOT_NULL

data class PageSpecification

Module Contents

PageSpecification(pageNumber:

pageSize

)

sealed class QueryCriteria :

ChainableQueryCriteria

Module Contents

)

abstract class CommonQueryCriteria :

AndVisitor

Module Contents

)

Module Contents

CommonQueryCriteria()

open val constraints:

open val constraintTypes:

ConstraintInfo

abstract val contractStateTypes:

Type

out

open val exactParticipants:

open val externalIds:

open val participants:

open val relevancyStatus: RelevancyStatus

abstract val status: StateStatus

open fun visit(parser:

)

data class FungibleAssetQueryCriteria : CommonQueryCriteria

Predicate

Module Contents

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

)

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

exactParticipants

)

out

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

FungibleAssetQueryCriteria

owner

quantity

issuer

issuerRef

status

StateStatus

contractStateTypes

out

)

FungibleAssetQueryCriteria

)

Predicate

out

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withIssuer(issuer:

fun withissuerRef(issuerRef:

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withOwner(owner:

)

FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): FungibleAssetQueryCriteria

)

FungibleAssetQueryCriteria

fun withStatus(status: StateStatus): FungibleAssetQueryCriteria

data class FungibleStateQueryCriteria : CommonQueryCriteria

Module Contents

FungibleStateQueryCriteria(participants:

quantity

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

out

)

Predicate

out

)

FungibleStateQueryCriteria

)

FungibleStateQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): FungibleStateQueryCriteria

)

FungibleStateQueryCriteria

fun withStatus(status: StateStatus): FungibleStateQueryCriteria

data class LinearStateQueryCriteria : CommonQueryCriteria

Module Contents

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

uuid

externalId

status

StateStatus

contractStateTypes

out

)

linearId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

linearId

status

StateStatus

contractStateTypes

out

)

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

exactParticipants

)

out

uuid

externalId

status

StateStatus

contractStateTypes

out

)

LinearStateQueryCriteria

uuid

externalId

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

LinearStateQueryCriteria

)

Predicate

out

)

LinearStateQueryCriteria

fun withExternalId(externalId:

)

LinearStateQueryCriteria

)

LinearStateQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): LinearStateQueryCriteria

)

LinearStateQueryCriteria

fun withStatus(status: StateStatus): LinearStateQueryCriteria

fun withUuid(uuid:

)

LinearStateQueryCriteria

)

data class SoftLockingCondition

OrVisitor

Module Contents

)

Module Contents

SoftLockingCondition(type: SoftLockingType, lockIds:

)

val type: SoftLockingType

enum class SoftLockingType

Module Contents

LOCKED_ONLY

SPECIFIED

UNLOCKED_AND_SPECIFIED

UNLOCKED_ONLY

data class TimeCondition

Module Contents

TimeCondition(type: TimeInstantType, predicate:

)

val type: TimeInstantType

enum class TimeInstantType

Module Contents

data class VaultCustomQueryCriteria<L :

RECORDED

CommonQueryCriteria

Module Contents

status

StateStatus

contractStateTypes

out

)

status

StateStatus

contractStateTypes

out

relevancyStatus

RelevancyStatus

)

out

status

StateStatus

contractStateTypes

out

)

VaultCustomQueryCriteria

val expression:

)

Predicate

out

fun withExpression(expression:

)

VaultCustomQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): VaultCustomQueryCriteria<L>

)

VaultCustomQueryCriteria

fun withStatus(status: StateStatus): VaultCustomQueryCriteria<L>

data class VaultQueryCriteria : CommonQueryCriteria

Module Contents

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

ConstraintInfo

participants

externalIds

)

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

)

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

)

VaultQueryCriteria(status: StateStatus)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

VaultQueryCriteria(status: StateStatus, contractStateTypes:

)

out

stateRefs

)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

stateRefs

notary

)

VaultQueryCriteria(status: StateStatus, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

)

VaultQueryCriteria(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

externalIds

exactParticipants

)

ConstraintInfo

Type

out

fun copy(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

fun copy(status: StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes:

ConstraintInfo

participants

externalIds

)

VaultQueryCriteria

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

relevancyStatus

RelevancyStatus

constraintTypes

Type

constraints

ConstraintInfo

participants

fun copy(status: StateStatus = this.status, contractStateTypes:

)

VaultQueryCriteria

out

stateRefs

notary

softLockingCondition

SoftLockingCondition

timeCondition

TimeCondition

)

VaultQueryCriteria

val softLockingCondition: SoftLockingCondition?

val stateRefs:

val timeCondition: TimeCondition?

)

fun withConstraints(constraints:

Predicate

fun withConstraintTypes(constraintTypes:

ConstraintInfo

)

VaultQueryCriteria

Type

)

VaultQueryCriteria

out

)

VaultQueryCriteria

fun withExternalIds(externalIds:

)

VaultQueryCriteria

)

VaultQueryCriteria

fun withNotary(notary:

)

VaultQueryCriteria

fun withRelevancyStatus(relevancyStatus: RelevancyStatus): VaultQueryCriteria

)

VaultQueryCriteria

fun withSoftLockingCondition(softLockingCondition: SoftLockingCondition): VaultQueryCriteria

fun withStateRefs(stateRefs:

fun withStatus(status: StateStatus): VaultQueryCriteria

)

VaultQueryCriteria

fun withTimeCondition(timeCondition: TimeCondition): VaultQueryCriteria

fun <O, C> resolveEnclosingObjectFromColumn(column:

)

fun <O, R> resolveEnclosingObjectFromExpression(expression:

)

@DoNotImplement interface SessionScope

Module Contents

abstract val session: Session

Module Contents

SortColumn

)

@DoNotImplement interface Attribute

enum class CommonStateAttribute : Attribute

SortColumn

Module Contents

Module Contents

enum class FungibleStateAttribute : Attribute

Module Contents

enum class LinearStateAttribute : Attribute

Module Contents

data class SortColumn

Module Contents

SortColumn(sortAttribute:

direction

Direction

)

val sortAttribute:

enum class VaultStateAttribute : Attribute

Module Contents

sealed class SortAttribute

Module Contents

data class Custom :

Module Contents

Custom(entityStateClass:

out

entityStateColumnName

)

val entityStateClass:

out

val entityStateColumnName:

data class Standard :

Standard(attribute: Attribute)

Module Contents

val attribute: Attribute

package net.corda.core.observable

Module Contents

fun <T> Observable<T>.continueOnError(): Observable<T>

Module Contents

package net.corda.core.schemas

Module Contents

object CommonSchema

object CommonSchemaV1 :

@MappedSuperclass class FungibleState :

Module Contents

FungibleState(participants:

Module Contents

owner

quantity

issuer

issuerRef

)

@MappedSuperclass class LinearState :

Module Contents

_participants

)

LinearState(participants:

externalId

uuid

)

interface DirectStatePersistable :

Module Contents

abstract val stateRef:

interface IndirectStatePersistable<T :

abstract val compositeKey: T

Module Contents

open class MappedSchema

Module Contents

MappedSchema(schemaFamily:

version

mappedTypes

)

open val migrationResource:

)

object MappedSchemaValidator

Module Contents

fun crossReferencesToOtherMappedSchema(schema:

)

fun fieldsFromOtherMappedSchema(schema:

SchemaCrossReferenceReport

)

fun methodsFromOtherMappedSchema(schema:

SchemaCrossReferenceReport

)

class SchemaCrossReferenceReport

SchemaCrossReferenceReport

Module Contents

SchemaCrossReferenceReport(schema:

entity

referencedSchema

fieldOrMethod

fieldOrMethodType

)

@MappedSuperclass class PersistentState :

PersistentState(stateRef:

Module Contents

)

var stateRef:

@Embeddable data class PersistentStateRef :

PersistentStateRef(stateRef:

Module Contents

interface QueryableState :

)

PersistentStateRef(txId:

index

)

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas():

interface StatePersistable

package net.corda.core.serialization

Module Contents

const val AMQP_ENVELOPE_CACHE_INITIAL_CAPACITY:

const val AMQP_ENVELOPE_CACHE_PROPERTY:

interface CheckpointCustomSerializer<OBJ, PROXY>

Module Contents

abstract fun hasListed(type:

interface ClassWhitelist

Module Contents

)

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class ConstructorForDeserialization

Module Contents

ConstructorForDeserialization()

enum class ContextPropertyKeys

Module Contents

SERIALIZERS

@Target([AnnotationTarget.CLASS]) @Inherited annotation class CordaSerializable

Module Contents

CordaSerializable()

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefault

Module Contents

CordaSerializationTransformEnumDefault(new:

old

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefaults

Module Contents

CordaSerializationTransformEnumDefaults(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRename

Module Contents

CordaSerializationTransformRename(to:

from

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRenames

Module Contents

CordaSerializationTransformRenames(vararg value:

)

out

interface CustomSerializationScheme

Module Contents

deserialize

(

bytes

clazz

context

abstract fun getSchemeId():

)

serialize

(

obj

context

)

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class DeprecatedConstructorForDeserialization

Module Contents

DeprecatedConstructorForDeserialization(version:

)

const val DESERIALIZATION_CACHE_PROPERTY:

deserialize

(

serializationFactory

context

)

deserialize

(

serializationFactory

context

)

deserializeWithCompatibleContext

(

serializationFactory

context

ObjectWithCompatibleContext

)

@DoNotImplement interface EncodingWhitelist

Module Contents

abstract fun acceptEncoding(encoding:

)

Module Contents

deserialize

(

serializationFactory

context

)

Module Contents

deserialize

(

serializationFactory

context

class MissingAttachmentsException :

)

Module Contents

)

class MissingAttachmentsRuntimeException :

message

)

Module Contents

message

)

)

data class ObjectWithCompatibleContext<out T :

message

cause

)

ObjectWithCompatibleContext(obj: T, context:

Module Contents

)

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.FUNCTION]) annotation class SerializableCalculatedProperty

Module Contents

SerializableCalculatedProperty()

@DoNotImplement interface SerializationContext

Module Contents

abstract val carpenterDisabled:

abstract val customSerializers:

abstract val encoding:

abstract val encodingWhitelist:

abstract val lenientCarpenterEnabled:

abstract val objectReferencesEnabled:

abstract val preferredSerializationVersion:

abstract val preventDataLoss:

abstract val useCase: UseCase

Module Contents

abstract fun ~~withAttachmentsClassLoader~~(attachmentHashes:

)

abstract fun withClassLoader(classLoader:

)

abstract fun withCustomSerializers(serializers:

)

abstract fun withEncoding(encoding:

)

abstract fun withEncodingWhitelist(encodingWhitelist:

)

abstract fun withLenientCarpenter():

abstract fun withoutCarpenter():

abstract fun withoutReferences():

abstract fun withPreferredSerializationVersion(magic:

)

abstract fun withPreventDataLoss():

abstract fun withProperties(extraProperties:

)

abstract fun withProperty(property:

value

)

abstract fun withWhitelisted(clazz:

)

interface SerializationCustomSerializer<OBJ, PROXY>

Module Contents

object SerializationDefaults

Module Contents

val P2P_CONTEXT:

val RPC_CLIENT_CONTEXT:

val RPC_SERVER_CONTEXT:

val SERIALIZATION_FACTORY:

val STORAGE_CONTEXT:

@DoNotImplement interface SerializationEncoding

abstract class SerializationFactory

Module Contents

SerializationFactory()

fun <T> asCurrent(block:

(

)

deserialize

(

byteSequence

clazz

context

)

deserializeWithCompatibleContext

(

byteSequence

clazz

context

ObjectWithCompatibleContext

)

serialize

(

obj

context

)

fun <T> withCurrentContext(context:

typealias SerializationMagic =

block

(

)

@DoNotImplement interface SerializationSchemeContext

Module Contents

interface SerializationToken

Module Contents

abstract fun fromToken(context:

)

interface SerializationWhitelist

Module Contents

serialize

(

serializationFactory

context

)

interface SerializeAsToken

Module Contents

abstract fun toToken(context:

)

interface SerializeAsTokenContext

Module Contents

abstract fun getSingleton(className:

)

abstract fun putSingleton(toBeTokenized:

)

abstract val serviceHub:

class SerializedBytes<T :

Module Contents

SerializedBytes(bytes:

)

class SingletonSerializationToken :

from

(

obj

serializationFactory

context

)

Module Contents

fun fromToken(context:

)

fun registerWithContext(context:

toBeTokenized

)

singletonSerializationToken

(

toBeTokenized

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

)

withWhitelist

(

classes

)

package net.corda.core.transactions

Module Contents

@DoNotImplement abstract class BaseTransaction :

Module Contents

BaseTransaction()

filterOutputs

(

clazz

predicate

)

filterOutputs

(

crossinline

predicate

(

)

)

filterOutRefs

(

clazz

predicate

)

filterOutRefs

(

crossinline

predicate

(

)

)

findOutput

(

clazz

predicate

)

findOutput

(

crossinline

predicate

(

)

)

findOutRef

(

clazz

predicate

)

findOutRef

(

crossinline

predicate

(

)

)

)

abstract val outputs:

outputsOfType

(

clazz

)

outputsOfType

(

)

outRef

(

index

)

outRef

(

state

)

outRefsOfType

(

clazz

)

outRefsOfType

(

)

open class ComponentGroup

Module Contents

ComponentGroup(groupIndex:

components

)

class ComponentVisibilityException :

ComponentVisibilityException(id:

Module Contents

reason

)

data class ContractUpgradeFilteredTransaction :

ContractUpgradeFilteredTransaction(visibleComponents:

Module Contents

FilteredComponent

hiddenComponents

ContractUpgradeFilteredTransaction(visibleComponents:

)

fun copy(visibleComponents:

FilteredComponent

hiddenComponents

digestService

)

FilteredComponent

hiddenComponents

)

FilteredComponent(component:

val digestService:

DigestService

class FilteredComponent

Module Contents

nonce

)

val hiddenComponents:

val visibleComponents:

class ContractUpgradeLedgerTransaction :

FilteredComponent

ContractUpgradeLedgerTransaction(inputs:

Module Contents

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

)

val legacyContractAttachment:

)

val upgradedContractAttachment:

data class ContractUpgradeWireTransaction :

ContractUpgradeWireTransaction(serializedComponents:

Module Contents

privacySalt

ContractUpgradeWireTransaction(serializedComponents:

)

privacySalt

digestService

)

fun buildFilteredTransaction():

Module Contents

privacySalt

ContractUpgradeWireTransaction

)

val legacyContractAttachmentId:

sigs

)

val upgradedContractAttachmentId:

abstract class CoreTransaction :

Module Contents

abstract val networkParametersHash:

data class FilteredComponentGroup :

FilteredComponentGroup(groupIndex:

Module Contents

components

nonces

partialMerkleTree

)

class FilteredTransaction :

@JvmStatic fun buildFilteredTransaction(wtx:

Module Contents

filtering

)

fun checkAllComponentsVisible(componentGroupEnum:

ComponentGroupEnum

)

fun checkCommandVisibility(publicKey:

)

fun checkWithFun(checkingFun: (

)

)

val filteredComponentGroups:

class FilteredTransactionVerificationException :

FilteredComponentGroup

FilteredTransactionVerificationException(id:

Module Contents

reason

)

abstract class FullTransaction :

Module Contents

FullTransaction()

protected fun checkNotaryWhitelisted():

class LedgerTransaction :

Module Contents

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

commandsOfType

(

clazz

)

commandsOfType

(

)

operator fun component10():

CommandWithParties

@CordaInternal fun createForContractVerify(inputs:

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

references

digestService

)

)

filterCommands

(

clazz

predicate

)

filterCommands

(

crossinline

predicate

(

)

)

filterInputs

(

clazz

predicate

)

filterInputs

(

crossinline

predicate

(

)

)

filterInRefs

(

clazz

predicate

)

filterInRefs

(

crossinline

predicate

(

)

)

filterReferenceInputRefs

(

clazz

predicate

)

filterReferenceInputRefs

(

crossinline

predicate

(

)

)

filterReferenceInputs

(

clazz

predicate

)

filterReferenceInputs

(

crossinline

predicate

(

)

)

findCommand

(

clazz

predicate

)

findCommand

(

crossinline

predicate

(

)

)

findInput

(

clazz

predicate

)

findInput

(

crossinline

predicate

(

)

)

findInRef

(

clazz

predicate

)

findInRef

(

crossinline

predicate

(

)

)

findReference

(

clazz

predicate

)

findReference

(

crossinline

predicate

(

)

)

findReferenceInputRef

(

clazz

predicate

)

findReferenceInputRef

(

crossinline

predicate

(

)

)

fun getAttachment(index:

)

fun getReferenceInput(index:

fun getAttachment(id:

)

getCommand

(

index

)

)

)

groupStates

(

ofType

selector

(

)

InOutGroup

data class InOutGroup<out T :

groupStates

(

noinline

selector

(

)

InOutGroup

out

Module Contents

outputs

groupingKey

)

inputsOfType

(

clazz

)

inputsOfType

(

)

inRef

(

index

)

inRefsOfType

(

clazz

)

inRefsOfType

(

)

@CordaInternal fun specialise(alternateVerifier: (

referenceInputRefsOfType

(

clazz

)

referenceInputRefsOfType

(

)

referenceInputsOfType

(

clazz

)

referenceInputsOfType

(

)

@CordaInternal fun <T> transform(transformer: (

)

Verifier

)

SerializedStateAndRef

SerializedStateAndRef

)

fun verify():

class MissingContractAttachments :

MissingContractAttachments(states:

Module Contents

contractsClassName

minimumRequiredContractClassVersion

Version

)

data class NetworkParametersHash

Module Contents

NetworkParametersHash(hash:

)

class NotaryChangeLedgerTransaction :

NotaryChangeLedgerTransaction(inputs:

Module Contents

notary

newNotary

sigs

)

notary

newNotary

sigs

)

)

)

data class NotaryChangeWireTransaction :

Module Contents

NotaryChangeWireTransaction(inputs:

)

notary

newNotary

)

digestService

)

Module Contents

)

sigs

)

sigs

)

data class ReferenceStateRef

Module Contents

ReferenceStateRef(stateRef:

)

val stateRef:

data class SignedTransaction :

Module Contents

SignedTransaction(ctx:

sigs

SignedTransaction(txBits:

)

sigs

)

)

)

fun ~~isNotaryChangeTransaction~~():

val ~~notaryChangeTx~~:

operator fun plus(sig:

)

operator fun plus(sigList:

)

fun resolveBaseTransaction(servicesForResolution:

)

fun resolveContractUpgradeTransaction(services:

)

)

)

fun resolveTransactionWithSignatures(services:

)

class SignaturesMissingException :

SignatureException

SignaturesMissingException(missing:

Module Contents

descriptions

)

@JvmOverloads fun toLedgerTransaction(services:

@JvmOverloads fun verify(services:

checkSufficientSignatures

)

checkSufficientSignatures

)

@VisibleForTesting fun withAdditionalSignature(keyPair:

signatureMetadata

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList:

)

open class TransactionBuilder

Module Contents

lockId

inputs

attachments

outputs

commands

window

privacySalt

)

)

fun addAttachment(attachmentId:

lockId

inputs

attachments

outputs

commands

window

privacySalt

references

serviceHub

)

)

)

vararg

keys

)

keys

)

open fun addInputState(stateAndRef:

)

)

contract

notary

encumbrance

constraint

)

contract

constraint

)

constraint

)

open fun addReferenceState(referencedStateAndRef:

protected val attachments:

)

protected val commands:

protected val inputs:

protected val outputs:

protected var privacySalt:

protected val references:

fun referenceStates():

protected val serviceHub:

fun setPrivacySalt(privacySalt:

)

fun setTimeWindow(timeWindow:

)

fun setTimeWindow(time:

timeTolerance

)

)

fun toSignedTransaction(keyManagementService:

publicKey

signatureMetadata

services

)

)

schemeId

)

schemeId

properties

)

)

protected var window:

fun withItems(vararg items:

)

@DoNotImplement interface TransactionWithSignatures :

open fun checkSignaturesAreValid():

Module Contents

abstract fun getKeyDescriptions(keys:

)

open fun getMissingSigners():

abstract val requiredSigningKeys:

open fun verifyRequiredSignatures():

open fun verifySignaturesExcept(vararg allowedToBeMissing:

)

open fun verifySignaturesExcept(allowedToBeMissing:

)

abstract class TraversableTransaction :

Module Contents

)

val availableComponentGroups:

digestService

)

open val componentGroups:

open val networkParametersHash:

class WireTransaction :

Module Contents

)

privacySalt

)

WireTransaction(inputs:

attachments

outputs

commands

notary

timeWindow

privacySalt

)

privacySalt

digestService

)

)

fun checkSignature(sig:

)

@CordaInternal fun ~~createComponentGroups~~(inputs:

outputs

commands

attachments

notary

timeWindow

)

)

@CordaInternal fun resolveStateRefBinaryComponent(stateRef:

services

)

)

fun ~~toLedgerTransaction~~(resolveIdentity: (

)

resolveAttachment

(

)

resolveStateRef

(

)

package net.corda.core.utilities

resolveContractAttachment

(

)

)

Module Contents

sealed class ByteSequence :

Module Contents

open fun compareTo(other:

)

@JvmStatic @JvmOverloads fun of(bytes:

)

offset

size

)

)

end

)

fun subSequence(offset:

size

)

)

)

fun detailedLogger(): Logger

open class Id<out VALUE :

Id(value: VALUE, entityType:

Module Contents

timestamp

)

)

newInstance

(

value

entityType

timestamp

)

java.lang.management.ThreadInfo

Module Contents

ThreadInfo

asString

(

maxFrames

)

Module Contents

toBase58String

(

)

toSHA256Bytes

(

)

Module Contents

fun <V>

getOrThrow

(

timeout

)

Module Contents

contextLogger

(

)

Logger

kotlin.ByteArray

Module Contents

sequence

(

offset

size

)

toBase58

(

)

toBase64

(

)

toHex

(

)

toHexString

(

)

Module Contents

fun <T>

toNonEmptySet

(

)

Module Contents

days

exactAdd

(

)

hours

millis

minutes

seconds

Module Contents

exactAdd

(

)

Module Contents

base58toBase64

(

)

base58ToByteArray

(

)

base58toHex

(

)

base58ToRealString

(

)

base64toBase58

(

)

base64ToByteArray

(

)

base64toHex

(

)

base64ToRealString

(

)

hexToBase58

(

)

hexToBase64

(

)

hexToByteArray

(

)

hexToRealString

(

)

parseAsHex

(

)

const val MAX_HASH_HEX_SIZE:

loggerFor

(

)

Logger

data class NetworkHostAndPort

Module Contents

NetworkHostAndPort(host:

port

)

)

class NonEmptySet<T> :

@JvmStatic fun <T> copyOf(elements:

Module Contents

)

)

)

@JvmStatic fun <T> of(element: T):

@JvmStatic fun <T> of(first: T, second: T, vararg rest: T):

@JvmStatic fun of(vararg b:

fun parallelStream():

open class OpaqueBytes :

Module Contents

)

)

class OpaqueBytesSubSequence :

OpaqueBytesSubSequence(bytes:

Module Contents

offset

size

)

Module Contents

inline fun Logger.debug(msg: () ->

)

inline fun Logger.trace(msg: () ->

)

fun parsePublicKeyBase58(base58String:

)

ProgressTracker(vararg inputSteps: Step)

class ProgressTracker

Module Contents

Step

Module Contents

data class Position : Change

Module Contents

Position(tracker:

data class Rendering : Change

newStep

Step

)

Module Contents

Rendering(tracker:

data class Structural : Change

ofStep

Step

)

Module Contents

Structural(tracker:

val changes: Observable<Change>

parent

Step

)

var currentStep: Step

val currentStepRecursive: Step

Module Contents

)

fun endWithError(error:

)

fun getChildProgressTracker(step: Step):

fun setChildProgressTracker(step: Step, childProgressTracker:

)

open val changes: Observable<Change>

object STARTING : Step

Module Contents

)

Module Contents

)

open fun childProgressTracker():

)

val stepsTreeChanges: Observable<

open val extraAuditData:

Step

val stepsTreeIndexChanges: Observable<

val topLevelTracker:

object UNSTARTED : Step

Module Contents

)

interface PropertyDelegate<out T>

Module Contents

abstract operator fun getValue(thisRef:

property

@JvmStatic val isInsideEnclave:

)

object SgxSupport

Module Contents

fun threadDumpAsString():

fun <T> transient(initializer: () -> T):

PropertyDelegate

sealed class Try<out A>

Module Contents

inline fun <B, C> combine(other:

function

(

)

fun doOnFailure(action:

)

fun doOnSuccess(action:

)

data class Failure<out A> :

Module Contents

)

inline fun flatMap(function: (A) ->

)

abstract fun getOrThrow(): A

abstract val isFailure:

abstract val isSuccess:

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

@JvmStatic inline fun <T> on(body: () -> T):

data class Success<out A> :

Module Contents

class UntrustworthyData<out T>

Module Contents

UntrustworthyData(fromUntrustedWorld: T)

@Suspendable fun <R> unwrap(validator: Validator<T, R>): R

@FunctionalInterface interface Validator<in T, out R> :

@Suspendable abstract fun validate(data: T): R

Module Contents

inline fun <T, R>

interface VariablePropertyDelegate<T> :

unwrap

(

validator

(

)

Module Contents

PropertyDelegate

Module Contents

abstract operator fun setValue(thisRef:

property

value

)

package net.corda.finance

Module Contents

AMOUNT

(

amount

token

)

AMOUNT

(

amount

token

)

AMOUNT

(

amount

token

)

)

)

)

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

)

)

)

fun SWISS_FRANCS(amount:

)

fun SWISS_FRANCS(amount:

)

package net.corda.finance.contracts

fun SWISS_FRANCS(amount:

)

Module Contents

enum class AccrualAdjustment

Module Contents

Adjusted

Unadjusted

interface BilateralNettableState<N :

abstract val bilateralNetState:

Module Contents

abstract fun net(other: N): N

open class BusinessCalendar

Module Contents

BusinessCalendar(holidayDates:

SortedSet

open fun applyRollConvention(testDate:

)

dateRollConvention

DateRollConvention

)

@JvmStatic fun calculateDaysBetween(startDate:

endDate

dcbYear

dcbDay

)

@JvmStatic fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

endDate

periodOffset

)

)

@JvmStatic fun getOffsetDate(startDate:

period

steps

)

open fun isWorkingDay(date:

)

fun moveBusinessDays(date:

direction

)

@JvmStatic fun parseDateFromString(it:

)

)

class CommercialPaper :

Module Contents

Module Contents

Commands

Module Contents

Issue()

class Move :

Commands

Module Contents

Move()

class Redeem :

Commands

Module Contents

Redeem()

const val CP_PROGRAM_ID:

ICommercialPaperState

Module Contents

owner

faceValue

maturityDate

)

)

fun withFaceValue(newFaceValue:

fun withMaturityDate(newMaturityDate:

)

ICommercialPaperState

)

ICommercialPaperState

)

fun withoutOwner(): State

fun withOwner(newOwner:

)

ICommercialPaperState

fun verify(tx:

)

data class Commodity :

TokenizableAssetInfo

Module Contents

Commodity(commodityCode:

displayName

defaultFractionDigits

)

val commodityCode:

val defaultFractionDigits:

val displayName:

fun getInstance(commodityCode:

)

Commodity

const val CP_PROGRAM_ID:

enum class DateRollConvention

Module Contents

enum class DateRollDirection

Module Contents

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

interface FixableDealState :

data class Expression

Module Contents

)

Module Contents

value

)

abstract fun generateFix(ptx:

Module Contents

oldState

fix

)

abstract fun nextFixingOf():

Module Contents

forDay

ofTenor

)

Module Contents

val annualCompoundCount:

(

)

interface MultilateralNettableState<out T :

abstract val multilateralNetState: T

Module Contents

interface NetCommand :

interface NettableState<N :

Module Contents

abstract val type:

NetType

out

MultilateralNettableState

enum class NetType

Module Contents

CLOSE_OUT

PAYMENT

enum class PaymentRule

Module Contents

Module Contents

)

fun daysToMaturity(startDate:

calendar

)

Module Contents

package net.corda.finance.contracts.asset

Module Contents

State

(

dueBefore

)

State

State

between

(

parties

data class BilateralNetState<P :

)

State

BilateralNetState(partyKeys:

Module Contents

template

Terms

)

Commands

State

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

fun deriveState(txState:

fun extractCommands(commands:

State

amount

owner

)

State

)

Commands

fun generateExitCommand(amount:

)

Exit

tokenDef

pennies

owner

notary

)

fun generateMoveCommand(): Move

amount

owner

notary

)

Module Contents

amount

owner

)

owner

)

)

infix fun issuedBy(party:

infix fun issuedBy(deposit:

)

State

)

State

infix fun ownedBy(owner:

)

State

infix fun withDeposit(deposit:

)

State

)

newOwner

)

)

CASH

State

fun <P :

extractAmountsDue

(

product

Terms

states

State

)

Terms

State

issued by

(

party

)

State

State

issuedBy

(

party

data class MultilateralNetState<P :

)

State

MultilateralNetState(template: Terms)

Module Contents

netAmountsDue

(

balances

)

interface NetState<P :

abstract val template: Terms

Module Contents

Module Contents

Module Contents

Module Contents

Terms

)

Terms

Module Contents

Module Contents

out

)

out

Module Contents

)

data class SetLifecycle :

SetLifecycle(lifecycle: Lifecycle)

Module Contents

val inverse: Lifecycle

val lifecycle: Lifecycle

data class Settle<P :

Module Contents

Terms

)

Terms

Module Contents

State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor:

Terms

State

Module Contents

val multilateralNetState:

template

Terms

quantity

beneficiary

)

Terms

val bilateralNetState:

var lifecycle: Lifecycle

MultilateralNetState

fun net(other: State): State

)

Terms

newOwner

)

State

data class Terms<P :

Terms(acceptableContracts:

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

)

abstract class OnLedgerAsset<T :

out

Module Contents

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands:

)

fun ~~generateExit~~(tx:

amountIssued

assetStates

)

amountIssued

assetStates

payChangeTo

)

~~generateExit~~

(

amountIssued

assetStates

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

generateExit

(

amountIssued

assetStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

abstract fun generateExitCommand(amount:

generateExitCommand

(

)

)

)

generateIssue

(

transactionState

issueCommand

)

abstract fun generateMoveCommand():

generateSpend

(

amount

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

generateSpend

(

payments

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

State

owned by

(

owner

)

State

State

ownedBy

(

owner

data class PartyAndAmount<T :

)

State

Module Contents

PartyAndAmount(party:

amount

)

STATE

State

fun <P :

package net.corda.finance.contracts.utils

sumAmountsDue

(

balances

)

Module Contents

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

sumObligations

(

)

Terms

sumObligationsOrNull

(

)

Terms

sumObligationsOrZero

(

issuanceDef

Terms

)

package net.corda.finance.flows

Terms

Module Contents

abstract class AbstractCashFlow<out T> :

AbstractCashFlow(progressTracker:

Module Contents

abstract class AbstractRequest

)

Module Contents

AbstractRequest(amount:

)

@Suspendable protected fun finaliseTx(tx:

sessions

message

)

object FINALISING_TX : Step

object GENERATING_TX : Step

Module Contents

recipient

)

object SIGNING_TX : Step

class CashException :

Module Contents

CashException(message:

cause

@InitiatingFlow @StartableByRPC class CashExitFlow :

)

CashExitFlow(request: ExitRequest)

Result

Module Contents

issuerRef

)

issuerRef

progressTracker

)

class ExitRequest : AbstractRequest

Module Contents

issuerRef

)

@InitiatedBy(NormalClass(value=net/corda/finance/flows/CashExitFlow)) class CashExitResponderFlow :

CashExitResponderFlow(otherSide:

Module Contents

)

@StartableByRPC class CashIssueAndPaymentFlow :

Result

Module Contents

CashIssueAndPaymentFlow(request: IssueAndPaymentRequest)

issueRef

recipient

anonymous

notary

)

issueRef

recipient

anonymous

notary

progressTracker

)

class IssueAndPaymentRequest : AbstractRequest

Module Contents

IssueAndPaymentRequest(amount:

issueRef

recipient

notary

anonymous

)

val ISSUING_CASH: Step

val PAYING_RECIPIENT: Step

@StartableByRPC class CashIssueFlow :

Result

Module Contents

CashIssueFlow(request: IssueRequest)

issuerBankPartyRef

notary

)

issuerBankPartyRef

notary

progressTracker

)

class IssueRequest : AbstractRequest

Module Contents

issueRef

notary

)

@StartableByRPC @InitiatingFlow open class CashPaymentFlow :

Result

Module Contents

recipient

)

recipient

anonymous

)

CashPaymentFlow(request: PaymentRequest)

recipient

anonymous

notary

)

@Suspendable open fun call(): Result

recipient

anonymous

progressTracker

issuerConstraint

notary

)

class PaymentRequest : AbstractRequest

Module Contents

PaymentRequest(amount:

recipient

anonymous

issuerConstraint

notary

)

@InitiatedBy(NormalClass(value=net/corda/finance/flows/CashPaymentFlow)) class CashPaymentReceiverFlow :

CashPaymentReceiverFlow(otherSide:

Module Contents

)

class Acceptor : Secondary<AutoOffer>

object TwoPartyDealFlow

Module Contents

Module Contents

Acceptor(otherSideSession:

progressTracker

protected open fun assembleSharedTX(handshake: Handshake<AutoOffer>):

)

protected open fun validateHandshake(handshake: Handshake<AutoOffer>): Handshake<AutoOffer>

Module Contents

dealBeingOffered

)

val dealBeingOffered:

data class Handshake<out T>

Module Contents

Handshake(payload: T, primaryIdentity:

secondaryIdentity

)

val secondaryIdentity:

class Instigator : Primary

Module Contents

Instigator(otherSideSession:

payload

AutoOffer

progressTracker

@Suspendable open fun checkProposal(stx:

)

)

open val notaryParty:

open val payload: AutoOffer

abstract class Primary :

Module Contents

Primary(progressTracker:

)

@Suspendable abstract fun checkProposal(stx:

)

abstract val notaryParty:

abstract val payload:

object SENDING_PROPOSAL : Step

abstract class Secondary :

Secondary(progressTracker:

Module Contents

@Suspendable protected abstract fun assembleSharedTX(handshake: Handshake):

)

@Suspendable protected abstract fun validateHandshake(handshake: Handshake): Handshake

class AssetMismatchException :

object TwoPartyTradeFlow

Module Contents

AssetMismatchException(expectedTypeName:

Module Contents

typeName

)

val expectedTypeName:

Module Contents

Buyer(otherSideSession:

notary

acceptablePrice

typeToBuy

out

)

notary

acceptablePrice

typeToBuy

out

anonymous

)

Module Contents

Module Contents

cashSigningPubKeys

)

val cashSigningPubKeys:

class Seller :

object AWAITING_PROPOSAL : Step

Module Contents

Seller(otherSideSession:

assetToSell

price

myParty

progressTracker

)

object VERIFYING_AND_SIGNING : Step

Module Contents

data class SellerTradeInfo

Module Contents

SellerTradeInfo(price:

payToIdentity

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

package net.corda.finance.schemas

)

Module Contents

object CashSchema

object CashSchemaV1 :

Module Contents

PersistentCashState(owner:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object CommercialPaperSchema

object CommercialPaperSchemaV1 :

Module Contents

@Entity class PersistentCommercialPaperState :

PersistentCommercialPaperState(issuancePartyHash:

Module Contents

issuanceRef

ownerHash

maturity

faceValue

currency

faceValueIssuerPartyHash

faceValueIssuerRef

)

var faceValueIssuerPartyHash:

var faceValueIssuerRef:

package net.corda.finance.test

var issuancePartyHash:

Module Contents

object CashSchema

object SampleCashSchemaV1 :

Module Contents

PersistentCashState(ownerHash:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object SampleCashSchemaV2 :

@Entity class PersistentCashState : FungibleState

Module Contents

Module Contents

PersistentCashState(currency:

participants

owner

quantity

issuerParty

issuerRef

)

object SampleCashSchemaV3 :

Module Contents

PersistentCashState(participants:

Module Contents

owner

pennies

currency

issuer

issuerRef

)

package net.corda.finance.workflows

Module Contents

object CommercialPaperUtils

Module Contents

@JvmStatic fun generateIssue(issuance:

faceValue

maturityDate

notary

)

@JvmStatic fun generateMove(tx:

paper

State

newOwner

)

@JvmStatic @Suspendable fun generateRedeem(tx:

paper

package net.corda.finance.workflows.asset

State

services

ourIdentity

)

getCashBalance

(

currency

)

getCashBalance

(

currency

)

getCashBalances

(

)

getCashBalances

(

)

Module Contents

object CashUtils

Module Contents

@JvmStatic @Suspendable fun ~~generateSpend~~(services:

amount

onlyFromParties

)

@JvmStatic @JvmOverloads @Suspendable fun generateSpend(services:

amount

ourIdentity

onlyFromParties

anonymous

)

@JvmStatic @Suspendable fun ~~generateSpend~~(services:

payments

onlyFromParties

)

@JvmStatic @JvmOverloads @Suspendable fun generateSpend(services:

payments

ourIdentity

onlyFromParties

anonymous

)

object ObligationUtils

Module Contents

@JvmStatic fun generateCashIssue(tx:

obligor

acceptableContract

amount

dueBefore

beneficiary

notary

)

generateCloseOutNetting

(

signer

vararg

inputs

State

)

generateExit

(

amountIssued

Terms

assetStates

State

)

generateIssue

(

obligor

issuanceDef

Terms

pennies

beneficiary

notary

)

generatePaymentNetting

(

issued

Terms

notary

vararg

inputs

State

)

generateSetLifecycle

(

statesAndRefs

State

lifecycle

Lifecycle

notary

)

generateSettle

(

statesAndRefs

package net.corda.finance.workflows.asset.selection

State

assetStatesAndRefs

moveCommand

notary

)

Module Contents

abstract class AbstractCashSelection

Module Contents

AbstractCashSelection(maxRetries:

retrySleep

retryCap

protected abstract fun executeQuery(connection:

)

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

fun getInstance(metadata: () ->

)

val instance:

AtomicReference

protected abstract fun isCompatible(metadata:

)

abstract fun toString():

@Suspendable fun unconsumedCashStatesForSpending(services:

amount

class CashSelectionH2Impl :

onlyFromIssuerParties

notary

lockId

withIssuerRefs

)

State

Module Contents

CashSelectionH2Impl()

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

class CashSelectionPostgreSQLImpl :

CashSelectionPostgreSQLImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

class CashSelectionSQLServerImpl :

CashSelectionSQLServerImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

val JDBC_DRIVER_NAME_REGEX:

Regex

package net.corda.finance.workflows.utils

Module Contents

fun loadTestCalendar(name:

)

BusinessCalendar

val TEST_CALENDAR_NAMES:

class UnknownCalendar :

Module Contents

UnknownCalendar(name:

package net.corda.testing.driver

)

Module Contents

fun <A> driver(defaultParameters:

@DoNotImplement interface DriverDSL

dsl

DriverDSL

(

)

Module Contents

abstract fun baseDirectory(nodeName:

)

open val defaultNotaryHandle:

open val defaultNotaryIdentity:

open val defaultNotaryNode:

abstract val notaryHandles:

open fun startNode():

abstract fun startNode(parameters:

)

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

logLevelOverride

)

open fun startWebserver(handle:

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

)

abstract fun startWebserver(handle:

WebserverHandle

maximumHeapSize

)

data class DriverParameters

Module Contents

DriverParameters(cordappsForAllNodes:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

notaryHandleTimeout

val allowHibernateToManageAppSchema:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

)

val debugPortAllocation:

val driverDirectory:

val environmentVariables:

val ~~extraCordappPackagesToScan~~:

val notaryCustomOverrides:

val premigrateH2Database:

val notaryHandleTimeout:

val startNodesInProcess:

val waitForAllNodesToFinish:

fun withAllowHibernateToManageAppSchema(value:

)

)

fun withDebugPortAllocation(debugPortAllocation:

)

fun withDriverDirectory(driverDirectory:

)

fun withEnvironmentVariables(variables:

)

fun ~~withExtraCordappPackagesToScan~~(extraCordappPackagesToScan:

)

fun withInMemoryDB(inMemoryDB:

)

fun withIsDebug(isDebug:

)

fun withJmxPolicy(jmxPolicy:

)

)

fun withNotaryCustomOverrides(notaryCustomOverrides:

)

fun withNotaryHandleTimeout(value:

)

)

fun withPortAllocation(portAllocation:

)

fun withStartNodesInProcess(startNodesInProcess:

)

fun withSystemProperties(systemProperties:

)

fun withUseTestClock(useTestClock:

)

fun withWaitForAllNodesToFinish(waitForAllNodesToFinish:

)

@DoNotImplement interface InProcess :

Module Contents

registerInitiatedFlow

(

initiatedFlowClass

)

Observable

open fun <T> startFlow(logic:

)

Module Contents

JmxPolicy(jmxHttpServerPortAllocation:

JmxPolicy(startJmxHttpServer:

)

jmxHttpServerPortAllocation

@JvmStatic fun defaultEnabled():

)

val jmxHttpServerPortAllocation:

val startJmxHttpServer:

@DoNotImplement interface NodeHandle :

logFile

(

)

File

abstract val baseDirectory:

Module Contents

abstract val jmxAddress:

abstract val nodeInfo:

abstract val p2pAddress:

abstract val rpc:

abstract val rpcAddress:

abstract val rpcAdminAddress:

data class NodeParameters

abstract val rpcUsers:

Module Contents

NodeParameters()

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

systemProperties

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

out

out

out

val logLevelOverride:

val startInSameProcess:

)

fun withCustomOverrides(customOverrides:

)

fun withFlowOverrides(flowOverrides:

out

out

)

fun withLogLevelOverride(logLevelOverride:

)

fun withMaximumHeapSize(maximumHeapSize:

)

fun withProvidedName(providedName:

)

fun withRpcUsers(rpcUsers:

User

)

fun withStartInSameProcess(startInSameProcess:

)

fun withVerifierType(verifierType:

VerifierType

)

@DoNotImplement interface OutOfProcess :

data class NotaryHandle

Module Contents

NotaryHandle(identity:

validating

nodeHandles

)

@DoNotImplement abstract class PortAllocation

Module Contents

abstract val process:

Process

Module Contents

PortAllocation()

const val DEFAULT_START_PORT:

@JvmStatic val defaultAllocator:

const val FIRST_EPHEMERAL_PORT:

@DoNotImplement open class ~~Incremental~~ :

Incremental(startingPort:

Module Contents

)

open fun ~~nextPort~~():

val ~~portCounter~~:

AtomicInteger

fun nextHostAndPort():

abstract fun nextPort():

WebserverHandle(listenAddress:

enum class VerifierType

Module Contents

InMemory

data class ~~WebserverHandle~~

Module Contents

process

)

package net.corda.testing.dsl

Module Contents

AttachmentResolutionException(attachmentId:

Module Contents

class DoubleSpentInputs :

)

Module Contents

DoubleSpentInputs(ids:

class DuplicateOutputLabel :

)

DuplicateOutputLabel(label:

Module Contents

@DoNotImplement sealed class EnforceVerifyOrFail

)

class LedgerDSL<out T :

out

LedgerDSL(interpreter: L, notary:

Module Contents

)

output

(

)

fun <reified S :

outputStateAndRef

(

)

fun <S :

retrieveOutput

(

clazz

label

@JvmOverloads fun transaction(label:

)

transactionBuilder

dsl

(

)

)

(

)

)

@JvmOverloads fun unverifiedTransaction(label:

transactionBuilder

dsl

(

)

)

@DoNotImplement interface LedgerDSLInterpreter<out T :

abstract fun _transaction(transactionLabel:

Module Contents

transactionBuilder

dsl

(

)

)

(

)

)

abstract fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

abstract fun attachment(attachment:

)

@DoNotImplement interface OutputStateLookup

Module Contents

abstract fun <S :

retrieveOutputStateAndRef

(

clazz

label

)

data class TestLedgerDSLInterpreter :

TestLedgerDSLInterpreter(services:

Module Contents

fun _transaction(transactionLabel:

)

transactionBuilder

dsl

(

)

)

(

)

)

fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

fun attachment(attachment:

)

fun transactionName(transactionHash:

fun outputToLabel(state:

)

retrieveOutputStateAndRef

(

clazz

label

)

)

val transactionsToVerify:

val transactionsUnverified:

Module Contents

TypeMismatch(requested:

actual

)

class VerifiesFailed :

VerifiesFailed(transactionName:

Module Contents

cause

)

val wireTransactions:

data class TestTransactionDSLInterpreter :

TestTransactionDSLInterpreter(ledgerInterpreter:

Module Contents

transactionBuilder

)

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

fun attachment(attachmentId:

)

commandData

)

)

val ledgerInterpreter:

label

notary

encumbrance

attachmentConstraint

contractState

)

fun reference(stateRef:

)

fun timeWindow(data:

)

val transactionBuilder:

fun verifies():

class TransactionDSL<out T :

TransactionDSL(interpreter: T, notary:

Module Contents

)

)

attachmentId

signers

jarManifestAttributes

)

attachmentId

)

fun attachments(vararg contractClassNames:

)

commandData

)

fun input(stateLabel:

)

stateLabel

)

state

)

label

notary

contractState

)

label

encumbrance

contractState

)

label

contractState

)

notary

contractState

)

encumbrance

contractState

)

contractState

)

fun reference(stateLabel:

)

fun reference(contractClassName:

state

)

@JvmOverloads fun timeWindow(time:

tolerance

)

(

)

)

@DoNotImplement interface TransactionDSLInterpreter :

Module Contents

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

abstract fun attachment(attachmentId:

)

abstract fun command(signers:

commandData

)

abstract fun input(stateRef:

)

abstract val ledgerInterpreter:

abstract fun output(contractClassName:

label

notary

encumbrance

attachmentConstraint

contractState

)

abstract fun reference(stateRef:

)

abstract fun timeWindow(data:

)

@DoNotImplement interface Verifies

Module Contents

open fun fails():

open infix fun fails with(msg:

)

open fun failsWith(expectedMessage:

)

abstract fun verifies():

package net.corda.testing.flows

Module Contents

out

from

(

session

)

kotlin.collections.Map

Module Contents

from

(

session

)

kotlin.reflect.KClass

Module Contents

net.corda.testing.node.internal.TestStartedNode

from

(

session

)

Module Contents

inline fun <reified P :

TestStartedNode

registerCordappFlowFactory

(

initiatingFlowClass

out

initiatedFlowVersion

noinline

flowFactory

(

)

TestStartedNode

registerCoreFlowFactory

(

initiatingFlowClass

out

initiatedFlowClass

flowFactory

(

)

track

)

Observable

@Suspendable fun

receiveAll

(

session

out

vararg

sessions

out

)

receiveAll

(

receiveType

session

vararg

sessions

)

receiveAll

(

session

vararg

sessions

)

fun waitForAllFlowsToComplete(nodeHandle:

maxIterations

iterationDelay

)

package net.corda.testing.http

Module Contents

class HttpApi

Module Contents

HttpApi(root:

fun fromHostAndPort(hostAndPort:

mapper

ObjectMapper

)

base

protocol

mapper

ObjectMapper

)

HttpApi

getJson

(

path

params

val defaultMapper: ObjectMapper

)

val mapper: ObjectMapper

data

)

data

)

data

)

Module Contents

getJson

(

url

params

package net.corda.testing.node

mapper

ObjectMapper

)

data

)

data

)

data

)

Module Contents

@DoNotImplement abstract class ClusterSpec

Module Contents

ClusterSpec()

abstract val clusterSize:

Module Contents

)

createMockCordaService

(

serviceHub

fun copyDatabaseSnapshot(baseDirectory:

serviceConstructor

(

AppServiceHub

)

object DatabaseSnapshot

Module Contents

)

fun databaseFilename(baseDirectory:

)

@ThreadSafe class InMemoryMessagingNetwork :

data class DistributedServiceHandle :

Module Contents

MessageRecipientGroup

Module Contents

DistributedServiceHandle(party:

)

val endpointsExternal:

interface LatencyCalculator

MockMessagingService

Module Contents

abstract fun between(sender:

receiver

)

class MessageTransfer

Module Contents

val sender: PeerHandle

class MockMessagingService

Module Contents

)

MessageTransfer

data class PeerHandle :

val receivedMessages: Observable<MessageTransfer>

Module Contents

name

)

)

)

MessageTransfer

val sentMessages: Observable<MessageTransfer>

@DoNotImplement sealed class ServicePeerAllocationStrategy

Module Contents

abstract fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

class Random : ServicePeerAllocationStrategy

)

Module Contents

Random(random:

fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

)

)

val random:

class RoundRobin : ServicePeerAllocationStrategy

Module Contents

RoundRobin()

fun <A> pickNext(service: DistributedServiceHandle, pickFrom:

)

ledger

(

notary

script

LedgerDSL

(

)

)

LedgerDSL

fun makeTestIdentityService(vararg identities:

)

MockNetFlowTimeOut(timeout:

class MockNetFlowTimeOut

Module Contents

maxRestartCount

backoffBase

)

class MockNetNotaryConfig

Module Contents

MockNetNotaryConfig(validating:

extraConfig

Config

className

serviceLegalName

)

val extraConfig: Config?

val serviceLegalName:

val validating:

open class MockNetwork

Module Contents

parameters

)

MockNetwork(parameters:

)

defaultParameters

networkSendManuallyPumped

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

fun baseDirectory(nodeId:

)

)

val ~~cordappPackages~~:

fun createNode(parameters:

)

@JvmOverloads fun createNode(legalName:

forcedID

entropyRoot

configOverrides

)

fun createPartyNode(legalName:

)

fun createUnstartedNode(parameters:

)

@JvmOverloads fun createUnstartedNode(legalName:

forcedID

entropyRoot

configOverrides

)

val defaultNotaryIdentity:

val defaultNotaryNode:

val defaultParameters:

@JvmOverloads fun runNetwork(rounds:

)

val servicePeerAllocationStrategy: ServicePeerAllocationStrategy

data class MockNetworkNotarySpec

Module Contents

validating

className

)

data class MockNetworkParameters

validating

)

Module Contents

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

MockNetworkParameters(cordappsForAllNodes:

)

)

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

cordappsForAllNodes

fun copy(networkSendManuallyPumped:

)

threadPerNode

servicePeerAllocationStrategy

ServicePeerAllocationStrategy

notarySpecs

networkParameters

)

val notarySpecs:

val servicePeerAllocationStrategy: ServicePeerAllocationStrategy

val threadPerNode:

)

)

fun withNetworkSendManuallyPumped(networkSendManuallyPumped:

)

)

fun withServicePeerAllocationStrategy(servicePeerAllocationStrategy: ServicePeerAllocationStrategy):

fun withThreadPerNode(threadPerNode:

)

class MockNodeConfigOverrides

Module Contents

MockNodeConfigOverrides(extraDataSourceProperties:

notary

flowTimeout

)

val extraDataSourceProperties:

data class MockNodeParameters

Module Contents

legalName

entropyRoot

configOverrides

)

legalName

entropyRoot

configOverrides

additionalCordapps

)

val configOverrides:

legalName

entropyRoot

configOverrides

)

)

fun withConfigOverrides(configOverrides:

)

fun withEntropyRoot(entropyRoot:

)

fun withForcedID(forcedID:

)

fun withLegalName(legalName:

)

open class MockServices :

Module Contents

initialIdentity

identityService

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

keyManagementService

)

initialIdentityName

identityService

key

vararg

moreKeys

)

initialIdentityName

identityService

)

)

identityService

key

vararg

moreKeys

)

identityService

)

initialIdentityName

identityService

networkParameters

)

MockServices(firstIdentity: <ERROR CLASS>, vararg moreIdentities: <ERROR CLASS>)

initialIdentityName

identityService

networkParameters

key

)

MockServices(firstIdentity: <ERROR CLASS>, networkParameters:

vararg

moreIdentities

)

firstIdentity

vararg

moreIdentities

)

firstIdentity

networkParameters

fun addMockCordapp(contractClassName:

vararg

moreIdentities

)

MockServices()

)

open val contractUpgradeService:

val attachments:

MockAttachmentStorage

open val clock:

TestClock

val cordappClassloader:

open val cordappProvider:

cordaService

(

type

open fun <T : TelemetryComponent> cordaTelemetryComponent(type:

)

open val diagnosticsService:

)

open val identityService:

open fun jdbcSession():

open val keyManagementService:

open fun loadContractAttachment(stateRef:

)

open fun loadState(stateRef:

)

open fun loadStates(stateRefs:

)

@JvmStatic @JvmOverloads fun makeTestDatabaseAndMockServices(cordappPackages:

identityService

initialIdentity

networkParameters

vararg

moreKeys

)

CordaPersistence

@JvmStatic @JvmOverloads fun makeTestDatabaseAndPersistentServices(cordappPackages:

initialIdentity

networkParameters

moreKeys

moreIdentities

cacheFactory

TestingNamedCacheFactory

)

CordaPersistence

@JvmStatic fun makeTestDataSourceProperties(nodeName:

)

open val networkMapCache:

open val networkParameters:

open var networkParametersService:

open fun recordTransactions(statesToRecord:

txs

)

@VisibleForTesting fun recordTransactions(txn:

disableSignatureVerification

)

@VisibleForTesting fun recordTransactions(txs:

disableSignatureVerification

)

open fun registerUnloadHandler(runOnStop: () ->

protected val servicesForResolution:

)

Nothing

open val telemetryService: TelemetryServiceImpl

open val validatedTransactions:

open val vaultService:

open fun <T> withEntityManager(block: EntityManager.() -> T): T

open fun withEntityManager(block:

EntityManager

)

data class NotarySpec

Module Contents

validating

rpcUsers

verifierType

cluster

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

startInProcess

)

validating

rpcUsers

verifierType

cluster

startInProcess

)

validating

rpcUsers

verifierType

cluster

)

class StartedMockNode

Module Contents

findStateMachines

(

flowClass

)

)

MessageTransfer

registerInitiatedFlow

(

initiatedFlowClass

)

Observable

registerInitiatedFlow

(

initiatingFlowClass

out

initiatedFlowClass

)

Observable

fun <T> transaction(statement: () -> T): T

fun <T> startFlow(logic:

)

fun testActor(owningLegalIdentity:

@ThreadSafe class TestClock : MutableClock

)

Actor

Module Contents

TestClock(delegateClock:

@Synchronized fun advanceBy(duration:

)

)

@Synchronized fun setTo(newInstant:

)

fun testContext(owningLegalIdentity:

)

@DoNotImplement abstract class TestCordapp

Module Contents

@JvmStatic fun findCordapp(scanPackage:

)

abstract fun withConfig(config:

)

transaction

(

notary

script

(

)

)

LedgerDSL

package net.corda.testing.services

class UnstartedMockNode

Module Contents

installCordaService

(

serviceClass

)

Module Contents

password

permissions

)

Module Contents

class MockAttachmentStorage :

fun getAttachmentIdAndBytes(jar:

Module Contents

MockAttachmentStorage()

)

fun getLatestContractAttachments(contractClassName:

minContractVersion

)

fun hasAttachment(attachmentId:

)

)

@JvmOverloads fun importContractAttachment(contractClassNames:

uploader

filename

)

uploader

jar

attachmentId

signers

)

fun importContractAttachment(attachmentId:

contractAttachment

ContractAttachment

)

fun importOrGetAttachment(jar:

)

fun openAttachment(id:

)

fun queryAttachments(criteria:

sorting

)