Struct soroban_sdk::Env

source · [−]

pub struct Env { /* private fields */ }

Expand description

The Env type provides access to the environment the contract is executing within.

The Env provides access to information about the currently executing contract, who invoked it, contract data, functions for signing, hashing, etc.

Most types require access to an Env to be constructed or converted.

Implementations

impl Env

pub fn invoke_contract<T: TryFromVal<Env, RawVal>>(
    &self,
    contract_id: &BytesN<32>,
    func: &Symbol,
    args: Vec<EnvVal>
) -> T

Invokes a function of a contract that is registered in the Env.

Panics

Will panic if the contract_id does not match a registered contract, func does not match a function of the referenced contract, or the number of args do not match the argument count of the referenced contract function.

Will also panic if the value returned from the contract cannot be converted into the type T.

TODO

Return a Result instead of panic.

pub fn contract_data(&self) -> ContractData

Get a ContractData for accessing and update contract data that has been stored by the currently executing contract.

pub fn ledger(&self) -> Ledger

Get a Ledger for accessing the current ledger.

pub fn events(&self) -> Events

Get Events for publishing events associated with the currently executing contract.

pub fn deployer(&self) -> Deployer

Get a deployer for deploying contracts.

pub fn get_current_contract(&self) -> BytesN<32>

Get the 32-byte hash identifier of the current executing contract.

pub fn get_invoking_contract(&self) -> BytesN<32>

Get the 32-byte hash identifier of the contract that invoked this contract.

Panics

Will panic the contract was not invoked by another contract.

pub fn compute_hash_sha256(&self, msg: Bytes) -> BytesN<32>

Computes a SHA-256 hash.

pub fn verify_sig_ed25519(&self, pk: BytesN<32>, msg: Bytes, sig: BytesN<64>)

Verifies an ed25519 signature.

The ed25519 siganture (sig) is verified as a valid signature of the message (msg) by the ed25519 public key (pk).

Panics

Will panic if the siganture verification fails.

TODO

Return a Result instead of panicking.

impl Env

pub fn set_ledger(&self, li: LedgerInfo)

Available on crate feature testutils only.

Sets ledger information in the Env, which will be accessible via Env::ledger.

pub fn register_contract<T: ContractFunctionSet + 'static>(
    &self,
    contract_id: &BytesN<32>,
    contract: T
)

Available on crate feature testutils only.

Register a contract with the Env for testing.

Examples

use soroban_sdk::{contractimpl, BytesN, Env, Symbol};

pub struct HelloContract;

#[contractimpl]
impl HelloContract {
    pub fn hello(env: Env, recipient: soroban_sdk::Symbol) -> soroban_sdk::Symbol {
        todo!()
    }
}

let env = Env::default();
let contract_id = BytesN::from_array(&env, &[0; 32]);
env.register_contract(&contract_id, HelloContract);

pub fn register_contract_wasm(
    &self,
    contract_id: &BytesN<32>,
    contract_wasm: &[u8]
)

Available on crate feature testutils only.

Register a contract in a WASM file with the Env for testing.

Examples

use soroban_sdk::{BytesN, Env};

const WASM: &[u8] = include_bytes!("../doctest_fixtures/contract.wasm");

let env = Env::default();
let contract_id = BytesN::from_array(&env, &[0; 32]);
env.register_contract_wasm(&contract_id, WASM);

pub fn register_contract_token(&self, contract_id: &BytesN<32>)

Available on crate feature testutils only.

Register the built-in token contract with the Env for testing.

Examples

use soroban_sdk::{BytesN, Env};

let env = Env::default();
let contract_id = BytesN::from_array(&env, &[0; 32]);
env.register_contract_token(&contract_id);

pub fn assert_panic_with_string<F, T: Debug>(&self, s: &str, f: F) where
F: FnOnce(Env) -> T,

Available on crate feature testutils only.

pub fn assert_panic_with_status<F, T: Debug>(&self, status: Status, f: F) where
F: FnOnce(Env) -> T,

Available on crate feature testutils only.

Trait Implementations

impl Clone for Env

fn clone(&self) -> Env

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

impl Default for Env

fn default() -> Self

Returns the “default value” for a type. Read more

impl FromVal<Env, i32> for BigInt

fn from_val(env: &Env, val: i32) -> Self

