Trait sc_service::TransactionPool[][src]

pub trait TransactionPool: Send + Sync {
    type Block: Block;
    type Hash: Hash + Eq + Member + Serialize;
    type InPoolTransaction: InPoolTransaction;
    type Error: From<Error> + IntoPoolError;
    fn submit_at(
        at: &BlockId<Self::Block>,
        source: TransactionSource,
        xts: Vec<<Self::Block as Block>::Extrinsic, Global>
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Result<Self::Hash, Self::Error>, Global>, Self::Error>> + Send + 'static, Global>>;
fn submit_one(
        at: &BlockId<Self::Block>,
        source: TransactionSource,
        xt: <Self::Block as Block>::Extrinsic
    ) -> Pin<Box<dyn Future<Output = Result<Self::Hash, Self::Error>> + Send + 'static, Global>>;
fn submit_and_watch(
        at: &BlockId<Self::Block>,
        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 + 'static, Global>>, Self::Error>> + Send + 'static, Global>>;
fn ready_at(
        at: <<Self::Block as Block>::Header as Header>::Number
    ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send + 'static, Global>> + Send + 'static, Global>>;
fn ready(
    ) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send + 'static, Global>
Notable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
    R: Read + ?Sized
impl<W> Write for Box<W, Global> where
    W: Write + ?Sized
impl<F, A> Future for Box<F, A> where
    F: Future + Unpin + ?Sized,
    A: Allocator + 'static, 
type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
    I: Iterator + ?Sized,
    A: Allocator
type Item = <I as Iterator>::Item;
fn remove_invalid(
        hashes: &[Self::Hash]
    ) -> Vec<Arc<Self::InPoolTransaction>, Global>
Notable traits for Vec<u8, A>
impl<A> Write for Vec<u8, A> where
    A: Allocator
fn status(&self) -> PoolStatus;
fn import_notification_stream(&self) -> Receiver<Self::Hash>;
fn on_broadcasted(
        propagations: HashMap<Self::Hash, Vec<String, Global>, RandomState>
fn hash_of(&self, xt: &<Self::Block as Block>::Extrinsic) -> Self::Hash;
fn ready_transaction(
        hash: &Self::Hash
    ) -> Option<Arc<Self::InPoolTransaction>>; }
Expand description

Transaction pool interface.

Associated Types

Block type.

Transaction hash type.

In-pool transaction type.

Error type.

Required methods

Returns a future that imports a bunch of unverified transactions to the pool.

Returns a future that imports one unverified transaction to the pool.

Returns a future that import a single transaction and starts to watch their progress in the pool.

Get an iterator for ready transactions ordered by priority.

Guarantees to return only when transaction pool got updated at at block. Guarantees to return immediately when None is passed.

Get an iterator for ready transactions ordered by priority.

Remove transactions identified by given hashes (and dependent transactions) from the pool.

Returns pool status.

Return an event stream of transactions imported to the pool.

Notify the pool about transactions broadcast.

Returns transaction hash

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

Implementations on Foreign Types