Line data Source code
1 : // Copyright (c) 2019-2025 The Dash Core developers
2 : // Distributed under the MIT software license, see the accompanying
3 : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 :
5 : #include <bls/bls.h>
6 : #include <bls/bls_batchverifier.h>
7 : #include <util/helpers.h>
8 :
9 : #include <clientversion.h>
10 : #include <random.h>
11 : #include <streams.h>
12 : #include <util/strencodings.h>
13 :
14 : #include <boost/test/unit_test.hpp>
15 :
16 146 : BOOST_AUTO_TEST_SUITE(bls_tests)
17 :
18 2 : void FuncSign(const bool legacy_scheme)
19 : {
20 2 : bls::bls_legacy_scheme.store(legacy_scheme);
21 :
22 2 : CBLSSecretKey sk1, sk2;
23 2 : sk1.MakeNewKey();
24 2 : sk2.MakeNewKey();
25 :
26 2 : uint256 msgHash1 = uint256::ONE;
27 2 : uint256 msgHash2 = uint256::TWO;
28 :
29 2 : auto sig1 = sk1.Sign(msgHash1, legacy_scheme);
30 2 : auto sig2 = sk2.Sign(msgHash1, legacy_scheme);
31 2 : BOOST_CHECK(sig1.VerifyInsecure(sk1.GetPublicKey(), msgHash1));
32 2 : BOOST_CHECK(!sig1.VerifyInsecure(sk1.GetPublicKey(), msgHash2));
33 2 : BOOST_CHECK(!sig2.VerifyInsecure(sk1.GetPublicKey(), msgHash1));
34 2 : BOOST_CHECK(!sig2.VerifyInsecure(sk2.GetPublicKey(), msgHash2));
35 2 : BOOST_CHECK(sig2.VerifyInsecure(sk2.GetPublicKey(), msgHash1));
36 :
37 : return;
38 2 : }
39 :
40 2 : void FuncSerialize(const bool legacy_scheme)
41 : {
42 2 : bls::bls_legacy_scheme.store(legacy_scheme);
43 :
44 2 : CBLSSecretKey sk;
45 2 : CDataStream ds2(SER_DISK, CLIENT_VERSION), ds3(SER_DISK, CLIENT_VERSION);
46 2 : uint256 msgHash = uint256::ONE;
47 :
48 2 : sk.MakeNewKey();
49 2 : CBLSSignature sig1 = sk.Sign(msgHash, legacy_scheme);
50 2 : ds2 << sig1;
51 2 : ds3 << CBLSSignatureVersionWrapper(const_cast<CBLSSignature&>(sig1), !legacy_scheme);
52 :
53 2 : CBLSSignature sig2;
54 2 : ds2 >> sig2;
55 2 : BOOST_CHECK(sig1 == sig2);
56 :
57 2 : CBLSSignature sig3;
58 2 : ds3 >> CBLSSignatureVersionWrapper(const_cast<CBLSSignature&>(sig3), !legacy_scheme);
59 2 : BOOST_CHECK(sig1 == sig3);
60 :
61 : return;
62 2 : }
63 :
64 2 : void FuncSetHexStr(const bool legacy_scheme)
65 : {
66 2 : bls::bls_legacy_scheme.store(legacy_scheme);
67 :
68 : // Note: 2nd bool argument for SetHexStr for bls::PrivateKey has a meaning modOrder, not is-legacy
69 2 : CBLSSecretKey sk;
70 2 : std::string strValidSecret = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
71 : // Note: invalid string passed to SetHexStr() should cause it to fail and reset key internal data
72 2 : BOOST_CHECK(sk.SetHexStr(strValidSecret, false));
73 2 : BOOST_CHECK(!sk.SetHexStr("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1g", false)); // non-hex
74 2 : BOOST_CHECK(!sk.IsValid());
75 2 : BOOST_CHECK(sk == CBLSSecretKey());
76 : // Try few more invalid strings
77 2 : BOOST_CHECK(sk.SetHexStr(strValidSecret, false));
78 2 : BOOST_CHECK(!sk.SetHexStr("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e", false)); // hex but too short
79 2 : BOOST_CHECK(!sk.IsValid());
80 2 : BOOST_CHECK(sk.SetHexStr(strValidSecret, false));
81 2 : BOOST_CHECK(
82 : !sk.SetHexStr("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20", false)); // hex but too long
83 2 : BOOST_CHECK(!sk.IsValid());
84 :
85 : return;
86 2 : }
87 :
88 2 : void FuncKeyAgg(const bool legacy_scheme)
89 : {
90 2 : bls::bls_legacy_scheme.store(legacy_scheme);
91 :
92 2 : CBLSSecretKey sk1, sk2;
93 2 : sk1.MakeNewKey();
94 2 : sk2.MakeNewKey();
95 :
96 2 : CBLSPublicKey ag_pk = sk1.GetPublicKey();
97 2 : ag_pk.AggregateInsecure(sk2.GetPublicKey());
98 :
99 2 : CBLSSecretKey ag_sk = sk1;
100 2 : ag_sk.AggregateInsecure(sk2);
101 :
102 2 : BOOST_CHECK(ag_pk == ag_sk.GetPublicKey());
103 :
104 2 : uint256 msgHash1 = uint256::ONE;
105 2 : uint256 msgHash2 = uint256::TWO;
106 :
107 2 : auto sig = ag_sk.Sign(msgHash1, legacy_scheme);
108 2 : BOOST_CHECK(sig.VerifyInsecure(ag_pk, msgHash1));
109 2 : BOOST_CHECK(!sig.VerifyInsecure(ag_pk, msgHash2));
110 2 : }
111 :
112 2 : void FuncKeyAggVec(const bool legacy_scheme)
113 : {
114 2 : bls::bls_legacy_scheme.store(legacy_scheme);
115 :
116 2 : std::vector<CBLSSecretKey> vec_sk;
117 2 : std::vector<CBLSPublicKey> vec_pk;
118 :
119 : {
120 2 : auto ret = CBLSSecretKey::AggregateInsecure(vec_sk);
121 2 : BOOST_CHECK(ret == CBLSSecretKey());
122 2 : }
123 : {
124 2 : auto ret = CBLSPublicKey::AggregateInsecure(vec_pk);
125 2 : BOOST_CHECK(ret == CBLSPublicKey());
126 : }
127 :
128 : // In practice, we only aggregate 400 key shares at any given time, something substantially larger than that should
129 : // be good. Plus this is very very fast, so who cares!
130 2 : int key_count = 10000;
131 2 : vec_sk.reserve(key_count);
132 2 : vec_pk.reserve(key_count);
133 2 : CBLSSecretKey sk;
134 20002 : for (int i = 0; i < key_count; i++) {
135 20000 : sk.MakeNewKey();
136 20000 : vec_sk.push_back(sk);
137 20000 : vec_pk.push_back(sk.GetPublicKey());
138 20000 : }
139 :
140 2 : CBLSSecretKey ag_sk = CBLSSecretKey::AggregateInsecure(vec_sk);
141 2 : CBLSPublicKey ag_pk = CBLSPublicKey::AggregateInsecure(vec_pk);
142 :
143 2 : BOOST_CHECK(ag_sk.IsValid());
144 2 : BOOST_CHECK(ag_pk.IsValid());
145 :
146 2 : uint256 msgHash1 = uint256::ONE;
147 2 : uint256 msgHash2 = uint256::TWO;
148 :
149 2 : auto sig = ag_sk.Sign(msgHash1, legacy_scheme);
150 2 : BOOST_CHECK(sig.VerifyInsecure(ag_pk, msgHash1));
151 2 : BOOST_CHECK(!sig.VerifyInsecure(ag_pk, msgHash2));
152 2 : }
153 :
154 :
155 2 : void FuncSigAggSub(const bool legacy_scheme)
156 : {
157 2 : bls::bls_legacy_scheme.store(legacy_scheme);
158 :
159 2 : int count = 20;
160 2 : std::vector<CBLSPublicKey> vec_pks;
161 2 : std::vector<uint256> vec_hashes;
162 2 : std::vector<CBLSSignature> vec_sigs;
163 2 : vec_pks.reserve(count);
164 2 : vec_hashes.reserve(count);
165 2 : vec_sigs.reserve(count);
166 :
167 2 : CBLSSignature sig;
168 2 : auto sk = CBLSSecretKey();
169 2 : uint256 hash;
170 42 : for (int i = 0; i < count; i++) {
171 40 : sk.MakeNewKey();
172 40 : vec_pks.push_back(sk.GetPublicKey());
173 40 : hash = GetRandHash();
174 40 : vec_hashes.push_back(hash);
175 40 : CBLSSignature sig_i = sk.Sign(hash, legacy_scheme);
176 40 : vec_sigs.push_back(sig_i);
177 40 : if (i == 0) {
178 : // first sig is assigned directly
179 2 : sig = sig_i;
180 2 : } else {
181 : // all other sigs are aggregated into the previously computed/stored sig
182 38 : sig.AggregateInsecure(sig_i);
183 : }
184 40 : BOOST_CHECK(sig.VerifyInsecureAggregated(vec_pks, vec_hashes));
185 40 : }
186 : // Create an aggregated signature from the vector of individual signatures
187 2 : auto vecSig = CBLSSignature::AggregateInsecure(vec_sigs);
188 2 : BOOST_CHECK(vecSig.VerifyInsecureAggregated(vec_pks, vec_hashes));
189 : // Check that these two signatures are equal
190 2 : BOOST_CHECK(sig == vecSig);
191 :
192 : // Test that the sig continues to be valid when subtracting sigs via `SubInsecure`
193 :
194 40 : for (int i = 0; i < count - 1; i++) {
195 38 : auto top_sig = vec_sigs.back();
196 38 : vec_pks.pop_back();
197 38 : vec_hashes.pop_back();
198 38 : BOOST_CHECK(!sig.VerifyInsecureAggregated(vec_pks, vec_hashes));
199 38 : sig.SubInsecure(top_sig);
200 38 : BOOST_CHECK(sig.VerifyInsecureAggregated(vec_pks, vec_hashes));
201 38 : vec_sigs.pop_back();
202 38 : }
203 : // Check that the final left-over sig validates
204 2 : BOOST_CHECK_EQUAL(vec_sigs.size(), 1);
205 2 : BOOST_CHECK_EQUAL(vec_pks.size(), 1);
206 2 : BOOST_CHECK_EQUAL(vec_hashes.size(), 1);
207 2 : BOOST_CHECK(vec_sigs[0].VerifyInsecure(vec_pks[0], vec_hashes[0]));
208 2 : }
209 :
210 :
211 2 : void FuncSigAggSecure(const bool legacy_scheme)
212 : {
213 2 : bls::bls_legacy_scheme.store(legacy_scheme);
214 :
215 2 : int count = 10;
216 :
217 2 : uint256 hash = GetRandHash();
218 :
219 2 : std::vector<CBLSSignature> vec_sigs;
220 2 : std::vector<CBLSPublicKey> vec_pks;
221 :
222 2 : CBLSSecretKey sk;
223 22 : for (int i = 0; i < count; i++) {
224 20 : sk.MakeNewKey();
225 20 : vec_pks.push_back(sk.GetPublicKey());
226 20 : vec_sigs.push_back(sk.Sign(hash, legacy_scheme));
227 20 : }
228 :
229 2 : auto sec_agg_sig = CBLSSignature::AggregateSecure(vec_sigs, vec_pks, hash);
230 2 : BOOST_CHECK(sec_agg_sig.IsValid());
231 2 : BOOST_CHECK(sec_agg_sig.VerifySecureAggregated(vec_pks, hash));
232 2 : }
233 :
234 2 : void FuncDHExchange(const bool legacy_scheme)
235 : {
236 2 : bls::bls_legacy_scheme.store(legacy_scheme);
237 :
238 2 : CBLSSecretKey sk1, sk2;
239 2 : sk1.MakeNewKey();
240 2 : sk2.MakeNewKey();
241 :
242 2 : CBLSPublicKey pk1, pk2;
243 2 : pk1 = sk1.GetPublicKey();
244 2 : pk2 = sk2.GetPublicKey();
245 :
246 : // Perform diffie-helman exchange
247 2 : CBLSPublicKey pke1, pke2;
248 2 : pke1.DHKeyExchange(sk1, pk2);
249 2 : pke2.DHKeyExchange(sk2, pk1);
250 :
251 2 : BOOST_CHECK(pke1.IsValid());
252 2 : BOOST_CHECK(pke2.IsValid());
253 2 : BOOST_CHECK(pke1 == pke2);
254 2 : }
255 :
256 32 : struct Message
257 : {
258 : uint32_t sourceId;
259 : uint32_t msgId;
260 : uint256 msgHash;
261 : CBLSSecretKey sk;
262 : CBLSPublicKey pk;
263 : CBLSSignature sig;
264 : bool valid;
265 : };
266 :
267 32 : static void AddMessage(std::vector<Message>& vec, uint32_t sourceId, uint32_t msgId, uint8_t msgHash, bool valid)
268 : {
269 32 : bool legacy_scheme = bls::bls_legacy_scheme.load();
270 32 : Message m;
271 32 : m.sourceId = sourceId;
272 32 : m.msgId = msgId;
273 32 : m.msgHash = uint256(msgHash);
274 32 : m.sk.MakeNewKey();
275 32 : m.pk = m.sk.GetPublicKey();
276 32 : m.sig = m.sk.Sign(m.msgHash, legacy_scheme);
277 32 : m.valid = valid;
278 :
279 32 : if (!valid) {
280 4 : CBLSSecretKey tmp;
281 4 : tmp.MakeNewKey();
282 4 : m.sig = tmp.Sign(m.msgHash, legacy_scheme);
283 4 : }
284 :
285 32 : vec.emplace_back(m);
286 32 : }
287 :
288 56 : static void Verify(std::vector<Message>& vec, bool secureVerification, bool perMessageFallback)
289 : {
290 56 : CBLSBatchVerifier<uint32_t, uint32_t> batchVerifier(secureVerification, perMessageFallback);
291 :
292 56 : std::set<uint32_t> expectedBadMessages;
293 56 : std::set<uint32_t> expectedBadSources;
294 424 : for (auto& m : vec) {
295 368 : if (!m.valid) {
296 32 : expectedBadMessages.emplace(m.msgId);
297 32 : expectedBadSources.emplace(m.sourceId);
298 32 : }
299 :
300 368 : batchVerifier.PushMessage(m.sourceId, m.msgId, m.msgHash, m.sig, m.pk);
301 : }
302 :
303 56 : batchVerifier.Verify();
304 :
305 56 : BOOST_CHECK(batchVerifier.badSources == expectedBadSources);
306 :
307 56 : if (perMessageFallback) {
308 28 : BOOST_CHECK(batchVerifier.badMessages == expectedBadMessages);
309 28 : } else {
310 28 : BOOST_CHECK(batchVerifier.badMessages.empty());
311 : }
312 56 : }
313 :
314 14 : static void Verify(std::vector<Message>& vec)
315 : {
316 14 : Verify(vec, false, false);
317 14 : Verify(vec, true, false);
318 14 : Verify(vec, false, true);
319 14 : Verify(vec, true, true);
320 14 : }
321 :
322 2 : void FuncBatchVerifier(const bool legacy_scheme)
323 : {
324 2 : bls::bls_legacy_scheme.store(legacy_scheme);
325 :
326 2 : std::vector<Message> msgs;
327 :
328 : // distinct messages from distinct sources
329 2 : AddMessage(msgs, 1, 1, 1, true);
330 2 : AddMessage(msgs, 2, 2, 2, true);
331 2 : AddMessage(msgs, 3, 3, 3, true);
332 2 : Verify(msgs);
333 :
334 : // distinct messages from same source
335 2 : AddMessage(msgs, 4, 4, 4, true);
336 2 : AddMessage(msgs, 4, 5, 5, true);
337 2 : AddMessage(msgs, 4, 6, 6, true);
338 2 : Verify(msgs);
339 :
340 : // invalid sig
341 2 : AddMessage(msgs, 7, 7, 7, false);
342 2 : Verify(msgs);
343 :
344 : // same message as before, but from another source and with valid sig
345 2 : AddMessage(msgs, 8, 8, 7, true);
346 2 : Verify(msgs);
347 :
348 : // same message as before, but from another source and signed with another key
349 2 : AddMessage(msgs, 9, 9, 7, true);
350 2 : Verify(msgs);
351 :
352 2 : msgs.clear();
353 : // same message, signed by multiple keys
354 2 : AddMessage(msgs, 1, 1, 1, true);
355 2 : AddMessage(msgs, 1, 2, 1, true);
356 2 : AddMessage(msgs, 1, 3, 1, true);
357 2 : AddMessage(msgs, 2, 4, 1, true);
358 2 : AddMessage(msgs, 2, 5, 1, true);
359 2 : AddMessage(msgs, 2, 6, 1, true);
360 2 : Verify(msgs);
361 :
362 : // last message invalid from one source
363 2 : AddMessage(msgs, 1, 7, 1, false);
364 2 : Verify(msgs);
365 2 : }
366 :
367 2 : void FuncThresholdSignature(const bool legacy_scheme)
368 : {
369 2 : bls::bls_legacy_scheme.store(legacy_scheme);
370 :
371 2 : [[maybe_unused]] const uint256 hash = GetRandHash();
372 :
373 2 : constexpr size_t m_size = 20;
374 2 : constexpr size_t m_threshold = 15;
375 :
376 2 : std::vector<CBLSSecretKey> v_threshold_sks;
377 2 : std::vector<CBLSPublicKey> v_threshold_pks;
378 32 : for ([[maybe_unused]] const auto i : util::irange(m_threshold)) {
379 30 : CBLSSecretKey sk;
380 30 : sk.MakeNewKey();
381 30 : v_threshold_sks.push_back(sk);
382 30 : v_threshold_pks.emplace_back(sk.GetPublicKey());
383 30 : }
384 :
385 2 : CBLSSecretKey thr_sk = v_threshold_sks[0];
386 2 : CBLSPublicKey thr_pk = v_threshold_pks[0];
387 2 : CBLSSignature thr_sig = thr_sk.Sign(hash, legacy_scheme);
388 :
389 2 : std::vector<CBLSId> v_size_ids;
390 2 : std::vector<CBLSSecretKey> v_size_sk_shares;
391 2 : std::vector<CBLSPublicKey> v_size_pk_shares;
392 42 : for ([[maybe_unused]] const auto m_shares : util::irange(m_size)) {
393 40 : v_size_ids.emplace_back(GetRandHash());
394 40 : CBLSSecretKey sk;
395 40 : BOOST_CHECK(sk.SecretKeyShare(v_threshold_sks, v_size_ids[m_shares]));
396 40 : v_size_sk_shares.push_back(sk);
397 40 : CBLSPublicKey pk;
398 40 : BOOST_CHECK(pk.PublicKeyShare(v_threshold_pks, v_size_ids[m_shares]));
399 40 : v_size_pk_shares.push_back(pk);
400 :
401 40 : std::vector<CBLSSignature> v_share_sigs;
402 40 : std::vector<CBLSId> v_share_ids;
403 420 : for ([[maybe_unused]] const auto j : util::irange(m_shares)) {
404 380 : v_share_sigs.emplace_back(v_size_sk_shares[j].Sign(hash, legacy_scheme));
405 380 : BOOST_CHECK(v_share_sigs.back().VerifyInsecure(v_size_pk_shares[j], hash));
406 380 : v_share_ids.push_back(v_size_ids[j]);
407 : }
408 :
409 40 : CBLSSignature rec_share_sig;
410 40 : BOOST_CHECK_EQUAL(rec_share_sig.Recover(v_share_sigs, v_share_ids), m_shares >= 2);
411 40 : BOOST_CHECK_EQUAL(rec_share_sig.IsValid(), m_shares >= 2);
412 40 : BOOST_CHECK_EQUAL(rec_share_sig == thr_sig, m_shares >= m_threshold);
413 40 : BOOST_CHECK_EQUAL(rec_share_sig.VerifyInsecure(thr_pk, hash), m_shares >= m_threshold);
414 40 : }
415 2 : }
416 :
417 148 : BOOST_AUTO_TEST_CASE(bls_sethexstr_tests)
418 : {
419 1 : FuncSetHexStr(true);
420 1 : FuncSetHexStr(false);
421 1 : }
422 :
423 148 : BOOST_AUTO_TEST_CASE(bls_serialize_tests)
424 : {
425 1 : FuncSerialize(true);
426 1 : FuncSerialize(false);
427 1 : }
428 :
429 148 : BOOST_AUTO_TEST_CASE(bls_sig_tests)
430 : {
431 1 : FuncSign(true);
432 1 : FuncSign(false);
433 1 : }
434 :
435 148 : BOOST_AUTO_TEST_CASE(bls_key_agg_tests)
436 : {
437 1 : FuncKeyAgg(true);
438 1 : FuncKeyAgg(false);
439 1 : }
440 :
441 148 : BOOST_AUTO_TEST_CASE(bls_key_agg_vec_tests)
442 : {
443 1 : FuncKeyAggVec(true);
444 1 : FuncKeyAggVec(false);
445 1 : }
446 :
447 148 : BOOST_AUTO_TEST_CASE(bls_sig_agg_sub_tests)
448 : {
449 1 : FuncSigAggSub(true);
450 1 : FuncSigAggSub(false);
451 1 : }
452 :
453 148 : BOOST_AUTO_TEST_CASE(bls_sig_agg_secure_tests)
454 : {
455 1 : FuncSigAggSecure(true);
456 1 : FuncSigAggSecure(false);
457 1 : }
458 :
459 148 : BOOST_AUTO_TEST_CASE(bls_dh_exchange_tests)
460 : {
461 1 : FuncDHExchange(true);
462 1 : FuncDHExchange(false);
463 1 : }
464 :
465 148 : BOOST_AUTO_TEST_CASE(batch_verifier_tests)
466 : {
467 1 : FuncBatchVerifier(true);
468 1 : FuncBatchVerifier(false);
469 1 : }
470 :
471 148 : BOOST_AUTO_TEST_CASE(bls_threshold_signature_tests)
472 : {
473 1 : FuncThresholdSignature(true);
474 1 : FuncThresholdSignature(false);
475 1 : }
476 :
477 : // A dummy BLS object that satisfies the minimal interface expected by CBLSLazyWrapper.
478 : class DummyBLS
479 : {
480 : public:
481 : // Define a fixed serialization size (for testing purposes).
482 : static const size_t SerSize = 4;
483 18 : std::array<uint8_t, SerSize> data{};
484 :
485 54 : DummyBLS() { data.fill(0); }
486 :
487 : // A dummy validity check: valid if any byte is non-zero.
488 1 : bool IsValid() const
489 : {
490 2 : return std::any_of(data.begin(), data.end(), [](uint8_t c) { return c != 0; });
491 : }
492 :
493 : // Convert to bytes; ignore the legacy flag for simplicity.
494 3 : std::array<uint8_t, SerSize> ToBytes(bool /*legacy*/) const { return data; }
495 :
496 : // Set from bytes; again, ignore the legacy flag.
497 1 : void SetBytes(const std::array<uint8_t, SerSize>& bytes, bool /*legacy*/) { data = bytes; }
498 :
499 : // A dummy malleability check: simply compares the stored data to the given bytes.
500 1 : bool CheckMalleable(const std::array<uint8_t, SerSize>& bytes, bool /*legacy*/) const { return data == bytes; }
501 :
502 : // Reset the object to an "empty" state.
503 : void Reset() { data.fill(0); }
504 :
505 : // Produce a string representation.
506 : std::string ToString(bool /*legacy*/) const { return HexStr(data); }
507 :
508 : // Equality operator.
509 3 : bool operator==(const DummyBLS& other) const { return data == other.data; }
510 : };
511 :
512 : // Define a type alias for our lazy wrapper instantiated with DummyBLS.
513 : using LazyDummyBLS = CBLSLazyWrapper<DummyBLS>;
514 :
515 : // Test 1: Two default (unset) wrappers should compare equal.
516 148 : BOOST_AUTO_TEST_CASE(test_default_equality)
517 : {
518 1 : LazyDummyBLS lazy1;
519 1 : LazyDummyBLS lazy2;
520 : // Neither instance has been set, so they represent the default/null object.
521 1 : BOOST_CHECK(lazy1 == lazy2);
522 1 : }
523 :
524 : // Test 2: A default wrapper and one initialized with a nonzero DummyBLS should compare unequal.
525 148 : BOOST_AUTO_TEST_CASE(test_non_default_vs_default)
526 : {
527 1 : LazyDummyBLS lazy_default;
528 1 : LazyDummyBLS lazy_set;
529 1 : DummyBLS obj;
530 1 : obj.data = {1, 0, 0, 0}; // nonzero data makes the object valid
531 1 : lazy_set.Set(obj, false);
532 1 : BOOST_CHECK(!(lazy_default == lazy_set));
533 1 : BOOST_CHECK(lazy_default != lazy_set);
534 1 : }
535 :
536 : // Test 2: A default wrapper and one initialized with a nonzero DummyBLS should compare unequal.
537 148 : BOOST_AUTO_TEST_CASE(test_non_default_vs_different)
538 : {
539 1 : LazyDummyBLS lazy_a;
540 1 : LazyDummyBLS lazy_b;
541 1 : DummyBLS obj;
542 1 : obj.data = {1, 2, 3, 4}; // nonzero data makes the object valid
543 1 : lazy_a.Set(obj, false);
544 1 : obj.data = {2, 2, 3, 4}; // nonzero data makes the object valid
545 1 : lazy_b.Set(obj, false);
546 1 : BOOST_CHECK(lazy_a != lazy_b);
547 1 : }
548 :
549 : // Test 3: Two wrappers set with the same underlying DummyBLS value compare equal.
550 148 : BOOST_AUTO_TEST_CASE(test_equality_same_value)
551 : {
552 1 : LazyDummyBLS lazy1;
553 1 : LazyDummyBLS lazy2;
554 1 : BOOST_CHECK(lazy1 == lazy2);
555 1 : DummyBLS obj;
556 1 : obj.data = {5, 6, 7, 8};
557 1 : lazy1.Set(obj, false);
558 1 : BOOST_CHECK(lazy1 != lazy2);
559 1 : lazy2.Set(obj, false);
560 1 : BOOST_CHECK(lazy1 == lazy2);
561 1 : }
562 :
563 : // Test 4: Serialization and unserialization preserve the wrapped value.
564 148 : BOOST_AUTO_TEST_CASE(test_serialization_unserialization)
565 : {
566 1 : LazyDummyBLS lazy1;
567 1 : DummyBLS obj;
568 1 : obj.data = {9, 10, 11, 12};
569 : // Set with a specific legacy flag (true in this case)
570 1 : lazy1.Set(obj, true);
571 :
572 : // Serialize the lazy object into a data stream.
573 1 : CDataStream ds(SER_DISK, CLIENT_VERSION);
574 1 : lazy1.Serialize(ds, true);
575 :
576 : // Create a new instance and unserialize the data into it.
577 1 : LazyDummyBLS lazy2;
578 1 : lazy2.Unserialize(ds, true);
579 1 : BOOST_CHECK(lazy1 == lazy2);
580 1 : BOOST_CHECK(lazy2.Get() == obj);
581 1 : }
582 :
583 : // Test 5: Two wrappers wrapping the same object should have the same hash.
584 148 : BOOST_AUTO_TEST_CASE(test_get_hash_consistency)
585 : {
586 1 : LazyDummyBLS lazy1;
587 1 : LazyDummyBLS lazy2;
588 1 : DummyBLS obj;
589 1 : obj.data = {13, 14, 15, 16};
590 1 : lazy1.Set(obj, false);
591 1 : lazy2.Set(obj, false);
592 1 : uint256 hash1 = lazy1.GetHash();
593 1 : uint256 hash2 = lazy2.GetHash();
594 1 : BOOST_CHECK(hash1 == hash2);
595 1 : }
596 :
597 146 : BOOST_AUTO_TEST_SUITE_END()
|
