use casper_types::{
account::AccountHash, system::handle_payment::Error, BlockTime, Key, Phase, StoredValue,
TransferredTo, URef, U512,
};
use crate::{
core::{execution, runtime::Runtime},
storage::global_state::StateReader,
system::handle_payment::{
mint_provider::MintProvider, runtime_provider::RuntimeProvider, HandlePayment,
},
};
impl From<execution::Error> for Option<Error> {
fn from(exec_error: execution::Error) -> Self {
match exec_error {
execution::Error::GasLimit => Some(Error::GasLimit),
_ => None,
}
}
}
impl<'a, R> MintProvider for Runtime<'a, R>
where
R: StateReader<Key, StoredValue>,
R::Error: Into<execution::Error>,
{
fn transfer_purse_to_account(
&mut self,
source: URef,
target: AccountHash,
amount: U512,
) -> Result<TransferredTo, Error> {
match self.transfer_from_purse_to_account(source, target, amount, None) {
Ok(Ok(transferred_to)) => Ok(transferred_to),
Ok(Err(_mint_error)) => Err(Error::Transfer),
Err(exec_error) => Err(<Option<Error>>::from(exec_error).unwrap_or(Error::Transfer)),
}
}
fn transfer_purse_to_purse(
&mut self,
source: URef,
target: URef,
amount: U512,
) -> Result<(), Error> {
let mint_contract_key = match self.get_mint_contract() {
Ok(mint_hash) => mint_hash,
Err(exec_error) => {
return Err(<Option<Error>>::from(exec_error).unwrap_or(Error::Transfer))
}
};
match self.mint_transfer(mint_contract_key, None, source, target, amount, None) {
Ok(Ok(_)) => Ok(()),
Ok(Err(_mint_error)) => Err(Error::Transfer),
Err(exec_error) => Err(<Option<Error>>::from(exec_error).unwrap_or(Error::Transfer)),
}
}
fn balance(&mut self, purse: URef) -> Result<Option<U512>, Error> {
self.get_balance(purse)
.map_err(|exec_error| <Option<Error>>::from(exec_error).unwrap_or(Error::GetBalance))
}
}
impl<'a, R> RuntimeProvider for Runtime<'a, R>
where
R: StateReader<Key, StoredValue>,
R::Error: Into<execution::Error>,
{
fn get_key(&self, name: &str) -> Option<Key> {
self.context.named_keys_get(name).cloned()
}
fn put_key(&mut self, name: &str, key: Key) -> Result<(), Error> {
self.context
.put_key(name.to_string(), key)
.map_err(|exec_error| <Option<Error>>::from(exec_error).unwrap_or(Error::PutKey))
}
fn remove_key(&mut self, name: &str) -> Result<(), Error> {
self.context
.remove_key(name)
.map_err(|exec_error| <Option<Error>>::from(exec_error).unwrap_or(Error::RemoveKey))
}
fn get_phase(&self) -> Phase {
self.context.phase()
}
fn get_block_time(&self) -> BlockTime {
self.context.get_blocktime()
}
fn get_caller(&self) -> AccountHash {
self.context.get_caller()
}
}
impl<'a, R> HandlePayment for Runtime<'a, R>
where
R: StateReader<Key, StoredValue>,
R::Error: Into<execution::Error>,
{
}