text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2020 The TNGC Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef TNGC_SCRIPT_STANDARD_H
  #define TNGC_SCRIPT_STANDARD_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_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 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)
   *  * WitnessUnknown: TxoutType::WITNESS_UNKNOWN/WITNESS_V1_TAPROOT destination (P2W???)
   *    (taproot outputs do not require their own type as long as no wallet support exists)
   *  A CTxDestination is the internal data type encoded in a tngc address
   */
  typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown> 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 TNGC 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);
  
  #endif // TNGC_SCRIPT_STANDARD_H
  