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           2 : static const std::string OUTPUT_TYPE_STRING_LEGACY = "legacy";
      19           2 : static const std::string OUTPUT_TYPE_STRING_P2SH_SEGWIT = "p2sh-segwit";
      20           2 : static const std::string OUTPUT_TYPE_STRING_BECH32 = "bech32";
      21           2 : static const std::string OUTPUT_TYPE_STRING_BECH32M = "bech32m";
      22           2 : 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           1 : const std::string& FormatOutputType(OutputType type)
      39             : {
      40           1 :     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           1 :     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           1 : }
      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           0 : std::optional<OutputType> OutputTypeFromDestination(const CTxDestination& dest) {
     111           0 :     if (std::holds_alternative<PKHash>(dest) ||
     112           0 :         std::holds_alternative<ScriptHash>(dest)) {
     113           0 :         return OutputType::LEGACY;
     114             :     }
     115           0 :     if (std::holds_alternative<WitnessV0KeyHash>(dest) ||
     116           0 :         std::holds_alternative<WitnessV0ScriptHash>(dest)) {
     117           0 :         return OutputType::BECH32;
     118             :     }
     119           0 :     if (std::holds_alternative<WitnessV1Taproot>(dest) ||
     120           0 :         std::holds_alternative<WitnessUnknown>(dest)) {
     121           0 :         return OutputType::BECH32M;
     122             :     }
     123           0 :     return std::nullopt;
     124           0 : }