src/addresstype.cpp

	// Copyright (c) 2023 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or https://www.opensource.org/licenses/mit-license.php.

	#include <addresstype.h>

	#include <crypto/sha256.h>
	#include <hash.h>
	#include <pubkey.h>
	#include <script/script.h>
	#include <script/solver.h>
	#include <uint256.h>
	#include <util/hash_type.h>

	#include <cassert>
	#include <vector>

	typedef std::vector<unsigned char> valtype;

	ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
	ScriptHash::ScriptHash(const CScriptID& in) : BaseHash{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{pubkey_hash} {}

	CKeyID ToKeyID(const PKHash& key_hash)
	{
	return CKeyID{uint160{key_hash}};
	}

	CKeyID ToKeyID(const WitnessV0KeyHash& key_hash)
	{
	return CKeyID{uint160{key_hash}};
	}

	CScriptID ToScriptID(const ScriptHash& script_hash)
	{
	return CScriptID{uint160{script_hash}};
	}

	WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
	{
	CSHA256().Write(in.data(), in.size()).Finalize(begin());
	}

	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()) {
	addressRet = CNoDestination(scriptPubKey);
	} else {
	addressRet = PubKeyDestination(pubKey);
	}
	return false;
	}
	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::ANCHOR: {
	addressRet = PayToAnchor();
	return true;
	}
	case TxoutType::WITNESS_UNKNOWN: {
	addressRet = WitnessUnknown{vSolutions[0][0], vSolutions[1]};
	return true;
	}
	case TxoutType::MULTISIG:
	case TxoutType::NULL_DATA:
	case TxoutType::NONSTANDARD:
	addressRet = CNoDestination(scriptPubKey);
	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 dest.GetScript();
	}

	CScript operator()(const PubKeyDestination& dest) const
	{
	return CScript() << ToByteVector(dest.GetPubKey()) << OP_CHECKSIG;
	}

	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.GetWitnessVersion()) << id.GetWitnessProgram();
	}
	};

	class ValidDestinationVisitor
	{
	public:
	bool operator()(const CNoDestination& dest) const { return false; }
	bool operator()(const PubKeyDestination& dest) const { return false; }
	bool operator()(const PKHash& dest) const { return true; }
	bool operator()(const ScriptHash& dest) const { return true; }
	bool operator()(const WitnessV0KeyHash& dest) const { return true; }
	bool operator()(const WitnessV0ScriptHash& dest) const { return true; }
	bool operator()(const WitnessV1Taproot& dest) const { return true; }
	bool operator()(const WitnessUnknown& dest) const { return true; }
	};
	} // namespace

	CScript GetScriptForDestination(const CTxDestination& dest)
	{
	return std::visit(CScriptVisitor(), dest);
	}

	bool IsValidDestination(const CTxDestination& dest) {
	return std::visit(ValidDestinationVisitor(), dest);
	}

Bitcoin