jlib 0.0.1

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
141
142
143
144
145
146
147
148
149
150

#![allow(unused)]
#![allow(non_snake_case)]

use std::fmt; //fmt METHOD
use serde::{Deserialize, Serialize};
// use serde::de::{self, Visitor, MapAccess};


////////////////////Flags 相关
// Universal flags can apply to any transaction type
#[derive(Serialize, Deserialize, Debug)]
pub enum Universal {
    FullyCanonicalSig = 0x80000000
}

#[derive(Serialize, Deserialize, Debug)]
pub enum AccountSet {
    RequireDestTag  = 0x00010000,
    OptionalDestTag = 0x00020000,
    RequireAuth     = 0x00040000,
    OptionalAuth    = 0x00080000,
    DisallowSWT     = 0x00100000,
    AllowSWT        = 0x00200000,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum TrustSet {
    SetAuth         =  0x00010000,
    ClearNoSkywell  =  0x00040000,
    SetFreeze       =  0x00100000,
    ClearFreeze     =  0x00200000,

    // NoSkywell       =  0x00020000,
    // SetNoSkywell    =  0x00020000,

    NoSkywell,
    SetNoSkywell,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum OfferCreate {
    Passive             =  0x00010000,
    ImmediateOrCancel   =  0x00020000,
    FillOrKill          =  0x00040000,
    Sell                =  0x00080000,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum Payment {
    NoSkywellDirect  =    0x00010000,
    PartialPayment   =    0x00020000,
    LimitQuality     =    0x00040000,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum RelationSet {
    Authorize   =    0x00000001,
    Freeze      =    0x00000011,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum Flags {
    Universal  { name: Universal   },
    AccountSet { name: AccountSet  },
    TrustSet   { name: TrustSet    },
    OfferCreate{ name: OfferCreate },
    Payment    { name: Payment     },
    RelationSet{ name: RelationSet },
    Other,
}

//Get enum as string
impl fmt::Display for Flags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
        // or, alternatively:
        // fmt::Debug::fmt(self, f)
    }
}

impl Flags {
    pub fn get(&self) -> u32 {
        match *self {
            //Universal
            Flags::Universal { ref name } => {
                 match name {
                     &Universal::FullyCanonicalSig => { Universal::FullyCanonicalSig as u32
                }
            }}

            //AccountSet
            Flags::AccountSet { ref name } => {
                match name {
                    &AccountSet::RequireDestTag  => { AccountSet::RequireDestTag   as u32 },
                    &AccountSet::OptionalDestTag => { AccountSet::OptionalDestTag  as u32 },
                    &AccountSet::RequireAuth     => { AccountSet::RequireAuth      as u32 },
                    &AccountSet::OptionalAuth    => { AccountSet::OptionalAuth     as u32 },
                    &AccountSet::DisallowSWT     => { AccountSet::DisallowSWT      as u32 },
                    &AccountSet::AllowSWT        => { AccountSet::AllowSWT         as u32 },
                }
            }

            //TrustSet
            Flags::TrustSet { ref name } => {
                match name {
                    &TrustSet::SetAuth         =>  { TrustSet::SetAuth         as u32 },
                    &TrustSet::ClearNoSkywell  =>  { TrustSet::ClearNoSkywell  as u32 },
                    &TrustSet::SetFreeze       =>  { TrustSet::SetFreeze       as u32 },
                    &TrustSet::ClearFreeze     =>  { TrustSet::ClearFreeze     as u32 },

                    // NoSkywell       =>  { TrustSet::NoSkywell       as i32 },
                    // SetNoSkywell    =>  { TrustSet::SetNoSkywell    as i32 },
                    &TrustSet::NoSkywell       =>  { 0x00020000    as u32 },
                    &TrustSet::SetNoSkywell    =>  { 0x00020000    as u32 },
                }
            }

            //OfferCreate
            Flags::OfferCreate { ref name } => {
                match name {
                    &OfferCreate::Passive             =>  { OfferCreate::Passive              as u32 },
                    &OfferCreate::ImmediateOrCancel   =>  { OfferCreate::ImmediateOrCancel    as u32 },
                    &OfferCreate::FillOrKill          =>  { OfferCreate::FillOrKill           as u32 },
                    &OfferCreate::Sell                =>  { OfferCreate::Sell                 as u32 },
                }
            }

            //Payment
            Flags::Payment { ref name } => {
                match name {
                    &Payment::NoSkywellDirect  =>  { Payment::NoSkywellDirect      as u32 },
                    &Payment::PartialPayment   =>  { Payment::PartialPayment       as u32 },
                    &Payment::LimitQuality     =>  { Payment::LimitQuality         as u32 },
                }
            }

            //RelationSet
            Flags::RelationSet { ref name } => {
                match name {
                    &RelationSet::Authorize   =>  { RelationSet::Authorize      as u32 },
                    &RelationSet::Freeze      =>  { RelationSet::Freeze         as u32 },
                }
            }

            Flags::Other => { 0 as u32 },

            _ => 0,
        }
    }
}