net.corda.flows

## Class NotaryFlow.Client

- FlowLogic
- - net.corda.flows.NotaryFlow.Client

- Enclosing class:
    NotaryFlow

      public static class NotaryFlow.Client
      extends FlowLogic

  A flow to be used by a party for obtaining signature(s) from a NotaryService ascertaining the transaction timestamp is correct and none of its inputs have been used in another completed transaction.

  In case of a single-node or Raft notary, the flow will return a single signature. For the BFT notary multiple signatures will be returned – one from each replica that accepted the input state commit.

  See Also:
    NotaryService

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Client.Companion`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Client.Companion` | `Companion`
    `Party` | `notaryParty`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Client(SignedTransaction stx, ProgressTracker progressTracker)` A flow to be used by a party for obtaining signature(s) from a NotaryService ascertaining the transaction timestamp is correct and none of its inputs have been used in another completed transaction.
    `Client(SignedTransaction stx)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.List<net.corda.core.crypto.DigitalSignature.WithKey>` | `call()` This is where you fill out your business logic. The returned object will usually be ignored, but can be helpful if this flow is meant to be used as a subflow.
    `Party` | `getNotaryParty()`
    `ProgressTracker` | `getProgressTracker()` Override this to provide a `class ProgressTracker`. If one is provided and stepped, the framework will do something helpful with the progress reports. If this flow is invoked as a subflow of another, then the tracker will be made a child of the current step in the parent. If it's null, this flow doesn't track progress.
    `void` | `setNotaryParty(Party p)`

    - ### Methods inherited from class net.corda.core.flows.FlowLogic

      `call, getCounterpartyMarker, getLogger, getProgressTracker, getRunId, getServiceHub, getStateMachine, receive, send, sendAndReceive, setStateMachine, subFlow, subFlow, track, waitForLedgerCommit`

- - ### Field Detail

    - #### notaryParty

          public Party notaryParty

    - #### Companion

          public static Client.Companion Companion

  - ### Constructor Detail

    - #### Client

          public Client(SignedTransaction stx,
                        ProgressTracker progressTracker)

      A flow to be used by a party for obtaining signature(s) from a NotaryService ascertaining the transaction timestamp is correct and none of its inputs have been used in another completed transaction.

      In case of a single-node or Raft notary, the flow will return a single signature. For the BFT notary multiple signatures will be returned – one from each replica that accepted the input state commit.

      Parameters:
        `progressTracker` -

        Override this to provide a `class ProgressTracker`. If one is provided and stepped, the framework will do something helpful with the progress reports. If this flow is invoked as a subflow of another, then the tracker will be made a child of the current step in the parent. If it's null, this flow doesn't track progress.

        Note that this has to return a tracker before the flow is invoked. You can't change your mind half way through.

      Throws:
        - in case the any of the inputs to the transaction have been consumed by another transaction or the timestamp is invalid.
      See Also:
        NotaryService

    - #### Client

          public Client(SignedTransaction stx)

  - ### Method Detail

    - #### getNotaryParty

          public Party getNotaryParty()

    - #### setNotaryParty

          public void setNotaryParty(Party p)

    - #### call

          public java.util.List<net.corda.core.crypto.DigitalSignature.WithKey> call()

      This is where you fill out your business logic. The returned object will usually be ignored, but can be helpful if this flow is meant to be used as a subflow.

    - #### getProgressTracker

          public ProgressTracker getProgressTracker()

      Override this to provide a `class ProgressTracker`. If one is provided and stepped, the framework will do something helpful with the progress reports. If this flow is invoked as a subflow of another, then the tracker will be made a child of the current step in the parent. If it's null, this flow doesn't track progress.

      Note that this has to return a tracker before the flow is invoked. You can't change your mind half way through.

      See Also:
        `class ProgressTracker`