bool CBasicKeyStore::RemoveWatchOnly(const CScript &dest)
{
LOCK(cs_KeyStore);
setWatchOnly.erase(dest);
CPubKey pubKey;
if (ExtractPubKey(dest, pubKey)) {
mapWatchKeys.erase(pubKey.GetID());
}
// Related CScripts are not removed; having superfluous scripts around is
// harmless (see comment in ImplicitlyLearnRelatedKeyScripts).
return true;
}
void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked()
{
CBitcoinAddress addr(ui->addressIn_VM->text().toStdString());
if (!addr.IsValid())
{
ui->addressIn_VM->setValid(false);
ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_VM->setText(tr("The entered address is invalid.") + QString(" ") + tr("Please check the address and try again."));
return;
}
CKeyID keyID;
if (!addr.GetKeyID(keyID))
{
ui->addressIn_VM->setValid(false);
ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_VM->setText(tr("The entered address does not refer to a key.") + QString(" ") + tr("Please check the address and try again."));
return;
}
bool fInvalid = false;
std::vector<unsigned char> vchSig = DecodeBase64(ui->signatureIn_VM->text().toStdString().c_str(), &fInvalid);
if (fInvalid)
{
ui->signatureIn_VM->setValid(false);
ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_VM->setText(tr("The signature could not be decoded.") + QString(" ") + tr("Please check the signature and try again."));
return;
}
CDataStream ss(SER_GETHASH, 0);
ss << strMessageMagic;
ss << ui->messageIn_VM->document()->toPlainText().toStdString();
CPubKey pubkey;
if (!pubkey.RecoverCompact(Hash(ss.begin(), ss.end()), vchSig))
{
ui->signatureIn_VM->setValid(false);
ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_VM->setText(tr("The signature did not match the message digest.") + QString(" ") + tr("Please check the signature and try again."));
return;
}
if (!(CBitcoinAddress(pubkey.GetID()) == addr))
{
ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verification failed.") + QString("</nobr>"));
return;
}
ui->statusLabel_VM->setStyleSheet("QLabel { color: green; }");
ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verified.") + QString("</nobr>"));
}
UniValue verifymessage(const JSONRPCRequest& request)
{
if (request.fHelp || request.params.size() != 3)
throw std::runtime_error(
"verifymessage \"address\" \"signature\" \"message\"\n"
"\nVerify a signed message\n"
"\nArguments:\n"
"1. \"address\" (string, required) The sexcoin address to use for the signature.\n"
"2. \"signature\" (string, required) The signature provided by the signer in base 64 encoding (see signmessage).\n"
"3. \"message\" (string, required) The message that was signed.\n"
"\nResult:\n"
"true|false (boolean) If the signature is verified or not.\n"
"\nExamples:\n"
"\nUnlock the wallet for 30 seconds\n"
+ HelpExampleCli("walletpassphrase", "\"mypassphrase\" 30") +
"\nCreate the signature\n"
+ HelpExampleCli("signmessage", "\"Vn1PmGY6T7P1BLsm42C2qcj2CSSwV7xk2Y\" \"my message\"") +
"\nVerify the signature\n"
+ HelpExampleCli("verifymessage", "\"Vn1PmGY6T7P1BLsm42C2qcj2CSSwV7xk2Y\" \"signature\" \"my message\"") +
"\nAs json rpc\n"
+ HelpExampleRpc("verifymessage", "\"Vn1PmGY6T7P1BLsm42C2qcj2CSSwV7xk2Y\", \"signature\", \"my message\"")
);
LOCK(cs_main);
std::string strAddress = request.params[0].get_str();
std::string strSign = request.params[1].get_str();
std::string strMessage = request.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;
std::vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
if (fInvalid)
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Malformed base64 encoding");
CHashWriter ss(SER_GETHASH, 0);
ss << strMessageMagic;
ss << strMessage;
CPubKey pubkey;
if (!pubkey.RecoverCompact(ss.GetHash(), vchSig))
return false;
return (pubkey.GetID() == keyID);
}
bool CMasternodeBroadcast::Create(CTxIn txin, CService service, CKey keyCollateralAddressNew, CPubKey pubKeyCollateralAddressNew, CKey keyMasternodeNew, CPubKey pubKeyMasternodeNew, std::string& strErrorRet, CMasternodeBroadcast& mnbRet)
{
// wait for reindex and/or import to finish
if (fImporting || fReindex) return false;
LogPrint("masternode", "CMasternodeBroadcast::Create -- pubKeyCollateralAddressNew = %s, pubKeyMasternodeNew.GetID() = %s\n",
CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
pubKeyMasternodeNew.GetID().ToString());
CMasternodePing mnp(txin);
if (!mnp.Sign(keyMasternodeNew, pubKeyMasternodeNew)) {
strErrorRet = strprintf("Failed to sign ping, masternode=%s", txin.prevout.ToStringShort());
LogPrintf("CMasternodeBroadcast::Create -- %s\n", strErrorRet);
mnbRet = CMasternodeBroadcast();
return false;
}
mnbRet = CMasternodeBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyMasternodeNew, PROTOCOL_VERSION);
if (!mnbRet.IsValidNetAddr()) {
strErrorRet = strprintf("Invalid IP address, masternode=%s", txin.prevout.ToStringShort());
LogPrintf("CMasternodeBroadcast::Create -- %s\n", strErrorRet);
mnbRet = CMasternodeBroadcast();
return false;
}
mnbRet.lastPing = mnp;
if (!mnbRet.Sign(keyCollateralAddressNew)) {
strErrorRet = strprintf("Failed to sign broadcast, masternode=%s", txin.prevout.ToStringShort());
LogPrintf("CMasternodeBroadcast::Create -- %s\n", strErrorRet);
mnbRet = CMasternodeBroadcast();
return false;
}
return true;
}
void dumpKeyInfo(uint256 secret)
{
CKey key;
CAnoncoinSecret b58secret;
printf(" * secret (hex): %s\n", secret.GetHex().c_str());
for (int nCompressed=0; nCompressed<2; nCompressed++)
{
bool fCompressed = nCompressed == 1;
printf(" * %s:\n", fCompressed ? "compressed" : "uncompressed");
key.Set( secret.begin(), secret.end(), fCompressed );
b58secret.SetKey( key );
printf(" * secret (base58): %s\n", b58secret.ToString().c_str());
CPubKey pubkey = key.GetPubKey();
printf(" * address (base58): %s\n", CAnoncoinAddress(CTxDestination(pubkey.GetID())).ToString().c_str() );
}
}
static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const CPubKey& pubkey, const CScript& scriptcode, SigVersion sigversion)
{
CKeyID keyid = pubkey.GetID();
const auto it = sigdata.signatures.find(keyid);
if (it != sigdata.signatures.end()) {
sig_out = it->second.second;
return true;
}
sigdata.misc_pubkeys.emplace(keyid, pubkey);
if (creator.CreateSig(provider, sig_out, keyid, scriptcode, sigversion)) {
auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
assert(i.second);
return true;
}
return false;
}
Value importprivkey(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 3)
throw runtime_error(
"importprivkey <dokdocoinprivkey> [label] [rescan=true]\n"
"Adds a private key (as returned by dumpprivkey) to your wallet.");
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();
CPubKey pubkey = key.GetPubKey();
CKeyID vchAddress = pubkey.GetID();
if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Private key outside allowed range");
{
LOCK2(cs_main, pwalletMain->cs_wallet);
pwalletMain->MarkDirty();
pwalletMain->SetAddressBookName(vchAddress, strLabel);
if (!pwalletMain->AddKeyPubKey(key, pubkey))
throw JSONRPCError(RPC_WALLET_ERROR, "Error adding key to wallet");
if (fRescan) {
pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
pwalletMain->ReacceptWalletTransactions();
}
}
return Value::null;
}
void AsyncRPCOperation_sendmany::add_taddr_change_output_to_tx(CAmount amount) {
LOCK2(cs_main, pwalletMain->cs_wallet);
EnsureWalletIsUnlocked();
CReserveKey keyChange(pwalletMain);
CPubKey vchPubKey;
bool ret = keyChange.GetReservedKey(vchPubKey);
if (!ret) {
throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Could not generate a taddr to use as a change address"); // should never fail, as we just unlocked
}
CScript scriptPubKey = GetScriptForDestination(vchPubKey.GetID());
CTxOut out(amount, scriptPubKey);
CMutableTransaction rawTx(tx_);
rawTx.vout.push_back(out);
tx_ = CTransaction(rawTx);
}
static bool GetPubKey(const SigningProvider& provider, SignatureData& sigdata, const CKeyID& address, CPubKey& pubkey)
{
if (provider.GetPubKey(address, pubkey)) {
sigdata.misc_pubkeys.emplace(pubkey.GetID(), pubkey);
return true;
}
// Look for pubkey in all partial sigs
const auto it = sigdata.signatures.find(address);
if (it != sigdata.signatures.end()) {
pubkey = it->second.first;
return true;
}
// Look for pubkey in pubkey list
const auto& pk_it = sigdata.misc_pubkeys.find(address);
if (pk_it != sigdata.misc_pubkeys.end()) {
pubkey = pk_it->second;
return true;
}
return false;
}
void Bip38ToolDialog::on_decryptKeyButton_DEC_clicked()
{
string strPassphrase = ui->passphraseIn_DEC->text().toStdString();
string strKey = ui->encryptedKeyIn_DEC->text().toStdString();
uint256 privKey;
bool fCompressed;
if (!BIP38_Decrypt(strPassphrase, strKey, privKey, fCompressed)) {
ui->statusLabel_DEC->setStyleSheet("QLabel { color: red; }");
ui->statusLabel_DEC->setText(tr("Failed to decrypt.") + QString(" ") + tr("Please check the key and passphrase and try again."));
return;
}
key.Set(privKey.begin(), privKey.end(), fCompressed);
CPubKey pubKey = key.GetPubKey();
CBitcoinAddress address(pubKey.GetID());
ui->decryptedKeyOut_DEC->setText(QString::fromStdString(CBitcoinSecret(key).ToString()));
ui->addressOut_DEC->setText(QString::fromStdString(address.ToString()));
}
Value createwalletuser(const Array& params, bool fHelp)
{
if (fHelp || (params.size() != 1 && params.size() != 2))
throw runtime_error(
"createwalletuser <username> [replacekey]\n"
"Create a new key pair for user and add it to wallet\n"
"Use sendnewusertransaction to publish it to the network.\n"
"Returns key secret (keep it safe)");
EnsureWalletIsUnlocked();
string strUsername = params[0].get_str();
bool replaceKey = false;
if (params.size() > 1)
replaceKey = params[1].get_bool();
CKeyID keyID;
bool keyInWallet = pwalletMain->GetKeyIdFromUsername(strUsername, keyID);
if( keyInWallet && !replaceKey )
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: this username exists in wallet");
if( !keyInWallet && replaceKey )
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: replacekey given but old key not in wallet");
CTransaction txOut;
uint256 hashBlock;
if( GetTransaction(strUsername, txOut, hashBlock) && !replaceKey )
throw JSONRPCError(RPC_WALLET_INVALID_ACCOUNT_NAME, "Error: this username exists in tx database");
if( replaceKey && !pwalletMain->MoveKeyForReplacement(strUsername) )
throw JSONRPCError(RPC_WALLET_ERROR, "Error: moving key for replacement");
// Generate a new key that is added to wallet
CPubKey newKey = pwalletMain->GenerateNewKey(strUsername);
keyID = newKey.GetID();
CKey vchSecret;
if (!pwalletMain->GetKey(keyID, vchSecret))
throw JSONRPCError(RPC_WALLET_ERROR, "Error: could not obtain just created privkey?!");
return CBitcoinSecret(vchSecret).ToString();
}
Value getdefaultuser(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getdefaultuser\n"
"Get default user being used");
EnsureWalletIsUnlocked();
CPubKey vchPubKey = pwalletMain->vchDefaultKey;
if( !vchPubKey.IsValid() )
throw JSONRPCError(RPC_WALLET_ERROR, "Error: default user key is invalid");
CKeyID keyID = vchPubKey.GetID();
std::string username;
if( !pwalletMain->GetUsernameFromKeyId(keyID, username) )
throw JSONRPCError(RPC_WALLET_ERROR, "Error converting keyID to username");
return username;
}
bool CAccountHD::AddKeyPubKey(int64_t HDKeyIndex, const CPubKey &pubkey, int keyChain)
{
if(keyChain == KEYCHAIN_EXTERNAL)
return externalKeyStore.AddKeyPubKey(HDKeyIndex, pubkey);
else
{
// Add public key with null private key - we later write the private key IFF it is used in a witnessing operation
if (IsPoW2Witness())
{
CKey nullKey;
//fixme: (2.1) This is possibly a bit inefficient - see if it can be sped up.
if(!internalKeyStore.HaveKey(pubkey.GetID()))
{
if(!internalKeyStore.AddKeyPubKey(nullKey, pubkey))
{
throw std::runtime_error("CAccountHD::AddKeyPubKey failed to store witness key.");
}
}
}
return internalKeyStore.AddKeyPubKey(HDKeyIndex, pubkey);
}
}
bool CGovernanceObject::Sign(CKey& keyMasternode, CPubKey& pubKeyMasternode)
{
std::string strError;
std::string strMessage = GetSignatureMessage();
LOCK(cs);
if(!CMessageSigner::SignMessage(strMessage, vchSig, keyMasternode)) {
LogPrintf("CGovernanceObject::Sign -- SignMessage() failed\n");
return false;
}
if(!CMessageSigner::VerifyMessage(pubKeyMasternode, vchSig, strMessage, strError)) {
LogPrintf("CGovernanceObject::Sign -- VerifyMessage() failed, error: %s\n", strError);
return false;
}
LogPrint("gobject", "CGovernanceObject::Sign -- pubkey id = %s, vin = %s\n",
pubKeyMasternode.GetID().ToString(), vinMasternode.prevout.ToStringShort());
return true;
}
static duk_ret_t API__getnewaddress ( duk_context * ctx )
{
const char * account;
account = duk_require_string ( ctx, 0 );
if (!pwalletMain->IsLocked())
pwalletMain->TopUpKeyPool();
// Generate a new key that is added to wallet
CPubKey newKey;
if (!pwalletMain->GetKeyFromPool(newKey, false))
duk_error ( ctx, EMEROBOT_ERR_KEYPOOL_RAN_OUT,
"Keypool ran out, please call keypoolrefill first" );
CKeyID keyID = newKey.GetID();
pwalletMain->SetAddressBookName ( keyID, account );
duk_push_string ( ctx, CBitcoinAddress(keyID).ToString().c_str() );
return 1;
}
void NewAccountDialog::showSyncQr()
{
WalletModel::UnlockContext ctx(walletModel->requestUnlock());
if (ctx.isValid()) {
newAccount = pwalletMain->GenerateNewAccount(ui->newAccountName->text().toStdString(), AccountType::Normal, AccountSubType::Mobi);
LOCK(pwalletMain->cs_wallet);
{
int64_t currentTime = newAccount->getEarliestPossibleCreationTime();
std::string payoutAddress;
CReserveKey reservekey(pwalletMain, newAccount, KEYCHAIN_CHANGE);
CPubKey vchPubKey;
if (!reservekey.GetReservedKey(vchPubKey))
return;
payoutAddress = CBitcoinAddress(vchPubKey.GetID()).ToString();
QString qrString = QString::fromStdString("guldensync:" + CBitcoinSecretExt(*newAccount->GetAccountMasterPrivKey()).ToString(QString::number(currentTime).toStdString(), payoutAddress));
ui->scanQRCode->setCode(qrString);
disconnect(this, SLOT(showSyncQr()));
}
}
}
void CBasicKeyStore::ImplicitlyLearnRelatedKeyScripts(const CPubKey& pubkey)
{
AssertLockHeld(cs_KeyStore);
CKeyID key_id = pubkey.GetID();
// We must actually know about this key already.
assert(HaveKey(key_id) || mapWatchKeys.count(key_id));
// This adds the redeemscripts necessary to detect P2WPKH and P2SH-P2WPKH
// outputs. Technically P2WPKH outputs don't have a redeemscript to be
// spent. However, our current IsMine logic requires the corresponding
// P2SH-P2WPKH redeemscript to be present in the wallet in order to accept
// payment even to P2WPKH outputs.
// Also note that having superfluous scripts in the keystore never hurts.
// They're only used to guide recursion in signing and IsMine logic - if
// a script is present but we can't do anything with it, it has no effect.
// "Implicitly" refers to fact that scripts are derived automatically from
// existing keys, and are present in memory, even without being explicitly
// loaded (e.g. from a file).
if (pubkey.IsCompressed()) {
CScript script = GetScriptForDestination(WitnessV0KeyHash(key_id));
// This does not use AddCScript, as it may be overridden.
CScriptID id(script);
mapScripts[id] = std::move(script);
}
}
std::string RestoreGridcoinBackupWallet()
{
//AdvancedBackup
//AdvancedSalvage
//4-26-2014
boost::filesystem::path path = GetDataDir() / "walletbackups" / "backup.dat";
std::string errors = "";
std::string sWallet = getfilecontents(path.string().c_str());
if (sWallet == "-1") return "Unable to open backup file.";
string strSecret = "from file";
string strLabel = "Restored";
std::vector<std::string> vWallet = split(sWallet.c_str(),"<KEY>");
if (vWallet.size() > 1)
{
for (unsigned int i = 0; i < vWallet.size(); i++)
{
std::string sKey = vWallet[i];
if (sKey.length() > 2)
{
printf("Restoring private key %s",sKey.substr(0,5).c_str());
//Key is delimited by <|>
std::vector<std::string> vKey = split(sKey.c_str(),"<|>");
if (vKey.size() > 1)
{
std::string sSecret = vKey[0];
std::string sPublic = vKey[1];
CBitcoinSecret vchSecret;
bool fGood = vchSecret.SetString(sSecret);
if (!fGood)
{
errors = errors + "Invalid private key : " + sSecret + "\r\n";
}
else
{
CKey key = vchSecret.GetKey();
CPubKey pubkey = key.GetPubKey();
CKeyID vchAddress = pubkey.GetID();
{
LOCK2(cs_main, pwalletMain->cs_wallet);
if (!pwalletMain->AddKeyPubKey(key, pubkey))
{
errors = errors + "Error adding key to wallet: " + sKey + "\r\n";
}
if (i==0)
{
pwalletMain->SetDefaultKey(pubkey);
pwalletMain->SetAddressBookName(vchAddress, strLabel);
}
pwalletMain->MarkDirty();
}
}
}
}
}
}
//Rescan
{
LOCK2(cs_main, pwalletMain->cs_wallet);
if (true) {
pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
pwalletMain->ReacceptWalletTransactions();
}
}
printf("Rebuilding wallet, results: %s",errors.c_str());
return errors;
}
CMasternode::CollateralStatus CMasternode::CheckCollateral(const COutPoint& outpoint, const CPubKey& pubkey, int& nHeightRet)
{
AssertLockHeld(cs_main);
Coin coin;
if (!GetUTXOCoin(outpoint, coin)) {
return COLLATERAL_UTXO_NOT_FOUND;
}
if (coin.out.nValue != 25000 * COIN) {
return COLLATERAL_INVALID_AMOUNT;
}
if (pubkey == CPubKey() || coin.out.scriptPubKey != GetScriptForDestination(CScriptID(GetScriptForDestination(WitnessV0KeyHash(pubkey.GetID()))))) {
return COLLATERAL_INVALID_PUBKEY;
}
nHeightRet = coin.nHeight;
return COLLATERAL_OK;
}
bool CAccount::AddCryptedKey(const CPubKey& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, int64_t nKeyChain)
{
assert(!IsHD());
if (nKeyChain == KEYCHAIN_EXTERNAL) {
if (!externalKeyStore.AddCryptedKey(vchPubKey, vchCryptedSecret))
return false;
} else {
if (!internalKeyStore.AddCryptedKey(vchPubKey, vchCryptedSecret))
return false;
}
if (pwalletMain) {
if (!pwalletMain->fFileBacked)
return true;
{
LOCK(pwalletMain->cs_wallet);
if (pwalletMain->pwalletdbEncryption)
return pwalletMain->pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret, pwalletMain->mapKeyMetadata[vchPubKey.GetID()], getUUID(), nKeyChain);
else
return CWalletDB(pwalletMain->strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret, pwalletMain->mapKeyMetadata[vchPubKey.GetID()], getUUID(), nKeyChain);
}
} else {
return true;
}
return false;
}
void ProcessMessageMasternode(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
{
if (strCommand == "dsee") { //DarkSend Election Entry
if (pfrom->nVersion != darkSendPool.MIN_PEER_PROTO_VERSION) {
return;
}
bool fIsInitialDownload = IsInitialBlockDownload();
if(fIsInitialDownload) return;
CTxIn vin;
CService addr;
CPubKey pubkey;
CPubKey pubkey2;
vector<unsigned char> vchSig;
int64 sigTime;
int count;
int current;
int64 lastUpdated;
vRecv >> vin >> addr >> vchSig >> sigTime >> pubkey >> pubkey2 >> count >> current >> lastUpdated;
bool isLocal = false; // addr.IsRFC1918();
std::string vchPubKey(pubkey.begin(), pubkey.end());
std::string vchPubKey2(pubkey2.begin(), pubkey2.end());
CScript pubkeyScript;
pubkeyScript.SetDestination(pubkey.GetID());
if(pubkeyScript.size() != 25) {
LogPrintf("dsee - pubkey the wrong size\n");
pfrom->Misbehaving(100);
return;
}
std::string strMessage = addr.ToString() + boost::lexical_cast<std::string>(sigTime) + vchPubKey + vchPubKey2;
CScript pubkeyScript2;
pubkeyScript2.SetDestination(pubkey2.GetID());
if(pubkeyScript2.size() != 25) {
LogPrintf("dsee - pubkey the wrong size\n");
pfrom->Misbehaving(100);
return;
}
std::string errorMessage = "";
if(!darkSendSigner.VerifyMessage(pubkey, vchSig, strMessage, errorMessage)){
LogPrintf("dsee - Got bad masternode address signature\n");
pfrom->Misbehaving(100);
return;
}
if((fTestNet && addr.GetPort() != 19999) || (!fTestNet && addr.GetPort() != 9999)) return;
//LogPrintf("Searching existing masternodes : %s - %s\n", addr.ToString().c_str(), vin.ToString().c_str());
BOOST_FOREACH(CMasterNode& mn, darkSendMasterNodes) {
//LogPrintf(" -- %s\n", mn.vin.ToString().c_str());
if(mn.vin.prevout == vin.prevout) {
//count == -1 when it's a new entry
// e.g. We don't want the entry relayed/time updated when we're syncing the list
if(count == -1 && !mn.UpdatedWithin(MASTERNODE_MIN_SECONDS)){
mn.UpdateLastSeen();
if(mn.now < sigTime){ //take the newest entry
LogPrintf("dsee - Got updated entry for %s\n", addr.ToString().c_str());
mn.pubkey2 = pubkey2;
mn.now = sigTime;
mn.sig = vchSig;
if(pubkey2 == activeMasternode.pubkeyMasterNode2){
activeMasternode.EnableHotColdMasterNode(vin, sigTime, addr);
}
RelayDarkSendElectionEntry(vin, addr, vchSig, sigTime, pubkey, pubkey2, count, current, lastUpdated);
}
}
return;
}
}
if(!darkSendSigner.IsVinAssociatedWithPubkey(vin, pubkey)) {
LogPrintf("dsee - Got mismatched pubkey and vin\n");
pfrom->Misbehaving(100);
return;
}
LogPrintf("dsee - Got NEW masternode entry %s\n", addr.ToString().c_str());
CValidationState state;
CTransaction tx = CTransaction();
CTxOut vout = CTxOut(999.99*COIN, darkSendPool.collateralPubKey);
tx.vin.push_back(vin);
tx.vout.push_back(vout);
if(tx.AcceptableInputs(state, true)){
LogPrintf("dsee - Accepted masternode entry %i %i\n", count, current);
if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){
LogPrintf("dsee - Input must have least %d confirmations\n", MASTERNODE_MIN_CONFIRMATIONS);
pfrom->Misbehaving(20);
return;
}
addrman.Add(CAddress(addr), pfrom->addr, 2*60*60);
CMasterNode mn(addr, vin, pubkey, vchSig, sigTime, pubkey2);
mn.UpdateLastSeen(lastUpdated);
darkSendMasterNodes.push_back(mn);
if(pubkey2 == activeMasternode.pubkeyMasterNode2){
activeMasternode.EnableHotColdMasterNode(vin, sigTime, addr);
}
if(count == -1 && !isLocal)
RelayDarkSendElectionEntry(vin, addr, vchSig, sigTime, pubkey, pubkey2, count, current, lastUpdated);
} else {
LogPrintf("dsee - Rejected masternode entry\n");
int nDoS = 0;
if (state.IsInvalid(nDoS))
{
LogPrintf("dsee - %s from %s %s was not accepted into the memory pool\n", tx.GetHash().ToString().c_str(),
pfrom->addr.ToString().c_str(), pfrom->cleanSubVer.c_str());
if (nDoS > 0)
pfrom->Misbehaving(nDoS);
}
}
}
else if (strCommand == "dseep") { //DarkSend Election Entry Ping
void ReceiveCoinsDialog::generateRequest()
{
CReserveKey reservekey(pwalletMain, model->getActiveAccount(), KEYCHAIN_EXTERNAL);
CPubKey vchPubKey;
if (!reservekey.GetReservedKey(vchPubKey)) {
return;
}
reservekey.KeepKey();
ui->receiveCoinsStackedWidget->setCurrentIndex(3);
ui->accountRequestPaymentButtonComposite->setVisible(false);
ui->accountBuyGuldenButton->setVisible(false);
ui->accountSaveQRButtonComposite->setVisible(true);
ui->accountCopyToClipboardButtonComposite->setVisible(true);
ui->cancelButton->setVisible(false);
ui->closeButton->setVisible(true);
ui->cancelButtonGroup->setVisible(true);
ui->generateRequestButton->setVisible(false);
ui->generateAnotherRequestButton->setVisible(true);
ui->accountBuyButton->setVisible(false);
ui->accountCopyToClipboardButton->setText(tr("Copy request to clipboard"));
CAmount amount = ui->requestAmount->value();
if (amount > 0) {
ui->labelPaymentRequestHeading->setText(tr("Request %1 Gulden").arg(BitcoinUnits::format(BitcoinUnits::BTC, amount, false, BitcoinUnits::separatorStandard, 2)));
} else {
ui->labelPaymentRequestHeading->setText(tr("Request Gulden"));
}
QString args;
QString label = QUrl::toPercentEncoding(ui->requestLabel->text());
QString strAmount;
if (!label.isEmpty()) {
label = "label=" + label;
}
if (amount > 0) {
strAmount = "amount=" + QUrl::toPercentEncoding(BitcoinUnits::format(BitcoinUnits::BTC, amount, false, BitcoinUnits::separatorNever, -1));
while (strAmount.endsWith("0")) {
strAmount.chop(1);
}
if (strAmount.endsWith(".")) {
strAmount.chop(1);
}
}
if (!strAmount.isEmpty() && !label.isEmpty()) {
args = "?" + label + "&" + strAmount;
} else if (!strAmount.isEmpty()) {
args = "?" + strAmount;
} else if (!label.isEmpty()) {
args = "?" + label;
}
QString uri = QString("Gulden:") + QString::fromStdString(CBitcoinAddress(vchPubKey.GetID()).ToString()) + args;
ui->labelPaymentRequest->setText(uri);
if (!uri.isEmpty()) {
if (uri.length() > MAX_URI_LENGTH) {
ui->requestQRImage->setFixedWidth(900);
ui->requestQRImage->setText(tr("Resulting URI too long, try to reduce the text for the label."));
} else {
ui->requestQRImage->setText("");
ui->requestQRImage->setFixedWidth(ui->requestQRImage->height());
ui->requestQRImage->setCode(uri);
}
}
pwalletMain->SetAddressBook(CBitcoinAddress(vchPubKey.GetID()).ToString(), ui->requestLabel->text().toStdString(), "receive");
}
CPubKey demoPubkey = pwalletMain->GenerateNewKey();
CBitcoinAddress demoAddress = CBitcoinAddress(CTxDestination(demoPubkey.GetID()));
Value retValue;
string strAccount = "walletDemoAccount";
string strPurpose = "receive";
BOOST_CHECK_NO_THROW({ /*Initialize Wallet with an account */
CWalletDB walletdb(pwalletMain->strWalletFile);
CAccount account;
account.vchPubKey = demoPubkey;
pwalletMain->SetAddressBook(account.vchPubKey.GetID(), strAccount, strPurpose);
walletdb.WriteAccount(strAccount, account);
});
CPubKey setaccountDemoPubkey = pwalletMain->GenerateNewKey();
CBitcoinAddress setaccountDemoAddress = CBitcoinAddress(CTxDestination(setaccountDemoPubkey.GetID()));
/*********************************
* setaccount
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("setaccount " + setaccountDemoAddress.ToString() + " nullaccount"));
/* 1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ is not owned by the test wallet. */
BOOST_CHECK_THROW(CallRPC("setaccount 1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XZ nullaccount"), runtime_error);
BOOST_CHECK_THROW(CallRPC("setaccount"), runtime_error);
/* 1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4X (33 chars) is an illegal address (should be 34 chars) */
BOOST_CHECK_THROW(CallRPC("setaccount 1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4X nullaccount"), runtime_error);
/*********************************
* listunspent
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listunspent"));
void ProcessMessageMasternode(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
{
if (strCommand == "dsee") { //DarkSend Election Entry
if(fLiteMode) return; //disable all darksend/masternode related functionality
bool fIsInitialDownload = IsInitialBlockDownload();
if(fIsInitialDownload) return;
CTxIn vin;
CService addr;
CPubKey pubkey;
CPubKey pubkey2;
vector<unsigned char> vchSig;
int64_t sigTime;
int count;
int current;
int64_t lastUpdated;
int protocolVersion;
std::string strMessage;
// 70047 and greater
vRecv >> vin >> addr >> vchSig >> sigTime >> pubkey >> pubkey2 >> count >> current >> lastUpdated >> protocolVersion;
// make sure signature isn't in the future (past is OK)
if (sigTime > GetAdjustedTime() + 60 * 60) {
printf("dsee - Signature rejected, too far into the future %s\n", vin.ToString().c_str());
return;
}
bool isLocal = addr.IsRFC1918() || addr.IsLocal();
//if(Params().MineBlocksOnDemand()) isLocal = false;
std::string vchPubKey(pubkey.vchPubKey.begin(), pubkey.vchPubKey.end());
std::string vchPubKey2(pubkey2.vchPubKey.begin(), pubkey2.vchPubKey.end());
strMessage = addr.ToString() + boost::lexical_cast<std::string>(sigTime) + vchPubKey + vchPubKey2 + boost::lexical_cast<std::string>(protocolVersion);
if(protocolVersion < MIN_MN_PROTO_VERSION) {
printf("dsee - ignoring outdated masternode %s protocol version %d\n", vin.ToString().c_str(), protocolVersion);
return;
}
CScript pubkeyScript;
pubkeyScript =GetScriptForDestination(pubkey.GetID());
if(pubkeyScript.size() != 25) {
printf("dsee - pubkey the wrong size\n");
pfrom->Misbehaving(100);
return;
}
CScript pubkeyScript2;
pubkeyScript2 =GetScriptForDestination(pubkey2.GetID());
if(pubkeyScript2.size() != 25) {
printf("dsee - pubkey2 the wrong size\n");
pfrom->Misbehaving(100);
return;
}
std::string errorMessage = "";
if(!darkSendSigner.VerifyMessage(pubkey, vchSig, strMessage, errorMessage)){
printf("dsee - Got bad masternode address signature\n");
pfrom->Misbehaving(100);
return;
}
//search existing masternode list, this is where we update existing masternodes with new dsee broadcasts
LOCK(cs_masternodes);
BOOST_FOREACH(CMasterNode& mn, vecMasternodes) {
if(mn.vin.prevout == vin.prevout) {
// count == -1 when it's a new entry
// e.g. We don't want the entry relayed/time updated when we're syncing the list
// mn.pubkey = pubkey, IsVinAssociatedWithPubkey is validated once below,
// after that they just need to match
if(count == -1 && mn.pubkey == pubkey && !mn.UpdatedWithin(MASTERNODE_MIN_DSEE_SECONDS)){
mn.UpdateLastSeen();
if(mn.now < sigTime){ //take the newest entry
printf("dsee - Got updated entry for %s\n", addr.ToString().c_str());
mn.pubkey2 = pubkey2;
mn.now = sigTime;
mn.sig = vchSig;
mn.protocolVersion = protocolVersion;
mn.addr = addr;
RelayDarkSendElectionEntry(vin, addr, vchSig, sigTime, pubkey, pubkey2, count, current, lastUpdated, protocolVersion);
}
}
return;
}
}
// make sure the vout that was signed is related to the transaction that spawned the masternode
// - this is expensive, so it's only done once per masternode
if(!darkSendSigner.IsVinAssociatedWithPubkey(vin, pubkey)) {
printf("dsee - Got mismatched pubkey and vin\n");
pfrom->Misbehaving(100);
return;
}
if(fDebug) printf("dsee - Got NEW masternode entry %s\n", addr.ToString().c_str());
// make sure it's still unspent
// - this is checked later by .check() in many places and by ThreadCheckDarkSendPool()
CTransaction tx = CTransaction();
CTxOut vout = CTxOut(24999*COIN, darkSendPool.collateralPubKey);
tx.vin.push_back(vin);
tx.vout.push_back(vout);
//if(AcceptableInputs(mempool, state, tx)){
bool* pfMissingInputs = false;
if(AcceptableInputs(mempool, tx, false, pfMissingInputs)){
if(fDebug) printf("dsee - Accepted masternode entry %i %i\n", count, current);
if(GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS){
printf("dsee - Input must have least %d confirmations\n", MASTERNODE_MIN_CONFIRMATIONS);
pfrom->Misbehaving(20);
return;
}
// use this as a peer
addrman.Add(CAddress(addr), pfrom->addr, 2*60*60);
// add our masternode
CMasterNode mn(addr, vin, pubkey, vchSig, sigTime, pubkey2, protocolVersion);
mn.UpdateLastSeen(lastUpdated);
vecMasternodes.push_back(mn);
// if it matches our masternodeprivkey, then we've been remotely activated
if(pubkey2 == activeMasternode.pubKeyMasternode && protocolVersion == PROTOCOL_VERSION){
activeMasternode.EnableHotColdMasterNode(vin, addr);
}
if(count == -1 && !isLocal)
RelayDarkSendElectionEntry(vin, addr, vchSig, sigTime, pubkey, pubkey2, count, current, lastUpdated, protocolVersion);
} else {
printf("dsee - Rejected masternode entry %s\n", addr.ToString().c_str());
int nDoS = 0;
/* if (state.IsInvalid(nDoS))
{
printf("dsee - %s from %s %s was not accepted into the memory pool\n", tx.GetHash().ToString().c_str(),
pfrom->addr.ToString().c_str(), pfrom->cleanSubVer.c_str());
if (nDoS > 0)
pfrom->Misbehaving(nDoS);
}*/
}
}
else if (strCommand == "dseep") { //DarkSend Election Entry Ping
void PaperWalletDialog::on_getNewAddress_clicked()
{
// Create a new private key
CKey privKey;
privKey.MakeNewKey(true);
// Derive the public key
CPubKey pubkey = privKey.GetPubKey();
// Derive the public key hash
CBitcoinAddress pubkeyhash;
pubkeyhash.Set(pubkey.GetID());
// Create String versions of each
string myPrivKey = CBitcoinSecret(privKey).ToString();
string myPubKey = HexStr(pubkey.begin(), pubkey.end());
string myAddress = pubkeyhash.ToString();
#ifdef USE_QRCODE
// Generate the address QR code
QRcode *code = QRcode_encodeString(myAddress.c_str(), 0, QR_ECLEVEL_M, QR_MODE_8, 1);
if (!code)
{
ui->addressQRCode->setText(tr("Error encoding Address into QR Code."));
return;
}
QImage publicKeyImage = QImage(code->width, code->width, QImage::Format_ARGB32);
publicKeyImage.fill(0x000000);
unsigned char *p = code->data;
for (int y = 0; y < code->width; y++)
{
for (int x = 0; x < code->width; x++)
{
publicKeyImage.setPixel(x, y, ((*p & 1) ? 0xff000000 : 0x0));
p++;
}
}
QRcode_free(code);
// Generate the private key QR code
code = QRcode_encodeString(myPrivKey.c_str(), 0, QR_ECLEVEL_M, QR_MODE_8, 1);
if (!code)
{
ui->privateKeyQRCode->setText(tr("Error encoding private key into QR Code."));
return;
}
QImage privateKeyImage = QImage(code->width, code->width, QImage::Format_ARGB32);
privateKeyImage.fill(0x000000);
p = code->data;
for (int y = 0; y < code->width; y++)
{
for (int x = 0; x < code->width; x++)
{
privateKeyImage.setPixel(x, y, ((*p & 1) ? 0xff000000 : 0x0));
p++;
}
}
QRcode_free(code);
// Populate the QR Codes
ui->addressQRCode->setPixmap(QPixmap::fromImage(publicKeyImage).scaled(ui->addressQRCode->width(), ui->addressQRCode->height()));
ui->privateKeyQRCode->setPixmap(QPixmap::fromImage(privateKeyImage).scaled(ui->privateKeyQRCode->width(), ui->privateKeyQRCode->height()));
#endif
// Populate the Texts
ui->addressText->setText(myAddress.c_str());
ui->privateKeyText->setText(tr(myPrivKey.c_str()));
ui->publicKey->setHtml(myPubKey.c_str());
// Update the fonts to fit the height of the wallet.
// This should only really trigger the first time since the font size persists.
double paperHeight = (double) ui->paperTemplate->height();
double maxTextWidth = paperHeight * 0.99;
double minTextWidth = paperHeight * 0.95;
int pixelSizeStep = 1;
int addressTextLength = ui->addressText->fontMetrics().boundingRect(ui->addressText->text()).width();
QFont font = ui->addressText->font();
for(int i = 0; i < PAPER_WALLET_READJUST_LIMIT; i++) {
if ( addressTextLength < minTextWidth) {
font.setPixelSize(font.pixelSize() + pixelSizeStep);
ui->addressText->setFont(font);
addressTextLength = ui->addressText->fontMetrics().boundingRect(ui->addressText->text()).width();
} else {
break;
}
}
if ( addressTextLength > maxTextWidth ) {
font.setPixelSize(font.pixelSize() - pixelSizeStep);
ui->addressText->setFont(font);
addressTextLength = ui->addressText->fontMetrics().boundingRect(ui->addressText->text()).width();
}
int privateKeyTextLength = ui->privateKeyText->fontMetrics().boundingRect(ui->privateKeyText->text()).width();
font = ui->privateKeyText->font();
for(int i = 0; i < PAPER_WALLET_READJUST_LIMIT; i++) {
if ( privateKeyTextLength < minTextWidth) {
font.setPixelSize(font.pixelSize() + pixelSizeStep);
ui->privateKeyText->setFont(font);
privateKeyTextLength = ui->privateKeyText->fontMetrics().boundingRect(ui->privateKeyText->text()).width();
} else {
break;
}
}
if ( privateKeyTextLength > maxTextWidth ) {
font.setPixelSize(font.pixelSize() - pixelSizeStep);
ui->privateKeyText->setFont(font);
privateKeyTextLength = ui->privateKeyText->fontMetrics().boundingRect(ui->privateKeyText->text()).width();
}
}
void ReceiveCoinsDialog::loadBuyViewFinished(bool bOk)
{
#if defined(HAVE_WEBENGINE_VIEW) || defined(HAVE_WEBKIT)
if (bOk) {
if (buyReceiveAddress) {
delete buyReceiveAddress;
buyReceiveAddress = NULL;
}
buyReceiveAddress = new CReserveKey(pwalletMain, currentAccount, KEYCHAIN_EXTERNAL);
CPubKey pubKey;
QString guldenAddress;
if (!buyReceiveAddress->GetReservedKey(pubKey)) {
guldenAddress = "error";
} else {
CKeyID keyID = pubKey.GetID();
guldenAddress = QString::fromStdString(CBitcoinAddress(keyID).ToString());
}
QString emailAddress = QString("");
QString paymentMethod = QString("");
QString paymentDetails = QString("");
#if defined(HAVE_WEBENGINE_VIEW)
buyView->page()->runJavaScript(QString("NocksBuyFormFillDetails('%1', '%2')").arg(guldenAddress, emailAddress));
buyView->page()->runJavaScript(QString("$('.extra-row').hide()"));
#else
QVariant ret = buyView->page()->mainFrame()->evaluateJavaScript(QString("NocksBuyFormFillDetails('%1', '%2')").arg(guldenAddress, emailAddress));
QString temp = ret.toString();
buyView->page()->mainFrame()->evaluateJavaScript(QString("$('.extra-row').hide()"));
#endif
#if defined(HAVE_WEBENGINE_VIEW)
#if QT_VERSION < QT_VERSION_CHECK(5, 6, 2) || QT_VERSION == QT_VERSION_CHECK(5, 7, 0)
buyView->page()->runJavaScript(QString("$('a[href]').attr('target', '_blank');"));
buyView->page()->runJavaScript(QString("$('form').attr('target', '_blank');"));
#endif
#else
buyView->page()->mainFrame()->evaluateJavaScript(QString("$('a[href]').attr('target', '_blank');"));
buyView->page()->mainFrame()->evaluateJavaScript(QString("$('form').attr('target', '_blank');"));
#endif
{
QFile fontFile(":/Gulden/fontawesome");
fontFile.open(QIODevice::ReadOnly);
QString rawCSS = "@font-face{ font-family: FontAwesome;src: url(data:font/ttf;base64," + fontFile.readAll().toBase64() + ") format('truetype');";
std::string encodedCSS = EncodeBase64(rawCSS.toStdString());
QString insertFontScript = QString("(function() {") + "var parent = document.getElementsByTagName('head').item(0);" + "var style = document.createElement('style');" + "style.type = 'text/css';" + "style.innerHTML = window.atob('" + encodedCSS.c_str() + "');" + "parent.appendChild(style)" + "})()";
#if defined(HAVE_WEBENGINE_VIEW)
buyView->page()->runJavaScript(insertFontScript);
#else
buyView->page()->mainFrame()->evaluateJavaScript(insertFontScript);
#endif
}
ui->loadingAnimationLabel->setVisible(false);
buyView->setVisible(true);
} else {
ui->loadingAnimationLabel->setText(tr("Error loading the buy page, please check your connection and try again later."));
ui->loadingAnimationLabel->setVisible(true);
buyView->setVisible(false);
}
#endif
}
bool CBasicKeyStore::AddKeyPubKey(const CKey& key, const CPubKey &pubkey)
{
LOCK(cs_KeyStore);
mapKeys[pubkey.GetID()] = key;
return true;
}
bool CAccount::AddCryptedKeyWithChain(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret, int64_t nKeyChain)
{
//fixme: (Post-2.1) This is essentially dead code now - it has been replaced at the bottom of CWallet::AddKeyPubKey
//For technical reasons (wallet upgrade)
//This should never be called on a non-HD wallet
assert(!IsHD());
if (nKeyChain == KEYCHAIN_EXTERNAL)
{
if (!externalKeyStore.AddCryptedKey(vchPubKey, vchCryptedSecret))
return false;
}
else
{
if (!internalKeyStore.AddCryptedKey(vchPubKey, vchCryptedSecret))
return false;
}
// If we don't have a wallet yet (busy during wallet upgrade) - then the below not being called is fine as the wallet does a 'force resave' of all keys at the end of the upgrade.
if (pactiveWallet)
{
{
LOCK(pactiveWallet->cs_wallet);
if (pactiveWallet->pwalletdbEncryption)
return pactiveWallet->pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret, pactiveWallet->mapKeyMetadata[vchPubKey.GetID()], getUUIDAsString(getUUID()), nKeyChain);
else
return CWalletDB(*pactiveWallet->dbw).WriteCryptedKey(vchPubKey, vchCryptedSecret, pactiveWallet->mapKeyMetadata[vchPubKey.GetID()], getUUIDAsString(getUUID()), nKeyChain);
}
}
else
{
return true;
}
return false;
}
