Trait sc_service::TransactionPool

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

    // Required methods
    fn submit_at(
        &self,
        at: <Self::Block as Block>::Hash,
        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, Global>>;
    fn submit_one(
        &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, Global>>;
    fn submit_and_watch(
        &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, Global>>, Self::Error>> + Send, Global>>;
    fn ready_at(
        &self,
        at: <<Self::Block as Block>::Header as Header>::Number
    ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction, Global>> + Send, Global>> + Send, Global>>;
    fn ready(
        &self
    ) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction, Global>> + Send, Global>;
    fn remove_invalid(
        &self,
        hashes: &[Self::Hash]
    ) -> Vec<Arc<Self::InPoolTransaction, Global>, Global>;
    fn futures(&self) -> Vec<Self::InPoolTransaction, Global>;
    fn status(&self) -> PoolStatus;
    fn import_notification_stream(&self) -> Receiver<Self::Hash>;
    fn on_broadcasted(
        &self,
        propagations: HashMap<Self::Hash, Vec<String, Global>, RandomState>
    );
    fn hash_of(&self, xt: &<Self::Block as Block>::Extrinsic) -> Self::Hash;
    fn ready_transaction(
        &self,
        hash: &Self::Hash
    ) -> Option<Arc<Self::InPoolTransaction, Global>>;
}

Transaction pool interface.

Required Associated Types

type Block: Block

Block type.

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

Transaction hash type.

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

In-pool transaction type.

type Error: From<Error> + IntoPoolError

Error type.

Required Methods

fn submit_at( &self, at: <Self::Block as Block>::Hash, 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, Global>>

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

fn submit_one( &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, Global>>

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

fn submit_and_watch( &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, Global>>, Self::Error>> + Send, Global>>

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

fn ready_at( &self, at: <<Self::Block as Block>::Header as Header>::Number ) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction, Global>> + Send, Global>> + Send, Global>>

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.

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

Get an iterator for ready transactions ordered by priority.

fn remove_invalid( &self, hashes: &[Self::Hash] ) -> Vec<Arc<Self::InPoolTransaction, Global>, Global>

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

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

Get futures transaction list.

fn status(&self) -> PoolStatus

Returns pool status.

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

Return an event stream of transactions imported to the pool.

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

Notify the pool about transactions broadcast.

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

Returns transaction hash

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

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

Implementations on Foreign Types

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

type Block = <PoolApi as ChainApi>::Block

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

type InPoolTransaction = Transaction<<BasicPool<PoolApi, Block> as TransactionPool>::Hash, <<BasicPool<PoolApi, Block> as TransactionPool>::Block as Block>::Extrinsic>

type Error = <PoolApi as ChainApi>::Error

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

fn submit_one( &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, Global>>

fn submit_and_watch( &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, Global>>, <BasicPool<PoolApi, Block> as TransactionPool>::Error>> + Send, Global>>

fn remove_invalid( &self, hashes: &[<BasicPool<PoolApi, Block> as TransactionPool>::Hash] ) -> Vec<Arc<<BasicPool<PoolApi, Block> as TransactionPool>::InPoolTransaction, Global>, Global>

fn status(&self) -> PoolStatus

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

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

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

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

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

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

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

Implementors