[VerusCoin.git] / db.h

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Distributed under the MIT/X11 software license, see the accompanying
// file license.txt or http://www.opensource.org/licenses/mit-license.php.

class CTransaction;
class CTxIndex;
class CDiskBlockIndex;
class CDiskTxPos;
class COutPoint;
class CUser;
class CReview;
class CAddress;
class CWalletTx;
class CAccount;
class CAccountingEntry;
class CBlockLocator;

extern map<string, string> mapAddressBook;
extern CCriticalSection cs_mapAddressBook;
extern vector<unsigned char> vchDefaultKey;
extern bool fClient;
extern int nBestHeight;


extern unsigned int nWalletDBUpdated;
extern DbEnv dbenv;


extern void DBFlush(bool fShutdown);
extern vector<unsigned char> GetKeyFromKeyPool();
extern int64 GetOldestKeyPoolTime();


class CDB
{
protected:
    Db* pdb;
    string strFile;
    vector<DbTxn*> vTxn;
    bool fReadOnly;

    explicit CDB(const char* pszFile, const char* pszMode="r+");
    ~CDB() { Close(); }
public:
    void Close();
private:
    CDB(const CDB&);
    void operator=(const CDB&);

protected:
    template<typename K, typename T>
    bool Read(const K& key, T& value)
    {
        if (!pdb)
            return false;

        // Key
        CDataStream ssKey(SER_DISK);
        ssKey.reserve(1000);
        ssKey << key;
        Dbt datKey(&ssKey[0], ssKey.size());

        // Read
        Dbt datValue;
        datValue.set_flags(DB_DBT_MALLOC);
        int ret = pdb->get(GetTxn(), &datKey, &datValue, 0);
        memset(datKey.get_data(), 0, datKey.get_size());
        if (datValue.get_data() == NULL)
            return false;

        // Unserialize value
        CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK);
        ssValue >> value;

        // Clear and free memory
        memset(datValue.get_data(), 0, datValue.get_size());
        free(datValue.get_data());
        return (ret == 0);
    }

    template<typename K, typename T>
    bool Write(const K& key, const T& value, bool fOverwrite=true)
    {
        if (!pdb)
            return false;
        if (fReadOnly)
            assert(("Write called on database in read-only mode", false));

        // Key
        CDataStream ssKey(SER_DISK);
        ssKey.reserve(1000);
        ssKey << key;
        Dbt datKey(&ssKey[0], ssKey.size());

        // Value
        CDataStream ssValue(SER_DISK);
        ssValue.reserve(10000);
        ssValue << value;
        Dbt datValue(&ssValue[0], ssValue.size());

        // Write
        int ret = pdb->put(GetTxn(), &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));

        // Clear memory in case it was a private key
        memset(datKey.get_data(), 0, datKey.get_size());
        memset(datValue.get_data(), 0, datValue.get_size());
        return (ret == 0);
    }

    template<typename K>
    bool Erase(const K& key)
    {
        if (!pdb)
            return false;
        if (fReadOnly)
            assert(("Erase called on database in read-only mode", false));

        // Key
        CDataStream ssKey(SER_DISK);
        ssKey.reserve(1000);
        ssKey << key;
        Dbt datKey(&ssKey[0], ssKey.size());

        // Erase
        int ret = pdb->del(GetTxn(), &datKey, 0);

        // Clear memory
        memset(datKey.get_data(), 0, datKey.get_size());
        return (ret == 0 || ret == DB_NOTFOUND);
    }

    template<typename K>
    bool Exists(const K& key)
    {
        if (!pdb)
            return false;

        // Key
        CDataStream ssKey(SER_DISK);
        ssKey.reserve(1000);
        ssKey << key;
        Dbt datKey(&ssKey[0], ssKey.size());

        // Exists
        int ret = pdb->exists(GetTxn(), &datKey, 0);

        // Clear memory
        memset(datKey.get_data(), 0, datKey.get_size());
        return (ret == 0);
    }

    Dbc* GetCursor()
    {
        if (!pdb)
            return NULL;
        Dbc* pcursor = NULL;
        int ret = pdb->cursor(NULL, &pcursor, 0);
        if (ret != 0)
            return NULL;
        return pcursor;
    }

    int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags=DB_NEXT)
    {
        // Read at cursor
        Dbt datKey;
        if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
        {
            datKey.set_data(&ssKey[0]);
            datKey.set_size(ssKey.size());
        }
        Dbt datValue;
        if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
        {
            datValue.set_data(&ssValue[0]);
            datValue.set_size(ssValue.size());
        }
        datKey.set_flags(DB_DBT_MALLOC);
        datValue.set_flags(DB_DBT_MALLOC);
        int ret = pcursor->get(&datKey, &datValue, fFlags);
        if (ret != 0)
            return ret;
        else if (datKey.get_data() == NULL || datValue.get_data() == NULL)
            return 99999;

        // Convert to streams
        ssKey.SetType(SER_DISK);
        ssKey.clear();
        ssKey.write((char*)datKey.get_data(), datKey.get_size());
        ssValue.SetType(SER_DISK);
        ssValue.clear();
        ssValue.write((char*)datValue.get_data(), datValue.get_size());

        // Clear and free memory
        memset(datKey.get_data(), 0, datKey.get_size());
        memset(datValue.get_data(), 0, datValue.get_size());
        free(datKey.get_data());
        free(datValue.get_data());
        return 0;
    }

    DbTxn* GetTxn()
    {
        if (!vTxn.empty())
            return vTxn.back();
        else
            return NULL;
    }

