src/wallet/walletdb.cpp

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