Trait RpcApi

pub trait RpcApi: Sized {
    // Required method
    fn call<T: for<'a> Deserialize<'a>>(
        &self,
        cmd: &str,
        args: &[Value],
    ) -> Result<T>;

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

Required Methods

fn call<T: for<'a> Deserialize<'a>>( &self, cmd: &str, args: &[Value], ) -> Result<T>

Call a cmd rpc with given args list

Provided Methods

fn get_by_id<T: Queryable<Self>>( &self, id: &<T as Queryable<Self>>::Id, ) -> Result<T>

Query an object implementing Querable type

Examples found in repository

examples/test_against_node.rs (line 38)

fn main_result() -> Result<(), Error> {
    let mut args = std::env::args();

    let _exe_name = args.next().unwrap();

    let url = args.next().expect("Usage: <rpc_url> <username> <password>");
    let user = args.next().expect("no user given");
    let pass = args.next().expect("no pass given");

    let rpc = Client::new(&url, Auth::UserPass(user, pass)).unwrap();

    let _blockchain_info = rpc.get_blockchain_info()?;

    let best_block_hash = rpc.get_best_block_hash()?;
    println!("best block hash: {}", best_block_hash);
    let bestblockcount = rpc.get_block_count()?;
    println!("best block height: {}", bestblockcount);
    let best_block_hash_by_height = rpc.get_block_hash(bestblockcount)?;
    println!("best block hash by height: {}", best_block_hash_by_height);
    assert_eq!(best_block_hash_by_height, best_block_hash);

    let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
    println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
    println!("tx by `get`: {}", bitcoin_tx.txid());

    Ok(())
}

fn get_network_info(&self) -> Result<GetNetworkInfoResult>

fn get_index_info(&self) -> Result<GetIndexInfoResult>

fn version(&self) -> Result<usize>

fn add_multisig_address( &self, nrequired: usize, keys: &[PubKeyOrAddress<'_>], label: Option<&str>, address_type: Option<AddressType>, ) -> Result<AddMultiSigAddressResult>

fn load_wallet(&self, wallet: &str) -> Result<LoadWalletResult>

fn unload_wallet( &self, wallet: Option<&str>, ) -> Result<Option<UnloadWalletResult>>

fn create_wallet( &self, wallet: &str, disable_private_keys: Option<bool>, blank: Option<bool>, passphrase: Option<&str>, avoid_reuse: Option<bool>, ) -> Result<LoadWalletResult>

fn list_wallets(&self) -> Result<Vec<String>>

fn list_wallet_dir(&self) -> Result<Vec<String>>

fn get_wallet_info(&self) -> Result<GetWalletInfoResult>

fn backup_wallet(&self, destination: Option<&str>) -> Result<()>

fn dump_private_key(&self, address: &Address) -> Result<PrivateKey>

fn encrypt_wallet(&self, passphrase: &str) -> Result<()>

fn get_difficulty(&self) -> Result<f64>

fn get_connection_count(&self) -> Result<usize>

fn get_block(&self, hash: &BlockHash) -> Result<Block>

fn get_block_hex(&self, hash: &BlockHash) -> Result<String>

fn get_block_info(&self, hash: &BlockHash) -> Result<GetBlockResult>

fn get_block_header(&self, hash: &BlockHash) -> Result<Header>

fn get_block_header_info( &self, hash: &BlockHash, ) -> Result<GetBlockHeaderResult>

fn get_mining_info(&self) -> Result<GetMiningInfoResult>

fn get_block_template( &self, mode: GetBlockTemplateModes, rules: &[GetBlockTemplateRules], capabilities: &[GetBlockTemplateCapabilities], ) -> Result<GetBlockTemplateResult>

fn get_blockchain_info(&self) -> Result<GetBlockchainInfoResult>

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

Examples found in repository

examples/test_against_node.rs (line 28)

fn main_result() -> Result<(), Error> {
    let mut args = std::env::args();

    let _exe_name = args.next().unwrap();

    let url = args.next().expect("Usage: <rpc_url> <username> <password>");
    let user = args.next().expect("no user given");
    let pass = args.next().expect("no pass given");

    let rpc = Client::new(&url, Auth::UserPass(user, pass)).unwrap();

    let _blockchain_info = rpc.get_blockchain_info()?;

    let best_block_hash = rpc.get_best_block_hash()?;
    println!("best block hash: {}", best_block_hash);
    let bestblockcount = rpc.get_block_count()?;
    println!("best block height: {}", bestblockcount);
    let best_block_hash_by_height = rpc.get_block_hash(bestblockcount)?;
    println!("best block hash by height: {}", best_block_hash_by_height);
    assert_eq!(best_block_hash_by_height, best_block_hash);

    let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
    println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
    println!("tx by `get`: {}", bitcoin_tx.txid());

    Ok(())
}

fn get_block_count(&self) -> Result<u64>

Returns the numbers of block in the longest chain.

Examples found in repository

examples/test_against_node.rs (line 32)

fn main_result() -> Result<(), Error> {
    let mut args = std::env::args();

    let _exe_name = args.next().unwrap();

    let url = args.next().expect("Usage: <rpc_url> <username> <password>");
    let user = args.next().expect("no user given");
    let pass = args.next().expect("no pass given");

    let rpc = Client::new(&url, Auth::UserPass(user, pass)).unwrap();

    let _blockchain_info = rpc.get_blockchain_info()?;

    let best_block_hash = rpc.get_best_block_hash()?;
    println!("best block hash: {}", best_block_hash);
    let bestblockcount = rpc.get_block_count()?;
    println!("best block height: {}", bestblockcount);
    let best_block_hash_by_height = rpc.get_block_hash(bestblockcount)?;
    println!("best block hash by height: {}", best_block_hash_by_height);
    assert_eq!(best_block_hash_by_height, best_block_hash);

    let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
    println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
    println!("tx by `get`: {}", bitcoin_tx.txid());

    Ok(())
}

fn get_best_block_hash(&self) -> Result<BlockHash>

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

Examples found in repository

examples/test_against_node.rs (line 30)

fn main_result() -> Result<(), Error> {
    let mut args = std::env::args();

    let _exe_name = args.next().unwrap();

    let url = args.next().expect("Usage: <rpc_url> <username> <password>");
    let user = args.next().expect("no user given");
    let pass = args.next().expect("no pass given");

    let rpc = Client::new(&url, Auth::UserPass(user, pass)).unwrap();

    let _blockchain_info = rpc.get_blockchain_info()?;

    let best_block_hash = rpc.get_best_block_hash()?;
    println!("best block hash: {}", best_block_hash);
    let bestblockcount = rpc.get_block_count()?;
    println!("best block height: {}", bestblockcount);
    let best_block_hash_by_height = rpc.get_block_hash(bestblockcount)?;
    println!("best block hash by height: {}", best_block_hash_by_height);
    assert_eq!(best_block_hash_by_height, best_block_hash);

    let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
    println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
    println!("tx by `get`: {}", bitcoin_tx.txid());

    Ok(())
}

fn get_block_hash(&self, height: u64) -> Result<BlockHash>

Get block hash at a given height

Examples found in repository

examples/test_against_node.rs (line 34)

fn main_result() -> Result<(), Error> {
    let mut args = std::env::args();

    let _exe_name = args.next().unwrap();

    let url = args.next().expect("Usage: <rpc_url> <username> <password>");
    let user = args.next().expect("no user given");
    let pass = args.next().expect("no pass given");

    let rpc = Client::new(&url, Auth::UserPass(user, pass)).unwrap();

    let _blockchain_info = rpc.get_blockchain_info()?;

    let best_block_hash = rpc.get_best_block_hash()?;
    println!("best block hash: {}", best_block_hash);
    let bestblockcount = rpc.get_block_count()?;
    println!("best block height: {}", bestblockcount);
    let best_block_hash_by_height = rpc.get_block_hash(bestblockcount)?;
    println!("best block hash by height: {}", best_block_hash_by_height);
    assert_eq!(best_block_hash_by_height, best_block_hash);

    let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
    println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
    println!("tx by `get`: {}", bitcoin_tx.txid());

    Ok(())
}

fn get_block_stats(&self, height: u64) -> Result<GetBlockStatsResult>

fn get_block_stats_fields( &self, height: u64, fields: &[BlockStatsFields], ) -> Result<GetBlockStatsResultPartial>

fn get_raw_transaction( &self, txid: &Txid, block_hash: Option<&BlockHash>, ) -> Result<Transaction>

fn get_raw_transaction_hex( &self, txid: &Txid, block_hash: Option<&BlockHash>, ) -> Result<String>

fn get_raw_transaction_info( &self, txid: &Txid, block_hash: Option<&BlockHash>, ) -> Result<GetRawTransactionResult>

fn get_block_filter( &self, block_hash: &BlockHash, ) -> Result<GetBlockFilterResult>

fn get_balance( &self, minconf: Option<usize>, include_watchonly: Option<bool>, ) -> Result<Amount>

fn get_balances(&self) -> Result<GetBalancesResult>

fn get_received_by_address( &self, address: &Address, minconf: Option<u32>, ) -> Result<Amount>

fn get_transaction( &self, txid: &Txid, include_watchonly: Option<bool>, ) -> Result<GetTransactionResult>

fn list_transactions( &self, label: Option<&str>, count: Option<usize>, skip: Option<usize>, include_watchonly: Option<bool>, ) -> Result<Vec<ListTransactionResult>>

fn list_since_block( &self, blockhash: Option<&BlockHash>, target_confirmations: Option<usize>, include_watchonly: Option<bool>, include_removed: Option<bool>, ) -> Result<ListSinceBlockResult>

fn get_tx_out( &self, txid: &Txid, vout: u32, include_mempool: Option<bool>, ) -> Result<Option<GetTxOutResult>>

fn get_tx_out_proof( &self, txids: &[Txid], block_hash: Option<&BlockHash>, ) -> Result<Vec<u8>>

fn import_public_key( &self, pubkey: &PublicKey, label: Option<&str>, rescan: Option<bool>, ) -> Result<()>

fn import_private_key( &self, privkey: &PrivateKey, label: Option<&str>, rescan: Option<bool>, ) -> Result<()>

fn import_address( &self, address: &Address, label: Option<&str>, rescan: Option<bool>, ) -> Result<()>

fn import_address_script( &self, script: &Script, label: Option<&str>, rescan: Option<bool>, p2sh: Option<bool>, ) -> Result<()>

fn import_multi( &self, requests: &[ImportMultiRequest<'_>], options: Option<&ImportMultiOptions>, ) -> Result<Vec<ImportMultiResult>>

fn import_descriptors( &self, req: Vec<ImportDescriptors>, ) -> Result<Vec<ImportMultiResult>>

fn list_descriptors( &self, private: Option<bool>, ) -> Result<ListDescriptorsResult>

fn set_label(&self, address: &Address, label: &str) -> Result<()>

fn key_pool_refill(&self, new_size: Option<usize>) -> Result<()>

fn list_unspent( &self, minconf: Option<usize>, maxconf: Option<usize>, addresses: Option<&[&Address<NetworkChecked>]>, include_unsafe: Option<bool>, query_options: Option<ListUnspentQueryOptions>, ) -> Result<Vec<ListUnspentResultEntry>>

fn lock_unspent(&self, outputs: &[OutPoint]) -> Result<bool>

To unlock, use [unlock_unspent].

fn unlock_unspent(&self, outputs: &[OutPoint]) -> Result<bool>

fn unlock_unspent_all(&self) -> Result<bool>

Unlock all unspent UTXOs.

fn list_received_by_address( &self, address_filter: Option<&Address>, minconf: Option<u32>, include_empty: Option<bool>, include_watchonly: Option<bool>, ) -> Result<Vec<ListReceivedByAddressResult>>

fn create_psbt( &self, inputs: &[CreateRawTransactionInput], outputs: &HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Result<String>

fn create_raw_transaction_hex( &self, utxos: &[CreateRawTransactionInput], outs: &HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Result<String>

fn create_raw_transaction( &self, utxos: &[CreateRawTransactionInput], outs: &HashMap<String, Amount>, locktime: Option<i64>, replaceable: Option<bool>, ) -> Result<Transaction>

fn decode_raw_transaction<R: RawTx>( &self, tx: R, is_witness: Option<bool>, ) -> Result<DecodeRawTransactionResult>

fn fund_raw_transaction<R: RawTx>( &self, tx: R, options: Option<&FundRawTransactionOptions>, is_witness: Option<bool>, ) -> Result<FundRawTransactionResult>

fn sign_raw_transaction<R: RawTx>( &self, tx: R, utxos: Option<&[SignRawTransactionInput]>, private_keys: Option<&[PrivateKey]>, sighash_type: Option<SigHashType>, ) -> Result<SignRawTransactionResult>

👎Deprecated

fn sign_raw_transaction_with_wallet<R: RawTx>( &self, tx: R, utxos: Option<&[SignRawTransactionInput]>, sighash_type: Option<SigHashType>, ) -> Result<SignRawTransactionResult>

fn sign_raw_transaction_with_key<R: RawTx>( &self, tx: R, privkeys: &[PrivateKey], prevtxs: Option<&[SignRawTransactionInput]>, sighash_type: Option<SigHashType>, ) -> Result<SignRawTransactionResult>

fn test_mempool_accept<R: RawTx>( &self, rawtxs: &[R], ) -> Result<Vec<TestMempoolAcceptResult>>

fn stop(&self) -> Result<String>

fn verify_message( &self, address: &Address, signature: &Signature, message: &str, ) -> Result<bool>

fn get_new_address( &self, label: Option<&str>, address_type: Option<AddressType>, ) -> Result<Address<NetworkUnchecked>>

Generate new address under own control

fn get_raw_change_address( &self, address_type: Option<AddressType>, ) -> Result<Address<NetworkUnchecked>>

Generate new address for receiving change

fn get_address_info(&self, address: &Address) -> Result<GetAddressInfoResult>

fn generate_to_address( &self, block_num: u64, address: &Address<NetworkChecked>, ) -> Result<Vec<BlockHash>>

Mine block_num blocks and pay coinbase to address

Returns hashes of the generated blocks

fn generate( &self, block_num: u64, maxtries: Option<u64>, ) -> Result<Vec<BlockHash>>

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

fn invalidate_block(&self, block_hash: &BlockHash) -> Result<()>

Mark a block as invalid by block_hash

fn reconsider_block(&self, block_hash: &BlockHash) -> Result<()>

Mark a block as valid by block_hash

fn get_mempool_info(&self) -> Result<GetMempoolInfoResult>

Returns details on the active state of the TX memory pool

fn get_raw_mempool(&self) -> Result<Vec<Txid>>

Get txids of all transactions in a memory pool

fn get_raw_mempool_verbose( &self, ) -> Result<HashMap<Txid, GetMempoolEntryResult>>

Get details for the transactions in a memory pool

fn get_mempool_entry(&self, txid: &Txid) -> Result<GetMempoolEntryResult>

Get mempool data for given transaction

fn get_chain_tips(&self) -> Result<GetChainTipsResult>

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

fn send_to_address( &self, address: &Address<NetworkChecked>, amount: Amount, comment: Option<&str>, comment_to: Option<&str>, subtract_fee: Option<bool>, replaceable: Option<bool>, confirmation_target: Option<u32>, estimate_mode: Option<EstimateMode>, ) -> Result<Txid>

fn add_node(&self, addr: &str) -> Result<()>

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(&self, addr: &str) -> Result<()>

Attempts to remove a node from the addnode list.

fn onetry_node(&self, addr: &str) -> Result<()>

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

fn disconnect_node(&self, addr: &str) -> Result<()>

Immediately disconnects from the specified peer node.

fn disconnect_node_by_id(&self, node_id: u32) -> Result<()>

fn get_added_node_info( &self, node: Option<&str>, ) -> Result<Vec<GetAddedNodeInfoResult>>

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

fn get_node_addresses( &self, count: Option<usize>, ) -> Result<Vec<GetNodeAddressesResult>>

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

fn list_banned(&self) -> Result<Vec<ListBannedResult>>

List all banned IPs/Subnets.

fn clear_banned(&self) -> Result<()>

Clear all banned IPs.

fn add_ban(&self, subnet: &str, bantime: u64, absolute: bool) -> Result<()>

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

fn remove_ban(&self, subnet: &str) -> Result<()>

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

fn set_network_active(&self, state: bool) -> Result<bool>

Disable/enable all p2p network activity.

fn get_peer_info(&self) -> Result<Vec<GetPeerInfoResult>>

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

fn ping(&self) -> Result<()>

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<R: RawTx>(&self, tx: R) -> Result<Txid>

fn estimate_smart_fee( &self, conf_target: u16, estimate_mode: Option<EstimateMode>, ) -> Result<EstimateSmartFeeResult>

fn wait_for_new_block(&self, timeout: u64) -> Result<BlockRef>

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( &self, blockhash: &BlockHash, timeout: u64, ) -> Result<BlockRef>

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( &self, inputs: &[CreateRawTransactionInput], outputs: &HashMap<String, Amount>, locktime: Option<i64>, options: Option<WalletCreateFundedPsbtOptions>, bip32derivs: Option<bool>, ) -> Result<WalletCreateFundedPsbtResult>

fn wallet_process_psbt( &self, psbt: &str, sign: Option<bool>, sighash_type: Option<SigHashType>, bip32derivs: Option<bool>, ) -> Result<WalletProcessPsbtResult>

fn get_descriptor_info(&self, desc: &str) -> Result<GetDescriptorInfoResult>

fn join_psbt(&self, psbts: &[String]) -> Result<String>

fn combine_psbt(&self, psbts: &[String]) -> Result<String>

fn combine_raw_transaction(&self, hex_strings: &[String]) -> Result<String>

fn finalize_psbt( &self, psbt: &str, extract: Option<bool>, ) -> Result<FinalizePsbtResult>

fn derive_addresses( &self, descriptor: &str, range: Option<[u32; 2]>, ) -> Result<Vec<Address<NetworkUnchecked>>>

fn rescan_blockchain( &self, start_from: Option<usize>, stop_height: Option<usize>, ) -> Result<(usize, Option<usize>)>

fn get_tx_out_set_info( &self, hash_type: Option<TxOutSetHashType>, hash_or_height: Option<HashOrHeight>, use_index: Option<bool>, ) -> Result<GetTxOutSetInfoResult>

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

fn get_net_totals(&self) -> Result<GetNetTotalsResult>

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

fn get_network_hash_ps( &self, nblocks: Option<u64>, height: Option<u64>, ) -> Result<f64>

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

fn uptime(&self) -> Result<u64>

Returns the total uptime of the server in seconds

fn submit_block(&self, block: &Block) -> Result<()>

Submit a block

fn submit_block_bytes(&self, block_bytes: &[u8]) -> Result<()>

Submit a raw block

fn submit_block_hex(&self, block_hex: &str) -> Result<()>

Submit a block as a hex string

fn scan_tx_out_set_blocking( &self, descriptors: &[ScanTxOutRequest], ) -> Result<ScanTxOutResult>

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