2115cba9c6
e306be7429Use 72 byte dummy signatures when watching only inputs may be used (Andrew Chow)48b1473c89Use 71 byte signature for DUMMY_SIGNATURE_CREATOR (Andrew Chow)18dfea0dd0Always create 70 byte signatures with low R values (Andrew Chow) Pull request description: When creating signatures for transactions, always make one which has a 32 byte or smaller R and 32 byte or smaller S value. This results in signatures that are always less than 71 bytes (32 byte R + 32 byte S + 6 bytes DER + 1 byte sighash) with low R values. In most cases, the signature will be 71 bytes. Because R is not mutable in the same way that S is, a low R value can only be found by trying different nonces. RFC 6979 for deterministic nonce generation has the option to specify additional entropy, so we simply use that and add a uin32_t counter which we increment in order to try different nonces. Nonces are sill deterministically generated as the nonce used will the be the first one where the counter results in a nonce that results in a low R value. Because different nonces need to be tried, time to produce a signature does increase. On average, it takes twice as long to make a signature as two signatures need to be created, on average, to find one with a low R. Having a fixed size signature makes size calculations easier and also saves half a byte of transaction size, on average. DUMMY_SIGNATURE_CREATOR has been modified to produce 71 byte dummy signatures instead of 72 byte signatures. Tree-SHA512: 3cd791505126ce92da7c631856a97ba0b59e87d9c132feff6e0eef1dc47768e81fbb38bfbe970371bedf9714b7f61a13a5fe9f30f962c81734092a4d19a4ef33
4468 lines
162 KiB
C++
4468 lines
162 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2018 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <wallet/wallet.h>
|
|
|
|
#include <checkpoints.h>
|
|
#include <chain.h>
|
|
#include <wallet/coincontrol.h>
|
|
#include <consensus/consensus.h>
|
|
#include <consensus/validation.h>
|
|
#include <fs.h>
|
|
#include <key.h>
|
|
#include <key_io.h>
|
|
#include <keystore.h>
|
|
#include <validation.h>
|
|
#include <net.h>
|
|
#include <policy/fees.h>
|
|
#include <policy/policy.h>
|
|
#include <policy/rbf.h>
|
|
#include <primitives/block.h>
|
|
#include <primitives/transaction.h>
|
|
#include <script/script.h>
|
|
#include <shutdown.h>
|
|
#include <timedata.h>
|
|
#include <txmempool.h>
|
|
#include <utilmoneystr.h>
|
|
#include <wallet/fees.h>
|
|
#include <wallet/walletutil.h>
|
|
|
|
#include <algorithm>
|
|
#include <assert.h>
|
|
#include <future>
|
|
|
|
#include <boost/algorithm/string/replace.hpp>
|
|
|
|
static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
|
|
|
|
static CCriticalSection cs_wallets;
|
|
static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);
|
|
|
|
bool AddWallet(const std::shared_ptr<CWallet>& wallet)
|
|
{
|
|
LOCK(cs_wallets);
|
|
assert(wallet);
|
|
std::vector<std::shared_ptr<CWallet>>::const_iterator i = std::find(vpwallets.begin(), vpwallets.end(), wallet);
|
|
if (i != vpwallets.end()) return false;
|
|
vpwallets.push_back(wallet);
|
|
return true;
|
|
}
|
|
|
|
bool RemoveWallet(const std::shared_ptr<CWallet>& wallet)
|
|
{
|
|
LOCK(cs_wallets);
|
|
assert(wallet);
|
|
std::vector<std::shared_ptr<CWallet>>::iterator i = std::find(vpwallets.begin(), vpwallets.end(), wallet);
|
|
if (i == vpwallets.end()) return false;
|
|
vpwallets.erase(i);
|
|
return true;
|
|
}
|
|
|
|
bool HasWallets()
|
|
{
|
|
LOCK(cs_wallets);
|
|
return !vpwallets.empty();
|
|
}
|
|
|
|
std::vector<std::shared_ptr<CWallet>> GetWallets()
|
|
{
|
|
LOCK(cs_wallets);
|
|
return vpwallets;
|
|
}
|
|
|
|
std::shared_ptr<CWallet> GetWallet(const std::string& name)
|
|
{
|
|
LOCK(cs_wallets);
|
|
for (const std::shared_ptr<CWallet>& wallet : vpwallets) {
|
|
if (wallet->GetName() == name) return wallet;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Custom deleter for shared_ptr<CWallet>.
|
|
static void ReleaseWallet(CWallet* wallet)
|
|
{
|
|
wallet->WalletLogPrintf("Releasing wallet\n");
|
|
wallet->BlockUntilSyncedToCurrentChain();
|
|
wallet->Flush();
|
|
delete wallet;
|
|
}
|
|
|
|
const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
|
|
|
|
const uint256 CMerkleTx::ABANDON_HASH(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
|
|
|
|
/** @defgroup mapWallet
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
std::string COutput::ToString() const
|
|
{
|
|
return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->tx->vout[i].nValue));
|
|
}
|
|
|
|
/** A class to identify which pubkeys a script and a keystore have in common. */
|
|
class CAffectedKeysVisitor : public boost::static_visitor<void> {
|
|
private:
|
|
const CKeyStore &keystore;
|
|
std::vector<CKeyID> &vKeys;
|
|
|
|
public:
|
|
/**
|
|
* @param[in] keystoreIn The CKeyStore that is queried for the presence of a pubkey.
|
|
* @param[out] vKeysIn A vector to which a script's pubkey identifiers are appended if they are in the keystore.
|
|
*/
|
|
CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector<CKeyID> &vKeysIn) : keystore(keystoreIn), vKeys(vKeysIn) {}
|
|
|
|
/**
|
|
* Apply the visitor to each destination in a script, recursively to the redeemscript
|
|
* in the case of p2sh destinations.
|
|
* @param[in] script The CScript from which destinations are extracted.
|
|
* @post Any CKeyIDs that script and keystore have in common are appended to the visitor's vKeys.
|
|
*/
|
|
void Process(const CScript &script) {
|
|
txnouttype type;
|
|
std::vector<CTxDestination> vDest;
|
|
int nRequired;
|
|
if (ExtractDestinations(script, type, vDest, nRequired)) {
|
|
for (const CTxDestination &dest : vDest)
|
|
boost::apply_visitor(*this, dest);
|
|
}
|
|
}
|
|
|
|
void operator()(const CKeyID &keyId) {
|
|
if (keystore.HaveKey(keyId))
|
|
vKeys.push_back(keyId);
|
|
}
|
|
|
|
void operator()(const CScriptID &scriptId) {
|
|
CScript script;
|
|
if (keystore.GetCScript(scriptId, script))
|
|
Process(script);
|
|
}
|
|
|
|
void operator()(const WitnessV0ScriptHash& scriptID)
|
|
{
|
|
CScriptID id;
|
|
CRIPEMD160().Write(scriptID.begin(), 32).Finalize(id.begin());
|
|
CScript script;
|
|
if (keystore.GetCScript(id, script)) {
|
|
Process(script);
|
|
}
|
|
}
|
|
|
|
void operator()(const WitnessV0KeyHash& keyid)
|
|
{
|
|
CKeyID id(keyid);
|
|
if (keystore.HaveKey(id)) {
|
|
vKeys.push_back(id);
|
|
}
|
|
}
|
|
|
|
template<typename X>
|
|
void operator()(const X &none) {}
|
|
};
|
|
|
|
const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
|
|
{
|
|
LOCK(cs_wallet);
|
|
std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(hash);
|
|
if (it == mapWallet.end())
|
|
return nullptr;
|
|
return &(it->second);
|
|
}
|
|
|
|
CPubKey CWallet::GenerateNewKey(WalletBatch &batch, bool internal)
|
|
{
|
|
assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
|
|
AssertLockHeld(cs_wallet); // mapKeyMetadata
|
|
bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
|
|
|
|
CKey secret;
|
|
|
|
// Create new metadata
|
|
int64_t nCreationTime = GetTime();
|
|
CKeyMetadata metadata(nCreationTime);
|
|
|
|
// use HD key derivation if HD was enabled during wallet creation
|
|
if (IsHDEnabled()) {
|
|
DeriveNewChildKey(batch, metadata, secret, (CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));
|
|
} else {
|
|
secret.MakeNewKey(fCompressed);
|
|
}
|
|
|
|
// Compressed public keys were introduced in version 0.6.0
|
|
if (fCompressed) {
|
|
SetMinVersion(FEATURE_COMPRPUBKEY);
|
|
}
|
|
|
|
CPubKey pubkey = secret.GetPubKey();
|
|
assert(secret.VerifyPubKey(pubkey));
|
|
|
|
mapKeyMetadata[pubkey.GetID()] = metadata;
|
|
UpdateTimeFirstKey(nCreationTime);
|
|
|
|
if (!AddKeyPubKeyWithDB(batch, secret, pubkey)) {
|
|
throw std::runtime_error(std::string(__func__) + ": AddKey failed");
|
|
}
|
|
return pubkey;
|
|
}
|
|
|
|
void CWallet::DeriveNewChildKey(WalletBatch &batch, CKeyMetadata& metadata, CKey& secret, bool internal)
|
|
{
|
|
// for now we use a fixed keypath scheme of m/0'/0'/k
|
|
CKey seed; //seed (256bit)
|
|
CExtKey masterKey; //hd master key
|
|
CExtKey accountKey; //key at m/0'
|
|
CExtKey chainChildKey; //key at m/0'/0' (external) or m/0'/1' (internal)
|
|
CExtKey childKey; //key at m/0'/0'/<n>'
|
|
|
|
// try to get the seed
|
|
if (!GetKey(hdChain.seed_id, seed))
|
|
throw std::runtime_error(std::string(__func__) + ": seed not found");
|
|
|
|
masterKey.SetSeed(seed.begin(), seed.size());
|
|
|
|
// derive m/0'
|
|
// use hardened derivation (child keys >= 0x80000000 are hardened after bip32)
|
|
masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);
|
|
|
|
// derive m/0'/0' (external chain) OR m/0'/1' (internal chain)
|
|
assert(internal ? CanSupportFeature(FEATURE_HD_SPLIT) : true);
|
|
accountKey.Derive(chainChildKey, BIP32_HARDENED_KEY_LIMIT+(internal ? 1 : 0));
|
|
|
|
// derive child key at next index, skip keys already known to the wallet
|
|
do {
|
|
// always derive hardened keys
|
|
// childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range
|
|
// example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649
|
|
if (internal) {
|
|
chainChildKey.Derive(childKey, hdChain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
|
|
metadata.hdKeypath = "m/0'/1'/" + std::to_string(hdChain.nInternalChainCounter) + "'";
|
|
hdChain.nInternalChainCounter++;
|
|
}
|
|
else {
|
|
chainChildKey.Derive(childKey, hdChain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT);
|
|
metadata.hdKeypath = "m/0'/0'/" + std::to_string(hdChain.nExternalChainCounter) + "'";
|
|
hdChain.nExternalChainCounter++;
|
|
}
|
|
} while (HaveKey(childKey.key.GetPubKey().GetID()));
|
|
secret = childKey.key;
|
|
metadata.hd_seed_id = hdChain.seed_id;
|
|
// update the chain model in the database
|
|
if (!batch.WriteHDChain(hdChain))
|
|
throw std::runtime_error(std::string(__func__) + ": Writing HD chain model failed");
|
|
}
|
|
|
|
bool CWallet::AddKeyPubKeyWithDB(WalletBatch &batch, const CKey& secret, const CPubKey &pubkey)
|
|
{
|
|
AssertLockHeld(cs_wallet); // mapKeyMetadata
|
|
|
|
// CCryptoKeyStore has no concept of wallet databases, but calls AddCryptedKey
|
|
// which is overridden below. To avoid flushes, the database handle is
|
|
// tunneled through to it.
|
|
bool needsDB = !encrypted_batch;
|
|
if (needsDB) {
|
|
encrypted_batch = &batch;
|
|
}
|
|
if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey)) {
|
|
if (needsDB) encrypted_batch = nullptr;
|
|
return false;
|
|
}
|
|
if (needsDB) encrypted_batch = nullptr;
|
|
|
|
// check if we need to remove from watch-only
|
|
CScript script;
|
|
script = GetScriptForDestination(pubkey.GetID());
|
|
if (HaveWatchOnly(script)) {
|
|
RemoveWatchOnly(script);
|
|
}
|
|
script = GetScriptForRawPubKey(pubkey);
|
|
if (HaveWatchOnly(script)) {
|
|
RemoveWatchOnly(script);
|
|
}
|
|
|
|
if (!IsCrypted()) {
|
|
return batch.WriteKey(pubkey,
|
|
secret.GetPrivKey(),
|
|
mapKeyMetadata[pubkey.GetID()]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)
|
|
{
|
|
WalletBatch batch(*database);
|
|
return CWallet::AddKeyPubKeyWithDB(batch, secret, pubkey);
|
|
}
|
|
|
|
bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,
|
|
const std::vector<unsigned char> &vchCryptedSecret)
|
|
{
|
|
if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
|
|
return false;
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (encrypted_batch)
|
|
return encrypted_batch->WriteCryptedKey(vchPubKey,
|
|
vchCryptedSecret,
|
|
mapKeyMetadata[vchPubKey.GetID()]);
|
|
else
|
|
return WalletBatch(*database).WriteCryptedKey(vchPubKey,
|
|
vchCryptedSecret,
|
|
mapKeyMetadata[vchPubKey.GetID()]);
|
|
}
|
|
}
|
|
|
|
void CWallet::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata &meta)
|
|
{
|
|
AssertLockHeld(cs_wallet); // mapKeyMetadata
|
|
UpdateTimeFirstKey(meta.nCreateTime);
|
|
mapKeyMetadata[keyID] = meta;
|
|
}
|
|
|
|
void CWallet::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata &meta)
|
|
{
|
|
AssertLockHeld(cs_wallet); // m_script_metadata
|
|
UpdateTimeFirstKey(meta.nCreateTime);
|
|
m_script_metadata[script_id] = meta;
|
|
}
|
|
|
|
bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
|
|
{
|
|
return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
|
|
}
|
|
|
|
/**
|
|
* Update wallet first key creation time. This should be called whenever keys
|
|
* are added to the wallet, with the oldest key creation time.
|
|
*/
|
|
void CWallet::UpdateTimeFirstKey(int64_t nCreateTime)
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
if (nCreateTime <= 1) {
|
|
// Cannot determine birthday information, so set the wallet birthday to
|
|
// the beginning of time.
|
|
nTimeFirstKey = 1;
|
|
} else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {
|
|
nTimeFirstKey = nCreateTime;
|
|
}
|
|
}
|
|
|
|
bool CWallet::AddCScript(const CScript& redeemScript)
|
|
{
|
|
if (!CCryptoKeyStore::AddCScript(redeemScript))
|
|
return false;
|
|
return WalletBatch(*database).WriteCScript(Hash160(redeemScript), redeemScript);
|
|
}
|
|
|
|
bool CWallet::LoadCScript(const CScript& redeemScript)
|
|
{
|
|
/* A sanity check was added in pull #3843 to avoid adding redeemScripts
|
|
* that never can be redeemed. However, old wallets may still contain
|
|
* these. Do not add them to the wallet and warn. */
|
|
if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
|
|
{
|
|
std::string strAddr = EncodeDestination(CScriptID(redeemScript));
|
|
WalletLogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
|
|
return true;
|
|
}
|
|
|
|
return CCryptoKeyStore::AddCScript(redeemScript);
|
|
}
|
|
|
|
bool CWallet::AddWatchOnly(const CScript& dest)
|
|
{
|
|
if (!CCryptoKeyStore::AddWatchOnly(dest))
|
|
return false;
|
|
const CKeyMetadata& meta = m_script_metadata[CScriptID(dest)];
|
|
UpdateTimeFirstKey(meta.nCreateTime);
|
|
NotifyWatchonlyChanged(true);
|
|
return WalletBatch(*database).WriteWatchOnly(dest, meta);
|
|
}
|
|
|
|
bool CWallet::AddWatchOnly(const CScript& dest, int64_t nCreateTime)
|
|
{
|
|
m_script_metadata[CScriptID(dest)].nCreateTime = nCreateTime;
|
|
return AddWatchOnly(dest);
|
|
}
|
|
|
|
bool CWallet::RemoveWatchOnly(const CScript &dest)
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
if (!CCryptoKeyStore::RemoveWatchOnly(dest))
|
|
return false;
|
|
if (!HaveWatchOnly())
|
|
NotifyWatchonlyChanged(false);
|
|
if (!WalletBatch(*database).EraseWatchOnly(dest))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::LoadWatchOnly(const CScript &dest)
|
|
{
|
|
return CCryptoKeyStore::AddWatchOnly(dest);
|
|
}
|
|
|
|
bool CWallet::Unlock(const SecureString& strWalletPassphrase)
|
|
{
|
|
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))
|
|
continue; // try another master key
|
|
if (CCryptoKeyStore::Unlock(_vMasterKey))
|
|
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 = static_cast<unsigned int>(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 + static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime)))) / 2;
|
|
|
|
if (pMasterKey.second.nDeriveIterations < 25000)
|
|
pMasterKey.second.nDeriveIterations = 25000;
|
|
|
|
WalletLogPrintf("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;
|
|
WalletBatch(*database).WriteMasterKey(pMasterKey.first, pMasterKey.second);
|
|
if (fWasLocked)
|
|
Lock();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CWallet::ChainStateFlushed(const CBlockLocator& loc)
|
|
{
|
|
WalletBatch batch(*database);
|
|
batch.WriteBestBlock(loc);
|
|
}
|
|
|
|
void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch* batch_in, bool fExplicit)
|
|
{
|
|
LOCK(cs_wallet); // nWalletVersion
|
|
if (nWalletVersion >= nVersion)
|
|
return;
|
|
|
|
// 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;
|
|
|
|
{
|
|
WalletBatch* batch = batch_in ? batch_in : new WalletBatch(*database);
|
|
if (nWalletVersion > 40000)
|
|
batch->WriteMinVersion(nWalletVersion);
|
|
if (!batch_in)
|
|
delete batch;
|
|
}
|
|
}
|
|
|
|
bool CWallet::SetMaxVersion(int nVersion)
|
|
{
|
|
LOCK(cs_wallet); // nWalletVersion, nWalletMaxVersion
|
|
// cannot downgrade below current version
|
|
if (nWalletVersion > nVersion)
|
|
return false;
|
|
|
|
nWalletMaxVersion = nVersion;
|
|
|
|
return true;
|
|
}
|
|
|
|
std::set<uint256> CWallet::GetConflicts(const uint256& txid) const
|
|
{
|
|
std::set<uint256> result;
|
|
AssertLockHeld(cs_wallet);
|
|
|
|
std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(txid);
|
|
if (it == mapWallet.end())
|
|
return result;
|
|
const CWalletTx& wtx = it->second;
|
|
|
|
std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
|
|
|
|
for (const CTxIn& txin : wtx.tx->vin)
|
|
{
|
|
if (mapTxSpends.count(txin.prevout) <= 1)
|
|
continue; // No conflict if zero or one spends
|
|
range = mapTxSpends.equal_range(txin.prevout);
|
|
for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it)
|
|
result.insert(_it->second);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool CWallet::HasWalletSpend(const uint256& txid) const
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
|
|
return (iter != mapTxSpends.end() && iter->first.hash == txid);
|
|
}
|
|
|
|
void CWallet::Flush(bool shutdown)
|
|
{
|
|
database->Flush(shutdown);
|
|
}
|
|
|
|
void CWallet::SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator> range)
|
|
{
|
|
// We want all the wallet transactions in range to have the same metadata as
|
|
// the oldest (smallest nOrderPos).
|
|
// So: find smallest nOrderPos:
|
|
|
|
int nMinOrderPos = std::numeric_limits<int>::max();
|
|
const CWalletTx* copyFrom = nullptr;
|
|
for (TxSpends::iterator it = range.first; it != range.second; ++it) {
|
|
const CWalletTx* wtx = &mapWallet.at(it->second);
|
|
if (wtx->nOrderPos < nMinOrderPos) {
|
|
nMinOrderPos = wtx->nOrderPos;
|
|
copyFrom = wtx;
|
|
}
|
|
}
|
|
|
|
if (!copyFrom) {
|
|
return;
|
|
}
|
|
|
|
// Now copy data from copyFrom to rest:
|
|
for (TxSpends::iterator it = range.first; it != range.second; ++it)
|
|
{
|
|
const uint256& hash = it->second;
|
|
CWalletTx* copyTo = &mapWallet.at(hash);
|
|
if (copyFrom == copyTo) continue;
|
|
assert(copyFrom && "Oldest wallet transaction in range assumed to have been found.");
|
|
if (!copyFrom->IsEquivalentTo(*copyTo)) continue;
|
|
copyTo->mapValue = copyFrom->mapValue;
|
|
copyTo->vOrderForm = copyFrom->vOrderForm;
|
|
// fTimeReceivedIsTxTime not copied on purpose
|
|
// nTimeReceived not copied on purpose
|
|
copyTo->nTimeSmart = copyFrom->nTimeSmart;
|
|
copyTo->fFromMe = copyFrom->fFromMe;
|
|
copyTo->strFromAccount = copyFrom->strFromAccount;
|
|
// nOrderPos not copied on purpose
|
|
// cached members not copied on purpose
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Outpoint is spent if any non-conflicted transaction
|
|
* spends it:
|
|
*/
|
|
bool CWallet::IsSpent(const uint256& hash, unsigned int n) const
|
|
{
|
|
const COutPoint outpoint(hash, n);
|
|
std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
|
|
range = mapTxSpends.equal_range(outpoint);
|
|
|
|
for (TxSpends::const_iterator it = range.first; it != range.second; ++it)
|
|
{
|
|
const uint256& wtxid = it->second;
|
|
std::map<uint256, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
|
|
if (mit != mapWallet.end()) {
|
|
int depth = mit->second.GetDepthInMainChain();
|
|
if (depth > 0 || (depth == 0 && !mit->second.isAbandoned()))
|
|
return true; // Spent
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid)
|
|
{
|
|
mapTxSpends.insert(std::make_pair(outpoint, wtxid));
|
|
|
|
setLockedCoins.erase(outpoint);
|
|
|
|
std::pair<TxSpends::iterator, TxSpends::iterator> range;
|
|
range = mapTxSpends.equal_range(outpoint);
|
|
SyncMetaData(range);
|
|
}
|
|
|
|
|
|
void CWallet::AddToSpends(const uint256& wtxid)
|
|
{
|
|
auto it = mapWallet.find(wtxid);
|
|
assert(it != mapWallet.end());
|
|
CWalletTx& thisTx = it->second;
|
|
if (thisTx.IsCoinBase()) // Coinbases don't spend anything!
|
|
return;
|
|
|
|
for (const CTxIn& txin : thisTx.tx->vin)
|
|
AddToSpends(txin.prevout, wtxid);
|
|
}
|
|
|
|
bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
|
|
{
|
|
if (IsCrypted())
|
|
return false;
|
|
|
|
CKeyingMaterial _vMasterKey;
|
|
|
|
_vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
|
|
GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
|
|
|
|
CMasterKey kMasterKey;
|
|
|
|
kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
|
|
GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
|
|
|
|
CCrypter crypter;
|
|
int64_t nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
|
|
kMasterKey.nDeriveIterations = static_cast<unsigned int>(2500000 / ((double)(GetTimeMillis() - nStartTime)));
|
|
|
|
nStartTime = GetTimeMillis();
|
|
crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
|
|
kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime)))) / 2;
|
|
|
|
if (kMasterKey.nDeriveIterations < 25000)
|
|
kMasterKey.nDeriveIterations = 25000;
|
|
|
|
WalletLogPrintf("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;
|
|
assert(!encrypted_batch);
|
|
encrypted_batch = new WalletBatch(*database);
|
|
if (!encrypted_batch->TxnBegin()) {
|
|
delete encrypted_batch;
|
|
encrypted_batch = nullptr;
|
|
return false;
|
|
}
|
|
encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
|
|
|
|
if (!EncryptKeys(_vMasterKey))
|
|
{
|
|
encrypted_batch->TxnAbort();
|
|
delete encrypted_batch;
|
|
// We now probably have half of our keys encrypted in memory, and half not...
|
|
// die and let the user reload the unencrypted wallet.
|
|
assert(false);
|
|
}
|
|
|
|
// Encryption was introduced in version 0.4.0
|
|
SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);
|
|
|
|
if (!encrypted_batch->TxnCommit()) {
|
|
delete encrypted_batch;
|
|
// We now have keys encrypted in memory, but not on disk...
|
|
// die to avoid confusion and let the user reload the unencrypted wallet.
|
|
assert(false);
|
|
}
|
|
|
|
delete encrypted_batch;
|
|
encrypted_batch = nullptr;
|
|
|
|
Lock();
|
|
Unlock(strWalletPassphrase);
|
|
|
|
// if we are using HD, replace the HD seed with a new one
|
|
if (IsHDEnabled()) {
|
|
SetHDSeed(GenerateNewSeed());
|
|
}
|
|
|
|
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.
|
|
database->Rewrite();
|
|
|
|
}
|
|
NotifyStatusChanged(this);
|
|
|
|
return true;
|
|
}
|
|
|
|
DBErrors CWallet::ReorderTransactions()
|
|
{
|
|
LOCK(cs_wallet);
|
|
WalletBatch batch(*database);
|
|
|
|
// Old wallets didn't have any defined order for transactions
|
|
// Probably a bad idea to change the output of this
|
|
|
|
// First: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap.
|
|
typedef std::pair<CWalletTx*, CAccountingEntry*> TxPair;
|
|
typedef std::multimap<int64_t, TxPair > TxItems;
|
|
TxItems txByTime;
|
|
|
|
for (auto& entry : mapWallet)
|
|
{
|
|
CWalletTx* wtx = &entry.second;
|
|
txByTime.insert(std::make_pair(wtx->nTimeReceived, TxPair(wtx, nullptr)));
|
|
}
|
|
std::list<CAccountingEntry> acentries;
|
|
batch.ListAccountCreditDebit("", acentries);
|
|
for (CAccountingEntry& entry : acentries)
|
|
{
|
|
txByTime.insert(std::make_pair(entry.nTime, TxPair(nullptr, &entry)));
|
|
}
|
|
|
|
nOrderPosNext = 0;
|
|
std::vector<int64_t> nOrderPosOffsets;
|
|
for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)
|
|
{
|
|
CWalletTx *const pwtx = (*it).second.first;
|
|
CAccountingEntry *const pacentry = (*it).second.second;
|
|
int64_t& nOrderPos = (pwtx != nullptr) ? pwtx->nOrderPos : pacentry->nOrderPos;
|
|
|
|
if (nOrderPos == -1)
|
|
{
|
|
nOrderPos = nOrderPosNext++;
|
|
nOrderPosOffsets.push_back(nOrderPos);
|
|
|
|
if (pwtx)
|
|
{
|
|
if (!batch.WriteTx(*pwtx))
|
|
return DBErrors::LOAD_FAIL;
|
|
}
|
|
else
|
|
if (!batch.WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
|
|
return DBErrors::LOAD_FAIL;
|
|
}
|
|
else
|
|
{
|
|
int64_t nOrderPosOff = 0;
|
|
for (const int64_t& nOffsetStart : nOrderPosOffsets)
|
|
{
|
|
if (nOrderPos >= nOffsetStart)
|
|
++nOrderPosOff;
|
|
}
|
|
nOrderPos += nOrderPosOff;
|
|
nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
|
|
|
|
if (!nOrderPosOff)
|
|
continue;
|
|
|
|
// Since we're changing the order, write it back
|
|
if (pwtx)
|
|
{
|
|
if (!batch.WriteTx(*pwtx))
|
|
return DBErrors::LOAD_FAIL;
|
|
}
|
|
else
|
|
if (!batch.WriteAccountingEntry(pacentry->nEntryNo, *pacentry))
|
|
return DBErrors::LOAD_FAIL;
|
|
}
|
|
}
|
|
batch.WriteOrderPosNext(nOrderPosNext);
|
|
|
|
return DBErrors::LOAD_OK;
|
|
}
|
|
|
|
int64_t CWallet::IncOrderPosNext(WalletBatch *batch)
|
|
{
|
|
AssertLockHeld(cs_wallet); // nOrderPosNext
|
|
int64_t nRet = nOrderPosNext++;
|
|
if (batch) {
|
|
batch->WriteOrderPosNext(nOrderPosNext);
|
|
} else {
|
|
WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
bool CWallet::AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment)
|
|
{
|
|
WalletBatch batch(*database);
|
|
if (!batch.TxnBegin())
|
|
return false;
|
|
|
|
int64_t nNow = GetAdjustedTime();
|
|
|
|
// Debit
|
|
CAccountingEntry debit;
|
|
debit.nOrderPos = IncOrderPosNext(&batch);
|
|
debit.strAccount = strFrom;
|
|
debit.nCreditDebit = -nAmount;
|
|
debit.nTime = nNow;
|
|
debit.strOtherAccount = strTo;
|
|
debit.strComment = strComment;
|
|
AddAccountingEntry(debit, &batch);
|
|
|
|
// Credit
|
|
CAccountingEntry credit;
|
|
credit.nOrderPos = IncOrderPosNext(&batch);
|
|
credit.strAccount = strTo;
|
|
credit.nCreditDebit = nAmount;
|
|
credit.nTime = nNow;
|
|
credit.strOtherAccount = strFrom;
|
|
credit.strComment = strComment;
|
|
AddAccountingEntry(credit, &batch);
|
|
|
|
if (!batch.TxnCommit())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::GetLabelDestination(CTxDestination &dest, const std::string& label, bool bForceNew)
|
|
{
|
|
WalletBatch batch(*database);
|
|
|
|
CAccount account;
|
|
batch.ReadAccount(label, account);
|
|
|
|
if (!bForceNew) {
|
|
if (!account.vchPubKey.IsValid())
|
|
bForceNew = true;
|
|
else {
|
|
// Check if the current key has been used (TODO: check other addresses with the same key)
|
|
CScript scriptPubKey = GetScriptForDestination(GetDestinationForKey(account.vchPubKey, m_default_address_type));
|
|
for (std::map<uint256, CWalletTx>::iterator it = mapWallet.begin();
|
|
it != mapWallet.end() && account.vchPubKey.IsValid();
|
|
++it)
|
|
for (const CTxOut& txout : (*it).second.tx->vout)
|
|
if (txout.scriptPubKey == scriptPubKey) {
|
|
bForceNew = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate a new key
|
|
if (bForceNew) {
|
|
if (!GetKeyFromPool(account.vchPubKey, false))
|
|
return false;
|
|
|
|
LearnRelatedScripts(account.vchPubKey, m_default_address_type);
|
|
dest = GetDestinationForKey(account.vchPubKey, m_default_address_type);
|
|
SetAddressBook(dest, label, "receive");
|
|
batch.WriteAccount(label, account);
|
|
} else {
|
|
dest = GetDestinationForKey(account.vchPubKey, m_default_address_type);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CWallet::MarkDirty()
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (std::pair<const uint256, CWalletTx>& item : mapWallet)
|
|
item.second.MarkDirty();
|
|
}
|
|
}
|
|
|
|
bool CWallet::MarkReplaced(const uint256& originalHash, const uint256& newHash)
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
auto mi = mapWallet.find(originalHash);
|
|
|
|
// There is a bug if MarkReplaced is not called on an existing wallet transaction.
|
|
assert(mi != mapWallet.end());
|
|
|
|
CWalletTx& wtx = (*mi).second;
|
|
|
|
// Ensure for now that we're not overwriting data
|
|
assert(wtx.mapValue.count("replaced_by_txid") == 0);
|
|
|
|
wtx.mapValue["replaced_by_txid"] = newHash.ToString();
|
|
|
|
WalletBatch batch(*database, "r+");
|
|
|
|
bool success = true;
|
|
if (!batch.WriteTx(wtx)) {
|
|
WalletLogPrintf("%s: Updating batch tx %s failed\n", __func__, wtx.GetHash().ToString());
|
|
success = false;
|
|
}
|
|
|
|
NotifyTransactionChanged(this, originalHash, CT_UPDATED);
|
|
|
|
return success;
|
|
}
|
|
|
|
bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFlushOnClose)
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
WalletBatch batch(*database, "r+", fFlushOnClose);
|
|
|
|
uint256 hash = wtxIn.GetHash();
|
|
|
|
// Inserts only if not already there, returns tx inserted or tx found
|
|
std::pair<std::map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(std::make_pair(hash, wtxIn));
|
|
CWalletTx& wtx = (*ret.first).second;
|
|
wtx.BindWallet(this);
|
|
bool fInsertedNew = ret.second;
|
|
if (fInsertedNew) {
|
|
wtx.nTimeReceived = GetAdjustedTime();
|
|
wtx.nOrderPos = IncOrderPosNext(&batch);
|
|
wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, nullptr)));
|
|
wtx.nTimeSmart = ComputeTimeSmart(wtx);
|
|
AddToSpends(hash);
|
|
}
|
|
|
|
bool fUpdated = false;
|
|
if (!fInsertedNew)
|
|
{
|
|
// Merge
|
|
if (!wtxIn.hashUnset() && wtxIn.hashBlock != wtx.hashBlock)
|
|
{
|
|
wtx.hashBlock = wtxIn.hashBlock;
|
|
fUpdated = true;
|
|
}
|
|
// If no longer abandoned, update
|
|
if (wtxIn.hashBlock.IsNull() && wtx.isAbandoned())
|
|
{
|
|
wtx.hashBlock = wtxIn.hashBlock;
|
|
fUpdated = true;
|
|
}
|
|
if (wtxIn.nIndex != -1 && (wtxIn.nIndex != wtx.nIndex))
|
|
{
|
|
wtx.nIndex = wtxIn.nIndex;
|
|
fUpdated = true;
|
|
}
|
|
if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
|
|
{
|
|
wtx.fFromMe = wtxIn.fFromMe;
|
|
fUpdated = true;
|
|
}
|
|
// If we have a witness-stripped version of this transaction, and we
|
|
// see a new version with a witness, then we must be upgrading a pre-segwit
|
|
// wallet. Store the new version of the transaction with the witness,
|
|
// as the stripped-version must be invalid.
|
|
// TODO: Store all versions of the transaction, instead of just one.
|
|
if (wtxIn.tx->HasWitness() && !wtx.tx->HasWitness()) {
|
|
wtx.SetTx(wtxIn.tx);
|
|
fUpdated = true;
|
|
}
|
|
}
|
|
|
|
//// debug print
|
|
WalletLogPrintf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
|
|
|
|
// Write to disk
|
|
if (fInsertedNew || fUpdated)
|
|
if (!batch.WriteTx(wtx))
|
|
return false;
|
|
|
|
// Break debit/credit balance caches:
|
|
wtx.MarkDirty();
|
|
|
|
// Notify UI of new or updated transaction
|
|
NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);
|
|
|
|
// notify an external script when a wallet transaction comes in or is updated
|
|
std::string strCmd = gArgs.GetArg("-walletnotify", "");
|
|
|
|
if (!strCmd.empty())
|
|
{
|
|
boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex());
|
|
std::thread t(runCommand, strCmd);
|
|
t.detach(); // thread runs free
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CWallet::LoadToWallet(const CWalletTx& wtxIn)
|
|
{
|
|
uint256 hash = wtxIn.GetHash();
|
|
const auto& ins = mapWallet.emplace(hash, wtxIn);
|
|
CWalletTx& wtx = ins.first->second;
|
|
wtx.BindWallet(this);
|
|
if (/* insertion took place */ ins.second) {
|
|
wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, nullptr)));
|
|
}
|
|
AddToSpends(hash);
|
|
for (const CTxIn& txin : wtx.tx->vin) {
|
|
auto it = mapWallet.find(txin.prevout.hash);
|
|
if (it != mapWallet.end()) {
|
|
CWalletTx& prevtx = it->second;
|
|
if (prevtx.nIndex == -1 && !prevtx.hashUnset()) {
|
|
MarkConflicted(prevtx.hashBlock, wtx.GetHash());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef& ptx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate)
|
|
{
|
|
const CTransaction& tx = *ptx;
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
|
|
if (pIndex != nullptr) {
|
|
for (const CTxIn& txin : tx.vin) {
|
|
std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range = mapTxSpends.equal_range(txin.prevout);
|
|
while (range.first != range.second) {
|
|
if (range.first->second != tx.GetHash()) {
|
|
WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), pIndex->GetBlockHash().ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);
|
|
MarkConflicted(pIndex->GetBlockHash(), range.first->second);
|
|
}
|
|
range.first++;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool fExisted = mapWallet.count(tx.GetHash()) != 0;
|
|
if (fExisted && !fUpdate) return false;
|
|
if (fExisted || IsMine(tx) || IsFromMe(tx))
|
|
{
|
|
/* Check if any keys in the wallet keypool that were supposed to be unused
|
|
* have appeared in a new transaction. If so, remove those keys from the keypool.
|
|
* This can happen when restoring an old wallet backup that does not contain
|
|
* the mostly recently created transactions from newer versions of the wallet.
|
|
*/
|
|
|
|
// loop though all outputs
|
|
for (const CTxOut& txout: tx.vout) {
|
|
// extract addresses and check if they match with an unused keypool key
|
|
std::vector<CKeyID> vAffected;
|
|
CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
|
|
for (const CKeyID &keyid : vAffected) {
|
|
std::map<CKeyID, int64_t>::const_iterator mi = m_pool_key_to_index.find(keyid);
|
|
if (mi != m_pool_key_to_index.end()) {
|
|
WalletLogPrintf("%s: Detected a used keypool key, mark all keypool key up to this key as used\n", __func__);
|
|
MarkReserveKeysAsUsed(mi->second);
|
|
|
|
if (!TopUpKeyPool()) {
|
|
WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CWalletTx wtx(this, ptx);
|
|
|
|
// Get merkle branch if transaction was found in a block
|
|
if (pIndex != nullptr)
|
|
wtx.SetMerkleBranch(pIndex, posInBlock);
|
|
|
|
return AddToWallet(wtx, false);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::TransactionCanBeAbandoned(const uint256& hashTx) const
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
const CWalletTx* wtx = GetWalletTx(hashTx);
|
|
return wtx && !wtx->isAbandoned() && wtx->GetDepthInMainChain() == 0 && !wtx->InMempool();
|
|
}
|
|
|
|
void CWallet::MarkInputsDirty(const CTransactionRef& tx)
|
|
{
|
|
for (const CTxIn& txin : tx->vin) {
|
|
auto it = mapWallet.find(txin.prevout.hash);
|
|
if (it != mapWallet.end()) {
|
|
it->second.MarkDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CWallet::AbandonTransaction(const uint256& hashTx)
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
WalletBatch batch(*database, "r+");
|
|
|
|
std::set<uint256> todo;
|
|
std::set<uint256> done;
|
|
|
|
// Can't mark abandoned if confirmed or in mempool
|
|
auto it = mapWallet.find(hashTx);
|
|
assert(it != mapWallet.end());
|
|
CWalletTx& origtx = it->second;
|
|
if (origtx.GetDepthInMainChain() != 0 || origtx.InMempool()) {
|
|
return false;
|
|
}
|
|
|
|
todo.insert(hashTx);
|
|
|
|
while (!todo.empty()) {
|
|
uint256 now = *todo.begin();
|
|
todo.erase(now);
|
|
done.insert(now);
|
|
auto it = mapWallet.find(now);
|
|
assert(it != mapWallet.end());
|
|
CWalletTx& wtx = it->second;
|
|
int currentconfirm = wtx.GetDepthInMainChain();
|
|
// If the orig tx was not in block, none of its spends can be
|
|
assert(currentconfirm <= 0);
|
|
// if (currentconfirm < 0) {Tx and spends are already conflicted, no need to abandon}
|
|
if (currentconfirm == 0 && !wtx.isAbandoned()) {
|
|
// If the orig tx was not in block/mempool, none of its spends can be in mempool
|
|
assert(!wtx.InMempool());
|
|
wtx.nIndex = -1;
|
|
wtx.setAbandoned();
|
|
wtx.MarkDirty();
|
|
batch.WriteTx(wtx);
|
|
NotifyTransactionChanged(this, wtx.GetHash(), CT_UPDATED);
|
|
// Iterate over all its outputs, and mark transactions in the wallet that spend them abandoned too
|
|
TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(now, 0));
|
|
while (iter != mapTxSpends.end() && iter->first.hash == now) {
|
|
if (!done.count(iter->second)) {
|
|
todo.insert(iter->second);
|
|
}
|
|
iter++;
|
|
}
|
|
// If a transaction changes 'conflicted' state, that changes the balance
|
|
// available of the outputs it spends. So force those to be recomputed
|
|
MarkInputsDirty(wtx.tx);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CWallet::MarkConflicted(const uint256& hashBlock, const uint256& hashTx)
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
int conflictconfirms = 0;
|
|
CBlockIndex* pindex = LookupBlockIndex(hashBlock);
|
|
if (pindex && chainActive.Contains(pindex)) {
|
|
conflictconfirms = -(chainActive.Height() - pindex->nHeight + 1);
|
|
}
|
|
// If number of conflict confirms cannot be determined, this means
|
|
// that the block is still unknown or not yet part of the main chain,
|
|
// for example when loading the wallet during a reindex. Do nothing in that
|
|
// case.
|
|
if (conflictconfirms >= 0)
|
|
return;
|
|
|
|
// Do not flush the wallet here for performance reasons
|
|
WalletBatch batch(*database, "r+", false);
|
|
|
|
std::set<uint256> todo;
|
|
std::set<uint256> done;
|
|
|
|
todo.insert(hashTx);
|
|
|
|
while (!todo.empty()) {
|
|
uint256 now = *todo.begin();
|
|
todo.erase(now);
|
|
done.insert(now);
|
|
auto it = mapWallet.find(now);
|
|
assert(it != mapWallet.end());
|
|
CWalletTx& wtx = it->second;
|
|
int currentconfirm = wtx.GetDepthInMainChain();
|
|
if (conflictconfirms < currentconfirm) {
|
|
// Block is 'more conflicted' than current confirm; update.
|
|
// Mark transaction as conflicted with this block.
|
|
wtx.nIndex = -1;
|
|
wtx.hashBlock = hashBlock;
|
|
wtx.MarkDirty();
|
|
batch.WriteTx(wtx);
|
|
// Iterate over all its outputs, and mark transactions in the wallet that spend them conflicted too
|
|
TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(now, 0));
|
|
while (iter != mapTxSpends.end() && iter->first.hash == now) {
|
|
if (!done.count(iter->second)) {
|
|
todo.insert(iter->second);
|
|
}
|
|
iter++;
|
|
}
|
|
// If a transaction changes 'conflicted' state, that changes the balance
|
|
// available of the outputs it spends. So force those to be recomputed
|
|
MarkInputsDirty(wtx.tx);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CWallet::SyncTransaction(const CTransactionRef& ptx, const CBlockIndex *pindex, int posInBlock, bool update_tx) {
|
|
if (!AddToWalletIfInvolvingMe(ptx, pindex, posInBlock, update_tx))
|
|
return; // Not one of ours
|
|
|
|
// If a transaction changes 'conflicted' state, that changes the balance
|
|
// available of the outputs it spends. So force those to be
|
|
// recomputed, also:
|
|
MarkInputsDirty(ptx);
|
|
}
|
|
|
|
void CWallet::TransactionAddedToMempool(const CTransactionRef& ptx) {
|
|
LOCK2(cs_main, cs_wallet);
|
|
SyncTransaction(ptx);
|
|
|
|
auto it = mapWallet.find(ptx->GetHash());
|
|
if (it != mapWallet.end()) {
|
|
it->second.fInMempool = true;
|
|
}
|
|
}
|
|
|
|
void CWallet::TransactionRemovedFromMempool(const CTransactionRef &ptx) {
|
|
LOCK(cs_wallet);
|
|
auto it = mapWallet.find(ptx->GetHash());
|
|
if (it != mapWallet.end()) {
|
|
it->second.fInMempool = false;
|
|
}
|
|
}
|
|
|
|
void CWallet::BlockConnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex *pindex, const std::vector<CTransactionRef>& vtxConflicted) {
|
|
LOCK2(cs_main, cs_wallet);
|
|
// TODO: Temporarily ensure that mempool removals are notified before
|
|
// connected transactions. This shouldn't matter, but the abandoned
|
|
// state of transactions in our wallet is currently cleared when we
|
|
// receive another notification and there is a race condition where
|
|
// notification of a connected conflict might cause an outside process
|
|
// to abandon a transaction and then have it inadvertently cleared by
|
|
// the notification that the conflicted transaction was evicted.
|
|
|
|
for (const CTransactionRef& ptx : vtxConflicted) {
|
|
SyncTransaction(ptx);
|
|
TransactionRemovedFromMempool(ptx);
|
|
}
|
|
for (size_t i = 0; i < pblock->vtx.size(); i++) {
|
|
SyncTransaction(pblock->vtx[i], pindex, i);
|
|
TransactionRemovedFromMempool(pblock->vtx[i]);
|
|
}
|
|
|
|
m_last_block_processed = pindex;
|
|
}
|
|
|
|
void CWallet::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock) {
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
for (const CTransactionRef& ptx : pblock->vtx) {
|
|
SyncTransaction(ptx);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CWallet::BlockUntilSyncedToCurrentChain() {
|
|
AssertLockNotHeld(cs_main);
|
|
AssertLockNotHeld(cs_wallet);
|
|
|
|
{
|
|
// Skip the queue-draining stuff if we know we're caught up with
|
|
// chainActive.Tip()...
|
|
// We could also take cs_wallet here, and call m_last_block_processed
|
|
// protected by cs_wallet instead of cs_main, but as long as we need
|
|
// cs_main here anyway, it's easier to just call it cs_main-protected.
|
|
LOCK(cs_main);
|
|
const CBlockIndex* initialChainTip = chainActive.Tip();
|
|
|
|
if (m_last_block_processed && m_last_block_processed->GetAncestor(initialChainTip->nHeight) == initialChainTip) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// ...otherwise put a callback in the validation interface queue and wait
|
|
// for the queue to drain enough to execute it (indicating we are caught up
|
|
// at least with the time we entered this function).
|
|
SyncWithValidationInterfaceQueue();
|
|
}
|
|
|
|
|
|
isminetype CWallet::IsMine(const CTxIn &txin) const
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
std::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.tx->vout.size())
|
|
return IsMine(prev.tx->vout[txin.prevout.n]);
|
|
}
|
|
}
|
|
return ISMINE_NO;
|
|
}
|
|
|
|
// Note that this function doesn't distinguish between a 0-valued input,
|
|
// and a not-"is mine" (according to the filter) input.
|
|
CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
|
|
{
|
|
{
|
|
LOCK(cs_wallet);
|
|
std::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.tx->vout.size())
|
|
if (IsMine(prev.tx->vout[txin.prevout.n]) & filter)
|
|
return prev.tx->vout[txin.prevout.n].nValue;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
isminetype CWallet::IsMine(const CTxOut& txout) const
|
|
{
|
|
return ::IsMine(*this, txout.scriptPubKey);
|
|
}
|
|
|
|
CAmount CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
|
|
{
|
|
if (!MoneyRange(txout.nValue))
|
|
throw std::runtime_error(std::string(__func__) + ": value out of range");
|
|
return ((IsMine(txout) & filter) ? txout.nValue : 0);
|
|
}
|
|
|
|
bool CWallet::IsChange(const CTxOut& txout) const
|
|
{
|
|
// TODO: fix handling of 'change' outputs. The assumption is that any
|
|
// payment to a script that is ours, but is not 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 (::IsMine(*this, txout.scriptPubKey))
|
|
{
|
|
CTxDestination address;
|
|
if (!ExtractDestination(txout.scriptPubKey, address))
|
|
return true;
|
|
|
|
LOCK(cs_wallet);
|
|
if (!mapAddressBook.count(address))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
CAmount CWallet::GetChange(const CTxOut& txout) const
|
|
{
|
|
if (!MoneyRange(txout.nValue))
|
|
throw std::runtime_error(std::string(__func__) + ": value out of range");
|
|
return (IsChange(txout) ? txout.nValue : 0);
|
|
}
|
|
|
|
bool CWallet::IsMine(const CTransaction& tx) const
|
|
{
|
|
for (const CTxOut& txout : tx.vout)
|
|
if (IsMine(txout))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool CWallet::IsFromMe(const CTransaction& tx) const
|
|
{
|
|
return (GetDebit(tx, ISMINE_ALL) > 0);
|
|
}
|
|
|
|
CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
|
|
{
|
|
CAmount nDebit = 0;
|
|
for (const CTxIn& txin : tx.vin)
|
|
{
|
|
nDebit += GetDebit(txin, filter);
|
|
if (!MoneyRange(nDebit))
|
|
throw std::runtime_error(std::string(__func__) + ": value out of range");
|
|
}
|
|
return nDebit;
|
|
}
|
|
|
|
bool CWallet::IsAllFromMe(const CTransaction& tx, const isminefilter& filter) const
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
for (const CTxIn& txin : tx.vin)
|
|
{
|
|
auto mi = mapWallet.find(txin.prevout.hash);
|
|
if (mi == mapWallet.end())
|
|
return false; // any unknown inputs can't be from us
|
|
|
|
const CWalletTx& prev = (*mi).second;
|
|
|
|
if (txin.prevout.n >= prev.tx->vout.size())
|
|
return false; // invalid input!
|
|
|
|
if (!(IsMine(prev.tx->vout[txin.prevout.n]) & filter))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
|
|
{
|
|
CAmount nCredit = 0;
|
|
for (const CTxOut& txout : tx.vout)
|
|
{
|
|
nCredit += GetCredit(txout, filter);
|
|
if (!MoneyRange(nCredit))
|
|
throw std::runtime_error(std::string(__func__) + ": value out of range");
|
|
}
|
|
return nCredit;
|
|
}
|
|
|
|
CAmount CWallet::GetChange(const CTransaction& tx) const
|
|
{
|
|
CAmount nChange = 0;
|
|
for (const CTxOut& txout : tx.vout)
|
|
{
|
|
nChange += GetChange(txout);
|
|
if (!MoneyRange(nChange))
|
|
throw std::runtime_error(std::string(__func__) + ": value out of range");
|
|
}
|
|
return nChange;
|
|
}
|
|
|
|
CPubKey CWallet::GenerateNewSeed()
|
|
{
|
|
assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));
|
|
CKey key;
|
|
key.MakeNewKey(true);
|
|
return DeriveNewSeed(key);
|
|
}
|
|
|
|
CPubKey CWallet::DeriveNewSeed(const CKey& key)
|
|
{
|
|
int64_t nCreationTime = GetTime();
|
|
CKeyMetadata metadata(nCreationTime);
|
|
|
|
// calculate the seed
|
|
CPubKey seed = key.GetPubKey();
|
|
assert(key.VerifyPubKey(seed));
|
|
|
|
// set the hd keypath to "s" -> Seed, refers the seed to itself
|
|
metadata.hdKeypath = "s";
|
|
metadata.hd_seed_id = seed.GetID();
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
// mem store the metadata
|
|
mapKeyMetadata[seed.GetID()] = metadata;
|
|
|
|
// write the key&metadata to the database
|
|
if (!AddKeyPubKey(key, seed))
|
|
throw std::runtime_error(std::string(__func__) + ": AddKeyPubKey failed");
|
|
}
|
|
|
|
return seed;
|
|
}
|
|
|
|
void CWallet::SetHDSeed(const CPubKey& seed)
|
|
{
|
|
LOCK(cs_wallet);
|
|
// store the keyid (hash160) together with
|
|
// the child index counter in the database
|
|
// as a hdchain object
|
|
CHDChain newHdChain;
|
|
newHdChain.nVersion = CanSupportFeature(FEATURE_HD_SPLIT) ? CHDChain::VERSION_HD_CHAIN_SPLIT : CHDChain::VERSION_HD_BASE;
|
|
newHdChain.seed_id = seed.GetID();
|
|
SetHDChain(newHdChain, false);
|
|
}
|
|
|
|
void CWallet::SetHDChain(const CHDChain& chain, bool memonly)
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (!memonly && !WalletBatch(*database).WriteHDChain(chain))
|
|
throw std::runtime_error(std::string(__func__) + ": writing chain failed");
|
|
|
|
hdChain = chain;
|
|
}
|
|
|
|
bool CWallet::IsHDEnabled() const
|
|
{
|
|
return !hdChain.seed_id.IsNull();
|
|
}
|
|
|
|
void CWallet::SetWalletFlag(uint64_t flags)
|
|
{
|
|
LOCK(cs_wallet);
|
|
m_wallet_flags |= flags;
|
|
if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags))
|
|
throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
|
|
}
|
|
|
|
bool CWallet::IsWalletFlagSet(uint64_t flag)
|
|
{
|
|
return (m_wallet_flags & flag);
|
|
}
|
|
|
|
bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly)
|
|
{
|
|
LOCK(cs_wallet);
|
|
m_wallet_flags = overwriteFlags;
|
|
if (((overwriteFlags & g_known_wallet_flags) >> 32) ^ (overwriteFlags >> 32)) {
|
|
// contains unknown non-tolerable wallet flags
|
|
return false;
|
|
}
|
|
if (!memonly && !WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {
|
|
throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int64_t CWalletTx::GetTxTime() const
|
|
{
|
|
int64_t n = nTimeSmart;
|
|
return n ? n : nTimeReceived;
|
|
}
|
|
|
|
// Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
|
|
// or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
|
|
bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout, bool use_max_sig) const
|
|
{
|
|
// Fill in dummy signatures for fee calculation.
|
|
const CScript& scriptPubKey = txout.scriptPubKey;
|
|
SignatureData sigdata;
|
|
|
|
if (!ProduceSignature(*this, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, scriptPubKey, sigdata)) {
|
|
return false;
|
|
}
|
|
UpdateInput(tx_in, sigdata);
|
|
return true;
|
|
}
|
|
|
|
// Helper for producing a bunch of max-sized low-S low-R signatures (eg 71 bytes)
|
|
bool CWallet::DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, bool use_max_sig) const
|
|
{
|
|
// Fill in dummy signatures for fee calculation.
|
|
int nIn = 0;
|
|
for (const auto& txout : txouts)
|
|
{
|
|
if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
|
|
return false;
|
|
}
|
|
|
|
nIn++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, bool use_max_sig)
|
|
{
|
|
std::vector<CTxOut> txouts;
|
|
// Look up the inputs. We should have already checked that this transaction
|
|
// IsAllFromMe(ISMINE_SPENDABLE), so every input should already be in our
|
|
// wallet, with a valid index into the vout array, and the ability to sign.
|
|
for (auto& input : tx.vin) {
|
|
const auto mi = wallet->mapWallet.find(input.prevout.hash);
|
|
if (mi == wallet->mapWallet.end()) {
|
|
return -1;
|
|
}
|
|
assert(input.prevout.n < mi->second.tx->vout.size());
|
|
txouts.emplace_back(mi->second.tx->vout[input.prevout.n]);
|
|
}
|
|
return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
|
|
}
|
|
|
|
// txouts needs to be in the order of tx.vin
|
|
int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, bool use_max_sig)
|
|
{
|
|
CMutableTransaction txNew(tx);
|
|
if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
|
|
// This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
|
|
// implies that we can sign for every input.
|
|
return -1;
|
|
}
|
|
return GetVirtualTransactionSize(txNew);
|
|
}
|
|
|
|
int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* wallet, bool use_max_sig)
|
|
{
|
|
CMutableTransaction txn;
|
|
txn.vin.push_back(CTxIn(COutPoint()));
|
|
if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
|
|
// This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
|
|
// implies that we can sign for every input.
|
|
return -1;
|
|
}
|
|
return GetVirtualTransactionInputSize(txn.vin[0]);
|
|
}
|
|
|
|
void CWalletTx::GetAmounts(std::list<COutputEntry>& listReceived,
|
|
std::list<COutputEntry>& listSent, CAmount& nFee, std::string& strSentAccount, const isminefilter& filter) const
|
|
{
|
|
nFee = 0;
|
|
listReceived.clear();
|
|
listSent.clear();
|
|
strSentAccount = strFromAccount;
|
|
|
|
// Compute fee:
|
|
CAmount nDebit = GetDebit(filter);
|
|
if (nDebit > 0) // debit>0 means we signed/sent this transaction
|
|
{
|
|
CAmount nValueOut = tx->GetValueOut();
|
|
nFee = nDebit - nValueOut;
|
|
}
|
|
|
|
// Sent/received.
|
|
for (unsigned int i = 0; i < tx->vout.size(); ++i)
|
|
{
|
|
const CTxOut& txout = tx->vout[i];
|
|
isminetype fIsMine = pwallet->IsMine(txout);
|
|
// 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;
|
|
}
|
|
else if (!(fIsMine & filter))
|
|
continue;
|
|
|
|
// In either case, we need to get the destination address
|
|
CTxDestination address;
|
|
|
|
if (!ExtractDestination(txout.scriptPubKey, address) && !txout.scriptPubKey.IsUnspendable())
|
|
{
|
|
pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
|
|
this->GetHash().ToString());
|
|
address = CNoDestination();
|
|
}
|
|
|
|
COutputEntry output = {address, txout.nValue, (int)i};
|
|
|
|
// If we are debited by the transaction, add the output as a "sent" entry
|
|
if (nDebit > 0)
|
|
listSent.push_back(output);
|
|
|
|
// If we are receiving the output, add it as a "received" entry
|
|
if (fIsMine & filter)
|
|
listReceived.push_back(output);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Scan active chain for relevant transactions after importing keys. This should
|
|
* be called whenever new keys are added to the wallet, with the oldest key
|
|
* creation time.
|
|
*
|
|
* @return Earliest timestamp that could be successfully scanned from. Timestamp
|
|
* returned will be higher than startTime if relevant blocks could not be read.
|
|
*/
|
|
int64_t CWallet::RescanFromTime(int64_t startTime, const WalletRescanReserver& reserver, bool update)
|
|
{
|
|
// Find starting block. May be null if nCreateTime is greater than the
|
|
// highest blockchain timestamp, in which case there is nothing that needs
|
|
// to be scanned.
|
|
CBlockIndex* startBlock = nullptr;
|
|
{
|
|
LOCK(cs_main);
|
|
startBlock = chainActive.FindEarliestAtLeast(startTime - TIMESTAMP_WINDOW);
|
|
WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, startBlock ? chainActive.Height() - startBlock->nHeight + 1 : 0);
|
|
}
|
|
|
|
if (startBlock) {
|
|
const CBlockIndex* const failedBlock = ScanForWalletTransactions(startBlock, nullptr, reserver, update);
|
|
if (failedBlock) {
|
|
return failedBlock->GetBlockTimeMax() + TIMESTAMP_WINDOW + 1;
|
|
}
|
|
}
|
|
return startTime;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Returns null if scan was successful. Otherwise, if a complete rescan was not
|
|
* possible (due to pruning or corruption), returns pointer to the most recent
|
|
* block that could not be scanned.
|
|
*
|
|
* If pindexStop is not a nullptr, the scan will stop at the block-index
|
|
* defined by pindexStop
|
|
*
|
|
* Caller needs to make sure pindexStop (and the optional pindexStart) are on
|
|
* the main chain after to the addition of any new keys you want to detect
|
|
* transactions for.
|
|
*/
|
|
CBlockIndex* CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, CBlockIndex* pindexStop, const WalletRescanReserver &reserver, bool fUpdate)
|
|
{
|
|
int64_t nNow = GetTime();
|
|
const CChainParams& chainParams = Params();
|
|
|
|
assert(reserver.isReserved());
|
|
if (pindexStop) {
|
|
assert(pindexStop->nHeight >= pindexStart->nHeight);
|
|
}
|
|
|
|
CBlockIndex* pindex = pindexStart;
|
|
CBlockIndex* ret = nullptr;
|
|
|
|
if (pindex) WalletLogPrintf("Rescan started from block %d...\n", pindex->nHeight);
|
|
|
|
{
|
|
fAbortRescan = false;
|
|
ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), 0); // show rescan progress in GUI as dialog or on splashscreen, if -rescan on startup
|
|
CBlockIndex* tip = nullptr;
|
|
double progress_begin;
|
|
double progress_end;
|
|
{
|
|
LOCK(cs_main);
|
|
progress_begin = GuessVerificationProgress(chainParams.TxData(), pindex);
|
|
if (pindexStop == nullptr) {
|
|
tip = chainActive.Tip();
|
|
progress_end = GuessVerificationProgress(chainParams.TxData(), tip);
|
|
} else {
|
|
progress_end = GuessVerificationProgress(chainParams.TxData(), pindexStop);
|
|
}
|
|
}
|
|
double progress_current = progress_begin;
|
|
while (pindex && !fAbortRescan && !ShutdownRequested())
|
|
{
|
|
if (pindex->nHeight % 100 == 0 && progress_end - progress_begin > 0.0) {
|
|
ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), std::max(1, std::min(99, (int)((progress_current - progress_begin) / (progress_end - progress_begin) * 100))));
|
|
}
|
|
if (GetTime() >= nNow + 60) {
|
|
nNow = GetTime();
|
|
WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", pindex->nHeight, progress_current);
|
|
}
|
|
|
|
CBlock block;
|
|
if (ReadBlockFromDisk(block, pindex, Params().GetConsensus())) {
|
|
LOCK2(cs_main, cs_wallet);
|
|
if (pindex && !chainActive.Contains(pindex)) {
|
|
// Abort scan if current block is no longer active, to prevent
|
|
// marking transactions as coming from the wrong block.
|
|
ret = pindex;
|
|
break;
|
|
}
|
|
for (size_t posInBlock = 0; posInBlock < block.vtx.size(); ++posInBlock) {
|
|
SyncTransaction(block.vtx[posInBlock], pindex, posInBlock, fUpdate);
|
|
}
|
|
} else {
|
|
ret = pindex;
|
|
}
|
|
if (pindex == pindexStop) {
|
|
break;
|
|
}
|
|
{
|
|
LOCK(cs_main);
|
|
pindex = chainActive.Next(pindex);
|
|
progress_current = GuessVerificationProgress(chainParams.TxData(), pindex);
|
|
if (pindexStop == nullptr && tip != chainActive.Tip()) {
|
|
tip = chainActive.Tip();
|
|
// in case the tip has changed, update progress max
|
|
progress_end = GuessVerificationProgress(chainParams.TxData(), tip);
|
|
}
|
|
}
|
|
}
|
|
if (pindex && fAbortRescan) {
|
|
WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", pindex->nHeight, progress_current);
|
|
} else if (pindex && ShutdownRequested()) {
|
|
WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", pindex->nHeight, progress_current);
|
|
}
|
|
ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), 100); // hide progress dialog in GUI
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void CWallet::ReacceptWalletTransactions()
|
|
{
|
|
// If transactions aren't being broadcasted, don't let them into local mempool either
|
|
if (!fBroadcastTransactions)
|
|
return;
|
|
LOCK2(cs_main, cs_wallet);
|
|
std::map<int64_t, CWalletTx*> mapSorted;
|
|
|
|
// Sort pending wallet transactions based on their initial wallet insertion order
|
|
for (std::pair<const uint256, CWalletTx>& item : mapWallet)
|
|
{
|
|
const uint256& wtxid = item.first;
|
|
CWalletTx& wtx = item.second;
|
|
assert(wtx.GetHash() == wtxid);
|
|
|
|
int nDepth = wtx.GetDepthInMainChain();
|
|
|
|
if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
|
|
mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
|
|
}
|
|
}
|
|
|
|
// Try to add wallet transactions to memory pool
|
|
for (std::pair<const int64_t, CWalletTx*>& item : mapSorted) {
|
|
CWalletTx& wtx = *(item.second);
|
|
CValidationState state;
|
|
wtx.AcceptToMemoryPool(maxTxFee, state);
|
|
}
|
|
}
|
|
|
|
bool CWalletTx::RelayWalletTransaction(CConnman* connman)
|
|
{
|
|
assert(pwallet->GetBroadcastTransactions());
|
|
if (!IsCoinBase() && !isAbandoned() && GetDepthInMainChain() == 0)
|
|
{
|
|
CValidationState state;
|
|
/* GetDepthInMainChain already catches known conflicts. */
|
|
if (InMempool() || AcceptToMemoryPool(maxTxFee, state)) {
|
|
pwallet->WalletLogPrintf("Relaying wtx %s\n", GetHash().ToString());
|
|
if (connman) {
|
|
CInv inv(MSG_TX, GetHash());
|
|
connman->ForEachNode([&inv](CNode* pnode)
|
|
{
|
|
pnode->PushInventory(inv);
|
|
});
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::set<uint256> CWalletTx::GetConflicts() const
|
|
{
|
|
std::set<uint256> result;
|
|
if (pwallet != nullptr)
|
|
{
|
|
uint256 myHash = GetHash();
|
|
result = pwallet->GetConflicts(myHash);
|
|
result.erase(myHash);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
CAmount CWalletTx::GetDebit(const isminefilter& filter) const
|
|
{
|
|
if (tx->vin.empty())
|
|
return 0;
|
|
|
|
CAmount debit = 0;
|
|
if(filter & ISMINE_SPENDABLE)
|
|
{
|
|
if (fDebitCached)
|
|
debit += nDebitCached;
|
|
else
|
|
{
|
|
nDebitCached = pwallet->GetDebit(*tx, ISMINE_SPENDABLE);
|
|
fDebitCached = true;
|
|
debit += nDebitCached;
|
|
}
|
|
}
|
|
if(filter & ISMINE_WATCH_ONLY)
|
|
{
|
|
if(fWatchDebitCached)
|
|
debit += nWatchDebitCached;
|
|
else
|
|
{
|
|
nWatchDebitCached = pwallet->GetDebit(*tx, ISMINE_WATCH_ONLY);
|
|
fWatchDebitCached = true;
|
|
debit += nWatchDebitCached;
|
|
}
|
|
}
|
|
return debit;
|
|
}
|
|
|
|
CAmount CWalletTx::GetCredit(const isminefilter& filter) const
|
|
{
|
|
// Must wait until coinbase is safely deep enough in the chain before valuing it
|
|
if (IsCoinBase() && GetBlocksToMaturity() > 0)
|
|
return 0;
|
|
|
|
CAmount credit = 0;
|
|
if (filter & ISMINE_SPENDABLE)
|
|
{
|
|
// GetBalance can assume transactions in mapWallet won't change
|
|
if (fCreditCached)
|
|
credit += nCreditCached;
|
|
else
|
|
{
|
|
nCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
|
|
fCreditCached = true;
|
|
credit += nCreditCached;
|
|
}
|
|
}
|
|
if (filter & ISMINE_WATCH_ONLY)
|
|
{
|
|
if (fWatchCreditCached)
|
|
credit += nWatchCreditCached;
|
|
else
|
|
{
|
|
nWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
|
|
fWatchCreditCached = true;
|
|
credit += nWatchCreditCached;
|
|
}
|
|
}
|
|
return credit;
|
|
}
|
|
|
|
CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const
|
|
{
|
|
if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
|
|
{
|
|
if (fUseCache && fImmatureCreditCached)
|
|
return nImmatureCreditCached;
|
|
nImmatureCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
|
|
fImmatureCreditCached = true;
|
|
return nImmatureCreditCached;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
CAmount CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter) const
|
|
{
|
|
if (pwallet == nullptr)
|
|
return 0;
|
|
|
|
// Must wait until coinbase is safely deep enough in the chain before valuing it
|
|
if (IsCoinBase() && GetBlocksToMaturity() > 0)
|
|
return 0;
|
|
|
|
CAmount* cache = nullptr;
|
|
bool* cache_used = nullptr;
|
|
|
|
if (filter == ISMINE_SPENDABLE) {
|
|
cache = &nAvailableCreditCached;
|
|
cache_used = &fAvailableCreditCached;
|
|
} else if (filter == ISMINE_WATCH_ONLY) {
|
|
cache = &nAvailableWatchCreditCached;
|
|
cache_used = &fAvailableWatchCreditCached;
|
|
}
|
|
|
|
if (fUseCache && cache_used && *cache_used) {
|
|
return *cache;
|
|
}
|
|
|
|
CAmount nCredit = 0;
|
|
uint256 hashTx = GetHash();
|
|
for (unsigned int i = 0; i < tx->vout.size(); i++)
|
|
{
|
|
if (!pwallet->IsSpent(hashTx, i))
|
|
{
|
|
const CTxOut &txout = tx->vout[i];
|
|
nCredit += pwallet->GetCredit(txout, filter);
|
|
if (!MoneyRange(nCredit))
|
|
throw std::runtime_error(std::string(__func__) + " : value out of range");
|
|
}
|
|
}
|
|
|
|
if (cache) {
|
|
*cache = nCredit;
|
|
assert(cache_used);
|
|
*cache_used = true;
|
|
}
|
|
return nCredit;
|
|
}
|
|
|
|
CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const
|
|
{
|
|
if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
|
|
{
|
|
if (fUseCache && fImmatureWatchCreditCached)
|
|
return nImmatureWatchCreditCached;
|
|
nImmatureWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
|
|
fImmatureWatchCreditCached = true;
|
|
return nImmatureWatchCreditCached;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
CAmount CWalletTx::GetChange() const
|
|
{
|
|
if (fChangeCached)
|
|
return nChangeCached;
|
|
nChangeCached = pwallet->GetChange(*tx);
|
|
fChangeCached = true;
|
|
return nChangeCached;
|
|
}
|
|
|
|
bool CWalletTx::InMempool() const
|
|
{
|
|
return fInMempool;
|
|
}
|
|
|
|
bool CWalletTx::IsTrusted() const
|
|
{
|
|
// Quick answer in most cases
|
|
if (!CheckFinalTx(*tx))
|
|
return false;
|
|
int nDepth = GetDepthInMainChain();
|
|
if (nDepth >= 1)
|
|
return true;
|
|
if (nDepth < 0)
|
|
return false;
|
|
if (!pwallet->m_spend_zero_conf_change || !IsFromMe(ISMINE_ALL)) // using wtx's cached debit
|
|
return false;
|
|
|
|
// Don't trust unconfirmed transactions from us unless they are in the mempool.
|
|
if (!InMempool())
|
|
return false;
|
|
|
|
// Trusted if all inputs are from us and are in the mempool:
|
|
for (const CTxIn& txin : tx->vin)
|
|
{
|
|
// Transactions not sent by us: not trusted
|
|
const CWalletTx* parent = pwallet->GetWalletTx(txin.prevout.hash);
|
|
if (parent == nullptr)
|
|
return false;
|
|
const CTxOut& parentOut = parent->tx->vout[txin.prevout.n];
|
|
if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWalletTx::IsEquivalentTo(const CWalletTx& _tx) const
|
|
{
|
|
CMutableTransaction tx1 {*this->tx};
|
|
CMutableTransaction tx2 {*_tx.tx};
|
|
for (auto& txin : tx1.vin) txin.scriptSig = CScript();
|
|
for (auto& txin : tx2.vin) txin.scriptSig = CScript();
|
|
return CTransaction(tx1) == CTransaction(tx2);
|
|
}
|
|
|
|
std::vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime, CConnman* connman)
|
|
{
|
|
std::vector<uint256> result;
|
|
|
|
LOCK(cs_wallet);
|
|
|
|
// Sort them in chronological order
|
|
std::multimap<unsigned int, CWalletTx*> mapSorted;
|
|
for (std::pair<const uint256, CWalletTx>& item : mapWallet)
|
|
{
|
|
CWalletTx& wtx = item.second;
|
|
// Don't rebroadcast if newer than nTime:
|
|
if (wtx.nTimeReceived > nTime)
|
|
continue;
|
|
mapSorted.insert(std::make_pair(wtx.nTimeReceived, &wtx));
|
|
}
|
|
for (std::pair<const unsigned int, CWalletTx*>& item : mapSorted)
|
|
{
|
|
CWalletTx& wtx = *item.second;
|
|
if (wtx.RelayWalletTransaction(connman))
|
|
result.push_back(wtx.GetHash());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void CWallet::ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman)
|
|
{
|
|
// Do this infrequently and randomly to avoid giving away
|
|
// that these are our transactions.
|
|
if (GetTime() < nNextResend || !fBroadcastTransactions)
|
|
return;
|
|
bool fFirst = (nNextResend == 0);
|
|
nNextResend = GetTime() + GetRand(30 * 60);
|
|
if (fFirst)
|
|
return;
|
|
|
|
// Only do it if there's been a new block since last time
|
|
if (nBestBlockTime < nLastResend)
|
|
return;
|
|
nLastResend = GetTime();
|
|
|
|
// Rebroadcast unconfirmed txes older than 5 minutes before the last
|
|
// block was found:
|
|
std::vector<uint256> relayed = ResendWalletTransactionsBefore(nBestBlockTime-5*60, connman);
|
|
if (!relayed.empty())
|
|
WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n", __func__, relayed.size());
|
|
}
|
|
|
|
/** @} */ // end of mapWallet
|
|
|
|
|
|
|
|
|
|
/** @defgroup Actions
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
|
|
CAmount CWallet::GetBalance(const isminefilter& filter, const int min_depth) const
|
|
{
|
|
CAmount nTotal = 0;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const CWalletTx* pcoin = &entry.second;
|
|
if (pcoin->IsTrusted() && pcoin->GetDepthInMainChain() >= min_depth) {
|
|
nTotal += pcoin->GetAvailableCredit(true, filter);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nTotal;
|
|
}
|
|
|
|
CAmount CWallet::GetUnconfirmedBalance() const
|
|
{
|
|
CAmount nTotal = 0;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const CWalletTx* pcoin = &entry.second;
|
|
if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && pcoin->InMempool())
|
|
nTotal += pcoin->GetAvailableCredit();
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
CAmount CWallet::GetImmatureBalance() const
|
|
{
|
|
CAmount nTotal = 0;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const CWalletTx* pcoin = &entry.second;
|
|
nTotal += pcoin->GetImmatureCredit();
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
|
|
{
|
|
CAmount nTotal = 0;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const CWalletTx* pcoin = &entry.second;
|
|
if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && pcoin->InMempool())
|
|
nTotal += pcoin->GetAvailableCredit(true, ISMINE_WATCH_ONLY);
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
CAmount CWallet::GetImmatureWatchOnlyBalance() const
|
|
{
|
|
CAmount nTotal = 0;
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const CWalletTx* pcoin = &entry.second;
|
|
nTotal += pcoin->GetImmatureWatchOnlyCredit();
|
|
}
|
|
}
|
|
return nTotal;
|
|
}
|
|
|
|
// Calculate total balance in a different way from GetBalance. The biggest
|
|
// difference is that GetBalance sums up all unspent TxOuts paying to the
|
|
// wallet, while this sums up both spent and unspent TxOuts paying to the
|
|
// wallet, and then subtracts the values of TxIns spending from the wallet. This
|
|
// also has fewer restrictions on which unconfirmed transactions are considered
|
|
// trusted.
|
|
CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth, const std::string* account) const
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
CAmount balance = 0;
|
|
for (const auto& entry : mapWallet) {
|
|
const CWalletTx& wtx = entry.second;
|
|
const int depth = wtx.GetDepthInMainChain();
|
|
if (depth < 0 || !CheckFinalTx(*wtx.tx) || wtx.GetBlocksToMaturity() > 0) {
|
|
continue;
|
|
}
|
|
|
|
// Loop through tx outputs and add incoming payments. For outgoing txs,
|
|
// treat change outputs specially, as part of the amount debited.
|
|
CAmount debit = wtx.GetDebit(filter);
|
|
const bool outgoing = debit > 0;
|
|
for (const CTxOut& out : wtx.tx->vout) {
|
|
if (outgoing && IsChange(out)) {
|
|
debit -= out.nValue;
|
|
} else if (IsMine(out) & filter && depth >= minDepth && (!account || *account == GetLabelName(out.scriptPubKey))) {
|
|
balance += out.nValue;
|
|
}
|
|
}
|
|
|
|
// For outgoing txs, subtract amount debited.
|
|
if (outgoing && (!account || *account == wtx.strFromAccount)) {
|
|
balance -= debit;
|
|
}
|
|
}
|
|
|
|
if (account) {
|
|
balance += WalletBatch(*database).GetAccountCreditDebit(*account);
|
|
}
|
|
|
|
return balance;
|
|
}
|
|
|
|
CAmount CWallet::GetAvailableBalance(const CCoinControl* coinControl) const
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
CAmount balance = 0;
|
|
std::vector<COutput> vCoins;
|
|
AvailableCoins(vCoins, true, coinControl);
|
|
for (const COutput& out : vCoins) {
|
|
if (out.fSpendable) {
|
|
balance += out.tx->tx->vout[out.i].nValue;
|
|
}
|
|
}
|
|
return balance;
|
|
}
|
|
|
|
void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const CCoinControl *coinControl, const CAmount &nMinimumAmount, const CAmount &nMaximumAmount, const CAmount &nMinimumSumAmount, const uint64_t nMaximumCount, const int nMinDepth, const int nMaxDepth) const
|
|
{
|
|
AssertLockHeld(cs_main);
|
|
AssertLockHeld(cs_wallet);
|
|
|
|
vCoins.clear();
|
|
CAmount nTotal = 0;
|
|
|
|
for (const auto& entry : mapWallet)
|
|
{
|
|
const uint256& wtxid = entry.first;
|
|
const CWalletTx* pcoin = &entry.second;
|
|
|
|
if (!CheckFinalTx(*pcoin->tx))
|
|
continue;
|
|
|
|
if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
|
|
continue;
|
|
|
|
int nDepth = pcoin->GetDepthInMainChain();
|
|
if (nDepth < 0)
|
|
continue;
|
|
|
|
// We should not consider coins which aren't at least in our mempool
|
|
// It's possible for these to be conflicted via ancestors which we may never be able to detect
|
|
if (nDepth == 0 && !pcoin->InMempool())
|
|
continue;
|
|
|
|
bool safeTx = pcoin->IsTrusted();
|
|
|
|
// We should not consider coins from transactions that are replacing
|
|
// other transactions.
|
|
//
|
|
// Example: There is a transaction A which is replaced by bumpfee
|
|
// transaction B. In this case, we want to prevent creation of
|
|
// a transaction B' which spends an output of B.
|
|
//
|
|
// Reason: If transaction A were initially confirmed, transactions B
|
|
// and B' would no longer be valid, so the user would have to create
|
|
// a new transaction C to replace B'. However, in the case of a
|
|
// one-block reorg, transactions B' and C might BOTH be accepted,
|
|
// when the user only wanted one of them. Specifically, there could
|
|
// be a 1-block reorg away from the chain where transactions A and C
|
|
// were accepted to another chain where B, B', and C were all
|
|
// accepted.
|
|
if (nDepth == 0 && pcoin->mapValue.count("replaces_txid")) {
|
|
safeTx = false;
|
|
}
|
|
|
|
// Similarly, we should not consider coins from transactions that
|
|
// have been replaced. In the example above, we would want to prevent
|
|
// creation of a transaction A' spending an output of A, because if
|
|
// transaction B were initially confirmed, conflicting with A and
|
|
// A', we wouldn't want to the user to create a transaction D
|
|
// intending to replace A', but potentially resulting in a scenario
|
|
// where A, A', and D could all be accepted (instead of just B and
|
|
// D, or just A and A' like the user would want).
|
|
if (nDepth == 0 && pcoin->mapValue.count("replaced_by_txid")) {
|
|
safeTx = false;
|
|
}
|
|
|
|
if (fOnlySafe && !safeTx) {
|
|
continue;
|
|
}
|
|
|
|
if (nDepth < nMinDepth || nDepth > nMaxDepth)
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) {
|
|
if (pcoin->tx->vout[i].nValue < nMinimumAmount || pcoin->tx->vout[i].nValue > nMaximumAmount)
|
|
continue;
|
|
|
|
if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs && !coinControl->IsSelected(COutPoint(entry.first, i)))
|
|
continue;
|
|
|
|
if (IsLockedCoin(entry.first, i))
|
|
continue;
|
|
|
|
if (IsSpent(wtxid, i))
|
|
continue;
|
|
|
|
isminetype mine = IsMine(pcoin->tx->vout[i]);
|
|
|
|
if (mine == ISMINE_NO) {
|
|
continue;
|
|
}
|
|
|
|
bool solvable = IsSolvable(*this, pcoin->tx->vout[i].scriptPubKey);
|
|
bool spendable = ((mine & ISMINE_SPENDABLE) != ISMINE_NO) || (((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) && (coinControl && coinControl->fAllowWatchOnly && solvable));
|
|
|
|
vCoins.push_back(COutput(pcoin, i, nDepth, spendable, solvable, safeTx, (coinControl && coinControl->fAllowWatchOnly)));
|
|
|
|
// Checks the sum amount of all UTXO's.
|
|
if (nMinimumSumAmount != MAX_MONEY) {
|
|
nTotal += pcoin->tx->vout[i].nValue;
|
|
|
|
if (nTotal >= nMinimumSumAmount) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Checks the maximum number of UTXO's.
|
|
if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::map<CTxDestination, std::vector<COutput>> CWallet::ListCoins() const
|
|
{
|
|
// TODO: Add AssertLockHeld(cs_wallet) here.
|
|
//
|
|
// Because the return value from this function contains pointers to
|
|
// CWalletTx objects, callers to this function really should acquire the
|
|
// cs_wallet lock before calling it. However, the current caller doesn't
|
|
// acquire this lock yet. There was an attempt to add the missing lock in
|
|
// https://github.com/bitcoin/bitcoin/pull/10340, but that change has been
|
|
// postponed until after https://github.com/bitcoin/bitcoin/pull/10244 to
|
|
// avoid adding some extra complexity to the Qt code.
|
|
|
|
std::map<CTxDestination, std::vector<COutput>> result;
|
|
std::vector<COutput> availableCoins;
|
|
|
|
LOCK2(cs_main, cs_wallet);
|
|
AvailableCoins(availableCoins);
|
|
|
|
for (auto& coin : availableCoins) {
|
|
CTxDestination address;
|
|
if (coin.fSpendable &&
|
|
ExtractDestination(FindNonChangeParentOutput(*coin.tx->tx, coin.i).scriptPubKey, address)) {
|
|
result[address].emplace_back(std::move(coin));
|
|
}
|
|
}
|
|
|
|
std::vector<COutPoint> lockedCoins;
|
|
ListLockedCoins(lockedCoins);
|
|
for (const auto& output : lockedCoins) {
|
|
auto it = mapWallet.find(output.hash);
|
|
if (it != mapWallet.end()) {
|
|
int depth = it->second.GetDepthInMainChain();
|
|
if (depth >= 0 && output.n < it->second.tx->vout.size() &&
|
|
IsMine(it->second.tx->vout[output.n]) == ISMINE_SPENDABLE) {
|
|
CTxDestination address;
|
|
if (ExtractDestination(FindNonChangeParentOutput(*it->second.tx, output.n).scriptPubKey, address)) {
|
|
result[address].emplace_back(
|
|
&it->second, output.n, depth, true /* spendable */, true /* solvable */, false /* safe */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
const CTxOut& CWallet::FindNonChangeParentOutput(const CTransaction& tx, int output) const
|
|
{
|
|
const CTransaction* ptx = &tx;
|
|
int n = output;
|
|
while (IsChange(ptx->vout[n]) && ptx->vin.size() > 0) {
|
|
const COutPoint& prevout = ptx->vin[0].prevout;
|
|
auto it = mapWallet.find(prevout.hash);
|
|
if (it == mapWallet.end() || it->second.tx->vout.size() <= prevout.n ||
|
|
!IsMine(it->second.tx->vout[prevout.n])) {
|
|
break;
|
|
}
|
|
ptx = it->second.tx.get();
|
|
n = prevout.n;
|
|
}
|
|
return ptx->vout[n];
|
|
}
|
|
|
|
bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
|
|
std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) const
|
|
{
|
|
setCoinsRet.clear();
|
|
nValueRet = 0;
|
|
|
|
std::vector<OutputGroup> utxo_pool;
|
|
if (coin_selection_params.use_bnb) {
|
|
// Get long term estimate
|
|
FeeCalculation feeCalc;
|
|
CCoinControl temp;
|
|
temp.m_confirm_target = 1008;
|
|
CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp, ::mempool, ::feeEstimator, &feeCalc);
|
|
|
|
// Calculate cost of change
|
|
CAmount cost_of_change = GetDiscardRate(*this, ::feeEstimator).GetFee(coin_selection_params.change_spend_size) + coin_selection_params.effective_fee.GetFee(coin_selection_params.change_output_size);
|
|
|
|
// Filter by the min conf specs and add to utxo_pool and calculate effective value
|
|
for (OutputGroup& group : groups) {
|
|
if (!group.EligibleForSpending(eligibility_filter)) continue;
|
|
|
|
group.fee = 0;
|
|
group.long_term_fee = 0;
|
|
group.effective_value = 0;
|
|
for (auto it = group.m_outputs.begin(); it != group.m_outputs.end(); ) {
|
|
const CInputCoin& coin = *it;
|
|
CAmount effective_value = coin.txout.nValue - (coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes));
|
|
// Only include outputs that are positive effective value (i.e. not dust)
|
|
if (effective_value > 0) {
|
|
group.fee += coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
|
|
group.long_term_fee += coin.m_input_bytes < 0 ? 0 : long_term_feerate.GetFee(coin.m_input_bytes);
|
|
group.effective_value += effective_value;
|
|
++it;
|
|
} else {
|
|
it = group.Discard(coin);
|
|
}
|
|
}
|
|
if (group.effective_value > 0) utxo_pool.push_back(group);
|
|
}
|
|
// Calculate the fees for things that aren't inputs
|
|
CAmount not_input_fees = coin_selection_params.effective_fee.GetFee(coin_selection_params.tx_noinputs_size);
|
|
bnb_used = true;
|
|
return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change, setCoinsRet, nValueRet, not_input_fees);
|
|
} else {
|
|
// Filter by the min conf specs and add to utxo_pool
|
|
for (const OutputGroup& group : groups) {
|
|
if (!group.EligibleForSpending(eligibility_filter)) continue;
|
|
utxo_pool.push_back(group);
|
|
}
|
|
bnb_used = false;
|
|
return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
|
|
}
|
|
}
|
|
|
|
bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CCoinControl& coin_control, CoinSelectionParams& coin_selection_params, bool& bnb_used) const
|
|
{
|
|
std::vector<COutput> vCoins(vAvailableCoins);
|
|
|
|
// coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
|
|
if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs)
|
|
{
|
|
// We didn't use BnB here, so set it to false.
|
|
bnb_used = false;
|
|
|
|
for (const COutput& out : vCoins)
|
|
{
|
|
if (!out.fSpendable)
|
|
continue;
|
|
nValueRet += out.tx->tx->vout[out.i].nValue;
|
|
setCoinsRet.insert(out.GetInputCoin());
|
|
}
|
|
return (nValueRet >= nTargetValue);
|
|
}
|
|
|
|
// calculate value from preset inputs and store them
|
|
std::set<CInputCoin> setPresetCoins;
|
|
CAmount nValueFromPresetInputs = 0;
|
|
|
|
std::vector<COutPoint> vPresetInputs;
|
|
coin_control.ListSelected(vPresetInputs);
|
|
for (const COutPoint& outpoint : vPresetInputs)
|
|
{
|
|
// For now, don't use BnB if preset inputs are selected. TODO: Enable this later
|
|
bnb_used = false;
|
|
coin_selection_params.use_bnb = false;
|
|
|
|
std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(outpoint.hash);
|
|
if (it != mapWallet.end())
|
|
{
|
|
const CWalletTx* pcoin = &it->second;
|
|
// Clearly invalid input, fail
|
|
if (pcoin->tx->vout.size() <= outpoint.n)
|
|
return false;
|
|
// Just to calculate the marginal byte size
|
|
nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue;
|
|
setPresetCoins.insert(CInputCoin(pcoin->tx, outpoint.n));
|
|
} else
|
|
return false; // TODO: Allow non-wallet inputs
|
|
}
|
|
|
|
// remove preset inputs from vCoins
|
|
for (std::vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coin_control.HasSelected();)
|
|
{
|
|
if (setPresetCoins.count(it->GetInputCoin()))
|
|
it = vCoins.erase(it);
|
|
else
|
|
++it;
|
|
}
|
|
|
|
// form groups from remaining coins; note that preset coins will not
|
|
// automatically have their associated (same address) coins included
|
|
if (coin_control.m_avoid_partial_spends && vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
|
|
// Cases where we have 11+ outputs all pointing to the same destination may result in
|
|
// privacy leaks as they will potentially be deterministically sorted. We solve that by
|
|
// explicitly shuffling the outputs before processing
|
|
std::shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
|
|
}
|
|
std::vector<OutputGroup> groups = GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);
|
|
|
|
size_t max_ancestors = (size_t)std::max<int64_t>(1, gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT));
|
|
size_t max_descendants = (size_t)std::max<int64_t>(1, gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT));
|
|
bool fRejectLongChains = gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
|
|
|
|
bool res = nTargetValue <= nValueFromPresetInputs ||
|
|
SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||
|
|
SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||
|
|
(m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
|
|
(m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors/3), std::min((size_t)4, max_descendants/3)), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
|
|
(m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors/2, max_descendants/2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
|
|
(m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors-1, max_descendants-1), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
|
|
(m_spend_zero_conf_change && !fRejectLongChains && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
|
|
|
|
// because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
|
|
util::insert(setCoinsRet, setPresetCoins);
|
|
|
|
// add preset inputs to the total value selected
|
|
nValueRet += nValueFromPresetInputs;
|
|
|
|
return res;
|
|
}
|
|
|
|
bool CWallet::SignTransaction(CMutableTransaction &tx)
|
|
{
|
|
AssertLockHeld(cs_wallet); // mapWallet
|
|
|
|
// sign the new tx
|
|
int nIn = 0;
|
|
for (auto& input : tx.vin) {
|
|
std::map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(input.prevout.hash);
|
|
if(mi == mapWallet.end() || input.prevout.n >= mi->second.tx->vout.size()) {
|
|
return false;
|
|
}
|
|
const CScript& scriptPubKey = mi->second.tx->vout[input.prevout.n].scriptPubKey;
|
|
const CAmount& amount = mi->second.tx->vout[input.prevout.n].nValue;
|
|
SignatureData sigdata;
|
|
if (!ProduceSignature(*this, MutableTransactionSignatureCreator(&tx, nIn, amount, SIGHASH_ALL), scriptPubKey, sigdata)) {
|
|
return false;
|
|
}
|
|
UpdateInput(input, sigdata);
|
|
nIn++;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, int& nChangePosInOut, std::string& strFailReason, bool lockUnspents, const std::set<int>& setSubtractFeeFromOutputs, CCoinControl coinControl)
|
|
{
|
|
std::vector<CRecipient> vecSend;
|
|
|
|
// Turn the txout set into a CRecipient vector.
|
|
for (size_t idx = 0; idx < tx.vout.size(); idx++) {
|
|
const CTxOut& txOut = tx.vout[idx];
|
|
CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, setSubtractFeeFromOutputs.count(idx) == 1};
|
|
vecSend.push_back(recipient);
|
|
}
|
|
|
|
coinControl.fAllowOtherInputs = true;
|
|
|
|
for (const CTxIn& txin : tx.vin) {
|
|
coinControl.Select(txin.prevout);
|
|
}
|
|
|
|
// Acquire the locks to prevent races to the new locked unspents between the
|
|
// CreateTransaction call and LockCoin calls (when lockUnspents is true).
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
CReserveKey reservekey(this);
|
|
CTransactionRef tx_new;
|
|
if (!CreateTransaction(vecSend, tx_new, reservekey, nFeeRet, nChangePosInOut, strFailReason, coinControl, false)) {
|
|
return false;
|
|
}
|
|
|
|
if (nChangePosInOut != -1) {
|
|
tx.vout.insert(tx.vout.begin() + nChangePosInOut, tx_new->vout[nChangePosInOut]);
|
|
// We don't have the normal Create/Commit cycle, and don't want to risk
|
|
// reusing change, so just remove the key from the keypool here.
|
|
reservekey.KeepKey();
|
|
}
|
|
|
|
// Copy output sizes from new transaction; they may have had the fee
|
|
// subtracted from them.
|
|
for (unsigned int idx = 0; idx < tx.vout.size(); idx++) {
|
|
tx.vout[idx].nValue = tx_new->vout[idx].nValue;
|
|
}
|
|
|
|
// Add new txins while keeping original txin scriptSig/order.
|
|
for (const CTxIn& txin : tx_new->vin) {
|
|
if (!coinControl.IsSelected(txin.prevout)) {
|
|
tx.vin.push_back(txin);
|
|
|
|
if (lockUnspents) {
|
|
LockCoin(txin.prevout);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
OutputType CWallet::TransactionChangeType(OutputType change_type, const std::vector<CRecipient>& vecSend)
|
|
{
|
|
// If -changetype is specified, always use that change type.
|
|
if (change_type != OutputType::CHANGE_AUTO) {
|
|
return change_type;
|
|
}
|
|
|
|
// if m_default_address_type is legacy, use legacy address as change (even
|
|
// if some of the outputs are P2WPKH or P2WSH).
|
|
if (m_default_address_type == OutputType::LEGACY) {
|
|
return OutputType::LEGACY;
|
|
}
|
|
|
|
// if any destination is P2WPKH or P2WSH, use P2WPKH for the change
|
|
// output.
|
|
for (const auto& recipient : vecSend) {
|
|
// Check if any destination contains a witness program:
|
|
int witnessversion = 0;
|
|
std::vector<unsigned char> witnessprogram;
|
|
if (recipient.scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {
|
|
return OutputType::BECH32;
|
|
}
|
|
}
|
|
|
|
// else use m_default_address_type for change
|
|
return m_default_address_type;
|
|
}
|
|
|
|
bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransactionRef& tx, CReserveKey& reservekey, CAmount& nFeeRet,
|
|
int& nChangePosInOut, std::string& strFailReason, const CCoinControl& coin_control, bool sign)
|
|
{
|
|
CAmount nValue = 0;
|
|
int nChangePosRequest = nChangePosInOut;
|
|
unsigned int nSubtractFeeFromAmount = 0;
|
|
for (const auto& recipient : vecSend)
|
|
{
|
|
if (nValue < 0 || recipient.nAmount < 0)
|
|
{
|
|
strFailReason = _("Transaction amounts must not be negative");
|
|
return false;
|
|
}
|
|
nValue += recipient.nAmount;
|
|
|
|
if (recipient.fSubtractFeeFromAmount)
|
|
nSubtractFeeFromAmount++;
|
|
}
|
|
if (vecSend.empty())
|
|
{
|
|
strFailReason = _("Transaction must have at least one recipient");
|
|
return false;
|
|
}
|
|
|
|
CMutableTransaction txNew;
|
|
|
|
// Discourage fee sniping.
|
|
//
|
|
// For a large miner the value of the transactions in the best block and
|
|
// the mempool can exceed the cost of deliberately attempting to mine two
|
|
// blocks to orphan the current best block. By setting nLockTime such that
|
|
// only the next block can include the transaction, we discourage this
|
|
// practice as the height restricted and limited blocksize gives miners
|
|
// considering fee sniping fewer options for pulling off this attack.
|
|
//
|
|
// A simple way to think about this is from the wallet's point of view we
|
|
// always want the blockchain to move forward. By setting nLockTime this
|
|
// way we're basically making the statement that we only want this
|
|
// transaction to appear in the next block; we don't want to potentially
|
|
// encourage reorgs by allowing transactions to appear at lower heights
|
|
// than the next block in forks of the best chain.
|
|
//
|
|
// Of course, the subsidy is high enough, and transaction volume low
|
|
// enough, that fee sniping isn't a problem yet, but by implementing a fix
|
|
// now we ensure code won't be written that makes assumptions about
|
|
// nLockTime that preclude a fix later.
|
|
txNew.nLockTime = chainActive.Height();
|
|
|
|
// Secondly occasionally randomly pick a nLockTime even further back, so
|
|
// that transactions that are delayed after signing for whatever reason,
|
|
// e.g. high-latency mix networks and some CoinJoin implementations, have
|
|
// better privacy.
|
|
if (GetRandInt(10) == 0)
|
|
txNew.nLockTime = std::max(0, (int)txNew.nLockTime - GetRandInt(100));
|
|
|
|
assert(txNew.nLockTime <= (unsigned int)chainActive.Height());
|
|
assert(txNew.nLockTime < LOCKTIME_THRESHOLD);
|
|
FeeCalculation feeCalc;
|
|
CAmount nFeeNeeded;
|
|
int nBytes;
|
|
{
|
|
std::set<CInputCoin> setCoins;
|
|
LOCK2(cs_main, cs_wallet);
|
|
{
|
|
std::vector<COutput> vAvailableCoins;
|
|
AvailableCoins(vAvailableCoins, true, &coin_control);
|
|
CoinSelectionParams coin_selection_params; // Parameters for coin selection, init with dummy
|
|
|
|
// Create change script that will be used if we need change
|
|
// TODO: pass in scriptChange instead of reservekey so
|
|
// change transaction isn't always pay-to-bitcoin-address
|
|
CScript scriptChange;
|
|
|
|
// coin control: send change to custom address
|
|
if (!boost::get<CNoDestination>(&coin_control.destChange)) {
|
|
scriptChange = GetScriptForDestination(coin_control.destChange);
|
|
} else { // no coin control: send change to newly generated address
|
|
// 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
|
|
if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
strFailReason = _("Can't generate a change-address key. Private keys are disabled for this wallet.");
|
|
return false;
|
|
}
|
|
CPubKey vchPubKey;
|
|
bool ret;
|
|
ret = reservekey.GetReservedKey(vchPubKey, true);
|
|
if (!ret)
|
|
{
|
|
strFailReason = _("Keypool ran out, please call keypoolrefill first");
|
|
return false;
|
|
}
|
|
|
|
const OutputType change_type = TransactionChangeType(coin_control.m_change_type ? *coin_control.m_change_type : m_default_change_type, vecSend);
|
|
|
|
LearnRelatedScripts(vchPubKey, change_type);
|
|
scriptChange = GetScriptForDestination(GetDestinationForKey(vchPubKey, change_type));
|
|
}
|
|
CTxOut change_prototype_txout(0, scriptChange);
|
|
coin_selection_params.change_output_size = GetSerializeSize(change_prototype_txout, SER_DISK, 0);
|
|
|
|
CFeeRate discard_rate = GetDiscardRate(*this, ::feeEstimator);
|
|
|
|
// Get the fee rate to use effective values in coin selection
|
|
CFeeRate nFeeRateNeeded = GetMinimumFeeRate(*this, coin_control, ::mempool, ::feeEstimator, &feeCalc);
|
|
|
|
nFeeRet = 0;
|
|
bool pick_new_inputs = true;
|
|
CAmount nValueIn = 0;
|
|
|
|
// BnB selector is the only selector used when this is true.
|
|
// That should only happen on the first pass through the loop.
|
|
coin_selection_params.use_bnb = nSubtractFeeFromAmount == 0; // If we are doing subtract fee from recipient, then don't use BnB
|
|
// Start with no fee and loop until there is enough fee
|
|
while (true)
|
|
{
|
|
nChangePosInOut = nChangePosRequest;
|
|
txNew.vin.clear();
|
|
txNew.vout.clear();
|
|
bool fFirst = true;
|
|
|
|
CAmount nValueToSelect = nValue;
|
|
if (nSubtractFeeFromAmount == 0)
|
|
nValueToSelect += nFeeRet;
|
|
|
|
// vouts to the payees
|
|
coin_selection_params.tx_noinputs_size = 11; // Static vsize overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1 input count, 1 output count, 1 witness overhead (dummy, flag, stack size)
|
|
for (const auto& recipient : vecSend)
|
|
{
|
|
CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
|
|
|
|
if (recipient.fSubtractFeeFromAmount)
|
|
{
|
|
assert(nSubtractFeeFromAmount != 0);
|
|
txout.nValue -= nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient
|
|
|
|
if (fFirst) // first receiver pays the remainder not divisible by output count
|
|
{
|
|
fFirst = false;
|
|
txout.nValue -= nFeeRet % nSubtractFeeFromAmount;
|
|
}
|
|
}
|
|
// Include the fee cost for outputs. Note this is only used for BnB right now
|
|
coin_selection_params.tx_noinputs_size += ::GetSerializeSize(txout, SER_NETWORK, PROTOCOL_VERSION);
|
|
|
|
if (IsDust(txout, ::dustRelayFee))
|
|
{
|
|
if (recipient.fSubtractFeeFromAmount && nFeeRet > 0)
|
|
{
|
|
if (txout.nValue < 0)
|
|
strFailReason = _("The transaction amount is too small to pay the fee");
|
|
else
|
|
strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
|
|
}
|
|
else
|
|
strFailReason = _("Transaction amount too small");
|
|
return false;
|
|
}
|
|
txNew.vout.push_back(txout);
|
|
}
|
|
|
|
// Choose coins to use
|
|
bool bnb_used;
|
|
if (pick_new_inputs) {
|
|
nValueIn = 0;
|
|
setCoins.clear();
|
|
coin_selection_params.change_spend_size = CalculateMaximumSignedInputSize(change_prototype_txout, this);
|
|
coin_selection_params.effective_fee = nFeeRateNeeded;
|
|
if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, nValueIn, coin_control, coin_selection_params, bnb_used))
|
|
{
|
|
// If BnB was used, it was the first pass. No longer the first pass and continue loop with knapsack.
|
|
if (bnb_used) {
|
|
coin_selection_params.use_bnb = false;
|
|
continue;
|
|
}
|
|
else {
|
|
strFailReason = _("Insufficient funds");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
const CAmount nChange = nValueIn - nValueToSelect;
|
|
if (nChange > 0)
|
|
{
|
|
// Fill a vout to ourself
|
|
CTxOut newTxOut(nChange, scriptChange);
|
|
|
|
// Never create dust outputs; if we would, just
|
|
// add the dust to the fee.
|
|
// The nChange when BnB is used is always going to go to fees.
|
|
if (IsDust(newTxOut, discard_rate) || bnb_used)
|
|
{
|
|
nChangePosInOut = -1;
|
|
nFeeRet += nChange;
|
|
}
|
|
else
|
|
{
|
|
if (nChangePosInOut == -1)
|
|
{
|
|
// Insert change txn at random position:
|
|
nChangePosInOut = GetRandInt(txNew.vout.size()+1);
|
|
}
|
|
else if ((unsigned int)nChangePosInOut > txNew.vout.size())
|
|
{
|
|
strFailReason = _("Change index out of range");
|
|
return false;
|
|
}
|
|
|
|
std::vector<CTxOut>::iterator position = txNew.vout.begin()+nChangePosInOut;
|
|
txNew.vout.insert(position, newTxOut);
|
|
}
|
|
} else {
|
|
nChangePosInOut = -1;
|
|
}
|
|
|
|
// Dummy fill vin for maximum size estimation
|
|
//
|
|
for (const auto& coin : setCoins) {
|
|
txNew.vin.push_back(CTxIn(coin.outpoint,CScript()));
|
|
}
|
|
|
|
nBytes = CalculateMaximumSignedTxSize(txNew, this, coin_control.fAllowWatchOnly);
|
|
if (nBytes < 0) {
|
|
strFailReason = _("Signing transaction failed");
|
|
return false;
|
|
}
|
|
|
|
nFeeNeeded = GetMinimumFee(*this, nBytes, coin_control, ::mempool, ::feeEstimator, &feeCalc);
|
|
if (feeCalc.reason == FeeReason::FALLBACK && !m_allow_fallback_fee) {
|
|
// eventually allow a fallback fee
|
|
strFailReason = _("Fee estimation failed. Fallbackfee is disabled. Wait a few blocks or enable -fallbackfee.");
|
|
return false;
|
|
}
|
|
|
|
// If we made it here and we aren't even able to meet the relay fee on the next pass, give up
|
|
// because we must be at the maximum allowed fee.
|
|
if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes))
|
|
{
|
|
strFailReason = _("Transaction too large for fee policy");
|
|
return false;
|
|
}
|
|
|
|
if (nFeeRet >= nFeeNeeded) {
|
|
// Reduce fee to only the needed amount if possible. This
|
|
// prevents potential overpayment in fees if the coins
|
|
// selected to meet nFeeNeeded result in a transaction that
|
|
// requires less fee than the prior iteration.
|
|
|
|
// If we have no change and a big enough excess fee, then
|
|
// try to construct transaction again only without picking
|
|
// new inputs. We now know we only need the smaller fee
|
|
// (because of reduced tx size) and so we should add a
|
|
// change output. Only try this once.
|
|
if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 && pick_new_inputs) {
|
|
unsigned int tx_size_with_change = nBytes + coin_selection_params.change_output_size + 2; // Add 2 as a buffer in case increasing # of outputs changes compact size
|
|
CAmount fee_needed_with_change = GetMinimumFee(*this, tx_size_with_change, coin_control, ::mempool, ::feeEstimator, nullptr);
|
|
CAmount minimum_value_for_change = GetDustThreshold(change_prototype_txout, discard_rate);
|
|
if (nFeeRet >= fee_needed_with_change + minimum_value_for_change) {
|
|
pick_new_inputs = false;
|
|
nFeeRet = fee_needed_with_change;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// If we have change output already, just increase it
|
|
if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
|
|
CAmount extraFeePaid = nFeeRet - nFeeNeeded;
|
|
std::vector<CTxOut>::iterator change_position = txNew.vout.begin()+nChangePosInOut;
|
|
change_position->nValue += extraFeePaid;
|
|
nFeeRet -= extraFeePaid;
|
|
}
|
|
break; // Done, enough fee included.
|
|
}
|
|
else if (!pick_new_inputs) {
|
|
// This shouldn't happen, we should have had enough excess
|
|
// fee to pay for the new output and still meet nFeeNeeded
|
|
// Or we should have just subtracted fee from recipients and
|
|
// nFeeNeeded should not have changed
|
|
strFailReason = _("Transaction fee and change calculation failed");
|
|
return false;
|
|
}
|
|
|
|
// Try to reduce change to include necessary fee
|
|
if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
|
|
CAmount additionalFeeNeeded = nFeeNeeded - nFeeRet;
|
|
std::vector<CTxOut>::iterator change_position = txNew.vout.begin()+nChangePosInOut;
|
|
// Only reduce change if remaining amount is still a large enough output.
|
|
if (change_position->nValue >= MIN_FINAL_CHANGE + additionalFeeNeeded) {
|
|
change_position->nValue -= additionalFeeNeeded;
|
|
nFeeRet += additionalFeeNeeded;
|
|
break; // Done, able to increase fee from change
|
|
}
|
|
}
|
|
|
|
// If subtracting fee from recipients, we now know what fee we
|
|
// need to subtract, we have no reason to reselect inputs
|
|
if (nSubtractFeeFromAmount > 0) {
|
|
pick_new_inputs = false;
|
|
}
|
|
|
|
// Include more fee and try again.
|
|
nFeeRet = nFeeNeeded;
|
|
coin_selection_params.use_bnb = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (nChangePosInOut == -1) reservekey.ReturnKey(); // Return any reserved key if we don't have change
|
|
|
|
// Shuffle selected coins and fill in final vin
|
|
txNew.vin.clear();
|
|
std::vector<CInputCoin> selected_coins(setCoins.begin(), setCoins.end());
|
|
std::shuffle(selected_coins.begin(), selected_coins.end(), FastRandomContext());
|
|
|
|
// Note how the sequence number is set to non-maxint so that
|
|
// the nLockTime set above actually works.
|
|
//
|
|
// BIP125 defines opt-in RBF as any nSequence < maxint-1, so
|
|
// we use the highest possible value in that range (maxint-2)
|
|
// to avoid conflicting with other possible uses of nSequence,
|
|
// and in the spirit of "smallest possible change from prior
|
|
// behavior."
|
|
const uint32_t nSequence = coin_control.m_signal_bip125_rbf.get_value_or(m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : (CTxIn::SEQUENCE_FINAL - 1);
|
|
for (const auto& coin : selected_coins) {
|
|
txNew.vin.push_back(CTxIn(coin.outpoint, CScript(), nSequence));
|
|
}
|
|
|
|
if (sign)
|
|
{
|
|
int nIn = 0;
|
|
for (const auto& coin : selected_coins)
|
|
{
|
|
const CScript& scriptPubKey = coin.txout.scriptPubKey;
|
|
SignatureData sigdata;
|
|
|
|
if (!ProduceSignature(*this, MutableTransactionSignatureCreator(&txNew, nIn, coin.txout.nValue, SIGHASH_ALL), scriptPubKey, sigdata))
|
|
{
|
|
strFailReason = _("Signing transaction failed");
|
|
return false;
|
|
} else {
|
|
UpdateInput(txNew.vin.at(nIn), sigdata);
|
|
}
|
|
|
|
nIn++;
|
|
}
|
|
}
|
|
|
|
// Return the constructed transaction data.
|
|
tx = MakeTransactionRef(std::move(txNew));
|
|
|
|
// Limit size
|
|
if (GetTransactionWeight(*tx) > MAX_STANDARD_TX_WEIGHT)
|
|
{
|
|
strFailReason = _("Transaction too large");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
|
|
// Lastly, ensure this tx will pass the mempool's chain limits
|
|
LockPoints lp;
|
|
CTxMemPoolEntry entry(tx, 0, 0, 0, false, 0, lp);
|
|
CTxMemPool::setEntries setAncestors;
|
|
size_t nLimitAncestors = gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);
|
|
size_t nLimitAncestorSize = gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT)*1000;
|
|
size_t nLimitDescendants = gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT);
|
|
size_t nLimitDescendantSize = gArgs.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT)*1000;
|
|
std::string errString;
|
|
LOCK(::mempool.cs);
|
|
if (!::mempool.CalculateMemPoolAncestors(entry, setAncestors, nLimitAncestors, nLimitAncestorSize, nLimitDescendants, nLimitDescendantSize, errString)) {
|
|
strFailReason = _("Transaction has too long of a mempool chain");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u Needed:%d Tgt:%d (requested %d) Reason:\"%s\" Decay %.5f: Estimation: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out) Fail: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out)\n",
|
|
nFeeRet, nBytes, nFeeNeeded, feeCalc.returnedTarget, feeCalc.desiredTarget, StringForFeeReason(feeCalc.reason), feeCalc.est.decay,
|
|
feeCalc.est.pass.start, feeCalc.est.pass.end,
|
|
100 * feeCalc.est.pass.withinTarget / (feeCalc.est.pass.totalConfirmed + feeCalc.est.pass.inMempool + feeCalc.est.pass.leftMempool),
|
|
feeCalc.est.pass.withinTarget, feeCalc.est.pass.totalConfirmed, feeCalc.est.pass.inMempool, feeCalc.est.pass.leftMempool,
|
|
feeCalc.est.fail.start, feeCalc.est.fail.end,
|
|
100 * feeCalc.est.fail.withinTarget / (feeCalc.est.fail.totalConfirmed + feeCalc.est.fail.inMempool + feeCalc.est.fail.leftMempool),
|
|
feeCalc.est.fail.withinTarget, feeCalc.est.fail.totalConfirmed, feeCalc.est.fail.inMempool, feeCalc.est.fail.leftMempool);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Call after CreateTransaction unless you want to abort
|
|
*/
|
|
bool CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, std::string fromAccount, CReserveKey& reservekey, CConnman* connman, CValidationState& state)
|
|
{
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
CWalletTx wtxNew(this, std::move(tx));
|
|
wtxNew.mapValue = std::move(mapValue);
|
|
wtxNew.vOrderForm = std::move(orderForm);
|
|
wtxNew.strFromAccount = std::move(fromAccount);
|
|
wtxNew.fTimeReceivedIsTxTime = true;
|
|
wtxNew.fFromMe = true;
|
|
|
|
WalletLogPrintf("CommitTransaction:\n%s", wtxNew.tx->ToString()); /* Continued */
|
|
{
|
|
// 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);
|
|
|
|
// Notify that old coins are spent
|
|
for (const CTxIn& txin : wtxNew.tx->vin)
|
|
{
|
|
CWalletTx &coin = mapWallet.at(txin.prevout.hash);
|
|
coin.BindWallet(this);
|
|
NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED);
|
|
}
|
|
}
|
|
|
|
// Get the inserted-CWalletTx from mapWallet so that the
|
|
// fInMempool flag is cached properly
|
|
CWalletTx& wtx = mapWallet.at(wtxNew.GetHash());
|
|
|
|
if (fBroadcastTransactions)
|
|
{
|
|
// Broadcast
|
|
if (!wtx.AcceptToMemoryPool(maxTxFee, state)) {
|
|
WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s\n", FormatStateMessage(state));
|
|
// TODO: if we expect the failure to be long term or permanent, instead delete wtx from the wallet and return failure.
|
|
} else {
|
|
wtx.RelayWalletTransaction(connman);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CWallet::ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& entries) {
|
|
WalletBatch batch(*database);
|
|
return batch.ListAccountCreditDebit(strAccount, entries);
|
|
}
|
|
|
|
bool CWallet::AddAccountingEntry(const CAccountingEntry& acentry)
|
|
{
|
|
WalletBatch batch(*database);
|
|
|
|
return AddAccountingEntry(acentry, &batch);
|
|
}
|
|
|
|
bool CWallet::AddAccountingEntry(const CAccountingEntry& acentry, WalletBatch *batch)
|
|
{
|
|
if (!batch->WriteAccountingEntry(++nAccountingEntryNumber, acentry)) {
|
|
return false;
|
|
}
|
|
|
|
laccentries.push_back(acentry);
|
|
CAccountingEntry & entry = laccentries.back();
|
|
wtxOrdered.insert(std::make_pair(entry.nOrderPos, TxPair(nullptr, &entry)));
|
|
|
|
return true;
|
|
}
|
|
|
|
DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
|
|
{
|
|
LOCK2(cs_main, cs_wallet);
|
|
|
|
fFirstRunRet = false;
|
|
DBErrors nLoadWalletRet = WalletBatch(*database,"cr+").LoadWallet(this);
|
|
if (nLoadWalletRet == DBErrors::NEED_REWRITE)
|
|
{
|
|
if (database->Rewrite("\x04pool"))
|
|
{
|
|
setInternalKeyPool.clear();
|
|
setExternalKeyPool.clear();
|
|
m_pool_key_to_index.clear();
|
|
// Note: can't top-up keypool here, because wallet is locked.
|
|
// User will be prompted to unlock wallet the next operation
|
|
// that requires a new key.
|
|
}
|
|
}
|
|
|
|
{
|
|
LOCK(cs_KeyStore);
|
|
// This wallet is in its first run if all of these are empty
|
|
fFirstRunRet = mapKeys.empty() && mapCryptedKeys.empty() && mapWatchKeys.empty() && setWatchOnly.empty() && mapScripts.empty() && !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
|
|
}
|
|
|
|
if (nLoadWalletRet != DBErrors::LOAD_OK)
|
|
return nLoadWalletRet;
|
|
|
|
return DBErrors::LOAD_OK;
|
|
}
|
|
|
|
DBErrors CWallet::ZapSelectTx(std::vector<uint256>& vHashIn, std::vector<uint256>& vHashOut)
|
|
{
|
|
AssertLockHeld(cs_wallet); // mapWallet
|
|
DBErrors nZapSelectTxRet = WalletBatch(*database,"cr+").ZapSelectTx(vHashIn, vHashOut);
|
|
for (uint256 hash : vHashOut) {
|
|
const auto& it = mapWallet.find(hash);
|
|
wtxOrdered.erase(it->second.m_it_wtxOrdered);
|
|
mapWallet.erase(it);
|
|
}
|
|
|
|
if (nZapSelectTxRet == DBErrors::NEED_REWRITE)
|
|
{
|
|
if (database->Rewrite("\x04pool"))
|
|
{
|
|
setInternalKeyPool.clear();
|
|
setExternalKeyPool.clear();
|
|
m_pool_key_to_index.clear();
|
|
// Note: can't top-up keypool here, because wallet is locked.
|
|
// User will be prompted to unlock wallet the next operation
|
|
// that requires a new key.
|
|
}
|
|
}
|
|
|
|
if (nZapSelectTxRet != DBErrors::LOAD_OK)
|
|
return nZapSelectTxRet;
|
|
|
|
MarkDirty();
|
|
|
|
return DBErrors::LOAD_OK;
|
|
|
|
}
|
|
|
|
DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx>& vWtx)
|
|
{
|
|
DBErrors nZapWalletTxRet = WalletBatch(*database,"cr+").ZapWalletTx(vWtx);
|
|
if (nZapWalletTxRet == DBErrors::NEED_REWRITE)
|
|
{
|
|
if (database->Rewrite("\x04pool"))
|
|
{
|
|
LOCK(cs_wallet);
|
|
setInternalKeyPool.clear();
|
|
setExternalKeyPool.clear();
|
|
m_pool_key_to_index.clear();
|
|
// Note: can't top-up keypool here, because wallet is locked.
|
|
// User will be prompted to unlock wallet the next operation
|
|
// that requires a new key.
|
|
}
|
|
}
|
|
|
|
if (nZapWalletTxRet != DBErrors::LOAD_OK)
|
|
return nZapWalletTxRet;
|
|
|
|
return DBErrors::LOAD_OK;
|
|
}
|
|
|
|
|
|
bool CWallet::SetAddressBook(const CTxDestination& address, const std::string& strName, const std::string& strPurpose)
|
|
{
|
|
bool fUpdated = false;
|
|
{
|
|
LOCK(cs_wallet); // mapAddressBook
|
|
std::map<CTxDestination, CAddressBookData>::iterator mi = mapAddressBook.find(address);
|
|
fUpdated = mi != mapAddressBook.end();
|
|
mapAddressBook[address].name = strName;
|
|
if (!strPurpose.empty()) /* update purpose only if requested */
|
|
mapAddressBook[address].purpose = strPurpose;
|
|
}
|
|
NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != ISMINE_NO,
|
|
strPurpose, (fUpdated ? CT_UPDATED : CT_NEW) );
|
|
if (!strPurpose.empty() && !WalletBatch(*database).WritePurpose(EncodeDestination(address), strPurpose))
|
|
return false;
|
|
return WalletBatch(*database).WriteName(EncodeDestination(address), strName);
|
|
}
|
|
|
|
bool CWallet::DelAddressBook(const CTxDestination& address)
|
|
{
|
|
{
|
|
LOCK(cs_wallet); // mapAddressBook
|
|
|
|
// Delete destdata tuples associated with address
|
|
std::string strAddress = EncodeDestination(address);
|
|
for (const std::pair<const std::string, std::string> &item : mapAddressBook[address].destdata)
|
|
{
|
|
WalletBatch(*database).EraseDestData(strAddress, item.first);
|
|
}
|
|
mapAddressBook.erase(address);
|
|
}
|
|
|
|
NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != ISMINE_NO, "", CT_DELETED);
|
|
|
|
WalletBatch(*database).ErasePurpose(EncodeDestination(address));
|
|
return WalletBatch(*database).EraseName(EncodeDestination(address));
|
|
}
|
|
|
|
const std::string& CWallet::GetLabelName(const CScript& scriptPubKey) const
|
|
{
|
|
CTxDestination address;
|
|
if (ExtractDestination(scriptPubKey, address) && !scriptPubKey.IsUnspendable()) {
|
|
auto mi = mapAddressBook.find(address);
|
|
if (mi != mapAddressBook.end()) {
|
|
return mi->second.name;
|
|
}
|
|
}
|
|
// A scriptPubKey that doesn't have an entry in the address book is
|
|
// associated with the default label ("").
|
|
const static std::string DEFAULT_LABEL_NAME;
|
|
return DEFAULT_LABEL_NAME;
|
|
}
|
|
|
|
/**
|
|
* Mark old keypool keys as used,
|
|
* and generate all new keys
|
|
*/
|
|
bool CWallet::NewKeyPool()
|
|
{
|
|
if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
return false;
|
|
}
|
|
{
|
|
LOCK(cs_wallet);
|
|
WalletBatch batch(*database);
|
|
|
|
for (int64_t nIndex : setInternalKeyPool) {
|
|
batch.ErasePool(nIndex);
|
|
}
|
|
setInternalKeyPool.clear();
|
|
|
|
for (int64_t nIndex : setExternalKeyPool) {
|
|
batch.ErasePool(nIndex);
|
|
}
|
|
setExternalKeyPool.clear();
|
|
|
|
for (int64_t nIndex : set_pre_split_keypool) {
|
|
batch.ErasePool(nIndex);
|
|
}
|
|
set_pre_split_keypool.clear();
|
|
|
|
m_pool_key_to_index.clear();
|
|
|
|
if (!TopUpKeyPool()) {
|
|
return false;
|
|
}
|
|
WalletLogPrintf("CWallet::NewKeyPool rewrote keypool\n");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
size_t CWallet::KeypoolCountExternalKeys()
|
|
{
|
|
AssertLockHeld(cs_wallet); // setExternalKeyPool
|
|
return setExternalKeyPool.size() + set_pre_split_keypool.size();
|
|
}
|
|
|
|
void CWallet::LoadKeyPool(int64_t nIndex, const CKeyPool &keypool)
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
if (keypool.m_pre_split) {
|
|
set_pre_split_keypool.insert(nIndex);
|
|
} else if (keypool.fInternal) {
|
|
setInternalKeyPool.insert(nIndex);
|
|
} else {
|
|
setExternalKeyPool.insert(nIndex);
|
|
}
|
|
m_max_keypool_index = std::max(m_max_keypool_index, nIndex);
|
|
m_pool_key_to_index[keypool.vchPubKey.GetID()] = nIndex;
|
|
|
|
// If no metadata exists yet, create a default with the pool key's
|
|
// creation time. Note that this may be overwritten by actually
|
|
// stored metadata for that key later, which is fine.
|
|
CKeyID keyid = keypool.vchPubKey.GetID();
|
|
if (mapKeyMetadata.count(keyid) == 0)
|
|
mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime);
|
|
}
|
|
|
|
bool CWallet::TopUpKeyPool(unsigned int kpSize)
|
|
{
|
|
if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
return false;
|
|
}
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
if (IsLocked())
|
|
return false;
|
|
|
|
// Top up key pool
|
|
unsigned int nTargetSize;
|
|
if (kpSize > 0)
|
|
nTargetSize = kpSize;
|
|
else
|
|
nTargetSize = std::max(gArgs.GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t) 0);
|
|
|
|
// count amount of available keys (internal, external)
|
|
// make sure the keypool of external and internal keys fits the user selected target (-keypool)
|
|
int64_t missingExternal = std::max(std::max((int64_t) nTargetSize, (int64_t) 1) - (int64_t)setExternalKeyPool.size(), (int64_t) 0);
|
|
int64_t missingInternal = std::max(std::max((int64_t) nTargetSize, (int64_t) 1) - (int64_t)setInternalKeyPool.size(), (int64_t) 0);
|
|
|
|
if (!IsHDEnabled() || !CanSupportFeature(FEATURE_HD_SPLIT))
|
|
{
|
|
// don't create extra internal keys
|
|
missingInternal = 0;
|
|
}
|
|
bool internal = false;
|
|
WalletBatch batch(*database);
|
|
for (int64_t i = missingInternal + missingExternal; i--;)
|
|
{
|
|
if (i < missingInternal) {
|
|
internal = true;
|
|
}
|
|
|
|
assert(m_max_keypool_index < std::numeric_limits<int64_t>::max()); // How in the hell did you use so many keys?
|
|
int64_t index = ++m_max_keypool_index;
|
|
|
|
CPubKey pubkey(GenerateNewKey(batch, internal));
|
|
if (!batch.WritePool(index, CKeyPool(pubkey, internal))) {
|
|
throw std::runtime_error(std::string(__func__) + ": writing generated key failed");
|
|
}
|
|
|
|
if (internal) {
|
|
setInternalKeyPool.insert(index);
|
|
} else {
|
|
setExternalKeyPool.insert(index);
|
|
}
|
|
m_pool_key_to_index[pubkey.GetID()] = index;
|
|
}
|
|
if (missingInternal + missingExternal > 0) {
|
|
WalletLogPrintf("keypool added %d keys (%d internal), size=%u (%u internal)\n", missingInternal + missingExternal, missingInternal, setInternalKeyPool.size() + setExternalKeyPool.size() + set_pre_split_keypool.size(), setInternalKeyPool.size());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CWallet::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool, bool fRequestedInternal)
|
|
{
|
|
nIndex = -1;
|
|
keypool.vchPubKey = CPubKey();
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
if (!IsLocked())
|
|
TopUpKeyPool();
|
|
|
|
bool fReturningInternal = IsHDEnabled() && CanSupportFeature(FEATURE_HD_SPLIT) && fRequestedInternal;
|
|
bool use_split_keypool = set_pre_split_keypool.empty();
|
|
std::set<int64_t>& setKeyPool = use_split_keypool ? (fReturningInternal ? setInternalKeyPool : setExternalKeyPool) : set_pre_split_keypool;
|
|
|
|
// Get the oldest key
|
|
if (setKeyPool.empty()) {
|
|
return false;
|
|
}
|
|
|
|
WalletBatch batch(*database);
|
|
|
|
auto it = setKeyPool.begin();
|
|
nIndex = *it;
|
|
setKeyPool.erase(it);
|
|
if (!batch.ReadPool(nIndex, keypool)) {
|
|
throw std::runtime_error(std::string(__func__) + ": read failed");
|
|
}
|
|
if (!HaveKey(keypool.vchPubKey.GetID())) {
|
|
throw std::runtime_error(std::string(__func__) + ": unknown key in key pool");
|
|
}
|
|
// If the key was pre-split keypool, we don't care about what type it is
|
|
if (use_split_keypool && keypool.fInternal != fReturningInternal) {
|
|
throw std::runtime_error(std::string(__func__) + ": keypool entry misclassified");
|
|
}
|
|
if (!keypool.vchPubKey.IsValid()) {
|
|
throw std::runtime_error(std::string(__func__) + ": keypool entry invalid");
|
|
}
|
|
|
|
m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
|
|
WalletLogPrintf("keypool reserve %d\n", nIndex);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CWallet::KeepKey(int64_t nIndex)
|
|
{
|
|
// Remove from key pool
|
|
WalletBatch batch(*database);
|
|
batch.ErasePool(nIndex);
|
|
WalletLogPrintf("keypool keep %d\n", nIndex);
|
|
}
|
|
|
|
void CWallet::ReturnKey(int64_t nIndex, bool fInternal, const CPubKey& pubkey)
|
|
{
|
|
// Return to key pool
|
|
{
|
|
LOCK(cs_wallet);
|
|
if (fInternal) {
|
|
setInternalKeyPool.insert(nIndex);
|
|
} else if (!set_pre_split_keypool.empty()) {
|
|
set_pre_split_keypool.insert(nIndex);
|
|
} else {
|
|
setExternalKeyPool.insert(nIndex);
|
|
}
|
|
m_pool_key_to_index[pubkey.GetID()] = nIndex;
|
|
}
|
|
WalletLogPrintf("keypool return %d\n", nIndex);
|
|
}
|
|
|
|
bool CWallet::GetKeyFromPool(CPubKey& result, bool internal)
|
|
{
|
|
if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
return false;
|
|
}
|
|
|
|
CKeyPool keypool;
|
|
{
|
|
LOCK(cs_wallet);
|
|
int64_t nIndex;
|
|
if (!ReserveKeyFromKeyPool(nIndex, keypool, internal)) {
|
|
if (IsLocked()) return false;
|
|
WalletBatch batch(*database);
|
|
result = GenerateNewKey(batch, internal);
|
|
return true;
|
|
}
|
|
KeepKey(nIndex);
|
|
result = keypool.vchPubKey;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static int64_t GetOldestKeyTimeInPool(const std::set<int64_t>& setKeyPool, WalletBatch& batch) {
|
|
if (setKeyPool.empty()) {
|
|
return GetTime();
|
|
}
|
|
|
|
CKeyPool keypool;
|
|
int64_t nIndex = *(setKeyPool.begin());
|
|
if (!batch.ReadPool(nIndex, keypool)) {
|
|
throw std::runtime_error(std::string(__func__) + ": read oldest key in keypool failed");
|
|
}
|
|
assert(keypool.vchPubKey.IsValid());
|
|
return keypool.nTime;
|
|
}
|
|
|
|
int64_t CWallet::GetOldestKeyPoolTime()
|
|
{
|
|
LOCK(cs_wallet);
|
|
|
|
WalletBatch batch(*database);
|
|
|
|
// load oldest key from keypool, get time and return
|
|
int64_t oldestKey = GetOldestKeyTimeInPool(setExternalKeyPool, batch);
|
|
if (IsHDEnabled() && CanSupportFeature(FEATURE_HD_SPLIT)) {
|
|
oldestKey = std::max(GetOldestKeyTimeInPool(setInternalKeyPool, batch), oldestKey);
|
|
if (!set_pre_split_keypool.empty()) {
|
|
oldestKey = std::max(GetOldestKeyTimeInPool(set_pre_split_keypool, batch), oldestKey);
|
|
}
|
|
}
|
|
|
|
return oldestKey;
|
|
}
|
|
|
|
std::map<CTxDestination, CAmount> CWallet::GetAddressBalances()
|
|
{
|
|
std::map<CTxDestination, CAmount> balances;
|
|
|
|
{
|
|
LOCK(cs_wallet);
|
|
for (const auto& walletEntry : mapWallet)
|
|
{
|
|
const CWalletTx *pcoin = &walletEntry.second;
|
|
|
|
if (!pcoin->IsTrusted())
|
|
continue;
|
|
|
|
if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
|
|
continue;
|
|
|
|
int nDepth = pcoin->GetDepthInMainChain();
|
|
if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1))
|
|
continue;
|
|
|
|
for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++)
|
|
{
|
|
CTxDestination addr;
|
|
if (!IsMine(pcoin->tx->vout[i]))
|
|
continue;
|
|
if(!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, addr))
|
|
continue;
|
|
|
|
CAmount n = IsSpent(walletEntry.first, i) ? 0 : pcoin->tx->vout[i].nValue;
|
|
|
|
if (!balances.count(addr))
|
|
balances[addr] = 0;
|
|
balances[addr] += n;
|
|
}
|
|
}
|
|
}
|
|
|
|
return balances;
|
|
}
|
|
|
|
std::set< std::set<CTxDestination> > CWallet::GetAddressGroupings()
|
|
{
|
|
AssertLockHeld(cs_wallet); // mapWallet
|
|
std::set< std::set<CTxDestination> > groupings;
|
|
std::set<CTxDestination> grouping;
|
|
|
|
for (const auto& walletEntry : mapWallet)
|
|
{
|
|
const CWalletTx *pcoin = &walletEntry.second;
|
|
|
|
if (pcoin->tx->vin.size() > 0)
|
|
{
|
|
bool any_mine = false;
|
|
// group all input addresses with each other
|
|
for (CTxIn txin : pcoin->tx->vin)
|
|
{
|
|
CTxDestination address;
|
|
if(!IsMine(txin)) /* If this input isn't mine, ignore it */
|
|
continue;
|
|
if(!ExtractDestination(mapWallet.at(txin.prevout.hash).tx->vout[txin.prevout.n].scriptPubKey, address))
|
|
continue;
|
|
grouping.insert(address);
|
|
any_mine = true;
|
|
}
|
|
|
|
// group change with input addresses
|
|
if (any_mine)
|
|
{
|
|
for (CTxOut txout : pcoin->tx->vout)
|
|
if (IsChange(txout))
|
|
{
|
|
CTxDestination txoutAddr;
|
|
if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
|
|
continue;
|
|
grouping.insert(txoutAddr);
|
|
}
|
|
}
|
|
if (grouping.size() > 0)
|
|
{
|
|
groupings.insert(grouping);
|
|
grouping.clear();
|
|
}
|
|
}
|
|
|
|
// group lone addrs by themselves
|
|
for (const auto& txout : pcoin->tx->vout)
|
|
if (IsMine(txout))
|
|
{
|
|
CTxDestination address;
|
|
if(!ExtractDestination(txout.scriptPubKey, address))
|
|
continue;
|
|
grouping.insert(address);
|
|
groupings.insert(grouping);
|
|
grouping.clear();
|
|
}
|
|
}
|
|
|
|
std::set< std::set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
|
|
std::map< CTxDestination, std::set<CTxDestination>* > setmap; // map addresses to the unique group containing it
|
|
for (std::set<CTxDestination> _grouping : groupings)
|
|
{
|
|
// make a set of all the groups hit by this new group
|
|
std::set< std::set<CTxDestination>* > hits;
|
|
std::map< CTxDestination, std::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
|
|
std::set<CTxDestination>* merged = new std::set<CTxDestination>(_grouping);
|
|
for (std::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;
|
|
}
|
|
|
|
std::set< std::set<CTxDestination> > ret;
|
|
for (std::set<CTxDestination>* uniqueGrouping : uniqueGroupings)
|
|
{
|
|
ret.insert(*uniqueGrouping);
|
|
delete uniqueGrouping;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::set<CTxDestination> CWallet::GetLabelAddresses(const std::string& label) const
|
|
{
|
|
LOCK(cs_wallet);
|
|
std::set<CTxDestination> result;
|
|
for (const std::pair<const CTxDestination, CAddressBookData>& item : mapAddressBook)
|
|
{
|
|
const CTxDestination& address = item.first;
|
|
const std::string& strName = item.second.name;
|
|
if (strName == label)
|
|
result.insert(address);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void CWallet::DeleteLabel(const std::string& label)
|
|
{
|
|
WalletBatch batch(*database);
|
|
batch.EraseAccount(label);
|
|
}
|
|
|
|
bool CReserveKey::GetReservedKey(CPubKey& pubkey, bool internal)
|
|
{
|
|
if (nIndex == -1)
|
|
{
|
|
CKeyPool keypool;
|
|
if (!pwallet->ReserveKeyFromKeyPool(nIndex, keypool, internal)) {
|
|
return false;
|
|
}
|
|
vchPubKey = keypool.vchPubKey;
|
|
fInternal = keypool.fInternal;
|
|
}
|
|
assert(vchPubKey.IsValid());
|
|
pubkey = vchPubKey;
|
|
return true;
|
|
}
|
|
|
|
void CReserveKey::KeepKey()
|
|
{
|
|
if (nIndex != -1)
|
|
pwallet->KeepKey(nIndex);
|
|
nIndex = -1;
|
|
vchPubKey = CPubKey();
|
|
}
|
|
|
|
void CReserveKey::ReturnKey()
|
|
{
|
|
if (nIndex != -1) {
|
|
pwallet->ReturnKey(nIndex, fInternal, vchPubKey);
|
|
}
|
|
nIndex = -1;
|
|
vchPubKey = CPubKey();
|
|
}
|
|
|
|
void CWallet::MarkReserveKeysAsUsed(int64_t keypool_id)
|
|
{
|
|
AssertLockHeld(cs_wallet);
|
|
bool internal = setInternalKeyPool.count(keypool_id);
|
|
if (!internal) assert(setExternalKeyPool.count(keypool_id) || set_pre_split_keypool.count(keypool_id));
|
|
std::set<int64_t> *setKeyPool = internal ? &setInternalKeyPool : (set_pre_split_keypool.empty() ? &setExternalKeyPool : &set_pre_split_keypool);
|
|
auto it = setKeyPool->begin();
|
|
|
|
WalletBatch batch(*database);
|
|
while (it != std::end(*setKeyPool)) {
|
|
const int64_t& index = *(it);
|
|
if (index > keypool_id) break; // set*KeyPool is ordered
|
|
|
|
CKeyPool keypool;
|
|
if (batch.ReadPool(index, keypool)) { //TODO: This should be unnecessary
|
|
m_pool_key_to_index.erase(keypool.vchPubKey.GetID());
|
|
}
|
|
LearnAllRelatedScripts(keypool.vchPubKey);
|
|
batch.ErasePool(index);
|
|
WalletLogPrintf("keypool index %d removed\n", index);
|
|
it = setKeyPool->erase(it);
|
|
}
|
|
}
|
|
|
|
void CWallet::GetScriptForMining(std::shared_ptr<CReserveScript> &script)
|
|
{
|
|
std::shared_ptr<CReserveKey> rKey = std::make_shared<CReserveKey>(this);
|
|
CPubKey pubkey;
|
|
if (!rKey->GetReservedKey(pubkey))
|
|
return;
|
|
|
|
script = rKey;
|
|
script->reserveScript = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
|
|
}
|
|
|
|
void CWallet::LockCoin(const COutPoint& output)
|
|
{
|
|
AssertLockHeld(cs_wallet); // setLockedCoins
|
|
setLockedCoins.insert(output);
|
|
}
|
|
|
|
void CWallet::UnlockCoin(const COutPoint& output)
|
|
{
|
|
AssertLockHeld(cs_wallet); // setLockedCoins
|
|
setLockedCoins.erase(output);
|
|
}
|
|
|
|
void CWallet::UnlockAllCoins()
|
|
{
|
|
AssertLockHeld(cs_wallet); // setLockedCoins
|
|
setLockedCoins.clear();
|
|
}
|
|
|
|
bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const
|
|
{
|
|
AssertLockHeld(cs_wallet); // setLockedCoins
|
|
COutPoint outpt(hash, n);
|
|
|
|
return (setLockedCoins.count(outpt) > 0);
|
|
}
|
|
|
|
void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
|
|
{
|
|
AssertLockHeld(cs_wallet); // setLockedCoins
|
|
for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
|
|
it != setLockedCoins.end(); it++) {
|
|
COutPoint outpt = (*it);
|
|
vOutpts.push_back(outpt);
|
|
}
|
|
}
|
|
|
|
/** @} */ // end of Actions
|
|
|
|
void CWallet::GetKeyBirthTimes(std::map<CTxDestination, int64_t> &mapKeyBirth) const {
|
|
AssertLockHeld(cs_wallet); // mapKeyMetadata
|
|
mapKeyBirth.clear();
|
|
|
|
// get birth times for keys with metadata
|
|
for (const auto& entry : mapKeyMetadata) {
|
|
if (entry.second.nCreateTime) {
|
|
mapKeyBirth[entry.first] = entry.second.nCreateTime;
|
|
}
|
|
}
|
|
|
|
// map in which we'll infer heights of other keys
|
|
CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() - 144)]; // the tip can be reorganized; use a 144-block safety margin
|
|
std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
|
|
for (const CKeyID &keyid : GetKeys()) {
|
|
if (mapKeyBirth.count(keyid) == 0)
|
|
mapKeyFirstBlock[keyid] = pindexMax;
|
|
}
|
|
|
|
// 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 (const auto& entry : mapWallet) {
|
|
// iterate over all wallet transactions...
|
|
const CWalletTx &wtx = entry.second;
|
|
CBlockIndex* pindex = LookupBlockIndex(wtx.hashBlock);
|
|
if (pindex && chainActive.Contains(pindex)) {
|
|
// ... which are already in a block
|
|
int nHeight = pindex->nHeight;
|
|
for (const CTxOut &txout : wtx.tx->vout) {
|
|
// iterate over all their outputs
|
|
CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
|
|
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 = pindex;
|
|
}
|
|
vAffected.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract block timestamps for those keys
|
|
for (const auto& entry : mapKeyFirstBlock)
|
|
mapKeyBirth[entry.first] = entry.second->GetBlockTime() - TIMESTAMP_WINDOW; // block times can be 2h off
|
|
}
|
|
|
|
/**
|
|
* Compute smart timestamp for a transaction being added to the wallet.
|
|
*
|
|
* Logic:
|
|
* - If sending a transaction, assign its timestamp to the current time.
|
|
* - If receiving a transaction outside a block, assign its timestamp to the
|
|
* current time.
|
|
* - If receiving a block with a future timestamp, assign all its (not already
|
|
* known) transactions' timestamps to the current time.
|
|
* - If receiving a block with a past timestamp, before the most recent known
|
|
* transaction (that we care about), assign all its (not already known)
|
|
* transactions' timestamps to the same timestamp as that most-recent-known
|
|
* transaction.
|
|
* - If receiving a block with a past timestamp, but after the most recent known
|
|
* transaction, assign all its (not already known) transactions' timestamps to
|
|
* the block time.
|
|
*
|
|
* For more information see CWalletTx::nTimeSmart,
|
|
* https://bitcointalk.org/?topic=54527, or
|
|
* https://github.com/bitcoin/bitcoin/pull/1393.
|
|
*/
|
|
unsigned int CWallet::ComputeTimeSmart(const CWalletTx& wtx) const
|
|
{
|
|
unsigned int nTimeSmart = wtx.nTimeReceived;
|
|
if (!wtx.hashUnset()) {
|
|
if (const CBlockIndex* pindex = LookupBlockIndex(wtx.hashBlock)) {
|
|
int64_t latestNow = wtx.nTimeReceived;
|
|
int64_t 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;
|
|
const TxItems& txOrdered = wtxOrdered;
|
|
for (auto 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;
|
|
}
|
|
}
|
|
|
|
int64_t blocktime = pindex->GetBlockTime();
|
|
nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
|
|
} else {
|
|
WalletLogPrintf("%s: found %s in block %s not in index\n", __func__, wtx.GetHash().ToString(), wtx.hashBlock.ToString());
|
|
}
|
|
}
|
|
return nTimeSmart;
|
|
}
|
|
|
|
bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
|
|
{
|
|
if (boost::get<CNoDestination>(&dest))
|
|
return false;
|
|
|
|
mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
|
|
return WalletBatch(*database).WriteDestData(EncodeDestination(dest), key, value);
|
|
}
|
|
|
|
bool CWallet::EraseDestData(const CTxDestination &dest, const std::string &key)
|
|
{
|
|
if (!mapAddressBook[dest].destdata.erase(key))
|
|
return false;
|
|
return WalletBatch(*database).EraseDestData(EncodeDestination(dest), key);
|
|
}
|
|
|
|
void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
|
|
{
|
|
mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
|
|
}
|
|
|
|
bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const
|
|
{
|
|
std::map<CTxDestination, CAddressBookData>::const_iterator i = mapAddressBook.find(dest);
|
|
if(i != mapAddressBook.end())
|
|
{
|
|
CAddressBookData::StringMap::const_iterator j = i->second.destdata.find(key);
|
|
if(j != i->second.destdata.end())
|
|
{
|
|
if(value)
|
|
*value = j->second;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> CWallet::GetDestValues(const std::string& prefix) const
|
|
{
|
|
LOCK(cs_wallet);
|
|
std::vector<std::string> values;
|
|
for (const auto& address : mapAddressBook) {
|
|
for (const auto& data : address.second.destdata) {
|
|
if (!data.first.compare(0, prefix.size(), prefix)) {
|
|
values.emplace_back(data.second);
|
|
}
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
|
|
void CWallet::MarkPreSplitKeys()
|
|
{
|
|
WalletBatch batch(*database);
|
|
for (auto it = setExternalKeyPool.begin(); it != setExternalKeyPool.end();) {
|
|
int64_t index = *it;
|
|
CKeyPool keypool;
|
|
if (!batch.ReadPool(index, keypool)) {
|
|
throw std::runtime_error(std::string(__func__) + ": read keypool entry failed");
|
|
}
|
|
keypool.m_pre_split = true;
|
|
if (!batch.WritePool(index, keypool)) {
|
|
throw std::runtime_error(std::string(__func__) + ": writing modified keypool entry failed");
|
|
}
|
|
set_pre_split_keypool.insert(index);
|
|
it = setExternalKeyPool.erase(it);
|
|
}
|
|
}
|
|
|
|
bool CWallet::Verify(std::string wallet_file, bool salvage_wallet, std::string& error_string, std::string& warning_string)
|
|
{
|
|
// Do some checking on wallet path. It should be either a:
|
|
//
|
|
// 1. Path where a directory can be created.
|
|
// 2. Path to an existing directory.
|
|
// 3. Path to a symlink to a directory.
|
|
// 4. For backwards compatibility, the name of a data file in -walletdir.
|
|
LOCK(cs_wallets);
|
|
fs::path wallet_path = fs::absolute(wallet_file, GetWalletDir());
|
|
fs::file_type path_type = fs::symlink_status(wallet_path).type();
|
|
if (!(path_type == fs::file_not_found || path_type == fs::directory_file ||
|
|
(path_type == fs::symlink_file && fs::is_directory(wallet_path)) ||
|
|
(path_type == fs::regular_file && fs::path(wallet_file).filename() == wallet_file))) {
|
|
error_string = strprintf(
|
|
"Invalid -wallet path '%s'. -wallet path should point to a directory where wallet.dat and "
|
|
"database/log.?????????? files can be stored, a location where such a directory could be created, "
|
|
"or (for backwards compatibility) the name of an existing data file in -walletdir (%s)",
|
|
wallet_file, GetWalletDir());
|
|
return false;
|
|
}
|
|
|
|
// Make sure that the wallet path doesn't clash with an existing wallet path
|
|
for (auto wallet : GetWallets()) {
|
|
if (fs::absolute(wallet->GetName(), GetWalletDir()) == wallet_path) {
|
|
error_string = strprintf("Error loading wallet %s. Duplicate -wallet filename specified.", wallet_file);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (!WalletBatch::VerifyEnvironment(wallet_path, error_string)) {
|
|
return false;
|
|
}
|
|
} catch (const fs::filesystem_error& e) {
|
|
error_string = strprintf("Error loading wallet %s. %s", wallet_file, e.what());
|
|
return false;
|
|
}
|
|
|
|
if (salvage_wallet) {
|
|
// Recover readable keypairs:
|
|
CWallet dummyWallet("dummy", WalletDatabase::CreateDummy());
|
|
std::string backup_filename;
|
|
if (!WalletBatch::Recover(wallet_path, (void *)&dummyWallet, WalletBatch::RecoverKeysOnlyFilter, backup_filename)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return WalletBatch::VerifyDatabaseFile(wallet_path, warning_string, error_string);
|
|
}
|
|
|
|
std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(const std::string& name, const fs::path& path, uint64_t wallet_creation_flags)
|
|
{
|
|
const std::string& walletFile = name;
|
|
|
|
// needed to restore wallet transaction meta data after -zapwallettxes
|
|
std::vector<CWalletTx> vWtx;
|
|
|
|
if (gArgs.GetBoolArg("-zapwallettxes", false)) {
|
|
uiInterface.InitMessage(_("Zapping all transactions from wallet..."));
|
|
|
|
std::unique_ptr<CWallet> tempWallet = MakeUnique<CWallet>(name, WalletDatabase::Create(path));
|
|
DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
|
|
if (nZapWalletRet != DBErrors::LOAD_OK) {
|
|
InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
uiInterface.InitMessage(_("Loading wallet..."));
|
|
|
|
int64_t nStart = GetTimeMillis();
|
|
bool fFirstRun = true;
|
|
// TODO: Can't use std::make_shared because we need a custom deleter but
|
|
// should be possible to use std::allocate_shared.
|
|
std::shared_ptr<CWallet> walletInstance(new CWallet(name, WalletDatabase::Create(path)), ReleaseWallet);
|
|
DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
|
|
if (nLoadWalletRet != DBErrors::LOAD_OK)
|
|
{
|
|
if (nLoadWalletRet == DBErrors::CORRUPT) {
|
|
InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
|
|
return nullptr;
|
|
}
|
|
else if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR)
|
|
{
|
|
InitWarning(strprintf(_("Error reading %s! All keys read correctly, but transaction data"
|
|
" or address book entries might be missing or incorrect."),
|
|
walletFile));
|
|
}
|
|
else if (nLoadWalletRet == DBErrors::TOO_NEW) {
|
|
InitError(strprintf(_("Error loading %s: Wallet requires newer version of %s"), walletFile, _(PACKAGE_NAME)));
|
|
return nullptr;
|
|
}
|
|
else if (nLoadWalletRet == DBErrors::NEED_REWRITE)
|
|
{
|
|
InitError(strprintf(_("Wallet needed to be rewritten: restart %s to complete"), _(PACKAGE_NAME)));
|
|
return nullptr;
|
|
}
|
|
else {
|
|
InitError(strprintf(_("Error loading %s"), walletFile));
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
int prev_version = walletInstance->nWalletVersion;
|
|
if (gArgs.GetBoolArg("-upgradewallet", fFirstRun))
|
|
{
|
|
int nMaxVersion = gArgs.GetArg("-upgradewallet", 0);
|
|
if (nMaxVersion == 0) // the -upgradewallet without argument case
|
|
{
|
|
walletInstance->WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);
|
|
nMaxVersion = FEATURE_LATEST;
|
|
walletInstance->SetMinVersion(FEATURE_LATEST); // permanently upgrade the wallet immediately
|
|
}
|
|
else
|
|
walletInstance->WalletLogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);
|
|
if (nMaxVersion < walletInstance->GetVersion())
|
|
{
|
|
InitError(_("Cannot downgrade wallet"));
|
|
return nullptr;
|
|
}
|
|
walletInstance->SetMaxVersion(nMaxVersion);
|
|
}
|
|
|
|
// Upgrade to HD if explicit upgrade
|
|
if (gArgs.GetBoolArg("-upgradewallet", false)) {
|
|
LOCK(walletInstance->cs_wallet);
|
|
|
|
// Do not upgrade versions to any version between HD_SPLIT and FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
|
|
int max_version = walletInstance->nWalletVersion;
|
|
if (!walletInstance->CanSupportFeature(FEATURE_HD_SPLIT) && max_version >=FEATURE_HD_SPLIT && max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
|
|
InitError(_("Cannot upgrade a non HD split wallet without upgrading to support pre split keypool. Please use -upgradewallet=169900 or -upgradewallet with no version specified."));
|
|
return nullptr;
|
|
}
|
|
|
|
bool hd_upgrade = false;
|
|
bool split_upgrade = false;
|
|
if (walletInstance->CanSupportFeature(FEATURE_HD) && !walletInstance->IsHDEnabled()) {
|
|
walletInstance->WalletLogPrintf("Upgrading wallet to HD\n");
|
|
walletInstance->SetMinVersion(FEATURE_HD);
|
|
|
|
// generate a new master key
|
|
CPubKey masterPubKey = walletInstance->GenerateNewSeed();
|
|
walletInstance->SetHDSeed(masterPubKey);
|
|
hd_upgrade = true;
|
|
}
|
|
// Upgrade to HD chain split if necessary
|
|
if (walletInstance->CanSupportFeature(FEATURE_HD_SPLIT)) {
|
|
walletInstance->WalletLogPrintf("Upgrading wallet to use HD chain split\n");
|
|
walletInstance->SetMinVersion(FEATURE_PRE_SPLIT_KEYPOOL);
|
|
split_upgrade = FEATURE_HD_SPLIT > prev_version;
|
|
}
|
|
// Mark all keys currently in the keypool as pre-split
|
|
if (split_upgrade) {
|
|
walletInstance->MarkPreSplitKeys();
|
|
}
|
|
// Regenerate the keypool if upgraded to HD
|
|
if (hd_upgrade) {
|
|
if (!walletInstance->TopUpKeyPool()) {
|
|
InitError(_("Unable to generate keys"));
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fFirstRun)
|
|
{
|
|
// ensure this wallet.dat can only be opened by clients supporting HD with chain split and expects no default key
|
|
if (!gArgs.GetBoolArg("-usehd", true)) {
|
|
InitError(strprintf(_("Error creating %s: You can't create non-HD wallets with this version."), walletFile));
|
|
return nullptr;
|
|
}
|
|
walletInstance->SetMinVersion(FEATURE_LATEST);
|
|
|
|
if ((wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
//selective allow to set flags
|
|
walletInstance->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
|
|
} else {
|
|
// generate a new seed
|
|
CPubKey seed = walletInstance->GenerateNewSeed();
|
|
walletInstance->SetHDSeed(seed);
|
|
}
|
|
|
|
// Top up the keypool
|
|
if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !walletInstance->TopUpKeyPool()) {
|
|
InitError(_("Unable to generate initial keys"));
|
|
return nullptr;
|
|
}
|
|
|
|
walletInstance->ChainStateFlushed(chainActive.GetLocator());
|
|
} else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
|
|
// Make it impossible to disable private keys after creation
|
|
InitError(strprintf(_("Error loading %s: Private keys can only be disabled during creation"), walletFile));
|
|
return NULL;
|
|
} else if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
|
|
LOCK(walletInstance->cs_KeyStore);
|
|
if (!walletInstance->mapKeys.empty() || !walletInstance->mapCryptedKeys.empty()) {
|
|
InitWarning(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));
|
|
}
|
|
} else if (gArgs.IsArgSet("-usehd")) {
|
|
bool useHD = gArgs.GetBoolArg("-usehd", true);
|
|
if (walletInstance->IsHDEnabled() && !useHD) {
|
|
InitError(strprintf(_("Error loading %s: You can't disable HD on an already existing HD wallet"), walletFile));
|
|
return nullptr;
|
|
}
|
|
if (!walletInstance->IsHDEnabled() && useHD) {
|
|
InitError(strprintf(_("Error loading %s: You can't enable HD on an already existing non-HD wallet"), walletFile));
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
if (!gArgs.GetArg("-addresstype", "").empty() && !ParseOutputType(gArgs.GetArg("-addresstype", ""), walletInstance->m_default_address_type)) {
|
|
InitError(strprintf("Unknown address type '%s'", gArgs.GetArg("-addresstype", "")));
|
|
return nullptr;
|
|
}
|
|
|
|
if (!gArgs.GetArg("-changetype", "").empty() && !ParseOutputType(gArgs.GetArg("-changetype", ""), walletInstance->m_default_change_type)) {
|
|
InitError(strprintf("Unknown change type '%s'", gArgs.GetArg("-changetype", "")));
|
|
return nullptr;
|
|
}
|
|
|
|
if (gArgs.IsArgSet("-mintxfee")) {
|
|
CAmount n = 0;
|
|
if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) || 0 == n) {
|
|
InitError(AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", "")));
|
|
return nullptr;
|
|
}
|
|
if (n > HIGH_TX_FEE_PER_KB) {
|
|
InitWarning(AmountHighWarn("-mintxfee") + " " +
|
|
_("This is the minimum transaction fee you pay on every transaction."));
|
|
}
|
|
walletInstance->m_min_fee = CFeeRate(n);
|
|
}
|
|
|
|
walletInstance->m_allow_fallback_fee = Params().IsFallbackFeeEnabled();
|
|
if (gArgs.IsArgSet("-fallbackfee")) {
|
|
CAmount nFeePerK = 0;
|
|
if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
|
|
InitError(strprintf(_("Invalid amount for -fallbackfee=<amount>: '%s'"), gArgs.GetArg("-fallbackfee", "")));
|
|
return nullptr;
|
|
}
|
|
if (nFeePerK > HIGH_TX_FEE_PER_KB) {
|
|
InitWarning(AmountHighWarn("-fallbackfee") + " " +
|
|
_("This is the transaction fee you may pay when fee estimates are not available."));
|
|
}
|
|
walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
|
|
walletInstance->m_allow_fallback_fee = nFeePerK != 0; //disable fallback fee in case value was set to 0, enable if non-null value
|
|
}
|
|
if (gArgs.IsArgSet("-discardfee")) {
|
|
CAmount nFeePerK = 0;
|
|
if (!ParseMoney(gArgs.GetArg("-discardfee", ""), nFeePerK)) {
|
|
InitError(strprintf(_("Invalid amount for -discardfee=<amount>: '%s'"), gArgs.GetArg("-discardfee", "")));
|
|
return nullptr;
|
|
}
|
|
if (nFeePerK > HIGH_TX_FEE_PER_KB) {
|
|
InitWarning(AmountHighWarn("-discardfee") + " " +
|
|
_("This is the transaction fee you may discard if change is smaller than dust at this level"));
|
|
}
|
|
walletInstance->m_discard_rate = CFeeRate(nFeePerK);
|
|
}
|
|
if (gArgs.IsArgSet("-paytxfee")) {
|
|
CAmount nFeePerK = 0;
|
|
if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
|
|
InitError(AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", "")));
|
|
return nullptr;
|
|
}
|
|
if (nFeePerK > HIGH_TX_FEE_PER_KB) {
|
|
InitWarning(AmountHighWarn("-paytxfee") + " " +
|
|
_("This is the transaction fee you will pay if you send a transaction."));
|
|
}
|
|
walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
|
|
if (walletInstance->m_pay_tx_fee < ::minRelayTxFee) {
|
|
InitError(strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' (must be at least %s)"),
|
|
gArgs.GetArg("-paytxfee", ""), ::minRelayTxFee.ToString()));
|
|
return nullptr;
|
|
}
|
|
}
|
|
walletInstance->m_confirm_target = gArgs.GetArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET);
|
|
walletInstance->m_spend_zero_conf_change = gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);
|
|
walletInstance->m_signal_rbf = gArgs.GetBoolArg("-walletrbf", DEFAULT_WALLET_RBF);
|
|
|
|
walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n", GetTimeMillis() - nStart);
|
|
|
|
// Try to top up keypool. No-op if the wallet is locked.
|
|
walletInstance->TopUpKeyPool();
|
|
|
|
LOCK(cs_main);
|
|
|
|
CBlockIndex *pindexRescan = chainActive.Genesis();
|
|
if (!gArgs.GetBoolArg("-rescan", false))
|
|
{
|
|
WalletBatch batch(*walletInstance->database);
|
|
CBlockLocator locator;
|
|
if (batch.ReadBestBlock(locator))
|
|
pindexRescan = FindForkInGlobalIndex(chainActive, locator);
|
|
}
|
|
|
|
walletInstance->m_last_block_processed = chainActive.Tip();
|
|
|
|
if (chainActive.Tip() && chainActive.Tip() != pindexRescan)
|
|
{
|
|
//We can't rescan beyond non-pruned blocks, stop and throw an error
|
|
//this might happen if a user uses an old wallet within a pruned node
|
|
// or if he ran -disablewallet for a longer time, then decided to re-enable
|
|
if (fPruneMode)
|
|
{
|
|
CBlockIndex *block = chainActive.Tip();
|
|
while (block && block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA) && block->pprev->nTx > 0 && pindexRescan != block)
|
|
block = block->pprev;
|
|
|
|
if (pindexRescan != block) {
|
|
InitError(_("Prune: last wallet synchronisation goes beyond pruned data. You need to -reindex (download the whole blockchain again in case of pruned node)"));
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
uiInterface.InitMessage(_("Rescanning..."));
|
|
walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", chainActive.Height() - pindexRescan->nHeight, pindexRescan->nHeight);
|
|
|
|
// No need to read and scan block if block was created before
|
|
// our wallet birthday (as adjusted for block time variability)
|
|
while (pindexRescan && walletInstance->nTimeFirstKey && (pindexRescan->GetBlockTime() < (walletInstance->nTimeFirstKey - TIMESTAMP_WINDOW))) {
|
|
pindexRescan = chainActive.Next(pindexRescan);
|
|
}
|
|
|
|
nStart = GetTimeMillis();
|
|
{
|
|
WalletRescanReserver reserver(walletInstance.get());
|
|
if (!reserver.reserve()) {
|
|
InitError(_("Failed to rescan the wallet during initialization"));
|
|
return nullptr;
|
|
}
|
|
walletInstance->ScanForWalletTransactions(pindexRescan, nullptr, reserver, true);
|
|
}
|
|
walletInstance->WalletLogPrintf("Rescan completed in %15dms\n", GetTimeMillis() - nStart);
|
|
walletInstance->ChainStateFlushed(chainActive.GetLocator());
|
|
walletInstance->database->IncrementUpdateCounter();
|
|
|
|
// Restore wallet transaction metadata after -zapwallettxes=1
|
|
if (gArgs.GetBoolArg("-zapwallettxes", false) && gArgs.GetArg("-zapwallettxes", "1") != "2")
|
|
{
|
|
WalletBatch batch(*walletInstance->database);
|
|
|
|
for (const CWalletTx& wtxOld : vWtx)
|
|
{
|
|
uint256 hash = wtxOld.GetHash();
|
|
std::map<uint256, CWalletTx>::iterator mi = walletInstance->mapWallet.find(hash);
|
|
if (mi != walletInstance->mapWallet.end())
|
|
{
|
|
const CWalletTx* copyFrom = &wtxOld;
|
|
CWalletTx* copyTo = &mi->second;
|
|
copyTo->mapValue = copyFrom->mapValue;
|
|
copyTo->vOrderForm = copyFrom->vOrderForm;
|
|
copyTo->nTimeReceived = copyFrom->nTimeReceived;
|
|
copyTo->nTimeSmart = copyFrom->nTimeSmart;
|
|
copyTo->fFromMe = copyFrom->fFromMe;
|
|
copyTo->strFromAccount = copyFrom->strFromAccount;
|
|
copyTo->nOrderPos = copyFrom->nOrderPos;
|
|
batch.WriteTx(*copyTo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uiInterface.LoadWallet(walletInstance);
|
|
|
|
// Register with the validation interface. It's ok to do this after rescan since we're still holding cs_main.
|
|
RegisterValidationInterface(walletInstance.get());
|
|
|
|
walletInstance->SetBroadcastTransactions(gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));
|
|
|
|
{
|
|
LOCK(walletInstance->cs_wallet);
|
|
walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n", walletInstance->GetKeyPoolSize());
|
|
walletInstance->WalletLogPrintf("mapWallet.size() = %u\n", walletInstance->mapWallet.size());
|
|
walletInstance->WalletLogPrintf("mapAddressBook.size() = %u\n", walletInstance->mapAddressBook.size());
|
|
}
|
|
|
|
return walletInstance;
|
|
}
|
|
|
|
void CWallet::postInitProcess()
|
|
{
|
|
// Add wallet transactions that aren't already in a block to mempool
|
|
// Do this here as mempool requires genesis block to be loaded
|
|
ReacceptWalletTransactions();
|
|
}
|
|
|
|
bool CWallet::BackupWallet(const std::string& strDest)
|
|
{
|
|
return database->Backup(strDest);
|
|
}
|
|
|
|
CKeyPool::CKeyPool()
|
|
{
|
|
nTime = GetTime();
|
|
fInternal = false;
|
|
m_pre_split = false;
|
|
}
|
|
|
|
CKeyPool::CKeyPool(const CPubKey& vchPubKeyIn, bool internalIn)
|
|
{
|
|
nTime = GetTime();
|
|
vchPubKey = vchPubKeyIn;
|
|
fInternal = internalIn;
|
|
m_pre_split = false;
|
|
}
|
|
|
|
CWalletKey::CWalletKey(int64_t nExpires)
|
|
{
|
|
nTimeCreated = (nExpires ? GetTime() : 0);
|
|
nTimeExpires = nExpires;
|
|
}
|
|
|
|
void CMerkleTx::SetMerkleBranch(const CBlockIndex* pindex, int posInBlock)
|
|
{
|
|
// Update the tx's hashBlock
|
|
hashBlock = pindex->GetBlockHash();
|
|
|
|
// set the position of the transaction in the block
|
|
nIndex = posInBlock;
|
|
}
|
|
|
|
int CMerkleTx::GetDepthInMainChain() const
|
|
{
|
|
if (hashUnset())
|
|
return 0;
|
|
|
|
AssertLockHeld(cs_main);
|
|
|
|
// Find the block it claims to be in
|
|
CBlockIndex* pindex = LookupBlockIndex(hashBlock);
|
|
if (!pindex || !chainActive.Contains(pindex))
|
|
return 0;
|
|
|
|
return ((nIndex == -1) ? (-1) : 1) * (chainActive.Height() - pindex->nHeight + 1);
|
|
}
|
|
|
|
int CMerkleTx::GetBlocksToMaturity() const
|
|
{
|
|
if (!IsCoinBase())
|
|
return 0;
|
|
int chain_depth = GetDepthInMainChain();
|
|
assert(chain_depth >= 0); // coinbase tx should not be conflicted
|
|
return std::max(0, (COINBASE_MATURITY+1) - chain_depth);
|
|
}
|
|
|
|
|
|
bool CWalletTx::AcceptToMemoryPool(const CAmount& nAbsurdFee, CValidationState& state)
|
|
{
|
|
// We must set fInMempool here - while it will be re-set to true by the
|
|
// entered-mempool callback, if we did not there would be a race where a
|
|
// user could call sendmoney in a loop and hit spurious out of funds errors
|
|
// because we think that this newly generated transaction's change is
|
|
// unavailable as we're not yet aware that it is in the mempool.
|
|
bool ret = ::AcceptToMemoryPool(mempool, state, tx, nullptr /* pfMissingInputs */,
|
|
nullptr /* plTxnReplaced */, false /* bypass_limits */, nAbsurdFee);
|
|
fInMempool |= ret;
|
|
return ret;
|
|
}
|
|
|
|
void CWallet::LearnRelatedScripts(const CPubKey& key, OutputType type)
|
|
{
|
|
if (key.IsCompressed() && (type == OutputType::P2SH_SEGWIT || type == OutputType::BECH32)) {
|
|
CTxDestination witdest = WitnessV0KeyHash(key.GetID());
|
|
CScript witprog = GetScriptForDestination(witdest);
|
|
// Make sure the resulting program is solvable.
|
|
assert(IsSolvable(*this, witprog));
|
|
AddCScript(witprog);
|
|
}
|
|
}
|
|
|
|
void CWallet::LearnAllRelatedScripts(const CPubKey& key)
|
|
{
|
|
// OutputType::P2SH_SEGWIT always adds all necessary scripts for all types.
|
|
LearnRelatedScripts(key, OutputType::P2SH_SEGWIT);
|
|
}
|
|
|
|
std::vector<OutputGroup> CWallet::GroupOutputs(const std::vector<COutput>& outputs, bool single_coin) const {
|
|
std::vector<OutputGroup> groups;
|
|
std::map<CTxDestination, OutputGroup> gmap;
|
|
CTxDestination dst;
|
|
for (const auto& output : outputs) {
|
|
if (output.fSpendable) {
|
|
CInputCoin input_coin = output.GetInputCoin();
|
|
|
|
size_t ancestors, descendants;
|
|
mempool.GetTransactionAncestry(output.tx->GetHash(), ancestors, descendants);
|
|
if (!single_coin && ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey, dst)) {
|
|
// Limit output groups to no more than 10 entries, to protect
|
|
// against inadvertently creating a too-large transaction
|
|
// when using -avoidpartialspends
|
|
if (gmap[dst].m_outputs.size() >= OUTPUT_GROUP_MAX_ENTRIES) {
|
|
groups.push_back(gmap[dst]);
|
|
gmap.erase(dst);
|
|
}
|
|
gmap[dst].Insert(input_coin, output.nDepth, output.tx->IsFromMe(ISMINE_ALL), ancestors, descendants);
|
|
} else {
|
|
groups.emplace_back(input_coin, output.nDepth, output.tx->IsFromMe(ISMINE_ALL), ancestors, descendants);
|
|
}
|
|
}
|
|
}
|
|
if (!single_coin) {
|
|
for (const auto& it : gmap) groups.push_back(it.second);
|
|
}
|
|
return groups;
|
|
}
|