Struct Resolver

pub struct Resolver<S> { /* private fields */ }

The Resolver is responsible for providing information about types. It relies on its internal package_store to load packages and then type definitions from those packages.

Implementations

impl<S> Resolver<S>

pub fn new(package_store: S) -> Self

pub fn new_with_limits(package_store: S, limits: Limits) -> Self

pub fn package_store(&self) -> &S

pub fn package_store_mut(&mut self) -> &mut S

impl<S: PackageStore> Resolver<S>

pub async fn canonical_type(&self, tag: TypeTag) -> Result<TypeTag>

The canonical form of a type refers to each type in terms of its defining package ID. This function takes a non-canonical type and updates all its package IDs to the appropriate defining ID.

For every package::module::datatype in the input tag, package must be an object on-chain, containing a move package that includes module, and that module must define the datatype. In practice this means the input type tag can refer to types at or after their defining IDs.

pub async fn type_layout(&self, tag: TypeTag) -> Result<MoveTypeLayout>

Return the type layout corresponding to the given type tag. The layout always refers to structs in terms of their defining ID (i.e. their package ID always points to the first package that introduced them).

pub async fn abilities(&self, tag: TypeTag) -> Result<AbilitySet>

Return the abilities of a concrete type, based on the abilities in its type definition, and the abilities of its concrete type parameters: An instance of a generic type has store, copy, or dropif its definition has the ability, and all its non-phantom type parameters have the ability as well. Similar rules apply forkeyexcept that it requires its type parameters to havestore`.

pub async fn function_signature( &self, pkg: AccountAddress, module: &str, function: &str, ) -> Result<FunctionDef>

Returns the signatures of parameters to function pkg::module::function in the package store, assuming the function exists.

pub async fn pure_input_layouts( &self, tx: &ProgrammableTransaction, ) -> Result<Vec<Option<MoveTypeLayout>>>

Attempts to infer the type layouts for pure inputs to the programmable transaction.

The returned vector contains an element for each input to tx. Elements corresponding to pure inputs that are used as arguments to transaction commands will contain Some(layout). Elements for other inputs (non-pure inputs, and unused pure inputs) will be None.

Layout resolution can fail if a type/module/package doesn’t exist, if layout resolution hits a limit, or if a pure input is somehow used in multiple conflicting occasions (with different types).

pub async fn resolve_module_id( &self, module_id: ModuleId, context: AccountAddress, ) -> Result<ModuleId>

Resolves a runtime address in a ModuleId to a storage ModuleId according to the linkage table in the context which must refer to a package.

• Will fail if the wrong context is provided, i.e., is not a package, or does not exist.
• Will fail if an invalid context is provided for the location, i.e., the package at context does not contain the module that location refers to.

pub async fn resolve_clever_error( &self, module_id: ModuleId, abort_code: u64, ) -> Option<CleverError>

Resolves an abort code following the clever error format to a CleverError enum. The module_id must be the storage ID of the module (which can e.g., be gotten from the resolve_module_id function) and not the runtime ID.

If the abort_code is not a clever error (i.e., does not follow the tagging and layout as defined in ErrorBitset), this function will return None.

In the case where it is a clever error but only a line number is present (i.e., the error is the result of an assert!(<cond>) source expression) a CleverError::LineNumberOnly is returned. Otherwise a CleverError::CompleteError is returned.

If for any reason we are unable to resolve the abort code to a CleverError, this function will return None.

Trait Implementations

impl<S: Debug> Debug for Resolver<S>

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

Formats the value using the given formatter.