LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

Pass chain and client variables where needed

Browse source 
This commit does not change behavior. All it does is pass new function
parameters.

It is easiest to review this change with:

    git log -p -n1 -U0 --word-diff-regex=.
This commit is contained in:
Russell Yanofsky 2017-05-30 15:55:17 -04:00
parent 7e2e62cf7c
commit 8db11dd0b1
24 changed files with 138 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/bench/coin_selection.cpp
View file

@ -3,6 +3,7 @@
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <bench/bench.h> #include <bench/bench.h>
#include <interfaces/chain.h>
#include <wallet/wallet.h> #include <wallet/wallet.h>
#include <wallet/coinselection.h> #include <wallet/coinselection.h>
@ -33,7 +34,8 @@ static void addCoin(const CAmount& nValue, const CWallet& wallet, std::vector<Ou
// (https://github.com/bitcoin/bitcoin/issues/7883#issuecomment-224807484) // (https://github.com/bitcoin/bitcoin/issues/7883#issuecomment-224807484)
static void CoinSelection(benchmark::State& state) static void CoinSelection(benchmark::State& state)
{ {
const CWallet wallet(WalletLocation(), WalletDatabase::CreateDummy()); auto chain = interfaces::MakeChain();
const CWallet wallet(*chain, WalletLocation(), WalletDatabase::CreateDummy());
LOCK(wallet.cs_wallet); LOCK(wallet.cs_wallet);
// Add coins. // Add coins.
@ -57,7 +59,8 @@ static void CoinSelection(benchmark::State& state)
} }
typedef std::set<CInputCoin> CoinSet; typedef std::set<CInputCoin> CoinSet;
static const CWallet testWallet(WalletLocation(), WalletDatabase::CreateDummy()); static auto testChain = interfaces::MakeChain();
static const CWallet testWallet(*testChain, WalletLocation(), WalletDatabase::CreateDummy());
std::vector<std::unique_ptr<CWalletTx>> wtxn; std::vector<std::unique_ptr<CWalletTx>> wtxn;
// Copied from src/wallet/test/coinselector_tests.cpp // Copied from src/wallet/test/coinselector_tests.cpp

8
src/bitcoind.cpp
View file

@ -11,6 +11,7 @@
#include <clientversion.h> #include <clientversion.h>
#include <compat.h> #include <compat.h>
#include <fs.h> #include <fs.h>
#include <interfaces/chain.h>
#include <rpc/server.h> #include <rpc/server.h>
#include <init.h> #include <init.h>
#include <noui.h> #include <noui.h>
@ -58,6 +59,9 @@ static void WaitForShutdown()
// //
static bool AppInit(int argc, char* argv[]) static bool AppInit(int argc, char* argv[])
{ {
InitInterfaces interfaces;
interfaces.chain = interfaces::MakeChain();
bool fRet = false; bool fRet = false;
// //
@ -164,7 +168,7 @@ static bool AppInit(int argc, char* argv[])
// If locking the data directory failed, exit immediately // If locking the data directory failed, exit immediately
return false; return false;
} }
fRet = AppInitMain(); fRet = AppInitMain(interfaces);
} }
catch (const std::exception& e) { catch (const std::exception& e) {
PrintExceptionContinue(&e, "AppInit()"); PrintExceptionContinue(&e, "AppInit()");
@ -178,7 +182,7 @@ static bool AppInit(int argc, char* argv[])
} else { } else {
WaitForShutdown(); WaitForShutdown();
} }
Shutdown(); Shutdown(interfaces);
return fRet; return fRet;
} }

4
src/dummywallet.cpp
View file

@ -15,8 +15,8 @@ public:
void AddWalletOptions() const override; void AddWalletOptions() const override;
bool ParameterInteraction() const override {return true;} bool ParameterInteraction() const override {return true;}
void RegisterRPC(CRPCTable &) const override {} void RegisterRPC(CRPCTable &) const override {}
bool Verify() const override {return true;} bool Verify(interfaces::Chain& chain) const override {return true;}
bool Open() const override {LogPrintf("No wallet support compiled in!\n"); return true;} bool Open(interfaces::Chain& chain) const override {LogPrintf("No wallet support compiled in!\n"); return true;}
void Start(CScheduler& scheduler) const override {} void Start(CScheduler& scheduler) const override {}
void Flush() const override {} void Flush() const override {}
void Stop() const override {} void Stop() const override {}

10
src/init.cpp
View file

