Struct soroban_env_host::Host

impl Host

pub fn ed25519_pub_key_from_bytesobj_input( &self, k: BytesObject ) -> Result<PublicKey, HostError>

pub fn sha256_hash_from_bytesobj_input( &self, x: BytesObject ) -> Result<Vec<u8>, HostError>

pub fn storage_key_from_rawval( &self, k: RawVal ) -> Result<Rc<LedgerKey>, HostError>

Converts a RawVal to an ScVal and combines it with the currently-executing [ContractID] to produce a [Key], that can be used to access ledger [Storage].

pub fn fn_call_diagnostics( &self, called_contract_id: &Hash, func: &Symbol, args: &[RawVal] ) -> Result<(), HostError>

pub fn fn_return_diagnostics( &self, contract_id: &Hash, func: &Symbol, res: &RawVal ) -> Result<(), HostError>

pub fn err_conversion_general(&self, msg: &'static str) -> HostError

pub fn map_err<T, E>(&self, res: Result<T, E>) -> Result<T, HostError>where DebugError: From<E>,

Given a result carrying some error type that can be converted to a DebugError, calls self.err with it when there’s an error. Returns a result over HostError.

If you have an error type T you want to record as a detailed debug event and a less-detailed Status code embedded in a HostError, add an impl From<T> for DebugError over in the events module and call this where the error is generated.

Note: we do not want to impl From<T> for HostError for such types, as doing so will avoid routing them through the host in order to record their extended diagnostic information into the debug buffer. This means you will wind up writing host.map_err(...)? a bunch in code that you used to be able to get away with just writing ...?, there’s no way around this if we want to record the diagnostic information.

impl Host

pub fn with_storage_and_budget(storage: Storage, budget: Budget) -> Self

Constructs a new Host that will use the provided Storage for contract-data access functions such as [Env::get_contract_data].

pub fn budget_cloned(&self) -> Budget

pub fn charge_budget( &self, ty: ContractCostType, input: Option<u64> ) -> Result<(), HostError>

pub fn set_diagnostic_level(&self, diagnostic_level: DiagnosticLevel)

pub fn is_debug(&self) -> bool

pub fn record_debug_event<T>(&self, src: T) -> Result<(), HostError>where DebugEvent: From<T>,

Records a debug event. This in itself is not necessarily an error; it might just be some contextual event we want to put in a debug log for diagnostic purpopses. The return value from this is therefore () when the event is recorded successfully, even if the event itself represented some other error. This function only returns Err(…) when there was a failure to record the event, such as when budget is exceeded.

pub fn with_mut_storage<F, U>(&self, f: F) -> Result<U, HostError>where F: FnOnce(&mut Storage) -> Result<U, HostError>,

pub fn try_finish(self) -> Result<(Storage, Budget, Events), (Self, HostError)>

Accept a unique (refcount = 1) host reference and destroy the underlying [HostImpl], returning its constituent components to the caller as a tuple wrapped in Ok(...). If the provided host reference is not unique, returns Err(self).

pub fn with_test_contract_frame<F>( &self, id: Hash, func: Symbol, f: F ) -> Result<RawVal, HostError>where F: FnOnce() -> Result<RawVal, HostError>,

Pushes a test contract [Frame], runs a closure, and then pops the frame, rolling back if the closure returned an error. Returns the result that the closure returned (or any error caused during the frame push/pop). Used for testing.

pub fn call_account_contract_check_auth( &self, contract: BytesObject, args: VecObject ) -> Result<RawVal, HostError>

Invokes the reserved __check_auth function on a provided contract.

This is useful for testing the custom account contracts. Otherwise, the host prohibits calling __check_auth outside of internal implementation of require_auth[_for_args] calls.

pub fn inject_val(&self, v: &ScVal) -> Result<RawVal, HostError>

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

impl Default for Host

fn default() -> Host

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

fn put_tmp_contract_data( &self, _vmcaller: &mut VmCaller<'_, Host>, k: RawVal, v: RawVal ) -> Result<Void, HostError>

fn has_tmp_contract_data( &self, _vmcaller: &mut VmCaller<'_, Host>, k: RawVal ) -> Result<Bool, HostError>

fn get_tmp_contract_data( &self, _vmcaller: &mut VmCaller<'_, Host>, k: RawVal ) -> Result<RawVal, HostError>

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.

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.

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.

Copy the RawVals of a vec into an array at a given linear-memory address.

fn put_tmp_contract_data( &self, k: RawVal, v: RawVal ) -> Result<Void, <T as EnvBase>::Error>

fn has_tmp_contract_data( &self, k: RawVal ) -> Result<Bool, <T as EnvBase>::Error>

fn get_tmp_contract_data( &self, k: RawVal ) -> Result<RawVal, <T as EnvBase>::Error>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Twhere T: Clone,