src/wallet/walletdb.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "wallet/walletdb.h"
   7
   8 #include "base58.h"
   9 #include "consensus/tx_verify.h"
  10 #include "consensus/validation.h"
  11 #include "fs.h"
  12 #include "protocol.h"
  13 #include "serialize.h"
  14 #include "sync.h"
  15 #include "util.h"
  16 #include "utiltime.h"
  17 #include "wallet/wallet.h"
  18
  19 #include <atomic>
  20
  21 #include <boost/foreach.hpp>
  22 #include <boost/thread.hpp>
  23
  24 //
  25 // CWalletDB
  26 //
  27
  28 bool CWalletDB::WriteName(const std::string& strAddress, const std::string& strName)
  29 {
  30     return WriteIC(std::make_pair(std::string("name"), strAddress), strName);
  31 }
  32
  33 bool CWalletDB::EraseName(const std::string& strAddress)
  34 {
  35     // This should only be used for sending addresses, never for receiving addresses,
  36     // receiving addresses must always have an address book entry if they're not change return.
  37     return EraseIC(std::make_pair(std::string("name"), strAddress));
  38 }
  39
  40 bool CWalletDB::WritePurpose(const std::string& strAddress, const std::string& strPurpose)
  41 {
  42     return WriteIC(std::make_pair(std::string("purpose"), strAddress), strPurpose);
  43 }
  44
  45 bool CWalletDB::ErasePurpose(const std::string& strPurpose)
  46 {
  47     return EraseIC(std::make_pair(std::string("purpose"), strPurpose));
  48 }
  49
  50 bool CWalletDB::WriteTx(const CWalletTx& wtx)
  51 {
  52     return WriteIC(std::make_pair(std::string("tx"), wtx.GetHash()), wtx);
  53 }
  54
  55 bool CWalletDB::EraseTx(uint256 hash)
  56 {
  57     return EraseIC(std::make_pair(std::string("tx"), hash));
  58 }
  59
  60 bool CWalletDB::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata& keyMeta)
  61 {
  62     if (!WriteIC(std::make_pair(std::string("keymeta"), vchPubKey), keyMeta, false)) {
  63         return false;
  64     }
  65
  66     // hash pubkey/privkey to accelerate wallet load
  67     std::vector<unsigned char> vchKey;
  68     vchKey.reserve(vchPubKey.size() + vchPrivKey.size());
  69     vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
  70     vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
  71
  72     return WriteIC(std::make_pair(std::string("key"), vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
  73 }
  74
  75 bool CWalletDB::WriteCryptedKey(const CPubKey& vchPubKey,
  76                                 const std::vector<unsigned char>& vchCryptedSecret,
  77                                 const CKeyMetadata &keyMeta)
  78 {
  79     const bool fEraseUnencryptedKey = true;
  80
  81     if (!WriteIC(std::make_pair(std::string("keymeta"), vchPubKey), keyMeta)) {
  82         return false;
  83     }
  84
  85     if (!WriteIC(std::make_pair(std::string("ckey"), vchPubKey), vchCryptedSecret, false)) {
  86         return false;
  87     }
  88     if (fEraseUnencryptedKey)
  89     {
  90         EraseIC(std::make_pair(std::string("key"), vchPubKey));
  91         EraseIC(std::make_pair(std::string("wkey"), vchPubKey));
  92     }
  93
  94     return true;
  95 }
  96
  97 bool CWalletDB::WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
  98 {
  99     return WriteIC(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
 100 }
 101
 102 bool CWalletDB::WriteCScript(const uint160& hash, const CScript& redeemScript)
 103 {
 104     return WriteIC(std::make_pair(std::string("cscript"), hash), *(const CScriptBase*)(&redeemScript), false);
 105 }
 106
 107 bool CWalletDB::WriteWatchOnly(const CScript &dest, const CKeyMetadata& keyMeta)
 108 {
 109     if (!WriteIC(std::make_pair(std::string("watchmeta"), *(const CScriptBase*)(&dest)), keyMeta)) {
 110         return false;
 111     }
 112     return WriteIC(std::make_pair(std::string("watchs"), *(const CScriptBase*)(&dest)), '1');
 113 }
 114
 115 bool CWalletDB::EraseWatchOnly(const CScript &dest)
 116 {
 117     if (!EraseIC(std::make_pair(std::string("watchmeta"), *(const CScriptBase*)(&dest)))) {
 118         return false;
 119     }
 120     return EraseIC(std::make_pair(std::string("watchs"), *(const CScriptBase*)(&dest)));
 121 }
 122
 123 bool CWalletDB::WriteBestBlock(const CBlockLocator& locator)
 124 {
 125     WriteIC(std::string("bestblock"), CBlockLocator()); // Write empty block locator so versions that require a merkle branch automatically rescan
 126     return WriteIC(std::string("bestblock_nomerkle"), locator);
 127 }
 128
 129 bool CWalletDB::ReadBestBlock(CBlockLocator& locator)
 130 {
 131     if (batch.Read(std::string("bestblock"), locator) && !locator.vHave.empty()) return true;
 132     return batch.Read(std::string("bestblock_nomerkle"), locator);
 133 }
 134
 135 bool CWalletDB::WriteOrderPosNext(int64_t nOrderPosNext)
 136 {
 137     return WriteIC(std::string("orderposnext"), nOrderPosNext);
 138 }
 139
 140 bool CWalletDB::WriteDefaultKey(const CPubKey& vchPubKey)
 141 {
 142     return WriteIC(std::string("defaultkey"), vchPubKey);
 143 }
 144
 145 bool CWalletDB::ReadPool(int64_t nPool, CKeyPool& keypool)
 146 {
 147     return batch.Read(std::make_pair(std::string("pool"), nPool), keypool);
 148 }
 149
 150 bool CWalletDB::WritePool(int64_t nPool, const CKeyPool& keypool)
 151 {
 152     return WriteIC(std::make_pair(std::string("pool"), nPool), keypool);
 153 }
 154
 155 bool CWalletDB::ErasePool(int64_t nPool)
 156 {
 157     return EraseIC(std::make_pair(std::string("pool"), nPool));
 158 }
 159
 160 bool CWalletDB::WriteMinVersion(int nVersion)
 161 {
 162     return WriteIC(std::string("minversion"), nVersion);
 163 }
 164
 165 bool CWalletDB::ReadAccount(const std::string& strAccount, CAccount& account)
 166 {
 167     account.SetNull();
 168     return batch.Read(std::make_pair(std::string("acc"), strAccount), account);
 169 }
 170
 171 bool CWalletDB::WriteAccount(const std::string& strAccount, const CAccount& account)
 172 {
 173     return WriteIC(std::make_pair(std::string("acc"), strAccount), account);
 174 }
 175
 176 bool CWalletDB::WriteAccountingEntry(const uint64_t nAccEntryNum, const CAccountingEntry& acentry)
 177 {
 178     return WriteIC(std::make_pair(std::string("acentry"), std::make_pair(acentry.strAccount, nAccEntryNum)), acentry);
 179 }
 180
 181 CAmount CWalletDB::GetAccountCreditDebit(const std::string& strAccount)
 182 {
 183     std::list<CAccountingEntry> entries;
 184     ListAccountCreditDebit(strAccount, entries);
 185
 186     CAmount nCreditDebit = 0;
 187     BOOST_FOREACH (const CAccountingEntry& entry, entries)
 188         nCreditDebit += entry.nCreditDebit;
 189
 190     return nCreditDebit;
 191 }
 192
 193 void CWalletDB::ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& entries)
 194 {
 195     bool fAllAccounts = (strAccount == "*");
 196
 197     Dbc* pcursor = batch.GetCursor();
 198     if (!pcursor)
 199         throw std::runtime_error(std::string(__func__) + ": cannot create DB cursor");
 200     bool setRange = true;
 201     while (true)
 202     {
 203         // Read next record
 204         CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 205         if (setRange)
 206             ssKey << std::make_pair(std::string("acentry"), std::make_pair((fAllAccounts ? std::string("") : strAccount), uint64_t(0)));
 207         CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 208         int ret = batch.ReadAtCursor(pcursor, ssKey, ssValue, setRange);
 209         setRange = false;
 210         if (ret == DB_NOTFOUND)
 211             break;
 212         else if (ret != 0)
 213         {
 214             pcursor->close();
 215             throw std::runtime_error(std::string(__func__) + ": error scanning DB");
 216         }
 217
 218         // Unserialize
 219         std::string strType;
 220         ssKey >> strType;
 221         if (strType != "acentry")
 222             break;
 223         CAccountingEntry acentry;
 224         ssKey >> acentry.strAccount;
 225         if (!fAllAccounts && acentry.strAccount != strAccount)
 226             break;
 227
 228         ssValue >> acentry;
 229         ssKey >> acentry.nEntryNo;
 230         entries.push_back(acentry);
 231     }
 232
 233     pcursor->close();
 234 }
 235
 236 class CWalletScanState {
 237 public:
 238     unsigned int nKeys;
 239     unsigned int nCKeys;
 240     unsigned int nWatchKeys;
 241     unsigned int nKeyMeta;
 242     bool fIsEncrypted;
 243     bool fAnyUnordered;
 244     int nFileVersion;
 245     std::vector<uint256> vWalletUpgrade;
 246
 247     CWalletScanState() {
 248         nKeys = nCKeys = nWatchKeys = nKeyMeta = 0;
 249         fIsEncrypted = false;
 250         fAnyUnordered = false;
 251         nFileVersion = 0;
 252     }
 253 };
 254
 255 bool
 256 ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
 257              CWalletScanState &wss, std::string& strType, std::string& strErr)
 258 {
 259     try {
 260         // Unserialize
 261         // Taking advantage of the fact that pair serialization
 262         // is just the two items serialized one after the other
 263         ssKey >> strType;
 264         if (strType == "name")
 265         {
 266             std::string strAddress;
 267             ssKey >> strAddress;
 268             ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()].name;
 269         }
 270         else if (strType == "purpose")
 271         {
 272             std::string strAddress;
 273             ssKey >> strAddress;
 274             ssValue >> pwallet->mapAddressBook[CBitcoinAddress(strAddress).Get()].purpose;
 275         }
 276         else if (strType == "tx")
 277         {
 278             uint256 hash;
 279             ssKey >> hash;
 280             CWalletTx wtx;
 281             ssValue >> wtx;
 282             CValidationState state;
 283             if (!(CheckTransaction(wtx, state) && (wtx.GetHash() == hash) && state.IsValid()))
 284                 return false;
 285
 286             // Undo serialize changes in 31600
 287             if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
 288             {
 289                 if (!ssValue.empty())
 290                 {
 291                     char fTmp;
 292                     char fUnused;
 293                     ssValue >> fTmp >> fUnused >> wtx.strFromAccount;
 294                     strErr = strprintf("LoadWallet() upgrading tx ver=%d %d '%s' %s",
 295                                        wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount, hash.ToString());
 296                     wtx.fTimeReceivedIsTxTime = fTmp;
 297                 }
 298                 else
 299                 {
 300                     strErr = strprintf("LoadWallet() repairing tx ver=%d %s", wtx.fTimeReceivedIsTxTime, hash.ToString());
 301                     wtx.fTimeReceivedIsTxTime = 0;
 302                 }
 303                 wss.vWalletUpgrade.push_back(hash);
 304             }
 305
 306             if (wtx.nOrderPos == -1)
 307                 wss.fAnyUnordered = true;
 308
 309             pwallet->LoadToWallet(wtx);
 310         }
 311         else if (strType == "acentry")
 312         {
 313             std::string strAccount;
 314             ssKey >> strAccount;
 315             uint64_t nNumber;
 316             ssKey >> nNumber;
 317             if (nNumber > pwallet->nAccountingEntryNumber) {
 318                 pwallet->nAccountingEntryNumber = nNumber;
 319             }
 320
 321             if (!wss.fAnyUnordered)
 322             {
 323                 CAccountingEntry acentry;
 324                 ssValue >> acentry;
 325                 if (acentry.nOrderPos == -1)
 326                     wss.fAnyUnordered = true;
 327             }
 328         }
 329         else if (strType == "watchs")
 330         {
 331             wss.nWatchKeys++;
 332             CScript script;
 333             ssKey >> *(CScriptBase*)(&script);
 334             char fYes;
 335             ssValue >> fYes;
 336             if (fYes == '1')
 337                 pwallet->LoadWatchOnly(script);
 338         }
 339         else if (strType == "key" || strType == "wkey")
 340         {
 341             CPubKey vchPubKey;
 342             ssKey >> vchPubKey;
 343             if (!vchPubKey.IsValid())
 344             {
 345                 strErr = "Error reading wallet database: CPubKey corrupt";
 346                 return false;
 347             }
 348             CKey key;
 349             CPrivKey pkey;
 350             uint256 hash;
 351
 352             if (strType == "key")
 353             {
 354                 wss.nKeys++;
 355                 ssValue >> pkey;
 356             } else {
 357                 CWalletKey wkey;
 358                 ssValue >> wkey;
 359                 pkey = wkey.vchPrivKey;
 360             }
 361
 362             // Old wallets store keys as "key" [pubkey] => [privkey]
 363             // ... which was slow for wallets with lots of keys, because the public key is re-derived from the private key
 364             // using EC operations as a checksum.
 365             // Newer wallets store keys as "key"[pubkey] => [privkey][hash(pubkey,privkey)], which is much faster while
 366             // remaining backwards-compatible.
 367             try
 368             {
 369                 ssValue >> hash;
 370             }
 371             catch (...) {}
 372
 373             bool fSkipCheck = false;
 374
 375             if (!hash.IsNull())
 376             {
 377                 // hash pubkey/privkey to accelerate wallet load
 378                 std::vector<unsigned char> vchKey;
 379                 vchKey.reserve(vchPubKey.size() + pkey.size());
 380                 vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
 381                 vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
 382
 383                 if (Hash(vchKey.begin(), vchKey.end()) != hash)
 384                 {
 385                     strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
 386                     return false;
 387                 }
 388
 389                 fSkipCheck = true;
 390             }
 391
 392             if (!key.Load(pkey, vchPubKey, fSkipCheck))
 393             {
 394                 strErr = "Error reading wallet database: CPrivKey corrupt";
 395                 return false;
 396             }
 397             if (!pwallet->LoadKey(key, vchPubKey))
 398             {
 399                 strErr = "Error reading wallet database: LoadKey failed";
 400                 return false;
 401             }
 402         }
 403         else if (strType == "mkey")
 404         {
 405             unsigned int nID;
 406             ssKey >> nID;
 407             CMasterKey kMasterKey;
 408             ssValue >> kMasterKey;
 409             if(pwallet->mapMasterKeys.count(nID) != 0)
 410             {
 411                 strErr = strprintf("Error reading wallet database: duplicate CMasterKey id %u", nID);
 412                 return false;
 413             }
 414             pwallet->mapMasterKeys[nID] = kMasterKey;
 415             if (pwallet->nMasterKeyMaxID < nID)
 416                 pwallet->nMasterKeyMaxID = nID;
 417         }
 418         else if (strType == "ckey")
 419         {
 420             CPubKey vchPubKey;
 421             ssKey >> vchPubKey;
 422             if (!vchPubKey.IsValid())
 423             {
 424                 strErr = "Error reading wallet database: CPubKey corrupt";
 425                 return false;
 426             }
 427             std::vector<unsigned char> vchPrivKey;
 428             ssValue >> vchPrivKey;
 429             wss.nCKeys++;
 430
 431             if (!pwallet->LoadCryptedKey(vchPubKey, vchPrivKey))
 432             {
 433                 strErr = "Error reading wallet database: LoadCryptedKey failed";
 434                 return false;
 435             }
 436             wss.fIsEncrypted = true;
 437         }
 438         else if (strType == "keymeta" || strType == "watchmeta")
 439         {
 440             CTxDestination keyID;
 441             if (strType == "keymeta")
 442             {
 443               CPubKey vchPubKey;
 444               ssKey >> vchPubKey;
 445               keyID = vchPubKey.GetID();
 446             }
 447             else if (strType == "watchmeta")
 448             {
 449               CScript script;
 450               ssKey >> *(CScriptBase*)(&script);
 451               keyID = CScriptID(script);
 452             }
 453
 454             CKeyMetadata keyMeta;
 455             ssValue >> keyMeta;
 456             wss.nKeyMeta++;
 457
 458             pwallet->LoadKeyMetadata(keyID, keyMeta);
 459         }
 460         else if (strType == "defaultkey")
 461         {
 462             ssValue >> pwallet->vchDefaultKey;
 463         }
 464         else if (strType == "pool")
 465         {
 466             int64_t nIndex;
 467             ssKey >> nIndex;
 468             CKeyPool keypool;
 469             ssValue >> keypool;
 470
 471             pwallet->LoadKeyPool(nIndex, keypool);
 472         }
 473         else if (strType == "version")
 474         {
 475             ssValue >> wss.nFileVersion;
 476             if (wss.nFileVersion == 10300)
 477                 wss.nFileVersion = 300;
 478         }
 479         else if (strType == "cscript")
 480         {
 481             uint160 hash;
 482             ssKey >> hash;
 483             CScript script;
 484             ssValue >> *(CScriptBase*)(&script);
 485             if (!pwallet->LoadCScript(script))
 486             {
 487                 strErr = "Error reading wallet database: LoadCScript failed";
 488                 return false;
 489             }
 490         }
 491         else if (strType == "orderposnext")
 492         {
 493             ssValue >> pwallet->nOrderPosNext;
 494         }
 495         else if (strType == "destdata")
 496         {
 497             std::string strAddress, strKey, strValue;
 498             ssKey >> strAddress;
 499             ssKey >> strKey;
 500             ssValue >> strValue;
 501             if (!pwallet->LoadDestData(CBitcoinAddress(strAddress).Get(), strKey, strValue))
 502             {
 503                 strErr = "Error reading wallet database: LoadDestData failed";
 504                 return false;
 505             }
 506         }
 507         else if (strType == "hdchain")
 508         {
 509             CHDChain chain;
 510             ssValue >> chain;
 511             if (!pwallet->SetHDChain(chain, true))
 512             {
 513                 strErr = "Error reading wallet database: SetHDChain failed";
 514                 return false;
 515             }
 516         }
 517     } catch (...)
 518     {
 519         return false;
 520     }
 521     return true;
 522 }
 523
 524 bool CWalletDB::IsKeyType(const std::string& strType)
 525 {
 526     return (strType== "key" || strType == "wkey" ||
 527             strType == "mkey" || strType == "ckey");
 528 }
 529
 530 DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
 531 {
 532     pwallet->vchDefaultKey = CPubKey();
 533     CWalletScanState wss;
 534     bool fNoncriticalErrors = false;
 535     DBErrors result = DB_LOAD_OK;
 536
 537     LOCK(pwallet->cs_wallet);
 538     try {
 539         int nMinVersion = 0;
 540         if (batch.Read((std::string)"minversion", nMinVersion))
 541         {
 542             if (nMinVersion > CLIENT_VERSION)
 543                 return DB_TOO_NEW;
 544             pwallet->LoadMinVersion(nMinVersion);
 545         }
 546
 547         // Get cursor
 548         Dbc* pcursor = batch.GetCursor();
 549         if (!pcursor)
 550         {
 551             LogPrintf("Error getting wallet database cursor\n");
 552             return DB_CORRUPT;
 553         }
 554
 555         while (true)
 556         {
 557             // Read next record
 558             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 559             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 560             int ret = batch.ReadAtCursor(pcursor, ssKey, ssValue);
 561             if (ret == DB_NOTFOUND)
 562                 break;
 563             else if (ret != 0)
 564             {
 565                 LogPrintf("Error reading next record from wallet database\n");
 566                 return DB_CORRUPT;
 567             }
 568
 569             // Try to be tolerant of single corrupt records:
 570             std::string strType, strErr;
 571             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr))
 572             {
 573                 // losing keys is considered a catastrophic error, anything else
 574                 // we assume the user can live with:
 575                 if (IsKeyType(strType))
 576                     result = DB_CORRUPT;
 577                 else
 578                 {
 579                     // Leave other errors alone, if we try to fix them we might make things worse.
 580                     fNoncriticalErrors = true; // ... but do warn the user there is something wrong.
 581                     if (strType == "tx")
 582                         // Rescan if there is a bad transaction record:
 583                         SoftSetBoolArg("-rescan", true);
 584                 }
 585             }
 586             if (!strErr.empty())
 587                 LogPrintf("%s\n", strErr);
 588         }
 589         pcursor->close();
 590     }
 591     catch (const boost::thread_interrupted&) {
 592         throw;
 593     }
 594     catch (...) {
 595         result = DB_CORRUPT;
 596     }
 597
 598     if (fNoncriticalErrors && result == DB_LOAD_OK)
 599         result = DB_NONCRITICAL_ERROR;
 600
 601     // Any wallet corruption at all: skip any rewriting or
 602     // upgrading, we don't want to make it worse.
 603     if (result != DB_LOAD_OK)
 604         return result;
 605
 606     LogPrintf("nFileVersion = %d\n", wss.nFileVersion);
 607
 608     LogPrintf("Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total\n",
 609            wss.nKeys, wss.nCKeys, wss.nKeyMeta, wss.nKeys + wss.nCKeys);
 610
 611     // nTimeFirstKey is only reliable if all keys have metadata
 612     if ((wss.nKeys + wss.nCKeys + wss.nWatchKeys) != wss.nKeyMeta)
 613         pwallet->UpdateTimeFirstKey(1);
 614
 615     BOOST_FOREACH(uint256 hash, wss.vWalletUpgrade)
 616         WriteTx(pwallet->mapWallet[hash]);
 617
 618     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
 619     if (wss.fIsEncrypted && (wss.nFileVersion == 40000 || wss.nFileVersion == 50000))
 620         return DB_NEED_REWRITE;
 621
 622     if (wss.nFileVersion < CLIENT_VERSION) // Update
 623         WriteVersion(CLIENT_VERSION);
 624
 625     if (wss.fAnyUnordered)
 626         result = pwallet->ReorderTransactions();
 627
 628     pwallet->laccentries.clear();
 629     ListAccountCreditDebit("*", pwallet->laccentries);
 630     BOOST_FOREACH(CAccountingEntry& entry, pwallet->laccentries) {
 631         pwallet->wtxOrdered.insert(make_pair(entry.nOrderPos, CWallet::TxPair((CWalletTx*)0, &entry)));
 632     }
 633
 634     return result;
 635 }
 636
 637 DBErrors CWalletDB::FindWalletTx(std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx)
 638 {
 639     bool fNoncriticalErrors = false;
 640     DBErrors result = DB_LOAD_OK;
 641
 642     try {
 643         int nMinVersion = 0;
 644         if (batch.Read((std::string)"minversion", nMinVersion))
 645         {
 646             if (nMinVersion > CLIENT_VERSION)
 647                 return DB_TOO_NEW;
 648         }
 649
 650         // Get cursor
 651         Dbc* pcursor = batch.GetCursor();
 652         if (!pcursor)
 653         {
 654             LogPrintf("Error getting wallet database cursor\n");
 655             return DB_CORRUPT;
 656         }
 657
 658         while (true)
 659         {
 660             // Read next record
 661             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 662             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 663             int ret = batch.ReadAtCursor(pcursor, ssKey, ssValue);
 664             if (ret == DB_NOTFOUND)
 665                 break;
 666             else if (ret != 0)
 667             {
 668                 LogPrintf("Error reading next record from wallet database\n");
 669                 return DB_CORRUPT;
 670             }
 671
 672             std::string strType;
 673             ssKey >> strType;
 674             if (strType == "tx") {
 675                 uint256 hash;
 676                 ssKey >> hash;
 677
 678                 CWalletTx wtx;
 679                 ssValue >> wtx;
 680
 681                 vTxHash.push_back(hash);
 682                 vWtx.push_back(wtx);
 683             }
 684         }
 685         pcursor->close();
 686     }
 687     catch (const boost::thread_interrupted&) {
 688         throw;
 689     }
 690     catch (...) {
 691         result = DB_CORRUPT;
 692     }
 693
 694     if (fNoncriticalErrors && result == DB_LOAD_OK)
 695         result = DB_NONCRITICAL_ERROR;
 696
 697     return result;
 698 }
 699
 700 DBErrors CWalletDB::ZapSelectTx(std::vector<uint256>& vTxHashIn, std::vector<uint256>& vTxHashOut)
 701 {
 702     // build list of wallet TXs and hashes
 703     std::vector<uint256> vTxHash;
 704     std::vector<CWalletTx> vWtx;
 705     DBErrors err = FindWalletTx(vTxHash, vWtx);
 706     if (err != DB_LOAD_OK) {
 707         return err;
 708     }
 709
 710     std::sort(vTxHash.begin(), vTxHash.end());
 711     std::sort(vTxHashIn.begin(), vTxHashIn.end());
 712
 713     // erase each matching wallet TX
 714     bool delerror = false;
 715     std::vector<uint256>::iterator it = vTxHashIn.begin();
 716     BOOST_FOREACH (uint256 hash, vTxHash) {
 717         while (it < vTxHashIn.end() && (*it) < hash) {
 718             it++;
 719         }
 720         if (it == vTxHashIn.end()) {
 721             break;
 722         }
 723         else if ((*it) == hash) {
 724             if(!EraseTx(hash)) {
 725                 LogPrint(BCLog::DB, "Transaction was found for deletion but returned database error: %s\n", hash.GetHex());
 726                 delerror = true;
 727             }
 728             vTxHashOut.push_back(hash);
 729         }
 730     }
 731
 732     if (delerror) {
 733         return DB_CORRUPT;
 734     }
 735     return DB_LOAD_OK;
 736 }
 737
 738 DBErrors CWalletDB::ZapWalletTx(std::vector<CWalletTx>& vWtx)
 739 {
 740     // build list of wallet TXs
 741     std::vector<uint256> vTxHash;
 742     DBErrors err = FindWalletTx(vTxHash, vWtx);
 743     if (err != DB_LOAD_OK)
 744         return err;
 745
 746     // erase each wallet TX
 747     BOOST_FOREACH (uint256& hash, vTxHash) {
 748         if (!EraseTx(hash))
 749             return DB_CORRUPT;
 750     }
 751
 752     return DB_LOAD_OK;
 753 }
 754
 755 void MaybeCompactWalletDB()
 756 {
 757     static std::atomic<bool> fOneThread;
 758     if (fOneThread.exchange(true)) {
 759         return;
 760     }
 761     if (!GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
 762         return;
 763     }
 764
 765     for (CWalletRef pwallet : vpwallets) {
 766         CWalletDBWrapper& dbh = pwallet->GetDBHandle();
 767
 768         unsigned int nUpdateCounter = dbh.nUpdateCounter;
 769
 770         if (dbh.nLastSeen != nUpdateCounter) {
 771             dbh.nLastSeen = nUpdateCounter;
 772             dbh.nLastWalletUpdate = GetTime();
 773         }
 774
 775         if (dbh.nLastFlushed != nUpdateCounter && GetTime() - dbh.nLastWalletUpdate >= 2) {
 776             if (CDB::PeriodicFlush(dbh)) {
 777                 dbh.nLastFlushed = nUpdateCounter;
 778             }
 779         }
 780     }
 781
 782     fOneThread = false;
 783 }
 784
 785 //
 786 // Try to (very carefully!) recover wallet file if there is a problem.
 787 //
 788 bool CWalletDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename)
 789 {
 790     return CDB::Recover(filename, callbackDataIn, recoverKVcallback, out_backup_filename);
 791 }
 792
 793 bool CWalletDB::Recover(const std::string& filename, std::string& out_backup_filename)
 794 {
 795     // recover without a key filter callback
 796     // results in recovering all record types
 797     return CWalletDB::Recover(filename, NULL, NULL, out_backup_filename);
 798 }
 799
 800 bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue)
 801 {
 802     CWallet *dummyWallet = reinterpret_cast<CWallet*>(callbackData);
 803     CWalletScanState dummyWss;
 804     std::string strType, strErr;
 805     bool fReadOK;
 806     {
 807         // Required in LoadKeyMetadata():
 808         LOCK(dummyWallet->cs_wallet);
 809         fReadOK = ReadKeyValue(dummyWallet, ssKey, ssValue,
 810                                dummyWss, strType, strErr);
 811     }
 812     if (!IsKeyType(strType) && strType != "hdchain")
 813         return false;
 814     if (!fReadOK)
 815     {
 816         LogPrintf("WARNING: CWalletDB::Recover skipping %s: %s\n", strType, strErr);
 817         return false;
 818     }
 819
 820     return true;
 821 }
 822
 823 bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& dataDir, std::string& errorStr)
 824 {
 825     return CDB::VerifyEnvironment(walletFile, dataDir, errorStr);
 826 }
 827
 828 bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& dataDir, std::string& warningStr, std::string& errorStr)
 829 {
 830     return CDB::VerifyDatabaseFile(walletFile, dataDir, warningStr, errorStr, CWalletDB::Recover);
 831 }
 832
 833 bool CWalletDB::WriteDestData(const std::string &address, const std::string &key, const std::string &value)
 834 {
 835     return WriteIC(std::make_pair(std::string("destdata"), std::make_pair(address, key)), value);
 836 }
 837
 838 bool CWalletDB::EraseDestData(const std::string &address, const std::string &key)
 839 {
 840     return EraseIC(std::make_pair(std::string("destdata"), std::make_pair(address, key)));
 841 }
 842
 843
 844 bool CWalletDB::WriteHDChain(const CHDChain& chain)
 845 {
 846     return WriteIC(std::string("hdchain"), chain);
 847 }
 848
 849 bool CWalletDB::TxnBegin()
 850 {
 851     return batch.TxnBegin();
 852 }
 853
 854 bool CWalletDB::TxnCommit()
 855 {
 856     return batch.TxnCommit();
 857 }
 858
 859 bool CWalletDB::TxnAbort()
 860 {
 861     return batch.TxnAbort();
 862 }
 863
 864 bool CWalletDB::ReadVersion(int& nVersion)
 865 {
 866     return batch.ReadVersion(nVersion);
 867 }
 868
 869 bool CWalletDB::WriteVersion(int nVersion)
 870 {
 871     return batch.WriteVersion(nVersion);
 872 }