Trait soroban_env_guest::VmCallerEnv

pub trait VmCallerEnv: EnvBase {
    type VmUserState;

    // Required methods
    fn log_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        msg_pos: U32Val,
        msg_len: U32Val,
        vals_pos: U32Val,
        vals_len: U32Val
    ) -> Result<Void, Self::Error>;
    fn obj_cmp(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        a: Val,
        b: Val
    ) -> Result<i64, Self::Error>;
    fn contract_event(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        topics: VecObject,
        data: Val
    ) -> Result<Void, Self::Error>;
    fn get_ledger_version(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<U32Val, Self::Error>;
    fn get_ledger_sequence(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<U32Val, Self::Error>;
    fn get_ledger_timestamp(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<U64Val, Self::Error>;
    fn fail_with_error(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        error: Error
    ) -> Result<Void, Self::Error>;
    fn get_ledger_network_id(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<BytesObject, Self::Error>;
    fn get_current_contract_address(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<AddressObject, Self::Error>;
    fn get_max_live_until_ledger(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<U32Val, Self::Error>;
    fn obj_from_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: u64
    ) -> Result<U64Object, Self::Error>;
    fn obj_to_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U64Object
    ) -> Result<u64, Self::Error>;
    fn obj_from_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: i64
    ) -> Result<I64Object, Self::Error>;
    fn obj_to_i64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I64Object
    ) -> Result<i64, Self::Error>;
    fn obj_from_u128_pieces(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        hi: u64,
        lo: u64
    ) -> Result<U128Object, Self::Error>;
    fn obj_to_u128_lo64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U128Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_u128_hi64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U128Object
    ) -> Result<u64, Self::Error>;
    fn obj_from_i128_pieces(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        hi: i64,
        lo: u64
    ) -> Result<I128Object, Self::Error>;
    fn obj_to_i128_lo64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I128Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_i128_hi64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I128Object
    ) -> Result<i64, Self::Error>;
    fn obj_from_u256_pieces(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        hi_hi: u64,
        hi_lo: u64,
        lo_hi: u64,
        lo_lo: u64
    ) -> Result<U256Object, Self::Error>;
    fn u256_val_from_be_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        bytes: BytesObject
    ) -> Result<U256Val, Self::Error>;
    fn u256_val_to_be_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        val: U256Val
    ) -> Result<BytesObject, Self::Error>;
    fn obj_to_u256_hi_hi(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U256Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_u256_hi_lo(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U256Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_u256_lo_hi(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U256Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_u256_lo_lo(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: U256Object
    ) -> Result<u64, Self::Error>;
    fn obj_from_i256_pieces(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        hi_hi: i64,
        hi_lo: u64,
        lo_hi: u64,
        lo_lo: u64
    ) -> Result<I256Object, Self::Error>;
    fn i256_val_from_be_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        bytes: BytesObject
    ) -> Result<I256Val, Self::Error>;
    fn i256_val_to_be_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        val: I256Val
    ) -> Result<BytesObject, Self::Error>;
    fn obj_to_i256_hi_hi(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I256Object
    ) -> Result<i64, Self::Error>;
    fn obj_to_i256_hi_lo(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I256Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_i256_lo_hi(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I256Object
    ) -> Result<u64, Self::Error>;
    fn obj_to_i256_lo_lo(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: I256Object
    ) -> Result<u64, Self::Error>;
    fn u256_add(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U256Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_sub(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U256Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_mul(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U256Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_div(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U256Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_rem_euclid(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U256Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_pow(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U32Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_shl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U32Val
    ) -> Result<U256Val, Self::Error>;
    fn u256_shr(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: U256Val,
        rhs: U32Val
    ) -> Result<U256Val, Self::Error>;
    fn i256_add(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: I256Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_sub(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: I256Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_mul(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: I256Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_div(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: I256Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_rem_euclid(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: I256Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_pow(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: U32Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_shl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: U32Val
    ) -> Result<I256Val, Self::Error>;
    fn i256_shr(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lhs: I256Val,
        rhs: U32Val
    ) -> Result<I256Val, Self::Error>;
    fn timepoint_obj_from_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: u64
    ) -> Result<TimepointObject, Self::Error>;
    fn timepoint_obj_to_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: TimepointObject
    ) -> Result<u64, Self::Error>;
    fn duration_obj_from_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: u64
    ) -> Result<DurationObject, Self::Error>;
    fn duration_obj_to_u64(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        obj: DurationObject
    ) -> Result<u64, Self::Error>;
    fn map_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<MapObject, Self::Error>;
    fn map_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        k: Val,
        v: Val
    ) -> Result<MapObject, Self::Error>;
    fn map_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        k: Val
    ) -> Result<Val, Self::Error>;
    fn map_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        k: Val
    ) -> Result<MapObject, Self::Error>;
    fn map_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject
    ) -> Result<U32Val, Self::Error>;
    fn map_has(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        k: Val
    ) -> Result<Bool, Self::Error>;
    fn map_key_by_pos(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        i: U32Val
    ) -> Result<Val, Self::Error>;
    fn map_val_by_pos(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject,
        i: U32Val
    ) -> Result<Val, Self::Error>;
    fn map_keys(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject
    ) -> Result<VecObject, Self::Error>;
    fn map_values(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        m: MapObject
    ) -> Result<VecObject, Self::Error>;
    fn map_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        keys_pos: U32Val,
        vals_pos: U32Val,
        len: U32Val
    ) -> Result<MapObject, Self::Error>;
    fn map_unpack_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        map: MapObject,
        keys_pos: U32Val,
        vals_pos: U32Val,
        len: U32Val
    ) -> Result<Void, Self::Error>;
    fn vec_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<VecObject, Self::Error>;
    fn vec_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        i: U32Val,
        x: Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        i: U32Val
    ) -> Result<Val, Self::Error>;
    fn vec_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        i: U32Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject
    ) -> Result<U32Val, Self::Error>;
    fn vec_push_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        x: Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_pop_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject
    ) -> Result<VecObject, Self::Error>;
    fn vec_push_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        x: Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_pop_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject
    ) -> Result<VecObject, Self::Error>;
    fn vec_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject
    ) -> Result<Val, Self::Error>;
    fn vec_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject
    ) -> Result<Val, Self::Error>;
    fn vec_insert(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        i: U32Val,
        x: Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_append(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v1: VecObject,
        v2: VecObject
    ) -> Result<VecObject, Self::Error>;
    fn vec_slice(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        start: U32Val,
        end: U32Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_first_index_of(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        x: Val
    ) -> Result<Val, Self::Error>;
    fn vec_last_index_of(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        x: Val
    ) -> Result<Val, Self::Error>;
    fn vec_binary_search(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: VecObject,
        x: Val
    ) -> Result<u64, Self::Error>;
    fn vec_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        vals_pos: U32Val,
        len: U32Val
    ) -> Result<VecObject, Self::Error>;
    fn vec_unpack_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        vec: VecObject,
        vals_pos: U32Val,
        len: U32Val
    ) -> Result<Void, Self::Error>;
    fn put_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: Val,
        v: Val,
        t: StorageType
    ) -> Result<Void, Self::Error>;
    fn has_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: Val,
        t: StorageType
    ) -> Result<Bool, Self::Error>;
    fn get_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: Val,
        t: StorageType
    ) -> Result<Val, Self::Error>;
    fn del_contract_data(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: Val,
        t: StorageType
    ) -> Result<Void, Self::Error>;
    fn create_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        deployer: AddressObject,
        wasm_hash: BytesObject,
        salt: BytesObject
    ) -> Result<AddressObject, Self::Error>;
    fn create_asset_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        serialized_asset: BytesObject
    ) -> Result<AddressObject, Self::Error>;
    fn upload_wasm(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        wasm: BytesObject
    ) -> Result<BytesObject, Self::Error>;
    fn update_current_contract_wasm(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        hash: BytesObject
    ) -> Result<Void, Self::Error>;
    fn extend_contract_data_ttl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: Val,
        t: StorageType,
        threshold: U32Val,
        extend_to: U32Val
    ) -> Result<Void, Self::Error>;
    fn extend_current_contract_instance_and_code_ttl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        threshold: U32Val,
        extend_to: U32Val
    ) -> Result<Void, Self::Error>;
    fn extend_contract_instance_and_code_ttl(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        contract: AddressObject,
        threshold: U32Val,
        extend_to: U32Val
    ) -> Result<Void, Self::Error>;
    fn get_contract_id(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        deployer: AddressObject,
        salt: BytesObject
    ) -> Result<AddressObject, Self::Error>;
    fn get_asset_contract_id(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        serialized_asset: BytesObject
    ) -> Result<AddressObject, Self::Error>;
    fn call(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        contract: AddressObject,
        func: Symbol,
        args: VecObject
    ) -> Result<Val, Self::Error>;
    fn try_call(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        contract: AddressObject,
        func: Symbol,
        args: VecObject
    ) -> Result<Val, Self::Error>;
    fn serialize_to_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        v: Val
    ) -> Result<BytesObject, Self::Error>;
    fn deserialize_from_bytes(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject
    ) -> Result<Val, Self::Error>;
    fn bytes_copy_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        b_pos: U32Val,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<Void, Self::Error>;
    fn bytes_copy_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        b_pos: U32Val,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_put(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        i: U32Val,
        u: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_get(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        i: U32Val
    ) -> Result<U32Val, Self::Error>;
    fn bytes_del(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        i: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject
    ) -> Result<U32Val, Self::Error>;
    fn bytes_push(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        u: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_pop(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_front(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject
    ) -> Result<U32Val, Self::Error>;
    fn bytes_back(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject
    ) -> Result<U32Val, Self::Error>;
    fn bytes_insert(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        i: U32Val,
        u: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_append(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b1: BytesObject,
        b2: BytesObject
    ) -> Result<BytesObject, Self::Error>;
    fn bytes_slice(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        b: BytesObject,
        start: U32Val,
        end: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn string_copy_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        s: StringObject,
        s_pos: U32Val,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<Void, Self::Error>;
    fn symbol_copy_to_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        s: SymbolObject,
        s_pos: U32Val,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<Void, Self::Error>;
    fn string_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<StringObject, Self::Error>;
    fn symbol_new_from_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lm_pos: U32Val,
        len: U32Val
    ) -> Result<SymbolObject, Self::Error>;
    fn string_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        s: StringObject
    ) -> Result<U32Val, Self::Error>;
    fn symbol_len(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        s: SymbolObject
    ) -> Result<U32Val, Self::Error>;
    fn symbol_index_in_linear_memory(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        sym: Symbol,
        slices_pos: U32Val,
        len: U32Val
    ) -> Result<U32Val, Self::Error>;
    fn compute_hash_sha256(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: BytesObject
    ) -> Result<BytesObject, Self::Error>;
    fn verify_sig_ed25519(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        k: BytesObject,
        x: BytesObject,
        s: BytesObject
    ) -> Result<Void, Self::Error>;
    fn compute_hash_keccak256(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        x: BytesObject
    ) -> Result<BytesObject, Self::Error>;
    fn recover_key_ecdsa_secp256k1(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        msg_digest: BytesObject,
        signature: BytesObject,
        recovery_id: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn require_auth_for_args(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        address: AddressObject,
        args: VecObject
    ) -> Result<Void, Self::Error>;
    fn require_auth(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        address: AddressObject
    ) -> Result<Void, Self::Error>;
    fn strkey_to_address(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        strkey: Val
    ) -> Result<AddressObject, Self::Error>;
    fn address_to_strkey(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        address: AddressObject
    ) -> Result<StringObject, Self::Error>;
    fn authorize_as_curr_contract(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        auth_entires: VecObject
    ) -> Result<Void, Self::Error>;
    fn dummy0(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>
    ) -> Result<Val, Self::Error>;
    fn prng_reseed(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        seed: BytesObject
    ) -> Result<Void, Self::Error>;
    fn prng_bytes_new(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        length: U32Val
    ) -> Result<BytesObject, Self::Error>;
    fn prng_u64_in_inclusive_range(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        lo: u64,
        hi: u64
    ) -> Result<u64, Self::Error>;
    fn prng_vec_shuffle(
        &self,
        vmcaller: &mut VmCaller<'_, Self::VmUserState>,
        vec: VecObject
    ) -> Result<VecObject, Self::Error>;
}

This trait is a variant of the Env trait used to define the interface implemented by Host. The wasmi VM dispatch functions (in soroban_env_host::dispatch) call methods on VmCallerEnv, 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:VmCallerEnv> Env for T that implements the Env for any VmCallerEnv 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

type VmUserState

Required Methods

fn log_from_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, msg_pos: U32Val, msg_len: U32Val, vals_pos: U32Val, vals_len: U32Val ) -> Result<Void, Self::Error>

Emit a diagnostic event containing a message and sequence of Vals.

fn obj_cmp( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, a: Val, b: Val ) -> Result<i64, Self::Error>

Compare two objects, or at least one object to a non-object, structurally. Returns -1 if a<b, 1 if a>b, or 0 if a==b.

fn contract_event( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, topics: VecObject, data: Val ) -> Result<Void, Self::Error>

Records a contract event. topics is expected to be a SCVec with length <= 4 that cannot contain Vec, Map, or Bytes with length > 32.

fn get_ledger_version( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<U32Val, Self::Error>

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

fn get_ledger_sequence( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<U32Val, Self::Error>

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

fn get_ledger_timestamp( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<U64Val, Self::Error>

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

fn fail_with_error( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, error: Error ) -> Result<Void, Self::Error>

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

fn get_ledger_network_id( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<BytesObject, 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_contract_address( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<AddressObject, Self::Error>

Get the Address object for the current contract.

fn get_max_live_until_ledger( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<U32Val, Self::Error>

Returns the max ledger sequence that an entry can live to (inclusive).

fn obj_from_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: u64 ) -> Result<U64Object, Self::Error>

Convert a u64 to an object containing a u64.

fn obj_to_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U64Object ) -> Result<u64, Self::Error>

Convert an object containing a u64 to a u64.

fn obj_from_i64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: i64 ) -> Result<I64Object, Self::Error>

Convert an i64 to an object containing an i64.

fn obj_to_i64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I64Object ) -> Result<i64, Self::Error>

Convert an object containing an i64 to an i64.

fn obj_from_u128_pieces( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, hi: u64, lo: u64 ) -> Result<U128Object, Self::Error>

Convert the high and low 64-bit words of a u128 to an object containing a u128.

fn obj_to_u128_lo64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U128Object ) -> Result<u64, Self::Error>

Extract the low 64 bits from an object containing a u128.

fn obj_to_u128_hi64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U128Object ) -> Result<u64, Self::Error>

Extract the high 64 bits from an object containing a u128.

fn obj_from_i128_pieces( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, hi: i64, lo: u64 ) -> Result<I128Object, Self::Error>

Convert the high and low 64-bit words of an i128 to an object containing an i128.

fn obj_to_i128_lo64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I128Object ) -> Result<u64, Self::Error>

Extract the low 64 bits from an object containing an i128.

fn obj_to_i128_hi64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I128Object ) -> Result<i64, Self::Error>

