#include "base58.h"
using namespace json_spirit;
-using namespace std;
int64_t nWalletUnlockTime;
static CCriticalSection cs_nWalletUnlockTime;
entry.push_back(Pair(item.first, item.second));
}
-string AccountFromValue(const Value& value)
+std::string AccountFromValue(const Value& value)
{
- string strAccount = value.get_str();
+ std::string strAccount = value.get_str();
if (strAccount == "*")
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Invalid account name");
return strAccount;
Value getinfo(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
- throw runtime_error(
+ throw std::runtime_error(
"getinfo\n"
"Returns an object containing various state info.");
obj.push_back(Pair("moneysupply", ValueFromAmount(pindexBest->nMoneySupply)));
obj.push_back(Pair("connections", (int)vNodes.size()));
- obj.push_back(Pair("proxy", (proxy.first.IsValid() ? proxy.first.ToStringIPPort() : string())));
+ obj.push_back(Pair("proxy", (proxy.first.IsValid() ? proxy.first.ToStringIPPort() : std::string())));
obj.push_back(Pair("ip", addrSeenByPeer.ToStringIP()));
diff.push_back(Pair("proof-of-work", GetDifficulty()));
Value getnewaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"getnewaddress [account]\n"
"Returns a new NovaCoin address for receiving payments. "
"If [account] is specified (recommended), it is added to the address book "
"so payments received with the address will be credited to [account].");
// Parse the account first so we don't generate a key if there's an error
- string strAccount;
+ std::string strAccount;
if (params.size() > 0)
strAccount = AccountFromValue(params[0]);
}
-CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
+CBitcoinAddress GetAccountAddress(std::string strAccount, bool bForceNew=false)
{
CWalletDB walletdb(pwalletMain->strWalletFile);
{
CScript scriptPubKey;
scriptPubKey.SetDestination(account.vchPubKey.GetID());
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin();
+ for (auto it = pwalletMain->mapWallet.begin();
it != pwalletMain->mapWallet.end() && account.vchPubKey.IsValid();
++it)
{
Value getaccountaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"getaccountaddress <account>\n"
"Returns the current NovaCoin address for receiving payments to this account.");
// Parse the account first so we don't generate a key if there's an error
- string strAccount = AccountFromValue(params[0]);
+ std::string strAccount = AccountFromValue(params[0]);
Value ret;
Value setaccount(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"setaccount <novacoinaddress> <account>\n"
"Sets the account associated with the given address.");
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
- string strAccount;
+ std::string strAccount;
if (params.size() > 1)
strAccount = AccountFromValue(params[1]);
// Detect when changing the account of an address that is the 'unused current key' of another account:
if (pwalletMain->mapAddressBook.count(address))
{
- string strOldAccount = pwalletMain->mapAddressBook[address];
+ std::string strOldAccount = pwalletMain->mapAddressBook[address];
if (address == GetAccountAddress(strOldAccount))
GetAccountAddress(strOldAccount, true);
}
Value getaccount(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"getaccount <novacoinaddress>\n"
"Returns the account associated with the given address.");
if (!address.IsValid())
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
- string strAccount;
- map<CBitcoinAddress, string>::iterator mi = pwalletMain->mapAddressBook.find(address);
+ std::string strAccount;
+ auto mi = pwalletMain->mapAddressBook.find(address);
if (mi != pwalletMain->mapAddressBook.end() && !(*mi).second.empty())
strAccount = (*mi).second;
return strAccount;
Value getaddressesbyaccount(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"getaddressesbyaccount <account>\n"
"Returns the list of addresses for the given account.");
- string strAccount = AccountFromValue(params[0]);
+ std::string strAccount = AccountFromValue(params[0]);
// Find all addresses that have the given account
Array ret;
for (const auto& item : pwalletMain->mapAddressBook)
{
const CBitcoinAddress& address = item.first;
- const string& strName = item.second;
+ const std::string& strName = item.second;
if (strName == strAccount)
ret.push_back(address.ToString());
}
Value mergecoins(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 3)
- throw runtime_error(
+ throw std::runtime_error(
"mergecoins <amount> <minvalue> <outputvalue>\n"
"<amount> is resulting inputs sum\n"
"<minvalue> is minimum value of inputs which are used in join process\n"
if (nOutputValue < nMinValue)
throw JSONRPCError(-101, "Output value is lower than min value");
- list<uint256> listMerged;
+ std::list<uint256> listMerged;
if (!pwalletMain->MergeCoins(nAmount, nMinValue, nOutputValue, listMerged))
return Value::null;
Value sendtoaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 2 || params.size() > 4)
- throw runtime_error(
+ throw std::runtime_error(
"sendtoaddress <novacoinaddress> <amount> [comment] [comment-to]\n"
"<amount> is a real and is rounded to the nearest " + FormatMoney(nMinimumInputValue)
+ HelpRequiringPassphrase());
// Parse address
CScript scriptPubKey;
- string strAddress = params[0].get_str();
+ std::string strAddress = params[0].get_str();
CBitcoinAddress address(strAddress);
if (address.IsValid())
if (pwalletMain->IsLocked())
throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
- string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
+ std::string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
if (!strError.empty())
throw JSONRPCError(RPC_WALLET_ERROR, strError);
Value listaddressgroupings(const Array& params, bool fHelp)
{
if (fHelp)
- throw runtime_error(
+ throw std::runtime_error(
"listaddressgroupings\n"
"Lists groups of addresses which have had their common ownership\n"
"made public by common use as inputs or as the resulting change\n"
"in past transactions");
Array jsonGroupings;
- map<CBitcoinAddress, int64_t> balances = pwalletMain->GetAddressBalances();
- for (set<CBitcoinAddress> grouping : pwalletMain->GetAddressGroupings())
+ auto balances = pwalletMain->GetAddressBalances();
+ for (auto grouping : pwalletMain->GetAddressGroupings())
{
Array jsonGrouping;
for (CBitcoinAddress address : grouping)
Value signmessage(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 2)
- throw runtime_error(
+ throw std::runtime_error(
"signmessage <novacoinaddress> <message>\n"
"Sign a message with the private key of an address");
EnsureWalletIsUnlocked();
- string strAddress = params[0].get_str();
- string strMessage = params[1].get_str();
+ std::string strAddress = params[0].get_str();
+ std::string strMessage = params[1].get_str();
CBitcoinAddress addr(strAddress);
if (!addr.IsValid())
ss << strMessageMagic;
ss << strMessage;
- vector<unsigned char> vchSig;
+ std::vector<unsigned char> vchSig;
if (!key.SignCompact(Hash(ss.begin(), ss.end()), vchSig))
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
Value verifymessage(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 3)
- throw runtime_error(
+ throw std::runtime_error(
"verifymessage <novacoinaddress> <signature> <message>\n"
"Verify a signed message");
- string strAddress = params[0].get_str();
- string strSign = params[1].get_str();
- string strMessage = params[2].get_str();
+ std::string strAddress = params[0].get_str();
+ std::string strSign = params[1].get_str();
+ std::string strMessage = params[2].get_str();
CBitcoinAddress addr(strAddress);
if (!addr.IsValid())
throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
bool fInvalid = false;
- vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
+ std::vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
if (fInvalid)
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Malformed base64 encoding");
Value getreceivedbyaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"getreceivedbyaddress <novacoinaddress> [minconf=1]\n"
"Returns the total amount received by <novacoinaddress> in transactions with at least [minconf] confirmations.");
nMinDepth = params[1].get_int();
int64_t nAmount = 0;
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || wtx.IsCoinStake() || !wtx.IsFinal())
return ValueFromAmount(nAmount);
}
-void GetAccountAddresses(string strAccount, set<CBitcoinAddress>& setAddress)
+void GetAccountAddresses(std::string strAccount, std::set<CBitcoinAddress>& setAddress)
{
for (const auto& item : pwalletMain->mapAddressBook)
{
const CBitcoinAddress& address = item.first;
- const string& strName = item.second;
+ const std::string& strName = item.second;
if (strName == strAccount)
setAddress.insert(address);
}
Value getreceivedbyaccount(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"getreceivedbyaccount <account> [minconf=1]\n"
"Returns the total amount received by addresses with <account> in transactions with at least [minconf] confirmations.");
nMinDepth = params[1].get_int();
// Get the set of pub keys assigned to account
- string strAccount = AccountFromValue(params[0]);
- set<CBitcoinAddress> setAddress;
+ std::string strAccount = AccountFromValue(params[0]);
+ std::set<CBitcoinAddress> setAddress;
GetAccountAddresses(strAccount, setAddress);
// Tally
int64_t nAmount = 0;
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || wtx.IsCoinStake() || !wtx.IsFinal())
}
-int64_t GetAccountBalance(CWalletDB& walletdb, const string& strAccount, int nMinDepth, const isminefilter& filter)
+int64_t GetAccountBalance(CWalletDB& walletdb, const std::string& strAccount, int nMinDepth, const isminefilter& filter)
{
int64_t nBalance = 0;
// Tally wallet transactions
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (!wtx.IsFinal())
return nBalance;
}
-int64_t GetAccountBalance(const string& strAccount, int nMinDepth, const isminefilter& filter)
+int64_t GetAccountBalance(const std::string& strAccount, int nMinDepth, const isminefilter& filter)
{
CWalletDB walletdb(pwalletMain->strWalletFile);
return GetAccountBalance(walletdb, strAccount, nMinDepth, filter);
Value getbalance(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 3)
- throw runtime_error(
+ throw std::runtime_error(
"getbalance [account] [minconf=1] [watchonly=0]\n"
"If [account] is not specified, returns the server's total available balance.\n"
"If [account] is specified, returns the balance in the account.\n"
// (GetBalance() sums up all unspent TxOuts)
// getbalance and getbalance '*' 0 should return the same number.
int64_t nBalance = 0;
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (!wtx.IsTrusted())
int64_t allGeneratedImmature, allGeneratedMature, allFee;
allGeneratedImmature = allGeneratedMature = allFee = 0;
- string strSentAccount;
- list<pair<CBitcoinAddress, int64_t> > listReceived;
- list<pair<CBitcoinAddress, int64_t> > listSent;
+ std::string strSentAccount;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listReceived;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount, filter);
if (wtx.GetDepthInMainChain() >= nMinDepth)
{
return ValueFromAmount(nBalance);
}
- string strAccount = AccountFromValue(params[0]);
+ std::string strAccount = AccountFromValue(params[0]);
int64_t nBalance = GetAccountBalance(strAccount, nMinDepth, filter);
Value movecmd(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 3 || params.size() > 5)
- throw runtime_error(
+ throw std::runtime_error(
"move <fromaccount> <toaccount> <amount> [minconf=1] [comment]\n"
"Move from one account in your wallet to another.");
- string strFrom = AccountFromValue(params[0]);
- string strTo = AccountFromValue(params[1]);
+ std::string strFrom = AccountFromValue(params[0]);
+ std::string strTo = AccountFromValue(params[1]);
int64_t nAmount = AmountFromValue(params[2]);
if (nAmount < nMinimumInputValue)
if (params.size() > 3)
// unused parameter, used to be nMinDepth, keep type-checking it though
(void)params[3].get_int();
- string strComment;
+ std::string strComment;
if (params.size() > 4)
strComment = params[4].get_str();
Value sendfrom(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 3 || params.size() > 6)
- throw runtime_error(
+ throw std::runtime_error(
"sendfrom <fromaccount> <tonovacoinaddress> <amount> [minconf=1] [comment] [comment-to]\n"
"<amount> is a real and is rounded to the nearest " + FormatMoney(nMinimumInputValue)
+ HelpRequiringPassphrase());
- string strAccount = AccountFromValue(params[0]);
+ std::string strAccount = AccountFromValue(params[0]);
// Parse address
CScript scriptPubKey;
- string strAddress = params[1].get_str();
+ std::string strAddress = params[1].get_str();
CBitcoinAddress address(strAddress);
if (address.IsValid())
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");
// Send
- string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
+ std::string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
if (!strError.empty())
throw JSONRPCError(RPC_WALLET_ERROR, strError);
Value sendmany(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 2 || params.size() > 4)
- throw runtime_error(
+ throw std::runtime_error(
"sendmany <fromaccount> '{address:amount,...}' [minconf=1] [comment]\n"
"amounts are double-precision floating point numbers"
+ HelpRequiringPassphrase());
- string strAccount = AccountFromValue(params[0]);
+ std::string strAccount = AccountFromValue(params[0]);
Object sendTo = params[1].get_obj();
int nMinDepth = 1;
if (params.size() > 2)
if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())
wtx.mapValue["comment"] = params[3].get_str();
- set<CBitcoinAddress> setAddress;
- vector<pair<CScript, int64_t> > vecSend;
+ std::set<CBitcoinAddress> setAddress;
+ std::vector<std::pair<CScript, int64_t> > vecSend;
int64_t totalAmount = 0;
for (const Pair& s : sendTo)
{
CBitcoinAddress address(s.name_);
if (!address.IsValid())
- throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid NovaCoin address: ")+s.name_);
+ throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid NovaCoin address: ")+s.name_);
if (!address.IsPair())
{
if (setAddress.count(address))
- throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+s.name_);
+ throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ")+s.name_);
setAddress.insert(address);
}
{
if (fHelp || params.size() < 2 || params.size() > 3)
{
- string msg = "addmultisigaddress <nrequired> <'[\"key\",\"key\"]'> [account]\n"
+ std::string msg = "addmultisigaddress <nrequired> <'[\"key\",\"key\"]'> [account]\n"
"Add a nrequired-to-sign multisignature address to the wallet\"\n"
"each key is a NovaCoin address or hex-encoded public key\n"
"If [account] is specified, assign address to [account].";
- throw runtime_error(msg);
+ throw std::runtime_error(msg);
}
int nRequired = params[0].get_int();
const Array& keys = params[1].get_array();
- string strAccount;
+ std::string strAccount;
if (params.size() > 2)
strAccount = AccountFromValue(params[2]);
// Gather public keys
if (nRequired < 1)
- throw runtime_error("a multisignature address must require at least one key to redeem");
+ throw std::runtime_error("a multisignature address must require at least one key to redeem");
if ((int)keys.size() < nRequired)
- throw runtime_error(
+ throw std::runtime_error(
strprintf("not enough keys supplied "
"(got %" PRIszu " keys, but need at least %d to redeem)", keys.size(), nRequired));
if (keys.size() > 16)
- throw runtime_error("Number of addresses involved in the multisignature address creation > 16\nReduce the number");
+ throw std::runtime_error("Number of addresses involved in the multisignature address creation > 16\nReduce the number");
std::vector<CPubKey> pubkeys;
pubkeys.resize(keys.size());
for (unsigned int i = 0; i < keys.size(); i++)
{
CKeyID keyID;
if (!address.GetKeyID(keyID))
- throw runtime_error(
+ throw std::runtime_error(
strprintf("%s does not refer to a key",ks.c_str()));
CPubKey vchPubKey;
if (!pwalletMain->GetPubKey(keyID, vchPubKey))
- throw runtime_error(
+ throw std::runtime_error(
strprintf("no full public key for address %s",ks.c_str()));
if (!vchPubKey.IsValid())
- throw runtime_error(" Invalid public key: "+ks);
+ throw std::runtime_error(" Invalid public key: "+ks);
pubkeys[i] = vchPubKey;
}
{
CPubKey vchPubKey(ParseHex(ks));
if (!vchPubKey.IsValid())
- throw runtime_error(" Invalid public key: "+ks);
+ throw std::runtime_error(" Invalid public key: "+ks);
pubkeys[i] = vchPubKey;
}
else
{
- throw runtime_error(" Invalid public key: "+ks);
+ throw std::runtime_error(" Invalid public key: "+ks);
}
}
inner.SetMultisig(nRequired, pubkeys);
if (inner.size() > MAX_SCRIPT_ELEMENT_SIZE)
- throw runtime_error(
+ throw std::runtime_error(
strprintf("redeemScript exceeds size limit: %" PRIszu " > %d", inner.size(), MAX_SCRIPT_ELEMENT_SIZE));
pwalletMain->AddCScript(inner);
{
if (fHelp || params.size() < 1 || params.size() > 2)
{
- string msg = "addredeemscript <redeemScript> [account]\n"
+ std::string msg = "addredeemscript <redeemScript> [account]\n"
"Add a P2SH address with a specified redeemScript to the wallet.\n"
"If [account] is specified, assign address to [account].";
- throw runtime_error(msg);
+ throw std::runtime_error(msg);
}
- string strAccount;
+ std::string strAccount;
if (params.size() > 1)
strAccount = AccountFromValue(params[1]);
// Construct using pay-to-script-hash:
- vector<unsigned char> innerData = ParseHexV(params[0], "redeemScript");
+ auto innerData = ParseHexV(params[0], "redeemScript");
CScript inner(innerData.begin(), innerData.end());
pwalletMain->AddCScript(inner);
CBitcoinAddress address(inner.GetID());
fIncludeEmpty = params[1].get_bool();
// Tally
- map<CBitcoinAddress, tallyitem> mapTally;
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ std::map<CBitcoinAddress, tallyitem> mapTally;
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
tallyitem& item = mapTally[address];
item.nAmount += txout.nValue;
- item.nConf = min(item.nConf, nDepth);
+ item.nConf = std::min(item.nConf, nDepth);
}
}
// Reply
Array ret;
- map<string, tallyitem> mapAccountTally;
+ std::map<std::string, tallyitem> mapAccountTally;
for (const auto& item : pwalletMain->mapAddressBook)
{
const CBitcoinAddress& address = item.first;
- const string& strAccount = item.second;
- map<CBitcoinAddress, tallyitem>::iterator it = mapTally.find(address);
+ const std::string& strAccount = item.second;
+ auto it = mapTally.find(address);
if (it == mapTally.end() && !fIncludeEmpty)
continue;
{
tallyitem& item = mapAccountTally[strAccount];
item.nAmount += nAmount;
- item.nConf = min(item.nConf, nConf);
+ item.nConf = std::min(item.nConf, nConf);
}
else
{
if (fByAccounts)
{
- for (map<string, tallyitem>::iterator it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
+ for (auto it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
{
int64_t nAmount = (*it).second.nAmount;
int nConf = (*it).second.nConf;
Value listreceivedbyaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"listreceivedbyaddress [minconf=1] [includeempty=false]\n"
"[minconf] is the minimum number of confirmations before payments are included.\n"
"[includeempty] whether to include addresses that haven't received any payments.\n"
Value listreceivedbyaccount(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"listreceivedbyaccount [minconf=1] [includeempty=false]\n"
"[minconf] is the minimum number of confirmations before payments are included.\n"
"[includeempty] whether to include accounts that haven't received any payments.\n"
entry.push_back(Pair("address", dest.ToString()));
}
-void ListTransactions(const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, Array& ret, const isminefilter& filter)
+void ListTransactions(const CWalletTx& wtx, const std::string& strAccount, int nMinDepth, bool fLong, Array& ret, const isminefilter& filter)
{
int64_t nGeneratedImmature, nGeneratedMature, nFee;
- string strSentAccount;
- list<pair<CBitcoinAddress, int64_t> > listReceived;
- list<pair<CBitcoinAddress, int64_t> > listSent;
+ std::string strSentAccount;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listReceived;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount, filter);
- bool fAllAccounts = (strAccount == string("*"));
+ bool fAllAccounts = (strAccount == std::string("*"));
bool involvesWatchonly = wtx.IsFromMe(MINE_WATCH_ONLY);
// Generated blocks assigned to account ""
if ((nGeneratedMature+nGeneratedImmature) != 0 && (fAllAccounts || strAccount.empty()))
{
Object entry;
- entry.push_back(Pair("account", string("")));
+ entry.push_back(Pair("account", std::string("")));
if (nGeneratedImmature)
{
entry.push_back(Pair("category", wtx.GetDepthInMainChain() ? "immature" : "orphan"));
{
for (const auto& r : listReceived)
{
- string account;
+ std::string account;
if (pwalletMain->mapAddressBook.count(r.first))
account = pwalletMain->mapAddressBook[r.first];
if (fAllAccounts || (account == strAccount))
}
}
-void AcentryToJSON(const CAccountingEntry& acentry, const string& strAccount, Array& ret)
+void AcentryToJSON(const CAccountingEntry& acentry, const std::string& strAccount, Array& ret)
{
- bool fAllAccounts = (strAccount == string("*"));
+ bool fAllAccounts = (strAccount == std::string("*"));
if (fAllAccounts || acentry.strAccount == strAccount)
{
Value listtransactions(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 3)
- throw runtime_error(
+ throw std::runtime_error(
"listtransactions [account] [count=10] [from=0]\n"
"Returns up to [count] most recent transactions skipping the first [from] transactions for account [account].");
- string strAccount = "*";
+ std::string strAccount = "*";
if (params.size() > 0)
strAccount = params[0].get_str();
int nCount = 10;
Value listaccounts(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"listaccounts [minconf=1]\n"
"Returns Object that has account names as keys, account balances as values.");
includeWatchonly = includeWatchonly | MINE_WATCH_ONLY;
- map<string, int64_t> mapAccountBalances;
+ std::map<std::string, int64_t> mapAccountBalances;
for (const auto& entry : pwalletMain->mapAddressBook) {
if (IsMine(*pwalletMain, entry.first)) // This address belongs to me
mapAccountBalances[entry.second] = 0;
}
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
int64_t nGeneratedImmature, nGeneratedMature, nFee;
- string strSentAccount;
- list<pair<CBitcoinAddress, int64_t> > listReceived;
- list<pair<CBitcoinAddress, int64_t> > listSent;
+ std::string strSentAccount;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listReceived;
+ std::list<std::pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount, includeWatchonly);
mapAccountBalances[strSentAccount] -= nFee;
for (const auto& s : listSent)
}
}
- list<CAccountingEntry> acentries;
+ std::list<CAccountingEntry> acentries;
CWalletDB(pwalletMain->strWalletFile).ListAccountCreditDebit("*", acentries);
for (const CAccountingEntry& entry : acentries)
mapAccountBalances[entry.strAccount] += entry.nCreditDebit;
Value listsinceblock(const Array& params, bool fHelp)
{
if (fHelp)
- throw runtime_error(
+ throw std::runtime_error(
"listsinceblock [blockhash] [target-confirmations]\n"
"Get all transactions in blocks since block [blockhash], or all transactions if omitted");
Array transactions;
- for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); it++)
+ for (auto it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); it++)
{
CWalletTx tx = (*it).second;
Value gettransaction(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"gettransaction <txid>\n"
"Get detailed information about <txid>");
else
{
entry.push_back(Pair("blockhash", hashBlock.GetHex()));
- map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
+ auto mi = mapBlockIndex.find(hashBlock);
if (mi != mapBlockIndex.end() && (*mi).second)
{
CBlockIndex* pindex = (*mi).second;
Value backupwallet(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"backupwallet <destination>\n"
"Safely copies wallet.dat to destination, which can be a directory or a path with filename.");
- string strDest = params[0].get_str();
+ std::string strDest = params[0].get_str();
if (!BackupWallet(*pwalletMain, strDest))
throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!");
Value keypoolrefill(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"keypoolrefill [new-size]\n"
"Fills the keypool.\n"
"IMPORTANT: Any previous backups you have made of your wallet file "
"should be replaced with the newly generated one."
+ HelpRequiringPassphrase());
- unsigned int nSize = max<unsigned int>(GetArgUInt("-keypool", 100), 0);
+ unsigned int nSize = std::max<unsigned int>(GetArgUInt("-keypool", 100), 0);
if (params.size() > 0) {
if (params[0].get_int() < 0)
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected valid size");
Value keypoolreset(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"keypoolreset [new-size]\n"
"Resets the keypool.\n"
"IMPORTANT: Any previous backups you have made of your wallet file "
"should be replaced with the newly generated one."
+ HelpRequiringPassphrase());
- unsigned int nSize = max<unsigned int>(GetArgUInt("-keypool", 100), 0);
+ unsigned int nSize = std::max<unsigned int>(GetArgUInt("-keypool", 100), 0);
if (params.size() > 0) {
if (params[0].get_int() < 0)
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected valid size");
Value walletpassphrase(const Array& params, bool fHelp)
{
if (pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 3))
- throw runtime_error(
+ throw std::runtime_error(
"walletpassphrase <passphrase> <timeout> [mintonly]\n"
"Stores the wallet decryption key in memory for <timeout> seconds.\n"
"mintonly is optional true/false allowing only block minting.");
throw JSONRPCError(RPC_WALLET_PASSPHRASE_INCORRECT, "Error: The wallet passphrase entered was incorrect.");
}
else
- throw runtime_error(
+ throw std::runtime_error(
"walletpassphrase <passphrase> <timeout>\n"
"Stores the wallet decryption key in memory for <timeout> seconds.");
Value walletpassphrasechange(const Array& params, bool fHelp)
{
if (pwalletMain->IsCrypted() && (fHelp || params.size() != 2))
- throw runtime_error(
+ throw std::runtime_error(
"walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
"Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
if (fHelp)
strNewWalletPass = params[1].get_str().c_str();
if (strOldWalletPass.length() < 1 || strNewWalletPass.length() < 1)
- throw runtime_error(
+ throw std::runtime_error(
"walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
"Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
Value walletlock(const Array& params, bool fHelp)
{
if (pwalletMain->IsCrypted() && (fHelp || params.size() != 0))
- throw runtime_error(
+ throw std::runtime_error(
"walletlock\n"
"Removes the wallet encryption key from memory, locking the wallet.\n"
"After calling this method, you will need to call walletpassphrase again\n"
Value encryptwallet(const Array& params, bool fHelp)
{
if (!pwalletMain->IsCrypted() && (fHelp || params.size() != 1))
- throw runtime_error(
+ throw std::runtime_error(
"encryptwallet <passphrase>\n"
"Encrypts the wallet with <passphrase>.");
if (fHelp)
strWalletPass = params[0].get_str().c_str();
if (strWalletPass.length() < 1)
- throw runtime_error(
+ throw std::runtime_error(
"encryptwallet <passphrase>\n"
"Encrypts the wallet with <passphrase>.");
Value validateaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
- throw runtime_error(
+ throw std::runtime_error(
"validateaddress <novacoinaddress>\n"
"Return information about <novacoinaddress>.");
}
else
{
- string currentAddress = address.ToString();
+ std::string currentAddress = address.ToString();
CTxDestination dest = address.Get();
ret.push_back(Pair("address", currentAddress));
isminetype mine = pwalletMain ? IsMine(*pwalletMain, address) : MINE_NO;
Value reservebalance(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 2)
- throw runtime_error(
+ throw std::runtime_error(
"reservebalance [<reserve> [amount]]\n"
"<reserve> is true or false to turn balance reserve on or off.\n"
"<amount> is a real and rounded to cent.\n"
if (fReserve)
{
if (params.size() == 1)
- throw runtime_error("must provide amount to reserve balance.\n");
+ throw std::runtime_error("must provide amount to reserve balance.\n");
int64_t nAmount = AmountFromValue(params[1]);
nAmount = (nAmount / CENT) * CENT; // round to cent
if (nAmount < 0)
- throw runtime_error("amount cannot be negative.\n");
+ throw std::runtime_error("amount cannot be negative.\n");
mapArgs["-reservebalance"] = FormatMoney(nAmount);
}
else
{
if (params.size() > 1)
- throw runtime_error("cannot specify amount to turn off reserve.\n");
+ throw std::runtime_error("cannot specify amount to turn off reserve.\n");
mapArgs["-reservebalance"] = "0";
}
}
Object result;
if (mapArgs.count("-reservebalance") && !ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
- throw runtime_error("invalid reserve balance amount\n");
+ throw std::runtime_error("invalid reserve balance amount\n");
result.push_back(Pair("reserve", (nReserveBalance > 0)));
result.push_back(Pair("amount", ValueFromAmount(nReserveBalance)));
return result;
Value checkwallet(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 0)
- throw runtime_error(
+ throw std::runtime_error(
"checkwallet\n"
"Check wallet for integrity.\n");
Value repairwallet(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 0)
- throw runtime_error(
+ throw std::runtime_error(
"repairwallet\n"
"Repair wallet if checkwallet reports any problem.\n");
Value resendtx(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"resendtx\n"
"Re-send unconfirmed transactions.\n"
);
Value resendwallettransactions(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
- throw runtime_error(
+ throw std::runtime_error(
"resendwallettransactions\n"
"Immediately re-broadcast unconfirmed wallet transactions to all peers.\n"
"Intended only for testing; the wallet code periodically re-broadcasts\n"
Value makekeypair(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 0)
- throw runtime_error(
+ throw std::runtime_error(
"makekeypair\n"
"Make a public/private key pair.\n");
- string strPrefix = "";
+ std::string strPrefix = "";
if (params.size() > 0)
strPrefix = params[0].get_str();
Value newmalleablekey(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"newmalleablekey\n"
"Make a malleable public/private key pair.\n");
// Parse the account first so we don't generate a key if there's an error
- string strAccount;
+ std::string strAccount;
if (params.size() > 0)
strAccount = AccountFromValue(params[0]);
CMalleableKey mKey;
if (!pwalletMain->GetMalleableKey(keyView, mKey))
- throw runtime_error("Unable to generate new malleable key");
+ throw std::runtime_error("Unable to generate new malleable key");
CMalleablePubKey mPubKey = mKey.GetMalleablePubKey();
CBitcoinAddress address(mPubKey);
Value adjustmalleablekey(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 3)
- throw runtime_error(
+ throw std::runtime_error(
"adjustmalleablekey <Malleable key data> <Public key variant data> <R data>\n"
"Calculate new private key using provided malleable key, public key and R data.\n");
CPubKey R(ParseHex(params[2].get_str()));
if (!malleableKey.CheckKeyVariant(R,vchPubKeyVariant, privKeyVariant)) {
- throw runtime_error("Unable to calculate the private key");
+ throw std::runtime_error("Unable to calculate the private key");
}
Object result;
Value adjustmalleablepubkey(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 2 || params.size() == 0)
- throw runtime_error(
+ throw std::runtime_error(
"adjustmalleablepubkey <Malleable address, key view or public key pair>\n"
"Calculate new public key using provided data.\n");
- string strData = params[0].get_str();
+ std::string strData = params[0].get_str();
CMalleablePubKey malleablePubKey;
do
if (malleablePubKey.SetString(strData))
break; // A valid public key pair
- throw runtime_error("Though your data seems a valid Base58 string, we were unable to recognize it.");
+ throw std::runtime_error("Though your data seems a valid Base58 string, we were unable to recognize it.");
}
while(false);
Value listmalleableviews(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
- throw runtime_error(
+ throw std::runtime_error(
"listmalleableviews\n"
"Get list of views for generated malleable keys.\n");