Trait RpcApi

pub trait RpcApi:
    Sync
    + Send
    + AnySync {
    // Required methods
    fn ping_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: PingRequest,
    ) -> Pin<Box<dyn Future<Output = Result<PingResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_system_info_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetSystemInfoRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetSystemInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_connections_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetConnectionsRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetConnectionsResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_metrics_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetMetricsRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetMetricsResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_server_info_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetServerInfoRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetServerInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_sync_status_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetSyncStatusRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetSyncStatusResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_current_network_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetCurrentNetworkRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetCurrentNetworkResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn submit_block_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: SubmitBlockRequest,
    ) -> Pin<Box<dyn Future<Output = Result<SubmitBlockResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_block_template_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBlockTemplateRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_peer_addresses_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetPeerAddressesRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetPeerAddressesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_sink_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetSinkRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetSinkResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_mempool_entry_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetMempoolEntryRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_mempool_entries_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetMempoolEntriesRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntriesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_connected_peer_info_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetConnectedPeerInfoRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetConnectedPeerInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn add_peer_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: AddPeerRequest,
    ) -> Pin<Box<dyn Future<Output = Result<AddPeerResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn submit_transaction_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: SubmitTransactionRequest,
    ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn submit_transaction_replacement_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: SubmitTransactionReplacementRequest,
    ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionReplacementResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_block_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBlockRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_subnetwork_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetSubnetworkRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetSubnetworkResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_virtual_chain_from_block_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetVirtualChainFromBlockRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetVirtualChainFromBlockResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_blocks_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBlocksRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlocksResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_block_count_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBlockCountRequest,
    ) -> Pin<Box<dyn Future<Output = Result<BlockCount, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_block_dag_info_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBlockDagInfoRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockDagInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn resolve_finality_conflict_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: ResolveFinalityConflictRequest,
    ) -> Pin<Box<dyn Future<Output = Result<ResolveFinalityConflictResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn shutdown_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: ShutdownRequest,
    ) -> Pin<Box<dyn Future<Output = Result<ShutdownResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_headers_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetHeadersRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetHeadersResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_balance_by_address_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBalanceByAddressRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBalanceByAddressResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_balances_by_addresses_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetBalancesByAddressesRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetBalancesByAddressesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_utxos_by_addresses_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetUtxosByAddressesRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetUtxosByAddressesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_sink_blue_score_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetSinkBlueScoreRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetSinkBlueScoreResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn ban_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: BanRequest,
    ) -> Pin<Box<dyn Future<Output = Result<BanResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn unban_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: UnbanRequest,
    ) -> Pin<Box<dyn Future<Output = Result<UnbanResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_info_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetInfoRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn estimate_network_hashes_per_second_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: EstimateNetworkHashesPerSecondRequest,
    ) -> Pin<Box<dyn Future<Output = Result<EstimateNetworkHashesPerSecondResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_mempool_entries_by_addresses_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetMempoolEntriesByAddressesRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntriesByAddressesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_coin_supply_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetCoinSupplyRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetCoinSupplyResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_daa_score_timestamp_estimate_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetDaaScoreTimestampEstimateRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetDaaScoreTimestampEstimateResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_fee_estimate_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetFeeEstimateRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_fee_estimate_experimental_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetFeeEstimateExperimentalRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateExperimentalResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn get_current_block_color_call<'life0, 'life1, 'async_trait>(
        &'life0 self,
        connection: Option<&'life1 Arc<dyn RpcConnection>>,
        request: GetCurrentBlockColorRequest,
    ) -> Pin<Box<dyn Future<Output = Result<GetCurrentBlockColorResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn register_new_listener(
        &self,
        connection: ChannelConnection<Notification>,
    ) -> u64;
    fn unregister_listener<'life0, 'async_trait>(
        &'life0 self,
        id: u64,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn start_notify<'life0, 'async_trait>(
        &'life0 self,
        id: u64,
        scope: Scope,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;
    fn stop_notify<'life0, 'async_trait>(
        &'life0 self,
        id: u64,
        scope: Scope,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait;

    // Provided methods
    fn ping<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_system_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetSystemInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_connections<'life0, 'async_trait>(
        &'life0 self,
        include_profile_data: bool,
    ) -> Pin<Box<dyn Future<Output = Result<GetConnectionsResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_metrics<'life0, 'async_trait>(
        &'life0 self,
        process_metrics: bool,
        connection_metrics: bool,
        bandwidth_metrics: bool,
        consensus_metrics: bool,
        storage_metrics: bool,
        custom_metrics: bool,
    ) -> Pin<Box<dyn Future<Output = Result<GetMetricsResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_server_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetServerInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_sync_status<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<bool, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_current_network<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<NetworkType, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn submit_block<'life0, 'async_trait>(
        &'life0 self,
        block: RpcRawBlock,
        allow_non_daa_blocks: bool,
    ) -> Pin<Box<dyn Future<Output = Result<SubmitBlockResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_block_template<'life0, 'async_trait>(
        &'life0 self,
        pay_address: Address,
        extra_data: Vec<u8>,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_peer_addresses<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetPeerAddressesResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_sink<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetSinkResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_mempool_entry<'life0, 'async_trait>(
        &'life0 self,
        transaction_id: Hash,
        include_orphan_pool: bool,
        filter_transaction_pool: bool,
    ) -> Pin<Box<dyn Future<Output = Result<RpcMempoolEntry, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_mempool_entries<'life0, 'async_trait>(
        &'life0 self,
        include_orphan_pool: bool,
        filter_transaction_pool: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcMempoolEntry>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_connected_peer_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetConnectedPeerInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn add_peer<'life0, 'async_trait>(
        &'life0 self,
        peer_address: ContextualNetAddress,
        is_permanent: bool,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn submit_transaction<'life0, 'async_trait>(
        &'life0 self,
        transaction: RpcTransaction,
        allow_orphan: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Hash, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn submit_transaction_replacement<'life0, 'async_trait>(
        &'life0 self,
        transaction: RpcTransaction,
    ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionReplacementResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_block<'life0, 'async_trait>(
        &'life0 self,
        hash: Hash,
        include_transactions: bool,
    ) -> Pin<Box<dyn Future<Output = Result<RpcBlock, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_subnetwork<'life0, 'async_trait>(
        &'life0 self,
        subnetwork_id: SubnetworkId,
    ) -> Pin<Box<dyn Future<Output = Result<GetSubnetworkResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_virtual_chain_from_block<'life0, 'async_trait>(
        &'life0 self,
        start_hash: Hash,
        include_accepted_transaction_ids: bool,
    ) -> Pin<Box<dyn Future<Output = Result<GetVirtualChainFromBlockResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_blocks<'life0, 'async_trait>(
        &'life0 self,
        low_hash: Option<Hash>,
        include_blocks: bool,
        include_transactions: bool,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlocksResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_block_count<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<BlockCount, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_block_dag_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockDagInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn resolve_finality_conflict<'life0, 'async_trait>(
        &'life0 self,
        finality_block_hash: Hash,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn shutdown<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_headers<'life0, 'async_trait>(
        &'life0 self,
        start_hash: Hash,
        limit: u64,
        is_ascending: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcHeader>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_balance_by_address<'life0, 'async_trait>(
        &'life0 self,
        address: Address,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_balances_by_addresses<'life0, 'async_trait>(
        &'life0 self,
        addresses: Vec<Address>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcBalancesByAddressesEntry>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_utxos_by_addresses<'life0, 'async_trait>(
        &'life0 self,
        addresses: Vec<Address>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcUtxosByAddressesEntry>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_sink_blue_score<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn ban<'life0, 'async_trait>(
        &'life0 self,
        ip: IpAddress,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn unban<'life0, 'async_trait>(
        &'life0 self,
        ip: IpAddress,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetInfoResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn estimate_network_hashes_per_second<'life0, 'async_trait>(
        &'life0 self,
        window_size: u32,
        start_hash: Option<Hash>,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_mempool_entries_by_addresses<'life0, 'async_trait>(
        &'life0 self,
        addresses: Vec<Address>,
        include_orphan_pool: bool,
        filter_transaction_pool: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcMempoolEntryByAddress>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_coin_supply<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetCoinSupplyResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_daa_score_timestamp_estimate<'life0, 'async_trait>(
        &'life0 self,
        daa_scores: Vec<u64>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u64>, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_fee_estimate<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<RpcFeeEstimate, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_fee_estimate_experimental<'life0, 'async_trait>(
        &'life0 self,
        verbose: bool,
    ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateExperimentalResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn get_current_block_color<'life0, 'async_trait>(
        &'life0 self,
        hash: Hash,
    ) -> Pin<Box<dyn Future<Output = Result<GetCurrentBlockColorResponse, RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
    fn execute_subscribe_command<'life0, 'async_trait>(
        &'life0 self,
        id: u64,
        scope: Scope,
        command: Command,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: 'async_trait { ... }
}

Client RPC Api

The RpcApi trait defines RPC calls taking a request message as unique parameter.

For each RPC call a matching readily implemented function taking detailed parameters is also provided.

Required Methods

fn ping_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: PingRequest, ) -> Pin<Box<dyn Future<Output = Result<PingResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_system_info_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetSystemInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<GetSystemInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_connections_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetConnectionsRequest, ) -> Pin<Box<dyn Future<Output = Result<GetConnectionsResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_metrics_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetMetricsRequest, ) -> Pin<Box<dyn Future<Output = Result<GetMetricsResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_server_info_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetServerInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<GetServerInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_sync_status_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetSyncStatusRequest, ) -> Pin<Box<dyn Future<Output = Result<GetSyncStatusResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_current_network_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetCurrentNetworkRequest, ) -> Pin<Box<dyn Future<Output = Result<GetCurrentNetworkResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn submit_block_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: SubmitBlockRequest, ) -> Pin<Box<dyn Future<Output = Result<SubmitBlockResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_block_template_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBlockTemplateRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_peer_addresses_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetPeerAddressesRequest, ) -> Pin<Box<dyn Future<Output = Result<GetPeerAddressesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_sink_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetSinkRequest, ) -> Pin<Box<dyn Future<Output = Result<GetSinkResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_mempool_entry_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetMempoolEntryRequest, ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_mempool_entries_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetMempoolEntriesRequest, ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntriesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_connected_peer_info_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetConnectedPeerInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<GetConnectedPeerInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn add_peer_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: AddPeerRequest, ) -> Pin<Box<dyn Future<Output = Result<AddPeerResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn submit_transaction_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: SubmitTransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn submit_transaction_replacement_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: SubmitTransactionReplacementRequest, ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionReplacementResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_block_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBlockRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBlockResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_subnetwork_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetSubnetworkRequest, ) -> Pin<Box<dyn Future<Output = Result<GetSubnetworkResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_virtual_chain_from_block_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetVirtualChainFromBlockRequest, ) -> Pin<Box<dyn Future<Output = Result<GetVirtualChainFromBlockResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_blocks_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBlocksRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBlocksResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_block_count_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBlockCountRequest, ) -> Pin<Box<dyn Future<Output = Result<BlockCount, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_block_dag_info_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBlockDagInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBlockDagInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn resolve_finality_conflict_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: ResolveFinalityConflictRequest, ) -> Pin<Box<dyn Future<Output = Result<ResolveFinalityConflictResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn shutdown_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: ShutdownRequest, ) -> Pin<Box<dyn Future<Output = Result<ShutdownResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_headers_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetHeadersRequest, ) -> Pin<Box<dyn Future<Output = Result<GetHeadersResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_balance_by_address_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBalanceByAddressRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBalanceByAddressResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_balances_by_addresses_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetBalancesByAddressesRequest, ) -> Pin<Box<dyn Future<Output = Result<GetBalancesByAddressesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_utxos_by_addresses_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetUtxosByAddressesRequest, ) -> Pin<Box<dyn Future<Output = Result<GetUtxosByAddressesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_sink_blue_score_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetSinkBlueScoreRequest, ) -> Pin<Box<dyn Future<Output = Result<GetSinkBlueScoreResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn ban_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: BanRequest, ) -> Pin<Box<dyn Future<Output = Result<BanResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn unban_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: UnbanRequest, ) -> Pin<Box<dyn Future<Output = Result<UnbanResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_info_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetInfoRequest, ) -> Pin<Box<dyn Future<Output = Result<GetInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn estimate_network_hashes_per_second_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: EstimateNetworkHashesPerSecondRequest, ) -> Pin<Box<dyn Future<Output = Result<EstimateNetworkHashesPerSecondResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_mempool_entries_by_addresses_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetMempoolEntriesByAddressesRequest, ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntriesByAddressesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_coin_supply_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetCoinSupplyRequest, ) -> Pin<Box<dyn Future<Output = Result<GetCoinSupplyResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_daa_score_timestamp_estimate_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetDaaScoreTimestampEstimateRequest, ) -> Pin<Box<dyn Future<Output = Result<GetDaaScoreTimestampEstimateResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_fee_estimate_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetFeeEstimateRequest, ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_fee_estimate_experimental_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetFeeEstimateExperimentalRequest, ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateExperimentalResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn get_current_block_color_call<'life0, 'life1, 'async_trait>( &'life0 self, connection: Option<&'life1 Arc<dyn RpcConnection>>, request: GetCurrentBlockColorRequest, ) -> Pin<Box<dyn Future<Output = Result<GetCurrentBlockColorResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

