text: // Copyright (c) 2014 The Bitcoin developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "base58.h"
  
  #include "hash.h"
  #include "uint256.h"
  #include "chainparams.h"
  
  #include <assert.h>
  #include <stdint.h>
  #include <string.h>
  #include <vector>
  #include <string>
  #include <boost/variant/apply_visitor.hpp>
  #include <boost/variant/static_visitor.hpp>
  
  /* All alphanumeric characters except for "0", "I", "O", and "l" */
  static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
  
  bool DecodeBase58(const char* psz, std::vector<unsigned char>& vchRet) {
      CAutoBN_CTX pctx;
      vchRet.clear();
      CBigNum bn58 = 58;
      CBigNum bn = 0;
      CBigNum bnChar;
      // Skip leading spaces.
      while (*psz && isspace(*psz))
          psz++;
      // Skip and count leading '1's.
      int zeroes = 0;
      while (*psz == '1') {
          zeroes++;
          psz++;
      }
      // Convert big endian string to bignum
      for (const char* p = psz; *p; p++)
      {
          const char* p1 = strchr(pszBase58, *p);
          if (p1 == NULL)
          {
              while (isspace(*p))
                  p++;
              if (*p != '\0')
                  return false;
              break;
          }
          bnChar.setulong(p1 - pszBase58);
          if (!BN_mul(&bn, &bn, &bn58, pctx))
              throw bignum_error("DecodeBase58 : BN_mul failed");
          bn += bnChar;
      }
  
       // Get bignum as little endian data
      std::vector<unsigned char> vchTmp = bn.getvch();
  
      // Trim off sign byte if present
      if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
          vchTmp.erase(vchTmp.end()-1);
  
      // Restore leading zeros
      int nLeadingZeros = 0;
      for (const char* p = psz; *p == pszBase58[0]; p++)
          nLeadingZeros++;
      vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
  
      // Convert little endian data to big endian
      reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
      return true;
      // Allocate enough space in big-endian base256 representation.
      std::vector<unsigned char> b256(strlen(psz) * 733 / 1000 + 1); // log(58) / log(256), rounded up.
      // Process the characters.
      while (*psz && !isspace(*psz)) {
          // Decode base58 character
          const char *ch = strchr(pszBase58, *psz);
          if (ch == NULL)
              return false;
          // Apply "b256 = b256 * 58 + ch".
          int carry = ch - pszBase58;
          for (std::vector<unsigned char>::reverse_iterator it = b256.rbegin(); it != b256.rend(); it++) {
              carry += 58 * (*it);
              *it = carry % 256;
              carry /= 256;
          }
          assert(carry == 0);
          psz++;
      }
      // Skip trailing spaces.
      while (isspace(*psz))
          psz++;
      if (*psz != 0)
          return false;
      // Skip leading zeroes in b256.
      std::vector<unsigned char>::iterator it = b256.begin();
      while (it != b256.end() && *it == 0)
          it++;
      // Copy result into output vector.
      vchRet.reserve(zeroes + (b256.end() - it));
      vchRet.assign(zeroes, 0x00);
      while (it != b256.end())
        vchRet.push_back(*(it++));
      return true;
  }
  
  std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend) {
      // Skip & count leading zeroes.
      int zeroes = 0;
      while (pbegin != pend && *pbegin == 0) {
          pbegin++;
          zeroes++;
      }
      // Allocate enough space in big-endian base58 representation.
      std::vector<unsigned char> b58((pend - pbegin) * 138 / 100 + 1); // log(256) / log(58), rounded up.
      // Process the bytes.
      while (pbegin != pend) {
          int carry = *pbegin;
          // Apply "b58 = b58 * 256 + ch".
          for (std::vector<unsigned char>::reverse_iterator it = b58.rbegin(); it != b58.rend(); it++) {
              carry += 256 * (*it);
              *it = carry % 58;
              carry /= 58;
          }
          assert(carry == 0);
          pbegin++;
      }
      // Skip leading zeroes in base58 result.
      std::vector<unsigned char>::iterator it = b58.begin();
      while (it != b58.end() && *it == 0)
          it++;
      // Translate the result into a string.
      std::string str;
      str.reserve(zeroes + (b58.end() - it));
      str.assign(zeroes, '1');
      while (it != b58.end())
          str += pszBase58[*(it++)];
      return str;
  }
  
  std::string EncodeBase58(const std::vector<unsigned char>& vch) {
      return EncodeBase58(&vch[0], &vch[0] + vch.size());
  }
  
  bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet) {
      return DecodeBase58(str.c_str(), vchRet);
  }
  
  std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn) {
      // add 4-byte hash check to the end
      std::vector<unsigned char> vch(vchIn);
      uint256 hash = Hash(vch.begin(), vch.end());
      vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
      return EncodeBase58(vch);
  }
  
  bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet) {
      if (!DecodeBase58(psz, vchRet) ||
          (vchRet.size() < 4))
      {
          vchRet.clear();
          return false;
      }
      // re-calculate the checksum, insure it matches the included 4-byte checksum
      uint256 hash = Hash(vchRet.begin(), vchRet.end()-4);
      if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
      {
          vchRet.clear();
          return false;
      }
      vchRet.resize(vchRet.size()-4);
      return true;
  }
  
  bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet) {
      return DecodeBase58Check(str.c_str(), vchRet);
  }
  
  CBase58Data::CBase58Data() {
      vchVersion.clear();
      vchData.clear();
  }
  
  void CBase58Data::SetData(const std::vector<unsigned char> &vchVersionIn, const void* pdata, size_t nSize) {
      vchVersion = vchVersionIn;
      vchData.resize(nSize);
      if (!vchData.empty())
          memcpy(&vchData[0], pdata, nSize);
  }
  
  void CBase58Data::SetData(const std::vector<unsigned char> &vchVersionIn, const unsigned char *pbegin, const unsigned char *pend) {
      SetData(vchVersionIn, (void*)pbegin, pend - pbegin);
  }
  
  bool CBase58Data::SetString(const char* psz, unsigned int nVersionBytes) {
      std::vector<unsigned char> vchTemp;
      bool rc58 = DecodeBase58Check(psz, vchTemp);
      if ((!rc58) || (vchTemp.size() < nVersionBytes)) {
          vchData.clear();
          vchVersion.clear();
          return false;
      }
      vchVersion.assign(vchTemp.begin(), vchTemp.begin() + nVersionBytes);
      vchData.resize(vchTemp.size() - nVersionBytes);
      if (!vchData.empty())
          memcpy(&vchData[0], &vchTemp[nVersionBytes], vchData.size());
      memory_cleanse(&vchTemp[0], vchData.size());
      return true;
  }
  
  bool CBase58Data::SetString(const std::string& str) {
      return SetString(str.c_str());
  }
  
  std::string CBase58Data::ToString() const {
      std::vector<unsigned char> vch = vchVersion;
      vch.insert(vch.end(), vchData.begin(), vchData.end());
      return EncodeBase58Check(vch);
  }
  
  int CBase58Data::CompareTo(const CBase58Data& b58) const {
      if (vchVersion < b58.vchVersion) return -1;
      if (vchVersion > b58.vchVersion) return  1;
      if (vchData < b58.vchData)   return -1;
      if (vchData > b58.vchData)   return  1;
      return 0;
  }
  
  namespace {
      class CAFROAddressVisitor : public boost::static_visitor<bool> {
      private:
          CAFROAddress *addr;
      public:
          CAFROAddressVisitor(CAFROAddress *addrIn) : addr(addrIn) { }
  
          bool operator()(const CKeyID &id) const { return addr->Set(id); }
          bool operator()(const CScriptID &id) const { return addr->Set(id); }
          bool operator()(const CNoDestination &no) const { return false; }
          bool operator()(const CStealthAddress &stxAddr) const { return false; }
      };
      class CBitcoinAddressVisitor : public boost::static_visitor<bool> {
      private:
          CBitcoinAddress *addr;
      public:
          CBitcoinAddressVisitor(CBitcoinAddress *addrIn) : addr(addrIn) { }
  
          bool operator()(const CKeyID &id) const { return addr->Set(id); }
          bool operator()(const CScriptID &id) const { return addr->Set(id); }
          bool operator()(const CNoDestination &no) const { return false; }
          bool operator()(const CStealthAddress &stxAddr) const { return false; }
      };
  };
  
  bool CAFROAddress::Set(const CKeyID &id) {
      SetData(Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS), &id, 20);
      return true;
  }
  
  bool CAFROAddress::Set(const CScriptID &id) {
      SetData(Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS), &id, 20);
      return true;
  }
  
  bool CAFROAddress::Set(const CTxDestination &dest) {
      return boost::apply_visitor(CAFROAddressVisitor(this), dest);
  }
  
  bool CAFROAddress::IsValid() const {
      bool fCorrectSize = vchData.size() == 20;
      bool fKnownVersion = vchVersion == Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS) ||
                           vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS);
      return fCorrectSize && fKnownVersion;
  }
  
  CTxDestination CAFROAddress::Get() const {
      if (!IsValid())
          return CNoDestination();
      uint160 id;
      memcpy(&id, &vchData[0], 20);
      if (vchVersion == Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
          return CKeyID(id);
      else if (vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS))
          return CScriptID(id);
      else
          return CNoDestination();
  }
  
  bool CAFROAddress::GetKeyID(CKeyID &keyID) const {
      if (!IsValid() || vchVersion != Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
          return false;
      uint160 id;
      memcpy(&id, &vchData[0], 20);
      keyID = CKeyID(id);
      return true;
  }
  
  bool CAFROAddress::IsScript() const {
      return IsValid() && vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS);
  }
  
  void CAFROSecret::SetKey(const CKey& vchSecret) {
      assert(vchSecret.IsValid());
      SetData(Params().Base58Prefix(CChainParams::SECRET_KEY), vchSecret.begin(), vchSecret.size());
      if (vchSecret.IsCompressed())
          vchData.push_back(1);
  }
  
  CKey CAFROSecret::GetKey() {
      CKey ret;
      ret.Set(&vchData[0], &vchData[32], vchData.size() > 32 && vchData[32] == 1);
      return ret;
  }
  
  bool CAFROSecret::IsValid() const {
      bool fExpectedFormat = vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1);
      bool fCorrectVersion = vchVersion == Params().Base58Prefix(CChainParams::SECRET_KEY);
      return fExpectedFormat && fCorrectVersion;
  }
  
  bool CAFROSecret::SetString(const char* pszSecret) {
      return CBase58Data::SetString(pszSecret) && IsValid();
  }
  
  bool CAFROSecret::SetString(const std::string& strSecret) {
      return SetString(strSecret.c_str());
  }
  
  /** base58-encoded Bitcoin addresses.
   * Public-key-hash-addresses have version 0 (or 111 testnet).
   * The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key.
   * Script-hash-addresses have version 5 (or 196 testnet).
   * The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
   */
  CChainParams::Base58Type pubkey_address = (CChainParams::Base58Type)0;
  CChainParams::Base58Type script_address = (CChainParams::Base58Type)5;
  bool CBitcoinAddress::Set(const CKeyID &id) {
      SetData(Params().Base58Prefix(pubkey_address), &id, 20);
      return true;
  }
  
  bool CBitcoinAddress::Set(const CScriptID &id) {
      SetData(Params().Base58Prefix(script_address), &id, 20);
      return true;
  }
  
  bool CBitcoinAddress::Set(const CTxDestination &dest) {
      return boost::apply_visitor(CBitcoinAddressVisitor(this), dest);
  }
  
  bool CBitcoinAddress::IsValid() const {
      bool fCorrectSize = vchData.size() == 20;
      bool fKnownVersion = vchVersion == Params().Base58Prefix(pubkey_address) ||
                           vchVersion == Params().Base58Prefix(script_address);
      return fCorrectSize && fKnownVersion;
  }
  
  CTxDestination CBitcoinAddress::Get() const {
      if (!IsValid())
          return CNoDestination();
      uint160 id;
      memcpy(&id, &vchData[0], 20);
      if (vchVersion == Params().Base58Prefix(pubkey_address))
          return CKeyID(id);
      else if (vchVersion == Params().Base58Prefix(script_address))
          return CScriptID(id);
      else
          return CNoDestination();
  }
  
  bool CBitcoinAddress::GetKeyID(CKeyID &keyID) const {
      if (!IsValid() || vchVersion != Params().Base58Prefix(pubkey_address))
          return false;
      uint160 id;
      memcpy(&id, &vchData[0], 20);
      keyID = CKeyID(id);
      return true;
  }
  
  bool CBitcoinAddress::IsScript() const {
      return IsValid() && vchVersion == Params().Base58Prefix(script_address);
  }
  