Skip to content

Commit ecd9bcd

Browse files
random-zebrarandom-zebra
committed
[zPIV] PublicCoinSpend v4 definition
1 parent 0f1f881 commit ecd9bcd

File tree

3 files changed

+113
-39
lines changed

3 files changed

+113
-39
lines changed

‎src/wallet/wallet.cpp‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4214,6 +4214,17 @@ bool CWallet::MintsToInputVectorPublicSpend(std::map<CBigNum, CZerocoinMint>& ma
42144214
// Default error status if not changed below
42154215
receipt.SetStatus(_("Transaction Mint Started"), ZPIV_TXMINT_GENERAL);
42164216

4217+
// Get the chain tip to determine the active public spend version
4218+
int nHeight = 0;
4219+
{
4220+
LOCK(cs_main);
4221+
nHeight = chainActive.Height();
4222+
}
4223+
if (!nHeight)
4224+
return error("%s: Unable to get chain tip height", __func__);
4225+
4226+
int spendVersion = Params().Zerocoin_PublicSpendVersion(nHeight);
4227+
42174228
int nLockAttempts = 0;
42184229
while (nLockAttempts < 100) {
42194230
TRY_LOCK(zpivTracker->cs_spendcache, lockSpendcache);
@@ -4263,7 +4274,7 @@ bool CWallet::MintsToInputVectorPublicSpend(std::map<CBigNum, CZerocoinMint>& ma
42634274

42644275
mint.SetOutputIndex(outputIndex);
42654276
CTxIn in;
4266-
if(!ZPIVModule::createInput(in, mint, hashTxOut)){
4277+
if(!ZPIVModule::createInput(in, mint, hashTxOut, spendVersion)) {
42674278
receipt.SetStatus(_("Cannot create public spend input"), ZPIV_TXMINT_GENERAL);
42684279
return false;
42694280
}
@@ -4485,6 +4496,7 @@ bool CWallet::CreateZerocoinSpendTransaction(
44854496
}
44864497

44874498
//hash with only the output info in it to be used in Signature of Knowledge
4499+
// and in CoinRandomness Schnorr Signature
44884500
uint256 hashTxOut = txNew.GetHash();
44894501

44904502
CBlockIndex* pindexCheckpoint = nullptr;

‎src/zpiv/zpivmodule.cpp‎

Lines changed: 84 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -10,19 +10,66 @@
1010
#include "main.h"
1111
#include "iostream"
1212

13+
PublicCoinSpend::PublicCoinSpend(libzerocoin::ZerocoinParams* params, const uint8_t version,
14+
const CBigNum& serial, const CBigNum& randomness, const uint256& ptxHash, CPubKey* pubkey):
15+
pubCoin(params)
16+
{
17+
this->coinSerialNumber = serial;
18+
this->version = version;
19+
this->spendType = libzerocoin::SpendType::SPEND;
20+
this->ptxHash = ptxHash;
21+
22+
const int coinVersion = getCoinVersion();
23+
24+
if (coinVersion < libzerocoin::PrivateCoin::PUBKEY_VERSION) {
25+
// v1 coins need at least version 4 spends
26+
if (version < PUBSPEND_SCHNORR) {
27+
std::string errMsg = strprintf("Unable to create PublicCoinSpend version %d with coin version 1. "
28+
"Minimum spend version required: %d", version, PUBSPEND_SCHNORR);
29+
throw std::runtime_error(errMsg);
30+
}
31+
32+
} else {
33+
// pubkey available only from v2 coins onwards
34+
this->pubkey = *pubkey;
35+
}
36+
37+
if (version < PUBSPEND_SCHNORR)
38+
this->randomness = randomness;
39+
else
40+
this->schnorrSig = libzerocoin::CoinRandomnessSchnorrSignature(params, randomness, ptxHash);
41+
42+
}
43+
1344
bool PublicCoinSpend::Verify(const libzerocoin::Accumulator& a, bool verifyParams) const {
1445
return validate();
1546
}
1647

1748
bool PublicCoinSpend::validate() const {
18-
libzerocoin::ZerocoinParams* params = Params().Zerocoin_Params(false);
19-
// Check that it opens to the input values
20-
libzerocoin::Commitment commitment(
21-
&params->coinCommitmentGroup, getCoinSerialNumber(), randomness);
49+
bool fUseV1Params = getCoinVersion() < libzerocoin::PrivateCoin::PUBKEY_VERSION;
50+
if (version < PUBSPEND_SCHNORR) {
51+
// spend contains the randomness of the coin
52+
if (fUseV1Params) {
53+
// Only v2+ coins can publish the randomness
54+
std::string errMsg = strprintf("PublicCoinSpend version %d with coin version 1 not allowed. "
55+
"Minimum spend version required: %d", version, PUBSPEND_SCHNORR);
56+
return error("%s: %s", __func__, errMsg);
57+
}
2258

23-
if (commitment.getCommitmentValue() != pubCoin.getValue()){
24-
return error("%s: commitments values are not equal", __func__);
59+
// Check that the coin is a commitment to serial and randomness.
60+
libzerocoin::ZerocoinParams* params = Params().Zerocoin_Params(false);
61+
libzerocoin::Commitment comm(&params->coinCommitmentGroup, getCoinSerialNumber(), randomness);
62+
if (comm.getCommitmentValue() != pubCoin.getValue()) {
63+
return error("%s: commitments values are not equal", __func__);
64+
}
65+
} else {
66+
// spend contains a shnorr signature of ptxHash with the randomness of the coin
67+
libzerocoin::ZerocoinParams* params = Params().Zerocoin_Params(fUseV1Params);
68+
if (!schnorrSig.Verify(params, getCoinSerialNumber(), pubCoin.getValue(), getTxOutHash())) {
69+
return error("%s: schnorr signature does not verify", __func__);
70+
}
2571
}
72+
2673
// Now check that the signature validates with the serial
2774
if (!HasValidSignature()) {
2875
return error("%s: signature invalid", __func__);;
@@ -39,29 +86,41 @@ const uint256 PublicCoinSpend::signatureHash() const
3986

4087
namespace ZPIVModule {
4188

42-
bool createInput(CTxIn &in, CZerocoinMint &mint, uint256 hashTxOut) {
43-
libzerocoin::ZerocoinParams *params = Params().Zerocoin_Params(false);
44-
uint8_t nVersion = mint.GetVersion();
45-
if (nVersion < libzerocoin::PrivateCoin::PUBKEY_VERSION) {
46-
// No v1 serials accepted anymore.
47-
return error("%s: failed to set zPIV privkey mint version=%d", __func__, nVersion);
89+
bool createInput(CTxIn &in, CZerocoinMint &mint, uint256 hashTxOut, const int spendVersion) {
90+
bool fUseV1Params = mint.GetVersion() < libzerocoin::PrivateCoin::PUBKEY_VERSION;
91+
libzerocoin::ZerocoinParams *params = Params().Zerocoin_Params(fUseV1Params);
92+
if (fUseV1Params && spendVersion < PUBSPEND_SCHNORR) {
93+
// v1 coins need at least version 4 spends
94+
std::string errMsg = strprintf("Unable to create PublicCoinSpend version %d with coin version 1. "
95+
"Minimum spend version required: %d", spendVersion, PUBSPEND_SCHNORR);
96+
return error("%s: %s", __func__, errMsg);
4897
}
4998

5099
CKey key;
51-
if (!mint.GetKeyPair(key))
52-
return error("%s: failed to set zPIV privkey mint version=%d", __func__, nVersion);
53100

54-
PublicCoinSpend spend(params, mint.GetSerialNumber(), mint.GetRandomness(), key.GetPubKey());
55-
spend.setTxOutHash(hashTxOut);
101+
CPubKey pk;
102+
CPubKey* pk_ptr = nullptr;
103+
if (!fUseV1Params) {
104+
if (!mint.GetKeyPair(key))
105+
return error("%s: failed to set zPIV privkey mint.", __func__);
106+
pk = key.GetPubKey();
107+
pk_ptr = &pk;
108+
}
109+
110+
PublicCoinSpend spend(params, spendVersion, mint.GetSerialNumber(),
111+
mint.GetRandomness(), hashTxOut, pk_ptr);
112+
56113
spend.outputIndex = mint.GetOutputIndex();
57114
spend.txHash = mint.GetTxHash();
58115
spend.setDenom(mint.GetDenomination());
59116

60117
std::vector<unsigned char> vchSig;
61-
if (!key.Sign(spend.signatureHash(), vchSig))
62-
throw std::runtime_error("ZPIVModule failed to sign signatureHash\n");
118+
if (!fUseV1Params) {
119+
if (!key.Sign(spend.signatureHash(), vchSig))
120+
throw std::runtime_error("ZPIVModule failed to sign signatureHash\n");
63121

64-
spend.setVchSig(vchSig);
122+
spend.setVchSig(vchSig);
123+
}
65124

66125
CDataStream ser(SER_NETWORK, PROTOCOL_VERSION);
67126
ser << spend;
@@ -75,10 +134,14 @@ namespace ZPIVModule {
75134
}
76135

77136
PublicCoinSpend parseCoinSpend(const CTxIn &in) {
137+
libzerocoin::ZerocoinParams *params = Params().Zerocoin_Params(false);
138+
// skip opcode and data-len
139+
uint8_t byteskip(in.scriptSig[1]);
140+
byteskip += 2;
78141
std::vector<char, zero_after_free_allocator<char> > data;
79-
data.insert(data.end(), in.scriptSig.begin() + 4, in.scriptSig.end());
142+
data.insert(data.end(), in.scriptSig.begin() + byteskip, in.scriptSig.end());
80143
CDataStream serializedCoinSpend(data, SER_NETWORK, PROTOCOL_VERSION);
81-
libzerocoin::ZerocoinParams *params = Params().Zerocoin_Params(false);
144+
82145
return PublicCoinSpend(params, serializedCoinSpend);
83146
}
84147

@@ -112,7 +175,6 @@ namespace ZPIVModule {
112175
libzerocoin::IntToZerocoinDenomination(in.nSequence)) != prevOut.nValue) {
113176
return error("PublicCoinSpend validateInput :: input nSequence different to prevout value");
114177
}
115-
116178
return publicSpend.validate();
117179
}
118180

‎src/zpiv/zpivmodule.h‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
#include "libzerocoin/Denominations.h"
1010
#include "libzerocoin/CoinSpend.h"
1111
#include "libzerocoin/Coin.h"
12+
#include "libzerocoin/CoinRandomnessSchnorrSignature.h"
1213
#include "libzerocoin/SpendType.h"
1314
#include "primitives/transaction.h"
1415
#include "script/script.h"
@@ -19,28 +20,21 @@
1920
#include "zpiv/zerocoin.h"
2021
#include "chainparams.h"
2122

22-
static int const COIN_SPEND_PUBLIC_SPEND_VERSION = 3;
23+
static int const PUBSPEND_SCHNORR = 4;
2324

24-
class PublicCoinSpend : public libzerocoin::CoinSpend{
25+
class PublicCoinSpend : public libzerocoin::CoinSpend {
2526
public:
2627

27-
PublicCoinSpend(libzerocoin::ZerocoinParams* params):pubCoin(params){};
28+
PublicCoinSpend(libzerocoin::ZerocoinParams* params): pubCoin(params) {};
2829

29-
PublicCoinSpend(libzerocoin::ZerocoinParams* params,
30-
CBigNum serial, CBigNum randomness, CPubKey pubkey):pubCoin(params){
31-
this->coinSerialNumber = serial;
32-
this->randomness = randomness;
33-
this->pubkey = pubkey;
34-
this->spendType = libzerocoin::SpendType::SPEND;
35-
this->version = COIN_SPEND_PUBLIC_SPEND_VERSION;
36-
};
30+
PublicCoinSpend(libzerocoin::ZerocoinParams* params, const uint8_t version, const CBigNum& serial, const CBigNum& randomness, const uint256& ptxHash, CPubKey* pubkey);
3731

3832
~PublicCoinSpend(){};
3933

4034
template <typename Stream>
4135
PublicCoinSpend(
4236
libzerocoin::ZerocoinParams* params,
43-
Stream& strm):pubCoin(params){
37+
Stream& strm): pubCoin(params) {
4438
strm >> *this;
4539
this->spendType = libzerocoin::SpendType::SPEND;
4640
}
@@ -52,6 +46,7 @@ class PublicCoinSpend : public libzerocoin::CoinSpend{
5246

5347
// Members
5448
CBigNum randomness;
49+
libzerocoin::CoinRandomnessSchnorrSignature schnorrSig;
5550
// prev out values
5651
uint256 txHash = 0;
5752
unsigned int outputIndex = -1;
@@ -63,17 +58,22 @@ class PublicCoinSpend : public libzerocoin::CoinSpend{
6358
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
6459
READWRITE(version);
6560
READWRITE(coinSerialNumber);
66-
READWRITE(randomness);
67-
READWRITE(pubkey);
68-
READWRITE(vchSig);
61+
if (version < PUBSPEND_SCHNORR)
62+
READWRITE(randomness);
63+
else
64+
READWRITE(schnorrSig);
65+
if (libzerocoin::ExtractVersionFromSerial(coinSerialNumber) >= libzerocoin::PrivateCoin::PUBKEY_VERSION) {
66+
READWRITE(pubkey);
67+
READWRITE(vchSig);
68+
}
6969
}
7070
};
7171

7272

7373
class CValidationState;
7474

7575
namespace ZPIVModule {
76-
bool createInput(CTxIn &in, CZerocoinMint& mint, uint256 hashTxOut);
76+
bool createInput(CTxIn &in, CZerocoinMint& mint, uint256 hashTxOut, const int spendVersion);
7777
PublicCoinSpend parseCoinSpend(const CTxIn &in);
7878
bool parseCoinSpend(const CTxIn &in, const CTransaction& tx, const CTxOut &prevOut, PublicCoinSpend& publicCoinSpend);
7979
bool validateInput(const CTxIn &in, const CTxOut &prevOut, const CTransaction& tx, PublicCoinSpend& ret);

0 commit comments

Comments
 (0)