public:
    bool TxnBegin()
    {
        if (!pdb)
            return false;
        DbTxn* ptxn = NULL;
        int ret = dbenv.txn_begin(GetTxn(), &ptxn, DB_TXN_NOSYNC);
        if (!ptxn || ret != 0)
            return false;
        vTxn.push_back(ptxn);
        return true;
    }

    bool TxnCommit()
    {
        if (!pdb)
            return false;
        if (vTxn.empty())
            return false;
        int ret = vTxn.back()->commit(0);
        vTxn.pop_back();
        return (ret == 0);
    }

    bool TxnAbort()
    {
        if (!pdb)
            return false;
        if (vTxn.empty())
            return false;
        int ret = vTxn.back()->abort();
        vTxn.pop_back();
        return (ret == 0);
    }

    bool ReadVersion(int& nVersion)
    {
        nVersion = 0;
        return Read(string("version"), nVersion);
    }

    bool WriteVersion(int nVersion)
    {
        return Write(string("version"), nVersion);
    }
};


class CTxDB : public CDB
{
public:
    CTxDB(const char* pszMode="r+") : CDB("blkindex.dat", pszMode) { }
private:
    CTxDB(const CTxDB&);
    void operator=(const CTxDB&);
public:
    bool ReadTxIndex(uint256 hash, CTxIndex& txindex);
    bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex);
    bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight);
    bool EraseTxIndex(const CTransaction& tx);
    bool ContainsTx(uint256 hash);
    bool ReadOwnerTxes(uint160 hash160, int nHeight, vector<CTransaction>& vtx);
    bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
    bool ReadDiskTx(uint256 hash, CTransaction& tx);
    bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
    bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
    bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
    bool EraseBlockIndex(uint256 hash);
    bool ReadHashBestChain(uint256& hashBestChain);
    bool WriteHashBestChain(uint256 hashBestChain);
    bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork);
    bool WriteBestInvalidWork(CBigNum bnBestInvalidWork);
    bool LoadBlockIndex();
};


class CAddrDB : public CDB
{
public:
    CAddrDB(const char* pszMode="r+") : CDB("addr.dat", pszMode) { }
private:
    CAddrDB(const CAddrDB&);
    void operator=(const CAddrDB&);
public:
    bool WriteAddress(const CAddress& addr);
    bool EraseAddress(const CAddress& addr);
    bool LoadAddresses();
};

bool LoadAddresses();


class CKeyPool
{
public:
    int64 nTime;
    vector<unsigned char> vchPubKey;

    CKeyPool()
    {
        nTime = GetTime();
    }

    CKeyPool(const vector<unsigned char>& vchPubKeyIn)
    {
        nTime = GetTime();
        vchPubKey = vchPubKeyIn;
    }

    IMPLEMENT_SERIALIZE
    (
        if (!(nType & SER_GETHASH))
            READWRITE(nVersion);
        READWRITE(nTime);
        READWRITE(vchPubKey);
    )
};


