Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-2022 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                 :             : #include <util/vector.h>
      13                 :             : 
      14                 :             : #include <assert.h>
      15                 :             : #include <optional>
      16                 :             : #include <string>
      17                 :             : 
      18                 :             : static const std::string OUTPUT_TYPE_STRING_LEGACY = "legacy";
      19                 :             : static const std::string OUTPUT_TYPE_STRING_P2SH_SEGWIT = "p2sh-segwit";
      20                 :             : static const std::string OUTPUT_TYPE_STRING_BECH32 = "bech32";
      21                 :             : static const std::string OUTPUT_TYPE_STRING_BECH32M = "bech32m";
      22                 :             : static const std::string OUTPUT_TYPE_STRING_UNKNOWN = "unknown";
      23                 :             : 
      24                 :         931 : std::optional<OutputType> ParseOutputType(const std::string& type)
      25                 :             : {
      26         [ +  + ]:         931 :     if (type == OUTPUT_TYPE_STRING_LEGACY) {
      27                 :          31 :         return OutputType::LEGACY;
      28         [ +  + ]:         900 :     } else if (type == OUTPUT_TYPE_STRING_P2SH_SEGWIT) {
      29                 :          11 :         return OutputType::P2SH_SEGWIT;
      30         [ +  + ]:         889 :     } else if (type == OUTPUT_TYPE_STRING_BECH32) {
      31                 :          11 :         return OutputType::BECH32;
      32         [ +  + ]:         878 :     } else if (type == OUTPUT_TYPE_STRING_BECH32M) {
      33                 :          11 :         return OutputType::BECH32M;
      34                 :             :     }
      35                 :         867 :     return std::nullopt;
      36                 :             : }
      37                 :             : 
      38                 :       29868 : const std::string& FormatOutputType(OutputType type)
      39                 :             : {
      40   [ +  +  +  -  :       29868 :     switch (type) {
                   -  + ]
      41                 :             :     case OutputType::LEGACY: return OUTPUT_TYPE_STRING_LEGACY;
      42                 :        7154 :     case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
      43                 :        8386 :     case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
      44                 :        7154 :     case OutputType::BECH32M: return OUTPUT_TYPE_STRING_BECH32M;
      45                 :           0 :     case OutputType::UNKNOWN: return OUTPUT_TYPE_STRING_UNKNOWN;
      46                 :             :     } // no default case, so the compiler can warn about missing cases
      47                 :           0 :     assert(false);
      48                 :             : }
      49                 :             : 
      50                 :         486 : CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
      51                 :             : {
      52      [ +  -  - ]:         486 :     switch (type) {
      53                 :         486 :     case OutputType::LEGACY: return PKHash(key);
      54                 :           0 :     case OutputType::P2SH_SEGWIT:
      55                 :           0 :     case OutputType::BECH32: {
      56         [ #  # ]:           0 :         if (!key.IsCompressed()) return PKHash(key);
      57         [ #  # ]:           0 :         CTxDestination witdest = WitnessV0KeyHash(key);
      58         [ #  # ]:           0 :         CScript witprog = GetScriptForDestination(witdest);
      59         [ #  # ]:           0 :         if (type == OutputType::P2SH_SEGWIT) {
      60         [ #  # ]:           0 :             return ScriptHash(witprog);
      61                 :             :         } else {
      62                 :           0 :             return witdest;
      63                 :             :         }
      64                 :           0 :     }
      65                 :           0 :     case OutputType::BECH32M:
      66                 :           0 :     case OutputType::UNKNOWN: {} // This function should never be used with BECH32M or UNKNOWN, so let it assert
      67                 :             :     } // no default case, so the compiler can warn about missing cases
      68                 :           0 :     assert(false);
      69                 :             : }
      70                 :             : 
      71                 :         486 : std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey& key)
      72                 :             : {
      73                 :         486 :     PKHash keyid(key);
      74         [ +  - ]:         486 :     CTxDestination p2pkh{keyid};
      75         [ +  - ]:         486 :     if (key.IsCompressed()) {
      76         [ +  - ]:         486 :         CTxDestination segwit = WitnessV0KeyHash(keyid);
      77   [ +  -  +  - ]:         486 :         CTxDestination p2sh = ScriptHash(GetScriptForDestination(segwit));
      78         [ +  - ]:         486 :         return Vector(std::move(p2pkh), std::move(p2sh), std::move(segwit));
      79                 :         486 :     } else {
      80         [ #  # ]:           0 :         return Vector(std::move(p2pkh));
      81                 :             :     }
      82                 :         486 : }
      83                 :             : 
      84                 :          22 : CTxDestination AddAndGetDestinationForScript(FlatSigningProvider& keystore, const CScript& script, OutputType type)
      85                 :             : {
      86                 :             :     // Add script to keystore
      87                 :          22 :     keystore.scripts.emplace(CScriptID(script), script);
      88                 :             : 
      89      [ +  -  - ]:          22 :     switch (type) {
      90                 :          22 :     case OutputType::LEGACY:
      91                 :          22 :         return ScriptHash(script);
      92                 :           0 :     case OutputType::P2SH_SEGWIT:
      93                 :           0 :     case OutputType::BECH32: {
      94         [ #  # ]:           0 :         CTxDestination witdest = WitnessV0ScriptHash(script);
      95         [ #  # ]:           0 :         CScript witprog = GetScriptForDestination(witdest);
      96                 :             :         // Add the redeemscript, so that P2WSH and P2SH-P2WSH outputs are recognized as ours.
      97   [ #  #  #  # ]:           0 :         keystore.scripts.emplace(CScriptID(witprog), witprog);
      98         [ #  # ]:           0 :         if (type == OutputType::BECH32) {
      99                 :           0 :             return witdest;
     100                 :             :         } else {
     101         [ #  # ]:           0 :             return ScriptHash(witprog);
     102                 :             :         }
     103                 :           0 :     }
     104                 :           0 :     case OutputType::BECH32M:
     105                 :           0 :     case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
     106                 :             :     } // no default case, so the compiler can warn about missing cases
     107                 :           0 :     assert(false);
     108                 :             : }
     109                 :             : 
     110                 :        1459 : std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
     111         [ +  - ]:        1459 :     if (std::holds_alternative<PKHash>(dest) ||
     112         [ -  + ]:        1459 :         std::holds_alternative<ScriptHash>(dest)) {
     113                 :           0 :         return OutputType::LEGACY;
     114                 :             :     }
     115         [ +  + ]:        1459 :     if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
     116         [ +  + ]:        1455 :         std::holds_alternative<WitnessV0ScriptHash>(dest)) {
     117                 :           8 :         return OutputType::BECH32;
     118                 :             :     }
     119         [ +  + ]:        1451 :     if (std::holds_alternative<WitnessV1Taproot>(dest) ||
     120         [ +  + ]:        1444 :         std::holds_alternative<WitnessUnknown>(dest)) {
     121                 :         688 :         return OutputType::BECH32M;
     122                 :             :     }
     123                 :         763 :     return std::nullopt;
     124                 :             : }