vrsc-rpc-json 0.0.3

a wrapper for RPC responses in JSON for Verus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::{collections::HashMap, str::FromStr};

use bitcoin::Txid;
use serde::de::{Deserialize, Deserializer};
use vrsc::Address;

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Identity {
    pub identity: InnerIdentity,
    pub status: String,
    pub canspendfor: bool,
    pub cansignfor: bool,
    pub blockheight: i64,
    pub txid: String, // TODO hash
    pub vout: u32,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InnerIdentity {
    pub version: u16,
    pub flags: u16,
    pub primaryaddresses: Vec<Address>,
    pub minimumsignatures: u16,
    pub name: String,
    pub identityaddress: Address,
    pub parent: Address,
    pub systemid: Address,
    pub contentmap: HashMap<String, String>,
    pub revocationauthority: Address,
    pub recoveryauthority: Address,
    pub privateaddress: Option<String>,
    pub timelock: u64,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct NameCommitment {
    pub txid: Txid,
    pub namereservation: NameReservation,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct NameReservation {
    pub name: String,
    pub salt: String,
    pub version: u8,
    // if no refferal was given, the response is an empty string.
    #[serde(deserialize_with = "object_empty_as_none")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub referral: Option<Address>,
    pub parent: String,
    pub nameid: Address,
}

pub fn object_empty_as_none<'de, D>(deserializer: D) -> Result<Option<Address>, D::Error>
where
    D: Deserializer<'de>,
{
    let s = String::deserialize(deserializer)?;
    if s.is_empty() {
        return Ok(None);
    } else {
        return Ok(Some(
            Address::from_str(&s).expect("a valid Verus i, b, or R address"),
        ));
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct MarketplaceOffer {
    pub identityid: Address,
    pub price: f64,
    pub offer: Offer,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Offer {
    pub accept: OfferVariant,
    pub offer: OfferVariant,
    pub blockexpiry: u64,
    pub txid: Txid,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum OfferVariant {
    CurrencyOffer(HashMap<String, f64>),
    IdentityOffer(IdentityOffer),
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct IdentityOffer {
    pub name: String,
    pub identityid: Address,
    pub systemid: Address,
    pub original: u8,
}