class CWalletDB : public CDB
{
public:
    CWalletDB(const char* pszMode="r+") : CDB("wallet.dat", pszMode)
    {
    }
private:
    CWalletDB(const CWalletDB&);
    void operator=(const CWalletDB&);
public:
    bool ReadName(const string& strAddress, string& strName)
    {
        strName = "";
        return Read(make_pair(string("name"), strAddress), strName);
    }

    bool WriteName(const string& strAddress, const string& strName)
    {
        CRITICAL_BLOCK(cs_mapAddressBook)
            mapAddressBook[strAddress] = strName;
        nWalletDBUpdated++;
        return Write(make_pair(string("name"), strAddress), strName);
    }

    bool EraseName(const string& strAddress)
    {
        // This should only be used for sending addresses, never for receiving addresses,
        // receiving addresses must always have an address book entry if they're not change return.
        CRITICAL_BLOCK(cs_mapAddressBook)
            mapAddressBook.erase(strAddress);
        nWalletDBUpdated++;
        return Erase(make_pair(string("name"), strAddress));
    }

    bool ReadTx(uint256 hash, CWalletTx& wtx)
    {
        return Read(make_pair(string("tx"), hash), wtx);
    }

    bool WriteTx(uint256 hash, const CWalletTx& wtx)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("tx"), hash), wtx);
    }

    bool EraseTx(uint256 hash)
    {
        nWalletDBUpdated++;
        return Erase(make_pair(string("tx"), hash));
    }

    bool ReadKey(const vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
    {
        vchPrivKey.clear();
        return Read(make_pair(string("key"), vchPubKey), vchPrivKey);
    }

    bool WriteKey(const vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("key"), vchPubKey), vchPrivKey, false);
    }

    bool WriteBestBlock(const CBlockLocator& locator)
    {
        nWalletDBUpdated++;
        return Write(string("bestblock"), locator);
    }

    bool ReadBestBlock(CBlockLocator& locator)
    {
        return Read(string("bestblock"), locator);
    }

    bool ReadDefaultKey(vector<unsigned char>& vchPubKey)
    {
        vchPubKey.clear();
        return Read(string("defaultkey"), vchPubKey);
    }

    bool WriteDefaultKey(const vector<unsigned char>& vchPubKey)
    {
        vchDefaultKey = vchPubKey;
        nWalletDBUpdated++;
        return Write(string("defaultkey"), vchPubKey);
    }

    template<typename T>
    bool ReadSetting(const string& strKey, T& value)
    {
        return Read(make_pair(string("setting"), strKey), value);
    }

    template<typename T>
    bool WriteSetting(const string& strKey, const T& value)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("setting"), strKey), value);
    }

    bool ReadAccount(const string& strAccount, CAccount& account);
    bool WriteAccount(const string& strAccount, const CAccount& account);
    bool WriteAccountingEntry(const CAccountingEntry& acentry);
    int64 GetAccountCreditDebit(const string& strAccount);
    void ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& acentries);

    bool LoadWallet();
protected:
    void ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool);
    void KeepKey(int64 nIndex);
    static void ReturnKey(int64 nIndex);
    friend class CReserveKey;
    friend vector<unsigned char> GetKeyFromKeyPool();
    friend int64 GetOldestKeyPoolTime();
};

bool LoadWallet(bool& fFirstRunRet);
void BackupWallet(const string& strDest);

inline bool SetAddressBookName(const string& strAddress, const string& strName)
{
    return CWalletDB().WriteName(strAddress, strName);
}

class CReserveKey
{
protected:
    int64 nIndex;
    vector<unsigned char> vchPubKey;
public:
    CReserveKey()
    {
        nIndex = -1;
    }

    ~CReserveKey()
    {
        if (!fShutdown)
            ReturnKey();
    }

    vector<unsigned char> GetReservedKey()
    {
        if (nIndex == -1)
        {
            CKeyPool keypool;
            CWalletDB().ReserveKeyFromKeyPool(nIndex, keypool);
            vchPubKey = keypool.vchPubKey;
        }
        assert(!vchPubKey.empty());
        return vchPubKey;
    }

    void KeepKey()
    {
        if (nIndex != -1)
            CWalletDB().KeepKey(nIndex);
        nIndex = -1;
        vchPubKey.clear();
    }

