Interface Contract

Example: Evaluate transaction

const result = await contract.evaluate('transactionName', {
    arguments: ['one', 'two'],
    // Specify additional proposal options here
});
Copy

Example: Submit transaction

const result = await contract.submit('transactionName', {
    arguments: ['one', 'two'],
    // Specify additional proposal options here
});
Copy

Example: Async submit

const commit = await contract.submitAsync('transactionName', {
    arguments: ['one', 'two']
});
const result = commit.getResult();

// Update UI or reply to REST request before waiting for commit status

const status = await commit.getStatus();
if (!status.successful) {
    throw new Error(`transaction ${status.transactionId} failed with status code ${status.code}`);
}
Copy

A finer-grained transaction flow can be employed by using newProposal. This allows retry of individual steps in the flow in response to errors.

Example: Fine-grained submit transaction

const proposal = contract.newProposal('transactionName');
const transaction = await proposal.endorse();
const commit = await transaction.submit();

const result = transaction.getResult();
const status = await commit.getStatus();
Copy

Off-line signing

By default, proposal, transaction and commit status messages will be signed using the signing implementation specified when connecting the Gateway. In cases where an external client holds the signing credentials, a default signing implementation can be omitted and off-line signing can be carried out by:

1. Returning the serialized proposal, transaction or commit status message along with its digest to the client for them to generate a signature.
2. With the serialized message and signature received from the client to create a signed proposal, transaction or commit using the Gateway.newSignedProposal, Gateway.newSignedTransaction or Gateway.newSignedCommit methods respectively.

Note that the message digest is created with the hash implementation specified by the hash option passed to the connect function used to create the Gateway instance. For off-line signing implementations that require the entire message content, a none (or no-op) hash implementation should be specified.

Example: Off-line signing

const unsignedProposal = contract.newProposal('transactionName');
const proposalBytes = unsignedProposal.getBytes();
const proposalDigest = unsignedProposal.getDigest();
const proposalSignature = // Generate signature from digest
const signedProposal = gateway.newSignedProposal(proposalBytes, proposalSignature);

const unsignedTransaction = await signedProposal.endorse();
const transactionBytes = unsignedTransaction.getBytes();
const transactionDigest = unsignedTransaction.getDigest();
const transactionSignature = // Generate signature from digest
const signedTransaction = gateway.newSignedTransaction(transactionBytes, transactionSignature);

const unsignedCommit = await signedTransaction.submit();
const commitBytes = unsignedCommit.getBytes();
const commitDigest = unsignedCommit.getDigest();
const commitSignature = // Generate signature from digest
const signedCommit = gateway.newSignedCommit(commitBytes, commitSignature);

const result = signedTransaction.getResult();
const status = await signedCommit.getStatus();
Copy