referrerpolicy=no-referrer-when-downgrade
sc_service

Trait TransactionPool

Source
pub trait TransactionPool: Send + Sync {
    type Block: Block;
    type Hash: Hash + Eq + Member + Serialize + DeserializeOwned + Codec;
    type InPoolTransaction: InPoolTransaction<Transaction = Arc<<Self::Block as Block>::Extrinsic>, Hash = Self::Hash>;
    type Error: From<Error> + IntoPoolError;

Show 13 methods // Required methods fn submit_at<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xts: Vec<<Self::Block as Block>::Extrinsic>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<Self::Hash, Self::Error>>, Self::Error>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait; fn submit_one<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xt: <Self::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Self::Hash, Self::Error>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait; fn submit_and_watch<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xt: <Self::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = TransactionStatus<Self::Hash, <Self::Block as Block>::Hash>> + Send>>, Self::Error>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait; fn ready_at<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait; fn ready( &self, ) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>; fn report_invalid( &self, at: Option<<Self::Block as Block>::Hash>, invalid_tx_errors: IndexMap<Self::Hash, Option<TransactionValidityError>>, ) -> Vec<Arc<Self::InPoolTransaction>>; fn futures(&self) -> Vec<Self::InPoolTransaction>; fn status(&self) -> PoolStatus; fn import_notification_stream(&self) -> Receiver<Self::Hash>; fn on_broadcasted(&self, propagations: HashMap<Self::Hash, Vec<String>>); fn hash_of(&self, xt: &<Self::Block as Block>::Extrinsic) -> Self::Hash; fn ready_transaction( &self, hash: &Self::Hash, ) -> Option<Arc<Self::InPoolTransaction>>; fn ready_at_with_timeout<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait;
}
Expand description

Transaction pool interface.

Required Associated Types§

Source

type Block: Block

Block type.

Source

type Hash: Hash + Eq + Member + Serialize + DeserializeOwned + Codec

Transaction hash type.

Source

type InPoolTransaction: InPoolTransaction<Transaction = Arc<<Self::Block as Block>::Extrinsic>, Hash = Self::Hash>

In-pool transaction type.

Source

type Error: From<Error> + IntoPoolError

Error type.

Required Methods§

Source

fn submit_at<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xts: Vec<<Self::Block as Block>::Extrinsic>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<Self::Hash, Self::Error>>, Self::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Asynchronously imports a bunch of unverified transactions to the pool.

Source

fn submit_one<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xt: <Self::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Self::Hash, Self::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Asynchronously imports one unverified transaction to the pool.

Source

fn submit_and_watch<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, source: TransactionSource, xt: <Self::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = TransactionStatus<Self::Hash, <Self::Block as Block>::Hash>> + Send>>, Self::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Asynchronously imports a single transaction and starts to watch their progress in the pool.

Source

fn ready_at<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Get an iterator for ready transactions ordered by priority.

Guaranteed to resolve only when transaction pool got updated at at block. Guaranteed to resolve immediately when None is passed.

Source

fn ready( &self, ) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>

Get an iterator for ready transactions ordered by priority.

Source

fn report_invalid( &self, at: Option<<Self::Block as Block>::Hash>, invalid_tx_errors: IndexMap<Self::Hash, Option<TransactionValidityError>>, ) -> Vec<Arc<Self::InPoolTransaction>>

Reports invalid transactions to the transaction pool.

This function takes a map where the key is a transaction hash and the value is an optional error encountered during the transaction execution, possibly within a specific block.

The transaction pool implementation decides which transactions to remove. Transactions removed from the pool will be notified with TransactionStatus::Invalid event (if submit_and_watch was used for submission).

If the error associated to transaction is None, the transaction will be forcibly removed from the pool.

The optional at parameter provides additional context regarding the block where the error occurred.

Function returns the transactions actually removed from the pool.

Source

fn futures(&self) -> Vec<Self::InPoolTransaction>

Get futures transaction list.

Source

fn status(&self) -> PoolStatus

Returns pool status.