Extract the high 64 bits from an object containing an i128.

fn obj_from_u256_pieces( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, hi_hi: u64, hi_lo: u64, lo_hi: u64, lo_lo: u64 ) -> Result<U256Object, Self::Error>

Convert the four 64-bit words of a u256 (big-endian) to an object containing a u256.

fn u256_val_from_be_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, bytes: BytesObject ) -> Result<U256Val, Self::Error>

Create a U256 Val from its representation as a byte array in big endian.

fn u256_val_to_be_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, val: U256Val ) -> Result<BytesObject, Self::Error>

Return the memory representation of this U256 Val as a byte array in big endian byte order.

fn obj_to_u256_hi_hi( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U256Object ) -> Result<u64, Self::Error>

Extract the highest 64-bits (bits 192-255) from an object containing a u256.

fn obj_to_u256_hi_lo( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U256Object ) -> Result<u64, Self::Error>

Extract bits 128-191 from an object containing a u256.

fn obj_to_u256_lo_hi( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U256Object ) -> Result<u64, Self::Error>

Extract bits 64-127 from an object containing a u256.

fn obj_to_u256_lo_lo( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: U256Object ) -> Result<u64, Self::Error>

Extract the lowest 64-bits (bits 0-63) from an object containing a u256.

fn obj_from_i256_pieces( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, hi_hi: i64, hi_lo: u64, lo_hi: u64, lo_lo: u64 ) -> Result<I256Object, Self::Error>

