use crate::{
backend::{
EnvBackend,
ReturnFlags,
TypedEnvBackend,
},
call::{
Call,
CallParams,
CreateParams,
DelegateCall,
},
engine::{
EnvInstance,
OnInstance,
},
hash::{
CryptoHash,
HashOutput,
},
topics::Topics,
types::Gas,
Environment,
Result,
};
use ink_primitives::Key;
pub fn caller<E>() -> E::AccountId
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::caller::<E>(instance)
})
}
pub fn transferred_value<E>() -> E::Balance
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::transferred_value::<E>(instance)
})
}
pub fn weight_to_fee<E>(gas: Gas) -> E::Balance
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::weight_to_fee::<E>(instance, gas)
})
}
pub fn gas_left<E>() -> Gas
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::gas_left::<E>(instance)
})
}
pub fn block_timestamp<E>() -> E::Timestamp
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::block_timestamp::<E>(instance)
})
}
pub fn account_id<E>() -> E::AccountId
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::account_id::<E>(instance)
})
}
pub fn balance<E>() -> E::Balance
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::balance::<E>(instance)
})
}
pub fn block_number<E>() -> E::BlockNumber
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::block_number::<E>(instance)
})
}
pub fn minimum_balance<E>() -> E::Balance
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::minimum_balance::<E>(instance)
})
}
pub fn emit_event<E, Event>(event: Event)
where
E: Environment,
Event: Topics + scale::Encode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::emit_event::<E, Event>(instance, event)
})
}
#[deprecated(
since = "3.3.0",
note = "`set_contract_storage_return_size()` provides more information, and will be made the standard in the future."
)]
pub fn set_contract_storage<V>(key: &Key, value: &V)
where
V: scale::Encode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::set_contract_storage::<V>(instance, key, value)
});
}
pub fn set_contract_storage_return_size<V>(key: &Key, value: &V) -> Option<u32>
where
V: scale::Encode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::set_contract_storage_return_size::<V>(instance, key, value)
})
}
pub fn get_contract_storage<R>(key: &Key) -> Result<Option<R>>
where
R: scale::Decode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::get_contract_storage::<R>(instance, key)
})
}
pub fn contract_storage_contains(key: &Key) -> Option<u32> {
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::contract_storage_contains(instance, key)
})
}
pub fn clear_contract_storage(key: &Key) {
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::clear_contract_storage(instance, key)
})
}
pub fn invoke_contract<E, Args, R>(params: &CallParams<E, Call<E>, Args, R>) -> Result<R>
where
E: Environment,
Args: scale::Encode,
R: scale::Decode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::invoke_contract::<E, Args, R>(instance, params)
})
}
pub fn invoke_contract_delegate<E, Args, R>(
params: &CallParams<E, DelegateCall<E>, Args, R>,
) -> Result<R>
where
E: Environment,
Args: scale::Encode,
R: scale::Decode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::invoke_contract_delegate::<E, Args, R>(instance, params)
})
}
pub fn instantiate_contract<E, Args, Salt, C>(
params: &CreateParams<E, Args, Salt, C>,
) -> Result<E::AccountId>
where
E: Environment,
Args: scale::Encode,
Salt: AsRef<[u8]>,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::instantiate_contract::<E, Args, Salt, C>(instance, params)
})
}
pub fn terminate_contract<E>(beneficiary: E::AccountId) -> !
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::terminate_contract::<E>(instance, beneficiary)
})
}
pub fn transfer<E>(destination: E::AccountId, value: E::Balance) -> Result<()>
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::transfer::<E>(instance, destination, value)
})
}
pub fn decode_input<T>() -> Result<T>
where
T: scale::Decode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::decode_input::<T>(instance)
})
}
pub fn return_value<R>(return_flags: ReturnFlags, return_value: &R) -> !
where
R: scale::Encode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::return_value::<R>(instance, return_flags, return_value)
})
}
pub fn random<E>(subject: &[u8]) -> Result<(E::Hash, E::BlockNumber)>
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::random::<E>(instance, subject)
})
}
pub fn debug_message(message: &str) {
<EnvInstance as OnInstance>::on_instance(|instance| {
EnvBackend::debug_message(instance, message)
})
}
pub fn hash_bytes<H>(input: &[u8], output: &mut <H as HashOutput>::Type)
where
H: CryptoHash,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
instance.hash_bytes::<H>(input, output)
})
}
pub fn hash_encoded<H, T>(input: &T, output: &mut <H as HashOutput>::Type)
where
H: CryptoHash,
T: scale::Encode,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
instance.hash_encoded::<H, T>(input, output)
})
}
pub fn ecdsa_recover(
signature: &[u8; 65],
message_hash: &[u8; 32],
output: &mut [u8; 33],
) -> Result<()> {
<EnvInstance as OnInstance>::on_instance(|instance| {
instance.ecdsa_recover(signature, message_hash, output)
})
}
pub fn ecdsa_to_eth_address(pubkey: &[u8; 33], output: &mut [u8; 20]) -> Result<()> {
<EnvInstance as OnInstance>::on_instance(|instance| {
instance.ecdsa_to_eth_address(pubkey, output)
})
}
pub fn is_contract<E>(account: &E::AccountId) -> bool
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::is_contract::<E>(instance, account)
})
}
pub fn code_hash<E>(account: &E::AccountId) -> Result<E::Hash>
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::code_hash::<E>(instance, account)
})
}
pub fn own_code_hash<E>() -> Result<E::Hash>
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::own_code_hash::<E>(instance)
})
}
pub fn caller_is_origin<E>() -> bool
where
E: Environment,
{
<EnvInstance as OnInstance>::on_instance(|instance| {
TypedEnvBackend::caller_is_origin::<E>(instance)
})
}
pub fn set_code_hash(code_hash: &[u8; 32]) -> Result<()> {
<EnvInstance as OnInstance>::on_instance(|instance| instance.set_code_hash(code_hash))
}