text: // Copyright (c) 2010 Satoshi Nakamoto
  // Copyright (c) 2009-2012 The Bitcoin developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include "wallet.h"
  #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_t nWalletUnlockTime;
  static CCriticalSection cs_nWalletUnlockTime;
  
  extern int64_t nReserveBalance;
  extern void TxToJSON(const CTransaction& tx, const uint256& hashBlock, json_spirit::Object& entry);
  
  std::string HelpRequiringPassphrase()
  {
      return pwalletMain->IsCrypted()
          ? "\n\nRequires wallet passphrase to be set with walletpassphrase first"
          : "";
  }
  
  void EnsureWalletIsUnlocked()
  {
      if (pwalletMain->IsLocked())
          throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Please enter the wallet passphrase with walletpassphrase first.");
      if (fWalletUnlockMintOnly)
          throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Error: Wallet unlocked for block minting only.");
  }
  
  void WalletTxToJSON(const CWalletTx& wtx, Object& entry)
  {
      int confirms = wtx.GetDepthInMainChain();
      entry.push_back(Pair("confirmations", confirms));
      if (wtx.IsCoinBase() || wtx.IsCoinStake())
          entry.push_back(Pair("generated", true));
      if (confirms)
      {
          entry.push_back(Pair("blockhash", wtx.hashBlock.GetHex()));
          entry.push_back(Pair("blockindex", wtx.nIndex));
          entry.push_back(Pair("blocktime", (int64_t)(mapBlockIndex[wtx.hashBlock]->nTime)));
      }
      entry.push_back(Pair("txid", wtx.GetHash().GetHex()));
      entry.push_back(Pair("time", (int64_t)wtx.GetTxTime()));
      entry.push_back(Pair("timereceived", (int64_t)wtx.nTimeReceived));
      BOOST_FOREACH(const PAIRTYPE(string,string)& item, wtx.mapValue)
          entry.push_back(Pair(item.first, item.second));
  }
  
  string AccountFromValue(const Value& value)
  {
      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(
              "getinfo\n"
              "Returns an object containing various state info.");
  
      proxyType proxy;
      GetProxy(NET_IPV4, proxy);
  
      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("balance",       ValueFromAmount(pwalletMain->GetBalance())));
      obj.push_back(Pair("unspendable",       ValueFromAmount(pwalletMain->GetWatchOnlyBalance())));
      obj.push_back(Pair("newmint",       ValueFromAmount(pwalletMain->GetNewMint())));
      obj.push_back(Pair("stake",         ValueFromAmount(pwalletMain->GetStake())));
      obj.push_back(Pair("blocks",        (int)nBestHeight));
  
      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("ip",            addrSeenByPeer.ToStringIP()));
  
      diff.push_back(Pair("proof-of-work",  GetDifficulty()));
      diff.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
      obj.push_back(Pair("difficulty",    diff));
  
      obj.push_back(Pair("testnet",       fTestNet));
      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", (int64_t)nWalletUnlockTime / 1000));
      obj.push_back(Pair("errors",        GetWarnings("statusbar")));
      return obj;
  }
  
  Value getnewaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 1)
          throw runtime_error(
              "getnewaddress [account]\n"
              "Returns a new Taurus 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;
      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, false))
          throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
      CBitcoinAddress address(newKey.GetID());
  
      pwalletMain->SetAddressBookName(address, strAccount);
  
      return address.ToString();
  }
  
  
  CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
  {
      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, false))
              throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
  
          pwalletMain->SetAddressBookName(account.vchPubKey.GetID(), strAccount);
          walletdb.WriteAccount(strAccount, account);
      }
  
      return CBitcoinAddress(account.vchPubKey.GetID());
  }
  
  Value getaccountaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "getaccountaddress <account>\n"
              "Returns the current Taurus 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]);
  
      Value ret;
  
      ret = GetAccountAddress(strAccount).ToString();
  
      return ret;
  }
  
  
  
  Value setaccount(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 1 || params.size() > 2)
          throw runtime_error(
              "setaccount <taurusaddress> <account>\n"
              "Sets the account associated with the given address.");
  
      CBitcoinAddress address(params[0].get_str());
      if (!address.IsValid())
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Taurus 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))
      {
          string strOldAccount = pwalletMain->mapAddressBook[address];
          if (address == GetAccountAddress(strOldAccount))
              GetAccountAddress(strOldAccount, true);
      }
  
      pwalletMain->SetAddressBookName(address, strAccount);
  
      return Value::null;
  }
  
  
  Value getaccount(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "getaccount <taurusaddress>\n"
              "Returns the account associated with the given address.");
  
      CBitcoinAddress address(params[0].get_str());
      if (!address.IsValid())
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Taurus address");
  
      string strAccount;
      map<CBitcoinAddress, string>::iterator 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(
              "getaddressesbyaccount <account>\n"
              "Returns the list of addresses for the given account.");
  
      string strAccount = AccountFromValue(params[0]);
  
      // Find all addresses that have the given account
      Array ret;
      BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
      {
          const CBitcoinAddress& address = item.first;
          const string& strName = item.second;
          if (strName == strAccount)
              ret.push_back(address.ToString());
      }
      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;
      BOOST_FOREACH(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 <taurusaddress> <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();
  
      CBitcoinAddress address(strAddress);
      if (address.IsValid())
          scriptPubKey.SetAddress(address);
      else
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Taurus address");
  
      // Amount
      int64_t nAmount = AmountFromValue(params[1]);
  
      if (nAmount < nMinimumInputValue)
          throw JSONRPCError(-101, "Send amount too small");
  
      // 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();
  
      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);
      if (!strError.empty())
          throw JSONRPCError(RPC_WALLET_ERROR, strError);
  
      return wtx.GetHash().GetHex();
  }
  
  Value listaddressgroupings(const Array& params, bool fHelp)
  {
      if (fHelp)
          throw 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();
      BOOST_FOREACH(set<CBitcoinAddress> grouping, pwalletMain->GetAddressGroupings())
      {
          Array jsonGrouping;
          BOOST_FOREACH(CBitcoinAddress address, grouping)
          {
              Array addressInfo;
              addressInfo.push_back(address.ToString());
              addressInfo.push_back(ValueFromAmount(balances[address]));
              {
                  LOCK(pwalletMain->cs_wallet);
                  if (pwalletMain->mapAddressBook.find(address) != pwalletMain->mapAddressBook.end())
                      addressInfo.push_back(pwalletMain->mapAddressBook.find(address)->second);
              }
              jsonGrouping.push_back(addressInfo);
          }
          jsonGroupings.push_back(jsonGrouping);
      }
      return jsonGroupings;
  }
  
  Value signmessage(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 2)
          throw runtime_error(
              "signmessage <taurusaddress> <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();
  
      CBitcoinAddress 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");
  
      CDataStream ss(SER_GETHASH, 0);
      ss << strMessageMagic;
      ss << strMessage;
  
      vector<unsigned char> vchSig;
      if (!key.SignCompact(Hash(ss.begin(), ss.end()), vchSig))
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Sign failed");
  
      return EncodeBase64(&vchSig[0], vchSig.size());
  }
  
  Value verifymessage(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 3)
          throw runtime_error(
              "verifymessage <taurusaddress> <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();
  
      CBitcoinAddress 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");
  
      bool fInvalid = false;
      vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
  
      if (fInvalid)
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Malformed base64 encoding");
  
      CDataStream ss(SER_GETHASH, 0);
      ss << strMessageMagic;
      ss << strMessage;
  
      CPubKey key;
      if (!key.SetCompactSignature(Hash(ss.begin(), ss.end()), vchSig))
          return false;
  
      return (key.GetID() == keyID);
  }
  
  
  Value getreceivedbyaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 1 || params.size() > 2)
          throw runtime_error(
                  "getreceivedbyaddress <taurusaddress> [minconf=1]\n"
                  "Returns the total amount received by <taurusaddress> in transactions with at least [minconf] confirmations.");
  
      // Bitcoin address
      CBitcoinAddress address = CBitcoinAddress(params[0].get_str());
      if (!address.IsValid())
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Taurus address");
      if (!IsMine(*pwalletMain,address))
          return 0.0;
  
      // Minimum confirmations
      int nMinDepth = 1;
      if (params.size() > 1)
          nMinDepth = params[1].get_int();
  
      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)
          {
              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<CBitcoinAddress>& setAddress)
  {
      BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
      {
          const CBitcoinAddress& address = item.first;
          const 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(
              "getreceivedbyaccount <account> [minconf=1]\n"
              "Returns the total amount received by addresses with <account> in transactions with at least [minconf] confirmations.");
  
      // 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<CBitcoinAddress> setAddress;
      GetAccountAddresses(strAccount, setAddress);
  
      // 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() || wtx.IsCoinStake() || !wtx.IsFinal())
              continue;
  
          BOOST_FOREACH(const CTxOut& txout, wtx.vout)
          {
              CBitcoinAddress address;
              if (ExtractAddress(*pwalletMain, txout.scriptPubKey, address) && IsMine(*pwalletMain, address) && setAddress.count(address))
                  if (wtx.GetDepthInMainChain() >= nMinDepth)
                      nAmount += txout.nValue;
          }
      }
  
      return (double)nAmount / (double)COIN;
  }
  
  
  int64_t GetAccountBalance(CWalletDB& walletdb, const 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)
      {
          const CWalletTx& wtx = (*it).second;
          if (!wtx.IsFinal())
              continue;
  
          int64_t nGenerated, nReceived, nSent, nFee;
          wtx.GetAccountAmounts(strAccount, nGenerated, nReceived, nSent, nFee, filter);
  
          if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth)
              nBalance += nReceived;
          nBalance += nGenerated - nSent - nFee;
      }
  
      // Tally internal accounting entries
      nBalance += walletdb.GetAccountCreditDebit(strAccount);
  
      return nBalance;
  }
  
  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)
          throw 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"
              "if [includeWatchonly] is specified, include balance in watchonly addresses (see 'importaddress').");
  
      if (params.size() == 0)
          return  ValueFromAmount(pwalletMain->GetBalance());
  
      int nMinDepth = 1;
      if (params.size() > 1)
          nMinDepth = params[1].get_int();
      isminefilter filter = MINE_SPENDABLE;
      if(params.size() > 2)
          if(params[2].get_bool())
              filter = filter | MINE_WATCH_ONLY;
  
      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())
                  continue;
  
              int64_t allGeneratedImmature, allGeneratedMature, allFee;
              allGeneratedImmature = allGeneratedMature = allFee = 0;
  
              string strSentAccount;
              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(CBitcoinAddress,int64_t)& r, listReceived)
                      nBalance += r.second;
              }
              BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64_t)& r, listSent)
                  nBalance -= r.second;
              nBalance -= allFee;
              nBalance += allGeneratedMature;
          }
          return  ValueFromAmount(nBalance);
      }
  
      string strAccount = AccountFromValue(params[0]);
  
      int64_t nBalance = GetAccountBalance(strAccount, nMinDepth, filter);
  
      return ValueFromAmount(nBalance);
  }
  
  
  Value movecmd(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 3 || params.size() > 5)
          throw 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]);
      int64_t nAmount = AmountFromValue(params[2]);
  
      if (nAmount < nMinimumInputValue)
          throw JSONRPCError(-101, "Send amount too small");
  
      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;
  }
  
  
  Value sendfrom(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 3 || params.size() > 6)
          throw runtime_error(
              "sendfrom <fromaccount> <totaurusaddress> <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]);
  
      // 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 Taurus address");
  
  
      int64_t nAmount = AmountFromValue(params[2]);
  
      if (nAmount < nMinimumInputValue)
          throw JSONRPCError(-101, "Send amount too small");
  
      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, MINE_SPENDABLE);
      if (nAmount > nBalance)
          throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Account has insufficient funds");
  
      // Send
      string strError = pwalletMain->SendMoney(scriptPubKey, nAmount, wtx);
      if (!strError.empty())
          throw JSONRPCError(RPC_WALLET_ERROR, strError);
  
      return wtx.GetHash().GetHex();
  }
  
  
  Value sendmany(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 2 || params.size() > 4)
          throw runtime_error(
              "sendmany <fromaccount> '{address:amount,...}' [minconf=1] [comment]\n"
              "amounts are double-precision floating point numbers"
              + HelpRequiringPassphrase());
  
      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<CBitcoinAddress> setAddress;
      vector<pair<CScript, int64_t> > vecSend;
  
      int64_t totalAmount = 0;
      BOOST_FOREACH(const Pair& s, sendTo)
      {
          CBitcoinAddress address(s.name_);
          if (!address.IsValid())
              throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, string("Invalid Taurus address: ")+s.name_);
  
          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.SetAddress(address);
          int64_t nAmount = AmountFromValue(s.value_);
  
          if (nAmount < nMinimumInputValue)
              throw JSONRPCError(-101, "Send amount too small");
  
          totalAmount += nAmount;
  
          vecSend.push_back(make_pair(scriptPubKey, nAmount));
      }
  
      EnsureWalletIsUnlocked();
  
      // Check funds
      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_t nFeeRequired = 0;
      bool fCreated = pwalletMain->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired);
      if (!fCreated)
      {
          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 (!pwalletMain->CommitTransaction(wtx, keyChange))
          throw JSONRPCError(RPC_WALLET_ERROR, "Transaction commit failed");
  
      return wtx.GetHash().GetHex();
  }
  
  Value addmultisigaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 2 || params.size() > 3)
      {
          string msg = "addmultisigaddress <nrequired> <'[\"key\",\"key\"]'> [account]\n"
              "Add a nrequired-to-sign multisignature address to the wallet\"\n"
              "each key is a Taurus address or hex-encoded public key\n"
              "If [account] is specified, assign address to [account].";
          throw runtime_error(msg);
      }
  
      int nRequired = params[0].get_int();
      const Array& keys = params[1].get_array();
      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");
      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));
      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++)
      {
          const std::string& ks = keys[i].get_str();
  
          // Case 1: Bitcoin address and we have full public key:
          CBitcoinAddress address(ks);
          if (address.IsValid())
          {
              CKeyID keyID;
              if (!address.GetKeyID(keyID))
                  throw runtime_error(
                      strprintf("%s does not refer to a key",ks.c_str()));
              CPubKey vchPubKey;
              if (!pwalletMain->GetPubKey(keyID, vchPubKey))
                  throw runtime_error(
                      strprintf("no full public key for address %s",ks.c_str()));
              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())
                  throw runtime_error(" Invalid public key: "+ks);
               pubkeys[i] = vchPubKey;
          }
          else
          {
              throw runtime_error(" Invalid public key: "+ks);
          }
      }
  
      // Construct using pay-to-script-hash:
      CScript inner;
      inner.SetMultisig(nRequired, pubkeys);
  
      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(address, strAccount);
      return address.ToString();
  }
  
  Value addredeemscript(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 1 || params.size() > 2)
      {
          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);
      }
  
      string strAccount;
      if (params.size() > 1)
          strAccount = AccountFromValue(params[1]);
  
      // Construct using pay-to-script-hash:
      vector<unsigned char> innerData = ParseHexV(params[0], "redeemScript");
      CScript inner(innerData.begin(), innerData.end());
      pwalletMain->AddCScript(inner);
      CBitcoinAddress address(inner.GetID());
  
      pwalletMain->SetAddressBookName(address, strAccount);
      return address.ToString();
  }
  
  struct tallyitem
  {
      int64_t nAmount;
      int nConf;
      tallyitem()
      {
          nAmount = 0;
          nConf = std::numeric_limits<int>::max();
      }
  };
  
  Value ListReceived(const Array& params, bool fByAccounts)
  {
      // 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<CBitcoinAddress, tallyitem> mapTally;
      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;
  
          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);
          }
      }
  
      // Reply
      Array ret;
      map<string, tallyitem> mapAccountTally;
      BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
      {
          const CBitcoinAddress& address = item.first;
          const string& strAccount = item.second;
          map<CBitcoinAddress, 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));
              obj.push_back(Pair("amount",        ValueFromAmount(nAmount)));
              obj.push_back(Pair("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf)));
              ret.push_back(obj);
          }
      }
  
      if (fByAccounts)
      {
          for (map<string, tallyitem>::iterator it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
          {
              int64_t nAmount = (*it).second.nAmount;
              int nConf = (*it).second.nConf;
              Object obj;
              obj.push_back(Pair("account",       (*it).first));
              obj.push_back(Pair("amount",        ValueFromAmount(nAmount)));
              obj.push_back(Pair("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf)));
              ret.push_back(obj);
          }
      }
  
      return ret;
  }
  
  Value listreceivedbyaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 2)
          throw 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"
              "Returns an array of objects containing:\n"
              "  \"address\" : receiving address\n"
              "  \"account\" : the account of the receiving address\n"
              "  \"amount\" : total amount received by the address\n"
              "  \"confirmations\" : number of confirmations of the most recent transaction included");
  
      return ListReceived(params, false);
  }
  
  Value listreceivedbyaccount(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 2)
          throw 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"
              "Returns an array of objects containing:\n"
              "  \"account\" : the account of the receiving addresses\n"
              "  \"amount\" : total amount received by addresses with this account\n"
              "  \"confirmations\" : number of confirmations of the most recent transaction included");
  
      return ListReceived(params, true);
  }
  
  static void MaybePushAddress(Object & entry, const CBitcoinAddress &dest)
  {
      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_t nGeneratedImmature, nGeneratedMature, nFee;
      string strSentAccount;
      list<pair<CBitcoinAddress, int64_t> > listReceived;
      list<pair<CBitcoinAddress, int64_t> > listSent;
  
      wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount, filter);
  
      bool fAllAccounts = (strAccount == 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("")));
          if (nGeneratedImmature)
          {
              entry.push_back(Pair("category", wtx.GetDepthInMainChain() ? "immature" : "orphan"));
              entry.push_back(Pair("amount", ValueFromAmount(nGeneratedImmature)));
          }
          else
          {
              entry.push_back(Pair("category", "generate"));
              entry.push_back(Pair("amount", ValueFromAmount(nGeneratedMature)));
          }
          if (fLong)
              WalletTxToJSON(wtx, entry);
          ret.push_back(entry);
      }
  
      // Sent
      if ((!listSent.empty() || nFee != 0) && (fAllAccounts || strAccount == strSentAccount))
      {
          BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64_t)& s, listSent)
          {
              Object entry;
              entry.push_back(Pair("account", strSentAccount));
              if(involvesWatchonly || (::IsMine(*pwalletMain, s.first) & MINE_WATCH_ONLY))
                  entry.push_back(Pair("involvesWatchonly", true));
              MaybePushAddress(entry, s.first);
  
              if (wtx.GetDepthInMainChain() < 0) {
                  entry.push_back(Pair("category", "conflicted"));
              } else {
                  entry.push_back(Pair("category", "send"));
              }
  
              entry.push_back(Pair("amount", ValueFromAmount(-s.second)));
              entry.push_back(Pair("fee", ValueFromAmount(-nFee)));
              if (fLong)
                  WalletTxToJSON(wtx, entry);
              ret.push_back(entry);
          }
      }
  
      // Received
      if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth)
      {
          BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64_t)& r, listReceived)
          {
              string account;
              if (pwalletMain->mapAddressBook.count(r.first))
                  account = pwalletMain->mapAddressBook[r.first];
              if (fAllAccounts || (account == strAccount))
              {
                  Object entry;
                  entry.push_back(Pair("account", account));
                  if(involvesWatchonly || (::IsMine(*pwalletMain, r.first) & MINE_WATCH_ONLY))
                      entry.push_back(Pair("involvesWatchonly", true));
                  MaybePushAddress(entry, r.first);
                  if (wtx.IsCoinBase())
                  {
                      if (wtx.GetDepthInMainChain() < 1)
                          entry.push_back(Pair("category", "orphan"));
                      else if (wtx.GetBlocksToMaturity() > 0)
                          entry.push_back(Pair("category", "immature"));
                      else
                          entry.push_back(Pair("category", "generate"));
                  }
                  else
                      entry.push_back(Pair("category", "receive"));
                  entry.push_back(Pair("amount", ValueFromAmount(r.second)));
                  if (fLong)
                      WalletTxToJSON(wtx, entry);
                  ret.push_back(entry);
              }
          }
      }
  }
  
  void AcentryToJSON(const CAccountingEntry& acentry, const string& strAccount, Array& ret)
  {
      bool fAllAccounts = (strAccount == string("*"));
  
      if (fAllAccounts || acentry.strAccount == strAccount)
      {
          Object entry;
          entry.push_back(Pair("account", acentry.strAccount));
          entry.push_back(Pair("category", "move"));
          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));
          ret.push_back(entry);
      }
  }
  
  Value listtransactions(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 3)
          throw 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 = "*";
      if (params.size() > 0)
          strAccount = params[0].get_str();
      int nCount = 10;
      if (params.size() > 1)
          nCount = params[1].get_int();
      int nFrom = 0;
      if (params.size() > 2)
          nFrom = params[2].get_int();
  
      isminefilter filter = MINE_SPENDABLE;
      if(params.size() > 3)
          if(params[3].get_bool())
              filter = filter | MINE_WATCH_ONLY;
  
      if (nCount < 0)
          throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative count");
      if (nFrom < 0)
          throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative from");
  
      Array ret;
  
      std::list<CAccountingEntry> acentries;
      CWallet::TxItems txOrdered = pwalletMain->OrderedTxItems(acentries, strAccount);
  
      // iterate backwards until we have nCount items to return:
      for (CWallet::TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
      {
          CWalletTx *const pwtx = (*it).second.first;
          if (pwtx != 0)
              ListTransactions(*pwtx, strAccount, 0, true, ret, filter);
          CAccountingEntry *const pacentry = (*it).second.second;
          if (pacentry != 0)
              AcentryToJSON(*pacentry, strAccount, ret);
  
          if ((int)ret.size() >= (nCount+nFrom)) break;
      }
      // ret is newest to oldest
  
      if (nFrom > (int)ret.size())
          nFrom = ret.size();
      if ((nFrom + nCount) > (int)ret.size())
          nCount = ret.size() - nFrom;
      Array::iterator first = ret.begin();
      std::advance(first, nFrom);
      Array::iterator last = ret.begin();
      std::advance(last, nFrom+nCount);
  
      if (last != ret.end()) ret.erase(last, ret.end());
      if (first != ret.begin()) ret.erase(ret.begin(), first);
  
      std::reverse(ret.begin(), ret.end()); // Return oldest to newest
  
      return ret;
  }
  
  Value listaccounts(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 1)
          throw runtime_error(
              "listaccounts [minconf=1]\n"
              "Returns Object that has account names as keys, account balances as values.");
  
      int nMinDepth = 1;
      if (params.size() > 0)
          nMinDepth = params[0].get_int();
  
      isminefilter includeWatchonly = MINE_SPENDABLE;
      if(params.size() > 1)
          if(params[1].get_bool())
              includeWatchonly = includeWatchonly | MINE_WATCH_ONLY;
  
  
      map<string, int64_t> mapAccountBalances;
      BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& 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_t nGeneratedImmature, nGeneratedMature, nFee;
          string strSentAccount;
          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(CBitcoinAddress, int64_t)& s, listSent)
              mapAccountBalances[strSentAccount] -= s.second;
          if (wtx.GetDepthInMainChain() >= nMinDepth)
          {
              mapAccountBalances[""] += nGeneratedMature;
              BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64_t)& r, listReceived)
                  if (pwalletMain->mapAddressBook.count(r.first))
                      mapAccountBalances[pwalletMain->mapAddressBook[r.first]] += r.second;
                  else
                      mapAccountBalances[""] += r.second;
          }
      }
  
      list<CAccountingEntry> acentries;
      CWalletDB(pwalletMain->strWalletFile).ListAccountCreditDebit("*", acentries);
      BOOST_FOREACH(const CAccountingEntry& entry, acentries)
          mapAccountBalances[entry.strAccount] += entry.nCreditDebit;
  
      Object ret;
      BOOST_FOREACH(const PAIRTYPE(string, int64_t)& accountBalance, mapAccountBalances) {
          ret.push_back(Pair(accountBalance.first, ValueFromAmount(accountBalance.second)));
      }
      return ret;
  }
  
  Value listsinceblock(const Array& params, bool fHelp)
  {
      if (fHelp)
          throw runtime_error(
              "listsinceblock [blockhash] [target-confirmations]\n"
              "Get all transactions in blocks since block [blockhash], or all transactions if omitted");
  
      CBlockIndex *pindex = NULL;
      int target_confirms = 1;
      isminefilter filter = MINE_SPENDABLE;
  
      if (params.size() > 0)
      {
          uint256 blockId = 0;
  
          blockId.SetHex(params[0].get_str());
          pindex = CBlockLocator(blockId).GetBlockIndex();
      }
  
      if (params.size() > 1)
      {
          target_confirms = params[1].get_int();
  
          if (target_confirms < 1)
              throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");
      }
  
      if(params.size() > 2)
          if(params[2].get_bool())
              filter = filter | MINE_WATCH_ONLY;
  
      int depth = pindex ? (1 + nBestHeight - pindex->nHeight) : -1;
  
      Array transactions;
  
      for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); it++)
      {
          CWalletTx tx = (*it).second;
  
          if (depth == -1 || tx.GetDepthInMainChain() < depth)
              ListTransactions(tx, "*", 0, true, transactions, filter);
      }
  
      uint256 lastblock;
  
      if (target_confirms == 1)
      {
          lastblock = hashBestChain;
      }
      else
      {
          int target_height = pindexBest->nHeight + 1 - target_confirms;
  
          CBlockIndex *block;
          for (block = pindexBest;
               block && block->nHeight > target_height;
               block = block->pprev)  { }
  
          lastblock = block ? block->GetBlockHash() : 0;
      }
  
      Object ret;
      ret.push_back(Pair("transactions", transactions));
      ret.push_back(Pair("lastblock", lastblock.GetHex()));
  
      return ret;
  }
  
  Value gettransaction(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "gettransaction <txid>\n"
              "Get detailed information about <txid>");
  
      uint256 hash;
      hash.SetHex(params[0].get_str());
  
      isminefilter filter = MINE_SPENDABLE;
      if(params.size() > 1)
          if(params[1].get_bool())
              filter = filter | MINE_WATCH_ONLY;
  
      Object entry;
  
      if (pwalletMain->mapWallet.count(hash))
      {
          const CWalletTx& wtx = pwalletMain->mapWallet[hash];
  
          TxToJSON(wtx, 0, entry);
  
          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))
              entry.push_back(Pair("fee", ValueFromAmount(nFee)));
  
          WalletTxToJSON(wtx, entry);
  
          Array details;
          ListTransactions(pwalletMain->mapWallet[hash], "*", 0, false, details, filter);
          entry.push_back(Pair("details", details));
      }
      else
      {
          CTransaction tx;
          uint256 hashBlock = 0;
          if (GetTransaction(hash, tx, hashBlock))
          {
              TxToJSON(tx, 0, entry);
              if (hashBlock == 0)
                  entry.push_back(Pair("confirmations", 0));
              else
              {
                  entry.push_back(Pair("blockhash", hashBlock.GetHex()));
                  map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
                  if (mi != mapBlockIndex.end() && (*mi).second)
                  {
                      CBlockIndex* pindex = (*mi).second;
                      if (pindex->IsInMainChain())
                          entry.push_back(Pair("confirmations", 1 + nBestHeight - pindex->nHeight));
                      else
                          entry.push_back(Pair("confirmations", 0));
                  }
              }
          }
          else
              throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "No information available about transaction");
      }
  
      return entry;
  }
  
  
  Value backupwallet(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw 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();
      if (!BackupWallet(*pwalletMain, strDest))
          throw JSONRPCError(RPC_WALLET_ERROR, "Error: Wallet backup failed!");
  
      return Value::null;
  }
  
  
  Value keypoolrefill(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 1)
          throw 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);
      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->TopUpKeyPool(nSize);
  
      if (pwalletMain->GetKeyPoolSize() < nSize)
          throw JSONRPCError(RPC_WALLET_ERROR, "Error refreshing keypool.");
  
      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 key-topping-up thread
      RenameThread("taurus-key-top");
  
      pwalletMain->TopUpKeyPool();
  }
  
  void ThreadCleanWalletPassphrase(void* parg)
  {
      // Make this thread recognisable as the wallet relocking thread
      RenameThread("taurus-lock-wa");
  
      int64_t nMyWakeTime = GetTimeMillis() + *((int64_t*)parg) * 1000;
  
      ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
  
      if (nWalletUnlockTime == 0)
      {
          nWalletUnlockTime = nMyWakeTime;
  
          for ( ; ; )
          {
              if (nWalletUnlockTime==0)
                  break;
              int64_t nToSleep = nWalletUnlockTime - GetTimeMillis();
              if (nToSleep <= 0)
                  break;
  
              LEAVE_CRITICAL_SECTION(cs_nWalletUnlockTime);
              Sleep(nToSleep);
              ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
  
          };
  
          if (nWalletUnlockTime)
          {
              nWalletUnlockTime = 0;
              pwalletMain->Lock();
          }
      }
      else
      {
          if (nWalletUnlockTime < nMyWakeTime)
              nWalletUnlockTime = nMyWakeTime;
      }
  
      LEAVE_CRITICAL_SECTION(cs_nWalletUnlockTime);
  
      delete (int64_t*)parg;
  }
  
  Value walletpassphrase(const Array& params, bool fHelp)
  {
      if (pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 3))
          throw 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.");
      if (fHelp)
          return true;
      if (!pwalletMain->IsCrypted())
          throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrase was called.");
  
      if (!pwalletMain->IsLocked())
          throw JSONRPCError(RPC_WALLET_ALREADY_UNLOCKED, "Error: Wallet is already unlocked, use walletlock first if need to change unlock settings.");
      // Note that the walletpassphrase is stored in params[0] which is not mlock()ed
      SecureString strWalletPass;
      strWalletPass.reserve(100);
      // TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
      // Alternately, find a way to make params[0] mlock()'d to begin with.
      strWalletPass = params[0].get_str().c_str();
  
      if (strWalletPass.length() > 0)
      {
          if (!pwalletMain->Unlock(strWalletPass))
              throw JSONRPCError(RPC_WALLET_PASSPHRASE_INCORRECT, "Error: The wallet passphrase entered was incorrect.");
      }
      else
          throw runtime_error(
              "walletpassphrase <passphrase> <timeout>\n"
              "Stores the wallet decryption key in memory for <timeout> seconds.");
  
      NewThread(ThreadTopUpKeyPool, NULL);
      int64_t* pnSleepTime = new int64_t(params[1].get_int64());
      NewThread(ThreadCleanWalletPassphrase, pnSleepTime);
  
      // ppcoin: if user OS account compromised prevent trivial sendmoney commands
      if (params.size() > 2)
          fWalletUnlockMintOnly = params[2].get_bool();
      else
          fWalletUnlockMintOnly = false;
  
      return Value::null;
  }
  
  
  Value walletpassphrasechange(const Array& params, bool fHelp)
  {
      if (pwalletMain->IsCrypted() && (fHelp || params.size() != 2))
          throw runtime_error(
              "walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
              "Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
      if (fHelp)
          return true;
      if (!pwalletMain->IsCrypted())
          throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletpassphrasechange was called.");
  
      // TODO: get rid of these .c_str() calls by implementing SecureString::operator=(std::string)
      // Alternately, find a way to make params[0] mlock()'d to begin with.
      SecureString strOldWalletPass;
      strOldWalletPass.reserve(100);
      strOldWalletPass = params[0].get_str().c_str();
  
      SecureString strNewWalletPass;
      strNewWalletPass.reserve(100);
      strNewWalletPass = params[1].get_str().c_str();
  
      if (strOldWalletPass.length() < 1 || strNewWalletPass.length() < 1)
          throw runtime_error(
              "walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
              "Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
  
      if (!pwalletMain->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass))
          throw JSONRPCError(RPC_WALLET_PASSPHRASE_INCORRECT, "Error: The wallet passphrase entered was incorrect.");
  
      return Value::null;
  }
  
  
  Value walletlock(const Array& params, bool fHelp)
  {
      if (pwalletMain->IsCrypted() && (fHelp || params.size() != 0))
          throw 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"
              "before being able to call any methods which require the wallet to be unlocked.");
      if (fHelp)
          return true;
      if (!pwalletMain->IsCrypted())
          throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an unencrypted wallet, but walletlock was called.");
  
      {
          LOCK(cs_nWalletUnlockTime);
          pwalletMain->Lock();
          nWalletUnlockTime = 0;
      }
  
      return Value::null;
  }
  
  
  Value encryptwallet(const Array& params, bool fHelp)
  {
      if (!pwalletMain->IsCrypted() && (fHelp || params.size() != 1))
          throw runtime_error(
              "encryptwallet <passphrase>\n"
              "Encrypts the wallet with <passphrase>.");
      if (fHelp)
          return true;
      if (pwalletMain->IsCrypted())
          throw JSONRPCError(RPC_WALLET_WRONG_ENC_STATE, "Error: running with an encrypted wallet, but encryptwallet was called.");
  
      // TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
      // Alternately, find a way to make params[0] mlock()'d to begin with.
      SecureString strWalletPass;
      strWalletPass.reserve(100);
      strWalletPass = params[0].get_str().c_str();
  
      if (strWalletPass.length() < 1)
          throw runtime_error(
              "encryptwallet <passphrase>\n"
              "Encrypts the wallet with <passphrase>.");
  
      if (!pwalletMain->EncryptWallet(strWalletPass))
          throw JSONRPCError(RPC_WALLET_ENCRYPTION_FAILED, "Error: Failed to encrypt the wallet.");
  
      // BDB seems to have a bad habit of writing old data into
      // slack space in .dat files; that is bad if the old data is
      // unencrypted private keys. So:
      StartShutdown();
      return "wallet encrypted; Taurus server stopping, restart to run with encrypted wallet.  The keypool has been flushed, you need to make a new backup.";
  }
  
  class DescribeAddressVisitor : public boost::static_visitor<Object>
  {
  private:
      isminetype mine;
  public:
      DescribeAddressVisitor(isminetype mineIn) : mine(mineIn) {}
  
      Object operator()(const CNoDestination &dest) const { return Object(); }
      Object operator()(const CKeyID &keyID) const {
          Object obj;
          CPubKey vchPubKey;
          pwalletMain->GetPubKey(keyID, vchPubKey);
          obj.push_back(Pair("isscript", false));
          if (mine == MINE_SPENDABLE) {
              pwalletMain->GetPubKey(keyID, vchPubKey);
              obj.push_back(Pair("pubkey", HexStr(vchPubKey.begin(), vchPubKey.end())));
              obj.push_back(Pair("iscompressed", vchPubKey.IsCompressed()));
          }
          return obj;
      }
  
      Object operator()(const CScriptID &scriptID) const {
          Object obj;
          obj.push_back(Pair("isscript", true));
          if (mine == MINE_SPENDABLE) {
              CScript subscript;
              pwalletMain->GetCScript(scriptID, subscript);
              std::vector<CTxDestination> addresses;
              txnouttype whichType;
              int nRequired;
              ExtractDestinations(subscript, whichType, addresses, nRequired);
              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)
                  a.push_back(CBitcoinAddress(addr).ToString());
              obj.push_back(Pair("addresses", a));
              if (whichType == TX_MULTISIG)
                  obj.push_back(Pair("sigsrequired", nRequired));
          }
          return obj;
      }
  };
  
  Value validateaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "validateaddress <taurusaddress>\n"
              "Return information about <taurusaddress>.");
  
      CBitcoinAddress address(params[0].get_str());
      bool isValid = address.IsValid();
  
      Object ret;
      ret.push_back(Pair("isvalid", isValid));
      if (isValid)
      {
          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 = boost::apply_visitor(DescribeAddressVisitor(mine), dest);
                  ret.insert(ret.end(), detail.begin(), detail.end());
              }
              if (pwalletMain->mapAddressBook.count(address))
                  ret.push_back(Pair("account", pwalletMain->mapAddressBook[address]));
          }
      }
      return ret;
  }
  
  // ppcoin: reserve balance from being staked for network protection
  Value reservebalance(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 2)
          throw 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"
              "Set reserve amount not participating in network protection.\n"
              "If no parameters provided current setting is printed.\n");
  
      if (params.size() > 0)
      {
          bool fReserve = params[0].get_bool();
          if (fReserve)
          {
              if (params.size() == 1)
                  throw 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");
              mapArgs["-reservebalance"] = FormatMoney(nAmount);
          }
          else
          {
              if (params.size() > 1)
                  throw 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");
      result.push_back(Pair("reserve", (nReserveBalance > 0)));
      result.push_back(Pair("amount", ValueFromAmount(nReserveBalance)));
      return result;
  }
  
  
  // ppcoin: check wallet integrity
  Value checkwallet(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 0)
          throw runtime_error(
              "checkwallet\n"
              "Check wallet for integrity.\n");
  
      int nMismatchSpent;
      int64_t nBalanceInQuestion;
      pwalletMain->FixSpentCoins(nMismatchSpent, nBalanceInQuestion, true);
      Object result;
      if (nMismatchSpent == 0)
          result.push_back(Pair("wallet check passed", true));
      else
      {
          result.push_back(Pair("mismatched spent coins", nMismatchSpent));
          result.push_back(Pair("amount in question", ValueFromAmount(nBalanceInQuestion)));
      }
      return result;
  }
  
  
  // ppcoin: repair wallet
  Value repairwallet(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 0)
          throw runtime_error(
              "repairwallet\n"
              "Repair wallet if checkwallet reports any problem.\n");
  
      int nMismatchSpent;
      int64_t nBalanceInQuestion;
      pwalletMain->FixSpentCoins(nMismatchSpent, nBalanceInQuestion);
      Object result;
      if (nMismatchSpent == 0)
          result.push_back(Pair("wallet check passed", true));
      else
      {
          result.push_back(Pair("mismatched spent coins", nMismatchSpent));
          result.push_back(Pair("amount affected by repair", ValueFromAmount(nBalanceInQuestion)));
      }
      return result;
  }
  
  // Taurus: resend unconfirmed wallet transactions
  Value resendtx(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() > 1)
          throw runtime_error(
              "resendtx\n"
              "Re-send unconfirmed transactions.\n"
          );
  
      ResendWalletTransactions(true);
  
      return Value::null;
  }
  
  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;
      BOOST_FOREACH(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() > 0)
          throw runtime_error(
              "makekeypair\n"
              "Make a public/private key pair.\n");
  
      string strPrefix = "";
      if (params.size() > 0)
          strPrefix = params[0].get_str();
  
      CKey key;
      key.MakeNewKey(true);
  
      CPrivKey vchPrivKey = key.GetPrivKey();
      Object result;
      result.push_back(Pair("PrivateKey", HexStr<CPrivKey::iterator>(vchPrivKey.begin(), vchPrivKey.end())));
  
      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;
      BOOST_FOREACH(const CMalleableKeyView &keyView, keyViewList)
      {
          result.push_back(keyView.ToString());
      }
  
      return result;
  }
  
  