Struct SharedBackend

pub struct SharedBackend {
    backend: UnboundedSender<BackendRequest>,
    cache: Arc<FlushJsonBlockCacheDB>,
    blocking_mode: BlockingMode,
}

A cloneable backend type that shares access to the backend data with all its clones.

This backend type is connected to the BackendHandler via a mpsc unbounded channel. The BackendHandler is spawned on a tokio task and listens for incoming commands on the receiver half of the channel. A SharedBackend holds a sender for that channel, which is Clone, so there can be multiple SharedBackends communicating with the same BackendHandler, hence this Backend type is thread safe.

All Backend trait functions are delegated as a BackendRequest via the channel to the BackendHandler. All BackendRequest variants include a sender half of an additional channel that is used by the BackendHandler to send the result of an executed BackendRequest back to SharedBackend.

The BackendHandler holds a Provider to look up missing accounts or storage slots from remote (e.g. infura). It detects duplicate requests from multiple SharedBackends and bundles them together, so that always only one provider request is executed. For example, there are two SharedBackends, A and B, both request the basic account info of account 0xasd9sa7d... at the same time. After the BackendHandler receives the request from A, it sends a new provider request to the provider’s endpoint, then it reads the identical request from B and simply adds it as an additional listener for the request already in progress, instead of sending another one. So that after the provider returns the response all listeners (A and B) get notified.

Fields

backend: UnboundedSender<BackendRequest>

cache: Arc<FlushJsonBlockCacheDB>

blocking_mode: BlockingMode

Implementations

impl SharedBackend

pub async fn spawn_backend<T, P>( provider: P, db: BlockchainDb, pin_block: Option<BlockId>, ) -> SharedBackend

where T: Transport + Clone + Unpin, P: Provider<T, AnyNetwork> + Unpin + 'static + Clone,

Spawns a new BackendHandler on a tokio::task that listens for requests from any SharedBackend. Missing values get inserted in the db.

The spawned BackendHandler finishes once the last SharedBackend connected to it is dropped.

NOTE: this should be called with Arc<Provider>

pub fn spawn_backend_thread<T, P>( provider: P, db: BlockchainDb, pin_block: Option<BlockId>, ) -> SharedBackend

where T: Transport + Clone + Unpin, P: Provider<T, AnyNetwork> + Unpin + 'static + Clone,

Same as Self::spawn_backend but spawns the BackendHandler on a separate std::thread in its own tokio::Runtime

pub fn new<T, P>( provider: P, db: BlockchainDb, pin_block: Option<BlockId>, ) -> (SharedBackend, BackendHandler<T, P>)

where T: Transport + Clone + Unpin, P: Provider<T, AnyNetwork> + Unpin + 'static + Clone,

Returns a new SharedBackend and the BackendHandler

pub fn with_blocking_mode(&self, mode: BlockingMode) -> SharedBackend

Returns a new SharedBackend and the BackendHandler with a specific blocking mode

pub fn set_pinned_block(&self, block: impl Into<BlockId>) -> Result<(), Report>

Updates the pinned block to fetch data from

pub fn get_full_block( &self, block: impl Into<BlockId>, ) -> Result<WithOtherFields<Block<WithOtherFields<Transaction<AnyTxEnvelope>>, Header<AnyHeader>>>, DatabaseError>

Returns the full block for the given block identifier

pub fn get_transaction( &self, tx: FixedBytes<32>, ) -> Result<WithOtherFields<Transaction<AnyTxEnvelope>>, DatabaseError>

Returns the transaction for the hash

pub fn insert_or_update_address( &self, address_data: HashMap<Address, AccountInfo, FbBuildHasher<20>>, )

Inserts or updates data for multiple addresses

pub fn insert_or_update_storage( &self, storage_data: HashMap<Address, HashMap<Uint<256, 4>, Uint<256, 4>, RandomState>, FbBuildHasher<20>>, )

Inserts or updates data for multiple storage slots

pub fn insert_or_update_block_hashes( &self, block_hash_data: HashMap<Uint<256, 4>, FixedBytes<32>, RandomState>, )

Inserts or updates data for multiple block hashes

pub fn do_any_request<T, F>(&mut self, fut: F) -> Result<T, DatabaseError>

where F: Future<Output = Result<T, Report>> + Send + 'static, T: Debug + Send + 'static,

Returns any arbitrary request on the provider

pub fn flush_cache(&self)

Flushes the DB to disk if caching is enabled

pub fn flush_cache_to(&self, cache_path: &Path)

Flushes the DB to a specific file

pub fn data(&self) -> Arc<MemDb>

Returns the DB

pub fn accounts(&self) -> HashMap<Address, AccountInfo, FbBuildHasher<20>>

Returns the DB accounts

pub fn accounts_len(&self) -> usize

Returns the DB accounts length

pub fn storage( &self, ) -> HashMap<Address, HashMap<Uint<256, 4>, Uint<256, 4>, RandomState>, FbBuildHasher<20>>

Returns the DB storage

pub fn storage_len(&self) -> usize

Returns the DB storage length

pub fn block_hashes(&self) -> HashMap<Uint<256, 4>, FixedBytes<32>, RandomState>

Returns the DB block_hashes

pub fn block_hashes_len(&self) -> usize

Returns the DB block_hashes length

Trait Implementations

impl Clone for SharedBackend

fn clone(&self) -> SharedBackend

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DatabaseRef for SharedBackend

type Error = DatabaseError

The database error type.

fn basic_ref( &self, address: Address, ) -> Result<Option<AccountInfo>, <SharedBackend as DatabaseRef>::Error>

Get basic account information.

fn code_by_hash_ref( &self, hash: FixedBytes<32>, ) -> Result<Bytecode, <SharedBackend as DatabaseRef>::Error>

Get account code by its hash.

fn storage_ref( &self, address: Address, index: Uint<256, 4>, ) -> Result<Uint<256, 4>, <SharedBackend as DatabaseRef>::Error>

Get storage value of address at index.

fn block_hash_ref( &self, number: u64, ) -> Result<FixedBytes<32>, <SharedBackend as DatabaseRef>::Error>

Get block hash by block number.

impl Debug for SharedBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes