sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-28 05:23:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
6e229e16ff
dash/src/darksend.cpp
UdjinM6 6e229e16ff DS fixes: 
- detect denominated but not yet anonymized balance properly or both (GetAnonymizableBalance)
 - fix progress calculation by using GetAnonymizableBalance
 - do not count MN-like inputs as anonymizable
 - denominate faster: if there is enough new inputs after DS started (their sum is greater then "already denominated but not yet anonymized balance")
 - allow small amounts to be used in CreateDenominated (modified SelectCoinsDark) but only if they are larger then 1 CENT
 - do not use collateral inputs in CreateDenominated (modified SelectCoinsDark)
 - convert some int64_t -> CAmount for money related variables/params
2015-05-02 19:18:20 +03:00

2311 lines
81 KiB
C++
Raw Blame History

// Copyright (c) 2014-2015 The Dash developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "darksend.h"
#include "main.h"
#include "init.h"
#include "util.h"
#include "masternodeman.h"
#include "script/sign.h"
#include "instantx.h"
#include "ui_interface.h"
#include <boost/algorithm/string/replace.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <boost/assign/list_of.hpp>
#include <openssl/rand.h>
using namespace std;
using namespace boost;
CCriticalSection cs_darksend;
// The main object for accessing Darksend
CDarksendPool darkSendPool;
// A helper object for signing messages from Masternodes
CDarkSendSigner darkSendSigner;
// The current Darksends in progress on the network
std::vector<CDarksendQueue> vecDarksendQueue;
// Keep track of the used Masternodes
std::vector<CTxIn> vecMasternodesUsed;
// Keep track of the scanning errors I've seen
map<uint256, CDarksendBroadcastTx> mapDarksendBroadcastTxes;
// Keep track of the active Masternode
CActiveMasternode activeMasternode;
// Count peers we've requested the list from
int RequestedMasterNodeList = 0;
/* *** BEGIN DARKSEND MAGIC - DASH **********
Copyright (c) 2014-2015, Dash Developers
eduffield - evan@dashpay.io
udjinm6 - udjinm6@dashpay.io
*/
void CDarksendPool::ProcessMessageDarksend(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
{
if(fLiteMode) return; //disable all Darksend/Masternode related functionality
if(IsInitialBlockDownload()) return;
if (strCommand == "dsa") { //Darksend Accept Into Pool
int errorID;
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
errorID = ERR_VERSION;
LogPrintf("dsa -- incompatible version! \n");
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(!fMasterNode){
errorID = ERR_NOT_A_MN;
LogPrintf("dsa -- not a Masternode! \n");
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
int nDenom;
CTransaction txCollateral;
vRecv >> nDenom >> txCollateral;
CMasternode* pmn = mnodeman.Find(activeMasternode.vin);
if(pmn == NULL)
{
errorID = ERR_MN_LIST;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(sessionUsers == 0) {
if(pmn->nLastDsq != 0 &&
pmn->nLastDsq + mnodeman.CountMasternodesAboveProtocol(MIN_POOL_PEER_PROTO_VERSION)/5 > mnodeman.nDsqCount){
LogPrintf("dsa -- last dsq too recent, must wait. %s \n", pfrom->addr.ToString().c_str());
errorID = ERR_RECENT;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
}
if(!IsCompatibleWithSession(nDenom, txCollateral, errorID))
{
LogPrintf("dsa -- not compatible with existing transactions! \n");
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
} else {
LogPrintf("dsa -- is compatible, please submit! \n");
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_ACCEPTED, errorID);
return;
}
} else if (strCommand == "dsq") { //Darksend Queue
TRY_LOCK(cs_darksend, lockRecv);
if(!lockRecv) return;
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
return;
}
CDarksendQueue dsq;
vRecv >> dsq;
CService addr;
if(!dsq.GetAddress(addr)) return;
if(!dsq.CheckSignature()) return;
if(dsq.IsExpired()) return;
CMasternode* pmn = mnodeman.Find(dsq.vin);
if(pmn == NULL) return;
// if the queue is ready, submit if we can
if(dsq.ready) {
if(!pSubmittedToMasternode) return;
if((CNetAddr)pSubmittedToMasternode->addr != (CNetAddr)addr){
LogPrintf("dsq - message doesn't match current Masternode - %s != %s\n", pSubmittedToMasternode->addr.ToString().c_str(), addr.ToString().c_str());
return;
}
if(state == POOL_STATUS_QUEUE){
if (fDebug) LogPrintf("Darksend queue is ready - %s\n", addr.ToString().c_str());
PrepareDarksendDenominate();
}
} else {
BOOST_FOREACH(CDarksendQueue q, vecDarksendQueue){
if(q.vin == dsq.vin) return;
}
if(fDebug) LogPrintf("dsq last %d last2 %d count %d\n", pmn->nLastDsq, pmn->nLastDsq + mnodeman.size()/5, mnodeman.nDsqCount);
//don't allow a few nodes to dominate the queuing process
if(pmn->nLastDsq != 0 &&
pmn->nLastDsq + mnodeman.CountMasternodesAboveProtocol(MIN_POOL_PEER_PROTO_VERSION)/5 > mnodeman.nDsqCount){
if(fDebug) LogPrintf("dsq -- Masternode sending too many dsq messages. %s \n", pmn->addr.ToString().c_str());
return;
}
mnodeman.nDsqCount++;
pmn->nLastDsq = mnodeman.nDsqCount;
pmn->allowFreeTx = true;
if(fDebug) LogPrintf("dsq - new Darksend queue object - %s\n", addr.ToString().c_str());
vecDarksendQueue.push_back(dsq);
dsq.Relay();
dsq.time = GetTime();
}
} else if (strCommand == "dsi") { //DarkSend vIn
int errorID = MSG_NOERR;
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
LogPrintf("dsi -- incompatible version! \n");
errorID = ERR_VERSION;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(!fMasterNode){
LogPrintf("dsi -- not a Masternode! \n");
errorID = ERR_NOT_A_MN;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
std::vector<CTxIn> in;
int64_t nAmount;
CTransaction txCollateral;
std::vector<CTxOut> out;
vRecv >> in >> nAmount >> txCollateral >> out;
//do we have enough users in the current session?
if(!IsSessionReady()){
LogPrintf("dsi -- session not complete! \n");
errorID = ERR_SESSION;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
//do we have the same denominations as the current session?
if(!IsCompatibleWithEntries(out))
{
LogPrintf("dsi -- not compatible with existing transactions! \n");
errorID = ERR_EXISTING_TX;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
//check it like a transaction
{
int64_t nValueIn = 0;
int64_t nValueOut = 0;
bool missingTx = false;
CValidationState state;
CMutableTransaction tx;
BOOST_FOREACH(const CTxOut o, out){
nValueOut += o.nValue;
tx.vout.push_back(o);
if(o.scriptPubKey.size() != 25){
LogPrintf("dsi - non-standard pubkey detected! %s\n", o.scriptPubKey.ToString().c_str());
errorID = ERR_NON_STANDARD_PUBKEY;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(!o.scriptPubKey.IsNormalPaymentScript()){
LogPrintf("dsi - invalid script! %s\n", o.scriptPubKey.ToString().c_str());
errorID = ERR_INVALID_SCRIPT;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
}
BOOST_FOREACH(const CTxIn i, in){
tx.vin.push_back(i);
if(fDebug) LogPrintf("dsi -- tx in %s\n", i.ToString().c_str());
CTransaction tx2;
uint256 hash;
if(GetTransaction(i.prevout.hash, tx2, hash, true)){
if(tx2.vout.size() > i.prevout.n) {
nValueIn += tx2.vout[i.prevout.n].nValue;
}
} else{
missingTx = true;
}
}
if (nValueIn > DARKSEND_POOL_MAX) {
LogPrintf("dsi -- more than Darksend pool max! %s\n", tx.ToString().c_str());
errorID = ERR_MAXIMUM;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(!missingTx){
if (nValueIn-nValueOut > nValueIn*.01) {
LogPrintf("dsi -- fees are too high! %s\n", tx.ToString().c_str());
errorID = ERR_FEES;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
} else {
LogPrintf("dsi -- missing input tx! %s\n", tx.ToString().c_str());
errorID = ERR_MISSING_TX;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
if(!AcceptableInputs(mempool, state, CTransaction(tx), false, NULL)) {
LogPrintf("dsi -- transaction not valid! \n");
errorID = ERR_INVALID_TX;
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
return;
}
}
if(AddEntry(in, nAmount, txCollateral, out, errorID)){
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_ACCEPTED, errorID);
Check();
RelayStatus(sessionID, GetState(), GetEntriesCount(), MASTERNODE_RESET);
} else {
pfrom->PushMessage("dssu", sessionID, GetState(), GetEntriesCount(), MASTERNODE_REJECTED, errorID);
}
} else if (strCommand == "dssu") { //Darksend status update
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
return;
}
if(!pSubmittedToMasternode) return;
if((CNetAddr)pSubmittedToMasternode->addr != (CNetAddr)pfrom->addr){
//LogPrintf("dssu - message doesn't match current Masternode - %s != %s\n", pSubmittedToMasternode->addr.ToString().c_str(), pfrom->addr.ToString().c_str());
return;
}
int sessionIDMessage;
int state;
int entriesCount;
int accepted;
int errorID;
vRecv >> sessionIDMessage >> state >> entriesCount >> accepted >> errorID;
if(fDebug) LogPrintf("dssu - state: %i entriesCount: %i accepted: %i error: %s \n", state, entriesCount, accepted, GetMessageByID(errorID).c_str());
if((accepted != 1 && accepted != 0) && sessionID != sessionIDMessage){
LogPrintf("dssu - message doesn't match current Darksend session %d %d\n", sessionID, sessionIDMessage);
return;
}
StatusUpdate(state, entriesCount, accepted, errorID, sessionIDMessage);
} else if (strCommand == "dss") { //Darksend Sign Final Tx
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
return;
}
vector<CTxIn> sigs;
vRecv >> sigs;
bool success = false;
int count = 0;
BOOST_FOREACH(const CTxIn item, sigs)
{
if(AddScriptSig(item)) success = true;
if(fDebug) LogPrintf(" -- sigs count %d %d\n", (int)sigs.size(), count);
count++;
}
if(success){
darkSendPool.Check();
RelayStatus(darkSendPool.sessionID, darkSendPool.GetState(), darkSendPool.GetEntriesCount(), MASTERNODE_RESET);
}
} else if (strCommand == "dsf") { //Darksend Final tx
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
return;
}
if(!pSubmittedToMasternode) return;
if((CNetAddr)pSubmittedToMasternode->addr != (CNetAddr)pfrom->addr){
//LogPrintf("dsc - message doesn't match current Masternode - %s != %s\n", pSubmittedToMasternode->addr.ToString().c_str(), pfrom->addr.ToString().c_str());
return;
}
int sessionIDMessage;
CTransaction txNew;
vRecv >> sessionIDMessage >> txNew;
if(sessionID != sessionIDMessage){
if (fDebug) LogPrintf("dsf - message doesn't match current Darksend session %d %d\n", sessionID, sessionIDMessage);
return;
}
//check to see if input is spent already? (and probably not confirmed)
SignFinalTransaction(txNew, pfrom);
} else if (strCommand == "dsc") { //Darksend Complete
if (pfrom->nVersion < MIN_POOL_PEER_PROTO_VERSION) {
return;
}
if(!pSubmittedToMasternode) return;
if((CNetAddr)pSubmittedToMasternode->addr != (CNetAddr)pfrom->addr){
//LogPrintf("dsc - message doesn't match current Masternode - %s != %s\n", pSubmittedToMasternode->addr.ToString().c_str(), pfrom->addr.ToString().c_str());
return;
}
int sessionIDMessage;
bool error;
std::string lastMessage;
vRecv >> sessionIDMessage >> error >> lastMessage;
if(sessionID != sessionIDMessage){
if (fDebug) LogPrintf("dsc - message doesn't match current Darksend session %d %d\n", darkSendPool.sessionID, sessionIDMessage);
return;
}
darkSendPool.CompletedTransaction(error, lastMessage);
}
}
int randomizeList (int i) { return std::rand()%i;}
// Recursively determine the rounds of a given input (How deep is the Darksend chain for a given input)
int GetInputDarksendRounds(CTxIn in, int rounds)
{
static std::map<uint256, CMutableTransaction> mDenomWtxes;
if(rounds >= 17) return rounds;
uint256 hash = in.prevout.hash;
unsigned int nout = in.prevout.n;
CWalletTx wtx;
if(pwalletMain->GetTransaction(hash, wtx))
{
std::map<uint256, CMutableTransaction>::const_iterator mdwi = mDenomWtxes.find(hash);
// not known yet, let's add it
if(mdwi == mDenomWtxes.end())
{
if(fDebug) LogPrintf("GetInputDarksendRounds INSERTING %s\n", hash.ToString());
mDenomWtxes[hash] = CMutableTransaction(wtx);
}
// found and it's not an initial value, just return it
else if(mDenomWtxes[hash].vout[nout].nRounds != -10)
{
return mDenomWtxes[hash].vout[nout].nRounds;
}
// bounds check
if(nout >= wtx.vout.size())
{
// should never actually hit this
if(fDebug) LogPrintf("GetInputDarksendRounds UPDATED %s %3d %d\n", hash.ToString(), nout, -4);
return -4;
}
if(pwalletMain->IsCollateralAmount(wtx.vout[nout].nValue))
{
mDenomWtxes[hash].vout[nout].nRounds = -3;
if(fDebug) LogPrintf("GetInputDarksendRounds UPDATED %s %3d %d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
return mDenomWtxes[hash].vout[nout].nRounds;
}
//make sure the final output is non-denominate
if(/*rounds == 0 && */!pwalletMain->IsDenominatedAmount(wtx.vout[nout].nValue)) //NOT DENOM
{
mDenomWtxes[hash].vout[nout].nRounds = -2;
if(fDebug) LogPrintf("GetInputDarksendRounds UPDATED %s %3d %d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
return mDenomWtxes[hash].vout[nout].nRounds;
}
bool fAllDenoms = true;
BOOST_FOREACH(CTxOut out, wtx.vout)
{
fAllDenoms = fAllDenoms && pwalletMain->IsDenominatedAmount(out.nValue);
}
// this one is denominated but there is another non-denominated output found in the same tx
if(!fAllDenoms)
{
mDenomWtxes[hash].vout[nout].nRounds = 0;
if(fDebug) LogPrintf("GetInputDarksendRounds UPDATED %s %3d %d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
return mDenomWtxes[hash].vout[nout].nRounds;
}
int nShortest = -10; // an initial value, should be no way to get this by calculations
bool fDenomFound = false;
// only denoms here so let's look up
BOOST_FOREACH(CTxIn in2, wtx.vin)
{
if(pwalletMain->IsMine(in2))
{
int n = GetInputDarksendRounds(in2, rounds+1);
// denom found, find the shortest chain or initially assign nShortest with the first found value
if(n >= 0 && (n < nShortest || nShortest == -10))
{
nShortest = n;
fDenomFound = true;
}
}
}
mDenomWtxes[hash].vout[nout].nRounds = fDenomFound
? nShortest + 1 // good, we a +1 to the shortest one
: 0; // too bad, we are the fist one in that chain
if(fDebug) LogPrintf("GetInputDarksendRounds UPDATED %s %3d %d\n", hash.ToString(), nout, mDenomWtxes[hash].vout[nout].nRounds);
return mDenomWtxes[hash].vout[nout].nRounds;
}
return rounds-1;
}
void CDarksendPool::Reset(){
cachedLastSuccess = 0;
vecMasternodesUsed.clear();
UnlockCoins();
SetNull();
}
void CDarksendPool::SetNull(bool clearEverything){
finalTransaction.vin.clear();
finalTransaction.vout.clear();
entries.clear();
state = POOL_STATUS_IDLE;
lastTimeChanged = GetTimeMillis();
entriesCount = 0;
lastEntryAccepted = 0;
countEntriesAccepted = 0;
lastNewBlock = 0;
sessionUsers = 0;
sessionDenom = 0;
sessionFoundMasternode = false;
vecSessionCollateral.clear();
txCollateral = CMutableTransaction();
if(clearEverything){
myEntries.clear();
sessionID = 0;
}
// -- seed random number generator (used for ordering output lists)
unsigned int seed = 0;
RAND_bytes((unsigned char*)&seed, sizeof(seed));
std::srand(seed);
}
bool CDarksendPool::SetCollateralAddress(std::string strAddress){
CBitcoinAddress address;
if (!address.SetString(strAddress))
{
LogPrintf("CDarksendPool::SetCollateralAddress - Invalid Darksend collateral address\n");
return false;
}
collateralPubKey = GetScriptForDestination(address.Get());
return true;
}
//
// Unlock coins after Darksend fails or succeeds
//
void CDarksendPool::UnlockCoins(){
BOOST_FOREACH(CTxIn v, lockedCoins)
pwalletMain->UnlockCoin(v.prevout);
lockedCoins.clear();
}
//
// Check the Darksend progress and send client updates if a Masternode
//
void CDarksendPool::Check()
{
if(fDebug && fMasterNode) LogPrintf("CDarksendPool::Check() - entries count %lu\n", entries.size());
//printf("CDarksendPool::Check() %d - %d - %d\n", state, anonTx.CountEntries(), GetTimeMillis()-lastTimeChanged);
// If entries is full, then move on to the next phase
if(state == POOL_STATUS_ACCEPTING_ENTRIES && (int)entries.size() >= GetMaxPoolTransactions())
{
if(fDebug) LogPrintf("CDarksendPool::Check() -- TRYING TRANSACTION \n");
UpdateState(POOL_STATUS_FINALIZE_TRANSACTION);
}
// create the finalized transaction for distribution to the clients
if(state == POOL_STATUS_FINALIZE_TRANSACTION) {
if(fDebug) LogPrintf("CDarksendPool::Check() -- FINALIZE TRANSACTIONS\n");
UpdateState(POOL_STATUS_SIGNING);
if (fMasterNode) {
CMutableTransaction txNew;
// make our new transaction
for(unsigned int i = 0; i < entries.size(); i++){
BOOST_FOREACH(const CTxOut& v, entries[i].vout)
txNew.vout.push_back(v);
BOOST_FOREACH(const CTxDSIn& s, entries[i].sev)
txNew.vin.push_back(s);
}
// shuffle the outputs for improved anonymity
std::random_shuffle ( txNew.vin.begin(), txNew.vin.end(), randomizeList);
std::random_shuffle ( txNew.vout.begin(), txNew.vout.end(), randomizeList);
if(fDebug) LogPrintf("Transaction 1: %s\n", txNew.ToString().c_str());
finalTransaction = txNew;
// request signatures from clients
RelayFinalTransaction(sessionID, finalTransaction);
}
}
// If we have all of the signatures, try to compile the transaction
if(state == POOL_STATUS_SIGNING && SignaturesComplete()) {
if(fDebug) LogPrintf("CDarksendPool::Check() -- SIGNING\n");
UpdateState(POOL_STATUS_TRANSMISSION);
CheckFinalTransaction();
}
// reset if we're here for 10 seconds
if((state == POOL_STATUS_ERROR || state == POOL_STATUS_SUCCESS) && GetTimeMillis()-lastTimeChanged >= 10000) {
if(fDebug) LogPrintf("CDarksendPool::Check() -- RESETTING MESSAGE \n");
SetNull(true);
if(fMasterNode) RelayStatus(darkSendPool.sessionID, darkSendPool.GetState(), darkSendPool.GetEntriesCount(), MASTERNODE_RESET);
UnlockCoins();
}
}
void CDarksendPool::CheckFinalTransaction()
{
CWalletTx txNew = CWalletTx(pwalletMain, finalTransaction);
LOCK2(cs_main, pwalletMain->cs_wallet);
{
if (fMasterNode) { //only the main node is master atm
if(fDebug) LogPrintf("Transaction 2: %s\n", txNew.ToString().c_str());
// See if the transaction is valid
if (!txNew.AcceptToMemoryPool(false))
{
LogPrintf("CDarksendPool::Check() - CommitTransaction : Error: Transaction not valid\n");
SetNull();
pwalletMain->Lock();
// not much we can do in this case
UpdateState(POOL_STATUS_ACCEPTING_ENTRIES);
RelayCompletedTransaction(sessionID, true, ERR_INVALID_TX);
return;
}
LogPrintf("CDarksendPool::Check() -- IS MASTER -- TRANSMITTING DARKSEND\n");
// sign a message
int64_t sigTime = GetAdjustedTime();
std::string strMessage = txNew.GetHash().ToString() + boost::lexical_cast<std::string>(sigTime);
std::string strError = "";
std::vector<unsigned char> vchSig;
CKey key2;
CPubKey pubkey2;
if(!darkSendSigner.SetKey(strMasterNodePrivKey, strError, key2, pubkey2))
{
LogPrintf("CDarksendPool::Check() - ERROR: Invalid Masternodeprivkey: '%s'\n", strError.c_str());
return;
}
if(!darkSendSigner.SignMessage(strMessage, strError, vchSig, key2)) {
LogPrintf("CDarksendPool::Check() - Sign message failed\n");
return;
}
if(!darkSendSigner.VerifyMessage(pubkey2, vchSig, strMessage, strError)) {
LogPrintf("CDarksendPool::Check() - Verify message failed\n");
return;
}
if(!mapDarksendBroadcastTxes.count(txNew.GetHash())){
CDarksendBroadcastTx dstx;
dstx.tx = txNew;
dstx.vin = activeMasternode.vin;
dstx.vchSig = vchSig;
dstx.sigTime = sigTime;
mapDarksendBroadcastTxes.insert(make_pair(txNew.GetHash(), dstx));
}
// Broadcast the transaction to the network
txNew.fTimeReceivedIsTxTime = true;
txNew.RelayWalletTransaction();
// Tell the clients it was successful
RelayCompletedTransaction(sessionID, false, MSG_SUCCESS);
// Randomly charge clients
ChargeRandomFees();
// Reset
if(fDebug) LogPrintf("CDarksendPool::Check() -- COMPLETED -- RESETTING \n");
SetNull(true);
UnlockCoins();
if(fMasterNode) RelayStatus(darkSendPool.sessionID, darkSendPool.GetState(), darkSendPool.GetEntriesCount(), MASTERNODE_RESET);
pwalletMain->Lock();
}
}
}
//
// Charge clients a fee if they're abusive
//
// Why bother? Darksend uses collateral to ensure abuse to the process is kept to a minimum.
// The submission and signing stages in Darksend 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 hault.
//
// How does this work? Messages to Masternodes come in via "dsi", 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 CDarksendPool::ChargeFees(){
if(fMasterNode) {
//we don't need to charge collateral for every offence.
int offences = 0;
int r = rand()%100;
if(r > 33) return;
if(state == POOL_STATUS_ACCEPTING_ENTRIES){
BOOST_FOREACH(const CTransaction& txCollateral, vecSessionCollateral) {
bool found = false;
BOOST_FOREACH(const CDarkSendEntry& v, entries) {
if(v.collateral == txCollateral) {
found = true;
}
}
// This queue entry didn't send us the promised transaction
if(!found){
LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't send transaction). Found offence.\n");
offences++;
}
}
}
if(state == POOL_STATUS_SIGNING) {
// who didn't sign?
BOOST_FOREACH(const CDarkSendEntry v, entries) {
BOOST_FOREACH(const CTxDSIn s, v.sev) {
if(!s.fHasSig){
LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't sign). Found offence\n");
offences++;
}
}
}
}
r = rand()%100;
int target = 0;
//mostly offending?
if(offences >= Params().PoolMaxTransactions()-1 && r > 33) return;
//everyone is an offender? That's not right
if(offences >= Params().PoolMaxTransactions()) return;
//charge one of the offenders randomly
if(offences > 1) target = 50;
//pick random client to charge
r = rand()%100;
if(state == POOL_STATUS_ACCEPTING_ENTRIES){
BOOST_FOREACH(const CTransaction& txCollateral, vecSessionCollateral) {
bool found = false;
BOOST_FOREACH(const CDarkSendEntry& v, entries) {
if(v.collateral == txCollateral) {
found = true;
}
}
// This queue entry didn't send us the promised transaction
if(!found && r > target){
LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't send transaction). charging fees.\n");
CWalletTx wtxCollateral = CWalletTx(pwalletMain, txCollateral);
// Broadcast
if (!wtxCollateral.AcceptToMemoryPool(true))
{
// This must not fail. The transaction has already been signed and recorded.
LogPrintf("CDarksendPool::ChargeFees() : Error: Transaction not valid");
}
wtxCollateral.RelayWalletTransaction();
return;
}
}
}
if(state == POOL_STATUS_SIGNING) {
// who didn't sign?
BOOST_FOREACH(const CDarkSendEntry v, entries) {
BOOST_FOREACH(const CTxDSIn s, v.sev) {
if(!s.fHasSig && r > target){
LogPrintf("CDarksendPool::ChargeFees -- found uncooperative node (didn't sign). charging fees.\n");
CWalletTx wtxCollateral = CWalletTx(pwalletMain, v.collateral);
// Broadcast
if (!wtxCollateral.AcceptToMemoryPool(false))
{
// This must not fail. The transaction has already been signed and recorded.
LogPrintf("CDarksendPool::ChargeFees() : Error: Transaction not valid");
}
wtxCollateral.RelayWalletTransaction();
return;
}
}
}
}
}
}
// charge the collateral randomly
// - Darksend is completely free, to pay miners we randomly pay the collateral of users.
void CDarksendPool::ChargeRandomFees(){
if(fMasterNode) {
int i = 0;
BOOST_FOREACH(const CTransaction& txCollateral, vecSessionCollateral) {
int r = rand()%100;
/*
Collateral Fee Charges:
Being that Darksend 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.
*/
if(r <= 10)
{
LogPrintf("CDarksendPool::ChargeRandomFees -- charging random fees. %u\n", i);
CWalletTx wtxCollateral = CWalletTx(pwalletMain, txCollateral);
// Broadcast
if (!wtxCollateral.AcceptToMemoryPool(true))
{
// This must not fail. The transaction has already been signed and recorded.
LogPrintf("CDarksendPool::ChargeRandomFees() : Error: Transaction not valid");
}
wtxCollateral.RelayWalletTransaction();
}
}
}
}
//
// Check for various timeouts (queue objects, Darksend, etc)
//
void CDarksendPool::CheckTimeout(){
if(!fEnableDarksend && !fMasterNode) return;
// catching hanging sessions
if(!fMasterNode) {
if(state == POOL_STATUS_TRANSMISSION) {
if(fDebug) LogPrintf("CDarksendPool::CheckTimeout() -- Session complete -- Running Check()\n");
Check();
}
}
// check Darksend queue objects for timeouts
int c = 0;
vector<CDarksendQueue>::iterator it;
for(it=vecDarksendQueue.begin();it<vecDarksendQueue.end();it++){
if((*it).IsExpired()){
if(fDebug) LogPrintf("CDarksendPool::CheckTimeout() : Removing expired queue entry - %d\n", c);
vecDarksendQueue.erase(it);
break;
}
c++;
}
int addLagTime = 0;
if(!fMasterNode) addLagTime = 10000; //if we're the client, give the server a few extra seconds before resetting.
if(state == POOL_STATUS_ACCEPTING_ENTRIES || state == POOL_STATUS_QUEUE){
c = 0;
// if it's a Masternode, the entries are stored in "entries", otherwise they're stored in myEntries
std::vector<CDarkSendEntry> *vec = &myEntries;
if(fMasterNode) vec = &entries;
// check for a timeout and reset if needed
vector<CDarkSendEntry>::iterator it2;
for(it2=vec->begin();it2<vec->end();it2++){
if((*it2).IsExpired()){
if(fDebug) LogPrintf("CDarksendPool::CheckTimeout() : Removing expired entry - %d\n", c);
vec->erase(it2);
if(entries.size() == 0 && myEntries.size() == 0){
SetNull(true);
UnlockCoins();
}
if(fMasterNode){
RelayStatus(darkSendPool.sessionID, darkSendPool.GetState(), darkSendPool.GetEntriesCount(), MASTERNODE_RESET);
}
break;
}
c++;
}
if(GetTimeMillis()-lastTimeChanged >= (DARKSEND_QUEUE_TIMEOUT*1000)+addLagTime){
lastTimeChanged = GetTimeMillis();
SetNull(true);
}
} else if(GetTimeMillis()-lastTimeChanged >= (DARKSEND_QUEUE_TIMEOUT*1000)+addLagTime){
if(fDebug) LogPrintf("CDarksendPool::CheckTimeout() -- Session timed out (30s) -- resetting\n");
SetNull();
UnlockCoins();
UpdateState(POOL_STATUS_ERROR);
lastMessage = _("Session timed out, please resubmit.");
}
if(state == POOL_STATUS_SIGNING && GetTimeMillis()-lastTimeChanged >= (DARKSEND_SIGNING_TIMEOUT*1000)+addLagTime ) {
if(fDebug) LogPrintf("CDarksendPool::CheckTimeout() -- Session timed out -- restting\n");
ChargeFees();
SetNull();
UnlockCoins();
//add my transactions to the new session
UpdateState(POOL_STATUS_ERROR);
lastMessage = _("Signing timed out, please resubmit.");
}
}
//
// Check for complete queue
//
void CDarksendPool::CheckForCompleteQueue(){
if(!fEnableDarksend && !fMasterNode) return;
/* 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
//
if(state == POOL_STATUS_QUEUE && sessionUsers == GetMaxPoolTransactions()) {
UpdateState(POOL_STATUS_ACCEPTING_ENTRIES);
CDarksendQueue dsq;
dsq.nDenom = sessionDenom;
dsq.vin = activeMasternode.vin;
dsq.time = GetTime();
dsq.ready = true;
dsq.Sign();
dsq.Relay();
}
}
// check to see if the signature is valid
bool CDarksendPool::SignatureValid(const CScript& newSig, const CTxIn& newVin){
CMutableTransaction txNew;
txNew.vin.clear();
txNew.vout.clear();
int found = -1;
CScript sigPubKey = CScript();
unsigned int i = 0;
BOOST_FOREACH(CDarkSendEntry& e, entries) {
BOOST_FOREACH(const CTxOut& out, e.vout)
txNew.vout.push_back(out);
BOOST_FOREACH(const CTxDSIn& s, e.sev){
txNew.vin.push_back(s);
if(s == newVin){
found = i;
sigPubKey = s.prevPubKey;
}
i++;
}
}
if(found >= 0){ //might have to do this one input at a time?
int n = found;
txNew.vin[n].scriptSig = newSig;
if(fDebug) LogPrintf("CDarksendPool::SignatureValid() - Sign with sig %s\n", newSig.ToString().substr(0,24).c_str());
if (!VerifyScript(txNew.vin[n].scriptSig, sigPubKey, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, MutableTransactionSignatureChecker(&txNew, n))){
if(fDebug) LogPrintf("CDarksendPool::SignatureValid() - Signing - Error signing input %u\n", n);
return false;
}
}
if(fDebug) LogPrintf("CDarksendPool::SignatureValid() - Signing - Successfully validated input\n");
return true;
}
// check to make sure the collateral provided by the client is valid
bool CDarksendPool::IsCollateralValid(const CTransaction& txCollateral){
if(txCollateral.vout.size() < 1) return false;
if(txCollateral.nLockTime != 0) return false;
int64_t nValueIn = 0;
int64_t nValueOut = 0;
bool missingTx = false;
BOOST_FOREACH(const CTxOut o, txCollateral.vout){
nValueOut += o.nValue;
if(!o.scriptPubKey.IsNormalPaymentScript()){
LogPrintf ("CDarksendPool::IsCollateralValid - Invalid Script %s\n", txCollateral.ToString().c_str());
return false;
}
}
BOOST_FOREACH(const CTxIn i, txCollateral.vin){
CTransaction tx2;
uint256 hash;
if(GetTransaction(i.prevout.hash, tx2, hash, true)){
if(tx2.vout.size() > i.prevout.n) {
nValueIn += tx2.vout[i.prevout.n].nValue;
}
} else{
missingTx = true;
}
}
if(missingTx){
if(fDebug) LogPrintf ("CDarksendPool::IsCollateralValid - Unknown inputs in collateral transaction - %s\n", txCollateral.ToString().c_str());
return false;
}
//collateral transactions are required to pay out DARKSEND_COLLATERAL as a fee to the miners
if(nValueIn - nValueOut < DARKSEND_COLLATERAL) {
if(fDebug) LogPrintf ("CDarksendPool::IsCollateralValid - did not include enough fees in transaction %d\n%s\n", nValueOut-nValueIn, txCollateral.ToString().c_str());
return false;
}
if(fDebug) LogPrintf("CDarksendPool::IsCollateralValid %s\n", txCollateral.ToString().c_str());
CValidationState state;
if(!AcceptableInputs(mempool, state, txCollateral, true, NULL)){
if(fDebug) LogPrintf ("CDarksendPool::IsCollateralValid - didn't pass IsAcceptable\n");
return false;
}
return true;
}
//
// Add a clients transaction to the pool
//
bool CDarksendPool::AddEntry(const std::vector<CTxIn>& newInput, const int64_t& nAmount, const CTransaction& txCollateral, const std::vector<CTxOut>& newOutput, int& errorID){
if (!fMasterNode) return false;
BOOST_FOREACH(CTxIn in, newInput) {
if (in.prevout.IsNull() || nAmount < 0) {
if(fDebug) LogPrintf ("CDarksendPool::AddEntry - input not valid!\n");
errorID = ERR_INVALID_INPUT;
sessionUsers--;
return false;
}
}
if (!IsCollateralValid(txCollateral)){
if(fDebug) LogPrintf ("CDarksendPool::AddEntry - collateral not valid!\n");
errorID = ERR_INVALID_COLLATERAL;
sessionUsers--;
return false;
}
if((int)entries.size() >= GetMaxPoolTransactions()){
if(fDebug) LogPrintf ("CDarksendPool::AddEntry - entries is full!\n");
errorID = ERR_ENTRIES_FULL;
sessionUsers--;
return false;
}
BOOST_FOREACH(CTxIn in, newInput) {
if(fDebug) LogPrintf("looking for vin -- %s\n", in.ToString().c_str());
BOOST_FOREACH(const CDarkSendEntry& v, entries) {
BOOST_FOREACH(const CTxDSIn& s, v.sev){
if((CTxIn)s == in) {
if(fDebug) LogPrintf ("CDarksendPool::AddEntry - found in vin\n");
errorID = ERR_ALREADY_HAVE;
sessionUsers--;
return false;
}
}
}
}
CDarkSendEntry v;
v.Add(newInput, nAmount, txCollateral, newOutput);
entries.push_back(v);
if(fDebug) LogPrintf("CDarksendPool::AddEntry -- adding %s\n", newInput[0].ToString().c_str());
errorID = MSG_NOERR;
return true;
}
bool CDarksendPool::AddScriptSig(const CTxIn& newVin){
if(fDebug) LogPrintf("CDarksendPool::AddScriptSig -- new sig %s\n", newVin.scriptSig.ToString().substr(0,24).c_str());
BOOST_FOREACH(const CDarkSendEntry& v, entries) {
BOOST_FOREACH(const CTxDSIn& s, v.sev){
if(s.scriptSig == newVin.scriptSig) {
printf("CDarksendPool::AddScriptSig - already exists \n");
return false;
}
}
}
if(!SignatureValid(newVin.scriptSig, newVin)){
if(fDebug) LogPrintf("CDarksendPool::AddScriptSig - Invalid Sig\n");
return false;
}
if(fDebug) LogPrintf("CDarksendPool::AddScriptSig -- sig %s\n", newVin.ToString().c_str());
BOOST_FOREACH(CTxIn& vin, finalTransaction.vin){
if(newVin.prevout == vin.prevout && vin.nSequence == newVin.nSequence){
vin.scriptSig = newVin.scriptSig;
vin.prevPubKey = newVin.prevPubKey;
if(fDebug) LogPrintf("CDarkSendPool::AddScriptSig -- adding to finalTransaction %s\n", newVin.scriptSig.ToString().substr(0,24).c_str());
}
}
for(unsigned int i = 0; i < entries.size(); i++){
if(entries[i].AddSig(newVin)){
if(fDebug) LogPrintf("CDarkSendPool::AddScriptSig -- adding %s\n", newVin.scriptSig.ToString().substr(0,24).c_str());
return true;
}
}
LogPrintf("CDarksendPool::AddScriptSig -- Couldn't set sig!\n" );
return false;
}
// Check to make sure everything is signed
bool CDarksendPool::SignaturesComplete(){
BOOST_FOREACH(const CDarkSendEntry& v, entries) {
BOOST_FOREACH(const CTxDSIn& s, v.sev){
if(!s.fHasSig) return false;
}
}
return true;
}
//
// Execute a Darksend denomination via a Masternode.
// This is only ran from clients
//
void CDarksendPool::SendDarksendDenominate(std::vector<CTxIn>& vin, std::vector<CTxOut>& vout, int64_t amount){
if(darkSendPool.txCollateral == CMutableTransaction()){
LogPrintf ("CDarksendPool:SendDarksendDenominate() - Darksend collateral not set");
return;
}
// lock the funds we're going to use
BOOST_FOREACH(CTxIn in, txCollateral.vin)
lockedCoins.push_back(in);
BOOST_FOREACH(CTxIn in, vin)
lockedCoins.push_back(in);
//BOOST_FOREACH(CTxOut o, vout)
// LogPrintf(" vout - %s\n", o.ToString().c_str());
// we should already be connected to a Masternode
if(!sessionFoundMasternode){
LogPrintf("CDarksendPool::SendDarksendDenominate() - No Masternode has been selected yet.\n");
UnlockCoins();
SetNull(true);
return;
}
if (!CheckDiskSpace())
return;
if(fMasterNode) {
LogPrintf("CDarksendPool::SendDarksendDenominate() - Darksend from a Masternode is not supported currently.\n");
return;
}
UpdateState(POOL_STATUS_ACCEPTING_ENTRIES);
LogPrintf("CDarksendPool::SendDarksendDenominate() - Added transaction to pool.\n");
ClearLastMessage();
//check it against the memory pool to make sure it's valid
{
int64_t nValueOut = 0;
CValidationState state;
CMutableTransaction tx;
BOOST_FOREACH(const CTxOut& o, vout){
nValueOut += o.nValue;
tx.vout.push_back(o);
}
BOOST_FOREACH(const CTxIn& i, vin){
tx.vin.push_back(i);
if(fDebug) LogPrintf("dsi -- tx in %s\n", i.ToString().c_str());
}
LogPrintf("Submitting tx %s\n", tx.ToString().c_str());
if(!AcceptableInputs(mempool, state, CTransaction(tx), false, NULL)){
LogPrintf("dsi -- transaction not valid! %s \n", tx.ToString().c_str());
return;
}
}
// store our entry for later use
CDarkSendEntry e;
e.Add(vin, amount, txCollateral, vout);
myEntries.push_back(e);
RelayIn(myEntries[0].sev, myEntries[0].amount, txCollateral, myEntries[0].vout);
Check();
}
// Incoming message from Masternode updating the progress of Darksend
// newAccepted: -1 mean's it'n not a "transaction accepted/not accepted" message, just a standard update
// 0 means transaction was not accepted
// 1 means transaction was accepted
bool CDarksendPool::StatusUpdate(int newState, int newEntriesCount, int newAccepted, int& errorID, int newSessionID){
if(fMasterNode) return false;
if(state == POOL_STATUS_ERROR || state == POOL_STATUS_SUCCESS) return false;
UpdateState(newState);
entriesCount = newEntriesCount;
if(errorID != MSG_NOERR) strAutoDenomResult = _("Masternode:") + " " + GetMessageByID(errorID);
if(newAccepted != -1) {
lastEntryAccepted = newAccepted;
countEntriesAccepted += newAccepted;
if(newAccepted == 0){
UpdateState(POOL_STATUS_ERROR);
lastMessage = GetMessageByID(errorID);
}
if(newAccepted == 1 && newSessionID != 0) {
sessionID = newSessionID;
LogPrintf("CDarksendPool::StatusUpdate - set sessionID to %d\n", sessionID);
sessionFoundMasternode = true;
}
}
if(newState == POOL_STATUS_ACCEPTING_ENTRIES){
if(newAccepted == 1){
LogPrintf("CDarksendPool::StatusUpdate - entry accepted! \n");
sessionFoundMasternode = true;
//wait for other users. Masternode will report when ready
UpdateState(POOL_STATUS_QUEUE);
} else if (newAccepted == 0 && sessionID == 0 && !sessionFoundMasternode) {
LogPrintf("CDarksendPool::StatusUpdate - entry not accepted by Masternode \n");
UnlockCoins();
UpdateState(POOL_STATUS_ACCEPTING_ENTRIES);
DoAutomaticDenominating(); //try another Masternode
}
if(sessionFoundMasternode) return true;
}
return true;
}
//
// After we receive the finalized transaction from the Masternode, we must
// check it to make sure it's what we want, then sign it if we agree.
// If we refuse to sign, it's possible we'll be charged collateral
//
bool CDarksendPool::SignFinalTransaction(CTransaction& finalTransactionNew, CNode* node){
if(fMasterNode) return false;
finalTransaction = finalTransactionNew;
LogPrintf("CDarksendPool::SignFinalTransaction %s\n", finalTransaction.ToString().c_str());
vector<CTxIn> sigs;
//make sure my inputs/outputs are present, otherwise refuse to sign
BOOST_FOREACH(const CDarkSendEntry e, myEntries) {
BOOST_FOREACH(const CTxDSIn s, e.sev) {
/* Sign my transaction and all outputs */
int mine = -1;
CScript prevPubKey = CScript();
CTxIn vin = CTxIn();
for(unsigned int i = 0; i < finalTransaction.vin.size(); i++){
if(finalTransaction.vin[i] == s){
mine = i;
prevPubKey = s.prevPubKey;
vin = s;
}
}
if(mine >= 0){ //might have to do this one input at a time?
int foundOutputs = 0;
CAmount nValue1 = 0;
CAmount nValue2 = 0;
for(unsigned int i = 0; i < finalTransaction.vout.size(); i++){
BOOST_FOREACH(const CTxOut& o, e.vout) {
if(finalTransaction.vout[i] == o){
foundOutputs++;
nValue1 += finalTransaction.vout[i].nValue;
}
}
}
BOOST_FOREACH(const CTxOut o, e.vout)
nValue2 += o.nValue;
int targetOuputs = e.vout.size();
if(foundOutputs < targetOuputs || nValue1 != nValue2) {
// in this case, something went wrong and we'll refuse to sign. It's possible we'll be charged collateral. But that's
// better then signing if the transaction doesn't look like what we wanted.
LogPrintf("CDarksendPool::Sign - My entries are not correct! Refusing to sign. %d entries %d target. \n", foundOutputs, targetOuputs);
return false;
}
const CKeyStore& keystore = *pwalletMain;
if(fDebug) LogPrintf("CDarksendPool::Sign - Signing my input %i\n", mine);
if(!SignSignature(keystore, prevPubKey, finalTransaction, mine, int(SIGHASH_ALL|SIGHASH_ANYONECANPAY))) { // changes scriptSig
if(fDebug) LogPrintf("CDarksendPool::Sign - Unable to sign my own transaction! \n");
// not sure what to do here, it will timeout...?
}
sigs.push_back(finalTransaction.vin[mine]);
if(fDebug) LogPrintf(" -- dss %d %d %s\n", mine, (int)sigs.size(), finalTransaction.vin[mine].scriptSig.ToString().c_str());
}
}
if(fDebug) LogPrintf("CDarksendPool::Sign - txNew:\n%s", finalTransaction.ToString().c_str());
}
// push all of our signatures to the Masternode
if(sigs.size() > 0 && node != NULL)
node->PushMessage("dss", sigs);
return true;
}
void CDarksendPool::NewBlock()
{
if(fDebug) LogPrintf("CDarksendPool::NewBlock \n");
//we we're processing lots of blocks, we'll just leave
if(GetTime() - lastNewBlock < 10) return;
lastNewBlock = GetTime();
darkSendPool.CheckTimeout();
if(!fEnableDarksend) return;
if(!fMasterNode){
//denominate all non-denominated inputs every 25 minutes.
if(chainActive.Tip()->nHeight % 10 == 0) UnlockCoins();
}
}
// Darksend transaction was completed (failed or successful)
void CDarksendPool::CompletedTransaction(bool error, std::string lastMessageNew)
{
if(fMasterNode) return;
if(error){
LogPrintf("CompletedTransaction -- error \n");
UpdateState(POOL_STATUS_ERROR);
Check();
UnlockCoins();
} else {
LogPrintf("CompletedTransaction -- success \n");
UpdateState(POOL_STATUS_SUCCESS);
myEntries.clear();
UnlockCoins();
if(!fMasterNode) SetNull(true);
// To avoid race conditions, we'll only let DS run once per block
cachedLastSuccess = chainActive.Tip()->nHeight;
}
lastMessage = lastMessageNew;
completedTransaction = true;
}
void CDarksendPool::ClearLastMessage()
{
lastMessage = "";
}
//
// Passively run Darksend in the background to anonymize funds based on the given configuration.
//
// This does NOT run by default for daemons, only for QT.
//
bool CDarksendPool::DoAutomaticDenominating(bool fDryRun, bool ready)
{
LOCK(cs_darksend);
if(IsInitialBlockDownload()) return false;
if(fMasterNode) return false;
if(state == POOL_STATUS_ERROR || state == POOL_STATUS_SUCCESS) return false;
if(chainActive.Tip()->nHeight - cachedLastSuccess < minBlockSpacing) {
LogPrintf("CDarksendPool::DoAutomaticDenominating - Last successful Darksend action was too recent\n");
strAutoDenomResult = _("Last successful Darksend action was too recent.");
return false;
}
if(!fEnableDarksend) {
if(fDebug) LogPrintf("CDarksendPool::DoAutomaticDenominating - Darksend is disabled\n");
strAutoDenomResult = _("Darksend is disabled.");
return false;
}
if (!fDryRun && pwalletMain->IsLocked()){
strAutoDenomResult = _("Wallet is locked.");
return false;
}
if(darkSendPool.GetState() != POOL_STATUS_ERROR && darkSendPool.GetState() != POOL_STATUS_SUCCESS){
if(darkSendPool.GetMyTransactionCount() > 0){
return true;
}
}
if(mnodeman.size() == 0){
if(fDebug) LogPrintf("CDarksendPool::DoAutomaticDenominating - No Masternodes detected\n");
strAutoDenomResult = _("No Masternodes detected.");
return false;
}
// ** find the coins we'll use
std::vector<CTxIn> vCoins;
CAmount nValueMin = CENT;
CAmount nValueIn = 0;
CAmount nOnlyDenominatedBalance;
CAmount nBalanceNeedsDenominated;
// should not be less than fees in DARKSEND_COLLATERAL + few (lets say 5) smallest denoms
CAmount nLowestDenom = DARKSEND_COLLATERAL + darkSendDenominations[darkSendDenominations.size() - 1]*5;
// if there are no DS collateral inputs yet
if(!pwalletMain->HasCollateralInputs())
// should have some additional amount for them
nLowestDenom += DARKSEND_COLLATERAL*4;
CAmount nBalanceNeedsAnonymized = nAnonymizeDarkcoinAmount*COIN - pwalletMain->GetAnonymizedBalance();
// if balanceNeedsAnonymized is more than pool max, take the pool max
if(nBalanceNeedsAnonymized > DARKSEND_POOL_MAX) nBalanceNeedsAnonymized = DARKSEND_POOL_MAX;
// if balanceNeedsAnonymized is more than non-anonymized, take non-anonymized
CAmount nAnonymizableBalance = pwalletMain->GetAnonymizableBalance();
if(nBalanceNeedsAnonymized > nAnonymizableBalance) nBalanceNeedsAnonymized = nAnonymizableBalance;
if(nBalanceNeedsAnonymized < nLowestDenom)
{
LogPrintf("DoAutomaticDenominating : No funds detected in need of denominating \n");
strAutoDenomResult = _("No funds detected in need of denominating.");
return false;
}
if (fDebug) LogPrintf("DoAutomaticDenominating : nLowestDenom=%d, nBalanceNeedsAnonymized=%d\n", nLowestDenom, nBalanceNeedsAnonymized);
// select coins that should be given to the pool
if (!pwalletMain->SelectCoinsDark(nValueMin, nBalanceNeedsAnonymized, vCoins, nValueIn, 0, nDarksendRounds))
{
nValueIn = 0;
vCoins.clear();
if (pwalletMain->SelectCoinsDark(nValueMin, 9999999*COIN, vCoins, nValueIn, -2, 0))
{
nOnlyDenominatedBalance = pwalletMain->GetDenominatedBalance(true, false, false);
nBalanceNeedsDenominated = nBalanceNeedsAnonymized - nOnlyDenominatedBalance;
if(nBalanceNeedsDenominated > nValueIn) nBalanceNeedsDenominated = nValueIn;
if(!fDryRun) return CreateDenominated(nBalanceNeedsDenominated);
return true;
} else {
LogPrintf("DoAutomaticDenominating : Can't denominate - no compatible inputs left\n");
strAutoDenomResult = _("Can't denominate: no compatible inputs left.");
return false;
}
}
nOnlyDenominatedBalance = pwalletMain->GetDenominatedBalance(true, false, false);
nBalanceNeedsDenominated = nBalanceNeedsAnonymized - nOnlyDenominatedBalance;
if(!fDryRun && nBalanceNeedsDenominated > nOnlyDenominatedBalance) return CreateDenominated(nBalanceNeedsDenominated);
//check to see if we have the collateral sized inputs, it requires these
if(!pwalletMain->HasCollateralInputs()){
if(!fDryRun) MakeCollateralAmounts();
return true;
}
if(fDryRun) return true;
std::vector<CTxOut> vOut;
// initial phase, find a Masternode
if(!sessionFoundMasternode){
int nUseQueue = rand()%100;
UpdateState(POOL_STATUS_ACCEPTING_ENTRIES);
sessionTotalValue = pwalletMain->GetTotalValue(vCoins);
//randomize the amounts we mix
if(sessionTotalValue > nBalanceNeedsAnonymized) sessionTotalValue = nBalanceNeedsAnonymized;
double fDarkcoinSubmitted = (sessionTotalValue / CENT);
LogPrintf("Submitting Darksend for %f DASH CENT - sessionTotalValue %d\n", fDarkcoinSubmitted, sessionTotalValue);
if(pwalletMain->GetDenominatedBalance(true, true) > 0){ //get denominated unconfirmed inputs
LogPrintf("DoAutomaticDenominating -- Found unconfirmed denominated outputs, will wait till they confirm to continue.\n");
strAutoDenomResult = _("Found unconfirmed denominated outputs, will wait till they confirm to continue.");
return false;
}
//check our collateral
if(txCollateral != CMutableTransaction()){
if(!IsCollateralValid(txCollateral)) {
txCollateral = CMutableTransaction();
LogPrintf("DoAutomaticDenominating -- Invalid collateral, resetting.\n");
}
}
//don't use the queues all of the time for mixing
if(nUseQueue > 33){
// Look through the queues and see if anything matches
BOOST_FOREACH(CDarksendQueue& dsq, vecDarksendQueue){
CService addr;
if(dsq.time == 0) continue;
if(!dsq.GetAddress(addr)) continue;
if(dsq.IsExpired()) continue;
int protocolVersion;
if(!dsq.GetProtocolVersion(protocolVersion)) continue;
if(protocolVersion < MIN_POOL_PEER_PROTO_VERSION) continue;
//non-denom's are incompatible
if((dsq.nDenom & (1 << 4))) continue;
//don't reuse Masternodes
BOOST_FOREACH(CTxIn usedVin, vecMasternodesUsed){
if(dsq.vin == usedVin) {
continue;
}
}
std::vector<CTxIn> vTempCoins;
std::vector<COutput> vTempCoins2;
// Try to match their denominations if possible
if (!pwalletMain->SelectCoinsByDenominations(dsq.nDenom, nValueMin, nBalanceNeedsAnonymized, vTempCoins, vTempCoins2, nValueIn, 0, nDarksendRounds)){
LogPrintf("DoAutomaticDenominating - Couldn't match denominations %d\n", dsq.nDenom);
continue;
}
// connect to Masternode and submit the queue request
if(ConnectNode((CAddress)addr, NULL, true)){
CNode* pNode = FindNode(addr);
if(pNode)
{
std::string strReason;
if(txCollateral == CMutableTransaction()){
if(!pwalletMain->CreateCollateralTransaction(txCollateral, strReason)){
LogPrintf("DoAutomaticDenominating -- dsa error:%s\n", strReason.c_str());
return false;
}
}
CMasternode* pmn = mnodeman.Find(dsq.vin);
if(pmn == NULL)
{
LogPrintf("DoAutomaticDenominating --- dsq vin %s is not in masternode list!", dsq.vin.ToString());
continue;
}
pSubmittedToMasternode = pmn;
vecMasternodesUsed.push_back(dsq.vin);
sessionDenom = dsq.nDenom;
pNode->PushMessage("dsa", sessionDenom, txCollateral);
LogPrintf("DoAutomaticDenominating --- connected (from queue), sending dsa for %d %d - %s\n", sessionDenom, GetDenominationsByAmount(sessionTotalValue), pNode->addr.ToString().c_str());
strAutoDenomResult = "";
dsq.time = 0; //remove node
return true;
}
} else {
LogPrintf("DoAutomaticDenominating --- error connecting \n");
strAutoDenomResult = _("Error connecting to Masternode.");
dsq.time = 0; //remove node
return DoAutomaticDenominating();
}
}
}
int i = 0;
// otherwise, try one randomly
while(i < 10)
{
CMasternode* pmn = mnodeman.FindRandom();
if(pmn == NULL)
{
LogPrintf("DoAutomaticDenominating --- Masternode list is empty!\n");
return false;
}
//don't reuse Masternodes
BOOST_FOREACH(CTxIn usedVin, vecMasternodesUsed) {
if(pmn->vin == usedVin){
i++;
continue;
}
}
if(pmn->protocolVersion < MIN_POOL_PEER_PROTO_VERSION) {
i++;
continue;
}
if(pmn->nLastDsq != 0 &&
pmn->nLastDsq + mnodeman.CountMasternodesAboveProtocol(MIN_POOL_PEER_PROTO_VERSION)/5 > mnodeman.nDsqCount){
i++;
continue;
}
lastTimeChanged = GetTimeMillis();
LogPrintf("DoAutomaticDenominating -- attempt %d connection to Masternode %s\n", i, pmn->addr.ToString().c_str());
if(ConnectNode((CAddress)pmn->addr, NULL, true)){
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if((CNetAddr)pnode->addr != (CNetAddr)pmn->addr) continue;
std::string strReason;
if(txCollateral == CMutableTransaction()){
if(!pwalletMain->CreateCollateralTransaction(txCollateral, strReason)){
LogPrintf("DoAutomaticDenominating -- create collateral error:%s\n", strReason.c_str());
return false;
}
}
pSubmittedToMasternode = pmn;
vecMasternodesUsed.push_back(pmn->vin);
std::vector<CAmount> vecAmounts;
pwalletMain->ConvertList(vCoins, vecAmounts);
sessionDenom = GetDenominationsByAmounts(vecAmounts);
pnode->PushMessage("dsa", sessionDenom, txCollateral);
LogPrintf("DoAutomaticDenominating --- connected, sending dsa for %d - denom %d\n", sessionDenom, GetDenominationsByAmount(sessionTotalValue));
strAutoDenomResult = "";
return true;
}
} else {
i++;
continue;
}
}
strAutoDenomResult = _("No compatible Masternode found.");
return false;
}
strAutoDenomResult = "";
if(!ready) return true;
if(sessionDenom == 0) return true;
return false;
}
bool CDarksendPool::PrepareDarksendDenominate()
{
// Submit transaction to the pool if we get here, use sessionDenom so we use the same amount of money
std::string strError = pwalletMain->PrepareDarksendDenominate(0, nDarksendRounds);
LogPrintf("DoAutomaticDenominating : Running Darksend denominate. Return '%s'\n", strError.c_str());
if(strError == "") return true;
strAutoDenomResult = strError;
LogPrintf("DoAutomaticDenominating : Error running denominate, %s\n", strError.c_str());
return false;
}
bool CDarksendPool::SendRandomPaymentToSelf()
{
int64_t nBalance = pwalletMain->GetBalance();
int64_t nPayment = (nBalance*0.35) + (rand() % nBalance);
if(nPayment > nBalance) nPayment = nBalance-(0.1*COIN);
// make our change address
CReserveKey reservekey(pwalletMain);
CScript scriptChange;
CPubKey vchPubKey;
assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
scriptChange = GetScriptForDestination(vchPubKey.GetID());
CWalletTx wtx;
int64_t nFeeRet = 0;
std::string strFail = "";
vector< pair<CScript, int64_t> > vecSend;
// ****** Add fees ************ /
vecSend.push_back(make_pair(scriptChange, nPayment));
CCoinControl *coinControl=NULL;
bool success = pwalletMain->CreateTransaction(vecSend, wtx, reservekey, nFeeRet, strFail, coinControl, ONLY_DENOMINATED);
if(!success){
LogPrintf("SendRandomPaymentToSelf: Error - %s\n", strFail.c_str());
return false;
}
pwalletMain->CommitTransaction(wtx, reservekey);
LogPrintf("SendRandomPaymentToSelf Success: tx %s\n", wtx.GetHash().GetHex().c_str());
return true;
}
// Split up large inputs or create fee sized inputs
bool CDarksendPool::MakeCollateralAmounts()
{
// make our change address
CReserveKey reservekey(pwalletMain);
CScript scriptChange;
CPubKey vchPubKey;
assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
scriptChange = GetScriptForDestination(vchPubKey.GetID());
CWalletTx wtx;
int64_t nFeeRet = 0;
std::string strFail = "";
vector< pair<CScript, int64_t> > vecSend;
vecSend.push_back(make_pair(scriptChange, DARKSEND_COLLATERAL*4));
CCoinControl *coinControl=NULL;
// try to use non-denominated and not mn-like funds
bool success = pwalletMain->CreateTransaction(vecSend, wtx, reservekey,
nFeeRet, strFail, coinControl, ONLY_NONDENOMINATED_NOTMN);
if(!success){
// if we failed (most likeky not enough funds), try to use denominated instead -
// MN-like funds should not be touched in any case and we can't mix denominated without collaterals anyway
success = pwalletMain->CreateTransaction(vecSend, wtx, reservekey,
nFeeRet, strFail, coinControl, ONLY_DENOMINATED);
if(!success){
LogPrintf("MakeCollateralAmounts: Error - %s\n", strFail.c_str());
return false;
}
}
// use the same cachedLastSuccess as for DS mixinx to prevent race
if(pwalletMain->CommitTransaction(wtx, reservekey))
cachedLastSuccess = chainActive.Tip()->nHeight;
LogPrintf("MakeCollateralAmounts Success: tx %s\n", wtx.GetHash().GetHex().c_str());
return true;
}
// Create denominations
bool CDarksendPool::CreateDenominated(int64_t nTotalValue)
{
// make our change address
CReserveKey reservekey(pwalletMain);
CScript scriptChange;
CPubKey vchPubKey;
assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
scriptChange = GetScriptForDestination(vchPubKey.GetID());
CWalletTx wtx;
int64_t nFeeRet = 0;
std::string strFail = "";
vector< pair<CScript, int64_t> > vecSend;
int64_t nValueLeft = nTotalValue;
// ****** Add collateral outputs ************ /
if(!pwalletMain->HasCollateralInputs()) {
vecSend.push_back(make_pair(scriptChange, DARKSEND_COLLATERAL*4));
nValueLeft -= DARKSEND_COLLATERAL*4;
}
// ****** Add denoms ************ /
BOOST_REVERSE_FOREACH(int64_t v, darkSendDenominations){
int nOutputs = 0;
// add each output up to 10 times until it can't be added again
while(nValueLeft - v >= DARKSEND_COLLATERAL && nOutputs <= 10) {
CScript scriptChange;
CPubKey vchPubKey;
//use a unique change address
assert(reservekey.GetReservedKey(vchPubKey)); // should never fail, as we just unlocked
scriptChange = GetScriptForDestination(vchPubKey.GetID());
reservekey.KeepKey();
vecSend.push_back(make_pair(scriptChange, v));
//increment outputs and subtract denomination amount
nOutputs++;
nValueLeft -= v;
LogPrintf("CreateDenominated1 %d\n", nValueLeft);
}
if(nValueLeft == 0) break;
}
LogPrintf("CreateDenominated2 %d\n", nValueLeft);
// if we have anything left over, it will be automatically send back as change - there is no need to send it manually
CCoinControl *coinControl=NULL;
bool success = pwalletMain->CreateTransaction(vecSend, wtx, reservekey,
nFeeRet, strFail, coinControl, ONLY_NONDENOMINATED_NOTMN);
if(!success){
LogPrintf("CreateDenominated: Error - %s\n", strFail.c_str());
return false;
}
// use the same cachedLastSuccess as for DS mixinx to prevent race
if(pwalletMain->CommitTransaction(wtx, reservekey))
cachedLastSuccess = chainActive.Tip()->nHeight;
LogPrintf("CreateDenominated Success: tx %s\n", wtx.GetHash().GetHex().c_str());
return true;
}
bool CDarksendPool::IsCompatibleWithEntries(std::vector<CTxOut>& vout)
{
if(GetDenominations(vout) == 0) return false;
BOOST_FOREACH(const CDarkSendEntry v, entries) {
LogPrintf(" IsCompatibleWithEntries %d %d\n", GetDenominations(vout), GetDenominations(v.vout));
/*
BOOST_FOREACH(CTxOut o1, vout)
LogPrintf(" vout 1 - %s\n", o1.ToString().c_str());
BOOST_FOREACH(CTxOut o2, v.vout)
LogPrintf(" vout 2 - %s\n", o2.ToString().c_str());
*/
if(GetDenominations(vout) != GetDenominations(v.vout)) return false;
}
return true;
}
bool CDarksendPool::IsCompatibleWithSession(int64_t nDenom, CTransaction txCollateral, int& errorID)
{
if(nDenom == 0) return false;
LogPrintf("CDarksendPool::IsCompatibleWithSession - sessionDenom %d sessionUsers %d\n", sessionDenom, sessionUsers);
if (!unitTest && !IsCollateralValid(txCollateral)){
if(fDebug) LogPrintf ("CDarksendPool::IsCompatibleWithSession - collateral not valid!\n");
errorID = ERR_INVALID_COLLATERAL;
return false;
}
if(sessionUsers < 0) sessionUsers = 0;
if(sessionUsers == 0) {
sessionID = 1 + (rand() % 999999);
sessionDenom = nDenom;
sessionUsers++;
lastTimeChanged = GetTimeMillis();
entries.clear();
if(!unitTest){
//broadcast that I'm accepting entries, only if it's the first entry through
CDarksendQueue dsq;
dsq.nDenom = nDenom;
dsq.vin = activeMasternode.vin;
dsq.time = GetTime();
dsq.Sign();
dsq.Relay();
}
UpdateState(POOL_STATUS_QUEUE);
vecSessionCollateral.push_back(txCollateral);
return true;
}
if((state != POOL_STATUS_ACCEPTING_ENTRIES && state != POOL_STATUS_QUEUE) || sessionUsers >= GetMaxPoolTransactions()){
if((state != POOL_STATUS_ACCEPTING_ENTRIES && state != POOL_STATUS_QUEUE)) errorID = ERR_MODE;
if(sessionUsers >= GetMaxPoolTransactions()) errorID = ERR_QUEUE_FULL;
LogPrintf("CDarksendPool::IsCompatibleWithSession - incompatible mode, return false %d %d\n", state != POOL_STATUS_ACCEPTING_ENTRIES, sessionUsers >= GetMaxPoolTransactions());
return false;
}
if(nDenom != sessionDenom) {
errorID = ERR_DENOM;
return false;
}
LogPrintf("CDarkSendPool::IsCompatibleWithSession - compatible\n");
sessionUsers++;
lastTimeChanged = GetTimeMillis();
vecSessionCollateral.push_back(txCollateral);
return true;
}
//create a nice string to show the denominations
void CDarksendPool::GetDenominationsToString(int nDenom, std::string& strDenom){
// Function returns as follows:
//
// bit 0 - 100DRK+1 ( bit on if present )
// bit 1 - 10DRK+1
// bit 2 - 1DRK+1
// bit 3 - .1DRK+1
// bit 3 - non-denom
strDenom = "";
if(nDenom & (1 << 0)) {
if(strDenom.size() > 0) strDenom += "+";
strDenom += "100";
}
if(nDenom & (1 << 1)) {
if(strDenom.size() > 0) strDenom += "+";
strDenom += "10";
}
if(nDenom & (1 << 2)) {
if(strDenom.size() > 0) strDenom += "+";
strDenom += "1";
}
if(nDenom & (1 << 3)) {
if(strDenom.size() > 0) strDenom += "+";
strDenom += "0.1";
}
}
int CDarksendPool::GetDenominations(const std::vector<CTxDSOut>& vout){
std::vector<CTxOut> vout2;
BOOST_FOREACH(CTxDSOut out, vout)
vout2.push_back(out);
return GetDenominations(vout2);
}
// return a bitshifted integer representing the denominations in this list
int CDarksendPool::GetDenominations(const std::vector<CTxOut>& vout){
std::vector<pair<int64_t, int> > denomUsed;
// make a list of denominations, with zero uses
BOOST_FOREACH(int64_t d, darkSendDenominations)
denomUsed.push_back(make_pair(d, 0));
// look for denominations and update uses to 1
BOOST_FOREACH(CTxOut out, vout){
bool found = false;
BOOST_FOREACH (PAIRTYPE(int64_t, int)& s, denomUsed){
if (out.nValue == s.first){
s.second = 1;
found = true;
}
}
if(!found) return 0;
}
int denom = 0;
int c = 0;
// if the denomination is used, shift the bit on.
// then move to the next
BOOST_FOREACH (PAIRTYPE(int64_t, int)& s, denomUsed)
denom |= s.second << c++;
// Function returns as follows:
//
// bit 0 - 100DRK+1 ( bit on if present )
// bit 1 - 10DRK+1
// bit 2 - 1DRK+1
// bit 3 - .1DRK+1
return denom;
}
int CDarksendPool::GetDenominationsByAmounts(std::vector<int64_t>& vecAmount){
CScript e = CScript();
std::vector<CTxOut> vout1;
// Make outputs by looping through denominations, from small to large
BOOST_REVERSE_FOREACH(int64_t v, vecAmount){
int nOutputs = 0;
CTxOut o(v, e);
vout1.push_back(o);
nOutputs++;
}
return GetDenominations(vout1);
}
int CDarksendPool::GetDenominationsByAmount(int64_t nAmount, int nDenomTarget){
CScript e = CScript();
int64_t nValueLeft = nAmount;
std::vector<CTxOut> vout1;
// Make outputs by looping through denominations, from small to large
BOOST_REVERSE_FOREACH(int64_t v, darkSendDenominations){
if(nDenomTarget != 0){
bool fAccepted = false;
if((nDenomTarget & (1 << 0)) && v == ((100*COIN)+100000)) {fAccepted = true;}
else if((nDenomTarget & (1 << 1)) && v == ((10*COIN) +10000)) {fAccepted = true;}
else if((nDenomTarget & (1 << 2)) && v == ((1*COIN) +1000)) {fAccepted = true;}
else if((nDenomTarget & (1 << 3)) && v == ((.1*COIN) +100)) {fAccepted = true;}
if(!fAccepted) continue;
}
int nOutputs = 0;
// add each output up to 10 times until it can't be added again
while(nValueLeft - v >= 0 && nOutputs <= 10) {
CTxOut o(v, e);
vout1.push_back(o);
nValueLeft -= v;
nOutputs++;
}
LogPrintf("GetDenominationsByAmount --- %d nOutputs %d\n", v, nOutputs);
}
//add non-denom left overs as change
if(nValueLeft > 0){
CTxOut o(nValueLeft, e);
vout1.push_back(o);
}
return GetDenominations(vout1);
}
std::string CDarksendPool::GetMessageByID(int messageID) {
switch (messageID) {
case ERR_ALREADY_HAVE: return _("Already have that input.");
case ERR_DENOM: return _("No matching denominations found for mixing.");
case ERR_ENTRIES_FULL: return _("Entries are full.");
case ERR_EXISTING_TX: return _("Not compatible with existing transactions.");
case ERR_FEES: return _("Transaction fees are too high.");
case ERR_INVALID_COLLATERAL: return _("Collateral not valid.");
case ERR_INVALID_INPUT: return _("Input is not valid.");
case ERR_INVALID_SCRIPT: return _("Invalid script detected.");
case ERR_INVALID_TX: return _("Transaction not valid.");
case ERR_MAXIMUM: return _("Value more than Darksend pool maximum allows.");
case ERR_MN_LIST: return _("Not in the Masternode list.");
case ERR_MODE: return _("Incompatible mode.");
case ERR_NON_STANDARD_PUBKEY: return _("Non-standard public key detected.");
case ERR_NOT_A_MN: return _("This is not a Masternode.");
case ERR_QUEUE_FULL: return _("Masternode queue is full.");
case ERR_RECENT: return _("Last Darksend was too recent.");
case ERR_SESSION: return _("Session not complete!");
case ERR_MISSING_TX: return _("Missing input transaction information.");
case ERR_VERSION: return _("Incompatible version.");
case MSG_SUCCESS: return _("Transaction created successfully.");
case MSG_NOERR:
default:
return "";
}
}
bool CDarkSendSigner::IsVinAssociatedWithPubkey(CTxIn& vin, CPubKey& pubkey){
CScript payee2;
payee2 = GetScriptForDestination(pubkey.GetID());
CTransaction txVin;
uint256 hash;
if(GetTransaction(vin.prevout.hash, txVin, hash, true)){
BOOST_FOREACH(CTxOut out, txVin.vout){
if(out.nValue == 1000*COIN){
if(out.scriptPubKey == payee2) return true;
}
}
}
return false;
}
bool CDarkSendSigner::SetKey(std::string strSecret, std::string& errorMessage, CKey& key, CPubKey& pubkey){
CBitcoinSecret vchSecret;
bool fGood = vchSecret.SetString(strSecret);
if (!fGood) {
errorMessage = _("Invalid private key.");
return false;
}
key = vchSecret.GetKey();
pubkey = key.GetPubKey();
return true;
}
bool CDarkSendSigner::SignMessage(std::string strMessage, std::string& errorMessage, vector<unsigned char>& vchSig, CKey key)
{
CHashWriter ss(SER_GETHASH, 0);
ss << strMessageMagic;
ss << strMessage;
if (!key.SignCompact(ss.GetHash(), vchSig)) {
errorMessage = _("Signing failed.");
return false;
}
return true;
}
bool CDarkSendSigner::VerifyMessage(CPubKey pubkey, vector<unsigned char>& vchSig, std::string strMessage, std::string& errorMessage)
{
CHashWriter ss(SER_GETHASH, 0);
ss << strMessageMagic;
ss << strMessage;
CPubKey pubkey2;
if (!pubkey2.RecoverCompact(ss.GetHash(), vchSig)) {
errorMessage = _("Error recovering public key.");
return false;
}
if (fDebug && pubkey2.GetID() != pubkey.GetID())
LogPrintf("CDarkSendSigner::VerifyMessage -- keys don't match: %s %s", pubkey2.GetID().ToString(), pubkey.GetID().ToString());
return (pubkey2.GetID() == pubkey.GetID());
}
bool CDarksendQueue::Sign()
{
if(!fMasterNode) return false;
std::string strMessage = vin.ToString() + boost::lexical_cast<std::string>(nDenom) + boost::lexical_cast<std::string>(time) + boost::lexical_cast<std::string>(ready);
CKey key2;
CPubKey pubkey2;
std::string errorMessage = "";
if(!darkSendSigner.SetKey(strMasterNodePrivKey, errorMessage, key2, pubkey2))
{
LogPrintf("CDarksendQueue():Relay - ERROR: Invalid Masternodeprivkey: '%s'\n", errorMessage.c_str());
return false;
}
if(!darkSendSigner.SignMessage(strMessage, errorMessage, vchSig, key2)) {
LogPrintf("CDarksendQueue():Relay - Sign message failed");
return false;
}
if(!darkSendSigner.VerifyMessage(pubkey2, vchSig, strMessage, errorMessage)) {
LogPrintf("CDarksendQueue():Relay - Verify message failed");
return false;
}
return true;
}
bool CDarksendQueue::Relay()
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes){
// always relay to everyone
pnode->PushMessage("dsq", (*this));
}
return true;
}
bool CDarksendQueue::CheckSignature()
{
CMasternode* pmn = mnodeman.Find(vin);
if(pmn != NULL)
{
std::string strMessage = vin.ToString() + boost::lexical_cast<std::string>(nDenom) + boost::lexical_cast<std::string>(time) + boost::lexical_cast<std::string>(ready);
std::string errorMessage = "";
if(!darkSendSigner.VerifyMessage(pmn->pubkey2, vchSig, strMessage, errorMessage)){
return error("CDarksendQueue::CheckSignature() - Got bad Masternode address signature %s \n", vin.ToString().c_str());
}
return true;
}
return false;
}
void CDarksendPool::RelayFinalTransaction(const int sessionID, const CTransaction& txNew)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
pnode->PushMessage("dsf", sessionID, txNew);
}
}
void CDarksendPool::RelayIn(const std::vector<CTxDSIn>& vin, const int64_t& nAmount, const CTransaction& txCollateral, const std::vector<CTxDSOut>& vout)
{
std::vector<CTxIn> vin2;
std::vector<CTxOut> vout2;
BOOST_FOREACH(CTxDSIn in, vin)
vin2.push_back(in);
BOOST_FOREACH(CTxDSOut out, vout)
vout2.push_back(out);
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if(!pSubmittedToMasternode) return;
if((CNetAddr)darkSendPool.pSubmittedToMasternode->addr != (CNetAddr)pnode->addr) continue;
LogPrintf("RelayIn - found master, relaying message - %s \n", pnode->addr.ToString().c_str());
pnode->PushMessage("dsi", vin2, nAmount, txCollateral, vout2);
}
}
void CDarksendPool::RelayStatus(const int sessionID, const int newState, const int newEntriesCount, const int newAccepted, const int errorID)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
pnode->PushMessage("dssu", sessionID, newState, newEntriesCount, newAccepted, errorID);
}
void CDarksendPool::RelayCompletedTransaction(const int sessionID, const bool error, const int errorID)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
pnode->PushMessage("dsc", sessionID, error, errorID);
}
//TODO: Rename/move to core
void ThreadCheckDarkSendPool()
{
if(fLiteMode) return; //disable all Darksend/Masternode related functionality
// Make this thread recognisable as the wallet flushing thread
RenameThread("dash-darksend");
unsigned int c = 0;
std::string errorMessage;
while (true)
{
c++;
MilliSleep(1000);
//LogPrintf("ThreadCheckDarkSendPool::check timeout\n");
darkSendPool.CheckTimeout();
darkSendPool.CheckForCompleteQueue();
if(c % 60 == 0)
{
LOCK(cs_main);
/*
cs_main is required for doing CMasternode.Check because something
is modifying the coins view without a mempool lock. It causes
segfaults from this code without the cs_main lock.
*/
mnodeman.CheckAndRemove();
mnodeman.ProcessMasternodeConnections();
masternodePayments.CleanPaymentList();
CleanTransactionLocksList();
}
if(c % MASTERNODE_PING_SECONDS == 0) activeMasternode.ManageStatus();
if(c % MASTERNODES_DUMP_SECONDS == 0) DumpMasternodes();
//try to sync the Masternode list and payment list every 5 seconds from at least 3 nodes
if(c % 5 == 0 && RequestedMasterNodeList < 3){
bool fIsInitialDownload = IsInitialBlockDownload();
if(!fIsInitialDownload) {
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if (pnode->nVersion >= MIN_POOL_PEER_PROTO_VERSION) {
//keep track of who we've asked for the list
if(pnode->HasFulfilledRequest("mnsync")) continue;
pnode->FulfilledRequest("mnsync");
LogPrintf("Successfully synced, asking for Masternode list and payment list\n");
//request full mn list only if Masternodes.dat was updated quite a long time ago
mnodeman.DsegUpdate(pnode);
pnode->PushMessage("mnget"); //sync payees
pnode->PushMessage("getsporks"); //get current network sporks
RequestedMasterNodeList++;
}
}
}
}
if(c % 60 == 0){
//if we've used 1/5 of the Masternode list, then clear the list.
if((int)vecMasternodesUsed.size() > (int)mnodeman.size() / 5)
vecMasternodesUsed.clear();
}
if(darkSendPool.GetState() == POOL_STATUS_IDLE && c % 6 == 0){
darkSendPool.DoAutomaticDenominating();
}
}
}
Reference in New Issue View Git Blame Copy Permalink