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                 :          0 : std::optional<OutputType> ParseOutputType(const std::string& type)
      25                 :            : {
      26         [ #  # ]:          0 :     if (type == OUTPUT_TYPE_STRING_LEGACY) {
      27                 :          0 :         return OutputType::LEGACY;
      28         [ #  # ]:          0 :     } else if (type == OUTPUT_TYPE_STRING_P2SH_SEGWIT) {
      29                 :          0 :         return OutputType::P2SH_SEGWIT;
      30         [ #  # ]:          0 :     } else if (type == OUTPUT_TYPE_STRING_BECH32) {
      31                 :          0 :         return OutputType::BECH32;
      32         [ #  # ]:          0 :     } else if (type == OUTPUT_TYPE_STRING_BECH32M) {
      33                 :          0 :         return OutputType::BECH32M;
      34                 :            :     }
      35                 :          0 :     return std::nullopt;
      36                 :          0 : }
      37                 :            : 
      38                 :          0 : const std::string& FormatOutputType(OutputType type)
      39                 :            : {
      40   [ #  #  #  #  :          0 :     switch (type) {
                   #  # ]
      41                 :          0 :     case OutputType::LEGACY: return OUTPUT_TYPE_STRING_LEGACY;
      42                 :          0 :     case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
      43                 :          0 :     case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
      44                 :          0 :     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                 :          0 : }
      49                 :            : 
      50                 :          0 : CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
      51                 :            : {
      52   [ #  #  #  # ]:          0 :     switch (type) {
      53                 :          0 :     case OutputType::LEGACY: return PKHash(key);
      54                 :            :     case OutputType::P2SH_SEGWIT:
      55                 :            :     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                 :            :     case OutputType::BECH32M:
      66                 :            :     case OutputType::UNKNOWN: {} // This function should never be used with BECH32M or UNKNOWN, so let it assert
      67                 :          0 :     } // no default case, so the compiler can warn about missing cases
      68                 :          0 :     assert(false);
      69                 :          0 : }
      70                 :            : 
      71                 :          0 : std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey& key)
      72                 :            : {
      73                 :          0 :     PKHash keyid(key);
      74                 :          0 :     CTxDestination p2pkh{keyid};
      75 [ #  # ][ #  # ]:          0 :     if (key.IsCompressed()) {
      76         [ #  # ]:          0 :         CTxDestination segwit = WitnessV0KeyHash(keyid);
      77 [ #  # ][ #  # ]:          0 :         CTxDestination p2sh = ScriptHash(GetScriptForDestination(segwit));
      78         [ #  # ]:          0 :         return Vector(std::move(p2pkh), std::move(p2sh), std::move(segwit));
      79                 :          0 :     } else {
      80         [ #  # ]:          0 :         return Vector(std::move(p2pkh));
      81                 :            :     }
      82                 :          0 : }
      83                 :            : 
      84                 :          0 : CTxDestination AddAndGetDestinationForScript(FillableSigningProvider& keystore, const CScript& script, OutputType type)
      85                 :            : {
      86                 :            :     // Add script to keystore
      87                 :          0 :     keystore.AddCScript(script);
      88                 :            :     // Note that scripts over 520 bytes are not yet supported.
      89   [ #  #  #  # ]:          0 :     switch (type) {
      90                 :            :     case OutputType::LEGACY:
      91                 :          0 :         return ScriptHash(script);
      92                 :            :     case OutputType::P2SH_SEGWIT:
      93                 :            :     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.AddCScript(witprog);
      98         [ #  # ]:          0 :         if (type == OutputType::BECH32) {
      99                 :          0 :             return witdest;
     100                 :            :         } else {
     101         [ #  # ]:          0 :             return ScriptHash(witprog);
     102                 :            :         }
     103                 :          0 :     }
     104                 :            :     case OutputType::BECH32M:
     105                 :            :     case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
     106                 :          0 :     } // no default case, so the compiler can warn about missing cases
     107                 :          0 :     assert(false);
     108                 :          0 : }
     109                 :            : 
     110                 :         55 : std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
     111 [ +  - ][ -  + ]:         55 :     if (std::holds_alternative<PKHash>(dest) ||
     112                 :         55 :         std::holds_alternative<ScriptHash>(dest)) {
     113                 :          0 :         return OutputType::LEGACY;
     114                 :            :     }
     115 [ +  - ][ -  + ]:         55 :     if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
     116                 :         55 :         std::holds_alternative<WitnessV0ScriptHash>(dest)) {
     117                 :          0 :         return OutputType::BECH32;
     118                 :            :     }
     119 [ +  - ][ +  + ]:         55 :     if (std::holds_alternative<WitnessV1Taproot>(dest) ||
     120                 :         55 :         std::holds_alternative<WitnessUnknown>(dest)) {
     121                 :          5 :         return OutputType::BECH32M;
     122                 :            :     }
     123                 :         50 :     return std::nullopt;
     124                 :         55 : }