Convert the four 64-bit words of an i256 (big-endian) to an object containing an i256.

fn i256_val_from_be_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, bytes: BytesObject ) -> Result<I256Val, Self::Error>

Create a I256 Val from its representation as a byte array in big endian.

fn i256_val_to_be_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, val: I256Val ) -> Result<BytesObject, Self::Error>

Return the memory representation of this I256 Val as a byte array in big endian byte order.

fn obj_to_i256_hi_hi( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I256Object ) -> Result<i64, Self::Error>

Extract the highest 64-bits (bits 192-255) from an object containing an i256.

fn obj_to_i256_hi_lo( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I256Object ) -> Result<u64, Self::Error>

Extract bits 128-191 from an object containing an i256.

fn obj_to_i256_lo_hi( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I256Object ) -> Result<u64, Self::Error>

Extract bits 64-127 from an object containing an i256.

fn obj_to_i256_lo_lo( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: I256Object ) -> Result<u64, Self::Error>

Extract the lowest 64-bits (bits 0-63) from an object containing an i256.

fn u256_add( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U256Val ) -> Result<U256Val, Self::Error>

Performs checked integer addition. Computes lhs + rhs, returning ScError if overflow occurred.

fn u256_sub( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U256Val ) -> Result<U256Val, Self::Error>

