void StakeForCharityDialog::setModel(WalletModel *model)
{
this->model = model;
CBitcoinAddress strAddress;
CBitcoinAddress strChangeAddress;
int nPer;
qint64 nMin;
qint64 nMax;
model->getStakeForCharity(nPer, strAddress, strChangeAddress, nMin, nMax);
if (strAddress.IsValid() && nPer > 0 )
{
ui->charityAddressEdit->setText(strAddress.ToString().c_str());
ui->charityPercentEdit->setText(QString::number(nPer));
if (strChangeAddress.IsValid())
ui->charityChangeAddressEdit->setText(strChangeAddress.ToString().c_str());
if (nMin > 0 && nMin != MIN_TX_FEE)
ui->charityMinEdit->setText(QString::number(nMin/COIN));
if (nMax > 0 && nMax != MAX_MONEY)
ui->charityMaxEdit->setText(QString::number(nMax/COIN));
ui->message->setStyleSheet("QLabel { color: green; }");
ui->message->setText(tr("Thank you for giving to\n") + strAddress.ToString().c_str() + tr("."));
}
}
void AutoSavingsDialog::setModel(WalletModel *model)
{
this->model = model;
CBitcoinAddress strAddress;
CBitcoinAddress strChangeAddress;
int nPer;
int64 nMin;
int64 nMax;
model->getAutoSavings(nPer, strAddress, strChangeAddress, nMin, nMax);
if (strAddress.IsValid() && nPer > 0 )
{
ui->savingsAddressEdit->setText(strAddress.ToString().c_str());
ui->savingsPercentEdit->setText(QString::number(nPer));
if (strChangeAddress.IsValid())
ui->savingsChangeAddressEdit->setText(strChangeAddress.ToString().c_str());
if (nMin > 0 && nMin != MIN_TX_FEE)
ui->savingsMinEdit->setText(QString::number(nMin/COIN));
if (nMax > 0 && nMax != MAX_MONEY)
ui->savingsMaxEdit->setText(QString::number(nMax/COIN));
ui->message->setStyleSheet("QLabel { color: green; }");
ui->message->setText(tr("You are now saving to\n") + strAddress.ToString().c_str() + tr("."));
}
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64 nTime = wtx.GetTxTime();
int64 nCredit = wtx.GetCredit(true);
int64 nDebit = wtx.GetDebit();
int64 nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash();
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (showTransaction(wtx))
{
if (wtx.IsCoinStake()) // alohacoin: coinstake transaction
{
parts.append(TransactionRecord(hash, nTime, TransactionRecord::StakeMint, "", -nDebit, wtx.GetValueOut()));
}
else if (nNet > 0 || wtx.IsCoinBase())
{
//
// Credit
//
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if(wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
CBitcoinAddress address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (wtx.IsCoinBase())
{
// Generated
sub.type = TransactionRecord::Generated;
if (ExtractAddress(txout.scriptPubKey, address) && wallet->HaveKey(address))
{
sub.address = address.ToString();
}
}
else if (ExtractAddress(txout.scriptPubKey, address) && wallet->HaveKey(address))
{
// Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = address.ToString();
}
else
{
// Received by IP connection (deprecated features), or a multisignature or other non-simple transaction
sub.type = TransactionRecord::RecvFromOther;
sub.address = mapValue["from"];
}
parts.append(sub);
}
}
}
else
{
static std::string ScriptToString(const CScript& Script, bool Long = false, bool Highlight = false)
{
if (Script.empty())
return "unknown";
CTxDestination Dest;
CBitcoinAddress Address;
if (ExtractDestination(Script, Dest) && Address.Set(Dest)) {
if (Highlight)
return "<span class=\"addr\">" + Address.ToString() + "</span>";
else
return makeHRef(Address.ToString());
} else
return Long ? "<pre>" + FormatScript(Script) + "</pre>" : _("Non-standard script");
}
std::string CProRegTx::MakeSignString() const
{
std::string s;
// We only include the important stuff in the string form...
CTxDestination destPayout;
CBitcoinAddress addrPayout;
std::string strPayout;
if (ExtractDestination(scriptPayout, destPayout) && addrPayout.Set(destPayout)) {
strPayout = addrPayout.ToString();
} else {
strPayout = HexStr(scriptPayout.begin(), scriptPayout.end());
}
s += strPayout + "|";
s += strprintf("%d", nOperatorReward) + "|";
s += CBitcoinAddress(keyIDOwner).ToString() + "|";
s += CBitcoinAddress(keyIDVoting).ToString() + "|";
// ... and also the full hash of the payload as a protection agains malleability and replays
s += ::SerializeHash(*this).ToString();
return s;
}
void AutoSavingsDialog::on_enableButton_clicked()
{
if(model->getEncryptionStatus() == WalletModel::Locked)
{
ui->message->setStyleSheet("QLabel { color: black; }");
ui->message->setText(tr("Please unlock wallet before starting auto savings."));
return;
}
bool fValidConversion = false;
int64 nMinAmount = MIN_TXOUT_AMOUNT;
int64 nMaxAmount = MAX_MONEY;
CBitcoinAddress address = ui->savingsAddressEdit->text().toStdString();
if (!address.IsValid())
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("The entered address: ") + ui->savingsAddressEdit->text() + tr(" is invalid.\nPlease check the address and try again."));
ui->savingsAddressEdit->setFocus();
return;
}
int nSavingsPercent = ui->savingsPercentEdit->text().toInt(&fValidConversion, 10);
if (!fValidConversion || nSavingsPercent > 50 || nSavingsPercent <= 0)
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Please Enter 1 - 50 for percent."));
ui->savingsPercentEdit->setFocus();
return;
}
if (!ui->savingsMinEdit->text().isEmpty())
{
nMinAmount = ui->savingsMinEdit->text().toDouble(&fValidConversion) * COIN;
if(!fValidConversion || nMinAmount <= MIN_TXOUT_AMOUNT || nMinAmount >= MAX_MONEY )
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Min Amount out of Range, please re-enter."));
ui->savingsMinEdit->setFocus();
return;
}
}
if (!ui->savingsMaxEdit->text().isEmpty())
{
nMaxAmount = ui->savingsMaxEdit->text().toDouble(&fValidConversion) * COIN;
if(!fValidConversion || nMaxAmount <= MIN_TXOUT_AMOUNT || nMaxAmount >= MAX_MONEY )
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Max Amount out of Range, please re-enter."));
ui->savingsMaxEdit->setFocus();
return;
}
}
model->setAutoSavings(true, nSavingsPercent, address, nMinAmount, nMaxAmount);
ui->message->setStyleSheet("QLabel { color: green; }");
ui->message->setText(tr("You are now saving to\n") + QString(address.ToString().c_str()) + tr("."));
return;
}
/**
* Utility routine to construct a "name info" object to return. This is used
* for name_show and also name_list.
* @param name The name.
* @param value The name's value.
* @param outp The last update's outpoint.
* @param addr The name's address script.
* @param height The name's last update height.
* @return A JSON object to return.
*/
UniValue
getNameInfo (const valtype& name, const valtype& value, const COutPoint& outp,
const CScript& addr, int height)
{
UniValue obj(UniValue::VOBJ);
obj.push_back (Pair ("name", ValtypeToString (name)));
obj.push_back (Pair ("value", ValtypeToString (value)));
obj.push_back (Pair ("txid", outp.hash.GetHex ()));
obj.push_back (Pair ("vout", static_cast<int> (outp.n)));
/* Try to extract the address. May fail if we can't parse the script
as a "standard" script. */
CTxDestination dest;
CBitcoinAddress addrParsed;
std::string addrStr;
if (ExtractDestination (addr, dest) && addrParsed.Set (dest))
addrStr = addrParsed.ToString ();
else
addrStr = "<nonstandard>";
obj.push_back (Pair ("address", addrStr));
/* Calculate expiration data. */
const int curHeight = chainActive.Height ();
const Consensus::Params& params = Params ().GetConsensus ();
const int expireDepth = params.rules->NameExpirationDepth (curHeight);
const int expireHeight = height + expireDepth;
const int expiresIn = expireHeight - curHeight;
const bool expired = (expiresIn <= 0);
obj.push_back (Pair ("height", height));
obj.push_back (Pair ("expires_in", expiresIn));
obj.push_back (Pair ("expired", expired));
return obj;
}
bool COeruShield::IsMasterKey(CBitcoinAddress addr) const
{
std::string strAddr = addr.ToString();
std::vector<unsigned char> hash;
hash.resize(CSHA256::OUTPUT_SIZE);
CSHA256().Write((unsigned char*) &strAddr[0], strAddr.size())
.Finalize(&hash[0]);
return IsMasterKey(hash);
}
std::string AddressToString(const CBitcoinAddress& Address)
{
std::string TxLabels[] =
{
_("Date"),
_("Hash"),
_("From"),
_("Amount"),
_("To"),
_("Amount"),
_("Delta"),
_("Balance")};
std::string TxContent = table + makeHTMLTableRow(TxLabels, sizeof(TxLabels) / sizeof(std::string));
std::set<COutPoint> PrevOuts;
/*
CScript AddressScript;
AddressScript.SetDestination(Address.Get());
CAmount Sum = 0;
bool fAddrIndex = false;
if (!fAddrIndex)
return ""; // it will take too long to find transactions by address
else
{
std::vector<CDiskTxPos> Txs;
paddressmap->GetTxs(Txs, AddressScript.GetID());
BOOST_FOREACH (const CDiskTxPos& pos, Txs)
{
CTransaction tx;
CBlock block;
uint256 bhash = block.GetHash();
GetTransaction(pos.nTxOffset, tx, bhash);
std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(block.GetHash());
if (mi == mapBlockIndex.end())
continue;
CBlockIndex* pindex = (*mi).second;
if (!pindex || !chainActive.Contains(pindex))
continue;
std::string Prepend = "<a href=\"" + itostr(pindex->nHeight) + "\">" + TimeToString(pindex->nTime) + "</a>";
TxContent += TxToRow(tx, AddressScript, Prepend, &Sum);
}
}
*/
TxContent += "</table>";
std::string Content;
Content += "<h1>" + _("Transactions to/from") + " <span>" + Address.ToString() + "</span></h1>";
Content += TxContent;
return Content;
}
void refreshAddressTable()
{
cachedAddressTable.clear();
{
LOCK(wallet->cs_wallet);
BOOST_FOREACH(const PAIRTYPE(CTxDestination, std::string)& item, wallet->mapAddressBook)
{
const CBitcoinAddress address(item.first, wallet->GetUnit());
const std::string& strName = item.second;
bool fMine = IsMine(*wallet, address.Get());
CPeercoinAddress dividendAddress;
if (wallet->GetUnit() == 'S')
dividendAddress = CPeercoinAddress(address);
cachedAddressTable.append(AddressTableEntry(fMine ? AddressTableEntry::Receiving : AddressTableEntry::Sending,
QString::fromStdString(strName),
QString::fromStdString(address.ToString()),
QString::fromStdString(dividendAddress.ToString())));
}
}
}
void SendCoinsEntry::on_payTo_editingFinished()
{
QString name = ui->payTo->text();
if (name.isEmpty())
return;
std::string strName = name.toStdString();
std::vector<unsigned char> vchName(strName.begin(), strName.end());
std::string error;
CBitcoinAddress address;
if (!GetNameCurrentAddress(vchName, address, error))
return;
QString qstrAddress = QString::fromStdString(address.ToString());
if (QMessageBox::Yes != QMessageBox::question(this, tr("Confirm name as address"),
tr("This name exist and still active. Do you wish to use address of its current owner - %1?").arg(qstrAddress),
QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Cancel))
return;
else
ui->payTo->setText(qstrAddress);
}
void SendMPDialog::sendMPTransaction()
{
// get the property being sent and get divisibility
QString spId = ui->propertyComboBox->itemData(ui->propertyComboBox->currentIndex()).toString();
if (spId.toStdString().empty()) {
QMessageBox::critical( this, "Unable to send transaction",
"The property selected is not valid.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
uint32_t propertyId = spId.toUInt();
bool divisible = isPropertyDivisible(propertyId);
// obtain the selected sender address
string strFromAddress = ui->sendFromComboBox->currentText().toStdString();
// push recipient address into a CBitcoinAddress type and check validity
CBitcoinAddress fromAddress;
if (false == strFromAddress.empty()) { fromAddress.SetString(strFromAddress); }
if (!fromAddress.IsValid()) {
QMessageBox::critical( this, "Unable to send transaction",
"The sender address selected is not valid.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
// obtain the entered recipient address
string strRefAddress = ui->sendToLineEdit->text().toStdString();
// push recipient address into a CBitcoinAddress type and check validity
CBitcoinAddress refAddress;
if (false == strRefAddress.empty()) { refAddress.SetString(strRefAddress); }
if (!refAddress.IsValid()) {
QMessageBox::critical( this, "Unable to send transaction",
"The recipient address entered is not valid.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
// warn if we have to truncate the amount due to a decimal amount for an indivisible property, but allow send to continue
string strAmount = ui->amountLineEdit->text().toStdString();
if (!divisible) {
size_t pos = strAmount.find(".");
if (pos!=std::string::npos) {
string tmpStrAmount = strAmount.substr(0,pos);
string strMsgText = "The amount entered contains a decimal however the property being sent is indivisible.\n\nThe amount entered will be truncated as follows:\n";
strMsgText += "Original amount entered: " + strAmount + "\nAmount that will be sent: " + tmpStrAmount + "\n\n";
strMsgText += "Do you still wish to proceed with the transaction?";
QString msgText = QString::fromStdString(strMsgText);
QMessageBox::StandardButton responseClick;
responseClick = QMessageBox::question(this, "Amount truncation warning", msgText, QMessageBox::Yes|QMessageBox::No);
if (responseClick == QMessageBox::No) {
QMessageBox::critical( this, "Send transaction cancelled",
"The send transaction has been cancelled.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
strAmount = tmpStrAmount;
ui->amountLineEdit->setText(QString::fromStdString(strAmount));
}
}
// use strToInt64 function to get the amount, using divisibility of the property
int64_t sendAmount = StrToInt64(strAmount, divisible);
if (0>=sendAmount) {
QMessageBox::critical( this, "Unable to send transaction",
"The amount entered is not valid.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
// check if sending address has enough funds
int64_t balanceAvailable = getUserAvailableMPbalance(fromAddress.ToString(), propertyId); //getMPbalance(fromAddress.ToString(), propertyId, MONEY);
if (sendAmount>balanceAvailable) {
QMessageBox::critical( this, "Unable to send transaction",
"The selected sending address does not have a sufficient balance to cover the amount entered.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
// check if wallet is still syncing, as this will currently cause a lockup if we try to send - compare our chain to peers to see if we're up to date
// Bitcoin Core devs have removed GetNumBlocksOfPeers, switching to a time based best guess scenario
uint32_t intBlockDate = GetLatestBlockTime(); // uint32, not using time_t for portability
QDateTime currentDate = QDateTime::currentDateTime();
int secs = QDateTime::fromTime_t(intBlockDate).secsTo(currentDate);
if(secs > 90*60) {
QMessageBox::critical( this, "Unable to send transaction",
"The client is still synchronizing. Sending transactions can currently be performed only when the client has completed synchronizing." );
return;
}
// validation checks all look ok, let's throw up a confirmation dialog
string strMsgText = "You are about to send the following transaction, please check the details thoroughly:\n\n";
string propDetails = getPropertyName(propertyId).c_str();
string spNum = strprintf("%d", propertyId);
propDetails += " (#" + spNum + ")";
strMsgText += "From: " + fromAddress.ToString() + "\nTo: " + refAddress.ToString() + "\nProperty: " + propDetails + "\nAmount that will be sent: ";
if (divisible) { strMsgText += FormatDivisibleMP(sendAmount); } else { strMsgText += FormatIndivisibleMP(sendAmount); }
strMsgText += "\n\nAre you sure you wish to send this transaction?";
QString msgText = QString::fromStdString(strMsgText);
QMessageBox::StandardButton responseClick;
responseClick = QMessageBox::question(this, "Confirm send transaction", msgText, QMessageBox::Yes|QMessageBox::No);
if (responseClick == QMessageBox::No) {
QMessageBox::critical( this, "Send transaction cancelled",
"The send transaction has been cancelled.\n\nPlease double-check the transction details thoroughly before retrying your send transaction." );
return;
}
// unlock the wallet
WalletModel::UnlockContext ctx(walletModel->requestUnlock());
if(!ctx.isValid()) {
QMessageBox::critical( this, "Send transaction failed",
"The send transaction has been cancelled.\n\nThe wallet unlock process must be completed to send a transaction." );
return; // unlock wallet was cancelled/failed
}
// create a payload for the transaction
std::vector<unsigned char> payload = CreatePayload_SimpleSend(propertyId, sendAmount);
// request the wallet build the transaction (and if needed commit it) - note UI does not support added reference amounts currently
uint256 txid;
std::string rawHex;
int result = WalletTxBuilder(fromAddress.ToString(), refAddress.ToString(), "", 0, payload, txid, rawHex, autoCommit);
// check error and return the txid (or raw hex depending on autocommit)
if (result != 0) {
QMessageBox::critical( this, "Send transaction failed",
"The send transaction has failed.\n\nThe error code was: " + QString::number(result) + "\nThe error message was:\n" + QString::fromStdString(error_str(result)));
return;
} else {
if (!autoCommit) {
PopulateSimpleDialog(rawHex, "Raw Hex (auto commit is disabled)", "Raw transaction hex");
} else {
PendingAdd(txid, fromAddress.ToString(), MSC_TYPE_SIMPLE_SEND, propertyId, sendAmount);
PopulateTXSentDialog(txid.GetHex());
}
}
clearFields();
}
void RunSerialiseTests()
{
int64_t nTest;
int64_t nTest0 = 0l;
int64_t nTest4 = 1432035740l;
int64_t nTest4_1 = 2189410940l; // 2039
int64_t nTest5 = 4294967298l; // 2106
int64_t nTest8 = -3l;
BOOST_CHECK(0 == GetNumBytesReqForInt(nTest0));
BOOST_CHECK(4 == GetNumBytesReqForInt(nTest4));
BOOST_CHECK(4 == GetNumBytesReqForInt(nTest4_1)); // expect 4, no sign bit
BOOST_CHECK(5 == GetNumBytesReqForInt(nTest5));
BOOST_CHECK(8 == GetNumBytesReqForInt(nTest8));
//BOOST_TEST_MESSAGE(GetNumBytesReqForInt(nTest5));
std::vector<uint8_t> v;
SetCompressedInt64(v, nTest0);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest0 == nTest);
SetCompressedInt64(v, nTest5);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest5 == nTest);
SetCompressedInt64(v, nTest8);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest8 == nTest);
CStoredExtKey sk, sk_;
CStoredExtKey skInvalid, skInvalid_;
CExtKey58 eKey58;
BOOST_CHECK(0 == eKey58.Set58("moivYMcZoUdupxqBNASoNKWbyBzKFPzYA3ZauZhCyQGcUhdvxhgsYNdqBkCbspTmaXWtW68Ha7gjMBjb5gbudrictnzw9KAVKogAXC8FsqiSzRp"));
sk.kp = eKey58.GetKey();
sk.sLabel = "sk label";
sk.nGenerated = 5;
sk.nHGenerated = 6;
sk.mapValue[EKVT_CREATED_AT] = SetCompressedInt64(v, nTest8);
eKey58.SetKey(sk.kp, CChainParams::EXT_PUBLIC_KEY);
BOOST_CHECK(eKey58.ToString() == "moipXY9njTPCnsVV8vPCLA1xKp2NXdRtPVyGABKcbshkKQUadnrk2XPccZcSDjefRX64mNjYpS33SAy97UHGWs9WoAufi9pdow9gsYMvVEcmgSk");
eKey58.SetKeyV(sk.kp);
BOOST_CHECK(eKey58.ToString() == "moivYMcZoUdupxqBNASoNKWbyBzKFPzYA3ZauZhCyQGcUhdvxhgsYNdqBkCbspTmaXWtW68Ha7gjMBjb5gbudrictnzw9KAVKogAXC8FsqiSzRp");
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
ss << sk << skInvalid;
ss >> sk_;
ss >> skInvalid_;
BOOST_CHECK(sk.kp == sk_.kp);
BOOST_CHECK(1 == sk_.kp.IsValidV());
BOOST_CHECK(1 == sk_.kp.IsValidP());
BOOST_CHECK(sk.sLabel == sk_.sLabel);
BOOST_CHECK(sk.nGenerated == sk_.nGenerated);
BOOST_CHECK(sk.nHGenerated == sk_.nHGenerated);
BOOST_CHECK(nTest8 == GetCompressedInt64(sk_.mapValue[EKVT_CREATED_AT], (uint64_t&)nTest));
BOOST_CHECK(0 == skInvalid.kp.IsValidV());
BOOST_CHECK(0 == skInvalid.kp.IsValidP());
// path
std::vector<uint8_t> vPath;
PushUInt32(vPath, 1);
PushUInt32(vPath, 3);
PushUInt32(vPath, 2);
PushUInt32(vPath, 4294967295);
std::string sPath;
BOOST_CHECK(0 == PathToString(vPath, sPath, 'h'));
BOOST_CHECK(sPath == "m/1/3/2/2147483647h");
vPath.resize(0);
PushUInt32(vPath, 1);
PushUInt32(vPath, 4294967294);
PushUInt32(vPath, 30);
BOOST_CHECK(0 == PathToString(vPath, sPath));
BOOST_CHECK(sPath == "m/1/2147483646'/30");
// id
CBitcoinAddress addr;
CKeyID id = sk.GetID();
CKeyID idTest;
BOOST_CHECK(true == addr.Set(id, CChainParams::EXT_KEY_HASH)
&& addr.IsValid(CChainParams::EXT_KEY_HASH)
&& addr.GetKeyID(idTest, CChainParams::EXT_KEY_HASH));
BOOST_CHECK(id == idTest);
BOOST_CHECK_MESSAGE(addr.ToString() == "x9S4Xj1DZwFsdFno1uHknNNGqdMWgXdhX6", addr.ToString());
// - test DeriveNextKey
CExtKey ev;
CExtPubKey ep;
uint32_t nChild=0;
sk.nGenerated = 0;
sk.nHGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild));
BOOST_CHECK_MESSAGE(1 == sk.nGenerated, "nGenerated " << sk.nGenerated);
sk.nGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ep, nChild));
BOOST_CHECK(ep.pubkey == ev.key.GetPubKey());
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xS8vxP6PVm3ycqm4NqvUkhiDWqeBhhekzn", addr.ToString());
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfAtU1u43VJBTt4agxpnPvXjf28hSmwrL", addr.ToString());
sk.nHGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xEcqVH3fRnNZabMHVctAeScJY9ySkg6BSF", addr.ToString());
BOOST_CHECK_MESSAGE(1 == sk.nHGenerated, "nHGenerated " << sk.nHGenerated);
sk.nHGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfBk2tuann5qTVKyW2HmA9CJZBAE1sRvJ", addr.ToString());
BOOST_CHECK_MESSAGE(2 == sk.nHGenerated, "nHGenerated " << sk.nHGenerated);
sk.nHGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ep, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfBk2tuann5qTVKyW2HmA9CJZBAE1sRvJ", addr.ToString());
BOOST_CHECK(ep.pubkey == ev.key.GetPubKey());
CStoredExtKey skp = sk;
skp.kp = skp.kp.Neutered();
CKey k;
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 1, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "0245a12d2ce075d947b6232b3e424ffa5d2208b6ff69800a1f2501ac6392499bf8", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
sk.nGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 2, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "02f430d7efc4d1ecbac888fb49446ec0b13ec4196512be93054a9b5b30df238910", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
sk.nHGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, true));
BOOST_CHECK_MESSAGE(nChild == 2147483650, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "0355825cbaf4365a2f7015d9c9bae4ecaf9b57a05e063237256f1565b20104c183", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
// - can't derive keys from pubkeys
skp.nGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(k, nChild, false));
skp.nHGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(k, nChild, true));
CPubKey pk;
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(pk, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 1, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "0245a12d2ce075d947b6232b3e424ffa5d2208b6ff69800a1f2501ac6392499bf8", "HexStr(pk) " << HexStr(pk));
sk.nHGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(pk, nChild, true));
BOOST_CHECK_MESSAGE(nChild == 2147483650, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "0355825cbaf4365a2f7015d9c9bae4ecaf9b57a05e063237256f1565b20104c183", "HexStr(pk) " << HexStr(pk));
skp.nGenerated = 2;
BOOST_CHECK(0 == skp.DeriveNextKey(pk, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 2, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "02f430d7efc4d1ecbac888fb49446ec0b13ec4196512be93054a9b5b30df238910", "HexStr(pk) " << HexStr(pk));
// - can't derive hardened pubkeys from pubkeys
skp.nHGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(pk, nChild, true));
// - CBitcoinAddress tests
// CBitcoinAddress always deals in public keys - should never expose a secret in an address
CExtKeyPair kp, kpT;
CTxDestination dest;
BOOST_CHECK(0 == eKey58.Set58("moipXY9njTPCnsVV8vPCLA1xKp2NXdRtPVyGABKcbshkKQUadnrk2XPccZcSDjefRX64mNjYpS33SAy97UHGWs9WoAufi9pdow9gsYMvVEcmgSk"));
kp = eKey58.GetKey();
CBitcoinAddress addrB(kp);
BOOST_CHECK(addrB.IsValid() == true);
BOOST_CHECK(addr.Set(kp) == true);
BOOST_CHECK(addr.IsValid() == true);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_SECRET_KEY) == false);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.ToString() == "moipXY9njTPCnsVV8vPCLA1xKp2NXdRtPVyGABKcbshkKQUadnrk2XPccZcSDjefRX64mNjYpS33SAy97UHGWs9WoAufi9pdow9gsYMvVEcmgSk");
dest = addr.Get();
BOOST_CHECK(dest.type() == typeid(CExtKeyPair));
kpT = boost::get<CExtKeyPair>(dest);
BOOST_CHECK(kpT == kp);
// - switch to testnet
BOOST_TEST_MESSAGE("Entering Testnet");
fTestNet = true;
SelectParams(CChainParams::TESTNET);
id = sk.GetID();
BOOST_CHECK(true == addr.Set(id, CChainParams::EXT_KEY_HASH)
&& addr.IsValid(CChainParams::EXT_KEY_HASH)
&& addr.GetKeyID(idTest, CChainParams::EXT_KEY_HASH));
BOOST_CHECK(id == idTest);
BOOST_CHECK_MESSAGE(addr.ToString() == "XCUfUzXMYkXYvP9RVtdzibVVpMP2bhfWRQ", addr.ToString());
BOOST_CHECK(0 == eKey58.Set58("toiprRP1Lw6KTeYbRxdfjunVry7emPouVaqrz8KX3uEKhKeZvsQaxqZEEPpB1uC2T8oMTnZTHj1BQHwUm8Tx634CXb4GrSmbwekU7LVQqt76VSJ"));
kp = eKey58.GetKey();
CBitcoinAddress addrC("toivSKjjCEpyZjWAeFqJRCtPPXwTSBLDzX327GfZy2u8Gp1gNiTrE8HRuVWBhQFk3kXQw6woCxxYC4yC3MwzQ67RQ4bSgjWTQ1UPkQinHXv9sV9");
BOOST_CHECK(addrC.IsValid() == true);
BOOST_CHECK(addrC.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.Set(kp) == true);
BOOST_CHECK(addr.IsValid() == true);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_SECRET_KEY) == false);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.ToString() == "toiprRP1Lw6KTeYbRxdfjunVry7emPouVaqrz8KX3uEKhKeZvsQaxqZEEPpB1uC2T8oMTnZTHj1BQHwUm8Tx634CXb4GrSmbwekU7LVQqt76VSJ");
dest = addr.Get();
BOOST_CHECK(dest.type() == typeid(CExtKeyPair));
kpT = boost::get<CExtKeyPair>(dest);
BOOST_CHECK(kpT == kp);
// -return to mainnet
fTestNet = false;
SelectParams(CChainParams::MAIN);
}
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"));
BOOST_CHECK_THROW(CallRPC("listunspent string"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 string"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 not_array"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 [] extra"), runtime_error);
BOOST_CHECK_NO_THROW(r = CallRPC("listunspent 0 1 []"));
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 StakeForCharityDialog::on_enableButton_clicked()
{
if(model->getEncryptionStatus() == WalletModel::Locked)
{
ui->message->setStyleSheet("QLabel { color: black; }");
ui->message->setText(tr("Please unlock wallet before starting stake for Charity."));
return;
}
bool fValidConversion = false;
qint64 nMinAmount = MIN_TXOUT_AMOUNT;
qint64 nMaxAmount = MAX_MONEY;
CBitcoinAddress changeAddress = "";
CBitcoinAddress address = ui->charityAddressEdit->text().toStdString();
if (!address.IsValid())
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("The entered address:\n") + ui->charityAddressEdit->text() + tr(" is invalid.\nPlease check the address and try again."));
ui->charityAddressEdit->setFocus();
return;
}
int nCharityPercent = ui->charityPercentEdit->text().toInt(&fValidConversion, 10);
if (!fValidConversion || nCharityPercent > 50 || nCharityPercent <= 0)
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Please Enter 1 - 50 for percent."));
ui->charityPercentEdit->setFocus();
return;
}
if (!ui->charityMinEdit->text().isEmpty())
{
nMinAmount = ui->charityMinEdit->text().toDouble(&fValidConversion) * COIN;
if(!fValidConversion || nMinAmount <= MIN_TXOUT_AMOUNT || nMinAmount >= MAX_MONEY )
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Min Amount out of Range, please re-enter."));
ui->charityMinEdit->setFocus();
return;
}
}
if (!ui->charityMaxEdit->text().isEmpty())
{
nMaxAmount = ui->charityMaxEdit->text().toDouble(&fValidConversion) * COIN;
if(!fValidConversion || nMaxAmount <= MIN_TXOUT_AMOUNT || nMaxAmount >= MAX_MONEY )
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Max Amount out of Range, please re-enter."));
ui->charityMaxEdit->setFocus();
return;
}
}
if (nMinAmount >= nMaxAmount)
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("Min Amount > Max Amount, please re-enter."));
ui->charityMinEdit->setFocus();
return;
}
if (!ui->charityChangeAddressEdit->text().isEmpty())
{
changeAddress = ui->charityChangeAddressEdit->text().toStdString();
if (!changeAddress.IsValid())
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("The entered change address:\n") + ui->charityChangeAddressEdit->text() + tr(" is invalid.\nPlease check the address and try again."));
ui->charityChangeAddressEdit->setFocus();
return;
}
else if (!model->isMine(changeAddress))
{
ui->message->setStyleSheet("QLabel { color: red; }");
ui->message->setText(tr("The entered change address:\n") + ui->charityChangeAddressEdit->text() + tr(" is not owned.\nPlease check the address and try again."));
ui->charityChangeAddressEdit->setFocus();
return;
}
}
model->setStakeForCharity(true, nCharityPercent, address, changeAddress, nMinAmount, nMaxAmount);
if(!fGlobalStakeForCharity)
fGlobalStakeForCharity = true;
ui->message->setStyleSheet("QLabel { color: green; }");
ui->message->setText(tr("Thank you for giving to\n") + QString(address.ToString().c_str()) + tr("."));
return;
}
void RunSerialiseTests()
{
int64_t nTest;
int64_t nTest0 = 0l;
int64_t nTest4 = 1432035740l;
int64_t nTest4_1 = 2189410940l; // 2039
int64_t nTest5 = 4294967298l; // 2106
int64_t nTest8 = -3l;
BOOST_CHECK(0 == GetNumBytesReqForInt(nTest0));
BOOST_CHECK(4 == GetNumBytesReqForInt(nTest4));
BOOST_CHECK(4 == GetNumBytesReqForInt(nTest4_1)); // expect 4, no sign bit
BOOST_CHECK(5 == GetNumBytesReqForInt(nTest5));
BOOST_CHECK(8 == GetNumBytesReqForInt(nTest8));
//BOOST_MESSAGE(GetNumBytesReqForInt(nTest5));
std::vector<uint8_t> v;
SetCompressedInt64(v, nTest0);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest0 == nTest);
SetCompressedInt64(v, nTest5);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest5 == nTest);
SetCompressedInt64(v, nTest8);
GetCompressedInt64(v, (uint64_t&)nTest);
BOOST_CHECK(nTest8 == nTest);
CStoredExtKey sk, sk_;
CStoredExtKey skInvalid, skInvalid_;
CExtKey58 eKey58;
BOOST_CHECK(0 == eKey58.Set58("sdcvmnKmFxG9k6UnN3wyLpTv83G1wgYEz1m21rZTUUimoDrYYMrZXUycudse21EZJTmkBBPN3k6Qhfzx5td8xzd9W893YhNozA3bZW3yVLVdrZU2"));
sk.kp = eKey58.GetKey();
sk.sLabel = "sk label";
sk.nGenerated = 5;
sk.nHGenerated = 6;
sk.mapValue[EKVT_CREATED_AT] = SetCompressedInt64(v, nTest8);
eKey58.SetKey(sk.kp, CChainParams::EXT_PUBLIC_KEY);
BOOST_CHECK(eKey58.ToString() == "sdcpmphCJNSUos9rNqn6FNi3ztvMW1wft1PVbifvBrwhm6JnhD9yk8rSNFTGfozGbmBsr8vZv9mGYSTfmEMpbfTTMb8TQfj7JRABmvBFKgA2xG8J");
eKey58.SetKeyV(sk.kp);
BOOST_CHECK(eKey58.ToString() == "sdcvmnKmFxG9k6UnN3wyLpTv83G1wgYEz1m21rZTUUimoDrYYMrZXUycudse21EZJTmkBBPN3k6Qhfzx5td8xzd9W893YhNozA3bZW3yVLVdrZU2");
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
ss << sk << skInvalid;
ss >> sk_;
ss >> skInvalid_;
BOOST_CHECK(sk.kp == sk_.kp);
BOOST_CHECK(1 == sk_.kp.IsValidV());
BOOST_CHECK(1 == sk_.kp.IsValidP());
BOOST_CHECK(sk.sLabel == sk_.sLabel);
BOOST_CHECK(sk.nGenerated == sk_.nGenerated);
BOOST_CHECK(sk.nHGenerated == sk_.nHGenerated);
BOOST_CHECK(nTest8 == GetCompressedInt64(sk_.mapValue[EKVT_CREATED_AT], (uint64_t&)nTest));
BOOST_CHECK(0 == skInvalid.kp.IsValidV());
BOOST_CHECK(0 == skInvalid.kp.IsValidP());
// path
std::vector<uint8_t> vPath;
PushUInt32(vPath, 1);
PushUInt32(vPath, 3);
PushUInt32(vPath, 2);
PushUInt32(vPath, 4294967295);
std::string sPath;
BOOST_CHECK(0 == PathToString(vPath, sPath, 'h'));
BOOST_CHECK(sPath == "m/1/3/2/2147483647h");
vPath.resize(0);
PushUInt32(vPath, 1);
PushUInt32(vPath, 4294967294);
PushUInt32(vPath, 30);
BOOST_CHECK(0 == PathToString(vPath, sPath));
BOOST_CHECK(sPath == "m/1/2147483646'/30");
// id
CBitcoinAddress addr;
CKeyID id = sk.GetID();
CKeyID idTest;
BOOST_CHECK(true == addr.Set(id, CChainParams::EXT_KEY_HASH)
&& addr.IsValid(CChainParams::EXT_KEY_HASH)
&& addr.GetKeyID(idTest, CChainParams::EXT_KEY_HASH));
BOOST_CHECK(id == idTest);
BOOST_CHECK_MESSAGE(addr.ToString() == "x9S4Xj1DZwFsdFno1uHknNNGqdMWgXdhX6", addr.ToString());
// - test DeriveNextKey
CExtKey ev;
CExtPubKey ep;
uint32_t nChild=0;
sk.nGenerated = 0;
sk.nHGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild));
BOOST_CHECK_MESSAGE(1 == sk.nGenerated, "nGenerated " << sk.nGenerated);
sk.nGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ep, nChild));
BOOST_CHECK(ep.pubkey == ev.key.GetPubKey());
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xS8vxP6PVm3ycqm4NqvUkhiDWqeBhhekzn", addr.ToString());
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfAtU1u43VJBTt4agxpnPvXjf28hSmwrL", addr.ToString());
sk.nHGenerated = 0;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xEcqVH3fRnNZabMHVctAeScJY9ySkg6BSF", addr.ToString());
BOOST_CHECK_MESSAGE(1 == sk.nHGenerated, "nHGenerated " << sk.nHGenerated);
sk.nHGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ev, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfBk2tuann5qTVKyW2HmA9CJZBAE1sRvJ", addr.ToString());
BOOST_CHECK_MESSAGE(2 == sk.nHGenerated, "nHGenerated " << sk.nHGenerated);
sk.nHGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(ep, nChild, true));
id = ev.key.GetPubKey().GetID();
addr.Set(id, CChainParams::EXT_KEY_HASH);
BOOST_CHECK_MESSAGE(addr.ToString() == "xRfBk2tuann5qTVKyW2HmA9CJZBAE1sRvJ", addr.ToString());
BOOST_CHECK(ep.pubkey == ev.key.GetPubKey());
CStoredExtKey skp = sk;
skp.kp = skp.kp.Neutered();
CKey k;
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 1, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "0245a12d2ce075d947b6232b3e424ffa5d2208b6ff69800a1f2501ac6392499bf8", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
sk.nGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 2, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "02f430d7efc4d1ecbac888fb49446ec0b13ec4196512be93054a9b5b30df238910", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
sk.nHGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(k, nChild, true));
BOOST_CHECK_MESSAGE(nChild == 2147483650, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(k.GetPubKey()) == "0355825cbaf4365a2f7015d9c9bae4ecaf9b57a05e063237256f1565b20104c183", "HexStr(k.GetPubKey()) " << HexStr(k.GetPubKey()));
// - can't derive keys from pubkeys
skp.nGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(k, nChild, false));
skp.nHGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(k, nChild, true));
CPubKey pk;
sk.nGenerated = 1;
BOOST_CHECK(0 == sk.DeriveNextKey(pk, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 1, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "0245a12d2ce075d947b6232b3e424ffa5d2208b6ff69800a1f2501ac6392499bf8", "HexStr(pk) " << HexStr(pk));
sk.nHGenerated = 2;
BOOST_CHECK(0 == sk.DeriveNextKey(pk, nChild, true));
BOOST_CHECK_MESSAGE(nChild == 2147483650, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "0355825cbaf4365a2f7015d9c9bae4ecaf9b57a05e063237256f1565b20104c183", "HexStr(pk) " << HexStr(pk));
skp.nGenerated = 2;
BOOST_CHECK(0 == skp.DeriveNextKey(pk, nChild, false));
BOOST_CHECK_MESSAGE(nChild == 2, "nChild " << nChild);
BOOST_CHECK_MESSAGE(HexStr(pk) == "02f430d7efc4d1ecbac888fb49446ec0b13ec4196512be93054a9b5b30df238910", "HexStr(pk) " << HexStr(pk));
// - can't derive hardened pubkeys from pubkeys
skp.nHGenerated = 1;
BOOST_CHECK(1 == skp.DeriveNextKey(pk, nChild, true));
// - CBitcoinAddress tests
// CBitcoinAddress always deals in public keys - should never expose a secret in an address
CExtKeyPair kp, kpT;
CTxDestination dest;
BOOST_CHECK(0 == eKey58.Set58("sdcpmphCJNSUos9rNqn6FNi3ztvMW1wft1PVbifvBrwhm6JnhD9yk8rSNFTGfozGbmBsr8vZv9mGYSTfmEMpbfTTMb8TQfj7JRABmvBFKgA2xG8J"));
kp = eKey58.GetKey();
CBitcoinAddress addrB(kp);
BOOST_CHECK(addrB.IsValid() == true);
BOOST_CHECK(addr.Set(kp) == true);
BOOST_CHECK(addr.IsValid() == true);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_SECRET_KEY) == false);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.ToString() == "sdcpmphCJNSUos9rNqn6FNi3ztvMW1wft1PVbifvBrwhm6JnhD9yk8rSNFTGfozGbmBsr8vZv9mGYSTfmEMpbfTTMb8TQfj7JRABmvBFKgA2xG8J");
dest = addr.Get();
BOOST_CHECK(dest.type() == typeid(CExtKeyPair));
kpT = boost::get<CExtKeyPair>(dest);
BOOST_CHECK(kpT == kp);
// - switch to testnet
BOOST_MESSAGE("Entering Testnet");
fTestNet = true;
SelectParams(CChainParams::TESTNET);
id = sk.GetID();
BOOST_CHECK(true == addr.Set(id, CChainParams::EXT_KEY_HASH)
&& addr.IsValid(CChainParams::EXT_KEY_HASH)
&& addr.GetKeyID(idTest, CChainParams::EXT_KEY_HASH));
BOOST_CHECK(id == idTest);
BOOST_CHECK_MESSAGE(addr.ToString() == "XCUfUzXMYkXYvP9RVtdzibVVpMP2bhfWRQ", addr.ToString());
BOOST_CHECK(0 == eKey58.Set58("SDCPTTad968GGU17vZThYUhb4WKgaLQ22ffBVjTnZGGCAcU1vfVFcJEroz4QeZjFZLs5a1dkpZxsKfB2Adnun1axAGuzrfBweXWSxuXu2Wj3AaGp"));
kp = eKey58.GetKey();
CBitcoinAddress addrC("SDCVTZWtnQrSZ1LBHScXxi5amgw4Q1zGaRuAy5S12NAttbx3Bmsm1jDYh1B5P5qTPZaWpUZZ5mmubGTYjXPB1cQ9btJmhDoBLHZnwAGUBVH42gB3");
BOOST_CHECK(addrC.IsValid() == true);
BOOST_CHECK(addrC.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.Set(kp) == true);
BOOST_CHECK(addr.IsValid() == true);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_SECRET_KEY) == false);
BOOST_CHECK(addr.IsValid(CChainParams::EXT_PUBLIC_KEY) == true);
BOOST_CHECK(addr.ToString() == "SDCPTTad968GGU17vZThYUhb4WKgaLQ22ffBVjTnZGGCAcU1vfVFcJEroz4QeZjFZLs5a1dkpZxsKfB2Adnun1axAGuzrfBweXWSxuXu2Wj3AaGp");
dest = addr.Get();
BOOST_CHECK(dest.type() == typeid(CExtKeyPair));
kpT = boost::get<CExtKeyPair>(dest);
BOOST_CHECK(kpT == kp);
// -return to mainnet
fTestNet = false;
SelectParams(CChainParams::MAIN);
}
MiningPage::MiningPage(QWidget *parent) :
QWidget(parent),
ui(new Ui::MiningPage),
hasMiningprivkey(false)
{
ui->setupUi(this);
int nThreads = boost::thread::hardware_concurrency();
int nUseThreads = GetArg("-genproclimit", -1);
if (nUseThreads < 0)
nUseThreads = nThreads;
std::string PrivAddress = GetArg("-miningprivkey", "");
if (!PrivAddress.empty())
{
CBitcoinSecret Secret;
Secret.SetString(PrivAddress);
if (Secret.IsValid())
{
CBitcoinAddress Address;
Address.Set(Secret.GetKey().GetPubKey().GetID());
ui->labelAddress->setText(QString("All mined coins will go to to %1").arg(Address.ToString().c_str()));
hasMiningprivkey = true;
}
}
ui->sliderCores->setMinimum(0);
ui->sliderCores->setMaximum(nThreads);
ui->sliderCores->setValue(nUseThreads);
ui->labelNCores->setText(QString("%1").arg(nUseThreads));
connect(ui->sliderCores, SIGNAL(valueChanged(int)), this, SLOT(changeNumberOfCores(int)));
connect(ui->pushSwitchMining, SIGNAL(clicked()), this, SLOT(switchMining()));
updateUI();
startTimer(1500);
}