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

use bindy::Result;
use chia_protocol::Bytes32;
use chia_puzzles::PREVENT_MULTIPLE_CREATE_COINS_HASH;
use chia_sdk_driver as sdk;
use chia_sdk_types::{
    Mod,
    puzzles::{Force1of2RestrictedVariable, PreventConditionOpcode, Timelock},
};
use clvm_utils::TreeHash;

#[derive(Clone)]
pub struct Restriction {
    pub kind: RestrictionKind,
    pub puzzle_hash: TreeHash,
}

impl From<Restriction> for sdk::Restriction {
    fn from(value: Restriction) -> Self {
        sdk::Restriction {
            kind: value.kind.into(),
            puzzle_hash: value.puzzle_hash,
        }
    }
}

#[derive(Clone)]
pub enum RestrictionKind {
    MemberCondition,
    DelegatedPuzzleHash,
    DelegatedPuzzleWrapper,
}

impl From<RestrictionKind> for sdk::RestrictionKind {
    fn from(value: RestrictionKind) -> Self {
        match value {
            RestrictionKind::MemberCondition => sdk::RestrictionKind::MemberCondition,
            RestrictionKind::DelegatedPuzzleHash => sdk::RestrictionKind::DelegatedPuzzleHash,
            RestrictionKind::DelegatedPuzzleWrapper => sdk::RestrictionKind::DelegatedPuzzleWrapper,
        }
    }
}

pub(crate) fn convert_restrictions(restrictions: Vec<Restriction>) -> Vec<sdk::Restriction> {
    restrictions.into_iter().map(Into::into).collect()
}

pub fn timelock_restriction(timelock: u64) -> Result<Restriction> {
    Ok(Restriction {
        kind: RestrictionKind::MemberCondition,
        puzzle_hash: Timelock::new(timelock).curry_tree_hash(),
    })
}

pub fn force_1_of_2_restriction(
    left_side_subtree_hash: Bytes32,
    nonce: u32,
    member_validator_list_hash: Bytes32,
    delegated_puzzle_validator_list_hash: Bytes32,
) -> Result<Restriction> {
    Ok(Restriction {
        kind: RestrictionKind::DelegatedPuzzleWrapper,
        puzzle_hash: Force1of2RestrictedVariable::new(
            left_side_subtree_hash,
            nonce.try_into().unwrap(),
            member_validator_list_hash,
            delegated_puzzle_validator_list_hash,
        )
        .curry_tree_hash(),
    })
}

pub fn prevent_condition_opcode_restriction(condition_opcode: u16) -> Result<Restriction> {
    Ok(Restriction {
        kind: RestrictionKind::DelegatedPuzzleWrapper,
        puzzle_hash: PreventConditionOpcode::new(condition_opcode).curry_tree_hash(),
    })
}

pub fn prevent_multiple_create_coins_restriction() -> Result<Restriction> {
    Ok(Restriction {
        kind: RestrictionKind::DelegatedPuzzleWrapper,
        puzzle_hash: PREVENT_MULTIPLE_CREATE_COINS_HASH.into(),
    })
}

pub fn prevent_vault_side_effects_restriction() -> Result<Vec<Restriction>> {
    Ok(vec![
        prevent_condition_opcode_restriction(60)?,
        prevent_condition_opcode_restriction(62)?,
        prevent_condition_opcode_restriction(66)?,
        prevent_condition_opcode_restriction(67)?,
        prevent_multiple_create_coins_restriction()?,
    ])
}