Struct novax_executor::BaseTransactionNetworkExecutor

pub struct BaseTransactionNetworkExecutor<Interactor: BlockchainInteractor> {
    pub gateway_url: String,
    pub wallet: Wallet,
    /* private fields */
}

A struct representing the executor for handling transactions in a real blockchain environment.

This executor is designed to interact with a blockchain network via a specified gateway URL and a wallet for signing transactions. It is parameterized by a type Interactor that encapsulates the blockchain interaction logic.

Fields

gateway_url: String

The URL of the blockchain network gateway through which transactions will be sent.

wallet: Wallet

The wallet used for signing transactions before they are sent to the blockchain network.

Implementations

impl<Interactor: BlockchainInteractor> BaseTransactionNetworkExecutor<Interactor>

pub fn new(gateway_url: &str, wallet: &Wallet) -> Self

Creates a new instance of BaseTransactionNetworkExecutor.

Parameters

• gateway_url: The URL of the blockchain network gateway.
• wallet: A reference to the wallet used for signing transactions.

Returns

A new BaseTransactionNetworkExecutor instance.

Trait Implementations

impl<Interactor> Clone for BaseTransactionNetworkExecutor<Interactor>

where Interactor: BlockchainInteractor,

Custom implementation of Clone for BaseTransactionNetworkExecutor.

This implementation is necessary because the Interactor generic parameter might not implement Clone. However, since Interactor is used only as phantom data (it does not affect the state of BaseTransactionNetworkExecutor), we can safely implement Clone without the Interactor needing to be Clone.

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Interactor> Debug for BaseTransactionNetworkExecutor<Interactor>

where Interactor: BlockchainInteractor,

Custom implementation of Debug for BaseTransactionNetworkExecutor.

This implementation is necessary because the Interactor generic parameter might not implement Debug. As with Clone, since Interactor is only used as phantom data, it does not impact the debug representation of BaseTransactionNetworkExecutor. This implementation ensures that instances of BaseTransactionNetworkExecutor can be formatted using the Debug trait regardless of whether Interactor implements Debug.

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

Formats the value using the given formatter.

impl<Interactor: BlockchainInteractor> DeployExecutor for BaseTransactionNetworkExecutor<Interactor>

Implementation of the DeployExecutor trait for the BaseTransactionNetworkExecutor struct. This implementation enables the deployment of smart contracts on the blockchain using a specified blockchain interactor.

fn sc_deploy<'life0, 'life1, 'async_trait, OriginalResult>( &'life0 mut self, sc_deploy_step: &'life1 mut TypedScDeploy<OriginalResult> ) -> Pin<Box<dyn Future<Output = Result<(), ExecutorError>> + Send + 'async_trait>>

where OriginalResult: TopEncodeMulti + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously deploys a smart contract to the blockchain.

Type Parameters

• OriginalResult: Represents the result type expected from the smart contract deployment. This type must implement TopEncodeMulti, Send, and Sync.
• S: Represents the type encapsulating the smart contract deployment step. This type must implement AsMut<TypedScDeploy<OriginalResult>> and Send.

Parameters

• sc_deploy_step: A mutable reference to the smart contract deployment step to be executed.

Returns

A Result with an empty Ok(()) value indicating success, or an Err(ExecutorError) indicating failure.

fn should_skip_deserialization<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Specifies whether deserialization should be skipped during the deployment execution. In this implementation, deserialization is not skipped.

Returns

A bool value of false, indicating that deserialization should not be skipped.

impl<Interactor: BlockchainInteractor> TransactionExecutor for BaseTransactionNetworkExecutor<Interactor>

fn sc_call<'life0, 'life1, 'async_trait, OriginalResult>( &'life0 mut self, sc_call_step: &'life1 mut TypedScCall<OriginalResult> ) -> Pin<Box<dyn Future<Output = Result<(), ExecutorError>> + Send + 'async_trait>>

where OriginalResult: 'async_trait + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Executes a smart contract call on the blockchain.

Parameters

• sc_call_step: A mutable reference to the smart contract call step.

Type Parameters

• OriginalResult: The type of the result expected from the smart contract call. Must implement the Send trait.

Returns

• A Result with an empty Ok(()) value if the call is successful, or an Err(ExecutorError) if the call fails.

fn should_skip_deserialization<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Indicates whether deserialization should be skipped during smart contract call execution.

In the context of a real blockchain environment, deserialization is not skipped, hence this method returns false.

Returns

• A boolean value false, indicating that deserialization should not be skipped.