@ -32,6 +32,7 @@
#include <rpc/server.h> #include <rpc/server.h>
#include <rpc/register.h> #include <rpc/register.h>
#include <rpc/blockchain.h> #include <rpc/blockchain.h>
#include <rpc/util.h>
#include <script/standard.h> #include <script/standard.h>
#include <script/sigcache.h> #include <script/sigcache.h>
#include <scheduler.h> #include <scheduler.h>
@ -157,7 +158,7 @@ void Interrupt()
} }
} }
void Shutdown() void Shutdown(InitInterfaces& interfaces)
{ {
LogPrintf("%s: In progress...\n", __func__); LogPrintf("%s: In progress...\n", __func__);
static CCriticalSection cs_Shutdown; static CCriticalSection cs_Shutdown;
@ -1158,7 +1159,7 @@ bool AppInitLockDataDirectory()
return true; return true;
} }
bool AppInitMain() bool AppInitMain(InitInterfaces& interfaces)
{ {
const CChainParams& chainparams = Params(); const CChainParams& chainparams = Params();
// ********************************************************* Step 4a: application initialization // ********************************************************* Step 4a: application initialization
@ -1226,6 +1227,7 @@ bool AppInitMain()
*/ */
RegisterAllCoreRPCCommands(tableRPC); RegisterAllCoreRPCCommands(tableRPC);
g_wallet_init_interface.RegisterRPC(tableRPC); g_wallet_init_interface.RegisterRPC(tableRPC);
g_rpc_interfaces = &interfaces;
#if ENABLE_ZMQ #if ENABLE_ZMQ
RegisterZMQRPCCommands(tableRPC); RegisterZMQRPCCommands(tableRPC);
#endif #endif
@ -1243,7 +1245,7 @@ bool AppInitMain()
} }
// ********************************************************* Step 5: verify wallet database integrity // ********************************************************* Step 5: verify wallet database integrity
if (!g_wallet_init_interface.Verify()) return false; if (!g_wallet_init_interface.Verify(*interfaces.chain)) return false;
// ********************************************************* Step 6: network initialization // ********************************************************* Step 6: network initialization
// Note that we absolutely cannot open any actual connections // Note that we absolutely cannot open any actual connections
@ -1562,7 +1564,7 @@ bool AppInitMain()
} }
// ********************************************************* Step 9: load wallet // ********************************************************* Step 9: load wallet
if (!g_wallet_init_interface.Open()) return false; if (!g_wallet_init_interface.Open(*interfaces.chain)) return false;
// ********************************************************* Step 10: data directory maintenance // ********************************************************* Step 10: data directory maintenance

17
src/init.h
View file

@ -10,8 +10,17 @@
#include <string> #include <string>
#include <util/system.h> #include <util/system.h>
class CScheduler; namespace interfaces {
class CWallet; class Chain;
class ChainClient;
} // namespace interfaces
//! Pointers to interfaces used during init and destroyed on shutdown.
struct InitInterfaces
{
std::unique_ptr<interfaces::Chain> chain;
std::vector<std::unique_ptr<interfaces::ChainClient>> chain_clients;
};
namespace boost namespace boost
{ {
@ -20,7 +29,7 @@ class thread_group;
/** Interrupt threads */ /** Interrupt threads */
void Interrupt(); void Interrupt();
void Shutdown(); void Shutdown(InitInterfaces& interfaces);
//!Initialize the logging infrastructure //!Initialize the logging infrastructure
void InitLogging(); void InitLogging();
//!Parameter interaction: change current parameters depending on various rules //!Parameter interaction: change current parameters depending on various rules
@ -54,7 +63,7 @@ bool AppInitLockDataDirectory();
* @note This should only be done after daemonization. Call Shutdown() if this function fails. * @note This should only be done after daemonization. Call Shutdown() if this function fails.
* @pre Parameters should be parsed and config file should be read, AppInitLockDataDirectory should have been called. * @pre Parameters should be parsed and config file should be read, AppInitLockDataDirectory should have been called.
*/ */
bool AppInitMain(); bool AppInitMain(InitInterfaces& interfaces);
/** /**
* Setup the arguments for gArgs * Setup the arguments for gArgs

8
src/interfaces/node.cpp
View file

@ -9,6 +9,7 @@
#include <chain.h> #include <chain.h>
#include <chainparams.h> #include <chainparams.h>
#include <init.h> #include <init.h>
#include <interfaces/chain.h>
#include <interfaces/handler.h> #include <interfaces/handler.h>
#include <interfaces/wallet.h> #include <interfaces/wallet.h>
#include <net.h> #include <net.h>
@ -50,6 +51,8 @@ namespace {
class NodeImpl : public Node class NodeImpl : public Node
{ {
public:
NodeImpl() { m_interfaces.chain = MakeChain(); }
bool parseParameters(int argc, const char* const argv[], std::string& error) override bool parseParameters(int argc, const char* const argv[], std::string& error) override
{ {
return gArgs.ParseParameters(argc, argv, error); return gArgs.ParseParameters(argc, argv, error);
@ -68,11 +71,11 @@ class NodeImpl : public Node
return AppInitBasicSetup() && AppInitParameterInteraction() && AppInitSanityChecks() && return AppInitBasicSetup() && AppInitParameterInteraction() && AppInitSanityChecks() &&
AppInitLockDataDirectory(); AppInitLockDataDirectory();
} }
bool appInitMain() override { return AppInitMain(); } bool appInitMain() override { return AppInitMain(m_interfaces); }
void appShutdown() override void appShutdown() override
{ {
Interrupt(); Interrupt();
Shutdown(); Shutdown(m_interfaces);
} }
void startShutdown() override { StartShutdown(); } void startShutdown() override { StartShutdown(); }
bool shutdownRequested() override { return ShutdownRequested(); } bool shutdownRequested() override { return ShutdownRequested(); }
@ -291,6 +294,7 @@ class NodeImpl : public Node
GuessVerificationProgress(Params().TxData(), block)); GuessVerificationProgress(Params().TxData(), block));
})); }));
} }
InitInterfaces m_interfaces;
}; };
} // namespace } // namespace

4
src/qt/test/addressbooktests.cpp
View file

@ -2,6 +2,7 @@
#include <qt/test/util.h> #include <qt/test/util.h>
#include <test/test_bitcoin.h> #include <test/test_bitcoin.h>
#include <interfaces/chain.h>
#include <interfaces/node.h> #include <interfaces/node.h>
#include <qt/addressbookpage.h> #include <qt/addressbookpage.h>
#include <qt/addresstablemodel.h> #include <qt/addresstablemodel.h>
@ -56,7 +57,8 @@ void EditAddressAndSubmit(
void TestAddAddressesToSendBook() void TestAddAddressesToSendBook()
{ {
TestChain100Setup test; TestChain100Setup test;
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateMock()); auto chain = interfaces::MakeChain();
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateMock());
bool firstRun; bool firstRun;
wallet->LoadWallet(firstRun); wallet->LoadWallet(firstRun);

4
src/qt/test/wallettests.cpp
View file

@ -1,6 +1,7 @@
#include <qt/test/wallettests.h> #include <qt/test/wallettests.h>
#include <qt/test/util.h> #include <qt/test/util.h>
#include <interfaces/chain.h>
#include <interfaces/node.h> #include <interfaces/node.h>
#include <base58.h> #include <base58.h>
#include <qt/bitcoinamountfield.h> #include <qt/bitcoinamountfield.h>
@ -132,7 +133,8 @@ void TestGUI()
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey())); test.CreateAndProcessBlock({}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
} }
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateMock()); auto chain = interfaces::MakeChain();
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateMock());
bool firstRun; bool firstRun;
wallet->LoadWallet(firstRun); wallet->LoadWallet(firstRun);
{ {

6
src/rpc/rawtransaction.cpp
View file

@ -9,6 +9,7 @@
#include <consensus/validation.h> #include <consensus/validation.h>
#include <core_io.h> #include <core_io.h>
#include <index/txindex.h> #include <index/txindex.h>
#include <init.h>
#include <keystore.h> #include <keystore.h>
#include <validation.h> #include <validation.h>
#include <validationinterface.h> #include <validationinterface.h>
@ -20,6 +21,7 @@
#include <primitives/transaction.h> #include <primitives/transaction.h>
#include <rpc/rawtransaction.h> #include <rpc/rawtransaction.h>
#include <rpc/server.h> #include <rpc/server.h>
#include <rpc/util.h>
#include <script/script.h> #include <script/script.h>
#include <script/script_error.h> #include <script/script_error.h>
#include <script/sign.h> #include <script/sign.h>
@ -754,7 +756,7 @@ static UniValue combinerawtransaction(const JSONRPCRequest& request)
return EncodeHexTx(mergedTx); return EncodeHexTx(mergedTx);
} }
UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival, CBasicKeyStore *keystore, bool is_temp_keystore, const UniValue& hashType) UniValue SignTransaction(interfaces::Chain& chain, CMutableTransaction& mtx, const UniValue& prevTxsUnival, CBasicKeyStore *keystore, bool is_temp_keystore, const UniValue& hashType)
{ {
// Fetch previous transactions (inputs): // Fetch previous transactions (inputs):
CCoinsView viewDummy; CCoinsView viewDummy;
@ -969,7 +971,7 @@ static UniValue signrawtransactionwithkey(const JSONRPCRequest& request)
keystore.AddKey(key); keystore.AddKey(key);
} }
return SignTransaction(mtx, request.params[2], &keystore, true, request.params[3]); return SignTransaction(*g_rpc_interfaces->chain, mtx, request.params[2], &keystore, true, request.params[3]);
} }
UniValue signrawtransaction(const JSONRPCRequest& request) UniValue signrawtransaction(const JSONRPCRequest& request)

6
src/rpc/rawtransaction.h
View file

@ -9,8 +9,12 @@ class CBasicKeyStore;
struct CMutableTransaction; struct CMutableTransaction;
class UniValue; class UniValue;
namespace interfaces {
class Chain;
} // namespace interfaces
/** Sign a transaction with the given keystore and previous transactions */ /** Sign a transaction with the given keystore and previous transactions */
UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxs, CBasicKeyStore *keystore, bool tempKeystore, const UniValue& hashType); UniValue SignTransaction(interfaces::Chain& chain, CMutableTransaction& mtx, const UniValue& prevTxs, CBasicKeyStore *keystore, bool tempKeystore, const UniValue& hashType);
/** Create a transaction from univalue parameters */ /** Create a transaction from univalue parameters */
CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf); CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf);

