?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Gavin: BIO_FLAGS_BASE64_NO_NL
[bitcoinplatinum.git] / main.cpp
blob45ad06f9367b2962952eab4f08a95ff7df863dbc
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Distributed under the MIT/X11 software license, see the accompanying
3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
4
5 #include "headers.h"
6 #include "sha.h"
7
8
9
10
11
12 //
13 // Global state
14 //
15
16 CCriticalSection cs_main;
17
18 map<uint256, CTransaction> mapTransactions;
19 CCriticalSection cs_mapTransactions;
20 unsigned int nTransactionsUpdated = 0;
21 map<COutPoint, CInPoint> mapNextTx;
22
23 map<uint256, CBlockIndex*> mapBlockIndex;
24 const uint256 hashGenesisBlock("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
25 CBlockIndex* pindexGenesisBlock = NULL;
26 int nBestHeight = -1;
27 CBigNum bnBestChainWork = 0;
28 uint256 hashBestChain = 0;
29 CBlockIndex* pindexBest = NULL;
30 int64 nTimeBestReceived = 0;
31
32 map<uint256, CBlock*> mapOrphanBlocks;
33 multimap<uint256, CBlock*> mapOrphanBlocksByPrev;
34
35 map<uint256, CDataStream*> mapOrphanTransactions;
36 multimap<uint256, CDataStream*> mapOrphanTransactionsByPrev;
37
38 map<uint256, CWalletTx> mapWallet;
39 vector<uint256> vWalletUpdated;
40 CCriticalSection cs_mapWallet;
41
42 map<vector<unsigned char>, CPrivKey> mapKeys;
43 map<uint160, vector<unsigned char> > mapPubKeys;
44 CCriticalSection cs_mapKeys;
45 CKey keyUser;
46
47 map<uint256, int> mapRequestCount;
48 CCriticalSection cs_mapRequestCount;
49
50 map<string, string> mapAddressBook;
51 CCriticalSection cs_mapAddressBook;
52
53 vector<unsigned char> vchDefaultKey;
54
55 // Settings
56 int fGenerateBitcoins = false;
57 int64 nTransactionFee = 0;
58 CAddress addrIncoming;
59 int fLimitProcessors = false;
60 int nLimitProcessors = 1;
61 int fMinimizeToTray = true;
62 int fMinimizeOnClose = true;
63
64
65
66
67
68
69 //////////////////////////////////////////////////////////////////////////////
70 //
71 // mapKeys
72 //
73
74 bool AddKey(const CKey& key)
75 {
76 CRITICAL_BLOCK(cs_mapKeys)
77 {
78 mapKeys[key.GetPubKey()] = key.GetPrivKey();
79 mapPubKeys[Hash160(key.GetPubKey())] = key.GetPubKey();
80 }
81 return CWalletDB().WriteKey(key.GetPubKey(), key.GetPrivKey());
82 }
83
84 vector<unsigned char> GenerateNewKey()
85 {
86 CKey key;
87 key.MakeNewKey();
88 if (!AddKey(key))
89 throw runtime_error("GenerateNewKey() : AddKey failed\n");
90 return key.GetPubKey();
91 }
92
93
94
95
96 //////////////////////////////////////////////////////////////////////////////
97 //
98 // mapWallet
99 //
100
101 bool AddToWallet(const CWalletTx& wtxIn)
102 {
103 uint256 hash = wtxIn.GetHash();
104 CRITICAL_BLOCK(cs_mapWallet)
105 {
106 // Inserts only if not already there, returns tx inserted or tx found
107 pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
108 CWalletTx& wtx = (*ret.first).second;
109 bool fInsertedNew = ret.second;
110 if (fInsertedNew)
111 wtx.nTimeReceived = GetAdjustedTime();
112
113 bool fUpdated = false;
114 if (!fInsertedNew)
115 {
116 // Merge
117 if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
118 {
119 wtx.hashBlock = wtxIn.hashBlock;
120 fUpdated = true;
121 }
122 if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
123 {
124 wtx.vMerkleBranch = wtxIn.vMerkleBranch;
125 wtx.nIndex = wtxIn.nIndex;
126 fUpdated = true;
127 }
128 if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
129 {
130 wtx.fFromMe = wtxIn.fFromMe;
131 fUpdated = true;
132 }
133 if (wtxIn.fSpent && wtxIn.fSpent != wtx.fSpent)
134 {
135 wtx.fSpent = wtxIn.fSpent;
136 fUpdated = true;
137 }
138 }
139
140 //// debug print
141 printf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString().substr(0,6).c_str(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
142
143 // Write to disk
144 if (fInsertedNew || fUpdated)
145 if (!wtx.WriteToDisk())
146 return false;
147
148 // If default receiving address gets used, replace it with a new one
149 CScript scriptDefaultKey;
150 scriptDefaultKey.SetBitcoinAddress(vchDefaultKey);
151 foreach(const CTxOut& txout, wtx.vout)
152 {
153 if (txout.scriptPubKey == scriptDefaultKey)
154 {
155 CWalletDB walletdb;
156 walletdb.WriteDefaultKey(GenerateNewKey());
157 walletdb.WriteName(PubKeyToAddress(vchDefaultKey), "");
158 }
159 }
160
161 // Notify UI
162 vWalletUpdated.push_back(hash);
163 }
164
165 // Refresh UI
166 MainFrameRepaint();
167 return true;
168 }
169
170 bool AddToWalletIfMine(const CTransaction& tx, const CBlock* pblock)
171 {
172 if (tx.IsMine() || mapWallet.count(tx.GetHash()))
173 {
174 CWalletTx wtx(tx);
175 // Get merkle branch if transaction was found in a block
176 if (pblock)
177 wtx.SetMerkleBranch(pblock);
178 return AddToWallet(wtx);
179 }
180 return true;
181 }
182
183 bool EraseFromWallet(uint256 hash)
184 {
185 CRITICAL_BLOCK(cs_mapWallet)
186 {
187 if (mapWallet.erase(hash))
188 CWalletDB().EraseTx(hash);
189 }
190 return true;
191 }
192
193 void WalletUpdateSpent(const COutPoint& prevout)
194 {
195 // Anytime a signature is successfully verified, it's proof the outpoint is spent.
196 // Update the wallet spent flag if it doesn't know due to wallet.dat being
197 // restored from backup or the user making copies of wallet.dat.
198 CRITICAL_BLOCK(cs_mapWallet)
199 {
200 map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
201 if (mi != mapWallet.end())
202 {
203 CWalletTx& wtx = (*mi).second;
204 if (!wtx.fSpent && wtx.vout[prevout.n].IsMine())
205 {
206 printf("WalletUpdateSpent found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
207 wtx.fSpent = true;
208 wtx.WriteToDisk();
209 vWalletUpdated.push_back(prevout.hash);
210 }
211 }
212 }
213 }
214
215
216
217
218
219
220
221
222 //////////////////////////////////////////////////////////////////////////////
223 //
224 // mapOrphanTransactions
225 //
226
227 void AddOrphanTx(const CDataStream& vMsg)
228 {
229 CTransaction tx;
230 CDataStream(vMsg) >> tx;
231 uint256 hash = tx.GetHash();
232 if (mapOrphanTransactions.count(hash))
233 return;
234 CDataStream* pvMsg = mapOrphanTransactions[hash] = new CDataStream(vMsg);
235 foreach(const CTxIn& txin, tx.vin)
236 mapOrphanTransactionsByPrev.insert(make_pair(txin.prevout.hash, pvMsg));
237 }
238
239 void EraseOrphanTx(uint256 hash)
240 {
241 if (!mapOrphanTransactions.count(hash))
242 return;
243 const CDataStream* pvMsg = mapOrphanTransactions[hash];
244 CTransaction tx;
245 CDataStream(*pvMsg) >> tx;
246 foreach(const CTxIn& txin, tx.vin)
247 {
248 for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(txin.prevout.hash);
249 mi != mapOrphanTransactionsByPrev.upper_bound(txin.prevout.hash);)
250 {
251 if ((*mi).second == pvMsg)
252 mapOrphanTransactionsByPrev.erase(mi++);
253 else
254 mi++;
255 }
256 }
257 delete pvMsg;
258 mapOrphanTransactions.erase(hash);
259 }
260
261
262
263
264
265
266
267
268 //////////////////////////////////////////////////////////////////////////////
269 //
270 // CTransaction
271 //
272
273 bool CTxIn::IsMine() const
274 {
275 CRITICAL_BLOCK(cs_mapWallet)
276 {
277 map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
278 if (mi != mapWallet.end())
279 {
280 const CWalletTx& prev = (*mi).second;
281 if (prevout.n < prev.vout.size())
282 if (prev.vout[prevout.n].IsMine())
283 return true;
284 }
285 }
286 return false;
287 }
288
289 int64 CTxIn::GetDebit() const
290 {
291 CRITICAL_BLOCK(cs_mapWallet)
292 {
293 map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
294 if (mi != mapWallet.end())
295 {
296 const CWalletTx& prev = (*mi).second;
297 if (prevout.n < prev.vout.size())
298 if (prev.vout[prevout.n].IsMine())
299 return prev.vout[prevout.n].nValue;
300 }
301 }
302 return 0;
303 }
304
305 int64 CWalletTx::GetTxTime() const
306 {
307 if (!fTimeReceivedIsTxTime && hashBlock != 0)
308 {
309 // If we did not receive the transaction directly, we rely on the block's
310 // time to figure out when it happened. We use the median over a range
311 // of blocks to try to filter out inaccurate block times.
312 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
313 if (mi != mapBlockIndex.end())
314 {
315 CBlockIndex* pindex = (*mi).second;
316 if (pindex)
317 return pindex->GetMedianTime();
318 }
319 }
320 return nTimeReceived;
321 }
322
323 int CWalletTx::GetRequestCount() const
324 {
325 // Returns -1 if it wasn't being tracked
326 int nRequests = -1;
327 CRITICAL_BLOCK(cs_mapRequestCount)
328 {
329 if (IsCoinBase())
330 {
331 // Generated block
332 if (hashBlock != 0)
333 {
334 map<uint256, int>::iterator mi = mapRequestCount.find(hashBlock);
335 if (mi != mapRequestCount.end())
336 nRequests = (*mi).second;
337 }
338 }
339 else
340 {
341 // Did anyone request this transaction?
342 map<uint256, int>::iterator mi = mapRequestCount.find(GetHash());
343 if (mi != mapRequestCount.end())
344 {
345 nRequests = (*mi).second;
346
347 // How about the block it's in?
348 if (nRequests == 0 && hashBlock != 0)
349 {
350 map<uint256, int>::iterator mi = mapRequestCount.find(hashBlock);
351 if (mi != mapRequestCount.end())
352 nRequests = (*mi).second;
353 else
354 nRequests = 1; // If it's in someone else's block it must have got out
355 }
356 }
357 }
358 }
359 return nRequests;
360 }
361
362
363
364
365 int CMerkleTx::SetMerkleBranch(const CBlock* pblock)
366 {
367 if (fClient)
368 {
369 if (hashBlock == 0)
370 return 0;
371 }
372 else
373 {
374 CBlock blockTmp;
375 if (pblock == NULL)
376 {
377 // Load the block this tx is in
378 CTxIndex txindex;
379 if (!CTxDB("r").ReadTxIndex(GetHash(), txindex))
380 return 0;
381 if (!blockTmp.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos))
382 return 0;
383 pblock = &blockTmp;
384 }
385
386 // Update the tx's hashBlock
387 hashBlock = pblock->GetHash();
388
389 // Locate the transaction
390 for (nIndex = 0; nIndex < pblock->vtx.size(); nIndex++)
391 if (pblock->vtx[nIndex] == *(CTransaction*)this)
392 break;
393 if (nIndex == pblock->vtx.size())
394 {
395 vMerkleBranch.clear();
396 nIndex = -1;
397 printf("ERROR: SetMerkleBranch() : couldn't find tx in block\n");
398 return 0;
399 }
400
401 // Fill in merkle branch
402 vMerkleBranch = pblock->GetMerkleBranch(nIndex);
403 }
404
405 // Is the tx in a block that's in the main chain
406 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
407 if (mi == mapBlockIndex.end())
408 return 0;
409 CBlockIndex* pindex = (*mi).second;
410 if (!pindex || !pindex->IsInMainChain())
411 return 0;
412
413 return pindexBest->nHeight - pindex->nHeight + 1;
414 }
415
416
417
418 void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
419 {
420 vtxPrev.clear();
421
422 const int COPY_DEPTH = 3;
423 if (SetMerkleBranch() < COPY_DEPTH)
424 {
425 vector<uint256> vWorkQueue;
426 foreach(const CTxIn& txin, vin)
427 vWorkQueue.push_back(txin.prevout.hash);
428
429 // This critsect is OK because txdb is already open
430 CRITICAL_BLOCK(cs_mapWallet)
431 {
432 map<uint256, const CMerkleTx*> mapWalletPrev;
433 set<uint256> setAlreadyDone;
434 for (int i = 0; i < vWorkQueue.size(); i++)
435 {
436 uint256 hash = vWorkQueue[i];
437 if (setAlreadyDone.count(hash))
438 continue;
439 setAlreadyDone.insert(hash);
440
441 CMerkleTx tx;
442 if (mapWallet.count(hash))
443 {
444 tx = mapWallet[hash];
445 foreach(const CMerkleTx& txWalletPrev, mapWallet[hash].vtxPrev)
446 mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
447 }
448 else if (mapWalletPrev.count(hash))
449 {
450 tx = *mapWalletPrev[hash];
451 }
452 else if (!fClient && txdb.ReadDiskTx(hash, tx))
453 {
454 ;
455 }
456 else
457 {
458 printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
459 continue;
460 }
461
462 int nDepth = tx.SetMerkleBranch();
463 vtxPrev.push_back(tx);
464
465 if (nDepth < COPY_DEPTH)
466 foreach(const CTxIn& txin, tx.vin)
467 vWorkQueue.push_back(txin.prevout.hash);
468 }
469 }
470 }
471
472 reverse(vtxPrev.begin(), vtxPrev.end());
473 }
474
475
476
477
478
479
480
481
482
483
484
485 bool CTransaction::AcceptTransaction(CTxDB& txdb, bool fCheckInputs, bool* pfMissingInputs)
486 {
487 if (pfMissingInputs)
488 *pfMissingInputs = false;
489
490 // Coinbase is only valid in a block, not as a loose transaction
491 if (IsCoinBase())
492 return error("AcceptTransaction() : coinbase as individual tx");
493
494 if (!CheckTransaction())
495 return error("AcceptTransaction() : CheckTransaction failed");
496
497 // To help v0.1.5 clients who would see it as a negative number
498 if (nLockTime > INT_MAX)
499 return error("AcceptTransaction() : not accepting nLockTime beyond 2038");
500
501 // Do we already have it?
502 uint256 hash = GetHash();
503 CRITICAL_BLOCK(cs_mapTransactions)
504 if (mapTransactions.count(hash))
505 return false;
506 if (fCheckInputs)
507 if (txdb.ContainsTx(hash))
508 return false;
509
510 // Check for conflicts with in-memory transactions
511 CTransaction* ptxOld = NULL;
512 for (int i = 0; i < vin.size(); i++)
513 {
514 COutPoint outpoint = vin[i].prevout;
515 if (mapNextTx.count(outpoint))
516 {
517 // Allow replacing with a newer version of the same transaction
518 if (i != 0)
519 return false;
520 ptxOld = mapNextTx[outpoint].ptx;
521 if (!IsNewerThan(*ptxOld))
522 return false;
523 for (int i = 0; i < vin.size(); i++)
524 {
525 COutPoint outpoint = vin[i].prevout;
526 if (!mapNextTx.count(outpoint) || mapNextTx[outpoint].ptx != ptxOld)
527 return false;
528 }
529 break;
530 }
531 }
532
533 // Check against previous transactions
534 map<uint256, CTxIndex> mapUnused;
535 int64 nFees = 0;
536 if (fCheckInputs && !ConnectInputs(txdb, mapUnused, CDiskTxPos(1,1,1), 0, nFees, false, false))
537 {
538 if (pfMissingInputs)
539 *pfMissingInputs = true;
540 return error("AcceptTransaction() : ConnectInputs failed %s", hash.ToString().substr(0,6).c_str());
541 }
542
543 // Store transaction in memory
544 CRITICAL_BLOCK(cs_mapTransactions)
545 {
546 if (ptxOld)
547 {
548 printf("mapTransaction.erase(%s) replacing with new version\n", ptxOld->GetHash().ToString().c_str());
549 mapTransactions.erase(ptxOld->GetHash());
550 }
551 AddToMemoryPool();
552 }
553
554 ///// are we sure this is ok when loading transactions or restoring block txes
555 // If updated, erase old tx from wallet
556 if (ptxOld)
557 EraseFromWallet(ptxOld->GetHash());
558
559 printf("AcceptTransaction(): accepted %s\n", hash.ToString().substr(0,6).c_str());
560 return true;
561 }
562
563
564 bool CTransaction::AddToMemoryPool()
565 {
566 // Add to memory pool without checking anything. Don't call this directly,
567 // call AcceptTransaction to properly check the transaction first.
568 CRITICAL_BLOCK(cs_mapTransactions)
569 {
570 uint256 hash = GetHash();
571 mapTransactions[hash] = *this;
572 for (int i = 0; i < vin.size(); i++)
573 mapNextTx[vin[i].prevout] = CInPoint(&mapTransactions[hash], i);
574 nTransactionsUpdated++;
575 }
576 return true;
577 }
578
579
580 bool CTransaction::RemoveFromMemoryPool()
581 {
582 // Remove transaction from memory pool
583 CRITICAL_BLOCK(cs_mapTransactions)
584 {
585 foreach(const CTxIn& txin, vin)
586 mapNextTx.erase(txin.prevout);
587 mapTransactions.erase(GetHash());
588 nTransactionsUpdated++;
589 }
590 return true;
591 }
592
593
594
595
596
597
598 int CMerkleTx::GetDepthInMainChain(int& nHeightRet) const
599 {
600 if (hashBlock == 0 || nIndex == -1)
601 return 0;
602
603 // Find the block it claims to be in
604 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
605 if (mi == mapBlockIndex.end())
606 return 0;
607 CBlockIndex* pindex = (*mi).second;
608 if (!pindex || !pindex->IsInMainChain())
609 return 0;
610
611 // Make sure the merkle branch connects to this block
612 if (!fMerkleVerified)
613 {
614 if (CBlock::CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != pindex->hashMerkleRoot)
615 return 0;
616 fMerkleVerified = true;
617 }
618
619 nHeightRet = pindex->nHeight;
620 return pindexBest->nHeight - pindex->nHeight + 1;
621 }
622
623
624 int CMerkleTx::GetBlocksToMaturity() const
625 {
626 if (!IsCoinBase())
627 return 0;
628 return max(0, (COINBASE_MATURITY+20) - GetDepthInMainChain());
629 }
630
631
632 bool CMerkleTx::AcceptTransaction(CTxDB& txdb, bool fCheckInputs)
633 {
634 if (fClient)
635 {
636 if (!IsInMainChain() && !ClientConnectInputs())
637 return false;
638 return CTransaction::AcceptTransaction(txdb, false);
639 }
640 else
641 {
642 return CTransaction::AcceptTransaction(txdb, fCheckInputs);
643 }
644 }
645
646
647
648 bool CWalletTx::AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs)
649 {
650 CRITICAL_BLOCK(cs_mapTransactions)
651 {
652 foreach(CMerkleTx& tx, vtxPrev)
653 {
654 if (!tx.IsCoinBase())
655 {
656 uint256 hash = tx.GetHash();
657 if (!mapTransactions.count(hash) && !txdb.ContainsTx(hash))
658 tx.AcceptTransaction(txdb, fCheckInputs);
659 }
660 }
661 if (!IsCoinBase())
662 return AcceptTransaction(txdb, fCheckInputs);
663 }
664 return true;
665 }
666
667 void ReacceptWalletTransactions()
668 {
669 CTxDB txdb("r");
670 CRITICAL_BLOCK(cs_mapWallet)
671 {
672 foreach(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
673 {
674 CWalletTx& wtx = item.second;
675 if (wtx.fSpent && wtx.IsCoinBase())
676 continue;
677
678 CTxIndex txindex;
679 if (txdb.ReadTxIndex(wtx.GetHash(), txindex))
680 {
681 // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
682 if (!wtx.fSpent)
683 {
684 if (txindex.vSpent.size() != wtx.vout.size())
685 {
686 printf("ERROR: ReacceptWalletTransactions() : txindex.vSpent.size() %d != wtx.vout.size() %d\n", txindex.vSpent.size(), wtx.vout.size());
687 continue;
688 }
689 for (int i = 0; i < txindex.vSpent.size(); i++)
690 {
691 if (!txindex.vSpent[i].IsNull() && wtx.vout[i].IsMine())
692 {
693 printf("ReacceptWalletTransactions found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
694 wtx.fSpent = true;
695 wtx.WriteToDisk();
696 break;
697 }
698 }
699 }
700 }
701 else
702 {
703 // Reaccept any txes of ours that aren't already in a block
704 if (!wtx.IsCoinBase())
705 wtx.AcceptWalletTransaction(txdb, false);
706 }
707 }
708 }
709 }
710
711
712 void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
713 {
714 foreach(const CMerkleTx& tx, vtxPrev)
715 {
716 if (!tx.IsCoinBase())
717 {
718 uint256 hash = tx.GetHash();
719 if (!txdb.ContainsTx(hash))
720 RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
721 }
722 }
723 if (!IsCoinBase())
724 {
725 uint256 hash = GetHash();
726 if (!txdb.ContainsTx(hash))
727 {
728 printf("Relaying wtx %s\n", hash.ToString().substr(0,6).c_str());
729 RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
730 }
731 }
732 }
733
734 void ResendWalletTransactions()
735 {
736 // Do this infrequently and randomly to avoid giving away
737 // that these are our transactions.
738 static int64 nNextTime;
739 if (GetTime() < nNextTime)
740 return;
741 bool fFirst = (nNextTime == 0);
742 nNextTime = GetTime() + GetRand(120 * 60);
743 if (fFirst)
744 return;
745
746 // Rebroadcast any of our txes that aren't in a block yet
747 printf("ResendWalletTransactions()\n");
748 CTxDB txdb("r");
749 CRITICAL_BLOCK(cs_mapWallet)
750 {
751 // Sort them in chronological order
752 multimap<unsigned int, CWalletTx*> mapSorted;
753 foreach(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
754 {
755 CWalletTx& wtx = item.second;
756 // Don't rebroadcast until it's had plenty of time that
757 // it should have gotten in already by now.
758 if (nTimeBestReceived - wtx.nTimeReceived > 60 * 60)
759 mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
760 }
761 foreach(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
762 {
763 CWalletTx& wtx = *item.second;
764 wtx.RelayWalletTransaction(txdb);
765 }
766 }
767 }
768
769
770
771
772
773
774
775
776
777
778 //////////////////////////////////////////////////////////////////////////////
779 //
780 // CBlock and CBlockIndex
781 //
782
783 bool CBlock::ReadFromDisk(const CBlockIndex* pblockindex, bool fReadTransactions)
784 {
785 return ReadFromDisk(pblockindex->nFile, pblockindex->nBlockPos, fReadTransactions);
786 }
787
788 uint256 GetOrphanRoot(const CBlock* pblock)
789 {
790 // Work back to the first block in the orphan chain
791 while (mapOrphanBlocks.count(pblock->hashPrevBlock))
792 pblock = mapOrphanBlocks[pblock->hashPrevBlock];
793 return pblock->GetHash();
794 }
795
796 int64 CBlock::GetBlockValue(int64 nFees) const
797 {
798 int64 nSubsidy = 50 * COIN;
799
800 // Subsidy is cut in half every 4 years
801 nSubsidy >>= (nBestHeight / 210000);
802
803 return nSubsidy + nFees;
804 }
805
806 unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast)
807 {
808 const unsigned int nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
809 const unsigned int nTargetSpacing = 10 * 60;
810 const unsigned int nInterval = nTargetTimespan / nTargetSpacing;
811
812 // Genesis block
813 if (pindexLast == NULL)
814 return bnProofOfWorkLimit.GetCompact();
815
816 // Only change once per interval
817 if ((pindexLast->nHeight+1) % nInterval != 0)
818 return pindexLast->nBits;
819
820 // Go back by what we want to be 14 days worth of blocks
821 const CBlockIndex* pindexFirst = pindexLast;
822 for (int i = 0; pindexFirst && i < nInterval-1; i++)
823 pindexFirst = pindexFirst->pprev;
824 assert(pindexFirst);
825
826 // Limit adjustment step
827 unsigned int nActualTimespan = pindexLast->nTime - pindexFirst->nTime;
828 printf(" nActualTimespan = %d before bounds\n", nActualTimespan);
829 if (nActualTimespan < nTargetTimespan/4)
830 nActualTimespan = nTargetTimespan/4;
831 if (nActualTimespan > nTargetTimespan*4)
832 nActualTimespan = nTargetTimespan*4;
833
834 // Retarget
835 CBigNum bnNew;
836 bnNew.SetCompact(pindexLast->nBits);
837 bnNew *= nActualTimespan;
838 bnNew /= nTargetTimespan;
839
840 if (bnNew > bnProofOfWorkLimit)
841 bnNew = bnProofOfWorkLimit;
842
843 /// debug print
844 printf("GetNextWorkRequired RETARGET\n");
845 printf("nTargetTimespan = %d nActualTimespan = %d\n", nTargetTimespan, nActualTimespan);
846 printf("Before: %08x %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
847 printf("After: %08x %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());
848
849 return bnNew.GetCompact();
850 }
851
852 vector<int> vStartingHeight;
853 void AddStartingHeight(int nStartingHeight)
854 {
855 if (nStartingHeight != -1)
856 {
857 vStartingHeight.push_back(nStartingHeight);
858 sort(vStartingHeight.begin(), vStartingHeight.end());
859 }
860 }
861
862 bool IsInitialBlockDownload()
863 {
864 int nMedian = 69000;
865 if (vStartingHeight.size() >= 5)
866 nMedian = vStartingHeight[vStartingHeight.size()/2];
867 return nBestHeight < nMedian-1000;
868 }
869
870
871
872
873
874
875
876
877 bool CTransaction::DisconnectInputs(CTxDB& txdb)
878 {
879 // Relinquish previous transactions' spent pointers
880 if (!IsCoinBase())
881 {
882 foreach(const CTxIn& txin, vin)
883 {
884 COutPoint prevout = txin.prevout;
885
886 // Get prev txindex from disk
887 CTxIndex txindex;
888 if (!txdb.ReadTxIndex(prevout.hash, txindex))
889 return error("DisconnectInputs() : ReadTxIndex failed");
890
891 if (prevout.n >= txindex.vSpent.size())
892 return error("DisconnectInputs() : prevout.n out of range");
893
894 // Mark outpoint as not spent
895 txindex.vSpent[prevout.n].SetNull();
896
897 // Write back
898 txdb.UpdateTxIndex(prevout.hash, txindex);
899 }
900 }
901
902 // Remove transaction from index
903 if (!txdb.EraseTxIndex(*this))
904 return error("DisconnectInputs() : EraseTxPos failed");
905
906 return true;
907 }
908
909
910 bool CTransaction::ConnectInputs(CTxDB& txdb, map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx, int nHeight, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee)
911 {
912 // Take over previous transactions' spent pointers
913 if (!IsCoinBase())
914 {
915 int64 nValueIn = 0;
916 for (int i = 0; i < vin.size(); i++)
917 {
918 COutPoint prevout = vin[i].prevout;
919
920 // Read txindex
921 CTxIndex txindex;
922 bool fFound = true;
923 if (fMiner && mapTestPool.count(prevout.hash))
924 {
925 // Get txindex from current proposed changes
926 txindex = mapTestPool[prevout.hash];
927 }
928 else
929 {
930 // Read txindex from txdb
931 fFound = txdb.ReadTxIndex(prevout.hash, txindex);
932 }
933 if (!fFound && (fBlock || fMiner))
934 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());
935
936 // Read txPrev
937 CTransaction txPrev;
938 if (!fFound || txindex.pos == CDiskTxPos(1,1,1))
939 {
940 // Get prev tx from single transactions in memory
941 CRITICAL_BLOCK(cs_mapTransactions)
942 {
943 if (!mapTransactions.count(prevout.hash))
944 return error("ConnectInputs() : %s mapTransactions prev not found %s", GetHash().ToString().substr(0,6).c_str(), prevout.hash.ToString().substr(0,6).c_str());
945 txPrev = mapTransactions[prevout.hash];
946 }
947 if (!fFound)
948 txindex.vSpent.resize(txPrev.vout.size());
949 }
950 else
951 {
952 // Get prev tx from disk
953 if (!txPrev.ReadFromDisk(txindex.pos))
954 return error("ConnectInputs() : %s ReadFromDisk prev tx %s failed", GetHash().ToString().substr(0,6).c_str(), prevout.hash.ToString().substr(0,6).c_str());
955 }
956
957 if (prevout.n >= txPrev.vout.size() || prevout.n >= txindex.vSpent.size())
958 return error("ConnectInputs() : %s prevout.n out of range %d %d %d prev tx %s\n%s", GetHash().ToString().substr(0,6).c_str(), prevout.n, txPrev.vout.size(), txindex.vSpent.size(), prevout.hash.ToString().substr(0,6).c_str(), txPrev.ToString().c_str());
959
960 // If prev is coinbase, check that it's matured
961 if (txPrev.IsCoinBase())
962 for (CBlockIndex* pindex = pindexBest; pindex && nBestHeight - pindex->nHeight < COINBASE_MATURITY-1; pindex = pindex->pprev)
963 if (pindex->nBlockPos == txindex.pos.nBlockPos && pindex->nFile == txindex.pos.nFile)
964 return error("ConnectInputs() : tried to spend coinbase at depth %d", nBestHeight - pindex->nHeight);
965
966 // Verify signature
967 if (!VerifySignature(txPrev, *this, i))
968 return error("ConnectInputs() : %s VerifySignature failed", GetHash().ToString().substr(0,6).c_str());
969
970 // Check for conflicts
971 if (!txindex.vSpent[prevout.n].IsNull())
972 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());
973
974 // Mark outpoints as spent
975 txindex.vSpent[prevout.n] = posThisTx;
976
977 // Write back
978 if (fBlock)
979 txdb.UpdateTxIndex(prevout.hash, txindex);
980 else if (fMiner)
981 mapTestPool[prevout.hash] = txindex;
982
983 nValueIn += txPrev.vout[prevout.n].nValue;
984 }
985
986 // Tally transaction fees
987 int64 nTxFee = nValueIn - GetValueOut();
988 if (nTxFee < 0)
989 return error("ConnectInputs() : %s nTxFee < 0", GetHash().ToString().substr(0,6).c_str());
990 if (nTxFee < nMinFee)
991 return false;
992 nFees += nTxFee;
993 }
994
995 if (fBlock)
996 {
997 // Add transaction to disk index
998 if (!txdb.AddTxIndex(*this, posThisTx, nHeight))
999 return error("ConnectInputs() : AddTxPos failed");
1000 }
1001 else if (fMiner)
1002 {
1003 // Add transaction to test pool
1004 mapTestPool[GetHash()] = CTxIndex(CDiskTxPos(1,1,1), vout.size());
1005 }
1006
1007 return true;
1008 }
1009
1010
1011 bool CTransaction::ClientConnectInputs()
1012 {
1013 if (IsCoinBase())
1014 return false;
1015
1016 // Take over previous transactions' spent pointers
1017 CRITICAL_BLOCK(cs_mapTransactions)
1018 {
1019 int64 nValueIn = 0;
1020 for (int i = 0; i < vin.size(); i++)
1021 {
1022 // Get prev tx from single transactions in memory
1023 COutPoint prevout = vin[i].prevout;
1024 if (!mapTransactions.count(prevout.hash))
1025 return false;
1026 CTransaction& txPrev = mapTransactions[prevout.hash];
1027
1028 if (prevout.n >= txPrev.vout.size())
1029 return false;
1030
1031 // Verify signature
1032 if (!VerifySignature(txPrev, *this, i))
1033 return error("ConnectInputs() : VerifySignature failed");
1034
1035 ///// this is redundant with the mapNextTx stuff, not sure which I want to get rid of
1036 ///// this has to go away now that posNext is gone
1037 // // Check for conflicts
1038 // if (!txPrev.vout[prevout.n].posNext.IsNull())
1039 // return error("ConnectInputs() : prev tx already used");
1040 //
1041 // // Flag outpoints as used
1042 // txPrev.vout[prevout.n].posNext = posThisTx;
1043
1044 nValueIn += txPrev.vout[prevout.n].nValue;
1045 }
1046 if (GetValueOut() > nValueIn)
1047 return false;
1048 }
1049
1050 return true;
1051 }
1052
1053
1054
1055
1056 bool CBlock::DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex)
1057 {
1058 // Disconnect in reverse order
1059 for (int i = vtx.size()-1; i >= 0; i--)
1060 if (!vtx[i].DisconnectInputs(txdb))
1061 return false;
1062
1063 // Update block index on disk without changing it in memory.
1064 // The memory index structure will be changed after the db commits.
1065 if (pindex->pprev)
1066 {
1067 CDiskBlockIndex blockindexPrev(pindex->pprev);
1068 blockindexPrev.hashNext = 0;
1069 txdb.WriteBlockIndex(blockindexPrev);
1070 }
1071
1072 return true;
1073 }
1074
1075 bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
1076 {
1077 //// issue here: it doesn't know the version
1078 unsigned int nTxPos = pindex->nBlockPos + ::GetSerializeSize(CBlock(), SER_DISK) - 1 + GetSizeOfCompactSize(vtx.size());
1079
1080 map<uint256, CTxIndex> mapUnused;
1081 int64 nFees = 0;
1082 foreach(CTransaction& tx, vtx)
1083 {
1084 CDiskTxPos posThisTx(pindex->nFile, pindex->nBlockPos, nTxPos);
1085 nTxPos += ::GetSerializeSize(tx, SER_DISK);
1086
1087 if (!tx.ConnectInputs(txdb, mapUnused, posThisTx, pindex->nHeight, nFees, true, false))
1088 return false;
1089 }
1090
1091 if (vtx[0].GetValueOut() > GetBlockValue(nFees))
1092 return false;
1093
1094 // Update block index on disk without changing it in memory.
1095 // The memory index structure will be changed after the db commits.
1096 if (pindex->pprev)
1097 {
1098 CDiskBlockIndex blockindexPrev(pindex->pprev);
1099 blockindexPrev.hashNext = pindex->GetBlockHash();
1100 txdb.WriteBlockIndex(blockindexPrev);
1101 }
1102
1103 // Watch for transactions paying to me
1104 foreach(CTransaction& tx, vtx)
1105 AddToWalletIfMine(tx, this);
1106
1107 return true;
1108 }
1109
1110
1111
1112 bool Reorganize(CTxDB& txdb, CBlockIndex* pindexNew)
1113 {
1114 printf("REORGANIZE\n");
1115
1116 // Find the fork
1117 CBlockIndex* pfork = pindexBest;
1118 CBlockIndex* plonger = pindexNew;
1119 while (pfork != plonger)
1120 {
1121 if (!(pfork = pfork->pprev))
1122 return error("Reorganize() : pfork->pprev is null");
1123 while (plonger->nHeight > pfork->nHeight)
1124 if (!(plonger = plonger->pprev))
1125 return error("Reorganize() : plonger->pprev is null");
1126 }
1127
1128 // List of what to disconnect
1129 vector<CBlockIndex*> vDisconnect;
1130 for (CBlockIndex* pindex = pindexBest; pindex != pfork; pindex = pindex->pprev)
1131 vDisconnect.push_back(pindex);
1132
1133 // List of what to connect
1134 vector<CBlockIndex*> vConnect;
1135 for (CBlockIndex* pindex = pindexNew; pindex != pfork; pindex = pindex->pprev)
1136 vConnect.push_back(pindex);
1137 reverse(vConnect.begin(), vConnect.end());
1138
1139 // Disconnect shorter branch
1140 vector<CTransaction> vResurrect;
1141 foreach(CBlockIndex* pindex, vDisconnect)
1142 {
1143 CBlock block;
1144 if (!block.ReadFromDisk(pindex->nFile, pindex->nBlockPos))
1145 return error("Reorganize() : ReadFromDisk for disconnect failed");
1146 if (!block.DisconnectBlock(txdb, pindex))
1147 return error("Reorganize() : DisconnectBlock failed");
1148
1149 // Queue memory transactions to resurrect
1150 foreach(const CTransaction& tx, block.vtx)
1151 if (!tx.IsCoinBase())
1152 vResurrect.push_back(tx);
1153 }
1154
1155 // Connect longer branch
1156 vector<CTransaction> vDelete;
1157 for (int i = 0; i < vConnect.size(); i++)
1158 {
1159 CBlockIndex* pindex = vConnect[i];
1160 CBlock block;
1161 if (!block.ReadFromDisk(pindex->nFile, pindex->nBlockPos))
1162 return error("Reorganize() : ReadFromDisk for connect failed");
1163 if (!block.ConnectBlock(txdb, pindex))
1164 {
1165 // Invalid block, delete the rest of this branch
1166 txdb.TxnAbort();
1167 for (int j = i; j < vConnect.size(); j++)
1168 {
1169 CBlockIndex* pindex = vConnect[j];
1170 pindex->EraseBlockFromDisk();
1171 txdb.EraseBlockIndex(pindex->GetBlockHash());
1172 mapBlockIndex.erase(pindex->GetBlockHash());
1173 delete pindex;
1174 }
1175 return error("Reorganize() : ConnectBlock failed");
1176 }
1177
1178 // Queue memory transactions to delete
1179 foreach(const CTransaction& tx, block.vtx)
1180 vDelete.push_back(tx);
1181 }
1182 if (!txdb.WriteHashBestChain(pindexNew->GetBlockHash()))
1183 return error("Reorganize() : WriteHashBestChain failed");
1184
1185 // Commit now because resurrecting could take some time
1186 txdb.TxnCommit();
1187
1188 // Disconnect shorter branch
1189 foreach(CBlockIndex* pindex, vDisconnect)
1190 if (pindex->pprev)
1191 pindex->pprev->pnext = NULL;
1192
1193 // Connect longer branch
1194 foreach(CBlockIndex* pindex, vConnect)
1195 if (pindex->pprev)
1196 pindex->pprev->pnext = pindex;
1197
1198 // Resurrect memory transactions that were in the disconnected branch
1199 foreach(CTransaction& tx, vResurrect)
1200 tx.AcceptTransaction(txdb, false);
1201
1202 // Delete redundant memory transactions that are in the connected branch
1203 foreach(CTransaction& tx, vDelete)
1204 tx.RemoveFromMemoryPool();
1205
1206 return true;
1207 }
1208
1209
1210 bool CBlock::AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos)
1211 {
1212 // Check for duplicate
1213 uint256 hash = GetHash();
1214 if (mapBlockIndex.count(hash))
1215 return error("AddToBlockIndex() : %s already exists", hash.ToString().substr(0,16).c_str());
1216
1217 // Construct new block index object
1218 CBlockIndex* pindexNew = new CBlockIndex(nFile, nBlockPos, *this);
1219 if (!pindexNew)
1220 return error("AddToBlockIndex() : new CBlockIndex failed");
1221 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
1222 pindexNew->phashBlock = &((*mi).first);
1223 map<uint256, CBlockIndex*>::iterator miPrev = mapBlockIndex.find(hashPrevBlock);
1224 if (miPrev != mapBlockIndex.end())
1225 {
1226 pindexNew->pprev = (*miPrev).second;
1227 pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
1228 }
1229 pindexNew->bnChainWork = (pindexNew->pprev ? pindexNew->pprev->bnChainWork : 0) + pindexNew->GetBlockWork();
1230
1231 CTxDB txdb;
1232 txdb.TxnBegin();
1233 txdb.WriteBlockIndex(CDiskBlockIndex(pindexNew));
1234
1235 // New best
1236 if (pindexNew->bnChainWork > bnBestChainWork)
1237 {
1238 if (pindexGenesisBlock == NULL && hash == hashGenesisBlock)
1239 {
1240 pindexGenesisBlock = pindexNew;
1241 txdb.WriteHashBestChain(hash);
1242 }
1243 else if (hashPrevBlock == hashBestChain)
1244 {
1245 // Adding to current best branch
1246 if (!ConnectBlock(txdb, pindexNew) || !txdb.WriteHashBestChain(hash))
1247 {
1248 txdb.TxnAbort();
1249 pindexNew->EraseBlockFromDisk();
1250 mapBlockIndex.erase(pindexNew->GetBlockHash());
1251 delete pindexNew;
1252 return error("AddToBlockIndex() : ConnectBlock failed");
1253 }
1254 txdb.TxnCommit();
1255 pindexNew->pprev->pnext = pindexNew;
1256
1257 // Delete redundant memory transactions
1258 foreach(CTransaction& tx, vtx)
1259 tx.RemoveFromMemoryPool();
1260 }
1261 else
1262 {
1263 // New best branch
1264 if (!Reorganize(txdb, pindexNew))
1265 {
1266 txdb.TxnAbort();
1267 return error("AddToBlockIndex() : Reorganize failed");
1268 }
1269 }
1270
1271 // New best block
1272 hashBestChain = hash;
1273 pindexBest = pindexNew;
1274 nBestHeight = pindexBest->nHeight;
1275 bnBestChainWork = pindexNew->bnChainWork;
1276 nTimeBestReceived = GetTime();
1277 nTransactionsUpdated++;
1278 printf("AddToBlockIndex: new best=%s height=%d\n", hashBestChain.ToString().substr(0,16).c_str(), nBestHeight);
1279 }
1280
1281 txdb.TxnCommit();
1282 txdb.Close();
1283
1284 if (pindexNew == pindexBest)
1285 {
1286 // Notify UI to display prev block's coinbase if it was ours
1287 static uint256 hashPrevBestCoinBase;
1288 CRITICAL_BLOCK(cs_mapWallet)
1289 vWalletUpdated.push_back(hashPrevBestCoinBase);
1290 hashPrevBestCoinBase = vtx[0].GetHash();
1291 }
1292
1293 MainFrameRepaint();
1294 return true;
1295 }
1296
1297
1298
1299
1300 bool CBlock::CheckBlock() const
1301 {
1302 // These are checks that are independent of context
1303 // that can be verified before saving an orphan block.
1304
1305 // Size limits
1306 if (vtx.empty() || vtx.size() > MAX_SIZE || ::GetSerializeSize(*this, SER_DISK) > MAX_SIZE)
1307 return error("CheckBlock() : size limits failed");
1308
1309 // Check timestamp
1310 if (nTime > GetAdjustedTime() + 2 * 60 * 60)
1311 return error("CheckBlock() : block timestamp too far in the future");
1312
1313 // First transaction must be coinbase, the rest must not be
1314 if (vtx.empty() || !vtx[0].IsCoinBase())
1315 return error("CheckBlock() : first tx is not coinbase");
1316 for (int i = 1; i < vtx.size(); i++)
1317 if (vtx[i].IsCoinBase())
1318 return error("CheckBlock() : more than one coinbase");
1319
1320 // Check transactions
1321 foreach(const CTransaction& tx, vtx)
1322 if (!tx.CheckTransaction())
1323 return error("CheckBlock() : CheckTransaction failed");
1324
1325 // Check proof of work matches claimed amount
1326 if (CBigNum().SetCompact(nBits) > bnProofOfWorkLimit)
1327 return error("CheckBlock() : nBits below minimum work");
1328 if (GetHash() > CBigNum().SetCompact(nBits).getuint256())
1329 return error("CheckBlock() : hash doesn't match nBits");
1330
1331 // Check merkleroot
1332 if (hashMerkleRoot != BuildMerkleTree())
1333 return error("CheckBlock() : hashMerkleRoot mismatch");
1334
1335 return true;
1336 }
1337
1338 bool CBlock::AcceptBlock()
1339 {
1340 // Check for duplicate
1341 uint256 hash = GetHash();
1342 if (mapBlockIndex.count(hash))
1343 return error("AcceptBlock() : block already in mapBlockIndex");
1344
1345 // Get prev block index
1346 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashPrevBlock);
1347 if (mi == mapBlockIndex.end())
1348 return error("AcceptBlock() : prev block not found");
1349 CBlockIndex* pindexPrev = (*mi).second;
1350
1351 // Check timestamp against prev
1352 if (nTime <= pindexPrev->GetMedianTimePast())
1353 return error("AcceptBlock() : block's timestamp is too early");
1354
1355 // Check that all transactions are finalized
1356 foreach(const CTransaction& tx, vtx)
1357 if (!tx.IsFinal(nTime))
1358 return error("AcceptBlock() : contains a non-final transaction");
1359
1360 // Check proof of work
1361 if (nBits != GetNextWorkRequired(pindexPrev))
1362 return error("AcceptBlock() : incorrect proof of work");
1363
1364 // Check that the block chain matches the known block chain up to a checkpoint
1365 if (pindexPrev->nHeight+1 == 11111 && hash != uint256("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
1366 return error("AcceptBlock() : rejected by checkpoint lockin at 11111");
1367 if (pindexPrev->nHeight+1 == 33333 && hash != uint256("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
1368 return error("AcceptBlock() : rejected by checkpoint lockin at 33333");
1369 if (pindexPrev->nHeight+1 == 68555 && hash != uint256("0x00000000001e1b4903550a0b96e9a9405c8a95f387162e4944e8d9fbe501cd6a"))
1370 return error("AcceptBlock() : rejected by checkpoint lockin at 68555");
1371
1372 // Write block to history file
1373 if (!CheckDiskSpace(::GetSerializeSize(*this, SER_DISK)))
1374 return error("AcceptBlock() : out of disk space");
1375 unsigned int nFile;
1376 unsigned int nBlockPos;
1377 if (!WriteToDisk(!fClient, nFile, nBlockPos))
1378 return error("AcceptBlock() : WriteToDisk failed");
1379 if (!AddToBlockIndex(nFile, nBlockPos))
1380 return error("AcceptBlock() : AddToBlockIndex failed");
1381
1382 // Relay inventory, but don't relay old inventory during initial block download
1383 if (hashBestChain == hash)
1384 CRITICAL_BLOCK(cs_vNodes)
1385 foreach(CNode* pnode, vNodes)
1386 if (nBestHeight > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : 55000))
1387 pnode->PushInventory(CInv(MSG_BLOCK, hash));
1388
1389 return true;
1390 }
1391
1392 bool ProcessBlock(CNode* pfrom, CBlock* pblock)
1393 {
1394 // Check for duplicate
1395 uint256 hash = pblock->GetHash();
1396 if (mapBlockIndex.count(hash))
1397 return error("ProcessBlock() : already have block %d %s", mapBlockIndex[hash]->nHeight, hash.ToString().substr(0,16).c_str());
1398 if (mapOrphanBlocks.count(hash))
1399 return error("ProcessBlock() : already have block (orphan) %s", hash.ToString().substr(0,16).c_str());
1400
1401 // Preliminary checks
1402 if (!pblock->CheckBlock())
1403 {
1404 delete pblock;
1405 return error("ProcessBlock() : CheckBlock FAILED");
1406 }
1407
1408 // If don't already have its previous block, shunt it off to holding area until we get it
1409 if (!mapBlockIndex.count(pblock->hashPrevBlock))
1410 {
1411 printf("ProcessBlock: ORPHAN BLOCK, prev=%s\n", pblock->hashPrevBlock.ToString().substr(0,16).c_str());
1412 mapOrphanBlocks.insert(make_pair(hash, pblock));
1413 mapOrphanBlocksByPrev.insert(make_pair(pblock->hashPrevBlock, pblock));
1414
1415 // Ask this guy to fill in what we're missing
1416 if (pfrom)
1417 pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(pblock));
1418 return true;
1419 }
1420
1421 // Store to disk
1422 if (!pblock->AcceptBlock())
1423 {
1424 delete pblock;
1425 return error("ProcessBlock() : AcceptBlock FAILED");
1426 }
1427 delete pblock;
1428
1429 // Recursively process any orphan blocks that depended on this one
1430 vector<uint256> vWorkQueue;
1431 vWorkQueue.push_back(hash);
1432 for (int i = 0; i < vWorkQueue.size(); i++)
1433 {
1434 uint256 hashPrev = vWorkQueue[i];
1435 for (multimap<uint256, CBlock*>::iterator mi = mapOrphanBlocksByPrev.lower_bound(hashPrev);
1436 mi != mapOrphanBlocksByPrev.upper_bound(hashPrev);
1437 ++mi)
1438 {
1439 CBlock* pblockOrphan = (*mi).second;
1440 if (pblockOrphan->AcceptBlock())
1441 vWorkQueue.push_back(pblockOrphan->GetHash());
1442 mapOrphanBlocks.erase(pblockOrphan->GetHash());
1443 delete pblockOrphan;
1444 }
1445 mapOrphanBlocksByPrev.erase(hashPrev);
1446 }
1447
1448 printf("ProcessBlock: ACCEPTED\n");
1449 return true;
1450 }
1451
1452
1453
1454
1455
1456
1457
1458
1459 template<typename Stream>
1460 bool ScanMessageStart(Stream& s)
1461 {
1462 // Scan ahead to the next pchMessageStart, which should normally be immediately
1463 // at the file pointer. Leaves file pointer at end of pchMessageStart.
1464 s.clear(0);
1465 short prevmask = s.exceptions(0);
1466 const char* p = BEGIN(pchMessageStart);
1467 try
1468 {
1469 loop
1470 {
1471 char c;
1472 s.read(&c, 1);
1473 if (s.fail())
1474 {
1475 s.clear(0);
1476 s.exceptions(prevmask);
1477 return false;
1478 }
1479 if (*p != c)
1480 p = BEGIN(pchMessageStart);
1481 if (*p == c)
1482 {
1483 if (++p == END(pchMessageStart))
1484 {
1485 s.clear(0);
1486 s.exceptions(prevmask);
1487 return true;
1488 }
1489 }
1490 }
1491 }
1492 catch (...)
1493 {
1494 s.clear(0);
1495 s.exceptions(prevmask);
1496 return false;
1497 }
1498 }
1499
1500 bool CheckDiskSpace(int64 nAdditionalBytes)
1501 {
1502 uint64 nFreeBytesAvailable = filesystem::space(GetDataDir()).available;
1503
1504 // Check for 15MB because database could create another 10MB log file at any time
1505 if (nFreeBytesAvailable < (int64)15000000 + nAdditionalBytes)
1506 {
1507 fShutdown = true;
1508 printf("*** %s***\n", _("Warning: Disk space is low "));
1509 #if wxUSE_GUI
1510 ThreadSafeMessageBox(_("Warning: Disk space is low "), "Bitcoin", wxOK | wxICON_EXCLAMATION);
1511 #endif
1512 CreateThread(Shutdown, NULL);
1513 return false;
1514 }
1515 return true;
1516 }
1517
1518 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode)
1519 {
1520 if (nFile == -1)
1521 return NULL;
1522 FILE* file = fopen(strprintf("%s/blk%04d.dat", GetDataDir().c_str(), nFile).c_str(), pszMode);
1523 if (!file)
1524 return NULL;
1525 if (nBlockPos != 0 && !strchr(pszMode, 'a') && !strchr(pszMode, 'w'))
1526 {
1527 if (fseek(file, nBlockPos, SEEK_SET) != 0)
1528 {
1529 fclose(file);
1530 return NULL;
1531 }
1532 }
1533 return file;
1534 }
1535
1536 static unsigned int nCurrentBlockFile = 1;
1537
1538 FILE* AppendBlockFile(unsigned int& nFileRet)
1539 {
1540 nFileRet = 0;
1541 loop
1542 {
1543 FILE* file = OpenBlockFile(nCurrentBlockFile, 0, "ab");
1544 if (!file)
1545 return NULL;
1546 if (fseek(file, 0, SEEK_END) != 0)
1547 return NULL;
1548 // FAT32 filesize max 4GB, fseek and ftell max 2GB, so we must stay under 2GB
1549 if (ftell(file) < 0x7F000000 - MAX_SIZE)
1550 {
1551 nFileRet = nCurrentBlockFile;
1552 return file;
1553 }
1554 fclose(file);
1555 nCurrentBlockFile++;
1556 }
1557 }
1558
1559 bool LoadBlockIndex(bool fAllowNew)
1560 {
1561 //
1562 // Load block index
1563 //
1564 CTxDB txdb("cr");
1565 if (!txdb.LoadBlockIndex())
1566 return false;
1567 txdb.Close();
1568
1569 //
1570 // Init with genesis block
1571 //
1572 if (mapBlockIndex.empty())
1573 {
1574 if (!fAllowNew)
1575 return false;
1576
1577
1578 // Genesis Block:
1579 // GetHash() = 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
1580 // hashMerkleRoot = 0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
1581 // txNew.vin[0].scriptSig = 486604799 4 0x736B6E616220726F662074756F6C69616220646E6F63657320666F206B6E697262206E6F20726F6C6C65636E61684320393030322F6E614A2F33302073656D695420656854
1582 // txNew.vout[0].nValue = 5000000000
1583 // txNew.vout[0].scriptPubKey = 0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704 OP_CHECKSIG
1584 // block.nVersion = 1
1585 // block.nTime = 1231006505
1586 // block.nBits = 0x1d00ffff
1587 // block.nNonce = 2083236893
1588 // CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
1589 // CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
1590 // CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
1591 // CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
1592 // vMerkleTree: 4a5e1e
1593
1594 // Genesis block
1595 const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
1596 CTransaction txNew;
1597 txNew.vin.resize(1);
1598 txNew.vout.resize(1);
1599 txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
1600 txNew.vout[0].nValue = 50 * COIN;
1601 CBigNum bnPubKey;
1602 bnPubKey.SetHex("0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704");
1603 txNew.vout[0].scriptPubKey = CScript() << bnPubKey << OP_CHECKSIG;
1604 CBlock block;
1605 block.vtx.push_back(txNew);
1606 block.hashPrevBlock = 0;
1607 block.hashMerkleRoot = block.BuildMerkleTree();
1608 block.nVersion = 1;
1609 block.nTime = 1231006505;
1610 block.nBits = 0x1d00ffff;
1611 block.nNonce = 2083236893;
1612
1613 //// debug print
1614 printf("%s\n", block.GetHash().ToString().c_str());
1615 printf("%s\n", block.hashMerkleRoot.ToString().c_str());
1616 printf("%s\n", hashGenesisBlock.ToString().c_str());
1617 txNew.vout[0].scriptPubKey.print();
1618 block.print();
1619 assert(block.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
1620
1621 assert(block.GetHash() == hashGenesisBlock);
1622
1623 // Start new block file
1624 unsigned int nFile;
1625 unsigned int nBlockPos;
1626 if (!block.WriteToDisk(!fClient, nFile, nBlockPos))
1627 return error("LoadBlockIndex() : writing genesis block to disk failed");
1628 if (!block.AddToBlockIndex(nFile, nBlockPos))
1629 return error("LoadBlockIndex() : genesis block not accepted");
1630 }
1631
1632 return true;
1633 }
1634
1635
1636
1637 void PrintBlockTree()
1638 {
1639 // precompute tree structure
1640 map<CBlockIndex*, vector<CBlockIndex*> > mapNext;
1641 for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
1642 {
1643 CBlockIndex* pindex = (*mi).second;
1644 mapNext[pindex->pprev].push_back(pindex);
1645 // test
1646 //while (rand() % 3 == 0)
1647 // mapNext[pindex->pprev].push_back(pindex);
1648 }
1649
1650 vector<pair<int, CBlockIndex*> > vStack;
1651 vStack.push_back(make_pair(0, pindexGenesisBlock));
1652
1653 int nPrevCol = 0;
1654 while (!vStack.empty())
1655 {
1656 int nCol = vStack.back().first;
1657 CBlockIndex* pindex = vStack.back().second;
1658 vStack.pop_back();
1659
1660 // print split or gap
1661 if (nCol > nPrevCol)
1662 {
1663 for (int i = 0; i < nCol-1; i++)
1664 printf("| ");
1665 printf("|\\\n");
1666 }
1667 else if (nCol < nPrevCol)
1668 {
1669 for (int i = 0; i < nCol; i++)
1670 printf("| ");
1671 printf("|\n");
1672 }
1673 nPrevCol = nCol;
1674
1675 // print columns
1676 for (int i = 0; i < nCol; i++)
1677 printf("| ");
1678
1679 // print item
1680 CBlock block;
1681 block.ReadFromDisk(pindex);
1682 printf("%d (%u,%u) %s %s tx %d",
1683 pindex->nHeight,
1684 pindex->nFile,
1685 pindex->nBlockPos,
1686 block.GetHash().ToString().substr(0,16).c_str(),
1687 DateTimeStrFormat("%x %H:%M:%S", block.nTime).c_str(),
1688 block.vtx.size());
1689
1690 CRITICAL_BLOCK(cs_mapWallet)
1691 {
1692 if (mapWallet.count(block.vtx[0].GetHash()))
1693 {
1694 CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
1695 printf(" mine: %d %d %d", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
1696 }
1697 }
1698 printf("\n");
1699
1700
1701 // put the main timechain first
1702 vector<CBlockIndex*>& vNext = mapNext[pindex];
1703 for (int i = 0; i < vNext.size(); i++)
1704 {
1705 if (vNext[i]->pnext)
1706 {
1707 swap(vNext[0], vNext[i]);
1708 break;
1709 }
1710 }
1711
1712 // iterate children
1713 for (int i = 0; i < vNext.size(); i++)
1714 vStack.push_back(make_pair(nCol+i, vNext[i]));
1715 }
1716 }
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727 //////////////////////////////////////////////////////////////////////////////
1728 //
1729 // Messages
1730 //
1731
1732
1733 bool AlreadyHave(CTxDB& txdb, const CInv& inv)
1734 {
1735 switch (inv.type)
1736 {
1737 case MSG_TX: return mapTransactions.count(inv.hash) || txdb.ContainsTx(inv.hash);
1738 case MSG_BLOCK: return mapBlockIndex.count(inv.hash) || mapOrphanBlocks.count(inv.hash);
1739 }
1740 // Don't know what it is, just say we already got one
1741 return true;
1742 }
1743
1744
1745
1746
1747
1748
1749
1750 bool ProcessMessages(CNode* pfrom)
1751 {
1752 CDataStream& vRecv = pfrom->vRecv;
1753 if (vRecv.empty())
1754 return true;
1755 //if (fDebug)
1756 // printf("ProcessMessages(%d bytes)\n", vRecv.size());
1757
1758 //
1759 // Message format
1760 // (4) message start
1761 // (12) command
1762 // (4) size
1763 // (4) checksum
1764 // (x) data
1765 //
1766
1767 loop
1768 {
1769 // Scan for message start
1770 CDataStream::iterator pstart = search(vRecv.begin(), vRecv.end(), BEGIN(pchMessageStart), END(pchMessageStart));
1771 int nHeaderSize = vRecv.GetSerializeSize(CMessageHeader());
1772 if (vRecv.end() - pstart < nHeaderSize)
1773 {
1774 if (vRecv.size() > nHeaderSize)
1775 {
1776 printf("\n\nPROCESSMESSAGE MESSAGESTART NOT FOUND\n\n");
1777 vRecv.erase(vRecv.begin(), vRecv.end() - nHeaderSize);
1778 }
1779 break;
1780 }
1781 if (pstart - vRecv.begin() > 0)
1782 printf("\n\nPROCESSMESSAGE SKIPPED %d BYTES\n\n", pstart - vRecv.begin());
1783 vRecv.erase(vRecv.begin(), pstart);
1784
1785 // Read header
1786 vector<char> vHeaderSave(vRecv.begin(), vRecv.begin() + nHeaderSize);
1787 CMessageHeader hdr;
1788 vRecv >> hdr;
1789 if (!hdr.IsValid())
1790 {
1791 printf("\n\nPROCESSMESSAGE: ERRORS IN HEADER %s\n\n\n", hdr.GetCommand().c_str());
1792 continue;
1793 }
1794 string strCommand = hdr.GetCommand();
1795
1796 // Message size
1797 unsigned int nMessageSize = hdr.nMessageSize;
1798 if (nMessageSize > vRecv.size())
1799 {
1800 // Rewind and wait for rest of message
1801 ///// need a mechanism to give up waiting for overlong message size error
1802 vRecv.insert(vRecv.begin(), vHeaderSave.begin(), vHeaderSave.end());
1803 break;
1804 }
1805
1806 // Copy message to its own buffer
1807 CDataStream vMsg(vRecv.begin(), vRecv.begin() + nMessageSize, vRecv.nType, vRecv.nVersion);
1808 vRecv.ignore(nMessageSize);
1809
1810 // Checksum
1811 if (vRecv.GetVersion() >= 209)
1812 {
1813 uint256 hash = Hash(vMsg.begin(), vMsg.end());
1814 unsigned int nChecksum = 0;
1815 memcpy(&nChecksum, &hash, sizeof(nChecksum));
1816 if (nChecksum != hdr.nChecksum)
1817 {
1818 printf("ProcessMessage(%s, %d bytes) : CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n",
1819 strCommand.c_str(), nMessageSize, nChecksum, hdr.nChecksum);
1820 continue;
1821 }
1822 }
1823
1824 // Process message
1825 bool fRet = false;
1826 try
1827 {
1828 CRITICAL_BLOCK(cs_main)
1829 fRet = ProcessMessage(pfrom, strCommand, vMsg);
1830 if (fShutdown)
1831 return true;
1832 }
1833 catch (std::ios_base::failure& e)
1834 {
1835 if (strstr(e.what(), "CDataStream::read() : end of data"))
1836 {
1837 // Allow exceptions from underlength message on vRecv
1838 printf("ProcessMessage(%s, %d bytes) : Exception '%s' caught, normally caused by a message being shorter than its stated length\n", strCommand.c_str(), nMessageSize, e.what());
1839 }
1840 else if (strstr(e.what(), ": size too large"))
1841 {
1842 // Allow exceptions from overlong size
1843 printf("ProcessMessage(%s, %d bytes) : Exception '%s' caught\n", strCommand.c_str(), nMessageSize, e.what());
1844 }
1845 else
1846 {
1847 PrintException(&e, "ProcessMessage()");
1848 }
1849 }
1850 catch (std::exception& e) {
1851 PrintException(&e, "ProcessMessage()");
1852 } catch (...) {
1853 PrintException(NULL, "ProcessMessage()");
1854 }
1855
1856 if (!fRet)
1857 printf("ProcessMessage(%s, %d bytes) FAILED\n", strCommand.c_str(), nMessageSize);
1858 }
1859
1860 vRecv.Compact();
1861 return true;
1862 }
1863
1864
1865
1866
1867 bool ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
1868 {
1869 static map<unsigned int, vector<unsigned char> > mapReuseKey;
1870 RandAddSeedPerfmon();
1871 if (fDebug)
1872 printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
1873 printf("received: %s (%d bytes)\n", strCommand.c_str(), vRecv.size());
1874 if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
1875 {
1876 printf("dropmessagestest DROPPING RECV MESSAGE\n");
1877 return true;
1878 }
1879
1880
1881
1882
1883
1884 if (strCommand == "version")
1885 {
1886 // Each connection can only send one version message
1887 if (pfrom->nVersion != 0)
1888 return false;
1889
1890 int64 nTime;
1891 CAddress addrMe;
1892 CAddress addrFrom;
1893 uint64 nNonce = 1;
1894 string strSubVer;
1895 vRecv >> pfrom->nVersion >> pfrom->nServices >> nTime >> addrMe;
1896 if (pfrom->nVersion == 10300)
1897 pfrom->nVersion = 300;
1898 if (pfrom->nVersion >= 106 && !vRecv.empty())
1899 vRecv >> addrFrom >> nNonce;
1900 if (pfrom->nVersion >= 106 && !vRecv.empty())
1901 vRecv >> strSubVer;
1902 if (pfrom->nVersion >= 209 && !vRecv.empty())
1903 vRecv >> pfrom->nStartingHeight;
1904
1905 if (pfrom->nVersion == 0)
1906 return false;
1907
1908 // Disconnect if we connected to ourself
1909 if (nNonce == nLocalHostNonce && nNonce > 1)
1910 {
1911 pfrom->fDisconnect = true;
1912 return true;
1913 }
1914
1915 pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
1916 if (pfrom->fClient)
1917 {
1918 pfrom->vSend.nType |= SER_BLOCKHEADERONLY;
1919 pfrom->vRecv.nType |= SER_BLOCKHEADERONLY;
1920 }
1921
1922 AddTimeData(pfrom->addr.ip, nTime);
1923 AddStartingHeight(pfrom->nStartingHeight);
1924
1925 // Change version
1926 if (pfrom->nVersion >= 209)
1927 pfrom->PushMessage("verack");
1928 pfrom->vSend.SetVersion(min(pfrom->nVersion, VERSION));
1929 if (pfrom->nVersion < 209)
1930 pfrom->vRecv.SetVersion(min(pfrom->nVersion, VERSION));
1931
1932 // Ask the first connected node for block updates
1933 static int nAskedForBlocks;
1934 if (!pfrom->fClient && (nAskedForBlocks < 1 || vNodes.size() <= 1))
1935 {
1936 nAskedForBlocks++;
1937 pfrom->PushGetBlocks(pindexBest, uint256(0));
1938 }
1939
1940 pfrom->fSuccessfullyConnected = true;
1941
1942 printf("version message: version %d, blocks=%d\n", pfrom->nVersion, pfrom->nStartingHeight);
1943 }
1944
1945
1946 else if (pfrom->nVersion == 0)
1947 {
1948 // Must have a version message before anything else
1949 return false;
1950 }
1951
1952
1953 else if (strCommand == "verack")
1954 {
1955 pfrom->vRecv.SetVersion(min(pfrom->nVersion, VERSION));
1956 }
1957
1958
1959 else if (strCommand == "addr")
1960 {
1961 vector<CAddress> vAddr;
1962 vRecv >> vAddr;
1963 if (pfrom->nVersion < 200) // don't want addresses from 0.1.5
1964 return true;
1965 if (pfrom->nVersion < 209 && mapAddresses.size() > 1000) // don't want addr from 0.2.0 unless seeding
1966 return true;
1967 if (vAddr.size() > 1000)
1968 return error("message addr size() = %d", vAddr.size());
1969
1970 // Store the new addresses
1971 foreach(CAddress& addr, vAddr)
1972 {
1973 if (fShutdown)
1974 return true;
1975 // ignore IPv6 for now, since it isn't implemented anyway
1976 if (!addr.IsIPv4())
1977 continue;
1978 addr.nTime = GetAdjustedTime() - 2 * 60 * 60;
1979 if (pfrom->fGetAddr || vAddr.size() > 10)
1980 addr.nTime -= 5 * 24 * 60 * 60;
1981 AddAddress(addr);
1982 pfrom->AddAddressKnown(addr);
1983 if (!pfrom->fGetAddr && addr.IsRoutable())
1984 {
1985 // Relay to a limited number of other nodes
1986 CRITICAL_BLOCK(cs_vNodes)
1987 {
1988 // Use deterministic randomness to send to
1989 // the same places for 12 hours at a time
1990 static uint256 hashSalt;
1991 if (hashSalt == 0)
1992 RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
1993 uint256 hashRand = addr.ip ^ ((GetTime()+addr.ip)/(12*60*60)) ^ hashSalt;
1994 multimap<uint256, CNode*> mapMix;
1995 foreach(CNode* pnode, vNodes)
1996 mapMix.insert(make_pair(hashRand = Hash(BEGIN(hashRand), END(hashRand)), pnode));
1997 int nRelayNodes = 4;
1998 for (multimap<uint256, CNode*>::iterator mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
1999 ((*mi).second)->PushAddress(addr);
2000 }
2001 }
2002 }
2003 if (vAddr.size() < 1000)
2004 pfrom->fGetAddr = false;
2005 }
2006
2007
2008 else if (strCommand == "inv")
2009 {
2010 vector<CInv> vInv;
2011 vRecv >> vInv;
2012 if (vInv.size() > 50000)
2013 return error("message inv size() = %d", vInv.size());
2014
2015 CTxDB txdb("r");
2016 foreach(const CInv& inv, vInv)
2017 {
2018 if (fShutdown)
2019 return true;
2020 pfrom->AddInventoryKnown(inv);
2021
2022 bool fAlreadyHave = AlreadyHave(txdb, inv);
2023 printf(" got inventory: %s %s\n", inv.ToString().c_str(), fAlreadyHave ? "have" : "new");
2024
2025 if (!fAlreadyHave)
2026 pfrom->AskFor(inv);
2027 else if (inv.type == MSG_BLOCK && mapOrphanBlocks.count(inv.hash))
2028 pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(mapOrphanBlocks[inv.hash]));
2029
2030 // Track requests for our stuff
2031 CRITICAL_BLOCK(cs_mapRequestCount)
2032 {
2033 map<uint256, int>::iterator mi = mapRequestCount.find(inv.hash);
2034 if (mi != mapRequestCount.end())
2035 (*mi).second++;
2036 }
2037 }
2038 }
2039
2040
2041 else if (strCommand == "getdata")
2042 {
2043 vector<CInv> vInv;
2044 vRecv >> vInv;
2045 if (vInv.size() > 50000)
2046 return error("message getdata size() = %d", vInv.size());
2047
2048 foreach(const CInv& inv, vInv)
2049 {
2050 if (fShutdown)
2051 return true;
2052 printf("received getdata for: %s\n", inv.ToString().c_str());
2053
2054 if (inv.type == MSG_BLOCK)
2055 {
2056 // Send block from disk
2057 map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(inv.hash);
2058 if (mi != mapBlockIndex.end())
2059 {
2060 //// could optimize this to send header straight from blockindex for client
2061 CBlock block;
2062 block.ReadFromDisk((*mi).second, !pfrom->fClient);
2063 pfrom->PushMessage("block", block);
2064
2065 // Trigger them to send a getblocks request for the next batch of inventory
2066 if (inv.hash == pfrom->hashContinue)
2067 {
2068 // Bypass PushInventory, this must send even if redundant,
2069 // and we want it right after the last block so they don't
2070 // wait for other stuff first.
2071 vector<CInv> vInv;
2072 vInv.push_back(CInv(MSG_BLOCK, hashBestChain));
2073 pfrom->PushMessage("inv", vInv);
2074 pfrom->hashContinue = 0;
2075 }
2076 }
2077 }
2078 else if (inv.IsKnownType())
2079 {
2080 // Send stream from relay memory
2081 CRITICAL_BLOCK(cs_mapRelay)
2082 {
2083 map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
2084 if (mi != mapRelay.end())
2085 pfrom->PushMessage(inv.GetCommand(), (*mi).second);
2086 }
2087 }
2088
2089 // Track requests for our stuff
2090 CRITICAL_BLOCK(cs_mapRequestCount)
2091 {
2092 map<uint256, int>::iterator mi = mapRequestCount.find(inv.hash);
2093 if (mi != mapRequestCount.end())
2094 (*mi).second++;
2095 }
2096 }
2097 }
2098
2099
2100 else if (strCommand == "getblocks")
2101 {
2102 CBlockLocator locator;
2103 uint256 hashStop;
2104 vRecv >> locator >> hashStop;
2105
2106 // Find the first block the caller has in the main chain
2107 CBlockIndex* pindex = locator.GetBlockIndex();
2108
2109 // Send the rest of the chain
2110 if (pindex)
2111 pindex = pindex->pnext;
2112 int nLimit = 500 + locator.GetDistanceBack();
2113 printf("getblocks %d to %s limit %d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,16).c_str(), nLimit);
2114 for (; pindex; pindex = pindex->pnext)
2115 {
2116 if (pindex->GetBlockHash() == hashStop)
2117 {
2118 printf(" getblocks stopping at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,16).c_str());
2119 break;
2120 }
2121 pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
2122 if (--nLimit <= 0)
2123 {
2124 // When this block is requested, we'll send an inv that'll make them
2125 // getblocks the next batch of inventory.
2126 printf(" getblocks stopping at limit %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,16).c_str());
2127 pfrom->hashContinue = pindex->GetBlockHash();
2128 break;
2129 }
2130 }
2131 }
2132
2133
2134 else if (strCommand == "tx")
2135 {
2136 vector<uint256> vWorkQueue;
2137 CDataStream vMsg(vRecv);
2138 CTransaction tx;
2139 vRecv >> tx;
2140
2141 CInv inv(MSG_TX, tx.GetHash());
2142 pfrom->AddInventoryKnown(inv);
2143
2144 bool fMissingInputs = false;
2145 if (tx.AcceptTransaction(true, &fMissingInputs))
2146 {
2147 AddToWalletIfMine(tx, NULL);
2148 RelayMessage(inv, vMsg);
2149 mapAlreadyAskedFor.erase(inv);
2150 vWorkQueue.push_back(inv.hash);
2151
2152 // Recursively process any orphan transactions that depended on this one
2153 for (int i = 0; i < vWorkQueue.size(); i++)
2154 {
2155 uint256 hashPrev = vWorkQueue[i];
2156 for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(hashPrev);
2157 mi != mapOrphanTransactionsByPrev.upper_bound(hashPrev);
2158 ++mi)
2159 {
2160 const CDataStream& vMsg = *((*mi).second);
2161 CTransaction tx;
2162 CDataStream(vMsg) >> tx;
2163 CInv inv(MSG_TX, tx.GetHash());
2164
2165 if (tx.AcceptTransaction(true))
2166 {
2167 printf(" accepted orphan tx %s\n", inv.hash.ToString().substr(0,6).c_str());
2168 AddToWalletIfMine(tx, NULL);
2169 RelayMessage(inv, vMsg);
2170 mapAlreadyAskedFor.erase(inv);
2171 vWorkQueue.push_back(inv.hash);
2172 }
2173 }
2174 }
2175
2176 foreach(uint256 hash, vWorkQueue)
2177 EraseOrphanTx(hash);
2178 }
2179 else if (fMissingInputs)
2180 {
2181 printf("storing orphan tx %s\n", inv.hash.ToString().substr(0,6).c_str());
2182 AddOrphanTx(vMsg);
2183 }
2184 }
2185
2186
2187 else if (strCommand == "block")
2188 {
2189 auto_ptr<CBlock> pblock(new CBlock);
2190 vRecv >> *pblock;
2191
2192 //// debug print
2193 printf("received block %s\n", pblock->GetHash().ToString().substr(0,16).c_str());
2194 // pblock->print();
2195
2196 CInv inv(MSG_BLOCK, pblock->GetHash());
2197 pfrom->AddInventoryKnown(inv);
2198
2199 if (ProcessBlock(pfrom, pblock.release()))
2200 mapAlreadyAskedFor.erase(inv);
2201 }
2202
2203
2204 else if (strCommand == "getaddr")
2205 {
2206 // This includes all nodes that are currently online,
2207 // since they rebroadcast an addr every 24 hours
2208 pfrom->vAddrToSend.clear();
2209 int64 nSince = GetAdjustedTime() - 24 * 60 * 60; // in the last 24 hours
2210 CRITICAL_BLOCK(cs_mapAddresses)
2211 {
2212 unsigned int nSize = mapAddresses.size();
2213 foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
2214 {
2215 if (fShutdown)
2216 return true;
2217 const CAddress& addr = item.second;
2218 if (addr.nTime > nSince)
2219 pfrom->PushAddress(addr);
2220 }
2221 }
2222 }
2223
2224
2225 else if (strCommand == "checkorder")
2226 {
2227 uint256 hashReply;
2228 CWalletTx order;
2229 vRecv >> hashReply >> order;
2230
2231 /// we have a chance to check the order here
2232
2233 // Keep giving the same key to the same ip until they use it
2234 if (!mapReuseKey.count(pfrom->addr.ip))
2235 mapReuseKey[pfrom->addr.ip] = GenerateNewKey();
2236
2237 // Send back approval of order and pubkey to use
2238 CScript scriptPubKey;
2239 scriptPubKey << mapReuseKey[pfrom->addr.ip] << OP_CHECKSIG;
2240 pfrom->PushMessage("reply", hashReply, (int)0, scriptPubKey);
2241 }
2242
2243
2244 else if (strCommand == "submitorder")
2245 {
2246 uint256 hashReply;
2247 CWalletTx wtxNew;
2248 vRecv >> hashReply >> wtxNew;
2249 wtxNew.fFromMe = false;
2250
2251 // Broadcast
2252 if (!wtxNew.AcceptWalletTransaction())
2253 {
2254 pfrom->PushMessage("reply", hashReply, (int)1);
2255 return error("submitorder AcceptWalletTransaction() failed, returning error 1");
2256 }
2257 wtxNew.fTimeReceivedIsTxTime = true;
2258 AddToWallet(wtxNew);
2259 wtxNew.RelayWalletTransaction();
2260 mapReuseKey.erase(pfrom->addr.ip);
2261
2262 // Send back confirmation
2263 pfrom->PushMessage("reply", hashReply, (int)0);
2264 }
2265
2266
2267 else if (strCommand == "reply")
2268 {
2269 uint256 hashReply;
2270 vRecv >> hashReply;
2271
2272 CRequestTracker tracker;
2273 CRITICAL_BLOCK(pfrom->cs_mapRequests)
2274 {
2275 map<uint256, CRequestTracker>::iterator mi = pfrom->mapRequests.find(hashReply);
2276 if (mi != pfrom->mapRequests.end())
2277 {
2278 tracker = (*mi).second;
2279 pfrom->mapRequests.erase(mi);
2280 }
2281 }
2282 if (!tracker.IsNull())
2283 tracker.fn(tracker.param1, vRecv);
2284 }
2285
2286
2287 else if (strCommand == "ping")
2288 {
2289 }
2290
2291
2292 else
2293 {
2294 // Ignore unknown commands for extensibility
2295 }
2296
2297
2298 // Update the last seen time for this node's address
2299 if (pfrom->fNetworkNode)
2300 if (strCommand == "version" || strCommand == "addr" || strCommand == "inv" || strCommand == "getdata" || strCommand == "ping")
2301 AddressCurrentlyConnected(pfrom->addr);
2302
2303
2304 return true;
2305 }
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315 bool SendMessages(CNode* pto, bool fSendTrickle)
2316 {
2317 CRITICAL_BLOCK(cs_main)
2318 {
2319 // Don't send anything until we get their version message
2320 if (pto->nVersion == 0)
2321 return true;
2322
2323 // Keep-alive ping
2324 if (pto->nLastSend && GetTime() - pto->nLastSend > 30 * 60 && pto->vSend.empty())
2325 pto->PushMessage("ping");
2326
2327 // Address refresh broadcast
2328 static int64 nLastRebroadcast;
2329 if (GetTime() - nLastRebroadcast > 24 * 60 * 60) // every 24 hours
2330 {
2331 nLastRebroadcast = GetTime();
2332 CRITICAL_BLOCK(cs_vNodes)
2333 {
2334 foreach(CNode* pnode, vNodes)
2335 {
2336 // Periodically clear setAddrKnown to allow refresh broadcasts
2337 pnode->setAddrKnown.clear();
2338
2339 // Rebroadcast our address
2340 if (addrLocalHost.IsRoutable() && !fUseProxy)
2341 pnode->PushAddress(addrLocalHost);
2342 }
2343 }
2344 }
2345
2346 // Resend wallet transactions that haven't gotten in a block yet
2347 ResendWalletTransactions();
2348
2349
2350 //
2351 // Message: addr
2352 //
2353 if (fSendTrickle)
2354 {
2355 vector<CAddress> vAddr;
2356 vAddr.reserve(pto->vAddrToSend.size());
2357 foreach(const CAddress& addr, pto->vAddrToSend)
2358 {
2359 // returns true if wasn't already contained in the set
2360 if (pto->setAddrKnown.insert(addr).second)
2361 {
2362 vAddr.push_back(addr);
2363 // receiver rejects addr messages larger than 1000
2364 if (vAddr.size() >= 1000)
2365 {
2366 pto->PushMessage("addr", vAddr);
2367 vAddr.clear();
2368 }
2369 }
2370 }
2371 pto->vAddrToSend.clear();
2372 if (!vAddr.empty())
2373 pto->PushMessage("addr", vAddr);
2374 }
2375
2376
2377 //
2378 // Message: inventory
2379 //
2380 vector<CInv> vInv;
2381 vector<CInv> vInvWait;
2382 CRITICAL_BLOCK(pto->cs_inventory)
2383 {
2384 vInv.reserve(pto->vInventoryToSend.size());
2385 vInvWait.reserve(pto->vInventoryToSend.size());
2386 foreach(const CInv& inv, pto->vInventoryToSend)
2387 {
2388 if (pto->setInventoryKnown.count(inv))
2389 continue;
2390
2391 // trickle out tx inv to protect privacy
2392 if (inv.type == MSG_TX && !fSendTrickle)
2393 {
2394 // 1/4 of tx invs blast to all immediately
2395 static uint256 hashSalt;
2396 if (hashSalt == 0)
2397 RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
2398 uint256 hashRand = inv.hash ^ hashSalt;
2399 hashRand = Hash(BEGIN(hashRand), END(hashRand));
2400 bool fTrickleWait = ((hashRand & 3) != 0);
2401
2402 // always trickle our own transactions
2403 if (!fTrickleWait)
2404 {
2405 TRY_CRITICAL_BLOCK(cs_mapWallet)
2406 {
2407 map<uint256, CWalletTx>::iterator mi = mapWallet.find(inv.hash);
2408 if (mi != mapWallet.end())
2409 {
2410 CWalletTx& wtx = (*mi).second;
2411 if (wtx.fFromMe)
2412 fTrickleWait = true;
2413 }
2414 }
2415 }
2416
2417 if (fTrickleWait)
2418 {
2419 vInvWait.push_back(inv);
2420 continue;
2421 }
2422 }
2423
2424 // returns true if wasn't already contained in the set
2425 if (pto->setInventoryKnown.insert(inv).second)
2426 {
2427 vInv.push_back(inv);
2428 if (vInv.size() >= 1000)
2429 {
2430 pto->PushMessage("inv", vInv);
2431 vInv.clear();
2432 }
2433 }
2434 }
2435 pto->vInventoryToSend = vInvWait;
2436 }
2437 if (!vInv.empty())
2438 pto->PushMessage("inv", vInv);
2439
2440
2441 //
2442 // Message: getdata
2443 //
2444 vector<CInv> vGetData;
2445 int64 nNow = GetTime() * 1000000;
2446 CTxDB txdb("r");
2447 while (!pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
2448 {
2449 const CInv& inv = (*pto->mapAskFor.begin()).second;
2450 if (!AlreadyHave(txdb, inv))
2451 {
2452 printf("sending getdata: %s\n", inv.ToString().c_str());
2453 vGetData.push_back(inv);
2454 if (vGetData.size() >= 1000)
2455 {
2456 pto->PushMessage("getdata", vGetData);
2457 vGetData.clear();
2458 }
2459 }
2460 pto->mapAskFor.erase(pto->mapAskFor.begin());
2461 }
2462 if (!vGetData.empty())
2463 pto->PushMessage("getdata", vGetData);
2464
2465 }
2466 return true;
2467 }
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482 //////////////////////////////////////////////////////////////////////////////
2483 //
2484 // BitcoinMiner
2485 //
2486
2487 void GenerateBitcoins(bool fGenerate)
2488 {
2489 if (fGenerateBitcoins != fGenerate)
2490 {
2491 fGenerateBitcoins = fGenerate;
2492 CWalletDB().WriteSetting("fGenerateBitcoins", fGenerateBitcoins);
2493 MainFrameRepaint();
2494 }
2495 if (fGenerateBitcoins)
2496 {
2497 int nProcessors = wxThread::GetCPUCount();
2498 printf("%d processors\n", nProcessors);
2499 if (nProcessors < 1)
2500 nProcessors = 1;
2501 if (fLimitProcessors && nProcessors > nLimitProcessors)
2502 nProcessors = nLimitProcessors;
2503 int nAddThreads = nProcessors - vnThreadsRunning[3];
2504 printf("Starting %d BitcoinMiner threads\n", nAddThreads);
2505 for (int i = 0; i < nAddThreads; i++)
2506 {
2507 if (!CreateThread(ThreadBitcoinMiner, NULL))
2508 printf("Error: CreateThread(ThreadBitcoinMiner) failed\n");
2509 Sleep(10);
2510 }
2511 }
2512 }
2513
2514 void ThreadBitcoinMiner(void* parg)
2515 {
2516 try
2517 {
2518 vnThreadsRunning[3]++;
2519 BitcoinMiner();
2520 vnThreadsRunning[3]--;
2521 }
2522 catch (std::exception& e) {
2523 vnThreadsRunning[3]--;
2524 PrintException(&e, "ThreadBitcoinMiner()");
2525 } catch (...) {
2526 vnThreadsRunning[3]--;
2527 PrintException(NULL, "ThreadBitcoinMiner()");
2528 }
2529 UIThreadCall(bind(CalledSetStatusBar, "", 0));
2530 printf("ThreadBitcoinMiner exiting, %d threads remaining\n", vnThreadsRunning[3]);
2531 }
2532
2533 int FormatHashBlocks(void* pbuffer, unsigned int len)
2534 {
2535 unsigned char* pdata = (unsigned char*)pbuffer;
2536 unsigned int blocks = 1 + ((len + 8) / 64);
2537 unsigned char* pend = pdata + 64 * blocks;
2538 memset(pdata + len, 0, 64 * blocks - len);
2539 pdata[len] = 0x80;
2540 unsigned int bits = len * 8;
2541 pend[-1] = (bits >> 0) & 0xff;
2542 pend[-2] = (bits >> 8) & 0xff;
2543 pend[-3] = (bits >> 16) & 0xff;
2544 pend[-4] = (bits >> 24) & 0xff;
2545 return blocks;
2546 }
2547
2548 using CryptoPP::ByteReverse;
2549 static int detectlittleendian = 1;
2550
2551 void BlockSHA256(const void* pin, unsigned int nBlocks, void* pout)
2552 {
2553 unsigned int* pinput = (unsigned int*)pin;
2554 unsigned int* pstate = (unsigned int*)pout;
2555
2556 CryptoPP::SHA256::InitState(pstate);
2557
2558 if (*(char*)&detectlittleendian != 0)
2559 {
2560 for (int n = 0; n < nBlocks; n++)
2561 {
2562 unsigned int pbuf[16];
2563 for (int i = 0; i < 16; i++)
2564 pbuf[i] = ByteReverse(pinput[n * 16 + i]);
2565 CryptoPP::SHA256::Transform(pstate, pbuf);
2566 }
2567 for (int i = 0; i < 8; i++)
2568 pstate[i] = ByteReverse(pstate[i]);
2569 }
2570 else
2571 {
2572 for (int n = 0; n < nBlocks; n++)
2573 CryptoPP::SHA256::Transform(pstate, pinput + n * 16);
2574 }
2575 }
2576
2577
2578 void BitcoinMiner()
2579 {
2580 printf("BitcoinMiner started\n");
2581 SetThreadPriority(THREAD_PRIORITY_LOWEST);
2582
2583 CKey key;
2584 key.MakeNewKey();
2585 CBigNum bnExtraNonce = 0;
2586 while (fGenerateBitcoins)
2587 {
2588 Sleep(50);
2589 if (fShutdown)
2590 return;
2591 while (vNodes.empty())
2592 {
2593 Sleep(1000);
2594 if (fShutdown)
2595 return;
2596 if (!fGenerateBitcoins)
2597 return;
2598 }
2599
2600 unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
2601 CBlockIndex* pindexPrev = pindexBest;
2602 unsigned int nBits = GetNextWorkRequired(pindexPrev);
2603
2604
2605 //
2606 // Create coinbase tx
2607 //
2608 CTransaction txNew;
2609 txNew.vin.resize(1);
2610 txNew.vin[0].prevout.SetNull();
2611 txNew.vin[0].scriptSig << nBits << ++bnExtraNonce;
2612 txNew.vout.resize(1);
2613 txNew.vout[0].scriptPubKey << key.GetPubKey() << OP_CHECKSIG;
2614
2615
2616 //
2617 // Create new block
2618 //
2619 auto_ptr<CBlock> pblock(new CBlock());
2620 if (!pblock.get())
2621 return;
2622
2623 // Add our coinbase tx as first transaction
2624 pblock->vtx.push_back(txNew);
2625
2626 // Collect the latest transactions into the block
2627 int64 nFees = 0;
2628 CRITICAL_BLOCK(cs_main)
2629 CRITICAL_BLOCK(cs_mapTransactions)
2630 {
2631 CTxDB txdb("r");
2632 map<uint256, CTxIndex> mapTestPool;
2633 vector<char> vfAlreadyAdded(mapTransactions.size());
2634 bool fFoundSomething = true;
2635 unsigned int nBlockSize = 0;
2636 while (fFoundSomething && nBlockSize < MAX_SIZE/2)
2637 {
2638 fFoundSomething = false;
2639 unsigned int n = 0;
2640 for (map<uint256, CTransaction>::iterator mi = mapTransactions.begin(); mi != mapTransactions.end(); ++mi, ++n)
2641 {
2642 if (vfAlreadyAdded[n])
2643 continue;
2644 CTransaction& tx = (*mi).second;
2645 if (tx.IsCoinBase() || !tx.IsFinal())
2646 continue;
2647 unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK);
2648 if (nBlockSize + nTxSize >= MAX_BLOCK_SIZE - 10000)
2649 continue;
2650
2651 // Transaction fee based on block size
2652 int64 nMinFee = tx.GetMinFee(nBlockSize);
2653
2654 map<uint256, CTxIndex> mapTestPoolTmp(mapTestPool);
2655 if (!tx.ConnectInputs(txdb, mapTestPoolTmp, CDiskTxPos(1,1,1), 0, nFees, false, true, nMinFee))
2656 continue;
2657 swap(mapTestPool, mapTestPoolTmp);
2658
2659 pblock->vtx.push_back(tx);
2660 nBlockSize += nTxSize;
2661 vfAlreadyAdded[n] = true;
2662 fFoundSomething = true;
2663 }
2664 }
2665 }
2666 pblock->nBits = nBits;
2667 pblock->vtx[0].vout[0].nValue = pblock->GetBlockValue(nFees);
2668 printf("Running BitcoinMiner with %d transactions in block\n", pblock->vtx.size());
2669
2670
2671 //
2672 // Prebuild hash buffer
2673 //
2674 struct unnamed1
2675 {
2676 struct unnamed2
2677 {
2678 int nVersion;
2679 uint256 hashPrevBlock;
2680 uint256 hashMerkleRoot;
2681 unsigned int nTime;
2682 unsigned int nBits;
2683 unsigned int nNonce;
2684 }
2685 block;
2686 unsigned char pchPadding0[64];
2687 uint256 hash1;
2688 unsigned char pchPadding1[64];
2689 }
2690 tmp;
2691
2692 tmp.block.nVersion = pblock->nVersion;
2693 tmp.block.hashPrevBlock = pblock->hashPrevBlock = (pindexPrev ? pindexPrev->GetBlockHash() : 0);
2694 tmp.block.hashMerkleRoot = pblock->hashMerkleRoot = pblock->BuildMerkleTree();
2695 tmp.block.nTime = pblock->nTime = max((pindexPrev ? pindexPrev->GetMedianTimePast()+1 : 0), GetAdjustedTime());
2696 tmp.block.nBits = pblock->nBits = nBits;
2697 tmp.block.nNonce = pblock->nNonce = 1;
2698
2699 unsigned int nBlocks0 = FormatHashBlocks(&tmp.block, sizeof(tmp.block));
2700 unsigned int nBlocks1 = FormatHashBlocks(&tmp.hash1, sizeof(tmp.hash1));
2701
2702
2703 //
2704 // Search
2705 //
2706 int64 nStart = GetTime();
2707 uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
2708 uint256 hash;
2709 loop
2710 {
2711 BlockSHA256(&tmp.block, nBlocks0, &tmp.hash1);
2712 BlockSHA256(&tmp.hash1, nBlocks1, &hash);
2713
2714 if (hash <= hashTarget)
2715 {
2716 pblock->nNonce = tmp.block.nNonce;
2717 assert(hash == pblock->GetHash());
2718
2719 //// debug print
2720 printf("BitcoinMiner:\n");
2721 printf("proof-of-work found \n hash: %s \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str());
2722 pblock->print();
2723 printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
2724 printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str());
2725
2726 SetThreadPriority(THREAD_PRIORITY_NORMAL);
2727 CRITICAL_BLOCK(cs_main)
2728 {
2729 if (pindexPrev == pindexBest)
2730 {
2731 // Save key
2732 if (!AddKey(key))
2733 return;
2734 key.MakeNewKey();
2735
2736 // Track how many getdata requests this block gets
2737 CRITICAL_BLOCK(cs_mapRequestCount)
2738 mapRequestCount[pblock->GetHash()] = 0;
2739
2740 // Process this block the same as if we had received it from another node
2741 if (!ProcessBlock(NULL, pblock.release()))
2742 printf("ERROR in BitcoinMiner, ProcessBlock, block not accepted\n");
2743 }
2744 }
2745 SetThreadPriority(THREAD_PRIORITY_LOWEST);
2746
2747 Sleep(500);
2748 break;
2749 }
2750
2751 // Update nTime every few seconds
2752 const unsigned int nMask = 0xffff;
2753 if ((++tmp.block.nNonce & nMask) == 0)
2754 {
2755 // Meter hashes/sec
2756 static int64 nTimerStart;
2757 static int nHashCounter;
2758 if (nTimerStart == 0)
2759 nTimerStart = GetTimeMillis();
2760 else
2761 nHashCounter++;
2762 if (GetTimeMillis() - nTimerStart > 4000)
2763 {
2764 static CCriticalSection cs;
2765 CRITICAL_BLOCK(cs)
2766 {
2767 if (GetTimeMillis() - nTimerStart > 4000)
2768 {
2769 double dHashesPerSec = 1000.0 * (nMask+1) * nHashCounter / (GetTimeMillis() - nTimerStart);
2770 nTimerStart = GetTimeMillis();
2771 nHashCounter = 0;
2772 string strStatus = strprintf(" %.0f khash/s", dHashesPerSec/1000.0);
2773 UIThreadCall(bind(CalledSetStatusBar, strStatus, 0));
2774 static int64 nLogTime;
2775 if (GetTime() - nLogTime > 30 * 60)
2776 {
2777 nLogTime = GetTime();
2778 printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
2779 printf("hashmeter %3d CPUs %6.0f khash/s\n", vnThreadsRunning[3], dHashesPerSec/1000.0);
2780 }
2781 }
2782 }
2783 }
2784
2785 // Check for stop or if block needs to be rebuilt
2786 if (fShutdown)
2787 return;
2788 if (!fGenerateBitcoins)
2789 return;
2790 if (fLimitProcessors && vnThreadsRunning[3] > nLimitProcessors)
2791 return;
2792 if (vNodes.empty())
2793 break;
2794 if (tmp.block.nNonce == 0)
2795 break;
2796 if (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60)
2797 break;
2798 if (pindexPrev != pindexBest)
2799 {
2800 // Pause generating during initial download
2801 if (GetTime() - nStart < 20)
2802 {
2803 CBlockIndex* pindexTmp;
2804 do
2805 {
2806 pindexTmp = pindexBest;
2807 for (int i = 0; i < 10; i++)
2808 {
2809 Sleep(1000);
2810 if (fShutdown)
2811 return;
2812 }
2813 }
2814 while (pindexTmp != pindexBest);
2815 }
2816 break;
2817 }
2818
2819 tmp.block.nTime = pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
2820 }
2821 }
2822 }
2823 }
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842 //////////////////////////////////////////////////////////////////////////////
2843 //
2844 // Actions
2845 //
2846
2847
2848 int64 GetBalance()
2849 {
2850 int64 nStart = GetTimeMillis();
2851
2852 int64 nTotal = 0;
2853 CRITICAL_BLOCK(cs_mapWallet)
2854 {
2855 for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2856 {
2857 CWalletTx* pcoin = &(*it).second;
2858 if (!pcoin->IsFinal() || pcoin->fSpent)
2859 continue;
2860 nTotal += pcoin->GetCredit(true);
2861 }
2862 }
2863
2864 //printf("GetBalance() %"PRI64d"ms\n", GetTimeMillis() - nStart);
2865 return nTotal;
2866 }
2867
2868
2869 int GetRandInt(int nMax)
2870 {
2871 return GetRand(nMax);
2872 }
2873
2874 bool SelectCoins(int64 nTargetValue, set<CWalletTx*>& setCoinsRet)
2875 {
2876 setCoinsRet.clear();
2877
2878 // List of values less than target
2879 int64 nLowestLarger = INT64_MAX;
2880 CWalletTx* pcoinLowestLarger = NULL;
2881 vector<pair<int64, CWalletTx*> > vValue;
2882 int64 nTotalLower = 0;
2883
2884 CRITICAL_BLOCK(cs_mapWallet)
2885 {
2886 vector<CWalletTx*> vCoins;
2887 vCoins.reserve(mapWallet.size());
2888 for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2889 vCoins.push_back(&(*it).second);
2890 random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
2891
2892 foreach(CWalletTx* pcoin, vCoins)
2893 {
2894 if (!pcoin->IsFinal() || pcoin->fSpent)
2895 continue;
2896 int64 n = pcoin->GetCredit();
2897 if (n <= 0)
2898 continue;
2899 if (n < nTargetValue)
2900 {
2901 vValue.push_back(make_pair(n, pcoin));
2902 nTotalLower += n;
2903 }
2904 else if (n == nTargetValue)
2905 {
2906 setCoinsRet.insert(pcoin);
2907 return true;
2908 }
2909 else if (n < nLowestLarger)
2910 {
2911 nLowestLarger = n;
2912 pcoinLowestLarger = pcoin;
2913 }
2914 }
2915 }
2916
2917 if (nTotalLower < nTargetValue)
2918 {
2919 if (pcoinLowestLarger == NULL)
2920 return false;
2921 setCoinsRet.insert(pcoinLowestLarger);
2922 return true;
2923 }
2924
2925 // Solve subset sum by stochastic approximation
2926 sort(vValue.rbegin(), vValue.rend());
2927 vector<char> vfIncluded;
2928 vector<char> vfBest(vValue.size(), true);
2929 int64 nBest = nTotalLower;
2930
2931 for (int nRep = 0; nRep < 1000 && nBest != nTargetValue; nRep++)
2932 {
2933 vfIncluded.assign(vValue.size(), false);
2934 int64 nTotal = 0;
2935 bool fReachedTarget = false;
2936 for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
2937 {
2938 for (int i = 0; i < vValue.size(); i++)
2939 {
2940 if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
2941 {
2942 nTotal += vValue[i].first;
2943 vfIncluded[i] = true;
2944 if (nTotal >= nTargetValue)
2945 {
2946 fReachedTarget = true;
2947 if (nTotal < nBest)
2948 {
2949 nBest = nTotal;
2950 vfBest = vfIncluded;
2951 }
2952 nTotal -= vValue[i].first;
2953 vfIncluded[i] = false;
2954 }
2955 }
2956 }
2957 }
2958 }
2959
2960 // If the next larger is still closer, return it
2961 if (pcoinLowestLarger && nLowestLarger - nTargetValue <= nBest - nTargetValue)
2962 setCoinsRet.insert(pcoinLowestLarger);
2963 else
2964 {
2965 for (int i = 0; i < vValue.size(); i++)
2966 if (vfBest[i])
2967 setCoinsRet.insert(vValue[i].second);
2968
2969 //// debug print
2970 printf("SelectCoins() best subset: ");
2971 for (int i = 0; i < vValue.size(); i++)
2972 if (vfBest[i])
2973 printf("%s ", FormatMoney(vValue[i].first).c_str());
2974 printf("total %s\n", FormatMoney(nBest).c_str());
2975 }
2976
2977 return true;
2978 }
2979
2980
2981
2982
2983 bool CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CKey& keyRet, int64& nFeeRequiredRet)
2984 {
2985 nFeeRequiredRet = 0;
2986 CRITICAL_BLOCK(cs_main)
2987 {
2988 // txdb must be opened before the mapWallet lock
2989 CTxDB txdb("r");
2990 CRITICAL_BLOCK(cs_mapWallet)
2991 {
2992 int64 nFee = nTransactionFee;
2993 loop
2994 {
2995 wtxNew.vin.clear();
2996 wtxNew.vout.clear();
2997 wtxNew.fFromMe = true;
2998 if (nValue < 0)
2999 return false;
3000 int64 nValueOut = nValue;
3001 int64 nTotalValue = nValue + nFee;
3002
3003 // Choose coins to use
3004 set<CWalletTx*> setCoins;
3005 if (!SelectCoins(nTotalValue, setCoins))
3006 return false;
3007 int64 nValueIn = 0;
3008 foreach(CWalletTx* pcoin, setCoins)
3009 nValueIn += pcoin->GetCredit();
3010
3011 // Fill a vout to the payee
3012 bool fChangeFirst = GetRand(2);
3013 if (!fChangeFirst)
3014 wtxNew.vout.push_back(CTxOut(nValueOut, scriptPubKey));
3015
3016 // Fill a vout back to self with any change
3017 if (nValueIn > nTotalValue)
3018 {
3019 // Note: We use a new key here to keep it from being obvious which side is the change.
3020 // The drawback is that by not reusing a previous key, the change may be lost if a
3021 // backup is restored, if the backup doesn't have the new private key for the change.
3022 // If we reused the old key, it would be possible to add code to look for and
3023 // rediscover unknown transactions that were written with keys of ours to recover
3024 // post-backup change.
3025
3026 // New private key
3027 if (keyRet.IsNull())
3028 keyRet.MakeNewKey();
3029
3030 // Fill a vout to ourself, using same address type as the payment
3031 CScript scriptChange;
3032 if (scriptPubKey.GetBitcoinAddressHash160() != 0)
3033 scriptChange.SetBitcoinAddress(keyRet.GetPubKey());
3034 else
3035 scriptChange << keyRet.GetPubKey() << OP_CHECKSIG;
3036 wtxNew.vout.push_back(CTxOut(nValueIn - nTotalValue, scriptChange));
3037 }
3038
3039 // Fill a vout to the payee
3040 if (fChangeFirst)
3041 wtxNew.vout.push_back(CTxOut(nValueOut, scriptPubKey));
3042
3043 // Fill vin
3044 foreach(CWalletTx* pcoin, setCoins)
3045 for (int nOut = 0; nOut < pcoin->vout.size(); nOut++)
3046 if (pcoin->vout[nOut].IsMine())
3047 wtxNew.vin.push_back(CTxIn(pcoin->GetHash(), nOut));
3048
3049 // Sign
3050 int nIn = 0;
3051 foreach(CWalletTx* pcoin, setCoins)
3052 for (int nOut = 0; nOut < pcoin->vout.size(); nOut++)
3053 if (pcoin->vout[nOut].IsMine())
3054 SignSignature(*pcoin, wtxNew, nIn++);
3055
3056 // Check that enough fee is included
3057 if (nFee < wtxNew.GetMinFee())
3058 {
3059 nFee = nFeeRequiredRet = wtxNew.GetMinFee();
3060 continue;
3061 }
3062
3063 // Fill vtxPrev by copying from previous transactions vtxPrev
3064 wtxNew.AddSupportingTransactions(txdb);
3065 wtxNew.fTimeReceivedIsTxTime = true;
3066
3067 break;
3068 }
3069 }
3070 }
3071 return true;
3072 }
3073
3074 // Call after CreateTransaction unless you want to abort
3075 bool CommitTransaction(CWalletTx& wtxNew, const CKey& key)
3076 {
3077 CRITICAL_BLOCK(cs_main)
3078 {
3079 printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
3080 CRITICAL_BLOCK(cs_mapWallet)
3081 {
3082 // This is only to keep the database open to defeat the auto-flush for the
3083 // duration of this scope. This is the only place where this optimization
3084 // maybe makes sense; please don't do it anywhere else.
3085 CWalletDB walletdb("r");
3086
3087 // Add the change's private key to wallet
3088 if (!key.IsNull() && !AddKey(key))
3089 throw runtime_error("CommitTransaction() : AddKey failed\n");
3090
3091 // Add tx to wallet, because if it has change it's also ours,
3092 // otherwise just for transaction history.
3093 AddToWallet(wtxNew);
3094
3095 // Mark old coins as spent
3096 set<CWalletTx*> setCoins;
3097 foreach(const CTxIn& txin, wtxNew.vin)
3098 setCoins.insert(&mapWallet[txin.prevout.hash]);
3099 foreach(CWalletTx* pcoin, setCoins)
3100 {
3101 pcoin->fSpent = true;
3102 pcoin->WriteToDisk();
3103 vWalletUpdated.push_back(pcoin->GetHash());
3104 }
3105 }
3106
3107 // Track how many getdata requests our transaction gets
3108 CRITICAL_BLOCK(cs_mapRequestCount)
3109 mapRequestCount[wtxNew.GetHash()] = 0;
3110
3111 // Broadcast
3112 if (!wtxNew.AcceptTransaction())
3113 {
3114 // This must not fail. The transaction has already been signed and recorded.
3115 printf("CommitTransaction() : Error: Transaction not valid");
3116 return false;
3117 }
3118 wtxNew.RelayWalletTransaction();
3119 }
3120 MainFrameRepaint();
3121 return true;
3122 }
3123
3124
3125
3126
3127 string SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
3128 {
3129 CRITICAL_BLOCK(cs_main)
3130 {
3131 CKey key;
3132 int64 nFeeRequired;
3133 if (!CreateTransaction(scriptPubKey, nValue, wtxNew, key, nFeeRequired))
3134 {
3135 string strError;
3136 if (nValue + nFeeRequired > GetBalance())
3137 strError = strprintf(_("Error: This is an oversized transaction that requires a transaction fee of %s "), FormatMoney(nFeeRequired).c_str());
3138 else
3139 strError = _("Error: Transaction creation failed ");
3140 printf("SendMoney() : %s", strError.c_str());
3141 return strError;
3142 }
3143
3144 if (fAskFee && !ThreadSafeAskFee(nFeeRequired, _("Sending..."), NULL))
3145 return "ABORTED";
3146
3147 if (!CommitTransaction(wtxNew, key))
3148 return _("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
3149 }
3150 MainFrameRepaint();
3151 return "";
3152 }
3153
3154
3155
3156 string SendMoneyToBitcoinAddress(string strAddress, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
3157 {
3158 // Check amount
3159 if (nValue <= 0)
3160 return _("Invalid amount");
3161 if (nValue + nTransactionFee > GetBalance())
3162 return _("Insufficient funds");
3163
3164 // Parse bitcoin address
3165 CScript scriptPubKey;
3166 if (!scriptPubKey.SetBitcoinAddress(strAddress))
3167 return _("Invalid bitcoin address");
3168
3169 return SendMoney(scriptPubKey, nValue, wtxNew, fAskFee);
3170 }