Struct Tx

pub struct Tx<Env, From, To, Payment, Gas, Data, RH>
where
    Env: TxEnv,
    From: TxFrom<Env>,
    To: TxTo<Env>,
    Payment: TxPayment<Env>,
    Gas: TxGas<Env>,
    Data: TxData<Env>,
    RH: TxResultHandler<Env>,
{
    pub env: Env,
    pub from: From,
    pub to: To,
    pub payment: Payment,
    pub gas: Gas,
    pub data: Data,
    pub result_handler: RH,
}

Universal representation of a blockchain transaction.

Uses 7 generic type arguments to encode all aspects of the transaction.

It is future-like, does nothing by itself, it needs a specialized method call to actually run or send it.

Rationale: https://twitter.com/andreimmarinica/status/1777157322155966601

Fields

env: Env

from: From

to: To

payment: Payment

gas: Gas

data: Data

result_handler: RH

Implementations

impl<Api> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Egld<BigUint<Api>>, (), FunctionCall<Api>, Option<CallbackClosure<Api>>>

where Api: CallTypeApi,

pub fn with_callback( self, callback_call: CallbackClosure<Api>, ) -> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Egld<BigUint<Api>>, (), FunctionCall<Api>, Option<CallbackClosure<Api>>>

impl<Api> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Egld<BigUint<Api>>, (), FunctionCall<Api>, Option<CallbackClosure<Api>>>

where Api: CallTypeApi + StorageWriteApi,

pub fn call_and_exit_ignore_callback(self) -> !

impl<Env, From, To, Payment, Gas, Data, RH> Tx<Env, From, To, Payment, Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxDataFunctionCall<Env>, RH: TxResultHandler<Env>,

pub fn to_call_data_string(&self) -> ManagedBuffer<<Env as TxEnv>::Api>

Converts object to a MultiversX transaction data field string.

impl<Env> Tx<Env, (), (), (), (), (), ()>

where Env: TxEnv,

pub fn new_with_env(env: Env) -> Tx<Env, (), (), (), (), (), ()>

Constructor, needs to take an environment object.

impl<Env, To, Payment, Gas, Data, RH> Tx<Env, (), To, Payment, Gas, Data, RH>

where Env: TxEnv, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn from<From>(self, from: From) -> Tx<Env, From, To, Payment, Gas, Data, RH>

where From: TxFrom<Env>,

Specifies transaction sender.

impl<Env, From, Payment, Gas, Data, RH> Tx<Env, From, (), Payment, Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn to<To>(self, to: To) -> Tx<Env, From, To, Payment, Gas, Data, RH>

where To: TxTo<Env>,

Specifies the recipient of the transaction.

Allows argument to also be ().

impl<Env, From, To, Gas, Data, RH> Tx<Env, From, To, (), Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn payment<Payment>( self, payment: Payment, ) -> Tx<Env, From, To, Payment, Gas, Data, RH>

where Payment: TxPayment<Env>,

Adds any payment to a transaction, if no payment has been added before.

pub fn egld<EgldValue>( self, egld_value: EgldValue, ) -> Tx<Env, From, To, Egld<EgldValue>, Gas, Data, RH>

where EgldValue: TxEgldValue<Env>,

Adds EGLD value to a transaction.

Accepts any type that can represent and EGLD amount: BigUint, &BigUint, etc.

