net.corda.flows

## Package net.corda.flows

### Types

AbstractStateReplacementFlow | `abstract class AbstractStateReplacementFlow<T>` Abstract flow to be used for replacing one state with another, for example when changing the notary of a state. Notably this requires a one to one replacement of states, states cannot be split, merged or issued as part of these flows.
BroadcastTransactionFlow | `class BroadcastTransactionFlow : FlowLogic<Unit>` Notify all involved parties about a transaction, including storing a copy. Normally this would be called via FinalityFlow.
CashCommand | `sealed class CashCommand` A command to initiate the Cash flow with.
CashFlow | `class CashFlow : FlowLogic<CashFlowResult>` Initiates a flow that produces an Issue/Move or Exit Cash transaction.
CashFlowResult | `sealed class CashFlowResult`
FetchAttachmentsFlow | `class FetchAttachmentsFlow : FetchDataFlow<Attachment, ByteArray>` Given a set of hashes either loads from from local storage or requests them from the other peer. Downloaded attachments are saved to local storage automatically.
FetchDataFlow | `abstract class FetchDataFlow<T : NamedByHash, in W : Any> : FlowLogic<Result<T>>` An abstract flow for fetching typed data from a remote peer.
FetchTransactionsFlow | `class FetchTransactionsFlow : FetchDataFlow<SignedTransaction, SignedTransaction>` Given a set of tx hashes (IDs), either loads them from local disk or asks the remote peer to provide them.
FinalityFlow | `class FinalityFlow : FlowLogic<Unit>` Finalise a transaction by notarising it, then recording it locally, and then sending it to all involved parties.
NotaryChangeFlow | `object NotaryChangeFlow : AbstractStateReplacementFlow<Party>` A flow to be used for changing a states Notary. This is required since all input states to a transaction must point to the same notary.
NotaryError | `sealed class NotaryError`
NotaryFlow | `object NotaryFlow`
ResolveTransactionsFlow | `class ResolveTransactionsFlow : FlowLogic<List<LedgerTransaction>>` This flow is used to verify the validity of a transaction by recursively checking the validity of all the dependencies. Once a transaction is checked its inserted into local storage so it can be relayed and wont be checked again.
ServiceRequestMessage | `interface ServiceRequestMessage` Abstract superclass for request messages sent to services which expect a reply.
StateReplacementRefused | `class StateReplacementRefused` Thrown when a participant refuses the proposed state replacement
TwoPartyDealFlow | `object TwoPartyDealFlow` Classes for manipulating a two party deal or agreement.
TwoPartyTradeFlow | `object TwoPartyTradeFlow` This asset trading flow implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:
ValidatingNotaryFlow | `class ValidatingNotaryFlow : Service` A notary commit flow that makes sure a given transaction is valid before committing it. This does mean that the calling party has to reveal the whole transaction history; however, we avoid complex conflict resolution logic where a party has its input states "blocked" by a transaction from another party, and needs to establish whether that transaction was indeed valid.

### Exceptions

InputStateRefResolveFailed | `class InputStateRefResolveFailed : Exception`
NotaryException | `class NotaryException : Exception`
StateReplacementException | `class StateReplacementException : Exception`

### Functions

sendRequest | `fun <R : Any> MessagingService.sendRequest(topic: String, request: ServiceRequestMessage, target: SingleMessageRecipient): <ERROR CLASS><R>` Sends a ServiceRequestMessage to target and returns a ListenableFuture of the response.