Performs checked integer subtraction. Computes lhs - rhs, returning ScError if overflow occurred.

fn u256_mul( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U256Val ) -> Result<U256Val, Self::Error>

Performs checked integer multiplication. Computes lhs * rhs, returning ScError if overflow occurred.

fn u256_div( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U256Val ) -> Result<U256Val, Self::Error>

Performs checked integer division. Computes lhs / rhs, returning ScError if rhs == 0 or overflow occurred.

fn u256_rem_euclid( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U256Val ) -> Result<U256Val, Self::Error>

Performs checked Euclidean modulo. Computes lhs % rhs, returning ScError if rhs == 0 or overflow occurred.

fn u256_pow( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U32Val ) -> Result<U256Val, Self::Error>

Performs checked exponentiation. Computes lhs.exp(rhs), returning ScError if overflow occurred.

fn u256_shl( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U32Val ) -> Result<U256Val, Self::Error>

Performs checked shift left. Computes lhs << rhs, returning ScError if rhs is larger than or equal to the number of bits in lhs.

fn u256_shr( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: U256Val, rhs: U32Val ) -> Result<U256Val, Self::Error>

Performs checked shift right. Computes lhs >> rhs, returning ScError if rhs is larger than or equal to the number of bits in lhs.

fn i256_add( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: I256Val ) -> Result<I256Val, Self::Error>

