text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2014 The Bitcoin developers
  // Copyright (c) 2014-2015 The Dash developers
  // Copyright (c) 2015-2019 The PIVX developers
  // Copyright (c) 2021 The T-Notes developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef T_Notes_HASH_H
  #define T_Notes_HASH_H
  
  #include "crypto/ripemd160.h"
  #include "crypto/sha256.h"
  #include "prevector.h"
  #include "serialize.h"
  #include "uint256.h"
  #include "version.h"
  
  #include "crypto/sph_blake.h"
  #include "crypto/sph_bmw.h"
  #include "crypto/sph_groestl.h"
  #include "crypto/sph_jh.h"
  #include "crypto/sph_keccak.h"
  #include "crypto/sph_skein.h"
  #include "crypto/sha512.h"
  
  #include <iomanip>
  #include <openssl/sha.h>
  #include <sstream>
  #include <vector>
  
  #include <sodium.h>
  
  
  typedef uint256 ChainCode;
  
  /** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
  class CHash256
  {
  private:
      CSHA256 sha;
  
  public:
      static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
  
      void Finalize(unsigned char hash[OUTPUT_SIZE])
      {
          unsigned char buf[CSHA256::OUTPUT_SIZE];
          sha.Finalize(buf);
          sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
      }
  
      CHash256& Write(const unsigned char* data, size_t len)
      {
          sha.Write(data, len);
          return *this;
      }
  
      CHash256& Reset()
      {
          sha.Reset();
          return *this;
      }
  };
  
  class CHash512
  {
  private:
      CSHA512 sha;
  
  public:
      static const size_t OUTPUT_SIZE = CSHA512::OUTPUT_SIZE;
  
      void Finalize(unsigned char hash[OUTPUT_SIZE])
      {
          unsigned char buf[CSHA512::OUTPUT_SIZE];
          sha.Finalize(buf);
          sha.Reset().Write(buf, CSHA512::OUTPUT_SIZE).Finalize(hash);
      }
  
      CHash512& Write(const unsigned char* data, size_t len)
      {
          sha.Write(data, len);
          return *this;
      }
  
      CHash512& Reset()
      {
          sha.Reset();
          return *this;
      }
  };
  
  #ifdef GLOBALDEFINED
  #define GLOBAL
  #else
  #define GLOBAL extern
  #endif
  
  GLOBAL sph_blake512_context z_blake;
  GLOBAL sph_bmw512_context z_bmw;
  GLOBAL sph_groestl512_context z_groestl;
  GLOBAL sph_jh512_context z_jh;
  GLOBAL sph_keccak512_context z_keccak;
  GLOBAL sph_skein512_context z_skein;
  
  #define fillz()                          \
      do {                                 \
          sph_blake512_init(&z_blake);     \
          sph_bmw512_init(&z_bmw);         \
          sph_groestl512_init(&z_groestl); \
          sph_jh512_init(&z_jh);           \
          sph_keccak512_init(&z_keccak);   \
          sph_skein512_init(&z_skein);     \
      } while (0)
  
  #define ZBLAKE (memcpy(&ctx_blake, &z_blake, sizeof(z_blake)))
  #define ZBMW (memcpy(&ctx_bmw, &z_bmw, sizeof(z_bmw)))
  #define ZGROESTL (memcpy(&ctx_groestl, &z_groestl, sizeof(z_groestl)))
  #define ZJH (memcpy(&ctx_jh, &z_jh, sizeof(z_jh)))
  #define ZKECCAK (memcpy(&ctx_keccak, &z_keccak, sizeof(z_keccak)))
  #define ZSKEIN (memcpy(&ctx_skein, &z_skein, sizeof(z_skein)))
  
  /* ----------- Bitcoin Hash ------------------------------------------------- */
  /** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
  class CHash160
  {
  private:
      CSHA256 sha;
  
  public:
      static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
  
      void Finalize(unsigned char hash[OUTPUT_SIZE])
      {
          unsigned char buf[CSHA256::OUTPUT_SIZE];
          sha.Finalize(buf);
          CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
      }
  
      CHash160& Write(const unsigned char* data, size_t len)
      {
          sha.Write(data, len);
          return *this;
      }
  
      CHash160& Reset()
      {
          sha.Reset();
          return *this;
      }
  };
  
  /** Compute the 256-bit hash of a std::string */
  inline std::string Hash(std::string input)
  {
      unsigned char hash[SHA256_DIGEST_LENGTH];
      SHA256_CTX sha256;
      SHA256_Init(&sha256);
      SHA256_Update(&sha256, input.c_str(), input.size());
      SHA256_Final(hash, &sha256);
      std::stringstream ss;
      for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
          ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
      }
      return ss.str();
  }
  
  /** Compute the 256-bit hash of a void pointer */
  inline void Hash(void* in, unsigned int len, unsigned char* out)
  {
      SHA256_CTX sha256;
      SHA256_Init(&sha256);
      SHA256_Update(&sha256, in, len);
      SHA256_Final(out, &sha256);
  }
  
  /** Compute the 512-bit hash of an object. */
  template <typename T1>
  inline uint512 Hash512(const T1 pbegin, const T1 pend)
  {
      static const unsigned char pblank[1] = {};
      uint512 result;
      CHash512().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  template <typename T1, typename T2>
  inline uint512 Hash512(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end)
  {
      static const unsigned char pblank[1] = {};
      uint512 result;
      CHash512().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of an object. */
  template <typename T1>
  inline uint256 Hash(const T1 pbegin, const T1 pend)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of the concatenation of two objects. */
  template <typename T1, typename T2>
  inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of the concatenation of three objects. */
  template <typename T1, typename T2, typename T3>
  inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of the concatenation of three objects. */
  template <typename T1, typename T2, typename T3, typename T4>
  inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of the concatenation of three objects. */
  template <typename T1, typename T2, typename T3, typename T4, typename T5>
  inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end, const T5 p5begin, const T5 p5end)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 256-bit hash of the concatenation of three objects. */
  template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  inline uint256 Hash(const T1 p1begin, const T1 p1end, const T2 p2begin, const T2 p2end, const T3 p3begin, const T3 p3end, const T4 p4begin, const T4 p4end, const T5 p5begin, const T5 p5end, const T6 p6begin, const T6 p6end)
  {
      static const unsigned char pblank[1] = {};
      uint256 result;
      CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0])).Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0])).Write(p3begin == p3end ? pblank : (const unsigned char*)&p3begin[0], (p3end - p3begin) * sizeof(p3begin[0])).Write(p4begin == p4end ? pblank : (const unsigned char*)&p4begin[0], (p4end - p4begin) * sizeof(p4begin[0])).Write(p5begin == p5end ? pblank : (const unsigned char*)&p5begin[0], (p5end - p5begin) * sizeof(p5begin[0])).Write(p6begin == p6end ? pblank : (const unsigned char*)&p6begin[0], (p6end - p6begin) * sizeof(p6begin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 160-bit hash an object. */
  template <typename T1>
  inline uint160 Hash160(const T1 pbegin, const T1 pend)
  {
      static unsigned char pblank[1] = {};
      uint160 result;
      CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0])).Finalize((unsigned char*)&result);
      return result;
  }
  
  /** Compute the 160-bit hash of a vector. */
  inline uint160 Hash160(const std::vector<unsigned char>& vch)
  {
      return Hash160(vch.begin(), vch.end());
  }
  
  /** Compute the 160-bit hash of a vector. */
  template<unsigned int N>
  inline uint160 Hash160(const prevector<N, unsigned char>& vch)
  {
      return Hash160(vch.begin(), vch.end());
  }
  
  /** A writer stream (for serialization) that computes a 256-bit hash. */
  class CHashWriter
  {
  private:
      CHash256 ctx;
  
      const int nType;
      const int nVersion;
  
  public:
  
      CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
  
      int GetType() const { return nType; }
      int GetVersion() const { return nVersion; }
  
      void write(const char* pch, size_t size)
      {
          ctx.Write((const unsigned char*)pch, size);
      }
  
      // invalidates the object
      uint256 GetHash()
      {
          uint256 result;
          ctx.Finalize((unsigned char*)&result);
          return result;
      }
  
      template <typename T>
      CHashWriter& operator<<(const T& obj)
      {
          // Serialize to this stream
          ::Serialize(*this, obj);
          return (*this);
      }
  };
  
  /** Reads data from an underlying stream, while hashing the read data. */
  template<typename Source>
  class CHashVerifier : public CHashWriter
  {
  private:
      Source* source;
  
  public:
      CHashVerifier(Source* source_) : CHashWriter(source_->GetType(), source_->GetVersion()), source(source_) {}
  
      void read(char* pch, size_t nSize)
      {
          source->read(pch, nSize);
          this->write(pch, nSize);
      }
  
      void ignore(size_t nSize)
      {
          char data[1024];
          while (nSize > 0) {
              size_t now = std::min<size_t>(nSize, 1024);
              read(data, now);
              nSize -= now;
          }
      }
  
      template<typename T>
      CHashVerifier<Source>& operator>>(T& obj)
      {
          // Unserialize from this stream
          ::Unserialize(*this, obj);
          return (*this);
      }
  };
  
  /** Compute the 256-bit hash of an object's serialization. */
  template <typename T>
  uint256 SerializeHash(const T& obj, int nType = SER_GETHASH, int nVersion = PROTOCOL_VERSION)
  {
      CHashWriter ss(nType, nVersion);
      ss << obj;
      return ss.GetHash();
  }
  
  /** A writer stream (for serialization) that computes a 256-bit BLAKE2b hash. */
  class CBLAKE2bWriter
  {
  private:
      crypto_generichash_blake2b_state state;
  
  public:
      int nType;
      int nVersion;
  
      CBLAKE2bWriter(int nTypeIn, int nVersionIn, const unsigned char* personal) : nType(nTypeIn), nVersion(nVersionIn) {
          assert(crypto_generichash_blake2b_init_salt_personal(
              &state,
              NULL, 0, // No key.
              32,
              NULL,    // No salt.
              personal) == 0);
      }
  
      CBLAKE2bWriter& write(const char *pch, size_t size) {
          crypto_generichash_blake2b_update(&state, (const unsigned char*)pch, size);
          return (*this);
      }
  
      // invalidates the object
      uint256 GetHash() {
          uint256 result;
          crypto_generichash_blake2b_final(&state, (unsigned char*)&result, 32);
          return result;
      }
  
      template<typename T>
      CBLAKE2bWriter& operator<<(const T& obj) {
          // Serialize to this stream
          ::Serialize(*this, obj);
          return (*this);
      }
  };
  
  unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
  
  void BIP32Hash(const ChainCode chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
  
  //int HMAC_SHA512_Init(HMAC_SHA512_CTX *pctx, const void *pkey, size_t len);
  //int HMAC_SHA512_Update(HMAC_SHA512_CTX *pctx, const void *pdata, size_t len);
  //int HMAC_SHA512_Final(unsigned char *pmd, HMAC_SHA512_CTX *pctx);
  
  /* ----------- Quark Hash ------------------------------------------------ */
  template <typename T1>
  inline uint256 HashQuark(const T1 pbegin, const T1 pend)
  
  {
      sph_blake512_context ctx_blake;
      sph_bmw512_context ctx_bmw;
      sph_groestl512_context ctx_groestl;
      sph_jh512_context ctx_jh;
      sph_keccak512_context ctx_keccak;
      sph_skein512_context ctx_skein;
      static unsigned char pblank[1];
  
      uint512 mask = 8;
      uint512 zero = 0;
  
      uint512 hash[9];
  
      sph_blake512_init(&ctx_blake);
      // ZBLAKE;
      sph_blake512(&ctx_blake, (pbegin == pend ? pblank : static_cast<const void*>(&pbegin[0])), (pend - pbegin) * sizeof(pbegin[0]));
      sph_blake512_close(&ctx_blake, static_cast<void*>(&hash[0]));
  
      sph_bmw512_init(&ctx_bmw);
      // ZBMW;
      sph_bmw512(&ctx_bmw, static_cast<const void*>(&hash[0]), 64);
      sph_bmw512_close(&ctx_bmw, static_cast<void*>(&hash[1]));
  
      if ((hash[1] & mask) != zero) {
          sph_groestl512_init(&ctx_groestl);
          // ZGROESTL;
          sph_groestl512(&ctx_groestl, static_cast<const void*>(&hash[1]), 64);
          sph_groestl512_close(&ctx_groestl, static_cast<void*>(&hash[2]));
      } else {
          sph_skein512_init(&ctx_skein);
          // ZSKEIN;
          sph_skein512(&ctx_skein, static_cast<const void*>(&hash[1]), 64);
          sph_skein512_close(&ctx_skein, static_cast<void*>(&hash[2]));
      }
  
      sph_groestl512_init(&ctx_groestl);
      // ZGROESTL;
      sph_groestl512(&ctx_groestl, static_cast<const void*>(&hash[2]), 64);
      sph_groestl512_close(&ctx_groestl, static_cast<void*>(&hash[3]));
  
      sph_jh512_init(&ctx_jh);
      // ZJH;
      sph_jh512(&ctx_jh, static_cast<const void*>(&hash[3]), 64);
      sph_jh512_close(&ctx_jh, static_cast<void*>(&hash[4]));
  
      if ((hash[4] & mask) != zero) {
          sph_blake512_init(&ctx_blake);
          // ZBLAKE;
          sph_blake512(&ctx_blake, static_cast<const void*>(&hash[4]), 64);
          sph_blake512_close(&ctx_blake, static_cast<void*>(&hash[5]));
      } else {
          sph_bmw512_init(&ctx_bmw);
          // ZBMW;
          sph_bmw512(&ctx_bmw, static_cast<const void*>(&hash[4]), 64);
          sph_bmw512_close(&ctx_bmw, static_cast<void*>(&hash[5]));
      }
  
      sph_keccak512_init(&ctx_keccak);
      // ZKECCAK;
      sph_keccak512(&ctx_keccak, static_cast<const void*>(&hash[5]), 64);
      sph_keccak512_close(&ctx_keccak, static_cast<void*>(&hash[6]));
  
      sph_skein512_init(&ctx_skein);
      // SKEIN;
      sph_skein512(&ctx_skein, static_cast<const void*>(&hash[6]), 64);
      sph_skein512_close(&ctx_skein, static_cast<void*>(&hash[7]));
  
      if ((hash[7] & mask) != zero) {
          sph_keccak512_init(&ctx_keccak);
          // ZKECCAK;
          sph_keccak512(&ctx_keccak, static_cast<const void*>(&hash[7]), 64);
          sph_keccak512_close(&ctx_keccak, static_cast<void*>(&hash[8]));
      } else {
          sph_jh512_init(&ctx_jh);
          // ZJH;
          sph_jh512(&ctx_jh, static_cast<const void*>(&hash[7]), 64);
          sph_jh512_close(&ctx_jh, static_cast<void*>(&hash[8]));
      }
      return hash[8].trim256();
  }
  
  void scrypt_hash(const char* pass, unsigned int pLen, const char* salt, unsigned int sLen, char* output, unsigned int N, unsigned int r, unsigned int p, unsigned int dkLen);
  
  
  /** SipHash-2-4 */
  class CSipHasher
  {
  private:
      uint64_t v[4];
      uint64_t tmp;
      int count;
  
  public:
      /** Construct a SipHash calculator initialized with 128-bit key (k0, k1) */
      CSipHasher(uint64_t k0, uint64_t k1);
      /** Hash a 64-bit integer worth of data
       *  It is treated as if this was the little-endian interpretation of 8 bytes.
       *  This function can only be used when a multiple of 8 bytes have been written so far.
       */
      CSipHasher& Write(uint64_t data);
      /** Hash arbitrary bytes. */
      CSipHasher& Write(const unsigned char* data, size_t size);
      /** Compute the 64-bit SipHash-2-4 of the data written so far. The object remains untouched. */
      uint64_t Finalize() const;
  };
  
  
  /** Optimized SipHash-2-4 implementation for uint256.
   *
   *  It is identical to:
   *    SipHasher(k0, k1)
   *      .Write(val.GetUint64(0))
   *      .Write(val.GetUint64(1))
   *      .Write(val.GetUint64(2))
   *      .Write(val.GetUint64(3))
   *      .Finalize()
   */
  uint64_t SipHashUint256(uint64_t k0, uint64_t k1, const uint256& val);
  uint64_t SipHashUint256Extra(uint64_t k0, uint64_t k1, const uint256& val, uint32_t extra);
  
  #endif // T_Notes_HASH_H
  
  