Branch data     Line data    Source code

       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                 :           0 : std::optional<OutputType> ParseOutputType(const std::string& type)
      24                 :             : {
      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                 :             :     }
      34                 :           0 :     return std::nullopt;
      35                 :             : }
      36                 :             : 
      37                 :         894 : const std::string& FormatOutputType(OutputType type)
      38                 :             : {
      39   [ +  +  +  -  :         894 :     switch (type) {
                   -  + ]
      40                 :             :     case OutputType::LEGACY: return OUTPUT_TYPE_STRING_LEGACY;
      41                 :          72 :     case OutputType::P2SH_SEGWIT: return OUTPUT_TYPE_STRING_P2SH_SEGWIT;
      42                 :         678 :     case OutputType::BECH32: return OUTPUT_TYPE_STRING_BECH32;
      43                 :          72 :     case OutputType::BECH32M: return OUTPUT_TYPE_STRING_BECH32M;
      44                 :           0 :     case OutputType::UNKNOWN: return OUTPUT_TYPE_STRING_UNKNOWN;
      45                 :             :     } // no default case, so the compiler can warn about missing cases
      46                 :           0 :     assert(false);
      47                 :             : }
      48                 :             : 
      49                 :           0 : CTxDestination AddAndGetDestinationForScript(FlatSigningProvider& keystore, const CScript& script, OutputType type)
      50                 :             : {
      51                 :             :     // Add script to keystore
      52                 :           0 :     keystore.scripts.emplace(CScriptID(script), script);
      53                 :             : 
      54      [ #  #  # ]:           0 :     switch (type) {
      55                 :           0 :     case OutputType::LEGACY:
      56                 :           0 :         return ScriptHash(script);
      57                 :           0 :     case OutputType::P2SH_SEGWIT:
      58                 :           0 :     case OutputType::BECH32: {
      59         [ #  # ]:           0 :         CTxDestination witdest = WitnessV0ScriptHash(script);
      60         [ #  # ]:           0 :         CScript witprog = GetScriptForDestination(witdest);
      61                 :             :         // Add the redeemscript, so that P2WSH and P2SH-P2WSH outputs are recognized as ours.
      62   [ #  #  #  # ]:           0 :         keystore.scripts.emplace(CScriptID(witprog), witprog);
      63         [ #  # ]:           0 :         if (type == OutputType::BECH32) {
      64                 :           0 :             return witdest;
      65                 :             :         } else {
      66         [ #  # ]:           0 :             return ScriptHash(witprog);
      67                 :             :         }
      68                 :           0 :     }
      69                 :           0 :     case OutputType::BECH32M:
      70                 :           0 :     case OutputType::UNKNOWN: {} // This function should not be used for BECH32M or UNKNOWN, so let it assert
      71                 :             :     } // no default case, so the compiler can warn about missing cases
      72                 :           0 :     assert(false);
      73                 :             : }
      74                 :             : 
      75                 :         124 : std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
      76         [ +  - ]:         124 :     if (std::holds_alternative<PKHash>(dest) ||
      77         [ -  + ]:         124 :         std::holds_alternative<ScriptHash>(dest)) {
      78                 :           0 :         return OutputType::LEGACY;
      79                 :             :     }
      80         [ -  + ]:         124 :     if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
      81         [ #  # ]:           0 :         std::holds_alternative<WitnessV0ScriptHash>(dest)) {
      82                 :         124 :         return OutputType::BECH32;
      83                 :             :     }
      84         [ #  # ]:           0 :     if (std::holds_alternative<WitnessV1Taproot>(dest) ||
      85         [ #  # ]:           0 :         std::holds_alternative<WitnessUnknown>(dest)) {
      86                 :           0 :         return OutputType::BECH32M;
      87                 :             :     }
      88                 :           0 :     return std::nullopt;
      89                 :             : }