Performs checked integer addition. Computes lhs + rhs, returning ScError if overflow occurred.

fn i256_sub( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: I256Val ) -> Result<I256Val, Self::Error>

Performs checked integer subtraction. Computes lhs - rhs, returning ScError if overflow occurred.

fn i256_mul( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: I256Val ) -> Result<I256Val, Self::Error>

Performs checked integer multiplication. Computes lhs * rhs, returning ScError if overflow occurred.

fn i256_div( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: I256Val ) -> Result<I256Val, Self::Error>

Performs checked integer division. Computes lhs / rhs, returning ScError if rhs == 0 or overflow occurred.

fn i256_rem_euclid( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: I256Val ) -> Result<I256Val, Self::Error>

Performs checked Euclidean modulo. Computes lhs % rhs, returning ScError if rhs == 0 or overflow occurred.

fn i256_pow( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: U32Val ) -> Result<I256Val, Self::Error>

Performs checked exponentiation. Computes lhs.exp(rhs), returning ScError if overflow occurred.

fn i256_shl( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: U32Val ) -> Result<I256Val, Self::Error>

Performs checked shift left. Computes lhs << rhs, returning ScError if rhs is larger than or equal to the number of bits in lhs.

fn i256_shr( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lhs: I256Val, rhs: U32Val ) -> Result<I256Val, Self::Error>

Performs checked shift right. Computes lhs >> rhs, returning ScError if rhs is larger than or equal to the number of bits in lhs.

fn timepoint_obj_from_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: u64 ) -> Result<TimepointObject, Self::Error>

Convert a u64 to a Timepoint object.

fn timepoint_obj_to_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: TimepointObject ) -> Result<u64, Self::Error>

Convert a Timepoint object to a u64.

fn duration_obj_from_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: u64 ) -> Result<DurationObject, Self::Error>

Convert a u64 to a Duration object.

fn duration_obj_to_u64( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, obj: DurationObject ) -> Result<u64, Self::Error>

Convert a Duration object a u64.