    void ReturnKey()
    {
        if (nIndex != -1)
            CWalletDB::ReturnKey(nIndex);
        nIndex = -1;
        vchPubKey.clear();
    }
};
Commit	Line	Data
0a61b0df	1	// Copyright (c) 2009-2010 Satoshi Nakamoto
	2	// Distributed under the MIT/X11 software license, see the accompanying
	3	// file license.txt or http://www.opensource.org/licenses/mit-license.php.
	4
	5	class CTransaction;
	6	class CTxIndex;
	7	class CDiskBlockIndex;
	8	class CDiskTxPos;
	9	class COutPoint;
	10	class CUser;
	11	class CReview;
	12	class CAddress;
	13	class CWalletTx;
e4ff4e68	14	class CAccount;
e4ff4e68	15	class CAccountingEntry;
6a76c60e	16	class CBlockLocator;
0a61b0df	17
	18	extern map<string, string> mapAddressBook;
	19	extern CCriticalSection cs_mapAddressBook;
	20	extern vector<unsigned char> vchDefaultKey;
	21	extern bool fClient;
	22	extern int nBestHeight;
	23
	24
	25	extern unsigned int nWalletDBUpdated;
	26	extern DbEnv dbenv;
	27
	28
	29	extern void DBFlush(bool fShutdown);
