bool fClearSpendCache = false;

extern bool fClearSpendCache;

bool fGlobalUnlockSpendCache = false;

{

TRY_LOCK(zpivTracker->cs_spendcache, fLocked);

if (!fLocked)

continue;

uint256 hashTxOut = txNew.GetHash();

CTxIn in;

if (!stakeInput->CreateTxIn(this, in, hashTxOut)) {

LogPrintf("%s : failed to create TxIn\n", __func__);

txNew.vin.clear();

txNew.vout.clear();

continue;

}

txNew.vin.emplace_back(in);

int nLockAttempts = 0;

while (nLockAttempts < 100) {

TRY_LOCK(zpivTracker->cs_spendcache, lockSpendcache);

if (!lockSpendcache) {

fGlobalUnlockSpendCache = true;

MilliSleep(100);

++nLockAttempts;

continue;

for (auto &it : mapMintsSelected) {

CZerocoinMint mint = it.second;

CMintMeta meta = zpivTracker->Get(GetSerialHash(mint.GetSerialNumber()));

CoinWitnessData *coinWitness = zpivTracker->GetSpendCache(meta.hashStake);

if (!coinWitness->nHeightAccEnd) {

*coinWitness = CoinWitnessData(mint);

coinWitness->SetHeightMintAdded(mint.GetHeight());

}

// Generate the witness for each mint being spent

if (!GenerateAccumulatorWitness(coinWitness, mapAccumulators, pindexCheckpoint)) {

receipt.SetStatus(_("Couldn't generate the accumulator witness"),

ZPIV_FAILED_ACCUMULATOR_INITIALIZATION);

return error("%s : %s", __func__, receipt.GetStatusMessage());

}

// Construct the CoinSpend object. This acts like a signature on the transaction.

int64_t nTime1 = GetTimeMicros();

libzerocoin::ZerocoinParams *paramsCoin = Params().Zerocoin_Params(coinWitness->isV1);

libzerocoin::PrivateCoin privateCoin(paramsCoin, coinWitness->denom);

privateCoin.setPublicCoin(*coinWitness->coin);

privateCoin.setRandomness(mint.GetRandomness());

privateCoin.setSerialNumber(mint.GetSerialNumber());

int64_t nTime2 = GetTimeMicros();

LogPrint("bench", " - CoinSpend constructed in %.2fms\n", 0.001 * (nTime2 - nTime1));

//Version 2 zerocoins have a privkey associated with them

uint8_t nVersion = mint.GetVersion();

privateCoin.setVersion(mint.GetVersion());

if (nVersion >= libzerocoin::PrivateCoin::PUBKEY_VERSION) {

CKey key;

if (!mint.GetKeyPair(key))

return error("%s: failed to set zPIV privkey mint version=%d", __func__, nVersion);

privateCoin.setPrivKey(key.GetPrivKey());

}

int64_t nTime3 = GetTimeMicros();

LogPrint("bench", " - Signing key set in %.2fms\n", 0.001 * (nTime3 - nTime2));

libzerocoin::Accumulator accumulator = mapAccumulators.GetAccumulator(coinWitness->denom);

uint32_t nChecksum = GetChecksum(accumulator.getValue());

CBigNum bnValue;

if (!GetAccumulatorValueFromChecksum(nChecksum, false, bnValue) || bnValue == 0)

return error("%s: could not find checksum used for spend\n", __func__);

int64_t nTime4 = GetTimeMicros();

LogPrint("bench", " - Accumulator value fetched in %.2fms\n", 0.001 * (nTime4 - nTime3));

try {

libzerocoin::CoinSpend spend(paramsCoin, paramsAccumulator, privateCoin, accumulator, nChecksum,

*coinWitness->pWitness, hashTxOut, spendType);

if (!CheckCoinSpend(spend, accumulator, receipt)) {

receipt.SetStatus(_("CoinSpend: failed check"), ZPIV_SPEND_ERROR);

return error("%s : %s", __func__, receipt.GetStatusMessage());

}

vin.emplace_back(CTxIn(spend, coinWitness->denom));

CZerocoinSpend zcSpend(spend.getCoinSerialNumber(), 0, mint.GetValue(), mint.GetDenomination(),

GetChecksum(accumulator.getValue()));

zcSpend.SetMintCount(coinWitness->nMintsAdded);

receipt.AddSpend(zcSpend);

int64_t nTime5 = GetTimeMicros();

LogPrint("bench", " - CoinSpend verified in %.2fms\n", 0.001 * (nTime5 - nTime4));

} catch (const std::exception&) {

receipt.SetStatus(_("CoinSpend: Accumulator witness does not verify"), ZPIV_INVALID_WITNESS);

}

break;

}

if (nLockAttempts == 100) {

LogPrintf("%s : could not get lock on cs_spendcache\n", __func__);

receipt.SetStatus(_("could not get lock on cs_spendcache"), ZPIV_TXMINT_GENERAL);

return false;

int nLockAttempts = 0;

while (nLockAttempts < 100) {

TRY_LOCK(zpivTracker->cs_spendcache, lockSpendcache);

if (!lockSpendcache) {

fGlobalUnlockSpendCache = true;

MilliSleep(100);

++nLockAttempts;

continue;

}

for (auto &it : mapMintsSelected) {

CZerocoinMint mint = it.second;

// Create the simple input and the scriptSig -> Serial + Randomness + Private key signature of both.

// As the mint doesn't have the output index search it..

CTransaction txMint;

uint256 hashBlock;

if (!GetTransaction(mint.GetTxHash(), txMint, hashBlock)) {

receipt.SetStatus(strprintf(_("Unable to find transaction containing mint %s"), mint.GetTxHash().GetHex()), ZPIV_TXMINT_GENERAL);

return false;

} else if (mapBlockIndex.count(hashBlock) < 1) {

// check that this mint made it into the blockchain

receipt.SetStatus(_("Mint did not make it into blockchain"), ZPIV_TXMINT_GENERAL);

return false;

}

int outputIndex = -1;

for (unsigned long i = 0; i < txMint.vout.size(); ++i) {

CTxOut out = txMint.vout[i];

if (out.scriptPubKey.IsZerocoinMint()){

libzerocoin::PublicCoin pubcoin(Params().Zerocoin_Params(false));

CValidationState state;

if (!TxOutToPublicCoin(out, pubcoin, state))

return error("%s: extracting pubcoin from txout failed", __func__);

if (pubcoin.getValue() == mint.GetValue()){

outputIndex = i;

break;

}

if (outputIndex == -1) {

receipt.SetStatus(_("Pubcoin not found in mint tx"), ZPIV_TXMINT_GENERAL);

return false;

}

mint.SetOutputIndex(outputIndex);

CTxIn in;

if(!ZPIVModule::createInput(in, mint, hashTxOut, spendVersion)) {

receipt.SetStatus(_("Cannot create public spend input"), ZPIV_TXMINT_GENERAL);

return false;

}

vin.emplace_back(in);

receipt.AddSpend(CZerocoinSpend(mint.GetSerialNumber(), 0, mint.GetValue(), mint.GetDenomination(), 0));

break;

}

if (nLockAttempts == 100) {

LogPrintf("%s : could not get lock on cs_spendcache\n", __func__);

receipt.SetStatus(_("could not get lock on cs_spendcache"), ZPIV_TXMINT_GENERAL);

return false;

extern bool fGlobalUnlockSpendCache; // Bool used for letting the precomputing thread know that zpivspends need to use the cs_spendcache

CoinWitnessData::CoinWitnessData(CoinWitnessCacheData& data)

{

SetNull();

denom = data.denom;

isV1 = data.isV1;

libzerocoin::ZerocoinParams* paramsCoin = Params().Zerocoin_Params(isV1);

coin = std::unique_ptr<libzerocoin::PublicCoin>(new libzerocoin::PublicCoin(paramsCoin, data.coinAmount, data.coinDenom));

pAccumulator = std::unique_ptr<libzerocoin::Accumulator>(new libzerocoin::Accumulator(Params().Zerocoin_Params(false), denom, data.accumulatorAmount));

pWitness = std::unique_ptr<libzerocoin::AccumulatorWitness>(new libzerocoin::AccumulatorWitness(Params().Zerocoin_Params(false), *pAccumulator, *coin));

nMintsAdded = data.nMintsAdded;

nHeightMintAdded = data.nHeightMintAdded;

nHeightCheckpoint = data.nHeightCheckpoint;

nHeightAccStart = data.nHeightAccStart;

nHeightAccEnd = data.nHeightAccEnd;

txid = data.txid;

}

void CoinWitnessCacheData::SetNull()

{

nMintsAdded = 0;

nHeightMintAdded = 0;

nHeightCheckpoint = 0;

nHeightAccStart = 0;

nHeightAccEnd = 0;

coinAmount = BN_ZERO;

coinDenom = libzerocoin::CoinDenomination::ZQ_ERROR;

accumulatorAmount = BN_ZERO;

accumulatorDenom = libzerocoin::CoinDenomination::ZQ_ERROR;

}

CoinWitnessCacheData::CoinWitnessCacheData()

{

SetNull();

}

CoinWitnessCacheData::CoinWitnessCacheData(CoinWitnessData* coinWitnessData)

{

SetNull();

denom = coinWitnessData->denom;

isV1 = coinWitnessData->isV1;

txid = coinWitnessData->txid;

nMintsAdded = coinWitnessData->nMintsAdded;

nHeightMintAdded = coinWitnessData->nHeightMintAdded;

nHeightCheckpoint = coinWitnessData->nHeightCheckpoint;

nHeightAccStart = coinWitnessData->nHeightAccStart;

nHeightAccEnd = coinWitnessData->nHeightAccEnd;

coinAmount = coinWitnessData->coin->getValue();

coinDenom = coinWitnessData->coin->getDenomination();

accumulatorAmount = coinWitnessData->pAccumulator->getValue();

accumulatorDenom = coinWitnessData->pAccumulator->getDenomination();

}