Trait soroban_env_host::VmCallerCheckedEnv

source · 
pub trait VmCallerCheckedEnv {
    type VmUserState;
    type Error: Debug;


Show 117 methods    fn escalate_error_to_panic(&self, e: Self::Error) -> !;
    fn log_value(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn get_invoking_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn obj_cmp(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: RawVal,
        b: RawVal
    ) -> Result<i64, Self::Error>;
    fn contract_event(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        topics: Object,
        data: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn get_current_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn get_ledger_version(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<RawVal, Self::Error>;
    fn get_ledger_sequence(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<RawVal, Self::Error>;
    fn get_ledger_timestamp(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn get_ledger_network_passphrase(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn get_current_call_stack(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn fail_with_status(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        status: Status
    ) -> Result<RawVal, Self::Error>;
    fn log_fmt_values(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        fmt: Object,
        args: Object
    ) -> Result<RawVal, Self::Error>;
    fn get_invoker_type(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<u64, Self::Error>;
    fn get_invoking_account(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn get_ledger_network_id(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn obj_from_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: u64
    ) -> Result<Object, Self::Error>;
    fn obj_to_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: Object
    ) -> Result<u64, Self::Error>;
    fn obj_from_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: i64
    ) -> Result<Object, Self::Error>;
    fn obj_to_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: Object
    ) -> Result<i64, Self::Error>;
    fn map_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn map_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal,
        v: RawVal
    ) -> Result<Object, Self::Error>;
    fn map_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn map_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal
    ) -> Result<Object, Self::Error>;
    fn map_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object
    ) -> Result<RawVal, Self::Error>;
    fn map_has(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn map_prev_key(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn map_next_key(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn map_min_key(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object
    ) -> Result<RawVal, Self::Error>;
    fn map_max_key(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object
    ) -> Result<RawVal, Self::Error>;
    fn map_keys(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object
    ) -> Result<Object, Self::Error>;
    fn map_values(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: Object
    ) -> Result<Object, Self::Error>;
    fn vec_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        c: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        i: RawVal,
        x: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        i: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn vec_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        i: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object
    ) -> Result<RawVal, Self::Error>;
    fn vec_push_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        x: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_pop_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object
    ) -> Result<Object, Self::Error>;
    fn vec_push_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        x: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_pop_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object
    ) -> Result<Object, Self::Error>;
    fn vec_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object
    ) -> Result<RawVal, Self::Error>;
    fn vec_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object
    ) -> Result<RawVal, Self::Error>;
    fn vec_insert(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        i: RawVal,
        x: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_append(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v1: Object,
        v2: Object
    ) -> Result<Object, Self::Error>;
    fn vec_slice(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        start: RawVal,
        end: RawVal
    ) -> Result<Object, Self::Error>;
    fn vec_first_index_of(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        x: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn vec_last_index_of(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        x: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn vec_binary_search(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        x: RawVal
    ) -> Result<u64, Self::Error>;
    fn put_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: RawVal,
        v: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn has_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn get_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn del_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn create_contract_from_ed25519(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        salt: Object,
        key: Object,
        sig: Object
    ) -> Result<Object, Self::Error>;
    fn create_contract_from_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        salt: Object
    ) -> Result<Object, Self::Error>;
    fn create_token_from_ed25519(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        salt: Object,
        key: Object,
        sig: Object
    ) -> Result<Object, Self::Error>;
    fn create_token_from_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        salt: Object
    ) -> Result<Object, Self::Error>;
    fn create_token_from_asset(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        asset: Object
    ) -> Result<Object, Self::Error>;
    fn create_contract_from_source_account(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Object,
        salt: Object
    ) -> Result<Object, Self::Error>;
    fn create_token_from_source_account(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        salt: Object
    ) -> Result<Object, Self::Error>;
    fn call(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        contract: Object,
        func: Symbol,
        args: Object
    ) -> Result<RawVal, Self::Error>;
    fn try_call(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        contract: Object,
        func: Symbol,
        args: Object
    ) -> Result<RawVal, Self::Error>;
    fn bigint_from_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: u64
    ) -> Result<Object, Self::Error>;
    fn bigint_to_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<u64, Self::Error>;
    fn bigint_from_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: i64
    ) -> Result<Object, Self::Error>;
    fn bigint_to_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<i64, Self::Error>;
    fn bigint_add(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_sub(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_mul(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_div(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_rem(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_and(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_or(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_xor(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_shl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_shr(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_is_zero(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<RawVal, Self::Error>;
    fn bigint_neg(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_not(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_gcd(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_lcm(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_pow(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        y: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_pow_mod(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        p: Object,
        q: Object,
        m: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_sqrt(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_bits(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<u64, Self::Error>;
    fn bigint_to_bytes_be(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_to_radix_be(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        radix: RawVal
    ) -> Result<Object, Self::Error>;
    fn bigint_from_bytes_be(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        sign: RawVal,
        bytes: Object
    ) -> Result<Object, Self::Error>;
    fn bigint_from_radix_be(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        sign: RawVal,
        buf: Object,
        radix: RawVal
    ) -> Result<Object, Self::Error>;
    fn serialize_to_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: RawVal
    ) -> Result<Object, Self::Error>;
    fn deserialize_from_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object
    ) -> Result<RawVal, Self::Error>;
    fn bytes_copy_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        b_pos: RawVal,
        lm_pos: RawVal,
        len: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn bytes_copy_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        b_pos: RawVal,
        lm_pos: RawVal,
        len: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lm_pos: RawVal,
        len: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Object, Self::Error>;
    fn bytes_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        i: RawVal,
        u: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        i: RawVal
    ) -> Result<RawVal, Self::Error>;
    fn bytes_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        i: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object
    ) -> Result<RawVal, Self::Error>;
    fn bytes_push(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        u: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_pop(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object
    ) -> Result<Object, Self::Error>;
    fn bytes_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object
    ) -> Result<RawVal, Self::Error>;
    fn bytes_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object
    ) -> Result<RawVal, Self::Error>;
    fn bytes_insert(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        i: RawVal,
        u: RawVal
    ) -> Result<Object, Self::Error>;
    fn bytes_append(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b1: Object,
        b2: Object
    ) -> Result<Object, Self::Error>;
    fn bytes_slice(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: Object,
        start: RawVal,
        end: RawVal
    ) -> Result<Object, Self::Error>;
    fn hash_from_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn hash_to_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn public_key_from_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn public_key_to_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn compute_hash_sha256(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object
    ) -> Result<Object, Self::Error>;
    fn verify_sig_ed25519(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: Object,
        k: Object,
        s: Object
    ) -> Result<RawVal, Self::Error>;
    fn account_get_low_threshold(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Object
    ) -> Result<RawVal, Self::Error>;
    fn account_get_medium_threshold(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Object
    ) -> Result<RawVal, Self::Error>;
    fn account_get_high_threshold(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Object
    ) -> Result<RawVal, Self::Error>;
    fn account_get_signer_weight(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Object,
        s: Object
    ) -> Result<RawVal, Self::Error>;
    fn account_exists(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Object
    ) -> Result<RawVal, Self::Error>;

}
Expand description

This trait is a variant of the Env trait used to define the interface implemented by Host. The wasmi VM dispatch functions call methods on VmCallerCheckedEnv, passing a VmCaller that wraps the wasmi Caller context, and then convert any Result::Err(...) return value into a VM trap, halting VM execution.

There is also a blanket impl<T:VmCallerCheckedEnv> CheckedEnv for T that implements the CheckedEnv for any VmCallerCheckedEnv by passing VmCaller::none() for the first argument, allowing user code such as the native contract to avoid writing VmCaller::none() everywhere.

Required Associated Types

Required Methods

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

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.

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

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

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

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

Return the network passphrase of the current ledger as Bytes.

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.

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.

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

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

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

Convert an i64 to an object containing an i64.

Convert an object containing an i64 to an i64.

Create an empty new map.

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.

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

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

Get the size of a map.

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

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).

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).

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

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

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

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

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.

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

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

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.

Returns length of the vector.

Push a value to the front of a vector.

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

Appends an element to the back of the vector.

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

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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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

  • if successful, result of the called function.
  • otherwise, an SCStatus containing the error status code.

Constructs a BigInt from an u64.

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

Constructs a BigInt from an i64.

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

Performs the + operation.

Performs the - operation.

Performs the * operation.

Performs the / operation. Traps if y is zero.

Performs the % operation. Traps if y is zero.

Performs the & operation.

Performs the | operation.

Performs the ^ operation.

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

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

Returns true if x is equal to the additive identity.

Performs the unary - operation.

Performs the unary ! operation.

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

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

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

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.

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

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

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

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.

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.

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.

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

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

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.

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.

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

Create an empty new Bytes object.

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

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

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.

Returns length of the Bytes object.

Appends an element to the back of the Bytes object.

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

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

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

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

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.

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.

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

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

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

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.

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

Implementors