stellar-base 0.7.0

Low level Stellar types
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

use crate::asset::Asset;
use crate::error::{Error, Result};
use crate::xdr;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LiquidityPoolId(Vec<u8>);

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LiquidityPoolConstantFeeParameters {
    assets: (Asset, Asset),
    fee: i32,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LiquidityPoolParameters {
    ConstantFee(LiquidityPoolConstantFeeParameters),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LiquidityPoolConstantFee {
    assets: (Asset, Asset),
    fee: i32,
    reserves: (i64, i64),
    total_pool_shares: i64,
    pool_shares_trust_line_count: i64,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LiquidityPool {
    ConstantFee(LiquidityPoolConstantFee),
}

impl LiquidityPoolId {
    /// Returns a new liquidity pool id, or Error if the hash length is not 32 bytes.
    pub fn new(hash: Vec<u8>) -> Result<Self> {
        if hash.len() != 32 {
            return Err(Error::InvalidLiquidityPoolIdLength);
        }

        Ok(Self(hash))
    }

    /// Retrieves the liquidity pool id bytes.
    pub fn as_bytes(&self) -> &[u8] {
        &self.0
    }

    /// Returns the xdr object.
    pub fn to_xdr(&self) -> xdr::PoolId {
        xdr::PoolId(self.0.as_slice().try_into().unwrap())
    }

    /// Creates from the xdr object.
    pub fn from_xdr(x: &xdr::PoolId) -> Result<Self> {
        Ok(Self(x.0 .0.to_vec()))
    }
}

impl LiquidityPoolConstantFeeParameters {
    /// Returns the xdr object.
    pub fn to_xdr(&self) -> Result<xdr::LiquidityPoolConstantProductParameters> {
        Ok(xdr::LiquidityPoolConstantProductParameters {
            asset_a: self.assets.0.to_xdr()?,
            asset_b: self.assets.1.to_xdr()?,
            fee: self.fee,
        })
    }

    pub fn from_xdr(x: &xdr::LiquidityPoolConstantProductParameters) -> Result<Self> {
        let asset_a = Asset::from_xdr(&x.asset_a)?;
        let asset_b = Asset::from_xdr(&x.asset_b)?;
        Ok(Self {
            assets: (asset_a, asset_b),
            fee: x.fee,
        })
    }
}

impl LiquidityPoolParameters {
    pub fn to_xdr(&self) -> Result<xdr::LiquidityPoolParameters> {
        match self {
            LiquidityPoolParameters::ConstantFee(ref params) => {
                let params_xdr = params.to_xdr()?;
                Ok(xdr::LiquidityPoolParameters::LiquidityPoolConstantProduct(
                    params_xdr,
                ))
            }
        }
    }

    pub fn from_xdr(x: &xdr::LiquidityPoolParameters) -> Result<Self> {
        match *x {
            xdr::LiquidityPoolParameters::LiquidityPoolConstantProduct(ref constant_params) => {
                let params = LiquidityPoolConstantFeeParameters::from_xdr(constant_params)?;
                Ok(Self::ConstantFee(params))
            }
        }
    }
}