Bitcoin Core Fuzz Coverage Report for #26966

Coverage Report

Created: 2025-10-10 09:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/Users/brunogarcia/projects/bitcoin-core-dev/src/outputtype.cpp
Line
Count
Source
1
// Copyright (c) 2009-2010 Satoshi Nakamoto
2
// Copyright (c) 2009-present The Bitcoin Core developers
3
// Distributed under the MIT software license, see the accompanying
4
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6
#include <outputtype.h>
7
8
#include <pubkey.h>
9
#include <script/script.h>
10
#include <script/sign.h>
11
#include <script/signingprovider.h>
12
13
#include <cassert>
14
#include <optional>
15
#include <string>
16
17
static const std::string OUTPUT_TYPE_STRING_LEGACY = "legacy";
18
static const std::string OUTPUT_TYPE_STRING_P2SH_SEGWIT = "p2sh-segwit";
19
static const std::string OUTPUT_TYPE_STRING_BECH32 = "bech32";
20
static const std::string OUTPUT_TYPE_STRING_BECH32M = "bech32m";
21
static const std::string OUTPUT_TYPE_STRING_UNKNOWN = "unknown";
22
23
std::optional<OutputType> ParseOutputType(const std::string& type)
24
0
{
25
0
    if (type == OUTPUT_TYPE_STRING_LEGACY) {
26
0
        return OutputType::LEGACY;
27
0
    } else if (type == OUTPUT_TYPE_STRING_P2SH_SEGWIT) {
28
0
        return OutputType::P2SH_SEGWIT;
29
0
    } else if (type == OUTPUT_TYPE_STRING_BECH32) {
30
0
        return OutputType::BECH32;
31
0
    } else if (type == OUTPUT_TYPE_STRING_BECH32M) {
32
0
        return OutputType::BECH32M;
33
0
    }
34
0
    return std::nullopt;
35
0
}
36
37
const std::string& FormatOutputType(OutputType type)
38
0
{
39
0
    switch (type) {
40
0
    case OutputType::LEGACY: return OUTPUT_TYPE_STRING_LEGACY;
41
0
    case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
42
0
    case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
43
0
    case OutputType::BECH32M: return OUTPUT_TYPE_STRING_BECH32M;
44
0
    case OutputType::UNKNOWN: return OUTPUT_TYPE_STRING_UNKNOWN;
45
0
    } // no default case, so the compiler can warn about missing cases
46
0
    assert(false);
47
0
}
48
49
std::string FormatAllOutputTypes()
50
0
{
51
0
    return util::Join(OUTPUT_TYPES, ", ", [](const auto& i) { return "\"" + FormatOutputType(i) + "\""; });
52
0
}
53
54
CTxDestination AddAndGetDestinationForScript(FlatSigningProvider& keystore, const CScript& script, OutputType type)
55
0
{
56
    // Add script to keystore
57
0
    keystore.scripts.emplace(CScriptID(script), script);
58
59
0
    switch (type) {
60
0
    case OutputType::LEGACY:
61
0
        return ScriptHash(script);
62
0
    case OutputType::P2SH_SEGWIT:
63
0
    case OutputType::BECH32: {
64
0
        CTxDestination witdest = WitnessV0ScriptHash(script);
65
0
        CScript witprog = GetScriptForDestination(witdest);
66
        // Add the redeemscript, so that P2WSH and P2SH-P2WSH outputs are recognized as ours.
67
0
        keystore.scripts.emplace(CScriptID(witprog), witprog);
68
0
        if (type == OutputType::BECH32) {
69
0
            return witdest;
70
0
        } else {
71
0
            return ScriptHash(witprog);
72
0
        }
73
0
    }
74
0
    case OutputType::BECH32M:
75
0
    case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
76
0
    } // no default case, so the compiler can warn about missing cases
77
0
    assert(false);
78
0
}
79
80
0
std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
81
0
    if (std::holds_alternative<PKHash>(dest) ||
82
0
        std::holds_alternative<ScriptHash>(dest)) {
83
0
        return OutputType::LEGACY;
84
0
    }
85
0
    if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
86
0
        std::holds_alternative<WitnessV0ScriptHash>(dest)) {
87
0
        return OutputType::BECH32;
88
0
    }
89
0
    if (std::holds_alternative<WitnessV1Taproot>(dest) ||
90
0
        std::holds_alternative<WitnessUnknown>(dest)) {
91
0
        return OutputType::BECH32M;
92
0
    }
93
0
    return std::nullopt;
94
0
}