mirror of
https://github.com/bitcoin/bitcoin.git
synced 2026-01-21 15:50:07 +01:00
fae51a5c6f
Common errors and warnings should be translated when displayed in the GUI, but not translated when displayed elsewhere. The wallet method CreateWalletFromFile does not know its caller, so this commit changes it to return a bilingual_str to the caller.
298 lines
10 KiB
C++
298 lines
10 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2020 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_WALLET_WALLETDB_H
|
|
#define BITCOIN_WALLET_WALLETDB_H
|
|
|
|
#include <amount.h>
|
|
#include <script/sign.h>
|
|
#include <wallet/db.h>
|
|
#include <wallet/walletutil.h>
|
|
#include <key.h>
|
|
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
/**
|
|
* Overview of wallet database classes:
|
|
*
|
|
* - WalletBatch is an abstract modifier object for the wallet database, and encapsulates a database
|
|
* batch update as well as methods to act on the database. It should be agnostic to the database implementation.
|
|
*
|
|
* The following classes are implementation specific:
|
|
* - BerkeleyEnvironment is an environment in which the database exists.
|
|
* - BerkeleyDatabase represents a wallet database.
|
|
* - BerkeleyBatch is a low-level database batch update.
|
|
*/
|
|
|
|
static const bool DEFAULT_FLUSHWALLET = true;
|
|
|
|
struct CBlockLocator;
|
|
class CKeyPool;
|
|
class CMasterKey;
|
|
class CScript;
|
|
class CWallet;
|
|
class CWalletTx;
|
|
class uint160;
|
|
class uint256;
|
|
|
|
/** Backend-agnostic database type. */
|
|
using WalletDatabase = BerkeleyDatabase;
|
|
|
|
/** Error statuses for the wallet database */
|
|
enum class DBErrors
|
|
{
|
|
LOAD_OK,
|
|
CORRUPT,
|
|
NONCRITICAL_ERROR,
|
|
TOO_NEW,
|
|
LOAD_FAIL,
|
|
NEED_REWRITE
|
|
};
|
|
|
|
namespace DBKeys {
|
|
extern const std::string ACENTRY;
|
|
extern const std::string ACTIVEEXTERNALSPK;
|
|
extern const std::string ACTIVEINTERNALSPK;
|
|
extern const std::string BESTBLOCK;
|
|
extern const std::string BESTBLOCK_NOMERKLE;
|
|
extern const std::string CRYPTED_KEY;
|
|
extern const std::string CSCRIPT;
|
|
extern const std::string DEFAULTKEY;
|
|
extern const std::string DESTDATA;
|
|
extern const std::string FLAGS;
|
|
extern const std::string HDCHAIN;
|
|
extern const std::string KEY;
|
|
extern const std::string KEYMETA;
|
|
extern const std::string MASTER_KEY;
|
|
extern const std::string MINVERSION;
|
|
extern const std::string NAME;
|
|
extern const std::string OLD_KEY;
|
|
extern const std::string ORDERPOSNEXT;
|
|
extern const std::string POOL;
|
|
extern const std::string PURPOSE;
|
|
extern const std::string SETTINGS;
|
|
extern const std::string TX;
|
|
extern const std::string VERSION;
|
|
extern const std::string WALLETDESCRIPTOR;
|
|
extern const std::string WALLETDESCRIPTORCKEY;
|
|
extern const std::string WALLETDESCRIPTORKEY;
|
|
extern const std::string WATCHMETA;
|
|
extern const std::string WATCHS;
|
|
} // namespace DBKeys
|
|
|
|
/* simple HD chain data model */
|
|
class CHDChain
|
|
{
|
|
public:
|
|
uint32_t nExternalChainCounter;
|
|
uint32_t nInternalChainCounter;
|
|
CKeyID seed_id; //!< seed hash160
|
|
|
|
static const int VERSION_HD_BASE = 1;
|
|
static const int VERSION_HD_CHAIN_SPLIT = 2;
|
|
static const int CURRENT_VERSION = VERSION_HD_CHAIN_SPLIT;
|
|
int nVersion;
|
|
|
|
CHDChain() { SetNull(); }
|
|
ADD_SERIALIZE_METHODS;
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action)
|
|
{
|
|
READWRITE(this->nVersion);
|
|
READWRITE(nExternalChainCounter);
|
|
READWRITE(seed_id);
|
|
if (this->nVersion >= VERSION_HD_CHAIN_SPLIT)
|
|
READWRITE(nInternalChainCounter);
|
|
}
|
|
|
|
void SetNull()
|
|
{
|
|
nVersion = CHDChain::CURRENT_VERSION;
|
|
nExternalChainCounter = 0;
|
|
nInternalChainCounter = 0;
|
|
seed_id.SetNull();
|
|
}
|
|
};
|
|
|
|
class CKeyMetadata
|
|
{
|
|
public:
|
|
static const int VERSION_BASIC=1;
|
|
static const int VERSION_WITH_HDDATA=10;
|
|
static const int VERSION_WITH_KEY_ORIGIN = 12;
|
|
static const int CURRENT_VERSION=VERSION_WITH_KEY_ORIGIN;
|
|
int nVersion;
|
|
int64_t nCreateTime; // 0 means unknown
|
|
std::string hdKeypath; //optional HD/bip32 keypath. Still used to determine whether a key is a seed. Also kept for backwards compatibility
|
|
CKeyID hd_seed_id; //id of the HD seed used to derive this key
|
|
KeyOriginInfo key_origin; // Key origin info with path and fingerprint
|
|
bool has_key_origin = false; //!< Whether the key_origin is useful
|
|
|
|
CKeyMetadata()
|
|
{
|
|
SetNull();
|
|
}
|
|
explicit CKeyMetadata(int64_t nCreateTime_)
|
|
{
|
|
SetNull();
|
|
nCreateTime = nCreateTime_;
|
|
}
|
|
|
|
ADD_SERIALIZE_METHODS;
|
|
|
|
template <typename Stream, typename Operation>
|
|
inline void SerializationOp(Stream& s, Operation ser_action) {
|
|
READWRITE(this->nVersion);
|
|
READWRITE(nCreateTime);
|
|
if (this->nVersion >= VERSION_WITH_HDDATA)
|
|
{
|
|
READWRITE(hdKeypath);
|
|
READWRITE(hd_seed_id);
|
|
}
|
|
if (this->nVersion >= VERSION_WITH_KEY_ORIGIN)
|
|
{
|
|
READWRITE(key_origin);
|
|
READWRITE(has_key_origin);
|
|
}
|
|
}
|
|
|
|
void SetNull()
|
|
{
|
|
nVersion = CKeyMetadata::CURRENT_VERSION;
|
|
nCreateTime = 0;
|
|
hdKeypath.clear();
|
|
hd_seed_id.SetNull();
|
|
key_origin.clear();
|
|
has_key_origin = false;
|
|
}
|
|
};
|
|
|
|
/** Access to the wallet database.
|
|
* Opens the database and provides read and write access to it. Each read and write is its own transaction.
|
|
* Multiple operation transactions can be started using TxnBegin() and committed using TxnCommit()
|
|
* Otherwise the transaction will be committed when the object goes out of scope.
|
|
* Optionally (on by default) it will flush to disk on close.
|
|
* Every 1000 writes will automatically trigger a flush to disk.
|
|
*/
|
|
class WalletBatch
|
|
{
|
|
private:
|
|
template <typename K, typename T>
|
|
bool WriteIC(const K& key, const T& value, bool fOverwrite = true)
|
|
{
|
|
if (!m_batch.Write(key, value, fOverwrite)) {
|
|
return false;
|
|
}
|
|
m_database.IncrementUpdateCounter();
|
|
if (m_database.nUpdateCounter % 1000 == 0) {
|
|
m_batch.Flush();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename K>
|
|
bool EraseIC(const K& key)
|
|
{
|
|
if (!m_batch.Erase(key)) {
|
|
return false;
|
|
}
|
|
m_database.IncrementUpdateCounter();
|
|
if (m_database.nUpdateCounter % 1000 == 0) {
|
|
m_batch.Flush();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public:
|
|
explicit WalletBatch(WalletDatabase& database, const char* pszMode = "r+", bool _fFlushOnClose = true) :
|
|
m_batch(database, pszMode, _fFlushOnClose),
|
|
m_database(database)
|
|
{
|
|
}
|
|
WalletBatch(const WalletBatch&) = delete;
|
|
WalletBatch& operator=(const WalletBatch&) = delete;
|
|
|
|
bool WriteName(const std::string& strAddress, const std::string& strName);
|
|
bool EraseName(const std::string& strAddress);
|
|
|
|
bool WritePurpose(const std::string& strAddress, const std::string& purpose);
|
|
bool ErasePurpose(const std::string& strAddress);
|
|
|
|
bool WriteTx(const CWalletTx& wtx);
|
|
bool EraseTx(uint256 hash);
|
|
|
|
bool WriteKeyMetadata(const CKeyMetadata& meta, const CPubKey& pubkey, const bool overwrite);
|
|
bool WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey, const CKeyMetadata &keyMeta);
|
|
bool WriteCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, const CKeyMetadata &keyMeta);
|
|
bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey);
|
|
|
|
bool WriteCScript(const uint160& hash, const CScript& redeemScript);
|
|
|
|
bool WriteWatchOnly(const CScript &script, const CKeyMetadata &keymeta);
|
|
bool EraseWatchOnly(const CScript &script);
|
|
|
|
bool WriteBestBlock(const CBlockLocator& locator);
|
|
bool ReadBestBlock(CBlockLocator& locator);
|
|
|
|
bool WriteOrderPosNext(int64_t nOrderPosNext);
|
|
|
|
bool ReadPool(int64_t nPool, CKeyPool& keypool);
|
|
bool WritePool(int64_t nPool, const CKeyPool& keypool);
|
|
bool ErasePool(int64_t nPool);
|
|
|
|
bool WriteMinVersion(int nVersion);
|
|
|
|
bool WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const CPrivKey& privkey);
|
|
bool WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret);
|
|
bool WriteDescriptor(const uint256& desc_id, const WalletDescriptor& descriptor);
|
|
bool WriteDescriptorDerivedCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index, uint32_t der_index);
|
|
bool WriteDescriptorParentCache(const CExtPubKey& xpub, const uint256& desc_id, uint32_t key_exp_index);
|
|
|
|
/// Write destination data key,value tuple to database
|
|
bool WriteDestData(const std::string &address, const std::string &key, const std::string &value);
|
|
/// Erase destination data tuple from wallet database
|
|
bool EraseDestData(const std::string &address, const std::string &key);
|
|
|
|
bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256& id, bool internal);
|
|
|
|
DBErrors LoadWallet(CWallet* pwallet);
|
|
DBErrors FindWalletTx(std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
|
|
DBErrors ZapWalletTx(std::vector<CWalletTx>& vWtx);
|
|
DBErrors ZapSelectTx(std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut);
|
|
/* Try to (very carefully!) recover wallet database (with a possible key type filter) */
|
|
static bool Recover(const fs::path& wallet_path, void *callbackDataIn, bool (*recoverKVcallback)(void* callbackData, CDataStream ssKey, CDataStream ssValue), std::string& out_backup_filename);
|
|
/* Recover convenience-function to bypass the key filter callback, called when verify fails, recovers everything */
|
|
static bool Recover(const fs::path& wallet_path, std::string& out_backup_filename);
|
|
/* Recover filter (used as callback), will only let keys (cryptographical keys) as KV/key-type pass through */
|
|
static bool RecoverKeysOnlyFilter(void *callbackData, CDataStream ssKey, CDataStream ssValue);
|
|
/* Function to determine if a certain KV/key-type is a key (cryptographical key) type */
|
|
static bool IsKeyType(const std::string& strType);
|
|
/* verifies the database environment */
|
|
static bool VerifyEnvironment(const fs::path& wallet_path, bilingual_str& errorStr);
|
|
/* verifies the database file */
|
|
static bool VerifyDatabaseFile(const fs::path& wallet_path, std::vector<bilingual_str>& warnings, bilingual_str& errorStr);
|
|
|
|
//! write the hdchain model (external chain child index counter)
|
|
bool WriteHDChain(const CHDChain& chain);
|
|
|
|
bool WriteWalletFlags(const uint64_t flags);
|
|
//! Begin a new transaction
|
|
bool TxnBegin();
|
|
//! Commit current transaction
|
|
bool TxnCommit();
|
|
//! Abort current transaction
|
|
bool TxnAbort();
|
|
private:
|
|
BerkeleyBatch m_batch;
|
|
WalletDatabase& m_database;
|
|
};
|
|
|
|
//! Compacts BDB state so that wallet.dat is self-contained (if there are changes)
|
|
void MaybeCompactWalletDB();
|
|
|
|
#endif // BITCOIN_WALLET_WALLETDB_H
|