net.corda.protocols

## Package net.corda.protocols

### Types

AbstractStateReplacementProtocol | `abstract class AbstractStateReplacementProtocol<T>` Abstract protocol 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 protocols.
BroadcastTransactionProtocol | `class BroadcastTransactionProtocol : ProtocolLogic<Unit>` Notify all involved parties about a transaction, including storing a copy. Normally this would be called via FinalityProtocol.
CashCommand | `sealed class CashCommand` A command to initiate the Cash protocol with.
CashProtocol | `class CashProtocol : ProtocolLogic<CashProtocolResult>` Initiates a protocol that produces an Issue/Move or Exit Cash transaction.
CashProtocolResult | `sealed class CashProtocolResult`
FetchAttachmentsProtocol | `class FetchAttachmentsProtocol : FetchDataProtocol<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.
FetchDataProtocol | `abstract class FetchDataProtocol<T : NamedByHash, in W : Any> : ProtocolLogic<Result<T>>` An abstract protocol for fetching typed data from a remote peer.
FetchTransactionsProtocol | `class FetchTransactionsProtocol : FetchDataProtocol<SignedTransaction, SignedTransaction>` Given a set of tx hashes (IDs), either loads them from local disk or asks the remote peer to provide them.
FinalityProtocol | `class FinalityProtocol : ProtocolLogic<Unit>` Finalise a transaction by notarising it, then recording it locally, and then sending it to all involved parties.
NotaryChangeProtocol | `object NotaryChangeProtocol : AbstractStateReplacementProtocol<Party>` A protocol 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`
NotaryProtocol | `object NotaryProtocol`
ResolveTransactionsProtocol | `class ResolveTransactionsProtocol : ProtocolLogic<List<LedgerTransaction>>` This protocol 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
TwoPartyDealProtocol | `object TwoPartyDealProtocol` Classes for manipulating a two party deal or agreement.
TwoPartyTradeProtocol | `object TwoPartyTradeProtocol` This asset trading protocol implements a "delivery vs payment" type swap. It has two parties (B and S for buyer and seller) and the following steps:
ValidatingNotaryProtocol | `class ValidatingNotaryProtocol : Service` A notary commit protocol 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.