text: // Copyright (c) 2009-2012 Bitcoin Developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #include <iostream>
  #include <fstream>
  
  #include "init.h" // for pwalletMain
  #include "rpcserver.h"
  #include "ui_interface.h"
  #include "base58.h"
  
  #include <boost/date_time/posix_time/posix_time.hpp>
  #include <boost/variant/get.hpp>
  #include <boost/algorithm/string.hpp>
  
  using namespace json_spirit;
  using namespace std;
  
  void EnsureWalletIsUnlocked();
  
  namespace bt = boost::posix_time;
  
  // Extended DecodeDumpTime implementation, see this page for details:
  // http://stackoverflow.com/questions/3786201/parsing-of-date-time-from-string-boost
  const std::locale formats[] = {
      std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%dT%H:%M:%SZ")),
      std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d %H:%M:%S")),
      std::locale(std::locale::classic(),new bt::time_input_facet("%Y/%m/%d %H:%M:%S")),
      std::locale(std::locale::classic(),new bt::time_input_facet("%d.%m.%Y %H:%M:%S")),
      std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d"))
  };
  
  const size_t formats_n = sizeof(formats)/sizeof(formats[0]);
  
  std::time_t pt_to_time_t(const bt::ptime& pt)
  {
      bt::ptime timet_start(boost::gregorian::date(1970,1,1));
      bt::time_duration diff = pt - timet_start;
      return diff.ticks()/bt::time_duration::rep_type::ticks_per_second;
  }
  
  int64_t DecodeDumpTime(const std::string& s)
  {
      bt::ptime pt;
  
      for(size_t i=0; i<formats_n; ++i)
      {
          std::istringstream is(s);
          is.imbue(formats[i]);
          is >> pt;
          if(pt != bt::ptime()) break;
      }
  
      return pt_to_time_t(pt);
  }
  
  std::string static EncodeDumpTime(int64_t nTime) {
      return DateTimeStrFormat("%Y-%m-%dT%H:%M:%SZ", nTime);
  }
  
  std::string static EncodeDumpString(const std::string &str) {
      std::stringstream ret;
      BOOST_FOREACH(unsigned char c, str) {
          if (c <= 32 || c >= 128 || c == '%') {
              ret << '%' << HexStr(&c, &c + 1);
          } else {
              ret << c;
          }
      }
      return ret.str();
  }
  
  std::string DecodeDumpString(const std::string &str) {
      std::stringstream ret;
      for (unsigned int pos = 0; pos < str.length(); pos++) {
          unsigned char c = str[pos];
          if (c == '%' && pos+2 < str.length()) {
              c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) | 
                  ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
              pos += 2;
          }
          ret << c;
      }
      return ret.str();
  }
  
  class CTxDump
  {
  public:
      CBlockIndex *pindex;
      int64_t nValue;
      bool fSpent;
      CWalletTx* ptx;
      int nOut;
      CTxDump(CWalletTx* ptx = NULL, int nOut = -1)
      {
          pindex = NULL;
          nValue = 0;
          fSpent = false;
          this->ptx = ptx;
          this->nOut = nOut;
      }
  };
  
  Value importprivkey(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 1 || params.size() > 3)
          throw runtime_error(
              "importprivkey <trollcoinprivkey> [label] [rescan=true]\n"
              "Adds a private key (as returned by dumpprivkey) to your wallet.");
  
      string strSecret = params[0].get_str();
      string strLabel = "";
      if (params.size() > 1)
          strLabel = params[1].get_str();
  
      // Whether to perform rescan after import
      bool fRescan = true;
      if (params.size() > 2)
          fRescan = params[2].get_bool();
  
      CBitcoinSecret vchSecret;
      bool fGood = vchSecret.SetString(strSecret);
  
      if (!fGood) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
      if (fWalletUnlockStakingOnly)
          throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Wallet is unlocked for staking only.");
  
      CKey key = vchSecret.GetKey();
      CPubKey pubkey = key.GetPubKey();
      CKeyID vchAddress = pubkey.GetID();
      {
          LOCK2(cs_main, pwalletMain->cs_wallet);
  
          pwalletMain->MarkDirty();
          pwalletMain->SetAddressBookName(vchAddress, strLabel);
  
          // Don't throw error in case a key is already there
          if (pwalletMain->HaveKey(vchAddress))
              return Value::null;
  
          pwalletMain->mapKeyMetadata[vchAddress].nCreateTime = 1;
  
          if (!pwalletMain->AddKeyPubKey(key, pubkey))
              throw JSONRPCError(RPC_WALLET_ERROR, "Error adding key to wallet");
  
          // whenever a key is imported, we need to scan the whole chain
          pwalletMain->nTimeFirstKey = 1; // 0 would be considered 'no value'
  
          if (fRescan) {
              pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
              pwalletMain->ReacceptWalletTransactions();
          }
      }
  
      return Value::null;
  }
  
  Value importaddress(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() < 1 || params.size() > 3)
          throw runtime_error(
              "importaddress <address> [label] [rescan=true]\n"
              "Adds an address that can be watched as if it were in your wallet but cannot be used to spend.");
  
      CBitcoinAddress address(params[0].get_str());
      if (!address.IsValid())
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
      CTxDestination dest;
      dest = address.Get();
  
      string strLabel = "";
      if (params.size() > 1)
          strLabel = params[1].get_str();
  
      // Whether to perform rescan after import
      bool fRescan = true;
      if (params.size() > 2)
          fRescan = params[2].get_bool();
  
      {
          LOCK2(cs_main, pwalletMain->cs_wallet);
  
          // Don't throw error in case an address is already there
          if (pwalletMain->HaveWatchOnly(dest))
              return Value::null;
  
          pwalletMain->MarkDirty();
          pwalletMain->SetAddressBookName(dest, strLabel);
  
          if (!pwalletMain->AddWatchOnly(dest))
              throw JSONRPCError(RPC_WALLET_ERROR, "Error adding address to wallet");
  
          if (fRescan)
          {
              pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
              pwalletMain->ReacceptWalletTransactions();
          }
      }
  
      return Value::null;
  }
  
  Value importwallet(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "importwallet <filename>\n"
              "Imports keys from a wallet dump file (see dumpwallet).");
  
      EnsureWalletIsUnlocked();
  
      ifstream file;
      file.open(params[0].get_str().c_str());
      if (!file.is_open())
          throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
  
      int64_t nTimeBegin = pindexBest->nTime;
  
      bool fGood = true;
  
      while (file.good()) {
          std::string line;
          std::getline(file, line);
          if (line.empty() || line[0] == '#')
              continue;
  
          std::vector<std::string> vstr;
          boost::split(vstr, line, boost::is_any_of(" "));
          if (vstr.size() < 2)
              continue;
          CBitcoinSecret vchSecret;
          if (!vchSecret.SetString(vstr[0]))
              continue;
          CKey key = vchSecret.GetKey();
          CPubKey pubkey = key.GetPubKey();
          CKeyID keyid = pubkey.GetID();
          if (pwalletMain->HaveKey(keyid)) {
              LogPrintf("Skipping import of %s (key already present)\n", CBitcoinAddress(keyid).ToString());
              continue;
          }
          int64_t nTime = DecodeDumpTime(vstr[1]);
          std::string strLabel;
          bool fLabel = true;
          for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
              if (boost::algorithm::starts_with(vstr[nStr], "#"))
                  break;
              if (vstr[nStr] == "change=1")
                  fLabel = false;
              if (vstr[nStr] == "reserve=1")
                  fLabel = false;
              if (boost::algorithm::starts_with(vstr[nStr], "label=")) {
                  strLabel = DecodeDumpString(vstr[nStr].substr(6));
                  fLabel = true;
              }
          }
          LogPrintf("Importing %s...\n", CBitcoinAddress(keyid).ToString());
          if (!pwalletMain->AddKey(key)) {
              fGood = false;
              continue;
          }
          pwalletMain->mapKeyMetadata[keyid].nCreateTime = nTime;
          if (fLabel)
              pwalletMain->SetAddressBookName(keyid, strLabel);
          nTimeBegin = std::min(nTimeBegin, nTime);
      }
      file.close();
  
      CBlockIndex *pindex = pindexBest;
      while (pindex && pindex->pprev && pindex->nTime > nTimeBegin - 7200)
          pindex = pindex->pprev;
  
      if (!pwalletMain->nTimeFirstKey || nTimeBegin < pwalletMain->nTimeFirstKey)
          pwalletMain->nTimeFirstKey = nTimeBegin;
  
      LogPrintf("Rescanning last %i blocks\n", pindexBest->nHeight - pindex->nHeight + 1);
      pwalletMain->ScanForWalletTransactions(pindex);
      pwalletMain->ReacceptWalletTransactions();
      pwalletMain->MarkDirty();
  
      if (!fGood)
          throw JSONRPCError(RPC_WALLET_ERROR, "Error adding some keys to wallet");
  
      return Value::null;
  }
  
  
  Value dumpprivkey(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "dumpprivkey <trollcoinaddress>\n"
              "Reveals the private key corresponding to <trollcoinaddress>.");
  
      EnsureWalletIsUnlocked();
  
      string strAddress = params[0].get_str();
      CBitcoinAddress address;
      if (!address.SetString(strAddress))
          throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid TrollCoin address");
      if (fWalletUnlockStakingOnly)
          throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Wallet is unlocked for staking only.");
      CKeyID keyID;
      if (!address.GetKeyID(keyID))
          throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to a key");
      CKey vchSecret;
      if (!pwalletMain->GetKey(keyID, vchSecret))
          throw JSONRPCError(RPC_WALLET_ERROR, "Private key for address " + strAddress + " is not known");
      return CBitcoinSecret(vchSecret).ToString();
  }
  
  Value dumpwallet(const Array& params, bool fHelp)
  {
      if (fHelp || params.size() != 1)
          throw runtime_error(
              "dumpwallet <filename>\n"
              "Dumps all wallet keys in a human-readable format.");
  
      EnsureWalletIsUnlocked();
  
      ofstream file;
      file.open(params[0].get_str().c_str());
      if (!file.is_open())
          throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
  
      std::map<CKeyID, int64_t> mapKeyBirth;
  
      std::set<CKeyID> setKeyPool;
  
      pwalletMain->GetKeyBirthTimes(mapKeyBirth);
  
      pwalletMain->GetAllReserveKeys(setKeyPool);
  
      // sort time/key pairs
      std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
      for (std::map<CKeyID, int64_t>::const_iterator it = mapKeyBirth.begin(); it != mapKeyBirth.end(); it++) {
          vKeyBirth.push_back(std::make_pair(it->second, it->first));
      }
      mapKeyBirth.clear();
      std::sort(vKeyBirth.begin(), vKeyBirth.end());
  
      // produce output
      file << strprintf("# Wallet dump created by TrollCoin %s (%s)\n", CLIENT_BUILD, CLIENT_DATE);
      file << strprintf("# * Created on %s\n", EncodeDumpTime(GetTime()));
      file << strprintf("# * Best block at time of backup was %i (%s),\n", nBestHeight, hashBestChain.ToString());
      file << strprintf("#   mined on %s\n", EncodeDumpTime(pindexBest->nTime));
      file << "\n";
      for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
          const CKeyID &keyid = it->second;
          std::string strTime = EncodeDumpTime(it->first);
          std::string strAddr = CBitcoinAddress(keyid).ToString();
  
          CKey key;
          if (pwalletMain->GetKey(keyid, key)) {
              if (pwalletMain->mapAddressBook.count(keyid)) {
                  file << strprintf("%s %s label=%s # addr=%s\n", CBitcoinSecret(key).ToString(), strTime, EncodeDumpString(pwalletMain->mapAddressBook[keyid]), strAddr);
              } else if (setKeyPool.count(keyid)) {
                  file << strprintf("%s %s reserve=1 # addr=%s\n", CBitcoinSecret(key).ToString(), strTime, strAddr);
              } else {
                  file << strprintf("%s %s change=1 # addr=%s\n", CBitcoinSecret(key).ToString(), strTime, strAddr);
              }
          }
      }
      file << "\n";
      file << "# End of dump\n";
      file.close();
      return Value::null;
  }
  