2
src/rpc/util.cpp
View file

@ -9,6 +9,8 @@
#include <tinyformat.h> #include <tinyformat.h>
#include <util/strencodings.h> #include <util/strencodings.h>
InitInterfaces* g_rpc_interfaces = nullptr;
// Converts a hex string to a public key if possible // Converts a hex string to a public key if possible
CPubKey HexToPubKey(const std::string& hex_in) CPubKey HexToPubKey(const std::string& hex_in)
{ {

6
src/rpc/util.h
View file

@ -17,6 +17,12 @@
class CKeyStore; class CKeyStore;
class CPubKey; class CPubKey;
class CScript; class CScript;
struct InitInterfaces;
//! Pointers to interfaces that need to be accessible from RPC methods. Due to
//! limitations of the RPC framework, there's currently no direct way to pass in
//! state to RPC method implementations.
extern InitInterfaces* g_rpc_interfaces;
CPubKey HexToPubKey(const std::string& hex_in); CPubKey HexToPubKey(const std::string& hex_in);
CPubKey AddrToPubKey(CKeyStore* const keystore, const std::string& addr_in); CPubKey AddrToPubKey(CKeyStore* const keystore, const std::string& addr_in);

7
src/test/rpc_tests.cpp
View file

@ -4,8 +4,11 @@
#include <rpc/server.h> #include <rpc/server.h>
#include <rpc/client.h> #include <rpc/client.h>
#include <rpc/util.h>
#include <core_io.h> #include <core_io.h>
#include <init.h>
#include <interfaces/chain.h>
#include <key_io.h> #include <key_io.h>
#include <netbase.h> #include <netbase.h>
@ -112,10 +115,14 @@ BOOST_AUTO_TEST_CASE(rpc_rawsign)
std::string notsigned = r.get_str(); std::string notsigned = r.get_str();
std::string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\""; std::string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
std::string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\""; std::string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
InitInterfaces interfaces;
interfaces.chain = interfaces::MakeChain();
g_rpc_interfaces = &interfaces;
r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" [] "+prevout); r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" [] "+prevout);
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false); BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" ["+privkey1+","+privkey2+"] "+prevout); r = CallRPC(std::string("signrawtransactionwithkey ")+notsigned+" ["+privkey1+","+privkey2+"] "+prevout);
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true); BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
g_rpc_interfaces = nullptr;
} }
BOOST_AUTO_TEST_CASE(rpc_createraw_op_return) BOOST_AUTO_TEST_CASE(rpc_createraw_op_return)

