stellar-baselib 0.5.7

A low level Rust library that offers a comprehensive set of functions for reading, writing, hashing, and signing primitive XDR constructs utilized in the Stellar network
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

use crate::{
    asset::{Asset, AssetBehavior},
    operation::{self, Operation},
    xdr,
};

impl Operation {
    /// Creates, updates, or deletes an offer to buy a specific amount of an asset for another
    pub fn manage_buy_offer(
        &self,
        selling: &Asset,
        buying: &Asset,
        buy_amount: i64,
        (n, d): (i32, i32),
        offer_id: i64,
    ) -> Result<xdr::Operation, operation::Error> {
        //
        if buy_amount < 0 {
            return Err(operation::Error::InvalidAmount(buy_amount));
        }
        if n <= 0 || d <= 0 {
            return Err(operation::Error::InvalidPrice(n, d));
        }
        let body = xdr::OperationBody::ManageBuyOffer(xdr::ManageBuyOfferOp {
            selling: selling.to_xdr_object(),
            buying: buying.to_xdr_object(),
            buy_amount,
            price: xdr::Price { n, d },
            offer_id,
        });
        Ok(xdr::Operation {
            source_account: self.source.clone(),
            body,
        })
    }
}

#[cfg(test)]
mod tests {

    use crate::{
        asset::{Asset, AssetBehavior},
        keypair::{Keypair, KeypairBehavior},
        operation::{self, Operation},
        xdr,
    };

    #[test]
    fn test_manage_buy_offer() {
        let selling_issuer = Keypair::random().unwrap().public_key();
        let selling = Asset::new("ABC", Some(&selling_issuer)).unwrap();
        let buying_issuer = Keypair::random().unwrap().public_key();
        let buying = Asset::new("XYZ", Some(&buying_issuer)).unwrap();
        let buy_amount = 38 * operation::ONE;
        let n = 1;
        let d = 2;
        let offer_id = 0;
        let op = Operation::new()
            .manage_buy_offer(&selling, &buying, buy_amount, (n, d), offer_id)
            .unwrap();

        if let xdr::OperationBody::ManageBuyOffer(xdr::ManageBuyOfferOp {
            selling: s,
            buying: b,
            buy_amount: a,
            price: p,
            offer_id: o,
        }) = op.body
        {
            assert_eq!(s, selling.to_xdr_object());
            assert_eq!(b, buying.to_xdr_object());
            assert_eq!(a, buy_amount);
            assert_eq!(p.n, n);
            assert_eq!(p.d, d);
            assert_eq!(o, offer_id);
        } else {
            panic!("Fail")
        }
    }

    #[test]
    fn test_manage_buy_offer_bad_amount() {
        let selling_issuer = Keypair::random().unwrap().public_key();
        let selling = Asset::new("ABC", Some(&selling_issuer)).unwrap();
        let buying_issuer = Keypair::random().unwrap().public_key();
        let buying = Asset::new("XYZ", Some(&buying_issuer)).unwrap();
        let buy_amount = -38 * operation::ONE;
        let n = 1;
        let d = 2;
        let offer_id = 0;
        let op = Operation::new().manage_buy_offer(&selling, &buying, buy_amount, (n, d), offer_id);
        assert_eq!(op.err(), Some(operation::Error::InvalidAmount(buy_amount)));
    }

    #[test]
    fn test_manage_buy_offer_bad_price() {
        let selling_issuer = Keypair::random().unwrap().public_key();
        let selling = Asset::new("ABC", Some(&selling_issuer)).unwrap();
        let buying_issuer = Keypair::random().unwrap().public_key();
        let buying = Asset::new("XYZ", Some(&buying_issuer)).unwrap();
        let buy_amount = 38 * operation::ONE;
        let n = 1;
        let d = 2;
        let offer_id = 0;

        let op =
            Operation::new().manage_buy_offer(&selling, &buying, buy_amount, (-n, d), offer_id);
        assert_eq!(op.err(), Some(operation::Error::InvalidPrice(-n, d)));

        let op =
            Operation::new().manage_buy_offer(&selling, &buying, buy_amount, (-n, -d), offer_id);
        assert_eq!(op.err(), Some(operation::Error::InvalidPrice(-n, -d)));

        let op =
            Operation::new().manage_buy_offer(&selling, &buying, buy_amount, (n, -d), offer_id);
        assert_eq!(op.err(), Some(operation::Error::InvalidPrice(n, -d)));
    }
}