text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2014 The Bitcoin developers
  // Copyright (c) 2014-2015 The Dash developers
  // Copyright (c) 2015-2017 The PIVX developers
  // Copyright (c) 2017-2018 The Solaris developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef HASH_H
  #define HASH_H
  
  #include "crypto/ripemd160.h"
  #include "crypto/sha256.h"
  #include "serialize.h"
  #include "uint256.h"
  #include "version.h"
  #include "util.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/sph_luffa.h"
  #include "crypto/sph_cubehash.h" 
  #include "crypto/sph_shavite.h"
  #include "crypto/sph_simd.h"
  #include "crypto/sph_echo.h" 
  #include "crypto/sph_hamsi.h"  
  #include "crypto/sph_fugue.h" 
  #include "crypto/sph_shabal.h"  
  #include "crypto/sph_whirlpool.h"  
  #include "crypto/sph_sha2.h"  
  #include "crypto/sph_haval.h"  
  
  #include <iomanip>
  #include <openssl/sha.h>
  #include <sstream>
  #include <vector>
  using namespace std;
  typedef uint256 ChainCode;
  
  #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;
  GLOBAL sph_luffa512_context     z_luffa;
  GLOBAL sph_cubehash512_context  z_cubehash;
  GLOBAL sph_shavite512_context   z_shavite;
  GLOBAL sph_simd512_context      z_simd;
  GLOBAL sph_echo512_context      z_echo;
  GLOBAL sph_hamsi512_context     z_hamsi;
  GLOBAL sph_fugue512_context     z_fugue;
  GLOBAL sph_shabal512_context    z_shabal;
  GLOBAL sph_whirlpool_context    z_whirlpool;
  GLOBAL sph_sha512_context       z_sha2;
  GLOBAL sph_haval256_5_context   z_haval;
  
  #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); \
      sph_luffa512_init(&z_luffa); \
      sph_cubehash512_init(&z_cubehash); \
      sph_shavite512_init(&z_shavite); \
      sph_simd512_init(&z_simd); \
      sph_echo512_init(&z_echo); \
      sph_hamsi512_init(&z_hamsi); \
      sph_fugue512_init(&z_fugue); \
      sph_shabal512_init(&z_shabal); \
      sph_whirlpool_init(&z_whirlpool); \
      sph_sha512_init(&z_sha2); \
      sph_haval256_5_init(&z_haval); \
  } 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)))
  #define ZHAMSI (memcpy(&ctx_hamsi, &z_hamsi, sizeof(z_hamsi)))
  #define ZFUGUE (memcpy(&ctx_fugue, &z_fugue, sizeof(z_fugue)))
  #define ZSHABAL (memcpy(&ctx_shabal, &z_shabal, sizeof(z_shabal)))
  #define ZWHIRLPOOL (memcpy(&ctx_whirlpool, &z_whirlpool, sizeof(z_whirlpool)))
  #define ZSHA2 (memcpy(&ctx_sha2, &z_sha2, sizeof(z_sha2)))
  #define ZHAVAL (memcpy(&ctx_haval, &z_haval, sizeof(z_haval)))
  
  /** 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[sha.OUTPUT_SIZE];
          sha.Finalize(buf);
          sha.Reset().Write(buf, sha.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;
      }
  };
  
  /** 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[sha.OUTPUT_SIZE];
          sha.Finalize(buf);
          CRIPEMD160().Write(buf, sha.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;
      }
  };
  
  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 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());
  }
  
  /** A writer stream (for serialization) that computes a 256-bit hash. */
  class CHashWriter
  {
  private:
      CHash256 ctx;
  
  public:
      int nType;
      int nVersion;
  
      CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
  
      CHashWriter& write(const char* pch, size_t size)
      {
          ctx.Write((const unsigned char*)pch, size);
          return (*this);
      }
  
      // 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, nType, nVersion);
          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();
  }
  
  unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
  
  void BIP32Hash(const unsigned char chainCode[32], 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);
  
  inline int GetHashSelection(const uint256 PrevBlockHash, int index) {
      assert(index >= 0);
      assert(index < 8);
  
      #define STEVOS_OF_LAST_16_NIBBLES_OF_HASH 48
      int hashSelection = PrevBlockHash.GetNibble(STEVOS_OF_LAST_16_NIBBLES_OF_HASH + index);
      return(hashSelection);
  }
  
  template<typename T1>
  inline uint256 HashZ16R(const T1 pbegin, const T1 pend, const uint256 PrevBlockHash)
  {
  //	static std::chrono::duration<double>[16];
      int hashSelection;
  
      sph_blake512_context     ctx_blake;      //0
      sph_bmw512_context       ctx_bmw;        //1
      sph_groestl512_context   ctx_groestl;    //2
      sph_jh512_context        ctx_jh;         //3
      sph_keccak512_context    ctx_keccak;     //4
      sph_skein512_context     ctx_skein;      //5
      sph_luffa512_context     ctx_luffa;      //6
      sph_cubehash512_context  ctx_cubehash;   //7
      sph_shavite512_context   ctx_shavite;    //8
      sph_simd512_context      ctx_simd;       //9
      sph_echo512_context      ctx_echo;       //A
      sph_hamsi512_context     ctx_hamsi;      //B
      sph_fugue512_context     ctx_fugue;      //C
      sph_shabal512_context    ctx_shabal;     //D
      sph_whirlpool_context    ctx_whirlpool;  //E
      sph_sha512_context       ctx_sha512;     //F
  
      static unsigned char pblank[1];
  
      uint512 hash[8];
  
      for (int i=0;i<8;i++)
      {
          const void *toHash;
          int lenToHash;
          if (i == 0) {
              toHash = (pbegin == pend ? pblank : static_cast<const void*>(&pbegin[0]));
              lenToHash = (pend - pbegin) * sizeof(pbegin[0]);
          } else {
              toHash = static_cast<const void*>(&hash[i-1]);
              lenToHash = 64;
          }
  
          hashSelection = GetHashSelection(PrevBlockHash, i);
  
          //LogPrintf("Hash selector: index=%d\n", hashSelection);
  
  
          switch(hashSelection) {
              case 0:
                  sph_blake512_init(&ctx_blake);
                  sph_blake512 (&ctx_blake, toHash, lenToHash);
                  sph_blake512_close(&ctx_blake, static_cast<void*>(&hash[i]));
  
                  sph_shavite512_init(&ctx_shavite);
                  sph_shavite512 (&ctx_shavite, static_cast<void*>(&hash[i]), lenToHash);
                  sph_shavite512_close(&ctx_shavite, static_cast<void*>(&hash[i]));
  
                  break;
              case 1:
                  sph_bmw512_init(&ctx_bmw);
                  sph_bmw512 (&ctx_bmw, toHash, lenToHash);
                  sph_bmw512_close(&ctx_bmw, static_cast<void*>(&hash[i]));
  
                  sph_simd512_init(&ctx_simd);
                  sph_simd512 (&ctx_simd, static_cast<void*>(&hash[i]), lenToHash);
                  sph_simd512_close(&ctx_simd, static_cast<void*>(&hash[i]));
  
                  break;
              case 2:
                  sph_groestl512_init(&ctx_groestl);
                  sph_groestl512 (&ctx_groestl, toHash, lenToHash);
                  sph_groestl512_close(&ctx_groestl, static_cast<void*>(&hash[i]));
  
                  sph_echo512_init(&ctx_echo);
                  sph_echo512 (&ctx_echo, static_cast<void*>(&hash[i]), lenToHash);
                  sph_echo512_close(&ctx_echo, static_cast<void*>(&hash[i]));
  
                  break;
              case 3:
                  sph_jh512_init(&ctx_jh);
                  sph_jh512 (&ctx_jh, toHash, lenToHash);
                  sph_jh512_close(&ctx_jh, static_cast<void*>(&hash[i]));
  
                  sph_hamsi512_init(&ctx_hamsi);
                  sph_hamsi512 (&ctx_hamsi, static_cast<void*>(&hash[i]), lenToHash);
                  sph_hamsi512_close(&ctx_hamsi, static_cast<void*>(&hash[i]));
                  break;
              case 4:
                  sph_keccak512_init(&ctx_keccak);
                  sph_keccak512 (&ctx_keccak, toHash, lenToHash);
                  sph_keccak512_close(&ctx_keccak, static_cast<void*>(&hash[i]));
  
                  sph_fugue512_init(&ctx_fugue);
                  sph_fugue512 (&ctx_fugue, static_cast<void*>(&hash[i]), lenToHash);
                  sph_fugue512_close(&ctx_fugue, static_cast<void*>(&hash[i]));
                  break;
              case 5:
                  sph_skein512_init(&ctx_skein);
                  sph_skein512 (&ctx_skein, toHash, lenToHash);
                  sph_skein512_close(&ctx_skein, static_cast<void*>(&hash[i]));
  
                  sph_shabal512_init(&ctx_shabal);
                  sph_shabal512 (&ctx_shabal, static_cast<void*>(&hash[i]), lenToHash);
                  sph_shabal512_close(&ctx_shabal, static_cast<void*>(&hash[i]));
                  break;
              case 6:
                  sph_luffa512_init(&ctx_luffa);
                  sph_luffa512 (&ctx_luffa, toHash, lenToHash);
                  sph_luffa512_close(&ctx_luffa, static_cast<void*>(&hash[i]));
  
                  sph_whirlpool_init(&ctx_whirlpool);
                  sph_whirlpool (&ctx_whirlpool, static_cast<void*>(&hash[i]), lenToHash);
                  sph_whirlpool_close(&ctx_whirlpool, static_cast<void*>(&hash[i]));
                  break;
              case 7:
                  sph_cubehash512_init(&ctx_cubehash);
                  sph_cubehash512 (&ctx_cubehash, toHash, lenToHash);
                  sph_cubehash512_close(&ctx_cubehash, static_cast<void*>(&hash[i]));
  
                  sph_sha512_init(&ctx_sha512);
                  sph_sha512(&ctx_sha512, static_cast<void*>(&hash[i]), lenToHash);
                  sph_sha512_close(&ctx_sha512, static_cast<void*>(&hash[i]));
  
                  break;
  
          }
      }
  
      return hash[7].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);
  
  #endif // BITCOIN_HASH_H
  