Coverage Report

Created: 2026-06-01 18:35

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/bitcoin/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(std::string_view type)
24
0
{
25
0
    if (type == OUTPUT_TYPE_STRING_LEGACY) {
  Branch (25:9): [True: 0, False: 0]

26
0
        return OutputType::LEGACY;
27
0
    } else if (type == OUTPUT_TYPE_STRING_P2SH_SEGWIT) {
  Branch (27:16): [True: 0, False: 0]

28
0
        return OutputType::P2SH_SEGWIT;
29
0
    } else if (type == OUTPUT_TYPE_STRING_BECH32) {
  Branch (29:16): [True: 0, False: 0]

30
0
        return OutputType::BECH32;
31
0
    } else if (type == OUTPUT_TYPE_STRING_BECH32M) {
  Branch (31:16): [True: 0, False: 0]

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) {
  Branch (39:13): [True: 0, False: 0]

40
0
    case OutputType::LEGACY: return OUTPUT_TYPE_STRING_LEGACY;
  Branch (40:5): [True: 0, False: 0]

41
0
    case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
  Branch (41:5): [True: 0, False: 0]

42
0
    case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
  Branch (42:5): [True: 0, False: 0]

43
0
    case OutputType::BECH32M: return OUTPUT_TYPE_STRING_BECH32M;
  Branch (43:5): [True: 0, False: 0]

44
0
    case OutputType::UNKNOWN: return OUTPUT_TYPE_STRING_UNKNOWN;
  Branch (44:5): [True: 0, False: 0]

45
0
    } // no default case, so the compiler can warn about missing cases
46
0
    assert(false);
  Branch (46:5): [Folded - Ignored]

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) {
  Branch (59:13): [True: 0, False: 0]

60
0
    case OutputType::LEGACY:
  Branch (60:5): [True: 0, False: 0]

61
0
        return ScriptHash(script);
62
0
    case OutputType::P2SH_SEGWIT:
  Branch (62:5): [True: 0, False: 0]

63
0
    case OutputType::BECH32: {
  Branch (63:5): [True: 0, False: 0]

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) {
  Branch (68:13): [True: 0, False: 0]

69
0
            return witdest;
70
0
        } else {
71
0
            return ScriptHash(witprog);
72
0
        }
73
0
    }
74
0
    case OutputType::BECH32M:
  Branch (74:5): [True: 0, False: 0]

75
0
    case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
  Branch (75:5): [True: 0, False: 0]

76
0
    } // no default case, so the compiler can warn about missing cases
77
0
    assert(false);
  Branch (77:5): [Folded - Ignored]

78
0
}
79
80
0
std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
81
0
    if (std::holds_alternative<PKHash>(dest) ||
  Branch (81:9): [True: 0, False: 0]

82
0
        std::holds_alternative<ScriptHash>(dest)) {
  Branch (82:9): [True: 0, False: 0]

83
0
        return OutputType::LEGACY;
84
0
    }
85
0
    if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
  Branch (85:9): [True: 0, False: 0]

86
0
        std::holds_alternative<WitnessV0ScriptHash>(dest)) {
  Branch (86:9): [True: 0, False: 0]

87
0
        return OutputType::BECH32;
88
0
    }
89
0
    if (std::holds_alternative<WitnessV1Taproot>(dest) ||
  Branch (89:9): [True: 0, False: 0]

90
0
        std::holds_alternative<WitnessUnknown>(dest)) {
  Branch (90:9): [True: 0, False: 0]

91
0
        return OutputType::BECH32M;
92
0
    }
93
0
    return std::nullopt;
94
0
}