chia-sdk-bindings 0.34.0

Underlying implementation of chia-wallet-sdk bindings.
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 bindy::Result;
use chia_bls::{PublicKey, SecretKey};
use chia_protocol::{Bytes32, Coin};

use crate::{K1PublicKey, K1SecretKey, R1PublicKey, R1SecretKey};

#[derive(Clone)]
pub struct BlsPair {
    pub sk: SecretKey,
    pub pk: PublicKey,
}

impl BlsPair {
    pub fn from_seed(seed: u64) -> Result<Self> {
        Ok(chia_sdk_test::BlsPair::new(seed).into())
    }

    pub fn many_from_seed(seed: u64, count: u32) -> Result<Vec<Self>> {
        let pairs = chia_sdk_test::BlsPair::range_vec_with_seed(seed, count.try_into().unwrap());
        Ok(pairs.into_iter().map(Into::into).collect())
    }
}

impl From<chia_sdk_test::BlsPair> for BlsPair {
    fn from(value: chia_sdk_test::BlsPair) -> Self {
        Self {
            sk: value.sk,
            pk: value.pk,
        }
    }
}
#[derive(Clone)]
pub struct BlsPairWithCoin {
    pub sk: SecretKey,
    pub pk: PublicKey,
    pub puzzle_hash: Bytes32,
    pub coin: Coin,
}

impl From<chia_sdk_test::BlsPairWithCoin> for BlsPairWithCoin {
    fn from(value: chia_sdk_test::BlsPairWithCoin) -> Self {
        Self {
            sk: value.sk,
            pk: value.pk,
            puzzle_hash: value.puzzle_hash,
            coin: value.coin,
        }
    }
}
#[derive(Clone)]
pub struct K1Pair {
    pub sk: K1SecretKey,
    pub pk: K1PublicKey,
}

impl K1Pair {
    pub fn from_seed(seed: u64) -> Result<Self> {
        Ok(chia_sdk_test::K1Pair::new(seed).into())
    }

    pub fn many_from_seed(seed: u64, count: u32) -> Result<Vec<Self>> {
        let pairs = chia_sdk_test::K1Pair::range_vec_with_seed(seed, count.try_into().unwrap());
        Ok(pairs.into_iter().map(Into::into).collect())
    }
}

impl From<chia_sdk_test::K1Pair> for K1Pair {
    fn from(value: chia_sdk_test::K1Pair) -> Self {
        Self {
            sk: K1SecretKey(value.sk),
            pk: K1PublicKey(value.pk),
        }
    }
}
#[derive(Clone)]
pub struct R1Pair {
    pub sk: R1SecretKey,
    pub pk: R1PublicKey,
}

impl R1Pair {
    pub fn from_seed(seed: u64) -> Result<Self> {
        Ok(chia_sdk_test::R1Pair::new(seed).into())
    }

    pub fn many_from_seed(seed: u64, count: u32) -> Result<Vec<Self>> {
        let pairs = chia_sdk_test::R1Pair::range_vec_with_seed(seed, count.try_into().unwrap());
        Ok(pairs.into_iter().map(Into::into).collect())
    }
}

impl From<chia_sdk_test::R1Pair> for R1Pair {
    fn from(value: chia_sdk_test::R1Pair) -> Self {
        Self {
            sk: R1SecretKey(value.sk),
            pk: R1PublicKey(value.pk),
        }
    }
}