776d0f34	30	extern vector<unsigned char> GetKeyFromKeyPool();
776d0f34	31	extern int64 GetOldestKeyPoolTime();
0a61b0df	32
	33
	34
	35
	36	class CDB
	37	{
	38	protected:
	39	Db* pdb;
	40	string strFile;
	41	vector<DbTxn*> vTxn;
	42	bool fReadOnly;
	43
	44	explicit CDB(const char* pszFile, const char* pszMode="r+");
	45	~CDB() { Close(); }
	46	public:
	47	void Close();
	48	private:
	49	CDB(const CDB&);
	50	void operator=(const CDB&);
	51
	52	protected:
	53	template<typename K, typename T>
	54	bool Read(const K& key, T& value)
	55	{
	56	if (!pdb)
	57	return false;
	58
	59	// Key
	60	CDataStream ssKey(SER_DISK);
	61	ssKey.reserve(1000);
	62	ssKey << key;
	63	Dbt datKey(&ssKey[0], ssKey.size());
	64
	65	// Read
	66	Dbt datValue;
	67	datValue.set_flags(DB_DBT_MALLOC);
	68	int ret = pdb->get(GetTxn(), &datKey, &datValue, 0);
	69	memset(datKey.get_data(), 0, datKey.get_size());
	70	if (datValue.get_data() == NULL)
	71	return false;
	72
	73	// Unserialize value
	74	CDataStream ssValue((char)datValue.get_data(), (char)datValue.get_data() + datValue.get_size(), SER_DISK);
	75	ssValue >> value;
	76
	77	// Clear and free memory
	78	memset(datValue.get_data(), 0, datValue.get_size());
	79	free(datValue.get_data());
	80	return (ret == 0);
	81	}
	82
	83	template<typename K, typename T>
	84	bool Write(const K& key, const T& value, bool fOverwrite=true)
	85	{
	86	if (!pdb)
	87	return false;
	88	if (fReadOnly)
	89	assert(("Write called on database in read-only mode", false));
	90
	91	// Key
	92	CDataStream ssKey(SER_DISK);
	93	ssKey.reserve(1000);
	94	ssKey << key;
	95	Dbt datKey(&ssKey[0], ssKey.size());
96
97	// Value
98	CDataStream ssValue(SER_DISK);
99	ssValue.reserve(10000);
100	ssValue << value;
101	Dbt datValue(&ssValue[0], ssValue.size());
102
103	// Write
104	int ret = pdb->put(GetTxn(), &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
105
106	// Clear memory in case it was a private key
107	memset(datKey.get_data(), 0, datKey.get_size());
108	memset(datValue.get_data(), 0, datValue.get_size());
109	return (ret == 0);
110	}
111
112	template<typename K>
113	bool Erase(const K& key)
114	{
115	if (!pdb)
116	return false;
117	if (fReadOnly)
118	assert(("Erase called on database in read-only mode", false));
119
120	// Key
121	CDataStream ssKey(SER_DISK);
122	ssKey.reserve(1000);
123	ssKey << key;
124	Dbt datKey(&ssKey[0], ssKey.size());
125
126	// Erase
127	int ret = pdb->del(GetTxn(), &datKey, 0);
128
129	// Clear memory
130	memset(datKey.get_data(), 0, datKey.get_size());
131	return (ret == 0 \|\| ret == DB_NOTFOUND);
132	}
133
134	template<typename K>
135	bool Exists(const K& key)
136	{
137	if (!pdb)
138	return false;
139
140	// Key
141	CDataStream ssKey(SER_DISK);
142	ssKey.reserve(1000);
143	ssKey << key;
144	Dbt datKey(&ssKey[0], ssKey.size());
145
146	// Exists
147	int ret = pdb->exists(GetTxn(), &datKey, 0);
148
149	// Clear memory
150	memset(datKey.get_data(), 0, datKey.get_size());
151	return (ret == 0);
152	}
153
154	Dbc* GetCursor()
155	{
156	if (!pdb)
157	return NULL;
158	Dbc* pcursor = NULL;
159	int ret = pdb->cursor(NULL, &pcursor, 0);
160	if (ret != 0)
161	return NULL;
162	return pcursor;
163	}
164
165	int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags=DB_NEXT)
166	{
167	// Read at cursor
168	Dbt datKey;
169	if (fFlags == DB_SET \|\| fFlags == DB_SET_RANGE \|\| fFlags == DB_GET_BOTH \|\| fFlags == DB_GET_BOTH_RANGE)
170	{
171	datKey.set_data(&ssKey[0]);
172	datKey.set_size(ssKey.size());
173	}
174	Dbt datValue;
175	if (fFlags == DB_GET_BOTH \|\| fFlags == DB_GET_BOTH_RANGE)
176	{
177	datValue.set_data(&ssValue[0]);
178	datValue.set_size(ssValue.size());
179	}
180	datKey.set_flags(DB_DBT_MALLOC);
181	datValue.set_flags(DB_DBT_MALLOC);
182	int ret = pcursor->get(&datKey, &datValue, fFlags);
183	if (ret != 0)
184	return ret;
185	else if (datKey.get_data() == NULL \|\| datValue.get_data() == NULL)
186	return 99999;
187
188	// Convert to streams
189	ssKey.SetType(SER_DISK);
190	ssKey.clear();
191	ssKey.write((char*)datKey.get_data(), datKey.get_size());
192	ssValue.SetType(SER_DISK);
193	ssValue.clear();
194	ssValue.write((char*)datValue.get_data(), datValue.get_size());
195
196	// Clear and free memory
197	memset(datKey.get_data(), 0, datKey.get_size());
198	memset(datValue.get_data(), 0, datValue.get_size());
199	free(datKey.get_data());
200	free(datValue.get_data());
201	return 0;
202	}
203
204	DbTxn* GetTxn()
205	{
206	if (!vTxn.empty())
207	return vTxn.back();
208	else
209	return NULL;
210	}
211
212	public:
213	bool TxnBegin()
214	{
215	if (!pdb)
216	return false;
217	DbTxn* ptxn = NULL;
218	int ret = dbenv.txn_begin(GetTxn(), &ptxn, DB_TXN_NOSYNC);
219	if (!ptxn \|\| ret != 0)
220	return false;
221	vTxn.push_back(ptxn);
222	return true;
223	}
224
225	bool TxnCommit()
226	{
227	if (!pdb)
228	return false;
229	if (vTxn.empty())
230	return false;
231	int ret = vTxn.back()->commit(0);
232	vTxn.pop_back();
233	return (ret == 0);
234	}
235
236	bool TxnAbort()
237	{
238	if (!pdb)
239	return false;
240	if (vTxn.empty())
241	return false;
242	int ret = vTxn.back()->abort();
243	vTxn.pop_back();
244	return (ret == 0);
245	}
246
247	bool ReadVersion(int& nVersion)
248	{
249	nVersion = 0;
250	return Read(string("version"), nVersion);
251	}
252
253	bool WriteVersion(int nVersion)
254	{
255	return Write(string("version"), nVersion);
256	}
257	};
258
259
260
261
262
263
264
265
266	class CTxDB : public CDB
267	{
268	public:
f03304a9	269	CTxDB(const char* pszMode="r+") : CDB("blkindex.dat", pszMode) { }
0a61b0df	270	private:
	271	CTxDB(const CTxDB&);
	272	void operator=(const CTxDB&);
	273	public:
	274	bool ReadTxIndex(uint256 hash, CTxIndex& txindex);
	275	bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex);
	276	bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight);
	277	bool EraseTxIndex(const CTransaction& tx);
	278	bool ContainsTx(uint256 hash);
	279	bool ReadOwnerTxes(uint160 hash160, int nHeight, vector<CTransaction>& vtx);
	280	bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
	281	bool ReadDiskTx(uint256 hash, CTransaction& tx);
	282	bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
	283	bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
	284	bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
	285	bool EraseBlockIndex(uint256 hash);
	286	bool ReadHashBestChain(uint256& hashBestChain);
	287	bool WriteHashBestChain(uint256 hashBestChain);
	288	bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork);
	289	bool WriteBestInvalidWork(CBigNum bnBestInvalidWork);
	290	bool LoadBlockIndex();
	291	};
	292
	293
	294
	295
	296
	297	class CAddrDB : public CDB
	298	{
	299	public:
	300	CAddrDB(const char* pszMode="r+") : CDB("addr.dat", pszMode) { }
	301	private:
	302	CAddrDB(const CAddrDB&);
	303	void operator=(const CAddrDB&);
	304	public:
	305	bool WriteAddress(const CAddress& addr);
c891967b	306	bool EraseAddress(const CAddress& addr);
0a61b0df	307	bool LoadAddresses();
	308	};
	309
	310	bool LoadAddresses();
	311
	312
	313
	314
	315
	316
