Wasmi: A Fast and Safe WebAssembly Runtime in Rust

soroban-wasmi

This is a fork of https://github.com/paritytech/wasmi with a small set of local patches applied for customizing interaction with https://soroban.stellar.org

It may be abandoned at some point if Soroban is able to meet its needs strictly with upstream interfaces. The fork was for expedience during development.

Other projects should not use it, and should use upstream instead.

The Parity authors have been removed from the Cargo.toml metadata to avoid the implication that this fork is their responsibility or action, and to emphasize that users should not bother the Parity authors with support requests for this crate.

This crate was still entirely (with the exception of a couple small patches) written by Parity Technologies, and their copyright notices are maintained.

License

wasmi is primarily distributed under the terms of both the MIT license and the APACHE license (Version 2.0), at your choice.

See LICENSE-APACHE and LICENSE-MIT for details.

lib.rs:

The wasmi virtual machine definitions.

These closely mirror the WebAssembly specification definitions. The overall structure is heavily inspired by the wasmtime virtual machine architecture.

Example

The following example shows a "Hello, World!"-like example of creating a Wasm module from some initial .wat contents, defining a simple host function and calling the exported Wasm function.

The example was inspired by Wasmtime's API example.

use soroban_wasmi as wasmi;
use anyhow::{anyhow, Result};
use wasmi::*;

fn main() -> Result<()> {
    // First step is to create the Wasm execution engine with some config.
    // In this example we are using the default configuration.
    let engine = Engine::default();
    let wat = r#"
        (module
            (import "host" "hello" (func $host_hello (param i32)))
            (func (export "hello")
                (call $host_hello (i32.const 3))
            )
        )
    "#;
    // Wasmi does not yet support parsing `.wat` so we have to convert
    // out `.wat` into `.wasm` before we compile and validate it.
    let wasm = wat::parse_str(&wat)?;
    let module = Module::new(&engine, &mut &wasm[..])?;

    // All Wasm objects operate within the context of a `Store`.
    // Each `Store` has a type parameter to store host-specific data,
    // which in this case we are using `42` for.
    type HostState = u32;
    let mut store = Store::new(&engine, 42);
    let host_hello = Func::wrap(&mut store, |caller: Caller<'_, HostState>, param: i32| {
        println!("Got {param} from WebAssembly");
        println!("My host state is: {}", caller.data());
    });

    // In order to create Wasm module instances and link their imports
    // and exports we require a `Linker`.
    let mut linker = <Linker<HostState>>::new(&engine);
    // Instantiation of a Wasm module requires defining its imports and then
    // afterwards we can fetch exports by name, as well as asserting the
    // type signature of the function with `get_typed_func`.
    //
    // Also before using an instance created this way we need to start it.
    linker.define("host", "hello", host_hello)?;
    let instance = linker
        .instantiate(&mut store, &module)?
        .start(&mut store)?;
    let hello = instance.get_typed_func::<(), ()>(&store, "hello")?;

    // And finally we can call the wasm!
    hello.call(&mut store, ())?;

    Ok(())
}

Download details:

Author: stellar
Source: https://github.com/stellar/wasmi

License: Apache-2.0, MIT licenses found
#webassembly #rust