880 lines
34 KiB
C++
880 lines
34 KiB
C++
// Copyright (c) 2014-2018 The Dash Core developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "privatesend-server.h"
|
|
|
|
#include "activemasternode.h"
|
|
#include "consensus/validation.h"
|
|
#include "core_io.h"
|
|
#include "init.h"
|
|
#include "masternode-sync.h"
|
|
#include "masternodeman.h"
|
|
#include "netmessagemaker.h"
|
|
#include "script/interpreter.h"
|
|
#include "txmempool.h"
|
|
#include "util.h"
|
|
#include "utilmoneystr.h"
|
|
|
|
CPrivateSendServer privateSendServer;
|
|
|
|
void CPrivateSendServer::ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
if (fLiteMode) return; // ignore all Dash related functionality
|
|
if (!masternodeSync.IsBlockchainSynced()) return;
|
|
|
|
if (strCommand == NetMsgType::DSACCEPT) {
|
|
if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
|
|
LogPrint("privatesend", "DSACCEPT -- peer=%d using obsolete version %i\n", pfrom->id, pfrom->nVersion);
|
|
connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE, strprintf("Version must be %d or greater", MIN_PRIVATESEND_PEER_PROTO_VERSION)));
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_VERSION, connman);
|
|
return;
|
|
}
|
|
|
|
if (IsSessionReady()) {
|
|
// too many users in this session already, reject new ones
|
|
LogPrintf("DSACCEPT -- queue is already full!\n");
|
|
PushStatus(pfrom, STATUS_ACCEPTED, ERR_QUEUE_FULL, connman);
|
|
return;
|
|
}
|
|
|
|
CPrivateSendAccept dsa;
|
|
vRecv >> dsa;
|
|
|
|
LogPrint("privatesend", "DSACCEPT -- nDenom %d (%s) txCollateral %s", dsa.nDenom, CPrivateSend::GetDenominationsToString(dsa.nDenom), dsa.txCollateral.ToString());
|
|
|
|
masternode_info_t mnInfo;
|
|
if (!mnodeman.GetMasternodeInfo(activeMasternodeInfo.outpoint, mnInfo)) {
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_MN_LIST, connman);
|
|
return;
|
|
}
|
|
|
|
if (vecSessionCollaterals.size() == 0) {
|
|
{
|
|
TRY_LOCK(cs_vecqueue, lockRecv);
|
|
if (!lockRecv) return;
|
|
|
|
for (const auto& q : vecPrivateSendQueue) {
|
|
if (q.masternodeOutpoint == activeMasternodeInfo.outpoint) {
|
|
// refuse to create another queue this often
|
|
LogPrint("privatesend", "DSACCEPT -- last dsq is still in queue, refuse to mix\n");
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT, connman);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mnInfo.nLastDsq != 0 && mnInfo.nLastDsq + mnodeman.CountMasternodes() / 5 > mnodeman.nDsqCount) {
|
|
LogPrintf("DSACCEPT -- last dsq too recent, must wait: addr=%s\n", pfrom->addr.ToString());
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_RECENT, connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
PoolMessage nMessageID = MSG_NOERR;
|
|
|
|
bool fResult = nSessionID == 0 ? CreateNewSession(dsa, nMessageID, connman)
|
|
: AddUserToExistingSession(dsa, nMessageID);
|
|
if (fResult) {
|
|
LogPrintf("DSACCEPT -- is compatible, please submit!\n");
|
|
PushStatus(pfrom, STATUS_ACCEPTED, nMessageID, connman);
|
|
return;
|
|
} else {
|
|
LogPrintf("DSACCEPT -- not compatible with existing transactions!\n");
|
|
PushStatus(pfrom, STATUS_REJECTED, nMessageID, connman);
|
|
return;
|
|
}
|
|
|
|
} else if (strCommand == NetMsgType::DSQUEUE) {
|
|
TRY_LOCK(cs_vecqueue, lockRecv);
|
|
if (!lockRecv) return;
|
|
|
|
if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
|
|
LogPrint("privatesend", "DSQUEUE -- peer=%d using obsolete version %i\n", pfrom->id, pfrom->nVersion);
|
|
connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE, strprintf("Version must be %d or greater", MIN_PRIVATESEND_PEER_PROTO_VERSION)));
|
|
return;
|
|
}
|
|
|
|
CPrivateSendQueue dsq;
|
|
vRecv >> dsq;
|
|
|
|
// process every dsq only once
|
|
for (const auto& q : vecPrivateSendQueue) {
|
|
if (q == dsq) {
|
|
// LogPrint("privatesend", "DSQUEUE -- %s seen\n", dsq.ToString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
LogPrint("privatesend", "DSQUEUE -- %s new\n", dsq.ToString());
|
|
|
|
if (dsq.IsExpired()) return;
|
|
|
|
masternode_info_t mnInfo;
|
|
if (!mnodeman.GetMasternodeInfo(dsq.masternodeOutpoint, mnInfo)) return;
|
|
|
|
if (!dsq.CheckSignature(mnInfo.legacyKeyIDOperator, mnInfo.blsPubKeyOperator)) {
|
|
// we probably have outdated info
|
|
mnodeman.AskForMN(pfrom, dsq.masternodeOutpoint, connman);
|
|
return;
|
|
}
|
|
|
|
if (!dsq.fReady) {
|
|
for (const auto& q : vecPrivateSendQueue) {
|
|
if (q.masternodeOutpoint == dsq.masternodeOutpoint) {
|
|
// no way same mn can send another "not yet ready" dsq this soon
|
|
LogPrint("privatesend", "DSQUEUE -- Masternode %s is sending WAY too many dsq messages\n", mnInfo.addr.ToString());
|
|
return;
|
|
}
|
|
}
|
|
|
|
int nThreshold = mnInfo.nLastDsq + mnodeman.CountMasternodes() / 5;
|
|
LogPrint("privatesend", "DSQUEUE -- nLastDsq: %d threshold: %d nDsqCount: %d\n", mnInfo.nLastDsq, nThreshold, mnodeman.nDsqCount);
|
|
//don't allow a few nodes to dominate the queuing process
|
|
if (mnInfo.nLastDsq != 0 && nThreshold > mnodeman.nDsqCount) {
|
|
LogPrint("privatesend", "DSQUEUE -- Masternode %s is sending too many dsq messages\n", mnInfo.addr.ToString());
|
|
return;
|
|
}
|
|
mnodeman.AllowMixing(dsq.masternodeOutpoint);
|
|
|
|
LogPrint("privatesend", "DSQUEUE -- new PrivateSend queue (%s) from masternode %s\n", dsq.ToString(), mnInfo.addr.ToString());
|
|
vecPrivateSendQueue.push_back(dsq);
|
|
dsq.Relay(connman);
|
|
}
|
|
|
|
} else if (strCommand == NetMsgType::DSVIN) {
|
|
if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
|
|
LogPrint("privatesend", "DSVIN -- peer=%d using obsolete version %i\n", pfrom->id, pfrom->nVersion);
|
|
connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE, strprintf("Version must be %d or greater", MIN_PRIVATESEND_PEER_PROTO_VERSION)));
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_VERSION, connman);
|
|
return;
|
|
}
|
|
|
|
//do we have enough users in the current session?
|
|
if (!IsSessionReady()) {
|
|
LogPrintf("DSVIN -- session not complete!\n");
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_SESSION, connman);
|
|
return;
|
|
}
|
|
|
|
CPrivateSendEntry entry;
|
|
vRecv >> entry;
|
|
|
|
LogPrint("privatesend", "DSVIN -- txCollateral %s", entry.txCollateral->ToString());
|
|
|
|
if (entry.vecTxDSIn.size() > PRIVATESEND_ENTRY_MAX_SIZE) {
|
|
LogPrintf("DSVIN -- ERROR: too many inputs! %d/%d\n", entry.vecTxDSIn.size(), PRIVATESEND_ENTRY_MAX_SIZE);
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_MAXIMUM, connman);
|
|
return;
|
|
}
|
|
|
|
if (entry.vecTxOut.size() > PRIVATESEND_ENTRY_MAX_SIZE) {
|
|
LogPrintf("DSVIN -- ERROR: too many outputs! %d/%d\n", entry.vecTxOut.size(), PRIVATESEND_ENTRY_MAX_SIZE);
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_MAXIMUM, connman);
|
|
return;
|
|
}
|
|
|
|
//do we have the same denominations as the current session?
|
|
if (!IsOutputsCompatibleWithSessionDenom(entry.vecTxOut)) {
|
|
LogPrintf("DSVIN -- not compatible with existing transactions!\n");
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_EXISTING_TX, connman);
|
|
return;
|
|
}
|
|
|
|
//check it like a transaction
|
|
{
|
|
CAmount nValueIn = 0;
|
|
CAmount nValueOut = 0;
|
|
|
|
CMutableTransaction tx;
|
|
|
|
for (const auto& txout : entry.vecTxOut) {
|
|
nValueOut += txout.nValue;
|
|
tx.vout.push_back(txout);
|
|
|
|
if (txout.scriptPubKey.size() != 25) {
|
|
LogPrintf("DSVIN -- non-standard pubkey detected! scriptPubKey=%s\n", ScriptToAsmStr(txout.scriptPubKey));
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_NON_STANDARD_PUBKEY, connman);
|
|
return;
|
|
}
|
|
if (!txout.scriptPubKey.IsPayToPublicKeyHash()) {
|
|
LogPrintf("DSVIN -- invalid script! scriptPubKey=%s\n", ScriptToAsmStr(txout.scriptPubKey));
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_INVALID_SCRIPT, connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (const auto& txin : entry.vecTxDSIn) {
|
|
tx.vin.push_back(txin);
|
|
|
|
LogPrint("privatesend", "DSVIN -- txin=%s\n", txin.ToString());
|
|
|
|
Coin coin;
|
|
if (GetUTXOCoin(txin.prevout, coin)) {
|
|
nValueIn += coin.out.nValue;
|
|
} else {
|
|
LogPrintf("DSVIN -- missing input! txin=%s\n", txin.ToString());
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_MISSING_TX, connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// There should be no fee in mixing tx
|
|
CAmount nFee = nValueIn - nValueOut;
|
|
if (nFee != 0) {
|
|
LogPrintf("DSVIN -- there should be no fee in mixing tx! fees: %lld, tx=%s", nFee, tx.ToString());
|
|
PushStatus(pfrom, STATUS_REJECTED, ERR_FEES, connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
PoolMessage nMessageID = MSG_NOERR;
|
|
|
|
entry.addr = pfrom->addr;
|
|
if (AddEntry(entry, nMessageID)) {
|
|
PushStatus(pfrom, STATUS_ACCEPTED, nMessageID, connman);
|
|
CheckPool(connman);
|
|
RelayStatus(STATUS_ACCEPTED, connman);
|
|
} else {
|
|
PushStatus(pfrom, STATUS_REJECTED, nMessageID, connman);
|
|
SetNull();
|
|
}
|
|
|
|
} else if (strCommand == NetMsgType::DSSIGNFINALTX) {
|
|
if (pfrom->nVersion < MIN_PRIVATESEND_PEER_PROTO_VERSION) {
|
|
LogPrint("privatesend", "DSSIGNFINALTX -- peer=%d using obsolete version %i\n", pfrom->id, pfrom->nVersion);
|
|
connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE, strprintf("Version must be %d or greater", MIN_PRIVATESEND_PEER_PROTO_VERSION)));
|
|
return;
|
|
}
|
|
|
|
std::vector<CTxIn> vecTxIn;
|
|
vRecv >> vecTxIn;
|
|
|
|
LogPrint("privatesend", "DSSIGNFINALTX -- vecTxIn.size() %s\n", vecTxIn.size());
|
|
|
|
int nTxInIndex = 0;
|
|
int nTxInsCount = (int)vecTxIn.size();
|
|
|
|
for (const auto& txin : vecTxIn) {
|
|
nTxInIndex++;
|
|
if (!AddScriptSig(txin)) {
|
|
LogPrint("privatesend", "DSSIGNFINALTX -- AddScriptSig() failed at %d/%d, session: %d\n", nTxInIndex, nTxInsCount, nSessionID);
|
|
RelayStatus(STATUS_REJECTED, connman);
|
|
return;
|
|
}
|
|
LogPrint("privatesend", "DSSIGNFINALTX -- AddScriptSig() %d/%d success\n", nTxInIndex, nTxInsCount);
|
|
}
|
|
// all is good
|
|
CheckPool(connman);
|
|
}
|
|
}
|
|
|
|
void CPrivateSendServer::SetNull()
|
|
{
|
|
// MN side
|
|
vecSessionCollaterals.clear();
|
|
|
|
CPrivateSendBaseSession::SetNull();
|
|
CPrivateSendBaseManager::SetNull();
|
|
}
|
|
|
|
//
|
|
// Check the mixing progress and send client updates if a Masternode
|
|
//
|
|
void CPrivateSendServer::CheckPool(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
LogPrint("privatesend", "CPrivateSendServer::CheckPool -- entries count %lu\n", GetEntriesCount());
|
|
|
|
// If entries are full, create finalized transaction
|
|
if (nState == POOL_STATE_ACCEPTING_ENTRIES && GetEntriesCount() >= CPrivateSend::GetMaxPoolTransactions()) {
|
|
LogPrint("privatesend", "CPrivateSendServer::CheckPool -- FINALIZE TRANSACTIONS\n");
|
|
CreateFinalTransaction(connman);
|
|
return;
|
|
}
|
|
|
|
// If we have all of the signatures, try to compile the transaction
|
|
if (nState == POOL_STATE_SIGNING && IsSignaturesComplete()) {
|
|
LogPrint("privatesend", "CPrivateSendServer::CheckPool -- SIGNING\n");
|
|
CommitFinalTransaction(connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CPrivateSendServer::CreateFinalTransaction(CConnman& connman)
|
|
{
|
|
LogPrint("privatesend", "CPrivateSendServer::CreateFinalTransaction -- FINALIZE TRANSACTIONS\n");
|
|
|
|
CMutableTransaction txNew;
|
|
|
|
// make our new transaction
|
|
for (int i = 0; i < GetEntriesCount(); i++) {
|
|
for (const auto& txout : vecEntries[i].vecTxOut)
|
|
txNew.vout.push_back(txout);
|
|
|
|
for (const auto& txdsin : vecEntries[i].vecTxDSIn)
|
|
txNew.vin.push_back(txdsin);
|
|
}
|
|
|
|
sort(txNew.vin.begin(), txNew.vin.end(), CompareInputBIP69());
|
|
sort(txNew.vout.begin(), txNew.vout.end(), CompareOutputBIP69());
|
|
|
|
finalMutableTransaction = txNew;
|
|
LogPrint("privatesend", "CPrivateSendServer::CreateFinalTransaction -- finalMutableTransaction=%s", txNew.ToString());
|
|
|
|
// request signatures from clients
|
|
RelayFinalTransaction(finalMutableTransaction, connman);
|
|
SetState(POOL_STATE_SIGNING);
|
|
}
|
|
|
|
void CPrivateSendServer::CommitFinalTransaction(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return; // check and relay final tx only on masternode
|
|
|
|
CTransactionRef finalTransaction = MakeTransactionRef(finalMutableTransaction);
|
|
uint256 hashTx = finalTransaction->GetHash();
|
|
|
|
LogPrint("privatesend", "CPrivateSendServer::CommitFinalTransaction -- finalTransaction=%s", finalTransaction->ToString());
|
|
|
|
{
|
|
// See if the transaction is valid
|
|
TRY_LOCK(cs_main, lockMain);
|
|
CValidationState validationState;
|
|
mempool.PrioritiseTransaction(hashTx, hashTx.ToString(), 1000, 0.1 * COIN);
|
|
if (!lockMain || !AcceptToMemoryPool(mempool, validationState, finalTransaction, false, NULL, false, maxTxFee, true)) {
|
|
LogPrintf("CPrivateSendServer::CommitFinalTransaction -- AcceptToMemoryPool() error: Transaction not valid\n");
|
|
SetNull();
|
|
// not much we can do in this case, just notify clients
|
|
RelayCompletedTransaction(ERR_INVALID_TX, connman);
|
|
return;
|
|
}
|
|
}
|
|
|
|
LogPrintf("CPrivateSendServer::CommitFinalTransaction -- CREATING DSTX\n");
|
|
|
|
// create and sign masternode dstx transaction
|
|
if (!CPrivateSend::GetDSTX(hashTx)) {
|
|
CPrivateSendBroadcastTx dstxNew(finalTransaction, activeMasternodeInfo.outpoint, GetAdjustedTime());
|
|
dstxNew.Sign();
|
|
CPrivateSend::AddDSTX(dstxNew);
|
|
}
|
|
|
|
LogPrintf("CPrivateSendServer::CommitFinalTransaction -- TRANSMITTING DSTX\n");
|
|
|
|
CInv inv(MSG_DSTX, hashTx);
|
|
connman.RelayInv(inv);
|
|
|
|
// Tell the clients it was successful
|
|
RelayCompletedTransaction(MSG_SUCCESS, connman);
|
|
|
|
// Randomly charge clients
|
|
ChargeRandomFees(connman);
|
|
|
|
// Reset
|
|
LogPrint("privatesend", "CPrivateSendServer::CommitFinalTransaction -- COMPLETED -- RESETTING\n");
|
|
SetNull();
|
|
}
|
|
|
|
//
|
|
// Charge clients a fee if they're abusive
|
|
//
|
|
// Why bother? PrivateSend uses collateral to ensure abuse to the process is kept to a minimum.
|
|
// The submission and signing stages are completely separate. In the cases where
|
|
// a client submits a transaction then refused to sign, there must be a cost. Otherwise they
|
|
// would be able to do this over and over again and bring the mixing to a halt.
|
|
//
|
|
// How does this work? Messages to Masternodes come in via NetMsgType::DSVIN, these require a valid collateral
|
|
// transaction for the client to be able to enter the pool. This transaction is kept by the Masternode
|
|
// until the transaction is either complete or fails.
|
|
//
|
|
void CPrivateSendServer::ChargeFees(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
//we don't need to charge collateral for every offence.
|
|
if (GetRandInt(100) > 33) return;
|
|
|
|
std::vector<CTransactionRef> vecOffendersCollaterals;
|
|
|
|
if (nState == POOL_STATE_ACCEPTING_ENTRIES) {
|
|
for (const auto& txCollateral : vecSessionCollaterals) {
|
|
bool fFound = false;
|
|
for (const auto& entry : vecEntries)
|
|
if (*entry.txCollateral == *txCollateral)
|
|
fFound = true;
|
|
|
|
// This queue entry didn't send us the promised transaction
|
|
if (!fFound) {
|
|
LogPrintf("CPrivateSendServer::ChargeFees -- found uncooperative node (didn't send transaction), found offence\n");
|
|
vecOffendersCollaterals.push_back(txCollateral);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nState == POOL_STATE_SIGNING) {
|
|
// who didn't sign?
|
|
for (const auto& entry : vecEntries) {
|
|
for (const auto& txdsin : entry.vecTxDSIn) {
|
|
if (!txdsin.fHasSig) {
|
|
LogPrintf("CPrivateSendServer::ChargeFees -- found uncooperative node (didn't sign), found offence\n");
|
|
vecOffendersCollaterals.push_back(entry.txCollateral);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// no offences found
|
|
if (vecOffendersCollaterals.empty()) return;
|
|
|
|
//mostly offending? Charge sometimes
|
|
if ((int)vecOffendersCollaterals.size() >= Params().PoolMaxTransactions() - 1 && GetRandInt(100) > 33) return;
|
|
|
|
//everyone is an offender? That's not right
|
|
if ((int)vecOffendersCollaterals.size() >= Params().PoolMaxTransactions()) return;
|
|
|
|
//charge one of the offenders randomly
|
|
std::random_shuffle(vecOffendersCollaterals.begin(), vecOffendersCollaterals.end());
|
|
|
|
if (nState == POOL_STATE_ACCEPTING_ENTRIES || nState == POOL_STATE_SIGNING) {
|
|
LogPrintf("CPrivateSendServer::ChargeFees -- found uncooperative node (didn't %s transaction), charging fees: %s",
|
|
(nState == POOL_STATE_SIGNING) ? "sign" : "send", vecOffendersCollaterals[0]->ToString());
|
|
|
|
LOCK(cs_main);
|
|
|
|
CValidationState state;
|
|
if (!AcceptToMemoryPool(mempool, state, vecOffendersCollaterals[0], false, NULL, false, maxTxFee)) {
|
|
// should never really happen
|
|
LogPrintf("CPrivateSendServer::ChargeFees -- ERROR: AcceptToMemoryPool failed!\n");
|
|
} else {
|
|
connman.RelayTransaction(*vecOffendersCollaterals[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
Charge the collateral randomly.
|
|
Mixing is completely free, to pay miners we randomly pay the collateral of users.
|
|
|
|
Collateral Fee Charges:
|
|
|
|
Being that mixing has "no fees" we need to have some kind of cost associated
|
|
with using it to stop abuse. Otherwise it could serve as an attack vector and
|
|
allow endless transaction that would bloat Dash and make it unusable. To
|
|
stop these kinds of attacks 1 in 10 successful transactions are charged. This
|
|
adds up to a cost of 0.001DRK per transaction on average.
|
|
*/
|
|
void CPrivateSendServer::ChargeRandomFees(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
LOCK(cs_main);
|
|
|
|
for (const auto& txCollateral : vecSessionCollaterals) {
|
|
if (GetRandInt(100) > 10) return;
|
|
LogPrintf("CPrivateSendServer::ChargeRandomFees -- charging random fees, txCollateral=%s", txCollateral->ToString());
|
|
|
|
CValidationState state;
|
|
if (!AcceptToMemoryPool(mempool, state, txCollateral, false, NULL, false, maxTxFee)) {
|
|
// should never really happen
|
|
LogPrintf("CPrivateSendServer::ChargeRandomFees -- ERROR: AcceptToMemoryPool failed!\n");
|
|
} else {
|
|
connman.RelayTransaction(*txCollateral);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check for various timeouts (queue objects, mixing, etc)
|
|
//
|
|
void CPrivateSendServer::CheckTimeout(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
CheckQueue();
|
|
|
|
int nTimeout = (nState == POOL_STATE_SIGNING) ? PRIVATESEND_SIGNING_TIMEOUT : PRIVATESEND_QUEUE_TIMEOUT;
|
|
bool fTimeout = GetTime() - nTimeLastSuccessfulStep >= nTimeout;
|
|
|
|
if (nState != POOL_STATE_IDLE && fTimeout) {
|
|
LogPrint("privatesend", "CPrivateSendServer::CheckTimeout -- %s timed out (%ds) -- resetting\n",
|
|
(nState == POOL_STATE_SIGNING) ? "Signing" : "Session", nTimeout);
|
|
ChargeFees(connman);
|
|
SetNull();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Check to see if we're ready for submissions from clients
|
|
After receiving multiple dsa messages, the queue will switch to "accepting entries"
|
|
which is the active state right before merging the transaction
|
|
*/
|
|
void CPrivateSendServer::CheckForCompleteQueue(CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
if (nState == POOL_STATE_QUEUE && IsSessionReady()) {
|
|
SetState(POOL_STATE_ACCEPTING_ENTRIES);
|
|
|
|
CPrivateSendQueue dsq(nSessionDenom, activeMasternodeInfo.outpoint, GetAdjustedTime(), true);
|
|
LogPrint("privatesend", "CPrivateSendServer::CheckForCompleteQueue -- queue is ready, signing and relaying (%s)\n", dsq.ToString());
|
|
dsq.Sign();
|
|
dsq.Relay(connman);
|
|
}
|
|
}
|
|
|
|
// Check to make sure a given input matches an input in the pool and its scriptSig is valid
|
|
bool CPrivateSendServer::IsInputScriptSigValid(const CTxIn& txin)
|
|
{
|
|
CMutableTransaction txNew;
|
|
txNew.vin.clear();
|
|
txNew.vout.clear();
|
|
|
|
int i = 0;
|
|
int nTxInIndex = -1;
|
|
CScript sigPubKey = CScript();
|
|
|
|
for (const auto& entry : vecEntries) {
|
|
for (const auto& txout : entry.vecTxOut)
|
|
txNew.vout.push_back(txout);
|
|
|
|
for (const auto& txdsin : entry.vecTxDSIn) {
|
|
txNew.vin.push_back(txdsin);
|
|
|
|
if (txdsin.prevout == txin.prevout) {
|
|
nTxInIndex = i;
|
|
sigPubKey = txdsin.prevPubKey;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
if (nTxInIndex >= 0) { //might have to do this one input at a time?
|
|
txNew.vin[nTxInIndex].scriptSig = txin.scriptSig;
|
|
LogPrint("privatesend", "CPrivateSendServer::IsInputScriptSigValid -- verifying scriptSig %s\n", ScriptToAsmStr(txin.scriptSig).substr(0, 24));
|
|
if (!VerifyScript(txNew.vin[nTxInIndex].scriptSig, sigPubKey, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, MutableTransactionSignatureChecker(&txNew, nTxInIndex))) {
|
|
LogPrint("privatesend", "CPrivateSendServer::IsInputScriptSigValid -- VerifyScript() failed on input %d\n", nTxInIndex);
|
|
return false;
|
|
}
|
|
} else {
|
|
LogPrint("privatesend", "CPrivateSendServer::IsInputScriptSigValid -- Failed to find matching input in pool, %s\n", txin.ToString());
|
|
return false;
|
|
}
|
|
|
|
LogPrint("privatesend", "CPrivateSendServer::IsInputScriptSigValid -- Successfully validated input and scriptSig\n");
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Add a clients transaction to the pool
|
|
//
|
|
bool CPrivateSendServer::AddEntry(const CPrivateSendEntry& entryNew, PoolMessage& nMessageIDRet)
|
|
{
|
|
if (!fMasternodeMode) return false;
|
|
|
|
for (const auto& txin : entryNew.vecTxDSIn) {
|
|
if (txin.prevout.IsNull()) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddEntry -- input not valid!\n");
|
|
nMessageIDRet = ERR_INVALID_INPUT;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!CPrivateSend::IsCollateralValid(*entryNew.txCollateral)) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddEntry -- collateral not valid!\n");
|
|
nMessageIDRet = ERR_INVALID_COLLATERAL;
|
|
return false;
|
|
}
|
|
|
|
if (GetEntriesCount() >= CPrivateSend::GetMaxPoolTransactions()) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddEntry -- entries is full!\n");
|
|
nMessageIDRet = ERR_ENTRIES_FULL;
|
|
return false;
|
|
}
|
|
|
|
for (const auto& txin : entryNew.vecTxDSIn) {
|
|
LogPrint("privatesend", "looking for txin -- %s\n", txin.ToString());
|
|
for (const auto& entry : vecEntries) {
|
|
for (const auto& txdsin : entry.vecTxDSIn) {
|
|
if (txdsin.prevout == txin.prevout) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddEntry -- found in txin\n");
|
|
nMessageIDRet = ERR_ALREADY_HAVE;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vecEntries.push_back(entryNew);
|
|
|
|
LogPrint("privatesend", "CPrivateSendServer::AddEntry -- adding entry\n");
|
|
nMessageIDRet = MSG_ENTRIES_ADDED;
|
|
nTimeLastSuccessfulStep = GetTime();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPrivateSendServer::AddScriptSig(const CTxIn& txinNew)
|
|
{
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
|
|
|
|
for (const auto& entry : vecEntries) {
|
|
for (const auto& txdsin : entry.vecTxDSIn) {
|
|
if (txdsin.scriptSig == txinNew.scriptSig) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- already exists\n");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!IsInputScriptSigValid(txinNew)) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- Invalid scriptSig\n");
|
|
return false;
|
|
}
|
|
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- scriptSig=%s new\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
|
|
|
|
for (auto& txin : finalMutableTransaction.vin) {
|
|
if (txin.prevout == txinNew.prevout && txin.nSequence == txinNew.nSequence) {
|
|
txin.scriptSig = txinNew.scriptSig;
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- adding to finalMutableTransaction, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
|
|
}
|
|
}
|
|
for (int i = 0; i < GetEntriesCount(); i++) {
|
|
if (vecEntries[i].AddScriptSig(txinNew)) {
|
|
LogPrint("privatesend", "CPrivateSendServer::AddScriptSig -- adding to entries, scriptSig=%s\n", ScriptToAsmStr(txinNew.scriptSig).substr(0, 24));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
LogPrintf("CPrivateSendServer::AddScriptSig -- Couldn't set sig!\n");
|
|
return false;
|
|
}
|
|
|
|
// Check to make sure everything is signed
|
|
bool CPrivateSendServer::IsSignaturesComplete()
|
|
{
|
|
for (const auto& entry : vecEntries)
|
|
for (const auto& txdsin : entry.vecTxDSIn)
|
|
if (!txdsin.fHasSig) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPrivateSendServer::IsOutputsCompatibleWithSessionDenom(const std::vector<CTxOut>& vecTxOut)
|
|
{
|
|
if (CPrivateSend::GetDenominations(vecTxOut) == 0) return false;
|
|
|
|
for (const auto& entry : vecEntries) {
|
|
LogPrintf("CPrivateSendServer::IsOutputsCompatibleWithSessionDenom -- vecTxOut denom %d, entry.vecTxOut denom %d\n",
|
|
CPrivateSend::GetDenominations(vecTxOut), CPrivateSend::GetDenominations(entry.vecTxOut));
|
|
if (CPrivateSend::GetDenominations(vecTxOut) != CPrivateSend::GetDenominations(entry.vecTxOut)) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPrivateSendServer::IsAcceptableDSA(const CPrivateSendAccept& dsa, PoolMessage& nMessageIDRet)
|
|
{
|
|
if (!fMasternodeMode) return false;
|
|
|
|
// is denom even smth legit?
|
|
std::vector<int> vecBits;
|
|
if (!CPrivateSend::GetDenominationsBits(dsa.nDenom, vecBits)) {
|
|
LogPrint("privatesend", "CPrivateSendServer::%s -- denom not valid!\n", __func__);
|
|
nMessageIDRet = ERR_DENOM;
|
|
return false;
|
|
}
|
|
|
|
// check collateral
|
|
if (!fUnitTest && !CPrivateSend::IsCollateralValid(dsa.txCollateral)) {
|
|
LogPrint("privatesend", "CPrivateSendServer::%s -- collateral not valid!\n", __func__);
|
|
nMessageIDRet = ERR_INVALID_COLLATERAL;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPrivateSendServer::CreateNewSession(const CPrivateSendAccept& dsa, PoolMessage& nMessageIDRet, CConnman& connman)
|
|
{
|
|
if (!fMasternodeMode || nSessionID != 0) return false;
|
|
|
|
// new session can only be started in idle mode
|
|
if (nState != POOL_STATE_IDLE) {
|
|
nMessageIDRet = ERR_MODE;
|
|
LogPrintf("CPrivateSendServer::CreateNewSession -- incompatible mode: nState=%d\n", nState);
|
|
return false;
|
|
}
|
|
|
|
if (!IsAcceptableDSA(dsa, nMessageIDRet)) {
|
|
return false;
|
|
}
|
|
|
|
// start new session
|
|
nMessageIDRet = MSG_NOERR;
|
|
nSessionID = GetRandInt(999999) + 1;
|
|
nSessionDenom = dsa.nDenom;
|
|
|
|
SetState(POOL_STATE_QUEUE);
|
|
nTimeLastSuccessfulStep = GetTime();
|
|
|
|
if (!fUnitTest) {
|
|
//broadcast that I'm accepting entries, only if it's the first entry through
|
|
CPrivateSendQueue dsq(nSessionDenom, activeMasternodeInfo.outpoint, GetAdjustedTime(), false);
|
|
LogPrint("privatesend", "CPrivateSendServer::CreateNewSession -- signing and relaying new queue: %s\n", dsq.ToString());
|
|
dsq.Sign();
|
|
dsq.Relay(connman);
|
|
vecPrivateSendQueue.push_back(dsq);
|
|
}
|
|
|
|
vecSessionCollaterals.push_back(MakeTransactionRef(dsa.txCollateral));
|
|
LogPrintf("CPrivateSendServer::CreateNewSession -- new session created, nSessionID: %d nSessionDenom: %d (%s) vecSessionCollaterals.size(): %d\n",
|
|
nSessionID, nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom), vecSessionCollaterals.size());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPrivateSendServer::AddUserToExistingSession(const CPrivateSendAccept& dsa, PoolMessage& nMessageIDRet)
|
|
{
|
|
if (!fMasternodeMode || nSessionID == 0 || IsSessionReady()) return false;
|
|
|
|
if (!IsAcceptableDSA(dsa, nMessageIDRet)) {
|
|
return false;
|
|
}
|
|
|
|
// we only add new users to an existing session when we are in queue mode
|
|
if (nState != POOL_STATE_QUEUE) {
|
|
nMessageIDRet = ERR_MODE;
|
|
LogPrintf("CPrivateSendServer::AddUserToExistingSession -- incompatible mode: nState=%d\n", nState);
|
|
return false;
|
|
}
|
|
|
|
if (dsa.nDenom != nSessionDenom) {
|
|
LogPrintf("CPrivateSendServer::AddUserToExistingSession -- incompatible denom %d (%s) != nSessionDenom %d (%s)\n",
|
|
dsa.nDenom, CPrivateSend::GetDenominationsToString(dsa.nDenom), nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom));
|
|
nMessageIDRet = ERR_DENOM;
|
|
return false;
|
|
}
|
|
|
|
// count new user as accepted to an existing session
|
|
|
|
nMessageIDRet = MSG_NOERR;
|
|
nTimeLastSuccessfulStep = GetTime();
|
|
vecSessionCollaterals.push_back(MakeTransactionRef(dsa.txCollateral));
|
|
|
|
LogPrintf("CPrivateSendServer::AddUserToExistingSession -- new user accepted, nSessionID: %d nSessionDenom: %d (%s) vecSessionCollaterals.size(): %d\n",
|
|
nSessionID, nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom), vecSessionCollaterals.size());
|
|
|
|
return true;
|
|
}
|
|
|
|
void CPrivateSendServer::RelayFinalTransaction(const CTransaction& txFinal, CConnman& connman)
|
|
{
|
|
LogPrint("privatesend", "CPrivateSendServer::%s -- nSessionID: %d nSessionDenom: %d (%s)\n",
|
|
__func__, nSessionID, nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom));
|
|
|
|
// final mixing tx with empty signatures should be relayed to mixing participants only
|
|
for (const auto entry : vecEntries) {
|
|
bool fOk = connman.ForNode(entry.addr, [&txFinal, &connman, this](CNode* pnode) {
|
|
CNetMsgMaker msgMaker(pnode->GetSendVersion());
|
|
connman.PushMessage(pnode, msgMaker.Make(NetMsgType::DSFINALTX, nSessionID, txFinal));
|
|
return true;
|
|
});
|
|
if (!fOk) {
|
|
// no such node? maybe this client disconnected or our own connection went down
|
|
RelayStatus(STATUS_REJECTED, connman);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPrivateSendServer::PushStatus(CNode* pnode, PoolStatusUpdate nStatusUpdate, PoolMessage nMessageID, CConnman& connman)
|
|
{
|
|
if (!pnode) return;
|
|
CNetMsgMaker msgMaker(pnode->GetSendVersion());
|
|
connman.PushMessage(pnode, msgMaker.Make(NetMsgType::DSSTATUSUPDATE, nSessionID, (int)nState, (int)vecEntries.size(), (int)nStatusUpdate, (int)nMessageID));
|
|
}
|
|
|
|
void CPrivateSendServer::RelayStatus(PoolStatusUpdate nStatusUpdate, CConnman& connman, PoolMessage nMessageID)
|
|
{
|
|
unsigned int nDisconnected{};
|
|
// status updates should be relayed to mixing participants only
|
|
for (const auto entry : vecEntries) {
|
|
// make sure everyone is still connected
|
|
bool fOk = connman.ForNode(entry.addr, [&nStatusUpdate, &nMessageID, &connman, this](CNode* pnode) {
|
|
PushStatus(pnode, nStatusUpdate, nMessageID, connman);
|
|
return true;
|
|
});
|
|
if (!fOk) {
|
|
// no such node? maybe this client disconnected or our own connection went down
|
|
++nDisconnected;
|
|
}
|
|
}
|
|
if (nDisconnected == 0) return; // all is clear
|
|
|
|
// smth went wrong
|
|
LogPrintf("CPrivateSendServer::%s -- can't continue, %llu client(s) disconnected, nSessionID: %d nSessionDenom: %d (%s)\n",
|
|
__func__, nDisconnected, nSessionID, nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom));
|
|
|
|
// notify everyone else that this session should be terminated
|
|
for (const auto& entry : vecEntries) {
|
|
connman.ForNode(entry.addr, [&connman, this](CNode* pnode) {
|
|
PushStatus(pnode, STATUS_REJECTED, MSG_NOERR, connman);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
if (nDisconnected == vecEntries.size()) {
|
|
// all clients disconnected, there is probably some issues with our own connection
|
|
// do not charge any fees, just reset the pool
|
|
SetNull();
|
|
}
|
|
}
|
|
|
|
void CPrivateSendServer::RelayCompletedTransaction(PoolMessage nMessageID, CConnman& connman)
|
|
{
|
|
LogPrint("privatesend", "CPrivateSendServer::%s -- nSessionID: %d nSessionDenom: %d (%s)\n",
|
|
__func__, nSessionID, nSessionDenom, CPrivateSend::GetDenominationsToString(nSessionDenom));
|
|
|
|
// final mixing tx with empty signatures should be relayed to mixing participants only
|
|
for (const auto& entry : vecEntries) {
|
|
bool fOk = connman.ForNode(entry.addr, [&nMessageID, &connman, this](CNode* pnode) {
|
|
CNetMsgMaker msgMaker(pnode->GetSendVersion());
|
|
connman.PushMessage(pnode, msgMaker.Make(NetMsgType::DSCOMPLETE, nSessionID, (int)nMessageID));
|
|
return true;
|
|
});
|
|
if (!fOk) {
|
|
// no such node? maybe client disconnected or our own connection went down
|
|
RelayStatus(STATUS_REJECTED, connman);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CPrivateSendServer::SetState(PoolState nStateNew)
|
|
{
|
|
if (!fMasternodeMode) return;
|
|
|
|
if (nStateNew == POOL_STATE_ERROR || nStateNew == POOL_STATE_SUCCESS) {
|
|
LogPrint("privatesend", "CPrivateSendServer::SetState -- Can't set state to ERROR or SUCCESS as a Masternode. \n");
|
|
return;
|
|
}
|
|
|
|
LogPrintf("CPrivateSendServer::SetState -- nState: %d, nStateNew: %d\n", nState, nStateNew);
|
|
nState = nStateNew;
|
|
}
|
|
|
|
void CPrivateSendServer::DoMaintenance(CConnman& connman)
|
|
{
|
|
if (fLiteMode) return; // disable all Dash specific functionality
|
|
if (!fMasternodeMode) return; // only run on masternodes
|
|
|
|
if (!masternodeSync.IsBlockchainSynced() || ShutdownRequested())
|
|
return;
|
|
|
|
privateSendServer.CheckTimeout(connman);
|
|
privateSendServer.CheckForCompleteQueue(connman);
|
|
}
|