fn map_new( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<MapObject, Self::Error>

Create an empty new map.

fn map_put( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject, k: Val, v: Val ) -> Result<MapObject, Self::Error>

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<'_, Self::VmUserState>, m: MapObject, k: Val ) -> Result<Val, Self::Error>

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

fn map_del( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject, k: Val ) -> Result<MapObject, Self::Error>

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

fn map_len( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject ) -> Result<U32Val, Self::Error>

Get the size of a map.

fn map_has( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject, k: Val ) -> Result<Bool, Self::Error>

Test for the presence of a key in a map. Returns Bool.

fn map_key_by_pos( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject, i: U32Val ) -> Result<Val, Self::Error>

Get the key from a map at position i. If i is an invalid position, return ScError.

fn map_val_by_pos( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject, i: U32Val ) -> Result<Val, Self::Error>

Get the value from a map at position i. If i is an invalid position, return ScError.

fn map_keys( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, m: MapObject ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, m: MapObject ) -> Result<VecObject, Self::Error>

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 map_new_from_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, keys_pos: U32Val, vals_pos: U32Val, len: U32Val ) -> Result<MapObject, Self::Error>

Return a new map initialized from a pair of equal-length arrays, one for keys and one for values, given by a pair of linear-memory addresses and a length in Vals.

fn map_unpack_to_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, map: MapObject, keys_pos: U32Val, vals_pos: U32Val, len: U32Val ) -> Result<Void, Self::Error>

Copy Vals from map to the array vals_pos, selecting only the keys identified by the array keys_pos. Both arrays have len elements and are identified by linear-memory addresses.

fn vec_new( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<VecObject, Self::Error>

Creates an empty new vector.

fn vec_put( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, i: U32Val, x: Val ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject, i: U32Val ) -> Result<Val, Self::Error>

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

fn vec_del( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, i: U32Val ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject ) -> Result<U32Val, Self::Error>

Returns length of the vector.

fn vec_push_front( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, x: Val ) -> Result<VecObject, Self::Error>

Push a value to the front of a vector.

fn vec_pop_front( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject, x: Val ) -> Result<VecObject, Self::Error>

Appends an element to the back of the vector.

fn vec_pop_back( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject ) -> Result<Val, Self::Error>

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

fn vec_back( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject ) -> Result<Val, Self::Error>

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

fn vec_insert( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, i: U32Val, x: Val ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v1: VecObject, v2: VecObject ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject, start: U32Val, end: U32Val ) -> Result<VecObject, Self::Error>

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<'_, Self::VmUserState>, v: VecObject, x: Val ) -> Result<Val, 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 Void.

fn vec_last_index_of( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, x: Val ) -> Result<Val, 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 Void.

fn vec_binary_search( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: VecObject, x: Val ) -> 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 0x0000_0001 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_0000 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 vec_new_from_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, vals_pos: U32Val, len: U32Val ) -> Result<VecObject, Self::Error>

Return a new vec initialized from an input slice of Vals given by a linear-memory address and length in Vals.

fn vec_unpack_to_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, vec: VecObject, vals_pos: U32Val, len: U32Val ) -> Result<Void, Self::Error>

Copy the Vals of a vec into an array at a given linear-memory address and length in Vals.

fn put_contract_data( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: Val, v: Val, t: StorageType ) -> Result<Void, Self::Error>

fn has_contract_data( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: Val, t: StorageType ) -> Result<Bool, Self::Error>

fn get_contract_data( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: Val, t: StorageType ) -> Result<Val, Self::Error>

fn del_contract_data( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: Val, t: StorageType ) -> Result<Void, Self::Error>

fn create_contract( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, deployer: AddressObject, wasm_hash: BytesObject, salt: BytesObject ) -> Result<AddressObject, Self::Error>

Creates the contract instance on behalf of deployer. deployer must authorize this call via Soroban auth framework, i.e. this calls deployer.require_auth with respective arguments. wasm_hash must be a hash of the contract code that has already been uploaded on this network. salt is used to create a unique contract id. Returns the address of the created contract.

fn create_asset_contract( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, serialized_asset: BytesObject ) -> Result<AddressObject, Self::Error>

Creates the instance of Stellar Asset contract corresponding to the provided asset. serialized_asset is stellar::Asset XDR serialized to bytes format. Returns the address of the created contract.

fn upload_wasm( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, wasm: BytesObject ) -> Result<BytesObject, Self::Error>

