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/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" || strType == "watchmeta")
 427         {
 428             CTxDestination keyID;
 429             if (strType == "keymeta")
 430             {
 431               CPubKey vchPubKey;
 432               ssKey >> vchPubKey;
 433               keyID = vchPubKey.GetID();
 434             }
 435             else if (strType == "watchmeta")
 436             {
 437               CScript script;
 438               ssKey >> script;
 439               keyID = CScriptID(script);
 440             }
 441
 442             CKeyMetadata keyMeta;
 443             ssValue >> keyMeta;
 444             wss.nKeyMeta++;
 445
 446             pwallet->LoadKeyMetadata(keyID, keyMeta);
 447         }
 448         else if (strType == "defaultkey")
 449         {
 450             // We don't want or need the default key, but if there is one set,
 451             // we want to make sure that it is valid so that we can detect corruption
 452             CPubKey vchPubKey;
 453             ssValue >> vchPubKey;
 454             if (!vchPubKey.IsValid()) {
 455                 strErr = "Error reading wallet database: Default Key corrupt";
 456                 return false;
 457             }
 458         }
 459         else if (strType == "pool")
 460         {
 461             int64_t nIndex;
 462             ssKey >> nIndex;
 463             CKeyPool keypool;
 464             ssValue >> keypool;
 465
 466             pwallet->LoadKeyPool(nIndex, keypool);
 467         }
 468         else if (strType == "version")
 469         {
 470             ssValue >> wss.nFileVersion;
 471             if (wss.nFileVersion == 10300)
 472                 wss.nFileVersion = 300;
 473         }
 474         else if (strType == "cscript")
 475         {
 476             uint160 hash;
 477             ssKey >> hash;
 478             CScript script;
 479             ssValue >> script;
 480             if (!pwallet->LoadCScript(script))
 481             {
 482                 strErr = "Error reading wallet database: LoadCScript failed";
 483                 return false;
 484             }
 485         }
 486         else if (strType == "orderposnext")
 487         {
 488             ssValue >> pwallet->nOrderPosNext;
 489         }
 490         else if (strType == "destdata")
 491         {
 492             std::string strAddress, strKey, strValue;
 493             ssKey >> strAddress;
 494             ssKey >> strKey;
 495             ssValue >> strValue;
 496             if (!pwallet->LoadDestData(DecodeDestination(strAddress), strKey, strValue))
 497             {
 498                 strErr = "Error reading wallet database: LoadDestData failed";
 499                 return false;
 500             }
 501         }
 502         else if (strType == "hdchain")
 503         {
 504             CHDChain chain;
 505             ssValue >> chain;
 506             if (!pwallet->SetHDChain(chain, true))
 507             {
 508                 strErr = "Error reading wallet database: SetHDChain failed";
 509                 return false;
 510             }
 511         }
 512     } catch (...)
 513     {
 514         return false;
 515     }
 516     return true;
 517 }
 518
 519 bool CWalletDB::IsKeyType(const std::string& strType)
 520 {
 521     return (strType== "key" || strType == "wkey" ||
 522             strType == "mkey" || strType == "ckey");
 523 }
 524
 525 DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
 526 {
 527     CWalletScanState wss;
 528     bool fNoncriticalErrors = false;
 529     DBErrors result = DB_LOAD_OK;
 530
 531     LOCK(pwallet->cs_wallet);
 532     try {
 533         int nMinVersion = 0;
 534         if (batch.Read((std::string)"minversion", nMinVersion))
 535         {
 536             if (nMinVersion > CLIENT_VERSION)
 537                 return DB_TOO_NEW;
 538             pwallet->LoadMinVersion(nMinVersion);
 539         }
 540
 541         // Get cursor
 542         Dbc* pcursor = batch.GetCursor();
 543         if (!pcursor)
 544         {
 545             LogPrintf("Error getting wallet database cursor\n");
 546             return DB_CORRUPT;
 547         }
 548
 549         while (true)
 550         {
 551             // Read next record
 552             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 553             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 554             int ret = batch.ReadAtCursor(pcursor, ssKey, ssValue);
 555             if (ret == DB_NOTFOUND)
 556                 break;
 557             else if (ret != 0)
 558             {
 559                 LogPrintf("Error reading next record from wallet database\n");
 560                 return DB_CORRUPT;
 561             }
 562
 563             // Try to be tolerant of single corrupt records:
 564             std::string strType, strErr;
 565             if (!ReadKeyValue(pwallet, ssKey, ssValue, wss, strType, strErr))
 566             {
 567                 // losing keys is considered a catastrophic error, anything else
 568                 // we assume the user can live with:
 569                 if (IsKeyType(strType) || strType == "defaultkey")
 570                     result = DB_CORRUPT;
 571                 else
 572                 {
 573                     // Leave other errors alone, if we try to fix them we might make things worse.
 574                     fNoncriticalErrors = true; // ... but do warn the user there is something wrong.
 575                     if (strType == "tx")
 576                         // Rescan if there is a bad transaction record:
 577                         gArgs.SoftSetBoolArg("-rescan", true);
 578                 }
 579             }
 580             if (!strErr.empty())
 581                 LogPrintf("%s\n", strErr);
 582         }
 583         pcursor->close();
 584     }
 585     catch (const boost::thread_interrupted&) {
 586         throw;
 587     }
 588     catch (...) {
 589         result = DB_CORRUPT;
 590     }
 591
 592     if (fNoncriticalErrors && result == DB_LOAD_OK)
 593         result = DB_NONCRITICAL_ERROR;
 594
 595     // Any wallet corruption at all: skip any rewriting or
 596     // upgrading, we don't want to make it worse.
 597     if (result != DB_LOAD_OK)
 598         return result;
 599
 600     LogPrintf("nFileVersion = %d\n", wss.nFileVersion);
 601
 602     LogPrintf("Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total\n",
 603            wss.nKeys, wss.nCKeys, wss.nKeyMeta, wss.nKeys + wss.nCKeys);
 604
 605     // nTimeFirstKey is only reliable if all keys have metadata
 606     if ((wss.nKeys + wss.nCKeys + wss.nWatchKeys) != wss.nKeyMeta)
 607         pwallet->UpdateTimeFirstKey(1);
 608
 609     for (uint256 hash : wss.vWalletUpgrade)
 610         WriteTx(pwallet->mapWallet[hash]);
 611
 612     // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
 613     if (wss.fIsEncrypted && (wss.nFileVersion == 40000 || wss.nFileVersion == 50000))
 614         return DB_NEED_REWRITE;
 615
 616     if (wss.nFileVersion < CLIENT_VERSION) // Update
 617         WriteVersion(CLIENT_VERSION);
 618
 619     if (wss.fAnyUnordered)
 620         result = pwallet->ReorderTransactions();
 621
 622     pwallet->laccentries.clear();
 623     ListAccountCreditDebit("*", pwallet->laccentries);
 624     for (CAccountingEntry& entry : pwallet->laccentries) {
 625         pwallet->wtxOrdered.insert(make_pair(entry.nOrderPos, CWallet::TxPair(nullptr, &entry)));
 626     }
 627
 628     return result;
 629 }
 630
 631 DBErrors CWalletDB::FindWalletTx(std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx)
 632 {
 633     bool fNoncriticalErrors = false;
 634     DBErrors result = DB_LOAD_OK;
 635
 636     try {
 637         int nMinVersion = 0;
 638         if (batch.Read((std::string)"minversion", nMinVersion))
 639         {
 640             if (nMinVersion > CLIENT_VERSION)
 641                 return DB_TOO_NEW;
 642         }
 643
 644         // Get cursor
 645         Dbc* pcursor = batch.GetCursor();
 646         if (!pcursor)
 647         {
 648             LogPrintf("Error getting wallet database cursor\n");
 649             return DB_CORRUPT;
 650         }
 651
 652         while (true)
 653         {
 654             // Read next record
 655             CDataStream ssKey(SER_DISK, CLIENT_VERSION);
 656             CDataStream ssValue(SER_DISK, CLIENT_VERSION);
 657             int ret = batch.ReadAtCursor(pcursor, ssKey, ssValue);
 658             if (ret == DB_NOTFOUND)
 659                 break;
 660             else if (ret != 0)
 661             {
 662                 LogPrintf("Error reading next record from wallet database\n");
 663                 return DB_CORRUPT;
 664             }
 665
 666             std::string strType;
 667             ssKey >> strType;
 668             if (strType == "tx") {
 669                 uint256 hash;
 670                 ssKey >> hash;
 671
 672                 CWalletTx wtx;
 673                 ssValue >> wtx;
 674
 675                 vTxHash.push_back(hash);
 676                 vWtx.push_back(wtx);
 677             }
 678         }
 679         pcursor->close();
 680     }
 681     catch (const boost::thread_interrupted&) {
 682         throw;
 683     }
 684     catch (...) {
 685         result = DB_CORRUPT;
 686     }
 687
 688     if (fNoncriticalErrors && result == DB_LOAD_OK)
 689         result = DB_NONCRITICAL_ERROR;
 690
 691     return result;
 692 }
 693
 694 DBErrors CWalletDB::ZapSelectTx(std::vector<uint256>& vTxHashIn, std::vector<uint256>& vTxHashOut)
 695 {
 696     // build list of wallet TXs and hashes
 697     std::vector<uint256> vTxHash;
 698     std::vector<CWalletTx> vWtx;
 699     DBErrors err = FindWalletTx(vTxHash, vWtx);
 700     if (err != DB_LOAD_OK) {
 701         return err;
 702     }
 703
 704     std::sort(vTxHash.begin(), vTxHash.end());
 705     std::sort(vTxHashIn.begin(), vTxHashIn.end());
 706
 707     // erase each matching wallet TX
 708     bool delerror = false;
 709     std::vector<uint256>::iterator it = vTxHashIn.begin();
 710     for (uint256 hash : vTxHash) {
 711         while (it < vTxHashIn.end() && (*it) < hash) {
 712             it++;
 713         }
 714         if (it == vTxHashIn.end()) {
 715             break;
 716         }
 717         else if ((*it) == hash) {
 718             if(!EraseTx(hash)) {
 719                 LogPrint(BCLog::DB, "Transaction was found for deletion but returned database error: %s\n", hash.GetHex());
 720                 delerror = true;
 721             }
 722             vTxHashOut.push_back(hash);
 723         }
 724     }
 725
 726     if (delerror) {
 727         return DB_CORRUPT;
 728     }
 729     return DB_LOAD_OK;
 730 }
 731
 732 DBErrors CWalletDB::ZapWalletTx(std::vector<CWalletTx>& vWtx)
 733 {
 734     // build list of wallet TXs
 735     std::vector<uint256> vTxHash;
 736     DBErrors err = FindWalletTx(vTxHash, vWtx);
 737     if (err != DB_LOAD_OK)
 738         return err;
 739
 740     // erase each wallet TX
 741     for (uint256& hash : vTxHash) {
 742         if (!EraseTx(hash))
 743             return DB_CORRUPT;
 744     }
 745
 746     return DB_LOAD_OK;
 747 }
 748
 749 void MaybeCompactWalletDB()
 750 {
 751     static std::atomic<bool> fOneThread(false);
 752     if (fOneThread.exchange(true)) {
 753         return;
 754     }
 755     if (!gArgs.GetBoolArg("-flushwallet", DEFAULT_FLUSHWALLET)) {
 756         return;
 757     }
 758
 759     for (CWalletRef pwallet : vpwallets) {
 760         CWalletDBWrapper& dbh = pwallet->GetDBHandle();
 761
 762         unsigned int nUpdateCounter = dbh.nUpdateCounter;
 763
 764         if (dbh.nLastSeen != nUpdateCounter) {
 765             dbh.nLastSeen = nUpdateCounter;
 766             dbh.nLastWalletUpdate = GetTime();
 767         }
 768
 769         if (dbh.nLastFlushed != nUpdateCounter && GetTime() - dbh.nLastWalletUpdate >= 2) {
 770             if (CDB::PeriodicFlush(dbh)) {
 771                 dbh.nLastFlushed = nUpdateCounter;
 772             }
 773         }
 774     }
 775
 776     fOneThread = false;
 777 }
 778
 779 //
 780 // Try to (very carefully!) recover wallet file if there is a problem.
 781 //
 782 bool CWalletDB::Recover(const std::string& filename, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename)
 783 {
 784     return CDB::Recover(filename, callbackDataIn, recoverKVcallback, out_backup_filename);
 785 }
 786
 787 bool CWalletDB::Recover(const std::string& filename, std::string& out_backup_filename)
 788 {
 789     // recover without a key filter callback
 790     // results in recovering all record types
 791     return CWalletDB::Recover(filename, nullptr, nullptr, out_backup_filename);
 792 }
 793
 794 bool CWalletDB::RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue)
 795 {
 796     CWallet *dummyWallet = reinterpret_cast<CWallet*>(callbackData);
 797     CWalletScanState dummyWss;
 798     std::string strType, strErr;
 799     bool fReadOK;
 800     {
 801         // Required in LoadKeyMetadata():
 802         LOCK(dummyWallet->cs_wallet);
 803         fReadOK = ReadKeyValue(dummyWallet, ssKey, ssValue,
 804                                dummyWss, strType, strErr);
 805     }
 806     if (!IsKeyType(strType) && strType != "hdchain")
 807         return false;
 808     if (!fReadOK)
 809     {
 810         LogPrintf("WARNING: CWalletDB::Recover skipping %s: %s\n", strType, strErr);
 811         return false;
 812     }
 813
 814     return true;
 815 }
 816
 817 bool CWalletDB::VerifyEnvironment(const std::string& walletFile, const fs::path& walletDir, std::string& errorStr)
 818 {
 819     return CDB::VerifyEnvironment(walletFile, walletDir, errorStr);
 820 }
 821
 822 bool CWalletDB::VerifyDatabaseFile(const std::string& walletFile, const fs::path& walletDir, std::string& warningStr, std::string& errorStr)
 823 {
 824     return CDB::VerifyDatabaseFile(walletFile, walletDir, warningStr, errorStr, CWalletDB::Recover);
 825 }
 826
 827 bool CWalletDB::WriteDestData(const std::string &address, const std::string &key, const std::string &value)
 828 {
 829     return WriteIC(std::make_pair(std::string("destdata"), std::make_pair(address, key)), value);
 830 }
 831
 832 bool CWalletDB::EraseDestData(const std::string &address, const std::string &key)
 833 {
 834     return EraseIC(std::make_pair(std::string("destdata"), std::make_pair(address, key)));
 835 }
 836
 837
 838 bool CWalletDB::WriteHDChain(const CHDChain& chain)
 839 {
 840     return WriteIC(std::string("hdchain"), chain);
 841 }
 842
 843 bool CWalletDB::TxnBegin()
 844 {
 845     return batch.TxnBegin();
 846 }
 847
 848 bool CWalletDB::TxnCommit()
 849 {
 850     return batch.TxnCommit();
 851 }
 852
 853 bool CWalletDB::TxnAbort()
 854 {
 855     return batch.TxnAbort();
 856 }
 857
 858 bool CWalletDB::ReadVersion(int& nVersion)
 859 {
 860     return batch.ReadVersion(nVersion);
 861 }
 862
 863 bool CWalletDB::WriteVersion(int nVersion)
 864 {
 865     return batch.WriteVersion(nVersion);
 866 }