#include "walletdb.h"
#include "bitcoinrpc.h"
#include "init.h"
+#include "util.h"
+#include "ntp.h"
#include "base58.h"
using namespace json_spirit;
using namespace std;
-int64 nWalletUnlockTime;
+int64_t nWalletUnlockTime;
static CCriticalSection cs_nWalletUnlockTime;
-extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, json_spirit::Object& entry);
+extern int64_t nReserveBalance;
+extern void TxToJSON(const CTransaction& tx, const uint256& hashBlock, json_spirit::Object& entry);
std::string HelpRequiringPassphrase()
{
return pwalletMain->IsCrypted()
- ? "\nrequires wallet passphrase to be set with walletpassphrase first"
+ ? "\n\nRequires wallet passphrase to be set with walletpassphrase first"
: "";
}
{
entry.push_back(Pair("blockhash", wtx.hashBlock.GetHex()));
entry.push_back(Pair("blockindex", wtx.nIndex));
- entry.push_back(Pair("blocktime", (boost::int64_t)(mapBlockIndex[wtx.hashBlock]->nTime)));
+ entry.push_back(Pair("blocktime", (int64_t)(mapBlockIndex[wtx.hashBlock]->nTime)));
}
entry.push_back(Pair("txid", wtx.GetHash().GetHex()));
- entry.push_back(Pair("time", (boost::int64_t)wtx.GetTxTime()));
- entry.push_back(Pair("timereceived", (boost::int64_t)wtx.nTimeReceived));
- BOOST_FOREACH(const PAIRTYPE(string,string)& item, wtx.mapValue)
+ entry.push_back(Pair("time", (int64_t)wtx.GetTxTime()));
+ entry.push_back(Pair("timereceived", (int64_t)wtx.nTimeReceived));
+ for (const auto& item : wtx.mapValue)
entry.push_back(Pair(item.first, item.second));
}
proxyType proxy;
GetProxy(NET_IPV4, proxy);
- Object obj, diff;
+ Object obj, diff, timestamping;
obj.push_back(Pair("version", FormatFullVersion()));
obj.push_back(Pair("protocolversion",(int)PROTOCOL_VERSION));
obj.push_back(Pair("walletversion", pwalletMain->GetVersion()));
obj.push_back(Pair("newmint", ValueFromAmount(pwalletMain->GetNewMint())));
obj.push_back(Pair("stake", ValueFromAmount(pwalletMain->GetStake())));
obj.push_back(Pair("blocks", (int)nBestHeight));
- obj.push_back(Pair("timeoffset", (boost::int64_t)GetTimeOffset()));
+
+ timestamping.push_back(Pair("systemclock", GetTime()));
+ timestamping.push_back(Pair("adjustedtime", GetAdjustedTime()));
+
+ int64_t nNtpOffset = GetNtpOffset(),
+ nP2POffset = GetNodesOffset();
+
+ timestamping.push_back(Pair("ntpoffset", nNtpOffset != INT64_MAX ? nNtpOffset : Value::null));
+ timestamping.push_back(Pair("p2poffset", nP2POffset != INT64_MAX ? nP2POffset : Value::null));
+
+ obj.push_back(Pair("timestamping", timestamping));
+
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("difficulty", diff));
obj.push_back(Pair("testnet", fTestNet));
- obj.push_back(Pair("keypoololdest", (boost::int64_t)pwalletMain->GetOldestKeyPoolTime()));
+ obj.push_back(Pair("keypoololdest", (int64_t)pwalletMain->GetOldestKeyPoolTime()));
obj.push_back(Pair("keypoolsize", (int)pwalletMain->GetKeyPoolSize()));
obj.push_back(Pair("paytxfee", ValueFromAmount(nTransactionFee)));
obj.push_back(Pair("mininput", ValueFromAmount(nMinimumInputValue)));
if (pwalletMain->IsCrypted())
- obj.push_back(Pair("unlocked_until", (boost::int64_t)nWalletUnlockTime / 1000));
+ obj.push_back(Pair("unlocked_until", (int64_t)nWalletUnlockTime / 1000));
obj.push_back(Pair("errors", GetWarnings("statusbar")));
return obj;
}
CPubKey newKey;
if (!pwalletMain->GetKeyFromPool(newKey, false))
throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
- CKeyID keyID = newKey.GetID();
+ CBitcoinAddress address(newKey.GetID());
- pwalletMain->SetAddressBookName(keyID, strAccount);
+ pwalletMain->SetAddressBookName(address, strAccount);
- return CBitcoinAddress(keyID).ToString();
+ return address.ToString();
}
++it)
{
const CWalletTx& wtx = (*it).second;
- BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ for (const CTxOut& txout : wtx.vout)
if (txout.scriptPubKey == scriptPubKey)
bKeyUsed = true;
}
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.Get()))
+ if (pwalletMain->mapAddressBook.count(address))
{
- string strOldAccount = pwalletMain->mapAddressBook[address.Get()];
+ string strOldAccount = pwalletMain->mapAddressBook[address];
if (address == GetAccountAddress(strOldAccount))
GetAccountAddress(strOldAccount, true);
}
- pwalletMain->SetAddressBookName(address.Get(), strAccount);
+ pwalletMain->SetAddressBookName(address, strAccount);
return Value::null;
}
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
string strAccount;
- map<CTxDestination, string>::iterator mi = pwalletMain->mapAddressBook.find(address.Get());
+ map<CBitcoinAddress, string>::iterator mi = pwalletMain->mapAddressBook.find(address);
if (mi != pwalletMain->mapAddressBook.end() && !(*mi).second.empty())
strAccount = (*mi).second;
return strAccount;
// Find all addresses that have the given account
Array ret;
- BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
+ for (const auto& item : pwalletMain->mapAddressBook)
{
const CBitcoinAddress& address = item.first;
const string& strName = item.second;
return ret;
}
+Value mergecoins(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 3)
+ throw 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"
+ "<outputvalue> is resulting value of inputs which will be created\n"
+ "All values are real and and rounded to the nearest " + FormatMoney(nMinimumInputValue)
+ + HelpRequiringPassphrase());
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ // Total amount
+ int64_t nAmount = AmountFromValue(params[0]);
+
+ // Min input amount
+ int64_t nMinValue = AmountFromValue(params[1]);
+
+ // Output amount
+ int64_t nOutputValue = AmountFromValue(params[2]);
+
+ if (nAmount < nMinimumInputValue)
+ throw JSONRPCError(-101, "Send amount too small");
+
+ if (nMinValue < nMinimumInputValue)
+ throw JSONRPCError(-101, "Max value too small");
+
+ if (nOutputValue < nMinimumInputValue)
+ throw JSONRPCError(-101, "Output value too small");
+
+ if (nOutputValue < nMinValue)
+ throw JSONRPCError(-101, "Output value is lower than min value");
+
+ list<uint256> listMerged;
+ if (!pwalletMain->MergeCoins(nAmount, nMinValue, nOutputValue, listMerged))
+ return Value::null;
+
+ Array mergedHashes;
+ for (const uint256 txHash : listMerged)
+ mergedHashes.push_back(txHash.GetHex());
+
+ return mergedHashes;
+}
+
Value sendtoaddress(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 2 || params.size() > 4)
throw runtime_error(
"sendtoaddress <novacoinaddress> <amount> [comment] [comment-to]\n"
- "<amount> is a real and is rounded to the nearest " + FormatMoney(MIN_TXOUT_AMOUNT)
+ "<amount> is a real and is rounded to the nearest " + FormatMoney(nMinimumInputValue)
+ HelpRequiringPassphrase());
- CBitcoinAddress address(params[0].get_str());
- if (!address.IsValid())
+ // Parse address
+ CScript scriptPubKey;
+ string strAddress = params[0].get_str();
+
+ CBitcoinAddress address(strAddress);
+ if (address.IsValid())
+ scriptPubKey.SetAddress(address);
+ else
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
// Amount
- int64 nAmount = AmountFromValue(params[1]);
+ int64_t nAmount = AmountFromValue(params[1]);
- if (nAmount < MIN_TXOUT_AMOUNT)
+ if (nAmount < nMinimumInputValue)
throw JSONRPCError(-101, "Send amount too small");
// Wallet comments
if (pwalletMain->IsLocked())
throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
- string strError = pwalletMain->SendMoneyToDestination(address.Get(), nAmount, wtx);
- if (strError != "")
+ string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
+ if (!strError.empty())
throw JSONRPCError(RPC_WALLET_ERROR, strError);
return wtx.GetHash().GetHex();
"in past transactions");
Array jsonGroupings;
- map<CTxDestination, int64> balances = pwalletMain->GetAddressBalances();
- BOOST_FOREACH(set<CTxDestination> grouping, pwalletMain->GetAddressGroupings())
+ map<CBitcoinAddress, int64_t> balances = pwalletMain->GetAddressBalances();
+ for (set<CBitcoinAddress> grouping : pwalletMain->GetAddressGroupings())
{
Array jsonGrouping;
- BOOST_FOREACH(CTxDestination address, grouping)
+ for (CBitcoinAddress address : grouping)
{
Array addressInfo;
- addressInfo.push_back(CBitcoinAddress(address).ToString());
+ addressInfo.push_back(address.ToString());
addressInfo.push_back(ValueFromAmount(balances[address]));
{
LOCK(pwalletMain->cs_wallet);
- if (pwalletMain->mapAddressBook.find(CBitcoinAddress(address).Get()) != pwalletMain->mapAddressBook.end())
- addressInfo.push_back(pwalletMain->mapAddressBook.find(CBitcoinAddress(address).Get())->second);
+ if (pwalletMain->mapAddressBook.find(address) != pwalletMain->mapAddressBook.end())
+ addressInfo.push_back(pwalletMain->mapAddressBook.find(address)->second);
}
jsonGrouping.push_back(addressInfo);
}
ss << strMessageMagic;
ss << strMessage;
- CKey key;
+ CPubKey key;
if (!key.SetCompactSignature(Hash(ss.begin(), ss.end()), vchSig))
return false;
- return (key.GetPubKey().GetID() == keyID);
+ return (key.GetID() == keyID);
}
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw runtime_error(
- "getreceivedbyaddress <novacoinaddress> [minconf=1]\n"
- "Returns the total amount received by <novacoinaddress> in transactions with at least [minconf] confirmations.");
+ "getreceivedbyaddress <novacoinaddress> [minconf=1]\n"
+ "Returns the total amount received by <novacoinaddress> in transactions with at least [minconf] confirmations.");
// Bitcoin address
CBitcoinAddress address = CBitcoinAddress(params[0].get_str());
- CScript scriptPubKey;
if (!address.IsValid())
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
- scriptPubKey.SetDestination(address.Get());
- if (!IsMine(*pwalletMain,scriptPubKey))
- return (double)0.0;
+ if (!IsMine(*pwalletMain,address))
+ return 0.0;
// Minimum confirmations
int nMinDepth = 1;
if (params.size() > 1)
nMinDepth = params[1].get_int();
- // Tally
- int64 nAmount = 0;
+ int64_t nAmount = 0;
for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || wtx.IsCoinStake() || !wtx.IsFinal())
continue;
-
- BOOST_FOREACH(const CTxOut& txout, wtx.vout)
- if (txout.scriptPubKey == scriptPubKey)
+ for (const CTxOut& txout : wtx.vout)
+ {
+ CBitcoinAddress addressRet;
+ if (!ExtractAddress(*pwalletMain, txout.scriptPubKey, addressRet))
+ continue;
+ if (addressRet == address)
if (wtx.GetDepthInMainChain() >= nMinDepth)
nAmount += txout.nValue;
+ }
}
return ValueFromAmount(nAmount);
}
-
-void GetAccountAddresses(string strAccount, set<CTxDestination>& setAddress)
+void GetAccountAddresses(string strAccount, set<CBitcoinAddress>& setAddress)
{
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, string)& item, pwalletMain->mapAddressBook)
+ for (const auto& item : pwalletMain->mapAddressBook)
{
- const CTxDestination& address = item.first;
+ const CBitcoinAddress& address = item.first;
const string& strName = item.second;
if (strName == strAccount)
setAddress.insert(address);
// Get the set of pub keys assigned to account
string strAccount = AccountFromValue(params[0]);
- set<CTxDestination> setAddress;
+ set<CBitcoinAddress> setAddress;
GetAccountAddresses(strAccount, setAddress);
// Tally
- int64 nAmount = 0;
+ int64_t nAmount = 0;
for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || wtx.IsCoinStake() || !wtx.IsFinal())
continue;
- BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ for (const CTxOut& txout : wtx.vout)
{
- CTxDestination address;
- if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*pwalletMain, address) && setAddress.count(address))
+ CBitcoinAddress address;
+ if (ExtractAddress(*pwalletMain, txout.scriptPubKey, address) && IsMine(*pwalletMain, address) && setAddress.count(address))
if (wtx.GetDepthInMainChain() >= nMinDepth)
nAmount += txout.nValue;
}
}
-int64 GetAccountBalance(CWalletDB& walletdb, const string& strAccount, int nMinDepth, const isminefilter& filter)
+int64_t GetAccountBalance(CWalletDB& walletdb, const string& strAccount, int nMinDepth, const isminefilter& filter)
{
- int64 nBalance = 0;
+ int64_t nBalance = 0;
// Tally wallet transactions
for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
if (!wtx.IsFinal())
continue;
- int64 nGenerated, nReceived, nSent, nFee;
+ int64_t nGenerated, nReceived, nSent, nFee;
wtx.GetAccountAmounts(strAccount, nGenerated, nReceived, nSent, nFee, filter);
if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth)
return nBalance;
}
-int64 GetAccountBalance(const string& strAccount, int nMinDepth, const isminefilter& filter)
+int64_t GetAccountBalance(const 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() > 2)
+ if (fHelp || params.size() > 3)
throw runtime_error(
"getbalance [account] [minconf=1] [watchonly=0]\n"
"If [account] is not specified, returns the server's total available balance.\n"
// Calculate total balance a different way from GetBalance()
// (GetBalance() sums up all unspent TxOuts)
// getbalance and getbalance '*' 0 should return the same number.
- int64 nBalance = 0;
+ int64_t nBalance = 0;
for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
{
const CWalletTx& wtx = (*it).second;
if (!wtx.IsTrusted())
continue;
- int64 allGeneratedImmature, allGeneratedMature, allFee;
+ int64_t allGeneratedImmature, allGeneratedMature, allFee;
allGeneratedImmature = allGeneratedMature = allFee = 0;
string strSentAccount;
- list<pair<CTxDestination, int64> > listReceived;
- list<pair<CTxDestination, int64> > listSent;
+ list<pair<CBitcoinAddress, int64_t> > listReceived;
+ list<pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount, filter);
if (wtx.GetDepthInMainChain() >= nMinDepth)
{
- BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64)& r, listReceived)
+ for (const auto& r : listReceived)
nBalance += r.second;
}
- BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64)& r, listSent)
+ for (const auto& r : listSent)
nBalance -= r.second;
nBalance -= allFee;
nBalance += allGeneratedMature;
string strAccount = AccountFromValue(params[0]);
- int64 nBalance = GetAccountBalance(strAccount, nMinDepth, filter);
+ int64_t nBalance = GetAccountBalance(strAccount, nMinDepth, filter);
return ValueFromAmount(nBalance);
}
string strFrom = AccountFromValue(params[0]);
string strTo = AccountFromValue(params[1]);
- int64 nAmount = AmountFromValue(params[2]);
+ int64_t nAmount = AmountFromValue(params[2]);
- if (nAmount < MIN_TXOUT_AMOUNT)
+ if (nAmount < nMinimumInputValue)
throw JSONRPCError(-101, "Send amount too small");
if (params.size() > 3)
if (!walletdb.TxnBegin())
throw JSONRPCError(RPC_DATABASE_ERROR, "database error");
- int64 nNow = GetAdjustedTime();
+ int64_t nNow = GetAdjustedTime();
// Debit
CAccountingEntry debit;
if (fHelp || params.size() < 3 || params.size() > 6)
throw runtime_error(
"sendfrom <fromaccount> <tonovacoinaddress> <amount> [minconf=1] [comment] [comment-to]\n"
- "<amount> is a real and is rounded to the nearest " + FormatMoney(MIN_TXOUT_AMOUNT)
+ "<amount> is a real and is rounded to the nearest " + FormatMoney(nMinimumInputValue)
+ HelpRequiringPassphrase());
string strAccount = AccountFromValue(params[0]);
- CBitcoinAddress address(params[1].get_str());
- if (!address.IsValid())
+
+ // Parse address
+ CScript scriptPubKey;
+ string strAddress = params[1].get_str();
+
+ CBitcoinAddress address(strAddress);
+ if (address.IsValid())
+ scriptPubKey.SetAddress(address);
+ else
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid NovaCoin address");
- int64 nAmount = AmountFromValue(params[2]);
- if (nAmount < MIN_TXOUT_AMOUNT)
+
+ int64_t nAmount = AmountFromValue(params[2]);
+
+ if (nAmount < nMinimumInputValue)
throw JSONRPCError(-101, "Send amount too small");
int nMinDepth = 1;
EnsureWalletIsUnlocked();
// Check funds
- int64 nBalance = GetAccountBalance(strAccount, nMinDepth, MINE_SPENDABLE);
+ int64_t nBalance = GetAccountBalance(strAccount, nMinDepth, MINE_SPENDABLE);
if (nAmount > nBalance)
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");
// Send
- string strError = pwalletMain->SendMoneyToDestination(address.Get(), nAmount, wtx);
- if (strError != "")
+ string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
+ if (!strError.empty())
throw JSONRPCError(RPC_WALLET_ERROR, strError);
return wtx.GetHash().GetHex();
{
if (fHelp || params.size() < 2 || params.size() > 4)
throw runtime_error(
- "sendmany <fromaccount> {address:amount,...} [minconf=1] [comment]\n"
+ "sendmany <fromaccount> '{address:amount,...}' [minconf=1] [comment]\n"
"amounts are double-precision floating point numbers"
+ HelpRequiringPassphrase());
wtx.mapValue["comment"] = params[3].get_str();
set<CBitcoinAddress> setAddress;
- vector<pair<CScript, int64> > vecSend;
+ vector<pair<CScript, int64_t> > vecSend;
- int64 totalAmount = 0;
- BOOST_FOREACH(const Pair& s, sendTo)
+ 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_);
- if (setAddress.count(address))
- throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+s.name_);
- setAddress.insert(address);
+ if (!address.IsPair())
+ {
+ if (setAddress.count(address))
+ throw JSONRPCError(RPC_INVALID_PARAMETER, string("Invalid parameter, duplicated address: ")+s.name_);
+ setAddress.insert(address);
+ }
CScript scriptPubKey;
- scriptPubKey.SetDestination(address.Get());
- int64 nAmount = AmountFromValue(s.value_);
+ scriptPubKey.SetAddress(address);
+ int64_t nAmount = AmountFromValue(s.value_);
- if (nAmount < MIN_TXOUT_AMOUNT)
+ if (nAmount < nMinimumInputValue)
throw JSONRPCError(-101, "Send amount too small");
totalAmount += nAmount;
EnsureWalletIsUnlocked();
// Check funds
- int64 nBalance = GetAccountBalance(strAccount, nMinDepth, MINE_SPENDABLE);
+ int64_t nBalance = GetAccountBalance(strAccount, nMinDepth, MINE_SPENDABLE);
if (totalAmount > nBalance)
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");
// Send
CReserveKey keyChange(pwalletMain);
- int64 nFeeRequired = 0;
+ int64_t nFeeRequired = 0;
bool fCreated = pwalletMain->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired);
if (!fCreated)
{
- int64 nTotal = pwalletMain->GetBalance(), nWatchOnly = pwalletMain->GetWatchOnlyBalance();
+ int64_t nTotal = pwalletMain->GetBalance(), nWatchOnly = pwalletMain->GetWatchOnlyBalance();
if (totalAmount + nFeeRequired > nTotal - nWatchOnly)
throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
throw JSONRPCError(RPC_WALLET_ERROR, "Transaction creation failed");
if ((int)keys.size() < nRequired)
throw runtime_error(
strprintf("not enough keys supplied "
- "(got %"PRIszu" keys, but need at least %d to redeem)", keys.size(), nRequired));
- std::vector<CKey> pubkeys;
+ "(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");
+ std::vector<CPubKey> pubkeys;
pubkeys.resize(keys.size());
for (unsigned int i = 0; i < keys.size(); i++)
{
if (!pwalletMain->GetPubKey(keyID, vchPubKey))
throw runtime_error(
strprintf("no full public key for address %s",ks.c_str()));
- if (!vchPubKey.IsValid() || !pubkeys[i].SetPubKey(vchPubKey))
+ if (!vchPubKey.IsValid())
throw runtime_error(" Invalid public key: "+ks);
+ pubkeys[i] = vchPubKey;
}
// Case 2: hex public key
else if (IsHex(ks))
{
CPubKey vchPubKey(ParseHex(ks));
- if (!vchPubKey.IsValid() || !pubkeys[i].SetPubKey(vchPubKey))
+ if (!vchPubKey.IsValid())
throw runtime_error(" Invalid public key: "+ks);
+ pubkeys[i] = vchPubKey;
}
else
{
// Construct using pay-to-script-hash:
CScript inner;
inner.SetMultisig(nRequired, pubkeys);
- CScriptID innerID = inner.GetID();
+
+ if (inner.size() > MAX_SCRIPT_ELEMENT_SIZE)
+ throw runtime_error(
+ strprintf("redeemScript exceeds size limit: %" PRIszu " > %d", inner.size(), MAX_SCRIPT_ELEMENT_SIZE));
+
pwalletMain->AddCScript(inner);
+ CBitcoinAddress address(inner.GetID());
- pwalletMain->SetAddressBookName(innerID, strAccount);
- return CBitcoinAddress(innerID).ToString();
+ pwalletMain->SetAddressBookName(address, strAccount);
+ return address.ToString();
}
Value addredeemscript(const Array& params, bool fHelp)
// Construct using pay-to-script-hash:
vector<unsigned char> innerData = ParseHexV(params[0], "redeemScript");
CScript inner(innerData.begin(), innerData.end());
- CScriptID innerID = inner.GetID();
pwalletMain->AddCScript(inner);
+ CBitcoinAddress address(inner.GetID());
- pwalletMain->SetAddressBookName(innerID, strAccount);
- return CBitcoinAddress(innerID).ToString();
+ pwalletMain->SetAddressBookName(address, strAccount);
+ return address.ToString();
}
struct tallyitem
{
- int64 nAmount;
+ int64_t nAmount;
int nConf;
tallyitem()
{
if (nDepth < nMinDepth)
continue;
- BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ for (const CTxOut& txout : wtx.vout)
{
CTxDestination address;
if (!ExtractDestination(txout.scriptPubKey, address) || !IsMine(*pwalletMain, address))
// Reply
Array ret;
map<string, tallyitem> mapAccountTally;
- BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
+ for (const auto& item : pwalletMain->mapAddressBook)
{
const CBitcoinAddress& address = item.first;
const string& strAccount = item.second;
if (it == mapTally.end() && !fIncludeEmpty)
continue;
- int64 nAmount = 0;
+ int64_t nAmount = 0;
int nConf = std::numeric_limits<int>::max();
if (it != mapTally.end())
{
{
for (map<string, tallyitem>::iterator it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
{
- int64 nAmount = (*it).second.nAmount;
+ int64_t nAmount = (*it).second.nAmount;
int nConf = (*it).second.nConf;
Object obj;
obj.push_back(Pair("account", (*it).first));
return ListReceived(params, true);
}
-static void MaybePushAddress(Object & entry, const CTxDestination &dest)
+static void MaybePushAddress(Object & entry, const CBitcoinAddress &dest)
{
- CBitcoinAddress addr;
- if (addr.Set(dest))
- entry.push_back(Pair("address", addr.ToString()));
+ entry.push_back(Pair("address", dest.ToString()));
}
void ListTransactions(const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, Array& ret, const isminefilter& filter)
{
- int64 nGeneratedImmature, nGeneratedMature, nFee;
+ int64_t nGeneratedImmature, nGeneratedMature, nFee;
string strSentAccount;
- list<pair<CTxDestination, int64> > listReceived;
- list<pair<CTxDestination, int64> > listSent;
+ list<pair<CBitcoinAddress, int64_t> > listReceived;
+ list<pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount, filter);
bool involvesWatchonly = wtx.IsFromMe(MINE_WATCH_ONLY);
// Generated blocks assigned to account ""
- if ((nGeneratedMature+nGeneratedImmature) != 0 && (fAllAccounts || strAccount == ""))
+ if ((nGeneratedMature+nGeneratedImmature) != 0 && (fAllAccounts || strAccount.empty()))
{
Object entry;
entry.push_back(Pair("account", string("")));
// Sent
if ((!listSent.empty() || nFee != 0) && (fAllAccounts || strAccount == strSentAccount))
{
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, int64)& s, listSent)
+ for (const auto& s : listSent)
{
Object entry;
entry.push_back(Pair("account", strSentAccount));
// Received
if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth)
{
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, int64)& r, listReceived)
+ for (const auto& r : listReceived)
{
string account;
if (pwalletMain->mapAddressBook.count(r.first))
Object entry;
entry.push_back(Pair("account", acentry.strAccount));
entry.push_back(Pair("category", "move"));
- entry.push_back(Pair("time", (boost::int64_t)acentry.nTime));
+ entry.push_back(Pair("time", (int64_t)acentry.nTime));
entry.push_back(Pair("amount", ValueFromAmount(acentry.nCreditDebit)));
entry.push_back(Pair("otheraccount", acentry.strOtherAccount));
entry.push_back(Pair("comment", acentry.strComment));
includeWatchonly = includeWatchonly | MINE_WATCH_ONLY;
- map<string, int64> mapAccountBalances;
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, string)& entry, pwalletMain->mapAddressBook) {
+ map<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)
{
const CWalletTx& wtx = (*it).second;
- int64 nGeneratedImmature, nGeneratedMature, nFee;
+ int64_t nGeneratedImmature, nGeneratedMature, nFee;
string strSentAccount;
- list<pair<CTxDestination, int64> > listReceived;
- list<pair<CTxDestination, int64> > listSent;
+ list<pair<CBitcoinAddress, int64_t> > listReceived;
+ list<pair<CBitcoinAddress, int64_t> > listSent;
wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount, includeWatchonly);
mapAccountBalances[strSentAccount] -= nFee;
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, int64)& s, listSent)
+ for (const auto& s : listSent)
mapAccountBalances[strSentAccount] -= s.second;
if (wtx.GetDepthInMainChain() >= nMinDepth)
{
mapAccountBalances[""] += nGeneratedMature;
- BOOST_FOREACH(const PAIRTYPE(CTxDestination, int64)& r, listReceived)
+ for (const auto& r : listReceived)
if (pwalletMain->mapAddressBook.count(r.first))
mapAccountBalances[pwalletMain->mapAddressBook[r.first]] += r.second;
else
list<CAccountingEntry> acentries;
CWalletDB(pwalletMain->strWalletFile).ListAccountCreditDebit("*", acentries);
- BOOST_FOREACH(const CAccountingEntry& entry, acentries)
+ for (const CAccountingEntry& entry : acentries)
mapAccountBalances[entry.strAccount] += entry.nCreditDebit;
Object ret;
- BOOST_FOREACH(const PAIRTYPE(string, int64)& accountBalance, mapAccountBalances) {
+ for (const auto& accountBalance : mapAccountBalances) {
ret.push_back(Pair(accountBalance.first, ValueFromAmount(accountBalance.second)));
}
return ret;
TxToJSON(wtx, 0, entry);
- int64 nCredit = wtx.GetCredit(filter);
- int64 nDebit = wtx.GetDebit(filter);
- int64 nNet = nCredit - nDebit;
- int64 nFee = (wtx.IsFromMe(filter) ? wtx.GetValueOut() - nDebit : 0);
+ int64_t nCredit = wtx.GetCredit(filter);
+ int64_t nDebit = wtx.GetDebit(filter);
+ int64_t nNet = nCredit - nDebit;
+ int64_t nFee = (wtx.IsFromMe(filter) ? wtx.GetValueOut() - nDebit : 0);
entry.push_back(Pair("amount", ValueFromAmount(nNet - nFee)));
if (wtx.IsFromMe(filter))
if (fHelp || params.size() > 1)
throw runtime_error(
"keypoolrefill [new-size]\n"
- "Fills the keypool."
+ "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(GetArg("-keypool", 100), 0LL);
+ unsigned int nSize = 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");
return Value::null;
}
+Value keypoolreset(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw 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);
+ if (params.size() > 0) {
+ if (params[0].get_int() < 0)
+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, expected valid size");
+ nSize = (unsigned int) params[0].get_int();
+ }
+
+ EnsureWalletIsUnlocked();
+
+ pwalletMain->NewKeyPool(nSize);
+
+ if (pwalletMain->GetKeyPoolSize() < nSize)
+ throw JSONRPCError(RPC_WALLET_ERROR, "Error refreshing keypool.");
+
+ return Value::null;
+}
+
void ThreadTopUpKeyPool(void* parg)
{
// Make this thread recognisable as the wallet relocking thread
RenameThread("novacoin-lock-wa");
- int64 nMyWakeTime = GetTimeMillis() + *((int64*)parg) * 1000;
+ int64_t nMyWakeTime = GetTimeMillis() + *((int64_t*)parg) * 1000;
ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
{
nWalletUnlockTime = nMyWakeTime;
- do
+ for ( ; ; )
{
if (nWalletUnlockTime==0)
break;
- int64 nToSleep = nWalletUnlockTime - GetTimeMillis();
+ int64_t nToSleep = nWalletUnlockTime - GetTimeMillis();
if (nToSleep <= 0)
break;
Sleep(nToSleep);
ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
- } while(1);
+ };
if (nWalletUnlockTime)
{
LEAVE_CRITICAL_SECTION(cs_nWalletUnlockTime);
- delete (int64*)parg;
+ delete (int64_t*)parg;
}
Value walletpassphrase(const Array& params, bool fHelp)
"Stores the wallet decryption key in memory for <timeout> seconds.");
NewThread(ThreadTopUpKeyPool, NULL);
- int64* pnSleepTime = new int64(params[1].get_int64());
+ int64_t* pnSleepTime = new int64_t(params[1].get_int64());
NewThread(ThreadCleanWalletPassphrase, pnSleepTime);
// ppcoin: if user OS account compromised prevent trivial sendmoney commands
obj.push_back(Pair("isscript", false));
if (mine == MINE_SPENDABLE) {
pwalletMain->GetPubKey(keyID, vchPubKey);
- obj.push_back(Pair("pubkey", HexStr(vchPubKey.Raw())));
+ obj.push_back(Pair("pubkey", HexStr(vchPubKey.begin(), vchPubKey.end())));
obj.push_back(Pair("iscompressed", vchPubKey.IsCompressed()));
}
return obj;
obj.push_back(Pair("script", GetTxnOutputType(whichType)));
obj.push_back(Pair("hex", HexStr(subscript.begin(), subscript.end())));
Array a;
- BOOST_FOREACH(const CTxDestination& addr, addresses)
+ for (const CTxDestination& addr : addresses)
a.push_back(CBitcoinAddress(addr).ToString());
obj.push_back(Pair("addresses", a));
if (whichType == TX_MULTISIG)
ret.push_back(Pair("isvalid", isValid));
if (isValid)
{
- CTxDestination dest = address.Get();
- string currentAddress = address.ToString();
- ret.push_back(Pair("address", currentAddress));
- isminetype mine = pwalletMain ? IsMine(*pwalletMain, dest) : MINE_NO;
- ret.push_back(Pair("ismine", mine != MINE_NO));
- if (mine != MINE_NO) {
- ret.push_back(Pair("watchonly", mine == MINE_WATCH_ONLY));
- Object detail = boost::apply_visitor(DescribeAddressVisitor(mine), dest);
- ret.insert(ret.end(), detail.begin(), detail.end());
+ if (address.IsPair())
+ {
+ CMalleablePubKey mpk;
+ mpk.setvch(address.GetData());
+ ret.push_back(Pair("ispair", true));
+
+ CMalleableKeyView view;
+ bool isMine = pwalletMain->GetMalleableView(mpk, view);
+ ret.push_back(Pair("ismine", isMine));
+ ret.push_back(Pair("PubkeyPair", mpk.ToString()));
+
+ if (isMine)
+ ret.push_back(Pair("KeyView", view.ToString()));
+ }
+ else
+ {
+ string currentAddress = address.ToString();
+ CTxDestination dest = address.Get();
+ ret.push_back(Pair("address", currentAddress));
+ isminetype mine = pwalletMain ? IsMine(*pwalletMain, address) : MINE_NO;
+ ret.push_back(Pair("ismine", mine != MINE_NO));
+ if (mine != MINE_NO) {
+ ret.push_back(Pair("watchonly", mine == MINE_WATCH_ONLY));
+ Object detail = std::visit(DescribeAddressVisitor(mine), dest);
+ ret.insert(ret.end(), detail.begin(), detail.end());
+ }
+ if (pwalletMain->mapAddressBook.count(address))
+ ret.push_back(Pair("account", pwalletMain->mapAddressBook[address]));
}
- if (pwalletMain->mapAddressBook.count(dest))
- ret.push_back(Pair("account", pwalletMain->mapAddressBook[dest]));
}
return ret;
}
{
if (params.size() == 1)
throw runtime_error("must provide amount to reserve balance.\n");
- int64 nAmount = AmountFromValue(params[1]);
+ int64_t nAmount = AmountFromValue(params[1]);
nAmount = (nAmount / CENT) * CENT; // round to cent
if (nAmount < 0)
throw runtime_error("amount cannot be negative.\n");
- mapArgs["-reservebalance"] = FormatMoney(nAmount).c_str();
+ mapArgs["-reservebalance"] = FormatMoney(nAmount);
}
else
{
}
Object result;
- int64 nReserveBalance = 0;
if (mapArgs.count("-reservebalance") && !ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
throw runtime_error("invalid reserve balance amount\n");
result.push_back(Pair("reserve", (nReserveBalance > 0)));
"Check wallet for integrity.\n");
int nMismatchSpent;
- int64 nBalanceInQuestion;
+ int64_t nBalanceInQuestion;
pwalletMain->FixSpentCoins(nMismatchSpent, nBalanceInQuestion, true);
Object result;
if (nMismatchSpent == 0)
"Repair wallet if checkwallet reports any problem.\n");
int nMismatchSpent;
- int64 nBalanceInQuestion;
+ int64_t nBalanceInQuestion;
pwalletMain->FixSpentCoins(nMismatchSpent, nBalanceInQuestion);
Object result;
if (nMismatchSpent == 0)
"Re-send unconfirmed transactions.\n"
);
- ResendWalletTransactions();
+ ResendWalletTransactions(true);
return Value::null;
}
-// ppcoin: make a public-private key pair
+Value resendwallettransactions(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw 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"
+ "automatically.\n"
+ "Returns array of transaction ids that were re-broadcast.\n"
+ );
+
+ LOCK2(cs_main, pwalletMain->cs_wallet);
+
+ std::vector<uint256> txids = pwalletMain->ResendWalletTransactionsBefore(GetTime());
+ Array result;
+ for (const uint256& txid : txids)
+ {
+ result.push_back(txid.ToString());
+ }
+ return result;
+}
+
+
+// Make a public-private key pair
Value makekeypair(const Array& params, bool fHelp)
{
- if (fHelp || params.size() > 1)
+ if (fHelp || params.size() > 0)
throw runtime_error(
- "makekeypair [prefix]\n"
- "Make a public/private key pair.\n"
- "[prefix] is optional preferred prefix for the public key.\n");
+ "makekeypair\n"
+ "Make a public/private key pair.\n");
string strPrefix = "";
if (params.size() > 0)
strPrefix = params[0].get_str();
-
+
CKey key;
- key.MakeNewKey(false);
+ key.MakeNewKey(true);
CPrivKey vchPrivKey = key.GetPrivKey();
Object result;
result.push_back(Pair("PrivateKey", HexStr<CPrivKey::iterator>(vchPrivKey.begin(), vchPrivKey.end())));
- result.push_back(Pair("PublicKey", HexStr(key.GetPubKey().Raw())));
+
+ bool fCompressed;
+ CSecret vchSecret = key.GetSecret(fCompressed);
+ CPubKey vchPubKey = key.GetPubKey();
+ result.push_back(Pair("Secret", HexStr<CSecret::iterator>(vchSecret.begin(), vchSecret.end())));
+ result.push_back(Pair("PublicKey", HexStr(vchPubKey.begin(), vchPubKey.end())));
+ return result;
+}
+
+Value newmalleablekey(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw 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;
+ if (params.size() > 0)
+ strAccount = AccountFromValue(params[0]);
+
+ CMalleableKeyView keyView = pwalletMain->GenerateNewMalleableKey();
+
+ CMalleableKey mKey;
+ if (!pwalletMain->GetMalleableKey(keyView, mKey))
+ throw runtime_error("Unable to generate new malleable key");
+
+ CMalleablePubKey mPubKey = mKey.GetMalleablePubKey();
+ CBitcoinAddress address(mPubKey);
+
+ pwalletMain->SetAddressBookName(address, strAccount);
+
+ Object result;
+ result.push_back(Pair("PublicPair", mPubKey.ToString()));
+ result.push_back(Pair("PublicBytes", HexStr(mPubKey.Raw())));
+ result.push_back(Pair("Address", address.ToString()));
+ result.push_back(Pair("KeyView", keyView.ToString()));
+
return result;
}
+
+Value adjustmalleablekey(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 3)
+ throw 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");
+
+ CMalleableKey malleableKey;
+ malleableKey.SetString(params[0].get_str());
+
+ CKey privKeyVariant;
+ CPubKey vchPubKeyVariant = CPubKey(ParseHex(params[1].get_str()));
+
+ CPubKey R(ParseHex(params[2].get_str()));
+
+ if (!malleableKey.CheckKeyVariant(R,vchPubKeyVariant, privKeyVariant)) {
+ throw runtime_error("Unable to calculate the private key");
+ }
+
+ Object result;
+ bool fCompressed;
+ CSecret vchPrivKeyVariant = privKeyVariant.GetSecret(fCompressed);
+
+ result.push_back(Pair("PrivateKey", CBitcoinSecret(vchPrivKeyVariant, fCompressed).ToString()));
+
+ return result;
+}
+
+Value adjustmalleablepubkey(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 2 || params.size() == 0)
+ throw 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();
+ CMalleablePubKey malleablePubKey;
+
+ do
+ {
+ CBitcoinAddress addr(strData);
+ if (addr.IsValid() && addr.IsPair())
+ {
+ // Initialize malleable pubkey with address data
+ malleablePubKey = CMalleablePubKey(addr.GetData());
+ break;
+ }
+ CMalleableKeyView viewTmp(strData);
+ if (viewTmp.IsValid())
+ {
+ // Shazaam, we have a valid key view here.
+ malleablePubKey = viewTmp.GetMalleablePubKey();
+ break;
+ }
+ 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.");
+ }
+ while(false);
+
+ CPubKey R, vchPubKeyVariant;
+ malleablePubKey.GetVariant(R, vchPubKeyVariant);
+
+ Object result;
+ result.push_back(Pair("R", HexStr(R.begin(), R.end())));
+ result.push_back(Pair("PubkeyVariant", HexStr(vchPubKeyVariant.begin(), vchPubKeyVariant.end())));
+ result.push_back(Pair("KeyVariantID", CBitcoinAddress(vchPubKeyVariant.GetID()).ToString()));
+
+ return result;
+}
+
+Value listmalleableviews(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "listmalleableviews\n"
+ "Get list of views for generated malleable keys.\n");
+
+ std::list<CMalleableKeyView> keyViewList;
+ pwalletMain->ListMalleableViews(keyViewList);
+
+ Array result;
+ for (const CMalleableKeyView &keyView : keyViewList)
+ {
+ result.push_back(keyView.ToString());
+ }
+
+ return result;
+}
+