git / moonbite-core / src/script/standard.h · raw
// Copyright (c) 2009-2010 Satoshi Nakamoto// Copyright (c) 2009-2020 The Bitcoin Core developers// Distributed under the MIT software license, see the accompanying// file COPYING or http://www.opensource.org/licenses/mit-license.php.#ifndef BITCOIN_SCRIPT_STANDARD_H#define BITCOIN_SCRIPT_STANDARD_H#include <mw/models/wallet/StealthAddress.h>#include <script/interpreter.h>#include <uint256.h>#include <boost/variant.hpp>#include <string>static const bool DEFAULT_ACCEPT_DATACARRIER = true;class CKeyID;class CScript;struct ScriptHash;template<typename HashType>class BaseHash{protected: HashType m_hash;public: BaseHash() : m_hash() {} BaseHash(const HashType& in) : m_hash(in) {} unsigned char* begin() { return m_hash.begin(); } const unsigned char* begin() const { return m_hash.begin(); } unsigned char* end() { return m_hash.end(); } const unsigned char* end() const { return m_hash.end(); } operator std::vector<unsigned char>() const { return std::vector<unsigned char>{m_hash.begin(), m_hash.end()}; } std::string ToString() const { return m_hash.ToString(); } bool operator==(const BaseHash<HashType>& other) const noexcept { return m_hash == other.m_hash; } bool operator!=(const BaseHash<HashType>& other) const noexcept { return !(m_hash == other.m_hash); } bool operator<(const BaseHash<HashType>& other) const noexcept { return m_hash < other.m_hash; } size_t size() const { return m_hash.size(); } unsigned char* data() { return m_hash.data(); } const unsigned char* data() const { return m_hash.data(); }};/** A reference to a CScript: the Hash160 of its serialization (see script.h) */class CScriptID : public BaseHash<uint160>{public: CScriptID() : BaseHash() {} explicit CScriptID(const CScript& in); explicit CScriptID(const uint160& in) : BaseHash(in) {} explicit CScriptID(const ScriptHash& in);};/** * Default setting for nMaxDatacarrierBytes. 80 bytes of data, +1 for OP_RETURN, * +2 for the pushdata opcodes. */static const unsigned int MAX_OP_RETURN_RELAY = 83;/** * A data carrying output is an unspendable output containing data. The script * type is designated as TxoutType::NULL_DATA. */extern bool fAcceptDatacarrier;/** Maximum size of TxoutType::NULL_DATA scripts that this node considers standard. */extern unsigned nMaxDatacarrierBytes;/** * Mandatory script verification flags that all new blocks must comply with for * them to be valid. (but old blocks may not comply with) Currently just P2SH, * but in the future other flags may be added. * * Failing one of these tests may trigger a DoS ban - see CheckInputScripts() for * details. */static const unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH;enum class TxoutType { NONSTANDARD, // 'standard' transaction types: PUBKEY, PUBKEYHASH, SCRIPTHASH, MULTISIG, NULL_DATA, //!< unspendable OP_RETURN script that carries data WITNESS_V0_SCRIPTHASH, WITNESS_V0_KEYHASH, WITNESS_V1_TAPROOT, WITNESS_MWEB_PEGIN, //!< Hash of the peg-in kernel WITNESS_MWEB_HOGADDR, //!< HogAddr (first output of HogEx) 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);};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);//! CTxDestination subtype to encode any future Witness versionstruct 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) * * WitnessUnknown: TxoutType::WITNESS_UNKNOWN/WITNESS_V1_TAPROOT destination (P2W???) * (taproot outputs do not require their own type as long as no wallet support exists) * * StealthAddress: MWEB destination * A CTxDestination is the internal data type encoded in a bitcoin address */typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown, StealthAddress> CTxDestination;/** 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);/** * Parse a scriptPubKey and identify script type for standard scripts. If * successful, returns script type and parsed pubkeys or hashes, depending on * the type. For example, for a P2SH script, vSolutionsRet will contain the * script hash, for P2PKH it will contain the key hash, etc. * * @param[in] scriptPubKey Script to parse * @param[out] vSolutionsRet Vector of parsed pubkeys and hashes * @return The script type. TxoutType::NONSTANDARD represents a failed solve. */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. For multisig * scripts, instead use ExtractDestinations. Currently only works for P2PK, * P2PKH, P2SH, P2WPKH, and P2WSH scripts. */bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet);/** * Parse a standard scriptPubKey with one or more destination addresses. For * multisig scripts, this populates the addressRet vector with the pubkey IDs * and nRequiredRet with the n required to spend. For other destinations, * addressRet is populated with a single value and nRequiredRet is set to 1. * Returns true if successful. * * Note: this function confuses destinations (a subset of CScripts that are * encodable as an address) with key identifiers (of keys involved in a * CScript), and its use should be phased out. */bool ExtractDestinations(const CScript& scriptPubKey, TxoutType& typeRet, std::vector<CTxDestination>& addressRet, int& nRequiredRet);/** * 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);/** Generate a multisig script. */CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);bool IsPegInOutput(const CTxOutput& output);CScript GetScriptForPegin(const mw::Hash& kernel_id);#include <script/address.h>#endif // BITCOIN_SCRIPT_STANDARD_H