static const boost::posix_time::ptime epoch = boost::posix_time::from_time_t(0);

static const std::locale loc(std::locale::classic(),

new boost::posix_time::time_input_facet("%Y-%m-%dT%H:%M:%SZ"));

std::istringstream iss(str);

iss.imbue(loc);

boost::posix_time::ptime ptime(boost::date_time::not_a_date_time);

iss >> ptime;

if (ptime.is_not_a_date_time())

return 0;

return (ptime - epoch).total_seconds();

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

{

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

throw runtime_error(

"importprivkey \"sidecoinprivkey\" ( \"label\" rescan )\n"

"\nAdds a private key (as returned by dumpprivkey) to your wallet.\n"

"\nArguments:\n"

"1. \"sidecoinprivkey\" (string, required) The private key (see dumpprivkey)\n"

"2. \"label\" (string, optional) an optional label\n"

"3. rescan (boolean, optional, default=true) Rescan the wallet for transactions\n"

"\nExamples:\n"

"\nDump a private key\n"

+ HelpExampleCli("dumpprivkey", "\"myaddress\"") +

"\nImport the private key\n"

+ HelpExampleCli("importprivkey", "\"mykey\"") +

"\nImport using a label\n"

+ HelpExampleCli("importprivkey", "\"mykey\" \"testing\" false") +

"\nAs a json rpc call\n"

+ HelpExampleRpc("importprivkey", "\"mykey\", \"testing\", false")

);

EnsureWalletIsUnlocked();

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

CSidecoinSecret vchSecret;

bool fGood = vchSecret.SetString(strSecret);

if (!fGood) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key encoding");

CKey key = vchSecret.GetKey();

if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Private key outside allowed range");

CPubKey pubkey = key.GetPubKey();

CKeyID vchAddress = pubkey.GetID();

{

LOCK2(cs_main, pwalletMain->cs_wallet);

pwalletMain->MarkDirty();

pwalletMain->SetAddressBook(vchAddress, strLabel, "receive");

// 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(chainActive.Genesis(), true);

}

}

return Value::null;

{

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

throw runtime_error(

"importwallet \"filename\"\n"

"\nImports keys from a wallet dump file (see dumpwallet).\n"

"\nArguments:\n"

"1. \"filename\" (string, required) The wallet file\n"

"\nExamples:\n"

"\nDump the wallet\n"

+ HelpExampleCli("dumpwallet", "\"test\"") +

"\nImport the wallet\n"

+ HelpExampleCli("importwallet", "\"test\"") +

"\nImport using the json rpc call\n"

+ HelpExampleRpc("importwallet", "\"test\"")

);

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 = chainActive.Tip()->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;

CSidecoinSecret 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", CSidecoinAddress(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", CSidecoinAddress(keyid).ToString());

if (!pwalletMain->AddKeyPubKey(key, pubkey)) {

fGood = false;

continue;

}

pwalletMain->mapKeyMetadata[keyid].nCreateTime = nTime;

if (fLabel)

pwalletMain->SetAddressBook(keyid, strLabel, "receive");

nTimeBegin = std::min(nTimeBegin, nTime);

}

file.close();

CBlockIndex *pindex = chainActive.Tip();

while (pindex && pindex->pprev && pindex->nTime > nTimeBegin - 7200)

pindex = pindex->pprev;

LogPrintf("Rescanning last %i blocks\n", chainActive.Height() - pindex->nHeight + 1);

pwalletMain->ScanForWalletTransactions(pindex);

pwalletMain->MarkDirty();

if (!fGood)

throw JSONRPCError(RPC_WALLET_ERROR, "Error adding some keys to wallet");

return Value::null;

{

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

throw runtime_error(

"dumpprivkey \"sidecoinaddress\"\n"

"\nReveals the private key corresponding to 'sidecoinaddress'.\n"

"Then the importprivkey can be used with this output\n"

"\nArguments:\n"

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

"\nResult:\n"

"\"key\" (string) The private key\n"

"\nExamples:\n"

+ HelpExampleCli("dumpprivkey", "\"myaddress\"")

+ HelpExampleCli("importprivkey", "\"mykey\"")

+ HelpExampleRpc("dumpprivkey", "\"myaddress\"")

);

EnsureWalletIsUnlocked();

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

CSidecoinAddress address;

if (!address.SetString(strAddress))

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

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 CSidecoinSecret(vchSecret).ToString();

{

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

throw runtime_error(

"dumpwallet \"filename\"\n"

"\nDumps all wallet keys in a human-readable format.\n"

"\nArguments:\n"

"1. \"filename\" (string, required) The filename\n"

"\nExamples:\n"

+ HelpExampleCli("dumpwallet", "\"test\"")

+ HelpExampleRpc("dumpwallet", "\"test\"")

);

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 Sidecoin %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", chainActive.Height(), chainActive.Tip()->GetBlockHash().ToString());

file << strprintf("# mined on %s\n", EncodeDumpTime(chainActive.Tip()->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 = CSidecoinAddress(keyid).ToString();

CKey key;

if (pwalletMain->GetKey(keyid, key)) {

if (pwalletMain->mapAddressBook.count(keyid)) {

file << strprintf("%s %s label=%s # addr=%s\n", CSidecoinSecret(key).ToString(), strTime, EncodeDumpString(pwalletMain->mapAddressBook[keyid].name), strAddr);

} else if (setKeyPool.count(keyid)) {

file << strprintf("%s %s reserve=1 # addr=%s\n", CSidecoinSecret(key).ToString(), strTime, strAddr);

} else {

file << strprintf("%s %s change=1 # addr=%s\n", CSidecoinSecret(key).ToString(), strTime, strAddr);

}

}

}

file << "\n";

file << "# End of dump\n";

file.close();

return Value::null;