Struct ContractCall 

pub struct ContractCall<R> { /* private fields */ }

A typed state-changing contract call, prepared but not yet submitted.

Built by Contract::prepare_call, and the natural return type of a typed client’s call methods. Awaiting it submits the call, requires successful execution, and decodes the return as R. To see the receipt as well, use with_receipt; to submit without waiting, use submit.

Implementations

impl<R> ContractCall<R>

pub async fn submit(self) -> Result<SubmittedContractCall>

Submit the call without waiting for its receipt.

pub async fn receipt(self) -> Result<TransactionReceipt>

Submit the call and await its receipt, requiring successful execution but ignoring the return value.

impl<R> ContractCall<R>

where R: for<'r> ReadXDR<'r>,

pub async fn with_receipt(self) -> Result<(R, TransactionReceipt)>

Submit the call, require successful execution, and return the decoded return value together with the receipt (for its events or gas).

pub async fn simulate(self) -> Result<R>

Simulate the call instead of submitting it, with the caller as msg.sender, and decode its return. For reading through a method whose interface does not declare it read-only; any state changes are discarded.

Trait Implementations

impl<R> Debug for ContractCall<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R> IntoFuture for ContractCall<R>

where R: for<'r> ReadXDR<'r> + Send + 'static,

type Output = Result<R, TestkitError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<R, TestkitError>> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.