Uploads provided wasm bytecode to the network and returns its identifier (SHA-256 hash). No-op in case if the same Wasm object already exists.

fn update_current_contract_wasm( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, hash: BytesObject ) -> Result<Void, Self::Error>

Replaces the executable of the current contract with the provided Wasm code identified by a hash. Wasm entry corresponding to the hash has to already be present in the ledger. The update happens only after the current contract invocation has successfully finished, so this can be safely called in the middle of a function.

fn extend_contract_data_ttl( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: Val, t: StorageType, threshold: U32Val, extend_to: U32Val ) -> Result<Void, Self::Error>

If the entry’s TTL is below threshold ledgers, extend live_until_ledger_seq such that TTL == extend_to, where TTL is defined as live_until_ledger_seq - current ledger

fn extend_current_contract_instance_and_code_ttl( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, threshold: U32Val, extend_to: U32Val ) -> Result<Void, Self::Error>

If the TTL for the current contract instance and code (if applicable) is below threshold ledgers, extend live_until_ledger_seq such that TTL == extend_to, where TTL is defined as live_until_ledger_seq - current ledger

fn extend_contract_instance_and_code_ttl( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, contract: AddressObject, threshold: U32Val, extend_to: U32Val ) -> Result<Void, Self::Error>

If the TTL for the provided contract instance and code (if applicable) is below threshold ledgers, extend live_until_ledger_seq such that TTL == extend_to, where TTL is defined as live_until_ledger_seq - current ledger

fn get_contract_id( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, deployer: AddressObject, salt: BytesObject ) -> Result<AddressObject, Self::Error>

Get the id of a contract without creating it. deployer is address of the contract deployer. salt is used to create a unique contract id. Returns the address of the would-be contract.

fn get_asset_contract_id( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, serialized_asset: BytesObject ) -> Result<AddressObject, Self::Error>

Get the id of the Stellar Asset contract corresponding to the provided asset without creating the instance. serialized_asset is stellar::Asset XDR serialized to bytes format. Returns the address of the would-be asset contract.

fn call( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, contract: AddressObject, func: Symbol, args: VecObject ) -> Result<Val, Self::Error>

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

fn try_call( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, contract: AddressObject, func: Symbol, args: VecObject ) -> Result<Val, Self::Error>

Calls a function in another contract with arguments contained in vector args, returning either the result of the called function or an Error if the called function failed. The returned error is either a custom ContractError that the called contract returns explicitly, or an error with type Context and code InvalidAction in case of any other error in the called contract (such as a host function failure that caused a trap). try_call might trap in a few scenarios where the error can’t be meaningfully recovered from, such as running out of budget.

fn serialize_to_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, v: Val ) -> Result<BytesObject, Self::Error>

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

fn deserialize_from_bytes( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject ) -> Result<Val, Self::Error>

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

fn bytes_copy_to_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject, b_pos: U32Val, lm_pos: U32Val, len: U32Val ) -> Result<Void, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject, b_pos: U32Val, lm_pos: U32Val, len: U32Val ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, lm_pos: U32Val, len: U32Val ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState> ) -> Result<BytesObject, Self::Error>

Create an empty new Bytes object.

fn bytes_put( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject, i: U32Val, u: U32Val ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject, i: U32Val ) -> Result<U32Val, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject, i: U32Val ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject ) -> Result<U32Val, Self::Error>

Returns length of the Bytes object.

fn bytes_push( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject, u: U32Val ) -> Result<BytesObject, Self::Error>

Appends an element to the back of the Bytes object.

fn bytes_pop( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject ) -> Result<U32Val, Self::Error>

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

fn bytes_back( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject ) -> Result<U32Val, Self::Error>

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

fn bytes_insert( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, b: BytesObject, i: U32Val, u: U32Val ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, b1: BytesObject, b2: BytesObject ) -> Result<BytesObject, Self::Error>

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<'_, Self::VmUserState>, b: BytesObject, start: U32Val, end: U32Val ) -> Result<BytesObject, Self::Error>

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 string_copy_to_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, s: StringObject, s_pos: U32Val, lm_pos: U32Val, len: U32Val ) -> Result<Void, Self::Error>

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

fn symbol_copy_to_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, s: SymbolObject, s_pos: U32Val, lm_pos: U32Val, len: U32Val ) -> Result<Void, Self::Error>

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

