Trait RpcApi

pub trait RpcApi: Sized {
    // Required method
    fn call<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self,
        method: &'life1 str,
        params: &'life2 [Value],
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
       where T: 'async_trait + for<'de> Deserialize<'de>,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

    // Provided methods
    fn get_by_id<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        id: &'life1 <T as Queryable<Self>>::Id,
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
       where <T as Queryable<Self>>::Id: Sync,
             T: 'async_trait + Queryable<Self>,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_network_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetNetworkInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_index_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetIndexInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn version<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn add_multisig_address<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        nrequired: usize,
        keys: &'life1 [PubKeyOrAddress<'_>],
        label: Option<&'life2 str>,
        address_type: Option<AddressType>,
    ) -> Pin<Box<dyn Future<Output = Result<AddMultiSigAddressResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn load_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self,
        wallet: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn unload_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self,
        wallet: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<UnloadWalletResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn create_wallet<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        wallet: &'life1 str,
        disable_private_keys: Option<bool>,
        blank: Option<bool>,
        passphrase: Option<&'life2 str>,
        avoid_reuse: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn list_wallets<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn list_wallet_dir<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_wallet_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetWalletInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn backup_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self,
        destination: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn dump_private_key<'life0, 'life1, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
    ) -> Pin<Box<dyn Future<Output = Result<PrivateKey>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn encrypt_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self,
        passphrase: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_difficulty<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_connection_count<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<Block>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_block_hex<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_block_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_block_header<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<Header>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_block_header_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockHeaderResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_mining_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetMiningInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block_template<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        mode: GetBlockTemplateModes,
        rules: &'life1 [GetBlockTemplateRules],
        capabilities: &'life2 [GetBlockTemplateCapabilities],
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn get_blockchain_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockchainInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block_count<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_best_block_hash<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block_hash<'life0, 'async_trait>(
        &'life0 self,
        height: u64,
    ) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block_stats<'life0, 'async_trait>(
        &'life0 self,
        height: u64,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockStatsResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_block_stats_fields<'life0, 'life1, 'async_trait>(
        &'life0 self,
        height: u64,
        fields: &'life1 [BlockStatsFields],
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockStatsResultPartial>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_raw_transaction<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
        block_hash: Option<&'life2 BlockHash>,
    ) -> Pin<Box<dyn Future<Output = Result<Transaction>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn get_raw_transaction_hex<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
        block_hash: Option<&'life2 BlockHash>,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn get_raw_transaction_info<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
        block_hash: Option<&'life2 BlockHash>,
    ) -> Pin<Box<dyn Future<Output = Result<GetRawTransactionResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn get_block_filter<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockFilterResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_balance<'life0, 'async_trait>(
        &'life0 self,
        minconf: Option<usize>,
        include_watchonly: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_balances<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetBalancesResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_received_by_address<'life0, 'life1, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
        minconf: Option<u32>,
    ) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_transaction<'life0, 'life1, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
        include_watchonly: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<GetTransactionResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn list_transactions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        label: Option<&'life1 str>,
        count: Option<usize>,
        skip: Option<usize>,
        include_watchonly: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ListTransactionResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn list_since_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        blockhash: Option<&'life1 BlockHash>,
        target_confirmations: Option<usize>,
        include_watchonly: Option<bool>,
        include_removed: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<ListSinceBlockResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_tx_out<'life0, 'life1, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
        vout: u32,
        include_mempool: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<GetTxOutResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_tx_out_proof<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        txids: &'life1 [Txid],
        block_hash: Option<&'life2 BlockHash>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_public_key<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        pubkey: &'life1 PublicKey,
        label: Option<&'life2 str>,
        rescan: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_private_key<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        privkey: &'life1 PrivateKey,
        label: Option<&'life2 str>,
        rescan: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_address<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
        label: Option<&'life2 str>,
        rescan: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_address_script<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        script: &'life1 Script,
        label: Option<&'life2 str>,
        rescan: Option<bool>,
        p2sh: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_multi<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        requests: &'life1 [ImportMultiRequest<'_>],
        options: Option<&'life2 ImportMultiOptions>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportMultiResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn import_descriptors<'life0, 'async_trait>(
        &'life0 self,
        req: ImportDescriptors,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportMultiResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn set_label<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
        label: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn key_pool_refill<'life0, 'async_trait>(
        &'life0 self,
        new_size: Option<usize>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn list_unspent<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        minconf: Option<usize>,
        maxconf: Option<usize>,
        addresses: Option<&'life1 [&'life2 Address<NetworkChecked>]>,
        include_unsafe: Option<bool>,
        query_options: Option<ListUnspentQueryOptions>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ListUnspentResultEntry>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn lock_unspent<'life0, 'life1, 'async_trait>(
        &'life0 self,
        outputs: &'life1 [OutPoint],
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn unlock_unspent<'life0, 'life1, 'async_trait>(
        &'life0 self,
        outputs: &'life1 [OutPoint],
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn unlock_unspent_all<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn list_received_by_address<'life0, 'life1, 'async_trait>(
        &'life0 self,
        address_filter: Option<&'life1 Address>,
        minconf: Option<u32>,
        include_empty: Option<bool>,
        include_watchonly: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ListReceivedByAddressResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn create_psbt<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        inputs: &'life1 [CreateRawTransactionInput],
        outputs: &'life2 HashMap<String, Amount>,
        locktime: Option<i64>,
        replaceable: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn create_raw_transaction_hex<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        utxos: &'life1 [CreateRawTransactionInput],
        outs: &'life2 HashMap<String, Amount>,
        locktime: Option<i64>,
        replaceable: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn create_raw_transaction<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        utxos: &'life1 [CreateRawTransactionInput],
        outs: &'life2 HashMap<String, Amount>,
        locktime: Option<i64>,
        replaceable: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<Transaction>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn decode_raw_transaction<'life0, 'async_trait, R>(
        &'life0 self,
        tx: R,
        is_witness: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<DecodeRawTransactionResult>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn fund_raw_transaction<'life0, 'life1, 'async_trait, R>(
        &'life0 self,
        tx: R,
        options: Option<&'life1 FundRawTransactionOptions>,
        is_witness: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<FundRawTransactionResult>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn sign_raw_transaction<'life0, 'life1, 'life2, 'async_trait, R>(
        &'life0 self,
        tx: R,
        utxos: Option<&'life1 [SignRawTransactionInput]>,
        private_keys: Option<&'life2 [PrivateKey]>,
        sighash_type: Option<SigHashType>,
    ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn sign_raw_transaction_with_wallet<'life0, 'life1, 'async_trait, R>(
        &'life0 self,
        tx: R,
        utxos: Option<&'life1 [SignRawTransactionInput]>,
        sighash_type: Option<SigHashType>,
    ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn sign_raw_transaction_with_key<'life0, 'life1, 'life2, 'async_trait, R>(
        &'life0 self,
        tx: R,
        privkeys: &'life1 [PrivateKey],
        prevtxs: Option<&'life2 [SignRawTransactionInput]>,
        sighash_type: Option<SigHashType>,
    ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn test_mempool_accept<'life0, 'life1, 'async_trait, R>(
        &'life0 self,
        rawtxs: &'life1 [R],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TestMempoolAcceptResult>>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Sync,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn stop<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn verify_message<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
        signature: &'life2 Signature,
        message: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait { ... }
    fn get_new_address<'life0, 'life1, 'async_trait>(
        &'life0 self,
        label: Option<&'life1 str>,
        address_type: Option<AddressType>,
    ) -> Pin<Box<dyn Future<Output = Result<Address<NetworkUnchecked>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_raw_change_address<'life0, 'async_trait>(
        &'life0 self,
        address_type: Option<AddressType>,
    ) -> Pin<Box<dyn Future<Output = Result<Address<NetworkUnchecked>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_address_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        address: &'life1 Address,
    ) -> Pin<Box<dyn Future<Output = Result<GetAddressInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn generate_to_address<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_num: u64,
        address: &'life1 Address<NetworkChecked>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn generate<'life0, 'async_trait>(
        &'life0 self,
        block_num: u64,
        maxtries: Option<u64>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn invalidate_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn reconsider_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_hash: &'life1 BlockHash,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_mempool_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_raw_mempool<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Txid>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_raw_mempool_verbose<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<Txid, GetMempoolEntryResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_mempool_entry<'life0, 'life1, 'async_trait>(
        &'life0 self,
        txid: &'life1 Txid,
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_chain_tips<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetChainTipsResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn send_to_address<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        address: &'life1 Address<NetworkChecked>,
        amount: Amount,
        comment: Option<&'life2 str>,
        comment_to: Option<&'life3 str>,
        subtract_fee: Option<bool>,
        replaceable: Option<bool>,
        confirmation_target: Option<u32>,
        estimate_mode: Option<EstimateMode>,
    ) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait { ... }
    fn add_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn remove_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn onetry_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn disconnect_node<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addr: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn disconnect_node_by_id<'life0, 'async_trait>(
        &'life0 self,
        node_id: u32,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_added_node_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        node: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GetAddedNodeInfoResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_node_addresses<'life0, 'async_trait>(
        &'life0 self,
        count: Option<usize>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GetNodeAddressesResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn list_banned<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ListBannedResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn clear_banned<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn add_ban<'life0, 'life1, 'async_trait>(
        &'life0 self,
        subnet: &'life1 str,
        bantime: u64,
        absolute: bool,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn remove_ban<'life0, 'life1, 'async_trait>(
        &'life0 self,
        subnet: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn set_network_active<'life0, 'async_trait>(
        &'life0 self,
        state: bool,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_peer_info<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GetPeerInfoResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn ping<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn send_raw_transaction<'life0, 'async_trait, R>(
        &'life0 self,
        tx: R,
    ) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>>
       where R: 'async_trait + RawTx + Send,
             Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn estimate_smart_fee<'life0, 'async_trait>(
        &'life0 self,
        conf_target: u16,
        estimate_mode: Option<EstimateMode>,
    ) -> Pin<Box<dyn Future<Output = Result<EstimateSmartFeeResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn wait_for_new_block<'life0, 'async_trait>(
        &'life0 self,
        timeout: u64,
    ) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn wait_for_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        blockhash: &'life1 BlockHash,
        timeout: u64,
    ) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn wallet_create_funded_psbt<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        inputs: &'life1 [CreateRawTransactionInput],
        outputs: &'life2 HashMap<String, Amount>,
        locktime: Option<i64>,
        options: Option<WalletCreateFundedPsbtOptions>,
        bip32derivs: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<WalletCreateFundedPsbtResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn wallet_process_psbt<'life0, 'life1, 'async_trait>(
        &'life0 self,
        psbt: &'life1 str,
        sign: Option<bool>,
        sighash_type: Option<SigHashType>,
        bip32derivs: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<WalletProcessPsbtResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_descriptor_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        desc: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<GetDescriptorInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn join_psbt<'life0, 'life1, 'async_trait>(
        &'life0 self,
        psbts: &'life1 [String],
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn combine_psbt<'life0, 'life1, 'async_trait>(
        &'life0 self,
        psbts: &'life1 [String],
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn combine_raw_transaction<'life0, 'life1, 'async_trait>(
        &'life0 self,
        hex_strings: &'life1 [String],
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn finalize_psbt<'life0, 'life1, 'async_trait>(
        &'life0 self,
        psbt: &'life1 str,
        extract: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<FinalizePsbtResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn derive_addresses<'life0, 'life1, 'async_trait>(
        &'life0 self,
        descriptor: &'life1 str,
        range: Option<[u32; 2]>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Address<NetworkUnchecked>>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn rescan_blockchain<'life0, 'async_trait>(
        &'life0 self,
        start_from: Option<usize>,
        stop_height: Option<usize>,
    ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<usize>)>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_tx_out_set_info<'life0, 'async_trait>(
        &'life0 self,
        hash_type: Option<TxOutSetHashType>,
        hash_or_height: Option<HashOrHeight>,
        use_index: Option<bool>,
    ) -> Pin<Box<dyn Future<Output = Result<GetTxOutSetInfoResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_net_totals<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GetNetTotalsResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn get_network_hash_ps<'life0, 'async_trait>(
        &'life0 self,
        nblocks: Option<u64>,
        height: Option<u64>,
    ) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn uptime<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn submit_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block: &'life1 Block,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn submit_block_bytes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_bytes: &'life1 [u8],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn submit_block_hex<'life0, 'life1, 'async_trait>(
        &'life0 self,
        block_hex: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn scan_tx_out_set_blocking<'life0, 'life1, 'async_trait>(
        &'life0 self,
        descriptors: &'life1 [ScanTxOutRequest],
    ) -> Pin<Box<dyn Future<Output = Result<ScanTxOutResult>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn get_zmq_notifications<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GetZmqNotificationsResult>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
}

Required Methods

fn call<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, method: &'life1 str, params: &'life2 [Value], ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>

where T: 'async_trait + for<'de> Deserialize<'de>, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Call a cmd rpc with given args list

Provided Methods

fn get_by_id<'life0, 'life1, 'async_trait, T>( &'life0 self, id: &'life1 <T as Queryable<Self>>::Id, ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>

where <T as Queryable<Self>>::Id: Sync, T: 'async_trait + Queryable<Self>, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Query an object implementing Querable type

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn add_multisig_address<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, nrequired: usize, keys: &'life1 [PubKeyOrAddress<'_>], label: Option<&'life2 str>, address_type: Option<AddressType>, ) -> Pin<Box<dyn Future<Output = Result<AddMultiSigAddressResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn load_wallet<'life0, 'life1, 'async_trait>( &'life0 self, wallet: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>>

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

fn unload_wallet<'life0, 'life1, 'async_trait>( &'life0 self, wallet: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Option<UnloadWalletResult>>> + Send + 'async_trait>>

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

fn create_wallet<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, wallet: &'life1 str, disable_private_keys: Option<bool>, blank: Option<bool>, passphrase: Option<&'life2 str>, avoid_reuse: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn backup_wallet<'life0, 'life1, 'async_trait>( &'life0 self, destination: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

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

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

fn encrypt_wallet<'life0, 'life1, 'async_trait>( &'life0 self, passphrase: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_block<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<Block>> + Send + 'async_trait>>

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

fn get_block_hex<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

fn get_block_info<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<GetBlockResult>> + Send + 'async_trait>>

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

fn get_block_header<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<Header>> + Send + 'async_trait>>

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

fn get_block_header_info<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<GetBlockHeaderResult>> + Send + 'async_trait>>

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

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_block_template<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, mode: GetBlockTemplateModes, rules: &'life1 [GetBlockTemplateRules], capabilities: &'life2 [GetBlockTemplateCapabilities], ) -> Pin<Box<dyn Future<Output = Result<GetBlockTemplateResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns a data structure containing various state info regarding blockchain processing.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns the numbers of block in the longest chain.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns the hash of the best (tip) block in the longest blockchain.

