Struct soroban_env_host::Host

pub struct Host(_);

Implementations

impl Host

pub fn ed25519_pub_key_from_obj_input(
    &self,
    k: Object
) -> Result<PublicKey, HostError>

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

pub fn storage_key_from_rawval(&self, k: RawVal) -> Result<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 contract_data_key_from_rawval(
    &self,
    k: RawVal
) -> Result<LedgerKey, HostError>

impl Host

pub fn contract_code_ledger_key(&self, contract_id: Hash) -> LedgerKey

pub fn retrieve_contract_code_from_storage(
    &self,
    key: &LedgerKey
) -> Result<ScContractCode, HostError>

pub fn store_contract_code(
    &self,
    contract: ScContractCode,
    contract_id: Hash,
    key: &LedgerKey
) -> Result<(), HostError>

pub fn id_preimage_from_ed25519(
    &self,
    key: Uint256,
    salt: Uint256
) -> Result<Vec<u8>, HostError>

pub fn id_preimage_from_contract(
    &self,
    contract_id: Hash,
    salt: Uint256
) -> Result<Vec<u8>, HostError>

pub fn id_preimage_from_asset(&self, asset: Asset) -> Result<Vec<u8>, HostError>

pub fn id_preimage_from_source_account(
    &self,
    salt: Uint256
) -> Result<Vec<u8>, HostError>

pub fn load_account(
    &self,
    account_id: AccountId
) -> Result<AccountEntry, HostError>

pub fn has_account(&self, account_id: AccountId) -> Result<bool, HostError>

impl Host

pub fn err<T>(&self, src: T) -> HostErrorwhere
    DebugError: From<T>,

Records a debug-event from its input in as much detail as possible, then converts its input to a (often coarser-granularity) Status code, and then forms a HostError with it (which also captures a backtrace::Backtrace). This is the method you want to call any time there’s a finer-granularity error type that you want to log the details of and then downgrade fail with.

pub fn err_status<T>(&self, status: T) -> HostErrorwhere
    Status: From<T>,

Helper for the simplest status-only error path.

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

Helper for the simplest string + general-error path.

