text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2017 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 <pubkey.h>
  
  //#include <script/interpreter.h>
  #include <uint256.h>
  
  #include <boost/variant.hpp>
  
  #include <stdint.h>
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////// 
  /** Script verification flags.
   *
   *  All flags are intended to be soft forks: the set of acceptable scripts under
   *  flags (A | B) is a subset of the acceptable scripts under flag (A).
   */
  enum
  {
      SCRIPT_VERIFY_NONE      = 0,
  
      // Evaluate P2SH subscripts (BIP16).
      SCRIPT_VERIFY_P2SH      = (1U << 0),
  
      // Passing a non-strict-DER signature or one with undefined hashtype to a checksig operation causes script failure.
      // Evaluating a pubkey that is not (0x04 + 64 bytes) or (0x02 or 0x03 + 32 bytes) by checksig causes script failure.
      // (not used or intended as a consensus rule).
      SCRIPT_VERIFY_STRICTENC = (1U << 1),
  
      // Passing a non-strict-DER signature to a checksig operation causes script failure (BIP62 rule 1)
      SCRIPT_VERIFY_DERSIG    = (1U << 2),
  
      // Passing a non-strict-DER signature or one with S > order/2 to a checksig operation causes script failure
      // (BIP62 rule 5).
      SCRIPT_VERIFY_LOW_S     = (1U << 3),
  
      // verify dummy stack item consumed by CHECKMULTISIG is of zero-length (BIP62 rule 7).
      SCRIPT_VERIFY_NULLDUMMY = (1U << 4),
  
      // Using a non-push operator in the scriptSig causes script failure (BIP62 rule 2).
      SCRIPT_VERIFY_SIGPUSHONLY = (1U << 5),
  
      // Require minimal encodings for all push operations (OP_0... OP_16, OP_1NEGATE where possible, direct
      // pushes up to 75 bytes, OP_PUSHDATA up to 255 bytes, OP_PUSHDATA2 for anything larger). Evaluating
      // any other push causes the script to fail (BIP62 rule 3).
      // In addition, whenever a stack element is interpreted as a number, it must be of minimal length (BIP62 rule 4).
      SCRIPT_VERIFY_MINIMALDATA = (1U << 6),
  
      // Discourage use of NOPs reserved for upgrades (NOP1-10)
      //
      // Provided so that nodes can avoid accepting or mining transactions
      // containing executed NOP's whose meaning may change after a soft-fork,
      // thus rendering the script invalid; with this flag set executing
      // discouraged NOPs fails the script. This verification flag will never be
      // a mandatory flag applied to scripts in a block. NOPs that are not
      // executed, e.g.  within an unexecuted IF ENDIF block, are *not* rejected.
      // NOPs that have associated forks to give them new meaning (CLTV, CSV)
      // are not subject to this rule.
      SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS  = (1U << 7),
  
      // Require that only a single stack element remains after evaluation. This changes the success criterion from
      // "At least one stack element must remain, and when interpreted as a boolean, it must be true" to
      // "Exactly one stack element must remain, and when interpreted as a boolean, it must be true".
      // (BIP62 rule 6)
      // Note: CLEANSTACK should never be used without P2SH or WITNESS.
      SCRIPT_VERIFY_CLEANSTACK = (1U << 8),
  
      // Verify CHECKLOCKTIMEVERIFY
      //
      // See BIP65 for details.
      SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = (1U << 9),
  
      // support CHECKSEQUENCEVERIFY opcode
      //
      // See BIP112 for details
      SCRIPT_VERIFY_CHECKSEQUENCEVERIFY = (1U << 10),
  
      // Support segregated witness
      //
      SCRIPT_VERIFY_WITNESS = (1U << 11),
  
      // Making v1-v16 witness program non-standard
      //
      SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM = (1U << 12),
  
      // Segwit script only: Require the argument of OP_IF/NOTIF to be exactly 0x01 or empty vector
      //
      SCRIPT_VERIFY_MINIMALIF = (1U << 13),
  
      // Signature(s) must be empty vector if an CHECK(MULTI)SIG operation failed
      //
      SCRIPT_VERIFY_NULLFAIL = (1U << 14),
  
      // Public keys in segregated witness scripts must be compressed
      //
      SCRIPT_VERIFY_WITNESS_PUBKEYTYPE = (1U << 15),
  };
  ///////////////////////////////////////////////////////////////////////////////////////////////////// 
  
  static const bool DEFAULT_ACCEPT_DATACARRIER = true;
  
  class CKeyID;
  class CScript;
  
  /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
  class CScriptID : public uint160
  {
  public:
      CScriptID() : uint160() {}
      CScriptID(const CScript& in);
      CScriptID(const uint160& in) : uint160(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 TX_NULL_DATA.
   */
  extern bool fAcceptDatacarrier;
  
  /** Maximum size of TX_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, such as a soft-fork to enforce
   * strict DER encoding.
   *
   * Failing one of these tests may trigger a DoS ban - see CheckInputs() for
   * details.
   */
  static const unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH;
  
  enum txnouttype
  {
      TX_NONSTANDARD,
      // 'standard' transaction types:
      TX_PUBKEY,
      TX_PUBKEYHASH,
      TX_SCRIPTHASH,
      TX_MULTISIG,
      TX_NULL_DATA, //!< unspendable OP_RETURN script that carries data
      TX_WITNESS_V0_SCRIPTHASH,
      TX_WITNESS_V0_KEYHASH,
      TX_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 WitnessV0ScriptHash : public uint256
  {
      WitnessV0ScriptHash() : uint256() {}
      explicit WitnessV0ScriptHash(const uint256& hash) : uint256(hash) {}
      using uint256::uint256;
  };
  
  struct WitnessV0KeyHash : public uint160
  {
      WitnessV0KeyHash() : uint160() {}
      explicit WitnessV0KeyHash(const uint160& hash) : uint160(hash) {}
      using uint160::uint160;
  };
  
  //! 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
   *  * CKeyID: TX_PUBKEYHASH destination (P2PKH)
   *  * CScriptID: TX_SCRIPTHASH destination (P2SH)
   *  * WitnessV0ScriptHash: TX_WITNESS_V0_SCRIPTHASH destination (P2WSH)
   *  * WitnessV0KeyHash: TX_WITNESS_V0_KEYHASH destination (P2WPKH)
   *  * WitnessUnknown: TX_WITNESS_UNKNOWN destination (P2W???)
   *  A CTxDestination is the internal data type encoded in a bitcoin address
   */
  typedef boost::variant<CNoDestination, CKeyID, CScriptID, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown> CTxDestination;
  
  /** Check whether a CTxDestination is a CNoDestination. */
  bool IsValidDestination(const CTxDestination& dest);
  
  /** Get the name of a txnouttype as a C string, or nullptr if unknown. */
  const char* GetTxnOutputType(txnouttype 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]  typeRet        The script type
   * @param[out]  vSolutionsRet  Vector of parsed pubkeys and hashes
   * @return                     True if script matches standard template
   */
  bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, 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. Currently does not extract address from
   * pay-to-witness scripts.
   *
   * 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, txnouttype& 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);
  
  /**
   * Generate a pay-to-witness script for the given redeem script. If the redeem
   * script is P2PK or P2PKH, this returns a P2WPKH script, otherwise it returns a
   * P2WSH script.
   *
   * TODO: replace calls to GetScriptForWitness with GetScriptForDestination using
   * the various witness-specific CTxDestination subtypes.
   */
  CScript GetScriptForWitness(const CScript& redeemscript);
  
  #endif // BITCOIN_SCRIPT_STANDARD_H
  