Move CTxDestination to its own file

CTxDestination is really our internal representation of an address and
doesn't really have anything to do with standard script types, so move
them to their own file.

3 files changed, 1 insertions, 240 deletions

diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index 26886e0d57..40927f57bc 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_SCRIPT_SIGNINGPROVIDER_H
 #define BITCOIN_SCRIPT_SIGNINGPROVIDER_H
 
+#include <addresstype.h>
 #include <attributes.h>
 #include <key.h>
 #include <pubkey.h>
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 01b074e27c..6cbcf9a016 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -16,35 +16,6 @@
 
 typedef std::vector<unsigned char> valtype;
 
-ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
-ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
-
-PKHash::PKHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
-PKHash::PKHash(const CKeyID& pubkey_id) : BaseHash(pubkey_id) {}
-
-WitnessV0KeyHash::WitnessV0KeyHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
-WitnessV0KeyHash::WitnessV0KeyHash(const PKHash& pubkey_hash) : BaseHash(static_cast<uint160>(pubkey_hash)) {}
-
-CKeyID ToKeyID(const PKHash& key_hash)
-{
-    return CKeyID{static_cast<uint160>(key_hash)};
-}
-
-CKeyID ToKeyID(const WitnessV0KeyHash& key_hash)
-{
-    return CKeyID{static_cast<uint160>(key_hash)};
-}
-
-CScriptID ToScriptID(const ScriptHash& script_hash)
-{
-    return CScriptID{static_cast<uint160>(script_hash)};
-}
-
-WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
-{
-    CSHA256().Write(in.data(), in.size()).Finalize(begin());
-}
-
 std::string GetTxnOutputType(TxoutType t)
 {
     switch (t) {
@@ -236,108 +207,6 @@ TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned c
     return TxoutType::NONSTANDARD;
 }
 
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
-{
-    std::vector<valtype> vSolutions;
-    TxoutType whichType = Solver(scriptPubKey, vSolutions);
-
-    switch (whichType) {
-    case TxoutType::PUBKEY: {
-        CPubKey pubKey(vSolutions[0]);
-        if (!pubKey.IsValid())
-            return false;
-
-        addressRet = PKHash(pubKey);
-        return true;
-    }
-    case TxoutType::PUBKEYHASH: {
-        addressRet = PKHash(uint160(vSolutions[0]));
-        return true;
-    }
-    case TxoutType::SCRIPTHASH: {
-        addressRet = ScriptHash(uint160(vSolutions[0]));
-        return true;
-    }
-    case TxoutType::WITNESS_V0_KEYHASH: {
-        WitnessV0KeyHash hash;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
-        addressRet = hash;
-        return true;
-    }
-    case TxoutType::WITNESS_V0_SCRIPTHASH: {
-        WitnessV0ScriptHash hash;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
-        addressRet = hash;
-        return true;
-    }
-    case TxoutType::WITNESS_V1_TAPROOT: {
-        WitnessV1Taproot tap;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
-        addressRet = tap;
-        return true;
-    }
-    case TxoutType::WITNESS_UNKNOWN: {
-        WitnessUnknown unk;
-        unk.version = vSolutions[0][0];
-        std::copy(vSolutions[1].begin(), vSolutions[1].end(), unk.program);
-        unk.length = vSolutions[1].size();
-        addressRet = unk;
-        return true;
-    }
-    case TxoutType::MULTISIG:
-    case TxoutType::NULL_DATA:
-    case TxoutType::NONSTANDARD:
-        return false;
-    } // no default case, so the compiler can warn about missing cases
-    assert(false);
-}
-
-namespace {
-class CScriptVisitor
-{
-public:
-    CScript operator()(const CNoDestination& dest) const
-    {
-        return CScript();
-    }
-
-    CScript operator()(const PKHash& keyID) const
-    {
-        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
-    }
-
-    CScript operator()(const ScriptHash& scriptID) const
-    {
-        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
-    }
-
-    CScript operator()(const WitnessV0KeyHash& id) const
-    {
-        return CScript() << OP_0 << ToByteVector(id);
-    }
-
-    CScript operator()(const WitnessV0ScriptHash& id) const
-    {
-        return CScript() << OP_0 << ToByteVector(id);
-    }
-
-    CScript operator()(const WitnessV1Taproot& tap) const
-    {
-        return CScript() << OP_1 << ToByteVector(tap);
-    }
-
-    CScript operator()(const WitnessUnknown& id) const
-    {
-        return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
-    }
-};
-} // namespace
-
-CScript GetScriptForDestination(const CTxDestination& dest)
-{
-    return std::visit(CScriptVisitor(), dest);
-}
-
 CScript GetScriptForRawPubKey(const CPubKey& pubKey)
 {
     return CScript() << std::vector<unsigned char>(pubKey.begin(), pubKey.end()) << OP_CHECKSIG;
@@ -354,7 +223,3 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
 
     return script;
 }
-
-bool IsValidDestination(const CTxDestination& dest) {
-    return dest.index() != 0;
-}
diff --git a/src/script/standard.h b/src/script/standard.h
index 9555cc2b61..097ab92652 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -18,7 +18,6 @@
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
-class CKeyID;
 class CScript;
 
 /**
@@ -41,96 +40,6 @@ enum class TxoutType {
     WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
 };
 
-class CNoDestination {
-public:
-    friend bool operator==(const CNoDestination &a, const CNoDestination &b) { return true; }
-    friend bool operator<(const CNoDestination &a, const CNoDestination &b) { return true; }
-};
-
-struct PKHash : public BaseHash<uint160>
-{
-    PKHash() : BaseHash() {}
-    explicit PKHash(const uint160& hash) : BaseHash(hash) {}
-    explicit PKHash(const CPubKey& pubkey);
-    explicit PKHash(const CKeyID& pubkey_id);
-};
-CKeyID ToKeyID(const PKHash& key_hash);
-
-struct WitnessV0KeyHash;
-struct ScriptHash : public BaseHash<uint160>
-{
-    ScriptHash() : BaseHash() {}
-    // These don't do what you'd expect.
-    // Use ScriptHash(GetScriptForDestination(...)) instead.
-    explicit ScriptHash(const WitnessV0KeyHash& hash) = delete;
-    explicit ScriptHash(const PKHash& hash) = delete;
-
-    explicit ScriptHash(const uint160& hash) : BaseHash(hash) {}
-    explicit ScriptHash(const CScript& script);
-    explicit ScriptHash(const CScriptID& script);
-};
-CScriptID ToScriptID(const ScriptHash& script_hash);
-
-struct WitnessV0ScriptHash : public BaseHash<uint256>
-{
-    WitnessV0ScriptHash() : BaseHash() {}
-    explicit WitnessV0ScriptHash(const uint256& hash) : BaseHash(hash) {}
-    explicit WitnessV0ScriptHash(const CScript& script);
-};
-
-struct WitnessV0KeyHash : public BaseHash<uint160>
-{
-    WitnessV0KeyHash() : BaseHash() {}
-    explicit WitnessV0KeyHash(const uint160& hash) : BaseHash(hash) {}
-    explicit WitnessV0KeyHash(const CPubKey& pubkey);
-    explicit WitnessV0KeyHash(const PKHash& pubkey_hash);
-};
-CKeyID ToKeyID(const WitnessV0KeyHash& key_hash);
-
-struct WitnessV1Taproot : public XOnlyPubKey
-{
-    WitnessV1Taproot() : XOnlyPubKey() {}
-    explicit WitnessV1Taproot(const XOnlyPubKey& xpk) : XOnlyPubKey(xpk) {}
-};
-
-//! CTxDestination subtype to encode any future Witness version
-struct WitnessUnknown
-{
-    unsigned int version;
-    unsigned int length;
-    unsigned char program[40];
-
-    friend bool operator==(const WitnessUnknown& w1, const WitnessUnknown& w2) {
-        if (w1.version != w2.version) return false;
-        if (w1.length != w2.length) return false;
-        return std::equal(w1.program, w1.program + w1.length, w2.program);
-    }
-
-    friend bool operator<(const WitnessUnknown& w1, const WitnessUnknown& w2) {
-        if (w1.version < w2.version) return true;
-        if (w1.version > w2.version) return false;
-        if (w1.length < w2.length) return true;
-        if (w1.length > w2.length) return false;
-        return std::lexicographical_compare(w1.program, w1.program + w1.length, w2.program, w2.program + w2.length);
-    }
-};
-
-/**
- * A txout script template with a specific destination. It is either:
- *  * CNoDestination: no destination set
- *  * PKHash: TxoutType::PUBKEYHASH destination (P2PKH)
- *  * ScriptHash: TxoutType::SCRIPTHASH destination (P2SH)
- *  * WitnessV0ScriptHash: TxoutType::WITNESS_V0_SCRIPTHASH destination (P2WSH)
- *  * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH)
- *  * WitnessV1Taproot: TxoutType::WITNESS_V1_TAPROOT destination (P2TR)
- *  * WitnessUnknown: TxoutType::WITNESS_UNKNOWN destination (P2W???)
- *  A CTxDestination is the internal data type encoded in a bitcoin address
- */
-using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown>;
-
-/** Check whether a CTxDestination is a CNoDestination. */
-bool IsValidDestination(const CTxDestination& dest);
-
 /** Get the name of a TxoutType as a string */
 std::string GetTxnOutputType(TxoutType t);
 
@@ -151,20 +60,6 @@ constexpr bool IsPushdataOp(opcodetype opcode)
  */
 TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned char>>& vSolutionsRet);
 
-/**
- * Parse a standard scriptPubKey for the destination address. Assigns result to
- * the addressRet parameter and returns true if successful. Currently only works for P2PK,
- * P2PKH, P2SH, P2WPKH, and P2WSH scripts.
- */
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet);
-
-/**
- * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
- * script for a CKeyID destination, a P2SH script for a CScriptID, and an empty
- * script for CNoDestination.
- */
-CScript GetScriptForDestination(const CTxDestination& dest);
-
 /** Generate a P2PK script for the given pubkey. */
 CScript GetScriptForRawPubKey(const CPubKey& pubkey);