fn get_block_hash<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get block hash at a given height

fn get_block_stats<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<GetBlockStatsResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_block_stats_fields<'life0, 'life1, 'async_trait>( &'life0 self, height: u64, fields: &'life1 [BlockStatsFields], ) -> Pin<Box<dyn Future<Output = Result<GetBlockStatsResultPartial>> + Send + 'async_trait>>

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

fn get_raw_transaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txid: &'life1 Txid, block_hash: Option<&'life2 BlockHash>, ) -> Pin<Box<dyn Future<Output = Result<Transaction>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_raw_transaction_hex<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txid: &'life1 Txid, block_hash: Option<&'life2 BlockHash>, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_raw_transaction_info<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txid: &'life1 Txid, block_hash: Option<&'life2 BlockHash>, ) -> Pin<Box<dyn Future<Output = Result<GetRawTransactionResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_block_filter<'life0, 'life1, 'async_trait>( &'life0 self, block_hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<GetBlockFilterResult>> + Send + 'async_trait>>

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

fn get_balance<'life0, 'async_trait>( &'life0 self, minconf: Option<usize>, include_watchonly: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_received_by_address<'life0, 'life1, 'async_trait>( &'life0 self, address: &'life1 Address, minconf: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Amount>> + Send + 'async_trait>>

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

fn get_transaction<'life0, 'life1, 'async_trait>( &'life0 self, txid: &'life1 Txid, include_watchonly: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<GetTransactionResult>> + Send + 'async_trait>>

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

fn list_transactions<'life0, 'life1, 'async_trait>( &'life0 self, label: Option<&'life1 str>, count: Option<usize>, skip: Option<usize>, include_watchonly: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ListTransactionResult>>> + Send + 'async_trait>>

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

fn list_since_block<'life0, 'life1, 'async_trait>( &'life0 self, blockhash: Option<&'life1 BlockHash>, target_confirmations: Option<usize>, include_watchonly: Option<bool>, include_removed: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<ListSinceBlockResult>> + Send + 'async_trait>>

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

fn get_tx_out<'life0, 'life1, 'async_trait>( &'life0 self, txid: &'life1 Txid, vout: u32, include_mempool: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Option<GetTxOutResult>>> + Send + 'async_trait>>

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

fn get_tx_out_proof<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, txids: &'life1 [Txid], block_hash: Option<&'life2 BlockHash>, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_public_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, pubkey: &'life1 PublicKey, label: Option<&'life2 str>, rescan: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_private_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, privkey: &'life1 PrivateKey, label: Option<&'life2 str>, rescan: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_address<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, address: &'life1 Address, label: Option<&'life2 str>, rescan: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_address_script<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, script: &'life1 Script, label: Option<&'life2 str>, rescan: Option<bool>, p2sh: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_multi<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, requests: &'life1 [ImportMultiRequest<'_>], options: Option<&'life2 ImportMultiOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportMultiResult>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn import_descriptors<'life0, 'async_trait>( &'life0 self, req: ImportDescriptors, ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportMultiResult>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn set_label<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, address: &'life1 Address, label: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn key_pool_refill<'life0, 'async_trait>( &'life0 self, new_size: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn list_unspent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, minconf: Option<usize>, maxconf: Option<usize>, addresses: Option<&'life1 [&'life2 Address<NetworkChecked>]>, include_unsafe: Option<bool>, query_options: Option<ListUnspentQueryOptions>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ListUnspentResultEntry>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn lock_unspent<'life0, 'life1, 'async_trait>( &'life0 self, outputs: &'life1 [OutPoint], ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

