Forkless state transition with upgradable WASM executor

[xgreenx]

Closes #1547

Change overview

The change adds the WASM version of the fuel_core_executor::Executor and the upgradable executor that works with native(std) and WASM(no-std) versions of the executor. Currently, it uses either the WASM or the std version. But in the follow-up PRs it will decide which version to use based on the block header. For now, this behavior is controlled by the "wasm-executor" feature. The CI runs tests two times, one with the WASM executor and the second with std, to verify that behaviors are the same.

Details on how WASM integration is done

The fuel-core-upgradable-executor uses the wasmtime library to compile and run the WASM bytecode. The wastime::Engine allows customization of how the wastime::Module compiles the bytecode. For simplicity, we are using the default configuration that works on all platforms for now, but later, it is possible to do more specific compilation.

We are using wastime::Linker to add host functions that can be called from the WASM runtime via extern "C" API:

#[link(wasm_import_module = "host_v0")]
extern "C" {
    /// Returns the size of the value from the storage.
    pub(crate) fn storage_size_of_value(
        key_ptr: Ptr32<[u8]>,
        key_len: u32,
        column: u32,
    ) -> u64;

    /// Returns the value from the storage.
    pub(crate) fn storage_get(
        key_ptr: Ptr32<[u8]>,
        key_len: u32,
        column: u32,
        out_ptr: Ptr32Mut<[u8]>,
        out_len: u32,
    ) -> ReturnResult;
}

The host functions are closures that capture data required for the work, such as the storage or relayer. Host functions have access to the ExecutionState, which accumulates intermediate data.

Data is passed between the host and runtime through memory, where one side gives the pointer where data should be stored, and another side writes the memory using this pointer and the size. The host is not responsible for allocating and deallocating memory; the memory management is done within WASM runtime. Currently, when we return something from the runtime to the host, we "leak" it to avoid deallocation. It allows the host to read the value from the memory.

Side changes:

• The coinbase contract id is not a part of the Config anymore. It is part of the Components and seats along with the gas_price because it is defined by the block producer and can always be changed on the fly.
• The usage of anyhow::Error in the ExecutorError was replaced by String because it doesn't implement serde ser/des.
• The ExecutionOptions, WriteOperation, ExecutionResult, TransactionExecutionResult, TransactionExecutionStatus, ExecutorError, and TransactionValidityError support serde ser/des.
• The fuel-core-executor only provides the ExecutionInstance without Executor. The logic of the Executor was moved to the fuel-core-upgradable-executor.

[Dentosal]

Why is this dead_code instead of a cfg(feature = ...)?

[Dentosal]

Why this isn't just part of Caller?

[xgreenx]

The Caller is the type defined inside of the wasmtime.

[Dentosal]

nit: this consumes only a single tx

Suggested change

	fn consume_next_txs(&mut self) -> Func {
	fn consume_next_tx(&mut self) -> Func {

[Voxelot]

Would we need to rerun if any files in the wasm-executor/src/* dir change?

[bvrooman]

Reviewed 26 files so far, will continue

[bvrooman]

It looks like all instances of new create the Arc inline. I might suggest taking config as config: Config and doing:

Self {
   ...
   config: Arc::new(config)
}

to simplify things a little.

[bvrooman]

Suggested change

	lazy_static = { version = "1.4", optional = true }
	lazy_static = { workspace = true, optional = true }

[bvrooman]

Suggested change

	/// The executor already has these parameters, and this field allows override the used value.
	/// The executor already has these parameters, and this field allows us to override the existing value.

[Voxelot]

Generally it's good practice to add some comments to unsafe code to explain why it's marked unsafe and any precautions taken to ensure no memory corruption occcurs or similar justifications

[xgreenx]

The function is unsafe because we call a method from extern. I'm not sure what comment should say in that case=) "We assume that the host implements corresponding function overwise it should fail before we even started execution of the WASM."

[Voxelot]

Might not need lazy static anymore.

https://docs.rs/once_cell/latest/once_cell/#safe-initialization-of-global-data

[xgreenx]

I will update our codebase to not use lazy static in a separate PR=)

[xgreenx]

Fixed in #1781