sami7777
014947580b
- ThreadStakeMiner: catch-and-retry instead of crash on exception (boost::bad_weak_ptr no longer kills the daemon) - GetStakeWeight: take wallet lock once instead of per-coin to reduce lock contention with 20K+ transaction wallets - StakeMiner: continue instead of exit when CreateNewBlock fails - Wrap all NotifyTransactionChanged/NotifyAddressBookChanged signal emissions in try/catch to absorb stale slot exceptions - Add -zapwallettxes flag: strips all tx records from wallet.dat keeping only keys, then rescans blockchain to rebuild history Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2864 lines
93 KiB
C++
2864 lines
93 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2012 The Bitcoin developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "txdb.h"
|
|
#include "wallet.h"
|
|
#include "walletdb.h"
|
|
#include "crypter.h"
|
|
#include "ui_interface.h"
|
|
#include "base58.h"
|
|
#include "kernel.h"
|
|
#include "coincontrol.h"
|
|
#include "addressindex.h"
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
#include <algorithm>
|
|
#include <random>
|
|
#include <deque>
|
|
|
|
using namespace std;
|
|
extern unsigned int nStakeMaxAge;
|
|
|
|
unsigned int nStakeSplitAge = 1 * 3 * 60 * 60;
|
|
int64_t nStakeCombineThreshold = 20 * COIN;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// mapWallet
|
|
//
|
|
|
|
struct CompareValueOnly
|
|
{
|
|
bool operator()(const pair<int64_t, pair<const CWalletTx*, unsigned int> >& t1,
|
|
const pair<int64_t, pair<const CWalletTx*, unsigned int> >& t2) const
|
|
{
|
|
return t1.first < t2.first;
|
|
}
|
|
};
|
|
|
|
static CBlockIndex* GetWalletRescanStart(const CWallet& wallet)
|
|
{
|
|
CBlockIndex* pindexStart = pindexGenesisBlock;
|
|
|
|
if (wallet.fFileBacked)
|
|
{
|
|
CWalletDB walletdb(wallet.strWalletFile);
|
|
CBlockLocator locator;
|
|
if (walletdb.ReadBestBlock(locator))
|
|
{
|
|
CBlockIndex* pindexLocator = locator.GetBlockIndex();
|
|
if (pindexLocator)
|
|
pindexStart = pindexLocator;
|
|
}
|
|
}
|
|
|
|
if (wallet.nTimeFirstKey > 1 && pindexBest)
|
|
{
|
|
int64_t nTimeWindowStart = wallet.nTimeFirstKey - 7200;
|
|
CBlockIndex* pindexBirthday = pindexBest;
|
|
while (pindexBirthday->pprev && pindexBirthday->GetBlockTime() > nTimeWindowStart)
|
|
pindexBirthday = pindexBirthday->pprev;
|
|
|
|
if (!pindexStart || pindexBirthday->nHeight < pindexStart->nHeight)
|
|
pindexStart = pindexBirthday;
|
|
}
|
|
|
|
return pindexStart ? pindexStart : pindexGenesisBlock;
|
|
}
|
|
|
|
struct IndexedWalletTx
|
|
{
|
|
int nHeight;
|
|
uint256 hashTx;
|
|
|
|
IndexedWalletTx(int nHeightIn, const uint256& hashTxIn)
|
|
: nHeight(nHeightIn), hashTx(hashTxIn)
|
|
{
|
|
}
|
|
};
|
|
|
|
static bool IndexedWalletTxLess(const IndexedWalletTx& a, const IndexedWalletTx& b)
|
|
{
|
|
if (a.nHeight < b.nHeight)
|
|
return true;
|
|
if (a.nHeight > b.nHeight)
|
|
return false;
|
|
return a.hashTx < b.hashTx;
|
|
}
|
|
|
|
static bool GetIndexedWalletTxHeight(const CTxIndex& txindex, int& nHeight)
|
|
{
|
|
CBlock block;
|
|
if (!block.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos, false))
|
|
return false;
|
|
|
|
map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(block.GetHash());
|
|
if (mi == mapBlockIndex.end())
|
|
return false;
|
|
|
|
nHeight = (*mi).second->nHeight;
|
|
return true;
|
|
}
|
|
|
|
static bool ReadIndexedWalletTransaction(CTxDB& txdb, const uint256& hashTx, CTransaction& tx, CTxIndex& txindex, int& nHeight)
|
|
{
|
|
if (!txdb.ReadDiskTx(hashTx, tx, txindex))
|
|
return false;
|
|
return GetIndexedWalletTxHeight(txindex, nHeight);
|
|
}
|
|
|
|
static bool ReadIndexedWalletTransaction(CTxDB& txdb, const CDiskTxPos& txPos, CTransaction& tx, CTxIndex& txindex, int& nHeight)
|
|
{
|
|
tx.SetNull();
|
|
if (!tx.ReadFromDisk(txPos))
|
|
return false;
|
|
if (!txdb.ReadTxIndex(tx.GetHash(), txindex))
|
|
return false;
|
|
return GetIndexedWalletTxHeight(txindex, nHeight);
|
|
}
|
|
|
|
CPubKey CWallet::GenerateNewKey()
|
|
{
|
|
bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
|
|
|
|
RandAddSeedPerfmon();
|
|
CKey key;
|
|
key.MakeNewKey(fCompressed);
|
|
|
|
// Compressed public keys were introduced in version 0.6.0
|
|
if (fCompressed)
|
|
SetMinVersion(FEATURE_COMPRPUBKEY);
|
|
|
|
CPubKey pubkey = key.GetPubKey();
|
|
|
|
// Create new metadata
|
|
int64_t nCreationTime = GetTime();
|
|
mapKeyMetadata[pubkey.GetID()] = CKeyMetadata(nCreationTime);
|
|
if (!nTimeFirstKey || nCreationTime < nTimeFirstKey)
|
|
nTimeFirstKey = nCreationTime;
|
|
|
|
if (!AddKey(key))
|
|
throw std::runtime_error("CWallet::GenerateNewKey() : AddKey failed");
|
|
return key.GetPubKey();
|
|
}
|
|
|
|
bool CWallet::AddKey(const CKey& key)
|
|
{
|
|
CPubKey pubkey = key.GetPubKey();
|
|
|
|
if (!CCryptoKeyStore::AddKey(key))
|
|
return false;
|
|
if (!fFileBacked)
|
|
return true;
|
|
if (!IsCrypted())
|
|
return CWalletDB(strWalletFile).WriteKey(pubkey, key.GetPrivKey(), mapKeyMetadata[pubkey.GetID()]);
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::AddCryptedKey(const CPubKey &vchPubKey, const vector<unsigned char> &vchCryptedSecret)
|
|
{
|
|
if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
|
|
return false;
|
|
if (!fFileBacked)
|
|
return true;
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (pwalletdbEncryption)
|
|
return pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
|
|
else
|
|
return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &meta)
|
|
{
|
|
if (meta.nCreateTime && (!nTimeFirstKey || meta.nCreateTime < nTimeFirstKey))
|
|
nTimeFirstKey = meta.nCreateTime;
|
|
|
|
mapKeyMetadata[pubkey.GetID()] = meta;
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
|
|
{
|
|
return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
|
|
}
|
|
|
|
bool CWallet::AddCScript(const CScript& redeemScript)
|
|
{
|
|
if (!CCryptoKeyStore::AddCScript(redeemScript))
|
|
return false;
|
|
if (!fFileBacked)
|
|
return true;
|
|
return CWalletDB(strWalletFile).WriteCScript(Hash160(redeemScript), redeemScript);
|
|
}
|
|
|
|
// optional setting to unlock wallet for staking only
|
|
// serves to disable the trivial sendmoney when OS account compromised
|
|
// provides no real security
|
|
bool fWalletUnlockStakingOnly = false;
|
|
|
|
bool CWallet::Lock()
|
|
{
|
|
if (IsLocked())
|
|
return true;
|
|
|
|
if (fDebug)
|
|
printf("Locking wallet.\n");
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
CWalletDB wdb(strWalletFile);
|
|
|
|
}
|
|
return LockKeyStore();
|
|
};
|
|
|
|
bool CWallet::Unlock(const SecureString& strWalletPassphrase)
|
|
{
|
|
if (!IsLocked())
|
|
return false;
|
|
|
|
CCrypter crypter;
|
|
CKeyingMaterial vMasterKey;
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (const MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
|
|
{
|
|
if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
|
|
return false;
|
|
if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
|
|
return false;
|
|
if (CCryptoKeyStore::Unlock(vMasterKey))
|
|
return true;
|
|
}
|
|
|
|
SecureMsgWalletUnlocked();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
|
|
{
|
|
bool fWasLocked = IsLocked();
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
Lock();
|
|
|
|
CCrypter crypter;
|
|
CKeyingMaterial vMasterKey;
|
|
for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
|
|
{
|
|
if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
|
|
return false;
|
|
if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
|
|
return false;
|
|
if (CCryptoKeyStore::Unlock(vMasterKey))
|
|
{
|
|
int64_t nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
|
|
pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
|
|
|
|
nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
|
|
pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
|
|
|
|
if (pMasterKey.second.nDeriveIterations < 25000)
|
|
pMasterKey.second.nDeriveIterations = 25000;
|
|
|
|
printf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
|
|
|
|
if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
|
|
return false;
|
|
if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
|
|
return false;
|
|
CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
|
|
if (fWasLocked)
|
|
Lock();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CWallet::SetBestChain(const CBlockLocator& loc)
|
|
{
|
|
CWalletDB walletdb(strWalletFile);
|
|
walletdb.WriteBestBlock(loc);
|
|
}
|
|
|
|
// This class implements an addrIncoming entry that causes pre-0.4
|
|
// clients to crash on startup if reading a private-key-encrypted wallet.
|
|
class CCorruptAddress
|
|
{
|
|
public:
|
|
IMPLEMENT_SERIALIZE
|
|
(
|
|
if (nType & SER_DISK)
|
|
READWRITE(nVersion);
|
|
)
|
|
};
|
|
|
|
bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB* pwalletdbIn, bool fExplicit)
|
|
{
|
|
if (nWalletVersion >= nVersion)
|
|
return true;
|
|
|
|
// when doing an explicit upgrade, if we pass the max version permitted, upgrade all the way
|
|
if (fExplicit && nVersion > nWalletMaxVersion)
|
|
nVersion = FEATURE_LATEST;
|
|
|
|
nWalletVersion = nVersion;
|
|
|
|
if (nVersion > nWalletMaxVersion)
|
|
nWalletMaxVersion = nVersion;
|
|
|
|
if (fFileBacked)
|
|
{
|
|
CWalletDB* pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(strWalletFile);
|
|
if (nWalletVersion >= 40000)
|
|
{
|
|
// Versions prior to 0.4.0 did not support the "minversion" record.
|
|
// Use a CCorruptAddress to make them crash instead.
|
|
CCorruptAddress corruptAddress;
|
|
pwalletdb->WriteSetting("addrIncoming", corruptAddress);
|
|
}
|
|
if (nWalletVersion > 40000)
|
|
pwalletdb->WriteMinVersion(nWalletVersion);
|
|
if (!pwalletdbIn)
|
|
delete pwalletdb;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::SetMaxVersion(int nVersion)
|
|
{
|
|
// cannot downgrade below current version
|
|
if (nWalletVersion > nVersion)
|
|
return false;
|
|
|
|
nWalletMaxVersion = nVersion;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
|
|
{
|
|
if (IsCrypted())
|
|
return false;
|
|
|
|
CKeyingMaterial vMasterKey;
|
|
RandAddSeedPerfmon();
|
|
|
|
vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
|
|
RAND_bytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
|
|
|
|
CMasterKey kMasterKey(nDerivationMethodIndex);
|
|
|
|
RandAddSeedPerfmon();
|
|
kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
|
|
RAND_bytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
|
|
|
|
CCrypter crypter;
|
|
int64_t nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
|
|
kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
|
|
|
|
nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
|
|
kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
|
|
|
|
if (kMasterKey.nDeriveIterations < 25000)
|
|
kMasterKey.nDeriveIterations = 25000;
|
|
|
|
printf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
|
|
|
|
if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
|
|
return false;
|
|
if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
|
|
return false;
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
|
|
if (fFileBacked)
|
|
{
|
|
pwalletdbEncryption = new CWalletDB(strWalletFile);
|
|
if (!pwalletdbEncryption->TxnBegin())
|
|
return false;
|
|
pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
|
|
}
|
|
|
|
if (!EncryptKeys(vMasterKey))
|
|
{
|
|
if (fFileBacked)
|
|
pwalletdbEncryption->TxnAbort();
|
|
exit(1); //We now probably have half of our keys encrypted in memory, and half not...die and let the user reload their unencrypted wallet.
|
|
}
|
|
|
|
// Encryption was introduced in version 0.4.0
|
|
SetMinVersion(FEATURE_WALLETCRYPT, pwalletdbEncryption, true);
|
|
|
|
if (fFileBacked)
|
|
{
|
|
if (!pwalletdbEncryption->TxnCommit())
|
|
exit(1); //We now have keys encrypted in memory, but no on disk...die to avoid confusion and let the user reload their unencrypted wallet.
|
|
|
|
delete pwalletdbEncryption;
|
|
pwalletdbEncryption = NULL;
|
|
}
|
|
|
|
Lock();
|
|
Unlock(strWalletPassphrase);
|
|
NewKeyPool();
|
|
Lock();
|
|
|
|
// Need to completely rewrite the wallet file; if we don't, bdb might keep
|
|
// bits of the unencrypted private key in slack space in the database file.
|
|
CDB::Rewrite(strWalletFile);
|
|
|
|
}
|
|
NotifyStatusChanged(this);
|
|
|
|
return true;
|
|
}
|
|
|
|
int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb)
|
|
{
|
|
int64_t nRet = nOrderPosNext++;
|
|
if (pwalletdb) {
|
|
pwalletdb->WriteOrderPosNext(nOrderPosNext);
|
|
} else {
|
|
CWalletDB(strWalletFile).WriteOrderPosNext(nOrderPosNext);
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
CWallet::TxItems CWallet::OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount)
|
|
{
|
|
CWalletDB walletdb(strWalletFile);
|
|
|
|
// First: get all CWalletTx and CAccountingEntry into a sorted-by-order multimap.
|
|
TxItems txOrdered;
|
|
|
|
// Note: maintaining indices in the database of (account,time) --> txid and (account, time) --> acentry
|
|
// would make this much faster for applications that do this a lot.
|
|
for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
CWalletTx* wtx = &((*it).second);
|
|
txOrdered.insert(make_pair(wtx->nOrderPos, TxPair(wtx, (CAccountingEntry*)0)));
|
|
}
|
|
acentries.clear();
|
|
walletdb.ListAccountCreditDebit(strAccount, acentries);
|
|
for (CAccountingEntry& entry : acentries)
|
|
{
|
|
txOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry)));
|
|
}
|
|
|
|
return txOrdered;
|
|
}
|
|
|
|
void CWallet::WalletUpdateSpent(const CTransaction &tx, bool fBlock)
|
|
{
|
|
// Anytime a signature is successfully verified, it's proof the outpoint is spent.
|
|
// Update the wallet spent flag if it doesn't know due to wallet.dat being
|
|
// restored from backup or the user making copies of wallet.dat.
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (const CTxIn& txin : tx.vin)
|
|
{
|
|
map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
|
|
if (mi != mapWallet.end())
|
|
{
|
|
CWalletTx& wtx = (*mi).second;
|
|
if (txin.prevout.n >= wtx.vout.size())
|
|
printf("WalletUpdateSpent: bad wtx %s\n", wtx.GetHash().ToString().c_str());
|
|
else if (!wtx.IsSpent(txin.prevout.n) && IsMine(wtx.vout[txin.prevout.n]))
|
|
{
|
|
printf("WalletUpdateSpent found spent coin %s TRI %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
|
|
wtx.MarkSpent(txin.prevout.n);
|
|
wtx.WriteToDisk();
|
|
if (!IsInitialBlockDownload())
|
|
{
|
|
try { NotifyTransactionChanged(this, txin.prevout.hash, CT_UPDATED); }
|
|
catch (...) { }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fBlock)
|
|
{
|
|
uint256 hash = tx.GetHash();
|
|
map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
|
|
CWalletTx& wtx = (*mi).second;
|
|
|
|
for (const CTxOut& txout : tx.vout)
|
|
{
|
|
if (IsMine(txout))
|
|
{
|
|
wtx.MarkUnspent(&txout - &tx.vout[0]);
|
|
wtx.WriteToDisk();
|
|
if (!IsInitialBlockDownload())
|
|
{
|
|
try { NotifyTransactionChanged(this, hash, CT_UPDATED); }
|
|
catch (...) { }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void CWallet::MarkDirty()
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (auto& item : mapWallet)
|
|
item.second.MarkDirty();
|
|
}
|
|
}
|
|
|
|
bool CWallet::AddToWallet(const CWalletTx& wtxIn)
|
|
{
|
|
uint256 hash = wtxIn.GetHash();
|
|
{
|
|
LOCK(cs_wallet);
|
|
// Inserts only if not already there, returns tx inserted or tx found
|
|
pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
|
|
CWalletTx& wtx = (*ret.first).second;
|
|
wtx.BindWallet(this);
|
|
bool fInsertedNew = ret.second;
|
|
if (fInsertedNew)
|
|
{
|
|
wtx.nTimeReceived = GetAdjustedTime();
|
|
wtx.nOrderPos = IncOrderPosNext();
|
|
|
|
wtx.nTimeSmart = wtx.nTimeReceived;
|
|
if (wtxIn.hashBlock != 0)
|
|
{
|
|
if (mapBlockIndex.count(wtxIn.hashBlock))
|
|
{
|
|
unsigned int latestNow = wtx.nTimeReceived;
|
|
unsigned int latestEntry = 0;
|
|
{
|
|
// Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
|
|
int64_t latestTolerated = latestNow + 300;
|
|
std::list<CAccountingEntry> acentries;
|
|
TxItems txOrdered = OrderedTxItems(acentries);
|
|
for (TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
|
|
{
|
|
CWalletTx *const pwtx = (*it).second.first;
|
|
if (pwtx == &wtx)
|
|
continue;
|
|
CAccountingEntry *const pacentry = (*it).second.second;
|
|
int64_t nSmartTime;
|
|
if (pwtx)
|
|
{
|
|
nSmartTime = pwtx->nTimeSmart;
|
|
if (!nSmartTime)
|
|
nSmartTime = pwtx->nTimeReceived;
|
|
}
|
|
else
|
|
nSmartTime = pacentry->nTime;
|
|
if (nSmartTime <= latestTolerated)
|
|
{
|
|
latestEntry = nSmartTime;
|
|
if (nSmartTime > latestNow)
|
|
latestNow = nSmartTime;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
unsigned int& blocktime = mapBlockIndex[wtxIn.hashBlock]->nTime;
|
|
wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
|
|
}
|
|
else
|
|
printf("AddToWallet() : found %s in block %s not in index\n",
|
|
wtxIn.GetHash().ToString().substr(0,10).c_str(),
|
|
wtxIn.hashBlock.ToString().c_str());
|
|
}
|
|
}
|
|
|
|
bool fUpdated = false;
|
|
if (!fInsertedNew)
|
|
{
|
|
// Merge
|
|
if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
|
|
{
|
|
wtx.hashBlock = wtxIn.hashBlock;
|
|
fUpdated = true;
|
|
}
|
|
if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
|
|
{
|
|
wtx.vMerkleBranch = wtxIn.vMerkleBranch;
|
|
wtx.nIndex = wtxIn.nIndex;
|
|
fUpdated = true;
|
|
}
|
|
if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
|
|
{
|
|
wtx.fFromMe = wtxIn.fFromMe;
|
|
fUpdated = true;
|
|
}
|
|
fUpdated |= wtx.UpdateSpent(wtxIn.vfSpent);
|
|
}
|
|
|
|
//// debug print
|
|
printf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString().substr(0,10).c_str(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
|
|
|
|
// Write to disk
|
|
if (fInsertedNew || fUpdated)
|
|
if (!wtx.WriteToDisk())
|
|
return false;
|
|
#ifndef QT_GUI
|
|
// If default receiving address gets used, replace it with a new one
|
|
if (vchDefaultKey.IsValid()) {
|
|
CScript scriptDefaultKey;
|
|
scriptDefaultKey.SetDestination(vchDefaultKey.GetID());
|
|
for (const CTxOut& txout : wtx.vout)
|
|
{
|
|
if (txout.scriptPubKey == scriptDefaultKey)
|
|
{
|
|
CPubKey newDefaultKey;
|
|
if (GetKeyFromPool(newDefaultKey, false))
|
|
{
|
|
SetDefaultKey(newDefaultKey);
|
|
SetAddressBookName(vchDefaultKey.GetID(), "");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// since AddToWallet is called directly for self-originating transactions, check for consumption of own coins
|
|
WalletUpdateSpent(wtx, (wtxIn.hashBlock != 0));
|
|
|
|
// Notify UI of new or updated transaction (skip during IBD to avoid flooding the event loop)
|
|
if (!IsInitialBlockDownload())
|
|
{
|
|
try {
|
|
NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);
|
|
} catch (...) {
|
|
// Absorb boost::bad_weak_ptr or other signal exceptions from stale slots
|
|
}
|
|
}
|
|
|
|
// notify an external script when a wallet transaction comes in or is updated
|
|
std::string strCmd = GetArg("-walletnotify", "");
|
|
|
|
if ( !strCmd.empty())
|
|
{
|
|
boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex());
|
|
boost::thread t(runCommand, strCmd); // thread runs free
|
|
}
|
|
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Add a transaction to the wallet, or update it.
|
|
// pblock is optional, but should be provided if the transaction is known to be in a block.
|
|
// If fUpdate is true, existing transactions will be updated.
|
|
bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate, bool fFindBlock)
|
|
{
|
|
uint256 hash = tx.GetHash();
|
|
{
|
|
LOCK(cs_wallet);
|
|
bool fExisted = mapWallet.count(hash);
|
|
if (fExisted && !fUpdate) return false;
|
|
|
|
mapValue_t mapNarr;
|
|
|
|
if (fExisted || IsMine(tx) || IsFromMe(tx))
|
|
{
|
|
CWalletTx wtx(this,tx);
|
|
|
|
if (!mapNarr.empty())
|
|
wtx.mapValue.insert(mapNarr.begin(), mapNarr.end());
|
|
|
|
// Get merkle branch if transaction was found in a block
|
|
if (pblock)
|
|
wtx.SetMerkleBranch(pblock);
|
|
return AddToWallet(wtx);
|
|
}
|
|
else
|
|
WalletUpdateSpent(tx);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::EraseFromWallet(uint256 hash)
|
|
{
|
|
if (!fFileBacked)
|
|
return false;
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (mapWallet.erase(hash))
|
|
CWalletDB(strWalletFile).EraseTx(hash);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CWallet::IsMine(const CTxIn &txin) const
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
|
|
if (mi != mapWallet.end())
|
|
{
|
|
const CWalletTx& prev = (*mi).second;
|
|
if (txin.prevout.n < prev.vout.size())
|
|
if (IsMine(prev.vout[txin.prevout.n]))
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int64_t CWallet::GetDebit(const CTxIn &txin) const
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
|
|
if (mi != mapWallet.end())
|
|
{
|
|
const CWalletTx& prev = (*mi).second;
|
|
if (txin.prevout.n < prev.vout.size())
|
|
if (IsMine(prev.vout[txin.prevout.n]))
|
|
return prev.vout[txin.prevout.n].nValue;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool CWallet::IsChange(const CTxOut& txout) const
|
|
{
|
|
CTxDestination address;
|
|
|
|
// TODO: fix handling of 'change' outputs. The assumption is that any
|
|
// payment to a TX_PUBKEYHASH that is mine but isn't in the address book
|
|
// is change. That assumption is likely to break when we implement multisignature
|
|
// wallets that return change back into a multi-signature-protected address;
|
|
// a better way of identifying which outputs are 'the send' and which are
|
|
// 'the change' will need to be implemented (maybe extend CWalletTx to remember
|
|
// which output, if any, was change).
|
|
if (ExtractDestination(txout.scriptPubKey, address) && ::IsMine(*this, address))
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (!mapAddressBook.count(address))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int64_t CWalletTx::GetTxTime() const
|
|
{
|
|
int64_t n = nTimeSmart;
|
|
return n ? n : nTimeReceived;
|
|
}
|
|
|
|
int CWalletTx::GetRequestCount() const
|
|
{
|
|
// Returns -1 if it wasn't being tracked
|
|
int nRequests = -1;
|
|
{
|
|
LOCK(pwallet->cs_wallet);
|
|
if (IsCoinBase() || IsCoinStake())
|
|
{
|
|
// Generated block
|
|
if (hashBlock != 0)
|
|
{
|
|
map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
|
|
if (mi != pwallet->mapRequestCount.end())
|
|
nRequests = (*mi).second;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Did anyone request this transaction?
|
|
map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
|
|
if (mi != pwallet->mapRequestCount.end())
|
|
{
|
|
nRequests = (*mi).second;
|
|
|
|
// How about the block it's in?
|
|
if (nRequests == 0 && hashBlock != 0)
|
|
{
|
|
map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
|
|
if (mi != pwallet->mapRequestCount.end())
|
|
nRequests = (*mi).second;
|
|
else
|
|
nRequests = 1; // If it's in someone else's block it must have got out
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nRequests;
|
|
}
|
|
|
|
void CWalletTx::GetAmounts(list<pair<CTxDestination, int64_t> >& listReceived,
|
|
list<pair<CTxDestination, int64_t> >& listSent, int64_t& nFee, string& strSentAccount) const
|
|
{
|
|
nFee = 0;
|
|
listReceived.clear();
|
|
listSent.clear();
|
|
strSentAccount = strFromAccount;
|
|
|
|
// Compute fee:
|
|
int64_t nDebit = GetDebit();
|
|
if (nDebit > 0) // debit>0 means we signed/sent this transaction
|
|
{
|
|
int64_t nValueOut = GetValueOut();
|
|
nFee = nDebit - nValueOut;
|
|
}
|
|
|
|
// Sent/received.
|
|
for (const CTxOut& txout : vout)
|
|
{
|
|
// Skip special stake out
|
|
if (txout.scriptPubKey.empty())
|
|
continue;
|
|
|
|
bool fIsMine;
|
|
// Only need to handle txouts if AT LEAST one of these is true:
|
|
// 1) they debit from us (sent)
|
|
// 2) the output is to us (received)
|
|
if (nDebit > 0)
|
|
{
|
|
// Don't report 'change' txouts
|
|
if (pwallet->IsChange(txout))
|
|
continue;
|
|
fIsMine = pwallet->IsMine(txout);
|
|
}
|
|
else if (!(fIsMine = pwallet->IsMine(txout)))
|
|
continue;
|
|
|
|
// In either case, we need to get the destination address
|
|
CTxDestination address;
|
|
if (!ExtractDestination(txout.scriptPubKey, address))
|
|
{
|
|
printf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
|
|
this->GetHash().ToString().c_str());
|
|
address = CNoDestination();
|
|
}
|
|
|
|
// If we are debited by the transaction, add the output as a "sent" entry
|
|
if (nDebit > 0)
|
|
listSent.push_back(make_pair(address, txout.nValue));
|
|
|
|
// If we are receiving the output, add it as a "received" entry
|
|
if (fIsMine)
|
|
listReceived.push_back(make_pair(address, txout.nValue));
|
|
}
|
|
|
|
}
|
|
|
|
void CWalletTx::GetAccountAmounts(const string& strAccount, int64_t& nReceived,
|
|
int64_t& nSent, int64_t& nFee) const
|
|
{
|
|
nReceived = nSent = nFee = 0;
|
|
|
|
int64_t allFee;
|
|
string strSentAccount;
|
|
list<pair<CTxDestination, int64_t> > listReceived;
|
|
list<pair<CTxDestination, int64_t> > listSent;
|
|
GetAmounts(listReceived, listSent, allFee, strSentAccount);
|
|
|
|
if (strAccount == strSentAccount)
|
|
{
|
|
for (const auto& s : listSent)
|
|
nSent += s.second;
|
|
nFee = allFee;
|
|
}
|
|
{
|
|
LOCK(pwallet->cs_wallet);
|
|
for (const auto& r : listReceived)
|
|
{
|
|
if (pwallet->mapAddressBook.count(r.first))
|
|
{
|
|
map<CTxDestination, string>::const_iterator mi = pwallet->mapAddressBook.find(r.first);
|
|
if (mi != pwallet->mapAddressBook.end() && (*mi).second == strAccount)
|
|
nReceived += r.second;
|
|
}
|
|
else if (strAccount.empty())
|
|
{
|
|
nReceived += r.second;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
|
|
{
|
|
vtxPrev.clear();
|
|
|
|
const int COPY_DEPTH = 3;
|
|
if (SetMerkleBranch() < COPY_DEPTH)
|
|
{
|
|
vector<uint256> vWorkQueue;
|
|
for (const CTxIn& txin : vin)
|
|
vWorkQueue.push_back(txin.prevout.hash);
|
|
|
|
// This critsect is OK because txdb is already open
|
|
{
|
|
LOCK(pwallet->cs_wallet);
|
|
map<uint256, const CMerkleTx*> mapWalletPrev;
|
|
set<uint256> setAlreadyDone;
|
|
for (unsigned int i = 0; i < vWorkQueue.size(); i++)
|
|
{
|
|
uint256 hash = vWorkQueue[i];
|
|
if (setAlreadyDone.count(hash))
|
|
continue;
|
|
setAlreadyDone.insert(hash);
|
|
|
|
CMerkleTx tx;
|
|
map<uint256, CWalletTx>::const_iterator mi = pwallet->mapWallet.find(hash);
|
|
if (mi != pwallet->mapWallet.end())
|
|
{
|
|
tx = (*mi).second;
|
|
for (const CMerkleTx& txWalletPrev : (*mi).second.vtxPrev)
|
|
mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
|
|
}
|
|
else if (mapWalletPrev.count(hash))
|
|
{
|
|
tx = *mapWalletPrev[hash];
|
|
}
|
|
else if (!fClient && txdb.ReadDiskTx(hash, tx))
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
|
|
continue;
|
|
}
|
|
|
|
int nDepth = tx.SetMerkleBranch();
|
|
vtxPrev.push_back(tx);
|
|
|
|
if (nDepth < COPY_DEPTH)
|
|
{
|
|
for (const CTxIn& txin : tx.vin)
|
|
vWorkQueue.push_back(txin.prevout.hash);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
reverse(vtxPrev.begin(), vtxPrev.end());
|
|
}
|
|
|
|
bool CWalletTx::WriteToDisk()
|
|
{
|
|
return CWalletDB(pwallet->strWalletFile).WriteTx(GetHash(), *this);
|
|
}
|
|
|
|
// Scan the block chain (starting in pindexStart) for transactions
|
|
// from or to us. If fUpdate is true, found transactions that already
|
|
// exist in the wallet will be updated.
|
|
int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
|
|
{
|
|
int ret = 0;
|
|
|
|
CBlockIndex* pindex = pindexStart;
|
|
int nScanned = 0;
|
|
int nTotal = nBestHeight - (pindexStart ? pindexStart->nHeight : 0);
|
|
if (nTotal < 1) nTotal = 1;
|
|
int64_t nLastProgressTime = GetTimeMillis();
|
|
|
|
// Cache wallet birthday outside the loop (only written during key import)
|
|
int64_t nBirthTime = nTimeFirstKey;
|
|
|
|
while (pindex)
|
|
{
|
|
if (fShutdown)
|
|
break;
|
|
|
|
++nScanned;
|
|
// Report progress every 500ms to keep UI responsive
|
|
int64_t nNow = GetTimeMillis();
|
|
if (nNow - nLastProgressTime > 500)
|
|
{
|
|
nLastProgressTime = nNow;
|
|
int nPercent = (nScanned * 100) / nTotal;
|
|
uiInterface.InitMessage(strprintf(_("Rescanning... %d%%"), nPercent));
|
|
}
|
|
|
|
// no need to read and scan block, if block was created before
|
|
// our wallet birthday (as adjusted for block time variability)
|
|
if (nBirthTime && (pindex->nTime < (nBirthTime - 7200))) {
|
|
pindex = pindex->pnext;
|
|
continue;
|
|
}
|
|
|
|
// Read block from disk WITHOUT holding wallet lock
|
|
CBlock block;
|
|
block.ReadFromDisk(pindex, true);
|
|
|
|
// AddToWalletIfInvolvingMe acquires cs_wallet internally
|
|
for (CTransaction& tx : block.vtx)
|
|
{
|
|
if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
|
|
ret++;
|
|
}
|
|
pindex = pindex->pnext;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool CWallet::ScanForWalletTransactionsFromIndex(CBlockIndex* pindexStart, bool fUpdate, int* pnFound)
|
|
{
|
|
int nFound = 0;
|
|
if (pnFound)
|
|
*pnFound = 0;
|
|
if (!pindexBest)
|
|
return false;
|
|
|
|
const int nStartHeight = pindexStart ? pindexStart->nHeight : 0;
|
|
|
|
set<CKeyID> setKeys;
|
|
GetKeys(setKeys);
|
|
|
|
set<CScriptID> setScripts;
|
|
{
|
|
LOCK(cs_KeyStore);
|
|
for (ScriptMap::const_iterator it = mapScripts.begin(); it != mapScripts.end(); ++it)
|
|
setScripts.insert((*it).first);
|
|
}
|
|
|
|
CTxDB txdb("r");
|
|
set<uint256> setSeedTxIds;
|
|
|
|
for (const CKeyID& keyId : setKeys)
|
|
{
|
|
vector<uint256> vTxIds;
|
|
if (!txdb.GetAddressTxIds(ADDR_TYPE_P2PKH, keyId, nStartHeight, nBestHeight, vTxIds))
|
|
return false;
|
|
setSeedTxIds.insert(vTxIds.begin(), vTxIds.end());
|
|
}
|
|
|
|
for (const CScriptID& scriptId : setScripts)
|
|
{
|
|
vector<uint256> vTxIds;
|
|
if (!txdb.GetAddressTxIds(ADDR_TYPE_P2SH, scriptId, nStartHeight, nBestHeight, vTxIds))
|
|
return false;
|
|
setSeedTxIds.insert(vTxIds.begin(), vTxIds.end());
|
|
}
|
|
|
|
vector<IndexedWalletTx> vOrderedSeedTxs;
|
|
for (const uint256& hashTx : setSeedTxIds)
|
|
{
|
|
CTransaction tx;
|
|
CTxIndex txindex;
|
|
int nHeight = 0;
|
|
if (!ReadIndexedWalletTransaction(txdb, hashTx, tx, txindex, nHeight))
|
|
return false;
|
|
if (nHeight < nStartHeight)
|
|
continue;
|
|
vOrderedSeedTxs.push_back(IndexedWalletTx(nHeight, hashTx));
|
|
}
|
|
sort(vOrderedSeedTxs.begin(), vOrderedSeedTxs.end(), IndexedWalletTxLess);
|
|
|
|
deque<uint256> vWorkQueue;
|
|
set<uint256> setQueuedTxs;
|
|
for (const IndexedWalletTx& indexedTx : vOrderedSeedTxs)
|
|
{
|
|
bool fExists = false;
|
|
{
|
|
LOCK(cs_wallet);
|
|
fExists = mapWallet.count(indexedTx.hashTx) > 0;
|
|
}
|
|
if (fExists && !fUpdate)
|
|
continue;
|
|
|
|
CTransaction tx;
|
|
CTxIndex txindex;
|
|
int nHeight = 0;
|
|
if (!ReadIndexedWalletTransaction(txdb, indexedTx.hashTx, tx, txindex, nHeight))
|
|
return false;
|
|
|
|
CWalletTx wtx(this, tx);
|
|
wtx.SetMerkleBranch();
|
|
if (!AddToWallet(wtx))
|
|
return false;
|
|
nFound++;
|
|
|
|
if (setQueuedTxs.insert(indexedTx.hashTx).second)
|
|
vWorkQueue.push_back(indexedTx.hashTx);
|
|
}
|
|
|
|
set<uint256> setProcessedTxs;
|
|
while (!vWorkQueue.empty())
|
|
{
|
|
uint256 hashTx = vWorkQueue.front();
|
|
vWorkQueue.pop_front();
|
|
|
|
if (!setProcessedTxs.insert(hashTx).second)
|
|
continue;
|
|
|
|
CWalletTx wtx;
|
|
{
|
|
LOCK(cs_wallet);
|
|
map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
|
|
if (mi == mapWallet.end())
|
|
continue;
|
|
wtx = (*mi).second;
|
|
}
|
|
|
|
// Check UTXO existence to update spent status.
|
|
// Spending transactions are discovered through block scanning.
|
|
if (!txdb.ContainsTx(hashTx))
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < wtx.vout.size(); i++)
|
|
{
|
|
if (!IsMine(wtx.vout[i]))
|
|
continue;
|
|
// If UTXO doesn't exist, the output was spent
|
|
if (!txdb.HaveUtxo(hashTx, i))
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (!wtx.IsSpent(i))
|
|
{
|
|
CWalletTx& wtxMutable = mapWallet[hashTx];
|
|
wtxMutable.MarkSpent(i);
|
|
wtxMutable.WriteToDisk();
|
|
nFound++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetBestChain(CBlockLocator(pindexBest));
|
|
|
|
if (pnFound)
|
|
*pnFound = nFound;
|
|
return true;
|
|
}
|
|
|
|
int CWallet::ScanForWalletTransaction(const uint256& hashTx)
|
|
{
|
|
CTransaction tx;
|
|
tx.ReadFromDisk(COutPoint(hashTx, 0));
|
|
if (AddToWalletIfInvolvingMe(tx, NULL, true, true))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
void CWallet::ReacceptWalletTransactions()
|
|
{
|
|
CTxDB txdb("r");
|
|
bool fRepeat = true;
|
|
while (fRepeat)
|
|
{
|
|
if (fShutdown)
|
|
break;
|
|
|
|
fRepeat = false;
|
|
vector<CDiskTxPos> vMissingTx;
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (auto& item : mapWallet)
|
|
{
|
|
if (fShutdown)
|
|
break;
|
|
|
|
CWalletTx& wtx = item.second;
|
|
if ((wtx.IsCoinBase() && wtx.IsSpent(0)) || (wtx.IsCoinStake() && wtx.IsSpent(1)))
|
|
continue;
|
|
|
|
uint256 hashTx = wtx.GetHash();
|
|
bool fUpdated = false;
|
|
// Check UTXO database for spent status of our outputs
|
|
if (txdb.ContainsTx(hashTx))
|
|
{
|
|
for (unsigned int i = 0; i < wtx.vout.size(); i++)
|
|
{
|
|
if (wtx.IsSpent(i))
|
|
continue;
|
|
// If the UTXO doesn't exist, the output was spent
|
|
if (!txdb.HaveUtxo(hashTx, i) && IsMine(wtx.vout[i]))
|
|
{
|
|
wtx.MarkSpent(i);
|
|
fUpdated = true;
|
|
}
|
|
}
|
|
if (fUpdated)
|
|
{
|
|
printf("ReacceptWalletTransactions found spent coin %s SUM %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
|
|
wtx.MarkDirty();
|
|
wtx.WriteToDisk();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Re-accept any txes of ours that aren't already in a block
|
|
if (!(wtx.IsCoinBase() || wtx.IsCoinStake()))
|
|
wtx.AcceptWalletTransaction(txdb);
|
|
}
|
|
}
|
|
}
|
|
if (!vMissingTx.empty())
|
|
{
|
|
if (fShutdown)
|
|
break;
|
|
|
|
CBlockIndex* pindexStart = GetWalletRescanStart(*this);
|
|
if (pindexStart)
|
|
printf("ReacceptWalletTransactions rescanning from block %d\n", pindexStart->nHeight);
|
|
if (ScanForWalletTransactions(pindexStart))
|
|
fRepeat = true; // Found missing transactions: re-do re-accept.
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
|
|
{
|
|
for (const CMerkleTx& tx : vtxPrev)
|
|
{
|
|
if (!(tx.IsCoinBase() || tx.IsCoinStake()))
|
|
{
|
|
uint256 hash = tx.GetHash();
|
|
if (!txdb.ContainsTx(hash))
|
|
RelayTransaction((CTransaction)tx, hash);
|
|
}
|
|
}
|
|
if (!(IsCoinBase() || IsCoinStake()))
|
|
{
|
|
uint256 hash = GetHash();
|
|
if (!txdb.ContainsTx(hash))
|
|
{
|
|
printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
|
|
RelayTransaction((CTransaction)*this, hash);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWalletTx::RelayWalletTransaction()
|
|
{
|
|
CTxDB txdb("r");
|
|
RelayWalletTransaction(txdb);
|
|
}
|
|
|
|
void CWallet::ResendWalletTransactions(bool fForce)
|
|
{
|
|
if (!fForce)
|
|
{
|
|
// Do this infrequently and randomly to avoid giving away
|
|
// that these are our transactions.
|
|
static int64_t nNextTime;
|
|
if (GetTime() < nNextTime)
|
|
return;
|
|
bool fFirst = (nNextTime == 0);
|
|
nNextTime = GetTime() + GetRand(30 * 60);
|
|
if (fFirst)
|
|
return;
|
|
|
|
// Only do it if there's been a new block since last time
|
|
static int64_t nLastTime;
|
|
if (nTimeBestReceived < nLastTime)
|
|
return;
|
|
nLastTime = GetTime();
|
|
}
|
|
|
|
// Rebroadcast any of our txes that aren't in a block yet
|
|
printf("ResendWalletTransactions()\n");
|
|
CTxDB txdb("r");
|
|
{
|
|
LOCK(cs_wallet);
|
|
// Sort them in chronological order
|
|
multimap<unsigned int, CWalletTx*> mapSorted;
|
|
for (auto& item : mapWallet)
|
|
{
|
|
CWalletTx& wtx = item.second;
|
|
// Don't rebroadcast until it's had plenty of time that
|
|
// it should have gotten in already by now.
|
|
if (fForce || nTimeBestReceived - (int64_t)wtx.nTimeReceived > 5 * 60)
|
|
mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
|
|
}
|
|
for (auto& item : mapSorted)
|
|
{
|
|
CWalletTx& wtx = *item.second;
|
|
if (wtx.CheckTransaction())
|
|
wtx.RelayWalletTransaction(txdb);
|
|
else
|
|
printf("ResendWalletTransactions() : CheckTransaction failed for transaction %s\n", wtx.GetHash().ToString().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Actions
|
|
//
|
|
|
|
|
|
int64_t CWallet::GetBalance() const
|
|
{
|
|
int64_t nTotal = 0;
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
if (pcoin->IsTrusted())
|
|
nTotal += pcoin->GetAvailableCredit();
|
|
}
|
|
}
|
|
|
|
return nTotal;
|
|
}
|
|
|
|
int64_t CWallet::GetUnconfirmedBalance() const
|
|
{
|
|
int64_t nTotal = 0;
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
if (!pcoin->IsFinal() || !pcoin->IsTrusted())
|
|
nTotal += pcoin->GetAvailableCredit();
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
int64_t CWallet::GetImmatureBalance() const
|
|
{
|
|
int64_t nTotal = 0;
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx& pcoin = (*it).second;
|
|
if (pcoin.IsCoinBase() && pcoin.GetBlocksToMaturity() > 0 && pcoin.IsInMainChain())
|
|
nTotal += GetCredit(pcoin);
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
// populate vCoins with vector of spendable COutputs
|
|
void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl) const
|
|
{
|
|
vCoins.clear();
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
|
|
if (!pcoin->IsFinal())
|
|
continue;
|
|
|
|
if (fOnlyConfirmed && !pcoin->IsTrusted())
|
|
continue;
|
|
|
|
if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
|
|
continue;
|
|
|
|
if(pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0)
|
|
continue;
|
|
|
|
int nDepth = pcoin->GetDepthInMainChain();
|
|
if (nDepth < 0)
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < pcoin->vout.size(); i++)
|
|
if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) && pcoin->vout[i].nValue >= nMinimumInputValue &&
|
|
(!coinControl || !coinControl->HasSelected() || coinControl->IsSelected((*it).first, i)))
|
|
vCoins.push_back(COutput(pcoin, i, nDepth));
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWallet::AvailableCoinsMinConf(vector<COutput>& vCoins, int nConf) const
|
|
{
|
|
vCoins.clear();
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
|
|
if (!pcoin->IsFinal())
|
|
continue;
|
|
|
|
if(pcoin->GetDepthInMainChain() < nConf)
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < pcoin->vout.size(); i++)
|
|
if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) && pcoin->vout[i].nValue >= nMinimumInputValue)
|
|
vCoins.push_back(COutput(pcoin, i, pcoin->GetDepthInMainChain()));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ApproximateBestSubset(vector<pair<int64_t, pair<const CWalletTx*,unsigned int> > >vValue, int64_t nTotalLower, int64_t nTargetValue,
|
|
vector<char>& vfBest, int64_t& nBest, int iterations = 1000)
|
|
{
|
|
vector<char> vfIncluded;
|
|
|
|
vfBest.assign(vValue.size(), true);
|
|
nBest = nTotalLower;
|
|
|
|
for (int nRep = 0; nRep < iterations && nBest != nTargetValue; nRep++)
|
|
{
|
|
vfIncluded.assign(vValue.size(), false);
|
|
int64_t nTotal = 0;
|
|
bool fReachedTarget = false;
|
|
for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
|
|
{
|
|
for (unsigned int i = 0; i < vValue.size(); i++)
|
|
{
|
|
if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
|
|
{
|
|
nTotal += vValue[i].first;
|
|
vfIncluded[i] = true;
|
|
if (nTotal >= nTargetValue)
|
|
{
|
|
fReachedTarget = true;
|
|
if (nTotal < nBest)
|
|
{
|
|
nBest = nTotal;
|
|
vfBest = vfIncluded;
|
|
}
|
|
nTotal -= vValue[i].first;
|
|
vfIncluded[i] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// triangles: total coins staked (non-spendable until maturity)
|
|
int64_t CWallet::GetStake() const
|
|
{
|
|
int64_t nTotal = 0;
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
if (pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0)
|
|
nTotal += CWallet::GetCredit(*pcoin);
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
int64_t CWallet::GetNewMint() const
|
|
{
|
|
int64_t nTotal = 0;
|
|
LOCK(cs_wallet);
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx* pcoin = &(*it).second;
|
|
if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0)
|
|
nTotal += CWallet::GetCredit(*pcoin);
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
bool CWallet::GetAllBalances(int64_t& nBalance, int64_t& nStake, int64_t& nUnconfirmed, int64_t& nImmature) const
|
|
{
|
|
nBalance = 0;
|
|
nStake = 0;
|
|
nUnconfirmed = 0;
|
|
nImmature = 0;
|
|
TRY_LOCK(cs_wallet, lockWallet);
|
|
if (!lockWallet)
|
|
return false;
|
|
for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
{
|
|
const CWalletTx& pcoin = (*it).second;
|
|
|
|
if (pcoin.IsCoinStake() && pcoin.GetBlocksToMaturity() > 0 && pcoin.GetDepthInMainChain() > 0)
|
|
nStake += CWallet::GetCredit(pcoin);
|
|
|
|
if (pcoin.IsCoinBase() && pcoin.GetBlocksToMaturity() > 0 && pcoin.IsInMainChain())
|
|
nImmature += GetCredit(pcoin);
|
|
|
|
if (pcoin.IsTrusted())
|
|
nBalance += pcoin.GetAvailableCredit();
|
|
|
|
if (!pcoin.IsFinal() || !pcoin.IsTrusted())
|
|
nUnconfirmed += pcoin.GetAvailableCredit();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::SelectCoinsMinConf(int64_t nTargetValue, unsigned int nSpendTime, int nConfMine, int nConfTheirs, vector<COutput> vCoins, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64_t& nValueRet) const
|
|
{
|
|
setCoinsRet.clear();
|
|
nValueRet = 0;
|
|
|
|
// List of values less than target
|
|
pair<int64_t, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
|
|
coinLowestLarger.first = std::numeric_limits<int64_t>::max();
|
|
coinLowestLarger.second.first = NULL;
|
|
vector<pair<int64_t, pair<const CWalletTx*,unsigned int> > > vValue;
|
|
int64_t nTotalLower = 0;
|
|
|
|
std::shuffle(vCoins.begin(), vCoins.end(), std::mt19937(GetRandInt(std::numeric_limits<int>::max())));
|
|
|
|
for (COutput output : vCoins)
|
|
{
|
|
const CWalletTx *pcoin = output.tx;
|
|
|
|
if (output.nDepth < (pcoin->IsFromMe() ? nConfMine : nConfTheirs))
|
|
continue;
|
|
|
|
int i = output.i;
|
|
|
|
// triangles: timestamp must not exceed spend time
|
|
if (pcoin->nTime > nSpendTime)
|
|
continue;
|
|
|
|
int64_t n = pcoin->vout[i].nValue;
|
|
|
|
pair<int64_t,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));
|
|
|
|
if (n == nTargetValue)
|
|
{
|
|
setCoinsRet.insert(coin.second);
|
|
nValueRet += coin.first;
|
|
return true;
|
|
}
|
|
else if (n < nTargetValue + CENT)
|
|
{
|
|
vValue.push_back(coin);
|
|
nTotalLower += n;
|
|
}
|
|
else if (n < coinLowestLarger.first)
|
|
{
|
|
coinLowestLarger = coin;
|
|
}
|
|
}
|
|
|
|
if (nTotalLower == nTargetValue)
|
|
{
|
|
for (unsigned int i = 0; i < vValue.size(); ++i)
|
|
{
|
|
setCoinsRet.insert(vValue[i].second);
|
|
nValueRet += vValue[i].first;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (nTotalLower < nTargetValue)
|
|
{
|
|
if (coinLowestLarger.second.first == NULL)
|
|
return false;
|
|
setCoinsRet.insert(coinLowestLarger.second);
|
|
nValueRet += coinLowestLarger.first;
|
|
return true;
|
|
}
|
|
|
|
// Solve subset sum by stochastic approximation
|
|
sort(vValue.rbegin(), vValue.rend(), CompareValueOnly());
|
|
vector<char> vfBest;
|
|
int64_t nBest;
|
|
|
|
ApproximateBestSubset(vValue, nTotalLower, nTargetValue, vfBest, nBest, 1000);
|
|
if (nBest != nTargetValue && nTotalLower >= nTargetValue + CENT)
|
|
ApproximateBestSubset(vValue, nTotalLower, nTargetValue + CENT, vfBest, nBest, 1000);
|
|
|
|
// If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
|
|
// or the next bigger coin is closer), return the bigger coin
|
|
if (coinLowestLarger.second.first &&
|
|
((nBest != nTargetValue && nBest < nTargetValue + CENT) || coinLowestLarger.first <= nBest))
|
|
{
|
|
setCoinsRet.insert(coinLowestLarger.second);
|
|
nValueRet += coinLowestLarger.first;
|
|
}
|
|
else {
|
|
for (unsigned int i = 0; i < vValue.size(); i++)
|
|
if (vfBest[i])
|
|
{
|
|
setCoinsRet.insert(vValue[i].second);
|
|
nValueRet += vValue[i].first;
|
|
}
|
|
|
|
if (fDebug && GetBoolArg("-printpriority"))
|
|
{
|
|
//// debug print
|
|
printf("SelectCoins() best subset: ");
|
|
for (unsigned int i = 0; i < vValue.size(); i++)
|
|
if (vfBest[i])
|
|
printf("%s ", FormatMoney(vValue[i].first).c_str());
|
|
printf("total %s\n", FormatMoney(nBest).c_str());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::SelectCoins(int64_t nTargetValue, unsigned int nSpendTime, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64_t& nValueRet, const CCoinControl* coinControl) const
|
|
{
|
|
vector<COutput> vCoins;
|
|
AvailableCoins(vCoins, true, coinControl);
|
|
|
|
// coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
|
|
if (coinControl && coinControl->HasSelected())
|
|
{
|
|
for (const COutput& out : vCoins)
|
|
{
|
|
nValueRet += out.tx->vout[out.i].nValue;
|
|
setCoinsRet.insert(make_pair(out.tx, out.i));
|
|
}
|
|
return (nValueRet >= nTargetValue);
|
|
}
|
|
|
|
return (SelectCoinsMinConf(nTargetValue, nSpendTime, 1, 6, vCoins, setCoinsRet, nValueRet) ||
|
|
SelectCoinsMinConf(nTargetValue, nSpendTime, 1, 1, vCoins, setCoinsRet, nValueRet) ||
|
|
SelectCoinsMinConf(nTargetValue, nSpendTime, 0, 1, vCoins, setCoinsRet, nValueRet));
|
|
}
|
|
|
|
// Select some coins without random shuffle or best subset approximation
|
|
bool CWallet::SelectCoinsSimple(int64_t nTargetValue, unsigned int nSpendTime, int nMinConf, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64_t& nValueRet) const
|
|
{
|
|
vector<COutput> vCoins;
|
|
AvailableCoinsMinConf(vCoins, nMinConf);
|
|
|
|
setCoinsRet.clear();
|
|
nValueRet = 0;
|
|
|
|
for (COutput output : vCoins)
|
|
{
|
|
const CWalletTx *pcoin = output.tx;
|
|
int i = output.i;
|
|
|
|
// Stop if we've chosen enough inputs
|
|
if (nValueRet >= nTargetValue)
|
|
break;
|
|
|
|
// Follow the timestamp rules
|
|
if (pcoin->nTime > nSpendTime)
|
|
continue;
|
|
|
|
int64_t n = pcoin->vout[i].nValue;
|
|
|
|
pair<int64_t,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));
|
|
|
|
if (n >= nTargetValue)
|
|
{
|
|
// If input value is greater or equal to target then simply insert
|
|
// it into the current subset and exit
|
|
setCoinsRet.insert(coin.second);
|
|
nValueRet += coin.first;
|
|
break;
|
|
}
|
|
else if (n < nTargetValue + CENT)
|
|
{
|
|
setCoinsRet.insert(coin.second);
|
|
nValueRet += coin.first;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::CreateTransaction(const vector<pair<CScript, int64_t> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl)
|
|
{
|
|
int64_t nValue = 0;
|
|
for (const auto& s : vecSend)
|
|
{
|
|
if (nValue < 0)
|
|
return false;
|
|
nValue += s.second;
|
|
}
|
|
if (vecSend.empty() || nValue < 0)
|
|
return false;
|
|
|
|
wtxNew.BindWallet(this);
|
|
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
// txdb must be opened before the mapWallet lock
|
|
CTxDB txdb("r");
|
|
{
|
|
nFeeRet = nTransactionFee;
|
|
while (true)
|
|
{
|
|
wtxNew.vin.clear();
|
|
wtxNew.vout.clear();
|
|
wtxNew.fFromMe = true;
|
|
|
|
int64_t nTotalValue = nValue + nFeeRet;
|
|
double dPriority = 0;
|
|
// vouts to the payees
|
|
for (const auto& s : vecSend)
|
|
wtxNew.vout.push_back(CTxOut(s.second, s.first));
|
|
|
|
// Choose coins to use
|
|
set<pair<const CWalletTx*,unsigned int> > setCoins;
|
|
int64_t nValueIn = 0;
|
|
if (!SelectCoins(nTotalValue, wtxNew.nTime, setCoins, nValueIn, coinControl))
|
|
return false;
|
|
for (auto pcoin : setCoins)
|
|
{
|
|
int64_t nCredit = pcoin.first->vout[pcoin.second].nValue;
|
|
dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
|
|
}
|
|
|
|
int64_t nChange = nValueIn - nValue - nFeeRet;
|
|
// if sub-cent change is required, the fee must be raised to at least MIN_TX_FEE
|
|
// or until nChange becomes zero
|
|
// NOTE: this depends on the exact behaviour of GetMinFee
|
|
if (nFeeRet < MIN_TX_FEE && nChange > 0 && nChange < CENT)
|
|
{
|
|
int64_t nMoveToFee = min(nChange, MIN_TX_FEE - nFeeRet);
|
|
nChange -= nMoveToFee;
|
|
nFeeRet += nMoveToFee;
|
|
}
|
|
|
|
if (nChange > 0)
|
|
{
|
|
// Fill a vout to ourself
|
|
// TODO: pass in scriptChange instead of reservekey so
|
|
// change transaction isn't always pay-to-triangles-address
|
|
CScript scriptChange;
|
|
|
|
// coin control: send change to custom address
|
|
if (coinControl && !std::get_if<CNoDestination>(&coinControl->destChange))
|
|
scriptChange.SetDestination(coinControl->destChange);
|
|
|
|
// no coin control: send change to newly generated address
|
|
else
|
|
{
|
|
// Note: We use a new key here to keep it from being obvious which side is the change.
|
|
// The drawback is that by not reusing a previous key, the change may be lost if a
|
|
// backup is restored, if the backup doesn't have the new private key for the change.
|
|
// If we reused the old key, it would be possible to add code to look for and
|
|
// rediscover unknown transactions that were written with keys of ours to recover
|
|
// post-backup change.
|
|
|
|
// Reserve a new key pair from key pool
|
|
CPubKey vchPubKey = reservekey.GetReservedKey();
|
|
|
|
scriptChange.SetDestination(vchPubKey.GetID());
|
|
}
|
|
|
|
// Insert change txn at random position:
|
|
vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size() + 1);
|
|
|
|
// -- don't put change output between value and narration outputs
|
|
if (position > wtxNew.vout.begin() && position < wtxNew.vout.end())
|
|
{
|
|
while (position > wtxNew.vout.begin())
|
|
{
|
|
if (position->nValue != 0)
|
|
break;
|
|
position--;
|
|
};
|
|
};
|
|
wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
|
|
}
|
|
else
|
|
reservekey.ReturnKey();
|
|
|
|
// Fill vin
|
|
for (const auto& coin : setCoins)
|
|
wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
|
|
|
|
// Sign
|
|
int nIn = 0;
|
|
for (const auto& coin : setCoins)
|
|
if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
|
|
return false;
|
|
|
|
// Limit size
|
|
unsigned int nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK, PROTOCOL_VERSION);
|
|
if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
|
|
return false;
|
|
dPriority /= nBytes;
|
|
|
|
// Check that enough fee is included
|
|
int64_t nPayFee = nTransactionFee * (1 + (int64_t)nBytes / 1000);
|
|
int64_t nMinFee = wtxNew.GetMinFee(1, GMF_SEND, nBytes);
|
|
|
|
if (nFeeRet < max(nPayFee, nMinFee))
|
|
{
|
|
nFeeRet = max(nPayFee, nMinFee);
|
|
continue;
|
|
}
|
|
|
|
// Fill vtxPrev by copying from previous transactions vtxPrev
|
|
wtxNew.AddSupportingTransactions(txdb);
|
|
wtxNew.fTimeReceivedIsTxTime = true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CWallet::CreateTransaction(CScript scriptPubKey, int64_t nValue, std::string& sNarr, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl)
|
|
{
|
|
vector< pair<CScript, int64_t> > vecSend;
|
|
vecSend.push_back(make_pair(scriptPubKey, nValue));
|
|
|
|
if (sNarr.length() > 0)
|
|
{
|
|
std::vector<uint8_t> vNarr(sNarr.c_str(), sNarr.c_str() + sNarr.length());
|
|
std::vector<uint8_t> vNDesc;
|
|
|
|
vNDesc.resize(2);
|
|
vNDesc[0] = 'n';
|
|
vNDesc[1] = 'p';
|
|
|
|
CScript scriptN = CScript() << OP_RETURN << vNDesc << OP_RETURN << vNarr;
|
|
|
|
vecSend.push_back(make_pair(scriptN, 0));
|
|
}
|
|
|
|
// -- CreateTransaction won't place change between value and narr output.
|
|
// narration output will be for preceding output
|
|
|
|
bool rv = CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet, coinControl);
|
|
|
|
// -- narration will be added to mapValue later in FindStealthTransactions From CommitTransaction
|
|
return rv;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool CWallet::GetStakeWeight(const CKeyStore& keystore, uint64_t& nMinWeight, uint64_t& nMaxWeight, uint64_t& nWeight)
|
|
{
|
|
// Choose coins to use
|
|
int64_t nBalance = GetBalance();
|
|
|
|
if (nBalance <= nReserveBalance)
|
|
return false;
|
|
|
|
vector<const CWalletTx*> vwtxPrev;
|
|
|
|
set<pair<const CWalletTx*,unsigned int> > setCoins;
|
|
int64_t nValueIn = 0;
|
|
|
|
if (!SelectCoinsSimple(nBalance - nReserveBalance, GetTime(), nCoinbaseMaturity, setCoins, nValueIn))
|
|
return false;
|
|
|
|
if (setCoins.empty())
|
|
return false;
|
|
|
|
// Collect coin hashes under lock, then read DB outside the per-coin lock
|
|
// to avoid acquiring/releasing LOCK2 thousands of times for large wallets
|
|
struct StakeCoin {
|
|
uint256 hash;
|
|
int64_t nValue;
|
|
unsigned int nTime;
|
|
};
|
|
vector<StakeCoin> vStakeCoins;
|
|
{
|
|
LOCK(cs_wallet);
|
|
vStakeCoins.reserve(setCoins.size());
|
|
for (auto& pcoin : setCoins)
|
|
{
|
|
StakeCoin sc;
|
|
sc.hash = pcoin.first->GetHash();
|
|
sc.nValue = pcoin.first->vout[pcoin.second].nValue;
|
|
sc.nTime = pcoin.first->nTime;
|
|
vStakeCoins.push_back(sc);
|
|
}
|
|
}
|
|
|
|
CTxDB txdb("r");
|
|
int64_t nNow = GetTime();
|
|
for (auto& sc : vStakeCoins)
|
|
{
|
|
CTxIndex txindex;
|
|
if (!txdb.ReadTxIndex(sc.hash, txindex))
|
|
continue;
|
|
|
|
int64_t nTimeWeight = GetWeight((int64_t)sc.nTime, nNow);
|
|
CBigNum bnCoinDayWeight = CBigNum(sc.nValue) * nTimeWeight / COIN / (24 * 60 * 60);
|
|
|
|
// Weight is greater than zero
|
|
if (nTimeWeight > 0)
|
|
{
|
|
nWeight += bnCoinDayWeight.getuint64();
|
|
}
|
|
|
|
// Weight is greater than zero, but the maximum value isn't reached yet
|
|
if (nTimeWeight > 0 && nTimeWeight < nStakeMaxAge)
|
|
{
|
|
nMinWeight += bnCoinDayWeight.getuint64();
|
|
}
|
|
|
|
// Maximum weight was reached
|
|
if (nTimeWeight == nStakeMaxAge)
|
|
{
|
|
nMaxWeight += bnCoinDayWeight.getuint64();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::CreateCoinStake(const CKeyStore& keystore, unsigned int nBits, int64_t nSearchInterval, int64_t nFees, CTransaction& txNew, CKey& key)
|
|
{
|
|
CBlockIndex* pindexPrev = pindexBest;
|
|
CBigNum bnTargetPerCoinDay;
|
|
bnTargetPerCoinDay.SetCompact(nBits);
|
|
|
|
txNew.vin.clear();
|
|
txNew.vout.clear();
|
|
|
|
// Mark coin stake transaction
|
|
CScript scriptEmpty;
|
|
scriptEmpty.clear();
|
|
txNew.vout.push_back(CTxOut(0, scriptEmpty));
|
|
|
|
// Choose coins to use
|
|
int64_t nBalance = GetBalance();
|
|
|
|
if (nBalance <= nReserveBalance)
|
|
return false;
|
|
|
|
vector<const CWalletTx*> vwtxPrev;
|
|
|
|
set<pair<const CWalletTx*,unsigned int> > setCoins;
|
|
int64_t nValueIn = 0;
|
|
|
|
// Select coins with suitable depth
|
|
if (!SelectCoinsSimple(nBalance - nReserveBalance, txNew.nTime, nCoinbaseMaturity , setCoins, nValueIn))
|
|
return false;
|
|
|
|
if (setCoins.empty())
|
|
return false;
|
|
|
|
int64_t nCredit = 0;
|
|
CScript scriptPubKeyKernel;
|
|
CTxDB txdb("r");
|
|
for (auto pcoin : setCoins)
|
|
{
|
|
CTxIndex txindex;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
if (!txdb.ReadTxIndex(pcoin.first->GetHash(), txindex))
|
|
continue;
|
|
}
|
|
|
|
// Read block header
|
|
CBlock block;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
if (!block.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos, false))
|
|
continue;
|
|
}
|
|
|
|
static int nMaxStakeSearchInterval = 60;
|
|
if (block.GetBlockTime() + nStakeMinAge > txNew.nTime - nMaxStakeSearchInterval)
|
|
continue; // only count coins meeting min age requirement
|
|
|
|
bool fKernelFound = false;
|
|
for (unsigned int n=0; n<min(nSearchInterval,(int64_t)nMaxStakeSearchInterval) && !fKernelFound && !fShutdown && pindexPrev == pindexBest; n++)
|
|
{
|
|
// Search backward in time from the given txNew timestamp
|
|
// Search nSearchInterval seconds back up to nMaxStakeSearchInterval
|
|
uint256 hashProofOfStake = 0, targetProofOfStake = 0;
|
|
COutPoint prevoutStake = COutPoint(pcoin.first->GetHash(), pcoin.second);
|
|
if (CheckStakeKernelHash(nBits, block, txindex.pos.nTxPos - txindex.pos.nBlockPos, *pcoin.first, prevoutStake, txNew.nTime - n, hashProofOfStake, targetProofOfStake))
|
|
{
|
|
// Found a kernel
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : kernel found\n");
|
|
vector<valtype> vSolutions;
|
|
txnouttype whichType;
|
|
CScript scriptPubKeyOut;
|
|
scriptPubKeyKernel = pcoin.first->vout[pcoin.second].scriptPubKey;
|
|
if (!Solver(scriptPubKeyKernel, whichType, vSolutions))
|
|
{
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : failed to parse kernel\n");
|
|
break;
|
|
}
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : parsed kernel type=%d\n", whichType);
|
|
if (whichType != TX_PUBKEY && whichType != TX_PUBKEYHASH)
|
|
{
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : no support for kernel type=%d\n", whichType);
|
|
break; // only support pay to public key and pay to address
|
|
}
|
|
if (whichType == TX_PUBKEYHASH) // pay to address type
|
|
{
|
|
// convert to pay to public key type
|
|
if (!keystore.GetKey(uint160(vSolutions[0]), key))
|
|
{
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
|
|
break; // unable to find corresponding public key
|
|
}
|
|
scriptPubKeyOut << key.GetPubKey() << OP_CHECKSIG;
|
|
}
|
|
if (whichType == TX_PUBKEY)
|
|
{
|
|
valtype& vchPubKey = vSolutions[0];
|
|
if (!keystore.GetKey(Hash160(vchPubKey), key))
|
|
{
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
|
|
break; // unable to find corresponding public key
|
|
}
|
|
|
|
if (key.GetPubKey() != vchPubKey)
|
|
{
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : invalid key for kernel type=%d\n", whichType);
|
|
break; // keys mismatch
|
|
}
|
|
|
|
scriptPubKeyOut = scriptPubKeyKernel;
|
|
}
|
|
|
|
txNew.nTime -= n;
|
|
txNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second));
|
|
nCredit += pcoin.first->vout[pcoin.second].nValue;
|
|
vwtxPrev.push_back(pcoin.first);
|
|
txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
|
|
|
|
if (GetWeight(block.GetBlockTime(), (int64_t)txNew.nTime) < nStakeSplitAge)
|
|
txNew.vout.push_back(CTxOut(0, scriptPubKeyOut)); //split stake
|
|
if (fDebug && GetBoolArg("-printcoinstake"))
|
|
printf("CreateCoinStake : added kernel type=%d\n", whichType);
|
|
fKernelFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fKernelFound || fShutdown)
|
|
break; // if kernel is found stop searching
|
|
}
|
|
|
|
if (nCredit == 0 || nCredit > nBalance - nReserveBalance)
|
|
{
|
|
// printf(">> Wallet: CreateCoinStake: nCredit = %"PRI64d", nBalance = %"PRI64d", nReserveBalance = %"PRI64d"\n", nCredit, nBalance, nReserveBalance);
|
|
return false;
|
|
}
|
|
|
|
for (auto pcoin : setCoins)
|
|
{
|
|
// Attempt to add more inputs
|
|
// Only add coins of the same key/address as kernel
|
|
if (txNew.vout.size() == 2 && ((pcoin.first->vout[pcoin.second].scriptPubKey == scriptPubKeyKernel || pcoin.first->vout[pcoin.second].scriptPubKey == txNew.vout[1].scriptPubKey))
|
|
&& pcoin.first->GetHash() != txNew.vin[0].prevout.hash)
|
|
{
|
|
int64_t nTimeWeight = GetWeight((int64_t)pcoin.first->nTime, (int64_t)txNew.nTime);
|
|
|
|
// Stop adding more inputs if already too many inputs
|
|
if (txNew.vin.size() >= 100)
|
|
break;
|
|
// Stop adding more inputs if value is already pretty significant
|
|
if (nCredit >= nStakeCombineThreshold)
|
|
break;
|
|
// Stop adding inputs if reached reserve limit
|
|
if (nCredit + pcoin.first->vout[pcoin.second].nValue > nBalance - nReserveBalance)
|
|
break;
|
|
// Do not add additional significant input
|
|
if (pcoin.first->vout[pcoin.second].nValue >= nStakeCombineThreshold)
|
|
continue;
|
|
// Do not add input that is still too young
|
|
if (nTimeWeight < nStakeMinAge)
|
|
continue;
|
|
|
|
txNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second));
|
|
nCredit += pcoin.first->vout[pcoin.second].nValue;
|
|
vwtxPrev.push_back(pcoin.first);
|
|
}
|
|
}
|
|
|
|
// Calculate coin age reward
|
|
{
|
|
uint64_t nCoinAge;
|
|
CTxDB txdb("r");
|
|
if (!txNew.GetCoinAge(txdb, nCoinAge))
|
|
return error("CreateCoinStake : failed to calculate coin age");
|
|
|
|
int64_t nReward = GetProofOfStakeReward(nCoinAge, nFees);
|
|
if (nReward <= 0)
|
|
return false;
|
|
|
|
nCredit += nReward;
|
|
}
|
|
|
|
// Set output amount
|
|
if (txNew.vout.size() == 3)
|
|
{
|
|
txNew.vout[1].nValue = (nCredit / 2 / CENT) * CENT;
|
|
txNew.vout[2].nValue = nCredit - txNew.vout[1].nValue;
|
|
}
|
|
else
|
|
txNew.vout[1].nValue = nCredit;
|
|
|
|
// Sign
|
|
int nIn = 0;
|
|
for (const CWalletTx* pcoin : vwtxPrev)
|
|
{
|
|
if (!SignSignature(*this, *pcoin, txNew, nIn++))
|
|
return error("CreateCoinStake : failed to sign coinstake");
|
|
}
|
|
|
|
// Limit size
|
|
unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION);
|
|
if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
|
|
return error("CreateCoinStake : exceeded coinstake size limit");
|
|
|
|
// Successfully generated coinstake
|
|
return true;
|
|
}
|
|
|
|
|
|
// Call after CreateTransaction unless you want to abort
|
|
bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
|
|
{
|
|
mapValue_t mapNarr;
|
|
|
|
if (!mapNarr.empty())
|
|
{
|
|
for (const auto& item : mapNarr)
|
|
wtxNew.mapValue[item.first] = item.second;
|
|
};
|
|
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
|
|
{
|
|
// This is only to keep the database open to defeat the auto-flush for the
|
|
// duration of this scope. This is the only place where this optimization
|
|
// maybe makes sense; please don't do it anywhere else.
|
|
CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;
|
|
|
|
// Take key pair from key pool so it won't be used again
|
|
reservekey.KeepKey();
|
|
|
|
// Add tx to wallet, because if it has change it's also ours,
|
|
// otherwise just for transaction history.
|
|
AddToWallet(wtxNew);
|
|
|
|
// Mark old coins as spent
|
|
set<CWalletTx*> setCoins;
|
|
for (const CTxIn& txin : wtxNew.vin)
|
|
{
|
|
CWalletTx &coin = mapWallet[txin.prevout.hash];
|
|
coin.BindWallet(this);
|
|
coin.MarkSpent(txin.prevout.n);
|
|
coin.WriteToDisk();
|
|
try { NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED); }
|
|
catch (...) { }
|
|
}
|
|
|
|
if (fFileBacked)
|
|
delete pwalletdb;
|
|
}
|
|
|
|
// Track how many getdata requests our transaction gets
|
|
mapRequestCount[wtxNew.GetHash()] = 0;
|
|
|
|
// Broadcast
|
|
if (!wtxNew.AcceptToMemoryPool())
|
|
{
|
|
// This must not fail. The transaction has already been signed and recorded.
|
|
printf("CommitTransaction() : Error: Transaction not valid\n");
|
|
return false;
|
|
}
|
|
wtxNew.RelayWalletTransaction();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
string CWallet::SendMoney(CScript scriptPubKey, int64_t nValue, std::string& sNarr, CWalletTx& wtxNew, bool fAskFee)
|
|
{
|
|
CReserveKey reservekey(this);
|
|
int64_t nFeeRequired;
|
|
|
|
if (IsLocked())
|
|
{
|
|
string strError = _("Error: Wallet locked, unable to create transaction ");
|
|
printf("SendMoney() : %s", strError.c_str());
|
|
return strError;
|
|
}
|
|
if (fWalletUnlockStakingOnly)
|
|
{
|
|
string strError = _("Error: Wallet unlocked for staking only, unable to create transaction.");
|
|
printf("SendMoney() : %s", strError.c_str());
|
|
return strError;
|
|
}
|
|
if (!CreateTransaction(scriptPubKey, nValue, sNarr, wtxNew, reservekey, nFeeRequired))
|
|
{
|
|
string strError;
|
|
if (nValue + nFeeRequired > GetBalance())
|
|
strError = strprintf(_("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds "), FormatMoney(nFeeRequired).c_str());
|
|
else
|
|
strError = _("Error: Transaction creation failed ");
|
|
printf("SendMoney() : %s", strError.c_str());
|
|
return strError;
|
|
}
|
|
|
|
if (fAskFee && !uiInterface.ThreadSafeAskFee(nFeeRequired, _("Sending...")))
|
|
return "ABORTED";
|
|
|
|
if (!CommitTransaction(wtxNew, reservekey))
|
|
return _("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
|
|
|
|
return "";
|
|
}
|
|
|
|
|
|
|
|
string CWallet::SendMoneyToDestination(const CTxDestination& address, int64_t nValue, std::string& sNarr, CWalletTx& wtxNew, bool fAskFee)
|
|
{
|
|
// Check amount
|
|
if (nValue <= 0)
|
|
return _("Invalid amount");
|
|
if (nValue + nTransactionFee > GetBalance())
|
|
return _("Insufficient funds");
|
|
|
|
if (sNarr.length() > 24)
|
|
return _("Narration must be 24 characters or less.");
|
|
|
|
// Parse Triangles address
|
|
CScript scriptPubKey;
|
|
scriptPubKey.SetDestination(address);
|
|
|
|
return SendMoney(scriptPubKey, nValue, sNarr, wtxNew, fAskFee);
|
|
}
|
|
|
|
|
|
|
|
|
|
DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
|
|
{
|
|
if (!fFileBacked)
|
|
return DB_LOAD_OK;
|
|
fFirstRunRet = false;
|
|
DBErrors nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
|
|
if (nLoadWalletRet == DB_NEED_REWRITE)
|
|
{
|
|
if (CDB::Rewrite(strWalletFile, "\x04pool"))
|
|
{
|
|
setKeyPool.clear();
|
|
// Note: can't top-up keypool here, because wallet is locked.
|
|
// User will be prompted to unlock wallet the next operation
|
|
// the requires a new key.
|
|
}
|
|
}
|
|
|
|
if (nLoadWalletRet != DB_LOAD_OK)
|
|
return nLoadWalletRet;
|
|
fFirstRunRet = !vchDefaultKey.IsValid();
|
|
|
|
NewThread(ThreadFlushWalletDB, &strWalletFile);
|
|
return DB_LOAD_OK;
|
|
}
|
|
|
|
|
|
bool CWallet::SetAddressBookName(const CTxDestination& address, const string& strName)
|
|
{
|
|
bool fOwned;
|
|
ChangeType nMode;
|
|
{
|
|
LOCK(cs_wallet); // mapAddressBook
|
|
std::map<CTxDestination, std::string>::iterator mi = mapAddressBook.find(address);
|
|
nMode = (mi == mapAddressBook.end()) ? CT_NEW : CT_UPDATED;
|
|
fOwned = ::IsMine(*this, address);
|
|
|
|
mapAddressBook[address] = strName;
|
|
}
|
|
|
|
if (fOwned)
|
|
{
|
|
const CTrianglesAddress& caddress = address;
|
|
SecureMsgWalletKeyChanged(caddress.ToString(), strName, nMode);
|
|
}
|
|
try { NotifyAddressBookChanged(this, address, strName, fOwned, nMode); }
|
|
catch (...) { }
|
|
|
|
if (!fFileBacked)
|
|
return false;
|
|
return CWalletDB(strWalletFile).WriteName(CTrianglesAddress(address).ToString(), strName);
|
|
}
|
|
|
|
bool CWallet::DelAddressBookName(const CTxDestination& address)
|
|
{
|
|
{
|
|
LOCK(cs_wallet); // mapAddressBook
|
|
|
|
mapAddressBook.erase(address);
|
|
}
|
|
|
|
bool fOwned = ::IsMine(*this, address);
|
|
string sName = "";
|
|
if (fOwned)
|
|
{
|
|
const CTrianglesAddress& caddress = address;
|
|
SecureMsgWalletKeyChanged(caddress.ToString(), sName, CT_DELETED);
|
|
}
|
|
try { NotifyAddressBookChanged(this, address, "", fOwned, CT_DELETED); }
|
|
catch (...) { }
|
|
|
|
if (!fFileBacked)
|
|
return false;
|
|
return CWalletDB(strWalletFile).EraseName(CTrianglesAddress(address).ToString());
|
|
}
|
|
|
|
|
|
void CWallet::PrintWallet(const CBlock& block)
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (block.IsProofOfWork() && mapWallet.count(block.vtx[0].GetHash()))
|
|
{
|
|
CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
|
|
printf(" mine: %d %d %"PRId64"", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
|
|
}
|
|
if (block.IsProofOfStake() && mapWallet.count(block.vtx[1].GetHash()))
|
|
{
|
|
CWalletTx& wtx = mapWallet[block.vtx[1].GetHash()];
|
|
printf(" stake: %d %d %"PRId64"", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
|
|
}
|
|
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
bool CWallet::GetTransaction(const uint256 &hashTx, CWalletTx& wtx)
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
map<uint256, CWalletTx>::iterator mi = mapWallet.find(hashTx);
|
|
if (mi != mapWallet.end())
|
|
{
|
|
wtx = (*mi).second;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::SetDefaultKey(const CPubKey &vchPubKey)
|
|
{
|
|
if (fFileBacked)
|
|
{
|
|
if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
|
|
return false;
|
|
}
|
|
vchDefaultKey = vchPubKey;
|
|
return true;
|
|
}
|
|
|
|
bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut)
|
|
{
|
|
if (!pwallet->fFileBacked)
|
|
return false;
|
|
strWalletFileOut = pwallet->strWalletFile;
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Mark old keypool keys as used,
|
|
// and generate all new keys
|
|
//
|
|
bool CWallet::NewKeyPool()
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
CWalletDB walletdb(strWalletFile);
|
|
for (int64_t nIndex : setKeyPool)
|
|
walletdb.ErasePool(nIndex);
|
|
setKeyPool.clear();
|
|
|
|
if (IsLocked())
|
|
return false;
|
|
|
|
int64_t nKeys = max(GetArg("-keypool", 100), (int64_t)0);
|
|
for (int i = 0; i < nKeys; i++)
|
|
{
|
|
int64_t nIndex = i+1;
|
|
walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
|
|
setKeyPool.insert(nIndex);
|
|
}
|
|
printf("CWallet::NewKeyPool wrote %"PRId64" new keys\n", nKeys);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::TopUpKeyPool(unsigned int nSize)
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
if (IsLocked())
|
|
return false;
|
|
|
|
CWalletDB walletdb(strWalletFile);
|
|
|
|
// Top up key pool
|
|
unsigned int nTargetSize;
|
|
if (nSize > 0)
|
|
nTargetSize = nSize;
|
|
else
|
|
nTargetSize = max(GetArg("-keypool", 100), (int64_t)0);
|
|
|
|
while (setKeyPool.size() < (nTargetSize + 1))
|
|
{
|
|
int64_t nEnd = 1;
|
|
if (!setKeyPool.empty())
|
|
nEnd = *(--setKeyPool.end()) + 1;
|
|
if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
|
|
throw runtime_error("TopUpKeyPool() : writing generated key failed");
|
|
setKeyPool.insert(nEnd);
|
|
printf("keypool added key %"PRId64", size=%"PRIszu"\n", nEnd, setKeyPool.size());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CWallet::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool)
|
|
{
|
|
nIndex = -1;
|
|
keypool.vchPubKey = CPubKey();
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
if (!IsLocked())
|
|
TopUpKeyPool();
|
|
|
|
// Get the oldest key
|
|
if(setKeyPool.empty())
|
|
return;
|
|
|
|
CWalletDB walletdb(strWalletFile);
|
|
|
|
nIndex = *(setKeyPool.begin());
|
|
setKeyPool.erase(setKeyPool.begin());
|
|
if (!walletdb.ReadPool(nIndex, keypool))
|
|
throw runtime_error("ReserveKeyFromKeyPool() : read failed");
|
|
if (!HaveKey(keypool.vchPubKey.GetID()))
|
|
throw runtime_error("ReserveKeyFromKeyPool() : unknown key in key pool");
|
|
assert(keypool.vchPubKey.IsValid());
|
|
if (fDebug && GetBoolArg("-printkeypool"))
|
|
printf("keypool reserve %"PRId64"\n", nIndex);
|
|
}
|
|
}
|
|
|
|
int64_t CWallet::AddReserveKey(const CKeyPool& keypool)
|
|
{
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
CWalletDB walletdb(strWalletFile);
|
|
|
|
int64_t nIndex = 1 + *(--setKeyPool.end());
|
|
if (!walletdb.WritePool(nIndex, keypool))
|
|
throw runtime_error("AddReserveKey() : writing added key failed");
|
|
setKeyPool.insert(nIndex);
|
|
return nIndex;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CWallet::KeepKey(int64_t nIndex)
|
|
{
|
|
// Remove from key pool
|
|
if (fFileBacked)
|
|
{
|
|
CWalletDB walletdb(strWalletFile);
|
|
walletdb.ErasePool(nIndex);
|
|
}
|
|
if(fDebug)
|
|
printf("keypool keep %"PRId64"\n", nIndex);
|
|
}
|
|
|
|
void CWallet::ReturnKey(int64_t nIndex)
|
|
{
|
|
// Return to key pool
|
|
{
|
|
LOCK(cs_wallet);
|
|
setKeyPool.insert(nIndex);
|
|
}
|
|
if(fDebug)
|
|
printf("keypool return %"PRId64"\n", nIndex);
|
|
}
|
|
|
|
bool CWallet::GetKeyFromPool(CPubKey& result, bool fAllowReuse)
|
|
{
|
|
int64_t nIndex = 0;
|
|
CKeyPool keypool;
|
|
{
|
|
LOCK(cs_wallet);
|
|
ReserveKeyFromKeyPool(nIndex, keypool);
|
|
if (nIndex == -1)
|
|
{
|
|
if (fAllowReuse && vchDefaultKey.IsValid())
|
|
{
|
|
result = vchDefaultKey;
|
|
return true;
|
|
}
|
|
if (IsLocked()) return false;
|
|
result = GenerateNewKey();
|
|
return true;
|
|
}
|
|
KeepKey(nIndex);
|
|
result = keypool.vchPubKey;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int64_t CWallet::GetOldestKeyPoolTime()
|
|
{
|
|
int64_t nIndex = 0;
|
|
CKeyPool keypool;
|
|
ReserveKeyFromKeyPool(nIndex, keypool);
|
|
if (nIndex == -1)
|
|
return GetTime();
|
|
ReturnKey(nIndex);
|
|
return keypool.nTime;
|
|
}
|
|
|
|
std::map<CTxDestination, int64_t> CWallet::GetAddressBalances()
|
|
{
|
|
map<CTxDestination, int64_t> balances;
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (auto walletEntry : mapWallet)
|
|
{
|
|
CWalletTx *pcoin = &walletEntry.second;
|
|
|
|
if (!pcoin->IsFinal() || !pcoin->IsTrusted())
|
|
continue;
|
|
|
|
if ((pcoin->IsCoinBase() || pcoin->IsCoinStake()) && pcoin->GetBlocksToMaturity() > 0)
|
|
continue;
|
|
|
|
int nDepth = pcoin->GetDepthInMainChain();
|
|
if (nDepth < (pcoin->IsFromMe() ? 0 : 1))
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < pcoin->vout.size(); i++)
|
|
{
|
|
CTxDestination addr;
|
|
if (!IsMine(pcoin->vout[i]))
|
|
continue;
|
|
if(!ExtractDestination(pcoin->vout[i].scriptPubKey, addr))
|
|
continue;
|
|
|
|
int64_t n = pcoin->IsSpent(i) ? 0 : pcoin->vout[i].nValue;
|
|
|
|
if (!balances.count(addr))
|
|
balances[addr] = 0;
|
|
balances[addr] += n;
|
|
}
|
|
}
|
|
}
|
|
|
|
return balances;
|
|
}
|
|
|
|
set< set<CTxDestination> > CWallet::GetAddressGroupings()
|
|
{
|
|
set< set<CTxDestination> > groupings;
|
|
set<CTxDestination> grouping;
|
|
|
|
for (auto walletEntry : mapWallet)
|
|
{
|
|
CWalletTx *pcoin = &walletEntry.second;
|
|
|
|
if (pcoin->vin.size() > 0 && IsMine(pcoin->vin[0]))
|
|
{
|
|
// group all input addresses with each other
|
|
for (CTxIn txin : pcoin->vin)
|
|
{
|
|
CTxDestination address;
|
|
if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
|
|
continue;
|
|
grouping.insert(address);
|
|
}
|
|
|
|
// group change with input addresses
|
|
for (CTxOut txout : pcoin->vout)
|
|
if (IsChange(txout))
|
|
{
|
|
CWalletTx tx = mapWallet[pcoin->vin[0].prevout.hash];
|
|
CTxDestination txoutAddr;
|
|
if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
|
|
continue;
|
|
grouping.insert(txoutAddr);
|
|
}
|
|
groupings.insert(grouping);
|
|
grouping.clear();
|
|
}
|
|
|
|
// group lone addrs by themselves
|
|
for (unsigned int i = 0; i < pcoin->vout.size(); i++)
|
|
if (IsMine(pcoin->vout[i]))
|
|
{
|
|
CTxDestination address;
|
|
if(!ExtractDestination(pcoin->vout[i].scriptPubKey, address))
|
|
continue;
|
|
grouping.insert(address);
|
|
groupings.insert(grouping);
|
|
grouping.clear();
|
|
}
|
|
}
|
|
|
|
set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
|
|
map< CTxDestination, set<CTxDestination>* > setmap; // map addresses to the unique group containing it
|
|
for (set<CTxDestination> grouping : groupings)
|
|
{
|
|
// make a set of all the groups hit by this new group
|
|
set< set<CTxDestination>* > hits;
|
|
map< CTxDestination, set<CTxDestination>* >::iterator it;
|
|
for (CTxDestination address : grouping)
|
|
if ((it = setmap.find(address)) != setmap.end())
|
|
hits.insert((*it).second);
|
|
|
|
// merge all hit groups into a new single group and delete old groups
|
|
set<CTxDestination>* merged = new set<CTxDestination>(grouping);
|
|
for (set<CTxDestination>* hit : hits)
|
|
{
|
|
merged->insert(hit->begin(), hit->end());
|
|
uniqueGroupings.erase(hit);
|
|
delete hit;
|
|
}
|
|
uniqueGroupings.insert(merged);
|
|
|
|
// update setmap
|
|
for (CTxDestination element : *merged)
|
|
setmap[element] = merged;
|
|
}
|
|
|
|
set< set<CTxDestination> > ret;
|
|
for (set<CTxDestination>* uniqueGrouping : uniqueGroupings)
|
|
{
|
|
ret.insert(*uniqueGrouping);
|
|
delete uniqueGrouping;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// triangles: check 'spent' consistency between wallet and txindex
|
|
// triangles: fix wallet spent state according to txindex
|
|
void CWallet::FixSpentCoins(int& nMismatchFound, int64_t& nBalanceInQuestion, bool fCheckOnly)
|
|
{
|
|
nMismatchFound = 0;
|
|
nBalanceInQuestion = 0;
|
|
|
|
LOCK(cs_wallet);
|
|
vector<CWalletTx*> vCoins;
|
|
vCoins.reserve(mapWallet.size());
|
|
for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
|
|
vCoins.push_back(&(*it).second);
|
|
|
|
CTxDB txdb("r");
|
|
for (CWalletTx* pcoin : vCoins)
|
|
{
|
|
uint256 hashTx = pcoin->GetHash();
|
|
if (!txdb.ContainsTx(hashTx))
|
|
continue;
|
|
for (unsigned int n=0; n < pcoin->vout.size(); n++)
|
|
{
|
|
bool fUtxoExists = txdb.HaveUtxo(hashTx, n);
|
|
// Wallet says spent but UTXO exists (meaning it's NOT spent) — lost coin
|
|
if (IsMine(pcoin->vout[n]) && pcoin->IsSpent(n) && fUtxoExists)
|
|
{
|
|
printf("FixSpentCoins found lost coin %s TRI %s[%d], %s\n",
|
|
FormatMoney(pcoin->vout[n].nValue).c_str(), hashTx.ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
|
|
nMismatchFound++;
|
|
nBalanceInQuestion += pcoin->vout[n].nValue;
|
|
if (!fCheckOnly)
|
|
{
|
|
pcoin->MarkUnspent(n);
|
|
pcoin->WriteToDisk();
|
|
}
|
|
}
|
|
// Wallet says unspent but UTXO doesn't exist (meaning it IS spent) — phantom coin
|
|
else if (IsMine(pcoin->vout[n]) && !pcoin->IsSpent(n) && !fUtxoExists)
|
|
{
|
|
printf("FixSpentCoins found spent coin %s TRI %s[%d], %s\n",
|
|
FormatMoney(pcoin->vout[n].nValue).c_str(), hashTx.ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
|
|
nMismatchFound++;
|
|
nBalanceInQuestion += pcoin->vout[n].nValue;
|
|
if (!fCheckOnly)
|
|
{
|
|
pcoin->MarkSpent(n);
|
|
pcoin->WriteToDisk();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// triangles: disable transaction (only for coinstake)
|
|
void CWallet::DisableTransaction(const CTransaction &tx)
|
|
{
|
|
if (!tx.IsCoinStake() || !IsFromMe(tx))
|
|
return; // only disconnecting coinstake requires marking input unspent
|
|
|
|
LOCK(cs_wallet);
|
|
for (const CTxIn& txin : tx.vin)
|
|
{
|
|
map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
|
|
if (mi != mapWallet.end())
|
|
{
|
|
CWalletTx& prev = (*mi).second;
|
|
if (txin.prevout.n < prev.vout.size() && IsMine(prev.vout[txin.prevout.n]))
|
|
{
|
|
prev.MarkUnspent(txin.prevout.n);
|
|
prev.WriteToDisk();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CPubKey CReserveKey::GetReservedKey()
|
|
{
|
|
if (nIndex == -1)
|
|
{
|
|
CKeyPool keypool;
|
|
pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
|
|
if (nIndex != -1)
|
|
vchPubKey = keypool.vchPubKey;
|
|
else
|
|
{
|
|
printf("CReserveKey::GetReservedKey(): Warning: Using default key instead of a new key, top up your keypool!");
|
|
vchPubKey = pwallet->vchDefaultKey;
|
|
}
|
|
}
|
|
assert(vchPubKey.IsValid());
|
|
return vchPubKey;
|
|
}
|
|
|
|
void CReserveKey::KeepKey()
|
|
{
|
|
if (nIndex != -1)
|
|
pwallet->KeepKey(nIndex);
|
|
nIndex = -1;
|
|
vchPubKey = CPubKey();
|
|
}
|
|
|
|
void CReserveKey::ReturnKey()
|
|
{
|
|
if (nIndex != -1)
|
|
pwallet->ReturnKey(nIndex);
|
|
nIndex = -1;
|
|
vchPubKey = CPubKey();
|
|
}
|
|
|
|
void CWallet::GetAllReserveKeys(set<CKeyID>& setAddress) const
|
|
{
|
|
setAddress.clear();
|
|
|
|
CWalletDB walletdb(strWalletFile);
|
|
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const int64_t& id : setKeyPool)
|
|
{
|
|
CKeyPool keypool;
|
|
if (!walletdb.ReadPool(id, keypool))
|
|
throw runtime_error("GetAllReserveKeyHashes() : read failed");
|
|
assert(keypool.vchPubKey.IsValid());
|
|
CKeyID keyID = keypool.vchPubKey.GetID();
|
|
if (!HaveKey(keyID))
|
|
throw runtime_error("GetAllReserveKeyHashes() : unknown key in key pool");
|
|
setAddress.insert(keyID);
|
|
}
|
|
}
|
|
|
|
void CWallet::UpdatedTransaction(const uint256 &hashTx)
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
// Only notify UI if this transaction is in this wallet
|
|
map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
|
|
if (mi != mapWallet.end() && !IsInitialBlockDownload())
|
|
{
|
|
try { NotifyTransactionChanged(this, hashTx, CT_UPDATED); }
|
|
catch (...) { }
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
|
|
mapKeyBirth.clear();
|
|
|
|
// get birth times for keys with metadata
|
|
for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++)
|
|
if (it->second.nCreateTime)
|
|
mapKeyBirth[it->first] = it->second.nCreateTime;
|
|
|
|
// map in which we'll infer heights of other keys
|
|
CBlockIndex *pindexMax = FindBlockByHeight(std::max(0, nBestHeight - 144)); // the tip can be reorganised; use a 144-block safety margin
|
|
std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
|
|
std::set<CKeyID> setKeys;
|
|
GetKeys(setKeys);
|
|
for (const CKeyID &keyid : setKeys) {
|
|
if (mapKeyBirth.count(keyid) == 0)
|
|
mapKeyFirstBlock[keyid] = pindexMax;
|
|
}
|
|
setKeys.clear();
|
|
|
|
// if there are no such keys, we're done
|
|
if (mapKeyFirstBlock.empty())
|
|
return;
|
|
|
|
// find first block that affects those keys, if there are any left
|
|
std::vector<CKeyID> vAffected;
|
|
for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) {
|
|
// iterate over all wallet transactions...
|
|
const CWalletTx &wtx = (*it).second;
|
|
std::map<uint256, CBlockIndex*>::const_iterator blit = mapBlockIndex.find(wtx.hashBlock);
|
|
if (blit != mapBlockIndex.end() && blit->second->IsInMainChain()) {
|
|
// ... which are already in a block
|
|
int nHeight = blit->second->nHeight;
|
|
for (const CTxOut &txout : wtx.vout) {
|
|
// iterate over all their outputs
|
|
::ExtractAffectedKeys(*this, txout.scriptPubKey, vAffected);
|
|
for (const CKeyID &keyid : vAffected) {
|
|
// ... and all their affected keys
|
|
std::map<CKeyID, CBlockIndex*>::iterator rit = mapKeyFirstBlock.find(keyid);
|
|
if (rit != mapKeyFirstBlock.end() && nHeight < rit->second->nHeight)
|
|
rit->second = blit->second;
|
|
}
|
|
vAffected.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract block timestamps for those keys
|
|
for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++)
|
|
mapKeyBirth[it->first] = it->second->nTime - 7200; // block times can be 2h off
|
|
}
|
|
|
|
|