protocols / TwoPartyDealProtocol / Primary

# Primary

`abstract class Primary<U> : ProtocolLogic<SignedTransaction>`

Abstracted bilateral deal protocol participant that initiates communication/handshake.

Theres a good chance we can push at least some of this logic down into core protocol logic and helper methods etc.

### Types

AWAITING_PROPOSAL | `object AWAITING_PROPOSAL : Step`
COPYING_TO_REGULATOR | `object COPYING_TO_REGULATOR : Step`
RECORDING | `object RECORDING : Step`
SENDING_SIGS | `object SENDING_SIGS : Step`
SIGNING | `object SIGNING : Step`
TIMESTAMPING | `object TIMESTAMPING : Step`
VERIFYING | `object VERIFYING : Step`

### Constructors

<init> | `Primary(payload: U, otherSide: SingleMessageRecipient, otherSessionID: Long, myKeyPair: KeyPair, timestampingAuthority: NodeInfo, progressTracker: ProgressTracker = Primary.tracker())` Abstracted bilateral deal protocol participant that initiates communication/handshake.

### Properties

myKeyPair | `val myKeyPair: KeyPair`
otherSessionID | `val otherSessionID: Long`
otherSide | `val otherSide: SingleMessageRecipient`
payload | `val payload: U`
progressTracker | `open val progressTracker: ProgressTracker` Override this to provide a ProgressTracker. If one is provided and stepped, the framework will do something helpful with the progress reports. If this protocol is invoked as a sub-protocol of another, then the tracker will be made a child of the current step in the parent. If its null, this protocol doesnt track progress.
timestampingAuthority | `val timestampingAuthority: NodeInfo`

### Inherited Properties

logger | `val logger: <ERROR CLASS>` This is where you should log things to.
psm | `lateinit var psm: ProtocolStateMachine<*>` Reference to the Fiber instance that is the top level controller for the entire flow.
serviceHub | `val serviceHub: ServiceHub` Provides access to big, heavy classes that may be reconstructed from time to time, e.g. across restarts

### Functions

call | `open fun call(): SignedTransaction` This is where you fill out your business logic.
getPartialTransaction | `fun getPartialTransaction(): UntrustworthyData<SignedTransaction>`
signWithOurKey | `open fun signWithOurKey(partialTX: SignedTransaction): WithKey`
verifyPartialTransaction | `fun verifyPartialTransaction(untrustedPartialTX: UntrustworthyData<SignedTransaction>): SignedTransaction`

### Inherited Functions

receive | `fun <T : Any> receive(topic: String, sessionIDForReceive: Long): UntrustworthyData<T>` `fun <T : Any> receive(topic: String, sessionIDForReceive: Long, clazz: Class<T>): UntrustworthyData<T>`
send | `fun send(topic: String, destination: MessageRecipients, sessionID: Long, obj: Any): Unit`
sendAndReceive | `fun <T : Any> sendAndReceive(topic: String, destination: MessageRecipients, sessionIDForSend: Long, sessionIDForReceive: Long, obj: Any): UntrustworthyData<T>`
subProtocol | `fun <R> subProtocol(subLogic: ProtocolLogic<R>): R` Invokes the given subprotocol by simply passing through this ProtocolLogics reference to the ProtocolStateMachine and then calling the call method.

### Companion Object Functions

tracker | `fun tracker(): <ERROR CLASS>`

### Inheritors

Floater | `class Floater<T : FixableDealState> : Primary<StateRef>` One side of the fixing protocol for an interest rate swap, but could easily be generalised furher
Instigator | `class Instigator<T : DealState> : Primary<T>` One side of the protocol for inserting a pre-agreed deal.