Struct ContractCallImport 

pub struct ContractCallImport {
    call: ContractCall,
    proofs: Vec<Vec<u8>>,
    secrets: Vec<SecretKey>,
}

This is a wrapper around ContractCall that also adds secret keys that should sign the entire transaction and any relevant ZK proofs. This is normally created by external smart contract clients, and used by the wallet when creating transactions.

Fields

call: ContractCall

Single contract call

proofs: Vec<Vec<u8>>

ZK proofs used for the call

secrets: Vec<SecretKey>

Secret keys used to sign the tx

Implementations

impl ContractCallImport

pub fn new( call: ContractCall, proofs: Vec<Vec<u8>>, secrets: Vec<SecretKey>, ) -> Self

Create a new ContractCallImport given a call and secret keys

pub fn call(&self) -> &ContractCall

Reference the inner ContractCall

pub fn proofs(&self) -> &[Vec<u8>]

Reference the inner ZK proofs

pub fn secrets(&self) -> &[SecretKey]

Reference the inner secret keys

Trait Implementations

impl AsyncDecodable for ContractCallImport

where ContractCall: AsyncDecodable, Vec<Vec<u8>>: AsyncDecodable, Vec<SecretKey>: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl AsyncEncodable for ContractCallImport

where ContractCall: AsyncEncodable, Vec<Vec<u8>>: AsyncEncodable, Vec<SecretKey>: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

impl Clone for ContractCallImport

fn clone(&self) -> ContractCallImport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Decodable for ContractCallImport

where ContractCall: Decodable, Vec<Vec<u8>>: Decodable, Vec<SecretKey>: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl Encodable for ContractCallImport

where ContractCall: Encodable, Vec<Vec<u8>>: Encodable, Vec<SecretKey>: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl PartialEq for ContractCallImport

fn eq(&self, other: &ContractCallImport) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ContractCallImport

impl StructuralPartialEq for ContractCallImport