impl FromVal<Env, i64> for BigInt

fn from_val(env: &Env, val: i64) -> Self

impl FromVal<Env, u32> for BigInt

fn from_val(env: &Env, val: u32) -> Self

impl FromVal<Env, u64> for BigInt

fn from_val(env: &Env, val: u64) -> Self

impl IntoVal<Env, Account> for [u8 ; 32]

fn into_val(self, env: &Env) -> Account

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, BigInt> for i32

fn into_val(self, env: &Env) -> BigInt

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, BigInt> for i64

fn into_val(self, env: &Env) -> BigInt

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, BigInt> for u32

fn into_val(self, env: &Env) -> BigInt

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, BigInt> for u64

fn into_val(self, env: &Env) -> BigInt

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, Bytes> for &[u8 ; N]

fn into_val(self, env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, Bytes> for &[u8]

fn into_val(self, env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, Bytes> for &Bytes

fn into_val(self, _env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, Bytes> for &BytesN<N>

fn into_val(self, _env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, Bytes> for &str

fn into_val(self, env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, Bytes> for [u8 ; N]

fn into_val(self, env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, Bytes> for Bytes

fn into_val(self, _env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, Bytes> for BytesN<N>

fn into_val(self, _env: &Env) -> Bytes

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, BytesN<N>> for &[u8 ; N]

fn into_val(self, env: &Env) -> BytesN<N>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, BytesN<N>> for &BytesN<N>

fn into_val(self, _env: &Env) -> BytesN<N>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, BytesN<N>> for [u8 ; N]

fn into_val(self, env: &Env) -> BytesN<N>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, BytesN<N>> for BytesN<N>

fn into_val(self, _env: &Env) -> BytesN<N>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T> IntoVal<Env, Object> for Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

fn into_val(self, _env: &Env) -> Object

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for &BigInt

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for &Bytes

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, RawVal> for &BytesN<N>

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<K, V> IntoVal<Env, RawVal> for &Map<K, V> where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T> IntoVal<Env, RawVal> for &Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for BigInt

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for Bytes

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, RawVal> for BytesN<N>

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<K, V> IntoVal<Env, RawVal> for Map<K, V> where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T> IntoVal<Env, RawVal> for Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,
    for<'a> &'a T8: IntoVal<Env, RawVal>,
    for<'a> &'a T9: IntoVal<Env, RawVal>,
    for<'a> &'a T10: IntoVal<Env, RawVal>,
    for<'a> &'a T11: IntoVal<Env, RawVal>,
    for<'a> &'a T12: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,
    for<'a> &'a T8: IntoVal<Env, RawVal>,
    for<'a> &'a T9: IntoVal<Env, RawVal>,
    for<'a> &'a T10: IntoVal<Env, RawVal>,
    for<'a> &'a T11: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,
    for<'a> &'a T8: IntoVal<Env, RawVal>,
    for<'a> &'a T9: IntoVal<Env, RawVal>,
    for<'a> &'a T10: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,
    for<'a> &'a T8: IntoVal<Env, RawVal>,
    for<'a> &'a T9: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,
    for<'a> &'a T8: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6, T7) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,
    for<'a> &'a T7: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5, T6) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,
    for<'a> &'a T6: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4, T5) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,
    for<'a> &'a T5: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3, T4) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,
    for<'a> &'a T4: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2, T3) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,
    for<'a> &'a T3: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2> IntoVal<Env, Vec<RawVal>> for &(T0, T1, T2) where
    for<'a> &'a T0: IntoVal<Env, RawVal>,
    for<'a> &'a T1: IntoVal<Env, RawVal>,
    for<'a> &'a T2: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1> IntoVal<Env, Vec<RawVal>> for &(T0, T1) where
for<'a> &'a T0: IntoVal<Env, RawVal>,
for<'a> &'a T1: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0> IntoVal<Env, Vec<RawVal>> for &(T0,) where
for<'a> &'a T0: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, Vec<RawVal>> for ()

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,
    T8: IntoVal<Env, RawVal>,
    T9: IntoVal<Env, RawVal>,
    T10: IntoVal<Env, RawVal>,
    T11: IntoVal<Env, RawVal>,
    T12: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,
    T8: IntoVal<Env, RawVal>,
    T9: IntoVal<Env, RawVal>,
    T10: IntoVal<Env, RawVal>,
    T11: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,
    T8: IntoVal<Env, RawVal>,
    T9: IntoVal<Env, RawVal>,
    T10: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,
    T8: IntoVal<Env, RawVal>,
    T9: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,
    T8: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6, T7> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,
    T7: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5, T6> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5, T6) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,
    T6: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4, T5> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4, T5) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,
    T5: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3, T4> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3, T4) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,
    T4: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2, T3> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2, T3) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,
    T3: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1, T2> IntoVal<Env, Vec<RawVal>> for (T0, T1, T2) where
    T0: IntoVal<Env, RawVal>,
    T1: IntoVal<Env, RawVal>,
    T2: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0, T1> IntoVal<Env, Vec<RawVal>> for (T0, T1) where
