Struct HttpCachedTransport

pub struct HttpCachedTransport {
    client: Http<Client>,
    block_number: Arc<AtomicU64>,
    block_filters: Arc<RwLock<HashMap<U128, BlockNumber>>>,
    block_hashes: Arc<RwLock<HashMap<BlockNumber, B256>>>,
    cache_folder: Option<CacheFolder>,
}

Fields

client: Http<Client>

block_number: Arc<AtomicU64>

block_filters: Arc<RwLock<HashMap<U128, BlockNumber>>>

block_hashes: Arc<RwLock<HashMap<BlockNumber, B256>>>

cache_folder: Option<CacheFolder>

Implementations

impl HttpCachedTransport

pub async fn new(url: Url, cache_path: Option<&str>) -> Self

pub fn set_block_number(&self, block_number: u64) -> u64

fn convert_block_number( &self, number_or_tag: BlockNumberOrTag, ) -> Result<BlockNumberOrTag>

fn convert_block_number_next( &self, number_or_tag: BlockNumberOrTag, ) -> Result<BlockNumberOrTag>

pub async fn read_cached( &self, method: String, params_hash: B256, ) -> Result<String>

pub async fn write_cached( &self, method: String, params_hash: B256, data: String, ) -> Result<()>

pub fn next_block_number(&self) -> BlockNumber

pub async fn fetch_next_block(&self) -> Result<BlockNumber, TransportError>

pub fn read_block_number(&self) -> u64

pub async fn create_block_filter(&self) -> U128

pub async fn get_block_number(self) -> Result<ResponsePacket, TransportError>

pub async fn new_block_filter(self) -> Result<ResponsePacket, TransportError>

pub async fn get_filter_changes( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn cached_or_execute( &self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn eth_call( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn eth_get_storage_at( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn eth_get_block_by_number( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn eth_get_block_by_hash( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn debug_trace_block_by_number( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn debug_trace_call( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn debug_trace_block_by_hash( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

pub async fn eth_get_logs( self, req: SerializedRequest, ) -> Result<ResponsePacket, TransportError>

Trait Implementations

impl Clone for HttpCachedTransport

fn clone(&self) -> HttpCachedTransport

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Service<RequestPacket> for HttpCachedTransport

type Response = ResponsePacket

Responses given by the service.

type Error = RpcError<TransportErrorKind>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<ResponsePacket, RpcError<TransportErrorKind>>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: RequestPacket) -> Self::Future

Process the request and return the response asynchronously.

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: 144 bytes