Struct frame_remote_externalities::RemoteExternalities

pub struct RemoteExternalities<B: BlockT> {
    pub inner_ext: TestExternalities<HashingFor<B>>,
    pub header: B::Header,
}

An externalities that acts exactly the same as [sp_io::TestExternalities] but has a few extra bits and pieces to it, and can be loaded remotely.

Fields

inner_ext: TestExternalities<HashingFor<B>>

The inner externalities.

header: B::Header

The block header which we created this externality env.

Methods from Deref<Target = TestExternalities<HashingFor<B>>>

pub fn ext( &mut self, ) -> Ext<'_, H, TrieBackend<MemoryDB<H, PrefixedKey<H>, Vec<u8>>, H>>

Get externalities implementation.

pub fn overlayed_changes(&self) -> &OverlayedChanges<H>

Returns the overlayed changes.

pub fn persist_offchain_overlay(&mut self)

Move offchain changes from overlay to the persistent store.

pub fn offchain_db(&self) -> TestPersistentOffchainDB

A shared reference type around the offchain worker storage.

pub fn batch_insert<I>(&mut self, kvs: I)

where I: IntoIterator<Item = (Vec<u8>, Vec<u8>)>,

Batch insert key/values into backend

pub fn insert(&mut self, k: Vec<u8>, v: Vec<u8>)

Insert key/value into backend

pub fn insert_child(&mut self, c: ChildInfo, k: Vec<u8>, v: Vec<u8>)

Insert key/value into backend.

This only supports inserting keys in child tries.

pub fn register_extension<E>(&mut self, ext: E)

where E: Any + Extension,

Registers the given extension for this instance.

pub fn as_backend( &mut self, ) -> TrieBackend<MemoryDB<H, PrefixedKey<H>, Vec<u8>>, H>

Return a new backend with all pending changes.

In contrast to commit_all this will not panic if there are open transactions.

pub fn commit_all(&mut self) -> Result<(), String>

Commit all pending changes to the underlying backend.

Panic

This will panic if there are still open transactions.

pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R

Execute the given closure while self is set as externalities.

Returns the result of the given closure.

pub fn execute_and_prove<R>( &mut self, execute: impl FnOnce() -> R, ) -> (R, StorageProof)

Execute the given closure while self, with proving_backend as backend, is set as externalities.

This implementation will wipe the proof recorded in between calls. Consecutive calls will get their own proof from scratch.

pub fn execute_with_safe<R>( &mut self, f: impl FnOnce() -> R + UnwindSafe, ) -> Result<R, String>

Execute the given closure while self is set as externalities.

Returns the result of the given closure, if no panics occurred. Otherwise, returns Err.

pub fn eq(&mut self, other: &mut TestExternalities<H>) -> bool

This doesn’t test if they are in the same state, only if they contains the same data at this state

Trait Implementations

impl<B: BlockT> Deref for RemoteExternalities<B>

type Target = TestExternalities<<<B as Block>::Header as Header>::Hashing>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B: BlockT> DerefMut for RemoteExternalities<B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.