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

//
// 挂单
//
extern crate ws;
use ws::{connect, CloseCode};
use std::rc::Rc;
use std::cell::Cell;
use serde_json::{Value};

use crate::misc::config::*;
use crate::message::transaction::offer_create::*;
use crate::message::common::command_trait::CommandConversion;
use crate::message::common::amount::Amount;
use crate::api::query::account_info::*;
use crate::message::transaction::local_sign_tx::LocalSignTx;
use crate::base::misc::util::{downcast_to_string,downcast_to_usize};

use crate::base::local_sign::sign_tx::{SignTx};
use OfferType;

pub trait CreateOfferI {
    fn create_offer<F>(&self, offer_type: OfferType, taker_gets: Amount, taker_pays: Amount, op: F)
    where F: Fn(Result<OfferCreateTxResponse, OfferCreateSideKick>);
}

pub struct CreateOffer {
    pub config: Box<Rc<Config>>,
    pub account: String,
    pub secret: String,
}
impl CreateOffer {
        pub fn with_params(config: Box<Rc<Config>>, account: String, secret: String) -> Self {
        CreateOffer {
            config  : config,
            account : account,
            secret  : secret,
        }
    }

    pub fn get_account_seq(&self) -> u32 {
        let seq_rc = Rc::new(Cell::new(0u64));

        let acc = String::from(self.account.as_str());
        AccountInfo::new().request_account_info(self.config.clone(), acc, |x| match x {
            Ok(response) => {
                let seq = seq_rc.clone();
                seq.set(response.sequence);
            },
            Err(_) => { }
        });

       downcast_to_usize(seq_rc)
    }
}

impl CreateOfferI for CreateOffer {
    fn create_offer<F>(&self, offer_type: OfferType, taker_gets: Amount, taker_pays: Amount, op: F)
    where F: Fn(Result<OfferCreateTxResponse, OfferCreateSideKick>) {

        let info = Rc::new(Cell::new("".to_string()));

        let account_rc = Rc::new(Cell::new(String::from(self.account.as_str())));
        let secret_rc  = Rc::new(Cell::new(String::from(self.secret.as_str())));

        let offer_type_rc = Rc::new(Cell::new(offer_type.get()));
        let taker_gets_rc = Rc::new(Cell::new(taker_gets));
        let taker_pays_rc = Rc::new(Cell::new(taker_pays));

        connect(self.config.addr, |out| {
            let copy = info.clone();

            let account = account_rc.clone();
            let secret = secret_rc.clone();

            let offer_type = offer_type_rc.clone();
            let taker_gets = taker_gets_rc.clone();
            let taker_pays = taker_pays_rc.clone();

            let tx_json = OfferCreateTxJson::new(account.take(), offer_type.take(), taker_gets.take(), taker_pays.take());
            if self.config.local_sign {
                let seq = self.get_account_seq();
                let blob = SignTx::with_params(seq, &secret.take()).create_offer(&tx_json);
                if let Ok(command) = LocalSignTx::new(blob).to_string() {
                    out.send(command).unwrap()
                }
            } else {
                if let Ok(command) = OfferCreateTx::new(secret.take(), tx_json).to_string() {
                    out.send(command).unwrap()
                }
            }

            move |msg: ws::Message| {
                let c = msg.as_text()?;
                copy.set(c.to_string());

                out.close(CloseCode::Normal)
            }

        }).unwrap();

        let resp = downcast_to_string(info);
        if let Ok(x) = serde_json::from_str(&resp) as Result<Value, serde_json::error::Error> {
            let status = x["status"].to_string();
            if status == "\"success\"" {
                let x: String = x["result"].to_string();
                if let Ok(v) = serde_json::from_str(&x) as Result<OfferCreateTxResponse, serde_json::error::Error> {
                    op(Ok(v))
                }
            } else {
                if let Ok(v) = serde_json::from_str(&x.to_string()) as Result<OfferCreateSideKick, serde_json::error::Error> {
                    op(Err(v))
                }
            }
        }

    }
}