12
src/wallet/init.cpp
View file

@ -34,10 +34,10 @@ public:
//! Responsible for reading and validating the -wallet arguments and verifying the wallet database. //! Responsible for reading and validating the -wallet arguments and verifying the wallet database.
// This function will perform salvage on the wallet if requested, as long as only one wallet is // This function will perform salvage on the wallet if requested, as long as only one wallet is
// being loaded (WalletParameterInteraction forbids -salvagewallet, -zapwallettxes or -upgradewallet with multiwallet). // being loaded (WalletParameterInteraction forbids -salvagewallet, -zapwallettxes or -upgradewallet with multiwallet).
bool Verify() const override; bool Verify(interfaces::Chain& chain) const override;
//! Load wallet databases. //! Load wallet databases.
bool Open() const override; bool Open(interfaces::Chain& chain) const override;
//! Complete startup of wallets. //! Complete startup of wallets.
void Start(CScheduler& scheduler) const override; void Start(CScheduler& scheduler) const override;
@ -174,7 +174,7 @@ void WalletInit::RegisterRPC(CRPCTable &t) const
RegisterWalletRPCCommands(t); RegisterWalletRPCCommands(t);
} }
bool WalletInit::Verify() const bool WalletInit::Verify(interfaces::Chain& chain) const
{ {
if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) { if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
return true; return true;
@ -219,7 +219,7 @@ bool WalletInit::Verify() const
std::string error_string; std::string error_string;
std::string warning_string; std::string warning_string;
bool verify_success = CWallet::Verify(location, salvage_wallet, error_string, warning_string); bool verify_success = CWallet::Verify(chain, location, salvage_wallet, error_string, warning_string);
if (!error_string.empty()) InitError(error_string); if (!error_string.empty()) InitError(error_string);
if (!warning_string.empty()) InitWarning(warning_string); if (!warning_string.empty()) InitWarning(warning_string);
if (!verify_success) return false; if (!verify_success) return false;
@ -228,7 +228,7 @@ bool WalletInit::Verify() const
return true; return true;
} }
bool WalletInit::Open() const bool WalletInit::Open(interfaces::Chain& chain) const
{ {
if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) { if (gArgs.GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) {
LogPrintf("Wallet disabled!\n"); LogPrintf("Wallet disabled!\n");
@ -236,7 +236,7 @@ bool WalletInit::Open() const
} }
for (const std::string& walletFile : gArgs.GetArgs("-wallet")) { for (const std::string& walletFile : gArgs.GetArgs("-wallet")) {
std::shared_ptr<CWallet> pwallet = CWallet::CreateWalletFromFile(WalletLocation(walletFile)); std::shared_ptr<CWallet> pwallet = CWallet::CreateWalletFromFile(chain, WalletLocation(walletFile));
if (!pwallet) { if (!pwallet) {
return false; return false;
} }

19
src/wallet/rpcwallet.cpp
View file

@ -8,6 +8,7 @@
#include <consensus/validation.h> #include <consensus/validation.h>
#include <core_io.h> #include <core_io.h>
#include <httpserver.h> #include <httpserver.h>
#include <init.h>
#include <validation.h> #include <validation.h>
#include <key_io.h> #include <key_io.h>
#include <net.h> #include <net.h>
@ -89,7 +90,7 @@ void EnsureWalletIsUnlocked(CWallet * const pwallet)
} }
} }
static void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry) EXCLUSIVE_LOCKS_REQUIRED(cs_main) static void WalletTxToJSON(interfaces::Chain& chain, const CWalletTx& wtx, UniValue& entry) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
{ {
int confirms = wtx.GetDepthInMainChain(); int confirms = wtx.GetDepthInMainChain();
entry.pushKV("confirmations", confirms); entry.pushKV("confirmations", confirms);
@ -1279,7 +1280,7 @@ static void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, int n
entry.pushKV("vout", s.vout); entry.pushKV("vout", s.vout);
entry.pushKV("fee", ValueFromAmount(-nFee)); entry.pushKV("fee", ValueFromAmount(-nFee));
if (fLong) if (fLong)
WalletTxToJSON(wtx, entry); WalletTxToJSON(pwallet->chain(), wtx, entry);
entry.pushKV("abandoned", wtx.isAbandoned()); entry.pushKV("abandoned", wtx.isAbandoned());
ret.push_back(entry); ret.push_back(entry);
} }
@ -1318,7 +1319,7 @@ static void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, int n
} }
entry.pushKV("vout", r.vout); entry.pushKV("vout", r.vout);
if (fLong) if (fLong)
WalletTxToJSON(wtx, entry); WalletTxToJSON(pwallet->chain(), wtx, entry);
ret.push_back(entry); ret.push_back(entry);
} }
} }
@ -1665,7 +1666,7 @@ static UniValue gettransaction(const JSONRPCRequest& request)
if (wtx.IsFromMe(filter)) if (wtx.IsFromMe(filter))
entry.pushKV("fee", ValueFromAmount(nFee)); entry.pushKV("fee", ValueFromAmount(nFee));
WalletTxToJSON(wtx, entry); WalletTxToJSON(pwallet->chain(), wtx, entry);
UniValue details(UniValue::VARR); UniValue details(UniValue::VARR);
ListTransactions(pwallet, wtx, 0, false, details, filter); ListTransactions(pwallet, wtx, 0, false, details, filter);
@ -2420,11 +2421,11 @@ static UniValue loadwallet(const JSONRPCRequest& request)
} }
std::string warning; std::string warning;
if (!CWallet::Verify(location, false, error, warning)) { if (!CWallet::Verify(*g_rpc_interfaces->chain, location, false, error, warning)) {
throw JSONRPCError(RPC_WALLET_ERROR, "Wallet file verification failed: " + error); throw JSONRPCError(RPC_WALLET_ERROR, "Wallet file verification failed: " + error);
} }
std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(location); std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(*g_rpc_interfaces->chain, location);
if (!wallet) { if (!wallet) {
throw JSONRPCError(RPC_WALLET_ERROR, "Wallet loading failed."); throw JSONRPCError(RPC_WALLET_ERROR, "Wallet loading failed.");
} }
@ -2472,11 +2473,11 @@ static UniValue createwallet(const JSONRPCRequest& request)
} }
// Wallet::Verify will check if we're trying to create a wallet with a duplication name. // Wallet::Verify will check if we're trying to create a wallet with a duplication name.
if (!CWallet::Verify(location, false, error, warning)) { if (!CWallet::Verify(*g_rpc_interfaces->chain, location, false, error, warning)) {
throw JSONRPCError(RPC_WALLET_ERROR, "Wallet file verification failed: " + error); throw JSONRPCError(RPC_WALLET_ERROR, "Wallet file verification failed: " + error);
} }
std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(location, (disable_privatekeys ? (uint64_t)WALLET_FLAG_DISABLE_PRIVATE_KEYS : 0)); std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(*g_rpc_interfaces->chain, location, (disable_privatekeys ? (uint64_t)WALLET_FLAG_DISABLE_PRIVATE_KEYS : 0));
if (!wallet) { if (!wallet) {
throw JSONRPCError(RPC_WALLET_ERROR, "Wallet creation failed."); throw JSONRPCError(RPC_WALLET_ERROR, "Wallet creation failed.");
} }
@ -3021,7 +3022,7 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
LOCK2(cs_main, pwallet->cs_wallet); LOCK2(cs_main, pwallet->cs_wallet);
EnsureWalletIsUnlocked(pwallet); EnsureWalletIsUnlocked(pwallet);
return SignTransaction(mtx, request.params[1], pwallet, false, request.params[2]); return SignTransaction(pwallet->chain(), mtx, request.params[1], pwallet, false, request.params[2]);
} }
static UniValue bumpfee(const JSONRPCRequest& request) static UniValue bumpfee(const JSONRPCRequest& request)

