/*
* 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;
int64 nTxFee = -(nDebit - wtx.GetValueOut());
uint256 hash = wtx.GetHash();
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (wtx.IsCoinStake())
{
// Stake generation
TransactionRecord sub(hash, nTime);
sub.type = TransactionRecord::StakeMint;
// sub.address = "";
sub.fee = 0;
sub.debit = -nDebit;
sub.credit = wtx.GetValueOut();
parts.append(sub);
// 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);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
// Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
if (wtx.IsCoinBase())
{
// Generated
sub.type = TransactionRecord::Generated;
}
parts.append(sub);
}
}
}
/*
* 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()) // ppcoin: coinstake transaction
{
int64 showCredit = wtx.GetValueOut();
BOOST_FOREACH(const PAIRTYPE(const uint256, CWalletTx)& hash_tx, wallet->mapWallet) {
const CWalletTx &otherTx = hash_tx.second;
if (otherTx.hashBlock == wtx.hashBlock && otherTx.IsCoinBase()) {
showCredit += otherTx.GetValueOut();
break;
}
}
parts.append(TransactionRecord(hash, nTime, TransactionRecord::StakeMint, "", -nDebit, showCredit));
}
else if (nNet > 0 || wtx.IsCoinBase())
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetTxTime();
int64_t nCredit = wtx.GetCredit(true);
int64_t nDebit = wtx.GetDebit();
int64_t nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash(), hashPrev = 0;
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (nNet > 0 || wtx.IsCoinBase() || wtx.IsCoinStake())
{
//
// Credit
//
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if(wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
// Received by Vickcurrency Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
if (wtx.IsCoinBase())
{
// Generated (proof-of-work)
//sub.type = TransactionRecord::PowGenerate;
sub.type = TransactionRecord::Generated;
}
if (wtx.IsCoinStake())
{
// Generated (proof-of-stake)
if (hashPrev == hash)
continue; // last coinstake output
sub.type = TransactionRecord::PosGenerated;
//sub.type = TransactionRecord::Generated;
sub.credit = nNet > 0 ? nNet : wtx.GetValueOut() - nDebit;
hashPrev = hash;
}
parts.append(sub);
}
}
}
QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx, int vout, int unit)
{
QString strHTML;
{
LOCK(wallet->cs_wallet);
strHTML.reserve(4000);
strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
int64_t nTime = wtx.GetTxTime();
int64_t nCredit = wtx.GetCredit();
int64_t nDebit = wtx.GetDebit();
int64_t nNet = nCredit - nDebit;
strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx) + "<br>";
strHTML += "<b>" + tr("Date") + ":</b> " + (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";
//
// From
//
if (wtx.IsCoinBase())
{
strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
}
else if (wtx.mapValue.count("from") && !wtx.mapValue["from"].empty())
{
// Online transaction
strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.mapValue["from"]) + "<br>";
}
else
{
// Offline transaction
if (nNet > 0)
{
// Credit
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if (wallet->IsMine(txout))
{
CTxDestination address = CKeyID(txout.pubKey);
if (wallet->IsMine(txout.pubKey))
{
if (wallet->mapAddressBook.count(address))
{
strHTML += "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
strHTML += "<b>" + tr("To") + ":</b> ";
strHTML += GUIUtil::HtmlEscape(CBitcoinAddress(address).ToString());
if (!wallet->mapAddressBook[address].name.empty())
strHTML += " (" + tr("own address") + ", " + tr("label") + ": " + GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + ")";
else
strHTML += " (" + tr("own address") + ")";
strHTML += "<br>";
}
}
break;
}
}
}
}
//
// To
//
if (wtx.mapValue.count("to") && !wtx.mapValue["to"].empty())
{
// Online transaction
std::string strAddress = wtx.mapValue["to"];
strHTML += "<b>" + tr("To") + ":</b> ";
CTxDestination dest = CBitcoinAddress(strAddress).Get();
if (wallet->mapAddressBook.count(dest) && !wallet->mapAddressBook[dest].name.empty())
strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[dest].name) + " ";
strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
}
//
// Amount
//
if (nNet > 0)
{
//
// Credit
//
strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nNet) + "<br>";
}
else
{
bool fAllFromMe = true;
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
fAllFromMe = fAllFromMe && wallet->IsMine(txin);
bool fAllToMe = true;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
fAllToMe = fAllToMe && wallet->IsMine(txout);
if (fAllFromMe)
{
//
// Debit
//
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if (wallet->IsMine(txout))
continue;
if (!wtx.mapValue.count("to") || wtx.mapValue["to"].empty())
{
// Offline transaction
CTxDestination address = CKeyID(txout.pubKey);
strHTML += "<b>" + tr("To") + ":</b> ";
if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].name.empty())
strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + " ";
strHTML += GUIUtil::HtmlEscape(CBitcoinAddress(address).ToString());
strHTML += "<br>";
}
strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -txout.nValue) + "<br>";
}
if (fAllToMe)
{
// Payment to self
strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nDebit) + "<br>";
strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nCredit) + "<br>";
}
uint64_t nTxFee = nDebit - wtx.GetValueOut();
if (nTxFee > 0)
strHTML += "<b>" + tr("Transaction fee") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nTxFee) + "<br>";
}
else
{
//
// Mixed debit transaction
//
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
if (wallet->IsMine(txin))
strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, wallet->GetDebit(txin)) + "<br>";
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
if (wallet->IsMine(txout))
strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, wallet->GetCredit(txout)) + "<br>";
}
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetTxTime();
int64_t nCredit = wtx.GetCredit(true);
int64_t nDebit = wtx.GetDebit();
int64_t nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash(), hashPrev = 0;
std::map<std::string, std::string> mapValue = wtx.mapValue;
char cbuf[256];
if (nNet > 0 || wtx.IsCoinBase() || wtx.IsCoinStake())
{
//
// Credit
//
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
const CTxOut& txout = wtx.vout[nOut];
if(wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
// Received by CannabisDarkcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CCannabisDarkcoinAddress(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"];
}
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
if (wtx.IsCoinBase())
{
// Generated (proof-of-work)
sub.type = TransactionRecord::Generated;
}
if (wtx.IsCoinStake())
{
// Generated (proof-of-stake)
if (hashPrev == hash)
continue; // last coinstake output
sub.type = TransactionRecord::Generated;
sub.credit = nNet > 0 ? nNet : wtx.GetValueOut() - nDebit;
hashPrev = hash;
}
parts.append(sub);
}
}
}
else
{
bool fAllFromMe = true;
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
fAllFromMe = fAllFromMe && wallet->IsMine(txin);
bool fAllToMe = true;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
fAllToMe = fAllToMe && wallet->IsMine(txout);
if (fAllFromMe && fAllToMe)
{
// Payment to self
int64_t nChange = wtx.GetChange();
std::string narration("");
mapValue_t::const_iterator mi;
for (mi = wtx.mapValue.begin(); mi != wtx.mapValue.end(); ++mi)
{
if (mi->first.compare(0, 2, "n_") != 0)
continue;
narration = mi->second;
break;
};
parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "", narration,
-(nDebit - nChange), nCredit - nChange));
}
else if (fAllFromMe)
{
//
// Debit
//
int64_t nTxFee = nDebit - wtx.GetValueOut();
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
const CTxOut& txout = wtx.vout[nOut];
TransactionRecord sub(hash, nTime);
sub.idx = parts.size();
if(wallet->IsMine(txout))
{
// Ignore parts sent to self, as this is usually the change
// from a transaction sent back to our own address.
continue;
}
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address))
{
// Sent to CannabisDarkcoin Address
sub.type = TransactionRecord::SendToAddress;
sub.address = CCannabisDarkcoinAddress(address).ToString();
}
else
{
// Sent to IP, or other non-address transaction like OP_EVAL
sub.type = TransactionRecord::SendToOther;
sub.address = mapValue["to"];
}
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
int64_t nValue = txout.nValue;
/* Add fee to first output */
if (nTxFee > 0)
{
nValue += nTxFee;
nTxFee = 0;
}
sub.debit = -nValue;
parts.append(sub);
}
}
else
{
//
// Mixed debit transaction, can't break down payees
//
parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", "", nNet, 0));
}
}
return parts;
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetTxTime();
int64_t nCredit = wtx.GetCredit(true);
int64_t nDebit = wtx.GetDebit();
int64_t nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash(), hashPrev = 0;
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (nNet > 0 || wtx.IsCoinBase() || wtx.IsCoinStake())
{
//
// Credit - Calculate Net from CryptoLottery Rob Halford - 4-3-2015-1
//
for (auto const& txout : wtx.vout)
{
if(wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
// Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
if (wtx.IsCoinBase())
{
// Generated (proof-of-work)
sub.type = TransactionRecord::Generated;
}
if (wtx.IsCoinStake())
{
// Generated (proof-of-stake)
if (hashPrev == hash)
continue; // last coinstake output
if (wtx.vout.size()==2)
{
//Standard POR CoinStake
sub.type = TransactionRecord::Generated;
sub.credit = nNet > 0 ? nNet : wtx.GetValueOut() - nDebit;
hashPrev = hash;
}
else
{
//CryptoLottery - CoinStake - 4-3-2015
sub.type = TransactionRecord::Generated;
if (nDebit == 0)
{
sub.credit = GetMyValueOut(wallet,wtx);
sub.RemoteFlag = 1;
}
else
{
sub.credit = nNet > 0 ? nNet : GetMyValueOut(wallet,wtx) - nDebit;
}
hashPrev = hash;
}
}
parts.append(sub);
}
}
}
else
{
bool fAllFromMe = true;
for (auto const& txin : wtx.vin)
fAllFromMe = fAllFromMe && wallet->IsMine(txin);
bool fAllToMe = true;
for (auto const& txout : wtx.vout)
fAllToMe = fAllToMe && wallet->IsMine(txout);
if (fAllFromMe && fAllToMe)
{
// Payment to self
int64_t nChange = wtx.GetChange();
parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "",
-(nDebit - nChange), nCredit - nChange));
}
else if (fAllFromMe)
{
//
// Debit
//
int64_t nTxFee = nDebit - wtx.GetValueOut();
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
const CTxOut& txout = wtx.vout[nOut];
TransactionRecord sub(hash, nTime);
sub.idx = parts.size();
if(wallet->IsMine(txout))
{
// Ignore parts sent to self, as this is usually the change
// from a transaction sent back to our own address.
continue;
}
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address))
{
// Sent to Bitcoin Address
sub.type = TransactionRecord::SendToAddress;
sub.address = CBitcoinAddress(address).ToString();
}
else
{
// Sent to IP, or other non-address transaction like OP_EVAL
sub.type = TransactionRecord::SendToOther;
sub.address = mapValue["to"];
}
int64_t nValue = txout.nValue;
/* Add fee to first output */
if (nTxFee > 0)
{
nValue += nTxFee;
nTxFee = 0;
}
sub.debit = -nValue;
parts.append(sub);
}
}
else
{
//
// Mixed debit transaction, can't break down payees
//
parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0));
}
}
return parts;
}
WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction& transaction, const CCoinControl* coinControl)
{
CAmount total = 0;
bool fSubtractFeeFromAmount = false;
QList<SendCoinsRecipient> recipients = transaction.getRecipients();
std::vector<CRecipient> vecSend;
if (recipients.empty()) {
return OK;
}
if (isAnonymizeOnlyUnlocked()) {
return AnonymizeOnlyUnlocked;
}
QSet<QString> setAddress; // Used to detect duplicates
int nAddresses = 0;
// Pre-check input data for validity
foreach (const SendCoinsRecipient& rcp, recipients) {
if (rcp.fSubtractFeeFromAmount)
fSubtractFeeFromAmount = true;
if (rcp.paymentRequest.IsInitialized()) { // PaymentRequest...
CAmount subtotal = 0;
const payments::PaymentDetails& details = rcp.paymentRequest.getDetails();
for (int i = 0; i < details.outputs_size(); i++) {
const payments::Output& out = details.outputs(i);
if (out.amount() <= 0) continue;
subtotal += out.amount();
const unsigned char* scriptStr = (const unsigned char*)out.script().data();
CScript scriptPubKey(scriptStr, scriptStr + out.script().size());
CAmount nAmount = out.amount();
CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
vecSend.push_back(recipient);
}
if (subtotal <= 0) {
return InvalidAmount;
}
total += subtotal;
} else { // User-entered ion address / amount:
if (!validateAddress(rcp.address)) {
return InvalidAddress;
}
if (rcp.amount <= 0) {
return InvalidAmount;
}
setAddress.insert(rcp.address);
++nAddresses;
CScript scriptPubKey = GetScriptForDestination(DecodeDestination(rcp.address.toStdString()));
CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
vecSend.push_back(recipient);
total += rcp.amount;
}
}
if (setAddress.size() != nAddresses) {
return DuplicateAddress;
}
CAmount nBalance = getBalance(coinControl);
if (total > nBalance) {
return AmountExceedsBalance;
}
{
LOCK2(cs_main, wallet->cs_wallet);
transaction.newPossibleKeyChange(wallet);
CAmount nFeeRequired = 0;
int nChangePosRet = -1;
std::string strFailReason;
CWalletTx* newTx = transaction.getTransaction();
CReserveKey* keyChange = transaction.getPossibleKeyChange();
if (recipients[0].useSwiftTX && total > GetSporkValue(SPORK_3_SWIFTTX_MAX_VALUE) * COIN) {
emit message(tr("Send Coins"), tr("SwiftX doesn't support sending values that high yet. Transactions are currently limited to %1 ION.").arg(GetSporkValue(SPORK_3_SWIFTTX_MAX_VALUE)),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
bool fCreated = wallet->CreateTransaction(vecSend, *newTx, *keyChange, nFeeRequired, nChangePosRet, strFailReason, coinControl, recipients[0].inputType, recipients[0].useSwiftTX);
transaction.setTransactionFee(nFeeRequired);
if (fSubtractFeeFromAmount && fCreated)
transaction.reassignAmounts(nChangePosRet);
if (recipients[0].useSwiftTX && newTx->GetValueOut() > GetSporkValue(SPORK_3_SWIFTTX_MAX_VALUE) * COIN) {
emit message(tr("Send Coins"), tr("SwiftX doesn't support sending values that high yet. Transactions are currently limited to %1 ION.").arg(GetSporkValue(SPORK_3_SWIFTTX_MAX_VALUE)),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
if (!fCreated) {
if (!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance) {
return SendCoinsReturn(AmountWithFeeExceedsBalance);
}
emit message(tr("Send Coins"), QString::fromStdString(strFailReason),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
// reject insane fee
if (nFeeRequired > ::minRelayTxFee.GetFee(transaction.getTransactionSize()) * 10000)
return InsaneFee;
}
return SendCoinsReturn(OK);
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetTxTime();
int64_t nCredMOIN, nCredMoinX;
wtx.GetCredit(nCredMOIN, nCredMoinX, true);
int64_t nCredit = nCredMOIN + nCredMoinX;
int64_t nDebit = wtx.GetDebit();
int64_t nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash(), hashPrev = 0;
std::map<std::string, std::string> mapValue = wtx.mapValue;
char cbuf[256];
if (wtx.nVersion == ANON_TXN_VERSION)
{
if (nNet > 0 && nCredMoinX > 0)
{
// -- credit
TransactionRecord sub(hash, nTime, TransactionRecord::RecvMoinX, "", "", nNet, 0);
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
// display 1st transaction
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
{
sub.narration = mi->second;
break;
};
};
parts.append(sub);
return parts;
} else
if (nNet <= 0)
{
// -- debit
TransactionRecord sub(hash, nTime, TransactionRecord::SendMoinX, "", "", nNet, 0);
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
// display 1st transaction
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
{
sub.narration = mi->second;
break;
}
};
parts.append(sub);
return parts;
};
// continue on
};
if (nNet > 0 || wtx.IsCoinBase() || wtx.IsCoinStake())
{
//
// Credit
//
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
const CTxOut& txout = wtx.vout[nOut];
if (wtx.nVersion == ANON_TXN_VERSION
&& txout.IsAnonOutput())
{
const CScript &s = txout.scriptPubKey;
CKeyID ckidD = CPubKey(&s[2+1], 33).GetID();
if (wallet->HaveKey(ckidD))
{
TransactionRecord sub(hash, nTime);
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
sub.type = TransactionRecord::RecvMoinX;
sub.address = CBitcoinAddress(ckidD).ToString();
//sub.address = wallet->mapAddressBook[ckidD]
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
parts.append(sub);
};
};
if (wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
sub.idx = parts.size(); // sequence number
CTxDestination address;
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsDestMine(*wallet, address))
{
// Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
if (wtx.IsCoinBase())
{
// Generated (proof-of-work)
sub.type = TransactionRecord::Generated;
};
if (wtx.IsCoinStake())
{
// Generated (proof-of-stake)
if (hashPrev == hash)
continue; // last coinstake output
sub.type = TransactionRecord::Generated;
sub.credit = nNet > 0 ? nNet : wtx.GetValueOut() - nDebit;
hashPrev = hash;
};
parts.append(sub);
}
}
} else
{
bool fAllFromMe = true;
BOOST_FOREACH(const CTxIn& txin, wtx.vin)
{
if (wtx.nVersion == ANON_TXN_VERSION
&& txin.IsAnonInput())
{
std::vector<uint8_t> vchImage;
txin.ExtractKeyImage(vchImage);
CWalletDB walletdb(wallet->strWalletFile, "r");
COwnedAnonOutput oao;
if (!walletdb.ReadOwnedAnonOutput(vchImage, oao))
{
fAllFromMe = false;
break; // display as send/recv moinx
};
continue;
};
if (wallet->IsMine(txin))
continue;
fAllFromMe = false;
break;
};
bool fAllToMe = true;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if (wtx.nVersion == ANON_TXN_VERSION
&& txout.IsAnonOutput())
{
fAllToMe = false;
break; // display as send/recv moinx
}
opcodetype firstOpCode;
CScript::const_iterator pc = txout.scriptPubKey.begin();
if (txout.scriptPubKey.GetOp(pc, firstOpCode)
&& firstOpCode == OP_RETURN)
continue;
if (wallet->IsMine(txout))
continue;
fAllToMe = false;
break;
};
if (fAllFromMe && fAllToMe)
{
// Payment to self
int64_t nChange = wtx.GetChange();
std::string narration("");
mapValue_t::const_iterator mi;
for (mi = wtx.mapValue.begin(); mi != wtx.mapValue.end(); ++mi)
{
if (mi->first.compare(0, 2, "n_") != 0)
continue;
narration = mi->second;
break;
};
parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "", narration,
-(nDebit - nChange), nCredit - nChange));
} else
if (fAllFromMe)
{
//
// Debit
//
int64_t nTxFee = nDebit - wtx.GetValueOut();
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
const CTxOut& txout = wtx.vout[nOut];
TransactionRecord sub(hash, nTime);
sub.idx = parts.size();
if (wtx.nVersion == ANON_TXN_VERSION
&& txout.IsAnonOutput())
{
const CScript &s = txout.scriptPubKey;
CKeyID ckidD = CPubKey(&s[2+1], 33).GetID();
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
sub.type = TransactionRecord::SendMoinX;
sub.address = CBitcoinAddress(ckidD).ToString();
} else
{
opcodetype firstOpCode;
CScript::const_iterator pc = txout.scriptPubKey.begin();
if (txout.scriptPubKey.GetOp(pc, firstOpCode)
&& firstOpCode == OP_RETURN)
continue;
if (wallet->IsMine(txout))
{
// Ignore parts sent to self, as this is usually the change
// from a transaction sent back to our own address.
continue;
}
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address))
{
// Sent to Bitcoin Address
sub.type = TransactionRecord::SendToAddress;
sub.address = CBitcoinAddress(address).ToString();
} else
{
// Sent to IP, or other non-address transaction like OP_EVAL
sub.type = TransactionRecord::SendToOther;
sub.address = mapValue["to"];
}
};
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
int64_t nValue = txout.nValue;
/* Add fee to first output */
if (nTxFee > 0)
{
nValue += nTxFee;
nTxFee = 0;
}
sub.debit = -nValue;
parts.append(sub);
}
} else
{
//
// Mixed debit transaction, can't break down payees
//
TransactionRecord sub(hash, nTime, TransactionRecord::Other, "", "", nNet, 0);
/*
for (unsigned int nOut = 0; nOut < wtx.vout.size(); nOut++)
{
// display 1st transaction
snprintf(cbuf, sizeof(cbuf), "n_%u", nOut);
mapValue_t::const_iterator mi = wtx.mapValue.find(cbuf);
if (mi != wtx.mapValue.end() && !mi->second.empty())
sub.narration = mi->second;
break;
};
*/
parts.append(sub);
}
}
return parts;
}
/*
* 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;
const bool combineOutputs = (wtx.cUnit == 'S');
if (wtx.IsCoinStake()) // ppcoin: coinstake transaction
{
parts.append(TransactionRecord(hash, nTime, TransactionRecord::StakeMint, "", -nDebit, wtx.GetValueOut()));
}
else if (nNet > 0 || wtx.IsCoinBase())
{
//
// Credit
//
QMap<CScript, TransactionRecord*> outputParts;
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
if(wallet->IsMine(txout))
{
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
if (wtx.IsUnpark())
sub.type = TransactionRecord::Unpark;
else // Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(address, wtx.cUnit).ToString();
}
else
{
// Received by IP connection (deprecated features), or a multisignature or other non-simple transaction
sub.type = TransactionRecord::RecvFromOther;
sub.address = mapValue["from"];
}
if (wtx.IsCoinBase())
{
// Generated
sub.type = TransactionRecord::Generated;
}
if (combineOutputs)
{
QMap<CScript, TransactionRecord*>::const_iterator it = outputParts.find(txout.scriptPubKey);
if (it != outputParts.end())
{
TransactionRecord& previous = *it.value();
previous.credit += sub.credit;
continue;
}
}
parts.append(sub);
if (combineOutputs)
outputParts[txout.scriptPubKey] = &parts.back();
}
}
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx,
bool fBurnMint)
{
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(fBurnMint && wtx.IsCoinBase())
parts.append(TransactionRecord(hash, nTime, TransactionRecord::BurnMint, "", -nDebit, wtx.GetValueOut()));
else if(wtx.IsCoinStake()) // heat: 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 by mining
sub.type = TransactionRecord::Generated;
}
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
{
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet* wallet, const CWalletTx& wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetComputedTxTime();
CAmount nCredit = wtx.GetCredit(ISMINE_ALL);
CAmount nDebit = wtx.GetDebit(ISMINE_ALL);
CAmount nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash();
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (wtx.IsCoinStake()) {
TransactionRecord sub(hash, nTime);
CTxDestination address;
if (!ExtractDestination(wtx.vout[1].scriptPubKey, address))
return parts;
if (!IsMine(*wallet, address)) {
//if the address is not yours then it means you have a tx sent to you in someone elses coinstake tx
for (unsigned int i = 1; i < wtx.vout.size(); i++) {
CTxDestination outAddress;
if (ExtractDestination(wtx.vout[i].scriptPubKey, outAddress)) {
if (IsMine(*wallet, outAddress)) {
isminetype mine = wallet->IsMine(wtx.vout[i]);
sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
sub.type = TransactionRecord::MNReward;
sub.address = CBitcoinAddress(outAddress).ToString();
sub.credit = wtx.vout[i].nValue;
}
}
}
} else {
//stake reward
isminetype mine = wallet->IsMine(wtx.vout[1]);
sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
sub.type = TransactionRecord::StakeMint;
sub.address = CBitcoinAddress(address).ToString();
sub.credit = nNet;
}
parts.append(sub);
} else if (wtx.IsZerocoinSpend()) {
// a zerocoin spend that was created by this wallet
libzerocoin::CoinSpend zcspend = TxInToZerocoinSpend(wtx.vin[0]);
bool fSpendFromMe = wallet->IsMyZerocoinSpend(zcspend.getCoinSerialNumber());
//zerocoin spend outputs
bool fFeeAssigned = false;
for (const CTxOut txout : wtx.vout) {
// change that was reminted as zerocoins
if (txout.IsZerocoinMint()) {
// do not display record if this isn't from our wallet
if (!fSpendFromMe)
continue;
TransactionRecord sub(hash, nTime);
sub.type = TransactionRecord::ZerocoinSpend_Change_zPiv;
sub.address = mapValue["zerocoinmint"];
sub.debit = -txout.nValue;
if (!fFeeAssigned) {
sub.debit -= (wtx.GetZerocoinSpent() - wtx.GetValueOut());
fFeeAssigned = true;
}
sub.idx = parts.size();
parts.append(sub);
continue;
}
string strAddress = "";
CTxDestination address;
if (ExtractDestination(txout.scriptPubKey, address))
strAddress = CBitcoinAddress(address).ToString();
// a zerocoinspend that was sent to an address held by this wallet
isminetype mine = wallet->IsMine(txout);
if (mine) {
TransactionRecord sub(hash, nTime);
sub.type = (fSpendFromMe ? TransactionRecord::ZerocoinSpend_FromMe : TransactionRecord::RecvFromZerocoinSpend);
sub.debit = txout.nValue;
sub.address = mapValue["recvzerocoinspend"];
if (strAddress != "")
sub.address = strAddress;
sub.idx = parts.size();
parts.append(sub);
continue;
}
// spend is not from us, so do not display the spend side of the record
if (!fSpendFromMe)
continue;
// zerocoin spend that was sent to someone else
TransactionRecord sub(hash, nTime);
sub.debit = -txout.nValue;
sub.type = TransactionRecord::ZerocoinSpend;
sub.address = mapValue["zerocoinspend"];
if (strAddress != "")
sub.address = strAddress;
sub.idx = parts.size();
parts.append(sub);
}
} else if (nNet > 0 || wtx.IsCoinBase()) {
//
// Credit
//
BOOST_FOREACH (const CTxOut& txout, wtx.vout) {
isminetype mine = wallet->IsMine(txout);
if (mine) {
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address)) {
// Received by PIVX Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
if (wtx.IsCoinBase()) {
// Generated
sub.type = TransactionRecord::Generated;
}
parts.append(sub);
}
}
} else {
WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransaction &transaction, const CCoinControl *coinControl)
{
CAmount total = 0;
bool fSubtractFeeFromAmount = false;
QList<SendCoinsRecipient> recipients = transaction.getRecipients();
std::vector<CRecipient> vecSend;
if(recipients.empty())
{
return OK;
}
// This should never really happen, yet another safety check, just in case.
if(wallet->IsLocked()) {
return TransactionCreationFailed;
}
QSet<QString> setAddress; // Used to detect duplicates
int nAddresses = 0;
// Pre-check input data for validity
Q_FOREACH(const SendCoinsRecipient &rcp, recipients)
{
if (rcp.fSubtractFeeFromAmount)
fSubtractFeeFromAmount = true;
if (rcp.paymentRequest.IsInitialized())
{ // PaymentRequest...
CAmount subtotal = 0;
const payments::PaymentDetails& details = rcp.paymentRequest.getDetails();
for (int i = 0; i < details.outputs_size(); i++)
{
const payments::Output& out = details.outputs(i);
if (out.amount() <= 0) continue;
subtotal += out.amount();
const unsigned char* scriptStr = (const unsigned char*)out.script().data();
CScript scriptPubKey(scriptStr, scriptStr+out.script().size());
CAmount nAmount = out.amount();
CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
vecSend.push_back(recipient);
}
if (subtotal <= 0)
{
return InvalidAmount;
}
total += subtotal;
}
else
{ // User-entered gridcoin address / amount:
if(!validateAddress(rcp.address))
{
return InvalidAddress;
}
if(rcp.amount <= 0)
{
return InvalidAmount;
}
setAddress.insert(rcp.address);
++nAddresses;
CScript scriptPubKey = GetScriptForDestination(CBitcoinAddress(rcp.address.toStdString()).Get());
CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
vecSend.push_back(recipient);
total += rcp.amount;
}
}
if(setAddress.size() != nAddresses)
{
return DuplicateAddress;
}
CAmount nBalance = getBalance(coinControl);
if(total > nBalance)
{
return AmountExceedsBalance;
}
{
LOCK2(cs_main, wallet->cs_wallet);
transaction.newPossibleKeyChange(wallet);
CAmount nFeeRequired = 0;
int nChangePosRet = -1;
std::string strFailReason;
CWalletTx *newTx = transaction.getTransaction();
CReserveKey *keyChange = transaction.getPossibleKeyChange();
if(recipients[0].fUseInstantSend && total > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN){
Q_EMIT message(tr("Send Coins"), tr("InstantSend doesn't support sending values that high yet. Transactions are currently limited to %1 GRIDCOIN.").arg(sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
bool fCreated = wallet->CreateTransaction(vecSend, *newTx, *keyChange, nFeeRequired, nChangePosRet, strFailReason, coinControl, true, recipients[0].inputType, recipients[0].fUseInstantSend);
transaction.setTransactionFee(nFeeRequired);
if (fSubtractFeeFromAmount && fCreated)
transaction.reassignAmounts(nChangePosRet);
if(recipients[0].fUseInstantSend) {
if(newTx->GetValueOut() > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
Q_EMIT message(tr("Send Coins"), tr("InstantSend doesn't support sending values that high yet. Transactions are currently limited to %1 GRIDCOIN.").arg(sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
if(newTx->vin.size() > CTxLockRequest::WARN_MANY_INPUTS) {
Q_EMIT message(tr("Send Coins"), tr("Used way too many inputs (>%1) for this InstantSend transaction, fees could be huge.").arg(CTxLockRequest::WARN_MANY_INPUTS),
CClientUIInterface::MSG_WARNING);
}
}
if(!fCreated)
{
if(!fSubtractFeeFromAmount && (total + nFeeRequired) > nBalance)
{
return SendCoinsReturn(AmountWithFeeExceedsBalance);
}
Q_EMIT message(tr("Send Coins"), QString::fromStdString(strFailReason),
CClientUIInterface::MSG_ERROR);
return TransactionCreationFailed;
}
// reject absurdly high fee. (This can never happen because the
// wallet caps the fee at maxTxFee. This merely serves as a
// belt-and-suspenders check)
if (nFeeRequired > maxTxFee)
return AbsurdFee;
}
return SendCoinsReturn(OK);
}
/*
* Decompose CWallet transaction to model transaction records.
*/
QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *wallet, const CWalletTx &wtx)
{
QList<TransactionRecord> parts;
int64_t nTime = wtx.GetTxTime();
CAmount nCredit = wtx.GetCredit(ISMINE_ALL);
CAmount nDebit = wtx.GetDebit(ISMINE_ALL);
CAmount nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash();
std::map<std::string, std::string> mapValue = wtx.mapValue;
if (wtx.IsCoinStake()) // ppcoin: coinstake transaction
{
CTxOut txout = wtx.vout[1];
CTxDestination address;
TransactionRecord sub(hash, nTime, TransactionRecord::StakeMint, "", -nDebit, wtx.GetValueOut());
if(ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
sub.address = CBitcoinAddress(address).ToString();
parts.append(sub);
}
else if (nNet > 0 || wtx.IsCoinBase())
{
//
// Credit
//
BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{
isminetype mine = wallet->IsMine(txout);
if(mine)
{
TransactionRecord sub(hash, nTime);
CTxDestination address;
sub.idx = parts.size(); // sequence number
sub.credit = txout.nValue;
sub.involvesWatchAddress = mine == ISMINE_WATCH_ONLY;
if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
{
// Received by Bitcoin Address
sub.type = TransactionRecord::RecvWithAddress;
sub.address = CBitcoinAddress(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"];
}
if (wtx.IsCoinBase())
{
// Generated
sub.type = TransactionRecord::Generated;
}
parts.append(sub);
}
}
}
