verifyTransaction.java

progressTracker.setCurrentStep(TX_VERIFICATION);

// Verifying a transaction will also verify every transaction in
// the transaction's dependency chain, which will require
// transaction data access on counterparty's node. The
// ``SendTransactionFlow`` can be used to automate the sending and
// data vending process. The ``SendTransactionFlow`` will listen
// for data request until the transaction is resolved and verified
// on the other side:
subFlow(new SendTransactionFlow(counterpartySession, twiceSignedTx));

// Optional request verification to further restrict data access.
subFlow(new SendTransactionFlow(counterpartySession, twiceSignedTx) {
    @Override
    protected void verifyDataRequest(@NotNull FetchDataFlow.Request.Data dataRequest) {
        // Extra request verification.
    }
});

// We can receive the transaction using ``ReceiveTransactionFlow``,
// which will automatically download all the dependencies and verify
// the transaction and then record in our vault
SignedTransaction verifiedTransaction = subFlow(new ReceiveTransactionFlow(counterpartySession));

// We can also send and receive a `StateAndRef` dependency chain and automatically resolve its dependencies.
subFlow(new SendStateAndRefFlow(counterpartySession, dummyStates));

// On the receive side ...
List<StateAndRef<DummyState>> resolvedStateAndRef = subFlow(new ReceiveStateAndRefFlow<>(counterpartySession));

try {
    // We can now verify the transaction to ensure that it satisfies
    // the contracts of all the transaction's input and output states.
    twiceSignedTx.verify(getServiceHub());

    // We'll often want to perform our own additional verification
    // too. Just because a transaction is valid based on the contract
    // rules and requires our signature doesn't mean we have to
    // sign it! We need to make sure the transaction represents an
    // agreement we actually want to enter into.

    // To do this, we need to convert our ``SignedTransaction``
    // into a ``LedgerTransaction``. This will use our ServiceHub
    // to resolve the transaction's inputs and attachments into
    // actual objects, rather than just references.
    LedgerTransaction ledgerTx = twiceSignedTx.toLedgerTransaction(getServiceHub());

    // We can now perform our additional verification.
    DummyState outputState = ledgerTx.outputsOfType(DummyState.class).get(0);
    if (outputState.getMagicNumber() != 777) {
        // ``FlowException`` is a special exception type. It will be
        // propagated back to any counterparty flows waiting for a
        // message from this flow, notifying them that the flow has
        // failed.
        throw new FlowException("We expected a magic number of 777.");
    }
} catch (GeneralSecurityException e) {
    // Handle this as required.
}

// Of course, if you are not a required signer on the transaction,
// you have no power to decide whether it is valid or not. If it
// requires signatures from all the required signers and is
// contractually valid, it's a valid ledger update.