Crate soroban_env_common

The environment-common crate contains three families of types:

• The Val type, a 64-bit value type that is a union between several different types (numbers, booleans, symbols, object references), encoded via careful bit-packing.
• Wrapper types (Object, Symbol, Error) that contain Val in a specific, known union state. These are also 64-bit values, but offer methods specific to the union state (eg. Symbol will interconvert with Rust string types).
• The Env trait, which describes the interface between guest and host code. In other words, Env describes a set of host functions that must be implemented in a contract host, and can be called from a guest (or by the SDK). Methods on the Env trait can only pass 64-bit values, which are usually Val or one of the wrapper types.

The crate additionally contains functions for interconversion between the Val type and XDR types, and re-exports the XDR definitions from stellar_xdr under the module xdr.

Re-exports

• pub use num::DurationObject;
• pub use num::I128Object;
• pub use num::I256Object;
• pub use num::I64Object;
• pub use num::TimepointObject;
• pub use num::U128Object;
• pub use num::U256Object;
• pub use num::U64Object;
• pub use num::DurationSmall;
• pub use num::I128Small;
• pub use num::I256Small;
• pub use num::I64Small;
• pub use num::TimepointSmall;
• pub use num::U128Small;
• pub use num::U256Small;
• pub use num::U64Small;
• pub use num::DurationVal;
• pub use num::I128Val;
• pub use num::I256Val;
• pub use num::I32Val;
• pub use num::I64Val;
• pub use num::TimepointVal;
• pub use num::U128Val;
• pub use num::U256Val;
• pub use num::U32Val;
• pub use num::U64Val;
• pub use env::call_macro_with_all_host_functions;

Modules

• meta
  This module contains version constants (and other metadata) that are embedded in binaries (especially WASM binaries) compiled against a particular version of this crate. Versioning at this level provides an early diagnostic check for compatibility between a loaded WASM binary and the Env interface provided by the host, rather than a cryptic failure due to a runtime host function signature mismatch.
• num
• xdr

Structs

• AddressObject
• Bool
• BytesObject
• ConversionError
  Error type indicating a failure to convert some type to another; details of the failed conversion may be written to the debug log, when possible.
• Error
  Wrapper for a Val that is tagged with [Tag::Error], interpreting the Val’s body as a pair of a 28-bit error-type code and a 32-bit error code. The error-type codes correspond to the enumerated cases of ScErrorType, and the error codes correspond to the code values stored in each variant of the ScError union.
• I256
  A 256-bit signed integer type.
• MapObject
• Object
  Wrapper for a Val that is tagged with one of the object types, interpreting the Val’s body as containing a 32-bit handle to a host object.
• ScValObjRef
• ScValObject
  ScValObject (and its reference-based type ScValObjRef) is a small wrapper type that does not have its own XDR definition, it just denotes (as a type) the subset of ScVal values that need to be represented in Val by one of the cases that can be an Object. In other words Val::try_from_val(&v, e).is_object() will be true iff ScValObject::classify(v) is Ok(ScValObject(v)).
• StringObject
• Symbol
• SymbolObject
• SymbolSmall
• SymbolSmallIter
  An iterator that decodes the individual bit-packed characters from a symbol and yields them as regular Rust char values.
• SymbolStr
  An expanded form of a Symbol that stores its characters as ASCII-range bytes in a u8 array – up to the maximum size of a large symbol object – rather than as packed 6-bit codes within a u64. Useful for interoperation with standard Rust string types.
• U256
  A 256-bit unsigned integer type.
• Val
• VecObject
• Version
• VmCaller
  The VmCallerEnv trait is similar to the Env trait – it provides all the same-named methods – but they have a form that takes an initial VmCaller argument by &mut that may or may-not wrap a wasmi::Caller structure, depending on whether it was invoked from a wasmi host-function wrapper.
• Void

Enums

• StorageType
  This is just a distinct enum local to the env interface that is used as an argument to storage functions. It doesn’t correspond to any [Val] types, and is passed by direct marshalling as a u64.
• SymbolError
  Errors related to operations on the SymbolObject and SymbolSmall types.
• Tag
  Code values for the 8 tag bits in the bit-packed representation of Val. These don’t coincide with tag numbers in the SCVal XDR but cover all those cases as well as some optimized refinements for special cases (boolean true and false, small-value forms).

Constants

• VERSION

Traits

• CheckedEnvArg
  This trait is used by macro-generated dispatch and forwarding functions to check arguments being passed to the Env. The default implementations call through to the Env integrity-checking functions.
• Compare
  General trait representing the ability to compare two values of some type. Similar to core::cmp::Cmp but with two key differences: the comparison is fallible, and is provided by some external type implementing Compare rather than the compared type itself.
• Convert
  General trait representing a the ability of some object to perform a (possibly unsuccessful) conversion between two other types.
• Env
  This trait represents the interface between Host and Guest, used by client contract code and implemented (via Env) by the host. It consists of functions that take or return only 64-bit values such as Val or u64.
• EnvBase
  Base trait extended by the Env trait, providing various special-case functions that do not simply call across cross the guest/host interface.
• TryFromVal
  Trait for types that can be fallibly converted to another type V, analogous to the standard Rust type TryFrom, but making use of the provided Env implementation E in order to convert parts of the type that require it. Mainly this exists because Val types that contain object handles need to delegate to the environment to look up and extract the content of those handles.
• TryIntoVal
  The opposite trait to TryFromVal, analogous to the way that TryInto exists as an opposite to TryFrom. Exists only for convenience of doing conversions via .try_into_val(e) or specifying convertability with a bound like TryIntoVal<E,Other>.
• VmCallerEnv
  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.
• WasmiMarshal