{

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;

{

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

{

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;

}

{

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

throw runtime_error(

"importprivkey <Mavroprivkey> [label]\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();

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;

bool fCompressed;

CSecret secret = vchSecret.GetSecret(fCompressed);

key.SetSecret(secret, fCompressed);

CKeyID vchAddress = key.GetPubKey().GetID();

{

LOCK2(cs_main, pwalletMain->cs_wallet);

pwalletMain->MarkDirty();

pwalletMain->SetAddressBookName(vchAddress, strLabel);

if (!pwalletMain->AddKey(key))

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

pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);

pwalletMain->ReacceptWalletTransactions();

}

return Value::null;

{

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;

bool fCompressed;

CKey key;

CSecret secret = vchSecret.GetSecret(fCompressed);

key.SetSecret(secret, fCompressed);

CKeyID keyid = key.GetPubKey().GetID();

if (pwalletMain->HaveKey(keyid)) {

printf("Skipping import of %s (key already present)\n", CBitcoinAddress(keyid).ToString().c_str());

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;

}

}

printf("Importing %s...\n", CBitcoinAddress(keyid).ToString().c_str());

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;

printf("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;

{

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

throw runtime_error(

"dumpprivkey <Mavroaddress>\n"

"Reveals the private key corresponding to <Mavroaddress>.");

EnsureWalletIsUnlocked();

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

CBitcoinAddress address;

if (!address.SetString(strAddress))

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Mavro 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");

CSecret vchSecret;

bool fCompressed;

if (!pwalletMain->GetSecret(keyID, vchSecret, fCompressed))

throw JSONRPCError(RPC_WALLET_ERROR, "Private key for address " + strAddress + " is not known");

return CBitcoinSecret(vchSecret, fCompressed).ToString();

{

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 Mavro %s (%s)\n", CLIENT_BUILD.c_str(), CLIENT_DATE.c_str());

file << strprintf("# * Created on %s\n", EncodeDumpTime(GetTime()).c_str());

file << strprintf("# * Best block at time of backup was %i (%s),\n", nBestHeight, hashBestChain.ToString().c_str());

file << strprintf("# mined on %s\n", EncodeDumpTime(pindexBest->nTime).c_str());

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

bool IsCompressed;

CKey key;

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

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

CSecret secret = key.GetSecret(IsCompressed);

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

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

CSecret secret = key.GetSecret(IsCompressed);

file << strprintf("%s %s reserve=1 # addr=%s\n", CBitcoinSecret(secret, IsCompressed).ToString().c_str(), strTime.c_str(), strAddr.c_str());

} else {

CSecret secret = key.GetSecret(IsCompressed);

file << strprintf("%s %s change=1 # addr=%s\n", CBitcoinSecret(secret, IsCompressed).ToString().c_str(), strTime.c_str(), strAddr.c_str());

}

}

}

file << "\n";

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

file.close();

return Value::null;