pub fn err_status_msg<T>(&self, status: T, msg: &'static str) -> HostErrorwhere
    Status: From<T>,

Helper for the next-simplest status-and-extended-debug-message error path.

pub fn err_conversion_into_rawval<T>(&self, rv: RawVal) -> 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 [CheckedEnv::get_contract_data].

pub fn set_source_account(&self, source_account: AccountId)

pub fn source_account(&self) -> Result<AccountId, HostError>

pub fn set_ledger_info(&self, info: LedgerInfo)

pub fn with_ledger_info<F, T>(&self, f: F) -> Result<T, HostError>where
    F: FnOnce(&LedgerInfo) -> Result<T, HostError>,

pub fn with_mut_ledger_info<F>(&self, f: F) -> Result<(), HostError>where
    F: FnMut(&mut LedgerInfo),

pub fn get_budget<T, F>(&self, f: F) -> Twhere
    F: FnOnce(Budget) -> T,

Helper for mutating the Budget held in this Host, either to allocate it on contract creation or to deplete it on callbacks from the VM or host functions.

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

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 record_contract_event(
    &self,
    type_: ContractEventType,
    topics: ScVec,
    data: ScVal
) -> Result<(), HostError>

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>

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 inject_val(&self, v: &ScVal) -> Result<RawVal, HostError>

pub fn get_events(&self) -> Result<Events, HostError>

pub fn create_contract_with_id(
    &self,
    contract: ScContractCode,
    id_obj: Object
) -> Result<(), HostError>

pub fn create_contract_with_id_preimage(
    &self,
    contract: ScContractCode,
    id_preimage: Vec<u8>
) -> Result<Object, HostError>

pub fn get_contract_id_from_asset(
    &self,
    asset: Asset
) -> Result<Object, HostError>

pub fn invoke_function_raw(
    &self,
    hf: HostFunction,
    args: ScVec
) -> Result<RawVal, HostError>

pub fn invoke_function(
    &self,
    hf: HostFunction,
    args: ScVec
) -> Result<ScVal, HostError>

pub fn register_test_contract(
    &self,
    contract_id: Object,
    contract_fns: Rc<dyn ContractFunctionSet>
) -> Result<(), HostError>

pub fn register_test_contract_wasm(
    &self,
    contract_id: Object,
    contract_wasm: &[u8]
) -> Result<(), HostError>

pub fn register_test_contract_token(
    &self,
    contract_id: Object
) -> Result<(), HostError>

pub fn add_ledger_entry(
    &self,
    key: LedgerKey,
    val: LedgerEntry
) -> Result<(), HostError>

pub fn system_event(
    &self,
    topics: Object,
    data: RawVal
) -> Result<RawVal, HostError>

Records a System contract event. topics is expected to be a SCVec length <= 4 that cannot contain Vec, Map, or Bytes with length > 32 On success, returns an SCStatus::Ok.

Trait Implementations

impl Clone for Host

fn clone(&self) -> Host

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Host

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Host

fn default() -> Host

Returns the “default value” for a type.

impl EnvBase for Host

fn as_mut_any(&mut self) -> &mut dyn Any

Used for recovering the concrete type of the Host.

fn check_same_env(&self, other: &Self)

Used to check two environments are the same, trapping if not.

fn deep_clone(&self) -> Self

Used to clone an environment deeply, not just a handle to it.

fn bytes_copy_from_slice(
    &self,
    b: Object,
    b_pos: RawVal,
    mem: &[u8]
) -> Result<Object, Status>

Copy a slice of bytes from the caller’s memory into an existing Bytes object the host, returning a new Bytes.

fn bytes_copy_to_slice(
    &self,
    b: Object,
    b_pos: RawVal,
    mem: &mut [u8]
) -> Result<(), Status>

Copy a slice of bytes from a Bytes object in the host into the caller’s memory.

fn bytes_new_from_slice(&self, mem: &[u8]) -> Result<Object, Status>

Form a new Bytes object in the host from a slice of memory in the caller.

fn log_static_fmt_val(&self, fmt: &'static str, v: RawVal) -> Result<(), Status>

Log a formatted debugging message to the debug log (if present), passing a simplified format string (supporting only positional {} markers) and a single RawVal argument that will be inserted at the marker in the format string.

fn log_static_fmt_static_str(
    &self,
    fmt: &'static str,
    s: &'static str
) -> Result<(), Status>

Log a formatted debugging message to the debug log (if present), passing a simplified format string (supporting only positional {} markers) and a single string-slice argument that will be inserted at the marker in the format string.

fn log_static_fmt_val_static_str(
    &self,
    fmt: &'static str,
    v: RawVal,
    s: &'static str
) -> Result<(), Status>

Log a formatted debugging message to the debug log (if present), passing a simplified format string (supporting only positional {} markers) and both a RawVal and a string-slice argument, that will each be inserted at markers in the format string.

fn log_static_fmt_general(
    &self,
    fmt: &'static str,
    vals: &[RawVal],
    strs: &[&'static str]
) -> Result<(), Status>

Log a formatted debugging message to the debug log (if present), passing a simplified format string (supporting only positional {} markers) and both a slice of RawVals and a slice of string-slice argument, that will be sequentially inserted at markers in the format string.

impl TryConvert<&Object, ScObject> for Host

type Error = HostError

fn convert(&self, ob: &Object) -> Result<ScObject, Self::Error>

impl TryConvert<&ScObject, Object> for Host

type Error = HostError

fn convert(&self, ob: &ScObject) -> Result<Object, Self::Error>

impl TryConvert<Object, ScObject> for Host

type Error = HostError

fn convert(&self, ob: Object) -> Result<ScObject, Self::Error>

impl TryConvert<ScObject, Object> for Host

type Error = HostError

fn convert(&self, ob: ScObject) -> Result<Object, Self::Error>

impl TryFromVal<Host, Object> for AccountId

type Error = HostError

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

impl TryFromVal<Host, RawVal> for AccountId

type Error = HostError

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

impl TryIntoVal<Host, RawVal> for AccountId

type Error = HostError

fn try_into_val(self, env: &Host) -> Result<RawVal, Self::Error>

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

impl VmCallerCheckedEnv for Host

type VmUserState = Host

type Error = HostError

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

fn log_fmt_values(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    fmt: Object,
    args: Object
) -> Result<RawVal, HostError>

fn get_invoker_type(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<u64, HostError>

Get whether the contract invocation is from an account or another contract. Returns 0 for account, 1 for contract.

fn get_invoking_account(
    &self,
    vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Get the AccountID object type of the account which invoked the running contract. Traps if the running contract was not invoked by an account.

fn get_invoking_contract(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Get the contractID Bytes of the contract which invoked the running contract. Traps if the running contract was not invoked by a contract.

fn obj_cmp(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: RawVal,
    b: RawVal
) -> Result<i64, HostError>

fn contract_event(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    topics: Object,
    data: RawVal
) -> Result<RawVal, HostError>

Records a contract event. topics is expected to be a SCVec with length <= 4 that cannot contain Vec, Map, or Bytes with length > 32 On success, returns an SCStatus::Ok.

fn get_current_contract(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Get the contractID Bytes of the contract which invoked the running contract. Traps if the running contract was not invoked by a contract.

fn obj_from_u64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    u: u64
) -> Result<Object, HostError>

fn obj_to_u64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    obj: Object
) -> Result<u64, HostError>

fn obj_from_i64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    i: i64
) -> Result<Object, HostError>

Convert an i64 to an object containing an i64.

fn obj_to_i64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    obj: Object
) -> Result<i64, HostError>

Convert an object containing an i64 to an i64.

fn map_new(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Create an empty new map.

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

Insert a key/value mapping into an existing map, and return the map object handle. If the map already has a mapping for the given key, the previous value is overwritten.

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

Get the value for a key from a map. Traps if key is not found.

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

Remove a key/value mapping from a map if it exists, traps if doesn’t.

fn map_len(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    m: Object
) -> Result<RawVal, HostError>

Get the size of a map.

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

Test for the presence of a key in a map. Returns (SCStatic) TRUE/FALSE.

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

Given a key, find the first key less than itself in the map’s sorted order. If such a key does not exist, return an SCStatus containing the error code (TBD).

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

Given a key, find the first key greater than itself in the map’s sorted order. If such a key does not exist, return an SCStatus containing the error code (TBD).

fn map_min_key(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    m: Object
) -> Result<RawVal, HostError>

Find the minimum key from a map. If the map is empty, return an SCStatus containing the error code (TBD).

fn map_max_key(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    m: Object
) -> Result<RawVal, HostError>

Find the maximum key from a map. If the map is empty, return an SCStatus containing the error code (TBD).

fn map_keys(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    m: Object
) -> Result<Object, HostError>

Return a new vector containing all the keys in a map. The new vector is ordered in the original map’s key-sorted order.

fn map_values(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    m: Object
) -> Result<Object, HostError>

Return a new vector containing all the values in a map. The new vector is ordered in the original map’s key-sorted order.

fn vec_new(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    c: RawVal
) -> Result<Object, HostError>

Creates a new vector with an optional capacity hint c. If c is ScStatic::Void, no hint is assumed and the new vector is empty. Otherwise, c is parsed as an u32 that represents the initial capacity of the new vector.

fn vec_put(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    i: RawVal,
    x: RawVal
) -> Result<Object, HostError>

Update the value at index i in the vector. Return the new vector. Trap if the index is out of bounds.

fn vec_get(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    i: RawVal
) -> Result<RawVal, HostError>

Returns the element at index i of the vector. Traps if the index is out of bound.

fn vec_del(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    i: RawVal
) -> Result<Object, HostError>

Delete an element in a vector at index i, shifting all elements after it to the left. Return the new vector. Traps if the index is out of bound.

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

Returns length of the vector.

fn vec_push_front(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    x: RawVal
) -> Result<Object, HostError>

Push a value to the front of a vector.

fn vec_pop_front(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object
) -> Result<Object, HostError>

Removes the first element from the vector and returns the new vector. Traps if original vector is empty.

fn vec_push_back(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    x: RawVal
) -> Result<Object, HostError>

Appends an element to the back of the vector.

fn vec_pop_back(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object
) -> Result<Object, HostError>

Removes the last element from the vector and returns the new vector. Traps if original vector is empty.

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

Return the first element in the vector. Traps if the vector is empty

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

Return the last element in the vector. Traps if the vector is empty

fn vec_insert(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    i: RawVal,
    x: RawVal
) -> Result<Object, HostError>

Inserts an element at index i within the vector, shifting all elements after it to the right. Traps if the index is out of bound

fn vec_append(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v1: Object,
    v2: Object
) -> Result<Object, HostError>

Clone the vector v1, then moves all the elements of vector v2 into it. Return the new vector. Traps if number of elements in the vector overflows a u32.

fn vec_slice(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    start: RawVal,
    end: RawVal
) -> Result<Object, HostError>

Copy the elements from start index until end index, exclusive, in the vector and create a new vector from it. Return the new vector. Traps if the index is out of bound.

fn vec_first_index_of(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    x: RawVal
) -> Result<RawVal, Self::Error>

Get the index of the first occurrence of a given element in the vector. Returns the u32 index of the value if it’s there. Otherwise, it returns ScStatic::Void.

fn vec_last_index_of(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    x: RawVal
) -> Result<RawVal, Self::Error>

Get the index of the last occurrence of a given element in the vector. Returns the u32 index of the value if it’s there. Otherwise, it returns ScStatic::Void.

fn vec_binary_search(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    x: RawVal
) -> Result<u64, Self::Error>

Binary search a sorted vector for a given element. If it exists, the high-32 bits of the return value is 0x0001 and the low-32 bits contain the u32 index of the element. If it does not exist, the high-32 bits of the return value is 0x0000 and the low-32 bits contain the u32 index at which the element would need to be inserted into the vector to maintain sorted order.

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

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

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

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

fn create_contract_from_ed25519(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    salt: Object,
    key: Object,
    sig: Object
) -> Result<Object, HostError>

fn create_contract_from_contract(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    salt: Object
) -> Result<Object, HostError>

fn create_contract_from_source_account(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    v: Object,
    salt: Object
) -> Result<Object, HostError>

Create a contract using the source account and salt as input to the contract ID that gets created. Pass as arguments a Bytes for the wasm code and a Bytes for the salt. Returned will be a Bytes of length 32 bytes.

fn create_token_from_source_account(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    salt: Object
) -> Result<Object, HostError>

Create a token contract using the source account and salt as input to the contract ID that gets created. Pass as arguments a Bytes for the salt. Returned will be a Bytes of length 32 bytes.

fn create_token_from_ed25519(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    salt: Object,
    key: Object,
    sig: Object
) -> Result<Object, HostError>

fn create_token_from_contract(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    salt: Object
) -> Result<Object, HostError>

fn create_token_from_asset(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    asset_bytes: Object
) -> Result<Object, HostError>

fn call(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    contract: Object,
    func: Symbol,
    args: Object
) -> Result<RawVal, HostError>

Calls a function in another contract with arguments contained in vector args. If the call is successful, forwards the result of the called function. Traps otherwise.

fn try_call(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    contract: Object,
    func: Symbol,
    args: Object
) -> Result<RawVal, HostError>

Calls a function in another contract with arguments contained in vector args. Returns:

fn bigint_from_u64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: u64
) -> Result<Object, HostError>

Constructs a BigInt from an u64.

fn bigint_to_u64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<u64, HostError>

Converts a BigInt to an u64. Traps if the value cannot fit into u64.

fn bigint_from_i64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: i64
) -> Result<Object, HostError>

Constructs a BigInt from an i64.

fn bigint_to_i64(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<i64, HostError>

Converts a BigInt to an i64. Traps if the value cannot fit into i64.

fn bigint_add(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the + operation.

fn bigint_sub(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the - operation.

fn bigint_mul(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the * operation.

fn bigint_div(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the / operation. Traps if y is zero.

fn bigint_rem(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the % operation. Traps if y is zero.

fn bigint_and(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the & operation.

fn bigint_or(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the | operation.

fn bigint_xor(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the ^ operation.

fn bigint_shl(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the << operation. Traps if y is negative or larger than the size of u64.

fn bigint_shr(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Performs the >> operation. Traps if y is negative or larger than the size of u64.

fn bigint_is_zero(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<RawVal, HostError>

Returns true if x is equal to the additive identity.

fn bigint_neg(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

Performs the unary - operation.

fn bigint_not(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

Performs the unary ! operation.

fn bigint_gcd(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Calculates the Greatest Common Divisor (GCD) of x and y.

fn bigint_lcm(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Calculates the Lowest Common Multiple (LCM) of x and y.

fn bigint_pow(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    y: Object
) -> Result<Object, HostError>

Calculates x to the power y. Traps if y is negative or larger than the size of u64.

fn bigint_pow_mod(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    p: Object,
    q: Object,
    m: Object
) -> Result<Object, HostError>

Calculates (p ^ q) mod m. Note that this rounds like mod_floor, not like the % operator, which makes a difference when given a negative p or m. The result will be in the interval [0, m) for m > 0, or in the interval (m, 0] for m < 0. Traps if the q is negative or the m is zero.

fn bigint_sqrt(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

Calculates the truncated principal square root of x. Traps if x is negative.

fn bigint_bits(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<u64, HostError>

Determines the fewest bits necessary to express x, not including the sign.

fn bigint_to_bytes_be(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, Self::Error>

Outputs the BigInt’s magnitude in big-endian byte order into a byte array. The sign is dropped.

fn bigint_to_radix_be(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object,
    radix: RawVal
) -> Result<Object, Self::Error>

Outputs the BigInt’s magnitude in the requested base in big-endian digit order into a byte array. The sign is dropped. Radix must be in the range 2…256.

fn bigint_from_bytes_be(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    sign: RawVal,
    bytes: Object
) -> Result<Object, Self::Error>

Creates a BigInt from a byte array and i32 sign. Bytes are in big-endian order. Sign is interpreted: -1 as negative, 0 as zero, 1 as positive If sign is 0, then the input bytes are ignored and will return a BigInt of 0.

fn bigint_from_radix_be(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    sign: RawVal,
    buf: Object,
    radix: RawVal
) -> Result<Object, Self::Error>

Creates a BigInt from a byte array buf, an i32 sign and an u32 radix. Each u8 of the byte array is interpreted as one digit of the number and must therefore be less than the radix. The bytes are in big-endian byte order. Radix must be in the range 2..=256. Sign follows same rule as in bigint_from_bytes_be.

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

Serializes an (SC)Val into XDR opaque Bytes object.

fn deserialize_from_bytes(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object
) -> Result<RawVal, HostError>

Deserialize a Bytes object to get back the (SC)Val.

fn bytes_copy_to_linear_memory(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    b_pos: RawVal,
    lm_pos: RawVal,
    len: RawVal
) -> Result<RawVal, HostError>

Copies a slice of bytes from a Bytes object specified at offset b_pos with length len into the linear memory at position lm_pos. Traps if either the Bytes object or the linear memory doesn’t have enough bytes.

fn bytes_copy_from_linear_memory(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    b_pos: RawVal,
    lm_pos: RawVal,
    len: RawVal
) -> Result<Object, HostError>

Copies a segment of the linear memory specified at position lm_pos with length len, into a Bytes object at offset b_pos. The Bytes object may grow in size to accommodate the new bytes. Traps if the linear memory doesn’t have enough bytes.

fn bytes_new_from_linear_memory(
    &self,
    vmcaller: &mut VmCaller<'_, Host>,
    lm_pos: RawVal,
    len: RawVal
) -> Result<Object, HostError>

Constructs a new Bytes object initialized with bytes copied from a linear memory slice specified at position lm_pos with length len.

fn bytes_new(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Create an empty new Bytes object.

fn bytes_put(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    i: RawVal,
    u: RawVal
) -> Result<Object, HostError>

Update the value at index i in the Bytes object. Return the new Bytes. Trap if the index is out of bounds.

fn bytes_get(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    i: RawVal
) -> Result<RawVal, HostError>

Returns the element at index i of the Bytes object. Traps if the index is out of bound.

fn bytes_del(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    i: RawVal
) -> Result<Object, HostError>

Delete an element in a Bytes object at index i, shifting all elements after it to the left. Return the new Bytes. Traps if the index is out of bound.

fn bytes_len(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object
) -> Result<RawVal, HostError>

Returns length of the Bytes object.

fn bytes_push(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    u: RawVal
) -> Result<Object, HostError>

Appends an element to the back of the Bytes object.

fn bytes_pop(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object
) -> Result<Object, HostError>

Removes the last element from the Bytes object and returns the new Bytes. Traps if original Bytes is empty.

fn bytes_front(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object
) -> Result<RawVal, HostError>

Return the first element in the Bytes object. Traps if the Bytes is empty

fn bytes_back(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object
) -> Result<RawVal, HostError>

Return the last element in the Bytes object. Traps if the Bytes is empty

fn bytes_insert(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    i: RawVal,
    u: RawVal
) -> Result<Object, HostError>

Inserts an element at index i within the Bytes object, shifting all elements after it to the right. Traps if the index is out of bound

fn bytes_append(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b1: Object,
    b2: Object
) -> Result<Object, HostError>

Clone the Bytes object b1, then moves all the elements of Bytes object b2 into it. Return the new Bytes. Traps if its length overflows a u32.

fn bytes_slice(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    b: Object,
    start: RawVal,
    end: RawVal
) -> Result<Object, HostError>

Copies the elements from start index until end index, exclusive, in the Bytes object and creates a new Bytes from it. Returns the new Bytes. Traps if the index is out of bound.

fn hash_from_bytes(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

fn hash_to_bytes(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

fn public_key_from_bytes(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

fn public_key_to_bytes(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

fn compute_hash_sha256(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    x: Object
) -> Result<Object, HostError>

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

fn account_get_low_threshold(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: Object
) -> Result<RawVal, Self::Error>

Get the low threshold for the account with ID a (a is AccountId). Traps if no such account exists.

fn account_get_medium_threshold(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: Object
) -> Result<RawVal, Self::Error>

Get the medium threshold for the account with ID a (a is AccountId). Traps if no such account exists.

fn account_get_high_threshold(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: Object
) -> Result<RawVal, Self::Error>

Get the high threshold for the account with ID a (a is AccountId). Traps if no such account exists.

fn account_exists(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: Object
) -> Result<RawVal, Self::Error>

Given an ID a (a is AccountId) of an account, check if it exists. Returns (SCStatic) TRUE/FALSE.

fn account_get_signer_weight(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>,
    a: Object,
    s: Object
) -> Result<RawVal, Self::Error>

Get the signer weight for the signer with ed25519 public key s (s is Bytes) on the account with ID a (a is AccountId). Returns the master weight if the signer is the master, and returns 0 if no such signer exists. Traps if no such account exists.

fn get_ledger_version(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<RawVal, Self::Error>

Return the protocol version of the current ledger as a u32.

fn get_ledger_sequence(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<RawVal, Self::Error>

Return the sequence number of the current ledger as a u32.

fn get_ledger_timestamp(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, Self::Error>

Return the timestamp number of the current ledger as a u64.

fn get_ledger_network_passphrase(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, Self::Error>

Return the network passphrase of the current ledger as Bytes.

fn get_ledger_network_id(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, Self::Error>

Return the network id (sha256 hash of network passphrase) of the current ledger as Bytes. The value is always 32 bytes in length.

fn get_current_call_stack(
    &self,
    _vmcaller: &mut VmCaller<'_, Host>
) -> Result<Object, HostError>

Returns the full call stack from the first contract call to the current one as a vector of vectors, where the inside vector contains the contract id as Hash, and a function as a Symbol.

fn fail_with_status(
    &self,
    vmcaller: &mut VmCaller<'_, Self::VmUserState>,
    status: Status
) -> Result<RawVal, Self::Error>

Causes the currently executing contract to fail immediately with a provided status code, which must be of error-type ScStatusType::ContractError. Does not actually return.