{

return pwalletMain && pwalletMain->IsCrypted()

? "\nRequires wallet passphrase to be set with walletpassphrase call."

: "";

{

if (pwalletMain->IsLocked())

throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");

{

int confirms = wtx.GetDepthInMainChain();

entry.push_back(Pair("confirmations", confirms));

if (wtx.IsCoinBase())

entry.push_back(Pair("generated", true));

if (confirms > 0)

{

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)));

}

uint256 hash = wtx.GetHash();

entry.push_back(Pair("txid", hash.GetHex()));

Array conflicts;

BOOST_FOREACH(const uint256& conflict, wtx.GetConflicts())

conflicts.push_back(conflict.GetHex());

entry.push_back(Pair("walletconflicts", conflicts));

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(item.first, item.second));

{

string strAccount = value.get_str();

if (strAccount == "*")

throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Invalid account name");

return strAccount;

{

if (fHelp || params.size() > 1)

throw runtime_error(

"getnewaddress ( \"account\" )\n"

"\nReturns a new Sidecoin address for receiving payments.\n"

"If 'account' is specified (recommended), it is added to the address book \n"

"so payments received with the address will be credited to 'account'.\n"

"\nArguments:\n"

"1. \"account\" (string, optional) The account name for the address to be linked to. if not provided, the default account \"\" is used. It can also be set to the empty string \"\" to represent the default account. The account does not need to exist, it will be created if there is no account by the given name.\n"

"\nResult:\n"

"\"sidecoinaddress\" (string) The new sidecoin address\n"

"\nExamples:\n"

+ HelpExampleCli("getnewaddress", "")

+ HelpExampleCli("getnewaddress", "\"\"")

+ HelpExampleCli("getnewaddress", "\"myaccount\"")

+ HelpExampleRpc("getnewaddress", "\"myaccount\"")

);

// 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]);

if (!pwalletMain->IsLocked())

pwalletMain->TopUpKeyPool();

// Generate a new key that is added to wallet

CPubKey newKey;

if (!pwalletMain->GetKeyFromPool(newKey))

throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");

CKeyID keyID = newKey.GetID();

pwalletMain->SetAddressBook(keyID, strAccount, "receive");

return CSidecoinAddress(keyID).ToString();

{

CWalletDB walletdb(pwalletMain->strWalletFile);

CAccount account;

walletdb.ReadAccount(strAccount, account);

bool bKeyUsed = false;

// Check if the current key has been used

if (account.vchPubKey.IsValid())

{

CScript scriptPubKey;

scriptPubKey.SetDestination(account.vchPubKey.GetID());

for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin();

it != pwalletMain->mapWallet.end() && account.vchPubKey.IsValid();

++it)

{

const CWalletTx& wtx = (*it).second;

BOOST_FOREACH(const CTxOut& txout, wtx.vout)

if (txout.scriptPubKey == scriptPubKey)

bKeyUsed = true;

}

}

// Generate a new key

if (!account.vchPubKey.IsValid() || bForceNew || bKeyUsed)

{

if (!pwalletMain->GetKeyFromPool(account.vchPubKey))

throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");

pwalletMain->SetAddressBook(account.vchPubKey.GetID(), strAccount, "receive");

walletdb.WriteAccount(strAccount, account);

}

return CSidecoinAddress(account.vchPubKey.GetID());

{

if (fHelp || params.size() != 1)

throw runtime_error(

"getaccountaddress \"account\"\n"

"\nReturns the current Sidecoin address for receiving payments to this account.\n"

"\nArguments:\n"

"1. \"account\" (string, required) The account name for the address. It can also be set to the empty string \"\" to represent the default account. The account does not need to exist, it will be created and a new address created if there is no account by the given name.\n"

"\nResult:\n"

"\"sidecoinaddress\" (string) The account sidecoin address\n"

"\nExamples:\n"

+ HelpExampleCli("getaccountaddress", "")

+ HelpExampleCli("getaccountaddress", "\"\"")

+ HelpExampleCli("getaccountaddress", "\"myaccount\"")

+ HelpExampleRpc("getaccountaddress", "\"myaccount\"")

);

// Parse the account first so we don't generate a key if there's an error

string strAccount = AccountFromValue(params[0]);

Value ret;

ret = GetAccountAddress(strAccount).ToString();

return ret;

{

if (fHelp || params.size() > 1)

throw runtime_error(

"getrawchangeaddress\n"

"\nReturns a new Sidecoin address, for receiving change.\n"

"This is for use with raw transactions, NOT normal use.\n"

"\nResult:\n"

"\"address\" (string) The address\n"

"\nExamples:\n"

+ HelpExampleCli("getrawchangeaddress", "")

+ HelpExampleRpc("getrawchangeaddress", "")

);

if (!pwalletMain->IsLocked())

pwalletMain->TopUpKeyPool();

CReserveKey reservekey(pwalletMain);

CPubKey vchPubKey;

if (!reservekey.GetReservedKey(vchPubKey))

throw JSONRPCError(RPC_WALLET_ERROR, "Error: Unable to obtain key for change");

reservekey.KeepKey();

CKeyID keyID = vchPubKey.GetID();

return CSidecoinAddress(keyID).ToString();

{

if (fHelp || params.size() < 1 || params.size() > 2)

throw runtime_error(

"setaccount \"sidecoinaddress\" \"account\"\n"

"\nSets the account associated with the given address.\n"

"\nArguments:\n"

"1. \"sidecoinaddress\" (string, required) The sidecoin address to be associated with an account.\n"

"2. \"account\" (string, required) The account to assign the address to.\n"

"\nExamples:\n"

+ HelpExampleCli("setaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"tabby\"")

+ HelpExampleRpc("setaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", \"tabby\"")

);

CSidecoinAddress address(params[0].get_str());

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Sidecoin address");

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.Get()))

{

string strOldAccount = pwalletMain->mapAddressBook[address.Get()].name;

if (address == GetAccountAddress(strOldAccount))

GetAccountAddress(strOldAccount, true);

}

pwalletMain->SetAddressBook(address.Get(), strAccount, "receive");

return Value::null;

{

if (fHelp || params.size() != 1)

throw runtime_error(

"getaccount \"sidecoinaddress\"\n"

"\nReturns the account associated with the given address.\n"

"\nArguments:\n"

"1. \"sidecoinaddress\" (string, required) The sidecoin address for account lookup.\n"

"\nResult:\n"

"\"accountname\" (string) the account address\n"

"\nExamples:\n"

+ HelpExampleCli("getaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"")

+ HelpExampleRpc("getaccount", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"")

);

CSidecoinAddress address(params[0].get_str());

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Sidecoin address");

string strAccount;

map<CTxDestination, CAddressBookData>::iterator mi = pwalletMain->mapAddressBook.find(address.Get());

if (mi != pwalletMain->mapAddressBook.end() && !(*mi).second.name.empty())

strAccount = (*mi).second.name;

return strAccount;

{

if (fHelp || params.size() != 1)

throw runtime_error(

"getaddressesbyaccount \"account\"\n"

"\nReturns the list of addresses for the given account.\n"

"\nArguments:\n"

"1. \"account\" (string, required) The account name.\n"

"\nResult:\n"

"[ (json array of string)\n"

" \"sidecoinaddress\" (string) a sidecoin address associated with the given account\n"

" ,...\n"

"]\n"

"\nExamples:\n"

+ HelpExampleCli("getaddressesbyaccount", "\"tabby\"")

+ HelpExampleRpc("getaddressesbyaccount", "\"tabby\"")

);

string strAccount = AccountFromValue(params[0]);

// Find all addresses that have the given account

Array ret;

BOOST_FOREACH(const PAIRTYPE(CSidecoinAddress, CAddressBookData)& item, pwalletMain->mapAddressBook)

{

const CSidecoinAddress& address = item.first;

const string& strName = item.second.name;

if (strName == strAccount)

ret.push_back(address.ToString());

}

return ret;

{

if (fHelp || params.size() < 2 || params.size() > 4)

throw runtime_error(

"sendtoaddress \"sidecoinaddress\" amount ( \"comment\" \"comment-to\" )\n"

"\nSent an amount to a given address. The amount is a real and is rounded to the nearest 0.00000001\n"

+ HelpRequiringPassphrase() +

"\nArguments:\n"

"1. \"sidecoinaddress\" (string, required) The sidecoin address to send to.\n"

"2. \"amount\" (numeric, required) The amount in btc to send. eg 0.1\n"

"3. \"comment\" (string, optional) A comment used to store what the transaction is for. \n"

" This is not part of the transaction, just kept in your wallet.\n"

"4. \"comment-to\" (string, optional) A comment to store the name of the person or organization \n"

" to which you're sending the transaction. This is not part of the \n"

" transaction, just kept in your wallet.\n"

"\nResult:\n"

"\"transactionid\" (string) The transaction id. (view at https://blockchain.info/tx/[transactionid])\n"

"\nExamples:\n"

+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1")

+ HelpExampleCli("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.1 \"donation\" \"seans outpost\"")

+ HelpExampleRpc("sendtoaddress", "\"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", 0.1, \"donation\", \"seans outpost\"")

);

CSidecoinAddress address(params[0].get_str());

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Sidecoin address");

// Amount

int64_t nAmount = AmountFromValue(params[1]);

// Wallet comments

CWalletTx wtx;

if (params.size() > 2 && params[2].type() != null_type && !params[2].get_str().empty())

wtx.mapValue["comment"] = params[2].get_str();

if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())

wtx.mapValue["to"] = params[3].get_str();

EnsureWalletIsUnlocked();

string strError = pwalletMain->SendMoneyToDestination(address.Get(), nAmount, wtx);

if (strError != "")

throw JSONRPCError(RPC_WALLET_ERROR, strError);

return wtx.GetHash().GetHex();

{

if (fHelp)

throw runtime_error(

"listaddressgroupings\n"

"\nLists 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\n"

"\nResult:\n"

"[\n"

" [\n"

" [\n"

" \"sidecoinaddress\", (string) The sidecoin address\n"

" amount, (numeric) The amount in btc\n"

" \"account\" (string, optional) The account\n"

" ]\n"

" ,...\n"

" ]\n"

" ,...\n"

"]\n"

"\nExamples:\n"

+ HelpExampleCli("listaddressgroupings", "")

+ HelpExampleRpc("listaddressgroupings", "")

);

Array jsonGroupings;

map<CTxDestination, int64_t> balances = pwalletMain->GetAddressBalances();

BOOST_FOREACH(set<CTxDestination> grouping, pwalletMain->GetAddressGroupings())

{

Array jsonGrouping;

BOOST_FOREACH(CTxDestination address, grouping)

{

Array addressInfo;

addressInfo.push_back(CSidecoinAddress(address).ToString());

addressInfo.push_back(ValueFromAmount(balances[address]));

{

LOCK(pwalletMain->cs_wallet);

if (pwalletMain->mapAddressBook.find(CSidecoinAddress(address).Get()) != pwalletMain->mapAddressBook.end())

addressInfo.push_back(pwalletMain->mapAddressBook.find(CSidecoinAddress(address).Get())->second.name);

}

jsonGrouping.push_back(addressInfo);

}

jsonGroupings.push_back(jsonGrouping);

}

return jsonGroupings;

{

if (fHelp || params.size() != 2)

throw runtime_error(

"signmessage \"sidecoinaddress\" \"message\"\n"

"\nSign a message with the private key of an address"

+ HelpRequiringPassphrase() + "\n"

"\nArguments:\n"

"1. \"sidecoinaddress\" (string, required) The sidecoin address to use for the private key.\n"

"2. \"message\" (string, required) The message to create a signature of.\n"

"\nResult:\n"

"\"signature\" (string) The signature of the message encoded in base 64\n"

"\nExamples:\n"

"\nUnlock the wallet for 30 seconds\n"

+ HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +

"\nCreate the signature\n"

+ HelpExampleCli("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"my message\"") +

"\nVerify the signature\n"

+ HelpExampleCli("verifymessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" \"signature\" \"my message\"") +

"\nAs json rpc\n"

+ HelpExampleRpc("signmessage", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", \"my message\"")

);

EnsureWalletIsUnlocked();

string strAddress = params[0].get_str();

string strMessage = params[1].get_str();

CSidecoinAddress addr(strAddress);

if (!addr.IsValid())

throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");

CKeyID keyID;

if (!addr.GetKeyID(keyID))

throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");

CKey key;

if (!pwalletMain->GetKey(keyID, key))

throw JSONRPCError(RPC_WALLET_ERROR, "Private key not available");

CHashWriter ss(SER_GETHASH, 0);

ss << strMessageMagic;

ss << strMessage;

vector<unsigned char> vchSig;

if (!key.SignCompact(ss.GetHash(), vchSig))

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");

return EncodeBase64(&vchSig[0], vchSig.size());

{

if (fHelp || params.size() < 1 || params.size() > 2)

throw runtime_error(

"getreceivedbyaddress \"sidecoinaddress\" ( minconf )\n"

"\nReturns the total amount received by the given sidecoinaddress in transactions with at least minconf confirmations.\n"

"\nArguments:\n"

"1. \"sidecoinaddress\" (string, required) The sidecoin address for transactions.\n"

"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"

"\nResult:\n"

"amount (numeric) The total amount in btc received at this address.\n"

"\nExamples:\n"

"\nThe amount from transactions with at least 1 confirmation\n"

+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\"") +

"\nThe amount including unconfirmed transactions, zero confirmations\n"

+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" 0") +

"\nThe amount with at least 6 confirmation, very safe\n"

+ HelpExampleCli("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\" 6") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("getreceivedbyaddress", "\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\", 6")

);

// Sidecoin address

CSidecoinAddress address = CSidecoinAddress(params[0].get_str());

CScript scriptPubKey;

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Sidecoin address");

scriptPubKey.SetDestination(address.Get());

if (!IsMine(*pwalletMain,scriptPubKey))

return (double)0.0;

// Minimum confirmations

int nMinDepth = 1;

if (params.size() > 1)

nMinDepth = params[1].get_int();

// Tally

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() || !IsFinalTx(wtx))

continue;

BOOST_FOREACH(const CTxOut& txout, wtx.vout)

if (txout.scriptPubKey == scriptPubKey)

if (wtx.GetDepthInMainChain() >= nMinDepth)

nAmount += txout.nValue;

}

return ValueFromAmount(nAmount);

{

if (fHelp || params.size() < 1 || params.size() > 2)

throw runtime_error(

"getreceivedbyaccount \"account\" ( minconf )\n"

"\nReturns the total amount received by addresses with <account> in transactions with at least [minconf] confirmations.\n"

"\nArguments:\n"

"1. \"account\" (string, required) The selected account, may be the default account using \"\".\n"

"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"

"\nResult:\n"

"amount (numeric) The total amount in btc received for this account.\n"

"\nExamples:\n"

"\nAmount received by the default account with at least 1 confirmation\n"

+ HelpExampleCli("getreceivedbyaccount", "\"\"") +

"\nAmount received at the tabby account including unconfirmed amounts with zero confirmations\n"

+ HelpExampleCli("getreceivedbyaccount", "\"tabby\" 0") +

"\nThe amount with at least 6 confirmation, very safe\n"

+ HelpExampleCli("getreceivedbyaccount", "\"tabby\" 6") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("getreceivedbyaccount", "\"tabby\", 6")

);

// Minimum confirmations

int nMinDepth = 1;

if (params.size() > 1)

nMinDepth = params[1].get_int();

// Get the set of pub keys assigned to account

string strAccount = AccountFromValue(params[0]);

set<CTxDestination> setAddress = pwalletMain->GetAccountAddresses(strAccount);

// Tally

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() || !IsFinalTx(wtx))

continue;

BOOST_FOREACH(const CTxOut& txout, wtx.vout)

{

CTxDestination address;

if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*pwalletMain, address) && setAddress.count(address))

if (wtx.GetDepthInMainChain() >= nMinDepth)

nAmount += txout.nValue;

}

}

return (double)nAmount / (double)COIN;

{

int64_t nBalance = 0;

// Tally wallet transactions

for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)

{

const CWalletTx& wtx = (*it).second;

if (!IsFinalTx(wtx) || wtx.GetBlocksToMaturity() > 0 || wtx.GetDepthInMainChain() < 0)

continue;

int64_t nReceived, nSent, nFee;

wtx.GetAccountAmounts(strAccount, nReceived, nSent, nFee);

if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth)

nBalance += nReceived;

nBalance -= nSent + nFee;

}

// Tally internal accounting entries

nBalance += walletdb.GetAccountCreditDebit(strAccount);

return nBalance;

{

CWalletDB walletdb(pwalletMain->strWalletFile);

return GetAccountBalance(walletdb, strAccount, nMinDepth);

{

if (fHelp || params.size() > 2)

throw runtime_error(

"getbalance ( \"account\" minconf )\n"

"\nIf account is not specified, returns the server's total available balance.\n"

"If account is specified, returns the balance in the account.\n"

"Note that the account \"\" is not the same as leaving the parameter out.\n"

"The server total may be different to the balance in the default \"\" account.\n"

"\nArguments:\n"

"1. \"account\" (string, optional) The selected account, or \"*\" for entire wallet. It may be the default account using \"\".\n"

"2. minconf (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"

"\nResult:\n"

"amount (numeric) The total amount in btc received for this account.\n"

"\nExamples:\n"

"\nThe total amount in the server across all accounts\n"

+ HelpExampleCli("getbalance", "") +

"\nThe total amount in the server across all accounts, with at least 5 confirmations\n"

+ HelpExampleCli("getbalance", "\"*\" 6") +

"\nThe total amount in the default account with at least 1 confirmation\n"

+ HelpExampleCli("getbalance", "\"\"") +

"\nThe total amount in the account named tabby with at least 6 confirmations\n"

+ HelpExampleCli("getbalance", "\"tabby\" 6") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("getbalance", "\"tabby\", 6")

);

if (params.size() == 0)

return ValueFromAmount(pwalletMain->GetBalance());

int nMinDepth = 1;

if (params.size() > 1)

nMinDepth = params[1].get_int();

if (params[0].get_str() == "*") {

// Calculate total balance a different way from GetBalance()

// (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)

{

const CWalletTx& wtx = (*it).second;

if (!wtx.IsTrusted() || wtx.GetBlocksToMaturity() > 0)

continue;

int64_t allFee;

string strSentAccount;

list<pair<CTxDestination, int64_t> > listReceived;

list<pair<CTxDestination, int64_t> > listSent;

wtx.GetAmounts(listReceived, listSent, allFee, strSentAccount);

if (wtx.GetDepthInMainChain() >= nMinDepth)

{

BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64_t)& r, listReceived)

nBalance += r.second;

}

BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64_t)& r, listSent)

nBalance -= r.second;

nBalance -= allFee;

}

