Struct sc_rpc_api::author::gen_client::Client

pub struct Client<Hash, BlockHash> { /* fields omitted */ }

The Client.

Implementations

impl<Hash, BlockHash> Client<Hash, BlockHash> where
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize,
    BlockHash: Send + Sync + 'static + DeserializeOwned, 

pub fn new(sender: RpcChannel) -> Self

Creates a new Client.

pub fn submit_extrinsic(
    &self,
    extrinsic: Bytes
) -> impl Future<Item = Hash, Error = RpcError>

Submit hex-encoded extrinsic for inclusion in block.

pub fn insert_key(
    &self,
    key_type: String,
    suri: String,
    public: Bytes
) -> impl Future<Item = (), Error = RpcError>

Insert a key into the keystore.

pub fn rotate_keys(&self) -> impl Future<Item = Bytes, Error = RpcError>

Generate new session keys and returns the corresponding public keys.

pub fn has_session_keys(
    &self,
    session_keys: Bytes
) -> impl Future<Item = bool, Error = RpcError>

Checks if the keystore has private keys for the given session public keys.

session_keys is the SCALE encoded session keys object from the runtime.

Returns true iff all private keys could be found.

pub fn has_key(
    &self,
    public_key: Bytes,
    key_type: String
) -> impl Future<Item = bool, Error = RpcError>

Checks if the keystore has private keys for the given public key and key type.

Returns true if a private key could be found.

pub fn pending_extrinsics(
    &self
) -> impl Future<Item = Vec<Bytes>, Error = RpcError>

Returns all pending extrinsics, potentially grouped by sender.

pub fn remove_extrinsic(
    &self,
    bytes_or_hash: Vec<ExtrinsicOrHash<Hash>>
) -> impl Future<Item = Vec<Hash>, Error = RpcError>

Remove given extrinsic from the pool and temporarily ban it to prevent reimporting.

pub fn watch_extrinsic(
    &self,
    bytes: Bytes
) -> impl Future<Item = TypedSubscriptionStream<TransactionStatus<Hash, BlockHash>>, Error = RpcError>

Submit an extrinsic to watch.

See TransactionStatus for details on transaction life cycle.

Trait Implementations

impl<Hash: Clone, BlockHash: Clone> Clone for Client<Hash, BlockHash>

fn clone(&self) -> Client<Hash, BlockHash>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash, BlockHash> From<RpcChannel> for Client<Hash, BlockHash> where
    Hash: Send + Sync + 'static + DeserializeOwned + Serialize,
    BlockHash: Send + Sync + 'static + DeserializeOwned, 

fn from(channel: RpcChannel) -> Self

Performs the conversion.