fn register_new_listener( &self, connection: ChannelConnection<Notification>, ) -> u64

Register a new listener and returns an id identifying it.

fn unregister_listener<'life0, 'async_trait>( &'life0 self, id: u64, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Unregister an existing listener.

Stop all notifications for this listener, unregister the id and its associated connection.

fn start_notify<'life0, 'async_trait>( &'life0 self, id: u64, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Start sending notifications of some type to a listener.

fn stop_notify<'life0, 'async_trait>( &'life0 self, id: u64, scope: Scope, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Stop sending notifications of some type to a listener.

Provided Methods

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_system_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetSystemInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_connections<'life0, 'async_trait>( &'life0 self, include_profile_data: bool, ) -> Pin<Box<dyn Future<Output = Result<GetConnectionsResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_metrics<'life0, 'async_trait>( &'life0 self, process_metrics: bool, connection_metrics: bool, bandwidth_metrics: bool, consensus_metrics: bool, storage_metrics: bool, custom_metrics: bool, ) -> Pin<Box<dyn Future<Output = Result<GetMetricsResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_server_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetServerInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_sync_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_current_network<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<NetworkType, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests the network the node is currently running against.

fn submit_block<'life0, 'async_trait>( &'life0 self, block: RpcRawBlock, allow_non_daa_blocks: bool, ) -> Pin<Box<dyn Future<Output = Result<SubmitBlockResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Submit a block into the DAG.

Blocks are generally expected to have been generated using the get_block_template call.

fn get_block_template<'life0, 'async_trait>( &'life0 self, pay_address: Address, extra_data: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Request a current block template.

Callers are expected to solve the block template and submit it using the submit_block call.

fn get_peer_addresses<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetPeerAddressesResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests the list of known kaspad addresses in the current network (mainnet, testnet, etc.)

fn get_sink<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetSinkResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

requests the hash of the current virtual’s selected parent.

fn get_mempool_entry<'life0, 'async_trait>( &'life0 self, transaction_id: Hash, include_orphan_pool: bool, filter_transaction_pool: bool, ) -> Pin<Box<dyn Future<Output = Result<RpcMempoolEntry, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests information about a specific transaction in the mempool.

fn get_mempool_entries<'life0, 'async_trait>( &'life0 self, include_orphan_pool: bool, filter_transaction_pool: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcMempoolEntry>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests information about all the transactions currently in the mempool.

fn get_connected_peer_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetConnectedPeerInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

requests information about all the p2p peers currently connected to this node.

fn add_peer<'life0, 'async_trait>( &'life0 self, peer_address: ContextualNetAddress, is_permanent: bool, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Adds a peer to the node’s outgoing connection list.

This will, in most cases, result in the node connecting to said peer.

fn submit_transaction<'life0, 'async_trait>( &'life0 self, transaction: RpcTransaction, allow_orphan: bool, ) -> Pin<Box<dyn Future<Output = Result<Hash, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Submits a transaction to the mempool.

fn submit_transaction_replacement<'life0, 'async_trait>( &'life0 self, transaction: RpcTransaction, ) -> Pin<Box<dyn Future<Output = Result<SubmitTransactionReplacementResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Submits a transaction replacement to the mempool, applying a mandatory Replace by Fee policy.

Returns the ID of the inserted transaction and the transaction the submission replaced in the mempool.

fn get_block<'life0, 'async_trait>( &'life0 self, hash: Hash, include_transactions: bool, ) -> Pin<Box<dyn Future<Output = Result<RpcBlock, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests information about a specific block.

fn get_subnetwork<'life0, 'async_trait>( &'life0 self, subnetwork_id: SubnetworkId, ) -> Pin<Box<dyn Future<Output = Result<GetSubnetworkResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests information about a specific subnetwork.

fn get_virtual_chain_from_block<'life0, 'async_trait>( &'life0 self, start_hash: Hash, include_accepted_transaction_ids: bool, ) -> Pin<Box<dyn Future<Output = Result<GetVirtualChainFromBlockResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests the virtual selected parent chain from some start_hash to this node’s current virtual.

fn get_blocks<'life0, 'async_trait>( &'life0 self, low_hash: Option<Hash>, include_blocks: bool, include_transactions: bool, ) -> Pin<Box<dyn Future<Output = Result<GetBlocksResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests blocks between a certain block low_hash up to this node’s current virtual.

fn get_block_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BlockCount, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests the current number of blocks in this node.

Note that this number may decrease as pruning occurs.

fn get_block_dag_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetBlockDagInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests general information about the current state of this node’s DAG.

fn resolve_finality_conflict<'life0, 'async_trait>( &'life0 self, finality_block_hash: Hash, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Shuts down this node.

fn get_headers<'life0, 'async_trait>( &'life0 self, start_hash: Hash, limit: u64, is_ascending: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcHeader>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests headers between the given start_hash and the current virtual, up to the given limit.

fn get_balance_by_address<'life0, 'async_trait>( &'life0 self, address: Address, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Returns the total balance in unspent transactions towards a given address.

This call is only available when this node was started with --utxoindex.

fn get_balances_by_addresses<'life0, 'async_trait>( &'life0 self, addresses: Vec<Address>, ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcBalancesByAddressesEntry>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_utxos_by_addresses<'life0, 'async_trait>( &'life0 self, addresses: Vec<Address>, ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcUtxosByAddressesEntry>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests all current UTXOs for the given node addresses.

This call is only available when this node was started with --utxoindex.

fn get_sink_blue_score<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Requests the blue score of the current selected parent of the virtual block.

fn ban<'life0, 'async_trait>( &'life0 self, ip: IpAddress, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Bans the given ip.

fn unban<'life0, 'async_trait>( &'life0 self, ip: IpAddress, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Unbans the given ip.

fn get_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetInfoResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Returns info about the node.

fn estimate_network_hashes_per_second<'life0, 'async_trait>( &'life0 self, window_size: u32, start_hash: Option<Hash>, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_mempool_entries_by_addresses<'life0, 'async_trait>( &'life0 self, addresses: Vec<Address>, include_orphan_pool: bool, filter_transaction_pool: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<RpcMempoolEntryByAddress>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_coin_supply<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GetCoinSupplyResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_daa_score_timestamp_estimate<'life0, 'async_trait>( &'life0 self, daa_scores: Vec<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<u64>, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_fee_estimate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RpcFeeEstimate, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_fee_estimate_experimental<'life0, 'async_trait>( &'life0 self, verbose: bool, ) -> Pin<Box<dyn Future<Output = Result<GetFeeEstimateExperimentalResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn get_current_block_color<'life0, 'async_trait>( &'life0 self, hash: Hash, ) -> Pin<Box<dyn Future<Output = Result<GetCurrentBlockColorResponse, RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

fn execute_subscribe_command<'life0, 'async_trait>( &'life0 self, id: u64, scope: Scope, command: Command, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Execute a subscription command leading to either start or stop sending notifications of some type to a listener.

Implementations

impl dyn RpcApi

pub fn is<_T>(&self) -> bool

where _T: Any, dyn RpcApi: Downcast<_T>,

pub fn downcast_ref<_T>(&self) -> Result<&_T, TypeMismatch>

where _T: Any, dyn RpcApi: Downcast<_T>,

pub fn downcast_mut<_T>(&mut self) -> Result<&mut _T, TypeMismatch>

where _T: Any, dyn RpcApi: Downcast<_T>,

pub fn downcast<_T>( self: Box<dyn RpcApi>, ) -> Result<Box<_T>, DowncastError<Box<dyn RpcApi>>>

where _T: Any, dyn RpcApi: Downcast<_T>,

pub fn downcast_rc<_T>( self: Rc<dyn RpcApi>, ) -> Result<Rc<_T>, DowncastError<Rc<dyn RpcApi>>>

where _T: Any, dyn RpcApi: Downcast<_T>,

pub fn downcast_arc<_T>( self: Arc<dyn RpcApi>, ) -> Result<Arc<_T>, DowncastError<Arc<dyn RpcApi>>>

where _T: AnySync, dyn RpcApi: DowncastSync<_T>,

Trait Implementations

impl<_T> Downcast<_T> for dyn RpcApi

where _T: Any,

fn is_type(&self) -> bool

fn downcast_ref(&self) -> Result<&T, TypeMismatch>

fn downcast_mut(&mut self) -> Result<&mut T, TypeMismatch>

fn downcast(self: Box<Self>) -> Result<Box<T>, DowncastError<Box<Self>>>

fn downcast_rc(self: Rc<Self>) -> Result<Rc<T>, DowncastError<Rc<Self>>>

impl<_T> DowncastSync<_T> for dyn RpcApi

where _T: AnySync,

fn downcast_arc(self: Arc<Self>) -> Result<Arc<T>, DowncastError<Arc<Self>>>

Implementors

impl RpcApi for KaspaRpcClient