3
src/wallet/test/coinselector_tests.cpp
View file

@ -28,7 +28,8 @@ std::vector<std::unique_ptr<CWalletTx>> wtxn;
typedef std::set<CInputCoin> CoinSet; typedef std::set<CInputCoin> CoinSet;
static std::vector<COutput> vCoins; static std::vector<COutput> vCoins;
static CWallet testWallet(WalletLocation(), WalletDatabase::CreateDummy()); static auto testChain = interfaces::MakeChain();
static CWallet testWallet(*testChain, WalletLocation(), WalletDatabase::CreateDummy());
static CAmount balance = 0; static CAmount balance = 0;
CoinEligibilityFilter filter_standard(1, 6, 0); CoinEligibilityFilter filter_standard(1, 6, 0);

2
src/wallet/test/init_test_fixture.h
View file

@ -5,6 +5,7 @@
#ifndef BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H #ifndef BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
#define BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H #define BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H
#include <interfaces/chain.h>
#include <test/test_bitcoin.h> #include <test/test_bitcoin.h>
@ -16,6 +17,7 @@ struct InitWalletDirTestingSetup: public BasicTestingSetup {
fs::path m_datadir; fs::path m_datadir;
fs::path m_cwd; fs::path m_cwd;
std::map<std::string, fs::path> m_walletdir_path_cases; std::map<std::string, fs::path> m_walletdir_path_cases;
std::unique_ptr<interfaces::Chain> m_chain = interfaces::MakeChain();
}; };
#endif // BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H #endif // BITCOIN_WALLET_TEST_INIT_TEST_FIXTURE_H

14
src/wallet/test/init_tests.cpp
View file

