celestia-types 1.0.0

Core types, traits and constants for working with the Celestia ecosystem
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

//! Misc types used by uniffi

use bytes::Bytes as RawBytes;
use tendermint::chain::Id as TendermintChainId;
use tendermint::time::Time as TendermintTime;
use uniffi::Record;

use crate::error::UniffiConversionError;

/// Chain identifier (e.g. ‘gaia-9000’)
#[derive(Record)]
pub struct ChainId {
    id: String,
}

impl From<TendermintChainId> for ChainId {
    fn from(value: TendermintChainId) -> Self {
        ChainId {
            id: value.to_string(),
        }
    }
}

impl TryFrom<ChainId> for TendermintChainId {
    type Error = UniffiConversionError;

    fn try_from(value: ChainId) -> Result<Self, Self::Error> {
        TendermintChainId::try_from(value.id)
            .map_err(|_| UniffiConversionError::InvalidChainIdLength)
    }
}

uniffi::custom_type!(TendermintChainId, ChainId, {
    remote,
    try_lift: |value| Ok(value.try_into()?),
    lower: |value| value.into()
});

/// Tendermint timestamp
#[derive(Record)]
pub struct Time {
    ts: i64,
    nanos: u32,
}

impl TryFrom<TendermintTime> for Time {
    type Error = UniffiConversionError;

    fn try_from(value: TendermintTime) -> Result<Self, Self::Error> {
        const NANOSECONDS_IN_SECOND: i128 = 1_000_000_000;
        let ts = value.unix_timestamp_nanos();
        let nanos: u32 = (ts % NANOSECONDS_IN_SECOND)
            .try_into()
            .expect("remainder to fit");
        let ts: i64 = (ts / NANOSECONDS_IN_SECOND)
            .try_into()
            .map_err(|_| UniffiConversionError::TimestampOutOfRange)?;
        Ok(Time { ts, nanos })
    }
}

impl TryFrom<Time> for TendermintTime {
    type Error = UniffiConversionError;

    fn try_from(value: Time) -> Result<Self, Self::Error> {
        let Time { ts, nanos } = value;
        TendermintTime::from_unix_timestamp(ts, nanos)
            .map_err(|_| UniffiConversionError::TimestampOutOfRange)
    }
}

uniffi::custom_type!(TendermintTime, Time, {
    remote,
    try_lift: |value| Ok(value.try_into()?),
    lower: |value| value.try_into().expect("valid data")
});

/// Array of bytes
#[derive(Record)]
pub struct Bytes {
    /// Stored bytes
    bytes: Vec<u8>,
}

impl From<Bytes> for RawBytes {
    fn from(value: Bytes) -> Self {
        value.bytes.into()
    }
}

impl From<RawBytes> for Bytes {
    fn from(value: RawBytes) -> Self {
        Bytes {
            bytes: value.into(),
        }
    }
}

uniffi::custom_type!(RawBytes, Bytes, {
    remote,
    try_lift: |value| Ok(value.into()),
    lower: |value| value.into()
});