mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-03-01 05:42:17 +01:00
f748ff730b
a3e192areplaced MINE_ with ISMINE_ (JaSK)53a2148fixed bug where validateaddress doesn't display information (JaSK)f28707afixed bug in ListReceived() (JaSK)519dd1cAdded MINE_ALL = (spendable|watchonly) (JaSK)23b0506Fixed some stuff in TransactionDesc (JaSK)80dda36removed default argument values for ismine filter (JaSK)d5087d1Use script matching rather than destination matching for watch-only. (Pieter Wuille)0fa2f88added includedWatchonly argument to listreceivedbyaddress/...account (JaSK)f87ba3dadded includeWatchonly argument to 'gettransaction' because it affects balance calculation (JaSK)a5c6c5dfixed tiny glitch and improved readability like laanwj suggested (JaSK)d7d5d23Added argument to listtransactions and listsinceblock to include watchonly addresses (JaSK)952877eShowing 'involvesWatchonly' property for transactions returned by 'listtransactions' and 'listsinceblock'. It is only appended when the transaction involves a watchonly address. (JaSK)83f3543Added argument to listaccounts to include watchonly addresses (JaSK)d4640d7Added argument to getbalance to include watchonly addresses and fixed errors in balance calculation. (JaSK)d2692f6Watchonly transactions are marked in transaction history (JaSK)ffd40daWatchonly balances are shown separately in gui. (JaSK)2935b21qt: Hide unspendable outputs in coin control (Wladimir J. van der Laan)c898846Add support for watch-only addresses (Pieter Wuille)
379 lines
14 KiB
C++
379 lines
14 KiB
C++
// Copyright (c) 2009-2014 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 "base58.h"
|
||
#include "rpcserver.h"
|
||
#include "init.h"
|
||
#include "main.h"
|
||
#include "sync.h"
|
||
#include "wallet.h"
|
||
|
||
#include <fstream>
|
||
#include <stdint.h>
|
||
|
||
#include <boost/algorithm/string.hpp>
|
||
#include <boost/date_time/posix_time/posix_time.hpp>
|
||
#include "json/json_spirit_value.h"
|
||
|
||
using namespace json_spirit;
|
||
using namespace std;
|
||
|
||
void EnsureWalletIsUnlocked();
|
||
|
||
std::string static EncodeDumpTime(int64_t nTime) {
|
||
return DateTimeStrFormat("%Y-%m-%dT%H:%M:%SZ", nTime);
|
||
}
|
||
|
||
int64_t static DecodeDumpTime(const std::string &str) {
|
||
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::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();
|
||
}
|
||
|
||
Value importprivkey(const Array& params, bool fHelp)
|
||
{
|
||
if (fHelp || params.size() < 1 || params.size() > 3)
|
||
throw runtime_error(
|
||
"importprivkey \"bitcoinprivkey\" ( \"label\" rescan )\n"
|
||
"\nAdds a private key (as returned by dumpprivkey) to your wallet.\n"
|
||
"\nArguments:\n"
|
||
"1. \"bitcoinprivkey\" (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();
|
||
|
||
CBitcoinSecret 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;
|
||
}
|
||
|
||
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 or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend.");
|
||
|
||
CScript script;
|
||
|
||
CBitcoinAddress address(params[0].get_str());
|
||
if (address.IsValid()) {
|
||
script.SetDestination(address.Get());
|
||
} else if (IsHex(params[0].get_str())) {
|
||
std::vector<unsigned char> data(ParseHex(params[0].get_str()));
|
||
script = CScript(data.begin(), data.end());
|
||
} else {
|
||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address or script");
|
||
}
|
||
|
||
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);
|
||
|
||
// add to address book or update label
|
||
if (address.IsValid())
|
||
pwalletMain->SetAddressBook(address.Get(), strLabel, "receive");
|
||
|
||
// Don't throw error in case an address is already there
|
||
if (pwalletMain->HaveWatchOnly(script))
|
||
return Value::null;
|
||
|
||
pwalletMain->MarkDirty();
|
||
|
||
if (!pwalletMain->AddWatchOnly(script))
|
||
throw JSONRPCError(RPC_WALLET_ERROR, "Error adding address to wallet");
|
||
|
||
if (fRescan)
|
||
{
|
||
pwalletMain->ScanForWalletTransactions(chainActive.Genesis(), true);
|
||
pwalletMain->ReacceptWalletTransactions();
|
||
}
|
||
}
|
||
|
||
return Value::null;
|
||
}
|
||
|
||
Value importwallet(const Array& params, bool fHelp)
|
||
{
|
||
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(), std::ios::in | std::ios::ate);
|
||
if (!file.is_open())
|
||
throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
|
||
|
||
int64_t nTimeBegin = chainActive.Tip()->GetBlockTime();
|
||
|
||
bool fGood = true;
|
||
|
||
int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
|
||
file.seekg(0, file.beg);
|
||
|
||
pwalletMain->ShowProgress(_("Importing..."), 0); // show progress dialog in GUI
|
||
while (file.good()) {
|
||
pwalletMain->ShowProgress("", std::max(1, std::min(99, (int)(((double)file.tellg() / (double)nFilesize) * 100))));
|
||
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->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();
|
||
pwalletMain->ShowProgress("", 100); // hide progress dialog in GUI
|
||
|
||
CBlockIndex *pindex = chainActive.Tip();
|
||
while (pindex && pindex->pprev && pindex->GetBlockTime() > nTimeBegin - 7200)
|
||
pindex = pindex->pprev;
|
||
|
||
if (!pwalletMain->nTimeFirstKey || nTimeBegin < pwalletMain->nTimeFirstKey)
|
||
pwalletMain->nTimeFirstKey = nTimeBegin;
|
||
|
||
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;
|
||
}
|
||
|
||
Value dumpprivkey(const Array& params, bool fHelp)
|
||
{
|
||
if (fHelp || params.size() != 1)
|
||
throw runtime_error(
|
||
"dumpprivkey \"bitcoinaddress\"\n"
|
||
"\nReveals the private key corresponding to 'bitcoinaddress'.\n"
|
||
"Then the importprivkey can be used with this output\n"
|
||
"\nArguments:\n"
|
||
"1. \"bitcoinaddress\" (string, required) The bitcoin 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();
|
||
CBitcoinAddress address;
|
||
if (!address.SetString(strAddress))
|
||
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin 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 CBitcoinSecret(vchSecret).ToString();
|
||
}
|
||
|
||
|
||
Value dumpwallet(const Array& params, bool fHelp)
|
||
{
|
||
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 Bitcoin %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()->GetBlockTime()));
|
||
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].name), 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;
|
||
}
|