Struct zebrad::components::mempool::downloads::Downloads

pub struct Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZS::Future: Send,{
    network: ZN,
    verifier: ZV,
    state: ZS,
    pending: FuturesUnordered<JoinHandle<Result<VerifiedUnminedTx, (TransactionDownloadVerifyError, UnminedTxId)>>>,
    cancel_handles: HashMap<UnminedTxId, (Sender<CancelDownloadAndVerify>, Gossip)>,
}

Represents a [Stream] of download and verification tasks.

Fields

network: ZN

A service that forwards requests to connected peers, and returns their responses.

verifier: ZV

A service that verifies downloaded transactions.

state: ZS

A service that manages cached blockchain state.

pending: FuturesUnordered<JoinHandle<Result<VerifiedUnminedTx, (TransactionDownloadVerifyError, UnminedTxId)>>>

A list of pending transaction download and verify tasks.

cancel_handles: HashMap<UnminedTxId, (Sender<CancelDownloadAndVerify>, Gossip)>

A list of channels that can be used to cancel pending transaction download and verify tasks. Each channel also has the corresponding request.

Implementations

impl<ZN, ZV, ZS> Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZS::Future: Send,

pub fn new(network: ZN, verifier: ZV, state: ZS) -> Self

Initialize a new download stream with the provided services.

network is used to download transactions. verifier is used to verify transactions. state is used to check if transactions are already in the state.

The Downloads stream is agnostic to the network policy, so retry and timeout limits should be applied to the network service passed into this constructor.

pub fn download_if_needed_and_verify(
    &mut self,
    gossiped_tx: Gossip
) -> Result<(), MempoolError>

Queue a transaction for download (if needed) and verification.

Returns the action taken in response to the queue request.

pub fn cancel(&mut self, mined_ids: &HashSet<Hash>)

Cancel download/verification tasks of transactions with the given transaction hash (see UnminedTxId::mined_id).

pub fn cancel_all(&mut self)

Cancel all running tasks and reset the downloader state.

pub fn in_flight(&self) -> usize

Get the number of currently in-flight download tasks.

pub fn transaction_requests(&self) -> impl Iterator<Item = &Gossip>

Get a list of the currently pending transaction requests.

async fn transaction_in_best_chain(
    state: &mut ZS,
    txid: UnminedTxId
) -> Result<(), TransactionDownloadVerifyError>

Check if transaction is already in the best chain.

Trait Implementations

impl<ZN, ZV, ZS> Debug for Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static + Debug,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static + Debug,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static + Debug,
    ZS::Future: Send,

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

Formats the value using the given formatter.

impl<ZN, ZV, ZS> Drop for Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZS::Future: Send,

fn drop(&mut self)

Executes the destructor for this type.

impl<ZN, ZV, ZS> Stream for Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZS::Future: Send,

type Item = Result<VerifiedUnminedTx, (UnminedTxId, TransactionDownloadVerifyError)>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'pin, ZN, ZV, ZS> Unpin for Downloads<ZN, ZV, ZS>where
    ZN: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZN::Future: Send,
    ZV: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZV::Future: Send,
    ZS: Service<Request, Response = Response, Error = Box<dyn Error + Send + Sync + 'static>> + Send + Clone + 'static,
    ZS::Future: Send,
    __Downloads<'pin, ZN, ZV, ZS>: Unpin,