Inside Bitcoin

251        std::string prv1;
252        BOOST_CHECK(parse_priv->ToPrivateString(keys_priv, prv1));
253        if (expected_prv) {
254            BOOST_CHECK_MESSAGE(EqualDescriptor(*expected_prv, prv1), "Private ser: " + prv1 + "Private desc: " + *expected_prv);
255        } else {
256            BOOST_CHECK_MESSAGE(EqualDescriptor(prv, prv1), "Private ser: " + prv1 + " Private desc: " + prv);
257        }
258        BOOST_CHECK(!parse_priv->ToPrivateString(keys_pub, prv1));
259        BOOST_CHECK(parse_pub->ToPrivateString(keys_priv, prv1));
260        if (expected_prv) {
261            BOOST_CHECK(EqualDescriptor(*expected_prv, prv1));
262            BOOST_CHECK_MESSAGE(EqualDescriptor(*expected_prv, prv1), "Private ser: " + prv1 + " Private desc: " + *expected_prv);
263        } else {
264            BOOST_CHECK_MESSAGE(EqualDescriptor(prv, prv1), "Private ser: " + prv1 + " Private desc: " + prv);
265        }
266        BOOST_CHECK(!parse_pub->ToPrivateString(keys_pub, prv1));
267
268        // Check that both can ExpandPrivate and get the same SigningProviders
269        FlatSigningProvider priv_prov;
270        parse_priv->ExpandPrivate(0, keys_priv, priv_prov);
271
272        FlatSigningProvider pub_prov;
273        parse_pub->ExpandPrivate(0, keys_priv, pub_prov);
274
275        BOOST_CHECK_MESSAGE(EqualSigningProviders(priv_prov, pub_prov), "Private desc: " + prv + " Pub desc: " + pub);
276    } else if (keys_priv.keys.size() > 0) {
277        // If there is at least one private key, ToPrivateString() should return true and include that key
278        std::string prv_str;
279        BOOST_CHECK(parse_priv->ToPrivateString(keys_priv, prv_str));
280        size_t checksum_len = 9; // Including the '#' character
281        BOOST_CHECK_MESSAGE(prv == prv_str.substr(0, prv_str.length() - checksum_len), prv);
282    }
283
284    // Check that private can produce the normalized descriptors
285    std::string norm1;
286    BOOST_CHECK(parse_priv->ToNormalizedString(keys_priv, norm1));
287    BOOST_CHECK_MESSAGE(EqualDescriptor(norm1, norm_pub), "priv->ToNormalizedString(): " + norm1 + " Norm. desc: " + norm_pub);
288    BOOST_CHECK(parse_pub->ToNormalizedString(keys_priv, norm1));
289    BOOST_CHECK_MESSAGE(EqualDescriptor(norm1, norm_pub), "pub->ToNormalizedString(): " + norm1 + " Norm. desc: " + norm_pub);
290
291    // Check whether IsRange on both returns the expected result
292    BOOST_CHECK_EQUAL(parse_pub->IsRange(), (flags & RANGE) != 0);
293    BOOST_CHECK_EQUAL(parse_priv->IsRange(), (flags & RANGE) != 0);
294
295    // Check that the highest key expression index matches the number of keys in the descriptor
296    BOOST_TEST_INFO("Pub desc: " + pub);
297    uint32_t key_exprs = parse_pub->GetMaxKeyExpr();
298    BOOST_CHECK_EQUAL(key_exprs + 1, parse_pub->GetKeyCount());
299    BOOST_TEST_INFO("Priv desc: " + prv);
300    BOOST_CHECK_EQUAL(key_exprs, parse_priv->GetMaxKeyExpr());
301    BOOST_CHECK_EQUAL(key_exprs + 1, parse_priv->GetKeyCount());
302
303    // * For ranged descriptors,  the `scripts` parameter is a list of expected result outputs, for subsequent
304    //   positions to evaluate the descriptors on (so the first element of `scripts` is for evaluating the
305    //   descriptor at 0; the second at 1; and so on). To verify this, we evaluate the descriptors once for
306    //   each element in `scripts`.
307    // * For non-ranged descriptors, we evaluate the descriptors at positions 0, 1, and 2, but expect the
308    //   same result in each case, namely the first element of `scripts`. Because of that, the size of
309    //   `scripts` must be one in that case.
310    if (!(flags & RANGE)) assert(scripts.size() == 1);
311    size_t max = (flags & RANGE) ? scripts.size() : 3;
312
313    // Iterate over the position we'll evaluate the descriptors in.
314    for (size_t i = 0; i < max; ++i) {
315        // Call the expected result scripts `ref`.
316        const auto& ref = scripts[(flags & RANGE) ? i : 0];
317        // When t=0, evaluate the `prv` descriptor; when t=1, evaluate the `pub` descriptor.
318        for (int t = 0; t < 2; ++t) {
319            // When the descriptor is hardened, evaluate with access to the private keys inside.
320            const FlatSigningProvider& key_provider = (flags & HARDENED) ? keys_priv : keys_pub;
321
322            // Evaluate the descriptor selected by `t` in position `i`.
323            FlatSigningProvider script_provider, script_provider_cached;
324            std::vector<CScript> spks, spks_cached;
325            DescriptorCache desc_cache;
326            BOOST_CHECK((t ? parse_priv : parse_pub)->Expand(i, key_provider, spks, script_provider, &desc_cache));
327
328            // Compare the output with the expected result.
329            BOOST_CHECK_EQUAL(spks.size(), ref.size());
330
331            // Try to expand again using cached data, and compare.
332            BOOST_CHECK(parse_pub->ExpandFromCache(i, desc_cache, spks_cached, script_provider_cached));
333            BOOST_CHECK(spks == spks_cached);
334            BOOST_CHECK(GetKeyData(script_provider, flags) == GetKeyData(script_provider_cached, flags));
335            BOOST_CHECK(script_provider.scripts == script_provider_cached.scripts);
336            BOOST_CHECK(GetKeyOriginData(script_provider, flags) == GetKeyOriginData(script_provider_cached, flags));
337
338            // Check whether keys are in the cache
339            const auto& der_xpub_cache = desc_cache.GetCachedDerivedExtPubKeys();
340            const auto& parent_xpub_cache = desc_cache.GetCachedParentExtPubKeys();
341            size_t num_xpubs = CountXpubs(pub1);
342            size_t num_unique_xpubs = CountUniqueXpubs(pub1);
343            if (flags & MUSIG_DERIVATION) {
344                // Deriving from the aggregate will include the synthetic xpub of the aggregate in the caches and SigningProviders.
345                num_xpubs++;
346                num_unique_xpubs++;
347            }
348            if ((flags & RANGE) && !(flags & (DERIVE_HARDENED))) {
349                // For ranged, unhardened derivation, None of the keys in origins should appear in the cache but the cache should have parent keys
350                // But we can derive one level from each of those parent keys and find them all
351                BOOST_CHECK(der_xpub_cache.empty());
352                BOOST_CHECK(parent_xpub_cache.size() > 0);
353                std::set<CPubKey> pubkeys;
354                for (const auto& xpub_pair : parent_xpub_cache) {
355                    const CExtPubKey& xpub = xpub_pair.second;
356                    CExtPubKey der;
357                    BOOST_CHECK(xpub.Derive(der, i));
358                    pubkeys.insert(der.pubkey);
359                }
360                int count_pks = 0;
361                for (const auto& origin_pair : script_provider_cached.origins) {
362                    const CPubKey& pk = origin_pair.second.first;
363                    count_pks += pubkeys.count(pk);
364                }
365                if (flags & MUSIG_DERIVATION) {
366                    if (!(flags & MIXED_MUSIG)) {
367                        BOOST_CHECK_EQUAL(count_pks, 1);
368                    }
369                    BOOST_CHECK_EQUAL(num_xpubs, pubkeys.size());
370                } else {
371                    if (flags & MUSIG) count_pks++; // One extra key for the aggregate key that is not in the cache
372                    if (flags & MIXED_PUBKEYS) {
373                        BOOST_CHECK_EQUAL(num_xpubs, count_pks);
374                    } else {
375                        BOOST_CHECK_EQUAL(script_provider_cached.origins.size(), count_pks);
376                    }
377                }
378            } else if (num_xpubs > 0) {
379                // For ranged, hardened derivation, or not ranged, but has an xpub, all of the keys should appear in the cache
380                BOOST_CHECK_EQUAL(der_xpub_cache.size() + parent_xpub_cache.size(), num_xpubs);
381                if (!(flags & MIXED_PUBKEYS)) {
382                    if (flags & UNIQUE_XPUBS) {
383                        BOOST_CHECK_EQUAL(script_provider_cached.origins.size(), num_unique_xpubs);
384                    } else {
385                        BOOST_CHECK_EQUAL(script_provider_cached.origins.size(), num_xpubs);
386                    }
387                }
388                // Get all of the derived pubkeys
389                std::set<CPubKey> pubkeys;
390                for (const auto& xpub_map_pair : der_xpub_cache) {
391                    for (const auto& xpub_pair : xpub_map_pair.second) {
392                        const CExtPubKey& xpub = xpub_pair.second;
393                        pubkeys.insert(xpub.pubkey);
394                    }
395                }
396                // Derive one level from all of the parents
397                for (const auto& xpub_pair : parent_xpub_cache) {
398                    const CExtPubKey& xpub = xpub_pair.second;
399                    pubkeys.insert(xpub.pubkey);
400                    CExtPubKey der;
401                    BOOST_CHECK(xpub.Derive(der, i));
402                    pubkeys.insert(der.pubkey);
403                }
404                int count_pks = 0;
405                for (const auto& origin_pair : script_provider_cached.origins) {
406                    const CPubKey& pk = origin_pair.second.first;
407                    count_pks += pubkeys.count(pk);
408                }
409                if (flags & MUSIG_DERIVATION && !(flags & MIXED_PUBKEYS)) {
410                    // pubkeys is one key per xpub + one derived key per xpub
411                    BOOST_CHECK_EQUAL(2 * count_pks, pubkeys.size());
412                    if (flags & UNIQUE_XPUBS) {
413                        BOOST_CHECK_EQUAL(2 * num_unique_xpubs, pubkeys.size());
414                    } else {
415                        BOOST_CHECK_EQUAL(2 * num_xpubs, pubkeys.size());
416                    }
417                } else {
418                    if (flags & MUSIG) count_pks++; // One extra key for the aggregate key that is not in the cache
419                    if (flags & MIXED_PUBKEYS) {
420                        BOOST_CHECK_EQUAL(num_xpubs, count_pks);
421                    } else {
422                        BOOST_CHECK_EQUAL(script_provider_cached.origins.size(), count_pks);
423                    }
424                }
425            } else if (!(flags & MIXED_PUBKEYS)) {
426                // Only const pubkeys, nothing should be cached
427                BOOST_CHECK(der_xpub_cache.empty());
428                BOOST_CHECK(parent_xpub_cache.empty());
429            }
430
431            // Make sure we can expand using cached xpubs for unhardened derivation
432            if (!(flags & DERIVE_HARDENED)) {
433                // Evaluate the descriptor at i + 1
434                FlatSigningProvider script_provider1, script_provider_cached1;
435                std::vector<CScript> spks1, spk1_from_cache;
436                BOOST_CHECK((t ? parse_priv : parse_pub)->Expand(i + 1, key_provider, spks1, script_provider1, nullptr));
437
438                // Try again but use the cache from expanding i. That cache won't have the pubkeys for i + 1, but will have the parent xpub for derivation.
439                BOOST_CHECK(parse_pub->ExpandFromCache(i + 1, desc_cache, spk1_from_cache, script_provider_cached1));
440                BOOST_CHECK(spks1 == spk1_from_cache);
441                BOOST_CHECK(GetKeyData(script_provider1, flags) == GetKeyData(script_provider_cached1, flags));
442                BOOST_CHECK(script_provider1.scripts == script_provider_cached1.scripts);
443                BOOST_CHECK(GetKeyOriginData(script_provider1, flags) == GetKeyOriginData(script_provider_cached1, flags));
444            }
445
446            // For each of the produced scripts, verify solvability, and when possible, try to sign a transaction spending it.
447            for (size_t n = 0; n < spks.size(); ++n) {
448                BOOST_CHECK_EQUAL(ref[n], HexStr(spks[n]));
449
450                if (flags & (SIGNABLE | SIGNABLE_FAILS)) {
451                    CMutableTransaction spend;
452                    spend.nLockTime = spender_nlocktime;
453                    spend.vin.resize(1);
454                    spend.vin[0].nSequence = spender_nsequence;
455                    spend.vout.resize(1);
456                    std::vector<CTxOut> utxos(1);
457                    PrecomputedTransactionData txdata;
458                    txdata.Init(spend, std::move(utxos), /*force=*/true);
459                    MutableTransactionSignatureCreator creator{spend, 0, CAmount{0}, &txdata, {.sighash_type = SIGHASH_DEFAULT}};
460                    SignatureData sigdata;
461                    // We assume there is no collision between the hashes (eg h1=SHA256(SHA256(x)) and h2=SHA256(x))
462                    sigdata.sha256_preimages = preimages;
463                    sigdata.hash256_preimages = preimages;
464                    sigdata.ripemd160_preimages = preimages;
465                    sigdata.hash160_preimages = preimages;
466                    const auto prod_sig_res = ProduceSignature(FlatSigningProvider{keys_priv}.Merge(FlatSigningProvider{script_provider}), creator, spks[n], sigdata);
467                    BOOST_CHECK_MESSAGE(prod_sig_res == !(flags & SIGNABLE_FAILS), prv);
468                }
469
470                /* Infer a descriptor from the generated script, and verify its solvability and that it roundtrips. */
471                auto inferred = InferDescriptor(spks[n], script_provider);
472                BOOST_CHECK_EQUAL(inferred->IsSolvable(), !(flags & UNSOLVABLE));
473                std::vector<CScript> spks_inferred;
474                FlatSigningProvider provider_inferred;
475                BOOST_CHECK(inferred->Expand(0, provider_inferred, spks_inferred, provider_inferred));
476                BOOST_CHECK_EQUAL(spks_inferred.size(), 1U);
477                BOOST_CHECK(spks_inferred[0] == spks[n]);
478                BOOST_CHECK_EQUAL(InferDescriptor(spks_inferred[0], provider_inferred)->IsSolvable(), !(flags & UNSOLVABLE));
479                BOOST_CHECK(GetKeyOriginData(provider_inferred, flags) == GetKeyOriginData(script_provider, flags));
480            }
481
482            // Test whether the observed key path is present in the 'paths' variable (which contains expected, unobserved paths),
483            // and then remove it from that set.
484            for (const auto& origin : script_provider.origins) {
485                BOOST_CHECK_MESSAGE(paths.contains(origin.second.second.path), "Unexpected key path: " + prv);
486                left_paths.erase(origin.second.second.path);
487            }
488
489            // Check that descriptors that have no hardened steps can self expand
490            BOOST_CHECK_EQUAL((t ? parse_priv : parse_pub)->CanSelfExpand(), !(flags & HARDENED));
491        }
492    }
493
494    // Verify no expected paths remain that were not observed.
495    BOOST_CHECK_MESSAGE(left_paths.empty(), "Not all expected key paths found: " + prv);
496}
497
498void Check(const std::string& prv, const std::string& pub, const std::string& norm_pub, int flags,
499           const std::vector<std::vector<std::string>>& scripts, const std::optional<OutputType>& type, std::optional<uint256> op_compat_desc_hash = std::nullopt,
500           const std::set<std::vector<uint32_t>>& paths = ONLY_EMPTY, uint32_t spender_nlocktime=0,