T0: IntoVal<Env, RawVal>,
T1: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T0> IntoVal<Env, Vec<RawVal>> for (T0,) where
T0: IntoVal<Env, RawVal>,

fn into_val(self, env: &Env) -> Vec<RawVal>

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl TryFromVal<Env, Object> for Account

type Error = ConversionError

fn try_from_val(env: &Env, val: Object) -> Result<Self, Self::Error>

impl TryFromVal<Env, Object> for BigInt

type Error = ConversionError

fn try_from_val(env: &Env, val: Object) -> Result<Self, Self::Error>

impl TryFromVal<Env, Object> for Bytes

type Error = ConversionError

fn try_from_val(env: &Env, val: Object) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, Object> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, val: Object) -> Result<Self, Self::Error>

impl<K, V> TryFromVal<Env, Object> for Map<K, V> where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_from_val(env: &Env, obj: Object) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, Object> for Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_from_val(env: &Env, obj: Object) -> Result<Self, Self::Error>

impl TryFromVal<Env, RawVal> for Account

type Error = <Account as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, RawVal> for BigInt

type Error = <BigInt as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, RawVal> for Bytes

type Error = <Bytes as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, RawVal> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<K, V> TryFromVal<Env, RawVal> for Map<K, V> where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = <Map<K, V> as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, RawVal> for Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = <Vec<T> as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for BigInt

type Error = ConversionError

fn try_from_val(env: &Env, val: ScVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, ScVal> for Bytes

type Error = ConversionError

fn try_from_val(env: &Env, val: ScVal) -> Result<Self, Self::Error>

impl<const N: usize> TryFromVal<Env, ScVal> for BytesN<N>

type Error = ConversionError

fn try_from_val(env: &Env, val: ScVal) -> Result<Self, Self::Error>

impl<K, V> TryFromVal<Env, ScVal> for Map<K, V> where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_from_val(env: &Env, val: ScVal) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, ScVal> for Vec<T> where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_from_val(env: &Env, val: ScVal) -> Result<Self, Self::Error>

impl TryIntoVal<Env, BigInt> for Object

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BigInt, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, BigInt> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BigInt, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, BigInt> for ScVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BigInt, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, Bytes> for Object

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Bytes, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, Bytes> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Bytes, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, Bytes> for ScVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Bytes, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<const N: usize> TryIntoVal<Env, BytesN<N>> for Object

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BytesN<N>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<const N: usize> TryIntoVal<Env, BytesN<N>> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BytesN<N>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<const N: usize> TryIntoVal<Env, BytesN<N>> for ScVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BytesN<N>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<K, V> TryIntoVal<Env, Map<K, V>> for Object where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Map<K, V>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<K, V> TryIntoVal<Env, Map<K, V>> for RawVal where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Map<K, V>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<K, V> TryIntoVal<Env, Map<K, V>> for ScVal where
K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Map<K, V>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<T> TryIntoVal<Env, Vec<T>> for Object where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Vec<T>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<T> TryIntoVal<Env, Vec<T>> for RawVal where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Vec<T>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<T> TryIntoVal<Env, Vec<T>> for ScVal where
T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Vec<T>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

Auto Trait Implementations

impl !RefUnwindSafe for Env

impl !Send for Env

impl !Sync for Env

impl Unpin for Env

impl !UnwindSafe for Env

Blanket Implementations

impl<T> Any for T where
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Downcast for T where
T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T where
V: MultiLane<T>,

fn vzip(self) -> V