Struct substrate_subxt::contracts::CallCall

pub struct CallCall<'a, T: Contracts> {
    pub dest: &'a <T as System>::Address,
    pub value: <T as Balances>::Balance,
    pub gas_limit: Gas,
    pub data: &'a [u8],
}

Makes a call to an account, optionally transferring some balance.

• If the account is a smart-contract account, the associated code will be executed and any value will be transferred.
• If the account is a regular account, any value will be transferred.
• If no account exists and the call value is not less than existential_deposit, a regular account will be created and any value will be transferred.

Fields

dest: &'a <T as System>::Address

Address of the contract.

value: <T as Balances>::Balance

Value to transfer to the contract.

gas_limit: Gas

Gas limit.

data: &'a [u8]

Data to send to the contract.

Trait Implementations

impl<'a, T: Contracts> Call<T> for CallCall<'a, T>

const MODULE: &'static str

Module name.

const FUNCTION: &'static str

Function name.

fn events_decoder(decoder: &mut EventsDecoder<T>)

Load event decoder.

impl<'a, T: Clone + Contracts> Clone for CallCall<'a, T>

fn clone(&self) -> CallCall<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + Contracts> Debug for CallCall<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: Contracts> Encode for CallCall<'a, T> where
    <T as System>::Address: Encode,
    &'a <T as System>::Address: Encode,
    <T as Balances>::Balance: Encode,
    <T as Balances>::Balance: Encode, 

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

impl<'a, T: Contracts> EncodeLike<CallCall<'a, T>> for CallCall<'a, T> where
    <T as System>::Address: Encode,
    &'a <T as System>::Address: Encode,
    <T as Balances>::Balance: Encode,
    <T as Balances>::Balance: Encode, 

impl<'a, T: PartialEq + Contracts> PartialEq<CallCall<'a, T>> for CallCall<'a, T>

fn eq(&self, other: &CallCall<'a, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &CallCall<'a, T>) -> bool

This method tests for !=.

impl<'a, T: Contracts> StructuralPartialEq for CallCall<'a, T>