10384941	317	class CKeyPool
	318	{
	319	public:
	320	int64 nTime;
	321	vector<unsigned char> vchPubKey;
	322
	323	CKeyPool()
	324	{
	325	nTime = GetTime();
	326	}
	327
	328	CKeyPool(const vector<unsigned char>& vchPubKeyIn)
	329	{
	330	nTime = GetTime();
	331	vchPubKey = vchPubKeyIn;
	332	}
	333
	334	IMPLEMENT_SERIALIZE
	335	(
	336	if (!(nType & SER_GETHASH))
	337	READWRITE(nVersion);
	338	READWRITE(nTime);
	339	READWRITE(vchPubKey);
	340	)
	341	};
	342
	343
	344
	345
0a61b0df	346	class CWalletDB : public CDB
	347	{
	348	public:
e4ff4e68	349	CWalletDB(const char* pszMode="r+") : CDB("wallet.dat", pszMode)
	350	{
	351	}
0a61b0df	352	private:
	353	CWalletDB(const CWalletDB&);
	354	void operator=(const CWalletDB&);
	355	public:
	356	bool ReadName(const string& strAddress, string& strName)
	357	{
	358	strName = "";
	359	return Read(make_pair(string("name"), strAddress), strName);
	360	}
	361
	362	bool WriteName(const string& strAddress, const string& strName)
	363	{
	364	CRITICAL_BLOCK(cs_mapAddressBook)
	365	mapAddressBook[strAddress] = strName;
	366	nWalletDBUpdated++;
	367	return Write(make_pair(string("name"), strAddress), strName);
	368	}
	369
	370	bool EraseName(const string& strAddress)
	371	{
	372	// This should only be used for sending addresses, never for receiving addresses,
	373	// receiving addresses must always have an address book entry if they're not change return.
	374	CRITICAL_BLOCK(cs_mapAddressBook)
	375	mapAddressBook.erase(strAddress);
	376	nWalletDBUpdated++;
	377	return Erase(make_pair(string("name"), strAddress));
	378	}
	379
	380	bool ReadTx(uint256 hash, CWalletTx& wtx)
	381	{
	382	return Read(make_pair(string("tx"), hash), wtx);
	383	}
	384
	385	bool WriteTx(uint256 hash, const CWalletTx& wtx)
	386	{
	387	nWalletDBUpdated++;
	388	return Write(make_pair(string("tx"), hash), wtx);
	389	}
	390
	391	bool EraseTx(uint256 hash)
	392	{
	393	nWalletDBUpdated++;
	394	return Erase(make_pair(string("tx"), hash));
	395	}
	396
	397	bool ReadKey(const vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
	398	{
	399	vchPrivKey.clear();
	400	return Read(make_pair(string("key"), vchPubKey), vchPrivKey);
	401	}
	402
	403	bool WriteKey(const vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
	404	{
	405	nWalletDBUpdated++;
	406	return Write(make_pair(string("key"), vchPubKey), vchPrivKey, false);
	407	}
	408
6a76c60e PW	409	bool WriteBestBlock(const CBlockLocator& locator)
	410	{
	411	nWalletDBUpdated++;
	412	return Write(string("bestblock"), locator);
	413	}
	414
	415	bool ReadBestBlock(CBlockLocator& locator)
	416	{
	417	return Read(string("bestblock"), locator);
	418	}
	419
0a61b0df	420	bool ReadDefaultKey(vector<unsigned char>& vchPubKey)
	421	{
	422	vchPubKey.clear();
	423	return Read(string("defaultkey"), vchPubKey);
	424	}
	425
	426	bool WriteDefaultKey(const vector<unsigned char>& vchPubKey)
	427	{
	428	vchDefaultKey = vchPubKey;
	429	nWalletDBUpdated++;
	430	return Write(string("defaultkey"), vchPubKey);
	431	}
	432
	433	template<typename T>
	434	bool ReadSetting(const string& strKey, T& value)
	435	{
	436	return Read(make_pair(string("setting"), strKey), value);
	437	}
	438
	439	template<typename T>
	440	bool WriteSetting(const string& strKey, const T& value)
	441	{
	442	nWalletDBUpdated++;
	443	return Write(make_pair(string("setting"), strKey), value);
	444	}
	445
e4ff4e68	446	bool ReadAccount(const string& strAccount, CAccount& account);
e4ff4e68	447	bool WriteAccount(const string& strAccount, const CAccount& account);
809ee795	448	bool WriteAccountingEntry(const CAccountingEntry& acentry);
e4ff4e68	449	int64 GetAccountCreditDebit(const string& strAccount);
bfd471f5	450	void ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& acentries);
e4ff4e68	451
0a61b0df	452	bool LoadWallet();
10384941	453	protected:
	454	void ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool);
	455	void KeepKey(int64 nIndex);
	456	static void ReturnKey(int64 nIndex);
	457	friend class CReserveKey;
776d0f34	458	friend vector<unsigned char> GetKeyFromKeyPool();
776d0f34	459	friend int64 GetOldestKeyPoolTime();
0a61b0df	460	};
	461
	462	bool LoadWallet(bool& fFirstRunRet);
