59 for (
const auto& txin : wtx.tx->vin) {
65 for (
const auto& txout : wtx.tx->vout) {
75 result.
time = wtx.GetTxTime();
86 wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height :
87 wtx.state<TxStateConflicted>() ? wtx.state<TxStateConflicted>()->conflicting_block_height :
88 std::numeric_limits<int>::max();
102 const CWalletTx& wtx,
107 result.
txout = wtx.tx->vout[n];
108 result.
time = wtx.GetTxTime();
114 class WalletImpl :
public Wallet
119 bool encryptWallet(
const SecureString& wallet_passphrase)
override
121 return m_wallet->EncryptWallet(wallet_passphrase);
123 bool isCrypted()
override {
return m_wallet->IsCrypted(); }
124 bool lock()
override {
return m_wallet->Lock(); }
125 bool unlock(
const SecureString& wallet_passphrase)
override {
return m_wallet->Unlock(wallet_passphrase); }
126 bool isLocked()
override {
return m_wallet->IsLocked(); }
127 bool changeWalletPassphrase(
const SecureString& old_wallet_passphrase,
130 return m_wallet->ChangeWalletPassphrase(old_wallet_passphrase, new_wallet_passphrase);
132 void abortRescan()
override {
m_wallet->AbortRescan(); }
133 bool backupWallet(
const std::string& filename)
override {
return m_wallet->BackupWallet(filename); }
134 std::string getWalletName()
override {
return m_wallet->GetName(); }
139 return m_wallet->GetNewDestination(type, label, dest,
error);
143 std::unique_ptr<SigningProvider> provider =
m_wallet->GetSolvingProvider(script);
145 return provider->GetPubKey(address, pub_key);
149 SigningResult signMessage(
const std::string& message,
const PKHash& pkhash, std::string& str_sig)
override
151 return m_wallet->SignMessage(message, pkhash, str_sig);
158 bool haveWatchOnly()
override
160 auto spk_man =
m_wallet->GetLegacyScriptPubKeyMan();
162 return spk_man->HaveWatchOnly();
166 bool setAddressBook(
const CTxDestination& dest,
const std::string&
name,
const std::string& purpose)
override
172 return m_wallet->DelAddressBook(dest);
177 std::string* purpose)
override
180 auto it =
m_wallet->m_address_book.find(dest);
181 if (it ==
m_wallet->m_address_book.end() || it->second.IsChange()) {
185 *
name = it->second.GetLabel();
191 *purpose = it->second.purpose;
195 std::vector<WalletAddress> getAddresses()
override
198 std::vector<WalletAddress> result;
199 for (
const auto& item :
m_wallet->m_address_book) {
200 if (item.second.IsChange())
continue;
201 result.emplace_back(item.first,
m_wallet->IsMine(item.first), item.second.GetLabel(), item.second.purpose);
205 std::vector<std::string> getAddressReceiveRequests()
override {
207 return m_wallet->GetAddressReceiveRequests();
209 bool setAddressReceiveRequest(
const CTxDestination& dest,
const std::string&
id,
const std::string& value)
override {
211 WalletBatch batch{
m_wallet->GetDatabase()};
212 return m_wallet->SetAddressReceiveRequest(batch, dest,
id, value);
217 return m_wallet->DisplayAddress(dest);
219 bool lockCoin(
const COutPoint& output,
const bool write_to_db)
override
222 std::unique_ptr<WalletBatch> batch = write_to_db ? std::make_unique<WalletBatch>(
m_wallet->GetDatabase()) : nullptr;
223 return m_wallet->LockCoin(output, batch.get());
225 bool unlockCoin(
const COutPoint& output)
override
228 std::unique_ptr<WalletBatch> batch = std::make_unique<WalletBatch>(
m_wallet->GetDatabase());
229 return m_wallet->UnlockCoin(output, batch.get());
231 bool isLockedCoin(
const COutPoint& output)
override
236 void listLockedCoins(std::vector<COutPoint>& outputs)
override
239 return m_wallet->ListLockedCoins(outputs);
241 CTransactionRef createTransaction(
const std::vector<CRecipient>& recipients,
242 const CCoinControl& coin_control,
252 fail_reason, coin_control, fee_calc_out, sign)) {
262 m_wallet->CommitTransaction(std::move(tx), std::move(value_map), std::move(order_form));
264 bool transactionCanBeAbandoned(
const uint256& txid)
override {
return m_wallet->TransactionCanBeAbandoned(txid); }
265 bool abandonTransaction(
const uint256& txid)
override
268 return m_wallet->AbandonTransaction(txid);
270 bool transactionCanBeBumped(
const uint256& txid)
override
274 bool createBumpTransaction(
const uint256& txid,
275 const CCoinControl& coin_control,
276 std::vector<bilingual_str>& errors,
284 bool commitBumpTransaction(
const uint256& txid,
286 std::vector<bilingual_str>& errors,
295 auto mi =
m_wallet->mapWallet.find(txid);
296 if (mi !=
m_wallet->mapWallet.end()) {
297 return mi->second.tx;
304 auto mi =
m_wallet->mapWallet.find(txid);
305 if (mi !=
m_wallet->mapWallet.end()) {
306 return MakeWalletTx(*
m_wallet, mi->second);
310 std::vector<WalletTx> getWalletTxs()
override
313 std::vector<WalletTx> result;
314 result.reserve(
m_wallet->mapWallet.size());
315 for (
const auto& entry :
m_wallet->mapWallet) {
316 result.emplace_back(MakeWalletTx(*
m_wallet, entry.second));
320 bool tryGetTxStatus(
const uint256& txid,
323 int64_t& block_time)
override
326 if (!locked_wallet) {
329 auto mi =
m_wallet->mapWallet.find(txid);
330 if (mi ==
m_wallet->mapWallet.end()) {
333 num_blocks =
m_wallet->GetLastBlockHeight();
336 tx_status = MakeWalletTxStatus(*
m_wallet, mi->second);
343 int& num_blocks)
override
346 auto mi =
m_wallet->mapWallet.find(txid);
347 if (mi !=
m_wallet->mapWallet.end()) {
348 num_blocks =
m_wallet->GetLastBlockHeight();
349 in_mempool = mi->second.InMempool();
350 order_form = mi->second.vOrderForm;
351 tx_status = MakeWalletTxStatus(*
m_wallet, mi->second);
352 return MakeWalletTx(*
m_wallet, mi->second);
361 bool& complete)
override
363 return m_wallet->FillPSBT(psbtx, complete, sighash_type, sign, bip32derivs, n_signed);
369 result.
balance = bal.m_mine_trusted;
383 if (!locked_wallet) {
386 block_hash =
m_wallet->GetLastBlockHash();
387 balances = getBalances();
391 CAmount getAvailableBalance(
const CCoinControl& coin_control)
override
408 return m_wallet->GetDebit(txin, filter);
415 CoinsList listCoins()
override
420 auto& group = result[entry.first];
421 for (
const auto& coin : entry.second) {
422 group.emplace_back(
COutPoint(coin.tx->GetHash(), coin.i),
423 MakeWalletTxOut(*
m_wallet, *coin.tx, coin.i, coin.nDepth));
428 std::vector<WalletTxOut> getCoins(
const std::vector<COutPoint>& outputs)
override
431 std::vector<WalletTxOut> result;
432 result.reserve(outputs.size());
433 for (
const auto& output : outputs) {
434 result.emplace_back();
436 if (it !=
m_wallet->mapWallet.end()) {
437 int depth =
m_wallet->GetTxDepthInMainChain(it->second);
439 result.back() = MakeWalletTxOut(*
m_wallet, it->second, output.
n, depth);
446 CAmount getMinimumFee(
unsigned int tx_bytes,
447 const CCoinControl& coin_control,
448 int* returned_target,
455 if (reason) *reason = fee_calc.
reason;
458 unsigned int getConfirmTarget()
override {
return m_wallet->m_confirm_target; }
459 bool hdEnabled()
override {
return m_wallet->IsHDEnabled(); }
460 bool canGetAddresses()
override {
return m_wallet->CanGetAddresses(); }
463 bool taprootEnabled()
override {
464 if (
m_wallet->IsLegacy())
return false;
466 return spk_man !=
nullptr;
468 OutputType getDefaultAddressType()
override {
return m_wallet->m_default_address_type; }
469 CAmount getDefaultMaxTxFee()
override {
return m_wallet->m_default_max_tx_fee; }
470 void remove()
override
474 bool isLegacy()
override {
return m_wallet->IsLegacy(); }
475 std::unique_ptr<Handler> handleUnload(UnloadFn fn)
override
479 std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn)
override
483 std::unique_ptr<Handler> handleStatusChanged(StatusChangedFn fn)
override
487 std::unique_ptr<Handler> handleAddressBookChanged(AddressBookChangedFn fn)
override
490 [fn](
const CTxDestination& address,
const std::string& label,
bool is_mine,
491 const std::string& purpose,
ChangeType status) { fn(address, label, is_mine, purpose, status); }));
493 std::unique_ptr<Handler> handleTransactionChanged(TransactionChangedFn fn)
override
498 std::unique_ptr<Handler> handleWatchOnlyChanged(WatchOnlyChangedFn fn)
override
502 std::unique_ptr<Handler> handleCanGetAddressesChanged(CanGetAddressesChangedFn fn)
override
523 void registerRpcs()
override
527 JSONRPCRequest wallet_request = request;
528 wallet_request.context = &m_context;
529 return command.actor(wallet_request, result, last_handler);
530 }, command.argNames, command.unique_id);
539 void setMockTime(int64_t time)
override {
return SetMockTime(time); }
542 std::unique_ptr<Wallet> createWallet(
const std::string&
name,
const SecureString& passphrase, uint64_t wallet_creation_flags,
bilingual_str&
error, std::vector<bilingual_str>& warnings)
override
544 std::shared_ptr<CWallet>
wallet;
545 DatabaseOptions options;
547 options.require_create =
true;
548 options.create_flags = wallet_creation_flags;
549 options.create_passphrase = passphrase;
552 std::unique_ptr<Wallet> loadWallet(
const std::string&
name,
bilingual_str&
error, std::vector<bilingual_str>& warnings)
override
554 DatabaseOptions options;
556 options.require_existing =
true;
559 std::unique_ptr<Wallet> restoreWallet(
const fs::path& backup_file,
const std::string& wallet_name,
bilingual_str&
error, std::vector<bilingual_str>& warnings)
override
565 std::string getWalletDir()
override
569 std::vector<std::string> listWalletDir()
override
571 std::vector<std::string> paths;
577 std::vector<std::unique_ptr<Wallet>> getWallets()
override
579 std::vector<std::unique_ptr<Wallet>> wallets;
585 std::unique_ptr<Handler> handleLoadWallet(
LoadWalletFn fn)
override
604 return std::make_unique<wallet::WalletLoaderImpl>(chain,
args);