corda
Module Contents
alltypes
Module Contents
class ANSIProgressObserver
object ANSIProgressRenderer
@Path("") interface APIServer
class APIServerImpl : APIServer
abstract class AbstractCashFlow : FlowLogic<SignedTransaction>
abstract class AbstractConserveAmount<S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
Module Contents
AbstractConserveAmount()
fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, CompositeKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData, generateExitCommand: (Amount<Issued<T>>) -> CommandData): CompositeKey
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
abstract class AbstractIssue<in S : ContractState, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
abstract class AbstractJDBCHashMap<K : Any, V : Any, out T : JDBCHashedTable> : MutableMap<K, V>, AbstractMap<K, V>
Module Contents
AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false, maxBuckets: Int = DEFAULT_MAX_BUCKETS)
protected abstract fun addKeyToInsert(insert: InsertStatement, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
protected abstract fun addValueToInsert(insert: InsertStatement, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
open fun clear(): Unit
open fun containsKey(key: K): Boolean
open fun containsValue(value: V): Boolean
open val entries: MutableSet<MutableEntry<K, V>>
open fun get(key: K): V?
open fun isEmpty(): Boolean
protected abstract fun keyFromRow(row: ResultRow): K
open val keys: MutableSet<K>
val loadOnInit: Boolean
protected val log: Logger
val maxBuckets: Int
open fun put(key: K, value: V): V?
open fun remove(key: K): V?
open val size: Int
val table: T
protected abstract fun valueFromRow(row: ResultRow): V
open val values: MutableCollection<V>
abstract class AbstractJDBCHashSet<K : Any, out T : JDBCHashedTable> : MutableSet<K>, AbstractSet<K>
@ThreadSafe abstract class AbstractNetworkMapService : NetworkMapService, AbstractNodeService
abstract class AbstractNode : SingletonSerializeAsToken
@ThreadSafe abstract class AbstractNodeService : SingletonSerializeAsToken
abstract class AbstractParty
abstract class AbstractStateReplacementFlow
interface AcceptsFileUpload : FileUploader
enum class AccrualAdjustment
object Ack : DeserializeAsKotlinObjectDef
enum class AddOrRemove
interface AffinityExecutor : Executor
class AggregatedList<A, E : Any, K : Any> : TransformationList<A, E>
class AllComposition<S : ContractState, C : CommandData, K : Any> : AllOf<S, C, K>
open class AllOf<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
AllOf(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
open val clauses: ArrayList<Clause<S, C, K>>
open fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
interface AllPossibleRecipients : MessageRecipients
data class Amount<T> : Comparable<Amount<T>>
object AmountBindings
class AmountGenerator<T> : Generator<Amount<T>>
class AnonymousParty : AbstractParty
class AnonymousPartyGenerator : Generator<AnonymousParty>
class AnyComposition<in S : ContractState, C : CommandData, in K : Any> : AnyOf<S, C, K>
open class AnyOf<in S : ContractState, C : CommandData, in K : Any> : CompositeClause<S, C, K>
Module Contents
AnyOf(vararg rawClauses: Clause<S, C, K>)
open val clauses: List<Clause<S, C, K>>
open fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class ApiUtils
data class AppContext
class ArgsParser
abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
@ThreadSafe class ArtemisMessagingServer : ArtemisMessagingComponent
class AssociatedList<K, out A, B> : ReadOnlyBackedObservableMapBase<K, B, Unit>
interface Attachment : NamedByHash
class AttachmentDownloadServlet : HttpServlet
class AttachmentResolutionException : FlowException
interface AttachmentStorage
class AttachmentsClassLoader : SecureClassLoader
data class AuthenticatedObject<out T : Any>
class BFTSmartClient<K : Any, V : Any>
class BFTSmartServer<K : Any, V : Any> : DefaultRecoverable
class BFTSmartUniquenessProvider : UniquenessProvider
class BFTValidatingNotaryService : NotaryService
abstract class BaseTransaction : NamedByHash
data class BilateralNetState<P> : NetState<P>
interface BilateralNettableState<N : BilateralNettableState<N>>
class BroadcastTransactionFlow : FlowLogic<Unit>
open class BusinessCalendar
Module Contents
val TEST_CALENDAR_DATA: Map<String, String>
class UnknownCalendar : Exception
open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
val calendars: List<String>
fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = getInstance(), dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate>
open fun equals(other: Any?): Boolean
fun getInstance(vararg calname: String): BusinessCalendar
fun getOffsetDate(startDate: LocalDate, period: Frequency, steps: Int = 1): LocalDate
open fun hashCode(): Int
val holidayDates: List<LocalDate>
open fun isWorkingDay(date: LocalDate): Boolean
fun moveBusinessDays(date: LocalDate, direction: DateRollDirection, i: Int): LocalDate
fun parseDateFromString(it: String): LocalDate
class Cash : OnLedgerAsset<Currency, Commands, State>
Module Contents
Cash()
interface Clauses
interface Commands : Commands
data class State : FungibleAsset<Currency>, QueryableState
val conserveClause: AbstractConserveAmount<State, Commands, Currency>
fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: CompositeKey): TransactionState<State>
fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): List<AuthenticatedObject<Commands>>
fun generateExitCommand(amount: Amount<Issued<Currency>>): Exit
fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Currency>, pennies: Long, owner: CompositeKey, notary: Party): Unit
fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Currency>>, owner: CompositeKey, notary: Party): Unit
fun generateIssueCommand(): Issue
fun generateMoveCommand(): Move
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
class CashBalanceAsMetricsObserver
class CashException : FlowException
class CashExitFlow : AbstractCashFlow
sealed class CashFlowCommand
class CashIssueFlow : AbstractCashFlow
open class CashPaymentFlow : AbstractCashFlow
object CashSchema
object CashSchemaV1 : MappedSchema
class CertificateRequestException : Exception
class CertificateStream
class Checkpoint
interface CheckpointStorage
class ChosenList<E> : ObservableListBase<E>
object CityDatabase
object ClassSerializer : Serializer<Class<*>>
abstract class Clause<in S : ContractState, C : CommandData, in K : Any>
data class ClientRPCRequestMessage
data class CmdLineOptions
data class Command
interface CommandData
class CommandDataGenerator : Generator<CommandData>
class CommandGenerator : Generator<Command>
class CommercialPaper : Contract
class CommercialPaperLegacy : Contract
object CommercialPaperSchema
object CommercialPaperSchemaV1 : MappedSchema
data class Commodity
class CommodityContract : OnLedgerAsset<Commodity, Commands, State>
Module Contents
CommodityContract()
interface Clauses
interface Commands : Commands
data class State : FungibleAsset<Commodity>
val conserveClause: AbstractConserveAmount<State, Commands, Commodity>
fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: CompositeKey): TransactionState<State>
fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): List<AuthenticatedObject<Commands>>
fun generateExitCommand(amount: Amount<Issued<Commodity>>): Exit
fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Commodity>, pennies: Long, owner: CompositeKey, notary: Party): Unit
fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: CompositeKey, notary: Party): Unit
fun generateIssueCommand(): Issue
fun generateMoveCommand(): Move
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
abstract class CompositeClause<in S : ContractState, C : CommandData, in K : Any> : Clause<S, C, K>
sealed class CompositeKey
object CompositeKeyColumnType : ColumnType
class CompositeKeyGenerator : Generator<CompositeKey>
@ThreadSafe object CompositeKeyLeafSerializer : Serializer<Leaf>
@ThreadSafe object CompositeKeyNodeSerializer : Serializer<Node>
class ConcatenatedList<A> : TransformationList<A, ObservableList<A>>
object ConfigHelper
Module Contents
fun loadConfig(baseDirectory: Path, configFile: Path = baseDirectory / "node.conf", allowMissingConfig: Boolean = false, configOverrides: Map<String, Any?> = emptyMap()): Config
class ConfigurationException : Exception
interface Contract
interface ContractState
class ContractStateGenerator : Generator<ContractState>
class ContractStateModel
object ContractUpgradeFlow
abstract class CordaPluginRegistry
Module Contents
CordaPluginRegistry(webApis: List<Function<CordaRPCOps, out Any>> = emptyList(), staticServeDirs: Map<String, String> = emptyMap(), requiredFlows: Map<String, Set<String>> = emptyMap(), servicePlugins: List<Function<PluginServiceHub, out Any>> = emptyList())
open fun registerRPCKryoTypes(kryo: Kryo): Boolean
open val requiredFlows: Map<String, Set<String>>
open val servicePlugins: List<Function<PluginServiceHub, out Any>>
open val staticServeDirs: Map<String, String>
open val webApis: List<Function<CordaRPCOps, out Any>>
@ThreadSafe class CordaRPCClient : Closeable, ArtemisMessagingComponent
class CordaRPCClientImpl
interface CordaRPCOps : RPCOps
Module Contents
abstract fun addVaultTransactionNote(txnId: SecureHash, txnNote: String): Unit
abstract fun attachmentExists(id: SecureHash): Boolean
abstract fun authoriseContractUpgrade(state: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
abstract fun currentNodeTime(): Instant
abstract fun deauthoriseContractUpgrade(state: StateAndRef<*>): Unit
abstract fun getVaultTransactionNotes(txnId: SecureHash): Iterable<String>
@RPCReturnsObservables abstract fun networkMapUpdates(): Pair<List<NodeInfo>, Observable<MapChange>>
abstract fun nodeIdentity(): NodeInfo
abstract fun openAttachment(id: SecureHash): InputStream
abstract fun partyFromKey(key: CompositeKey): Party?
abstract fun partyFromName(name: String): Party?
@RPCReturnsObservables abstract fun <T : Any> startFlowDynamic(logicType: Class<out FlowLogic<T>>, vararg args: Any?): FlowHandle<T>
@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMapping(): Pair<List<StateMachineTransactionMapping>, Observable<StateMachineTransactionMapping>>
@RPCReturnsObservables abstract fun stateMachinesAndUpdates(): Pair<List<StateMachineInfo>, Observable<StateMachineUpdate>>
abstract fun uploadAttachment(jar: InputStream): SecureHash
abstract fun uploadFile(dataType: String, name: String?, file: InputStream): String
@RPCReturnsObservables abstract fun vaultAndUpdates(): Pair<List<StateAndRef<ContractState>>, Observable<Update>>
@RPCReturnsObservables abstract fun verifiedTransactions(): Pair<List<SignedTransaction>, Observable<SignedTransaction>>
@RPCReturnsObservables abstract fun waitUntilRegisteredWithNetworkMap(): ListenableFuture<Unit>
class CordaRPCOpsImpl : CordaRPCOps
Module Contents
CordaRPCOpsImpl(services: ServiceHub, smm: StateMachineManager, database: Database)
fun addVaultTransactionNote(txnId: SecureHash, txnNote: String): Unit
fun attachmentExists(id: SecureHash): Boolean
fun authoriseContractUpgrade(state: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
fun currentNodeTime(): Instant
val database: Database
fun deauthoriseContractUpgrade(state: StateAndRef<*>): Unit
fun getVaultTransactionNotes(txnId: SecureHash): Iterable<String>
fun networkMapUpdates(): Pair<List<NodeInfo>, Observable<MapChange>>
fun nodeIdentity(): NodeInfo
fun openAttachment(id: SecureHash): InputStream
fun partyFromKey(key: CompositeKey): Party?
fun partyFromName(name: String): Party?
val protocolVersion: Int
val services: ServiceHub
val smm: StateMachineManager
fun <T : Any> startFlowDynamic(logicType: Class<out FlowLogic<T>>, vararg args: Any?): FlowHandle<T>
fun stateMachineRecordedTransactionMapping(): Pair<List<StateMachineTransactionMapping>, Observable<StateMachineTransactionMapping>>
fun stateMachinesAndUpdates(): Pair<List<StateMachineInfo>, Observable<StateMachineUpdate>>
fun uploadAttachment(jar: InputStream): SecureHash
fun uploadFile(dataType: String, name: String?, file: InputStream): String
fun vaultAndUpdates(): Pair<List<StateAndRef<ContractState>>, Observable<Update>>
fun verifiedTransactions(): Pair<List<SignedTransaction>, Observable<SignedTransaction>>
fun waitUntilRegisteredWithNetworkMap(): ListenableFuture<Unit>
class CubicSplineInterpolator : Interpolator
class CurrencyGenerator : Generator<Currency>
class DBCheckpointStorage : CheckpointStorage
@ThreadSafe class DBTransactionMappingStorage : StateMachineRecordedTransactionMappingStorage
class DBTransactionStorage : TransactionStorage
class DataUploadServlet : HttpServlet
object DataVending
enum class DateRollConvention
enum class DateRollDirection
enum class DayCountBasisDay
enum class DayCountBasisYear
interface DealState : LinearState
interface DeserializeAsKotlinObjectDef
data class Diff<out T : ContractState>
open class DigitalSignature : OpaqueBytes
class DistributedImmutableMap<K : Any, V : Any> : StateMachine, Snapshottable
abstract class DriverBasedTest
open class DriverDSL : DriverDSLInternalInterface
Module Contents
DriverDSL(portAllocation: PortAllocation, debugPortAllocation: PortAllocation, driverDirectory: Path, useTestClock: Boolean, isDebug: Boolean)
class State
val debugPortAllocation: PortAllocation
val driverDirectory: Path
val isDebug: Boolean
val name: Array<String>
fun <A> pickA(array: Array<A>): A
val portAllocation: PortAllocation
fun registerProcess(process: ListenableFuture<Process>): Unit
open fun shutdown(): Unit
open fun start(): Unit
open fun startNode(providedName: String?, advertisedServices: Set<ServiceInfo>, rpcUsers: List<User>, customOverrides: Map<String, Any?>): ListenableFuture<NodeHandle>
open fun startNotaryCluster(notaryName: String, clusterSize: Int, type: ServiceType, rpcUsers: List<User>): ListenableFuture<Pair<Party, List<NodeHandle>>>
open fun startWebserver(handle: NodeHandle): ListenableFuture<HostAndPort>
val useTestClock: Boolean
open fun waitForAllNodesToFinish(): Unit
interface DriverDSLExposedInterface
interface DriverDSLInternalInterface : DriverDSLExposedInterface
data class DummyContract : Contract
class DummyContractV2 : UpgradedContract<State, State>
class DummyDealContract : Contract
class DummyLinearContract : Contract
class DummyPublicKey : PublicKey, Comparable<PublicKey>
data class DummyState : ContractState
class DurationGenerator : Generator<Duration>
@ThreadSafe class E2ETestKeyManagementService : SingletonSerializeAsToken, KeyManagementService
@ThreadSafe object Ed25519PrivateKeySerializer : Serializer<EdDSAPrivateKey>
@ThreadSafe object Ed25519PublicKeySerializer : Serializer<EdDSAPublicKey>
object Emoji
data class ErrorOr<out A>
data class ErrorSessionEnd : SessionEnd
class EventGenerator
interface ExchangeRate
class ExchangeRateModel
interface ExistingSessionMessage : SessionMessage
class ExitGenerator : Generator<Exit>
data class Expression
object ExpressionDeserializer : JsonDeserializer<Expression>
object ExpressionSerializer : JsonSerializer<Expression>
class FetchAttachmentsFlow : FetchDataFlow<Attachment, ByteArray>
abstract class FetchDataFlow<T : NamedByHash, in W : Any> : FlowLogic<Result<T>>
class FetchTransactionsFlow : FetchDataFlow<SignedTransaction, SignedTransaction>
class FiberBox<out T>
interface FileUploader
class FilterOn<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, K>
Module Contents
FilterOn(clause: Clause<S, C, K>, filterStates: (List<ContractState>) -> List<S>)
val clause: Clause<S, C, K>
val filterStates: (List<ContractState>) -> List<S>
fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
val requiredCommands: Set<Class<out CommandData>>
fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class FilteredLeaves : TraversableTransaction
class FilteredTransaction
class FinalityFlow : FlowLogic<List<SignedTransaction>>
class FirstComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
FirstComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
val clauses: ArrayList<Clause<S, C, K>>
val firstClause: Clause<S, C, K>
val logger: Logger
fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
fun toString(): String
fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class FirstOf<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
FirstOf(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
val clauses: ArrayList<Clause<S, C, K>>
val firstClause: Clause<S, C, K>
val logger: Logger
fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
fun toString(): String
fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
data class Fix : CommandData
data class FixOf
interface FixableDealState : DealState
class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>
open class FlowException : Exception
data class FlowHandle<A>
interface FlowIORequest
abstract class FlowLogic<out T>
data class FlowLogicRef
class FlowLogicRefFactory : SingletonSerializeAsToken
class FlowSession
class FlowSessionException : RuntimeException
sealed class FlowSessionState
interface FlowStateMachine<R>
class FlowStateMachineImpl<R> : Fiber<Unit>, FlowStateMachine<R>
Module Contents
FlowStateMachineImpl(id: StateMachineRunId, logic: FlowLogic<R>, scheduler: FiberScheduler)
fun currentStateMachine(): FlowStateMachineImpl<*>?
val id: StateMachineRunId
val logger: Logger
val logic: FlowLogic<R>
@Suspendable fun <T : Any> receive(receiveType: Class<T>, otherParty: Party, sessionFlow: FlowLogic<*>): UntrustworthyData<T>
val resultFuture: ListenableFuture<R>
@Suspendable protected fun run(): Unit
@Suspendable fun send(otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): Unit
@Suspendable fun <T : Any> sendAndReceive(receiveType: Class<T>, otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): UntrustworthyData<T>
@Transient lateinit var serviceHub: ServiceHubInternal
@Suspendable fun waitForLedgerCommit(hash: SecureHash, sessionFlow: FlowLogic<*>): SignedTransaction
data class FlowStatus
enum class Frequency
class FullNodeConfiguration : NodeConfiguration
interface FungibleAsset<T> : OwnableState
data class GatheredTransactionData
class Generator<out A : Any>
Module Contents
Generator(generate: (SplittableRandom) -> ErrorOr<A>)
fun <B : Any> bind(function: (A) -> Generator<B>): Generator<B>
fun <A : Any> choice(generators: List<Generator<A>>): Generator<A>
fun <B : Any, R : Any> combine(other1: Generator<B>, function: (A, B) -> R): Generator<R>
fun <B : Any, C : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, function: (A, B, C) -> R): Generator<R>
fun <B : Any, C : Any, D : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, function: (A, B, C, D) -> R): Generator<R>
fun <B : Any, C : Any, D : Any, E : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, other4: Generator<E>, function: (A, B, C, D, E) -> R): Generator<R>
fun <A : Any> fail(error: Exception): Generator<A>
fun <A : Any> frequency(generators: List<Pair<Double, Generator<A>>>): Generator<A>
val generate: (SplittableRandom) -> ErrorOr<A>
fun <A : Any> impure(valueClosure: () -> A): Generator<A>
fun <B : Any> map(function: (A) -> B): Generator<B>
fun <B : Any> product(other: Generator<(A) -> B>): Generator<B>
fun <A : Any> pure(value: A): Generator<A>
fun <A : Any> sequence(generators: List<Generator<A>>): Generator<List<A>>
fun <A : Any> success(generate: (SplittableRandom) -> A): Generator<A>
abstract class GroupClauseVerifier<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, Unit>
Module Contents
GroupClauseVerifier(clause: Clause<S, C, K>)
val clause: Clause<S, C, K>
open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
abstract fun groupStates(tx: TransactionForContract): List<InOutGroup<S, K>>
open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
class HTTPNetworkRegistrationService : NetworkRegistrationService
class HibernateObserver
interface IdentityService
class IllegalFlowLogicException : IllegalArgumentException
class ImmutableClassSerializer<T : Any> : Serializer<T>
@ThreadSafe class InMemoryIdentityService : SingletonSerializeAsToken, IdentityService
@ThreadSafe open class InMemoryNetworkMapCache : SingletonSerializeAsToken, NetworkMapCache
@ThreadSafe class InMemoryNetworkMapService : AbstractNetworkMapService
@ThreadSafe class InMemoryStateMachineRecordedTransactionMappingStorage : StateMachineRecordedTransactionMappingStorage
@ThreadSafe class InMemoryUniquenessProvider : UniquenessProvider
object InputStreamSerializer : Serializer<InputStream>
object InstantColumnType : ColumnType
class InstantConverter : Converter<Instant, Timestamp>
class InstantGenerator : Generator<Instant>
class InsufficientBalanceException : FlowException
interface Interpolator
interface InterpolatorFactory
interface IssuanceDefinition
interface IssueCommand : CommandData
class IssueGenerator : Generator<Issue>
data class Issued<out P>
class IssuedGenerator<T> : Generator<Issued<T>>
object IssuerFlow
class JDBCHashMap<K : Any, V : Any> : AbstractJDBCHashMap<K, V, BlobMapTable>
class JDBCHashSet<K : Any> : AbstractJDBCHashSet<K, BlobSetTable>
open class JDBCHashedTable : Table
object JsonSupport
interface KeyManagementService
class KotlinConfigurationTransactionWrapper : Configuration
Module Contents
KotlinConfigurationTransactionWrapper(model: EntityModel, dataSource: DataSource, mapping: Mapping? = null, platform: Platform? = null, cache: EntityCache = WeakEntityCache(), useDefaultLogging: Boolean = false, statementCacheSize: Int = 0, batchUpdateSize: Int = 64, quoteTableNames: Boolean = false, quoteColumnNames: Boolean = false, tableTransformer: Function<String, String>? = null, columnTransformer: Function<String, String>? = null, transactionMode: TransactionMode = TransactionMode.NONE, transactionIsolation: TransactionIsolation? = null, statementListeners: Set<StatementListener> = LinkedHashSet(), entityStateListeners: Set<EntityStateListener<Any>> = LinkedHashSet(), transactionListeners: Set<Supplier<TransactionListener>> = LinkedHashSet(), writeExecutor: Executor? = null)
class CordaConnection : Connection
class CordaDataSourceConnectionProvider : ConnectionProvider
fun getBatchUpdateSize(): Int
fun getCache(): EntityCache?
fun getColumnTransformer(): Function<String, String>?
fun getConnectionProvider(): ConnectionProvider?
fun getEntityStateListeners(): Set<EntityStateListener<Any>>
fun getMapping(): Mapping?
fun getModel(): EntityModel
fun getPlatform(): Platform?
fun getQuoteColumnNames(): Boolean
fun getQuoteTableNames(): Boolean
fun getStatementCacheSize(): Int
fun getStatementListeners(): Set<StatementListener>?
fun getTableTransformer(): Function<String, String>?
fun getTransactionIsolation(): TransactionIsolation?
fun getTransactionListenerFactories(): Set<Supplier<TransactionListener>>?
fun getTransactionMode(): TransactionMode?
fun getUseDefaultLogging(): Boolean
fun getWriteExecutor(): Executor?
object KotlinObjectSerializer : Serializer<DeserializeAsKotlinObjectDef>
data class LastAcknowledgeInfo
class LedgerTransaction : BaseTransaction
class LeftOuterJoinedMap<K : Any, A, B, C> : ReadOnlyBackedObservableMapBase<K, C, SimpleObjectProperty<B?>>
class LinearInterpolator : Interpolator
interface LinearState : ContractState
object LocalDateColumnType : ColumnType
object LocalDateTimeColumnType : ColumnType
object LogHelper
class MapValuesList<K, A, C> : ObservableList<C>
class MappedList<A, B> : TransformationList<B, A>
abstract class MappedSchema
data class MarshalledObservation
sealed class MerkleTree
class MerkleTreeException : Exception
interface Message
interface MessageHandlerRegistration
interface MessageRecipientGroup : MessageRecipients
interface MessageRecipients
@ThreadSafe interface MessagingService
interface MessagingServiceBuilder<out T : MessagingServiceInternal>
interface MessagingServiceInternal : MessagingService
class MissingAttachmentsException : Exception
object Models
class MonitoringService : SingletonSerializeAsToken
interface MoveCommand : CommandData
class MoveGenerator : Generator<Move>
data class MultilateralNetState<P> : NetState<P>
interface MultilateralNettableState<out T : Any>
abstract class MutableClock : Clock
interface NamedByHash
open class NetClause<C : CommandData, P> : Clause<ContractState, C, Unit>
interface NetCommand : CommandData
interface NetState<P>
enum class NetType
interface NettableState<N : BilateralNettableState<N>, T : Any> : BilateralNettableState<N>, MultilateralNettableState<T>
sealed class NetworkCacheError : Exception
class NetworkIdentityModel
interface NetworkMapCache
data class NetworkMapInfo
interface NetworkMapService
class NetworkRegistrationHelper
interface NetworkRegistrationService
class NoReferencesSerializer<T> : Serializer<T>
open class NoZeroSizedOutputs<in S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
class Node : AbstractNode
@ThreadSafe class NodeAttachmentService : AttachmentStorage, AcceptsFileUpload
@ThreadSafe class NodeClock : Clock, SerializeAsToken
interface NodeConfiguration : SSLConfiguration
data class NodeHandle
data class NodeInfo
class NodeLoginModule : LoginModule
sealed class NodeMapError : Exception
@ThreadSafe class NodeMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
Module Contents
NodeMessagingClient(config: NodeConfiguration, serverHostPort: HostAndPort, myIdentity: CompositeKey?, nodeExecutor: AffinityExecutor, database: Database, networkMapRegistrationFuture: ListenableFuture<Unit>)
data class Handler : MessageHandlerRegistration
const val SESSION_ID_PROPERTY: String
const val TOPIC_PROPERTY: String
fun addMessageHandler(topic: String, sessionID: Long, callback: (ReceivedMessage, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
fun addMessageHandler(topicSession: TopicSession, callback: (ReceivedMessage, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
val config: NodeConfiguration
fun createMessage(topicSession: TopicSession, data: ByteArray, uuid: UUID): Message
val database: Database
fun getAddressOfParty(partyInfo: PartyInfo): MessageRecipients
val myAddress: SingleMessageRecipient
val myIdentity: CompositeKey?
val networkMapRegistrationFuture: ListenableFuture<Unit>
val nodeExecutor: AffinityExecutor
fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
fun run(): Unit
fun send(message: Message, target: MessageRecipients): Unit
val serverHostPort: HostAndPort
fun start(rpcOps: RPCOps, userService: RPCUserService): Unit
fun stop(): Unit
class NodeMonitorModel
class NodeRegistration
data class NodeRegistrationInfo
@ThreadSafe class NodeSchedulerService : SchedulerService, SingletonSerializeAsToken
class NodeSchemaService : SchemaService, SingletonSerializeAsToken
class NodeVaultService : SingletonSerializeAsToken, VaultService
Module Contents
NodeVaultService(services: ServiceHub, dataSourceProperties: Properties)
fun addNoteToTransaction(txnId: SecureHash, noteText: String): Unit
fun authoriseContractUpgrade(stateAndRef: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
val cashBalances: Map<Currency, Amount<Currency>>
val configuration: RequeryConfiguration
fun deauthoriseContractUpgrade(stateAndRef: StateAndRef<*>): Unit
fun generateSpend(tx: TransactionBuilder, amount: Amount<Currency>, to: CompositeKey, onlyFromParties: Set<AbstractParty>?): Pair<TransactionBuilder, List<CompositeKey>>
fun getAuthorisedContractUpgrade(ref: StateRef): Class<out UpgradedContract<*, *>>?
fun getTransactionNotes(txnId: SecureHash): Iterable<String>
val log: Logger
fun notifyAll(txns: Iterable<WireTransaction>): Unit
val rawUpdates: Observable<Update>
val session: KotlinEntityDataStore<Persistable>
fun <T : ContractState> states(clazzes: Set<Class<T>>, statuses: EnumSet<StateStatus>): List<StateAndRef<T>>
fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
fun track(): Pair<Vault<ContractState>, Observable<Update>>
val updates: Observable<Update>
class NonEmptySet<T> : MutableSet<T>
object NonEmptySetSerializer : Serializer<NonEmptySet<Any>>
class NonValidatingNotaryFlow : Service
data class NormalSessionEnd : SessionEnd
object NotaryChange
object NotaryChangeFlow : AbstractStateReplacementFlow
sealed class NotaryError
class NotaryException : FlowException
object NotaryFlow
abstract class NotaryService : SingletonSerializeAsToken
object NullPublicKey : PublicKey, Comparable<PublicKey>
object NullSignature : WithKey
@Provider class ObjectMapperConfig : ContextResolver<ObjectMapper>
class Obligation<P> : Contract
Module Contents
Obligation()
interface Clauses
Module Contents
class ConserveAmount<P> : AbstractConserveAmount<State<P>, Commands, Terms<P>>
class Group<P> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>
class Issue<P> : AbstractIssue<State<P>, Commands, Terms<P>>
class Net<C : CommandData, P> : NetClause<C, P>
class SetLifecycle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
class Settle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P> : Clause<S, C, T>
interface Commands : Commands
enum class Lifecycle
data class State<P> : FungibleAsset<Terms<P>>, NettableState<State<P>, MultilateralNetState<P>>
Module Contents
State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: Party, template: Terms<P>, quantity: Long, beneficiary: CompositeKey)
State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: AnonymousParty, template: Terms<P>, quantity: Long, beneficiary: CompositeKey)
val amount: Amount<Issued<Terms<P>>>
val beneficiary: CompositeKey
val bilateralNetState: BilateralNetState<P>
val contract: Obligation<Currency>
val dueBefore: Instant
val exitKeys: Collection<CompositeKey>
var lifecycle: Lifecycle
fun move(newAmount: Amount<Issued<Terms<P>>>, newOwner: CompositeKey): State<P>
val multilateralNetState: MultilateralNetState<P>
fun net(other: State<P>): State<P>
val obligor: AnonymousParty
val owner: CompositeKey
val participants: List<CompositeKey>
val quantity: Long
val template: Terms<P>
fun toString(): String
fun withNewOwner(newOwner: CompositeKey): Pair<Move, State<P>>
data class Terms<P>
fun generateCloseOutNetting(tx: TransactionBuilder, signer: CompositeKey, vararg states: State<P>): Unit
fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, assetStates: List<StateAndRef<State<P>>>): CompositeKey
fun generateIssue(tx: TransactionBuilder, obligor: AbstractParty, issuanceDef: Terms<P>, pennies: Long, beneficiary: CompositeKey, notary: Party): Unit
fun generatePaymentNetting(tx: TransactionBuilder, issued: Issued<Terms<P>>, notary: Party, vararg states: State<P>): Unit
fun generateSetLifecycle(tx: TransactionBuilder, statesAndRefs: List<StateAndRef<State<P>>>, lifecycle: Lifecycle, notary: Party): Unit
fun generateSettle(tx: TransactionBuilder, statesAndRefs: Iterable<StateAndRef<State<P>>>, assetStatesAndRefs: Iterable<StateAndRef<FungibleAsset<P>>>, moveCommand: MoveCommand, notary: Party): Unit
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : Contract
open class OpaqueBytes
class OptionalConfig<out T>
object OrderedSerializer : Serializer<HashMap<Any, Any>>
interface OwnableState : ContractState
class PartialMerkleTree
data class PartiallyResolvedTransaction
class Party : AbstractParty
data class PartyAndReference
class PartyAndReferenceGenerator : Generator<PartyAndReference>
data class PartyColumns
class PartyGenerator : Generator<Party>
sealed class PartyInfo
enum class PaymentRule
class PermissionException : RuntimeException
class PersistentKeyManagementService : SingletonSerializeAsToken, KeyManagementService
class PersistentNetworkMapService : AbstractNetworkMapService
@MappedSuperclass open class PersistentState : Persistable
@Embeddable data class PersistentStateRef : Serializable
@ThreadSafe class PersistentUniquenessProvider : UniquenessProvider, SingletonSerializeAsToken
data class PhysicalLocation
interface PluginServiceHub : ServiceHub
class Polynomial
sealed class PortAllocation
class PrivateKeyGenerator : Generator<PrivateKey>
class ProgressTracker
data class ProgressTrackingEvent
object PublicKeyColumnType : ColumnType
class PublicKeyGenerator : Generator<PublicKey>
interface QueryableState : ContractState
abstract class RPCDispatcher
open class RPCException : RuntimeException
interface RPCOps
@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables
@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion
interface RPCUserService
class RPCUserServiceImpl : RPCUserService
@ThreadSafe class RaftUniquenessProvider : UniquenessProvider, SingletonSerializeAsToken
class RaftValidatingNotaryService : NotaryService
open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A>
interface ReadOnlyTransactionStorage
data class ReceiveOnly<T : SessionMessage> : ReceiveRequest<T>
interface ReceiveRequest<T : SessionMessage> : SessionedFlowIORequest, WaitingRequest
interface ReceivedMessage : Message
data class ReceivedSessionMessage<out M : ExistingSessionMessage>
object ReferencesAwareJavaSerializer : JavaSerializer
interface RegulatorService
class ReplayedList<A> : TransformationList<A, A>
object Requery
class RequeryConfiguration
data class Request
enum class RequestType
object Requirements
class ResolveTransactionsFlow : FlowLogic<List<LedgerTransaction>>
@Provider class ResponseFilter : ContainerResponseFilter
abstract class RetryableException : Exception
interface SSLConfiguration
interface SchedulableState : ContractState
interface Scheduled
data class ScheduledActivity : Scheduled
class ScheduledActivityObserver
data class ScheduledStateRef : Scheduled
interface SchedulerService
interface SchemaService
sealed class SecureHash : OpaqueBytes
object SecureHashColumnType : ColumnType
class SecureHashGenerator : Generator<SecureHash>
data class SendAndReceive<T : SessionMessage> : SendRequest, ReceiveRequest<T>
data class SendOnly : SendRequest
interface SendRequest : SessionedFlowIORequest
interface SerializationToken
interface SerializeAsToken
class SerializeAsTokenContext
class SerializeAsTokenSerializer<T : SerializeAsToken> : Serializer<T>
class SerializedBytes<T : Any> : OpaqueBytes
object SerializedBytesSerializer : Serializer<SerializedBytes<Any>>
data class ServiceEntry
interface ServiceHub
abstract class ServiceHubInternal : PluginServiceHub
object ServiceIdentityGenerator
data class ServiceInfo
interface ServiceRequestMessage
sealed class ServiceType
data class SessionConfirm : SessionInitResponse
data class SessionData : ExistingSessionMessage
interface SessionEnd : ExistingSessionMessage
data class SessionInit : SessionMessage
interface SessionInitResponse : ExistingSessionMessage
interface SessionMessage
data class SessionReject : SessionInitResponse
interface SessionedFlowIORequest : FlowIORequest
open class SignedData<T : Any>
data class SignedTransaction : NamedByHash
class SignedTransactionGenerator : Generator<SignedTransaction>
class SimpleNotaryService : NotaryService
interface SingleMessageRecipient : MessageRecipients
data class SingletonSerializationToken : SerializationToken
abstract class SingletonSerializeAsToken : SerializeAsToken
class SplineFunction
class StackSnapshot : Throwable
data class StateAndRef<out T : ContractState>
data class StateMachineData
data class StateMachineInfo
@ThreadSafe class StateMachineManager
interface StateMachineRecordedTransactionMappingStorage
data class StateMachineRunId
sealed class StateMachineStatus
data class StateMachineTransactionMapping
sealed class StateMachineUpdate
data class StateRef
data class StateRefColumns
class StateRefConverter : Converter<StateRef, Pair<String, Int>>
class StateRefGenerator : Generator<StateRef>
open class StateReplacementException : FlowException
interface StatesQuery
interface StorageService
open class StorageServiceImpl : SingletonSerializeAsToken, TxWritableStorageService
class StrandLocalTransactionManager : TransactionManager
data class Tenor
@ThreadSafe class TestClock : MutableClock, SerializeAsToken
class ThreadBox<out T>
data class TimeWindow
data class Timestamp
class TimestampChecker
class TimestampGenerator : Generator<Timestamp>
data class TopicSession
object TopicStringValidator
sealed class TrackedDelegate<M : Any>
Module Contents
class EventSinkDelegate<M : Any, T> : TrackedDelegate<M>
class EventStreamDelegate<M : Any, T> : TrackedDelegate<M>
class ObjectPropertyDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableListDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableListReadOnlyDelegate<M : Any, out T> : TrackedDelegate<M>
class ObservableValueDelegate<M : Any, T> : TrackedDelegate<M>
class ObserverDelegate<M : Any, T> : TrackedDelegate<M>
class SubjectDelegate<M : Any, T> : TrackedDelegate<M>
class WritableValueDelegate<M : Any, T> : TrackedDelegate<M>
val klass: KClass<M>
open class TransactionBuilder
Module Contents
TransactionBuilder(type: TransactionType = TransactionType.General(), notary: Party? = null, inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<TransactionState<ContractState>> = arrayListOf(), commands: MutableList<Command> = arrayListOf(), signers: MutableSet<CompositeKey> = mutableSetOf(), timestamp: Timestamp? = null)
fun addAttachment(attachmentId: SecureHash): Unit
fun addCommand(arg: Command): Unit
fun addCommand(data: CommandData, vararg keys: CompositeKey): Unit
fun addCommand(data: CommandData, keys: List<CompositeKey>): Unit
open fun addInputState(stateAndRef: StateAndRef<*>): Unit
fun addOutputState(state: TransactionState<*>): Int
@JvmOverloads fun addOutputState(state: ContractState, notary: Party, encumbrance: Int? = null): Int
fun addOutputState(state: ContractState): Int
fun addSignatureUnchecked(sig: WithKey): TransactionBuilder
fun attachments(): List<SecureHash>
protected val attachments: MutableList<SecureHash>
fun checkAndAddSignature(sig: WithKey): Unit
fun checkSignature(sig: WithKey): Unit
fun commands(): List<Command>
protected val commands: MutableList<Command>
fun copy(): TransactionBuilder
protected val currentSigs: ArrayList<WithKey>
fun inputStates(): List<StateRef>
protected val inputs: MutableList<StateRef>
var notary: Party?
fun outputStates(): List<TransactionState<*>>
protected val outputs: MutableList<TransactionState<ContractState>>
fun setTime(time: Instant, timeTolerance: Duration): Unit
fun setTime(newTimestamp: Timestamp): Unit
fun signWith(key: KeyPair): TransactionBuilder
protected val signers: MutableSet<CompositeKey>
val time: Timestamp?
protected var timestamp: Timestamp?
fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
fun toWireTransaction(): WireTransaction
protected val type: TransactionType
fun withItems(vararg items: Any): TransactionBuilder
class TransactionConflictException : Exception
sealed class TransactionCreateStatus
class TransactionDataModel
data class TransactionForContract
Module Contents
TransactionForContract(inputs: List<ContractState>, outputs: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash, inputNotary: Party? = null, timestamp: Timestamp? = null)
data class InOutGroup<out T : ContractState, out K : Any>
val attachments: List<Attachment>
val commands: List<AuthenticatedObject<CommandData>>
fun equals(other: Any?): Boolean
fun <T : ContractState, K : Any> groupStates(ofType: Class<T>, selector: (T) -> K): List<InOutGroup<T, K>>
inline fun <reified T : ContractState, K : Any> groupStates(selector: (T) -> K): List<InOutGroup<T, K>>
fun <T : ContractState, K : Any> groupStatesInternal(inGroups: Map<K, List<T>>, outGroups: Map<K, List<T>>): List<InOutGroup<T, K>>
fun hashCode(): Int
val inputNotary: Party?
val inputs: List<ContractState>
val origHash: SecureHash
val outputs: List<ContractState>
val timestamp: Timestamp?
class TransactionGraphSearch : Callable<List<WireTransaction>>
class TransactionResolutionException : FlowException
data class TransactionState<out T : ContractState>
class TransactionStateGenerator<T : ContractState> : Generator<TransactionState<T>>
interface TransactionStorage : ReadOnlyTransactionStorage
sealed class TransactionType
sealed class TransactionVerificationException : FlowException
class TransientProperty<out T>
interface TraversableTransaction
object TwoPartyDealFlow
object TwoPartyTradeFlow
interface TxWritableStorageService : StorageService
data class TxnNoteColumns
abstract class TypeOnlyCommandData : CommandData
object UUIDStringColumnType : ColumnType
data class UniqueIdentifier : Comparable<UniqueIdentifier>
class UniquenessException : Exception
interface UniquenessProvider
class UntrustworthyData<out T>
data class UpgradeCommand : CommandData
interface UpgradedContract<in OldState : ContractState, out NewState : ContractState> : Contract
data class User
class ValidatingNotaryFlow : Service
class ValidatingNotaryService : NotaryService
class Vault<out T : ContractState>
interface VaultService
Module Contents
abstract fun addNoteToTransaction(txnId: SecureHash, noteText: String): Unit
abstract fun authoriseContractUpgrade(stateAndRef: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
abstract val cashBalances: Map<Currency, Amount<Currency>>
abstract fun deauthoriseContractUpgrade(stateAndRef: StateAndRef<*>): Unit
abstract fun generateSpend(tx: TransactionBuilder, amount: Amount<Currency>, to: CompositeKey, onlyFromParties: Set<AbstractParty>? = null): Pair<TransactionBuilder, List<CompositeKey>>
abstract fun getAuthorisedContractUpgrade(ref: StateRef): Class<out UpgradedContract<*, *>>?
abstract fun getTransactionNotes(txnId: SecureHash): Iterable<String>
open fun notify(tx: WireTransaction): Unit
abstract fun notifyAll(txns: Iterable<WireTransaction>): Unit
abstract val rawUpdates: Observable<Update>
abstract fun <T : ContractState> states(clazzes: Set<Class<T>>, statuses: EnumSet<StateStatus>): List<StateAndRef<T>>
abstract fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
abstract fun track(): Pair<Vault<ContractState>, Observable<Update>>
abstract val updates: Observable<Update>
open fun whenConsumed(ref: StateRef): ListenableFuture<Update>
class VaultStateStatusConverter : EnumOrdinalConverter<StateStatus>
class VerifyingNettyConnectorFactory : NettyConnectorFactory
data class WaitForLedgerCommit : WaitingRequest
interface WaitingRequest : FlowIORequest
class WebServer
class WireNodeRegistration : SignedData<NodeRegistration>
class WireTransaction : BaseTransaction, TraversableTransaction
@ThreadSafe object WireTransactionSerializer : Serializer<WireTransaction>
class WiredTransactionGenerator : Generator<WireTransaction>
data class WorldCoordinate
object X509Utilities
Module Contents
data class CACertAndKey
val CORDA_CLIENT_CA: String
val CORDA_CLIENT_CA_PRIVATE_KEY: String
val CORDA_INTERMEDIATE_CA: String
val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String
val CORDA_ROOT_CA: String
val CORDA_ROOT_CA_PRIVATE_KEY: String
val ECDSA_CURVE: String
val KEYSTORE_TYPE: String
val KEY_GENERATION_ALGORITHM: String
val SIGNATURE_ALGORITHM: String
fun KeyStore.addOrReplaceCertificate(alias: String, cert: Certificate): Unit
fun KeyStore.addOrReplaceKey(alias: String, key: Key, password: CharArray, chain: Array<Certificate>): Unit
fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair: KeyPair): PKCS10CertificationRequest
fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
fun createKeystoreForSSL(: Path, : String, : String, : KeyStore, : String, : String): KeyStore
fun createSelfSignedCACert(myLegalName: String): CACertAndKey
fun createServerCert(subject: X500Name, publicKey: PublicKey, certificateAuthority: CACertAndKey, subjectAlternativeNameDomains: List<String>, subjectAlternativeNameIps: List<String>): X509Certificate
fun generateECDSAKeyPairForSSL(): KeyPair
fun getDevX509Name(commonName: String): X500Name
fun getX509Name(myLegalName: String, nearestCity: String, email: String): X500Name
fun loadCertificateAndKey(keyStore: KeyStore, keyPassword: String, alias: String): CACertAndKey
fun loadCertificateFromKeyStore(keyStoreFilePath: Path, storePassword: String, alias: String): X509Certificate
fun loadCertificateFromPEMFile(filename: Path): X509Certificate
fun loadKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String): KeyPair
fun loadKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
fun loadKeyStore(input: InputStream, storePassword: String): KeyStore
fun loadOrCreateKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String, keyGenerator: () -> CACertAndKey): KeyPair
fun loadOrCreateKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
fun saveCertificateAsPEMFile(x509Certificate: X509Certificate, filename: Path): Unit
fun saveKeyStore(keyStore: KeyStore, keyStoreFilePath: Path, storePassword: String): Unit
com.esotericsoftware.kryo.Kryo
com.esotericsoftware.kryo.io.Input
com.esotericsoftware.kryo.io.Output
com.google.common.util.concurrent.ListenableFuture
com.google.common.util.concurrent.SettableFuture
com.pholser.junit.quickcheck.generator.Generator
com.typesafe.config.Config
com.typesafe.config.Config
java.io.InputStream
java.nio.file.Path
java.security.KeyPair
java.security.PrivateKey
java.security.PublicKey
java.time.Clock
java.time.LocalDate
java.time.temporal.Temporal
java.util.Currency
java.util.concurrent.Future
javafx.beans.value.ObservableValue
javafx.collections.ObservableList
Module Contents
fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>
fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>
fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>
fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>
fun <A> ObservableList<ObservableList<A>>.concatenate(): ObservableList<A>
fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>
fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>
fun <A> ObservableList<A>.first(): ObservableValue<A?>
fun <A> ObservableList<A>.firstOrDefault(default: ObservableValue<A?>, predicate: (A) -> Boolean): ObservableValue<A?>
fun <A> ObservableList<A>.firstOrNullObservable(predicate: (A) -> Boolean): ObservableValue<A?>
fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<A>
fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>
fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>
fun <A> ObservableList<A>.last(): ObservableValue<A?>
fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>
fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, Pair<ObservableList<A>, ObservableList<B>>>
fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>
fun <T : Any> ObservableList<T>.unique(): ObservableList<T>
javafx.collections.ObservableMap
Module Contents
fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A>
fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>
fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>
fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>
kotlin.ByteArray
kotlin.ByteArray
kotlin.Double
kotlin.Double
kotlin.Function1
kotlin.Function2
kotlin.Function3
kotlin.Function4
Module Contents
fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>
kotlin.Int
kotlin.Int
kotlin.Long
kotlin.String
kotlin.String
kotlin.String
kotlin.Throwable
kotlin.collections.Collection
kotlin.collections.Collection
kotlin.collections.Iterable
kotlin.collections.Iterable
kotlin.collections.Iterable
kotlin.collections.Iterable
kotlin.collections.Iterable
kotlin.collections.List
org.bouncycastle.asn1.x500.X500Name
org.jetbrains.exposed.sql.Table
org.slf4j.Logger
org.slf4j.Logger
rx.Observable
rx.Observable
Module Contents
fun <T, R> Observable<T>.fold(accumulator: R, folderFun: (R, T) -> Unit): R
fun <A, B> Observable<A>.foldToObservableValue(initial: B, folderFun: (A, B) -> B): ObservableValue<B>
fun <A, K> Observable<A>.recordAsAssociation(toKey: (A) -> K, merge: (K, oldValue: A, newValue: A) -> A = { _key, _oldValue, newValue -> newValue }): ObservableMap<K, A>
fun <A> Observable<A>.recordInSequence(): ObservableList<A>
rx.Observable
rx.Observer
rx.Observer
package net.corda.client.fxutils
Module Contents
class AggregatedList<A, E : Any, K : Any> : TransformationList<A, E>
object AmountBindings
class AssociatedList<K, out A, B> : ReadOnlyBackedObservableMapBase<K, B, Unit>
class ChosenList<E> : ObservableListBase<E>
class ConcatenatedList<A> : TransformationList<A, ObservableList<A>>
class FlattenedList<A> : TransformationList<A, ObservableValue<out A>>
class LeftOuterJoinedMap<K : Any, A, B, C> : ReadOnlyBackedObservableMapBase<K, C, SimpleObjectProperty<B?>>
class MapValuesList<K, A, C> : ObservableList<C>
class MappedList<A, B> : TransformationList<B, A>
open class ReadOnlyBackedObservableMapBase<K, A, B> : ObservableMap<K, A>
class ReplayedList<A> : TransformationList<A, A>
javafx.beans.value.ObservableValue
javafx.collections.ObservableList
Module Contents
fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>
fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>
fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>
fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>
fun <A> ObservableList<ObservableList<A>>.concatenate(): ObservableList<A>
fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>
fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>
fun <A> ObservableList<A>.first(): ObservableValue<A?>
fun <A> ObservableList<A>.firstOrDefault(default: ObservableValue<A?>, predicate: (A) -> Boolean): ObservableValue<A?>
fun <A> ObservableList<A>.firstOrNullObservable(predicate: (A) -> Boolean): ObservableValue<A?>
fun <A> ObservableList<out ObservableValue<out A>>.flatten(): ObservableList<A>
fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>
fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>
fun <A> ObservableList<A>.last(): ObservableValue<A?>
fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>
fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, Pair<ObservableList<A>, ObservableList<B>>>
fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>
fun <T : Any> ObservableList<T>.unique(): ObservableList<T>
javafx.collections.ObservableMap
Module Contents
fun <A, K> ObservableMap<K, A>.createMapChange(key: K, removedValue: A?, addedValue: A?): Change<K, A>
fun <K, V> ObservableMap<K, V>.getObservableEntries(): ObservableList<Entry<K, V>>
fun <K, V> ObservableMap<K, V>.getObservableValue(key: K): ObservableValue<V?>
fun <K, V> ObservableMap<K, V>.getObservableValues(): ObservableList<V>
kotlin.Function1
kotlin.Function2
kotlin.Function3
kotlin.Function4
Module Contents
fun <A, B, C, D, R> (A, B, C, D) -> R.lift(arg0: ObservableValue<A>, arg1: ObservableValue<B>, arg2: ObservableValue<C>, arg3: ObservableValue<D>): ObservableValue<R>
kotlin.collections.Collection
fun <A> A.lift(): ObservableValue<A>
rx.Observable
Module Contents
fun <T, R> Observable<T>.fold(accumulator: R, folderFun: (R, T) -> Unit): R
fun <A, B> Observable<A>.foldToObservableValue(initial: B, folderFun: (A, B) -> B): ObservableValue<B>
fun <A, K> Observable<A>.recordAsAssociation(toKey: (A) -> K, merge: (K, oldValue: A, newValue: A) -> A = { _key, _oldValue, newValue -> newValue }): ObservableMap<K, A>
fun <A> Observable<A>.recordInSequence(): ObservableList<A>
package net.corda.client.mock
Module Contents
class EventGenerator
class Generator<out A : Any>
Module Contents
Generator(generate: (SplittableRandom) -> ErrorOr<A>)
fun <B : Any> bind(function: (A) -> Generator<B>): Generator<B>
fun <A : Any> choice(generators: List<Generator<A>>): Generator<A>
fun <B : Any, R : Any> combine(other1: Generator<B>, function: (A, B) -> R): Generator<R>
fun <B : Any, C : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, function: (A, B, C) -> R): Generator<R>
fun <B : Any, C : Any, D : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, function: (A, B, C, D) -> R): Generator<R>
fun <B : Any, C : Any, D : Any, E : Any, R : Any> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, other4: Generator<E>, function: (A, B, C, D, E) -> R): Generator<R>
fun <A : Any> fail(error: Exception): Generator<A>
fun <A : Any> frequency(generators: List<Pair<Double, Generator<A>>>): Generator<A>
val generate: (SplittableRandom) -> ErrorOr<A>
fun <A : Any> impure(valueClosure: () -> A): Generator<A>
fun <B : Any> map(function: (A) -> B): Generator<B>
fun <B : Any> product(other: Generator<(A) -> B>): Generator<B>
fun <A : Any> pure(value: A): Generator<A>
fun <A : Any> sequence(generators: List<Generator<A>>): Generator<List<A>>
fun <A : Any> success(generate: (SplittableRandom) -> A): Generator<A>
fun Generator.Companion.bytes(size: Int): Generator<ByteArray>
fun Generator.Companion.double(): Generator<Double>
fun Generator.Companion.doubleRange(from: Double, to: Double): Generator<Double>
fun <A : Any> Generator.Companion.frequency(vararg generators: Pair<Double, Generator<A>>): Generator<A>
fun <T : Any> generateAmount(min: Long, max: Long, tokenGenerator: Generator<T>): Generator<Amount<T>>
fun generateCurrency(): Generator<Currency>
fun generateCurrencyAmount(min: Long, max: Long): Generator<Amount<Currency>>
fun generateIssueRef(size: Int): Generator<OpaqueBytes>
fun <A : Any> Generator<A>.generateOrFail(random: SplittableRandom, numberOfTries: Int = 1): A
fun Generator.Companion.int(): Generator<Int>
fun Generator.Companion.intRange(range: IntRange): Generator<Int>
fun Generator.Companion.intRange(from: Int, to: Int): Generator<Int>
fun Generator.Companion.longRange(range: LongRange): Generator<Long>
fun Generator.Companion.longRange(from: Long, to: Long): Generator<Long>
fun <A : Any> Generator.Companion.pickN(number: Int, list: List<A>): Generator<List<A>>
fun <A : Any> Generator.Companion.pickOne(list: List<A>): Generator<A>
fun <A : Any> Generator.Companion.replicate(number: Int, generator: Generator<A>): Generator<List<A>>
fun <A : Any> Generator.Companion.replicatePoisson(meanSize: Double, generator: Generator<A>): Generator<List<A>>
fun <A> Generator.Companion.sampleBernoulli(maxRatio: Double = 1.0, vararg collection: A): Generator<List<Array<out A>>>
fun <A> Generator.Companion.sampleBernoulli(collection: Collection<A>, maxRatio: Double = 1.0): Generator<List<A>>
package net.corda.client.model
Module Contents
class ContractStateModel
data class Diff<out T : ContractState>
interface ExchangeRate
class ExchangeRateModel
data class FlowStatus
data class GatheredTransactionData
object Models
class NetworkIdentityModel
class NodeMonitorModel
data class PartiallyResolvedTransaction
data class ProgressTrackingEvent
data class StateMachineData
sealed class StateMachineStatus
sealed class TrackedDelegate<M : Any>
Module Contents
class EventSinkDelegate<M : Any, T> : TrackedDelegate<M>
class EventStreamDelegate<M : Any, T> : TrackedDelegate<M>
class ObjectPropertyDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableListDelegate<M : Any, T> : TrackedDelegate<M>
class ObservableListReadOnlyDelegate<M : Any, out T> : TrackedDelegate<M>
class ObservableValueDelegate<M : Any, T> : TrackedDelegate<M>
class ObserverDelegate<M : Any, T> : TrackedDelegate<M>
class SubjectDelegate<M : Any, T> : TrackedDelegate<M>
class WritableValueDelegate<M : Any, T> : TrackedDelegate<M>
val klass: KClass<M>
sealed class TransactionCreateStatus
class TransactionDataModel
inline fun <reified M : Any, T> eventSink(noinline sinkProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
inline fun <reified M : Any, T> eventStream(noinline streamProperty: (M) -> <ERROR CLASS><T>): <ERROR CLASS>
fun ExchangeRate.exchangeAmount(amount: Amount<Currency>, to: Currency): Amount<Currency>
fun ExchangeRate.exchangeDouble(amount: Amount<Currency>, to: Currency): Double
inline fun <reified M : Any, T> objectProperty(noinline objectProperty: (M) -> ObjectProperty<T>): ObjectPropertyDelegate<M, T>
inline fun <reified M : Any, T> observable(noinline observableProperty: (M) -> Observable<T>): ObservableDelegate<M, T>
inline fun <reified M : Any, T> observableList(noinline observableListProperty: (M) -> ObservableList<T>): ObservableListDelegate<M, T>
inline fun <reified M : Any, T> observableListReadOnly(noinline observableListProperty: (M) -> ObservableList<out T>): ObservableListReadOnlyDelegate<M, T>
inline fun <reified M : Any, T> observableValue(noinline observableValueProperty: (M) -> ObservableValue<T>): ObservableValueDelegate<M, T>
inline fun <reified M : Any, T> observer(noinline observerProperty: (M) -> Observer<T>): ObserverDelegate<M, T>
inline fun <reified M : Any, T> subject(noinline subjectProperty: (M) -> Subject<T, T>): SubjectDelegate<M, T>
inline fun <reified M : Any, T> writableValue(noinline writableValueProperty: (M) -> WritableValue<T>): WritableValueDelegate<M, T>
package net.corda.contracts
package net.corda.contracts.asset
Module Contents
val Amount<Currency>.CASH: State
val CASH_PROGRAM_ID: Cash
val COMMODITY_PROGRAM_ID: CommodityContract
class Cash : OnLedgerAsset<Currency, Commands, State>
Module Contents
Cash()
interface Clauses
interface Commands : Commands
data class State : FungibleAsset<Currency>, QueryableState
val conserveClause: AbstractConserveAmount<State, Commands, Currency>
fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Currency>>, owner: CompositeKey): TransactionState<State>
fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): List<AuthenticatedObject<Commands>>
fun generateExitCommand(amount: Amount<Issued<Currency>>): Exit
fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Currency>, pennies: Long, owner: CompositeKey, notary: Party): Unit
fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Currency>>, owner: CompositeKey, notary: Party): Unit
fun generateIssueCommand(): Issue
fun generateMoveCommand(): Move
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
class CommodityContract : OnLedgerAsset<Commodity, Commands, State>
Module Contents
CommodityContract()
interface Clauses
interface Commands : Commands
data class State : FungibleAsset<Commodity>
val conserveClause: AbstractConserveAmount<State, Commands, Commodity>
fun deriveState(txState: TransactionState<State>, amount: Amount<Issued<Commodity>>, owner: CompositeKey): TransactionState<State>
fun extractCommands(commands: Collection<AuthenticatedObject<CommandData>>): List<AuthenticatedObject<Commands>>
fun generateExitCommand(amount: Amount<Issued<Commodity>>): Exit
fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Commodity>, pennies: Long, owner: CompositeKey, notary: Party): Unit
fun generateIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: CompositeKey, notary: Party): Unit
fun generateIssueCommand(): Issue
fun generateMoveCommand(): Move
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
val DUMMY_CASH_ISSUER: PartyAndReference
val DUMMY_CASH_ISSUER_KEY: KeyPair
val DUMMY_OBLIGATION_ISSUER: Party
val DUMMY_OBLIGATION_ISSUER_KEY: KeyPair
val Amount<Issued<Currency>>.OBLIGATION: State<Currency>
val Issued<Currency>.OBLIGATION_DEF: Terms<Currency>
val OBLIGATION_PROGRAM_ID: Obligation<Currency>
class Obligation<P> : Contract
Module Contents
Obligation()
interface Clauses
Module Contents
class ConserveAmount<P> : AbstractConserveAmount<State<P>, Commands, Terms<P>>
class Group<P> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>
class Issue<P> : AbstractIssue<State<P>, Commands, Terms<P>>
class Net<C : CommandData, P> : NetClause<C, P>
class SetLifecycle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
class Settle<P> : Clause<State<P>, Commands, Issued<Terms<P>>>
class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P> : Clause<S, C, T>
interface Commands : Commands
enum class Lifecycle
data class State<P> : FungibleAsset<Terms<P>>, NettableState<State<P>, MultilateralNetState<P>>
Module Contents
State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: Party, template: Terms<P>, quantity: Long, beneficiary: CompositeKey)
State(lifecycle: Lifecycle = Lifecycle.NORMAL, obligor: AnonymousParty, template: Terms<P>, quantity: Long, beneficiary: CompositeKey)
val amount: Amount<Issued<Terms<P>>>
val beneficiary: CompositeKey
val bilateralNetState: BilateralNetState<P>
val contract: Obligation<Currency>
val dueBefore: Instant
val exitKeys: Collection<CompositeKey>
var lifecycle: Lifecycle
fun move(newAmount: Amount<Issued<Terms<P>>>, newOwner: CompositeKey): State<P>
val multilateralNetState: MultilateralNetState<P>
fun net(other: State<P>): State<P>
val obligor: AnonymousParty
val owner: CompositeKey
val participants: List<CompositeKey>
val quantity: Long
val template: Terms<P>
fun toString(): String
fun withNewOwner(newOwner: CompositeKey): Pair<Move, State<P>>
data class Terms<P>
fun generateCloseOutNetting(tx: TransactionBuilder, signer: CompositeKey, vararg states: State<P>): Unit
fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<Terms<P>>>, assetStates: List<StateAndRef<State<P>>>): CompositeKey
fun generateIssue(tx: TransactionBuilder, obligor: AbstractParty, issuanceDef: Terms<P>, pennies: Long, beneficiary: CompositeKey, notary: Party): Unit
fun generatePaymentNetting(tx: TransactionBuilder, issued: Issued<Terms<P>>, notary: Party, vararg states: State<P>): Unit
fun generateSetLifecycle(tx: TransactionBuilder, statesAndRefs: List<StateAndRef<State<P>>>, lifecycle: Lifecycle, notary: Party): Unit
fun generateSettle(tx: TransactionBuilder, statesAndRefs: Iterable<StateAndRef<State<P>>>, assetStatesAndRefs: Iterable<StateAndRef<FungibleAsset<P>>>, moveCommand: MoveCommand, notary: Party): Unit
val legalContractReference: SecureHash
fun verify(tx: TransactionForContract): Unit
abstract class OnLedgerAsset<T : Any, C : CommandData, S : FungibleAsset<T>> : Contract
val Amount<Issued<Currency>>.STATE: State
infix fun <T> State<T>.at(dueBefore: Instant): State<T>
infix fun <T> State<T>.between(parties: Pair<AbstractParty, CompositeKey>): State<T>
fun <P> extractAmountsDue(: Terms<P>, : Iterable<State<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<Terms<P>>>
infix fun State.issued by(party: AbstractParty): State
infix fun State.issued by(deposit: PartyAndReference): State
infix fun <T> State<T>.issued by(party: AbstractParty): State<T>
fun State.issuedBy(party: AbstractParty): State
fun State.issuedBy(deposit: PartyAndReference): State
fun <T> State<T>.issuedBy(party: AnonymousParty): State<T>
kotlin.collections.Iterable
fun <P> netAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<P>>
infix fun State.owned by(owner: CompositeKey): State
infix fun <T> State<T>.owned by(owner: CompositeKey): State<T>
fun State.ownedBy(owner: CompositeKey): State
fun <T> State<T>.ownedBy(owner: CompositeKey): State<T>
fun <P> sumAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<CompositeKey, Long>
infix fun State.with deposit(deposit: PartyAndReference): State
fun State.withDeposit(deposit: PartyAndReference): State
package net.corda.contracts.clause
Module Contents
abstract class AbstractConserveAmount<S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
Module Contents
AbstractConserveAmount()
fun generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, CompositeKey) -> TransactionState<S>, generateMoveCommand: () -> CommandData, generateExitCommand: (Amount<Issued<T>>) -> CommandData): CompositeKey
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: Issued<T>?): Set<C>
abstract class AbstractIssue<in S : ContractState, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
data class BilateralNetState<P> : NetState<P>
data class MultilateralNetState<P> : NetState<P>
open class NetClause<C : CommandData, P> : Clause<ContractState, C, Unit>
interface NetState<P>
open class NoZeroSizedOutputs<in S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>
package net.corda.contracts.testing
Module Contents
class CommandDataGenerator : Generator<CommandData>
class CommandGenerator : Generator<Command>
class ContractStateGenerator : Generator<ContractState>
class DummyDealContract : Contract
class DummyLinearContract : Contract
class ExitGenerator : Generator<Exit>
class IssueGenerator : Generator<Issue>
class MoveGenerator : Generator<Move>
class SignedTransactionGenerator : Generator<SignedTransaction>
class WiredTransactionGenerator : Generator<WireTransaction>
fun calculateRandomlySizedAmounts(howMuch: Amount<Currency>, min: Int, max: Int, rng: Random): LongArray
fun ServiceHub.fillWithSomeTestCash(howMuch: Amount<Currency>, outputNotary: Party = DUMMY_NOTARY, atLeastThisManyStates: Int = 3, atMostThisManyStates: Int = 10, rng: Random = Random(), ref: OpaqueBytes = OpaqueBytes(ByteArray(1, { 1 })), ownedBy: CompositeKey? = null, issuedBy: PartyAndReference = DUMMY_CASH_ISSUER, issuerKey: KeyPair = DUMMY_CASH_ISSUER_KEY): Vault<State>
fun ServiceHub.fillWithSomeTestDeals(dealIds: List<String>): Unit
fun ServiceHub.fillWithSomeTestLinearStates(numberToCreate: Int): Unit
package net.corda.core
package net.corda.core.contracts
Module Contents
enum class AccrualAdjustment
data class Amount<T> : Comparable<Amount<T>>
interface Attachment : NamedByHash
class AttachmentResolutionException : FlowException
data class AuthenticatedObject<out T : Any>
interface BilateralNettableState<N : BilateralNettableState<N>>
open class BusinessCalendar
Module Contents
val TEST_CALENDAR_DATA: Map<String, String>
class UnknownCalendar : Exception
open fun applyRollConvention(testDate: LocalDate, dateRollConvention: DateRollConvention): LocalDate
val calendars: List<String>
fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = getInstance(), dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate>
open fun equals(other: Any?): Boolean
fun getInstance(vararg calname: String): BusinessCalendar
fun getOffsetDate(startDate: LocalDate, period: Frequency, steps: Int = 1): LocalDate
open fun hashCode(): Int
val holidayDates: List<LocalDate>
open fun isWorkingDay(date: LocalDate): Boolean
fun moveBusinessDays(date: LocalDate, direction: DateRollDirection, i: Int): LocalDate
fun parseDateFromString(it: String): LocalDate
@JvmField val CHF: Currency
data class Command
interface CommandData
data class Commodity
interface Contract
interface ContractState
fun DOLLARS(amount: Int): Amount<Currency>
fun DOLLARS(amount: Double): Amount<Currency>
val DUMMY_PROGRAM_ID: DummyContract
val DUMMY_V2_PROGRAM_ID: DummyContractV2
enum class DateRollConvention
enum class DateRollDirection
enum class DayCountBasisDay
enum class DayCountBasisYear
interface DealState : LinearState
data class DummyContract : Contract
class DummyContractV2 : UpgradedContract<State, State>
data class DummyState : ContractState
@JvmField val EUR: Currency
data class Expression
object ExpressionDeserializer : JsonDeserializer<Expression>
object ExpressionSerializer : JsonSerializer<Expression>
@JvmField val FCOJ: Commodity
fun FCOJ(amount: Int): Amount<Commodity>
data class Fix : CommandData
data class FixOf
interface FixableDealState : DealState
enum class Frequency
interface FungibleAsset<T> : OwnableState
@JvmField val GBP: Currency
class InsufficientBalanceException : FlowException
interface IssuanceDefinition
interface IssueCommand : CommandData
data class Issued<out P>
interface LinearState : ContractState
interface MoveCommand : CommandData
interface MultilateralNettableState<out T : Any>
interface NamedByHash
interface NetCommand : CommandData
enum class NetType
interface NettableState<N : BilateralNettableState<N>, T : Any> : BilateralNettableState<N>, MultilateralNettableState<T>
interface OwnableState : ContractState
fun POUNDS(amount: Int): Amount<Currency>
data class PartyAndReference
enum class PaymentRule
object Requirements
fun SWISS_FRANCS(amount: Int): Amount<Currency>
interface SchedulableState : ContractState
interface Scheduled
data class ScheduledActivity : Scheduled
data class ScheduledStateRef : Scheduled
data class StateAndRef<out T : ContractState>
data class StateRef
data class Tenor
data class Timestamp
class TransactionConflictException : Exception
data class TransactionForContract
Module Contents
TransactionForContract(inputs: List<ContractState>, outputs: List<ContractState>, attachments: List<Attachment>, commands: List<AuthenticatedObject<CommandData>>, origHash: SecureHash, inputNotary: Party? = null, timestamp: Timestamp? = null)
data class InOutGroup<out T : ContractState, out K : Any>
val attachments: List<Attachment>
val commands: List<AuthenticatedObject<CommandData>>
fun equals(other: Any?): Boolean
fun <T : ContractState, K : Any> groupStates(ofType: Class<T>, selector: (T) -> K): List<InOutGroup<T, K>>
inline fun <reified T : ContractState, K : Any> groupStates(selector: (T) -> K): List<InOutGroup<T, K>>
fun <T : ContractState, K : Any> groupStatesInternal(inGroups: Map<K, List<T>>, outGroups: Map<K, List<T>>): List<InOutGroup<T, K>>
fun hashCode(): Int
val inputNotary: Party?
val inputs: List<ContractState>
val origHash: SecureHash
val outputs: List<ContractState>
val timestamp: Timestamp?
class TransactionGraphSearch : Callable<List<WireTransaction>>
class TransactionResolutionException : FlowException
data class TransactionState<out T : ContractState>
sealed class TransactionType
sealed class TransactionVerificationException : FlowException
abstract class TypeOnlyCommandData : CommandData
@JvmField val USD: Currency
data class UniqueIdentifier : Comparable<UniqueIdentifier>
data class UpgradeCommand : CommandData
interface UpgradedContract<in OldState : ContractState, out NewState : ContractState> : Contract
fun calculateDaysBetween(startDate: LocalDate, endDate: LocalDate, dcbYear: DayCountBasisYear, dcbDay: DayCountBasisDay): Int
fun commodity(code: String): Commodity
fun currency(code: String): Currency
fun ContractState.hash(): SecureHash
infix fun Commodity.issued by(deposit: PartyAndReference): Issued<Commodity>
infix fun Amount<Currency>.issued by(deposit: PartyAndReference): Amount<Issued<Currency>>
infix fun Commodity.issuedBy(deposit: PartyAndReference): Issued<Commodity>
infix fun Amount<Currency>.issuedBy(deposit: PartyAndReference): Amount<Issued<Currency>>
java.time.LocalDate
java.util.Currency
kotlin.Double
kotlin.Int
kotlin.collections.Collection
kotlin.collections.Iterable
inline fun <R> requireThat(body: Requirements.() -> R): R
fun Amount<Currency>.toDecimal(): BigDecimal
inline fun <reified T : MoveCommand> verifyMoveCommand(inputs: List<OwnableState>, tx: TransactionForContract): MoveCommand
inline fun <reified T : MoveCommand> verifyMoveCommand(inputs: List<OwnableState>, commands: List<AuthenticatedObject<CommandData>>): MoveCommand
infix fun <T : ContractState> T.with notary(newNotary: Party): TransactionState<T>
infix fun <T : ContractState> T.withNotary(newNotary: Party): TransactionState<T>
fun <T> Amount<Issued<T>>.withoutIssuer(): Amount<T>
package net.corda.core.contracts.clauses
Module Contents
class AllComposition<S : ContractState, C : CommandData, K : Any> : AllOf<S, C, K>
open class AllOf<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
AllOf(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
open val clauses: ArrayList<Clause<S, C, K>>
open fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class AnyComposition<in S : ContractState, C : CommandData, in K : Any> : AnyOf<S, C, K>
open class AnyOf<in S : ContractState, C : CommandData, in K : Any> : CompositeClause<S, C, K>
Module Contents
AnyOf(vararg rawClauses: Clause<S, C, K>)
open val clauses: List<Clause<S, C, K>>
open fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
open fun toString(): String
open fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
abstract class Clause<in S : ContractState, C : CommandData, in K : Any>
abstract class CompositeClause<in S : ContractState, C : CommandData, in K : Any> : Clause<S, C, K>
class FilterOn<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, K>
Module Contents
FilterOn(clause: Clause<S, C, K>, filterStates: (List<ContractState>) -> List<S>)
val clause: Clause<S, C, K>
val filterStates: (List<ContractState>) -> List<S>
fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
val requiredCommands: Set<Class<out CommandData>>
fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class FirstComposition<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
FirstComposition(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
val clauses: ArrayList<Clause<S, C, K>>
val firstClause: Clause<S, C, K>
val logger: Logger
fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
fun toString(): String
fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
class FirstOf<S : ContractState, C : CommandData, K : Any> : CompositeClause<S, C, K>
Module Contents
FirstOf(firstClause: Clause<S, C, K>, vararg remainingClauses: Clause<S, C, K>)
val clauses: ArrayList<Clause<S, C, K>>
val firstClause: Clause<S, C, K>
val logger: Logger
fun matchedClauses(commands: List<AuthenticatedObject<C>>): List<Clause<S, C, K>>
fun toString(): String
fun verify(tx: TransactionForContract, inputs: List<S>, outputs: List<S>, commands: List<AuthenticatedObject<C>>, groupingKey: K?): Set<C>
abstract class GroupClauseVerifier<S : ContractState, C : CommandData, K : Any> : Clause<ContractState, C, Unit>
Module Contents
GroupClauseVerifier(clause: Clause<S, C, K>)
val clause: Clause<S, C, K>
open fun getExecutionPath(commands: List<AuthenticatedObject<C>>): List<Clause<*, *, *>>
abstract fun groupStates(tx: TransactionForContract): List<InOutGroup<S, K>>
open fun verify(tx: TransactionForContract, inputs: List<ContractState>, outputs: List<ContractState>, commands: List<AuthenticatedObject<C>>, groupingKey: Unit?): Set<C>
fun <C : CommandData> Clause<*, C, *>.matches(commands: List<AuthenticatedObject<C>>): Boolean
fun <C : CommandData> verifyClause(tx: TransactionForContract, clause: Clause<ContractState, C, Unit>, commands: List<AuthenticatedObject<C>>): Unit
package net.corda.core.crypto
Module Contents
abstract class AbstractParty
class AnonymousParty : AbstractParty
class CertificateStream
sealed class CompositeKey
open class DigitalSignature : OpaqueBytes
class DummyPublicKey : PublicKey, Comparable<PublicKey>
sealed class MerkleTree
class MerkleTreeException : Exception
val NullCompositeKey: CompositeKey
object NullPublicKey : PublicKey, Comparable<PublicKey>
object NullSignature : WithKey
class PartialMerkleTree
class Party : AbstractParty
sealed class SecureHash : OpaqueBytes
open class SignedData<T : Any>
object X509Utilities
Module Contents
data class CACertAndKey
val CORDA_CLIENT_CA: String
val CORDA_CLIENT_CA_PRIVATE_KEY: String
val CORDA_INTERMEDIATE_CA: String
val CORDA_INTERMEDIATE_CA_PRIVATE_KEY: String
val CORDA_ROOT_CA: String
val CORDA_ROOT_CA_PRIVATE_KEY: String
val ECDSA_CURVE: String
val KEYSTORE_TYPE: String
val KEY_GENERATION_ALGORITHM: String
val SIGNATURE_ALGORITHM: String
fun KeyStore.addOrReplaceCertificate(alias: String, cert: Certificate): Unit
fun KeyStore.addOrReplaceKey(alias: String, key: Key, password: CharArray, chain: Array<Certificate>): Unit
fun createCAKeyStoreAndTrustStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, trustStoreFilePath: Path, trustStorePassword: String): KeyStore
fun createCertificateSigningRequest(myLegalName: String, nearestCity: String, email: String, keyPair: KeyPair): PKCS10CertificationRequest
fun createIntermediateCert(domain: String, certificateAuthority: CACertAndKey): CACertAndKey
fun createKeystoreForSSL(: Path, : String, : String, : KeyStore, : String, : String): KeyStore
fun createSelfSignedCACert(myLegalName: String): CACertAndKey
fun createServerCert(subject: X500Name, publicKey: PublicKey, certificateAuthority: CACertAndKey, subjectAlternativeNameDomains: List<String>, subjectAlternativeNameIps: List<String>): X509Certificate
fun generateECDSAKeyPairForSSL(): KeyPair
fun getDevX509Name(commonName: String): X500Name
fun getX509Name(myLegalName: String, nearestCity: String, email: String): X500Name
fun loadCertificateAndKey(keyStore: KeyStore, keyPassword: String, alias: String): CACertAndKey
fun loadCertificateFromKeyStore(keyStoreFilePath: Path, storePassword: String, alias: String): X509Certificate
fun loadCertificateFromPEMFile(filename: Path): X509Certificate
fun loadKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String): KeyPair
fun loadKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
fun loadKeyStore(input: InputStream, storePassword: String): KeyStore
fun loadOrCreateKeyPairFromKeyStore(keyStoreFilePath: Path, storePassword: String, keyPassword: String, alias: String, keyGenerator: () -> CACertAndKey): KeyPair
fun loadOrCreateKeyStore(keyStoreFilePath: Path, storePassword: String): KeyStore
fun saveCertificateAsPEMFile(x509Certificate: X509Certificate, filename: Path): Unit
fun saveKeyStore(keyStore: KeyStore, keyStoreFilePath: Path, storePassword: String): Unit
val ed25519Curve: EdDSANamedCurveSpec
fun entropyToKeyPair(entropy: BigInteger): KeyPair
fun generateKeyPair(): KeyPair
java.security.KeyPair
java.security.PrivateKey
java.security.PublicKey
kotlin.ByteArray
kotlin.String
kotlin.collections.Iterable
fun newSecureRandom(): SecureRandom
org.bouncycastle.asn1.x500.X500Name
fun parsePublicKeyBase58(base58String: String): EdDSAPublicKey
fun OpaqueBytes.sha256(): SHA256
package net.corda.core.flows
package net.corda.core.math
package net.corda.core.messaging
Module Contents
object Ack : DeserializeAsKotlinObjectDef
interface AllPossibleRecipients : MessageRecipients
interface CordaRPCOps : RPCOps
Module Contents
abstract fun addVaultTransactionNote(txnId: SecureHash, txnNote: String): Unit
abstract fun attachmentExists(id: SecureHash): Boolean
abstract fun authoriseContractUpgrade(state: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
abstract fun currentNodeTime(): Instant
abstract fun deauthoriseContractUpgrade(state: StateAndRef<*>): Unit
abstract fun getVaultTransactionNotes(txnId: SecureHash): Iterable<String>
@RPCReturnsObservables abstract fun networkMapUpdates(): Pair<List<NodeInfo>, Observable<MapChange>>
abstract fun nodeIdentity(): NodeInfo
abstract fun openAttachment(id: SecureHash): InputStream
abstract fun partyFromKey(key: CompositeKey): Party?
abstract fun partyFromName(name: String): Party?
@RPCReturnsObservables abstract fun <T : Any> startFlowDynamic(logicType: Class<out FlowLogic<T>>, vararg args: Any?): FlowHandle<T>
@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMapping(): Pair<List<StateMachineTransactionMapping>, Observable<StateMachineTransactionMapping>>
@RPCReturnsObservables abstract fun stateMachinesAndUpdates(): Pair<List<StateMachineInfo>, Observable<StateMachineUpdate>>
abstract fun uploadAttachment(jar: InputStream): SecureHash
abstract fun uploadFile(dataType: String, name: String?, file: InputStream): String
@RPCReturnsObservables abstract fun vaultAndUpdates(): Pair<List<StateAndRef<ContractState>>, Observable<Update>>
@RPCReturnsObservables abstract fun verifiedTransactions(): Pair<List<SignedTransaction>, Observable<SignedTransaction>>
@RPCReturnsObservables abstract fun waitUntilRegisteredWithNetworkMap(): ListenableFuture<Unit>
data class FlowHandle<A>
interface Message
interface MessageHandlerRegistration
interface MessageRecipientGroup : MessageRecipients
interface MessageRecipients
@ThreadSafe interface MessagingService
interface RPCOps
@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables
interface ReceivedMessage : Message
interface SingleMessageRecipient : MessageRecipients
data class StateMachineInfo
sealed class StateMachineUpdate
data class TopicSession
object TopicStringValidator
fun MessagingService.createMessage(topic: String, sessionID: Long = DEFAULT_SESSION_ID, data: ByteArray): Message
fun <M : Any> MessagingService.onNext(topic: String, sessionId: Long): ListenableFuture<M>
fun MessagingService.runOnNextMessage(topic: String, sessionID: Long, callback: (ReceivedMessage) -> Unit): Unit
inline fun MessagingService.runOnNextMessage(topicSession: TopicSession, crossinline callback: (ReceivedMessage) -> Unit): Unit
fun MessagingService.send(topic: String, sessionID: Long, payload: Any, to: MessageRecipients, uuid: UUID = UUID.randomUUID()): Unit
fun MessagingService.send(topicSession: TopicSession, payload: Any, to: MessageRecipients, uuid: UUID = UUID.randomUUID()): Unit
inline fun <T : Any, reified R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: () -> R): FlowHandle<T>
inline fun <T : Any, A, reified R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A) -> R, arg0: A): FlowHandle<T>
inline fun <T : Any, A, B, reified R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B) -> R, arg0: A, arg1: B): FlowHandle<T>
inline fun <T : Any, A, B, C, reified R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C) -> R, arg0: A, arg1: B, arg2: C): FlowHandle<T>
inline fun <T : Any, A, B, C, D, reified R : FlowLogic<T>> CordaRPCOps.startFlow(flowConstructor: (A, B, C, D) -> R, arg0: A, arg1: B, arg2: C, arg3: D): FlowHandle<T>
package net.corda.core.node
Module Contents
class AttachmentsClassLoader : SecureClassLoader
object CityDatabase
abstract class CordaPluginRegistry
Module Contents
CordaPluginRegistry(webApis: List<Function<CordaRPCOps, out Any>> = emptyList(), staticServeDirs: Map<String, String> = emptyMap(), requiredFlows: Map<String, Set<String>> = emptyMap(), servicePlugins: List<Function<PluginServiceHub, out Any>> = emptyList())
open fun registerRPCKryoTypes(kryo: Kryo): Boolean
open val requiredFlows: Map<String, Set<String>>
open val servicePlugins: List<Function<PluginServiceHub, out Any>>
open val staticServeDirs: Map<String, String>
open val webApis: List<Function<CordaRPCOps, out Any>>
data class NodeInfo
data class PhysicalLocation
interface PluginServiceHub : ServiceHub
data class ServiceEntry
interface ServiceHub
data class WorldCoordinate
fun ServiceHub.recordTransactions(vararg txs: SignedTransaction): Unit
package net.corda.core.node.services
Module Contents
interface AttachmentStorage
val DEFAULT_SESSION_ID: Long
interface FileUploader
interface IdentityService
interface KeyManagementService
sealed class NetworkCacheError : Exception
interface NetworkMapCache
sealed class PartyInfo
interface ReadOnlyTransactionStorage
interface SchedulerService
data class ServiceInfo
sealed class ServiceType
interface StateMachineRecordedTransactionMappingStorage
data class StateMachineTransactionMapping
interface StorageService
class TimestampChecker
interface TransactionStorage : ReadOnlyTransactionStorage
interface TxWritableStorageService : StorageService
class UniquenessException : Exception
interface UniquenessProvider
class Vault<out T : ContractState>
interface VaultService
Module Contents
abstract fun addNoteToTransaction(txnId: SecureHash, noteText: String): Unit
abstract fun authoriseContractUpgrade(stateAndRef: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
abstract val cashBalances: Map<Currency, Amount<Currency>>
abstract fun deauthoriseContractUpgrade(stateAndRef: StateAndRef<*>): Unit
abstract fun generateSpend(tx: TransactionBuilder, amount: Amount<Currency>, to: CompositeKey, onlyFromParties: Set<AbstractParty>? = null): Pair<TransactionBuilder, List<CompositeKey>>
abstract fun getAuthorisedContractUpgrade(ref: StateRef): Class<out UpgradedContract<*, *>>?
abstract fun getTransactionNotes(txnId: SecureHash): Iterable<String>
open fun notify(tx: WireTransaction): Unit
abstract fun notifyAll(txns: Iterable<WireTransaction>): Unit
abstract val rawUpdates: Observable<Update>
abstract fun <T : ContractState> states(clazzes: Set<Class<T>>, statuses: EnumSet<StateStatus>): List<StateAndRef<T>>
abstract fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
abstract fun track(): Pair<Vault<ContractState>, Observable<Update>>
abstract val updates: Observable<Update>
open fun whenConsumed(ref: StateRef): ListenableFuture<Update>
inline fun <reified T : ContractState> VaultService.consumedStates(): List<StateAndRef<T>>
inline fun <reified T : DealState> VaultService.dealsWith(party: AbstractParty): List<StateAndRef<T>>
kotlin.collections.Iterable
inline fun <reified T : LinearState> VaultService.linearHeadsOfType(): Map<UniqueIdentifier, StateAndRef<T>>
inline fun <reified T : ContractState> VaultService.unconsumedStates(): List<StateAndRef<T>>
package net.corda.core.schemas
package net.corda.core.schemas.requery
package net.corda.core.schemas.requery.converters
package net.corda.core.serialization
package net.corda.core.testing
package net.corda.core.transactions
Module Contents
abstract class BaseTransaction : NamedByHash
class FilteredLeaves : TraversableTransaction
class FilteredTransaction
class LedgerTransaction : BaseTransaction
data class SignedTransaction : NamedByHash
open class TransactionBuilder
Module Contents
TransactionBuilder(type: TransactionType = TransactionType.General(), notary: Party? = null, inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<TransactionState<ContractState>> = arrayListOf(), commands: MutableList<Command> = arrayListOf(), signers: MutableSet<CompositeKey> = mutableSetOf(), timestamp: Timestamp? = null)
fun addAttachment(attachmentId: SecureHash): Unit
fun addCommand(arg: Command): Unit
fun addCommand(data: CommandData, vararg keys: CompositeKey): Unit
fun addCommand(data: CommandData, keys: List<CompositeKey>): Unit
open fun addInputState(stateAndRef: StateAndRef<*>): Unit
fun addOutputState(state: TransactionState<*>): Int
@JvmOverloads fun addOutputState(state: ContractState, notary: Party, encumbrance: Int? = null): Int
fun addOutputState(state: ContractState): Int
fun addSignatureUnchecked(sig: WithKey): TransactionBuilder
fun attachments(): List<SecureHash>
protected val attachments: MutableList<SecureHash>
fun checkAndAddSignature(sig: WithKey): Unit
fun checkSignature(sig: WithKey): Unit
fun commands(): List<Command>
protected val commands: MutableList<Command>
fun copy(): TransactionBuilder
protected val currentSigs: ArrayList<WithKey>
fun inputStates(): List<StateRef>
protected val inputs: MutableList<StateRef>
var notary: Party?
fun outputStates(): List<TransactionState<*>>
protected val outputs: MutableList<TransactionState<ContractState>>
fun setTime(time: Instant, timeTolerance: Duration): Unit
fun setTime(newTimestamp: Timestamp): Unit
fun signWith(key: KeyPair): TransactionBuilder
protected val signers: MutableSet<CompositeKey>
val time: Timestamp?
protected var timestamp: Timestamp?
fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction
fun toWireTransaction(): WireTransaction
protected val type: TransactionType
fun withItems(vararg items: Any): TransactionBuilder
interface TraversableTransaction
class WireTransaction : BaseTransaction, TraversableTransaction
fun <T : Any> serializedHash(x: T): SecureHash
package net.corda.core.utilities
package net.corda.flows
package net.corda.node
package net.corda.node.driver
Module Contents
abstract class DriverBasedTest
open class DriverDSL : DriverDSLInternalInterface
Module Contents
DriverDSL(portAllocation: PortAllocation, debugPortAllocation: PortAllocation, driverDirectory: Path, useTestClock: Boolean, isDebug: Boolean)
class State
val debugPortAllocation: PortAllocation
val driverDirectory: Path
val isDebug: Boolean
val name: Array<String>
fun <A> pickA(array: Array<A>): A
val portAllocation: PortAllocation
fun registerProcess(process: ListenableFuture<Process>): Unit
open fun shutdown(): Unit
open fun start(): Unit
open fun startNode(providedName: String?, advertisedServices: Set<ServiceInfo>, rpcUsers: List<User>, customOverrides: Map<String, Any?>): ListenableFuture<NodeHandle>
open fun startNotaryCluster(notaryName: String, clusterSize: Int, type: ServiceType, rpcUsers: List<User>): ListenableFuture<Pair<Party, List<NodeHandle>>>
open fun startWebserver(handle: NodeHandle): ListenableFuture<HostAndPort>
val useTestClock: Boolean
open fun waitForAllNodesToFinish(): Unit
interface DriverDSLExposedInterface
interface DriverDSLInternalInterface : DriverDSLExposedInterface
data class NodeHandle
sealed class PortAllocation
fun addressMustBeBound(executorService: ScheduledExecutorService, hostAndPort: HostAndPort): ListenableFuture<Unit>
fun addressMustNotBeBound(executorService: ScheduledExecutorService, hostAndPort: HostAndPort): ListenableFuture<Unit>
@JvmOverloads fun <A> driver(isDebug: Boolean = false, driverDirectory: Path = Paths.get("build", getTimestampAsDirectoryName()), portAllocation: PortAllocation = PortAllocation.Incremental(10000), debugPortAllocation: PortAllocation = PortAllocation.Incremental(5005), useTestClock: Boolean = false, dsl: DriverDSLExposedInterface.() -> A): A
fun <DI : DriverDSLExposedInterface, D : DriverDSLInternalInterface, A> genericDriver(driverDsl: D, coerce: (D) -> DI, dsl: DI.() -> A): A
fun getTimestampAsDirectoryName(): String
fun writeConfig(path: Path, filename: String, config: Config): Unit
package net.corda.node.internal
Module Contents
abstract class AbstractNode : SingletonSerializeAsToken
class ConfigurationException : Exception
class CordaRPCOpsImpl : CordaRPCOps
Module Contents
CordaRPCOpsImpl(services: ServiceHub, smm: StateMachineManager, database: Database)
fun addVaultTransactionNote(txnId: SecureHash, txnNote: String): Unit
fun attachmentExists(id: SecureHash): Boolean
fun authoriseContractUpgrade(state: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
fun currentNodeTime(): Instant
val database: Database
fun deauthoriseContractUpgrade(state: StateAndRef<*>): Unit
fun getVaultTransactionNotes(txnId: SecureHash): Iterable<String>
fun networkMapUpdates(): Pair<List<NodeInfo>, Observable<MapChange>>
fun nodeIdentity(): NodeInfo
fun openAttachment(id: SecureHash): InputStream
fun partyFromKey(key: CompositeKey): Party?
fun partyFromName(name: String): Party?
val protocolVersion: Int
val services: ServiceHub
val smm: StateMachineManager
fun <T : Any> startFlowDynamic(logicType: Class<out FlowLogic<T>>, vararg args: Any?): FlowHandle<T>
fun stateMachineRecordedTransactionMapping(): Pair<List<StateMachineTransactionMapping>, Observable<StateMachineTransactionMapping>>
fun stateMachinesAndUpdates(): Pair<List<StateMachineInfo>, Observable<StateMachineUpdate>>
fun uploadAttachment(jar: InputStream): SecureHash
fun uploadFile(dataType: String, name: String?, file: InputStream): String
fun vaultAndUpdates(): Pair<List<StateAndRef<ContractState>>, Observable<Update>>
fun verifiedTransactions(): Pair<List<SignedTransaction>, Observable<SignedTransaction>>
fun waitUntilRegisteredWithNetworkMap(): ListenableFuture<Unit>
data class NetworkMapInfo
class Node : AbstractNode
package net.corda.node.serialization
package net.corda.node.services
package net.corda.node.services.api
package net.corda.node.services.config
package net.corda.node.services.database
Module Contents
class KotlinConfigurationTransactionWrapper : Configuration
Module Contents
KotlinConfigurationTransactionWrapper(model: EntityModel, dataSource: DataSource, mapping: Mapping? = null, platform: Platform? = null, cache: EntityCache = WeakEntityCache(), useDefaultLogging: Boolean = false, statementCacheSize: Int = 0, batchUpdateSize: Int = 64, quoteTableNames: Boolean = false, quoteColumnNames: Boolean = false, tableTransformer: Function<String, String>? = null, columnTransformer: Function<String, String>? = null, transactionMode: TransactionMode = TransactionMode.NONE, transactionIsolation: TransactionIsolation? = null, statementListeners: Set<StatementListener> = LinkedHashSet(), entityStateListeners: Set<EntityStateListener<Any>> = LinkedHashSet(), transactionListeners: Set<Supplier<TransactionListener>> = LinkedHashSet(), writeExecutor: Executor? = null)
class CordaConnection : Connection
class CordaDataSourceConnectionProvider : ConnectionProvider
fun getBatchUpdateSize(): Int
fun getCache(): EntityCache?
fun getColumnTransformer(): Function<String, String>?
fun getConnectionProvider(): ConnectionProvider?
fun getEntityStateListeners(): Set<EntityStateListener<Any>>
fun getMapping(): Mapping?
fun getModel(): EntityModel
fun getPlatform(): Platform?
fun getQuoteColumnNames(): Boolean
fun getQuoteTableNames(): Boolean
fun getStatementCacheSize(): Int
fun getStatementListeners(): Set<StatementListener>?
fun getTableTransformer(): Function<String, String>?
fun getTransactionIsolation(): TransactionIsolation?
fun getTransactionListenerFactories(): Set<Supplier<TransactionListener>>?
fun getTransactionMode(): TransactionMode?
fun getUseDefaultLogging(): Boolean
fun getWriteExecutor(): Executor?
class RequeryConfiguration
package net.corda.node.services.events
package net.corda.node.services.identity
package net.corda.node.services.keys
package net.corda.node.services.messaging
Module Contents
abstract class ArtemisMessagingComponent : SingletonSerializeAsToken
@ThreadSafe class ArtemisMessagingServer : ArtemisMessagingComponent
@JvmField val CURRENT_RPC_USER: ThreadLocal<User>
object ClassSerializer : Serializer<Class<*>>
data class ClientRPCRequestMessage
@ThreadSafe class CordaRPCClient : Closeable, ArtemisMessagingComponent
class CordaRPCClientImpl
data class MarshalledObservation
class NodeLoginModule : LoginModule
@ThreadSafe class NodeMessagingClient : ArtemisMessagingComponent, MessagingServiceInternal
Module Contents
NodeMessagingClient(config: NodeConfiguration, serverHostPort: HostAndPort, myIdentity: CompositeKey?, nodeExecutor: AffinityExecutor, database: Database, networkMapRegistrationFuture: ListenableFuture<Unit>)
data class Handler : MessageHandlerRegistration
const val SESSION_ID_PROPERTY: String
const val TOPIC_PROPERTY: String
fun addMessageHandler(topic: String, sessionID: Long, callback: (ReceivedMessage, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
fun addMessageHandler(topicSession: TopicSession, callback: (ReceivedMessage, MessageHandlerRegistration) -> Unit): MessageHandlerRegistration
val config: NodeConfiguration
fun createMessage(topicSession: TopicSession, data: ByteArray, uuid: UUID): Message
val database: Database
fun getAddressOfParty(partyInfo: PartyInfo): MessageRecipients
val myAddress: SingleMessageRecipient
val myIdentity: CompositeKey?
val networkMapRegistrationFuture: ListenableFuture<Unit>
val nodeExecutor: AffinityExecutor
fun removeMessageHandler(registration: MessageHandlerRegistration): Unit
fun run(): Unit
fun send(message: Message, target: MessageRecipients): Unit
val serverHostPort: HostAndPort
fun start(rpcOps: RPCOps, userService: RPCUserService): Unit
fun stop(): Unit
class PermissionException : RuntimeException
abstract class RPCDispatcher
open class RPCException : RuntimeException
@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion
class VerifyingNettyConnectorFactory : NettyConnectorFactory
fun createRPCKryo(observableSerializer: Serializer<Observable<Any>>? = null): Kryo
fun requirePermission(permission: String): Unit
val rpcLog: Logger
package net.corda.node.services.network
package net.corda.node.services.persistence
package net.corda.node.services.schema
package net.corda.node.services.statemachine
Module Contents
data class ErrorSessionEnd : SessionEnd
interface ExistingSessionMessage : SessionMessage
interface FlowIORequest
class FlowSession
class FlowSessionException : RuntimeException
sealed class FlowSessionState
class FlowStateMachineImpl<R> : Fiber<Unit>, FlowStateMachine<R>
Module Contents
FlowStateMachineImpl(id: StateMachineRunId, logic: FlowLogic<R>, scheduler: FiberScheduler)
fun currentStateMachine(): FlowStateMachineImpl<*>?
val id: StateMachineRunId
val logger: Logger
val logic: FlowLogic<R>
@Suspendable fun <T : Any> receive(receiveType: Class<T>, otherParty: Party, sessionFlow: FlowLogic<*>): UntrustworthyData<T>
val resultFuture: ListenableFuture<R>
@Suspendable protected fun run(): Unit
@Suspendable fun send(otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): Unit
@Suspendable fun <T : Any> sendAndReceive(receiveType: Class<T>, otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): UntrustworthyData<T>
@Transient lateinit var serviceHub: ServiceHubInternal
@Suspendable fun waitForLedgerCommit(hash: SecureHash, sessionFlow: FlowLogic<*>): SignedTransaction
data class NormalSessionEnd : SessionEnd
data class ReceiveOnly<T : SessionMessage> : ReceiveRequest<T>
interface ReceiveRequest<T : SessionMessage> : SessionedFlowIORequest, WaitingRequest
data class ReceivedSessionMessage<out M : ExistingSessionMessage>
data class SendAndReceive<T : SessionMessage> : SendRequest, ReceiveRequest<T>
data class SendOnly : SendRequest
interface SendRequest : SessionedFlowIORequest
data class SessionConfirm : SessionInitResponse
data class SessionData : ExistingSessionMessage
interface SessionEnd : ExistingSessionMessage
data class SessionInit : SessionMessage
interface SessionInitResponse : ExistingSessionMessage
interface SessionMessage
data class SessionReject : SessionInitResponse
interface SessionedFlowIORequest : FlowIORequest
class StackSnapshot : Throwable
@ThreadSafe class StateMachineManager
data class WaitForLedgerCommit : WaitingRequest
interface WaitingRequest : FlowIORequest
fun <T> ReceivedSessionMessage<SessionData>.checkPayloadIs(type: Class<T>): UntrustworthyData<T>
package net.corda.node.services.transactions
package net.corda.node.services.vault
Module Contents
class CashBalanceAsMetricsObserver
class NodeVaultService : SingletonSerializeAsToken, VaultService
Module Contents
NodeVaultService(services: ServiceHub, dataSourceProperties: Properties)
fun addNoteToTransaction(txnId: SecureHash, noteText: String): Unit
fun authoriseContractUpgrade(stateAndRef: StateAndRef<*>, upgradedContractClass: Class<out UpgradedContract<*, *>>): Unit
val cashBalances: Map<Currency, Amount<Currency>>
val configuration: RequeryConfiguration
fun deauthoriseContractUpgrade(stateAndRef: StateAndRef<*>): Unit
fun generateSpend(tx: TransactionBuilder, amount: Amount<Currency>, to: CompositeKey, onlyFromParties: Set<AbstractParty>?): Pair<TransactionBuilder, List<CompositeKey>>
fun getAuthorisedContractUpgrade(ref: StateRef): Class<out UpgradedContract<*, *>>?
fun getTransactionNotes(txnId: SecureHash): Iterable<String>
val log: Logger
fun notifyAll(txns: Iterable<WireTransaction>): Unit
val rawUpdates: Observable<Update>
val session: KotlinEntityDataStore<Persistable>
fun <T : ContractState> states(clazzes: Set<Class<T>>, statuses: EnumSet<StateStatus>): List<StateAndRef<T>>
fun statesForRefs(refs: List<StateRef>): Map<StateRef, TransactionState<*>?>
fun track(): Pair<Vault<ContractState>, Observable<Update>>
val updates: Observable<Update>
package net.corda.node.utilities
Module Contents
class ANSIProgressObserver
object ANSIProgressRenderer
abstract class AbstractJDBCHashMap<K : Any, V : Any, out T : JDBCHashedTable> : MutableMap<K, V>, AbstractMap<K, V>
Module Contents
AbstractJDBCHashMap(table: T, loadOnInit: Boolean = false, maxBuckets: Int = DEFAULT_MAX_BUCKETS)
protected abstract fun addKeyToInsert(insert: InsertStatement, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
protected abstract fun addValueToInsert(insert: InsertStatement, entry: Entry<K, V>, finalizables: MutableList<() -> Unit>): Unit
open fun clear(): Unit
open fun containsKey(key: K): Boolean
open fun containsValue(value: V): Boolean
open val entries: MutableSet<MutableEntry<K, V>>
open fun get(key: K): V?
open fun isEmpty(): Boolean
protected abstract fun keyFromRow(row: ResultRow): K
open val keys: MutableSet<K>
val loadOnInit: Boolean
protected val log: Logger
val maxBuckets: Int
open fun put(key: K, value: V): V?
open fun remove(key: K): V?
open val size: Int
val table: T
protected abstract fun valueFromRow(row: ResultRow): V
open val values: MutableCollection<V>
abstract class AbstractJDBCHashSet<K : Any, out T : JDBCHashedTable> : MutableSet<K>, AbstractSet<K>
enum class AddOrRemove
interface AffinityExecutor : Executor
object CompositeKeyColumnType : ColumnType
val DEFAULT_MAX_BUCKETS: Int
class FiberBox<out T>
object InstantColumnType : ColumnType
class JDBCHashMap<K : Any, V : Any> : AbstractJDBCHashMap<K, V, BlobMapTable>
class JDBCHashSet<K : Any> : AbstractJDBCHashSet<K, BlobSetTable>
open class JDBCHashedTable : Table
object JsonSupport
object LocalDateColumnType : ColumnType
object LocalDateTimeColumnType : ColumnType
abstract class MutableClock : Clock
const val NODE_DATABASE_PREFIX: String
data class PartyColumns
object PublicKeyColumnType : ColumnType
object SecureHashColumnType : ColumnType
object ServiceIdentityGenerator
data class StateRefColumns
class StrandLocalTransactionManager : TransactionManager
@ThreadSafe class TestClock : MutableClock, SerializeAsToken
data class TxnNoteColumns
object UUIDStringColumnType : ColumnType
fun <T : Any> bytesFromBlob(blob: Blob): SerializedBytes<T>
fun bytesToBlob(value: SerializedBytes<*>, finalizables: MutableList<() -> Unit>): Blob
com.typesafe.config.Config
fun configureDatabase(props: Properties): Pair<Closeable, Database>
fun createDatabaseTransaction(db: Database): Transaction
fun <T> databaseTransaction(db: Database, statement: Transaction.() -> T): T
fun <T : Any> deserializeFromBlob(blob: Blob): T
fun <T> isolatedTransaction(database: Database, block: Transaction.() -> T): T
java.time.Clock
fun main(args: Array<String>): Unit
org.jetbrains.exposed.sql.Table
rx.Observable
rx.Observer
fun serializeToBlob(value: Any, finalizables: MutableList<() -> Unit>): Blob
package net.corda.node.utilities.registration
package net.corda.node.webserver
package net.corda.node.webserver.api
package net.corda.node.webserver.internal
package net.corda.node.webserver.servlets
package net.corda.schemas