Advertisement
Guest User

bitcoin

a guest
Sep 7th, 2013
869
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 414.77 KB
  1. static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
  2. inline string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
  3. {
  4.     CAutoBN_CTX pctx;
  5.     CBigNum bn58 = 58;
  6.     CBigNum bn0 = 0;
  7.     vector<unsigned char> vchTmp(pend-pbegin+1, 0);
  8.     reverse_copy(pbegin, pend, vchTmp.begin());
  9.     CBigNum bn;
  10.     bn.setvch(vchTmp);
  11.     string str;
  12.     str.reserve((pend - pbegin) * 138 / 100 + 1);
  13.     CBigNum dv;
  14.     CBigNum rem;
  15.     while (bn > bn0)
  16.     {
  17.         if (!BN_div(&dv, &rem, &bn, &bn58, pctx))
  18.             throw bignum_error("EncodeBase58 : BN_div failed");
  19.         bn = dv;
  20.         unsigned int c = rem.getulong();
  21.         str += pszBase58[c];
  22.     }
  23.     for (const unsigned char* p = pbegin; p < pend && *p == 0; p++)
  24.         str += pszBase58[0];
  25.     reverse(str.begin(), str.end());
  26.     return str;
  27. }
  28. inline string EncodeBase58(const vector<unsigned char>& vch)
  29. {
  30.     return EncodeBase58(&vch[0], &vch[0] + vch.size());
  31. }
  32. inline bool DecodeBase58(const char* psz, vector<unsigned char>& vchRet)
  33. {
  34.     CAutoBN_CTX pctx;
  35.     vchRet.clear();
  36.     CBigNum bn58 = 58;
  37.     CBigNum bn = 0;
  38.     CBigNum bnChar;
  39.     while (isspace(*psz))
  40.         psz++;
  41.     for (const char* p = psz; *p; p++)
  42.     {
  43.         const char* p1 = strchr(pszBase58, *p);
  44.         if (p1 == NULL)
  45.         {
  46.             while (isspace(*p))
  47.                 p++;
  48.             if (*p != '\0')
  49.                 return false;
  50.             break;
  51.         }
  52.         bnChar.setulong(p1 - pszBase58);
  53.         if (!BN_mul(&bn, &bn, &bn58, pctx))
  54.             throw bignum_error("DecodeBase58 : BN_mul failed");
  55.         bn += bnChar;
  56.     }
  57.     vector<unsigned char> vchTmp = bn.getvch();
  58.     if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
  59.         vchTmp.erase(vchTmp.end()-1);
  60.     int nLeadingZeros = 0;
  61.     for (const char* p = psz; *p == pszBase58[0]; p++)
  62.         nLeadingZeros++;
  63.     vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
  64.     reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
  65.     return true;
  66. }
  67. inline bool DecodeBase58(const string& str, vector<unsigned char>& vchRet)
  68. {
  69.     return DecodeBase58(str.c_str(), vchRet);
  70. }
  71. inline string EncodeBase58Check(const vector<unsigned char>& vchIn)
  72. {
  73.     vector<unsigned char> vch(vchIn);
  74.     uint256 hash = Hash(vch.begin(), vch.end());
  75.     vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
  76.     return EncodeBase58(vch);
  77. }
  78. inline bool DecodeBase58Check(const char* psz, vector<unsigned char>& vchRet)
  79. {
  80.     if (!DecodeBase58(psz, vchRet))
  81.         return false;
  82.     if (vchRet.size() < 4)
  83.     {
  84.         vchRet.clear();
  85.         return false;
  86.     }
  87.     uint256 hash = Hash(vchRet.begin(), vchRet.end()-4);
  88.     if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
  89.     {
  90.         vchRet.clear();
  91.         return false;
  92.     }
  93.     vchRet.resize(vchRet.size()-4);
  94.     return true;
  95. }
  96. inline bool DecodeBase58Check(const string& str, vector<unsigned char>& vchRet)
  97. {
  98.     return DecodeBase58Check(str.c_str(), vchRet);
  99. }
  100. static const unsigned char ADDRESSVERSION = 0;
  101. inline string Hash160ToAddress(uint160 hash160)
  102. {
  103.     vector<unsigned char> vch(1, ADDRESSVERSION);
  104.     vch.insert(vch.end(), UBEGIN(hash160), UEND(hash160));
  105.     return EncodeBase58Check(vch);
  106. }
  107. inline bool AddressToHash160(const char* psz, uint160& hash160Ret)
  108. {
  109.     vector<unsigned char> vch;
  110.     if (!DecodeBase58Check(psz, vch))
  111.         return false;
  112.     if (vch.empty())
  113.         return false;
  114.     unsigned char nVersion = vch[0];
  115.     if (vch.size() != sizeof(hash160Ret) + 1)
  116.         return false;
  117.     memcpy(&hash160Ret, &vch[1], sizeof(hash160Ret));
  118.     return (nVersion <= ADDRESSVERSION);
  119. }
  120. inline bool AddressToHash160(const string& str, uint160& hash160Ret)
  121. {
  122.     return AddressToHash160(str.c_str(), hash160Ret);
  123. }
  124. inline bool IsValidBitcoinAddress(const char* psz)
  125. {
  126.     uint160 hash160;
  127.     return AddressToHash160(psz, hash160);
  128. }
  129. inline bool IsValidBitcoinAddress(const string& str)
  130. {
  131.     return IsValidBitcoinAddress(str.c_str());
  132. }
  133. inline string PubKeyToAddress(const vector<unsigned char>& vchPubKey)
  134. {
  135.     return Hash160ToAddress(Hash160(vchPubKey));
  136. }
  137. #include <stdexcept>
  138. #include <vector>
  139. #include <openssl/bn.h>
  140. class bignum_error : public std::runtime_error
  141. {
  142. public:
  143.     explicit bignum_error(const std::string& str) : std::runtime_error(str) {}
  144. };
  145. class CAutoBN_CTX
  146. {
  147. protected:
  148.     BN_CTX* pctx;
  149.     BN_CTX* operator=(BN_CTX* pnew) { return pctx = pnew; }
  150. public:
  151.     CAutoBN_CTX()
  152.     {
  153.         pctx = BN_CTX_new();
  154.         if (pctx == NULL)
  155.             throw bignum_error("CAutoBN_CTX : BN_CTX_new() returned NULL");
  156.     }
  157.     ~CAutoBN_CTX()
  158.     {
  159.         if (pctx != NULL)
  160.             BN_CTX_free(pctx);
  161.     }
  162.     operator BN_CTX*() { return pctx; }
  163.     BN_CTX& operator*() { return *pctx; }
  164.     BN_CTX** operator&() { return &pctx; }
  165.     bool operator!() { return (pctx == NULL); }
  166. };
  167. class CBigNum : public BIGNUM
  168. {
  169. public:
  170.     CBigNum()
  171.     {
  172.         BN_init(this);
  173.     }
  174.     CBigNum(const CBigNum& b)
  175.     {
  176.         BN_init(this);
  177.         if (!BN_copy(this, &b))
  178.         {
  179.             BN_clear_free(this);
  180.             throw bignum_error("CBigNum::CBigNum(const CBigNum&) : BN_copy failed");
  181.         }
  182.     }
  183.     explicit CBigNum(const std::string& str)
  184.     {
  185.         BN_init(this);
  186.         SetHex(str);
  187.     }
  188.     CBigNum& operator=(const CBigNum& b)
  189.     {
  190.         if (!BN_copy(this, &b))
  191.             throw bignum_error("CBigNum::operator= : BN_copy failed");
  192.         return (*this);
  193.     }
  194.     ~CBigNum()
  195.     {
  196.         BN_clear_free(this);
  197.     }
  198.     CBigNum(char n)             { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
  199.     CBigNum(short n)            { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
  200.     CBigNum(int n)              { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
  201.     CBigNum(long n)             { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
  202.     CBigNum(int64 n)            { BN_init(this); setint64(n); }
  203.     CBigNum(unsigned char n)    { BN_init(this); setulong(n); }
  204.     CBigNum(unsigned short n)   { BN_init(this); setulong(n); }
  205.     CBigNum(unsigned int n)     { BN_init(this); setulong(n); }
  206.     CBigNum(unsigned long n)    { BN_init(this); setulong(n); }
  207.     CBigNum(uint64 n)           { BN_init(this); setuint64(n); }
  208.     explicit CBigNum(uint256 n) { BN_init(this); setuint256(n); }
  209.     explicit CBigNum(const std::vector<unsigned char>& vch)
  210.     {
  211.         BN_init(this);
  212.         setvch(vch);
  213.     }
  214.     void setulong(unsigned long n)
  215.     {
  216.         if (!BN_set_word(this, n))
  217.             throw bignum_error("CBigNum conversion from unsigned long : BN_set_word failed");
  218.     }
  219.     unsigned long getulong() const
  220.     {
  221.         return BN_get_word(this);
  222.     }
  223.     unsigned int getuint() const
  224.     {
  225.         return BN_get_word(this);
  226.     }
  227.     int getint() const
  228.     {
  229.         unsigned long n = BN_get_word(this);
  230.         if (!BN_is_negative(this))
  231.             return (n > INT_MAX ? INT_MAX : n);
  232.         else
  233.             return (n > INT_MAX ? INT_MIN : -(int)n);
  234.     }
  235.     void setint64(int64 n)
  236.     {
  237.         unsigned char pch[sizeof(n) + 6];
  238.         unsigned char* p = pch + 4;
  239.         bool fNegative = false;
  240.         if (n < (int64)0)
  241.         {
  242.             n = -n;
  243.             fNegative = true;
  244.         }
  245.         bool fLeadingZeroes = true;
  246.         for (int i = 0; i < 8; i++)
  247.         {
  248.             unsigned char c = (n >> 56) & 0xff;
  249.             n <<= 8;
  250.             if (fLeadingZeroes)
  251.             {
  252.                 if (c == 0)
  253.                     continue;
  254.                 if (c & 0x80)
  255.                     *p++ = (fNegative ? 0x80 : 0);
  256.                 else if (fNegative)
  257.                     c |= 0x80;
  258.                 fLeadingZeroes = false;
  259.             }
  260.             *p++ = c;
  261.         }
  262.         unsigned int nSize = p - (pch + 4);
  263.         pch[0] = (nSize >> 24) & 0xff;
  264.         pch[1] = (nSize >> 16) & 0xff;
  265.         pch[2] = (nSize >> 8) & 0xff;
  266.         pch[3] = (nSize) & 0xff;
  267.         BN_mpi2bn(pch, p - pch, this);
  268.     }
  269.     void setuint64(uint64 n)
  270.     {
  271.         unsigned char pch[sizeof(n) + 6];
  272.         unsigned char* p = pch + 4;
  273.         bool fLeadingZeroes = true;
  274.         for (int i = 0; i < 8; i++)
  275.         {
  276.             unsigned char c = (n >> 56) & 0xff;
  277.             n <<= 8;
  278.             if (fLeadingZeroes)
  279.             {
  280.                 if (c == 0)
  281.                     continue;
  282.                 if (c & 0x80)
  283.                     *p++ = 0;
  284.                 fLeadingZeroes = false;
  285.             }
  286.             *p++ = c;
  287.         }
  288.         unsigned int nSize = p - (pch + 4);
  289.         pch[0] = (nSize >> 24) & 0xff;
  290.         pch[1] = (nSize >> 16) & 0xff;
  291.         pch[2] = (nSize >> 8) & 0xff;
  292.         pch[3] = (nSize) & 0xff;
  293.         BN_mpi2bn(pch, p - pch, this);
  294.     }
  295.     void setuint256(uint256 n)
  296.     {
  297.         unsigned char pch[sizeof(n) + 6];
  298.         unsigned char* p = pch + 4;
  299.         bool fLeadingZeroes = true;
  300.         unsigned char* pbegin = (unsigned char*)&n;
  301.         unsigned char* psrc = pbegin + sizeof(n);
  302.         while (psrc != pbegin)
  303.         {
  304.             unsigned char c = *(--psrc);
  305.             if (fLeadingZeroes)
  306.             {
  307.                 if (c == 0)
  308.                     continue;
  309.                 if (c & 0x80)
  310.                     *p++ = 0;
  311.                 fLeadingZeroes = false;
  312.             }
  313.             *p++ = c;
  314.         }
  315.         unsigned int nSize = p - (pch + 4);
  316.         pch[0] = (nSize >> 24) & 0xff;
  317.         pch[1] = (nSize >> 16) & 0xff;
  318.         pch[2] = (nSize >> 8) & 0xff;
  319.         pch[3] = (nSize >> 0) & 0xff;
  320.         BN_mpi2bn(pch, p - pch, this);
  321.     }
  322.     uint256 getuint256()
  323.     {
  324.         unsigned int nSize = BN_bn2mpi(this, NULL);
  325.         if (nSize < 4)
  326.             return 0;
  327.         std::vector<unsigned char> vch(nSize);
  328.         BN_bn2mpi(this, &vch[0]);
  329.         if (vch.size() > 4)
  330.             vch[4] &= 0x7f;
  331.         uint256 n = 0;
  332.         for (int i = 0, j = vch.size()-1; i < sizeof(n) && j >= 4; i++, j--)
  333.             ((unsigned char*)&n)[i] = vch[j];
  334.         return n;
  335.     }
  336.     void setvch(const std::vector<unsigned char>& vch)
  337.     {
  338.         std::vector<unsigned char> vch2(vch.size() + 4);
  339.         unsigned int nSize = vch.size();
  340.         vch2[0] = (nSize >> 24) & 0xff;
  341.         vch2[1] = (nSize >> 16) & 0xff;
  342.         vch2[2] = (nSize >> 8) & 0xff;
  343.         vch2[3] = (nSize >> 0) & 0xff;
  344.         reverse_copy(vch.begin(), vch.end(), vch2.begin() + 4);
  345.         BN_mpi2bn(&vch2[0], vch2.size(), this);
  346.     }
  347.     std::vector<unsigned char> getvch() const
  348.     {
  349.         unsigned int nSize = BN_bn2mpi(this, NULL);
  350.         if (nSize < 4)
  351.             return std::vector<unsigned char>();
  352.         std::vector<unsigned char> vch(nSize);
  353.         BN_bn2mpi(this, &vch[0]);
  354.         vch.erase(vch.begin(), vch.begin() + 4);
  355.         reverse(vch.begin(), vch.end());
  356.         return vch;
  357.     }
  358.     CBigNum& SetCompact(unsigned int nCompact)
  359.     {
  360.         unsigned int nSize = nCompact >> 24;
  361.         std::vector<unsigned char> vch(4 + nSize);
  362.         vch[3] = nSize;
  363.         if (nSize >= 1) vch[4] = (nCompact >> 16) & 0xff;
  364.         if (nSize >= 2) vch[5] = (nCompact >> 8) & 0xff;
  365.         if (nSize >= 3) vch[6] = (nCompact >> 0) & 0xff;
  366.         BN_mpi2bn(&vch[0], vch.size(), this);
  367.         return *this;
  368.     }
  369.     unsigned int GetCompact() const
  370.     {
  371.         unsigned int nSize = BN_bn2mpi(this, NULL);
  372.         std::vector<unsigned char> vch(nSize);
  373.         nSize -= 4;
  374.         BN_bn2mpi(this, &vch[0]);
  375.         unsigned int nCompact = nSize << 24;
  376.         if (nSize >= 1) nCompact |= (vch[4] << 16);
  377.         if (nSize >= 2) nCompact |= (vch[5] << 8);
  378.         if (nSize >= 3) nCompact |= (vch[6] << 0);
  379.         return nCompact;
  380.     }
  381.     void SetHex(const std::string& str)
  382.     {
  383.         const char* psz = str.c_str();
  384.         while (isspace(*psz))
  385.             psz++;
  386.         bool fNegative = false;
  387.         if (*psz == '-')
  388.         {
  389.             fNegative = true;
  390.             psz++;
  391.         }
  392.         if (psz[0] == '0' && tolower(psz[1]) == 'x')
  393.             psz += 2;
  394.         while (isspace(*psz))
  395.             psz++;
  396.         static char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
  397.         *this = 0;
  398.         while (isxdigit(*psz))
  399.         {
  400.             *this <<= 4;
  401.             int n = phexdigit[*psz++];
  402.             *this += n;
  403.         }
  404.         if (fNegative)
  405.             *this = 0 - *this;
  406.     }
  407.     unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const
  408.     {
  409.         return ::GetSerializeSize(getvch(), nType, nVersion);
  410.     }
  411.     template<typename Stream>
  412.     void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
  413.     {
  414.         ::Serialize(s, getvch(), nType, nVersion);
  415.     }
  416.     template<typename Stream>
  417.     void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)
  418.     {
  419.         vector<unsigned char> vch;
  420.         ::Unserialize(s, vch, nType, nVersion);
  421.         setvch(vch);
  422.     }
  423.     bool operator!() const
  424.     {
  425.         return BN_is_zero(this);
  426.     }
  427.     CBigNum& operator+=(const CBigNum& b)
  428.     {
  429.         if (!BN_add(this, this, &b))
  430.             throw bignum_error("CBigNum::operator+= : BN_add failed");
  431.         return *this;
  432.     }
  433.     CBigNum& operator-=(const CBigNum& b)
  434.     {
  435.         *this = *this - b;
  436.         return *this;
  437.     }
  438.     CBigNum& operator*=(const CBigNum& b)
  439.     {
  440.         CAutoBN_CTX pctx;
  441.         if (!BN_mul(this, this, &b, pctx))
  442.             throw bignum_error("CBigNum::operator*= : BN_mul failed");
  443.         return *this;
  444.     }
  445.     CBigNum& operator/=(const CBigNum& b)
  446.     {
  447.         *this = *this / b;
  448.         return *this;
  449.     }
  450.     CBigNum& operator%=(const CBigNum& b)
  451.     {
  452.         *this = *this % b;
  453.         return *this;
  454.     }
  455.     CBigNum& operator<<=(unsigned int shift)
  456.     {
  457.         if (!BN_lshift(this, this, shift))
  458.             throw bignum_error("CBigNum:operator<<= : BN_lshift failed");
  459.         return *this;
  460.     }
  461.     CBigNum& operator>>=(unsigned int shift)
  462.     {
  463.         if (!BN_rshift(this, this, shift))
  464.             throw bignum_error("CBigNum:operator>>= : BN_rshift failed");
  465.         return *this;
  466.     }
  467.     CBigNum& operator++()
  468.     {
  469.         if (!BN_add(this, this, BN_value_one()))
  470.             throw bignum_error("CBigNum::operator++ : BN_add failed");
  471.         return *this;
  472.     }
  473.     const CBigNum operator++(int)
  474.     {
  475.         const CBigNum ret = *this;
  476.         ++(*this);
  477.         return ret;
  478.     }
  479.     CBigNum& operator--()
  480.     {
  481.         CBigNum r;
  482.         if (!BN_sub(&r, this, BN_value_one()))
  483.             throw bignum_error("CBigNum::operator-- : BN_sub failed");
  484.         *this = r;
  485.         return *this;
  486.     }
  487.     const CBigNum operator--(int)
  488.     {
  489.         const CBigNum ret = *this;
  490.         --(*this);
  491.         return ret;
  492.     }
  493.     friend inline const CBigNum operator-(const CBigNum& a, const CBigNum& b);
  494.     friend inline const CBigNum operator/(const CBigNum& a, const CBigNum& b);
  495.     friend inline const CBigNum operator%(const CBigNum& a, const CBigNum& b);
  496. };
  497. inline const CBigNum operator+(const CBigNum& a, const CBigNum& b)
  498. {
  499.     CBigNum r;
  500.     if (!BN_add(&r, &a, &b))
  501.         throw bignum_error("CBigNum::operator+ : BN_add failed");
  502.     return r;
  503. }
  504. inline const CBigNum operator-(const CBigNum& a, const CBigNum& b)
  505. {
  506.     CBigNum r;
  507.     if (!BN_sub(&r, &a, &b))
  508.         throw bignum_error("CBigNum::operator- : BN_sub failed");
  509.     return r;
  510. }
  511. inline const CBigNum operator-(const CBigNum& a)
  512. {
  513.     CBigNum r(a);
  514.     BN_set_negative(&r, !BN_is_negative(&r));
  515.     return r;
  516. }
  517. inline const CBigNum operator*(const CBigNum& a, const CBigNum& b)
  518. {
  519.     CAutoBN_CTX pctx;
  520.     CBigNum r;
  521.     if (!BN_mul(&r, &a, &b, pctx))
  522.         throw bignum_error("CBigNum::operator* : BN_mul failed");
  523.     return r;
  524. }
  525. inline const CBigNum operator/(const CBigNum& a, const CBigNum& b)
  526. {
  527.     CAutoBN_CTX pctx;
  528.     CBigNum r;
  529.     if (!BN_div(&r, NULL, &a, &b, pctx))
  530.         throw bignum_error("CBigNum::operator/ : BN_div failed");
  531.     return r;
  532. }
  533. inline const CBigNum operator%(const CBigNum& a, const CBigNum& b)
  534. {
  535.     CAutoBN_CTX pctx;
  536.     CBigNum r;
  537.     if (!BN_mod(&r, &a, &b, pctx))
  538.         throw bignum_error("CBigNum::operator% : BN_div failed");
  539.     return r;
  540. }
  541. inline const CBigNum operator<<(const CBigNum& a, unsigned int shift)
  542. {
  543.     CBigNum r;
  544.     if (!BN_lshift(&r, &a, shift))
  545.         throw bignum_error("CBigNum:operator<< : BN_lshift failed");
  546.     return r;
  547. }
  548. inline const CBigNum operator>>(const CBigNum& a, unsigned int shift)
  549. {
  550.     CBigNum r;
  551.     if (!BN_rshift(&r, &a, shift))
  552.         throw bignum_error("CBigNum:operator>> : BN_rshift failed");
  553.     return r;
  554. }
  555. inline bool operator==(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) == 0); }
  556. inline bool operator!=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) != 0); }
  557. inline bool operator<=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) <= 0); }
  558. inline bool operator>=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) >= 0); }
  559. inline bool operator<(const CBigNum& a, const CBigNum& b)  { return (BN_cmp(&a, &b) < 0); }
  560. inline bool operator>(const CBigNum& a, const CBigNum& b)  { return (BN_cmp(&a, &b) > 0); }
  561. #include "headers.h"
  562. static CCriticalSection cs_db;
  563. static bool fDbEnvInit = false;
  564. DbEnv dbenv(0);
  565. static map<string, int> mapFileUseCount;
  566. class CDBInit
  567. {
  568. public:
  569.     CDBInit()
  570.     {
  571.     }
  572.     ~CDBInit()
  573.     {
  574.         if (fDbEnvInit)
  575.         {
  576.             dbenv.close(0);
  577.             fDbEnvInit = false;
  578.         }
  579.     }
  580. }
  581. instance_of_cdbinit;
  582. CDB::CDB(const char* pszFile, const char* pszMode, bool fTxn) : pdb(NULL)
  583. {
  584.     int ret;
  585.     if (pszFile == NULL)
  586.         return;
  587.  
  588.     bool fCreate = strchr(pszMode, 'c');
  589.     bool fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
  590.     unsigned int nFlags = DB_THREAD;
  591.     if (fCreate)
  592.         nFlags |= DB_CREATE;
  593.     else if (fReadOnly)
  594.         nFlags |= DB_RDONLY;
  595.     if (!fReadOnly || fTxn)
  596.         nFlags |= DB_AUTO_COMMIT;
  597.     CRITICAL_BLOCK(cs_db)
  598.     {
  599.         if (!fDbEnvInit)
  600.         {
  601.             string strAppDir = GetAppDir();
  602.             string strLogDir = strAppDir + "\\database";
  603.             _mkdir(strLogDir.c_str());
  604.             printf("dbenv.open strAppDir=%s\n", strAppDir.c_str());
  605.             dbenv.set_lg_dir(strLogDir.c_str());
  606.             dbenv.set_lg_max(10000000);
  607.             dbenv.set_lk_max_locks(10000);
  608.             dbenv.set_lk_max_objects(10000);
  609.             dbenv.set_errfile(fopen("db.log", "a"));
  610.             ret = dbenv.open(strAppDir.c_str(),
  611.                              DB_CREATE     |
  612.                              DB_INIT_LOCK  |
  613.                              DB_INIT_LOG   |
  614.                              DB_INIT_MPOOL |
  615.                              DB_INIT_TXN   |
  616.                              DB_THREAD     |
  617.                              DB_PRIVATE    |
  618.                              DB_RECOVER,
  619.                              0);
  620.             if (ret > 0)
  621.                 throw runtime_error(strprintf("CDB() : error %d opening database environment\n", ret));
  622.             fDbEnvInit = true;
  623.         }
  624.         strFile = pszFile;
  625.         ++mapFileUseCount[strFile];
  626.     }
  627.     pdb = new Db(&dbenv, 0);
  628.     ret = pdb->open(NULL,      
  629.                     pszFile,  
  630.                     "main",    
  631.                     DB_BTREE,  
  632.                     nFlags,    
  633.                     0);
  634.     if (ret > 0)
  635.     {
  636.         delete pdb;
  637.         pdb = NULL;
  638.         CRITICAL_BLOCK(cs_db)
  639.             --mapFileUseCount[strFile];
  640.         strFile = "";
  641.         throw runtime_error(strprintf("CDB() : can't open database file %s, error %d\n", pszFile, ret));
  642.     }
  643.     if (fCreate && !Exists(string("version")))
  644.         WriteVersion(VERSION);
  645.     RandAddSeed();
  646. }
  647. void CDB::Close()
  648. {
  649.     if (!pdb)
  650.         return;
  651.     if (!vTxn.empty())
  652.         vTxn.front()->abort();
  653.     vTxn.clear();
  654.     pdb->close(0);
  655.     delete pdb;
  656.     pdb = NULL;
  657.     dbenv.txn_checkpoint(0, 0, 0);
  658.     CRITICAL_BLOCK(cs_db)
  659.         --mapFileUseCount[strFile];
  660.     RandAddSeed();
  661. }
  662. void DBFlush(bool fShutdown)
  663. {
  664.     printf("DBFlush(%s)\n", fShutdown ? "true" : "false");
  665.     CRITICAL_BLOCK(cs_db)
  666.     {
  667.         dbenv.txn_checkpoint(0, 0, 0);
  668.         map<string, int>::iterator mi = mapFileUseCount.begin();
  669.         while (mi != mapFileUseCount.end())
  670.         {
  671.             string strFile = (*mi).first;
  672.             int nRefCount = (*mi).second;
  673.             if (nRefCount == 0)
  674.             {
  675.                 dbenv.lsn_reset(strFile.c_str(), 0);
  676.                 mapFileUseCount.erase(mi++);
  677.             }
  678.             else
  679.                 mi++;
  680.         }
  681.         if (fShutdown)
  682.         {
  683.             char** listp;
  684.             if (mapFileUseCount.empty())
  685.                 dbenv.log_archive(&listp, DB_ARCH_REMOVE);
  686.             dbenv.close(0);
  687.             fDbEnvInit = false;
  688.         }
  689.     }
  690. }
  691. bool CTxDB::ReadTxIndex(uint256 hash, CTxIndex& txindex)
  692. {
  693.     assert(!fClient);
  694.     txindex.SetNull();
  695.     return Read(make_pair(string("tx"), hash), txindex);
  696. }
  697. bool CTxDB::UpdateTxIndex(uint256 hash, const CTxIndex& txindex)
  698. {
  699.     assert(!fClient);
  700.     return Write(make_pair(string("tx"), hash), txindex);
  701. }
  702. bool CTxDB::AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight)
  703. {
  704.     assert(!fClient);
  705.     uint256 hash = tx.GetHash();
  706.     CTxIndex txindex(pos, tx.vout.size());
  707.     return Write(make_pair(string("tx"), hash), txindex);
  708. }
  709. bool CTxDB::EraseTxIndex(const CTransaction& tx)
  710. {
  711.     assert(!fClient);
  712.     uint256 hash = tx.GetHash();
  713.     return Erase(make_pair(string("tx"), hash));
  714. }
  715. bool CTxDB::ContainsTx(uint256 hash)
  716. {
  717.     assert(!fClient);
  718.     return Exists(make_pair(string("tx"), hash));
  719. }
  720. bool CTxDB::ReadOwnerTxes(uint160 hash160, int nMinHeight, vector<CTransaction>& vtx)
  721. {
  722.     assert(!fClient);
  723.     vtx.clear();
  724.     Dbc* pcursor = GetCursor();
  725.     if (!pcursor)
  726.         return false;
  727.     unsigned int fFlags = DB_SET_RANGE;
  728.     loop
  729.     {
  730.         CDataStream ssKey;
  731.         if (fFlags == DB_SET_RANGE)
  732.             ssKey << string("owner") << hash160 << CDiskTxPos(0, 0, 0);
  733.         CDataStream ssValue;
  734.         int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
  735.         fFlags = DB_NEXT;
  736.         if (ret == DB_NOTFOUND)
  737.             break;
  738.         else if (ret != 0)
  739.             return false;
  740.         string strType;
  741.         uint160 hashItem;
  742.         CDiskTxPos pos;
  743.         ssKey >> strType >> hashItem >> pos;
  744.         int nItemHeight;
  745.         ssValue >> nItemHeight;
  746.         if (strType != "owner" || hashItem != hash160)
  747.             break;
  748.         if (nItemHeight >= nMinHeight)
  749.         {
  750.             vtx.resize(vtx.size()+1);
  751.             if (!vtx.back().ReadFromDisk(pos))
  752.                 return false;
  753.         }
  754.     }
  755.     return true;
  756. }
  757. bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex)
  758. {
  759.     assert(!fClient);
  760.     tx.SetNull();
  761.     if (!ReadTxIndex(hash, txindex))
  762.         return false;
  763.     return (tx.ReadFromDisk(txindex.pos));
  764. }
  765. bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx)
  766. {
  767.     CTxIndex txindex;
  768.     return ReadDiskTx(hash, tx, txindex);
  769. }
  770. bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex)
  771. {
  772.     return ReadDiskTx(outpoint.hash, tx, txindex);
  773. }
  774. bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx)
  775. {
  776.     CTxIndex txindex;
  777.     return ReadDiskTx(outpoint.hash, tx, txindex);
  778. }
  779. bool CTxDB::WriteBlockIndex(const CDiskBlockIndex& blockindex)
  780. {
  781.     return Write(make_pair(string("blockindex"), blockindex.GetBlockHash()), blockindex);
  782. }
  783. bool CTxDB::EraseBlockIndex(uint256 hash)
  784. {
  785.     return Erase(make_pair(string("blockindex"), hash));
  786. }
  787. bool CTxDB::ReadHashBestChain(uint256& hashBestChain)
  788. {
  789.     return Read(string("hashBestChain"), hashBestChain);
  790. }
  791. bool CTxDB::WriteHashBestChain(uint256 hashBestChain)
  792. {
  793.     return Write(string("hashBestChain"), hashBestChain);
  794. }
  795. CBlockIndex* InsertBlockIndex(uint256 hash)
  796. {
  797.     if (hash == 0)
  798.         return NULL;
  799.     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
  800.     if (mi != mapBlockIndex.end())
  801.         return (*mi).second;
  802.     CBlockIndex* pindexNew = new CBlockIndex();
  803.     if (!pindexNew)
  804.         throw runtime_error("LoadBlockIndex() : new CBlockIndex failed");
  805.     mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
  806.     pindexNew->phashBlock = &((*mi).first);
  807.     return pindexNew;
  808. }
  809. bool CTxDB::LoadBlockIndex()
  810. {
  811.     Dbc* pcursor = GetCursor();
  812.     if (!pcursor)
  813.         return false;
  814.     unsigned int fFlags = DB_SET_RANGE;
  815.     loop
  816.     {
  817.         CDataStream ssKey;
  818.         if (fFlags == DB_SET_RANGE)
  819.             ssKey << make_pair(string("blockindex"), uint256(0));
  820.         CDataStream ssValue;
  821.         int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
  822.         fFlags = DB_NEXT;
  823.         if (ret == DB_NOTFOUND)
  824.             break;
  825.         else if (ret != 0)
  826.             return false;
  827.         string strType;
  828.         ssKey >> strType;
  829.         if (strType == "blockindex")
  830.         {
  831.             CDiskBlockIndex diskindex;
  832.             ssValue >> diskindex;
  833.             CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash());
  834.             pindexNew->pprev          = InsertBlockIndex(diskindex.hashPrev);
  835.             pindexNew->pnext          = InsertBlockIndex(diskindex.hashNext);
  836.             pindexNew->nFile          = diskindex.nFile;
  837.             pindexNew->nBlockPos      = diskindex.nBlockPos;
  838.             pindexNew->nHeight        = diskindex.nHeight;
  839.             pindexNew->nVersion       = diskindex.nVersion;
  840.             pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
  841.             pindexNew->nTime          = diskindex.nTime;
  842.             pindexNew->nBits          = diskindex.nBits;
  843.             pindexNew->nNonce         = diskindex.nNonce;
  844.             if (pindexGenesisBlock == NULL && diskindex.GetBlockHash() == hashGenesisBlock)
  845.                 pindexGenesisBlock = pindexNew;
  846.         }
  847.         else
  848.         {
  849.             break;
  850.         }
  851.     }
  852.     if (!ReadHashBestChain(hashBestChain))
  853.     {
  854.         if (pindexGenesisBlock == NULL)
  855.             return true;
  856.         return error("CTxDB::LoadBlockIndex() : hashBestChain not found\n");
  857.     }
  858.     if (!mapBlockIndex.count(hashBestChain))
  859.         return error("CTxDB::LoadBlockIndex() : blockindex for hashBestChain not found\n");
  860.     pindexBest = mapBlockIndex[hashBestChain];
  861.     nBestHeight = pindexBest->nHeight;
  862.     printf("LoadBlockIndex(): hashBestChain=%s  height=%d\n", hashBestChain.ToString().substr(0,14).c_str(), nBestHeight);
  863.     return true;
  864. }
  865. bool CAddrDB::WriteAddress(const CAddress& addr)
  866. {
  867.     return Write(make_pair(string("addr"), addr.GetKey()), addr);
  868. }
  869. bool CAddrDB::LoadAddresses()
  870. {
  871.     CRITICAL_BLOCK(cs_mapAddresses)
  872.     {
  873.         CAutoFile filein = fopen("addr.txt", "rt");
  874.         if (filein)
  875.         {
  876.             try
  877.             {
  878.                 char psz[1000];
  879.                 while (fgets(psz, sizeof(psz), filein))
  880.                 {
  881.                     CAddress addr(psz, NODE_NETWORK);
  882.                     if (addr.ip != 0)
  883.                         AddAddress(*this, addr);
  884.                 }
  885.             }
  886.             catch (...) { }
  887.         }
  888.         Dbc* pcursor = GetCursor();
  889.         if (!pcursor)
  890.             return false;
  891.         loop
  892.         {
  893.             CDataStream ssKey;
  894.             CDataStream ssValue;
  895.             int ret = ReadAtCursor(pcursor, ssKey, ssValue);
  896.             if (ret == DB_NOTFOUND)
  897.                 break;
  898.             else if (ret != 0)
  899.                 return false;
  900.             string strType;
  901.             ssKey >> strType;
  902.             if (strType == "addr")
  903.             {
  904.                 CAddress addr;
  905.                 ssValue >> addr;
  906.                 mapAddresses.insert(make_pair(addr.GetKey(), addr));
  907.             }
  908.         }
  909.         printf("mapAddresses:\n");
  910.         foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
  911.             item.second.print();
  912.         printf("-----\n");
  913.     }
  914.     return true;
  915. }
  916. bool LoadAddresses()
  917. {
  918.     return CAddrDB("cr+").LoadAddresses();
  919. }
  920. bool CReviewDB::ReadReviews(uint256 hash, vector<CReview>& vReviews)
  921. {
  922.     vReviews.size();
  923.     return Read(make_pair(string("reviews"), hash), vReviews);
  924. }
  925. bool CReviewDB::WriteReviews(uint256 hash, const vector<CReview>& vReviews)
  926. {
  927.     return Write(make_pair(string("reviews"), hash), vReviews);
  928. }
  929. bool CWalletDB::LoadWallet(vector<unsigned char>& vchDefaultKeyRet)
  930. {
  931.     vchDefaultKeyRet.clear();
  932.     CRITICAL_BLOCK(cs_mapKeys)
  933.     CRITICAL_BLOCK(cs_mapWallet)
  934.     {
  935.         Dbc* pcursor = GetCursor();
  936.         if (!pcursor)
  937.             return false;
  938.         loop
  939.         {
  940.             CDataStream ssKey;
  941.             CDataStream ssValue;
  942.             int ret = ReadAtCursor(pcursor, ssKey, ssValue);
  943.             if (ret == DB_NOTFOUND)
  944.                 break;
  945.             else if (ret != 0)
  946.                 return false;
  947.             string strType;
  948.             ssKey >> strType;
  949.             if (strType == "name")
  950.             {
  951.                 string strAddress;
  952.                 ssKey >> strAddress;
  953.                 ssValue >> mapAddressBook[strAddress];
  954.             }
  955.             else if (strType == "tx")
  956.             {
  957.                 uint256 hash;
  958.                 ssKey >> hash;
  959.                 CWalletTx& wtx = mapWallet[hash];
  960.                 ssValue >> wtx;
  961.  
  962.                 if (wtx.GetHash() != hash)
  963.                     printf("Error in wallet.dat, hash mismatch\n");
  964.             }
  965.             else if (strType == "key")
  966.             {
  967.                 vector<unsigned char> vchPubKey;
  968.                 ssKey >> vchPubKey;
  969.                 CPrivKey vchPrivKey;
  970.                 ssValue >> vchPrivKey;
  971.                 mapKeys[vchPubKey] = vchPrivKey;
  972.                 mapPubKeys[Hash160(vchPubKey)] = vchPubKey;
  973.             }
  974.             else if (strType == "defaultkey")
  975.             {
  976.                 ssValue >> vchDefaultKeyRet;
  977.             }
  978.             else if (strType == "setting")
  979.             {
  980.                 string strKey;
  981.                 ssKey >> strKey;
  982.                 if (strKey == "fGenerateBitcoins")  ssValue >> fGenerateBitcoins;
  983.                 if (strKey == "nTransactionFee")    ssValue >> nTransactionFee;
  984.                 if (strKey == "addrIncoming")       ssValue >> addrIncoming;
  985.             }
  986.         }
  987.     }
  988.     printf("fGenerateBitcoins = %d\n", fGenerateBitcoins);
  989.     printf("nTransactionFee = %I64d\n", nTransactionFee);
  990.     printf("addrIncoming = %s\n", addrIncoming.ToString().c_str());
  991.     return true;
  992. }
  993. bool LoadWallet()
  994. {
  995.     vector<unsigned char> vchDefaultKey;
  996.     if (!CWalletDB("cr").LoadWallet(vchDefaultKey))
  997.         return false;
  998.     if (mapKeys.count(vchDefaultKey))
  999.     {
  1000.         keyUser.SetPubKey(vchDefaultKey);
  1001.         keyUser.SetPrivKey(mapKeys[vchDefaultKey]);
  1002.     }
  1003.     else
  1004.     {
  1005.         keyUser.MakeNewKey();
  1006.         if (!AddKey(keyUser))
  1007.             return false;
  1008.         if (!SetAddressBookName(PubKeyToAddress(keyUser.GetPubKey()), "Your Address"))
  1009.             return false;
  1010.         CWalletDB().WriteDefaultKey(keyUser.GetPubKey());
  1011.     }
  1012.     return true;
  1013. }
  1014. #include <db_cxx.h>
  1015. class CTransaction;
  1016. class CTxIndex;
  1017. class CDiskBlockIndex;
  1018. class CDiskTxPos;
  1019. class COutPoint;
  1020. class CUser;
  1021. class CReview;
  1022. class CAddress;
  1023. class CWalletTx;
  1024. extern map<string, string> mapAddressBook;
  1025. extern bool fClient;
  1026. extern DbEnv dbenv;
  1027. extern void DBFlush(bool fShutdown);
  1028. class CDB
  1029. {
  1030. protected:
  1031.     Db* pdb;
  1032.     string strFile;
  1033.     vector<DbTxn*> vTxn;
  1034.     explicit CDB(const char* pszFile, const char* pszMode="r+", bool fTxn=false);
  1035.     ~CDB() { Close(); }
  1036. public:
  1037.     void Close();
  1038. private:
  1039.     CDB(const CDB&);
  1040.     void operator=(const CDB&);
  1041. protected:
  1042.     template<typename K, typename T>
  1043.     bool Read(const K& key, T& value)
  1044.     {
  1045.         if (!pdb)
  1046.             return false;
  1047.         CDataStream ssKey(SER_DISK);
  1048.         ssKey.reserve(1000);
  1049.         ssKey << key;
  1050.         Dbt datKey(&ssKey[0], ssKey.size());
  1051.         Dbt datValue;
  1052.         datValue.set_flags(DB_DBT_MALLOC);
  1053.         int ret = pdb->get(GetTxn(), &datKey, &datValue, 0);
  1054.         memset(datKey.get_data(), 0, datKey.get_size());
  1055.         if (datValue.get_data() == NULL)
  1056.             return false;
  1057.         CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK);
  1058.         ssValue >> value;
  1059.         memset(datValue.get_data(), 0, datValue.get_size());
  1060.         free(datValue.get_data());
  1061.         return (ret == 0);
  1062.     }
  1063.     template<typename K, typename T>
  1064.     bool Write(const K& key, const T& value, bool fOverwrite=true)
  1065.     {
  1066.         if (!pdb)
  1067.             return false;
  1068.         CDataStream ssKey(SER_DISK);
  1069.         ssKey.reserve(1000);
  1070.         ssKey << key;
  1071.         Dbt datKey(&ssKey[0], ssKey.size());
  1072.         CDataStream ssValue(SER_DISK);
  1073.         ssValue.reserve(10000);
  1074.         ssValue << value;
  1075.         Dbt datValue(&ssValue[0], ssValue.size());
  1076.         int ret = pdb->put(GetTxn(), &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
  1077.         memset(datKey.get_data(), 0, datKey.get_size());
  1078.         memset(datValue.get_data(), 0, datValue.get_size());
  1079.         return (ret == 0);
  1080.     }
  1081.     template<typename K>
  1082.     bool Erase(const K& key)
  1083.     {
  1084.         if (!pdb)
  1085.             return false;
  1086.         CDataStream ssKey(SER_DISK);
  1087.         ssKey.reserve(1000);
  1088.         ssKey << key;
  1089.         Dbt datKey(&ssKey[0], ssKey.size());
  1090.         int ret = pdb->del(GetTxn(), &datKey, 0);
  1091.         memset(datKey.get_data(), 0, datKey.get_size());
  1092.         return (ret == 0 || ret == DB_NOTFOUND);
  1093.     }
  1094.     template<typename K>
  1095.     bool Exists(const K& key)
  1096.     {
  1097.         if (!pdb)
  1098.             return false;
  1099.         CDataStream ssKey(SER_DISK);
  1100.         ssKey.reserve(1000);
  1101.         ssKey << key;
  1102.         Dbt datKey(&ssKey[0], ssKey.size());
  1103.         int ret = pdb->exists(GetTxn(), &datKey, 0);
  1104.         memset(datKey.get_data(), 0, datKey.get_size());
  1105.         return (ret == 0);
  1106.     }
  1107.     Dbc* GetCursor()
  1108.     {
  1109.         if (!pdb)
  1110.             return NULL;
  1111.         Dbc* pcursor = NULL;
  1112.         int ret = pdb->cursor(NULL, &pcursor, 0);
  1113.         if (ret != 0)
  1114.             return NULL;
  1115.         return pcursor;
  1116.     }
  1117.     int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags=DB_NEXT)
  1118.     {
  1119.         Dbt datKey;
  1120.         if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
  1121.         {
  1122.             datKey.set_data(&ssKey[0]);
  1123.             datKey.set_size(ssKey.size());
  1124.         }
  1125.         Dbt datValue;
  1126.         if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
  1127.         {
  1128.             datValue.set_data(&ssValue[0]);
  1129.             datValue.set_size(ssValue.size());
  1130.         }
  1131.         datKey.set_flags(DB_DBT_MALLOC);
  1132.         datValue.set_flags(DB_DBT_MALLOC);
  1133.         int ret = pcursor->get(&datKey, &datValue, fFlags);
  1134.         if (ret != 0)
  1135.             return ret;
  1136.         else if (datKey.get_data() == NULL || datValue.get_data() == NULL)
  1137.             return 99999;
  1138.         ssKey.SetType(SER_DISK);
  1139.         ssKey.clear();
  1140.         ssKey.write((char*)datKey.get_data(), datKey.get_size());
  1141.         ssValue.SetType(SER_DISK);
  1142.         ssValue.clear();
  1143.         ssValue.write((char*)datValue.get_data(), datValue.get_size());
  1144.         memset(datKey.get_data(), 0, datKey.get_size());
  1145.         memset(datValue.get_data(), 0, datValue.get_size());
  1146.         free(datKey.get_data());
  1147.         free(datValue.get_data());
  1148.         return 0;
  1149.     }
  1150.     DbTxn* GetTxn()
  1151.     {
  1152.         if (!vTxn.empty())
  1153.             return vTxn.back();
  1154.         else
  1155.             return NULL;
  1156.     }
  1157. public:
  1158.     bool TxnBegin()
  1159.     {
  1160.         if (!pdb)
  1161.             return false;
  1162.         DbTxn* ptxn = NULL;
  1163.         int ret = dbenv.txn_begin(GetTxn(), &ptxn, 0);
  1164.         if (!ptxn || ret != 0)
  1165.             return false;
  1166.         vTxn.push_back(ptxn);
  1167.         return true;
  1168.     }
  1169.     bool TxnCommit()
  1170.     {
  1171.         if (!pdb)
  1172.             return false;
  1173.         if (vTxn.empty())
  1174.             return false;
  1175.         int ret = vTxn.back()->commit(0);
  1176.         vTxn.pop_back();
  1177.         return (ret == 0);
  1178.     }
  1179.     bool TxnAbort()
  1180.     {
  1181.         if (!pdb)
  1182.             return false;
  1183.         if (vTxn.empty())
  1184.             return false;
  1185.         int ret = vTxn.back()->abort();
  1186.         vTxn.pop_back();
  1187.         return (ret == 0);
  1188.     }
  1189.     bool ReadVersion(int& nVersion)
  1190.     {
  1191.         nVersion = 0;
  1192.         return Read(string("version"), nVersion);
  1193.     }
  1194.     bool WriteVersion(int nVersion)
  1195.     {
  1196.         return Write(string("version"), nVersion);
  1197.     }
  1198. };
  1199. class CTxDB : public CDB
  1200. {
  1201. public:
  1202.     CTxDB(const char* pszMode="r+", bool fTxn=false) : CDB(!fClient ? "blkindex.dat" : NULL, pszMode, fTxn) { }
  1203. private:
  1204.     CTxDB(const CTxDB&);
  1205.     void operator=(const CTxDB&);
  1206. public:
  1207.     bool ReadTxIndex(uint256 hash, CTxIndex& txindex);
  1208.     bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex);
  1209.     bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight);
  1210.     bool EraseTxIndex(const CTransaction& tx);
  1211.     bool ContainsTx(uint256 hash);
  1212.     bool ReadOwnerTxes(uint160 hash160, int nHeight, vector<CTransaction>& vtx);
  1213.     bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
  1214.     bool ReadDiskTx(uint256 hash, CTransaction& tx);
  1215.     bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
  1216.     bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
  1217.     bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
  1218.     bool EraseBlockIndex(uint256 hash);
  1219.     bool ReadHashBestChain(uint256& hashBestChain);
  1220.     bool WriteHashBestChain(uint256 hashBestChain);
  1221.     bool LoadBlockIndex();
  1222. };
  1223. class CReviewDB : public CDB
  1224. {
  1225. public:
  1226.     CReviewDB(const char* pszMode="r+", bool fTxn=false) : CDB("reviews.dat", pszMode, fTxn) { }
  1227. private:
  1228.     CReviewDB(const CReviewDB&);
  1229.     void operator=(const CReviewDB&);
  1230. public:
  1231.     bool ReadUser(uint256 hash, CUser& user)
  1232.     {
  1233.         return Read(make_pair(string("user"), hash), user);
  1234.     }
  1235.     bool WriteUser(uint256 hash, const CUser& user)
  1236.     {
  1237.         return Write(make_pair(string("user"), hash), user);
  1238.     }
  1239.     bool ReadReviews(uint256 hash, vector<CReview>& vReviews);
  1240.     bool WriteReviews(uint256 hash, const vector<CReview>& vReviews);
  1241. };
  1242. class CMarketDB : public CDB
  1243. {
  1244. public:
  1245.     CMarketDB(const char* pszMode="r+", bool fTxn=false) : CDB("market.dat", pszMode, fTxn) { }
  1246. private:
  1247.     CMarketDB(const CMarketDB&);
  1248.     void operator=(const CMarketDB&);
  1249. };
  1250. class CAddrDB : public CDB
  1251. {
  1252. public:
  1253.     CAddrDB(const char* pszMode="r+", bool fTxn=false) : CDB("addr.dat", pszMode, fTxn) { }
  1254. private:
  1255.     CAddrDB(const CAddrDB&);
  1256.     void operator=(const CAddrDB&);
  1257. public:
  1258.     bool WriteAddress(const CAddress& addr);
  1259.     bool LoadAddresses();
  1260. };
  1261. bool LoadAddresses();
  1262. class CWalletDB : public CDB
  1263. {
  1264. public:
  1265.     CWalletDB(const char* pszMode="r+", bool fTxn=false) : CDB("wallet.dat", pszMode, fTxn) { }
  1266. private:
  1267.     CWalletDB(const CWalletDB&);
  1268.     void operator=(const CWalletDB&);
  1269. public:
  1270.     bool ReadName(const string& strAddress, string& strName)
  1271.     {
  1272.         strName = "";
  1273.         return Read(make_pair(string("name"), strAddress), strName);
  1274.     }
  1275.     bool WriteName(const string& strAddress, const string& strName)
  1276.     {
  1277.         mapAddressBook[strAddress] = strName;
  1278.         return Write(make_pair(string("name"), strAddress), strName);
  1279.     }
  1280.     bool EraseName(const string& strAddress)
  1281.     {
  1282.         mapAddressBook.erase(strAddress);
  1283.         return Erase(make_pair(string("name"), strAddress));
  1284.     }
  1285.     bool ReadTx(uint256 hash, CWalletTx& wtx)
  1286.     {
  1287.         return Read(make_pair(string("tx"), hash), wtx);
  1288.     }
  1289.     bool WriteTx(uint256 hash, const CWalletTx& wtx)
  1290.     {
  1291.         return Write(make_pair(string("tx"), hash), wtx);
  1292.     }
  1293.     bool EraseTx(uint256 hash)
  1294.     {
  1295.         return Erase(make_pair(string("tx"), hash));
  1296.     }
  1297.     bool ReadKey(const vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
  1298.     {
  1299.         vchPrivKey.clear();
  1300.         return Read(make_pair(string("key"), vchPubKey), vchPrivKey);
  1301.     }
  1302.     bool WriteKey(const vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
  1303.     {
  1304.         return Write(make_pair(string("key"), vchPubKey), vchPrivKey, false);
  1305.     }
  1306.     bool ReadDefaultKey(vector<unsigned char>& vchPubKey)
  1307.     {
  1308.         vchPubKey.clear();
  1309.         return Read(string("defaultkey"), vchPubKey);
  1310.     }
  1311.     bool WriteDefaultKey(const vector<unsigned char>& vchPubKey)
  1312.     {
  1313.         return Write(string("defaultkey"), vchPubKey);
  1314.     }
  1315.     template<typename T>
  1316.     bool ReadSetting(const string& strKey, T& value)
  1317.     {
  1318.         return Read(make_pair(string("setting"), strKey), value);
  1319.     }
  1320.     template<typename T>
  1321.     bool WriteSetting(const string& strKey, const T& value)
  1322.     {
  1323.         return Write(make_pair(string("setting"), strKey), value);
  1324.     }
  1325.     bool LoadWallet(vector<unsigned char>& vchDefaultKeyRet);
  1326. };
  1327. bool LoadWallet();
  1328. inline bool SetAddressBookName(const string& strAddress, const string& strName)
  1329. {
  1330.     return CWalletDB().WriteName(strAddress, strName);
  1331. }
  1332. #ifdef _MSC_VER
  1333. #pragma warning(disable:4786)
  1334. #pragma warning(disable:4804)
  1335. #pragma warning(disable:4717)
  1336. #endif
  1337. #ifdef _WIN32_WINNT
  1338. #undef _WIN32_WINNT
  1339. #endif
  1340. #define _WIN32_WINNT 0x0400
  1341. #define WIN32_LEAN_AND_MEAN 1
  1342. #include <wx/wx.h>
  1343. #include <wx/clipbrd.h>
  1344. #include <wx/snglinst.h>
  1345. #include <openssl/ecdsa.h>
  1346. #include <openssl/evp.h>
  1347. #include <openssl/rand.h>
  1348. #include <openssl/sha.h>
  1349. #include <openssl/ripemd.h>
  1350. #include <windows.h>
  1351. #include <winsock2.h>
  1352. #include <mswsock.h>
  1353. #include <stdio.h>
  1354. #include <stdlib.h>
  1355. #include <io.h>
  1356. #include <math.h>
  1357. #include <limits.h>
  1358. #include <float.h>
  1359. #include <assert.h>
  1360. #include <process.h>
  1361. #include <malloc.h>
  1362. #include <memory>
  1363. #define BOUNDSCHECK 1
  1364. #include <sstream>
  1365. #include <string>
  1366. #include <vector>
  1367. #include <list>
  1368. #include <deque>
  1369. #include <map>
  1370. #include <set>
  1371. #include <algorithm>
  1372. #include <numeric>
  1373. #include <boost/foreach.hpp>
  1374. #include <boost/lexical_cast.hpp>
  1375. #include <boost/tuple/tuple.hpp>
  1376. #include <boost/tuple/tuple_comparison.hpp>
  1377. #include <boost/tuple/tuple_io.hpp>
  1378. #include <boost/array.hpp>
  1379. #pragma hdrstop
  1380. using namespace std;
  1381. using namespace boost;
  1382. #include "serialize.h"
  1383. #include "uint256.h"
  1384. #include "util.h"
  1385. #include "key.h"
  1386. #include "bignum.h"
  1387. #include "base58.h"
  1388. #include "script.h"
  1389. #include "db.h"
  1390. #include "net.h"
  1391. #include "irc.h"
  1392. #include "main.h"
  1393. #include "market.h"
  1394. #include "uibase.h"
  1395. #include "ui.h"
  1396. #include "headers.h"
  1397. #pragma pack(1)
  1398. struct ircaddr
  1399. {
  1400.     int ip;
  1401.     short port;
  1402. };
  1403. string EncodeAddress(const CAddress& addr)
  1404. {
  1405.     struct ircaddr tmp;
  1406.     tmp.ip    = addr.ip;
  1407.     tmp.port  = addr.port;
  1408.     vector<unsigned char> vch(UBEGIN(tmp), UEND(tmp));
  1409.     return string("u") + EncodeBase58Check(vch);
  1410. }
  1411. bool DecodeAddress(string str, CAddress& addr)
  1412. {
  1413.     vector<unsigned char> vch;
  1414.     if (!DecodeBase58Check(str.substr(1), vch))
  1415.         return false;
  1416.     struct ircaddr tmp;
  1417.     if (vch.size() != sizeof(tmp))
  1418.         return false;
  1419.     memcpy(&tmp, &vch[0], sizeof(tmp));
  1420.     addr  = CAddress(tmp.ip, tmp.port);
  1421.     return true;
  1422. }
  1423. static bool Send(SOCKET hSocket, const char* pszSend)
  1424. {
  1425.     if (strstr(pszSend, "PONG") != pszSend)
  1426.         printf("SENDING: %s\n", pszSend);
  1427.     const char* psz = pszSend;
  1428.     const char* pszEnd = psz + strlen(psz);
  1429.     while (psz < pszEnd)
  1430.     {
  1431.         int ret = send(hSocket, psz, pszEnd - psz, 0);
  1432.         if (ret < 0)
  1433.             return false;
  1434.         psz += ret;
  1435.     }
  1436.     return true;
  1437. }
  1438. bool RecvLine(SOCKET hSocket, string& strLine)
  1439. {
  1440.     strLine = "";
  1441.     loop
  1442.     {
  1443.         char c;
  1444.         int nBytes = recv(hSocket, &c, 1, 0);
  1445.         if (nBytes > 0)
  1446.         {
  1447.             if (c == '\n')
  1448.                 continue;
  1449.             if (c == '\r')
  1450.                 return true;
  1451.             strLine += c;
  1452.         }
  1453.         else if (nBytes <= 0)
  1454.         {
  1455.             if (!strLine.empty())
  1456.                 return true;
  1457.             printf("IRC socket closed\n");
  1458.             return false;
  1459.         }
  1460.         else
  1461.         {
  1462.             int nErr = WSAGetLastError();
  1463.             if (nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
  1464.             {
  1465.                 printf("IRC recv failed: %d\n", nErr);
  1466.                 return false;
  1467.             }
  1468.         }
  1469.     }
  1470. }
  1471. bool RecvLineIRC(SOCKET hSocket, string& strLine)
  1472. {
  1473.     loop
  1474.     {
  1475.         bool fRet = RecvLine(hSocket, strLine);
  1476.         if (fRet)
  1477.         {
  1478.             if (fShutdown)
  1479.                 return false;
  1480.             vector<string> vWords;
  1481.             ParseString(strLine, ' ', vWords);
  1482.             if (vWords[0] == "PING")
  1483.             {
  1484.                 strLine[1] = 'O';
  1485.                 strLine += '\r';
  1486.                 Send(hSocket, strLine.c_str());
  1487.                 continue;
  1488.             }
  1489.         }
  1490.         return fRet;
  1491.     }
  1492. }
  1493. bool RecvUntil(SOCKET hSocket, const char* psz1, const char* psz2=NULL, const char* psz3=NULL)
  1494. {
  1495.     loop
  1496.     {
  1497.         string strLine;
  1498.         if (!RecvLineIRC(hSocket, strLine))
  1499.             return false;
  1500.         printf("IRC %s\n", strLine.c_str());
  1501.         if (psz1 && strLine.find(psz1) != -1)
  1502.             return true;
  1503.         if (psz2 && strLine.find(psz2) != -1)
  1504.             return true;
  1505.         if (psz3 && strLine.find(psz3) != -1)
  1506.             return true;
  1507.     }
  1508. }
  1509. bool fRestartIRCSeed = false;
  1510. void ThreadIRCSeed(void* parg)
  1511. {
  1512.     loop
  1513.     {
  1514.         struct hostent* phostent = gethostbyname("chat.freenode.net");
  1515.         CAddress addrConnect(*(u_long*)phostent->h_addr_list[0], htons(6667));
  1516.         SOCKET hSocket;
  1517.         if (!ConnectSocket(addrConnect, hSocket))
  1518.         {
  1519.             printf("IRC connect failed\n");
  1520.             return;
  1521.         }
  1522.         if (!RecvUntil(hSocket, "Found your hostname", "using your IP address instead", "Couldn't look up your hostname"))
  1523.         {
  1524.             closesocket(hSocket);
  1525.             return;
  1526.         }
  1527.         string strMyName = EncodeAddress(addrLocalHost);
  1528.         if (!addrLocalHost.IsRoutable())
  1529.             strMyName = strprintf("x%u", GetRand(1000000000));
  1530.         Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
  1531.         Send(hSocket, strprintf("USER %s 8 * : %s\r", strMyName.c_str(), strMyName.c_str()).c_str());
  1532.         if (!RecvUntil(hSocket, " 004 "))
  1533.         {
  1534.             closesocket(hSocket);
  1535.             return;
  1536.         }
  1537.         Sleep(500);
  1538.         Send(hSocket, "JOIN #bitcoin\r");
  1539.         Send(hSocket, "WHO #bitcoin\r");
  1540.         while (!fRestartIRCSeed)
  1541.         {
  1542.             string strLine;
  1543.             if (fShutdown || !RecvLineIRC(hSocket, strLine))
  1544.             {
  1545.                 closesocket(hSocket);
  1546.                 return;
  1547.             }
  1548.             if (strLine.empty() || strLine[0] != ':')
  1549.                 continue;
  1550.             printf("IRC %s\n", strLine.c_str());
  1551.             vector<string> vWords;
  1552.             ParseString(strLine, ' ', vWords);
  1553.             if (vWords.size() < 2)
  1554.                 continue;
  1555.             char pszName[10000];
  1556.             pszName[0] = '\0';
  1557.             if (vWords[1] == "352" && vWords.size() >= 8)
  1558.             {            
  1559.                 strcpy(pszName, vWords[7].c_str());
  1560.                 printf("GOT WHO: [%s]  ", pszName);
  1561.             }
  1562.             if (vWords[1] == "JOIN")
  1563.             {
  1564.                 strcpy(pszName, vWords[0].c_str() + 1);
  1565.                 if (strchr(pszName, '!'))
  1566.                     *strchr(pszName, '!') = '\0';
  1567.                 printf("GOT JOIN: [%s]  ", pszName);
  1568.             }
  1569.             if (pszName[0] == 'u')
  1570.             {
  1571.                 CAddress addr;
  1572.                 if (DecodeAddress(pszName, addr))
  1573.                 {
  1574.                     CAddrDB addrdb;
  1575.                     if (AddAddress(addrdb, addr))
  1576.                         printf("new  ");
  1577.                     addr.print();
  1578.                 }
  1579.                 else
  1580.                 {
  1581.                     printf("decode failed\n");
  1582.                 }
  1583.             }
  1584.         }
  1585.         fRestartIRCSeed = false;
  1586.         closesocket(hSocket);
  1587.     }
  1588. }
  1589. #ifdef TEST
  1590. int main(int argc, char *argv[])
  1591. {
  1592.     WSADATA wsadata;
  1593.     if (WSAStartup(MAKEWORD(2,2), &wsadata) != NO_ERROR)
  1594.     {
  1595.         printf("Error at WSAStartup()\n");
  1596.         return false;
  1597.     }
  1598.     ThreadIRCSeed(NULL);
  1599.     WSACleanup();
  1600.     return 0;
  1601. }
  1602. #endif
  1603. extern bool RecvLine(SOCKET hSocket, string& strLine);
  1604. extern void ThreadIRCSeed(void* parg);
  1605. extern bool fRestartIRCSeed;
  1606. class key_error : public std::runtime_error
  1607. {
  1608. public:
  1609.     explicit key_error(const std::string& str) : std::runtime_error(str) {}
  1610. };
  1611. typedef vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
  1612. class CKey
  1613. {
  1614. protected:
  1615.     EC_KEY* pkey;
  1616. public:
  1617.     CKey()
  1618.     {
  1619.         pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
  1620.         if (pkey == NULL)
  1621.             throw key_error("CKey::CKey() : EC_KEY_new_by_curve_name failed");
  1622.     }
  1623.     CKey(const CKey& b)
  1624.     {
  1625.         pkey = EC_KEY_dup(b.pkey);
  1626.         if (pkey == NULL)
  1627.             throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
  1628.     }
  1629.     CKey& operator=(const CKey& b)
  1630.     {
  1631.         if (!EC_KEY_copy(pkey, b.pkey))
  1632.             throw key_error("CKey::operator=(const CKey&) : EC_KEY_copy failed");
  1633.         return (*this);
  1634.     }
  1635.     ~CKey()
  1636.     {
  1637.         EC_KEY_free(pkey);
  1638.     }
  1639.     void MakeNewKey()
  1640.     {
  1641.         if (!EC_KEY_generate_key(pkey))
  1642.             throw key_error("CKey::MakeNewKey() : EC_KEY_generate_key failed");
  1643.     }
  1644.     bool SetPrivKey(const CPrivKey& vchPrivKey)
  1645.     {
  1646.         const unsigned char* pbegin = &vchPrivKey[0];
  1647.         if (!d2i_ECPrivateKey(&pkey, &pbegin, vchPrivKey.size()))
  1648.             return false;
  1649.         return true;
  1650.     }
  1651.     CPrivKey GetPrivKey() const
  1652.     {
  1653.         unsigned int nSize = i2d_ECPrivateKey(pkey, NULL);
  1654.         if (!nSize)
  1655.             throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey failed");
  1656.         CPrivKey vchPrivKey(nSize, 0);
  1657.         unsigned char* pbegin = &vchPrivKey[0];
  1658.         if (i2d_ECPrivateKey(pkey, &pbegin) != nSize)
  1659.             throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey returned unexpected size");
  1660.         return vchPrivKey;
  1661.     }
  1662.     bool SetPubKey(const vector<unsigned char>& vchPubKey)
  1663.     {
  1664.         const unsigned char* pbegin = &vchPubKey[0];
  1665.         if (!o2i_ECPublicKey(&pkey, &pbegin, vchPubKey.size()))
  1666.             return false;
  1667.         return true;
  1668.     }
  1669.     vector<unsigned char> GetPubKey() const
  1670.     {
  1671.         unsigned int nSize = i2o_ECPublicKey(pkey, NULL);
  1672.         if (!nSize)
  1673.             throw key_error("CKey::GetPubKey() : i2o_ECPublicKey failed");
  1674.         vector<unsigned char> vchPubKey(nSize, 0);
  1675.         unsigned char* pbegin = &vchPubKey[0];
  1676.         if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
  1677.             throw key_error("CKey::GetPubKey() : i2o_ECPublicKey returned unexpected size");
  1678.         return vchPubKey;
  1679.     }
  1680.     bool Sign(uint256 hash, vector<unsigned char>& vchSig)
  1681.     {
  1682.         vchSig.clear();
  1683.         unsigned char pchSig[10000];
  1684.         unsigned int nSize = 0;
  1685.         if (!ECDSA_sign(0, (unsigned char*)&hash, sizeof(hash), pchSig, &nSize, pkey))
  1686.             return false;
  1687.         vchSig.resize(nSize);
  1688.         memcpy(&vchSig[0], pchSig, nSize);
  1689.         return true;
  1690.     }
  1691.     bool Verify(uint256 hash, const vector<unsigned char>& vchSig)
  1692.     {
  1693.         if (ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), &vchSig[0], vchSig.size(), pkey) != 1)
  1694.             return false;
  1695.         return true;
  1696.     }
  1697.     static bool Sign(const CPrivKey& vchPrivKey, uint256 hash, vector<unsigned char>& vchSig)
  1698.     {
  1699.         CKey key;
  1700.         if (!key.SetPrivKey(vchPrivKey))
  1701.             return false;
  1702.         return key.Sign(hash, vchSig);
  1703.     }
  1704.     static bool Verify(const vector<unsigned char>& vchPubKey, uint256 hash, const vector<unsigned char>& vchSig)
  1705.     {
  1706.         CKey key;
  1707.         if (!key.SetPubKey(vchPubKey))
  1708.             return false;
  1709.         return key.Verify(hash, vchSig);
  1710.     }
  1711. };
  1712. #include "headers.h"
  1713. #include "sha.h"
  1714. CCriticalSection cs_main;
  1715. map<uint256, CTransaction> mapTransactions;
  1716. CCriticalSection cs_mapTransactions;
  1717. unsigned int nTransactionsUpdated = 0;
  1718. map<COutPoint, CInPoint> mapNextTx;
  1719. map<uint256, CBlockIndex*> mapBlockIndex;
  1720. const uint256 hashGenesisBlock("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
  1721. CBlockIndex* pindexGenesisBlock = NULL;
  1722. int nBestHeight = -1;
  1723. uint256 hashBestChain = 0;
  1724. CBlockIndex* pindexBest = NULL;
  1725. map<uint256, CBlock*> mapOrphanBlocks;
  1726. multimap<uint256, CBlock*> mapOrphanBlocksByPrev;
  1727. map<uint256, CDataStream*> mapOrphanTransactions;
  1728. multimap<uint256, CDataStream*> mapOrphanTransactionsByPrev;
  1729. map<uint256, CWalletTx> mapWallet;
  1730. vector<pair<uint256, bool> > vWalletUpdated;
  1731. CCriticalSection cs_mapWallet;
  1732. map<vector<unsigned char>, CPrivKey> mapKeys;
  1733. map<uint160, vector<unsigned char> > mapPubKeys;
  1734. CCriticalSection cs_mapKeys;
  1735. CKey keyUser;
  1736. string strSetDataDir;
  1737. int nDropMessagesTest = 0;
  1738. int fGenerateBitcoins;
  1739. int64 nTransactionFee = 0;
  1740. CAddress addrIncoming;
  1741. bool AddKey(const CKey& key)
  1742. {
  1743.     CRITICAL_BLOCK(cs_mapKeys)
  1744.     {
  1745.         mapKeys[key.GetPubKey()] = key.GetPrivKey();
  1746.         mapPubKeys[Hash160(key.GetPubKey())] = key.GetPubKey();
  1747.     }
  1748.     return CWalletDB().WriteKey(key.GetPubKey(), key.GetPrivKey());
  1749. }
  1750. vector<unsigned char> GenerateNewKey()
  1751. {
  1752.     CKey key;
  1753.     key.MakeNewKey();
  1754.     if (!AddKey(key))
  1755.         throw runtime_error("GenerateNewKey() : AddKey failed\n");
  1756.     return key.GetPubKey();
  1757. }
  1758. bool AddToWallet(const CWalletTx& wtxIn)
  1759. {
  1760.     uint256 hash = wtxIn.GetHash();
  1761.     CRITICAL_BLOCK(cs_mapWallet)
  1762.     {
  1763.         pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
  1764.         CWalletTx& wtx = (*ret.first).second;
  1765.         bool fInsertedNew = ret.second;
  1766.         if (fInsertedNew)
  1767.             wtx.nTimeReceived = GetAdjustedTime();
  1768.         printf("AddToWallet %s  %s\n", wtxIn.GetHash().ToString().substr(0,6).c_str(), fInsertedNew ? "new" : "update");
  1769.         if (!fInsertedNew)
  1770.         {
  1771.             bool fUpdated = false;
  1772.             if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
  1773.             {
  1774.                 wtx.hashBlock = wtxIn.hashBlock;
  1775.                 fUpdated = true;
  1776.             }
  1777.             if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
  1778.             {
  1779.                 wtx.vMerkleBranch = wtxIn.vMerkleBranch;
  1780.                 wtx.nIndex = wtxIn.nIndex;
  1781.                 fUpdated = true;
  1782.             }
  1783.             if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
  1784.             {
  1785.                 wtx.fFromMe = wtxIn.fFromMe;
  1786.                 fUpdated = true;
  1787.             }
  1788.             if (wtxIn.fSpent && wtxIn.fSpent != wtx.fSpent)
  1789.             {
  1790.                 wtx.fSpent = wtxIn.fSpent;
  1791.                 fUpdated = true;
  1792.             }
  1793.             if (!fUpdated)
  1794.                 return true;
  1795.         }
  1796.         if (!wtx.WriteToDisk())
  1797.             return false;
  1798.         vWalletUpdated.push_back(make_pair(hash, fInsertedNew));
  1799.     }
  1800.     MainFrameRepaint();
  1801.     return true;
  1802. }
  1803. bool AddToWalletIfMine(const CTransaction& tx, const CBlock* pblock)
  1804. {
  1805.     if (tx.IsMine() || mapWallet.count(tx.GetHash()))
  1806.     {
  1807.         CWalletTx wtx(tx);
  1808.         if (pblock)
  1809.             wtx.SetMerkleBranch(pblock);
  1810.         return AddToWallet(wtx);
  1811.     }
  1812.     return true;
  1813. }
  1814. bool EraseFromWallet(uint256 hash)
  1815. {
  1816.     CRITICAL_BLOCK(cs_mapWallet)
  1817.     {
  1818.         if (mapWallet.erase(hash))
  1819.             CWalletDB().EraseTx(hash);
  1820.     }
  1821.     return true;
  1822. }
  1823. void AddOrphanTx(const CDataStream& vMsg)
  1824. {
  1825.     CTransaction tx;
  1826.     CDataStream(vMsg) >> tx;
  1827.     uint256 hash = tx.GetHash();
  1828.     if (mapOrphanTransactions.count(hash))
  1829.         return;
  1830.     CDataStream* pvMsg = mapOrphanTransactions[hash] = new CDataStream(vMsg);
  1831.     foreach(const CTxIn& txin, tx.vin)
  1832.         mapOrphanTransactionsByPrev.insert(make_pair(txin.prevout.hash, pvMsg));
  1833. }
  1834. void EraseOrphanTx(uint256 hash)
  1835. {
  1836.     if (!mapOrphanTransactions.count(hash))
  1837.         return;
  1838.     const CDataStream* pvMsg = mapOrphanTransactions[hash];
  1839.     CTransaction tx;
  1840.     CDataStream(*pvMsg) >> tx;
  1841.     foreach(const CTxIn& txin, tx.vin)
  1842.     {
  1843.         for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(txin.prevout.hash);
  1844.              mi != mapOrphanTransactionsByPrev.upper_bound(txin.prevout.hash);)
  1845.         {
  1846.             if ((*mi).second == pvMsg)
  1847.                 mapOrphanTransactionsByPrev.erase(mi++);
  1848.             else
  1849.                 mi++;
  1850.         }
  1851.     }
  1852.     delete pvMsg;
  1853.     mapOrphanTransactions.erase(hash);
  1854. }
  1855. bool CTxIn::IsMine() const
  1856. {
  1857.     CRITICAL_BLOCK(cs_mapWallet)
  1858.     {
  1859.         map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
  1860.         if (mi != mapWallet.end())
  1861.         {
  1862.             const CWalletTx& prev = (*mi).second;
  1863.             if (prevout.n < prev.vout.size())
  1864.                 if (prev.vout[prevout.n].IsMine())
  1865.                     return true;
  1866.         }
  1867.     }
  1868.     return false;
  1869. }
  1870. int64 CTxIn::GetDebit() const
  1871. {
  1872.     CRITICAL_BLOCK(cs_mapWallet)
  1873.     {
  1874.         map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
  1875.         if (mi != mapWallet.end())
  1876.         {
  1877.             const CWalletTx& prev = (*mi).second;
  1878.             if (prevout.n < prev.vout.size())
  1879.                 if (prev.vout[prevout.n].IsMine())
  1880.                     return prev.vout[prevout.n].nValue;
  1881.         }
  1882.     }
  1883.     return 0;
  1884. }
  1885. int64 CWalletTx::GetTxTime() const
  1886. {
  1887.     if (!fTimeReceivedIsTxTime && hashBlock != 0)
  1888.     {
  1889.         map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
  1890.         if (mi != mapBlockIndex.end())
  1891.         {
  1892.             CBlockIndex* pindex = (*mi).second;
  1893.             if (pindex)
  1894.                 return pindex->GetMedianTime();
  1895.         }
  1896.     }
  1897.     return nTimeReceived;
  1898. }
  1899. int CMerkleTx::SetMerkleBranch(const CBlock* pblock)
  1900. {
  1901.     if (fClient)
  1902.     {
  1903.         if (hashBlock == 0)
  1904.             return 0;
  1905.     }
  1906.     else
  1907.     {
  1908.         CBlock blockTmp;
  1909.         if (pblock == NULL)
  1910.         {
  1911.             CTxIndex txindex;
  1912.             if (!CTxDB("r").ReadTxIndex(GetHash(), txindex))
  1913.                 return 0;
  1914.             if (!blockTmp.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos, true))
  1915.                 return 0;
  1916.             pblock = &blockTmp;
  1917.         }
  1918.         hashBlock = pblock->GetHash();
  1919.         for (nIndex = 0; nIndex < pblock->vtx.size(); nIndex++)
  1920.             if (pblock->vtx[nIndex] == *(CTransaction*)this)
  1921.                 break;
  1922.         if (nIndex == pblock->vtx.size())
  1923.         {
  1924.             vMerkleBranch.clear();
  1925.             nIndex = -1;
  1926.             printf("ERROR: SetMerkleBranch() : couldn't find tx in block\n");
  1927.             return 0;
  1928.         }
  1929.         vMerkleBranch = pblock->GetMerkleBranch(nIndex);
  1930.     }
  1931.     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
  1932.     if (mi == mapBlockIndex.end())
  1933.         return 0;
  1934.     CBlockIndex* pindex = (*mi).second;
  1935.     if (!pindex || !pindex->IsInMainChain())
  1936.         return 0;
  1937.     return pindexBest->nHeight - pindex->nHeight + 1;
  1938. }
  1939. void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
  1940. {
  1941.     vtxPrev.clear();
  1942.     const int COPY_DEPTH = 3;
  1943.     if (SetMerkleBranch() < COPY_DEPTH)
  1944.     {
  1945.         vector<uint256> vWorkQueue;
  1946.         foreach(const CTxIn& txin, vin)
  1947.         vWorkQueue.push_back(txin.prevout.hash);
  1948.         CRITICAL_BLOCK(cs_mapWallet)
  1949.         {
  1950.             map<uint256, const CMerkleTx*> mapWalletPrev;
  1951.             set<uint256> setAlreadyDone;
  1952.             for (int i = 0; i < vWorkQueue.size(); i++)
  1953.             {
  1954.                 uint256 hash = vWorkQueue[i];
  1955.                 if (setAlreadyDone.count(hash))
  1956.                     continue;
  1957.                 setAlreadyDone.insert(hash);
  1958.                 CMerkleTx tx;
  1959.                 if (mapWallet.count(hash))
  1960.                 {
  1961.                     tx = mapWallet[hash];
  1962.                     foreach(const CMerkleTx& txWalletPrev, mapWallet[hash].vtxPrev)
  1963.                         mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
  1964.                 }
  1965.                 else if (mapWalletPrev.count(hash))
  1966.                 {
  1967.                     tx = *mapWalletPrev[hash];
  1968.                 }
  1969.                 else if (!fClient && txdb.ReadDiskTx(hash, tx))
  1970.                 {
  1971.                     ;
  1972.                 }
  1973.                 else
  1974.                 {
  1975.                     printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
  1976.                     continue;
  1977.                 }
  1978.                 int nDepth = tx.SetMerkleBranch();
  1979.                 vtxPrev.push_back(tx);
  1980.                 if (nDepth < COPY_DEPTH)
  1981.                     foreach(const CTxIn& txin, tx.vin)
  1982.                         vWorkQueue.push_back(txin.prevout.hash);
  1983.             }
  1984.         }
  1985.     }
  1986.     reverse(vtxPrev.begin(), vtxPrev.end());
  1987. }
  1988. bool CTransaction::AcceptTransaction(CTxDB& txdb, bool fCheckInputs, bool* pfMissingInputs)
  1989. {
  1990.     if (pfMissingInputs)
  1991.         *pfMissingInputs = false;
  1992.     if (IsCoinBase())
  1993.         return error("AcceptTransaction() : coinbase as individual tx");
  1994.     if (!CheckTransaction())
  1995.         return error("AcceptTransaction() : CheckTransaction failed");
  1996.     uint256 hash = GetHash();
  1997.     CRITICAL_BLOCK(cs_mapTransactions)
  1998.         if (mapTransactions.count(hash))
  1999.             return false;
  2000.     if (fCheckInputs)
  2001.         if (txdb.ContainsTx(hash))
  2002.             return false;
  2003.     CTransaction* ptxOld = NULL;
  2004.     for (int i = 0; i < vin.size(); i++)
  2005.     {
  2006.         COutPoint outpoint = vin[i].prevout;
  2007.         if (mapNextTx.count(outpoint))
  2008.         {
  2009.             if (i != 0)
  2010.                 return false;
  2011.             ptxOld = mapNextTx[outpoint].ptx;
  2012.             if (!IsNewerThan(*ptxOld))
  2013.                 return false;
  2014.             for (int i = 0; i < vin.size(); i++)
  2015.             {
  2016.                 COutPoint outpoint = vin[i].prevout;
  2017.                 if (!mapNextTx.count(outpoint) || mapNextTx[outpoint].ptx != ptxOld)
  2018.                     return false;
  2019.             }
  2020.             break;
  2021.         }
  2022.     }
  2023.     map<uint256, CTxIndex> mapUnused;
  2024.     int64 nFees = 0;
  2025.     if (fCheckInputs && !ConnectInputs(txdb, mapUnused, CDiskTxPos(1,1,1), 0, nFees, false, false))
  2026.     {
  2027.         if (pfMissingInputs)
  2028.             *pfMissingInputs = true;
  2029.         return error("AcceptTransaction() : ConnectInputs failed %s", hash.ToString().substr(0,6).c_str());
  2030.     }
  2031.     CRITICAL_BLOCK(cs_mapTransactions)
  2032.     {
  2033.         if (ptxOld)
  2034.         {
  2035.             printf("mapTransaction.erase(%s) replacing with new version\n", ptxOld->GetHash().ToString().c_str());
  2036.             mapTransactions.erase(ptxOld->GetHash());
  2037.         }
  2038.         AddToMemoryPool();
  2039.     }
  2040.     if (ptxOld)
  2041.         EraseFromWallet(ptxOld->GetHash());
  2042.     printf("AcceptTransaction(): accepted %s\n", hash.ToString().substr(0,6).c_str());
  2043.     return true;
  2044. }
  2045. bool CTransaction::AddToMemoryPool()
  2046. {
  2047.     CRITICAL_BLOCK(cs_mapTransactions)
  2048.     {
  2049.         uint256 hash = GetHash();
  2050.         mapTransactions[hash] = *this;
  2051.         for (int i = 0; i < vin.size(); i++)
  2052.             mapNextTx[vin[i].prevout] = CInPoint(&mapTransactions[hash], i);
  2053.         nTransactionsUpdated++;
  2054.     }
  2055.     return true;
  2056. }
  2057. bool CTransaction::RemoveFromMemoryPool()
  2058. {
  2059.     CRITICAL_BLOCK(cs_mapTransactions)
  2060.     {
  2061.         foreach(const CTxIn& txin, vin)
  2062.             mapNextTx.erase(txin.prevout);
  2063.         mapTransactions.erase(GetHash());
  2064.         nTransactionsUpdated++;
  2065.     }
  2066.     return true;
  2067. }
  2068. int CMerkleTx::GetDepthInMainChain() const
  2069. {
  2070.     if (hashBlock == 0 || nIndex == -1)
  2071.         return 0;
  2072.     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
  2073.     if (mi == mapBlockIndex.end())
  2074.         return 0;
  2075.     CBlockIndex* pindex = (*mi).second;
  2076.     if (!pindex || !pindex->IsInMainChain())
  2077.         return 0;
  2078.     if (!fMerkleVerified)
  2079.     {
  2080.         if (CBlock::CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != pindex->hashMerkleRoot)
  2081.             return 0;
  2082.         fMerkleVerified = true;
  2083.     }
  2084.     return pindexBest->nHeight - pindex->nHeight + 1;
  2085. }
  2086. int CMerkleTx::GetBlocksToMaturity() const
  2087. {
  2088.     if (!IsCoinBase())
  2089.         return 0;
  2090.     return max(0, (COINBASE_MATURITY+20) - GetDepthInMainChain());
  2091. }
  2092. bool CMerkleTx::AcceptTransaction(CTxDB& txdb, bool fCheckInputs)
  2093. {
  2094.     if (fClient)
  2095.     {
  2096.         if (!IsInMainChain() && !ClientConnectInputs())
  2097.             return false;
  2098.         return CTransaction::AcceptTransaction(txdb, false);
  2099.     }
  2100.     else
  2101.     {
  2102.         return CTransaction::AcceptTransaction(txdb, fCheckInputs);
  2103.     }
  2104. }
  2105. bool CWalletTx::AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs)
  2106. {
  2107.     CRITICAL_BLOCK(cs_mapTransactions)
  2108.     {
  2109.         foreach(CMerkleTx& tx, vtxPrev)
  2110.         {
  2111.             if (!tx.IsCoinBase())
  2112.             {
  2113.                 uint256 hash = tx.GetHash();
  2114.                 if (!mapTransactions.count(hash) && !txdb.ContainsTx(hash))
  2115.                     tx.AcceptTransaction(txdb, fCheckInputs);
  2116.             }
  2117.         }
  2118.         if (!IsCoinBase())
  2119.             return AcceptTransaction(txdb, fCheckInputs);
  2120.     }
  2121.     return true;
  2122. }
  2123. void ReacceptWalletTransactions()
  2124. {
  2125.     CTxDB txdb("r");
  2126.     CRITICAL_BLOCK(cs_mapWallet)
  2127.     {
  2128.         foreach(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
  2129.         {
  2130.             CWalletTx& wtx = item.second;
  2131.             if (!wtx.IsCoinBase() && !txdb.ContainsTx(wtx.GetHash()))
  2132.                 wtx.AcceptWalletTransaction(txdb, false);
  2133.         }
  2134.     }
  2135. }
  2136. void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
  2137. {
  2138.     foreach(const CMerkleTx& tx, vtxPrev)
  2139.     {
  2140.         if (!tx.IsCoinBase())
  2141.         {
  2142.             uint256 hash = tx.GetHash();
  2143.             if (!txdb.ContainsTx(hash))
  2144.                 RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
  2145.         }
  2146.     }
  2147.     if (!IsCoinBase())
  2148.     {
  2149.         uint256 hash = GetHash();
  2150.         if (!txdb.ContainsTx(hash))
  2151.         {
  2152.             printf("Relaying wtx %s\n", hash.ToString().substr(0,6).c_str());
  2153.             RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
  2154.         }
  2155.     }
  2156. }
  2157. void RelayWalletTransactions()
  2158. {
  2159.     static int64 nLastTime;
  2160.     if (GetTime() - nLastTime < 10 * 60)
  2161.         return;
  2162.     nLastTime = GetTime();
  2163.     printf("RelayWalletTransactions()\n");
  2164.     CTxDB txdb("r");
  2165.     CRITICAL_BLOCK(cs_mapWallet)
  2166.     {
  2167.         multimap<unsigned int, CWalletTx*> mapSorted;
  2168.         foreach(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
  2169.         {
  2170.             CWalletTx& wtx = item.second;
  2171.             mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
  2172.         }
  2173.         foreach(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
  2174.         {
  2175.             CWalletTx& wtx = *item.second;
  2176.             wtx.RelayWalletTransaction(txdb);
  2177.         }
  2178.     }
  2179. }
  2180. bool CBlock::ReadFromDisk(const CBlockIndex* pblockindex, bool fReadTransactions)
  2181. {
  2182.     return ReadFromDisk(pblockindex->nFile, pblockindex->nBlockPos, fReadTransactions);
  2183. }
  2184. uint256 GetOrphanRoot(const CBlock* pblock)
  2185. {
  2186.     while (mapOrphanBlocks.count(pblock->hashPrevBlock))
  2187.         pblock = mapOrphanBlocks[pblock->hashPrevBlock];
  2188.     return pblock->GetHash();
  2189. }
  2190. int64 CBlock::GetBlockValue(int64 nFees) const
  2191. {
  2192.     int64 nSubsidy = 50 * COIN;
  2193.     nSubsidy >>= (nBestHeight / 210000);
  2194.     return nSubsidy + nFees;
  2195. }
  2196. unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast)
  2197. {
  2198.     const unsigned int nTargetTimespan = 14 * 24 * 60 * 60;
  2199.     const unsigned int nTargetSpacing = 10 * 60;
  2200.     const unsigned int nInterval = nTargetTimespan / nTargetSpacing;
  2201.     if (pindexLast == NULL)
  2202.         return bnProofOfWorkLimit.GetCompact();
  2203.     if ((pindexLast->nHeight+1) % nInterval != 0)
  2204.         return pindexLast->nBits;
  2205.     const CBlockIndex* pindexFirst = pindexLast;
  2206.     for (int i = 0; pindexFirst && i < nInterval-1; i++)
  2207.         pindexFirst = pindexFirst->pprev;
  2208.     assert(pindexFirst);
  2209.     unsigned int nActualTimespan = pindexLast->nTime - pindexFirst->nTime;
  2210.     printf("  nActualTimespan = %d  before bounds\n", nActualTimespan);
  2211.     if (nActualTimespan < nTargetTimespan/4)
  2212.         nActualTimespan = nTargetTimespan/4;
  2213.     if (nActualTimespan > nTargetTimespan*4)
  2214.         nActualTimespan = nTargetTimespan*4;
  2215.     CBigNum bnNew;
  2216.     bnNew.SetCompact(pindexLast->nBits);
  2217.     bnNew *= nActualTimespan;
  2218.     bnNew /= nTargetTimespan;
  2219.     if (bnNew > bnProofOfWorkLimit)
  2220.         bnNew = bnProofOfWorkLimit;
  2221.     printf("\n\n\nGetNextWorkRequired RETARGET *****\n");
  2222.     printf("nTargetTimespan = %d    nActualTimespan = %d\n", nTargetTimespan, nActualTimespan);
  2223.     printf("Before: %08x  %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
  2224.     printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());
  2225.     return bnNew.GetCompact();
  2226. }
  2227. bool CTransaction::DisconnectInputs(CTxDB& txdb)
  2228. {
  2229.     if (!IsCoinBase())
  2230.     {
  2231.         foreach(const CTxIn& txin, vin)
  2232.         {
  2233.             COutPoint prevout = txin.prevout;
  2234.             CTxIndex txindex;
  2235.             if (!txdb.ReadTxIndex(prevout.hash, txindex))
  2236.                 return error("DisconnectInputs() : ReadTxIndex failed");
  2237.             if (prevout.n >= txindex.vSpent.size())
  2238.                 return error("DisconnectInputs() : prevout.n out of range");
  2239.             txindex.vSpent[prevout.n].SetNull();
  2240.             txdb.UpdateTxIndex(prevout.hash, txindex);
  2241.         }
  2242.     }
  2243.     if (!txdb.EraseTxIndex(*this))
  2244.         return error("DisconnectInputs() : EraseTxPos failed");
  2245.     return true;
  2246. }
  2247. bool CTransaction::ConnectInputs(CTxDB& txdb, map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx, int nHeight, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee)
  2248. {
  2249.     if (!IsCoinBase())
  2250.     {
  2251.         int64 nValueIn = 0;
  2252.         for (int i = 0; i < vin.size(); i++)
  2253.         {
  2254.             COutPoint prevout = vin[i].prevout;
  2255.             CTxIndex txindex;
  2256.             bool fFound = true;
  2257.             if (fMiner && mapTestPool.count(prevout.hash))
  2258.             {
  2259.                 txindex = mapTestPool[prevout.hash];
  2260.             }
  2261.             else
  2262.             {
  2263.                 fFound = txdb.ReadTxIndex(prevout.hash, txindex);
  2264.             }
  2265.             if (!fFound && (fBlock || fMiner))
  2266.                 return fMiner ? false : error("ConnectInputs() : %s prev tx %s index entry not found", GetHash().ToString().substr(0,6).c_str(),  prevout.hash.ToString().substr(0,6).c_str());
  2267.             CTransaction txPrev;
  2268.             if (!fFound || txindex.pos == CDiskTxPos(1,1,1))
  2269.             {
  2270.                 CRITICAL_BLOCK(cs_mapTransactions)
  2271.                 {
  2272.                     if (!mapTransactions.count(prevout.hash))
  2273.                         return error("ConnectInputs() : %s mapTransactions prev not found %s", GetHash().ToString().substr(0,6).c_str(),  prevout.hash.ToString().substr(0,6).c_str());
  2274.                     txPrev = mapTransactions[prevout.hash];
  2275.                 }
  2276.                 if (!fFound)
  2277.                     txindex.vSpent.resize(txPrev.vout.size());
  2278.             }
  2279.             else
  2280.             {
  2281.                 if (!txPrev.ReadFromDisk(txindex.pos))
  2282.                     return error("ConnectInputs() : %s ReadFromDisk prev tx %s failed", GetHash().ToString().substr(0,6).c_str(),  prevout.hash.ToString().substr(0,6).c_str());
  2283.             }
  2284.             if (prevout.n >= txPrev.vout.size() || prevout.n >= txindex.vSpent.size())
  2285.                 return error("ConnectInputs() : %s prevout.n out of range %d %d %d", GetHash().ToString().substr(0,6).c_str(), prevout.n, txPrev.vout.size(), txindex.vSpent.size());
  2286.             if (txPrev.IsCoinBase())
  2287.                 for (CBlockIndex* pindex = pindexBest; pindex && nBestHeight - pindex->nHeight < COINBASE_MATURITY-1; pindex = pindex->pprev)
  2288.                     if (pindex->nBlockPos == txindex.pos.nBlockPos && pindex->nFile == txindex.pos.nFile)
  2289.                         return error("ConnectInputs() : tried to spend coinbase at depth %d", nBestHeight - pindex->nHeight);
  2290.             if (!VerifySignature(txPrev, *this, i))
  2291.                 return error("ConnectInputs() : %s VerifySignature failed", GetHash().ToString().substr(0,6).c_str());
  2292.             if (!txindex.vSpent[prevout.n].IsNull())
  2293.                 return fMiner ? false : error("ConnectInputs() : %s prev tx already used at %s", GetHash().ToString().substr(0,6).c_str(), txindex.vSpent[prevout.n].ToString().c_str());
  2294.             txindex.vSpent[prevout.n] = posThisTx;
  2295.             if (fBlock)
  2296.                 txdb.UpdateTxIndex(prevout.hash, txindex);
  2297.             else if (fMiner)
  2298.                 mapTestPool[prevout.hash] = txindex;
  2299.             nValueIn += txPrev.vout[prevout.n].nValue;
  2300.         }
  2301.         int64 nTxFee = nValueIn - GetValueOut();
  2302.         if (nTxFee < 0)
  2303.             return error("ConnectInputs() : %s nTxFee < 0", GetHash().ToString().substr(0,6).c_str());
  2304.         if (nTxFee < nMinFee)
  2305.             return false;
  2306.         nFees += nTxFee;
  2307.     }
  2308.     if (fBlock)
  2309.     {
  2310.         if (!txdb.AddTxIndex(*this, posThisTx, nHeight))
  2311.             return error("ConnectInputs() : AddTxPos failed");
  2312.     }
  2313.     else if (fMiner)
  2314.     {
  2315.         mapTestPool[GetHash()] = CTxIndex(CDiskTxPos(1,1,1), vout.size());
  2316.     }
  2317.     return true;
  2318. }
  2319. bool CTransaction::ClientConnectInputs()
  2320. {
  2321.     if (IsCoinBase())
  2322.         return false;
  2323.     CRITICAL_BLOCK(cs_mapTransactions)
  2324.     {
  2325.         int64 nValueIn = 0;
  2326.         for (int i = 0; i < vin.size(); i++)
  2327.         {
  2328.             COutPoint prevout = vin[i].prevout;
  2329.             if (!mapTransactions.count(prevout.hash))
  2330.                 return false;
  2331.             CTransaction& txPrev = mapTransactions[prevout.hash];
  2332.             if (prevout.n >= txPrev.vout.size())
  2333.                 return false;
  2334.             if (!VerifySignature(txPrev, *this, i))
  2335.                 return error("ConnectInputs() : VerifySignature failed");
  2336.             nValueIn += txPrev.vout[prevout.n].nValue;
  2337.         }
  2338.         if (GetValueOut() > nValueIn)
  2339.             return false;
  2340.     }
  2341.     return true;
  2342. }
  2343. bool CBlock::DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex)
  2344. {
  2345.     for (int i = vtx.size()-1; i >= 0; i--)
  2346.         if (!vtx[i].DisconnectInputs(txdb))
  2347.             return false;
  2348.     if (pindex->pprev)
  2349.     {
  2350.         CDiskBlockIndex blockindexPrev(pindex->pprev);
  2351.         blockindexPrev.hashNext = 0;
  2352.         txdb.WriteBlockIndex(blockindexPrev);
  2353.     }
  2354.     return true;
  2355. }
  2356. bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
  2357. {
  2358.     unsigned int nTxPos = pindex->nBlockPos + ::GetSerializeSize(CBlock(), SER_DISK) - 1 + GetSizeOfCompactSize(vtx.size());
  2359.     map<uint256, CTxIndex> mapUnused;
  2360.     int64 nFees = 0;
  2361.     foreach(CTransaction& tx, vtx)
  2362.     {
  2363.         CDiskTxPos posThisTx(pindex->nFile, pindex->nBlockPos, nTxPos);
  2364.         nTxPos += ::GetSerializeSize(tx, SER_DISK);
  2365.         if (!tx.ConnectInputs(txdb, mapUnused, posThisTx, pindex->nHeight, nFees, true, false))
  2366.             return false;
  2367.     }
  2368.     if (vtx[0].GetValueOut() > GetBlockValue(nFees))
  2369.         return false;
  2370.     if (pindex->pprev)
  2371.     {
  2372.         CDiskBlockIndex blockindexPrev(pindex->pprev);
  2373.         blockindexPrev.hashNext = pindex->GetBlockHash();
  2374.         txdb.WriteBlockIndex(blockindexPrev);
  2375.     }
  2376.     foreach(CTransaction& tx, vtx)
  2377.         AddToWalletIfMine(tx, this);
  2378.     return true;
  2379. }
  2380. bool Reorganize(CTxDB& txdb, CBlockIndex* pindexNew)
  2381. {
  2382.     printf("*** REORGANIZE ***\n");
  2383.     CBlockIndex* pfork = pindexBest;
  2384.     CBlockIndex* plonger = pindexNew;
  2385.     while (pfork != plonger)
  2386.     {
  2387.         if (!(pfork = pfork->pprev))
  2388.             return error("Reorganize() : pfork->pprev is null");
  2389.         while (plonger->nHeight > pfork->nHeight)
  2390.             if (!(plonger = plonger->pprev))
  2391.                 return error("Reorganize() : plonger->pprev is null");
  2392.     }
  2393.     vector<CBlockIndex*> vDisconnect;
  2394.     for (CBlockIndex* pindex = pindexBest; pindex != pfork; pindex = pindex->pprev)
  2395.         vDisconnect.push_back(pindex);
  2396.     vector<CBlockIndex*> vConnect;
  2397.     for (CBlockIndex* pindex = pindexNew; pindex != pfork; pindex = pindex->pprev)
  2398.         vConnect.push_back(pindex);
  2399.     reverse(vConnect.begin(), vConnect.end());
  2400.     vector<CTransaction> vResurrect;
  2401.     foreach(CBlockIndex* pindex, vDisconnect)
  2402.     {
  2403.         CBlock block;
  2404.         if (!block.ReadFromDisk(pindex->nFile, pindex->nBlockPos, true))
  2405.             return error("Reorganize() : ReadFromDisk for disconnect failed");
  2406.         if (!block.DisconnectBlock(txdb, pindex))
  2407.             return error("Reorganize() : DisconnectBlock failed");
  2408.         foreach(const CTransaction& tx, block.vtx)
  2409.             if (!tx.IsCoinBase())
  2410.                 vResurrect.push_back(tx);
  2411.     }
  2412.     vector<CTransaction> vDelete;
  2413.     for (int i = 0; i < vConnect.size(); i++)
  2414.     {
  2415.         CBlockIndex* pindex = vConnect[i];
  2416.         CBlock block;
  2417.         if (!block.ReadFromDisk(pindex->nFile, pindex->nBlockPos, true))
  2418.             return error("Reorganize() : ReadFromDisk for connect failed");
  2419.         if (!block.ConnectBlock(txdb, pindex))
  2420.         {
  2421.             txdb.TxnAbort();
  2422.             for (int j = i; j < vConnect.size(); j++)
  2423.             {
  2424.                 CBlockIndex* pindex = vConnect[j];
  2425.                 pindex->EraseBlockFromDisk();
  2426.                 txdb.EraseBlockIndex(pindex->GetBlockHash());
  2427.                 mapBlockIndex.erase(pindex->GetBlockHash());
  2428.                 delete pindex;
  2429.             }
  2430.             return error("Reorganize() : ConnectBlock failed");
  2431.         }
  2432.         foreach(const CTransaction& tx, block.vtx)
  2433.             vDelete.push_back(tx);
  2434.     }
  2435.     if (!txdb.WriteHashBestChain(pindexNew->GetBlockHash()))
  2436.         return error("Reorganize() : WriteHashBestChain failed");
  2437.     txdb.TxnCommit();
  2438.     foreach(CBlockIndex* pindex, vDisconnect)
  2439.         if (pindex->pprev)
  2440.             pindex->pprev->pnext = NULL;
  2441.     foreach(CBlockIndex* pindex, vConnect)
  2442.         if (pindex->pprev)
  2443.             pindex->pprev->pnext = pindex;
  2444.     foreach(CTransaction& tx, vResurrect)
  2445.         tx.AcceptTransaction(txdb, false);
  2446.     foreach(CTransaction& tx, vDelete)
  2447.         tx.RemoveFromMemoryPool();
  2448.     return true;
  2449. }
  2450. bool CBlock::AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos)
  2451. {
  2452.     uint256 hash = GetHash();
  2453.     if (mapBlockIndex.count(hash))
  2454.         return error("AddToBlockIndex() : %s already exists", hash.ToString().substr(0,14).c_str());
  2455.     CBlockIndex* pindexNew = new CBlockIndex(nFile, nBlockPos, *this);
  2456.     if (!pindexNew)
  2457.         return error("AddToBlockIndex() : new CBlockIndex failed");
  2458.     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
  2459.     pindexNew->phashBlock = &((*mi).first);
  2460.     map<uint256, CBlockIndex*>::iterator miPrev = mapBlockIndex.find(hashPrevBlock);
  2461.     if (miPrev != mapBlockIndex.end())
  2462.     {
  2463.         pindexNew->pprev = (*miPrev).second;
  2464.         pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
  2465.     }
  2466.     CTxDB txdb;
  2467.     txdb.TxnBegin();
  2468.     txdb.WriteBlockIndex(CDiskBlockIndex(pindexNew));
  2469.     if (pindexNew->nHeight > nBestHeight)
  2470.     {
  2471.         if (pindexGenesisBlock == NULL && hash == hashGenesisBlock)
  2472.         {
  2473.             pindexGenesisBlock = pindexNew;
  2474.             txdb.WriteHashBestChain(hash);
  2475.         }
  2476.         else if (hashPrevBlock == hashBestChain)
  2477.         {
  2478.             if (!ConnectBlock(txdb, pindexNew) || !txdb.WriteHashBestChain(hash))
  2479.             {
  2480.                 txdb.TxnAbort();
  2481.                 pindexNew->EraseBlockFromDisk();
  2482.                 mapBlockIndex.erase(pindexNew->GetBlockHash());
  2483.                 delete pindexNew;
  2484.                 return error("AddToBlockIndex() : ConnectBlock failed");
  2485.             }
  2486.             txdb.TxnCommit();
  2487.             pindexNew->pprev->pnext = pindexNew;
  2488.             foreach(CTransaction& tx, vtx)
  2489.                 tx.RemoveFromMemoryPool();
  2490.         }
  2491.         else
  2492.         {
  2493.             if (!Reorganize(txdb, pindexNew))
  2494.             {
  2495.                 txdb.TxnAbort();
  2496.                 return error("AddToBlockIndex() : Reorganize failed");
  2497.             }
  2498.         }
  2499.         hashBestChain = hash;
  2500.         pindexBest = pindexNew;
  2501.         nBestHeight = pindexBest->nHeight;
  2502.         nTransactionsUpdated++;
  2503.         printf("AddToBlockIndex: new best=%s  height=%d\n", hashBestChain.ToString().substr(0,14).c_str(), nBestHeight);
  2504.     }
  2505.     txdb.TxnCommit();
  2506.     txdb.Close();
  2507.     if (pindexNew == pindexBest)
  2508.         RelayWalletTransactions();
  2509.     MainFrameRepaint();
  2510.     return true;
  2511. }
  2512. bool CBlock::CheckBlock() const
  2513. {
  2514.     if (vtx.empty() || vtx.size() > MAX_SIZE || ::GetSerializeSize(*this, SER_DISK) > MAX_SIZE)
  2515.         return error("CheckBlock() : size limits failed");
  2516.     if (nTime > GetAdjustedTime() + 2 * 60 * 60)
  2517.         return error("CheckBlock() : block timestamp too far in the future");
  2518.     if (vtx.empty() || !vtx[0].IsCoinBase())
  2519.         return error("CheckBlock() : first tx is not coinbase");
  2520.     for (int i = 1; i < vtx.size(); i++)
  2521.         if (vtx[i].IsCoinBase())
  2522.             return error("CheckBlock() : more than one coinbase");
  2523.     foreach(const CTransaction& tx, vtx)
  2524.         if (!tx.CheckTransaction())
  2525.             return error("CheckBlock() : CheckTransaction failed");
  2526.     if (CBigNum().SetCompact(nBits) > bnProofOfWorkLimit)
  2527.         return error("CheckBlock() : nBits below minimum work");
  2528.     if (GetHash() > CBigNum().SetCompact(nBits).getuint256())
  2529.         return error("CheckBlock() : hash doesn't match nBits");
  2530.     if (hashMerkleRoot != BuildMerkleTree())
  2531.         return error("CheckBlock() : hashMerkleRoot mismatch");
  2532.     return true;
  2533. }
  2534. bool CBlock::AcceptBlock()
  2535. {
  2536.     uint256 hash = GetHash();
  2537.     if (mapBlockIndex.count(hash))
  2538.         return error("AcceptBlock() : block already in mapBlockIndex");
  2539.     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashPrevBlock);
  2540.     if (mi == mapBlockIndex.end())
  2541.         return error("AcceptBlock() : prev block not found");
  2542.     CBlockIndex* pindexPrev = (*mi).second;
  2543.     if (nTime <= pindexPrev->GetMedianTimePast())
  2544.         return error("AcceptBlock() : block's timestamp is too early");
  2545.     if (nBits != GetNextWorkRequired(pindexPrev))
  2546.         return error("AcceptBlock() : incorrect proof of work");
  2547.     unsigned int nFile;
  2548.     unsigned int nBlockPos;
  2549.     if (!WriteToDisk(!fClient, nFile, nBlockPos))
  2550.         return error("AcceptBlock() : WriteToDisk failed");
  2551.     if (!AddToBlockIndex(nFile, nBlockPos))
  2552.         return error("AcceptBlock() : AddToBlockIndex failed");
  2553.     if (hashBestChain == hash)
  2554.         RelayInventory(CInv(MSG_BLOCK, hash));
  2555.     return true;
  2556. }
  2557. bool ProcessBlock(CNode* pfrom, CBlock* pblock)
  2558. {
  2559.     uint256 hash = pblock->GetHash();
  2560.     if (mapBlockIndex.count(hash))
  2561.         return error("ProcessBlock() : already have block %d %s", mapBlockIndex[hash]->nHeight, hash.ToString().substr(0,14).c_str());
  2562.     if (mapOrphanBlocks.count(hash))
  2563.         return error("ProcessBlock() : already have block (orphan) %s", hash.ToString().substr(0,14).c_str());
  2564.     if (!pblock->CheckBlock())
  2565.     {
  2566.         delete pblock;
  2567.         return error("ProcessBlock() : CheckBlock FAILED");
  2568.     }
  2569.     if (!mapBlockIndex.count(pblock->hashPrevBlock))
  2570.     {
  2571.         printf("ProcessBlock: ORPHAN BLOCK, prev=%s\n", pblock->hashPrevBlock.ToString().substr(0,14).c_str());
  2572.         mapOrphanBlocks.insert(make_pair(hash, pblock));
  2573.         mapOrphanBlocksByPrev.insert(make_pair(pblock->hashPrevBlock, pblock));
  2574.         if (pfrom)
  2575.             pfrom->PushMessage("getblocks", CBlockLocator(pindexBest), GetOrphanRoot(pblock));
  2576.         return true;
  2577.     }
  2578.     if (!pblock->AcceptBlock())
  2579.     {
  2580.         delete pblock;
  2581.         return error("ProcessBlock() : AcceptBlock FAILED");
  2582.     }
  2583.     delete pblock;
  2584.     vector<uint256> vWorkQueue;
  2585.     vWorkQueue.push_back(hash);
  2586.     for (int i = 0; i < vWorkQueue.size(); i++)
  2587.     {
  2588.         uint256 hashPrev = vWorkQueue[i];
  2589.         for (multimap<uint256, CBlock*>::iterator mi = mapOrphanBlocksByPrev.lower_bound(hashPrev);
  2590.              mi != mapOrphanBlocksByPrev.upper_bound(hashPrev);
  2591.              ++mi)
  2592.         {
  2593.             CBlock* pblockOrphan = (*mi).second;
  2594.             if (pblockOrphan->AcceptBlock())
  2595.                 vWorkQueue.push_back(pblockOrphan->GetHash());
  2596.             mapOrphanBlocks.erase(pblockOrphan->GetHash());
  2597.             delete pblockOrphan;
  2598.         }
  2599.         mapOrphanBlocksByPrev.erase(hashPrev);
  2600.     }
  2601.     printf("ProcessBlock: ACCEPTED\n");
  2602.     return true;
  2603. }
  2604. template<typename Stream>
  2605. bool ScanMessageStart(Stream& s)
  2606. {
  2607.     s.clear(0);
  2608.     short prevmask = s.exceptions(0);
  2609.     const char* p = BEGIN(pchMessageStart);
  2610.     try
  2611.     {
  2612.         loop
  2613.         {
  2614.             char c;
  2615.             s.read(&c, 1);
  2616.             if (s.fail())
  2617.             {
  2618.                 s.clear(0);
  2619.                 s.exceptions(prevmask);
  2620.                 return false;
  2621.             }
  2622.             if (*p != c)
  2623.                 p = BEGIN(pchMessageStart);
  2624.             if (*p == c)
  2625.             {
  2626.                 if (++p == END(pchMessageStart))
  2627.                 {
  2628.                     s.clear(0);
  2629.                     s.exceptions(prevmask);
  2630.                     return true;
  2631.                 }
  2632.             }
  2633.         }
  2634.     }
  2635.     catch (...)
  2636.     {
  2637.         s.clear(0);
  2638.         s.exceptions(prevmask);
  2639.         return false;
  2640.     }
  2641. }
  2642. string GetAppDir()
  2643. {
  2644.     string strDir;
  2645.     if (!strSetDataDir.empty())
  2646.     {
  2647.         strDir = strSetDataDir;
  2648.     }
  2649.     else if (getenv("APPDATA"))
  2650.     {
  2651.         strDir = strprintf("%s\\Bitcoin", getenv("APPDATA"));
  2652.     }
  2653.     else if (getenv("USERPROFILE"))
  2654.     {
  2655.         string strAppData = strprintf("%s\\Application Data", getenv("USERPROFILE"));
  2656.         static bool fMkdirDone;
  2657.         if (!fMkdirDone)
  2658.         {
  2659.             fMkdirDone = true;
  2660.             _mkdir(strAppData.c_str());
  2661.         }
  2662.         strDir = strprintf("%s\\Bitcoin", strAppData.c_str());
  2663.     }
  2664.     else
  2665.     {
  2666.         return ".";
  2667.     }
  2668.     static bool fMkdirDone;
  2669.     if (!fMkdirDone)
  2670.     {
  2671.         fMkdirDone = true;
  2672.         _mkdir(strDir.c_str());
  2673.     }
  2674.     return strDir;
  2675. }
  2676. FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode)
  2677. {
  2678.     if (nFile == -1)
  2679.         return NULL;
  2680.     FILE* file = fopen(strprintf("%s\\blk%04d.dat", GetAppDir().c_str(), nFile).c_str(), pszMode);
  2681.     if (!file)
  2682.         return NULL;
  2683.     if (nBlockPos != 0 && !strchr(pszMode, 'a') && !strchr(pszMode, 'w'))
  2684.     {
  2685.         if (fseek(file, nBlockPos, SEEK_SET) != 0)
  2686.         {
  2687.             fclose(file);
  2688.             return NULL;
  2689.         }
  2690.     }
  2691.     return file;
  2692. }
  2693. static unsigned int nCurrentBlockFile = 1;
  2694. FILE* AppendBlockFile(unsigned int& nFileRet)
  2695. {
  2696.     nFileRet = 0;
  2697.     loop
  2698.     {
  2699.         FILE* file = OpenBlockFile(nCurrentBlockFile, 0, "ab");
  2700.         if (!file)
  2701.             return NULL;
  2702.         if (fseek(file, 0, SEEK_END) != 0)
  2703.             return NULL;
  2704.         if (ftell(file) < 0x7F000000 - MAX_SIZE)
  2705.         {
  2706.             nFileRet = nCurrentBlockFile;
  2707.             return file;
  2708.         }
  2709.         fclose(file);
  2710.         nCurrentBlockFile++;
  2711.     }
  2712. }
  2713. bool LoadBlockIndex(bool fAllowNew)
  2714. {
  2715.     CTxDB txdb("cr");
  2716.     if (!txdb.LoadBlockIndex())
  2717.         return false;
  2718.     txdb.Close();
  2719.     if (mapBlockIndex.empty())
  2720.     {
  2721.         if (!fAllowNew)
  2722.             return false;
  2723.         char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
  2724.         CTransaction txNew;
  2725.         txNew.vin.resize(1);
  2726.         txNew.vout.resize(1);
  2727.         txNew.vin[0].scriptSig     = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((unsigned char*)pszTimestamp, (unsigned char*)pszTimestamp + strlen(pszTimestamp));
  2728.         txNew.vout[0].nValue       = 50 * COIN;
  2729.         txNew.vout[0].scriptPubKey = CScript() << CBigNum("0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704") << OP_CHECKSIG;
  2730.         CBlock block;
  2731.         block.vtx.push_back(txNew);
  2732.         block.hashPrevBlock = 0;
  2733.         block.hashMerkleRoot = block.BuildMerkleTree();
  2734.         block.nVersion = 1;
  2735.         block.nTime    = 1231006505;
  2736.         block.nBits    = 0x1d00ffff;
  2737.         block.nNonce   = 2083236893;
  2738.             printf("%s\n", block.GetHash().ToString().c_str());
  2739.             printf("%s\n", block.hashMerkleRoot.ToString().c_str());
  2740.             printf("%s\n", hashGenesisBlock.ToString().c_str());
  2741.             txNew.vout[0].scriptPubKey.print();
  2742.             block.print();
  2743.             assert(block.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
  2744.         assert(block.GetHash() == hashGenesisBlock);
  2745.         unsigned int nFile;
  2746.         unsigned int nBlockPos;
  2747.         if (!block.WriteToDisk(!fClient, nFile, nBlockPos))
  2748.             return error("LoadBlockIndex() : writing genesis block to disk failed");
  2749.         if (!block.AddToBlockIndex(nFile, nBlockPos))
  2750.             return error("LoadBlockIndex() : genesis block not accepted");
  2751.     }
  2752.     return true;
  2753. }
  2754. void PrintBlockTree()
  2755. {
  2756.     map<CBlockIndex*, vector<CBlockIndex*> > mapNext;
  2757.     for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
  2758.     {
  2759.         CBlockIndex* pindex = (*mi).second;
  2760.         mapNext[pindex->pprev].push_back(pindex);
  2761.     }
  2762.     vector<pair<int, CBlockIndex*> > vStack;
  2763.     vStack.push_back(make_pair(0, pindexGenesisBlock));
  2764.     int nPrevCol = 0;
  2765.     while (!vStack.empty())
  2766.     {
  2767.         int nCol = vStack.back().first;
  2768.         CBlockIndex* pindex = vStack.back().second;
  2769.         vStack.pop_back();
  2770.         if (nCol > nPrevCol)
  2771.         {
  2772.             for (int i = 0; i < nCol-1; i++)
  2773.                 printf("| ");
  2774.             printf("|\\\n");
  2775.         }
  2776.         else if (nCol < nPrevCol)
  2777.         {
  2778.             for (int i = 0; i < nCol; i++)
  2779.                 printf("| ");
  2780.             printf("|\n");
  2781.         }
  2782.         nPrevCol = nCol;
  2783.         for (int i = 0; i < nCol; i++)
  2784.             printf("| ");
  2785.         CBlock block;
  2786.         block.ReadFromDisk(pindex, true);
  2787.         printf("%d (%u,%u) %s  %s  tx %d",
  2788.             pindex->nHeight,
  2789.             pindex->nFile,
  2790.             pindex->nBlockPos,
  2791.             block.GetHash().ToString().substr(0,14).c_str(),
  2792.             DateTimeStr(block.nTime).c_str(),
  2793.             block.vtx.size());
  2794.         CRITICAL_BLOCK(cs_mapWallet)
  2795.         {
  2796.             if (mapWallet.count(block.vtx[0].GetHash()))
  2797.             {
  2798.                 CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
  2799.                 printf("    mine:  %d  %d  %d", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
  2800.             }
  2801.         }
  2802.         printf("\n");
  2803.         vector<CBlockIndex*>& vNext = mapNext[pindex];
  2804.         for (int i = 0; i < vNext.size(); i++)
  2805.         {
  2806.             if (vNext[i]->pnext)
  2807.             {
  2808.                 swap(vNext[0], vNext[i]);
  2809.                 break;
  2810.             }
  2811.         }
  2812.         for (int i = 0; i < vNext.size(); i++)
  2813.             vStack.push_back(make_pair(nCol+i, vNext[i]));
  2814.     }
  2815. }bool AlreadyHave(CTxDB& txdb, const CInv& inv)
  2816. {
  2817.     switch (inv.type)
  2818.     {
  2819.     case MSG_TX:        return mapTransactions.count(inv.hash) || txdb.ContainsTx(inv.hash);
  2820.     case MSG_BLOCK:     return mapBlockIndex.count(inv.hash) || mapOrphanBlocks.count(inv.hash);
  2821.     case MSG_REVIEW:    return true;
  2822.     case MSG_PRODUCT:   return mapProducts.count(inv.hash);
  2823.     }
  2824.     return true;
  2825. }
  2826. bool ProcessMessages(CNode* pfrom)
  2827. {
  2828.     CDataStream& vRecv = pfrom->vRecv;
  2829.     if (vRecv.empty())
  2830.         return true;
  2831.     printf("ProcessMessages(%d bytes)\n", vRecv.size());
  2832.     loop
  2833.     {
  2834.         CDataStream::iterator pstart = search(vRecv.begin(), vRecv.end(), BEGIN(pchMessageStart), END(pchMessageStart));
  2835.         if (vRecv.end() - pstart < sizeof(CMessageHeader))
  2836.         {
  2837.             if (vRecv.size() > sizeof(CMessageHeader))
  2838.             {
  2839.                 printf("\n\nPROCESSMESSAGE MESSAGESTART NOT FOUND\n\n");
  2840.                 vRecv.erase(vRecv.begin(), vRecv.end() - sizeof(CMessageHeader));
  2841.             }
  2842.             break;
  2843.         }
  2844.         if (pstart - vRecv.begin() > 0)
  2845.             printf("\n\nPROCESSMESSAGE SKIPPED %d BYTES\n\n", pstart - vRecv.begin());
  2846.         vRecv.erase(vRecv.begin(), pstart);
  2847.         CMessageHeader hdr;
  2848.         vRecv >> hdr;
  2849.         if (!hdr.IsValid())
  2850.         {
  2851.             printf("\n\nPROCESSMESSAGE: ERRORS IN HEADER %s\n\n\n", hdr.GetCommand().c_str());
  2852.             continue;
  2853.         }
  2854.         string strCommand = hdr.GetCommand();
  2855.         unsigned int nMessageSize = hdr.nMessageSize;
  2856.         if (nMessageSize > vRecv.size())
  2857.         {
  2858.             printf("MESSAGE-BREAK 2\n");
  2859.             vRecv.insert(vRecv.begin(), BEGIN(hdr), END(hdr));
  2860.             Sleep(100);
  2861.             break;
  2862.         }
  2863.         CDataStream vMsg(vRecv.begin(), vRecv.begin() + nMessageSize, vRecv.nType, vRecv.nVersion);
  2864.         vRecv.ignore(nMessageSize);
  2865.         bool fRet = false;
  2866.         try
  2867.         {
  2868.             CheckForShutdown(2);
  2869.             CRITICAL_BLOCK(cs_main)
  2870.                 fRet = ProcessMessage(pfrom, strCommand, vMsg);
  2871.             CheckForShutdown(2);
  2872.         }
  2873.         CATCH_PRINT_EXCEPTION("ProcessMessage()")
  2874.         if (!fRet)
  2875.             printf("ProcessMessage(%s, %d bytes) from %s to %s FAILED\n", strCommand.c_str(), nMessageSize, pfrom->addr.ToString().c_str(), addrLocalHost.ToString().c_str());
  2876.     }
  2877.     vRecv.Compact();
  2878.     return true;
  2879. }
  2880. bool ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
  2881. {
  2882.     static map<unsigned int, vector<unsigned char> > mapReuseKey;
  2883.     printf("received: %-12s (%d bytes)  ", strCommand.c_str(), vRecv.size());
  2884.     for (int i = 0; i < min(vRecv.size(), (unsigned int)25); i++)
  2885.         printf("%02x ", vRecv[i] & 0xff);
  2886.     printf("\n");
  2887.     if (nDropMessagesTest > 0 && GetRand(nDropMessagesTest) == 0)
  2888.     {
  2889.         printf("dropmessages DROPPING RECV MESSAGE\n");
  2890.         return true;
  2891.     }
  2892.     if (strCommand == "version")
  2893.     {
  2894.         if (pfrom->nVersion != 0)
  2895.             return false;
  2896.         int64 nTime;
  2897.         CAddress addrMe;
  2898.         vRecv >> pfrom->nVersion >> pfrom->nServices >> nTime >> addrMe;
  2899.         if (pfrom->nVersion == 0)
  2900.             return false;
  2901.         pfrom->vSend.SetVersion(min(pfrom->nVersion, VERSION));
  2902.         pfrom->vRecv.SetVersion(min(pfrom->nVersion, VERSION));
  2903.         pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
  2904.         if (pfrom->fClient)
  2905.         {
  2906.             pfrom->vSend.nType |= SER_BLOCKHEADERONLY;
  2907.             pfrom->vRecv.nType |= SER_BLOCKHEADERONLY;
  2908.         }
  2909.         AddTimeData(pfrom->addr.ip, nTime);
  2910.         static bool fAskedForBlocks;
  2911.         if (!fAskedForBlocks && !pfrom->fClient)
  2912.         {
  2913.             fAskedForBlocks = true;
  2914.             pfrom->PushMessage("getblocks", CBlockLocator(pindexBest), uint256(0));
  2915.         }
  2916.         printf("version addrMe = %s\n", addrMe.ToString().c_str());
  2917.     }
  2918.     else if (pfrom->nVersion == 0)
  2919.     {
  2920.         return false;
  2921.     }
  2922.     else if (strCommand == "addr")
  2923.     {
  2924.         vector<CAddress> vAddr;
  2925.         vRecv >> vAddr;
  2926.         CAddrDB addrdb;
  2927.         foreach(const CAddress& addr, vAddr)
  2928.         {
  2929.             if (fShutdown)
  2930.                 return true;
  2931.             if (AddAddress(addrdb, addr))
  2932.             {
  2933.                 pfrom->setAddrKnown.insert(addr);
  2934.                 CRITICAL_BLOCK(cs_vNodes)
  2935.                     foreach(CNode* pnode, vNodes)
  2936.                         if (!pnode->setAddrKnown.count(addr))
  2937.                             pnode->vAddrToSend.push_back(addr);
  2938.             }
  2939.         }
  2940.     }
  2941.     else if (strCommand == "inv")
  2942.     {
  2943.         vector<CInv> vInv;
  2944.         vRecv >> vInv;
  2945.         CTxDB txdb("r");
  2946.         foreach(const CInv& inv, vInv)
  2947.         {
  2948.             if (fShutdown)
  2949.                 return true;
  2950.             pfrom->AddInventoryKnown(inv);
  2951.  
  2952.             bool fAlreadyHave = AlreadyHave(txdb, inv);
  2953.             printf("  got inventory: %s  %s\n", inv.ToString().c_str(), fAlreadyHave ? "have" : "new");
  2954.             if (!fAlreadyHave)
  2955.                 pfrom->AskFor(inv);
  2956.             else if (inv.type == MSG_BLOCK && mapOrphanBlocks.count(inv.hash))
  2957.                 pfrom->PushMessage("getblocks", CBlockLocator(pindexBest), GetOrphanRoot(mapOrphanBlocks[inv.hash]));
  2958.         }
  2959.     }
  2960.     else if (strCommand == "getdata")
  2961.     {
  2962.         vector<CInv> vInv;
  2963.         vRecv >> vInv;
  2964.         foreach(const CInv& inv, vInv)
  2965.         {
  2966.             if (fShutdown)
  2967.                 return true;
  2968.             printf("received getdata for: %s\n", inv.ToString().c_str());
  2969.             if (inv.type == MSG_BLOCK)
  2970.             {
  2971.                 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(inv.hash);
  2972.                 if (mi != mapBlockIndex.end())
  2973.                 {
  2974.                     CBlock block;
  2975.                     block.ReadFromDisk((*mi).second, !pfrom->fClient);
  2976.                     pfrom->PushMessage("block", block);
  2977.                 }
  2978.             }
  2979.             else if (inv.IsKnownType())
  2980.             {
  2981.                 CRITICAL_BLOCK(cs_mapRelay)
  2982.                 {
  2983.                     map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
  2984.                     if (mi != mapRelay.end())
  2985.                         pfrom->PushMessage(inv.GetCommand(), (*mi).second);
  2986.                 }
  2987.             }
  2988.         }
  2989.     }
  2990.     else if (strCommand == "getblocks")
  2991.     {
  2992.         CBlockLocator locator;
  2993.         uint256 hashStop;
  2994.         vRecv >> locator >> hashStop;
  2995.         CBlockIndex* pindex = locator.GetBlockIndex();
  2996.         if (pindex)
  2997.             pindex = pindex->pnext;
  2998.         printf("getblocks %d to %s\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,14).c_str());
  2999.         for (; pindex; pindex = pindex->pnext)
  3000.         {
  3001.             if (pindex->GetBlockHash() == hashStop)
  3002.             {
  3003.                 printf("  getblocks stopping at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,14).c_str());
  3004.                 break;
  3005.             }
  3006.             CRITICAL_BLOCK(pfrom->cs_inventory)
  3007.             {
  3008.                 CInv inv(MSG_BLOCK, pindex->GetBlockHash());
  3009.                 if (pfrom->setInventoryKnown2.insert(inv).second)
  3010.                 {
  3011.                     pfrom->setInventoryKnown.erase(inv);
  3012.                     pfrom->vInventoryToSend.push_back(inv);
  3013.                 }
  3014.             }
  3015.         }
  3016.     }
  3017.     else if (strCommand == "tx")
  3018.     {
  3019.         vector<uint256> vWorkQueue;
  3020.         CDataStream vMsg(vRecv);
  3021.         CTransaction tx;
  3022.         vRecv >> tx;
  3023.         CInv inv(MSG_TX, tx.GetHash());
  3024.         pfrom->AddInventoryKnown(inv);
  3025.         bool fMissingInputs = false;
  3026.         if (tx.AcceptTransaction(true, &fMissingInputs))
  3027.         {
  3028.             AddToWalletIfMine(tx, NULL);
  3029.             RelayMessage(inv, vMsg);
  3030.             mapAlreadyAskedFor.erase(inv);
  3031.             vWorkQueue.push_back(inv.hash);
  3032.             for (int i = 0; i < vWorkQueue.size(); i++)
  3033.             {
  3034.                 uint256 hashPrev = vWorkQueue[i];
  3035.                 for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(hashPrev);
  3036.                      mi != mapOrphanTransactionsByPrev.upper_bound(hashPrev);
  3037.                      ++mi)
  3038.                 {
  3039.                     const CDataStream& vMsg = *((*mi).second);
  3040.                     CTransaction tx;
  3041.                     CDataStream(vMsg) >> tx;
  3042.                     CInv inv(MSG_TX, tx.GetHash());
  3043.                     if (tx.AcceptTransaction(true))
  3044.                     {
  3045.                         printf("   accepted orphan tx %s\n", inv.hash.ToString().substr(0,6).c_str());
  3046.                         AddToWalletIfMine(tx, NULL);
  3047.                         RelayMessage(inv, vMsg);
  3048.                         mapAlreadyAskedFor.erase(inv);
  3049.                         vWorkQueue.push_back(inv.hash);
  3050.                     }
  3051.                 }
  3052.             }
  3053.             foreach(uint256 hash, vWorkQueue)
  3054.                 EraseOrphanTx(hash);
  3055.         }
  3056.         else if (fMissingInputs)
  3057.         {
  3058.             printf("storing orphan tx %s\n", inv.hash.ToString().substr(0,6).c_str());
  3059.             AddOrphanTx(vMsg);
  3060.         }
  3061.     }
  3062.     else if (strCommand == "review")
  3063.     {
  3064.         CDataStream vMsg(vRecv);
  3065.         CReview review;
  3066.         vRecv >> review;
  3067.         CInv inv(MSG_REVIEW, review.GetHash());
  3068.         pfrom->AddInventoryKnown(inv);
  3069.         if (review.AcceptReview())
  3070.         {
  3071.             RelayMessage(inv, vMsg);
  3072.             mapAlreadyAskedFor.erase(inv);
  3073.         }
  3074.     }
  3075.     else if (strCommand == "block")
  3076.     {
  3077.         auto_ptr<CBlock> pblock(new CBlock);
  3078.         vRecv >> *pblock;
  3079.         printf("received block:\n"); pblock->print();
  3080.         CInv inv(MSG_BLOCK, pblock->GetHash());
  3081.         pfrom->AddInventoryKnown(inv);
  3082.         if (ProcessBlock(pfrom, pblock.release()))
  3083.             mapAlreadyAskedFor.erase(inv);
  3084.     }
  3085.     else if (strCommand == "getaddr")
  3086.     {
  3087.         pfrom->vAddrToSend.clear();
  3088.         int64 nSince = GetAdjustedTime() - 60 * 60;
  3089.         CRITICAL_BLOCK(cs_mapAddresses)
  3090.         {
  3091.             foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
  3092.             {
  3093.                 if (fShutdown)
  3094.                     return true;
  3095.                 const CAddress& addr = item.second;
  3096.                 if (addr.nTime > nSince)
  3097.                     pfrom->vAddrToSend.push_back(addr);
  3098.             }
  3099.         }
  3100.     }
  3101.     else if (strCommand == "checkorder")
  3102.     {
  3103.         uint256 hashReply;
  3104.         CWalletTx order;
  3105.         vRecv >> hashReply >> order;
  3106.         if (!mapReuseKey.count(pfrom->addr.ip))
  3107.             mapReuseKey[pfrom->addr.ip] = GenerateNewKey();
  3108.         CScript scriptPubKey;
  3109.         scriptPubKey << mapReuseKey[pfrom->addr.ip] << OP_CHECKSIG;
  3110.         pfrom->PushMessage("reply", hashReply, (int)0, scriptPubKey);
  3111.     }
  3112.     else if (strCommand == "submitorder")
  3113.     {
  3114.         uint256 hashReply;
  3115.         CWalletTx wtxNew;
  3116.         vRecv >> hashReply >> wtxNew;
  3117.         if (!wtxNew.AcceptWalletTransaction())
  3118.         {
  3119.             pfrom->PushMessage("reply", hashReply, (int)1);
  3120.             return error("submitorder AcceptWalletTransaction() failed, returning error 1");
  3121.         }
  3122.         wtxNew.fTimeReceivedIsTxTime = true;
  3123.         AddToWallet(wtxNew);
  3124.         wtxNew.RelayWalletTransaction();
  3125.         mapReuseKey.erase(pfrom->addr.ip);
  3126.         pfrom->PushMessage("reply", hashReply, (int)0);
  3127.     }
  3128.     else if (strCommand == "reply")
  3129.     {
  3130.         uint256 hashReply;
  3131.         vRecv >> hashReply;
  3132.         CRequestTracker tracker;
  3133.         CRITICAL_BLOCK(pfrom->cs_mapRequests)
  3134.         {
  3135.             map<uint256, CRequestTracker>::iterator mi = pfrom->mapRequests.find(hashReply);
  3136.             if (mi != pfrom->mapRequests.end())
  3137.             {
  3138.                 tracker = (*mi).second;
  3139.                 pfrom->mapRequests.erase(mi);
  3140.             }
  3141.         }
  3142.         if (!tracker.IsNull())
  3143.             tracker.fn(tracker.param1, vRecv);
  3144.     }
  3145.     else
  3146.     {
  3147.         printf("ProcessMessage(%s) : Ignored unknown message\n", strCommand.c_str());
  3148.     }
  3149.     if (!vRecv.empty())
  3150.         printf("ProcessMessage(%s) : %d extra bytes\n", strCommand.c_str(), vRecv.size());
  3151.     return true;
  3152. }
  3153. bool SendMessages(CNode* pto)
  3154. {
  3155.     CheckForShutdown(2);
  3156.     CRITICAL_BLOCK(cs_main)
  3157.     {
  3158.         if (pto->nVersion == 0)
  3159.             return true;
  3160.         vector<CAddress> vAddrToSend;
  3161.         vAddrToSend.reserve(pto->vAddrToSend.size());
  3162.         foreach(const CAddress& addr, pto->vAddrToSend)
  3163.             if (!pto->setAddrKnown.count(addr))
  3164.                 vAddrToSend.push_back(addr);
  3165.         pto->vAddrToSend.clear();
  3166.         if (!vAddrToSend.empty())
  3167.             pto->PushMessage("addr", vAddrToSend);
  3168.         vector<CInv> vInventoryToSend;
  3169.         CRITICAL_BLOCK(pto->cs_inventory)
  3170.         {
  3171.             vInventoryToSend.reserve(pto->vInventoryToSend.size());
  3172.             foreach(const CInv& inv, pto->vInventoryToSend)
  3173.             {
  3174.                 if (pto->setInventoryKnown.insert(inv).second)
  3175.                     vInventoryToSend.push_back(inv);
  3176.             }
  3177.             pto->vInventoryToSend.clear();
  3178.             pto->setInventoryKnown2.clear();
  3179.         }
  3180.         if (!vInventoryToSend.empty())
  3181.             pto->PushMessage("inv", vInventoryToSend);
  3182.         vector<CInv> vAskFor;
  3183.         int64 nNow = GetTime() * 1000000;
  3184.         CTxDB txdb("r");
  3185.         while (!pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
  3186.         {
  3187.             const CInv& inv = (*pto->mapAskFor.begin()).second;
  3188.             printf("sending getdata: %s\n", inv.ToString().c_str());
  3189.             if (!AlreadyHave(txdb, inv))
  3190.                 vAskFor.push_back(inv);
  3191.             pto->mapAskFor.erase(pto->mapAskFor.begin());
  3192.         }
  3193.         if (!vAskFor.empty())
  3194.             pto->PushMessage("getdata", vAskFor);
  3195.     }
  3196.     return true;
  3197. }
  3198. int FormatHashBlocks(void* pbuffer, unsigned int len)
  3199. {
  3200.     unsigned char* pdata = (unsigned char*)pbuffer;
  3201.     unsigned int blocks = 1 + ((len + 8) / 64);
  3202.     unsigned char* pend = pdata + 64 * blocks;
  3203.     memset(pdata + len, 0, 64 * blocks - len);
  3204.     pdata[len] = 0x80;
  3205.     unsigned int bits = len * 8;
  3206.     pend[-1] = (bits >> 0) & 0xff;
  3207.     pend[-2] = (bits >> 8) & 0xff;
  3208.     pend[-3] = (bits >> 16) & 0xff;
  3209.     pend[-4] = (bits >> 24) & 0xff;
  3210.     return blocks;
  3211. }
  3212. using CryptoPP::ByteReverse;
  3213. static int detectlittleendian = 1;
  3214. void BlockSHA256(const void* pin, unsigned int nBlocks, void* pout)
  3215. {
  3216.     unsigned int* pinput = (unsigned int*)pin;
  3217.     unsigned int* pstate = (unsigned int*)pout;
  3218.     CryptoPP::SHA256::InitState(pstate);
  3219.     if (*(char*)&detectlittleendian != 0)
  3220.     {
  3221.         for (int n = 0; n < nBlocks; n++)
  3222.         {
  3223.             unsigned int pbuf[16];
  3224.             for (int i = 0; i < 16; i++)
  3225.                 pbuf[i] = ByteReverse(pinput[n * 16 + i]);
  3226.             CryptoPP::SHA256::Transform(pstate, pbuf);
  3227.         }
  3228.         for (int i = 0; i < 8; i++)
  3229.             pstate[i] = ByteReverse(pstate[i]);
  3230.     }
  3231.     else
  3232.     {
  3233.         for (int n = 0; n < nBlocks; n++)
  3234.             CryptoPP::SHA256::Transform(pstate, pinput + n * 16);
  3235.     }
  3236. }
  3237. bool BitcoinMiner()
  3238. {    printf("BitcoinMiner started\n");
  3239.     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST);
  3240.     CKey key;
  3241.     key.MakeNewKey();
  3242.     CBigNum bnExtraNonce = 0;
  3243.     while (fGenerateBitcoins)
  3244.     {
  3245.         Sleep(50);
  3246.         CheckForShutdown(3);
  3247.         while (vNodes.empty())
  3248.         {
  3249.             Sleep(1000);
  3250.             CheckForShutdown(3);
  3251.         }
  3252.         unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
  3253.         CBlockIndex* pindexPrev = pindexBest;
  3254.         unsigned int nBits = GetNextWorkRequired(pindexPrev);
  3255.         CTransaction txNew;
  3256.         txNew.vin.resize(1);
  3257.         txNew.vin[0].prevout.SetNull();
  3258.         txNew.vin[0].scriptSig << nBits << ++bnExtraNonce;
  3259.         txNew.vout.resize(1);
  3260.         txNew.vout[0].scriptPubKey << key.GetPubKey() << OP_CHECKSIG;
  3261.         auto_ptr<CBlock> pblock(new CBlock());
  3262.         if (!pblock.get())
  3263.             return false;
  3264.         pblock->vtx.push_back(txNew);
  3265.         int64 nFees = 0;
  3266.         CRITICAL_BLOCK(cs_main)
  3267.         CRITICAL_BLOCK(cs_mapTransactions)
  3268.         {
  3269.             CTxDB txdb("r");
  3270.             map<uint256, CTxIndex> mapTestPool;
  3271.             vector<char> vfAlreadyAdded(mapTransactions.size());
  3272.             bool fFoundSomething = true;
  3273.             unsigned int nBlockSize = 0;
  3274.             while (fFoundSomething && nBlockSize < MAX_SIZE/2)
  3275.             {
  3276.                 fFoundSomething = false;
  3277.                 unsigned int n = 0;
  3278.                 for (map<uint256, CTransaction>::iterator mi = mapTransactions.begin(); mi != mapTransactions.end(); ++mi, ++n)
  3279.                 {
  3280.                     if (vfAlreadyAdded[n])
  3281.                         continue;
  3282.                     CTransaction& tx = (*mi).second;
  3283.                     if (tx.IsCoinBase() || !tx.IsFinal())
  3284.                         continue;
  3285.                     int64 nMinFee = tx.GetMinFee(pblock->vtx.size() < 100);
  3286.  
  3287.                     map<uint256, CTxIndex> mapTestPoolTmp(mapTestPool);
  3288.                     if (!tx.ConnectInputs(txdb, mapTestPoolTmp, CDiskTxPos(1,1,1), 0, nFees, false, true, nMinFee))
  3289.                         continue;
  3290.                     swap(mapTestPool, mapTestPoolTmp);
  3291.  
  3292.                     pblock->vtx.push_back(tx);
  3293.                     nBlockSize += ::GetSerializeSize(tx, SER_NETWORK);
  3294.                     vfAlreadyAdded[n] = true;
  3295.                     fFoundSomething = true;
  3296.                 }
  3297.             }
  3298.         }
  3299.         pblock->nBits = nBits;
  3300.         pblock->vtx[0].vout[0].nValue = pblock->GetBlockValue(nFees);
  3301.         printf("\n\nRunning BitcoinMiner with %d transactions in block\n", pblock->vtx.size());
  3302.         struct unnamed1
  3303.         {
  3304.             struct unnamed2
  3305.             {
  3306.                 int nVersion;
  3307.                 uint256 hashPrevBlock;
  3308.                 uint256 hashMerkleRoot;
  3309.                 unsigned int nTime;
  3310.                 unsigned int nBits;
  3311.                 unsigned int nNonce;
  3312.             }
  3313.             block;
  3314.             unsigned char pchPadding0[64];
  3315.             uint256 hash1;
  3316.             unsigned char pchPadding1[64];
  3317.         }
  3318.         tmp;
  3319.         tmp.block.nVersion       = pblock->nVersion;
  3320.         tmp.block.hashPrevBlock  = pblock->hashPrevBlock  = (pindexPrev ? pindexPrev->GetBlockHash() : 0);
  3321.         tmp.block.hashMerkleRoot = pblock->hashMerkleRoot = pblock->BuildMerkleTree();
  3322.         tmp.block.nTime          = pblock->nTime          = max((pindexPrev ? pindexPrev->GetMedianTimePast()+1 : 0), GetAdjustedTime());
  3323.         tmp.block.nBits          = pblock->nBits          = nBits;
  3324.         tmp.block.nNonce         = pblock->nNonce         = 1;
  3325.         unsigned int nBlocks0 = FormatHashBlocks(&tmp.block, sizeof(tmp.block));
  3326.         unsigned int nBlocks1 = FormatHashBlocks(&tmp.hash1, sizeof(tmp.hash1));
  3327.         unsigned int nStart = GetTime();
  3328.         uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
  3329.         uint256 hash;
  3330.         loop
  3331.         {
  3332.             BlockSHA256(&tmp.block, nBlocks0, &tmp.hash1);
  3333.             BlockSHA256(&tmp.hash1, nBlocks1, &hash);
  3334.             if (hash <= hashTarget)
  3335.             {
  3336.                 pblock->nNonce = tmp.block.nNonce;
  3337.                 assert(hash == pblock->GetHash());
  3338.                     printf("BitcoinMiner:\n");
  3339.                     printf("proof-of-work found  \n  hash: %s  \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str());
  3340.                     pblock->print();
  3341.  
  3342.                 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
  3343.                 CRITICAL_BLOCK(cs_main)
  3344.                 {
  3345.                     if (!AddKey(key))
  3346.                         return false;
  3347.                     key.MakeNewKey();
  3348.                     if (!ProcessBlock(NULL, pblock.release()))
  3349.                         printf("ERROR in BitcoinMiner, ProcessBlock, block not accepted\n");
  3350.                 }
  3351.                 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST);
  3352.                 Sleep(500);
  3353.                 break;
  3354.             }
  3355.             if ((++tmp.block.nNonce & 0x3ffff) == 0)
  3356.             {
  3357.                 CheckForShutdown(3);
  3358.                 if (tmp.block.nNonce == 0)
  3359.                     break;
  3360.                 if (pindexPrev != pindexBest)
  3361.                     break;
  3362.                 if (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60)
  3363.                     break;
  3364.                 if (!fGenerateBitcoins)
  3365.                     break;
  3366.                 tmp.block.nTime = pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
  3367.             }
  3368.         }
  3369.     }
  3370.     return true;
  3371. }
  3372. int64 GetBalance()
  3373. {
  3374.     int64 nStart, nEnd;
  3375.     QueryPerformanceCounter((LARGE_INTEGER*)&nStart);
  3376.     int64 nTotal = 0;
  3377.     CRITICAL_BLOCK(cs_mapWallet)
  3378.     {
  3379.         for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
  3380.         {
  3381.             CWalletTx* pcoin = &(*it).second;
  3382.             if (!pcoin->IsFinal() || pcoin->fSpent)
  3383.                 continue;
  3384.             nTotal += pcoin->GetCredit();
  3385.         }
  3386.     }
  3387.     QueryPerformanceCounter((LARGE_INTEGER*)&nEnd);
  3388.     return nTotal;
  3389. }
  3390. bool SelectCoins(int64 nTargetValue, set<CWalletTx*>& setCoinsRet)
  3391. {
  3392.     setCoinsRet.clear();
  3393.     int64 nLowestLarger = _I64_MAX;
  3394.     CWalletTx* pcoinLowestLarger = NULL;
  3395.     vector<pair<int64, CWalletTx*> > vValue;
  3396.     int64 nTotalLower = 0;
  3397.     CRITICAL_BLOCK(cs_mapWallet)
  3398.     {
  3399.         for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
  3400.         {
  3401.             CWalletTx* pcoin = &(*it).second;
  3402.             if (!pcoin->IsFinal() || pcoin->fSpent)
  3403.                 continue;
  3404.             int64 n = pcoin->GetCredit();
  3405.             if (n <= 0)
  3406.                 continue;
  3407.             if (n < nTargetValue)
  3408.             {
  3409.                 vValue.push_back(make_pair(n, pcoin));
  3410.                 nTotalLower += n;
  3411.             }
  3412.             else if (n == nTargetValue)
  3413.             {
  3414.                 setCoinsRet.insert(pcoin);
  3415.                 return true;
  3416.             }
  3417.             else if (n < nLowestLarger)
  3418.             {
  3419.                 nLowestLarger = n;
  3420.                 pcoinLowestLarger = pcoin;
  3421.             }
  3422.         }
  3423.     }
  3424.     if (nTotalLower < nTargetValue)
  3425.     {
  3426.         if (pcoinLowestLarger == NULL)
  3427.             return false;
  3428.         setCoinsRet.insert(pcoinLowestLarger);
  3429.         return true;
  3430.     }
  3431.     sort(vValue.rbegin(), vValue.rend());
  3432.     vector<char> vfIncluded;
  3433.     vector<char> vfBest(vValue.size(), true);
  3434.     int64 nBest = nTotalLower;
  3435.     for (int nRep = 0; nRep < 1000 && nBest != nTargetValue; nRep++)
  3436.     {
  3437.         vfIncluded.assign(vValue.size(), false);
  3438.         int64 nTotal = 0;
  3439.         bool fReachedTarget = false;
  3440.         for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
  3441.         {
  3442.             for (int i = 0; i < vValue.size(); i++)
  3443.             {
  3444.                 if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
  3445.                 {
  3446.                     nTotal += vValue[i].first;
  3447.                     vfIncluded[i] = true;
  3448.                     if (nTotal >= nTargetValue)
  3449.                     {
  3450.                         fReachedTarget = true;
  3451.                         if (nTotal < nBest)
  3452.                         {
  3453.                             nBest = nTotal;
  3454.                             vfBest = vfIncluded;
  3455.                         }
  3456.                         nTotal -= vValue[i].first;
  3457.                         vfIncluded[i] = false;
  3458.                     }
  3459.                 }
  3460.             }
  3461.         }
  3462.     }
  3463.     if (pcoinLowestLarger && nLowestLarger - nTargetValue <= nBest - nTargetValue)
  3464.         setCoinsRet.insert(pcoinLowestLarger);
  3465.     else
  3466.     {
  3467.         for (int i = 0; i < vValue.size(); i++)
  3468.             if (vfBest[i])
  3469.                 setCoinsRet.insert(vValue[i].second);
  3470.  
  3471.         printf("SelectCoins() best subset: ");
  3472.         for (int i = 0; i < vValue.size(); i++)
  3473.             if (vfBest[i])
  3474.                 printf("%s ", FormatMoney(vValue[i].first).c_str());
  3475.         printf("total %s\n", FormatMoney(nBest).c_str());
  3476.     }
  3477.     return true;
  3478. }
  3479. bool CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, int64& nFeeRequiredRet)
  3480. {
  3481.     nFeeRequiredRet = 0;
  3482.     CRITICAL_BLOCK(cs_main)
  3483.     {
  3484.         CTxDB txdb("r");
  3485.         CRITICAL_BLOCK(cs_mapWallet)
  3486.         {
  3487.             int64 nFee = nTransactionFee;
  3488.             loop
  3489.             {
  3490.                 wtxNew.vin.clear();
  3491.                 wtxNew.vout.clear();
  3492.                 if (nValue < 0)
  3493.                     return false;
  3494.                 int64 nValueOut = nValue;
  3495.                 nValue += nFee;
  3496.  
  3497.                 set<CWalletTx*> setCoins;
  3498.                 if (!SelectCoins(nValue, setCoins))
  3499.                     return false;
  3500.                 int64 nValueIn = 0;
  3501.                 foreach(CWalletTx* pcoin, setCoins)
  3502.                     nValueIn += pcoin->GetCredit();
  3503.                 wtxNew.vout.push_back(CTxOut(nValueOut, scriptPubKey));
  3504.                 if (nValueIn > nValue)
  3505.                 {
  3506.                     vector<unsigned char> vchPubKey;
  3507.                     CTransaction& txFirst = *(*setCoins.begin());
  3508.                     foreach(const CTxOut& txout, txFirst.vout)
  3509.                         if (txout.IsMine())
  3510.                             if (ExtractPubKey(txout.scriptPubKey, true, vchPubKey))
  3511.                                 break;
  3512.                     if (vchPubKey.empty())
  3513.                         return false;
  3514.                     CScript scriptPubKey;
  3515.                     scriptPubKey << vchPubKey << OP_CHECKSIG;
  3516.                     wtxNew.vout.push_back(CTxOut(nValueIn - nValue, scriptPubKey));
  3517.                 }
  3518.                 foreach(CWalletTx* pcoin, setCoins)
  3519.                     for (int nOut = 0; nOut < pcoin->vout.size(); nOut++)
  3520.                         if (pcoin->vout[nOut].IsMine())
  3521.                             wtxNew.vin.push_back(CTxIn(pcoin->GetHash(), nOut));
  3522.                 int nIn = 0;
  3523.                 foreach(CWalletTx* pcoin, setCoins)
  3524.                     for (int nOut = 0; nOut < pcoin->vout.size(); nOut++)
  3525.                         if (pcoin->vout[nOut].IsMine())
  3526.                             SignSignature(*pcoin, wtxNew, nIn++);
  3527.                 if (nFee < wtxNew.GetMinFee(true))
  3528.                 {
  3529.                     nFee = nFeeRequiredRet = wtxNew.GetMinFee(true);
  3530.                     continue;
  3531.                 }
  3532.                 wtxNew.AddSupportingTransactions(txdb);
  3533.                 wtxNew.fTimeReceivedIsTxTime = true;
  3534.                 break;
  3535.             }
  3536.         }
  3537.     }
  3538.     return true;
  3539. }
  3540. bool CommitTransactionSpent(const CWalletTx& wtxNew)
  3541. {
  3542.     CRITICAL_BLOCK(cs_main)
  3543.     CRITICAL_BLOCK(cs_mapWallet)
  3544.     {
  3545.        AddToWallet(wtxNew);
  3546.         set<CWalletTx*> setCoins;
  3547.         foreach(const CTxIn& txin, wtxNew.vin)
  3548.             setCoins.insert(&mapWallet[txin.prevout.hash]);
  3549.         foreach(CWalletTx* pcoin, setCoins)
  3550.         {
  3551.             pcoin->fSpent = true;
  3552.             pcoin->WriteToDisk();
  3553.             vWalletUpdated.push_back(make_pair(pcoin->GetHash(), false));
  3554.         }
  3555.     }
  3556.     MainFrameRepaint();
  3557.     return true;
  3558. }
  3559. bool SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew)
  3560. {
  3561.     CRITICAL_BLOCK(cs_main)
  3562.     {
  3563.         int64 nFeeRequired;
  3564.         if (!CreateTransaction(scriptPubKey, nValue, wtxNew, nFeeRequired))
  3565.         {
  3566.             string strError;
  3567.             if (nValue + nFeeRequired > GetBalance())
  3568.                 strError = strprintf("Error: This is an oversized transaction that requires a transaction fee of %s ", FormatMoney(nFeeRequired).c_str());
  3569.             else
  3570.                 strError = "Error: Transaction creation failed ";
  3571.             wxMessageBox(strError, "Sending...");
  3572.             return error("SendMoney() : %s\n", strError.c_str());
  3573.         }
  3574.         if (!CommitTransactionSpent(wtxNew))
  3575.         {
  3576.             wxMessageBox("Error finalizing transaction", "Sending...");
  3577.             return error("SendMoney() : Error finalizing transaction");
  3578.         }
  3579.         printf("SendMoney: %s\n", wtxNew.GetHash().ToString().substr(0,6).c_str());
  3580.         if (!wtxNew.AcceptTransaction())
  3581.         {
  3582.             throw runtime_error("SendMoney() : wtxNew.AcceptTransaction() failed\n");
  3583.             wxMessageBox("Error: Transaction not valid", "Sending...");
  3584.             return error("SendMoney() : Error: Transaction not valid");
  3585.         }
  3586.         wtxNew.RelayWalletTransaction();
  3587.     }
  3588.     MainFrameRepaint();
  3589.     return true;
  3590. }
  3591. class COutPoint;
  3592. class CInPoint;
  3593. class CDiskTxPos;
  3594. class CCoinBase;
  3595. class CTxIn;
  3596. class CTxOut;
  3597. class CTransaction;
  3598. class CBlock;
  3599. class CBlockIndex;
  3600. class CWalletTx;
  3601. class CKeyItem;
  3602. static const unsigned int MAX_SIZE = 0x02000000;
  3603. static const int64 COIN = 100000000;
  3604. static const int64 CENT = 1000000;
  3605. static const int COINBASE_MATURITY = 100;
  3606. static const CBigNum bnProofOfWorkLimit(~uint256(0) >> 32);
  3607. extern CCriticalSection cs_main;
  3608. extern map<uint256, CBlockIndex*> mapBlockIndex;
  3609. extern const uint256 hashGenesisBlock;
  3610. extern CBlockIndex* pindexGenesisBlock;
  3611. extern int nBestHeight;
  3612. extern uint256 hashBestChain;
  3613. extern CBlockIndex* pindexBest;
  3614. extern unsigned int nTransactionsUpdated;
  3615. extern string strSetDataDir;
  3616. extern int nDropMessagesTest;
  3617. extern int fGenerateBitcoins;
  3618. extern int64 nTransactionFee;
  3619. extern CAddress addrIncoming;
  3620. string GetAppDir();
  3621. FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
  3622. FILE* AppendBlockFile(unsigned int& nFileRet);
  3623. bool AddKey(const CKey& key);
  3624. vector<unsigned char> GenerateNewKey();
  3625. bool AddToWallet(const CWalletTx& wtxIn);
  3626. void ReacceptWalletTransactions();
  3627. void RelayWalletTransactions();
  3628. bool LoadBlockIndex(bool fAllowNew=true);
  3629. void PrintBlockTree();
  3630. bool BitcoinMiner();
  3631. bool ProcessMessages(CNode* pfrom);
  3632. bool ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv);
  3633. bool SendMessages(CNode* pto);
  3634. int64 GetBalance();
  3635. bool CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& txNew, int64& nFeeRequiredRet);
  3636. bool CommitTransactionSpent(const CWalletTx& wtxNew);
  3637. bool SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew);
  3638. class CDiskTxPos
  3639. {
  3640. public:
  3641.     unsigned int nFile;
  3642.     unsigned int nBlockPos;
  3643.     unsigned int nTxPos;
  3644.     CDiskTxPos()
  3645.     {
  3646.         SetNull();
  3647.     }
  3648.     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
  3649.     {
  3650.         nFile = nFileIn;
  3651.         nBlockPos = nBlockPosIn;
  3652.         nTxPos = nTxPosIn;
  3653.     }
  3654.     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
  3655.     void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
  3656.     bool IsNull() const { return (nFile == -1); }
  3657.     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
  3658.     {
  3659.         return (a.nFile     == b.nFile &&
  3660.                 a.nBlockPos == b.nBlockPos &&
  3661.                 a.nTxPos    == b.nTxPos);
  3662.     }
  3663.     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
  3664.     {
  3665.         return !(a == b);
  3666.     }
  3667.     string ToString() const
  3668.     {
  3669.         if (IsNull())
  3670.             return strprintf("null");
  3671.         else
  3672.             return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
  3673.     }
  3674.     void print() const
  3675.     {
  3676.         printf("%s", ToString().c_str());
  3677.     }
  3678. };
  3679. class CInPoint
  3680. {
  3681. public:
  3682.     CTransaction* ptx;
  3683.     unsigned int n;
  3684.     CInPoint() { SetNull(); }
  3685.     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
  3686.     void SetNull() { ptx = NULL; n = -1; }
  3687.     bool IsNull() const { return (ptx == NULL && n == -1); }
  3688. };
  3689. class COutPoint
  3690. {
  3691. public:
  3692.     uint256 hash;
  3693.     unsigned int n;
  3694.     COutPoint() { SetNull(); }
  3695.     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
  3696.     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
  3697.     void SetNull() { hash = 0; n = -1; }
  3698.     bool IsNull() const { return (hash == 0 && n == -1); }
  3699.     friend bool operator<(const COutPoint& a, const COutPoint& b)
  3700.     {
  3701.         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
  3702.     }
  3703.     friend bool operator==(const COutPoint& a, const COutPoint& b)
  3704.     {
  3705.         return (a.hash == b.hash && a.n == b.n);
  3706.     }
  3707.     friend bool operator!=(const COutPoint& a, const COutPoint& b)
  3708.     {
  3709.         return !(a == b);
  3710.     }
  3711.     string ToString() const
  3712.     {
  3713.         return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,6).c_str(), n);
  3714.     }
  3715.     void print() const
  3716.     {
  3717.         printf("%s\n", ToString().c_str());
  3718.     }
  3719. };
  3720. class CTxIn
  3721. {
  3722. public:
  3723.     COutPoint prevout;
  3724.     CScript scriptSig;
  3725.     unsigned int nSequence;
  3726.     CTxIn()
  3727.     {
  3728.         nSequence = UINT_MAX;
  3729.     }
  3730.     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
  3731.     {
  3732.         prevout = prevoutIn;
  3733.         scriptSig = scriptSigIn;
  3734.         nSequence = nSequenceIn;
  3735.     }
  3736.     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
  3737.     {
  3738.         prevout = COutPoint(hashPrevTx, nOut);
  3739.         scriptSig = scriptSigIn;
  3740.         nSequence = nSequenceIn;
  3741.     }
  3742.     IMPLEMENT_SERIALIZE
  3743.     (
  3744.         READWRITE(prevout);
  3745.         READWRITE(scriptSig);
  3746.         READWRITE(nSequence);
  3747.     )
  3748.     bool IsFinal() const
  3749.     {
  3750.         return (nSequence == UINT_MAX);
  3751.     }
  3752.     friend bool operator==(const CTxIn& a, const CTxIn& b)
  3753.     {
  3754.         return (a.prevout   == b.prevout &&
  3755.                 a.scriptSig == b.scriptSig &&
  3756.                 a.nSequence == b.nSequence);
  3757.     }
  3758.     friend bool operator!=(const CTxIn& a, const CTxIn& b)
  3759.     {
  3760.         return !(a == b);
  3761.     }
  3762.     string ToString() const
  3763.     {
  3764.         string str;
  3765.         str += strprintf("CTxIn(");
  3766.         str += prevout.ToString();
  3767.         if (prevout.IsNull())
  3768.             str += strprintf(", coinbase %s", HexStr(scriptSig.begin(), scriptSig.end(), false).c_str());
  3769.         else
  3770.             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
  3771.         if (nSequence != UINT_MAX)
  3772.             str += strprintf(", nSequence=%u", nSequence);
  3773.         str += ")";
  3774.         return str;
  3775.     }
  3776.     void print() const
  3777.     {
  3778.         printf("%s\n", ToString().c_str());
  3779.     }
  3780.     bool IsMine() const;
  3781.     int64 GetDebit() const;
  3782. };
  3783. class CTxOut
  3784. {
  3785. public:
  3786.     int64 nValue;
  3787.     CScript scriptPubKey;
  3788. public:
  3789.     CTxOut()
  3790.     {
  3791.         SetNull();
  3792.     }
  3793.     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
  3794.     {
  3795.         nValue = nValueIn;
  3796.         scriptPubKey = scriptPubKeyIn;
  3797.     }
  3798.     IMPLEMENT_SERIALIZE
  3799.     (
  3800.         READWRITE(nValue);
  3801.         READWRITE(scriptPubKey);
  3802.     )
  3803.     void SetNull()
  3804.     {
  3805.         nValue = -1;
  3806.         scriptPubKey.clear();
  3807.     }
  3808.     bool IsNull()
  3809.     {
  3810.         return (nValue == -1);
  3811.     }
  3812.     uint256 GetHash() const
  3813.     {
  3814.         return SerializeHash(*this);
  3815.     }
  3816.     bool IsMine() const
  3817.     {
  3818.         return ::IsMine(scriptPubKey);
  3819.     }
  3820.     int64 GetCredit() const
  3821.     {
  3822.         if (IsMine())
  3823.             return nValue;
  3824.         return 0;
  3825.     }
  3826.     friend bool operator==(const CTxOut& a, const CTxOut& b)
  3827.     {
  3828.         return (a.nValue       == b.nValue &&
  3829.                 a.scriptPubKey == b.scriptPubKey);
  3830.     }
  3831.     friend bool operator!=(const CTxOut& a, const CTxOut& b)
  3832.     {
  3833.         return !(a == b);
  3834.     }
  3835.     string ToString() const
  3836.     {
  3837.         if (scriptPubKey.size() < 6)
  3838.             return "CTxOut(error)";
  3839.         return strprintf("CTxOut(nValue=%I64d.%08I64d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,24).c_str());
  3840.     }
  3841.     void print() const
  3842.     {
  3843.         printf("%s\n", ToString().c_str());
  3844.     }
  3845. };
  3846. class CTransaction
  3847. {
  3848. public:
  3849.     int nVersion;
  3850.     vector<CTxIn> vin;
  3851.     vector<CTxOut> vout;
  3852.     int nLockTime;
  3853.     CTransaction()
  3854.     {
  3855.         SetNull();
  3856.     }
  3857.     IMPLEMENT_SERIALIZE
  3858.     (
  3859.         READWRITE(this->nVersion);
  3860.         nVersion = this->nVersion;
  3861.         READWRITE(vin);
  3862.         READWRITE(vout);
  3863.         READWRITE(nLockTime);
  3864.     )
  3865.     void SetNull()
  3866.     {
  3867.         nVersion = 1;
  3868.         vin.clear();
  3869.         vout.clear();
  3870.         nLockTime = 0;
  3871.     }
  3872.     bool IsNull() const
  3873.     {
  3874.         return (vin.empty() && vout.empty());
  3875.     }
  3876.     uint256 GetHash() const
  3877.     {
  3878.         return SerializeHash(*this);
  3879.     }
  3880.     bool IsFinal() const
  3881.     {
  3882.         if (nLockTime == 0 || nLockTime < nBestHeight)
  3883.             return true;
  3884.         foreach(const CTxIn& txin, vin)
  3885.             if (!txin.IsFinal())
  3886.                 return false;
  3887.         return true;
  3888.     }
  3889.     bool IsNewerThan(const CTransaction& old) const
  3890.     {
  3891.         if (vin.size() != old.vin.size())
  3892.             return false;
  3893.         for (int i = 0; i < vin.size(); i++)
  3894.             if (vin[i].prevout != old.vin[i].prevout)
  3895.                 return false;
  3896.         bool fNewer = false;
  3897.         unsigned int nLowest = UINT_MAX;
  3898.         for (int i = 0; i < vin.size(); i++)
  3899.         {
  3900.             if (vin[i].nSequence != old.vin[i].nSequence)
  3901.             {
  3902.                 if (vin[i].nSequence <= nLowest)
  3903.                 {
  3904.                     fNewer = false;
  3905.                     nLowest = vin[i].nSequence;
  3906.                 }
  3907.                 if (old.vin[i].nSequence < nLowest)
  3908.                 {
  3909.                     fNewer = true;
  3910.                     nLowest = old.vin[i].nSequence;
  3911.                 }
  3912.             }
  3913.         }
  3914.         return fNewer;
  3915.     }
  3916.     bool IsCoinBase() const
  3917.     {
  3918.         return (vin.size() == 1 && vin[0].prevout.IsNull());
  3919.     }
  3920.     bool CheckTransaction() const
  3921.     {
  3922.         if (vin.empty() || vout.empty())
  3923.             return error("CTransaction::CheckTransaction() : vin or vout empty");
  3924.         foreach(const CTxOut& txout, vout)
  3925.             if (txout.nValue < 0)
  3926.                 return error("CTransaction::CheckTransaction() : txout.nValue negative");
  3927.         if (IsCoinBase())
  3928.         {
  3929.             if (vin[0].scriptSig.size() < 2 || vin[0].scriptSig.size() > 100)
  3930.                 return error("CTransaction::CheckTransaction() : coinbase script size");
  3931.         }
  3932.         else
  3933.         {
  3934.             foreach(const CTxIn& txin, vin)
  3935.                 if (txin.prevout.IsNull())
  3936.                     return error("CTransaction::CheckTransaction() : prevout is null");
  3937.         }
  3938.         return true;
  3939.     }
  3940.     bool IsMine() const
  3941.     {
  3942.         foreach(const CTxOut& txout, vout)
  3943.             if (txout.IsMine())
  3944.                 return true;
  3945.         return false;
  3946.     }
  3947.     int64 GetDebit() const
  3948.     {
  3949.         int64 nDebit = 0;
  3950.         foreach(const CTxIn& txin, vin)
  3951.             nDebit += txin.GetDebit();
  3952.         return nDebit;
  3953.     }
  3954.     int64 GetCredit() const
  3955.     {
  3956.         int64 nCredit = 0;
  3957.         foreach(const CTxOut& txout, vout)
  3958.             nCredit += txout.GetCredit();
  3959.         return nCredit;
  3960.     }
  3961.     int64 GetValueOut() const
  3962.     {
  3963.         int64 nValueOut = 0;
  3964.         foreach(const CTxOut& txout, vout)
  3965.         {
  3966.             if (txout.nValue < 0)
  3967.                 throw runtime_error("CTransaction::GetValueOut() : negative value");
  3968.             nValueOut += txout.nValue;
  3969.         }
  3970.         return nValueOut;
  3971.     }
  3972.     int64 GetMinFee(bool fDiscount=false) const
  3973.     {
  3974.         unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
  3975.         if (fDiscount && nBytes < 10000)
  3976.             return 0;
  3977.         return (1 + (int64)nBytes / 1000) * CENT;
  3978.     }
  3979.     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
  3980.     {
  3981.         CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
  3982.         if (!filein)
  3983.             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
  3984.         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
  3985.             return error("CTransaction::ReadFromDisk() : fseek failed");
  3986.         filein >> *this;
  3987.         if (pfileRet)
  3988.         {
  3989.             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
  3990.                 return error("CTransaction::ReadFromDisk() : second fseek failed");
  3991.             *pfileRet = filein.release();
  3992.         }
  3993.         return true;
  3994.     }
  3995.     friend bool operator==(const CTransaction& a, const CTransaction& b)
  3996.     {
  3997.         return (a.nVersion  == b.nVersion &&
  3998.                 a.vin       == b.vin &&
  3999.                 a.vout      == b.vout &&
  4000.                 a.nLockTime == b.nLockTime);
  4001.     }
  4002.     friend bool operator!=(const CTransaction& a, const CTransaction& b)
  4003.     {
  4004.         return !(a == b);
  4005.     }
  4006.     string ToString() const
  4007.     {
  4008.         string str;
  4009.         str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
  4010.             GetHash().ToString().substr(0,6).c_str(),
  4011.             nVersion,
  4012.             vin.size(),
  4013.             vout.size(),
  4014.             nLockTime);
  4015.         for (int i = 0; i < vin.size(); i++)
  4016.             str += "    " + vin[i].ToString() + "\n";
  4017.         for (int i = 0; i < vout.size(); i++)
  4018.             str += "    " + vout[i].ToString() + "\n";
  4019.         return str;
  4020.     }
  4021.     void print() const
  4022.     {
  4023.         printf("%s", ToString().c_str());
  4024.     }
  4025.     bool DisconnectInputs(CTxDB& txdb);
  4026.     bool ConnectInputs(CTxDB& txdb, map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx, int nHeight, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee=0);
  4027.     bool ClientConnectInputs();
  4028.     bool AcceptTransaction(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
  4029.     bool AcceptTransaction(bool fCheckInputs=true, bool* pfMissingInputs=NULL)
  4030.     {
  4031.         CTxDB txdb("r");
  4032.         return AcceptTransaction(txdb, fCheckInputs, pfMissingInputs);
  4033.     }
  4034. protected:
  4035.     bool AddToMemoryPool();
  4036. public:
  4037.     bool RemoveFromMemoryPool();
  4038. };
  4039. class CMerkleTx : public CTransaction
  4040. {
  4041. public:
  4042.     uint256 hashBlock;
  4043.     vector<uint256> vMerkleBranch;
  4044.     int nIndex;
  4045.     mutable bool fMerkleVerified;
  4046.     CMerkleTx()
  4047.     {
  4048.         Init();
  4049.     }
  4050.     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
  4051.     {
  4052.         Init();
  4053.     }
  4054.     void Init()
  4055.     {
  4056.         hashBlock = 0;
  4057.         nIndex = -1;
  4058.         fMerkleVerified = false;
  4059.     }
  4060.     int64 GetCredit() const
  4061.     {
  4062.         if (IsCoinBase() && GetBlocksToMaturity() > 0)
  4063.             return 0;
  4064.         return CTransaction::GetCredit();
  4065.     }
  4066.     IMPLEMENT_SERIALIZE
  4067.     (
  4068.         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
  4069.         nVersion = this->nVersion;
  4070.         READWRITE(hashBlock);
  4071.         READWRITE(vMerkleBranch);
  4072.         READWRITE(nIndex);
  4073.     )
  4074.     int SetMerkleBranch(const CBlock* pblock=NULL);
  4075.     int GetDepthInMainChain() const;
  4076.     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
  4077.     int GetBlocksToMaturity() const;
  4078.     bool AcceptTransaction(CTxDB& txdb, bool fCheckInputs=true);
  4079.     bool AcceptTransaction() { CTxDB txdb("r"); return AcceptTransaction(txdb); }
  4080. };
  4081. class CWalletTx : public CMerkleTx
  4082. {
  4083. public:
  4084.     vector<CMerkleTx> vtxPrev;
  4085.     map<string, string> mapValue;
  4086.     vector<pair<string, string> > vOrderForm;
  4087.     unsigned int fTimeReceivedIsTxTime;
  4088.     unsigned int nTimeReceived;
  4089.     char fFromMe;
  4090.     char fSpent;
  4091.     mutable unsigned int nTimeDisplayed;
  4092.     CWalletTx()
  4093.     {
  4094.         Init();
  4095.     }
  4096.     CWalletTx(const CMerkleTx& txIn) : CMerkleTx(txIn)
  4097.     {
  4098.         Init();
  4099.     }
  4100.     CWalletTx(const CTransaction& txIn) : CMerkleTx(txIn)
  4101.     {
  4102.         Init();
  4103.     }
  4104.     void Init()
  4105.     {
  4106.         fTimeReceivedIsTxTime = false;
  4107.         nTimeReceived = 0;
  4108.         fFromMe = false;
  4109.         fSpent = false;
  4110.         nTimeDisplayed = 0;
  4111.     }
  4112.     IMPLEMENT_SERIALIZE
  4113.     (
  4114.         nSerSize += SerReadWrite(s, *(CMerkleTx*)this, nType, nVersion, ser_action);
  4115.         nVersion = this->nVersion;
  4116.         READWRITE(vtxPrev);
  4117.         READWRITE(mapValue);
  4118.         READWRITE(vOrderForm);
  4119.         READWRITE(fTimeReceivedIsTxTime);
  4120.         READWRITE(nTimeReceived);
  4121.         READWRITE(fFromMe);
  4122.         READWRITE(fSpent);
  4123.     )
  4124.     bool WriteToDisk()
  4125.     {
  4126.         return CWalletDB().WriteTx(GetHash(), *this);
  4127.     }
  4128.     int64 GetTxTime() const;
  4129.     void AddSupportingTransactions(CTxDB& txdb);
  4130.     bool AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs=true);
  4131.     bool AcceptWalletTransaction() { CTxDB txdb("r"); return AcceptWalletTransaction(txdb); }
  4132.     void RelayWalletTransaction(CTxDB& txdb);
  4133.     void RelayWalletTransaction() { CTxDB txdb("r"); RelayWalletTransaction(txdb); }
  4134. };
  4135. class CTxIndex
  4136. {
  4137. public:
  4138.     CDiskTxPos pos;
  4139.     vector<CDiskTxPos> vSpent;
  4140.     CTxIndex()
  4141.     {
  4142.         SetNull();
  4143.     }
  4144.     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
  4145.     {
  4146.         pos = posIn;
  4147.         vSpent.resize(nOutputs);
  4148.     }
  4149.     IMPLEMENT_SERIALIZE
  4150.     (
  4151.         if (!(nType & SER_GETHASH))
  4152.         READWRITE(nVersion);
  4153.         READWRITE(pos);
  4154.         READWRITE(vSpent);
  4155.     )
  4156.     void SetNull()
  4157.     {
  4158.         pos.SetNull();
  4159.         vSpent.clear();
  4160.     }
  4161.     bool IsNull()
  4162.     {
  4163.         return pos.IsNull();
  4164.     }
  4165.     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
  4166.     {
  4167.         if (a.pos != b.pos || a.vSpent.size() != b.vSpent.size())
  4168.             return false;
  4169.         for (int i = 0; i < a.vSpent.size(); i++)
  4170.             if (a.vSpent[i] != b.vSpent[i])
  4171.                 return false;
  4172.         return true;
  4173.     }
  4174.     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
  4175.     {
  4176.         return !(a == b);
  4177.     }
  4178. };
  4179. class CBlock
  4180. {
  4181. public:
  4182.     int nVersion;
  4183.     uint256 hashPrevBlock;
  4184.     uint256 hashMerkleRoot;
  4185.     unsigned int nTime;
  4186.     unsigned int nBits;
  4187.     unsigned int nNonce;
  4188.     vector<CTransaction> vtx;
  4189.     mutable vector<uint256> vMerkleTree;
  4190.     CBlock()
  4191.     {
  4192.         SetNull();
  4193.     }
  4194.     IMPLEMENT_SERIALIZE
  4195.     (
  4196.         READWRITE(this->nVersion);
  4197.         nVersion = this->nVersion;
  4198.         READWRITE(hashPrevBlock);
  4199.         READWRITE(hashMerkleRoot);
  4200.         READWRITE(nTime);
  4201.         READWRITE(nBits);
  4202.         READWRITE(nNonce);
  4203.         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
  4204.             READWRITE(vtx);
  4205.         else if (fRead)
  4206.             const_cast<CBlock*>(this)->vtx.clear();
  4207.     )
  4208.     void SetNull()
  4209.     {
  4210.         nVersion = 1;
  4211.         hashPrevBlock = 0;
  4212.         hashMerkleRoot = 0;
  4213.         nTime = 0;
  4214.         nBits = 0;
  4215.         nNonce = 0;
  4216.         vtx.clear();
  4217.         vMerkleTree.clear();
  4218.     }
  4219.     bool IsNull() const
  4220.     {
  4221.         return (nBits == 0);
  4222.     }
  4223.     uint256 GetHash() const
  4224.     {
  4225.         return Hash(BEGIN(nVersion), END(nNonce));
  4226.     }
  4227.     uint256 BuildMerkleTree() const
  4228.     {
  4229.         vMerkleTree.clear();
  4230.         foreach(const CTransaction& tx, vtx)
  4231.             vMerkleTree.push_back(tx.GetHash());
  4232.         int j = 0;
  4233.         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
  4234.         {
  4235.             for (int i = 0; i < nSize; i += 2)
  4236.             {
  4237.                 int i2 = min(i+1, nSize-1);
  4238.                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
  4239.                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
  4240.             }
  4241.             j += nSize;
  4242.         }
  4243.         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
  4244.     }
  4245.     vector<uint256> GetMerkleBranch(int nIndex) const
  4246.     {
  4247.         if (vMerkleTree.empty())
  4248.             BuildMerkleTree();
  4249.         vector<uint256> vMerkleBranch;
  4250.         int j = 0;
  4251.         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
  4252.         {
  4253.             int i = min(nIndex^1, nSize-1);
  4254.             vMerkleBranch.push_back(vMerkleTree[j+i]);
  4255.             nIndex >>= 1;
  4256.             j += nSize;
  4257.         }
  4258.         return vMerkleBranch;
  4259.     }
  4260.     static uint256 CheckMerkleBranch(uint256 hash, const vector<uint256>& vMerkleBranch, int nIndex)
  4261.     {
  4262.         if (nIndex == -1)
  4263.             return 0;
  4264.         foreach(const uint256& otherside, vMerkleBranch)
  4265.         {
  4266.             if (nIndex & 1)
  4267.                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
  4268.             else
  4269.                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
  4270.             nIndex >>= 1;
  4271.         }
  4272.         return hash;
  4273.     }
  4274.     bool WriteToDisk(bool fWriteTransactions, unsigned int& nFileRet, unsigned int& nBlockPosRet)
  4275.     {
  4276.         CAutoFile fileout = AppendBlockFile(nFileRet);
  4277.         if (!fileout)
  4278.             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
  4279.         if (!fWriteTransactions)
  4280.             fileout.nType |= SER_BLOCKHEADERONLY;
  4281.         unsigned int nSize = fileout.GetSerializeSize(*this);
  4282.         fileout << FLATDATA(pchMessageStart) << nSize;
  4283.         nBlockPosRet = ftell(fileout);
  4284.         if (nBlockPosRet == -1)
  4285.             return error("CBlock::WriteToDisk() : ftell failed");
  4286.         fileout << *this;
  4287.         return true;
  4288.     }
  4289.     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions)
  4290.     {
  4291.         SetNull();
  4292.         CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
  4293.         if (!filein)
  4294.             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
  4295.         if (!fReadTransactions)
  4296.             filein.nType |= SER_BLOCKHEADERONLY;
  4297.         filein >> *this;
  4298.         if (CBigNum().SetCompact(nBits) > bnProofOfWorkLimit)
  4299.             return error("CBlock::ReadFromDisk() : nBits errors in block header");
  4300.         if (GetHash() > CBigNum().SetCompact(nBits).getuint256())
  4301.             return error("CBlock::ReadFromDisk() : GetHash() errors in block header");
  4302.         return true;
  4303.     }
  4304.     void print() const
  4305.     {
  4306.         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
  4307.             GetHash().ToString().substr(0,14).c_str(),
  4308.             nVersion,
  4309.             hashPrevBlock.ToString().substr(0,14).c_str(),
  4310.             hashMerkleRoot.ToString().substr(0,6).c_str(),
  4311.             nTime, nBits, nNonce,
  4312.             vtx.size());
  4313.         for (int i = 0; i < vtx.size(); i++)
  4314.         {
  4315.             printf("  ");
  4316.             vtx[i].print();
  4317.         }
  4318.         printf("  vMerkleTree: ");
  4319.         for (int i = 0; i < vMerkleTree.size(); i++)
  4320.             printf("%s ", vMerkleTree[i].ToString().substr(0,6).c_str());
  4321.         printf("\n");
  4322.     }
  4323.     int64 GetBlockValue(int64 nFees) const;
  4324.     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
  4325.     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
  4326.     bool ReadFromDisk(const CBlockIndex* blockindex, bool fReadTransactions);
  4327.     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
  4328.     bool CheckBlock() const;
  4329.     bool AcceptBlock();
  4330. };
  4331. class CBlockIndex
  4332. {
  4333. public:
  4334.     const uint256* phashBlock;
  4335.     CBlockIndex* pprev;
  4336.     CBlockIndex* pnext;
  4337.     unsigned int nFile;
  4338.     unsigned int nBlockPos;
  4339.     int nHeight;
  4340.     int nVersion;
  4341.     uint256 hashMerkleRoot;
  4342.     unsigned int nTime;
  4343.     unsigned int nBits;
  4344.     unsigned int nNonce;
  4345.     CBlockIndex()
  4346.     {
  4347.         phashBlock = NULL;
  4348.         pprev = NULL;
  4349.         pnext = NULL;
  4350.         nFile = 0;
  4351.         nBlockPos = 0;
  4352.         nHeight = 0;
  4353.         nVersion       = 0;
  4354.         hashMerkleRoot = 0;
  4355.         nTime          = 0;
  4356.         nBits          = 0;
  4357.         nNonce         = 0;
  4358.     }
  4359.     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
  4360.     {
  4361.         phashBlock = NULL;
  4362.         pprev = NULL;
  4363.         pnext = NULL;
  4364.         nFile = nFileIn;
  4365.         nBlockPos = nBlockPosIn;
  4366.         nHeight = 0;
  4367.         nVersion       = block.nVersion;
  4368.         hashMerkleRoot = block.hashMerkleRoot;
  4369.         nTime          = block.nTime;
  4370.         nBits          = block.nBits;
  4371.         nNonce         = block.nNonce;
  4372.     }
  4373.     uint256 GetBlockHash() const
  4374.     {
  4375.         return *phashBlock;
  4376.     }
  4377.     bool IsInMainChain() const
  4378.     {
  4379.         return (pnext || this == pindexBest);
  4380.     }
  4381.     bool EraseBlockFromDisk()
  4382.     {
  4383.         CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
  4384.         if (!fileout)
  4385.             return false;
  4386.         CBlock block;
  4387.         block.SetNull();
  4388.         fileout << block;
  4389.         return true;
  4390.     }
  4391.     enum { nMedianTimeSpan=11 };
  4392.     int64 GetMedianTimePast() const
  4393.     {
  4394.         unsigned int pmedian[nMedianTimeSpan];
  4395.         unsigned int* pbegin = &pmedian[nMedianTimeSpan];
  4396.         unsigned int* pend = &pmedian[nMedianTimeSpan];
  4397.         const CBlockIndex* pindex = this;
  4398.         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
  4399.             *(--pbegin) = pindex->nTime;
  4400.         sort(pbegin, pend);
  4401.         return pbegin[(pend - pbegin)/2];
  4402.     }
  4403.     int64 GetMedianTime() const
  4404.     {
  4405.         const CBlockIndex* pindex = this;
  4406.         for (int i = 0; i < nMedianTimeSpan/2; i++)
  4407.         {
  4408.             if (!pindex->pnext)
  4409.                 return nTime;
  4410.             pindex = pindex->pnext;
  4411.         }
  4412.         return pindex->GetMedianTimePast();
  4413.     }
  4414.     string ToString() const
  4415.     {
  4416.         return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
  4417.             pprev, pnext, nFile, nBlockPos, nHeight,
  4418.             hashMerkleRoot.ToString().substr(0,6).c_str(),
  4419.             GetBlockHash().ToString().substr(0,14).c_str());
  4420.     }
  4421.     void print() const
  4422.     {
  4423.         printf("%s\n", ToString().c_str());
  4424.     }
  4425. };
  4426. class CDiskBlockIndex : public CBlockIndex
  4427. {
  4428. public:
  4429.     uint256 hashPrev;
  4430.     uint256 hashNext;
  4431.     CDiskBlockIndex()
  4432.     {
  4433.         hashPrev = 0;
  4434.         hashNext = 0;
  4435.     }
  4436.     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
  4437.     {
  4438.         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
  4439.         hashNext = (pnext ? pnext->GetBlockHash() : 0);
  4440.     }
  4441.     IMPLEMENT_SERIALIZE
  4442.     (
  4443.         if (!(nType & SER_GETHASH))
  4444.         READWRITE(nVersion);
  4445.         READWRITE(hashNext);
  4446.         READWRITE(nFile);
  4447.         READWRITE(nBlockPos);
  4448.         READWRITE(nHeight);
  4449.         READWRITE(this->nVersion);
  4450.         READWRITE(hashPrev);
  4451.         READWRITE(hashMerkleRoot);
  4452.         READWRITE(nTime);
  4453.         READWRITE(nBits);
  4454.         READWRITE(nNonce);
  4455.     )
  4456.     uint256 GetBlockHash() const
  4457.     {
  4458.         CBlock block;
  4459.         block.nVersion        = nVersion;
  4460.         block.hashPrevBlock   = hashPrev;
  4461.         block.hashMerkleRoot  = hashMerkleRoot;
  4462.         block.nTime           = nTime;
  4463.         block.nBits           = nBits;
  4464.         block.nNonce          = nNonce;
  4465.         return block.GetHash();
  4466.     }
  4467.     string ToString() const
  4468.     {
  4469.         string str = "CDiskBlockIndex(";
  4470.         str += CBlockIndex::ToString();
  4471.         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
  4472.             GetBlockHash().ToString().c_str(),
  4473.             hashPrev.ToString().substr(0,14).c_str(),
  4474.             hashNext.ToString().substr(0,14).c_str());
  4475.         return str;
  4476.     }
  4477.     void print() const
  4478.     {
  4479.         printf("%s\n", ToString().c_str());
  4480.     }
  4481. };
  4482. class CBlockLocator
  4483. {
  4484. protected:
  4485.     vector<uint256> vHave;
  4486. public:
  4487.     CBlockLocator()
  4488.     {
  4489.     }
  4490.     explicit CBlockLocator(const CBlockIndex* pindex)
  4491.     {
  4492.         Set(pindex);
  4493.     }
  4494.     explicit CBlockLocator(uint256 hashBlock)
  4495.     {
  4496.         map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
  4497.         if (mi != mapBlockIndex.end())
  4498.             Set((*mi).second);
  4499.     }
  4500.     IMPLEMENT_SERIALIZE
  4501.     (
  4502.         if (!(nType & SER_GETHASH))
  4503.             READWRITE(nVersion);
  4504.         READWRITE(vHave);
  4505.     )
  4506.     void Set(const CBlockIndex* pindex)
  4507.     {
  4508.         vHave.clear();
  4509.         int nStep = 1;
  4510.         while (pindex)
  4511.         {
  4512.             vHave.push_back(pindex->GetBlockHash());
  4513.  
  4514.             for (int i = 0; pindex && i < nStep; i++)
  4515.                 pindex = pindex->pprev;
  4516.             if (vHave.size() > 10)
  4517.                 nStep *= 2;
  4518.         }
  4519.         vHave.push_back(hashGenesisBlock);
  4520.     }
  4521.     CBlockIndex* GetBlockIndex()
  4522.     {
  4523.         foreach(const uint256& hash, vHave)
  4524.         {
  4525.             map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
  4526.             if (mi != mapBlockIndex.end())
  4527.             {
  4528.                 CBlockIndex* pindex = (*mi).second;
  4529.                 if (pindex->IsInMainChain())
  4530.                     return pindex;
  4531.             }
  4532.         }
  4533.         return pindexGenesisBlock;
  4534.     }
  4535.     uint256 GetBlockHash()
  4536.     {
  4537.      foreach(const uint256& hash, vHave)
  4538.         {
  4539.             map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
  4540.             if (mi != mapBlockIndex.end())
  4541.             {
  4542.                 CBlockIndex* pindex = (*mi).second;
  4543.                 if (pindex->IsInMainChain())
  4544.                     return hash;
  4545.             }
  4546.         }
  4547.         return hashGenesisBlock;
  4548.     }
  4549.     int GetHeight()
  4550.     {
  4551.         CBlockIndex* pindex = GetBlockIndex();
  4552.         if (!pindex)
  4553.             return 0;
  4554.         return pindex->nHeight;
  4555.     }
  4556. };
  4557. extern map<uint256, CTransaction> mapTransactions;
  4558. extern map<uint256, CWalletTx> mapWallet;
  4559. extern vector<pair<uint256, bool> > vWalletUpdated;
  4560. extern CCriticalSection cs_mapWallet;
  4561. extern map<vector<unsigned char>, CPrivKey> mapKeys;
  4562. extern map<uint160, vector<unsigned char> > mapPubKeys;
  4563. extern CCriticalSection cs_mapKeys;
  4564. extern CKey keyUser;
  4565. #include "headers.h"
  4566. map<uint256, CProduct> mapMyProducts;
  4567. map<uint256, CProduct> mapProducts;
  4568. CCriticalSection cs_mapProducts;
  4569. bool AdvertInsert(const CProduct& product)
  4570. {
  4571.     uint256 hash = product.GetHash();
  4572.     bool fNew = false;
  4573.     bool fUpdated = false;
  4574.     CRITICAL_BLOCK(cs_mapProducts)
  4575.     {
  4576.         pair<map<uint256, CProduct>::iterator, bool> item = mapProducts.insert(make_pair(hash, product));
  4577.         CProduct* pproduct = &(*(item.first)).second;
  4578.         fNew = item.second;
  4579.         if (product.nSequence > pproduct->nSequence)
  4580.         {
  4581.             *pproduct = product;
  4582.             fUpdated = true;
  4583.         }
  4584.     }
  4585.     return (fNew || fUpdated);
  4586. }
  4587. void AdvertErase(const CProduct& product)
  4588. {
  4589.     uint256 hash = product.GetHash();
  4590.     CRITICAL_BLOCK(cs_mapProducts)
  4591.         mapProducts.erase(hash);
  4592. }
  4593. template<typename T>
  4594. unsigned int Union(T& v1, T& v2)
  4595. {
  4596.     T vUnion;
  4597.     vUnion.reserve(v1.size() + v2.size());
  4598.     set_union(v1.begin(), v1.end(),
  4599.               v2.begin(), v2.end(),
  4600.               back_inserter(vUnion));
  4601.     unsigned int nAdded = vUnion.size() - v1.size();
  4602.     if (nAdded > 0)
  4603.         v1 = vUnion;
  4604.     return nAdded;
  4605. }
  4606. void CUser::AddAtom(unsigned short nAtom, bool fOrigin)
  4607. {
  4608.     if (binary_search(vAtomsIn.begin(), vAtomsIn.end(), nAtom) ||
  4609.         find(vAtomsNew.begin(), vAtomsNew.end(), nAtom) != vAtomsNew.end())
  4610.         return;
  4611.     if (nAtom == 0 || fOrigin)
  4612.     {
  4613.         vector<unsigned short> vTmp(1, nAtom);
  4614.         Union(vAtomsIn, vTmp);
  4615.         if (fOrigin)
  4616.             vAtomsOut.push_back(nAtom);
  4617.         return;
  4618.     }
  4619.     vAtomsNew.push_back(nAtom);
  4620.     if (vAtomsNew.size() >= nFlowthroughRate || vAtomsOut.empty())
  4621.     {
  4622.         vAtomsOut.push_back(vAtomsNew[GetRand(vAtomsNew.size())]);
  4623.         sort(vAtomsNew.begin(), vAtomsNew.end());
  4624.         Union(vAtomsIn, vAtomsNew);
  4625.         vAtomsNew.clear();
  4626.     }
  4627. }
  4628. bool AddAtomsAndPropagate(uint256 hashUserStart, const vector<unsigned short>& vAtoms, bool fOrigin)
  4629. {
  4630.     CReviewDB reviewdb;
  4631.     map<uint256, vector<unsigned short> > pmapPropagate[2];
  4632.     pmapPropagate[0][hashUserStart] = vAtoms;
  4633.     for (int side = 0; !pmapPropagate[side].empty(); side = 1 - side)
  4634.     {
  4635.         map<uint256, vector<unsigned short> >& mapFrom = pmapPropagate[side];
  4636.         map<uint256, vector<unsigned short> >& mapTo = pmapPropagate[1 - side];
  4637.         for (map<uint256, vector<unsigned short> >::iterator mi = mapFrom.begin(); mi != mapFrom.end(); ++mi)
  4638.         {
  4639.             const uint256& hashUser = (*mi).first;
  4640.             const vector<unsigned short>& vReceived = (*mi).second;
  4641.             CUser user;
  4642.             reviewdb.ReadUser(hashUser, user);
  4643.             unsigned int nIn = user.vAtomsIn.size();
  4644.             unsigned int nNew = user.vAtomsNew.size();
  4645.             unsigned int nOut = user.vAtomsOut.size();
  4646.             foreach(unsigned short nAtom, vReceived)
  4647.             user.AddAtom(nAtom, fOrigin);
  4648.             fOrigin = false;
  4649.             if (user.vAtomsIn.size() == nIn && user.vAtomsNew.size() == nNew)
  4650.                 continue;
  4651.             if (user.vAtomsOut.size() > nOut)
  4652.                 foreach(const uint256& hash, user.vLinksOut)
  4653.                     mapTo[hash].insert(mapTo[hash].end(), user.vAtomsOut.begin() + nOut, user.vAtomsOut.end());
  4654.             if (!reviewdb.WriteUser(hashUser, user))
  4655.                 return false;
  4656.         }
  4657.         mapFrom.clear();
  4658.     }
  4659.     return true;
  4660. }
  4661. bool CReview::AcceptReview()
  4662. {
  4663.     nTime = GetTime();
  4664.     if (!CKey::Verify(vchPubKeyFrom, GetSigHash(), vchSig))
  4665.         return false;
  4666.     CReviewDB reviewdb;
  4667.     vector<CReview> vReviews;
  4668.     reviewdb.ReadReviews(hashTo, vReviews);
  4669.     vReviews.push_back(*this);
  4670.     if (!reviewdb.WriteReviews(hashTo, vReviews))
  4671.         return false;
  4672.     CUser user;
  4673.     uint256 hashFrom = Hash(vchPubKeyFrom.begin(), vchPubKeyFrom.end());
  4674.     reviewdb.ReadUser(hashFrom, user);
  4675.     user.vLinksOut.push_back(hashTo);
  4676.     if (!reviewdb.WriteUser(hashFrom, user))
  4677.         return false;
  4678.     reviewdb.Close();
  4679.     vector<unsigned short> vZeroAtom(1, 0);
  4680.     if (!AddAtomsAndPropagate(hashTo, user.vAtomsOut.size() ? user.vAtomsOut : vZeroAtom, false))
  4681.         return false;
  4682.     return true;
  4683. }
  4684. bool CProduct::CheckSignature()
  4685. {
  4686.     return (CKey::Verify(vchPubKeyFrom, GetSigHash(), vchSig));
  4687. }
  4688. bool CProduct::CheckProduct()
  4689. {
  4690.     if (!CheckSignature())
  4691.         return false;
  4692.     if (!mapDetails.empty() || !vOrderForm.empty())
  4693.         return false;
  4694.     CReviewDB reviewdb("r");
  4695.     CUser user;
  4696.     reviewdb.ReadUser(GetUserHash(), user);
  4697.     nAtoms = user.GetAtomCount();
  4698.     reviewdb.Close();
  4699.     return true;
  4700. }
  4701. class CUser;
  4702. class CReview;
  4703. class CProduct;
  4704. static const unsigned int nFlowthroughRate = 2;
  4705. bool AdvertInsert(const CProduct& product);
  4706. void AdvertErase(const CProduct& product);
  4707. bool AddAtomsAndPropagate(uint256 hashUserStart, const vector<unsigned short>& vAtoms, bool fOrigin);
  4708. class CUser
  4709. {
  4710. public:
  4711.     vector<unsigned short> vAtomsIn;
  4712.     vector<unsigned short> vAtomsNew;
  4713.     vector<unsigned short> vAtomsOut;
  4714.     vector<uint256> vLinksOut;
  4715.     CUser()
  4716.     {
  4717.     }
  4718.     IMPLEMENT_SERIALIZE
  4719.     (
  4720.         if (!(nType & SER_GETHASH))
  4721.             READWRITE(nVersion);
  4722.         READWRITE(vAtomsIn);
  4723.         READWRITE(vAtomsNew);
  4724.         READWRITE(vAtomsOut);
  4725.         READWRITE(vLinksOut);
  4726.     )
  4727.     void SetNull()
  4728.     {
  4729.         vAtomsIn.clear();
  4730.         vAtomsNew.clear();
  4731.         vAtomsOut.clear();
  4732.         vLinksOut.clear();
  4733.     }
  4734.     uint256 GetHash() const { return SerializeHash(*this); }
  4735.     int GetAtomCount() const
  4736.     {
  4737.         return (vAtomsIn.size() + vAtomsNew.size());
  4738.     }
  4739.     void AddAtom(unsigned short nAtom, bool fOrigin);
  4740. };
  4741. class CReview
  4742. {
  4743. public:
  4744.     int nVersion;
  4745.     uint256 hashTo;
  4746.     map<string, string> mapValue;
  4747.     vector<unsigned char> vchPubKeyFrom;
  4748.     vector<unsigned char> vchSig;
  4749.     unsigned int nTime;
  4750.     int nAtoms;
  4751.     CReview()
  4752.     {
  4753.         nVersion = 1;
  4754.         hashTo = 0;
  4755.         nTime = 0;
  4756.         nAtoms = 0;
  4757.     }
  4758.     IMPLEMENT_SERIALIZE
  4759.     (
  4760.         READWRITE(this->nVersion);
  4761.         nVersion = this->nVersion;
  4762.         if (!(nType & SER_DISK))
  4763.             READWRITE(hashTo);
  4764.         READWRITE(mapValue);
  4765.         READWRITE(vchPubKeyFrom);
  4766.         if (!(nType & SER_GETHASH))
  4767.             READWRITE(vchSig);
  4768.     )
  4769.     uint256 GetHash() const { return SerializeHash(*this); }
  4770.     uint256 GetSigHash() const { return SerializeHash(*this, SER_GETHASH|SER_SKIPSIG); }
  4771.     uint256 GetUserHash() const { return Hash(vchPubKeyFrom.begin(), vchPubKeyFrom.end()); }
  4772.     bool AcceptReview();
  4773. };
  4774. class CProduct
  4775. {
  4776. public:
  4777.     int nVersion;
  4778.     CAddress addr;
  4779.     map<string, string> mapValue;
  4780.     map<string, string> mapDetails;
  4781.     vector<pair<string, string> > vOrderForm;
  4782.     unsigned int nSequence;
  4783.     vector<unsigned char> vchPubKeyFrom;
  4784.     vector<unsigned char> vchSig;
  4785.     int nAtoms;
  4786.     set<unsigned int> setSources;
  4787.     CProduct()
  4788.     {
  4789.         nVersion = 1;
  4790.         nAtoms = 0;
  4791.         nSequence = 0;
  4792.     }
  4793.     IMPLEMENT_SERIALIZE
  4794.     (
  4795.         READWRITE(this->nVersion);
  4796.         nVersion = this->nVersion;
  4797.         READWRITE(addr);
  4798.         READWRITE(mapValue);
  4799.         if (!(nType & SER_GETHASH))
  4800.         {
  4801.             READWRITE(mapDetails);
  4802.             READWRITE(vOrderForm);
  4803.             READWRITE(nSequence);
  4804.         }
  4805.         READWRITE(vchPubKeyFrom);
  4806.         if (!(nType & SER_GETHASH))
  4807.             READWRITE(vchSig);
  4808.         if (nType & SER_DISK)
  4809.             READWRITE(nAtoms);
  4810.     )
  4811.     uint256 GetHash() const { return SerializeHash(*this); }
  4812.     uint256 GetSigHash() const { return SerializeHash(*this, SER_GETHASH|SER_SKIPSIG); }
  4813.     uint256 GetUserHash() const { return Hash(vchPubKeyFrom.begin(), vchPubKeyFrom.end()); }
  4814.     bool CheckSignature();
  4815.     bool CheckProduct();
  4816. };
  4817. extern map<uint256, CProduct> mapProducts;
  4818. extern CCriticalSection cs_mapProducts;
  4819. extern map<uint256, CProduct> mapMyProducts;
  4820. #include "headers.h"
  4821. #include <winsock2.h>
  4822. void ThreadMessageHandler2(void* parg);
  4823. void ThreadSocketHandler2(void* parg);
  4824. void ThreadOpenConnections2(void* parg);
  4825. bool fClient = false;
  4826. uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
  4827. CAddress addrLocalHost(0, DEFAULT_PORT, nLocalServices);
  4828. CNode nodeLocalHost(INVALID_SOCKET, CAddress("127.0.0.1", nLocalServices));
  4829. CNode* pnodeLocalHost = &nodeLocalHost;
  4830. bool fShutdown = false;
  4831. array<bool, 10> vfThreadRunning;
  4832. vector<CNode*> vNodes;
  4833. CCriticalSection cs_vNodes;
  4834. map<vector<unsigned char>, CAddress> mapAddresses;
  4835. CCriticalSection cs_mapAddresses;
  4836. map<CInv, CDataStream> mapRelay;
  4837. deque<pair<int64, CInv> > vRelayExpiration;
  4838. CCriticalSection cs_mapRelay;
  4839. map<CInv, int64> mapAlreadyAskedFor;
  4840. CAddress addrProxy;
  4841. bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet)
  4842. {
  4843.     hSocketRet = INVALID_SOCKET;
  4844.     SOCKET hSocket = socket(AF_INET, SOCK_STREAM, 0);
  4845.     if (hSocket == INVALID_SOCKET)
  4846.         return false;
  4847.     bool fRoutable = !(addrConnect.GetByte(3) == 10 || (addrConnect.GetByte(3) == 192 && addrConnect.GetByte(2) == 168));
  4848.     bool fProxy = (addrProxy.ip && fRoutable);
  4849.     struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
  4850.     if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
  4851.     {
  4852.         closesocket(hSocket);
  4853.         return false;
  4854.     }
  4855.     if (fProxy)
  4856.     {
  4857.         printf("Proxy connecting to %s\n", addrConnect.ToString().c_str());
  4858.         char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
  4859.         memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
  4860.         memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
  4861.         char* pszSocks4 = pszSocks4IP;
  4862.         int nSize = sizeof(pszSocks4IP);
  4863.         int ret = send(hSocket, pszSocks4, nSize, 0);
  4864.         if (ret != nSize)
  4865.         {
  4866.             closesocket(hSocket);
  4867.             return error("Error sending to proxy\n");
  4868.         }
  4869.         char pchRet[8]