#![crate_name = "digibyte_rpc_json"]
#![crate_type = "rlib"]
pub extern crate digibyte;
#[allow(unused)]
#[macro_use]
extern crate serde;
extern crate serde_json;
use std::collections::HashMap;
use digibyte::consensus::encode;
use digibyte::hashes::hex::{FromHex, ToHex};
use digibyte::hashes::sha256;
use digibyte::util::{bip158, bip32};
use digibyte::{Address, Amount, PrivateKey, PublicKey, Script, SignedAmount, Transaction};
use serde::de::Error as SerdeError;
use serde::{Deserialize, Serialize};
pub mod serde_hex {
use digibyte::hashes::hex::{FromHex, ToHex};
use serde::de::Error;
use serde::{Deserializer, Serializer};
pub fn serialize<S: Serializer>(b: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&b.to_hex())
}
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
let hex_str: String = ::serde::Deserialize::deserialize(d)?;
Ok(FromHex::from_hex(&hex_str).map_err(D::Error::custom)?)
}
pub mod opt {
use digibyte::hashes::hex::{FromHex, ToHex};
use serde::de::Error;
use serde::{Deserializer, Serializer};
pub fn serialize<S: Serializer>(b: &Option<Vec<u8>>, s: S) -> Result<S::Ok, S::Error> {
match *b {
None => s.serialize_none(),
Some(ref b) => s.serialize_str(&b.to_hex()),
}
}
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Vec<u8>>, D::Error> {
let hex_str: String = ::serde::Deserialize::deserialize(d)?;
Ok(Some(FromHex::from_hex(&hex_str).map_err(D::Error::custom)?))
}
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetNetworkInfoResultNetwork {
pub name: String,
pub limited: bool,
pub reachable: bool,
pub proxy: String,
pub proxy_randomize_credentials: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetNetworkInfoResultAddress {
pub address: String,
pub port: usize,
pub score: usize,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetNetworkInfoResult {
pub version: usize,
pub subversion: String,
#[serde(rename = "protocolversion")]
pub protocol_version: usize,
#[serde(rename = "localservices")]
pub local_services: String,
#[serde(rename = "localrelay")]
pub local_relay: bool,
#[serde(rename = "timeoffset")]
pub time_offset: isize,
pub connections: usize,
pub connections_in: Option<usize>,
pub connections_out: Option<usize>,
#[serde(rename = "networkactive")]
pub network_active: bool,
pub networks: Vec<GetNetworkInfoResultNetwork>,
#[serde(rename = "relayfee", with = "digibyte::util::amount::serde::as_dgb")]
pub relay_fee: Amount,
#[serde(rename = "incrementalfee", with = "digibyte::util::amount::serde::as_dgb")]
pub incremental_fee: Amount,
#[serde(rename = "localaddresses")]
pub local_addresses: Vec<GetNetworkInfoResultAddress>,
pub warnings: String,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AddMultiSigAddressResult {
pub address: Address,
pub redeem_script: Script,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct LoadWalletResult {
pub name: String,
pub warning: Option<String>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetWalletInfoResult {
#[serde(rename = "walletname")]
pub wallet_name: String,
#[serde(rename = "walletversion")]
pub wallet_version: u32,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub balance: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub unconfirmed_balance: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub immature_balance: Amount,
#[serde(rename = "txcount")]
pub tx_count: usize,
#[serde(rename = "keypoololdest")]
pub keypool_oldest: usize,
#[serde(rename = "keypoolsize")]
pub keypool_size: usize,
#[serde(rename = "keypoolsize_hd_internal")]
pub keypool_size_hd_internal: usize,
pub unlocked_until: Option<u64>,
#[serde(rename = "paytxfee", with = "digibyte::util::amount::serde::as_dgb")]
pub pay_tx_fee: Amount,
#[serde(rename = "hdseedid")]
pub hd_seed_id: Option<digibyte::XpubIdentifier>,
pub private_keys_enabled: bool,
pub avoid_reuse: Option<bool>,
pub scanning: Option<ScanningDetails>,
}
#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ScanningDetails {
Scanning {
duration: usize,
progress: f32,
},
NotScanning(bool),
}
impl Eq for ScanningDetails {}
#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetBlockResult {
pub hash: digibyte::BlockHash,
pub confirmations: i32,
pub size: usize,
pub strippedsize: Option<usize>,
pub weight: usize,
pub height: usize,
pub version: i32,
#[serde(default, with = "::serde_hex::opt")]
pub version_hex: Option<Vec<u8>>,
pub merkleroot: digibyte::TxMerkleNode,
pub tx: Vec<digibyte::Txid>,
pub time: usize,
pub mediantime: Option<usize>,
pub nonce: u32,
pub bits: String,
pub difficulty: f64,
#[serde(with = "::serde_hex")]
pub chainwork: Vec<u8>,
pub n_tx: usize,
pub previousblockhash: Option<digibyte::BlockHash>,
pub nextblockhash: Option<digibyte::BlockHash>,
}
#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetBlockHeaderResult {
pub hash: digibyte::BlockHash,
pub confirmations: i32,
pub height: usize,
pub version: i32,
#[serde(default, with = "::serde_hex::opt")]
pub version_hex: Option<Vec<u8>>,
#[serde(rename = "merkleroot")]
pub merkle_root: digibyte::TxMerkleNode,
pub time: usize,
#[serde(rename = "mediantime")]
pub median_time: Option<usize>,
pub nonce: u32,
pub bits: String,
pub difficulty: f64,
#[serde(with = "::serde_hex")]
pub chainwork: Vec<u8>,
pub n_tx: usize,
#[serde(rename = "previousblockhash")]
pub previous_block_hash: Option<digibyte::BlockHash>,
#[serde(rename = "nextblockhash")]
pub next_block_hash: Option<digibyte::BlockHash>,
}
#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetMiningInfoResult {
pub blocks: u32,
#[serde(rename = "currentblockweight")]
pub current_block_weight: Option<u64>,
#[serde(rename = "currentblocktx")]
pub current_block_tx: Option<usize>,
pub difficulty: f64,
#[serde(rename = "networkhashps")]
pub network_hash_ps: f64,
#[serde(rename = "pooledtx")]
pub pooled_tx: usize,
pub chain: String,
pub warnings: String,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetRawTransactionResultVinScriptSig {
pub asm: String,
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
}
impl GetRawTransactionResultVinScriptSig {
pub fn script(&self) -> Result<Script, encode::Error> {
Ok(Script::from(self.hex.clone()))
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetRawTransactionResultVin {
pub sequence: u32,
#[serde(default, with = "::serde_hex::opt")]
pub coinbase: Option<Vec<u8>>,
pub txid: Option<digibyte::Txid>,
pub vout: Option<u32>,
pub script_sig: Option<GetRawTransactionResultVinScriptSig>,
#[serde(default, deserialize_with = "deserialize_hex_array_opt")]
pub txinwitness: Option<Vec<Vec<u8>>>,
}
impl GetRawTransactionResultVin {
pub fn is_coinbase(&self) -> bool {
self.coinbase.is_some()
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetRawTransactionResultVoutScriptPubKey {
pub asm: String,
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
pub req_sigs: Option<usize>,
#[serde(rename = "type")]
pub type_: Option<ScriptPubkeyType>,
pub addresses: Option<Vec<Address>>,
}
impl GetRawTransactionResultVoutScriptPubKey {
pub fn script(&self) -> Result<Script, encode::Error> {
Ok(Script::from(self.hex.clone()))
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetRawTransactionResultVout {
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub value: Amount,
pub n: u32,
pub script_pub_key: GetRawTransactionResultVoutScriptPubKey,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetRawTransactionResult {
#[serde(rename = "in_active_chain")]
pub in_active_chain: Option<bool>,
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
pub txid: digibyte::Txid,
pub hash: digibyte::Wtxid,
pub size: usize,
pub vsize: usize,
pub version: u32,
pub locktime: u32,
pub vin: Vec<GetRawTransactionResultVin>,
pub vout: Vec<GetRawTransactionResultVout>,
pub blockhash: Option<digibyte::BlockHash>,
pub confirmations: Option<u32>,
pub time: Option<usize>,
pub blocktime: Option<usize>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetBlockFilterResult {
pub header: digibyte::FilterHash,
#[serde(with = "::serde_hex")]
pub filter: Vec<u8>,
}
impl GetBlockFilterResult {
pub fn to_filter(&self) -> bip158::BlockFilter {
bip158::BlockFilter::new(&self.filter)
}
pub fn into_filter(self) -> bip158::BlockFilter {
bip158::BlockFilter {
content: self.filter,
}
}
}
impl GetRawTransactionResult {
pub fn is_coinbase(&self) -> bool {
self.vin.len() == 1 && self.vin[0].is_coinbase()
}
pub fn transaction(&self) -> Result<Transaction, encode::Error> {
Ok(encode::deserialize(&self.hex)?)
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Bip125Replaceable {
Yes,
No,
Unknown,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum GetTransactionResultDetailCategory {
Send,
Receive,
Generate,
Immature,
Orphan,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize)]
pub struct GetTransactionResultDetail {
pub address: Option<Address>,
pub category: GetTransactionResultDetailCategory,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub amount: SignedAmount,
pub label: Option<String>,
pub vout: u32,
#[serde(default, with = "digibyte::util::amount::serde::as_dgb::opt")]
pub fee: Option<SignedAmount>,
pub abandoned: Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize)]
pub struct WalletTxInfo {
pub confirmations: i32,
pub blockhash: Option<digibyte::BlockHash>,
pub blockindex: Option<usize>,
pub blocktime: Option<u64>,
pub blockheight: Option<u32>,
pub txid: digibyte::Txid,
pub time: u64,
pub timereceived: u64,
#[serde(rename = "bip125-replaceable")]
pub bip125_replaceable: Bip125Replaceable,
#[serde(rename = "walletconflicts")]
pub wallet_conflicts: Vec<digibyte::Txid>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize)]
pub struct GetTransactionResult {
#[serde(flatten)]
pub info: WalletTxInfo,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub amount: SignedAmount,
#[serde(default, with = "digibyte::util::amount::serde::as_dgb::opt")]
pub fee: Option<SignedAmount>,
pub details: Vec<GetTransactionResultDetail>,
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
}
impl GetTransactionResult {
pub fn transaction(&self) -> Result<Transaction, encode::Error> {
Ok(encode::deserialize(&self.hex)?)
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize)]
pub struct ListTransactionResult {
#[serde(flatten)]
pub info: WalletTxInfo,
#[serde(flatten)]
pub detail: GetTransactionResultDetail,
pub trusted: Option<bool>,
pub comment: Option<String>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize)]
pub struct ListSinceBlockResult {
pub transactions: Vec<ListTransactionResult>,
#[serde(default)]
pub removed: Vec<ListTransactionResult>,
pub lastblock: digibyte::BlockHash,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetTxOutResult {
pub bestblock: digibyte::BlockHash,
pub confirmations: u32,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub value: Amount,
pub script_pub_key: GetRawTransactionResultVoutScriptPubKey,
pub coinbase: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct ListUnspentQueryOptions {
#[serde(
rename = "minimumAmount",
with = "digibyte::util::amount::serde::as_dgb::opt",
skip_serializing_if = "Option::is_none"
)]
pub minimum_amount: Option<Amount>,
#[serde(
rename = "maximumAmount",
with = "digibyte::util::amount::serde::as_dgb::opt",
skip_serializing_if = "Option::is_none"
)]
pub maximum_amount: Option<Amount>,
#[serde(rename = "maximumCount", skip_serializing_if = "Option::is_none")]
pub maximum_count: Option<usize>,
#[serde(
rename = "minimumSumAmount",
with = "digibyte::util::amount::serde::as_dgb::opt",
skip_serializing_if = "Option::is_none"
)]
pub minimum_sum_amount: Option<Amount>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListUnspentResultEntry {
pub txid: digibyte::Txid,
pub vout: u32,
pub address: Option<Address>,
pub label: Option<String>,
pub redeem_script: Option<Script>,
pub witness_script: Option<Script>,
pub script_pub_key: Script,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub amount: Amount,
pub confirmations: u32,
pub spendable: bool,
pub solvable: bool,
#[serde(rename = "desc")]
pub descriptor: Option<String>,
pub safe: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListReceivedByAddressResult {
#[serde(default, rename = "involvesWatchonly")]
pub involved_watch_only: bool,
pub address: Address,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub amount: Amount,
pub confirmations: u32,
pub label: String,
pub txids: Vec<digibyte::Txid>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SignRawTransactionResultError {
pub txid: digibyte::Txid,
pub vout: u32,
pub script_sig: Script,
pub sequence: u32,
pub error: String,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SignRawTransactionResult {
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
pub complete: bool,
pub errors: Option<Vec<SignRawTransactionResultError>>,
}
impl SignRawTransactionResult {
pub fn transaction(&self) -> Result<Transaction, encode::Error> {
Ok(encode::deserialize(&self.hex)?)
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct TestMempoolAcceptResult {
pub txid: digibyte::Txid,
pub allowed: bool,
#[serde(rename = "reject-reason")]
pub reject_reason: Option<String>,
pub vsize: Option<u64>,
pub fees: Option<TestMempoolAcceptResultFees>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct TestMempoolAcceptResultFees {
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub base: Amount,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Bip9SoftforkStatus {
Defined,
Started,
LockedIn,
Active,
Failed,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct Bip9SoftforkStatistics {
pub period: u32,
pub threshold: u32,
pub elapsed: u32,
pub count: u32,
pub possible: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct Bip9SoftforkInfo {
pub status: Bip9SoftforkStatus,
pub bit: Option<u8>,
pub start_time: i64,
pub timeout: u64,
pub since: u32,
pub statistics: Option<Bip9SoftforkStatistics>,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum SoftforkType {
Buried,
Bip9,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct Softfork {
#[serde(rename = "type")]
pub type_: SoftforkType,
pub bip9: Option<Bip9SoftforkInfo>,
pub height: Option<u32>,
pub active: bool,
}
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum ScriptPubkeyType {
Nonstandard,
Pubkey,
PubkeyHash,
ScriptHash,
MultiSig,
NullData,
Witness_v0_KeyHash,
Witness_v0_ScriptHash,
Witness_Unknown,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetAddressInfoResultEmbedded {
pub address: Address,
#[serde(rename = "scriptPubKey")]
pub script_pub_key: Script,
#[serde(rename = "is_script")]
pub is_script: Option<bool>,
#[serde(rename = "is_witness")]
pub is_witness: Option<bool>,
pub witness_version: Option<u32>,
#[serde(with = "::serde_hex")]
pub witness_program: Vec<u8>,
pub script: Option<ScriptPubkeyType>,
#[serde(default, with = "::serde_hex::opt")]
pub hex: Option<Vec<u8>>,
pub pubkeys: Option<Vec<PublicKey>>,
#[serde(rename = "sigsrequired")]
pub n_signatures_required: Option<usize>,
pub pubkey: Option<PublicKey>,
#[serde(rename = "is_compressed")]
pub is_compressed: Option<bool>,
pub label: Option<String>,
#[serde(rename = "hdkeypath")]
pub hd_key_path: Option<bip32::DerivationPath>,
#[serde(rename = "hdseedid")]
pub hd_seed_id: Option<digibyte::XpubIdentifier>,
#[serde(default)]
pub labels: Vec<GetAddressInfoResultLabel>,
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum GetAddressInfoResultLabelPurpose {
Send,
Receive,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum GetAddressInfoResultLabel {
Simple(String),
WithPurpose {
name: String,
purpose: GetAddressInfoResultLabelPurpose,
},
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetAddressInfoResult {
pub address: Address,
#[serde(rename = "scriptPubKey")]
pub script_pub_key: Script,
#[serde(rename = "ismine")]
pub is_mine: Option<bool>,
#[serde(rename = "iswatchonly")]
pub is_watchonly: Option<bool>,
#[serde(rename = "isscript")]
pub is_script: Option<bool>,
#[serde(rename = "iswitness")]
pub is_witness: Option<bool>,
pub witness_version: Option<u32>,
#[serde(default, with = "::serde_hex::opt")]
pub witness_program: Option<Vec<u8>>,
pub script: Option<ScriptPubkeyType>,
#[serde(default, with = "::serde_hex::opt")]
pub hex: Option<Vec<u8>>,
pub pubkeys: Option<Vec<PublicKey>>,
#[serde(rename = "sigsrequired")]
pub n_signatures_required: Option<usize>,
pub pubkey: Option<PublicKey>,
pub embedded: Option<GetAddressInfoResultEmbedded>,
#[serde(rename = "is_compressed")]
pub is_compressed: Option<bool>,
pub timestamp: Option<u64>,
#[serde(rename = "hdkeypath")]
pub hd_key_path: Option<bip32::DerivationPath>,
#[serde(rename = "hdseedid")]
pub hd_seed_id: Option<digibyte::XpubIdentifier>,
pub labels: Vec<GetAddressInfoResultLabel>,
#[deprecated(note = "since Core v0.20.0")]
pub label: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GetBlockchainInfoResult {
pub chain: String,
pub blocks: u64,
pub headers: u64,
#[serde(rename = "bestblockhash")]
pub best_block_hash: digibyte::BlockHash,
pub difficulty: f64,
#[serde(rename = "mediantime")]
pub median_time: u64,
#[serde(rename = "verificationprogress")]
pub verification_progress: f64,
#[serde(rename = "initialblockdownload")]
pub initial_block_download: bool,
#[serde(rename = "chainwork", with = "::serde_hex")]
pub chain_work: Vec<u8>,
pub size_on_disk: u64,
pub pruned: bool,
#[serde(rename = "pruneheight")]
pub prune_height: Option<u64>,
pub automatic_pruning: Option<bool>,
pub prune_target_size: Option<u64>,
#[serde(default)]
pub softforks: HashMap<String, Softfork>,
pub warnings: String,
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum ImportMultiRequestScriptPubkey<'a> {
Address(&'a Address),
Script(&'a Script),
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetMempoolEntryResult {
#[serde(alias = "size")]
pub vsize: u64,
pub weight: Option<u64>,
pub time: u64,
pub height: u64,
#[serde(rename = "descendantcount")]
pub descendant_count: u64,
#[serde(rename = "descendantsize")]
pub descendant_size: u64,
#[serde(rename = "ancestorcount")]
pub ancestor_count: u64,
#[serde(rename = "ancestorsize")]
pub ancestor_size: u64,
pub wtxid: digibyte::Txid,
pub fees: GetMempoolEntryResultFees,
pub depends: Vec<digibyte::Txid>,
#[serde(rename = "spentby")]
pub spent_by: Vec<digibyte::Txid>,
#[serde(rename = "bip125-replaceable")]
pub bip125_replaceable: bool,
pub unbroadcast: Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetMempoolEntryResultFees {
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub base: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub modified: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub ancestor: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub descendant: Amount,
}
impl<'a> serde::Serialize for ImportMultiRequestScriptPubkey<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match *self {
ImportMultiRequestScriptPubkey::Address(ref addr) => {
#[derive(Serialize)]
struct Tmp<'a> {
pub address: &'a Address,
};
serde::Serialize::serialize(
&Tmp {
address: addr,
},
serializer,
)
}
ImportMultiRequestScriptPubkey::Script(script) => {
serializer.serialize_str(&script.as_bytes().to_hex())
}
}
}
}
#[derive(Clone, PartialEq, Eq, Debug, Default, Serialize)]
pub struct ImportMultiRequest<'a> {
pub timestamp: ImportMultiRescanSince,
#[serde(rename = "desc", skip_serializing_if = "Option::is_none")]
pub descriptor: Option<&'a str>,
#[serde(rename = "scriptPubKey", skip_serializing_if = "Option::is_none")]
pub script_pubkey: Option<ImportMultiRequestScriptPubkey<'a>>,
#[serde(rename = "redeemscript", skip_serializing_if = "Option::is_none")]
pub redeem_script: Option<&'a Script>,
#[serde(rename = "witnessscript", skip_serializing_if = "Option::is_none")]
pub witness_script: Option<&'a Script>,
#[serde(skip_serializing_if = "<[_]>::is_empty")]
pub pubkeys: &'a [PublicKey],
#[serde(skip_serializing_if = "<[_]>::is_empty")]
pub keys: &'a [PrivateKey],
#[serde(skip_serializing_if = "Option::is_none")]
pub range: Option<(usize, usize)>,
#[serde(skip_serializing_if = "Option::is_none")]
pub internal: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub watchonly: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub keypool: Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Debug, Default, Deserialize, Serialize)]
pub struct ImportMultiOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub rescan: Option<bool>,
}
#[derive(Clone, PartialEq, Eq, Copy, Debug)]
pub enum ImportMultiRescanSince {
Now,
Timestamp(u64),
}
impl serde::Serialize for ImportMultiRescanSince {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match *self {
ImportMultiRescanSince::Now => serializer.serialize_str("now"),
ImportMultiRescanSince::Timestamp(timestamp) => serializer.serialize_u64(timestamp),
}
}
}
impl<'de> serde::Deserialize<'de> for ImportMultiRescanSince {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::de;
use std::fmt;
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
type Value = ImportMultiRescanSince;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "unix timestamp or 'now'")
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(ImportMultiRescanSince::Timestamp(value))
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
if value == "now" {
Ok(ImportMultiRescanSince::Now)
} else {
Err(de::Error::custom(format!(
"invalid str '{}', expecting 'now' or unix timestamp",
value
)))
}
}
}
deserializer.deserialize_any(Visitor)
}
}
impl Default for ImportMultiRescanSince {
fn default() -> Self {
ImportMultiRescanSince::Timestamp(0)
}
}
impl From<u64> for ImportMultiRescanSince {
fn from(timestamp: u64) -> Self {
ImportMultiRescanSince::Timestamp(timestamp)
}
}
impl From<Option<u64>> for ImportMultiRescanSince {
fn from(timestamp: Option<u64>) -> Self {
timestamp.map_or(ImportMultiRescanSince::Now, ImportMultiRescanSince::Timestamp)
}
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct ImportMultiResultError {
pub code: i64,
pub message: String,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct ImportMultiResult {
pub success: bool,
#[serde(default)]
pub warnings: Vec<String>,
pub error: Option<ImportMultiResultError>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct RejectStatus {
pub status: bool,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct GetPeerInfoResult {
pub id: u64,
pub addr: String,
pub addrbind: String,
pub addrlocal: Option<String>,
pub network: Option<GetPeerInfoResultNetwork>,
pub services: String,
pub relaytxes: bool,
pub lastsend: u64,
pub lastrecv: u64,
pub last_transaction: Option<u64>,
pub last_block: Option<u64>,
pub bytessent: u64,
pub bytesrecv: u64,
pub conntime: u64,
pub timeoffset: i64,
pub pingtime: Option<f64>,
pub minping: Option<f64>,
pub pingwait: Option<f64>,
pub version: u64,
pub subver: String,
pub inbound: bool,
pub addnode: Option<bool>,
pub startingheight: i64,
pub banscore: Option<i64>,
pub synced_headers: i64,
pub synced_blocks: i64,
pub inflight: Vec<u64>,
pub whitelisted: Option<bool>,
#[serde(rename = "minfeefilter", default, with = "digibyte::util::amount::serde::as_dgb::opt")]
pub min_fee_filter: Option<Amount>,
pub bytessent_per_msg: HashMap<String, u64>,
pub bytesrecv_per_msg: HashMap<String, u64>,
pub connection_type: Option<GetPeerInfoResultConnectionType>,
}
#[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "lowercase")]
pub enum GetPeerInfoResultNetwork {
Ipv4,
Ipv6,
Onion,
Unroutable,
}
#[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "kebab-case")]
pub enum GetPeerInfoResultConnectionType {
OutboundFullRelay,
BlockRelayOnly,
Inbound,
Manual,
AddrFetch,
Feeler,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct EstimateSmartFeeResult {
#[serde(
default,
rename = "feerate",
skip_serializing_if = "Option::is_none",
with = "digibyte::util::amount::serde::as_dgb::opt"
)]
pub fee_rate: Option<Amount>,
pub errors: Option<Vec<String>>,
pub blocks: i64,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct BlockRef {
pub hash: digibyte::BlockHash,
pub height: u64,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetDescriptorInfoResult {
pub descriptor: String,
pub checksum: String,
#[serde(rename = "isrange")]
pub is_range: bool,
#[serde(rename = "issolvable")]
pub is_solvable: bool,
#[serde(rename = "hasprivatekeys")]
pub has_private_keys: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct WalletCreateFundedPsbtResult {
pub psbt: String,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub fee: Amount,
#[serde(rename = "changepos")]
pub change_position: i32,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct WalletProcessPsbtResult {
pub psbt: String,
pub complete: bool,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize, Default)]
pub struct WalletCreateFundedPsbtOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub add_inputs: Option<bool>,
#[serde(rename = "changeAddress", skip_serializing_if = "Option::is_none")]
pub change_address: Option<Address>,
#[serde(rename = "changePosition", skip_serializing_if = "Option::is_none")]
pub change_position: Option<u16>,
#[serde(skip_serializing_if = "Option::is_none")]
pub change_type: Option<AddressType>,
#[serde(rename = "includeWatching", skip_serializing_if = "Option::is_none")]
pub include_watching: Option<bool>,
#[serde(rename = "lockUnspents", skip_serializing_if = "Option::is_none")]
pub lock_unspent: Option<bool>,
#[serde(
rename = "feeRate",
skip_serializing_if = "Option::is_none",
with = "digibyte::util::amount::serde::as_dgb::opt"
)]
pub fee_rate: Option<Amount>,
#[serde(rename = "subtractFeeFromOutputs", skip_serializing_if = "Vec::is_empty")]
pub subtract_fee_from_outputs: Vec<u16>,
#[serde(skip_serializing_if = "Option::is_none")]
pub replaceable: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub conf_target: Option<u16>,
#[serde(skip_serializing_if = "Option::is_none")]
pub estimate_mode: Option<EstimateMode>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct FinalizePsbtResult {
pub psbt: Option<String>,
#[serde(default, with = "::serde_hex::opt")]
pub hex: Option<Vec<u8>>,
pub complete: bool,
}
pub type GetChainTipsResult = Vec<GetChainTipsResultTip>;
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetChainTipsResultTip {
pub height: u64,
pub hash: digibyte::BlockHash,
#[serde(rename = "branchlen")]
pub branch_length: usize,
pub status: GetChainTipsResultStatus,
}
#[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "lowercase")]
pub enum GetChainTipsResultStatus {
Invalid,
#[serde(rename = "headers-only")]
HeadersOnly,
#[serde(rename = "valid-headers")]
ValidHeaders,
#[serde(rename = "valid-fork")]
ValidFork,
Active,
}
impl FinalizePsbtResult {
pub fn transaction(&self) -> Option<Result<Transaction, encode::Error>> {
self.hex.as_ref().map(|h| encode::deserialize(h))
}
}
#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[serde(rename_all = "UPPERCASE")]
pub enum EstimateMode {
Unset,
Economical,
Conservative,
}
pub struct SigHashType(digibyte::SigHashType);
impl From<digibyte::SigHashType> for SigHashType {
fn from(sht: digibyte::SigHashType) -> SigHashType {
SigHashType(sht)
}
}
impl serde::Serialize for SigHashType {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(match self.0 {
digibyte::SigHashType::All => "ALL",
digibyte::SigHashType::None => "NONE",
digibyte::SigHashType::Single => "SINGLE",
digibyte::SigHashType::AllPlusAnyoneCanPay => "ALL|ANYONECANPAY",
digibyte::SigHashType::NonePlusAnyoneCanPay => "NONE|ANYONECANPAY",
digibyte::SigHashType::SinglePlusAnyoneCanPay => "SINGLE|ANYONECANPAY",
})
}
}
#[derive(Serialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CreateRawTransactionInput {
pub txid: digibyte::Txid,
pub vout: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub sequence: Option<u32>,
}
#[derive(Serialize, Clone, PartialEq, Eq, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct FundRawTransactionOptions {
#[serde(rename = "add_inputs", skip_serializing_if = "Option::is_none")]
pub add_inputs: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub change_address: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub change_position: Option<u32>,
#[serde(rename = "change_type", skip_serializing_if = "Option::is_none")]
pub change_type: Option<AddressType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub include_watching: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub lock_unspents: Option<bool>,
#[serde(
with = "digibyte::util::amount::serde::as_dgb::opt",
skip_serializing_if = "Option::is_none"
)]
pub fee_rate: Option<Amount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subtract_fee_from_outputs: Option<Vec<u32>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub replaceable: Option<bool>,
#[serde(rename = "conf_target", skip_serializing_if = "Option::is_none")]
pub conf_target: Option<u32>,
#[serde(rename = "estimate_mode", skip_serializing_if = "Option::is_none")]
pub estimate_mode: Option<EstimateMode>,
}
#[derive(Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "camelCase")]
pub struct FundRawTransactionResult {
#[serde(with = "::serde_hex")]
pub hex: Vec<u8>,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub fee: Amount,
#[serde(rename = "changepos")]
pub change_position: i32,
}
#[derive(Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct GetBalancesResultEntry {
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub trusted: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub untrusted_pending: Amount,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub immature: Amount,
}
#[derive(Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "camelCase")]
pub struct GetBalancesResult {
pub mine: GetBalancesResultEntry,
pub watchonly: Option<GetBalancesResultEntry>,
}
impl FundRawTransactionResult {
pub fn transaction(&self) -> Result<Transaction, encode::Error> {
encode::deserialize(&self.hex)
}
}
#[derive(Serialize, Clone, PartialEq, Debug)]
#[serde(rename_all = "camelCase")]
pub struct SignRawTransactionInput {
pub txid: digibyte::Txid,
pub vout: u32,
pub script_pub_key: Script,
#[serde(skip_serializing_if = "Option::is_none")]
pub redeem_script: Option<Script>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
with = "digibyte::util::amount::serde::as_dgb::opt"
)]
pub amount: Option<Amount>,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetTxOutSetInfoResult {
pub height: u64,
#[serde(rename = "bestblock")]
pub best_block: digibyte::BlockHash,
pub transactions: u64,
#[serde(rename = "txouts")]
pub tx_outs: u64,
pub bogosize: u64,
pub hash_serialized_2: sha256::Hash,
pub disk_size: u64,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub total_amount: Amount,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetNetTotalsResult {
#[serde(rename = "totalbytesrecv")]
pub total_bytes_recv: u64,
#[serde(rename = "totalbytessent")]
pub total_bytes_sent: u64,
#[serde(rename = "timemillis")]
pub time_millis: u64,
#[serde(rename = "uploadtarget")]
pub upload_target: GetNetTotalsResultUploadTarget,
}
#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
pub struct GetNetTotalsResultUploadTarget {
#[serde(rename = "timeframe")]
pub time_frame: u64,
pub target: u64,
pub target_reached: bool,
pub serve_historical_blocks: bool,
pub bytes_left_in_cycle: u64,
pub time_left_in_cycle: u64,
}
#[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "kebab-case")]
pub enum AddressType {
Legacy,
P2shSegwit,
Bech32,
}
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub enum PubKeyOrAddress<'a> {
Address(&'a Address),
PubKey(&'a PublicKey),
}
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(untagged)]
pub enum ScanTxOutRequest {
Single(String),
Extended {
desc: String,
range: (u64, u64),
},
}
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
pub struct ScanTxOutResult {
pub success: Option<bool>,
#[serde(rename = "txouts")]
pub tx_outs: Option<u64>,
pub height: Option<u64>,
#[serde(rename = "bestblock")]
pub best_block_hash: Option<digibyte::BlockHash>,
pub unspents: Vec<Utxo>,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub total_amount: digibyte::Amount,
}
#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Utxo {
pub txid: digibyte::Txid,
pub vout: u32,
pub script_pub_key: digibyte::Script,
#[serde(rename = "desc")]
pub descriptor: String,
#[serde(with = "digibyte::util::amount::serde::as_dgb")]
pub amount: digibyte::Amount,
pub height: u64,
}
impl<'a> serde::Serialize for PubKeyOrAddress<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match *self {
PubKeyOrAddress::Address(a) => serde::Serialize::serialize(a, serializer),
PubKeyOrAddress::PubKey(k) => serde::Serialize::serialize(k, serializer),
}
}
}
fn deserialize_hex_array_opt<'de, D>(deserializer: D) -> Result<Option<Vec<Vec<u8>>>, D::Error>
where
D: serde::Deserializer<'de>,
{
let v: Vec<String> = Vec::deserialize(deserializer)?;
let mut res = Vec::new();
for h in v.into_iter() {
res.push(FromHex::from_hex(&h).map_err(D::Error::custom)?);
}
Ok(Some(res))
}