pyonear 0.2.0

Python bindings for NEAR Rust primitives.
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

use crate::{crypto_hash::CryptoHash, hash_enum, quick_struct_boilerplate_core};
use borsh::{BorshDeserialize, BorshSerialize};
use derive_more::{From, Into};
use near_primitives::merkle::{
    Direction as DirectionOriginal, MerklePathItem as MerklePathItemOriginal,
};
use pyo3::prelude::*;
use serde::{Deserialize, Serialize};
use solders_macros::{common_methods, enum_original_mapping, richcmp_eq_only};
use solders_traits::impl_display;

#[pyclass(module = "pyonear.merkle")]
#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[enum_original_mapping(DirectionOriginal)]
pub enum Direction {
    Left,
    Right,
}
hash_enum!(Direction);

#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    BorshSerialize,
    BorshDeserialize,
    Serialize,
    Deserialize,
    From,
    Into,
)]
#[pyclass(module = "pyonear.merkle", subclass)]
pub struct MerklePathItem(pub MerklePathItemOriginal);

#[richcmp_eq_only]
#[common_methods]
#[pymethods]
impl MerklePathItem {
    #[new]
    pub fn new(hash: CryptoHash, direction: Direction) -> Self {
        MerklePathItemOriginal {
            hash: hash.into(),
            direction: direction.into(),
        }
        .into()
    }

    /// CryptoHash: the hash field of the item.
    #[getter]
    pub fn hash(&self) -> CryptoHash {
        self.0.hash.into()
    }

    /// Direction: the direction.
    #[getter]
    pub fn direction(&self) -> Direction {
        self.0.direction.clone().into()
    }
}
impl_display!(MerklePathItem);
quick_struct_boilerplate_core!(MerklePathItem);

pub(crate) fn create_merkle_mod(py: Python<'_>) -> PyResult<&PyModule> {
    let m = PyModule::new(py, "merkle")?;
    m.add_class::<MerklePathItem>()?;
    m.add_class::<Direction>()?;
    Ok(m)
}