chia 0.43.0

A meta-crate that exports all of the Chia crates in the workspace.
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

import pytest
from chia_rs.sized_ints import uint8, uint16
from chia_rs.sized_bytes import bytes32

from chia_rs import (
    G1Element,
    ProofOfSpace,
)


def test_proof_of_space() -> None:
    challenge = b"abababababababababababababababab"

    # version 1
    pos = ProofOfSpace(
        challenge,
        G1Element(),
        None,
        G1Element(),
        uint8(0),
        uint16(1),
        uint8(2),
        uint8(3),
        uint8(4),
        bytes.fromhex("80"),
    )

    buffer = bytes(pos)
    pos2, consumed = ProofOfSpace.parse_rust(buffer)

    assert pos2.version == 0

    assert pos2.plot_index == 0
    assert pos2.meta_group == 0
    assert pos2.strength == 0

    assert pos2.size == 4

    # version 2
    pos = ProofOfSpace(
        challenge,
        G1Element(),
        None,
        G1Element(),
        uint8(1),
        uint16(1),
        uint8(2),
        uint8(3),
        uint8(4),
        bytes.fromhex("80"),
    )

    buffer = bytes(pos)
    pos2, consumed = ProofOfSpace.parse_rust(buffer)

    assert pos2.plot_index == 1
    assert pos2.meta_group == 2
    assert pos2.strength == 3

    assert pos2.size == 0

    # version 2, invalid
    pos = ProofOfSpace(
        challenge,
        None,  ## neither of pool_pk or puzzle hash set
        None,
        G1Element(),
        uint8(1),
        uint16(1),
        uint8(2),
        uint8(3),
        uint8(4),
        bytes.fromhex("80"),
    )
    buffer = bytes(pos)
    with pytest.raises(ValueError, match="Invalid ProofOfSpace"):
        pos2, consumed = ProofOfSpace.parse_rust(buffer)

    pos = ProofOfSpace(
        challenge,
        G1Element(),  # both pool_pk and puzzle hash set
        bytes32.random(),
        G1Element(),
        uint8(1),
        uint16(1),
        uint8(2),
        uint8(3),
        uint8(4),
        bytes.fromhex("80"),
    )
    buffer = bytes(pos)
    with pytest.raises(ValueError, match="Invalid ProofOfSpace"):
        pos2, consumed = ProofOfSpace.parse_rust(buffer)

    pos = ProofOfSpace(
        challenge,
        G1Element(),
        None,
        G1Element(),
        uint8(2),  # invalid version
        uint16(1),
        uint8(2),
        uint8(3),
        uint8(4),
        bytes.fromhex("80"),
    )
    with pytest.raises(ValueError, match="Invalid ProofOfSpace"):
        buffer = bytes(pos)