63 for (
const auto& txin : wtx.tx->vin) {
69 for (
const auto& txout : wtx.tx->vout) {
80 result.
time = wtx.GetTxTime();
94 wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height :
95 wtx.state<TxStateBlockConflicted>() ? wtx.state<TxStateBlockConflicted>()->conflicting_block_height :
96 std::numeric_limits<int>::max();
110 const CWalletTx& wtx,
115 result.
txout = wtx.tx->vout[n];
116 result.
time = wtx.GetTxTime();
126 result.
txout = output.txout;
127 result.
time = output.time;
133 class WalletImpl :
public Wallet
138 bool encryptWallet(
const SecureString& wallet_passphrase)
override
140 return m_wallet->EncryptWallet(wallet_passphrase);
142 bool isCrypted()
override {
return m_wallet->IsCrypted(); }
143 bool lock()
override {
return m_wallet->Lock(); }
144 bool unlock(
const SecureString& wallet_passphrase)
override {
return m_wallet->Unlock(wallet_passphrase); }
145 bool isLocked()
override {
return m_wallet->IsLocked(); }
146 bool changeWalletPassphrase(
const SecureString& old_wallet_passphrase,
149 return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase, new_wallet_passphrase);
151 void abortRescan()
override {
m_wallet->AbortRescan(); }
152 bool backupWallet(
const std::string& filename)
override {
return m_wallet->BackupWallet(filename); }
153 std::string getWalletName()
override {
return m_wallet->GetName(); }
157 return m_wallet->GetNewDestination(type, label);
161 std::unique_ptr<SigningProvider> provider =
m_wallet->GetSolvingProvider(script);
163 return provider->GetPubKey(address, pub_key);
167 SigningResult signMessage(
const std::string& message,
const PKHash& pkhash, std::string& str_sig)
override
169 return m_wallet->SignMessage(message, pkhash, str_sig);
176 bool haveWatchOnly()
override
178 auto spk_man =
m_wallet->GetLegacyScriptPubKeyMan();
180 return spk_man->HaveWatchOnly();
184 bool setAddressBook(
const CTxDestination& dest,
const std::string&
name,
const std::optional<AddressPurpose>& purpose)
override
190 return m_wallet->DelAddressBook(dest);
198 const auto& entry =
m_wallet->FindAddressBookEntry(dest,
false);
199 if (!entry)
return false;
201 *
name = entry->GetLabel();
203 std::optional<isminetype> dest_is_mine;
204 if (is_mine || purpose) {
205 dest_is_mine =
m_wallet->IsMine(dest);
208 *is_mine = *dest_is_mine;
216 std::vector<WalletAddress> getAddresses()
override
219 std::vector<WalletAddress> result;
221 if (is_change) return;
222 isminetype is_mine = m_wallet->IsMine(dest);
224 result.emplace_back(dest, is_mine, purpose.value_or(is_mine ? AddressPurpose::RECEIVE : AddressPurpose::SEND), label);
228 std::vector<std::string> getAddressReceiveRequests()
override {
230 return m_wallet->GetAddressReceiveRequests();
232 bool setAddressReceiveRequest(
const CTxDestination& dest,
const std::string&
id,
const std::string& value)
override {
246 WalletBatch batch{
m_wallet->GetDatabase()};
247 return value.empty() ?
m_wallet->EraseAddressReceiveRequest(batch, dest,
id)
248 :
m_wallet->SetAddressReceiveRequest(batch, dest,
id, value);
253 return m_wallet->DisplayAddress(dest);
255 bool lockCoin(
const COutPoint& output,
const bool write_to_db)
override
258 std::unique_ptr<WalletBatch> batch = write_to_db ? std::make_unique<WalletBatch>(
m_wallet->GetDatabase()) : nullptr;
259 return m_wallet->LockCoin(output, batch.get());
261 bool unlockCoin(
const COutPoint& output)
override
264 std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(
m_wallet->GetDatabase());
265 return m_wallet->UnlockCoin(output, batch.get());
267 bool isLockedCoin(
const COutPoint& output)
override
270 return m_wallet->IsLockedCoin(output);
272 void listLockedCoins(std::vector<COutPoint>& outputs)
override
275 return m_wallet->ListLockedCoins(outputs);
278 const CCoinControl& coin_control,
287 const auto& txr = *res;
289 change_pos = txr.change_pos ? *txr.change_pos : -1;
298 m_wallet->CommitTransaction(std::move(tx), std::move(value_map), std::move(order_form));
300 bool transactionCanBeAbandoned(
const uint256& txid)
override {
return m_wallet->TransactionCanBeAbandoned(txid); }
301 bool abandonTransaction(
const uint256& txid)
override
304 return m_wallet->AbandonTransaction(txid);
306 bool transactionCanBeBumped(
const uint256& txid)
override
310 bool createBumpTransaction(
const uint256& txid,
311 const CCoinControl& coin_control,
312 std::vector<bilingual_str>& errors,
317 std::vector<CTxOut> outputs;
321 bool commitBumpTransaction(
const uint256& txid,
323 std::vector<bilingual_str>& errors,
332 auto mi =
m_wallet->mapWallet.find(txid);
333 if (mi !=
m_wallet->mapWallet.end()) {
334 return mi->second.tx;
341 auto mi =
m_wallet->mapWallet.find(txid);
342 if (mi !=
m_wallet->mapWallet.end()) {
343 return MakeWalletTx(*
m_wallet, mi->second);
347 std::set<WalletTx> getWalletTxs()
override
350 std::set<WalletTx> result;
351 for (
const auto& entry :
m_wallet->mapWallet) {
352 result.emplace(MakeWalletTx(*
m_wallet, entry.second));
356 bool tryGetTxStatus(
const uint256& txid,
359 int64_t& block_time)
override
362 if (!locked_wallet) {
365 auto mi =
m_wallet->mapWallet.find(txid);
366 if (mi ==
m_wallet->mapWallet.end()) {
369 num_blocks =
m_wallet->GetLastBlockHeight();
372 tx_status = MakeWalletTxStatus(*
m_wallet, mi->second);
379 int& num_blocks)
override
382 auto mi =
m_wallet->mapWallet.find(txid);
383 if (mi !=
m_wallet->mapWallet.end()) {
384 num_blocks =
m_wallet->GetLastBlockHeight();
385 in_mempool = mi->second.InMempool();
386 order_form = mi->second.vOrderForm;
387 tx_status = MakeWalletTxStatus(*
m_wallet, mi->second);
388 return MakeWalletTx(*
m_wallet, mi->second);
397 bool& complete)
override
399 return m_wallet->FillPSBT(psbtx, complete, sighash_type, sign, bip32derivs, n_signed);
405 result.
balance = bal.m_mine_trusted;
419 if (!locked_wallet) {
422 block_hash =
m_wallet->GetLastBlockHash();
423 balances = getBalances();
427 CAmount getAvailableBalance(
const CCoinControl& coin_control)
override
432 if (coin_control.HasSelected()) {
434 CoinSelectionParams params(rng);
437 total_amount += res->total_amount;
442 if (coin_control.m_allow_other_inputs) {
461 return m_wallet->GetDebit(txin, filter);
468 CoinsList listCoins()
override
473 auto&
group = result[entry.first];
474 for (
const auto& coin : entry.second) {
475 group.emplace_back(coin.outpoint,
481 std::vector<WalletTxOut> getCoins(
const std::vector<COutPoint>& outputs)
override
484 std::vector<WalletTxOut> result;
485 result.reserve(outputs.size());
486 for (
const auto& output : outputs) {
487 result.emplace_back();
489 if (it !=
m_wallet->mapWallet.end()) {
490 int depth =
m_wallet->GetTxDepthInMainChain(it->second);
492 result.back() = MakeWalletTxOut(*
m_wallet, it->second, output.
n, depth);
499 CAmount getMinimumFee(
unsigned int tx_bytes,
500 const CCoinControl& coin_control,
501 int* returned_target,
508 if (reason) *reason = fee_calc.
reason;
511 unsigned int getConfirmTarget()
override {
return m_wallet->m_confirm_target; }
512 bool hdEnabled()
override {
return m_wallet->IsHDEnabled(); }
513 bool canGetAddresses()
override {
return m_wallet->CanGetAddresses(); }
516 bool taprootEnabled()
override {
517 if (
m_wallet->IsLegacy())
return false;
519 return spk_man !=
nullptr;
521 OutputType getDefaultAddressType()
override {
return m_wallet->m_default_address_type; }
522 CAmount getDefaultMaxTxFee()
override {
return m_wallet->m_default_max_tx_fee; }
523 void remove()
override
527 bool isLegacy()
override {
return m_wallet->IsLegacy(); }
528 std::unique_ptr<Handler> handleUnload(UnloadFn fn)
override
532 std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn)
override
536 std::unique_ptr<Handler> handleStatusChanged(StatusChangedFn fn)
override
540 std::unique_ptr<Handler> handleAddressBookChanged(AddressBookChangedFn fn)
override
543 [fn](
const CTxDestination& address,
const std::string& label,
bool is_mine,
546 std::unique_ptr<Handler> handleTransactionChanged(TransactionChangedFn fn)
override
551 std::unique_ptr<Handler> handleWatchOnlyChanged(WatchOnlyChangedFn fn)
override
555 std::unique_ptr<Handler> handleCanGetAddressesChanged(CanGetAddressesChangedFn fn)
override
576 void registerRpcs()
override
580 JSONRPCRequest wallet_request = request;
581 wallet_request.context = &m_context;
582 return command.actor(wallet_request, result, last_handler);
596 void setMockTime(int64_t time)
override {
return SetMockTime(time); }
597 void schedulerMockForward(std::chrono::seconds delta)
override {
Assert(
m_context.scheduler)->MockForward(delta); }
602 DatabaseOptions options;
605 options.require_create =
true;
606 options.create_flags = wallet_creation_flags;
607 options.create_passphrase = passphrase;
618 DatabaseOptions options;
621 options.require_existing =
true;
647 .watchonly_wallet_name = res->watchonly_wallet ? std::make_optional(res->watchonly_wallet->GetName()) :
std::nullopt,
648 .solvables_wallet_name = res->solvables_wallet ?
std::make_optional(res->solvables_wallet->GetName()) :
std::nullopt,
649 .backup_path = res->backup_path,
653 std::string getWalletDir()
override
657 std::vector<std::string> listWalletDir()
override
659 std::vector<std::string> paths;
665 std::vector<std::unique_ptr<Wallet>> getWallets()
override
667 std::vector<std::unique_ptr<Wallet>> wallets;
673 std::unique_ptr<Handler> handleLoadWallet(
LoadWalletFn fn)
override
677 WalletContext* context()
override {
return &
m_context; }
692 return std::make_unique<wallet::WalletLoaderImpl>(chain,
args);
bool ExtractDestination(const CScript &scriptPubKey, CTxDestination &addressRet)
Parse a scriptPubKey for the destination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
int64_t CAmount
Amount in satoshis (Can be negative)
#define CHECK_NONFATAL(condition)
Identity function.
#define Assert(val)
Identity function.
A reference to a CKey: the Hash160 of its serialized public key.
An outpoint - a combination of a transaction hash and an index n into its vout.
An encapsulated public key.
Simple class for background tasks that should be run periodically or once "after a while".
Serialized script, used inside transaction inputs and outputs.
An input of a transaction.
An output of a transaction.
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...
Helper for findBlock to selectively return pieces of block data.
Generic interface for managing an event handler or callback function registered with another interfac...
Interface for accessing a wallet.
Wallet chain client that in addition to having chain client methods for starting up,...
static std::string PathToString(const path &path)
Convert path object to a byte string.
std::unique_ptr< Handler > MakeSignalHandler(boost::signals2::connection connection)
Return handler wrapping a boost signal connection.
std::unique_ptr< WalletLoader > MakeWalletLoader(Chain &chain, ArgsManager &args)
Return implementation of ChainClient interface for a wallet loader.
std::vector< std::pair< std::string, std::string > > WalletOrderForm
std::unique_ptr< Wallet > MakeWallet(wallet::WalletContext &context, const std::shared_ptr< wallet::CWallet > &wallet)
Return implementation of Wallet interface.
std::map< std::string, std::string > WalletValueMap
bilingual_str ErrorString(const Result< T > &result)
Result CreateRateBumpTransaction(CWallet &wallet, const uint256 &txid, const CCoinControl &coin_control, std::vector< bilingual_str > &errors, CAmount &old_fee, CAmount &new_fee, CMutableTransaction &mtx, bool require_mine, const std::vector< CTxOut > &outputs, std::optional< uint32_t > original_change_index)
Create bumpfee transaction based on feerate estimates.
Result CommitTransaction(CWallet &wallet, const uint256 &txid, CMutableTransaction &&mtx, std::vector< bilingual_str > &errors, uint256 &bumped_txid)
Commit the bumpfee transaction.
bool SignTransaction(CWallet &wallet, CMutableTransaction &mtx)
Sign the new transaction,.
bool TransactionCanBeBumped(const CWallet &wallet, const uint256 &txid)
Return whether transaction can be bumped.
void StartWallets(WalletContext &context)
Complete startup of wallets.
bool OutputIsChange(const CWallet &wallet, const CTxOut &txout)
void ReadDatabaseArgs(const ArgsManager &args, DatabaseOptions &options)
Balance GetBalance(const CWallet &wallet, const int min_depth, bool avoid_reuse)
std::shared_ptr< CWallet > LoadWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
util::Result< CreatedTransactionResult > CreateTransaction(CWallet &wallet, const std::vector< CRecipient > &vecSend, std::optional< unsigned int > change_pos, const CCoinControl &coin_control, bool sign)
Create a new transaction paying the recipients with a set of coins selected by SelectCoins(); Also cr...
std::vector< std::shared_ptr< CWallet > > GetWallets(WalletContext &context)
CAmount CachedTxGetDebit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
filter decides which addresses will count towards the debit
CAmount GetMinimumFee(const CWallet &wallet, unsigned int nTxBytes, const CCoinControl &coin_control, FeeCalculation *feeCalc)
Estimate the minimum fee considering user set parameters and the required fee.
std::vector< fs::path > ListDatabases(const fs::path &wallet_dir)
Recursively list database paths in directory.
CAmount OutputGetCredit(const CWallet &wallet, const CTxOut &txout, const isminefilter &filter)
util::Result< PreSelectedInputs > FetchSelectedInputs(const CWallet &wallet, const CCoinControl &coin_control, const CoinSelectionParams &coin_selection_params) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet)
Fetch and validate coin control selected inputs.
bool VerifyWallets(WalletContext &context)
Responsible for reading and validating the -wallet arguments and verifying the wallet database.
std::unique_ptr< interfaces::Handler > HandleLoadWallet(WalletContext &context, LoadWalletFn load_wallet)
CAmount CachedTxGetCredit(const CWallet &wallet, const CWalletTx &wtx, const isminefilter &filter)
bool CachedTxIsTrusted(const CWallet &wallet, const CWalletTx &wtx, std::set< uint256 > &trusted_parents)
std::underlying_type< isminetype >::type isminefilter
used for bitflags of isminetype
fs::path GetWalletDir()
Get the path of the wallet directory.
util::Result< MigrationResult > MigrateLegacyToDescriptor(const std::string &wallet_name, const SecureString &passphrase, WalletContext &context)
Do all steps to migrate a legacy wallet to a descriptor wallet.
std::map< CTxDestination, std::vector< COutput > > ListCoins(const CWallet &wallet)
Return list of available coins and locked coins grouped by non-change output address.
isminetype
IsMine() return codes, which depend on ScriptPubKeyMan implementation.
CAmount CachedTxGetChange(const CWallet &wallet, const CWalletTx &wtx)
AddressPurpose
Address purpose field that has been been stored with wallet sending and receiving addresses since BIP...
std::shared_ptr< CWallet > RestoreWallet(WalletContext &context, const fs::path &backup_file, const std::string &wallet_name, std::optional< bool > load_on_start, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
isminetype InputIsMine(const CWallet &wallet, const CTxIn &txin)
void UnloadWallets(WalletContext &context)
Close all wallets.
Span< const CRPCCommand > GetWalletRPCCommands()
std::shared_ptr< CWallet > CreateWallet(WalletContext &context, const std::string &name, std::optional< bool > load_on_start, DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error, std::vector< bilingual_str > &warnings)
bool LoadWallets(WalletContext &context)
Load wallet databases.
@ WALLET_FLAG_EXTERNAL_SIGNER
Indicates that the wallet needs an external signer.
@ WALLET_FLAG_DISABLE_PRIVATE_KEYS
void FlushWallets(WalletContext &context)
Flush all wallets in preparation for shutdown.
void StopWallets(WalletContext &context)
Stop all wallets. Wallets will be flushed first.
CAmount GetRequiredFee(const CWallet &wallet, unsigned int nTxBytes)
Return the minimum required absolute fee for this size based on the required fee rate.
CTxDestination getNewDestination(CWallet &w, OutputType output_type)
Returns a new destination, of an specific type, from the wallet.
bool RemoveWallet(WalletContext &context, const std::shared_ptr< CWallet > &wallet, std::optional< bool > load_on_start, std::vector< bilingual_str > &warnings)
CoinsResult AvailableCoins(const CWallet &wallet, const CCoinControl *coinControl, std::optional< CFeeRate > feerate, const CoinFilterParams ¶ms)
Populate the CoinsResult struct with vectors of available COutputs, organized by OutputType.
std::shared_ptr< CWallet > wallet
std::shared_ptr< const CTransaction > CTransactionRef
static bool verify(const CScriptNum10 &bignum, const CScriptNum &scriptnum)
std::basic_string< char, std::char_traits< char >, secure_allocator< char > > SecureString
A mutable version of CTransaction.
A version of CTransaction with the PSBT format.
Information about one wallet address.
Collection of wallet balances.
CAmount watch_only_balance
CAmount unconfirmed_balance
CAmount unconfirmed_watch_only_balance
CAmount immature_watch_only_balance
std::vector< wallet::isminetype > txin_is_mine
std::vector< CTxDestination > txout_address
std::vector< wallet::isminetype > txout_address_is_mine
std::vector< bool > txout_is_change
std::map< std::string, std::string > value_map
std::vector< wallet::isminetype > txout_is_mine
Wallet transaction output.
Updated transaction status.
unsigned int time_received
CAmount m_mine_trusted
Trusted, at depth=GetBalance.min_depth or more.
WalletContext struct containing references to state shared between CWallet instances,...
#define TRY_LOCK(cs, name)
#define EXCLUSIVE_LOCKS_REQUIRED(...)
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
ChangeType
General change type (added, updated, removed).
std::list< CRPCCommand > m_rpc_commands
std::shared_ptr< CWallet > m_wallet
std::vector< std::unique_ptr< Handler > > m_rpc_handlers
const std::vector< std::string > m_wallet_filenames
std::function< void(std::unique_ptr< interfaces::Wallet > wallet)> LoadWalletFn