Struct ethers_providers::QuorumProvider

pub struct QuorumProvider<T = Box<dyn JsonRpcClientWrapper>> { /* private fields */ }

A provider that bundles multiple providers and only returns a value to the caller once the quorum has been reached.

Example

Create a QuorumProvider that uses a homogenous Provider type only returns a value if the Quorum::Majority of the weighted providers return the same value.

use ethers_core::types::U64;
use ethers_providers::{JsonRpcClient, QuorumProvider, Quorum, WeightedProvider, Http};
use std::str::FromStr;

let provider1 = WeightedProvider::new(Http::from_str("http://localhost:8545")?);
let provider2 = WeightedProvider::with_weight(Http::from_str("http://localhost:8545")?, 2);
let provider3 = WeightedProvider::new(Http::from_str("http://localhost:8545")?);
let provider = QuorumProvider::builder()
    .add_providers([provider1, provider2, provider3])
    .quorum(Quorum::Majority)
    .build();
// the weight at which a quorum is reached,
assert_eq!(provider.quorum_weight(), 4 / 2); // majority >=50%
let block_number: U64 = provider.request("eth_blockNumber", ()).await?;

Example

Create a QuorumProvider consisting of different Provider types

use ethers_core::types::U64;
use ethers_providers::{JsonRpcClient, QuorumProvider, Quorum, WeightedProvider, Http, Ws};
use std::str::FromStr;

    let provider: QuorumProvider = QuorumProvider::dyn_rpc()
        .add_provider(WeightedProvider::new(Box::new(Http::from_str("http://localhost:8545")?)))
        .add_provider(WeightedProvider::with_weight(
            Box::new(Ws::connect("ws://localhost:8545").await?),
            2,
        ))
        .add_provider(WeightedProvider::with_weight(
            Box::new(Ws::connect("ws://localhost:8545").await?),
            2,
        ))
        // the quorum provider will yield the response if >50% of the weighted inner provider
        // returned the same value
        .quorum(Quorum::Majority)
        .build();

Implementations

impl QuorumProvider<Box<dyn JsonRpcClientWrapper>>

pub fn dyn_rpc() -> QuorumProviderBuilder<Box<dyn JsonRpcClientWrapper>>

Create a QuorumProvider for different JsonRpcClient types

impl QuorumProvider<Box<dyn PubsubClientWrapper>>

pub fn dyn_pub_sub() -> QuorumProviderBuilder<Box<dyn PubsubClientWrapper>>

Create a QuorumProvider for different PubsubClient types

impl<T> QuorumProvider<T>

pub fn builder() -> QuorumProviderBuilder<T>

Convenience method for creating a QuorumProviderBuilder with same JsonRpcClient types

pub fn new( quorum: Quorum, providers: impl IntoIterator<Item = WeightedProvider<T>> ) -> Self

Instantiate a new QuorumProvider from a Quorum and a set of providers

pub fn providers(&self) -> &[WeightedProvider<T>]

Return a reference to the weighted providers

pub fn quorum_weight(&self) -> u64

The weight at which the provider reached a quorum

pub fn add_provider(&mut self, provider: WeightedProvider<T>)

Add a provider to the set

Trait Implementations

impl<T: Clone> Clone for QuorumProvider<T>

fn clone(&self) -> QuorumProvider<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for QuorumProvider<T>

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

Formats the value using the given formatter.

impl<C> JsonRpcClient for QuorumProvider<C>

where C: JsonRpcClientWrapper,

type Error = ProviderError

A JSON-RPC Error

fn request<'life0, 'life1, 'async_trait, T, R>( &'life0 self, method: &'life1 str, params: T ) -> Pin<Box<dyn Future<Output = Result<R, Self::Error>> + Send + 'async_trait>>

where T: 'async_trait + Serialize + Send + Sync, R: 'async_trait + DeserializeOwned, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sends a request with the provided JSON-RPC and parameters serialized as JSON

impl<C> PubsubClient for QuorumProvider<C>

where C: PubsubClientWrapper,

type NotificationStream = QuorumStream

The type of stream this transport returns

fn subscribe<T: Into<U256>>( &self, id: T ) -> Result<Self::NotificationStream, Self::Error>

Add a subscription to this transport

fn unsubscribe<T: Into<U256>>(&self, id: T) -> Result<(), Self::Error>

Remove a subscription from this transport