jlib 0.3.7

A lightweight blockchain lib.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140


#![allow(unused)]

use serde_json::json;
use serde_json::Result;
use std::any::Any;

use std::fmt; //fmt METHOD
use std::marker::PhantomData;
use std::str::FromStr;

use serde::{Deserialize, Serialize, Deserializer};
use serde::de::{self, Visitor, MapAccess};

extern crate void;
use void::Void;

use crate::message::common::command_trait::CommandConversion;
use crate::message::common::meta::*;
use crate::message::common::amount::{Amount, string_or_struct};
use crate::message::tx_flags::*;

use std::error::Error;

#[derive(Serialize, Deserialize, Debug)]
pub struct RequestTxCommand {
    #[serde(rename="id")]
    id: u64,

    #[serde(rename="command")]
    command: String,

    #[serde(rename="transaction")]
    hash: String,
}

impl RequestTxCommand {
    pub fn with_params(hash: String) -> Box<Self> {
        Box::new(
            RequestTxCommand {
                id: 1,
                command: "tx".to_string(),
                hash: hash,
            }
        )
    }
}

impl CommandConversion for RequestTxCommand {
    type T = RequestTxCommand;
    fn to_string(&self) -> Result<String> {
        let j = serde_json::to_string(&self)?;
        Ok(j)
    }

    fn box_to_raw(&self) -> &dyn Any {
        self
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct RequestTxResponse {
    #[serde(rename="Account")]
    pub account: String,

    #[serde(rename="Fee")]
    pub fee: String,

    #[serde(rename="Flags")]
    pub flags: i32,

    #[serde(rename="Sequence")]
    pub sequence: u64,

    #[serde(rename="SigningPubKey")]
    pub signing_pub_key: String,

    #[serde(rename="Timestamp")]
    pub timestamp: u64,

    #[serde(rename="TransactionType")]
    pub transaction_type: String,

    #[serde(rename="TxnSignature")]
    pub txn_signature: String,

    #[serde(rename="date")]
    pub date: u64,

    #[serde(rename="hash")]
    pub hash: String,

    #[serde(rename="inLedger")]
    pub in_ledger: u64,

    #[serde(rename="ledger_index")]
    pub ledger_index: u64,

    #[serde(rename="meta")]
    pub meta: Option<Meta>,

    #[serde(rename="validated")]
    pub validated: bool,

    #[serde(rename="TakerGets")]
    #[serde(deserialize_with = "string_or_struct")]
    pub taker_gets: Amount,

    #[serde(rename="TakerPays")]
    #[serde(deserialize_with = "string_or_struct")]
    pub taker_pays: Amount,

    #[serde(rename="Memos")]
    pub memos: Option<Vec<String>>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct SpecTxSideKick {
    pub error           : String,
    pub error_code      : i32,
    pub error_message   : String,
    pub id              : u32,
    pub request         : RequestTxCommand,
    pub status          : String,

    #[serde(rename="type")]
    pub rtype            : String,
}

impl fmt::Display for SpecTxSideKick {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SpecTxSideKick is here!")
    }
}

impl Error for SpecTxSideKick  {
    fn description(&self) -> &str {
        "I'm SpecTxSideKick side kick"
    }
}