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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use bindy::{Error, Result};
use chia_bls::SecretKey;
use chia_protocol::{Bytes32, Coin};
use chia_puzzle_types::{EveProof as EveProofRs, LineageProof, Proof as ProofRs};

use crate::{Nft, Program};

#[derive(Clone)]
pub struct Spend {
    pub puzzle: Program,
    pub solution: Program,
}

impl From<Spend> for chia_sdk_driver::Spend {
    fn from(value: Spend) -> Self {
        Self {
            puzzle: value.puzzle.1,
            solution: value.solution.1,
        }
    }
}

#[derive(Clone)]
pub struct Output {
    pub value: Program,
    pub cost: u64,
}

#[derive(Clone)]
pub struct Pair {
    pub first: Program,
    pub rest: Program,
}

#[derive(Clone)]
pub struct CurriedProgram {
    pub program: Program,
    pub args: Vec<Program>,
}

#[derive(Clone)]
pub struct Proof {
    pub parent_parent_coin_info: Bytes32,
    pub parent_inner_puzzle_hash: Option<Bytes32>,
    pub parent_amount: u64,
}

impl Proof {
    pub fn to_lineage_proof(&self) -> Result<Option<LineageProof>> {
        Ok(self.clone().try_into().ok())
    }
}

impl TryFrom<Proof> for LineageProof {
    type Error = Error;

    fn try_from(value: Proof) -> Result<Self> {
        Ok(Self {
            parent_parent_coin_info: value.parent_parent_coin_info,
            parent_inner_puzzle_hash: value
                .parent_inner_puzzle_hash
                .ok_or(Error::MissingParentInnerPuzzleHash)?,
            parent_amount: value.parent_amount,
        })
    }
}

impl From<LineageProof> for Proof {
    fn from(value: LineageProof) -> Self {
        Self {
            parent_parent_coin_info: value.parent_parent_coin_info,
            parent_inner_puzzle_hash: Some(value.parent_inner_puzzle_hash),
            parent_amount: value.parent_amount,
        }
    }
}

impl From<Proof> for ProofRs {
    fn from(value: Proof) -> Self {
        if let Some(parent_inner_puzzle_hash) = value.parent_inner_puzzle_hash {
            Self::Lineage(chia_puzzle_types::LineageProof {
                parent_parent_coin_info: value.parent_parent_coin_info,
                parent_inner_puzzle_hash,
                parent_amount: value.parent_amount,
            })
        } else {
            Self::Eve(EveProofRs {
                parent_parent_coin_info: value.parent_parent_coin_info,
                parent_amount: value.parent_amount,
            })
        }
    }
}

impl From<ProofRs> for Proof {
    fn from(value: ProofRs) -> Self {
        match value {
            ProofRs::Lineage(proof) => Self {
                parent_parent_coin_info: proof.parent_parent_coin_info,
                parent_inner_puzzle_hash: Some(proof.parent_inner_puzzle_hash),
                parent_amount: proof.parent_amount,
            },
            ProofRs::Eve(proof) => Self {
                parent_parent_coin_info: proof.parent_parent_coin_info,
                parent_inner_puzzle_hash: None,
                parent_amount: proof.parent_amount,
            },
        }
    }
}

pub trait LineageProofExt {
    fn to_proof(&self) -> Result<Proof>;
}

impl LineageProofExt for LineageProof {
    fn to_proof(&self) -> Result<Proof> {
        Ok((*self).into())
    }
}

#[derive(Clone)]
pub struct OfferSecurityCoinDetails {
    pub security_coin: Coin,
    pub security_coin_sk: SecretKey,
}

#[derive(Clone)]
pub struct SettlementNftSpendResult {
    pub new_nft: Nft,
    pub security_conditions: Vec<Program>,
}