Trait bitcoincore_rpc_async::RpcApi[−][src]

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

#[must_use]    fn get_by_id<'life0, 'life1, 'async_trait, T: Queryable<Self>>(
        &'life0 self, 
        id: &'life1 <T as Queryable<Self>>::Id
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
    where
        T: Sync + Send,
        <T as Queryable<Self>>::Id: Sync + Send,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_network_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetNetworkInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn version<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn add_multisig_address<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self, 
        nrequired: usize, 
        keys: &'life1 [PubKeyOrAddress<'life2>], 
        label: Option<&'life3 str>, 
        address_type: Option<AddressType>
    ) -> Pin<Box<dyn Future<Output = Result<AddMultiSigAddressResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn load_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        wallet: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn unload_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        wallet: Option<&'life1 str>
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn list_wallets<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_wallet_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetWalletInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn backup_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        destination: Option<&'life1 str>
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn dump_private_key<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        address: &'life1 Address
    ) -> Pin<Box<dyn Future<Output = Result<PrivateKey>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn encrypt_wallet<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        passphrase: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_difficulty<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_connection_count<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<Block>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block_hex<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block_info<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block_header<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<BlockHeader>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_mining_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetMiningInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_blockchain_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetBlockchainInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block_count<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_best_block_hash<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_block_hash<'life0, 'async_trait>(
        &'life0 self, 
        height: u64
    ) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_balances<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetBalancesResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn import_multi<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self, 
        requests: &'life1 [ImportMultiRequest<'life2>], 
        options: Option<&'life3 ImportMultiOptions>
    ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportMultiResult>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn key_pool_refill<'life0, 'async_trait>(
        &'life0 self, 
        new_size: Option<usize>
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

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

#[must_use]    fn lock_unspent<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        outputs: &'life1 [OutPoint]
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn unlock_unspent<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        outputs: &'life1 [OutPoint]
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn fund_raw_transaction<'life0, 'life1, 'async_trait, R: RawTx>(
        &'life0 self, 
        tx: R, 
        options: Option<&'life1 FundRawTransactionOptions>, 
        is_witness: Option<bool>
    ) -> Pin<Box<dyn Future<Output = Result<FundRawTransactionResult>> + Send + 'async_trait>>
    where
        R: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn sign_raw_transaction<'life0, 'life1, 'life2, 'async_trait, R: RawTx>(
        &'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: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn sign_raw_transaction_with_wallet<'life0, 'life1, 'async_trait, R: RawTx>(
        &'life0 self, 
        tx: R, 
        utxos: Option<&'life1 [SignRawTransactionInput]>, 
        sighash_type: Option<SigHashType>
    ) -> Pin<Box<dyn Future<Output = Result<SignRawTransactionResult>> + Send + 'async_trait>>
    where
        R: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn sign_raw_transaction_with_key<'life0, 'life1, 'life2, 'async_trait, R: RawTx>(
        &'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: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn test_mempool_accept<'life0, 'life1, 'async_trait, R: RawTx>(
        &'life0 self, 
        rawtxs: &'life1 [R]
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TestMempoolAcceptResult>>> + Send + 'async_trait>>
    where
        R: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn stop<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_address_info<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        address: &'life1 Address
    ) -> Pin<Box<dyn Future<Output = Result<GetAddressInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn generate_to_address<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        block_num: u64, 
        address: &'life1 Address
    ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn invalidate_block<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        block_hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn reconsider_block<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        block_hash: &'life1 BlockHash
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_raw_mempool<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Txid>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_mempool_entry<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        txid: &'life1 Txid
    ) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn send_to_address<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self, 
        address: &'life1 Address, 
        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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_peer_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GetPeerInfoResult>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn ping<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn send_raw_transaction<'life0, 'async_trait, R: RawTx>(
        &'life0 self, 
        tx: R
    ) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>>
    where
        R: Sync + Send,
        R: 'async_trait,
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn wait_for_new_block<'life0, 'async_trait>(
        &'life0 self, 
        timeout: u64
    ) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_descriptor_info<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        desc: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<GetDescriptorInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn combine_psbt<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        psbts: &'life1 [String]
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn derive_addresses<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        descriptor: &'life1 str, 
        range: Option<[u32; 2]>
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Address>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_tx_out_set_info<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetTxOutSetInfoResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn get_net_totals<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<GetNetTotalsResult>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    fn uptime<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }

#[must_use]    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
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: Sync + 'async_trait,
    { ... }
}

Required methods

#[must_use]fn call<'life0, 'life1, 'life2, 'async_trait, T: for<'a> Deserialize<'a>>(
    &'life0 self,
    cmd: &'life1 str,
    args: &'life2 [Value]
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

Call a cmd rpc with given args list

Loading content...

Provided methods

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

Query an object implementing Querable type

