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

use celestia_proto::tendermint_celestia_mods::types::Data as RawData;
#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
use js_sys::Uint8Array;
use serde::{Deserialize, Serialize};
use tendermint_proto::Protobuf;
#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
use wasm_bindgen::prelude::*;

use crate::Error;

/// Data contained in a [`Block`].
///
/// [`Block`]: crate::block::Block
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(try_from = "RawData", into = "RawData")]
#[cfg_attr(
    all(target_arch = "wasm32", feature = "wasm-bindgen"),
    wasm_bindgen(getter_with_clone)
)]
pub struct Data {
    /// Transactions.
    #[cfg_attr(
        all(target_arch = "wasm32", feature = "wasm-bindgen"),
        wasm_bindgen(skip)
    )]
    pub txs: Vec<Vec<u8>>,

    /// Square width of original data square.
    pub square_size: u64,

    /// Hash is the root of a binary Merkle tree where the leaves of the tree are
    /// the row and column roots of an extended data square. Hash is often referred
    /// to as the "data root".
    pub hash: Vec<u8>,
}

#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
#[wasm_bindgen]
impl Data {
    /// Transactions
    #[wasm_bindgen(getter)]
    pub fn transactions(&self) -> Vec<Uint8Array> {
        self.txs
            .iter()
            .map(|tx| Uint8Array::from(&tx[..]))
            .collect()
    }
}

impl Protobuf<RawData> for Data {}

impl TryFrom<RawData> for Data {
    type Error = Error;

    fn try_from(value: RawData) -> Result<Self, Self::Error> {
        Ok(Data {
            txs: value.txs,
            square_size: value.square_size,
            hash: value.hash,
        })
    }
}

impl From<Data> for RawData {
    fn from(value: Data) -> RawData {
        RawData {
            txs: value.txs,
            square_size: value.square_size,
            hash: value.hash,
        }
    }
}

#[cfg(feature = "uniffi")]
mod uniffi_types {
    use super::Data as BlockData;

    // we need to rename `Data`, otherwise it clashes with `Foundation::Data` for Swift
    #[uniffi::remote(Record)]
    pub struct BlockData {
        /// Transactions.
        pub txs: Vec<Vec<u8>>,

        /// Square width of original data square.
        pub square_size: u64,

        /// Hash is the root of a binary Merkle tree where the leaves of the tree are
        /// the row and column roots of an extended data square. Hash is often referred
        /// to as the "data root".
        pub hash: Vec<u8>,
    }
}