@ -17,7 +17,7 @@ BOOST_FIXTURE_TEST_SUITE(init_tests, InitWalletDirTestingSetup)
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_default) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_default)
{ {
SetWalletDir(m_walletdir_path_cases["default"]); SetWalletDir(m_walletdir_path_cases["default"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == true); BOOST_CHECK(result == true);
fs::path walletdir = gArgs.GetArg("-walletdir", ""); fs::path walletdir = gArgs.GetArg("-walletdir", "");
fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]); fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
@ -27,7 +27,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_default)
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom)
{ {
SetWalletDir(m_walletdir_path_cases["custom"]); SetWalletDir(m_walletdir_path_cases["custom"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == true); BOOST_CHECK(result == true);
fs::path walletdir = gArgs.GetArg("-walletdir", ""); fs::path walletdir = gArgs.GetArg("-walletdir", "");
fs::path expected_path = fs::canonical(m_walletdir_path_cases["custom"]); fs::path expected_path = fs::canonical(m_walletdir_path_cases["custom"]);
@ -37,28 +37,28 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_custom)
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_does_not_exist) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_does_not_exist)
{ {
SetWalletDir(m_walletdir_path_cases["nonexistent"]); SetWalletDir(m_walletdir_path_cases["nonexistent"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == false); BOOST_CHECK(result == false);
} }
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_directory) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_directory)
{ {
SetWalletDir(m_walletdir_path_cases["file"]); SetWalletDir(m_walletdir_path_cases["file"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == false); BOOST_CHECK(result == false);
} }
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_relative) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_is_not_relative)
{ {
SetWalletDir(m_walletdir_path_cases["relative"]); SetWalletDir(m_walletdir_path_cases["relative"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == false); BOOST_CHECK(result == false);
} }
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing)
{ {
SetWalletDir(m_walletdir_path_cases["trailing"]); SetWalletDir(m_walletdir_path_cases["trailing"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == true); BOOST_CHECK(result == true);
fs::path walletdir = gArgs.GetArg("-walletdir", ""); fs::path walletdir = gArgs.GetArg("-walletdir", "");
fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]); fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);
@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing)
BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing2) BOOST_AUTO_TEST_CASE(walletinit_verify_walletdir_no_trailing2)
{ {
SetWalletDir(m_walletdir_path_cases["trailing2"]); SetWalletDir(m_walletdir_path_cases["trailing2"]);
bool result = g_wallet_init_interface.Verify(); bool result = g_wallet_init_interface.Verify(*m_chain);
BOOST_CHECK(result == true); BOOST_CHECK(result == true);
fs::path walletdir = gArgs.GetArg("-walletdir", ""); fs::path walletdir = gArgs.GetArg("-walletdir", "");
fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]); fs::path expected_path = fs::canonical(m_walletdir_path_cases["default"]);

2
src/wallet/test/wallet_test_fixture.cpp
View file

