Struct LegacyRpcMethods 

pub struct LegacyRpcMethods<T> { /* private fields */ }

An interface to call the legacy RPC methods. This interface is instantiated with some T: Config trait which determines some of the types that the RPC methods will take or hand back.

Implementations

impl<T: RpcConfig> LegacyRpcMethods<T>

pub fn new(client: RpcClient) -> Self

Instantiate the legacy RPC method interface.

pub async fn state_get_storage( &self, key: &[u8], hash: Option<T::Hash>, ) -> Result<Option<StorageData>, Error>

Fetch the raw bytes for a given storage key

pub async fn state_get_keys_paged( &self, key: &[u8], count: u32, start_key: Option<&[u8]>, at: Option<T::Hash>, ) -> Result<Vec<StorageKey>, Error>

Returns the keys with prefix with pagination support. Up to count keys will be returned. If start_key is passed, return next keys in storage in lexicographic order.

pub async fn state_query_storage( &self, keys: impl IntoIterator<Item = &[u8]>, from: T::Hash, to: Option<T::Hash>, ) -> Result<Vec<StorageChangeSet<T::Hash>>, Error>

Query historical storage entries in the range from the start block to the end block, defaulting the end block to the current best block if it’s not given. The first StorageChangeSet returned has all of the values for each key, and subsequent ones only contain values for any keys which have changed since the last.

pub async fn state_query_storage_at( &self, keys: impl IntoIterator<Item = &[u8]>, at: Option<T::Hash>, ) -> Result<Vec<StorageChangeSet<T::Hash>>, Error>

Query storage entries at some block, using the best block if none is given. This essentially provides a way to ask for a batch of values given a batch of keys, despite the name of the StorageChangeSet type.

pub async fn genesis_hash(&self) -> Result<T::Hash, Error>

Fetch the genesis hash

pub async fn state_get_metadata( &self, at: Option<T::Hash>, ) -> Result<StateGetMetadataResponse, Error>

Fetch the metadata via the legacy state_getMetadata RPC method.

pub async fn system_health(&self) -> Result<SystemHealth, Error>

Fetch system health

pub async fn system_chain(&self) -> Result<String, Error>

Fetch system chain

pub async fn system_name(&self) -> Result<String, Error>

Fetch system name

pub async fn system_version(&self) -> Result<String, Error>

Fetch system version

pub async fn system_properties(&self) -> Result<SystemProperties, Error>

Fetch system properties

pub async fn system_account_next_index( &self, account_id: &T::AccountId, ) -> Result<u64, Error>

Fetch next nonce for an Account

Return account nonce adjusted for extrinsics currently in transaction pool

pub async fn chain_get_header( &self, hash: Option<T::Hash>, ) -> Result<Option<T::Header>, Error>

Get a header

pub async fn chain_get_block_hash( &self, block_number: Option<BlockNumber>, ) -> Result<Option<T::Hash>, Error>

Get a block hash, returns hash of latest best block by default.

pub async fn chain_get_finalized_head(&self) -> Result<T::Hash, Error>

Get a block hash of the latest finalized block

pub async fn chain_get_block( &self, hash: Option<T::Hash>, ) -> Result<Option<BlockDetails<T>>, Error>

Get a Block

pub async fn dev_get_block_stats( &self, block_hash: T::Hash, ) -> Result<Option<BlockStats>, Error>

Reexecute the specified block_hash and gather statistics while doing so.

This function requires the specified block and its parent to be available at the queried node. If either the specified block or the parent is pruned, this function will return None.

pub async fn state_get_read_proof( &self, keys: impl IntoIterator<Item = &[u8]>, hash: Option<T::Hash>, ) -> Result<ReadProof<T::Hash>, Error>

Get proof of storage entries at a specific block’s state.

pub async fn state_get_runtime_version( &self, at: Option<T::Hash>, ) -> Result<RuntimeVersion, Error>

Fetch the runtime version

pub async fn chain_subscribe_new_heads( &self, ) -> Result<RpcSubscription<T::Header>, Error>

Subscribe to all new best block headers.

pub async fn chain_subscribe_all_heads( &self, ) -> Result<RpcSubscription<T::Header>, Error>

Subscribe to all new block headers.

pub async fn chain_subscribe_finalized_heads( &self, ) -> Result<RpcSubscription<T::Header>, Error>

Subscribe to finalized block headers.

Note: this may not produce every block in the finalized chain; sometimes multiple blocks are finalized at once, and in this case only the latest one is returned. the higher level APIs that use this “fill in” the gaps for us.

pub async fn state_subscribe_runtime_version( &self, ) -> Result<RpcSubscription<RuntimeVersion>, Error>

Subscribe to runtime version updates that produce changes in the metadata. The first item emitted by the stream is the current runtime version.

pub async fn author_submit_extrinsic( &self, extrinsic: &[u8], ) -> Result<T::Hash, Error>

Create and submit an extrinsic and return corresponding Hash if successful

pub async fn author_submit_and_watch_extrinsic( &self, extrinsic: &[u8], ) -> Result<RpcSubscription<TransactionStatus<T::Hash>>, Error>

Create and submit an extrinsic and return a subscription to the events triggered.

pub async fn author_insert_key( &self, key_type: String, suri: String, public: Vec<u8>, ) -> Result<(), Error>

Insert a key into the keystore.

pub async fn author_rotate_keys(&self) -> Result<Vec<u8>, Error>

Generate new session keys and returns the corresponding public keys.

pub async fn author_has_session_keys( &self, session_keys: Vec<u8>, ) -> Result<bool, Error>

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 if all private keys could be found.

pub async fn author_has_key( &self, public_key: Vec<u8>, key_type: String, ) -> Result<bool, Error>

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 async fn state_call( &self, function: &str, call_parameters: Option<&[u8]>, at: Option<T::Hash>, ) -> Result<Vec<u8>, Error>

Execute a runtime API call via state_call RPC method.

pub async fn dry_run( &self, encoded_signed: &[u8], at: Option<T::Hash>, ) -> Result<DryRunResultBytes, Error>

Submits the extrinsic to the dry_run RPC, to test if it would succeed.

Returns a DryRunResult, which is the result of performing the dry run.

Trait Implementations

impl<T> Clone for LegacyRpcMethods<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for LegacyRpcMethods<T>

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

Formats the value using the given formatter.