return ValueFromAmount(nBalance);

}

string strAccount = AccountFromValue(params[0]);

int64_t nBalance = GetAccountBalance(strAccount, nMinDepth);

return ValueFromAmount(nBalance);

{

if (fHelp || params.size() > 0)

throw runtime_error(

"getunconfirmedbalance\n"

"Returns the server's total unconfirmed balance\n");

return ValueFromAmount(pwalletMain->GetUnconfirmedBalance());

{

if (fHelp || params.size() < 3 || params.size() > 5)

throw runtime_error(

"move \"fromaccount\" \"toaccount\" amount ( minconf \"comment\" )\n"

"\nMove a specified amount from one account in your wallet to another.\n"

"\nArguments:\n"

"1. \"fromaccount\" (string, required) The name of the account to move funds from. May be the default account using \"\".\n"

"2. \"toaccount\" (string, required) The name of the account to move funds to. May be the default account using \"\".\n"

"3. minconf (numeric, optional, default=1) Only use funds with at least this many confirmations.\n"

"4. \"comment\" (string, optional) An optional comment, stored in the wallet only.\n"

"\nResult:\n"

"true|false (boolean) true if successfull.\n"

"\nExamples:\n"

"\nMove 0.01 btc from the default account to the account named tabby\n"

+ HelpExampleCli("move", "\"\" \"tabby\" 0.01") +

"\nMove 0.01 btc timotei to akiko with a comment and funds have 6 confirmations\n"

+ HelpExampleCli("move", "\"timotei\" \"akiko\" 0.01 6 \"happy birthday!\"") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("move", "\"timotei\", \"akiko\", 0.01, 6, \"happy birthday!\"")

);

string strFrom = AccountFromValue(params[0]);

string strTo = AccountFromValue(params[1]);

int64_t nAmount = AmountFromValue(params[2]);

if (params.size() > 3)

// unused parameter, used to be nMinDepth, keep type-checking it though

(void)params[3].get_int();

string strComment;

if (params.size() > 4)

strComment = params[4].get_str();

CWalletDB walletdb(pwalletMain->strWalletFile);

if (!walletdb.TxnBegin())

throw JSONRPCError(RPC_DATABASE_ERROR, "database error");

int64_t nNow = GetAdjustedTime();

// Debit

CAccountingEntry debit;

debit.nOrderPos = pwalletMain->IncOrderPosNext(&walletdb);

debit.strAccount = strFrom;

debit.nCreditDebit = -nAmount;

debit.nTime = nNow;

debit.strOtherAccount = strTo;

debit.strComment = strComment;

walletdb.WriteAccountingEntry(debit);

// Credit

CAccountingEntry credit;

credit.nOrderPos = pwalletMain->IncOrderPosNext(&walletdb);

credit.strAccount = strTo;

credit.nCreditDebit = nAmount;

credit.nTime = nNow;

credit.strOtherAccount = strFrom;

credit.strComment = strComment;

walletdb.WriteAccountingEntry(credit);

if (!walletdb.TxnCommit())

throw JSONRPCError(RPC_DATABASE_ERROR, "database error");

return true;

{

if (fHelp || params.size() < 3 || params.size() > 6)

throw runtime_error(

"sendfrom \"fromaccount\" \"tosidecoinaddress\" amount ( minconf \"comment\" \"comment-to\" )\n"

"\nSent an amount from an account to a sidecoin address.\n"

"The amount is a real and is rounded to the nearest 0.00000001."

+ HelpRequiringPassphrase() + "\n"

"\nArguments:\n"

"1. \"fromaccount\" (string, required) The name of the account to send funds from. May be the default account using \"\".\n"

"2. \"tosidecoinaddress\" (string, required) The sidecoin address to send funds to.\n"

"3. amount (numeric, required) The amount in btc. (transaction fee is added on top).\n"

"4. minconf (numeric, optional, default=1) Only use funds with at least this many confirmations.\n"

"5. \"comment\" (string, optional) A comment used to store what the transaction is for. \n"

" This is not part of the transaction, just kept in your wallet.\n"

"6. \"comment-to\" (string, optional) An optional comment to store the name of the person or organization \n"

" to which you're sending the transaction. This is not part of the transaction, \n"

" it is just kept in your wallet.\n"

"\nResult:\n"

"\"transactionid\" (string) The transaction id. (view at https://blockchain.info/tx/[transactionid])\n"

"\nExamples:\n"

"\nSend 0.01 btc from the default account to the address, must have at least 1 confirmation\n"

+ HelpExampleCli("sendfrom", "\"\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.01") +

"\nSend 0.01 from the tabby account to the given address, funds must have at least 6 confirmations\n"

+ HelpExampleCli("sendfrom", "\"tabby\" \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\" 0.01 6 \"donation\" \"seans outpost\"") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("sendfrom", "\"tabby\", \"1M72Sfpbz1BPpXFHz9m3CdqATR44Jvaydd\", 0.01, 6, \"donation\", \"seans outpost\"")

);

string strAccount = AccountFromValue(params[0]);

CSidecoinAddress address(params[1].get_str());

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Sidecoin address");

int64_t nAmount = AmountFromValue(params[2]);

int nMinDepth = 1;

if (params.size() > 3)

nMinDepth = params[3].get_int();

CWalletTx wtx;

wtx.strFromAccount = strAccount;

if (params.size() > 4 && params[4].type() != null_type && !params[4].get_str().empty())

wtx.mapValue["comment"] = params[4].get_str();

if (params.size() > 5 && params[5].type() != null_type && !params[5].get_str().empty())

wtx.mapValue["to"] = params[5].get_str();

EnsureWalletIsUnlocked();

// Check funds

int64_t nBalance = GetAccountBalance(strAccount, nMinDepth);

if (nAmount > nBalance)

throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");

// Send

string strError = pwalletMain->SendMoneyToDestination(address.Get(), nAmount, wtx);

if (strError != "")

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 \"comment\" )\n"

"\nSend multiple times. Amounts are double-precision floating point numbers."

+ HelpRequiringPassphrase() + "\n"

"\nArguments:\n"

"1. \"fromaccount\" (string, required) The account to send the funds from, can be \"\" for the default account\n"

"2. \"amounts\" (string, required) A json object with addresses and amounts\n"

" {\n"

" \"address\":amount (numeric) The sidecoin address is the key, the numeric amount in btc is the value\n"

" ,...\n"

" }\n"

"3. minconf (numeric, optional, default=1) Only use the balance confirmed at least this many times.\n"

"4. \"comment\" (string, optional) A comment\n"

"\nResult:\n"

"\"transactionid\" (string) The transaction id for the send. Only 1 transaction is created regardless of \n"

" the number of addresses. See https://blockchain.info/tx/[transactionid]\n"

"\nExamples:\n"

"\nSend two amounts to two different addresses:\n"

+ HelpExampleCli("sendmany", "\"tabby\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\"") +

"\nSend two amounts to two different addresses setting the confirmation and comment:\n"

+ HelpExampleCli("sendmany", "\"tabby\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" 6 \"testing\"") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("sendmany", "\"tabby\", \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\", 6, \"testing\"")

);

string strAccount = AccountFromValue(params[0]);

Object sendTo = params[1].get_obj();

int nMinDepth = 1;

if (params.size() > 2)

nMinDepth = params[2].get_int();

CWalletTx wtx;

wtx.strFromAccount = strAccount;

if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())

wtx.mapValue["comment"] = params[3].get_str();

set<CSidecoinAddress> setAddress;

vector<pair<CScript, int64_t> > vecSend;

int64_t totalAmount = 0;

BOOST_FOREACH(const Pair& s, sendTo)

{

CSidecoinAddress address(s.name_);

if (!address.IsValid())

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid Sidecoin address: ")+s.name_);

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_t nAmount = AmountFromValue(s.value_);

totalAmount += nAmount;

vecSend.push_back(make_pair(scriptPubKey, nAmount));

}

EnsureWalletIsUnlocked();

// Check funds

int64_t nBalance = GetAccountBalance(strAccount, nMinDepth);

if (totalAmount > nBalance)

throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");

// Send

CReserveKey keyChange(pwalletMain);

int64_t nFeeRequired = 0;

string strFailReason;

bool fCreated = pwalletMain->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, strFailReason);