d743f035	463	void BackupWallet(const string& strDest);
0a61b0df	464
	465	inline bool SetAddressBookName(const string& strAddress, const string& strName)
	466	{
	467	return CWalletDB().WriteName(strAddress, strName);
	468	}
10384941	469
	470	class CReserveKey
	471	{
	472	protected:
	473	int64 nIndex;
	474	vector<unsigned char> vchPubKey;
	475	public:
	476	CReserveKey()
	477	{
	478	nIndex = -1;
	479	}
	480
	481	~CReserveKey()
	482	{
5cbf7532	483	if (!fShutdown)
5cbf7532	484	ReturnKey();
10384941	485	}
	486
	487	vector<unsigned char> GetReservedKey()
	488	{
	489	if (nIndex == -1)
	490	{
	491	CKeyPool keypool;
	492	CWalletDB().ReserveKeyFromKeyPool(nIndex, keypool);
	493	vchPubKey = keypool.vchPubKey;
	494	}
	495	assert(!vchPubKey.empty());
	496	return vchPubKey;
	497	}
	498
	499	void KeepKey()
	500	{
	501	if (nIndex != -1)
	502	CWalletDB().KeepKey(nIndex);
	503	nIndex = -1;
	504	vchPubKey.clear();
	505	}
	506
	507	void ReturnKey()
	508	{
	509	if (nIndex != -1)
	510	CWalletDB::ReturnKey(nIndex);
	511	nIndex = -1;
	512	vchPubKey.clear();
	513	}
	514	};