chia-pos2 0.4.2

A library for creating plots, validating proofs of space, farming partial proofs and solving proofs. Using Chia proof of space v2
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266

#pragma once

#include <cstdint>
#include <span>
#include <stdexcept>

#include "BlakeHash.hpp"
#include "ProofConstants.hpp"
#include "ProofCore.hpp"
#include "ProofParams.hpp"
#include "aes/AesHash.hpp"

// A simple structure to hold the result of a pairing computation.
struct PairingResult {
    uint32_t match_info_result; // Always present.
    uint64_t meta_result; // Valid if out_num_meta_bits != 0.
    uint32_t test_result; // Valid if num_test_bits != 0.
};

class ProofHashing {
public:
    // Constructor.
    // proof_params: a ProofParams instance.
    ProofHashing(ProofParams const& proof_params)
        : params_(proof_params)
        , aes_(proof_params.get_plot_id_bytes(), static_cast<int>(proof_params.get_k()))
    {
    }

    // Returns a single hash value computed from x.
    uint32_t g(uint32_t x);

    // Computes and returns the matching target using the Blake hash.
    // table_id: used as salt, match_key, meta: additional parameters.
    // num_target_bits: the number of bits to return from the hash.
    uint32_t matching_target(
        uint32_t table_id, uint32_t match_key, uint64_t meta, int num_target_bits);

    PairingResult pairing_t1(uint64_t meta_l,
        uint64_t meta_r,
        int num_match_info_bits,
        int out_num_meta_bits,
        int num_test_bits);
    PairingResult pairing_t2(uint64_t meta_l,
        uint64_t meta_r,
        int num_match_info_bits,
        int out_num_meta_bits,
        int num_test_bits);
    PairingResult pairing_t3(uint64_t meta_l, uint64_t meta_r, int num_test_bits);

    std::array<uint64_t, NUM_CHAIN_LINKS> chainingChallengeWithPlotIdHash(
        std::span<uint8_t const, 32> const challenge) const
    {
        std::array<uint64_t, NUM_CHAIN_LINKS> result;

        uint32_t block_words[16];
        uint8_t const* plot_id_bytes = params_.get_plot_id_bytes();
        // Fill the first 8 words with the plot ID.

        // set data from plot id
        for (int i = 0; i < 8; i++) {
            block_words[i] = (static_cast<uint32_t>(plot_id_bytes[i * 4 + 0]))
                | (static_cast<uint32_t>(plot_id_bytes[i * 4 + 1]) << 8)
                | (static_cast<uint32_t>(plot_id_bytes[i * 4 + 2]) << 16)
                | (static_cast<uint32_t>(plot_id_bytes[i * 4 + 3]) << 24);
        }
        // set data from challenge
        for (int i = 0; i < 8; i++) {
            block_words[i + 8] = (static_cast<uint32_t>(challenge[i * 4 + 0]))
                | (static_cast<uint32_t>(challenge[i * 4 + 1]) << 8)
                | (static_cast<uint32_t>(challenge[i * 4 + 2]) << 16)
                | (static_cast<uint32_t>(challenge[i * 4 + 3]) << 24);
        }

        auto blake = BlakeHash::hash_block_256(block_words);
        result[0] = blake.r[0] + ((uint64_t)blake.r[1] << 32);
        result[1] = blake.r[2] + ((uint64_t)blake.r[3] << 32);
        result[2] = blake.r[4] + ((uint64_t)blake.r[5] << 32);
        result[3] = blake.r[6] + ((uint64_t)blake.r[7] << 32);

        // do hashes for rest of chain links
        assert(NUM_CHAIN_LINKS % 4 == 0);
        for (int c = 1; c < NUM_CHAIN_LINKS / 4; c++) {
            // set up block words (note: first 8 words are still from plot id)
            for (int i = 0; i < 8; i++) {
                block_words[i + 8] = blake.r[i];
            }
            blake = BlakeHash::hash_block_256(block_words);
            result[c * 4 + 0] = blake.r[0] + ((uint64_t)blake.r[1] << 32);
            result[c * 4 + 1] = blake.r[2] + ((uint64_t)blake.r[3] << 32);
            result[c * 4 + 2] = blake.r[4] + ((uint64_t)blake.r[5] << 32);
            result[c * 4 + 3] = blake.r[6] + ((uint64_t)blake.r[7] << 32);
        }

        return result;
    }

    BlakeHash::Result256 challengeWithPlotIdHash(std::span<uint8_t const, 32> const challenge) const
    {
        uint32_t block_words[16];
        std::array<uint8_t, 32> plot_id = params_.get_plot_id();
        // Fill the first 8 words with the plot ID.

        // set data from plot id
        for (int i = 0; i < 8; i++) {
            block_words[i] = (static_cast<uint32_t>(plot_id[i * 4 + 0]))
                | (static_cast<uint32_t>(plot_id[i * 4 + 1]) << 8)
                | (static_cast<uint32_t>(plot_id[i * 4 + 2]) << 16)
                | (static_cast<uint32_t>(plot_id[i * 4 + 3]) << 24);
        }
        // set data from challenge
        for (int i = 0; i < 8; i++) {
            block_words[i + 8] = (static_cast<uint32_t>(challenge[i * 4 + 0]))
                | (static_cast<uint32_t>(challenge[i * 4 + 1]) << 8)
                | (static_cast<uint32_t>(challenge[i * 4 + 2]) << 16)
                | (static_cast<uint32_t>(challenge[i * 4 + 3]) << 24);
        }

        return BlakeHash::hash_block_256(block_words);
    }

