Differential D10142 Diff 30043 src/interfaces/wallet.cpp

Changeset View

Standalone View

src/interfaces/wallet.cpp

Show First 20 Lines • Show All 454 Lines • ▼ Show 20 Lines	public:
const CCoinControl &coin_control) override {		const CCoinControl &coin_control) override {
return GetMinimumFee(*m_wallet, tx_bytes, coin_control);		return GetMinimumFee(*m_wallet, tx_bytes, coin_control);
}		}
CWallet *wallet() override { return m_wallet.get(); }		CWallet *wallet() override { return m_wallet.get(); }

std::shared_ptr<CWallet> m_wallet;		std::shared_ptr<CWallet> m_wallet;
};		};

class WalletClientImpl : public ChainClient {		class WalletClientImpl : public WalletClient {
public:		public:
WalletClientImpl(Chain &chain, ArgsManager &args,		WalletClientImpl(Chain &chain, ArgsManager &args,
std::vector<std::string> wallet_filenames)		std::vector<std::string> wallet_filenames)
: m_wallet_filenames(std::move(wallet_filenames)) {		: m_wallet_filenames(std::move(wallet_filenames)) {
m_context.chain = &chain;		m_context.chain = &chain;
m_context.args = &args;		m_context.args = &args;
}		}
		~WalletClientImpl() override { UnloadWallets(); }

		//! ChainClient methods
void registerRpcs(const Span<const CRPCCommand> &commands) {		void registerRpcs(const Span<const CRPCCommand> &commands) {
for (const CRPCCommand &command : commands) {		for (const CRPCCommand &command : commands) {
m_rpc_commands.emplace_back(		m_rpc_commands.emplace_back(
command.category, command.name,		command.category, command.name,
[this, &command](const Config &config,		[this, &command](const Config &config,
const JSONRPCRequest &request,		const JSONRPCRequest &request,
UniValue &result, bool last_handler) {		UniValue &result, bool last_handler) {
return command.actor(config, {request, m_context},		return command.actor(config, {request, m_context},
Show All 18 Lines	public:
m_wallet_filenames);		m_wallet_filenames);
}		}
void start(CScheduler &scheduler) override {		void start(CScheduler &scheduler) override {
return StartWallets(scheduler, *Assert(m_context.args));		return StartWallets(scheduler, *Assert(m_context.args));
}		}
void flush() override { return FlushWallets(); }		void flush() override { return FlushWallets(); }
void stop() override { return StopWallets(); }		void stop() override { return StopWallets(); }
void setMockTime(int64_t time) override { return SetMockTime(time); }		void setMockTime(int64_t time) override { return SetMockTime(time); }

		//! WalletClient methods
		std::unique_ptr<Wallet>
		createWallet(const CChainParams &params, const std::string &name,
		const SecureString &passphrase,
		uint64_t wallet_creation_flags,
		WalletCreationStatus &status, bilingual_str &error,
		std::vector<bilingual_str> &warnings) override {
		std::shared_ptr<CWallet> wallet;
		status = CreateWallet(params, *m_context.chain, passphrase,
		wallet_creation_flags, name, error, warnings,
		wallet);
		return MakeWallet(std::move(wallet));
		}
		std::unique_ptr<Wallet>
		loadWallet(const CChainParams &params, const std::string &name,
		bilingual_str &error,
		std::vector<bilingual_str> &warnings) override {
		return MakeWallet(LoadWallet(params, *m_context.chain,
		WalletLocation(name), error,
		warnings));
		}
		std::string getWalletDir() override { return GetWalletDir().string(); }
		std::vector<std::string> listWalletDir() override {
		std::vector<std::string> paths;
		for (auto &path : ListWalletDir()) {
		paths.push_back(path.string());
		}
		return paths;
		}

std::vector<std::unique_ptr<Wallet>> getWallets() override {		std::vector<std::unique_ptr<Wallet>> getWallets() override {
std::vector<std::unique_ptr<Wallet>> wallets;		std::vector<std::unique_ptr<Wallet>> wallets;
for (const auto &wallet : GetWallets()) {		for (const auto &wallet : GetWallets()) {
wallets.emplace_back(MakeWallet(wallet));		wallets.emplace_back(MakeWallet(wallet));
}		}
return wallets;		return wallets;
}		}
~WalletClientImpl() override { UnloadWallets(); }
		std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override {
		return HandleLoadWallet(std::move(fn));
		}

WalletContext m_context;		WalletContext m_context;
const std::vector<std::string> m_wallet_filenames;		const std::vector<std::string> m_wallet_filenames;
std::vector<std::unique_ptr<Handler>> m_rpc_handlers;		std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
std::list<CRPCCommand> m_rpc_commands;		std::list<CRPCCommand> m_rpc_commands;
};		};

} // namespace		} // namespace

std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {		std::unique_ptr<Wallet> MakeWallet(const std::shared_ptr<CWallet> &wallet) {
return wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;		return wallet ? std::make_unique<WalletImpl>(wallet) : nullptr;
}		}

std::unique_ptr<ChainClient>		std::unique_ptr<WalletClient>
MakeWalletClient(Chain &chain, ArgsManager &args,		MakeWalletClient(Chain &chain, ArgsManager &args,
std::vector<std::string> wallet_filenames) {		std::vector<std::string> wallet_filenames) {
return std::make_unique<WalletClientImpl>(chain, args,		return std::make_unique<WalletClientImpl>(chain, args,
std::move(wallet_filenames));		std::move(wallet_filenames));
}		}

} // namespace interfaces		} // namespace interfaces