fn string_new_from_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lm_pos: U32Val, len: U32Val ) -> Result<StringObject, Self::Error>

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

fn symbol_new_from_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lm_pos: U32Val, len: U32Val ) -> Result<SymbolObject, Self::Error>

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

fn string_len( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, s: StringObject ) -> Result<U32Val, Self::Error>

Returns length of the String object.

fn symbol_len( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, s: SymbolObject ) -> Result<U32Val, Self::Error>

Returns length of the Symbol object.

fn symbol_index_in_linear_memory( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, sym: Symbol, slices_pos: U32Val, len: U32Val ) -> Result<U32Val, Self::Error>

Return the index of a Symbol in an array of linear-memory byte-slices, or trap if not found.

fn compute_hash_sha256( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, x: BytesObject ) -> Result<BytesObject, Self::Error>

fn verify_sig_ed25519( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, k: BytesObject, x: BytesObject, s: BytesObject ) -> Result<Void, Self::Error>

fn compute_hash_keccak256( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, x: BytesObject ) -> Result<BytesObject, Self::Error>

Returns the keccak256 hash of given input bytes.

fn recover_key_ecdsa_secp256k1( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, msg_digest: BytesObject, signature: BytesObject, recovery_id: U32Val ) -> Result<BytesObject, Self::Error>

Recovers the SEC-1-encoded ECDSA secp256k1 public key that produced a given 64-byte signature over a given 32-byte message digest, for a given recovery_id byte.

fn require_auth_for_args( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, address: AddressObject, args: VecObject ) -> Result<Void, Self::Error>

Checks if the address has authorized the invocation of the current contract function with the provided arguments. Traps if the invocation hasn’t been authorized.

fn require_auth( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, address: AddressObject ) -> Result<Void, Self::Error>

Checks if the address has authorized the invocation of the current contract function with all the arguments of the invocation. Traps if the invocation hasn’t been authorized.

fn strkey_to_address( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, strkey: Val ) -> Result<AddressObject, Self::Error>

Converts a provided Stellar strkey address of an account or a contract (‘G…’ or ‘C…’ respectively) to an address object. strkey can be either BytesObject or StringObject (the contents should represent the G.../C... string in both cases). Any other valid or invalid strkey (e.g. ‘S…’) will trigger an error. Prefer directly using the Address objects whenever possible. This is only useful in the context of custom messaging protocols (e.g. cross-chain).

fn address_to_strkey( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, address: AddressObject ) -> Result<StringObject, Self::Error>

Converts a provided address to Stellar strkey format (‘G…’ for account or ‘C…’ for contract). Prefer directly using the Address objects whenever possible. This is only useful in the context of custom messaging protocols (e.g. cross-chain).

fn authorize_as_curr_contract( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, auth_entires: VecObject ) -> Result<Void, Self::Error>

Authorizes sub-contract calls for the next contract call on behalf of the current contract. Every entry in the argument vector corresponds to InvokerContractAuthEntry contract type that authorizes a tree of require_auth calls on behalf of the current contract. The entries must not contain any authorizations for the direct contract call, i.e. if current contract needs to call contract function F1 that calls function F2 both of which require auth, only F2 should be present in auth_entries.

fn dummy0( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState> ) -> Result<Val, Self::Error>

A dummy function taking 0 arguments and performs no-op. This function is for test purpose only, for measuring the roundtrip cost of invoking a host function, i.e. host->Vm->host.

fn prng_reseed( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, seed: BytesObject ) -> Result<Void, Self::Error>

Reseed the frame-local PRNG with a given BytesObject, which should be 32 bytes long.

fn prng_bytes_new( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, length: U32Val ) -> Result<BytesObject, Self::Error>

Construct a new BytesObject of the given length filled with bytes drawn from the frame-local PRNG.

fn prng_u64_in_inclusive_range( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, lo: u64, hi: u64 ) -> Result<u64, Self::Error>

Return a u64 uniformly sampled from the inclusive range [lo,hi] by the frame-local PRNG.

fn prng_vec_shuffle( &self, vmcaller: &mut VmCaller<'_, Self::VmUserState>, vec: VecObject ) -> Result<VecObject, Self::Error>

Return a (Fisher-Yates) shuffled clone of a given vector, using the frame-local PRNG.

Object Safety

This trait is not object safe.

Implementors