    uint64_t chain_hash(uint64_t input) const
    {
#if HAVE_AES
        return aes_.chain<false>(input);
#else
        return aes_.chain<true>(input);
#endif
    }

private:
    ProofParams params_;
    AesHash aes_;
};

inline uint32_t mask32(int const bits) { return numeric_cast<uint32_t>((uint64_t(1) << bits) - 1); }

//
// -------------------------
// Member function definitions
// -------------------------
//

inline uint32_t ProofHashing::g(uint32_t x)
{
    if (params_.is_testnet()) {
        x ^= TESTNET_G_XOR_CONST;
    }
#if HAVE_AES
    return aes_.g_x<false>(x);
#else
    return aes_.g_x<true>(x);
#endif
}

inline uint32_t ProofHashing::matching_target(
    uint32_t table_id, uint32_t match_key, uint64_t meta, int num_target_bits)
{
    // T1 get's extra hashing rounds based on strength.
    int const extra_rounds_bits = (table_id == 1) ? (params_.get_strength() - 2) : 0;
#if HAVE_AES
    return aes_.matching_target<false>(table_id, match_key, meta, extra_rounds_bits)
        & mask32(num_target_bits);
#else
    return aes_.matching_target<true>(
               static_cast<uint32_t>(table_id), match_key, meta, extra_rounds_bits)
        & mask32(num_target_bits);
#endif
}

inline PairingResult ProofHashing::pairing_t1(uint64_t meta_l,
    uint64_t meta_r,
    int num_match_info_bits,
    int out_num_meta_bits,
    int num_test_bits)
{
    assert(num_match_info_bits > 0 && num_match_info_bits <= 32);
    assert(out_num_meta_bits > 0 && out_num_meta_bits <= 64);
    assert(num_test_bits > 0 && num_test_bits <= 32);

    // T1 get's extra hashing rounds based on strength.
    int const extra_rounds_bits = params_.get_strength() - 2;
#if HAVE_AES
    AesHash::Result128 res = aes_.pairing<false>(meta_l, meta_r, extra_rounds_bits);
#else
    AesHash::Result128 res = aes_.pairing<true>(meta_l, meta_r, extra_rounds_bits);
#endif

    PairingResult pr = { 0, 0, 0 };

    if (num_match_info_bits == 32)
        pr.match_info_result = res.r[0];
    else if (num_match_info_bits < 32)
        pr.match_info_result = res.r[0] & mask32(num_match_info_bits);
    else {
        throw std::invalid_argument("num_match_info_bits > 32 not supported");
    }

    if (out_num_meta_bits == 64)
        pr.meta_result = res.r[1] + (static_cast<uint64_t>(res.r[2]) << 32);
    else if (out_num_meta_bits < 64)
        pr.meta_result = (res.r[1] + (static_cast<uint64_t>(res.r[2]) << 32))
            & ((1ULL << out_num_meta_bits) - 1);
    else {
        throw std::invalid_argument("num_bits_meta > 64 not supported");
    }

    uint32_t test_result = res.r[3] & mask32(num_test_bits);
    pr.test_result = test_result;
    return pr;
}

inline PairingResult ProofHashing::pairing_t2(uint64_t meta_l,
    uint64_t meta_r,
    int num_match_info_bits,
    int out_num_meta_bits,
    int num_test_bits)
{
    assert(num_match_info_bits > 0 && num_match_info_bits <= 32);
    assert(out_num_meta_bits > 0 && out_num_meta_bits <= 64);
    assert(num_test_bits >= 0 && num_test_bits <= 32);
#if HAVE_AES
    AesHash::Result128 res = aes_.pairing<false>(meta_l, meta_r);
#else
    AesHash::Result128 res = aes_.pairing<true>(meta_l, meta_r);
#endif

    PairingResult pr = { 0, 0, 0 };

    if (num_match_info_bits == 32)
        pr.match_info_result = res.r[0];
    else if (num_match_info_bits < 32)
        pr.match_info_result = res.r[0] & mask32(num_match_info_bits);
    else {
        throw std::invalid_argument("num_match_info_bits > 32 not supported");
    }

    if (out_num_meta_bits == 64)
        pr.meta_result = res.r[1] + (static_cast<uint64_t>(res.r[2]) << 32);
    else if (out_num_meta_bits < 64)
        pr.meta_result = (res.r[1] + (static_cast<uint64_t>(res.r[2]) << 32))
            & ((1ULL << out_num_meta_bits) - 1);
    else {
        throw std::invalid_argument("num_bits_meta > 64 not supported");
    }

    uint32_t test_result = res.r[3] & mask32(num_test_bits);
    pr.test_result = test_result;
    return pr;
}

inline PairingResult ProofHashing::pairing_t3(uint64_t meta_l, uint64_t meta_r, int num_test_bits)
{
    assert(num_test_bits >= 0 && num_test_bits <= 32);
#if HAVE_AES
    AesHash::Result128 res = aes_.pairing<false>(meta_l, meta_r);
#else
    AesHash::Result128 res = aes_.pairing<true>(meta_l, meta_r);
#endif

    PairingResult pr = { 0, 0, 0 };

    uint32_t test_result = res.r[3] & mask32(num_test_bits);
    pr.test_result = test_result;
    return pr;
}