pub fn with_egld_transfer( self, egld_amount: BigUint<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, Egld<BigUint<<Env as TxEnv>::Api>>, Gas, Data, RH>

Backwards compatibility. Use method egld instead.

pub fn esdt<P>( self, payment: P, ) -> Tx<Env, From, To, EsdtTokenPayment<<Env as TxEnv>::Api>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

Adds the first single, owned ESDT token payment to a transaction.

Since this is the first ESDT payment, a single payment tx is produced.

Can subsequently be called again for multiple payments.

pub fn single_esdt<'a>( self, token_identifier: &'a TokenIdentifier<<Env as TxEnv>::Api>, token_nonce: u64, amount: &'a BigUint<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, EsdtTokenPaymentRefs<'a, <Env as TxEnv>::Api>, Gas, Data, RH>

Sets a single token payment, with the token identifier and amount kept as references.

This is handy whem we only want one ESDT transfer and we want to avoid unnecessary object clones.

pub fn egld_or_single_esdt<'a>( self, token_identifier: &'a EgldOrEsdtTokenIdentifier<<Env as TxEnv>::Api>, token_nonce: u64, amount: &'a BigUint<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, EgldOrEsdtTokenPaymentRefs<'a, <Env as TxEnv>::Api>, Gas, Data, RH>

Syntactic sugar for self.payment(EgldOrEsdtTokenPaymentRefs::new(...). Takes references.

pub fn multi_esdt<IntoMulti>( self, payments: IntoMulti, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where IntoMulti: Into<ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>>,

Sets a collection of ESDT transfers as the payment of the transaction.

Can be formed from single ESDT payments, but the result will always be a collection.

Always converts the argument into an owned collection of ESDT payments. For work with references, use .payment(&p) instead.

pub fn with_esdt_transfer<P>( self, payment: P, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

Backwards compatibility.

pub fn with_multi_token_transfer( self, payments: ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

Backwards compatibility.

pub fn with_egld_or_single_esdt_transfer<P>( self, payment: P, ) -> Tx<Env, From, To, EgldOrEsdtTokenPayment<<Env as TxEnv>::Api>, Gas, Data, RH>

where P: Into<EgldOrEsdtTokenPayment<<Env as TxEnv>::Api>>,

Backwards compatibility.

pub fn egld_or_multi_esdt<P>( self, payment: P, ) -> Tx<Env, From, To, EgldOrMultiEsdtPayment<<Env as TxEnv>::Api>, Gas, Data, RH>

where P: Into<EgldOrMultiEsdtPayment<<Env as TxEnv>::Api>>,

Converts argument to EgldOrMultiEsdtPayment, then sets it as payment.

In most cases, payment should be used instead.

impl<Env, From, To, Gas, Data, RH> Tx<Env, From, To, EsdtTokenPayment<<Env as TxEnv>::Api>, Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn esdt<P>( self, payment: P, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

Adds the second ESDT token transfer to a contract call.

Can be called multiple times on the same call.

When the Tx already contains a single (owned) ESDT payment, adding the second one will convert it to a list.

impl<Env, From, To, Gas, Data, RH> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn esdt<P>( self, payment: P, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

Adds a single ESDT token transfer to a contract call.

Can be called multiple times on the same call.

pub fn multi_esdt<P>( self, payment: P, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

When the Tx already contains an owned collection of ESDT payments, calling multi_esdt is equivalent to esdt, it just adds another payment to the list.

Can be called multiple times.

pub fn with_esdt_transfer<P>( self, payment: P, ) -> Tx<Env, From, To, ManagedVec<<Env as TxEnv>::Api, EsdtTokenPayment<<Env as TxEnv>::Api>>, Gas, Data, RH>

where P: Into<EsdtTokenPayment<<Env as TxEnv>::Api>>,

Backwards compatibility.

impl<Env, From, To, Payment, Data, RH> Tx<Env, From, To, Payment, (), Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn gas<GasValue>( self, gas_value: GasValue, ) -> Tx<Env, From, To, Payment, ExplicitGas<GasValue>, Data, RH>

where GasValue: TxGasValue<Env>,

Sets an explicit gas limit to the call.

pub fn with_gas_limit( self, gas_limit: u64, ) -> Tx<Env, From, To, Payment, ExplicitGas<u64>, Data, RH>

Backwards compatibility.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, (), RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn raw_call<N>( self, function_name: N, ) -> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

where N: Into<ManagedBuffer<<Env as TxEnv>::Api>>,

Starts a contract call, serialized by hand.

Whenever possible, should use proxies instead, since manual serialization is not type-safe.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn into_function_call(self) -> FunctionCall<<Env as TxEnv>::Api>

Converts tx to a simple FunctionCall, to be used as argument or data in contracts.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxToSpecified<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn normalize( self, ) -> Tx<Env, From, ManagedAddress<<Env as TxEnv>::Api>, Egld<BigUint<<Env as TxEnv>::Api>>, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

Produces the normalized function call, i.e. with builtin function calls for ESDT transfers.

The resulting transaction can differ from the input in several ways:

• the recipient is changed (some builtin functions are called with recipient = sender),
• the function call becomes a builtin function call.

Important

Do not call this before sending transactions! Normalization is don automatically whenever necessary. Only use when you need the normalized data, e.g. for a multisig.

Warning

To produce owned values, some clones are performed. It is not optimized for contracts, but can be used nonetheless.

impl<Env, From, Payment, Gas> Tx<Env, From, (), Payment, Gas, (), ()>

where Env: TxEnv, From: TxFrom<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>,

pub fn legacy_proxy_call<Env2, To, O>( self, call: Tx<Env2, (), To, (), (), FunctionCall<<Env as TxEnv>::Api>, OriginalResultMarker<O>>, ) -> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, OriginalResultMarker<O>>

where Env2: TxEnv<Api = <Env as TxEnv>::Api>, To: TxTo<Env> + TxTo<Env2>,

Merges the argument data into the current tx. Used for function calls originating in legacy proxies.

Different environment in the argument allowed because of compatibility with old proxies.

Method still subject to considerable change.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn argument<T>( self, arg: &T, ) -> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

where T: TopEncodeMulti,

Adds argument to function call.

Whenever possible, use proxies instead.

It serializes the value, but does not enforce type safety.

pub fn arguments_raw( self, raw: ManagedArgBuffer<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, Payment, Gas, FunctionCall<<Env as TxEnv>::Api>, RH>

Adds serialized argument to function call.

Whenever possible, use proxies instead.

Doesa not serialize, does not enforce type safety.

impl<Env, From, To, Payment, Gas, Data> Tx<Env, From, To, Payment, Gas, Data, ()>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>,

pub fn original_result<OriginalResult>( self, ) -> Tx<Env, From, To, Payment, Gas, Data, OriginalResultMarker<OriginalResult>>

Type marker to set the original contract or VM function return type.

Only the compile-time type annotation is given.

impl<Env, From, To, Gas> Tx<Env, From, To, (), Gas, (), ()>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Gas: TxGas<Env>,

pub fn typed<Proxy>( self, proxy: Proxy, ) -> <Proxy as TxProxyTrait<Env, From, To, Gas>>::TxProxyMethods

where Proxy: TxProxyTrait<Env, From, To, Gas>,

Starts a proxy call, deploy, or upgrade.

The proxy object will be given, the subsequent call will be from a proxy context, containing all the contract endpoint names.

impl<Env, From, To, Payment, Gas, Data, ResultList> Tx<Env, From, To, Payment, Gas, Data, ResultList>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>, ResultList: RHList<Env>,

pub fn with_result<ResultHandler>( self, result_handler: ResultHandler, ) -> Tx<Env, From, To, Payment, Gas, Data, <ResultList as RHListAppendNoRet<Env, ResultHandler>>::NoRetOutput>

where ResultHandler: RHListItem<Env, <ResultList as TxResultHandler<Env>>::OriginalResult, Returns = ()>, ResultList: RHListAppendNoRet<Env, ResultHandler>,

Adds a result handler that doesn’t return anything.

pub fn returns<RH>( self, item: RH, ) -> Tx<Env, From, To, Payment, Gas, Data, <ResultList as RHListAppendRet<Env, RH>>::RetOutput>

where RH: RHListItem<Env, <ResultList as TxResultHandler<Env>>::OriginalResult>, ResultList: RHListAppendRet<Env, RH>,

Adds a result handler that can also return processed data.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, (), RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn raw_deploy( self, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, ()>, RH>

Starts a contract deploy call, serialized by hand.

Whenever possible, should use proxies instead, since manual serialization is not type-safe.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, ()>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn code<CodeValue>( self, code: CodeValue, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, Code<CodeValue>>, RH>

where CodeValue: TxCodeValue<Env>,

Sets upgrade code source as explicit code bytes.

pub fn from_source<FromSourceValue>( self, source_address: FromSourceValue, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, FromSource<FromSourceValue>>, RH>

where FromSourceValue: TxFromSourceValue<Env>,

Sets upgrade code source as another deployed contract code.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, DeployCall<Env, ()>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn code<CodeValue>( self, code: CodeValue, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, Code<CodeValue>>, RH>

where CodeValue: TxCodeValue<Env>,

Sets deploy code source as explicit code bytes.

pub fn from_source<FromSourceValue>( self, source_address: FromSourceValue, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, FromSource<FromSourceValue>>, RH>

where FromSourceValue: TxFromSourceValue<Env>,

Sets deploy code source as another deployed contract code.

impl<Env, From, To, Payment, Gas, CodeSource, RH> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, CodeSource: TxCodeSource<Env>, RH: TxResultHandler<Env>,

pub fn code_metadata( self, code_metadata: CodeMetadata, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

Sets code metadata to deploy.

pub fn argument<T>( self, arg: &T, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

where T: TopEncodeMulti,

Adds argument to a contract deploy.

Whenever possible, use proxies instead.

It serializes the value, but does not enforce type safety.

pub fn arguments_raw( self, raw: ManagedArgBuffer<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

Adds serialized argument to a contract deploy.

Whenever possible, use proxies instead.

Does not serialize, does not enforce type safety.

impl<Env, From, To, Payment, Gas, CodeSource, RH> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

where Env: TxEnvMockDeployAddress, From: TxFromSpecified<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, CodeSource: TxCodeSource<Env>, RH: TxResultHandler<Env>,

pub fn new_address<NA>( self, new_address: NA, ) -> Tx<Env, From, To, Payment, Gas, DeployCall<Env, CodeSource>, RH>

where NA: AnnotatedValue<Env, ManagedAddress<<Env as TxEnv>::Api>>,

Sets the new mock address to be used for the newly deployed contract.

Only allowed in tests.

impl<Env, From, To, Payment, Gas, RH> Tx<Env, From, To, Payment, Gas, (), RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, RH: TxResultHandler<Env>,

pub fn raw_upgrade( self, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, ()>, RH>

Starts a contract deploy upgrade, serialized by hand.

Whenever possible, should use proxies instead, since manual serialization is not type-safe.

impl<Env, From, To, Payment, Gas, CodeSource, RH> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, CodeSource>, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPaymentEgldOnly<Env>, Gas: TxGas<Env>, CodeSource: TxCodeSource<Env>, RH: TxResultHandler<Env>,

pub fn code_metadata( self, code_metadata: CodeMetadata, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, CodeSource>, RH>

pub fn argument<T>( self, arg: &T, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, CodeSource>, RH>

where T: TopEncodeMulti,

Adds argument to upgrade call.

Whenever possible, use proxies instead.

It serializes the value, but does not enforce type safety.

pub fn arguments_raw( self, raw: ManagedArgBuffer<<Env as TxEnv>::Api>, ) -> Tx<Env, From, To, Payment, Gas, UpgradeCall<Env, CodeSource>, RH>

Adds serialized argument to an upgrade call.

Whenever possible, use proxies instead.

Doesa not serialize, does not enforce type safety.

impl<Env, From, To, Payment, Gas, Data, RH> Tx<Env, From, To, Payment, Gas, Data, RH>

where Env: TxEnvWithTxHash, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn tx_hash<H>(self, tx_hash: H) -> Tx<Env, From, To, Payment, Gas, Data, RH>

where H256: From<H>,

Sets the mock transaction hash to be used in a test.

Only allowed in tests.

impl<Api> Tx<TxScEnv<Api>, (), (), (), (), (), ()>

where Api: CallTypeApi,

pub fn new_tx_from_sc() -> Tx<TxScEnv<Api>, (), (), (), (), (), ()>

impl<Api, To, Payment, Gas, Data, EmptyRH> Tx<TxScEnv<Api>, (), To, Payment, Gas, Data, EmptyRH>

where Api: CallTypeApi, To: TxTo<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, Data: TxData<TxScEnv<Api>>, EmptyRH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn callback<RH>( self, callback: RH, ) -> Tx<TxScEnv<Api>, (), To, Payment, Gas, Data, RH>

where RH: TxAsyncCallCallback<Api>,

impl<Api, To, Payment, Gas, FC, EmptyRH> Tx<TxScEnv<Api>, (), To, Payment, Gas, FC, EmptyRH>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FC: TxDataFunctionCall<TxScEnv<Api>>, EmptyRH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn with_callback<RH>( self, callback: RH, ) -> Tx<TxScEnv<Api>, (), To, Payment, Gas, FC, RH>

where RH: TxAsyncCallCallback<Api>,

Backwards compatibility.

impl<Api, To, Payment, FC, RH> Tx<TxScEnv<Api>, (), To, Payment, (), FC, RH>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, FC: TxDataFunctionCall<TxScEnv<Api>>, RH: TxAsyncCallCallback<Api>,

pub fn async_call_and_exit(self) -> !

pub fn call_and_exit(self) -> !

impl<Env, From, To, Payment, Gas, Data, RH> Tx<Env, From, To, Payment, Gas, Data, RH>

where Env: TxEnv, From: TxFrom<Env>, To: TxTo<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, Data: TxData<Env>, RH: TxResultHandler<Env>,

pub fn async_call(self) -> Tx<Env, From, To, Payment, Gas, Data, RH>

👎Deprecated since 0.50.2: Backwards compatibility only, does nothing. Just delete. Use async_call_and_exit to launch asynchronous calls.

Backwards compatibility only.

impl<Api, To, Payment, Gas> Tx<TxScEnv<Api>, (), To, Payment, Gas, FunctionCall<Api>, CallbackClosure<Api>>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>,

pub fn gas_for_callback( self, gas: u64, ) -> Tx<TxScEnv<Api>, (), To, Payment, Gas, FunctionCall<Api>, CallbackClosureWithGas<Api>>

pub fn with_extra_gas_for_callback( self, gas: u64, ) -> Tx<TxScEnv<Api>, (), To, Payment, Gas, FunctionCall<Api>, CallbackClosureWithGas<Api>>

Backwards compatibility.

impl<Api, To, Payment, GasValue, Callback> Tx<TxScEnv<Api>, (), To, Payment, ExplicitGas<GasValue>, FunctionCall<Api>, Callback>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, GasValue: TxGasValue<TxScEnv<Api>>, Callback: TxPromisesCallback<Api>,

pub fn register_promise(self)

Launches a transaction as an asynchronous promise (async v2 mechanism).

Several such transactions can be launched from a single transaction.

Must set:

• to
• gas
• a function call, ideally via a proxy.

Value-only promises are not supported.

Optionally, can add:

• any payment
• a promise callback, which also needs explicit gas for callback.

impl<Api, To, Payment, GasValue, Callback> Tx<TxScEnv<Api>, (), To, Payment, ExplicitGas<GasValue>, (), Callback>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, GasValue: TxGasValue<TxScEnv<Api>>, Callback: TxPromisesCallback<Api>,

pub fn register_promise(self)

Launches a transaction as an asynchronous promise (async v2 mechanism), but without calling any function on the destination.

Such calls are useful for appending callbacks to simple transfers, mitigating edge cases such as non-payable SCs and frozen assets.

impl<Api, To, Payment, Callback> Tx<TxScEnv<Api>, (), To, Payment, (), FunctionCall<Api>, Callback>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Callback: TxPromisesCallback<Api>,

pub unsafe fn register_promise(self)

Incorrect call

Must set gas in order to call register_promise.

Safety

This version of the method must never be called. It is only here to provide a more readable error.

impl<Api, To, Payment, Callback> Tx<TxScEnv<Api>, (), To, Payment, (), (), Callback>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Callback: TxPromisesCallback<Api>,

pub unsafe fn register_promise(self)

Incorrect call

Must set gas in order to call register_promise, even when no SC endpoint is called.

Safety

This version of the method must never be called. It is only here to provide a more readable error.

impl<Api, To, Payment, Gas, Callback> Tx<TxScEnv<Api>, (), To, Payment, Gas, FunctionCall<Api>, Callback>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, Callback: TxPromisesCallback<Api>,

pub fn async_call_promise( self, ) -> Tx<TxScEnv<Api>, (), To, Payment, Gas, FunctionCall<Api>, Callback>

👎Deprecated since 0.50.2: Backwards compatibility only, does nothing. Just delete. Use register_promise to launch asynchronous calls.

Backwards compatibility only.

impl<Api, Payment, Gas, CodeValue, RH> Tx<TxScEnv<Api>, (), (), Payment, Gas, DeployCall<TxScEnv<Api>, Code<CodeValue>>, RH>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, CodeValue: TxCodeValue<TxScEnv<Api>>, RH: RHListExec<DeployRawResult<Api>, TxScEnv<Api>>, <RH as RHList<TxScEnv<Api>>>::ListReturns: NestedTupleFlatten,

pub fn sync_call( self, ) -> <<RH as RHList<TxScEnv<Api>>>::ListReturns as NestedTupleFlatten>::Unpacked

Synchronously deploys a contract.

impl<Api, Payment, Gas, FromSourceValue, RH> Tx<TxScEnv<Api>, (), (), Payment, Gas, DeployCall<TxScEnv<Api>, FromSource<FromSourceValue>>, RH>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FromSourceValue: TxFromSourceValue<TxScEnv<Api>>, RH: RHListExec<DeployRawResult<Api>, TxScEnv<Api>>, <RH as RHList<TxScEnv<Api>>>::ListReturns: NestedTupleFlatten,

pub fn sync_call( self, ) -> <<RH as RHList<TxScEnv<Api>>>::ListReturns as NestedTupleFlatten>::Unpacked

Synchronously deploys a contract from source.

impl<Api, Payment, Gas, OriginalResult> Tx<TxScEnv<Api>, (), (), Payment, Gas, DeployCall<TxScEnv<Api>, ()>, OriginalResultMarker<OriginalResult>>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, OriginalResult: TopEncodeMulti,

pub fn deploy_contract<RequestedResult>( self, code: &ManagedBuffer<Api>, code_metadata: CodeMetadata, ) -> (ManagedAddress<Api>, RequestedResult)

where RequestedResult: TopDecodeMulti + TypeAbiFrom<OriginalResult>,

Backwards compatibility, immitates the old API.

Note that the data type (the DeployCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

pub fn deploy_from_source<RequestedResult>( self, source_address: &ManagedAddress<Api>, code_metadata: CodeMetadata, ) -> (ManagedAddress<Api>, RequestedResult)

where RequestedResult: TopDecodeMulti + TypeAbiFrom<OriginalResult>,

Backwards compatibility, immitates the old API.

Note that the data type (the DeployCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

impl<Api, Payment, Gas, OriginalResult> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Payment, Gas, DeployCall<TxScEnv<Api>, ()>, OriginalResultMarker<OriginalResult>>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, OriginalResult: TopEncodeMulti,

pub fn upgrade_contract( self, code: &ManagedBuffer<Api>, code_metadata: CodeMetadata, )

👎Deprecated since 0.49.0: The legacy upgrade method does not correctly take the upgrade constructor into account. Please switch to the new syntax.

Backwards compatibility, immitates the old API.

Should no longer be used, which is why unlike all the rest of the old syntax, was deprecated.

Uses a DeployCall instead of the correct UpgradeCall, because the old syntax did not know about upgrades.

Note that the data type (the DeployCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

pub fn upgrade_from_source( self, source_address: &ManagedAddress<Api>, code_metadata: CodeMetadata, )

👎Deprecated since 0.49.0: The legacy upgrade method does not correctly take the upgrade constructor into account. Please switch to the new syntax.

Backwards compatibility, immitates the old API.

Should no longer be used, which is why unlike all the rest of the old syntax, was deprecated.

Uses a DeployCall instead of the correct UpgradeCall, because the old syntax did not know about upgrades.

Note that the data type (the DeployCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

impl<Api, To, Payment, Gas, FC, RH> Tx<TxScEnv<Api>, (), To, Payment, Gas, FC, RH>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FC: TxDataFunctionCall<TxScEnv<Api>>, RH: RHListExec<SyncCallRawResult<Api>, TxScEnv<Api>>, <RH as RHList<TxScEnv<Api>>>::ListReturns: NestedTupleFlatten,

pub fn sync_call( self, ) -> <<RH as RHList<TxScEnv<Api>>>::ListReturns as NestedTupleFlatten>::Unpacked

Executes transaction synchronously.

Only works with contracts from the same shard.

pub fn sync_call_same_context( self, ) -> <<RH as RHList<TxScEnv<Api>>>::ListReturns as NestedTupleFlatten>::Unpacked

Executes transaction synchronously, in the same context (performed in the name of the caller).

Only works with contracts from the same shard.

impl<Api, To, Payment, Gas, FC, RH> Tx<TxScEnv<Api>, (), To, Payment, Gas, FC, RH>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxNoPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FC: TxDataFunctionCall<TxScEnv<Api>>, RH: RHListExec<SyncCallRawResult<Api>, TxScEnv<Api>>, <RH as RHList<TxScEnv<Api>>>::ListReturns: NestedTupleFlatten,

pub fn sync_call_readonly( self, ) -> <<RH as RHList<TxScEnv<Api>>>::ListReturns as NestedTupleFlatten>::Unpacked

Executes transaction synchronously, in readonly mode (target contract cannot have its state altered).

Only works with contracts from the same shard.

impl<Api, To, Payment, Gas, FC, OriginalResult> Tx<TxScEnv<Api>, (), To, Payment, Gas, FC, OriginalResultMarker<OriginalResult>>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FC: TxDataFunctionCall<TxScEnv<Api>>,

pub fn execute_on_dest_context<RequestedResult>(self) -> RequestedResult

where RequestedResult: TopDecodeMulti,

Backwards compatibility.

pub fn execute_on_dest_context_with_back_transfers<RequestedResult>( self, ) -> (RequestedResult, BackTransfers<Api>)

where RequestedResult: TopDecodeMulti,

Backwards compatibility.

impl<Api, From, To, Payment, Gas, FC, RH> Tx<TxScEnv<Api>, From, To, Payment, Gas, FC, RH>

where Api: CallTypeApi, From: TxFrom<TxScEnv<Api>>, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FC: TxData<TxScEnv<Api>> + Into<FunctionCall<Api>>, RH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn transfer_execute(self)

Sends transaction asynchronously, and doesn’t wait for callback (“fire and forget”.)

impl<Api, From, To, Payment> Tx<TxScEnv<Api>, From, To, Payment, (), (), ()>

where Api: CallTypeApi, From: TxFrom<TxScEnv<Api>>, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>,

pub fn transfer(self)

Only allowed for simple transfers.

pub fn transfer_if_not_empty(self)

Transfers funds, if amount is greater than zero. Does nothing otherwise.

Can only used for simple transfers.

impl<Api, Payment, Gas, CodeValue, RH> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Payment, Gas, UpgradeCall<TxScEnv<Api>, Code<CodeValue>>, RH>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, CodeValue: TxCodeValue<TxScEnv<Api>>, RH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn upgrade_async_call_and_exit(self)

Launches the upgrade async call.

TODO: change return type to !.

impl<Api, Payment, Gas, FromSourceValue, RH> Tx<TxScEnv<Api>, (), ManagedAddress<Api>, Payment, Gas, UpgradeCall<TxScEnv<Api>, FromSource<FromSourceValue>>, RH>

where Api: CallTypeApi, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, FromSourceValue: TxFromSourceValue<TxScEnv<Api>>, RH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn upgrade_async_call_and_exit(self)

Launches the upgrade from source async call.

TODO: change return type to !.

impl<Api, To, Payment, Gas, RH> Tx<TxScEnv<Api>, (), To, Payment, Gas, UpgradeCall<TxScEnv<Api>, ()>, RH>

where Api: CallTypeApi, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, Gas: TxGas<TxScEnv<Api>>, RH: TxEmptyResultHandler<TxScEnv<Api>>,

pub fn upgrade_contract( self, code: &ManagedBuffer<Api>, code_metadata: CodeMetadata, )

👎Deprecated since 0.49.0: This is a transition syntax, it would not have been reachable before 0.49.0. Use [upgrade_async_call_and_exit] instead.

Transition syntax, immitates the old API.

Note that the data type (the UpgradeCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

pub fn upgrade_from_source( self, source_address: &ManagedAddress<Api>, code_metadata: CodeMetadata, )

👎Deprecated since 0.49.0: This is a transition syntax, it would not have been reachable before 0.49.0. Use [upgrade_async_call_and_exit] instead.

Transition syntax, immitates the old API.

Note that the data type (the UpgradeCall) doesn’t have the code set. This is because the old API was passing it as paramter, so we use it from the code argument.

Also note that the code metadata is taken from the code_metadata argument. If another one was previously set in the Tx object, that one will be ignored.

Trait Implementations

impl<Api, To, Payment, OriginalResult> ContractCallBase<Api> for Tx<TxScEnv<Api>, (), To, Payment, (), FunctionCall<Api>, OriginalResultMarker<OriginalResult>>

where Api: CallTypeApi + 'static, To: TxToSpecified<TxScEnv<Api>>, Payment: TxPayment<TxScEnv<Api>>, OriginalResult: TopEncodeMulti,

type OriginalResult = OriginalResult

👎Deprecated since 0.49.0: Please use the unified transaction syntax instead.

impl<Api, To, Payment, OriginalResult> From<Tx<TxScEnv<Api>, (), To, Payment, (), DeployCall<TxScEnv<Api>, ()>, OriginalResultMarker<OriginalResult>>> for ContractDeploy<Api, OriginalResult>

where Api: CallTypeApi + 'static, To: TxTo<TxScEnv<Api>>, Payment: TxPaymentEgldOnly<TxScEnv<Api>>, OriginalResult: TopEncodeMulti,

fn from( value: Tx<TxScEnv<Api>, (), To, Payment, (), DeployCall<TxScEnv<Api>, ()>, OriginalResultMarker<OriginalResult>>, ) -> ContractDeploy<Api, OriginalResult>

Converts to this type from the input type.

impl<'w, From, Payment, Gas, CodeValue, RH> ScenarioTxRun for Tx<ScenarioEnvExec<'w>, From, (), Payment, Gas, DeployCall<ScenarioEnvExec<'w>, Code<CodeValue>>, RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, Payment: TxPayment<ScenarioEnvExec<'w>>, Gas: TxGas<ScenarioEnvExec<'w>>, CodeValue: TxCodeValue<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn run(self) -> Self::Returns

impl<'w, From, To, RH> ScenarioTxRun for Tx<ScenarioEnvExec<'w>, From, To, NotPayable, (), UpgradeCall<ScenarioEnvExec<'w>, Code<MxscPath<'w>>>, RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, To: TxToSpecified<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn run(self) -> Self::Returns

impl<'w, From, To, Payment, Gas, RH> ScenarioTxRun for Tx<ScenarioEnvExec<'w>, From, To, Payment, Gas, FunctionCall<StaticApi>, RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, To: TxToSpecified<ScenarioEnvExec<'w>>, Payment: TxPayment<ScenarioEnvExec<'w>>, Gas: TxGas<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn run(self) -> Self::Returns

impl<'w, To, Payment, RH> ScenarioTxRun for Tx<ScenarioEnvQuery<'w>, (), To, Payment, (), FunctionCall<StaticApi>, RH>

where To: TxToSpecified<ScenarioEnvQuery<'w>>, Payment: TxNoPayment<ScenarioEnvQuery<'w>>, RH: RHListExec<TxResponse, ScenarioEnvQuery<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvQuery<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn run(self) -> Self::Returns

impl<'w, From, Payment, CodeValue, RH> ScenarioTxWhitebox for Tx<ScenarioEnvExec<'w>, From, (), Payment, (), DeployCall<ScenarioEnvExec<'w>, Code<CodeValue>>, RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, Payment: TxNoPayment<ScenarioEnvExec<'w>>, CodeValue: TxCodeValue<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn whitebox<ContractObj, F>( self, contract_obj_builder: fn() -> ContractObj, f: F, ) -> Self::Returns

where ContractObj: ContractBase<Api = DebugApi> + 'static, F: FnOnce(ContractObj),

Runs a lambda function in the name of a smart contract, with the configured transaction context.

impl<'w, From, To, Payment, RH> ScenarioTxWhitebox for Tx<ScenarioEnvExec<'w>, From, To, Payment, (), (), RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, To: TxToSpecified<ScenarioEnvExec<'w>>, Payment: TxPayment<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn whitebox<ContractObj, F>( self, contract_obj_builder: fn() -> ContractObj, f: F, ) -> Self::Returns

where ContractObj: ContractBase<Api = DebugApi> + 'static, F: FnOnce(ContractObj),

Runs a lambda function in the name of a smart contract, with the configured transaction context.

impl<'w, From, To, Payment, RH> ScenarioTxWhitebox for Tx<ScenarioEnvExec<'w>, From, To, Payment, (), FunctionCall<StaticApi>, RH>

where From: TxFromSpecified<ScenarioEnvExec<'w>>, To: TxToSpecified<ScenarioEnvExec<'w>>, Payment: TxPayment<ScenarioEnvExec<'w>>, RH: RHListExec<TxResponse, ScenarioEnvExec<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvExec<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn whitebox<ContractObj, F>( self, contract_obj_builder: fn() -> ContractObj, f: F, ) -> Self::Returns

where ContractObj: ContractBase<Api = DebugApi> + 'static, F: FnOnce(ContractObj),

Runs a lambda function in the name of a smart contract, with the configured transaction context.

impl<'w, To, Payment, RH> ScenarioTxWhitebox for Tx<ScenarioEnvQuery<'w>, (), To, Payment, (), (), RH>

where To: TxToSpecified<ScenarioEnvQuery<'w>>, Payment: TxNoPayment<ScenarioEnvQuery<'w>>, RH: RHListExec<TxResponse, ScenarioEnvQuery<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvQuery<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn whitebox<ContractObj, F>( self, contract_obj_builder: fn() -> ContractObj, f: F, ) -> Self::Returns

where ContractObj: ContractBase<Api = DebugApi> + 'static, F: FnOnce(ContractObj),

Runs a lambda function in the name of a smart contract, with the configured transaction context.

impl<'w, To, Payment, RH> ScenarioTxWhitebox for Tx<ScenarioEnvQuery<'w>, (), To, Payment, (), FunctionCall<StaticApi>, RH>

where To: TxToSpecified<ScenarioEnvQuery<'w>>, Payment: TxNoPayment<ScenarioEnvQuery<'w>>, RH: RHListExec<TxResponse, ScenarioEnvQuery<'w>>, RH::ListReturns: NestedTupleFlatten,

type Returns = <<RH as RHList<ScenarioEnvQuery<'w>>>::ListReturns as NestedTupleFlatten>::Unpacked

fn whitebox<ContractObj, F>( self, contract_obj_builder: fn() -> ContractObj, f: F, ) -> Self::Returns

where ContractObj: ContractBase<Api = DebugApi> + 'static, F: FnOnce(ContractObj),

Runs a lambda function in the name of a smart contract, with the configured transaction context.

impl<Env, To, Payment, RH> TxToQueryStep<Env, RH> for Tx<Env, (), To, Payment, (), FunctionCall<Env::Api>, RH>

where Env: TxEnv<RHExpect = TxExpect>, To: TxToSpecified<Env>, Payment: TxNoPayment<Env>, RH: RHListExec<TxResponse, Env>,

type Step = ScQueryStep

fn tx_to_query_step(self) -> StepWrapper<Env, Self::Step, RH>

impl<Env, From, To, Payment, Gas> TxToStep<Env, ()> for Tx<Env, From, To, Payment, Gas, (), ()>

where Env: TxEnv, From: TxFromSpecified<Env>, To: TxToSpecified<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>,

type Step = TransferStep

fn tx_to_step(self) -> StepWrapper<Env, Self::Step, ()>

impl<Env, From, Payment, Gas, CodeValue, RH> TxToStep<Env, RH> for Tx<Env, From, (), Payment, Gas, DeployCall<Env, Code<CodeValue>>, RH>

where Env: TxEnvWithTxHash<RHExpect = TxExpect>, From: TxFromSpecified<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, CodeValue: TxCodeValue<Env>, RH: RHListExec<TxResponse, Env>,

type Step = ScDeployStep

fn tx_to_step(self) -> StepWrapper<Env, Self::Step, RH>

impl<Env, From, To, Gas, RH, CodeValue> TxToStep<Env, RH> for Tx<Env, From, To, NotPayable, Gas, UpgradeCall<Env, Code<CodeValue>>, RH>

where Env: TxEnv<RHExpect = TxExpect>, From: TxFromSpecified<Env>, To: TxToSpecified<Env>, Gas: TxGas<Env>, CodeValue: TxCodeValue<Env>, RH: RHListExec<TxResponse, Env>,

type Step = ScCallStep

fn tx_to_step(self) -> StepWrapper<Env, Self::Step, RH>

impl<Env, From, To, Payment, Gas, RH> TxToStep<Env, RH> for Tx<Env, From, To, Payment, Gas, FunctionCall<Env::Api>, RH>

where Env: TxEnvWithTxHash<RHExpect = TxExpect>, From: TxFromSpecified<Env>, To: TxToSpecified<Env>, Payment: TxPayment<Env>, Gas: TxGas<Env>, RH: RHListExec<TxResponse, Env>,

type Step = ScCallStep

fn tx_to_step(self) -> StepWrapper<Env, Self::Step, RH>