Source

fn import_notification_stream(&self) -> Receiver<Self::Hash>

Return an event stream of transactions imported to the pool.

Source

fn on_broadcasted(&self, propagations: HashMap<Self::Hash, Vec<String>>)

Notify the pool about transactions broadcast.

Source

fn hash_of(&self, xt: &<Self::Block as Block>::Extrinsic) -> Self::Hash

Returns transaction hash

Source

fn ready_transaction( &self, hash: &Self::Hash, ) -> Option<Arc<Self::InPoolTransaction>>

Return specific ready transaction by hash, if there is one.

Source

fn ready_at_with_timeout<'life0, 'async_trait>( &'life0 self, at: <Self::Block as Block>::Hash, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Asynchronously returns a set of ready transaction at given block within given timeout.

If the timeout is hit during method execution, then the best effort (without executing full maintain process) set of ready transactions for given block is returned.

Implementations on Foreign Types§

Source§

impl<Block, Client> TransactionPool for TransactionPoolWrapper<Block, Client>
where Block: Block, Client: ProvideRuntimeApi<Block> + BlockBackend<Block> + HeaderBackend<Block> + BlockIdTo<Block> + HeaderMetadata<Block, Error = Error> + 'static, <Client as ProvideRuntimeApi<Block>>::Api: TaggedTransactionQueue<Block>,

Source§

type Block = Block

Source§

type Hash = <<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Hash

Source§

type InPoolTransaction = Transaction<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Hash, Arc<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Extrinsic>>

Source§

type Error = <FullChainApi<Client, Block> as ChainApi>::Error

Source§

fn submit_at<'life0, 'async_trait>( &'life0 self, at: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xts: Vec<<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Extrinsic>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, <TransactionPoolWrapper<Block, Client> as TransactionPool>::Error>>, <TransactionPoolWrapper<Block, Client> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, TransactionPoolWrapper<Block, Client>: 'async_trait,

Source§

fn submit_one<'life0, 'async_trait>( &'life0 self, at: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, <TransactionPoolWrapper<Block, Client> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, TransactionPoolWrapper<Block, Client>: 'async_trait,

Source§

fn submit_and_watch<'life0, 'async_trait>( &'life0 self, at: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = TransactionStatus<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash>> + Send>>, <TransactionPoolWrapper<Block, Client> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, TransactionPoolWrapper<Block, Client>: 'async_trait,

Source§

fn ready_at<'life0, 'async_trait>( &'life0 self, at: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Hash, Arc<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, TransactionPoolWrapper<Block, Client>: 'async_trait,

Source§

fn ready( &self, ) -> Box<dyn ReadyTransactions<Item = Arc<<TransactionPoolWrapper<Block, Client> as TransactionPool>::InPoolTransaction>> + Send>

Source§

fn report_invalid( &self, at: Option<<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash>, invalid_tx_errors: IndexMap<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, Option<TransactionValidityError>>, ) -> Vec<Arc<<TransactionPoolWrapper<Block, Client> as TransactionPool>::InPoolTransaction>>

Source§

fn futures( &self, ) -> Vec<<TransactionPoolWrapper<Block, Client> as TransactionPool>::InPoolTransaction>

Source§

fn status(&self) -> PoolStatus

Source§

fn import_notification_stream( &self, ) -> Receiver<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash>

Source§

fn on_broadcasted( &self, propagations: HashMap<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, Vec<String>>, )

Source§

fn hash_of( &self, xt: &<<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Extrinsic, ) -> <TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash

Source§

fn ready_transaction( &self, hash: &<TransactionPoolWrapper<Block, Client> as TransactionPool>::Hash, ) -> Option<Arc<<TransactionPoolWrapper<Block, Client> as TransactionPool>::InPoolTransaction>>

Source§

fn ready_at_with_timeout<'life0, 'async_trait>( &'life0 self, at: <<TransactionPoolWrapper<Block, Client> as TransactionPool>::Block as Block>::Hash, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Hash, Arc<<<FullChainApi<Client, Block> as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, TransactionPoolWrapper<Block, Client>: 'async_trait,

Source§

impl<ChainApi, Block> TransactionPool for ForkAwareTxPool<ChainApi, Block>
where Block: Block, ChainApi: 'static + ChainApi<Block = Block>, <Block as Block>::Hash: Unpin,

Source§

fn submit_at<'life0, 'async_trait>( &'life0 self, __arg1: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xts: Vec<<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Extrinsic>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, <ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Error>>, <ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, ForkAwareTxPool<ChainApi, Block>: 'async_trait,

Submits multiple transactions and returns a future resolving to the submission results.

Actual transactions submission process is delegated to the ViewStore internal instance.

The internal limits of the pool are checked. The results of submissions to individual views are reduced to single result. Refer to reduce_multiview_result for more details.

Source§

fn submit_one<'life0, 'async_trait>( &'life0 self, _at: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, <ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, ForkAwareTxPool<ChainApi, Block>: 'async_trait,

Submits a single transaction and returns a future resolving to the submission results.

Actual transaction submission process is delegated to the submit_at function.

Source§

fn submit_and_watch<'life0, 'async_trait>( &'life0 self, at: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = TransactionStatus<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash>> + Send>>, <ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, ForkAwareTxPool<ChainApi, Block>: 'async_trait,

Submits a transaction and starts to watch its progress in the pool, returning a stream of status updates.

Actual transaction submission process is delegated to the ViewStore internal instance.

Source§

fn report_invalid( &self, at: Option<<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash>, invalid_tx_errors: IndexMap<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, Option<TransactionValidityError>>, ) -> Vec<Arc<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::InPoolTransaction>>

Reports invalid transactions to the transaction pool.

This function takes an array of tuples, each consisting of a transaction hash and the corresponding error that occurred during transaction execution at given block.

The transaction pool implementation will determine which transactions should be removed from the pool. Transactions that depend on invalid transactions will also be removed.

Source§

fn status(&self) -> PoolStatus

Returns the pool status which includes information like the number of ready and future transactions.

Currently the status for the most recently notified best block is returned (for which maintain process was accomplished).

Source§

fn import_notification_stream( &self, ) -> Receiver<<<ChainApi as ChainApi>::Block as Block>::Hash>

Return an event stream of notifications when transactions are imported to the pool.

Consumers of this stream should use the ready method to actually get the pending transactions in the right order.

Source§

fn hash_of( &self, xt: &<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> <ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash

Returns the hash of a given transaction.

Source§

fn on_broadcasted( &self, propagations: HashMap<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, Vec<String>>, )

Notifies the pool about the broadcasting status of transactions.

Source§

fn ready_transaction( &self, tx_hash: &<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Hash, ) -> Option<Arc<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::InPoolTransaction>>

Return specific ready transaction by hash, if there is one.

Currently the ready transaction is returned if it exists for the most recently notified best block (for which maintain process was accomplished).

Source§

fn ready_at<'life0, 'async_trait>( &'life0 self, at: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<ChainApi as ChainApi>::Block as Block>::Hash, Arc<<<ChainApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, ForkAwareTxPool<ChainApi, Block>: 'async_trait,

Returns an iterator for ready transactions at a specific block, ordered by priority.

Source§

fn ready( &self, ) -> Box<dyn ReadyTransactions<Item = Arc<Transaction<<<ChainApi as ChainApi>::Block as Block>::Hash, Arc<<<ChainApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>

Returns an iterator for ready transactions, ordered by priority.

Currently the set of ready transactions is returned if it exists for the most recently notified best block (for which maintain process was accomplished).

Source§

fn futures( &self, ) -> Vec<<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::InPoolTransaction>

Returns a list of future transactions in the pool.

Currently the set of future transactions is returned if it exists for the most recently notified best block (for which maintain process was accomplished).

Source§

fn ready_at_with_timeout<'life0, 'async_trait>( &'life0 self, at: <<ForkAwareTxPool<ChainApi, Block> as TransactionPool>::Block as Block>::Hash, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<ChainApi as ChainApi>::Block as Block>::Hash, Arc<<<ChainApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, ForkAwareTxPool<ChainApi, Block>: 'async_trait,

Returns a set of ready transactions at a given block within the specified timeout.

If the timeout expires before the maintain process is accomplished, a best-effort set of transactions is returned (refer to ready_at_light).

Source§

type Block = <ChainApi as ChainApi>::Block

Source§

type Hash = <<ChainApi as ChainApi>::Block as Block>::Hash

Source§

type InPoolTransaction = Transaction<<<ChainApi as ChainApi>::Block as Block>::Hash, Arc<<<ChainApi as ChainApi>::Block as Block>::Extrinsic>>

Source§

type Error = <ChainApi as ChainApi>::Error

Source§

impl<PoolApi, Block> TransactionPool for BasicPool<PoolApi, Block>
where Block: Block, PoolApi: 'static + ChainApi<Block = Block>,

Source§

type Block = <PoolApi as ChainApi>::Block

Source§

type Hash = <<PoolApi as ChainApi>::Block as Block>::Hash

Source§

type InPoolTransaction = Transaction<<<PoolApi as ChainApi>::Block as Block>::Hash, Arc<<<PoolApi as ChainApi>::Block as Block>::Extrinsic>>

Source§

type Error = <PoolApi as ChainApi>::Error

Source§

fn submit_at<'life0, 'async_trait>( &'life0 self, at: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xts: Vec<<<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Extrinsic>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, <BasicPool<PoolApi, Block> as TransactionPool>::Error>>, <BasicPool<PoolApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, BasicPool<PoolApi, Block>: 'async_trait,

Source§

fn submit_one<'life0, 'async_trait>( &'life0 self, at: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, <BasicPool<PoolApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, BasicPool<PoolApi, Block>: 'async_trait,

Source§

fn submit_and_watch<'life0, 'async_trait>( &'life0 self, at: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash, source: TransactionSource, xt: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = TransactionStatus<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash>> + Send>>, <BasicPool<PoolApi, Block> as TransactionPool>::Error>> + Send + 'async_trait>>
where 'life0: 'async_trait, BasicPool<PoolApi, Block>: 'async_trait,

Source§

fn report_invalid( &self, _at: Option<<<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash>, invalid_tx_errors: IndexMap<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, Option<TransactionValidityError>>, ) -> Vec<Arc<<BasicPool<PoolApi, Block> as TransactionPool>::InPoolTransaction>>

Source§

fn status(&self) -> PoolStatus

Source§

fn import_notification_stream( &self, ) -> Receiver<<BasicPool<PoolApi, Block> as TransactionPool>::Hash>

Source§

fn hash_of( &self, xt: &<<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Extrinsic, ) -> <BasicPool<PoolApi, Block> as TransactionPool>::Hash

Source§

fn on_broadcasted( &self, propagations: HashMap<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, Vec<String>>, )

Source§

fn ready_transaction( &self, hash: &<BasicPool<PoolApi, Block> as TransactionPool>::Hash, ) -> Option<Arc<<BasicPool<PoolApi, Block> as TransactionPool>::InPoolTransaction>>

Source§

fn ready_at<'life0, 'async_trait>( &'life0 self, at: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as Block>::Hash, Arc<<<PoolApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, BasicPool<PoolApi, Block>: 'async_trait,

Source§

fn ready( &self, ) -> Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as Block>::Hash, Arc<<<PoolApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>

Source§

fn futures( &self, ) -> Vec<<BasicPool<PoolApi, Block> as TransactionPool>::InPoolTransaction>

Source§

fn ready_at_with_timeout<'life0, 'async_trait>( &'life0 self, at: <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Hash, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as Block>::Hash, Arc<<<PoolApi as ChainApi>::Block as Block>::Extrinsic>>>> + Send>> + Send + 'async_trait>>
where 'life0: 'async_trait, BasicPool<PoolApi, Block>: 'async_trait,

Implementors§