if (!fCreated)

throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);

if (!pwalletMain->CommitTransaction(wtx, keyChange))

throw JSONRPCError(RPC_WALLET_ERROR, "Transaction commit failed");

return wtx.GetHash().GetHex();

{

if (fHelp || params.size() < 2 || params.size() > 3)

{

string msg = "addmultisigaddress nrequired [\"key\",...] ( \"account\" )\n"

"\nAdd a nrequired-to-sign multisignature address to the wallet.\n"

"Each key is a Sidecoin address or hex-encoded public key.\n"

"If 'account' is specified, assign address to that account.\n"

"\nArguments:\n"

"1. nrequired (numeric, required) The number of required signatures out of the n keys or addresses.\n"

"2. \"keysobject\" (string, required) A json array of sidecoin addresses or hex-encoded public keys\n"

" [\n"

" \"address\" (string) sidecoin address or hex-encoded public key\n"

" ...,\n"

" ]\n"

"3. \"account\" (string, optional) An account to assign the addresses to.\n"

"\nResult:\n"

"\"sidecoinaddress\" (string) A sidecoin address associated with the keys.\n"

"\nExamples:\n"

"\nAdd a multisig address from 2 addresses\n"

+ HelpExampleCli("addmultisigaddress", "2 \"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\",\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"") +

"\nAs json rpc call\n"

+ HelpExampleRpc("addmultisigaddress", "2, \"[\\\"16sSauSf5pF2UkUwvKGq4qjNRzBZYqgEL5\\\",\\\"171sgjn4YtPu27adkKGrdDwzRTxnRkBfKV\\\"]\"")

;

throw runtime_error(msg);

}

string strAccount;

if (params.size() > 2)

strAccount = AccountFromValue(params[2]);

// Construct using pay-to-script-hash:

CScript inner = _createmultisig(params);

CScriptID innerID = inner.GetID();

pwalletMain->AddCScript(inner);

pwalletMain->SetAddressBook(innerID, strAccount, "send");

return CSidecoinAddress(innerID).ToString();

{

int64_t nAmount;

int nConf;

vector<uint256> txids;

tallyitem()

{

nAmount = 0;

nConf = std::numeric_limits<int>::max();

}

{

// Minimum confirmations

int nMinDepth = 1;

if (params.size() > 0)

nMinDepth = params[0].get_int();

// Whether to include empty accounts

bool fIncludeEmpty = false;

if (params.size() > 1)

fIncludeEmpty = params[1].get_bool();

// Tally

map<CSidecoinAddress, tallyitem> mapTally;

for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)

{

const CWalletTx& wtx = (*it).second;

if (wtx.IsCoinBase() || !IsFinalTx(wtx))

continue;

int nDepth = wtx.GetDepthInMainChain();

if (nDepth < nMinDepth)

continue;

BOOST_FOREACH(const CTxOut& txout, wtx.vout)

{

CTxDestination address;

if (!ExtractDestination(txout.scriptPubKey, address) || !IsMine(*pwalletMain, address))

continue;

tallyitem& item = mapTally[address];

item.nAmount += txout.nValue;

item.nConf = min(item.nConf, nDepth);

item.txids.push_back(wtx.GetHash());

}

}

// Reply

Array ret;

map<string, tallyitem> mapAccountTally;

BOOST_FOREACH(const PAIRTYPE(CSidecoinAddress, CAddressBookData)& item, pwalletMain->mapAddressBook)

{

const CSidecoinAddress& address = item.first;

const string& strAccount = item.second.name;

map<CSidecoinAddress, tallyitem>::iterator it = mapTally.find(address);

if (it == mapTally.end() && !fIncludeEmpty)

continue;

int64_t nAmount = 0;

int nConf = std::numeric_limits<int>::max();

if (it != mapTally.end())

{

nAmount = (*it).second.nAmount;

nConf = (*it).second.nConf;

}

if (fByAccounts)

{

tallyitem& item = mapAccountTally[strAccount];

item.nAmount += nAmount;

item.nConf = min(item.nConf, nConf);

}

else

{

Object obj;

obj.push_back(Pair("address", address.ToString()));

obj.push_back(Pair("account", strAccount));