#[must_use]fn get_network_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetNetworkInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn version<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn load_wallet<'life0, 'life1, 'async_trait>(
    &'life0 self,
    wallet: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<LoadWalletResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn unload_wallet<'life0, 'life1, 'async_trait>(
    &'life0 self,
    wallet: Option<&'life1 str>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn list_wallets<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_wallet_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetWalletInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn backup_wallet<'life0, 'life1, 'async_trait>(
    &'life0 self,
    destination: Option<&'life1 str>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn dump_private_key<'life0, 'life1, 'async_trait>(
    &'life0 self,
    address: &'life1 Address
) -> Pin<Box<dyn Future<Output = Result<PrivateKey>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn encrypt_wallet<'life0, 'life1, 'async_trait>(
    &'life0 self,
    passphrase: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_difficulty<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<f64>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_connection_count<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_block<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<Block>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_block_hex<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_block_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<GetBlockResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_block_header<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<BlockHeader>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_mining_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetMiningInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_blockchain_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetBlockchainInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn get_block_count<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Returns the numbers of block in the longest chain.

#[must_use]fn get_best_block_hash<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn get_block_hash<'life0, 'async_trait>(
    &'life0 self,
    height: u64
) -> Pin<Box<dyn Future<Output = Result<BlockHash>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Get block hash at a given height

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_balances<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetBalancesResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn key_pool_refill<'life0, 'async_trait>(
    &'life0 self,
    new_size: Option<usize>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

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

To unlock, use [unlock_unspent].

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

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn fund_raw_transaction<'life0, 'life1, 'async_trait, R: RawTx>(
    &'life0 self,
    tx: R,
    options: Option<&'life1 FundRawTransactionOptions>,
    is_witness: Option<bool>
) -> Pin<Box<dyn Future<Output = Result<FundRawTransactionResult>> + Send + 'async_trait>> where
    R: Sync + Send,
    R: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn sign_raw_transaction<'life0, 'life1, 'life2, 'async_trait, R: RawTx>(
    &'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: Sync + Send,
    R: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

👎 Deprecated

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

#[must_use]fn sign_raw_transaction_with_key<'life0, 'life1, 'life2, 'async_trait, R: RawTx>(
    &'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: Sync + Send,
    R: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn stop<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Generate new address under own control

#[must_use]fn get_address_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    address: &'life1 Address
) -> Pin<Box<dyn Future<Output = Result<GetAddressInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn generate_to_address<'life0, 'life1, 'async_trait>(
    &'life0 self,
    block_num: u64,
    address: &'life1 Address
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockHash>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Mine block_num blocks and pay coinbase to address

Returns hashes of the generated blocks

#[must_use]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
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn invalidate_block<'life0, 'life1, 'async_trait>(
    &'life0 self,
    block_hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Mark a block as invalid by block_hash

#[must_use]fn reconsider_block<'life0, 'life1, 'async_trait>(
    &'life0 self,
    block_hash: &'life1 BlockHash
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Mark a block as valid by block_hash

#[must_use]fn get_raw_mempool<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Txid>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Get txids of all transactions in a memory pool

#[must_use]fn get_mempool_entry<'life0, 'life1, 'async_trait>(
    &'life0 self,
    txid: &'life1 Txid
) -> Pin<Box<dyn Future<Output = Result<GetMempoolEntryResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Get mempool data for given transaction

#[must_use]fn send_to_address<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    address: &'life1 Address,
    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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_peer_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<GetPeerInfoResult>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Returns data about each connected network node as an array of PeerInfo

#[must_use]fn ping<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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.

#[must_use]fn send_raw_transaction<'life0, 'async_trait, R: RawTx>(
    &'life0 self,
    tx: R
) -> Pin<Box<dyn Future<Output = Result<Txid>> + Send + 'async_trait>> where
    R: Sync + Send,
    R: 'async_trait,
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]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
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn wait_for_new_block<'life0, 'async_trait>(
    &'life0 self,
    timeout: u64
) -> Pin<Box<dyn Future<Output = Result<BlockRef>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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.

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

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.

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_descriptor_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    desc: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<GetDescriptorInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]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
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

#[must_use]fn get_tx_out_set_info<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetTxOutSetInfoResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Returns statistics about the unspent transaction output set. This call may take some time.

#[must_use]fn get_net_totals<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<GetNetTotalsResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]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
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

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

#[must_use]fn uptime<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Sync + 'async_trait, [src]

Returns the total uptime of the server in seconds

#[must_use]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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, [src]

Loading content...

Implementors

impl RpcApi for Client[src]

fn call<'life0, 'life1, 'life2, 'async_trait, T: for<'a> Deserialize<'a>>(
    &'life0 self,
    cmd: &'life1 str,
    args: &'life2 [Value]
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

Call an cmd rpc with given args list

Loading content...