@ -9,7 +9,7 @@
#include <wallet/rpcwallet.h> #include <wallet/rpcwallet.h>
WalletTestingSetup::WalletTestingSetup(const std::string& chainName): WalletTestingSetup::WalletTestingSetup(const std::string& chainName):
TestingSetup(chainName), m_wallet(WalletLocation(), WalletDatabase::CreateMock()) TestingSetup(chainName), m_wallet(*m_chain, WalletLocation(), WalletDatabase::CreateMock())
{ {
bool fFirstRun; bool fFirstRun;
m_wallet.LoadWallet(fFirstRun); m_wallet.LoadWallet(fFirstRun);

3
src/wallet/test/wallet_test_fixture.h
View file

@ -7,6 +7,8 @@
#include <test/test_bitcoin.h> #include <test/test_bitcoin.h>
#include <interfaces/chain.h>
#include <interfaces/wallet.h>
#include <wallet/wallet.h> #include <wallet/wallet.h>
#include <memory> #include <memory>
@ -17,6 +19,7 @@ struct WalletTestingSetup: public TestingSetup {
explicit WalletTestingSetup(const std::string& chainName = CBaseChainParams::MAIN); explicit WalletTestingSetup(const std::string& chainName = CBaseChainParams::MAIN);
~WalletTestingSetup(); ~WalletTestingSetup();
std::unique_ptr<interfaces::Chain> m_chain = interfaces::MakeChain();
CWallet m_wallet; CWallet m_wallet;
}; };

23
src/wallet/test/wallet_tests.cpp
View file

@ -34,6 +34,8 @@ static void AddKey(CWallet& wallet, const CKey& key)
BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup) BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
{ {
auto chain = interfaces::MakeChain();
// Cap last block file size, and mine new block in a new block file. // Cap last block file size, and mine new block in a new block file.
CBlockIndex* const nullBlock = nullptr; CBlockIndex* const nullBlock = nullptr;
CBlockIndex* oldTip = chainActive.Tip(); CBlockIndex* oldTip = chainActive.Tip();
@ -46,7 +48,7 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
// Verify ScanForWalletTransactions picks up transactions in both the old // Verify ScanForWalletTransactions picks up transactions in both the old
// and new block files. // and new block files.
{ {
CWallet wallet(WalletLocation(), WalletDatabase::CreateDummy()); CWallet wallet(*chain, WalletLocation(), WalletDatabase::CreateDummy());
AddKey(wallet, coinbaseKey); AddKey(wallet, coinbaseKey);
WalletRescanReserver reserver(&wallet); WalletRescanReserver reserver(&wallet);
reserver.reserve(); reserver.reserve();
@ -61,7 +63,7 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
// Verify ScanForWalletTransactions only picks transactions in the new block // Verify ScanForWalletTransactions only picks transactions in the new block
// file. // file.
{ {
CWallet wallet(WalletLocation(), WalletDatabase::CreateDummy()); CWallet wallet(*chain, WalletLocation(), WalletDatabase::CreateDummy());
AddKey(wallet, coinbaseKey); AddKey(wallet, coinbaseKey);
WalletRescanReserver reserver(&wallet); WalletRescanReserver reserver(&wallet);
reserver.reserve(); reserver.reserve();
@ -73,7 +75,7 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
// before the missing block, and success for a key whose creation time is // before the missing block, and success for a key whose creation time is
// after. // after.
{ {
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateDummy()); std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateDummy());
AddWallet(wallet); AddWallet(wallet);
UniValue keys; UniValue keys;
keys.setArray(); keys.setArray();
@ -115,6 +117,8 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
// than or equal to key birthday. // than or equal to key birthday.
BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup) BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
{ {
auto chain = interfaces::MakeChain();
// Create two blocks with same timestamp to verify that importwallet rescan // Create two blocks with same timestamp to verify that importwallet rescan
// will pick up both blocks, not just the first. // will pick up both blocks, not just the first.
const int64_t BLOCK_TIME = chainActive.Tip()->GetBlockTimeMax() + 5; const int64_t BLOCK_TIME = chainActive.Tip()->GetBlockTimeMax() + 5;
@ -134,7 +138,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
// Import key into wallet and call dumpwallet to create backup file. // Import key into wallet and call dumpwallet to create backup file.
{ {
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateDummy()); std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateDummy());
LOCK(wallet->cs_wallet); LOCK(wallet->cs_wallet);
wallet->mapKeyMetadata[coinbaseKey.GetPubKey().GetID()].nCreateTime = KEY_TIME; wallet->mapKeyMetadata[coinbaseKey.GetPubKey().GetID()].nCreateTime = KEY_TIME;
wallet->AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey()); wallet->AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
@ -150,7 +154,7 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
// Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME // Call importwallet RPC and verify all blocks with timestamps >= BLOCK_TIME
// were scanned, and no prior blocks were scanned. // were scanned, and no prior blocks were scanned.
{ {
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateDummy()); std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateDummy());
JSONRPCRequest request; JSONRPCRequest request;
request.params.setArray(); request.params.setArray();
@ -180,7 +184,8 @@ BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
// debit functions. // debit functions.
BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup) BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
{ {
CWallet wallet(WalletLocation(), WalletDatabase::CreateDummy()); auto chain = interfaces::MakeChain();
CWallet wallet(*chain, WalletLocation(), WalletDatabase::CreateDummy());
CWalletTx wtx(&wallet, m_coinbase_txns.back()); CWalletTx wtx(&wallet, m_coinbase_txns.back());
LOCK2(cs_main, wallet.cs_wallet); LOCK2(cs_main, wallet.cs_wallet);
wtx.hashBlock = chainActive.Tip()->GetBlockHash(); wtx.hashBlock = chainActive.Tip()->GetBlockHash();
@ -273,7 +278,7 @@ public:
ListCoinsTestingSetup() ListCoinsTestingSetup()
{ {
CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey())); CreateAndProcessBlock({}, GetScriptForRawPubKey(coinbaseKey.GetPubKey()));
wallet = MakeUnique<CWallet>(WalletLocation(), WalletDatabase::CreateMock()); wallet = MakeUnique<CWallet>(*m_chain, WalletLocation(), WalletDatabase::CreateMock());
bool firstRun; bool firstRun;
wallet->LoadWallet(firstRun); wallet->LoadWallet(firstRun);
AddKey(*wallet, coinbaseKey); AddKey(*wallet, coinbaseKey);
@ -311,6 +316,7 @@ public:
return it->second; return it->second;
} }
std::unique_ptr<interfaces::Chain> m_chain = interfaces::MakeChain();
std::unique_ptr<CWallet> wallet; std::unique_ptr<CWallet> wallet;
}; };
@ -377,7 +383,8 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup) BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)
{ {
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(WalletLocation(), WalletDatabase::CreateDummy()); auto chain = interfaces::MakeChain();
std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(*chain, WalletLocation(), WalletDatabase::CreateDummy());
wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS); wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
BOOST_CHECK(!wallet->TopUpKeyPool(1000)); BOOST_CHECK(!wallet->TopUpKeyPool(1000));
CPubKey pubkey; CPubKey pubkey;

10
src/wallet/wallet.cpp
View file

@ -3825,7 +3825,7 @@ void CWallet::MarkPreSplitKeys()
} }
} }
bool CWallet::Verify(const WalletLocation& location, bool salvage_wallet, std::string& error_string, std::string& warning_string) bool CWallet::Verify(interfaces::Chain& chain, const WalletLocation& location, bool salvage_wallet, std::string& error_string, std::string& warning_string)
{ {
// Do some checking on wallet path. It should be either a: // Do some checking on wallet path. It should be either a:
// //
@ -3866,7 +3866,7 @@ bool CWallet::Verify(const WalletLocation& location, bool salvage_wallet, std::s
if (salvage_wallet) { if (salvage_wallet) {
// Recover readable keypairs: // Recover readable keypairs:
CWallet dummyWallet(WalletLocation(), WalletDatabase::CreateDummy()); CWallet dummyWallet(chain, WalletLocation(), WalletDatabase::CreateDummy());
std::string backup_filename; std::string backup_filename;
if (!WalletBatch::Recover(wallet_path, (void *)&dummyWallet, WalletBatch::RecoverKeysOnlyFilter, backup_filename)) { if (!WalletBatch::Recover(wallet_path, (void *)&dummyWallet, WalletBatch::RecoverKeysOnlyFilter, backup_filename)) {
return false; return false;
@ -3876,7 +3876,7 @@ bool CWallet::Verify(const WalletLocation& location, bool salvage_wallet, std::s
return WalletBatch::VerifyDatabaseFile(wallet_path, warning_string, error_string); return WalletBatch::VerifyDatabaseFile(wallet_path, warning_string, error_string);
} }
std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(const WalletLocation& location, uint64_t wallet_creation_flags) std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(interfaces::Chain& chain, const WalletLocation& location, uint64_t wallet_creation_flags)
{ {
const std::string& walletFile = location.GetName(); const std::string& walletFile = location.GetName();
@ -3886,7 +3886,7 @@ std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(const WalletLocation& loc
if (gArgs.GetBoolArg("-zapwallettxes", false)) { if (gArgs.GetBoolArg("-zapwallettxes", false)) {
uiInterface.InitMessage(_("Zapping all transactions from wallet...")); uiInterface.InitMessage(_("Zapping all transactions from wallet..."));
std::unique_ptr<CWallet> tempWallet = MakeUnique<CWallet>(location, WalletDatabase::Create(location.GetPath())); std::unique_ptr<CWallet> tempWallet = MakeUnique<CWallet>(chain, location, WalletDatabase::Create(location.GetPath()));
DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx); DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
if (nZapWalletRet != DBErrors::LOAD_OK) { if (nZapWalletRet != DBErrors::LOAD_OK) {
InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile)); InitError(strprintf(_("Error loading %s: Wallet corrupted"), walletFile));
@ -3900,7 +3900,7 @@ std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(const WalletLocation& loc
bool fFirstRun = true; bool fFirstRun = true;
// TODO: Can't use std::make_shared because we need a custom deleter but // TODO: Can't use std::make_shared because we need a custom deleter but
// should be possible to use std::allocate_shared. // should be possible to use std::allocate_shared.
std::shared_ptr<CWallet> walletInstance(new CWallet(location, WalletDatabase::Create(location.GetPath())), ReleaseWallet); std::shared_ptr<CWallet> walletInstance(new CWallet(chain, location, WalletDatabase::Create(location.GetPath())), ReleaseWallet);
DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun); DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
if (nLoadWalletRet != DBErrors::LOAD_OK) if (nLoadWalletRet != DBErrors::LOAD_OK)
{ {

16
src/wallet/wallet.h
View file

@ -33,6 +33,10 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
namespace interfaces {
class Chain;
} // namespace interfaces
bool AddWallet(const std::shared_ptr<CWallet>& wallet); bool AddWallet(const std::shared_ptr<CWallet>& wallet);
bool RemoveWallet(const std::shared_ptr<CWallet>& wallet); bool RemoveWallet(const std::shared_ptr<CWallet>& wallet);
bool HasWallets(); bool HasWallets();
@ -676,6 +680,9 @@ private:
*/ */
bool AddWatchOnly(const CScript& dest) override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet); bool AddWatchOnly(const CScript& dest) override EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
/** Interface for accessing chain state. */
interfaces::Chain& m_chain;
/** Wallet location which includes wallet name (see WalletLocation). */ /** Wallet location which includes wallet name (see WalletLocation). */
WalletLocation m_location; WalletLocation m_location;
@ -737,7 +744,7 @@ public:
unsigned int nMasterKeyMaxID = 0; unsigned int nMasterKeyMaxID = 0;
/** Construct wallet with specified name and database implementation. */ /** Construct wallet with specified name and database implementation. */
CWallet(const WalletLocation& location, std::unique_ptr<WalletDatabase> database) : m_location(location), database(std::move(database)) CWallet(interfaces::Chain& chain, const WalletLocation& location, std::unique_ptr<WalletDatabase> database) : m_chain(chain), m_location(location), database(std::move(database))
{ {
} }
@ -759,6 +766,9 @@ public:
std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet); std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);
/** Interface for accessing chain state. */
interfaces::Chain& chain() const { return m_chain; }
const CWalletTx* GetWalletTx(const uint256& hash) const; const CWalletTx* GetWalletTx(const uint256& hash) const;
//! check whether we are allowed to upgrade (or already support) to the named feature //! check whether we are allowed to upgrade (or already support) to the named feature
@ -1057,10 +1067,10 @@ public:
bool MarkReplaced(const uint256& originalHash, const uint256& newHash); bool MarkReplaced(const uint256& originalHash, const uint256& newHash);
//! Verify wallet naming and perform salvage on the wallet if required //! Verify wallet naming and perform salvage on the wallet if required
static bool Verify(const WalletLocation& location, bool salvage_wallet, std::string& error_string, std::string& warning_string); static bool Verify(interfaces::Chain& chain, const WalletLocation& location, bool salvage_wallet, std::string& error_string, std::string& warning_string);
/* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */ /* Initializes the wallet, returns a new CWallet instance or a null pointer in case of an error */
static std::shared_ptr<CWallet> CreateWalletFromFile(const WalletLocation& location, uint64_t wallet_creation_flags = 0); static std::shared_ptr<CWallet> CreateWalletFromFile(interfaces::Chain& chain, const WalletLocation& location, uint64_t wallet_creation_flags = 0);
/** /**
* Wallet post-init setup * Wallet post-init setup

8
src/walletinitinterface.h
View file

@ -10,6 +10,10 @@
class CScheduler; class CScheduler;
class CRPCTable; class CRPCTable;
namespace interfaces {
class Chain;
} // namespace interfaces
class WalletInitInterface { class WalletInitInterface {
public: public:
/** Is the wallet component enabled */ /** Is the wallet component enabled */
@ -21,9 +25,9 @@ public:
/** Register wallet RPC*/ /** Register wallet RPC*/
virtual void RegisterRPC(CRPCTable &) const = 0; virtual void RegisterRPC(CRPCTable &) const = 0;
/** Verify wallets */ /** Verify wallets */
virtual bool Verify() const = 0; virtual bool Verify(interfaces::Chain& chain) const = 0;
/** Open wallets*/ /** Open wallets*/
virtual bool Open() const = 0; virtual bool Open(interfaces::Chain& chain) const = 0;
/** Start wallets*/ /** Start wallets*/
virtual void Start(CScheduler& scheduler) const = 0; virtual void Start(CScheduler& scheduler) const = 0;
/** Flush Wallets*/ /** Flush Wallets*/