chia 0.9.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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

from typing import List, Optional

import string
import chia_rs
from chia.types.blockchain_format.program import Program as ChiaProgram
from chia.types.blockchain_format.serialized_program import SerializedProgram
from random import Random


def rand_bytes(rnd: Random) -> bytes:
    size = rnd.randint(0, 4)
    ret = bytearray()
    for _ in range(size):
        ret.append(rnd.getrandbits(8))
    return bytes(ret)


def rand_string(rnd: Random) -> str:
    size = rnd.randint(1, 10)
    return "".join(rnd.choices(string.ascii_uppercase + string.digits, k=size))


def rand_int(rnd: Random) -> int:
    return rnd.randint(0, 100000000000000)


def rand_list(rnd: Random) -> List:
    size = rnd.randint(0, 3)
    ret = []
    for _ in range(size):
        ret.append(rand_object(rnd))
    return ret


def rand_program(rnd: Random) -> ChiaProgram:
    return ChiaProgram.from_bytes(b"\xff\x01\xff\x04\x01")


def rand_rust_program(rnd: Random) -> chia_rs.Program:
    return chia_rs.Program.from_bytes(b"\xff\x01\xff\x04\x01")


def rand_optional(rnd: Random) -> Optional[object]:
    if rnd.randint(0, 1) == 0:
        return None
    return rand_object(rnd)


def rand_object(rnd: Random) -> object:
    types = [
        rand_optional,
        rand_int,
        rand_string,
        rand_bytes,
        rand_program,
        rand_list,
        rand_rust_program,
    ]
    return rnd.sample(types, 1)[0](rnd)


def recursive_replace(o: object) -> object:
    if isinstance(o, list):
        ret = []
        for i in o:
            ret.append(recursive_replace(i))
        return ret
    elif isinstance(o, chia_rs.Program):
        return SerializedProgram.from_bytes(o.to_bytes())
    else:
        return o


def test_run_program() -> None:

    rust_identity = chia_rs.Program.from_bytes(b"\x01")
    py_identity = SerializedProgram.from_bytes(b"\x01")

    rnd = Random()
    for _ in range(10000):
        args = rand_object(rnd)

        # the python SerializedProgram treats itself specially, the rust
        # Program treats itself specially, but they don't recognize each other,
        # so they will produce different results in this regard
        rust_ret = rust_identity._run(10000, 0, args)

        # Replace rust Program with the python SerializedProgram.
        args = recursive_replace(args)

        py_ret = py_identity._run(10000, 0, args)

        assert rust_ret == py_ret


def test_tree_hash() -> None:

    rnd = Random()
    for _ in range(10000):
        py_prg = ChiaProgram.to(rand_object(rnd))
        rust_prg = chia_rs.Program.from_bytes(bytes(py_prg))

        assert py_prg.get_tree_hash() == rust_prg.get_tree_hash()


def test_uncurry() -> None:

    rnd = Random()
    for _ in range(10000):
        py_prg = ChiaProgram.to(rand_object(rnd))
        py_prg = py_prg.curry(rand_object(rnd))
        rust_prg = chia_rs.Program.from_program(py_prg)
        assert py_prg.uncurry() == rust_prg.uncurry()

        py_prg = py_prg.curry(rand_object(rnd), rand_object(rnd))
        rust_prg = chia_rs.Program.from_program(py_prg)
        assert py_prg.uncurry() == rust_prg.uncurry()


def test_round_trip() -> None:

    rnd = Random()
    for _ in range(10000):
        obj = rand_object(rnd)
        py_prg = ChiaProgram.to(obj)
        rust_prg = chia_rs.Program.from_program(py_prg)
        rust_prg2 = chia_rs.Program.to(obj)

        assert py_prg == rust_prg.to_program()
        assert py_prg == rust_prg2.to_program()

        assert bytes(py_prg) == bytes(rust_prg)
        assert bytes(py_prg) == bytes(rust_prg2)