Interface Contract

Represents a smart contract, and allows applications to:

• Evaluate transactions that query state from the ledger using evaluateTransaction.
• Submit transactions that store state to the ledger using submitTransaction.

For more complex transaction invocations, such as including private data, transactions can be evaluated or submitted using evaluate or submit respectively. The result of a submitted transaction can be accessed prior to its commit to the ledger using submitAsync.

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

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's Gateway.newSignedProposal, Gateway.newSignedTransaction or Gateway.newSignedCommit methods respectively.

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

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

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