To unlock, use [unlock_unspent].

fn unlock_unspent<'life0, 'life1, 'async_trait>( &'life0 self, outputs: &'life1 [OutPoint], ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Unlock all unspent UTXOs.

fn list_received_by_address<'life0, 'life1, 'async_trait>( &'life0 self, address_filter: Option<&'life1 Address>, minconf: Option<u32>, include_empty: Option<bool>, include_watchonly: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ListReceivedByAddressResult>>> + Send + 'async_trait>>

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

fn create_psbt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, inputs: &'life1 [CreateRawTransactionInput], outputs: &'life2 HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn create_raw_transaction_hex<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, utxos: &'life1 [CreateRawTransactionInput], outs: &'life2 HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn create_raw_transaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, utxos: &'life1 [CreateRawTransactionInput], outs: &'life2 HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<Transaction>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn decode_raw_transaction<'life0, 'async_trait, R>( &'life0 self, tx: R, is_witness: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<DecodeRawTransactionResult>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

fn fund_raw_transaction<'life0, 'life1, 'async_trait, R>( &'life0 self, tx: R, options: Option<&'life1 FundRawTransactionOptions>, is_witness: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<FundRawTransactionResult>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn sign_raw_transaction<'life0, 'life1, 'life2, 'async_trait, R>( &'life0 self, tx: R, utxos: Option<&'life1 [SignRawTransactionInput]>, private_keys: Option<&'life2 [PrivateKey]>, sighash_type: Option<SigHashType>, ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

👎Deprecated

fn sign_raw_transaction_with_wallet<'life0, 'life1, 'async_trait, R>( &'life0 self, tx: R, utxos: Option<&'life1 [SignRawTransactionInput]>, sighash_type: Option<SigHashType>, ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn sign_raw_transaction_with_key<'life0, 'life1, 'life2, 'async_trait, R>( &'life0 self, tx: R, privkeys: &'life1 [PrivateKey], prevtxs: Option<&'life2 [SignRawTransactionInput]>, sighash_type: Option<SigHashType>, ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn test_mempool_accept<'life0, 'life1, 'async_trait, R>( &'life0 self, rawtxs: &'life1 [R], ) -> Pin<Box<dyn Future<Output = Result<Vec<TestMempoolAcceptResult>>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Sync, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn verify_message<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, address: &'life1 Address, signature: &'life2 Signature, message: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn get_new_address<'life0, 'life1, 'async_trait>( &'life0 self, label: Option<&'life1 str>, address_type: Option<AddressType>, ) -> Pin<Box<dyn Future<Output = Result<Address<NetworkUnchecked>>> + Send + 'async_trait>>

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

Generate new address under own control

fn get_raw_change_address<'life0, 'async_trait>( &'life0 self, address_type: Option<AddressType>, ) -> Pin<Box<dyn Future<Output = Result<Address<NetworkUnchecked>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Generate new address for receiving change

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

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

fn generate_to_address<'life0, 'life1, 'async_trait>( &'life0 self, block_num: u64, address: &'life1 Address<NetworkChecked>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>>

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

Mine block_num blocks and pay coinbase to address

Returns hashes of the generated blocks

fn generate<'life0, 'async_trait>( &'life0 self, block_num: u64, maxtries: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Mine up to block_num blocks immediately (before the RPC call returns) to an address in the wallet.

fn invalidate_block<'life0, 'life1, 'async_trait>( &'life0 self, block_hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Mark a block as invalid by block_hash

fn reconsider_block<'life0, 'life1, 'async_trait>( &'life0 self, block_hash: &'life1 BlockHash, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Mark a block as valid by block_hash

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns details on the active state of the TX memory pool

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get txids of all transactions in a memory pool

fn get_raw_mempool_verbose<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<Txid, GetMempoolEntryResult>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get details for the transactions in a memory pool

fn get_mempool_entry<'life0, 'life1, 'async_trait>( &'life0 self, txid: &'life1 Txid, ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResult>> + Send + 'async_trait>>

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

Get mempool data for given transaction

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Get information about all known tips in the block tree, including the main chain as well as stale branches.

fn send_to_address<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, address: &'life1 Address<NetworkChecked>, amount: Amount, comment: Option<&'life2 str>, comment_to: Option<&'life3 str>, subtract_fee: Option<bool>, replaceable: Option<bool>, confirmation_target: Option<u32>, estimate_mode: Option<EstimateMode>, ) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn add_node<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Attempts to add a node to the addnode list. Nodes added using addnode (or -connect) are protected from DoS disconnection and are not required to be full nodes/support SegWit as other outbound peers are (though such peers will not be synced from).

fn remove_node<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Attempts to remove a node from the addnode list.

fn onetry_node<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Attempts to connect to a node without permanently adding it to the addnode list.

fn disconnect_node<'life0, 'life1, 'async_trait>( &'life0 self, addr: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Immediately disconnects from the specified peer node.

fn disconnect_node_by_id<'life0, 'async_trait>( &'life0 self, node_id: u32, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_added_node_info<'life0, 'life1, 'async_trait>( &'life0 self, node: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<GetAddedNodeInfoResult>>> + Send + 'async_trait>>

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

Returns information about the given added node, or all added nodes (note that onetry addnodes are not listed here)

fn get_node_addresses<'life0, 'async_trait>( &'life0 self, count: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<GetNodeAddressesResult>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Return known addresses which can potentially be used to find new nodes in the network

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

List all banned IPs/Subnets.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Clear all banned IPs.

fn add_ban<'life0, 'life1, 'async_trait>( &'life0 self, subnet: &'life1 str, bantime: u64, absolute: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Attempts to add an IP/Subnet to the banned list.

fn remove_ban<'life0, 'life1, 'async_trait>( &'life0 self, subnet: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Attempts to remove an IP/Subnet from the banned list.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Disable/enable all p2p network activity.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns data about each connected network node as an array of [PeerInfo].as_slice()[]

[PeerInfo].as_slice(): net/struct.PeerInfo.html

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Requests that a ping be sent to all other nodes, to measure ping time.

Results provided in getpeerinfo, pingtime and pingwait fields are decimal seconds.

Ping command is handled in queue with all other commands, so it measures processing backlog, not just network ping.

fn send_raw_transaction<'life0, 'async_trait, R>( &'life0 self, tx: R, ) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>>

where R: 'async_trait + RawTx + Send, Self: Sync + 'async_trait, 'life0: 'async_trait,

fn estimate_smart_fee<'life0, 'async_trait>( &'life0 self, conf_target: u16, estimate_mode: Option<EstimateMode>, ) -> Pin<Box<dyn Future<Output = Result<EstimateSmartFeeResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn wait_for_new_block<'life0, 'async_trait>( &'life0 self, timeout: u64, ) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Waits for a specific new block and returns useful info about it. Returns the current block on timeout or exit.

Arguments

1. timeout: Time in milliseconds to wait for a response. 0 indicates no timeout.

fn wait_for_block<'life0, 'life1, 'async_trait>( &'life0 self, blockhash: &'life1 BlockHash, timeout: u64, ) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>>

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

Waits for a specific new block and returns useful info about it. Returns the current block on timeout or exit.

Arguments

1. blockhash: Block hash to wait for.
2. timeout: Time in milliseconds to wait for a response. 0 indicates no timeout.

fn wallet_create_funded_psbt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, inputs: &'life1 [CreateRawTransactionInput], outputs: &'life2 HashMap<String, Amount>, locktime: Option<i64>, options: Option<WalletCreateFundedPsbtOptions>, bip32derivs: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<WalletCreateFundedPsbtResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn wallet_process_psbt<'life0, 'life1, 'async_trait>( &'life0 self, psbt: &'life1 str, sign: Option<bool>, sighash_type: Option<SigHashType>, bip32derivs: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<WalletProcessPsbtResult>> + Send + 'async_trait>>

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

fn get_descriptor_info<'life0, 'life1, 'async_trait>( &'life0 self, desc: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<GetDescriptorInfoResult>> + Send + 'async_trait>>

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

fn join_psbt<'life0, 'life1, 'async_trait>( &'life0 self, psbts: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

fn combine_psbt<'life0, 'life1, 'async_trait>( &'life0 self, psbts: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

fn combine_raw_transaction<'life0, 'life1, 'async_trait>( &'life0 self, hex_strings: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

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

fn finalize_psbt<'life0, 'life1, 'async_trait>( &'life0 self, psbt: &'life1 str, extract: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<FinalizePsbtResult>> + Send + 'async_trait>>

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

fn derive_addresses<'life0, 'life1, 'async_trait>( &'life0 self, descriptor: &'life1 str, range: Option<[u32; 2]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Address<NetworkUnchecked>>>> + Send + 'async_trait>>

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

fn rescan_blockchain<'life0, 'async_trait>( &'life0 self, start_from: Option<usize>, stop_height: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<(usize, Option<usize>)>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

fn get_tx_out_set_info<'life0, 'async_trait>( &'life0 self, hash_type: Option<TxOutSetHashType>, hash_or_height: Option<HashOrHeight>, use_index: Option<bool>, ) -> Pin<Box<dyn Future<Output = Result<GetTxOutSetInfoResult>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns statistics about the unspent transaction output set. Note this call may take some time if you are not using coinstatsindex..await

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns information about network traffic, including bytes in, bytes out, and current time.

fn get_network_hash_ps<'life0, 'async_trait>( &'life0 self, nblocks: Option<u64>, height: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns the estimated network hashes per second based on the last n blocks.

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns the total uptime of the server in seconds

fn submit_block<'life0, 'life1, 'async_trait>( &'life0 self, block: &'life1 Block, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Submit a block

fn submit_block_bytes<'life0, 'life1, 'async_trait>( &'life0 self, block_bytes: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Submit a raw block

fn submit_block_hex<'life0, 'life1, 'async_trait>( &'life0 self, block_hex: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Submit a block as a hex string

fn scan_tx_out_set_blocking<'life0, 'life1, 'async_trait>( &'life0 self, descriptors: &'life1 [ScanTxOutRequest], ) -> Pin<Box<dyn Future<Output = Result<ScanTxOutResult>> + Send + 'async_trait>>

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

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

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Returns information about the active ZeroMQ notifications

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl RpcApi for Client