Trait core_rpc::RpcApi[−][src]

pub trait RpcApi: Sized {

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

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

    fn get_network_info(&self) -> Result<GetNetworkInfoResult> { ... }

    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<()> { ... }

    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 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<BlockHeader> { ... }

    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_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 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]>, 
        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_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 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> { ... }

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

    fn generate_to_address(
        &self, 
        block_num: u64, 
        address: &Address
    ) -> 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_raw_mempool(&self) -> Result<Vec<Txid>> { ... }

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

    fn get_chain_tips(&self) -> Result<GetChainTipsResult> { ... }

    fn send_to_address(
        &self, 
        address: &Address, 
        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 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 combine_psbt(&self, psbts: &[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>> { ... }

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

    fn get_tx_out_set_info(&self) -> 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 scan_tx_out_set_blocking(
        &self, 
        descriptors: &[ScanTxOutRequest]
    ) -> Result<ScanTxOutResult> { ... }

}

Required methods

Call a cmd rpc with given args list

Provided methods

Query an object implementing Querable type

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

Returns the numbers of block in the longest chain.

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

Get block hash at a given height

To unlock, use [unlock_unspent].

Unlock all unspent UTXOs.

👎 Deprecated

Generate new address under own control

Mine block_num blocks and pay coinbase to address

Returns hashes of the generated blocks

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

Mark a block as invalid by block_hash

Mark a block as valid by block_hash

Get txids of all transactions in a memory pool

[src]

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

Get mempool data for given transaction

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

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

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.

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.

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.

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

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

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

Returns the total uptime of the server in seconds

Implementors