Struct MemoryStorage

pub struct MemoryStorage { /* private fields */ }

Implementations

impl MemoryStorage

pub fn new() -> Self

Trait Implementations

impl Clone for MemoryStorage

fn clone(&self) -> MemoryStorage

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for MemoryStorage

fn default() -> Self

Returns the “default value” for a type.

impl QueryState for MemoryStorage

async fn query_state( &self, address: &ContentAddress, key: &Key, ) -> Result<Vec<Word>>

Query the state of a content address.

impl StateRead for MemoryStorage

type Error = MemoryStorageError

An error type describing any cases that might occur during state reading.

type Future = Pin<Box<dyn Future<Output = Result<Vec<Vec<i64>>, <MemoryStorage as StateRead>::Error>> + Send>>

The future type returned from the key_range method.

fn key_range( &self, contract_addr: ContentAddress, key: Key, num_words: usize, ) -> Self::Future

Read the given number of values from state at the given key associated with the given contract address.

impl StateStorage for MemoryStorage

async fn update_state( &self, address: &ContentAddress, key: &Key, value: Vec<Word>, ) -> Result<Vec<Word>>

Update the state of a content address.

async fn update_state_batch<U>(&self, updates: U) -> Result<Vec<Vec<Word>>>

where U: IntoIterator<Item = (ContentAddress, Key, Vec<Word>)> + Send,

Update a batch of state in one transaction.

impl Storage for MemoryStorage

async fn insert_contract(&self, signed: SignedContract) -> Result<()>

Insert a contract with their storage layout.

async fn insert_solution_into_pool(&self, solution: Solution) -> Result<()>

Add a solution to the pool of unsolved solutions.

async fn move_solutions_to_solved( &self, block_number: u64, block_timestamp: Duration, solutions: &[Hash], ) -> Result<()>

Move these solutions from the pool to the solved state.

async fn move_solutions_to_failed( &self, solutions: &[(Hash, SolutionFailReason)], ) -> Result<()>

Move these solutions from the pool to the failed state.

async fn get_predicate( &self, address: &PredicateAddress, ) -> Result<Option<Predicate>>

Get an individual predicate. Note that the same predicate might be in multiple contracts.

async fn get_contract( &self, address: &ContentAddress, ) -> Result<Option<SignedContract>>

Get the entire contract.

async fn list_contracts( &self, time_range: Option<Range<Duration>>, page: Option<usize>, ) -> Result<Vec<Contract>>

List all contracts. This will paginate the results. The page is 0-indexed. A time range can optionally be provided to filter the results. The time is duration since the Unix epoch.

fn subscribe_contracts( self, start_time: Option<Duration>, start_page: Option<usize>, ) -> impl Stream<Item = Result<Contract>> + Send + 'static

Subscribe to new contracts from a given start page or start time. This will return all the contracts from that point then continue to stream as new contracts are added.

async fn list_solutions_pool( &self, page: Option<usize>, ) -> Result<Vec<Solution>>

List all solutions in the pool.

async fn list_failed_solutions_pool( &self, page: Option<usize>, ) -> Result<Vec<FailedSolution>>

List all failed solutions in the pool.

async fn list_blocks( &self, time_range: Option<Range<Duration>>, block_number: Option<u64>, page: Option<usize>, ) -> Result<Vec<Block>>

List all blocks of solutions that have been solved.

fn subscribe_blocks( self, start_time: Option<Duration>, block_number: Option<u64>, start_page: Option<usize>, ) -> impl Stream<Item = Result<Block>> + Send + 'static

Subscribe to new blocks from a given block number or start page or start time. This will return all the blocks from that point then continue to stream as new blocks are added.

async fn get_solution( &self, solution_hash: Hash, ) -> Result<Option<SolutionOutcomes>>

Get failed solution and its failing reason.

async fn prune_failed_solutions(&self, older_than: Duration) -> Result<()>

Prune failed solutions that failed before the provided duration.

fn commit_block( &self, data: CommitData<'_>, ) -> impl Future<Output = Result<()>> + Send

Commit block data atomically.

async fn get_latest_block(&self) -> Result<Option<Block>>

Get latest block.