Struct Instance

pub struct Instance<E: RuntimeEnv + 'static> { /* private fields */ }

An instance running Lyquor Virtual Machine (LVM) for a Lyquid.

Each Lyquid corresponds to an instance (it’s called “instance” because with LyteMemory, it’s like a tiny “VM instance” in cloud computing sense). Because the network state for a Lyquid is versioned, a LyquidNumber uniquely determines an execution environment for any function call.

In the implementation, crate::barrel::Barrel is the final execution unit that corresponds to a given version. All instance calls will try to grab a Barrel from the cached pool of Barrels, whereas the sequencing part keeps its single, dedicated Barrel for efficient sequencing.

Implementations

impl<E: RuntimeEnv + 'static> Instance<E>

pub fn builder( versioned_store: Arc<dyn VersionedStateStore<LyquidNumber>>, simple_store: Arc<dyn SimpleStateStore>, log: LyquidLog, env: E, id: LyquidID, ) -> Result<InstanceBuilder<E>, Error>

Create a builder for Instance.

pub async fn call_instance_func_decoded<'b, O: for<'a> Deserialize<'a>>( &mut self, version: LyquidNumber, params: CallParams, ) -> impl Future<Output = Result<O, Error>> + 'b

Returns a standalone task that will execute instance opearations in an environment where the network state is sandboxed (any changes made by WASM execution will be discarded after the run).

This method is used to implement Lyquid instance function calls by external events other than the sequencer event. You should first await for this function call to obtain the returned future (and release the lock of the Instance if applicable). Then await the future for the actual call execution (resolving the returned future does not require any lock/access to the instance).

pub async fn call_instance_func<'a>( &mut self, version: LyquidNumber, params: CallParams, ) -> impl Future<Output = Result<Vec<u8>, Error>> + 'a

Similar to Self::call_instance_func but without encoding/decoding. This is useful for handling Ethereum API calls and remote calls (such as UPC) through the network/IPC.

pub fn flush_instance_state(&self) -> Result<(), Error>

Flush the changes made to the instance state in a bundled write to the storage backend.

pub async fn new_sequenced_batch( &mut self, image: Option<Bytes>, ) -> Result<(), Error>

Start a new batch of sequenced events which update the network state.

The invariant is that each batch only contains events for the same image version. Upon an image update, image parameter will carry the new image and the LyquidNumber will be bumped up properly. It is required that the invocation of this function should be paired with either Self::commit_sequenced_batch or Self::abort_sequenced_batch, otherwise it returns an error.

pub async fn commit_sequenced_batch(&mut self) -> Result<LyquidNumber, Error>

Commit the current batch of updates induced by sequenced events.

Upon failure in writing to storage backend, all changes made by this batch are reverted.

pub fn abort_sequenced_batch(&mut self)

Revert all changes since the beginning of this batch (and start a new, empty batch).

pub async fn sequence_event( &mut self, event: SeqEvent, pos: ChainPos, ) -> Result<Option<Vec<u8>>, ExecutionError>

Append (and execute) a sequenced event to the current batch. If the event updates the image, the existing batch will be committed and a new batch will be created.

pub fn latest_number(&self) -> &LyquidNumber

Obtain the lastest committed LyquidNumber.

pub async fn reset_last_committed( &mut self, v: LyquidNumber, ) -> Result<(), Error>

pub fn get_deps(&self)