tlb-ton 0.2.21

Common TL-B types for TON blockchain
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

//! Collection of types to work with currencies
use lazy_static::lazy_static;
use num_bigint::BigUint;
use num_traits::One;
use tlb::{
    bits::{de::BitReaderExt, r#as::VarInt, ser::BitWriterExt},
    de::{CellDeserialize, CellParser, CellParserError},
    r#as::{Data, NoArgs},
    ser::{CellBuilder, CellBuilderError, CellSerialize},
};

use crate::hashmap::HashmapE;

lazy_static! {
    /// 1 gram (nano-TON)
    pub static ref ONE_GRAM: BigUint = BigUint::one();
    /// 1 TON
    pub static ref ONE_TON: BigUint = &*ONE_GRAM * 1_000_000_000u64;
}

/// Alias for `VarUInteger 16`
/// ```tlb
/// nanograms$_ amount:(VarUInteger 16) = Grams;
/// ```
pub type Coins = VarInt<4>;

/// Alias for `VarUInteger 16`
/// ```tlb
/// nanograms$_ amount:(VarUInteger 16) = Grams;
/// ```
pub type Grams = Coins;

/// [`CurrencyCollection`](https://docs.ton.org/develop/data-formats/msg-tlb#currencycollection)
/// ```tlb
/// currencies$_ grams:Grams other:ExtraCurrencyCollection = CurrencyCollection;
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct CurrencyCollection {
    pub grams: BigUint,
    pub other: ExtraCurrencyCollection,
}

impl CellSerialize for CurrencyCollection {
    #[inline]
    fn store(&self, builder: &mut CellBuilder) -> Result<(), CellBuilderError> {
        builder
            .pack_as::<_, &Grams>(&self.grams)?
            .store(&self.other)?;
        Ok(())
    }
}

impl<'de> CellDeserialize<'de> for CurrencyCollection {
    #[inline]
    fn parse(parser: &mut CellParser<'de>) -> Result<Self, CellParserError<'de>> {
        Ok(Self {
            grams: parser.unpack_as::<_, Grams>()?,
            other: parser.parse()?,
        })
    }
}

/// ```tlb
/// extra_currencies$_ dict:(HashmapE 32 (VarUInteger 32)) = ExtraCurrencyCollection;
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ExtraCurrencyCollection(pub HashmapE<BigUint>);

impl CellSerialize for ExtraCurrencyCollection {
    #[inline]
    fn store(&self, builder: &mut CellBuilder) -> Result<(), CellBuilderError> {
        builder.store_as_with::<_, &HashmapE<NoArgs<_, Data<VarInt<32>>>, NoArgs<_>>>(
            &self.0,
            (32, (), ()),
        )?;
        Ok(())
    }
}

impl<'de> CellDeserialize<'de> for ExtraCurrencyCollection {
    #[inline]
    fn parse(parser: &mut CellParser<'de>) -> Result<Self, CellParserError<'de>> {
        Ok(Self(
            parser.parse_as_with::<_, HashmapE<NoArgs<_, Data<VarInt<32>>>, NoArgs<_>>>((
                32,
                (),
                (),
            ))?,
        ))
    }
}

#[cfg(test)]
mod tests {
    use tlb::ser::CellSerializeExt;

    use super::*;

    #[test]
    fn currency_collection_serde() {
        let v = CurrencyCollection::default();

        let cell = v.to_cell().unwrap();
        let got: CurrencyCollection = cell.parse_fully().unwrap();

        assert_eq!(got, v);
    }
}