44 "You need to rescan the blockchain in order to correctly mark used "
45 "destinations in the past. Until this is done, some destinations may "
46 "be considered unused, even if the opposite is the case."},
54 const std::string &wallet_name) {
60 if (value.isStr() && value.get_str() == wallet_name) {
69 const std::string &wallet_name) {
76 if (!value.isStr() || value.get_str() != wallet_name) {
80 if (new_value.
size() == setting_value.
size()) {
87 const std::string &wallet_name,
88 std::optional<bool> load_on_startup,
89 std::vector<bilingual_str> &warnings) {
90 if (!load_on_startup) {
94 warnings.emplace_back(
95 Untranslated(
"Wallet load on startup setting could not be updated, "
96 "so wallet may not be loaded next node startup."));
97 }
else if (!load_on_startup.value() &&
99 warnings.emplace_back(
100 Untranslated(
"Wallet load on startup setting could not be updated, "
101 "so wallet may still be loaded next node startup."));
108 std::vector<std::shared_ptr<CWallet>>::const_iterator i =
109 std::find(vpwallets.begin(), vpwallets.end(),
wallet);
110 if (i != vpwallets.end()) {
113 vpwallets.push_back(
wallet);
114 wallet->ConnectScriptPubKeyManNotifiers();
115 wallet->NotifyCanGetAddressesChanged();
120 std::optional<bool> load_on_start,
121 std::vector<bilingual_str> &warnings) {
128 wallet->m_chain_notifications_handler.reset();
130 std::vector<std::shared_ptr<CWallet>>::iterator i =
131 std::find(vpwallets.begin(), vpwallets.end(),
wallet);
132 if (i == vpwallets.end()) {
144 std::optional<bool> load_on_start) {
145 std::vector<bilingual_str> warnings;
156 for (
const std::shared_ptr<CWallet> &
wallet : vpwallets) {
164 std::unique_ptr<interfaces::Handler>
167 auto it = g_load_wallet_fns.emplace(g_load_wallet_fns.end(),
168 std::move(load_wallet));
171 g_load_wallet_fns.erase(it);
178 static std::set<std::string>
180 static std::set<std::string>
186 wallet->WalletLogPrintf(
"Releasing wallet\n");
192 if (g_unloading_wallet_set.erase(
name) == 0) {
205 auto it = g_unloading_wallet_set.insert(
name);
217 while (g_unloading_wallet_set.count(
name) == 1) {
224 std::shared_ptr<CWallet>
226 std::optional<bool> load_on_start,
230 std::unique_ptr<WalletDatabase> database =
238 std::shared_ptr<CWallet>
wallet =
248 wallet->postInitProcess();
254 }
catch (
const std::runtime_error &e) {
262 std::shared_ptr<CWallet>
266 std::vector<bilingual_str> &warnings) {
268 return g_loading_wallet_set.insert(
name));
269 if (!result.second) {
274 auto wallet = LoadWalletInternal(chain,
name, load_on_start, options,
275 status,
error, warnings);
280 std::shared_ptr<CWallet>
284 std::vector<bilingual_str> &warnings) {
293 if (!passphrase.empty()) {
299 std::unique_ptr<WalletDatabase> database =
309 if (!passphrase.empty() &&
312 "Passphrase provided but private keys are disabled. A passphrase "
313 "is only used to encrypt private keys, so cannot be used for "
314 "wallets with private keys disabled.");
320 std::shared_ptr<CWallet>
wallet =
331 if (!passphrase.empty() &&
333 if (!
wallet->EncryptWallet(passphrase)) {
335 Untranslated(
"Error: Wallet created but failed to encrypt.");
341 if (!
wallet->Unlock(passphrase)) {
343 "Error: Wallet was encrypted but could not be unlocked");
352 wallet->SetupDescriptorScriptPubKeyMans();
354 for (
auto spk_man :
wallet->GetActiveScriptPubKeyMans()) {
355 if (!spk_man->SetupGeneration()) {
370 wallet->postInitProcess();
392 std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
393 if (it == mapWallet.end()) {
397 return &(it->second);
410 spk_man->UpgradeKeyMetadata();
415 bool accept_no_keys) {
421 for (
const MasterKeyMap::value_type &pMasterKey :
mapMasterKeys) {
423 strWalletPassphrase, pMasterKey.second.vchSalt,
424 pMasterKey.second.nDeriveIterations,
425 pMasterKey.second.nDerivationMethod)) {
428 if (!crypter.
Decrypt(pMasterKey.second.vchCryptedKey,
433 if (
Unlock(_vMasterKey, accept_no_keys)) {
456 strOldWalletPassphrase, pMasterKey.second.vchSalt,
457 pMasterKey.second.nDeriveIterations,
458 pMasterKey.second.nDerivationMethod)) {
462 if (!crypter.
Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
466 if (
Unlock(_vMasterKey)) {
469 pMasterKey.second.vchSalt,
470 pMasterKey.second.nDeriveIterations,
471 pMasterKey.second.nDerivationMethod);
472 pMasterKey.second.nDeriveIterations =
static_cast<unsigned int>(
473 pMasterKey.second.nDeriveIterations *
478 pMasterKey.second.vchSalt,
479 pMasterKey.second.nDeriveIterations,
480 pMasterKey.second.nDerivationMethod);
481 pMasterKey.second.nDeriveIterations =
482 (pMasterKey.second.nDeriveIterations +
483 static_cast<unsigned int>(
484 pMasterKey.second.nDeriveIterations * 100 /
488 if (pMasterKey.second.nDeriveIterations < 25000) {
489 pMasterKey.second.nDeriveIterations = 25000;
493 "Wallet passphrase changed to an nDeriveIterations of %i\n",
494 pMasterKey.second.nDeriveIterations);
497 strNewWalletPassphrase, pMasterKey.second.vchSalt,
498 pMasterKey.second.nDeriveIterations,
499 pMasterKey.second.nDerivationMethod)) {
503 if (!crypter.
Encrypt(_vMasterKey,
504 pMasterKey.second.vchCryptedKey)) {
529 if (nWalletVersion >= nVersion) {
535 if (fExplicit && nVersion > nWalletMaxVersion) {
539 nWalletVersion = nVersion;
541 if (nVersion > nWalletMaxVersion) {
542 nWalletMaxVersion = nVersion;
546 if (nWalletVersion > 40000) {
558 if (nWalletVersion > nVersion) {
562 nWalletMaxVersion = nVersion;
568 std::set<TxId> result;
571 std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
572 if (it == mapWallet.end()) {
578 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
580 for (
const CTxIn &txin : wtx.
tx->vin) {
581 if (mapTxSpends.count(txin.
prevout) <= 1) {
586 range = mapTxSpends.equal_range(txin.
prevout);
587 for (TxSpends::const_iterator _it = range.first; _it != range.second;
589 result.insert(_it->second);
598 auto iter = mapTxSpends.lower_bound(
COutPoint(txid, 0));
599 return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
611 std::pair<TxSpends::iterator, TxSpends::iterator> range) {
616 int nMinOrderPos = std::numeric_limits<int>::max();
618 for (TxSpends::iterator it = range.first; it != range.second; ++it) {
619 const CWalletTx *wtx = &mapWallet.at(it->second);
631 for (TxSpends::iterator it = range.first; it != range.second; ++it) {
632 const TxId &txid = it->second;
634 if (copyFrom == copyTo) {
640 "Oldest wallet transaction in range assumed to have been found.");
662 std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
663 mapTxSpends.equal_range(outpoint);
665 for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
666 const TxId &wtxid = it->second;
667 std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
668 if (mit != mapWallet.end()) {
670 if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) {
681 mapTxSpends.insert(std::make_pair(outpoint, wtxid));
683 setLockedCoins.erase(outpoint);
685 std::pair<TxSpends::iterator, TxSpends::iterator> range;
686 range = mapTxSpends.equal_range(outpoint);
691 auto it = mapWallet.find(wtxid);
692 assert(it != mapWallet.end());
699 for (
const CTxIn &txin : thisTx.
tx->vin) {
758 delete encrypted_batch;
759 encrypted_batch =
nullptr;
765 auto spk_man = spk_man_pair.second.get();
766 if (!spk_man->Encrypt(_vMasterKey, encrypted_batch)) {
768 delete encrypted_batch;
769 encrypted_batch =
nullptr;
781 delete encrypted_batch;
782 encrypted_batch =
nullptr;
789 delete encrypted_batch;
790 encrypted_batch =
nullptr;
793 Unlock(strWalletPassphrase);
801 if (spk_man->IsHDEnabled()) {
802 if (!spk_man->SetupGeneration(
true)) {
835 for (
auto &entry : mapWallet) {
841 std::vector<int64_t> nOrderPosOffsets;
842 for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
846 if (nOrderPos == -1) {
847 nOrderPos = nOrderPosNext++;
848 nOrderPosOffsets.push_back(nOrderPos);
854 int64_t nOrderPosOff = 0;
855 for (
const int64_t &nOffsetStart : nOrderPosOffsets) {
856 if (nOrderPos >= nOffsetStart) {
861 nOrderPos += nOrderPosOff;
862 nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);
882 int64_t nRet = nOrderPosNext++;
894 for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
895 item.second.MarkDirty();
900 unsigned int n,
bool used,
901 std::set<CTxDestination> &tx_destinations) {
914 tx_destinations.insert(dst);
916 }
else if (!used &&
GetDestData(dst,
"used",
nullptr)) {
937 assert(spk_man !=
nullptr);
938 for (
const auto &keyid :
953 bool fFlushOnClose) {
958 const TxId &txid = tx->GetId();
962 std::set<CTxDestination> tx_destinations;
964 for (
const CTxIn &txin : tx->vin) {
975 mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
976 std::forward_as_tuple(tx));
978 bool fInsertedNew = ret.second;
979 bool fUpdated = update_wtx && update_wtx(wtx, fInsertedNew);
1006 (fInsertedNew ?
"new" :
""), (fUpdated ?
"update" :
""));
1009 if ((fInsertedNew || fUpdated) && !batch.
WriteTx(wtx)) {
1019 #if defined(HAVE_SYSTEM)
1022 std::string strCmd =
gArgs.
GetArg(
"-walletnotify",
"");
1024 if (!strCmd.empty()) {
1035 std::thread t(runCommand, strCmd);
1046 mapWallet.emplace(std::piecewise_construct, std::forward_as_tuple(txid),
1047 std::forward_as_tuple(
nullptr));
1049 if (!fill_wtx(wtx, ins.second)) {
1057 if (
chain().findBlock(
1059 FoundBlock().inActiveChain(active).height(height)) &&
1082 for (
const CTxIn &txin : wtx.
tx->vin) {
1084 if (it != mapWallet.end()) {
1100 const TxId &txid = ptx->GetId();
1103 for (
const CTxIn &txin : ptx->vin) {
1104 std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
1105 range = mapTxSpends.equal_range(txin.
prevout);
1106 while (range.first != range.second) {
1107 if (range.first->second != txid) {
1109 "Transaction %s (in block %s) conflicts with wallet "
1110 "transaction %s (both spend %s:%i)\n",
1112 range.first->second.ToString(),
1113 range.first->first.GetTxId().ToString(),
1114 range.first->first.GetN());
1116 range.first->second);
1123 bool fExisted = mapWallet.count(txid) != 0;
1124 if (fExisted && !fUpdate) {
1137 for (
const CTxOut &txout : ptx->vout) {
1139 spk_man_pair.second->MarkUnusedAddresses(txout.
scriptPubKey);
1160 for (
const CTxIn &txin : tx->vin) {
1162 if (it != mapWallet.end()) {
1163 it->second.MarkDirty();
1173 std::set<TxId> todo;
1174 std::set<TxId> done;
1177 auto it = mapWallet.find(txid);
1178 assert(it != mapWallet.end());
1186 while (!todo.empty()) {
1190 it = mapWallet.find(now);
1191 assert(it != mapWallet.end());
1195 assert(currentconfirm <= 0);
1208 TxSpends::const_iterator iter =
1209 mapTxSpends.lower_bound(
COutPoint(now, 0));
1210 while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
1211 if (!done.count(iter->second)) {
1212 todo.insert(iter->second);
1231 int conflictconfirms =
1232 (m_last_block_processed_height - conflicting_height + 1) * -1;
1237 if (conflictconfirms >= 0) {
1244 std::set<TxId> todo;
1245 std::set<TxId> done;
1249 while (!todo.empty()) {
1253 auto it = mapWallet.find(now);
1254 assert(it != mapWallet.end());
1257 if (conflictconfirms < currentconfirm) {
1268 TxSpends::const_iterator iter =
1269 mapTxSpends.lower_bound(
COutPoint(now, 0));
1270 while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
1271 if (!done.count(iter->second)) {
1272 todo.insert(iter->second);
1298 uint64_t mempool_sequence) {
1304 auto it = mapWallet.find(tx->GetId());
1305 if (it != mapWallet.end()) {
1306 it->second.fInMempool =
true;
1312 uint64_t mempool_sequence) {
1314 auto it = mapWallet.find(tx->GetId());
1315 if (it != mapWallet.end()) {
1316 it->second.fInMempool =
false;
1347 {CWalletTx::Status::UNCONFIRMED, 0,
1356 m_last_block_processed_height = height;
1357 m_last_block_processed = block_hash;
1358 for (
size_t index = 0; index < block.
vtx.size(); index++) {
1360 block_hash, int(index)});
1375 m_last_block_processed_height = height - 1;
1379 {CWalletTx::Status::UNCONFIRMED, 0,
1388 void CWallet::BlockUntilSyncedToCurrentChain()
const {
1403 std::map<TxId, CWalletTx>::const_iterator mi =
1405 if (mi != mapWallet.end()) {
1431 result = std::max(result, spk_man_pair.second->IsMine(script));
1457 throw std::runtime_error(std::string(__func__) +
1458 ": value out of range");
1469 result &= spk_man->IsHDEnabled();
1481 if (spk_man && spk_man->CanGetAddresses(
internal)) {
1488 void CWallet::SetWalletFlag(uint64_t
flags) {
1492 throw std::runtime_error(std::string(__func__) +
1493 ": writing wallet flags failed");
1506 throw std::runtime_error(std::string(__func__) +
1507 ": writing wallet flags failed");
1535 throw std::runtime_error(std::string(__func__) +
1536 ": writing wallet flags failed");
1545 bool use_max_sig)
const {
1550 std::unique_ptr<SigningProvider> provider =
1560 scriptPubKey, sigdata)) {
1571 const std::vector<CTxOut> &txouts,
1572 bool use_max_sig)
const {
1575 for (
const auto &txout : txouts) {
1586 int64_t timestamp) {
1591 LOCK(spk_man->cs_KeyStore);
1592 return spk_man->ImportScripts(scripts, timestamp);
1596 const int64_t timestamp) {
1601 LOCK(spk_man->cs_KeyStore);
1602 return spk_man->ImportPrivKeys(privkey_map, timestamp);
1606 const std::vector<CKeyID> &ordered_pubkeys,
1607 const std::map<CKeyID, CPubKey> &pubkey_map,
1608 const std::map<
CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
1609 const bool add_keypool,
const bool internal,
const int64_t timestamp) {
1614 LOCK(spk_man->cs_KeyStore);
1615 return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins,
1616 add_keypool,
internal, timestamp);
1620 const std::set<CScript> &script_pub_keys,
1621 const bool have_solving_data,
1622 const bool apply_label,
1623 const int64_t timestamp) {
1628 LOCK(spk_man->cs_KeyStore);
1629 if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data,
1635 for (
const CScript &script : script_pub_keys) {
1660 int start_height = 0;
1664 FoundBlock().hash(start_block).height(start_height));
1673 start_block, start_height, {} , reserver, update);
1706 const BlockHash &start_block,
int start_height,
1733 double progress_current = progress_begin;
1734 int block_height = start_height;
1736 if (progress_end - progress_begin > 0.0) {
1738 (progress_end - progress_begin);
1744 if (block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
1746 strprintf(
"%s " +
_(
"Rescanning...").translated,
1753 block_height, progress_current);
1762 bool block_still_active =
false;
1763 bool next_block =
false;
1767 .inActiveChain(block_still_active)
1769 .inActiveChain(next_block)
1770 .hash(next_block_hash)));
1774 if (!block_still_active) {
1781 for (
size_t posInBlock = 0; posInBlock < block.
vtx.size();
1784 block_height, block_hash,
1787 {CWalletTx::Status::CONFIRMED, block_height,
1788 block_hash, int(posInBlock)},
1801 if (max_height && block_height >= *max_height) {
1812 block_hash = next_block_hash;
1817 const BlockHash prev_tip_hash = tip_hash;
1819 if (!max_height && prev_tip_hash != tip_hash) {
1832 block_height, progress_current);
1834 }
else if (block_height &&
chain().shutdownRequested()) {
1836 "Rescan interrupted by shutdown request at block %d. Progress=%f\n",
1837 block_height, progress_current);
1855 std::map<int64_t, CWalletTx *> mapSorted;
1859 for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
1860 const TxId &wtxid = item.first;
1867 mapSorted.insert(std::make_pair(wtx.
nOrderPos, &wtx));
1872 for (
const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
1874 std::string unused_err_string;
1880 std::string &err_string,
1923 std::set<TxId> result;
1943 if (!
chain().isReadyToBroadcast()) {
1960 int submitted_tx_count = 0;
1966 for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
1974 std::string unused_err_string;
1976 ++submitted_tx_count;
1981 if (submitted_tx_count > 0) {
1982 WalletLogPrintf(
"%s: resubmit %u unconfirmed transactions\n", __func__,
1983 submitted_tx_count);
1990 for (
const std::shared_ptr<CWallet> &pwallet :
GetWallets()) {
1991 pwallet->ResendWalletTransactions();
2005 std::map<COutPoint, Coin> coins;
2006 for (
auto &input : tx.
vin) {
2007 auto mi = mapWallet.find(input.prevout.GetTxId());
2008 if (mi == mapWallet.end() ||
2009 input.prevout.GetN() >= mi->second.tx->vout.size()) {
2013 coins[input.prevout] =
2017 std::map<int, std::string> input_errors;
2022 const std::map<COutPoint, Coin> &coins,
2024 std::map<int, std::string> &input_errors)
const {
2029 if (spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
2040 if (legacy_spk_man &&
2041 legacy_spk_man->SignTransaction(tx, coins, sighash, input_errors)) {
2050 bool sign,
bool bip32derivs)
const {
2053 for (
size_t i = 0; i < psbtx.
tx->vin.size(); ++i) {
2054 const CTxIn &txin = psbtx.
tx->vin[i];
2064 const auto it = mapWallet.find(txid);
2065 if (it != mapWallet.end()) {
2077 spk_man->FillPSBT(psbtx, sighash_type, sign, bip32derivs);
2085 for (
const auto &input : psbtx.
inputs) {
2094 std::string &str_sig)
const {
2098 if (spk_man_pair.second->CanProvide(script_pub_key, sigdata)) {
2099 return spk_man_pair.second->SignMessage(message, pkhash, str_sig);
2107 const std::vector<CRecipient> &vecSend)
const {
2110 return *change_type;
2124 std::vector<std::pair<std::string, std::string>> orderForm,
2135 wtx.
mapValue = std::move(mapValue);
2143 for (
const CTxIn &txin : tx->vin) {
2151 CWalletTx &wtx = mapWallet.at(tx->GetId());
2159 std::string err_string;
2161 WalletLogPrintf(
"CommitTransaction(): Transaction cannot be broadcast "
2162 "immediately, %s\n",
2172 fFirstRunRet =
false;
2175 if (
database->Rewrite(
"\x04pool")) {
2177 spk_man_pair.second->RewriteDB();
2193 return nLoadWalletRet;
2200 std::vector<TxId> &txIdsOut) {
2204 for (
const TxId &txid : txIdsOut) {
2205 const auto &it = mapWallet.find(txid);
2206 wtxOrdered.erase(it->second.m_it_wtxOrdered);
2207 for (
const auto &txin : it->second.tx->vin) {
2208 mapTxSpends.erase(txin.prevout);
2210 mapWallet.erase(it);
2215 if (
database->Rewrite(
"\x04pool")) {
2217 spk_man_pair.second->RewriteDB();
2223 return nZapSelectTxRet;
2233 const std::string &strName,
2234 const std::string &strPurpose) {
2235 bool fUpdated =
false;
2239 std::map<CTxDestination, CAddressBookData>::iterator mi =
2240 m_address_book.find(address);
2241 fUpdated = (mi != m_address_book.end() && !mi->second.IsChange());
2242 m_address_book[address].SetLabel(strName);
2244 if (!strPurpose.empty()) {
2245 m_address_book[address].purpose = strPurpose;
2252 if (!strPurpose.empty() && !batch.
WritePurpose(address, strPurpose)) {
2255 return batch.
WriteName(address, strName);
2259 const std::string &strName,
2260 const std::string &strPurpose) {
2279 "%s called with IsMine address, NOT SUPPORTED. Please "
2280 "report this bug! %s\n",
2281 __func__, PACKAGE_BUGREPORT);
2285 for (
const std::pair<const std::string, std::string> &item :
2286 m_address_book[address].destdata) {
2289 m_address_book.erase(address);
2302 unsigned int count = 0;
2304 count += spk_man->KeypoolCountExternalKeys();
2313 unsigned int count = 0;
2315 count += spk_man->GetKeyPoolSize();
2324 res &= spk_man->TopUp(kpSize);
2333 bool result =
false;
2337 result = spk_man->GetNewDestination(type, dest,
error);
2351 std::string &
error) {
2357 error =
_(
"Error: Keypool ran out, please call keypoolrefill first")
2368 int64_t oldestKey = std::numeric_limits<int64_t>::max();
2371 std::min(oldestKey, spk_man_pair.second->GetOldestKeyPoolTime());
2377 const std::set<CTxDestination> &destinations) {
2378 for (
auto &entry : mapWallet) {
2384 for (
size_t i = 0; i < wtx.
tx->vout.size(); i++) {
2388 destinations.count(dst)) {
2396 std::set<CTxDestination>
2399 std::set<CTxDestination> result;
2400 for (
const std::pair<const CTxDestination, CAddressBookData> &item :
2402 if (item.second.IsChange()) {
2406 const std::string &strName = item.second.GetLabel();
2407 if (strName == label) {
2408 result.insert(address);
2455 setLockedCoins.insert(output);
2460 setLockedCoins.erase(output);
2465 setLockedCoins.clear();
2471 return setLockedCoins.count(outpoint) > 0;
2476 for (
COutPoint outpoint : setLockedCoins) {
2477 vOutpts.push_back(outpoint);
2485 mapKeyBirth.clear();
2488 std::map<CKeyID, const CWalletTx::Confirmation *> mapKeyFirstBlock;
2499 assert(spk_man !=
nullptr);
2503 for (
const auto &entry : spk_man->mapKeyMetadata) {
2504 if (entry.second.nCreateTime) {
2505 mapKeyBirth[entry.first] = entry.second.nCreateTime;
2511 if (mapKeyBirth.count(keyid) == 0) {
2512 mapKeyFirstBlock[keyid] = &max_confirm;
2517 if (mapKeyFirstBlock.empty()) {
2522 for (
const auto &entry : mapWallet) {
2527 for (
const CTxOut &txout : wtx.
tx->vout) {
2529 for (
const auto &keyid :
2532 auto rit = mapKeyFirstBlock.find(keyid);
2533 if (rit != mapKeyFirstBlock.end() &&
2535 rit->second->block_height) {
2545 for (
const auto &entry : mapKeyFirstBlock) {
2582 int64_t latestEntry = 0;
2586 int64_t latestTolerated = latestNow + 300;
2588 for (
auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
2598 if (nSmartTime <= latestTolerated) {
2599 latestEntry = nSmartTime;
2600 if (nSmartTime > latestNow) {
2601 latestNow = nSmartTime;
2607 nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
2618 const std::string &key,
const std::string &value) {
2619 if (std::get_if<CNoDestination>(&dest)) {
2623 m_address_book[dest].destdata.insert(std::make_pair(key, value));
2628 const std::string &key) {
2629 if (!m_address_book[dest].destdata.erase(key)) {
2637 const std::string &value) {
2638 m_address_book[dest].destdata.insert(std::make_pair(key, value));
2642 std::string *value)
const {
2643 std::map<CTxDestination, CAddressBookData>::const_iterator i =
2644 m_address_book.find(dest);
2645 if (i != m_address_book.end()) {
2646 CAddressBookData::StringMap::const_iterator j =
2647 i->second.destdata.find(key);
2648 if (j != i->second.destdata.end()) {
2659 std::vector<std::string>
2661 std::vector<std::string> values;
2662 for (
const auto &address : m_address_book) {
2663 for (
const auto &data : address.second.destdata) {
2665 values.emplace_back(data.second);
2672 std::unique_ptr<WalletDatabase>
2683 fs::file_type path_type = fs::symlink_status(wallet_path).type();
2684 if (!(path_type == fs::file_type::not_found ||
2685 path_type == fs::file_type::directory ||
2686 (path_type == fs::file_type::symlink &&
2687 fs::is_directory(wallet_path)) ||
2688 (path_type == fs::file_type::regular &&
2691 strprintf(
"Invalid -wallet path '%s'. -wallet path should point to "
2692 "a directory where wallet.dat and "
2693 "database/log.?????????? files can be stored, a location "
2694 "where such a directory could be created, "
2695 "or (for backwards compatibility) the name of an "
2696 "existing data file in -walletdir (%s)",
2701 return MakeDatabase(wallet_path, options, status, error_string);
2704 std::shared_ptr<CWallet>
2706 std::unique_ptr<WalletDatabase> database,
2708 std::vector<bilingual_str> &warnings) {
2709 const std::string &walletFile =
database->Filename();
2714 bool fFirstRun =
true;
2717 std::shared_ptr<CWallet> walletInstance(
2719 DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
2723 strprintf(
_(
"Error loading %s: Wallet corrupted"), walletFile);
2729 strprintf(
_(
"Error reading %s! All keys read correctly, but "
2730 "transaction data or address book entries might be "
2731 "missing or incorrect."),
2735 _(
"Error loading %s: Wallet requires newer version of %s"),
2736 walletFile, PACKAGE_NAME);
2740 _(
"Wallet needed to be rewritten: restart %s to complete"),
2754 walletInstance->AddWalletFlags(wallet_creation_flags);
2758 walletInstance->SetupLegacyScriptPubKeyMan();
2761 if (!(wallet_creation_flags &
2763 LOCK(walletInstance->cs_wallet);
2765 walletInstance->SetupDescriptorScriptPubKeyMans();
2771 walletInstance->GetActiveScriptPubKeyMans()) {
2772 if (!spk_man->SetupGeneration()) {
2773 error =
_(
"Unable to generate initial keys");
2784 "disabled during creation"),
2787 }
else if (walletInstance->IsWalletFlagSet(
2789 for (
auto spk_man : walletInstance->GetActiveScriptPubKeyMans()) {
2790 if (spk_man->HavePrivateKeys()) {
2792 strprintf(
_(
"Warning: Private keys detected in wallet {%s} "
2793 "with disabled private keys"),
2808 _(
"This is the minimum transaction fee you pay "
2809 "on every transaction."));
2811 walletInstance->m_min_fee =
CFeeRate(n);
2815 const std::string max_aps_fee{
gArgs.
GetArg(
"-maxapsfee",
"")};
2817 if (max_aps_fee ==
"-1") {
2826 _(
"This is the maximum transaction fee you pay (in addition to"
2827 " the normal fee) to prioritize partial spend avoidance over"
2828 " regular coin selection."));
2830 walletInstance->m_max_aps_fee = n;
2837 strprintf(
_(
"Invalid amount for -fallbackfee=<amount>: '%s'"),
2844 _(
"This is the transaction fee you may pay when "
2845 "fee estimates are not available."));
2847 walletInstance->m_fallback_fee =
CFeeRate(nFeePerK);
2850 walletInstance->m_allow_fallback_fee =
2851 walletInstance->m_fallback_fee.GetFeePerK() !=
Amount::zero();
2861 _(
"This is the transaction fee you will pay if "
2862 "you send a transaction."));
2864 walletInstance->m_pay_tx_fee =
CFeeRate(nFeePerK, 1000);
2867 "(must be at least %s)"),
2881 warnings.push_back(
_(
"-maxtxfee is set very high! Fees this large "
2882 "could be paid on a single transaction."));
2886 _(
"Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
2887 "least the minrelay fee of %s to prevent stuck "
2892 walletInstance->m_default_max_tx_fee = nMaxFee;
2898 _(
"The wallet will avoid paying less than the minimum relay fee."));
2901 walletInstance->m_spend_zero_conf_change =
2906 walletInstance->WalletLogPrintf(
"Wallet completed loading in %15dms\n",
2910 walletInstance->TopUpKeyPool();
2912 LOCK(walletInstance->cs_wallet);
2922 walletInstance->m_chain_notifications_handler =
2923 walletInstance->chain().handleNotifications(walletInstance);
2925 int rescan_height = 0;
2930 if (
const std::optional<int> fork_height =
2932 rescan_height = *fork_height;
2939 walletInstance->m_last_block_processed =
2941 walletInstance->m_last_block_processed_height = *tip_height;
2943 walletInstance->m_last_block_processed.
SetNull();
2944 walletInstance->m_last_block_processed_height = -1;
2947 if (tip_height && *tip_height != rescan_height) {
2956 int block_height = *tip_height;
2957 while (block_height > 0 &&
2959 rescan_height != block_height) {
2963 if (rescan_height != block_height) {
2964 error =
_(
"Prune: last wallet synchronisation goes beyond "
2965 "pruned data. You need to -reindex (download the "
2966 "whole blockchain again in case of pruned node)");
2972 walletInstance->WalletLogPrintf(
2973 "Rescanning last %i blocks (from block %i)...\n",
2974 *tip_height - rescan_height, rescan_height);
2978 std::optional<int64_t> time_first_key;
2979 for (
auto spk_man : walletInstance->GetAllScriptPubKeyMans()) {
2980 int64_t time = spk_man->GetTimeFirstKey();
2981 if (!time_first_key || time < *time_first_key) {
2982 time_first_key = time;
2985 if (time_first_key) {
2996 ->ScanForWalletTransactions(
2998 {} , reserver,
true )
3000 error =
_(
"Failed to rescan the wallet during initialization");
3005 walletInstance->database->IncrementUpdateCounter();
3010 for (
auto &load_wallet : g_load_wallet_fns) {
3015 walletInstance->SetBroadcastTransactions(
3018 walletInstance->WalletLogPrintf(
"setKeyPool.size() = %u\n",
3019 walletInstance->GetKeyPoolSize());
3020 walletInstance->WalletLogPrintf(
"mapWallet.size() = %u\n",
3021 walletInstance->mapWallet.size());
3022 walletInstance->WalletLogPrintf(
"m_address_book.size() = %u\n",
3023 walletInstance->m_address_book.size());
3025 return walletInstance;
3030 bool allow_change)
const {
3031 const auto &address_book_it = m_address_book.find(dest);
3032 if (address_book_it == m_address_book.end()) {
3035 if ((!allow_change) && address_book_it->second.IsChange()) {
3038 return &address_book_it->second;
3043 int nMaxVersion = version;
3045 if (nMaxVersion == 0) {
3055 error =
_(
"Cannot downgrade wallet");
3069 error =
_(
"Cannot upgrade a non HD split wallet without upgrading to "
3070 "support pre split keypool. Please use version 200300 or no "
3071 "version specified.");
3076 if (!spk_man->Upgrade(prev_version,
error)) {
3130 assert(chain_depth >= 0);
3150 return vMasterKey.empty();
3160 if (!vMasterKey.empty()) {
3163 sizeof(decltype(vMasterKey)::value_type));
3176 if (!spk_man_pair.second->CheckDecryptionKey(vMasterKeyIn,
3181 vMasterKey = vMasterKeyIn;
3188 std::set<ScriptPubKeyMan *> spk_mans;
3189 for (
bool internal : {
false,
true}) {
3193 spk_mans.insert(spk_man);
3201 std::set<ScriptPubKeyMan *> spk_mans;
3203 spk_mans.insert(spk_man_pair.second.get());
3209 bool internal)
const {
3210 const std::map<OutputType, ScriptPubKeyMan *> &spk_managers =
3212 std::map<OutputType, ScriptPubKeyMan *>::const_iterator it =
3213 spk_managers.find(type);
3214 if (it == spk_managers.end()) {
3216 "%s scriptPubKey Manager for output type %d does not exist\n",
3217 internal ?
"Internal" :
"External",
static_cast<int>(type));
3223 std::set<ScriptPubKeyMan *>
3226 std::set<ScriptPubKeyMan *> spk_mans;
3228 if (spk_man_pair.second->CanProvide(script, sigdata)) {
3229 spk_mans.insert(spk_man_pair.second.get());
3238 if (spk_man_pair.second->CanProvide(script, sigdata)) {
3239 return spk_man_pair.second.get();
3252 std::unique_ptr<SigningProvider>
3258 std::unique_ptr<SigningProvider>
3262 if (spk_man_pair.second->CanProvide(script, sigdata)) {
3263 return spk_man_pair.second->GetSolvingProvider(script);
3314 spk_man->NotifyCanGetAddressesChanged.connect(
3321 auto spk_manager = std::unique_ptr<ScriptPubKeyMan>(
3339 for (
bool internal : {
false,
true}) {
3342 std::make_unique<DescriptorScriptPubKeyMan>(*
this,
internal);
3345 throw std::runtime_error(
3346 std::string(__func__) +
3347 ": Wallet is locked, cannot setup new descriptors");
3349 if (!spk_manager->CheckDecryptionKey(vMasterKey) &&
3350 !spk_manager->Encrypt(vMasterKey,
nullptr)) {
3351 throw std::runtime_error(
3352 std::string(__func__) +
3353 ": Could not encrypt new descriptors");
3356 spk_manager->SetupDescriptorGeneration(master_key, t);
3357 uint256 id = spk_manager->GetID();
3369 throw std::runtime_error(std::string(__func__) +
3370 ": writing active ScriptPubKeyMan id failed");
3384 "Setting spkMan to active: id = %s, type = %d, internal = %d\n",
3385 id.
ToString(),
static_cast<int>(type),
static_cast<int>(
internal));
3388 auto &spk_mans_other =
3391 spk_man->SetInternal(
internal);
3392 spk_mans[type] = spk_man;
3394 const auto it = spk_mans_other.find(type);
3395 if (it != spk_mans_other.end() && it->second == spk_man) {
3396 spk_mans_other.erase(type);
3405 if (spk_man !=
nullptr && spk_man->GetID() ==
id) {
3407 "Deactivate spkMan: id = %s, type = %d, internal = %d\n",
3408 id.
ToString(),
static_cast<int>(type),
static_cast<int>(
internal));
3412 throw std::runtime_error(
3413 std::string(__func__) +
3414 ": erasing active ScriptPubKeyMan id failed");
3419 spk_mans.erase(type);
3431 return spk_man !=
nullptr;
3441 spk_man_pair.second.get());
3453 const std::string &label,
bool internal) {
3458 "Cannot add WalletDescriptor to a non-descriptor wallet\n");
3466 spk_man->UpdateWalletDescriptor(desc);
3469 std::make_unique<DescriptorScriptPubKeyMan>(*
this, desc);
3470 spk_man = new_spk_man.get();
3477 for (
const auto &entry : signing_provider.
keys) {
3478 const CKey &key = entry.second;
3479 spk_man->AddDescriptorKey(key, key.
GetPubKey());
3483 if (!spk_man->TopUp()) {
3491 auto script_pub_keys = spk_man->GetScriptPubKeys();
3492 if (script_pub_keys.empty()) {
3494 "Could not generate scriptPubKeys (cache is empty)\n");
3505 spk_man->WriteDescriptor();
bool MoneyRange(const Amount nValue)
static constexpr Amount SATOSHI
static constexpr int64_t TIMESTAMP_WINDOW
Timestamp window used as a grace period by code that compares external timestamps (such as timestamps...
const CChainParams & Params()
Return the currently selected parameters.
#define CHECK_NONFATAL(condition)
Identity function.
#define Assert(val)
Identity function.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
std::vector< CTransactionRef > vtx
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Encryption/decryption context with key information.
bool Encrypt(const CKeyingMaterial &vchPlaintext, std::vector< uint8_t > &vchCiphertext) const
bool SetKeyFromPassphrase(const SecureString &strKeyData, const std::vector< uint8_t > &chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod)
bool Decrypt(const std::vector< uint8_t > &vchCiphertext, CKeyingMaterial &vchPlaintext) const
Fee rate in satoshis per kilobyte: Amount / kB.
std::string ToString() const
Amount GetFeePerK() const
Return the fee in satoshis for a size of 1000 bytes.
An encapsulated secp256k1 private key.
const uint8_t * begin() const
unsigned int size() const
Simple read-only vector-like interface.
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
CPubKey GetPubKey() const
Compute the public key from a private key.
bool VerifyPubKey(const CPubKey &vchPubKey) const
Verify thoroughly whether a private key and a public key match.
A reference to a CKey: the Hash160 of its serialized public key.
A key from a CWallet's keypool.
bool fInternal
Whether this keypool entry is in the internal keypool (for change outputs)
CPubKey vchPubKey
The public key.
int64_t nTime
The time at which the key was generated. Set in AddKeypoolPubKeyWithDB.
bool m_pre_split
Whether this key was generated for a keypool before the wallet was upgraded to HD-split.
Private key encryption is done based on a CMasterKey, which holds a salt and random encryption key.
std::vector< uint8_t > vchSalt
unsigned int nDerivationMethod
0 = EVP_sha512() 1 = scrypt()
unsigned int nDeriveIterations
std::vector< uint8_t > vchCryptedKey
A mutable version of CTransaction.
An outpoint - a combination of a transaction hash and an index n into its vout.
const TxId & GetTxId() const
An encapsulated public key.
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
const std::vector< CTxIn > vin
An input of a transaction.
An output of a transaction.
A CWallet maintains a set of transactions and balances, and provides the ability to create new transa...
std::unique_ptr< SigningProvider > GetSolvingProvider(const CScript &script) const
Get the SigningProvider for a script.
std::atomic< int64_t > m_best_block_time
BlockHash GetLastBlockHash() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
std::set< ScriptPubKeyMan * > GetScriptPubKeyMans(const CScript &script, SignatureData &sigdata) const
Get all of the ScriptPubKeyMans for a script given additional information in sigdata (populated by e....
bool HaveChain() const
Interface to assert chain access.
int GetTxBlocksToMaturity(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool DummySignTx(CMutableTransaction &txNew, const std::set< CTxOut > &txouts, bool use_max_sig=false) const
void ConnectScriptPubKeyManNotifiers()
Connect the signals from ScriptPubKeyMans to the signals in CWallet.
void AddActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Adds the active ScriptPubKeyMan for the specified type and internal.
void SetupLegacyScriptPubKeyMan()
Make a LegacyScriptPubKeyMan and set it for all types, internal, and external.
bool AddDestData(WalletBatch &batch, const CTxDestination &dest, const std::string &key, const std::string &value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Adds a destination data tuple to the store, and saves it to disk When adding new fields,...
boost::signals2::signal< void()> NotifyCanGetAddressesChanged
Keypool has new keys.
const std::string GetDisplayName() const override
Returns a bracketed wallet name for displaying in logs, will return [default wallet] if the wallet ha...
MasterKeyMap mapMasterKeys
const std::string & GetName() const
Get a name for this wallet for logging/debugging purposes.
int GetTxDepthInMainChain(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Return depth of transaction in blockchain: <0 : conflicts with a transaction this deep in the blockch...
bool IsTxImmatureCoinBase(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
boost::signals2::signal< void(const std::string &title, int nProgress)> ShowProgress
Show progress e.g.
bool Unlock(const CKeyingMaterial &vMasterKeyIn, bool accept_no_keys=false)
bool GetBroadcastTransactions() const
Inquire whether this wallet broadcasts transactions.
void WalletLogPrintf(std::string fmt, Params... parameters) const
Prepends the wallet name in logging output to ease debugging in multi-wallet use cases.
void SetupDescriptorScriptPubKeyMans() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Create new DescriptorScriptPubKeyMans and add them to the wallet.
interfaces::Chain * m_chain
Interface for accessing chain state.
LegacyScriptPubKeyMan * GetOrCreateLegacyScriptPubKeyMan()
std::map< OutputType, ScriptPubKeyMan * > m_external_spk_managers
WalletDatabase & GetDatabase() override
void DeactivateScriptPubKeyMan(const uint256 &id, OutputType type, bool internal)
Remove specified ScriptPubKeyMan from set of active SPK managers.
bool GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Look up a destination data tuple in the store, return true if found false otherwise.
bool IsLegacy() const
Determine if we are a legacy wallet.
interfaces::Chain & chain() const
Interface for accessing chain state.
std::atomic< bool > fAbortRescan
std::map< uint256, std::unique_ptr< ScriptPubKeyMan > > m_spk_managers
void LoadActiveScriptPubKeyMan(uint256 id, OutputType type, bool internal)
Loads an active ScriptPubKeyMan for the specified type and internal.
static std::shared_ptr< CWallet > Create(interfaces::Chain &chain, const std::string &name, std::unique_ptr< WalletDatabase > database, uint64_t wallet_creation_flags, bilingual_str &error, std::vector< bilingual_str > &warnings)
Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error.
boost::signals2::signal< void(CWallet *wallet, const CTxDestination &address, const std::string &label, bool isMine, const std::string &purpose, ChangeType status)> NotifyAddressBookChanged
Address book entry changed.
int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get last block processed height.
boost::signals2::signal< void(CWallet *wallet)> NotifyStatusChanged
Wallet status (encrypted, locked) changed.
OutputType m_default_address_type
DescriptorScriptPubKeyMan * GetDescriptorScriptPubKeyMan(const WalletDescriptor &desc) const
Return the DescriptorScriptPubKeyMan for a WalletDescriptor if it is already in the wallet.
void LoadDescriptorScriptPubKeyMan(uint256 id, WalletDescriptor &desc)
Instantiate a descriptor ScriptPubKeyMan from the WalletDescriptor and load it.
LegacyScriptPubKeyMan * GetLegacyScriptPubKeyMan() const
Get the LegacyScriptPubKeyMan which is used for all types, internal, and external.
std::atomic< uint64_t > m_wallet_flags
bool CanSupportFeature(enum WalletFeature wf) const override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
check whether we are allowed to upgrade (or already support) to the named feature
bool BackupWallet(const std::string &strDest) const
unsigned int ComputeTimeSmart(const CWalletTx &wtx) const
Compute smart timestamp for a transaction being added to the wallet.
void WalletLogPrintfToBeContinued(std::string fmt, Params... parameters) const
std::unique_ptr< WalletDatabase > database
Internal database handle.
ScriptPubKeyMan * AddWalletDescriptor(WalletDescriptor &desc, const FlatSigningProvider &signing_provider, const std::string &label, bool internal) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Add a descriptor to the wallet, return a ScriptPubKeyMan & associated output type.
std::set< ScriptPubKeyMan * > GetActiveScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans in m_internal_spk_managers and m_external_spk_managers.
std::vector< std::string > GetDestValues(const std::string &prefix) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get all destination values matching a prefix.
boost::signals2::signal< void(bool fHaveWatchOnly)> NotifyWatchonlyChanged
Watch-only address added.
bool IsLocked() const override
std::map< OutputType, ScriptPubKeyMan * > m_internal_spk_managers
std::atomic< double > m_scanning_progress
int GetVersion() const
get the current wallet format (the oldest client version guaranteed to understand this wallet)
void GetKeyBirthTimes(std::map< CKeyID, int64_t > &mapKeyBirth) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool EraseDestData(WalletBatch &batch, const CTxDestination &dest, const std::string &key) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Erases a destination data tuple in the store and on disk.
boost::signals2::signal< void(CWallet *wallet, const TxId &txid, ChangeType status)> NotifyTransactionChanged
Wallet transaction added, removed or updated.
bool HasEncryptionKeys() const override
CWallet(interfaces::Chain *chain, const std::string &name, std::unique_ptr< WalletDatabase > _database)
Construct wallet with specified name and database implementation.
Amount m_default_max_tx_fee
Absolute maximum transaction fee (in satoshis) used by default for the wallet.
bool UpgradeWallet(int version, bilingual_str &error)
Upgrade the wallet.
bool fBroadcastTransactions
ScriptPubKeyMan * GetScriptPubKeyMan(const OutputType &type, bool internal) const
Get the ScriptPubKeyMan for the given OutputType and internal/external chain.
std::set< ScriptPubKeyMan * > GetAllScriptPubKeyMans() const
Returns all unique ScriptPubKeyMans.
std::multimap< int64_t, CWalletTx * > TxItems
void LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Adds a destination data tuple to the store, without saving it to disk.
unsigned int nMasterKeyMaxID
std::function< bool(CWalletTx &wtx, bool new_tx)> UpdateWalletTxFn
Callback for updating transaction metadata in mapWallet.
void postInitProcess()
Wallet post-init setup Gives the wallet a chance to register repetitive tasks and complete post-init ...
const CAddressBookData * FindAddressBookEntry(const CTxDestination &, bool allow_change=false) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
const CKeyingMaterial & GetEncryptionKey() const override
A transaction with a bunch of additional info that only the owner cares about.
mapValue_t mapValue
Key/value map with information about the transaction.
bool isUnconfirmed() const
unsigned int nTimeSmart
Stable timestamp that never changes, and reflects the order a transaction was added to the wallet.
std::multimap< int64_t, CWalletTx * >::const_iterator m_it_wtxOrdered
bool IsEquivalentTo(const CWalletTx &tx) const
bool isConflicted() const
std::vector< std::pair< std::string, std::string > > vOrderForm
bool fFromMe
From me flag is set to 1 for transactions that were created by the wallet on this bitcoin node,...
unsigned int fTimeReceivedIsTxTime
void MarkDirty()
make sure balances are recalculated
bool m_is_cache_empty
This flag is true if all m_amounts caches are empty.
unsigned int nTimeReceived
time received by this node
int64_t nOrderPos
position in ordered transaction list
bool HasWalletDescriptor(const WalletDescriptor &desc) const
RecursiveMutex cs_KeyStore
Different type to mark Mutex at global scope.
std::set< CKeyID > GetKeys() const override
A wrapper to reserve an address from a wallet.
bool fInternal
Whether this is from the internal (change output) keypool.
ScriptPubKeyMan * m_spk_man
The ScriptPubKeyMan to reserve from.
int64_t nIndex
The index of the address's key in the keypool.
CTxDestination address
The destination.
const CWallet *const pwallet
The wallet to reserve from.
A class implementing ScriptPubKeyMan manages some (or all) scriptPubKeys used in a wallet.
virtual bool TopUp(unsigned int size=0)
Fills internal address pool.
virtual bool GetReservedDestination(const OutputType type, bool internal, CTxDestination &address, int64_t &index, CKeyPool &keypool)
virtual void KeepDestination(int64_t index, const OutputType &type)
virtual void ReturnDestination(int64_t index, bool internal, const CTxDestination &addr)
Signature hash type wrapper class.
const std::vector< UniValue > & getValues() const
bool push_back(const UniValue &val)
Access to the wallet database.
bool TxnCommit()
Commit current transaction.
bool WriteActiveScriptPubKeyMan(uint8_t type, const uint256 &id, bool internal)
bool WriteMasterKey(unsigned int nID, const CMasterKey &kMasterKey)
bool WriteName(const CTxDestination &address, const std::string &strName)
bool WritePurpose(const CTxDestination &address, const std::string &purpose)
bool WriteMinVersion(int nVersion)
bool ErasePurpose(const CTxDestination &address)
bool EraseDestData(const CTxDestination &address, const std::string &key)
Erase destination data tuple from wallet database.
bool WriteWalletFlags(const uint64_t flags)
bool ReadBestBlock(CBlockLocator &locator)
bool WriteOrderPosNext(int64_t nOrderPosNext)
bool EraseActiveScriptPubKeyMan(uint8_t type, bool internal)
bool WriteTx(const CWalletTx &wtx)
bool TxnBegin()
Begin a new transaction.
bool TxnAbort()
Abort current transaction.
bool EraseName(const CTxDestination &address)
bool WriteBestBlock(const CBlockLocator &locator)
DBErrors ZapSelectTx(std::vector< TxId > &txIdsIn, std::vector< TxId > &txIdsOut)
DBErrors LoadWallet(CWallet *pwallet)
bool WriteDestData(const CTxDestination &address, const std::string &key, const std::string &value)
Write destination data key,value tuple to database.
Descriptor with some wallet metadata.
std::shared_ptr< Descriptor > descriptor
RAII object to check and reserve a wallet rescan.
std::string ToString() const
std::string GetHex() const
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
virtual CBlockLocator getTipLocator()=0
Get locator for the current chain tip.
virtual BlockHash getBlockHash(int height)=0
Get block hash. Height must be valid or this function will abort.
virtual bool findBlock(const BlockHash &hash, const FoundBlock &block={})=0
Return whether node has the block and optionally return block metadata or contents.
virtual bool updateRwSetting(const std::string &name, const util::SettingsValue &value, bool write=true)=0
Write a setting to <datadir>/settings.json.
virtual bool findFirstBlockWithTimeAndHeight(int64_t min_time, int min_height, const FoundBlock &block={})=0
Find first block in the chain with timestamp >= the given time and height >= than the given height,...
virtual bool broadcastTransaction(const Config &config, const CTransactionRef &tx, const Amount &max_tx_fee, bool relay, std::string &err_string)=0
Transaction is added to memory pool, if the transaction fee is below the amount specified by max_tx_f...
virtual util::SettingsValue getRwSetting(const std::string &name)=0
Return <datadir>/settings.json setting value.
virtual double guessVerificationProgress(const BlockHash &block_hash)=0
Estimate fraction of total transactions verified if blocks up to the specified block hash are verifie...
virtual bool havePruned()=0
Check if any block has been pruned.
virtual std::optional< int > getHeight()=0
Get current chain height, not including genesis block (returns 0 if chain only contains genesis block...
virtual std::optional< int > findLocatorFork(const CBlockLocator &locator)=0
Return height of the highest block on chain in common with the locator, which will either be the orig...
virtual bool findAncestorByHeight(const BlockHash &block_hash, int ancestor_height, const FoundBlock &ancestor_out={})=0
Find ancestor of block at specified height and optionally return ancestor information.
virtual void initMessage(const std::string &message)=0
Send init message.
virtual bool haveBlockOnDisk(int height)=0
Check that the block is available on disk (i.e.
virtual void requestMempoolTransactions(Notifications ¬ifications)=0
Synchronously send transactionAddedToMempool notifications about all current mempool transactions to ...
virtual void waitForNotificationsIfTipChanged(const BlockHash &old_tip)=0
Wait for pending notifications to be processed unless block hash points to the current chain tip.
virtual CFeeRate relayMinFee()=0
Relay current minimum fee (from -minrelaytxfee settings).
virtual const CChainParams & params() const =0
This Chain's parameters.
Helper for findBlock to selectively return pieces of block data.
void memory_cleanse(void *ptr, size_t len)
Secure overwrite a buffer (possibly containing secret data) with zero-bytes.
const Config & GetConfig()
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule).
const unsigned int WALLET_CRYPTO_SALT_SIZE
std::vector< uint8_t, secure_allocator< uint8_t > > CKeyingMaterial
const unsigned int WALLET_CRYPTO_KEY_SIZE
bilingual_str AmountHighWarn(const std::string &optname)
bilingual_str AmountErrMsg(const std::string &optname, const std::string &strValue)
void LockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void MarkDestinationsDirty(const std::set< CTxDestination > &destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Marks all outputs in each one of the destinations dirty, so their cache is reset and does not return ...
size_t KeypoolCountExternalKeys() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector< std::pair< std::string, std::string >> orderForm, bool broadcast=true)
Add the transaction to the wallet and maybe attempt to broadcast it.
void KeepDestination()
Keep the address.
void ListLockedCoins(std::vector< COutPoint > &vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
std::set< CTxDestination > GetLabelAddresses(const std::string &label) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool IsLockedCoin(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
SigningResult SignMessage(const std::string &message, const PKHash &pkhash, std::string &str_sig) const
void UnlockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool SetAddressBook(const CTxDestination &address, const std::string &strName, const std::string &purpose)
DBErrors LoadWallet(bool &fFirstRunRet)
OutputType TransactionChangeType(const std::optional< OutputType > &change_type, const std::vector< CRecipient > &vecSend) const
bool SignTransaction(CMutableTransaction &tx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void ReturnDestination()
Return reserved address.
bool GetNewChangeDestination(const OutputType type, CTxDestination &dest, std::string &error)
void UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool TopUpKeyPool(unsigned int kpSize=0)
bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address, const std::string &strName, const std::string &strPurpose)
TransactionError FillPSBT(PartiallySignedTransaction &psbtx, bool &complete, SigHashType sighash_type=SigHashType().withForkId(), bool sign=true, bool bip32derivs=true) const
Fills out a PSBT with information from the wallet.
bool GetReservedDestination(CTxDestination &pubkey, bool internal)
Reserve an address.
int64_t GetOldestKeyPoolTime() const
bool DelAddressBook(const CTxDestination &address)
bool GetNewDestination(const OutputType type, const std::string label, CTxDestination &dest, std::string &error)
DBErrors ZapSelectTx(std::vector< TxId > &txIdsIn, std::vector< TxId > &txIdsOut) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool AddWalletFlags(uint64_t flags)
Overwrite all flags by the given uint64_t.
void blockConnected(const CBlock &block, int height) override
bool LoadToWallet(const TxId &txid, const UpdateWalletTxFn &fill_wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void MarkConflicted(const BlockHash &hashBlock, int conflicting_height, const TxId &txid)
Mark a transaction (and its in-wallet descendants) as conflicting with a particular block.
void Flush()
Flush wallet (bitdb flush)
void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Upgrade stored CKeyMetadata objects to store key origin info as KeyOriginInfo.
bool SetMaxVersion(int nVersion)
change which version we're allowed to upgrade to (note that this does not immediately imply upgrading...
bool ImportPubKeys(const std::vector< CKeyID > &ordered_pubkeys, const std::map< CKeyID, CPubKey > &pubkey_map, const std::map< CKeyID, std::pair< CPubKey, KeyOriginInfo >> &key_origins, const bool add_keypool, const bool internal, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
std::set< TxId > GetConflicts(const TxId &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Get wallet transactions that conflict with given transaction (spend same outputs)
bool SubmitTxMemoryPoolAndRelay(const CWalletTx &wtx, std::string &err_string, bool relay) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Pass this transaction to node for mempool insertion and relay to peers if flag set to true.
void AddToSpends(const COutPoint &outpoint, const TxId &wtxid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void SyncTransaction(const CTransactionRef &tx, CWalletTx::Confirmation confirm, bool update_tx=true) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Used by TransactionAddedToMemorypool/BlockConnected/Disconnected/ScanForWalletTransactions.
bool ImportScripts(const std::set< CScript > scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
CWalletTx * AddToWallet(CTransactionRef tx, const CWalletTx::Confirmation &confirm, const UpdateWalletTxFn &update_wtx=nullptr, bool fFlushOnClose=true)
bool HasWalletSpend(const TxId &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Check if a given transaction has any of its outputs spent by another transaction in the wallet.
bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase, const SecureString &strNewWalletPassphrase)
bool IsFromMe(const CTransaction &tx) const
should probably be renamed to IsRelevantToMe
bool ImportPrivKeys(const std::map< CKeyID, CKey > &privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
isminetype IsMine(const CTxDestination &dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool LoadWalletFlags(uint64_t flags)
Loads the flags into the wallet.
bool ImportScriptPubKeys(const std::string &label, const std::set< CScript > &script_pub_keys, const bool have_solving_data, const bool apply_label, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool CanGetAddresses(bool internal=false) const
Returns true if the wallet can give out new addresses.
ScanResult ScanForWalletTransactions(const BlockHash &start_block, int start_height, std::optional< int > max_height, const WalletRescanReserver &reserver, bool fUpdate)
Scan the block chain (starting in start_block) for transactions from or to us.
bool IsSpentKey(const TxId &txid, unsigned int n) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool TransactionCanBeAbandoned(const TxId &txid) const
Return whether transaction can be abandoned.
const CChainParams & GetChainParams() const override
Amount GetDebit(const CTxIn &txin, const isminefilter &filter) const
Returns amount of debit if the input matches the filter, otherwise returns 0.
void MarkInputsDirty(const CTransactionRef &tx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Mark a transaction's inputs dirty, thus forcing the outputs to be recomputed.
bool AddToWalletIfInvolvingMe(const CTransactionRef &tx, CWalletTx::Confirmation confirm, bool fUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Add a transaction to the wallet, or update it.
bool IsSpent(const COutPoint &outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Outpoint is spent if any non-conflicted transaction, spends it:
void ReacceptWalletTransactions() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag)
Unsets a wallet flag and saves it to disk.
void SyncMetaData(std::pair< TxSpends::iterator, TxSpends::iterator >) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool EncryptWallet(const SecureString &strWalletPassphrase)
void updatedBlockTip() override
void UnsetWalletFlag(uint64_t flag)
Unsets a single wallet flag.
void transactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) override
bool IsWalletFlagSet(uint64_t flag) const override
Check if a certain wallet flag is set.
int64_t RescanFromTime(int64_t startTime, const WalletRescanReserver &reserver, bool update)
Scan active chain for relevant transactions after importing keys.
bool AbandonTransaction(const TxId &txid)
Mark a transaction (and it in-wallet descendants) as abandoned so its inputs may be respent.
void UnsetBlankWalletFlag(WalletBatch &batch) override
Unset the blank wallet flag and saves it to disk.
void SetSpentKeyState(WalletBatch &batch, const TxId &txid, unsigned int n, bool used, std::set< CTxDestination > &tx_destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void transactionAddedToMempool(const CTransactionRef &tx, uint64_t mempool_sequence) override
DBErrors ReorderTransactions()
void blockDisconnected(const CBlock &block, int height) override
void Close()
Close wallet database.
int64_t IncOrderPosNext(WalletBatch *batch=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
Increment the next transaction order id.
const CWalletTx * GetWalletTx(const TxId &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
void ResendWalletTransactions()
void SetMinVersion(enum WalletFeature, WalletBatch *batch_in=nullptr, bool fExplicit=false) override
signify that a particular wallet feature is now used.
std::set< TxId > GetTxConflicts(const CWalletTx &wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
bool DummySignInput(CTxIn &tx_in, const CTxOut &txout, bool use_max_sig=false) const
void chainStateFlushed(const CBlockLocator &loc) override
isminetype
IsMine() return codes.
@ PRIVATE_KEY_NOT_AVAILABLE
bool ParseMoney(const std::string &money_string, Amount &nRet)
Parse an amount denoted in full coins.
static auto quoted(const std::string &s)
static std::string PathToString(const path &path)
Convert path object to byte string.
static path PathFromString(const std::string &string)
Convert byte string to path object.
fs::path AbsPathJoin(const fs::path &base, const fs::path &path)
Helper function for joining two paths.
std::unique_ptr< Wallet > MakeWallet(const std::shared_ptr< CWallet > &wallet)
Return implementation of Wallet interface.
std::unique_ptr< Handler > MakeHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
const std::string & FormatOutputType(OutputType type)
const std::array< OutputType, 1 > OUTPUT_TYPES
std::shared_ptr< const CTransaction > CTransactionRef
bool PSBTInputSigned(const PSBTInput &input)
Checks whether a PSBTInput is already signed.
void GetStrongRandBytes(Span< uint8_t > bytes) noexcept
Gather entropy from various sources, feed it into the internal PRNG, and generate random data using i...
T GetRand(T nMax=std::numeric_limits< T >::max()) noexcept
Generate a uniform random integer of type T in the range [0..nMax) nMax defaults to std::numeric_limi...
std::vector< CKeyID > GetAffectedKeys(const CScript &spk, const SigningProvider &provider)
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
void UpdateInput(CTxIn &input, const SignatureData &data)
const BaseSignatureCreator & DUMMY_MAXIMUM_SIGNATURE_CREATOR
A signature creator that just produces 72-byte empty signatures.
const BaseSignatureCreator & DUMMY_SIGNATURE_CREATOR
A signature creator that just produces 71-byte empty signatures.
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a standard scriptPubKey for the destination address.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PKHash, ScriptHash > CTxDestination
A txout script template with a specific destination.
void ReplaceAll(std::string &in_out, const std::string &search, const std::string &substitute)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
static constexpr Amount zero() noexcept
A BlockHash is a unqiue identifier for a block.
Describes a place in the block chain to another node such that if the other node doesn't have the sam...
void SetSeed(const uint8_t *seed, unsigned int nSeedLen)
std::optional< int > last_scanned_height
BlockHash last_scanned_block
Hash and height of most recent block that was successfully scanned.
enum CWallet::ScanResult::@20 status
BlockHash last_failed_block
Hash of the most recent block that could not be scanned due to read errors or pruning.
Confirmation includes tx status and a triplet of {block height/block hash/tx index in block} at which...
SecureString create_passphrase
std::map< CKeyID, CKey > keys
A version of CTransaction with the PSBT format.
std::vector< PSBTInput > inputs
std::optional< CMutableTransaction > tx
A TxId is the identifier of a transaction.
#define WAIT_LOCK(cs, name)
#define AssertLockNotHeld(cs)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
std::string ShellEscape(const std::string &arg)
bool error(const char *fmt, const Args &...args)
int64_t GetTimeMillis()
Returns the system time (not mockable)
bilingual_str _(const char *psz)
Translation function.
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
@ BLOCK
Removed for block.
@ CONFLICT
Removed for conflict with in-block transaction.
std::unique_ptr< WalletDatabase > MakeDatabase(const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error)
std::map< std::string, std::string > mapValue_t
constexpr Amount HIGH_TX_FEE_PER_KB
Discourage users to set fees higher than this amount (in satoshis) per kB.
std::function< void(std::unique_ptr< interfaces::Wallet > wallet)> LoadWalletFn
constexpr OutputType DEFAULT_ADDRESS_TYPE
Default for -addresstype.
constexpr Amount HIGH_MAX_TX_FEE
-maxtxfee will warn if called with a higher fee than this amount (in satoshis)
static const bool DEFAULT_SPEND_ZEROCONF_CHANGE
Default for -spendzeroconfchange.
static constexpr uint64_t KNOWN_WALLET_FLAGS
static const bool DEFAULT_WALLETBROADCAST
constexpr Amount HIGH_APS_FEE
discourage APS fee higher than this amount
std::shared_ptr< CWallet > LoadWallet(interfaces::Chain &chain, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
std::unique_ptr< interfaces::Handler > HandleLoadWallet(LoadWalletFn load_wallet)
bool RemoveWallet(const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings)
static void ReleaseWallet(CWallet *wallet)
const std::map< uint64_t, std::string > WALLET_FLAG_CAVEATS
void MaybeResendWalletTxs()
Called periodically by the schedule thread.
static std::vector< std::shared_ptr< CWallet > > vpwallets GUARDED_BY(cs_wallets)
std::shared_ptr< CWallet > GetWallet(const std::string &name)
std::shared_ptr< CWallet > CreateWallet(interfaces::Chain &chain, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
void UnloadWallet(std::shared_ptr< CWallet > &&wallet)
Explicitly unload and delete the wallet.
static std::condition_variable g_wallet_release_cv
std::unique_ptr< WalletDatabase > MakeWalletDatabase(const std::string &name, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error_string)
static GlobalMutex g_loading_wallet_mutex
RecursiveMutex cs_wallets
bool AddWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Add wallet name to persistent configuration so it will be loaded on startup.
bool RemoveWalletSetting(interfaces::Chain &chain, const std::string &wallet_name)
Remove wallet name from persistent configuration so it will not be loaded on startup.
static void UpdateWalletSetting(interfaces::Chain &chain, const std::string &wallet_name, std::optional< bool > load_on_startup, std::vector< bilingual_str > &warnings)
std::vector< std::shared_ptr< CWallet > > GetWallets()
static GlobalMutex g_wallet_release_mutex
bool AddWallet(const std::shared_ptr< CWallet > &wallet)
DBErrors
Error statuses for the wallet database.
fs::path GetWalletDir()
Get the path of the wallet directory.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
@ WALLET_FLAG_AVOID_REUSE
@ WALLET_FLAG_KEY_ORIGIN_METADATA
@ WALLET_FLAG_DESCRIPTORS
Indicate that this wallet supports DescriptorScriptPubKeyMan.
@ WALLET_FLAG_BLANK_WALLET
Flag set when a wallet contains no HD seed and no private keys, scripts, addresses,...
WalletFeature
(client) version numbers for particular wallet features
@ FEATURE_PRE_SPLIT_KEYPOOL