zecfoundation
/
zcashd
mirror of https://github.com/ZcashFoundation/zcashd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rename vjoinsplit to vJoinSplit

This commit is contained in:
Dimitris Apostolou 2019-06-16 14:39:05 +03:00 committed by rex4539
parent 9b3cc52c0e
commit f57f76d789
No known key found for this signature in database
GPG Key ID: 4B5D20E938204A8A
27 changed files with 224 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
qa/rpc-tests/test_framework/mininode.py
View File

@ -575,7 +575,7 @@ class CTransaction(object):
self.vout = []
self.nLockTime = 0
self.nExpiryHeight = 0
self.vjoinsplit = []
self.vJoinSplit = []
self.joinSplitPubKey = None
self.joinSplitSig = None
self.sha256 = None
@ -588,7 +588,7 @@ class CTransaction(object):
self.vout = copy.deepcopy(tx.vout)
self.nLockTime = tx.nLockTime
self.nExpiryHeight = tx.nExpiryHeight
self.vjoinsplit = copy.deepcopy(tx.vjoinsplit)
self.vJoinSplit = copy.deepcopy(tx.vJoinSplit)
self.joinSplitPubKey = tx.joinSplitPubKey
self.joinSplitSig = tx.joinSplitSig
self.sha256 = None
@ -612,8 +612,8 @@ class CTransaction(object):
self.nExpiryHeight = struct.unpack("<I", f.read(4))[0]
if self.nVersion >= 2:
self.vjoinsplit = deser_vector(f, JSDescription)
if len(self.vjoinsplit) > 0:
self.vJoinSplit = deser_vector(f, JSDescription)
if len(self.vJoinSplit) > 0:
self.joinSplitPubKey = deser_uint256(f)
self.joinSplitSig = f.read(64)
@ -636,8 +636,8 @@ class CTransaction(object):
if isOverwinterV3:
r += struct.pack("<I", self.nExpiryHeight)
if self.nVersion >= 2:
r += ser_vector(self.vjoinsplit)
if len(self.vjoinsplit) > 0:
r += ser_vector(self.vJoinSplit)
if len(self.vJoinSplit) > 0:
r += ser_uint256(self.joinSplitPubKey)
r += self.joinSplitSig
return r
@ -664,8 +664,8 @@ class CTransaction(object):
% (self.fOverwintered, self.nVersion, self.nVersionGroupId,
repr(self.vin), repr(self.vout), self.nLockTime, self.nExpiryHeight))
if self.nVersion >= 2:
r += " vjoinsplit=%s" % repr(self.vjoinsplit)
if len(self.vjoinsplit) > 0:
r += " vJoinSplit=%s" % repr(self.vJoinSplit)
if len(self.vJoinSplit) > 0:
r += " joinSplitPubKey=%064x joinSplitSig=%064x" \
(self.joinSplitPubKey, self.joinSplitSig)
r += ")"

6
src/coins.cpp
View File

@ -316,7 +316,7 @@ void CCoinsViewCache::PopAnchor(const uint256 &newrt, ShieldedType type) {
}
void CCoinsViewCache::SetNullifiers(const CTransaction& tx, bool spent) {
for (const JSDescription &joinsplit : tx.vjoinsplit) {
for (const JSDescription &joinsplit : tx.vJoinSplit) {
for (const uint256 &nullifier : joinsplit.nullifiers) {
std::pair<CNullifiersMap::iterator, bool> ret = cacheSproutNullifiers.insert(std::make_pair(nullifier, CNullifiersCacheEntry()));
ret.first->second.entered = spent;
@ -566,7 +566,7 @@ bool CCoinsViewCache::HaveShieldedRequirements(const CTransaction& tx) const
{
boost::unordered_map<uint256, SproutMerkleTree, CCoinsKeyHasher> intermediates;
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit)
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit)
{
BOOST_FOREACH(const uint256& nullifier, joinsplit.nullifiers)
{
@ -630,7 +630,7 @@ double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight) const
// use the maximum priority for all (partially or fully) shielded transactions.
// (Note that coinbase transactions cannot contain JoinSplits, or Sapling shielded Spends or Outputs.)
if (tx.vjoinsplit.size() > 0 || tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0) {
if (tx.vJoinSplit.size() > 0 || tx.vShieldedSpend.size() > 0 || tx.vShieldedOutput.size() > 0) {
return MAX_PRIORITY;
}

74
src/gtest/test_checktransaction.cpp
View File

@ -18,9 +18,9 @@ TEST(checktransaction_tests, check_vpub_not_both_nonzero) {
CMutableTransaction newTx(tx);
CValidationState state;
newTx.vjoinsplit.push_back(JSDescription());
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vjoinsplit[0];
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->vpub_old = 1;
jsdesc->vpub_new = 1;
@ -61,11 +61,11 @@ CMutableTransaction GetValidTransaction() {
// mtx.vout[0].scriptPubKey =
mtx.vout[0].nValue = 0;
mtx.vout[1].nValue = 0;
mtx.vjoinsplit.resize(2);
mtx.vjoinsplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vjoinsplit[0].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
mtx.vjoinsplit[1].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000002");
mtx.vjoinsplit[1].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000003");
mtx.vJoinSplit.resize(2);
mtx.vJoinSplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vJoinSplit[0].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000001");
mtx.vJoinSplit[1].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000002");
mtx.vJoinSplit[1].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000003");
CreateJoinSplitSignature(mtx, consensusBranchId);
return mtx;
@ -115,7 +115,7 @@ TEST(checktransaction_tests, BadVersionTooLow) {
TEST(checktransaction_tests, bad_txns_vin_empty) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.vin.resize(0);
CTransaction tx(mtx);
@ -126,7 +126,7 @@ TEST(checktransaction_tests, bad_txns_vin_empty) {
TEST(checktransaction_tests, bad_txns_vout_empty) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.vout.resize(0);
CTransaction tx(mtx);
@ -179,8 +179,8 @@ TEST(checktransaction_tests, BadTxnsOversize) {
mtx.nVersion = SAPLING_TX_VERSION;
// Change the proof types (which requires re-signing the JoinSplit data)
mtx.vjoinsplit[0].proof = libzcash::GrothProof();
mtx.vjoinsplit[1].proof = libzcash::GrothProof();
mtx.vJoinSplit[0].proof = libzcash::GrothProof();
mtx.vJoinSplit[1].proof = libzcash::GrothProof();
CreateJoinSplitSignature(mtx, NetworkUpgradeInfo[Consensus::UPGRADE_SAPLING].nBranchId);
CTransaction tx(mtx);
@ -204,8 +204,8 @@ TEST(checktransaction_tests, OversizeSaplingTxns) {
mtx.nVersion = SAPLING_TX_VERSION;
// Change the proof types (which requires re-signing the JoinSplit data)
mtx.vjoinsplit[0].proof = libzcash::GrothProof();
mtx.vjoinsplit[1].proof = libzcash::GrothProof();
mtx.vJoinSplit[0].proof = libzcash::GrothProof();
mtx.vJoinSplit[1].proof = libzcash::GrothProof();
CreateJoinSplitSignature(mtx, NetworkUpgradeInfo[Consensus::UPGRADE_SAPLING].nBranchId);
// Transaction just under the limit
@ -337,7 +337,7 @@ TEST(checktransaction_tests, ValueBalanceOverflowsTotal) {
TEST(checktransaction_tests, bad_txns_txouttotal_toolarge_joinsplit) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vout[0].nValue = 1;
mtx.vjoinsplit[0].vpub_old = MAX_MONEY;
mtx.vJoinSplit[0].vpub_old = MAX_MONEY;
CTransaction tx(mtx);
@ -348,8 +348,8 @@ TEST(checktransaction_tests, bad_txns_txouttotal_toolarge_joinsplit) {
TEST(checktransaction_tests, bad_txns_txintotal_toolarge_joinsplit) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_new = MAX_MONEY - 1;
mtx.vjoinsplit[1].vpub_new = MAX_MONEY - 1;
mtx.vJoinSplit[0].vpub_new = MAX_MONEY - 1;
mtx.vJoinSplit[1].vpub_new = MAX_MONEY - 1;
CTransaction tx(mtx);
@ -360,7 +360,7 @@ TEST(checktransaction_tests, bad_txns_txintotal_toolarge_joinsplit) {
TEST(checktransaction_tests, bad_txns_vpub_old_negative) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_old = -1;
mtx.vJoinSplit[0].vpub_old = -1;
CTransaction tx(mtx);
@ -371,7 +371,7 @@ TEST(checktransaction_tests, bad_txns_vpub_old_negative) {
TEST(checktransaction_tests, bad_txns_vpub_new_negative) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_new = -1;
mtx.vJoinSplit[0].vpub_new = -1;
CTransaction tx(mtx);
@ -382,7 +382,7 @@ TEST(checktransaction_tests, bad_txns_vpub_new_negative) {
TEST(checktransaction_tests, bad_txns_vpub_old_toolarge) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_old = MAX_MONEY + 1;
mtx.vJoinSplit[0].vpub_old = MAX_MONEY + 1;
CTransaction tx(mtx);
@ -393,7 +393,7 @@ TEST(checktransaction_tests, bad_txns_vpub_old_toolarge) {
TEST(checktransaction_tests, bad_txns_vpub_new_toolarge) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_new = MAX_MONEY + 1;
mtx.vJoinSplit[0].vpub_new = MAX_MONEY + 1;
CTransaction tx(mtx);
@ -404,8 +404,8 @@ TEST(checktransaction_tests, bad_txns_vpub_new_toolarge) {
TEST(checktransaction_tests, bad_txns_vpubs_both_nonzero) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].vpub_old = 1;
mtx.vjoinsplit[0].vpub_new = 1;
mtx.vJoinSplit[0].vpub_old = 1;
mtx.vJoinSplit[0].vpub_new = 1;
CTransaction tx(mtx);
@ -428,8 +428,8 @@ TEST(checktransaction_tests, bad_txns_inputs_duplicate) {
TEST(checktransaction_tests, bad_joinsplits_nullifiers_duplicate_same_joinsplit) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vjoinsplit[0].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vJoinSplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vJoinSplit[0].nullifiers.at(1) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
CTransaction tx(mtx);
@ -440,8 +440,8 @@ TEST(checktransaction_tests, bad_joinsplits_nullifiers_duplicate_same_joinsplit)
TEST(checktransaction_tests, bad_joinsplits_nullifiers_duplicate_different_joinsplit) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vjoinsplit[1].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vJoinSplit[0].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
mtx.vJoinSplit[1].nullifiers.at(0) = uint256S("0000000000000000000000000000000000000000000000000000000000000000");
CTransaction tx(mtx);
@ -456,7 +456,7 @@ TEST(checktransaction_tests, bad_cb_has_joinsplits) {
mtx.vin.resize(1);
mtx.vin[0].prevout.SetNull();
mtx.vjoinsplit.resize(1);
mtx.vJoinSplit.resize(1);
CTransaction tx(mtx);
EXPECT_TRUE(tx.IsCoinBase());
@ -472,7 +472,7 @@ TEST(checktransaction_tests, bad_cb_empty_scriptsig) {
mtx.vin.resize(1);
mtx.vin[0].prevout.SetNull();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
CTransaction tx(mtx);
EXPECT_TRUE(tx.IsCoinBase());
@ -643,7 +643,7 @@ TEST(checktransaction_tests, OverwinterDefaultValues) {
// A valid v3 transaction with no joinsplits
TEST(checktransaction_tests, OverwinterValidTx) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_TX_VERSION;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
@ -655,7 +655,7 @@ TEST(checktransaction_tests, OverwinterValidTx) {
TEST(checktransaction_tests, OverwinterExpiryHeight) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_TX_VERSION;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
@ -696,7 +696,7 @@ TEST(checktransaction_tests, OverwinterExpiryHeight) {
// given the new Overwinter logic
TEST(checktransaction_tests, SproutTxVersionTooLow) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = false;
mtx.nVersion = -1;
@ -718,7 +718,7 @@ class UNSAFE_CTransaction : public CTransaction {
TEST(checktransaction_tests, SaplingSproutInputSumsTooLarge) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = SAPLING_TX_VERSION;
mtx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
@ -746,12 +746,12 @@ TEST(checktransaction_tests, SaplingSproutInputSumsTooLarge) {
inputMap, outputMap,
0, 0, false);
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
}
mtx.vShieldedSpend.push_back(SpendDescription());
mtx.vjoinsplit[0].vpub_new = (MAX_MONEY / 2) + 10;
mtx.vJoinSplit[0].vpub_new = (MAX_MONEY / 2) + 10;
{
UNSAFE_CTransaction tx(mtx);
@ -772,7 +772,7 @@ TEST(checktransaction_tests, SaplingSproutInputSumsTooLarge) {
// Test bad Overwinter version number in CheckTransactionWithoutProofVerification
TEST(checktransaction_tests, OverwinterVersionNumberLow) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_MIN_TX_VERSION - 1;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
@ -790,7 +790,7 @@ TEST(checktransaction_tests, OverwinterVersionNumberHigh) {
UpdateNetworkUpgradeParameters(Consensus::UPGRADE_OVERWINTER, Consensus::NetworkUpgrade::ALWAYS_ACTIVE);
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_MAX_TX_VERSION + 1;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
@ -809,7 +809,7 @@ TEST(checktransaction_tests, OverwinterVersionNumberHigh) {
// Test bad Overwinter version group id
TEST(checktransaction_tests, OverwinterBadVersionGroupId) {
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0);
mtx.vJoinSplit.resize(0);
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_TX_VERSION;
mtx.nExpiryHeight = 0;

10
src/gtest/test_mempool.cpp
View File

@ -174,7 +174,7 @@ TEST(Mempool, OverwinterNotActiveYet) {
CTxMemPool pool(::minRelayTxFee);
bool missingInputs;
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0); // no joinsplits
mtx.vJoinSplit.resize(0); // no joinsplits
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_TX_VERSION;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
@ -200,7 +200,7 @@ TEST(Mempool, SproutV3TxFailsAsExpected) {
CTxMemPool pool(::minRelayTxFee);
bool missingInputs;
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0); // no joinsplits
mtx.vJoinSplit.resize(0); // no joinsplits
mtx.fOverwintered = false;
mtx.nVersion = 3;
CValidationState state1;
@ -221,7 +221,7 @@ TEST(Mempool, SproutV3TxWhenOverwinterActive) {
CTxMemPool pool(::minRelayTxFee);
bool missingInputs;
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0); // no joinsplits
mtx.vJoinSplit.resize(0); // no joinsplits
mtx.fOverwintered = false;
mtx.nVersion = 3;
CValidationState state1;
@ -245,7 +245,7 @@ TEST(Mempool, SproutNegativeVersionTxWhenOverwinterActive) {
CTxMemPool pool(::minRelayTxFee);
bool missingInputs;
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0); // no joinsplits
mtx.vJoinSplit.resize(0); // no joinsplits
mtx.fOverwintered = false;
// A Sprout transaction with version -3 is created using Sprout code (as found in zcashd <= 1.0.14).
@ -294,7 +294,7 @@ TEST(Mempool, ExpiringSoonTxRejection) {
CTxMemPool pool(::minRelayTxFee);
bool missingInputs;
CMutableTransaction mtx = GetValidTransaction();
mtx.vjoinsplit.resize(0); // no joinsplits
mtx.vJoinSplit.resize(0); // no joinsplits
mtx.fOverwintered = true;
mtx.nVersion = OVERWINTER_TX_VERSION;
mtx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;

36
src/gtest/test_transaction_builder.cpp
View File

@ -100,7 +100,7 @@ TEST(TransactionBuilder, TransparentToSapling)
EXPECT_EQ(tx.vin.size(), 1);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 0);
EXPECT_EQ(tx.vShieldedOutput.size(), 1);
EXPECT_EQ(tx.valueBalance, -40000);
@ -137,7 +137,7 @@ TEST(TransactionBuilder, SaplingToSapling) {
EXPECT_EQ(tx.vin.size(), 0);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 1);
EXPECT_EQ(tx.vShieldedOutput.size(), 2);
EXPECT_EQ(tx.valueBalance, 10000);
@ -173,9 +173,9 @@ TEST(TransactionBuilder, SaplingToSprout) {
EXPECT_EQ(tx.vin.size(), 0);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 1);
EXPECT_EQ(tx.vjoinsplit[0].vpub_old, 25000);
EXPECT_EQ(tx.vjoinsplit[0].vpub_new, 0);
EXPECT_EQ(tx.vJoinSplit.size(), 1);
EXPECT_EQ(tx.vJoinSplit[0].vpub_old, 25000);
EXPECT_EQ(tx.vJoinSplit[0].vpub_new, 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 1);
EXPECT_EQ(tx.vShieldedOutput.size(), 1);
EXPECT_EQ(tx.valueBalance, 35000);
@ -203,7 +203,7 @@ TEST(TransactionBuilder, SproutToSproutAndSapling) {
SproutMerkleTree sproutTree;
for (int i = 0; i < ZC_NUM_JS_OUTPUTS; i++) {
sproutTree.append(wtx.vjoinsplit[0].commitments[i]);
sproutTree.append(wtx.vJoinSplit[0].commitments[i]);
}
SproutWitness sproutWitness = sproutTree.witness();
// Fake a view with the Sprout note in it
@ -230,13 +230,13 @@ TEST(TransactionBuilder, SproutToSproutAndSapling) {
EXPECT_EQ(tx.vout.size(), 0);
// TODO: This should be doable in two JoinSplits.
// There's an inefficiency in the implementation.
EXPECT_EQ(tx.vjoinsplit.size(), 3);
EXPECT_EQ(tx.vjoinsplit[0].vpub_old, 0);
EXPECT_EQ(tx.vjoinsplit[0].vpub_new, 0);
EXPECT_EQ(tx.vjoinsplit[1].vpub_old, 0);
EXPECT_EQ(tx.vjoinsplit[1].vpub_new, 0);
EXPECT_EQ(tx.vjoinsplit[2].vpub_old, 0);
EXPECT_EQ(tx.vjoinsplit[2].vpub_new, 10000);
EXPECT_EQ(tx.vJoinSplit.size(), 3);
EXPECT_EQ(tx.vJoinSplit[0].vpub_old, 0);
EXPECT_EQ(tx.vJoinSplit[0].vpub_new, 0);
EXPECT_EQ(tx.vJoinSplit[1].vpub_old, 0);
EXPECT_EQ(tx.vJoinSplit[1].vpub_new, 0);
EXPECT_EQ(tx.vJoinSplit[2].vpub_old, 0);
EXPECT_EQ(tx.vJoinSplit[2].vpub_new, 10000);
EXPECT_EQ(tx.vShieldedSpend.size(), 0);
EXPECT_EQ(tx.vShieldedOutput.size(), 1);
EXPECT_EQ(tx.valueBalance, -5000);
@ -373,7 +373,7 @@ TEST(TransactionBuilder, ChangeOutput)
EXPECT_EQ(tx.vin.size(), 1);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 1);
EXPECT_EQ(tx.vShieldedOutput.size(), 1);
EXPECT_EQ(tx.valueBalance, -15000);
@ -388,7 +388,7 @@ TEST(TransactionBuilder, ChangeOutput)
EXPECT_EQ(tx.vin.size(), 1);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 0);
EXPECT_EQ(tx.vShieldedOutput.size(), 1);
EXPECT_EQ(tx.valueBalance, -15000);
@ -403,7 +403,7 @@ TEST(TransactionBuilder, ChangeOutput)
EXPECT_EQ(tx.vin.size(), 1);
EXPECT_EQ(tx.vout.size(), 1);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 0);
EXPECT_EQ(tx.vShieldedOutput.size(), 0);
EXPECT_EQ(tx.valueBalance, 0);
@ -435,7 +435,7 @@ TEST(TransactionBuilder, SetFee)
EXPECT_EQ(tx.vin.size(), 0);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 1);
EXPECT_EQ(tx.vShieldedOutput.size(), 2);
EXPECT_EQ(tx.valueBalance, 10000);
@ -451,7 +451,7 @@ TEST(TransactionBuilder, SetFee)
EXPECT_EQ(tx.vin.size(), 0);
EXPECT_EQ(tx.vout.size(), 0);
EXPECT_EQ(tx.vjoinsplit.size(), 0);
EXPECT_EQ(tx.vJoinSplit.size(), 0);
EXPECT_EQ(tx.vShieldedSpend.size(), 1);
EXPECT_EQ(tx.vShieldedOutput.size(), 2);
EXPECT_EQ(tx.valueBalance, 20000);

32
src/main.cpp
View File

@ -980,7 +980,7 @@ bool ContextualCheckTransaction(
uint256 dataToBeSigned;
if (!tx.vjoinsplit.empty() ||
if (!tx.vJoinSplit.empty() ||
!tx.vShieldedSpend.empty() ||
!tx.vShieldedOutput.empty())
{
@ -995,7 +995,7 @@ bool ContextualCheckTransaction(
}
}
if (!tx.vjoinsplit.empty())
if (!tx.vJoinSplit.empty())
{
BOOST_STATIC_ASSERT(crypto_sign_PUBLICKEYBYTES == 32);
@ -1079,7 +1079,7 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state,
return false;
} else {
// Ensure that zk-SNARKs verify
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
if (!joinsplit.Verify(*pzcashParams, verifier, tx.joinSplitPubKey)) {
return state.DoS(100, error("CheckTransaction(): joinsplit does not verify"),
REJECT_INVALID, "bad-txns-joinsplit-verification-failed");
@ -1136,13 +1136,13 @@ bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidatio
}
// Transactions containing empty `vin` must have either non-empty
// `vjoinsplit` or non-empty `vShieldedSpend`.
if (tx.vin.empty() && tx.vjoinsplit.empty() && tx.vShieldedSpend.empty())
// `vJoinSplit` or non-empty `vShieldedSpend`.
if (tx.vin.empty() && tx.vJoinSplit.empty() && tx.vShieldedSpend.empty())
return state.DoS(10, error("CheckTransaction(): vin empty"),
REJECT_INVALID, "bad-txns-vin-empty");
// Transactions containing empty `vout` must have either non-empty
// `vjoinsplit` or non-empty `vShieldedOutput`.
if (tx.vout.empty() && tx.vjoinsplit.empty() && tx.vShieldedOutput.empty())
// `vJoinSplit` or non-empty `vShieldedOutput`.
if (tx.vout.empty() && tx.vJoinSplit.empty() && tx.vShieldedOutput.empty())
return state.DoS(10, error("CheckTransaction(): vout empty"),
REJECT_INVALID, "bad-txns-vout-empty");
@ -1192,7 +1192,7 @@ bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidatio
}
// Ensure that joinsplit values are well-formed
BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
BOOST_FOREACH(const JSDescription& joinsplit, tx.vJoinSplit)
{
if (joinsplit.vpub_old < 0) {
return state.DoS(100, error("CheckTransaction(): joinsplit.vpub_old negative"),
@ -1232,7 +1232,7 @@ bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidatio
// to the value pool.
{
CAmount nValueIn = 0;
for (std::vector<JSDescription>::const_iterator it(tx.vjoinsplit.begin()); it != tx.vjoinsplit.end(); ++it)
for (std::vector<JSDescription>::const_iterator it(tx.vJoinSplit.begin()); it != tx.vJoinSplit.end(); ++it)
{
nValueIn += it->vpub_new;
@ -1267,7 +1267,7 @@ bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidatio
// Check for duplicate joinsplit nullifiers in this transaction
{
set<uint256> vJoinSplitNullifiers;
BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit)
BOOST_FOREACH(const JSDescription& joinsplit, tx.vJoinSplit)
{
BOOST_FOREACH(const uint256& nf, joinsplit.nullifiers)
{
@ -1296,7 +1296,7 @@ bool CheckTransactionWithoutProofVerification(const CTransaction& tx, CValidatio
if (tx.IsCoinBase())
{
// There should be no joinsplits in a coinbase transaction
if (tx.vjoinsplit.size() > 0)
if (tx.vJoinSplit.size() > 0)
return state.DoS(100, error("CheckTransaction(): coinbase has joinsplits"),
REJECT_INVALID, "bad-cb-has-joinsplits");
@ -1429,7 +1429,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
return false;
}
}
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
if (pool.nullifierExists(nf, SPROUT)) {
return false;
@ -1528,7 +1528,7 @@ bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const CTransa
unsigned int nSize = entry.GetTxSize();
// Accept a tx if it contains joinsplits and has at least the default fee specified by z_sendmany.
if (tx.vjoinsplit.size() > 0 && nFees >= ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE) {
if (tx.vJoinSplit.size() > 0 && nFees >= ASYNC_RPC_OPERATION_DEFAULT_MINERS_FEE) {
// In future we will we have more accurate and dynamic computation of fees for tx with joinsplits.
} else {
// Don't accept it if it can't get into a block
@ -2726,7 +2726,7 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
}
UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256 &note_commitment, joinsplit.commitments) {
// Insert the note commitments into our temporary tree.
@ -3546,7 +3546,7 @@ bool ReceivedBlockTransactions(
// pool. So we invert the sign here.
saplingValue += -tx.valueBalance;
for (auto js : tx.vjoinsplit) {
for (auto js : tx.vJoinSplit) {
sproutValue += js.vpub_old;
sproutValue -= js.vpub_new;
}
@ -5806,7 +5806,7 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
}
// TODO: currently, prohibit joinsplits and shielded spends/outputs from entering mapOrphans
else if (fMissingInputs &&
tx.vjoinsplit.empty() &&
tx.vJoinSplit.empty() &&
tx.vShieldedSpend.empty() &&
tx.vShieldedOutput.empty())
{

2
src/miner.cpp
View File

@ -334,7 +334,7 @@ CBlockTemplate* CreateNewBlock(const CChainParams& chainparams, const CScript& s
saplingValueDummy += -tx.valueBalance;
for (auto js : tx.vjoinsplit) {
for (auto js : tx.vJoinSplit) {
sproutValueDummy += js.vpub_old;
sproutValueDummy -= js.vpub_new;
}

16
src/primitives/transaction.cpp
View File

@ -203,7 +203,7 @@ CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::SPROUT_MIN_C
CMutableTransaction::CMutableTransaction(const CTransaction& tx) : nVersion(tx.nVersion), fOverwintered(tx.fOverwintered), nVersionGroupId(tx.nVersionGroupId), nExpiryHeight(tx.nExpiryHeight),
vin(tx.vin), vout(tx.vout), nLockTime(tx.nLockTime),
valueBalance(tx.valueBalance), vShieldedSpend(tx.vShieldedSpend), vShieldedOutput(tx.vShieldedOutput),
vjoinsplit(tx.vjoinsplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
vJoinSplit(tx.vJoinSplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
bindingSig(tx.bindingSig)
{
@ -219,12 +219,12 @@ void CTransaction::UpdateHash() const
*const_cast<uint256*>(&hash) = SerializeHash(*this);
}
CTransaction::CTransaction() : nVersion(CTransaction::SPROUT_MIN_CURRENT_VERSION), fOverwintered(false), nVersionGroupId(0), nExpiryHeight(0), vin(), vout(), nLockTime(0), valueBalance(0), vShieldedSpend(), vShieldedOutput(), vjoinsplit(), joinSplitPubKey(), joinSplitSig(), bindingSig() { }
CTransaction::CTransaction() : nVersion(CTransaction::SPROUT_MIN_CURRENT_VERSION), fOverwintered(false), nVersionGroupId(0), nExpiryHeight(0), vin(), vout(), nLockTime(0), valueBalance(0), vShieldedSpend(), vShieldedOutput(), vJoinSplit(), joinSplitPubKey(), joinSplitSig(), bindingSig() { }
CTransaction::CTransaction(const CMutableTransaction &tx) : nVersion(tx.nVersion), fOverwintered(tx.fOverwintered), nVersionGroupId(tx.nVersionGroupId), nExpiryHeight(tx.nExpiryHeight),
vin(tx.vin), vout(tx.vout), nLockTime(tx.nLockTime),
valueBalance(tx.valueBalance), vShieldedSpend(tx.vShieldedSpend), vShieldedOutput(tx.vShieldedOutput),
vjoinsplit(tx.vjoinsplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
vJoinSplit(tx.vJoinSplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
bindingSig(tx.bindingSig)
{
UpdateHash();
@ -237,7 +237,7 @@ CTransaction::CTransaction(
bool evilDeveloperFlag) : nVersion(tx.nVersion), fOverwintered(tx.fOverwintered), nVersionGroupId(tx.nVersionGroupId), nExpiryHeight(tx.nExpiryHeight),
vin(tx.vin), vout(tx.vout), nLockTime(tx.nLockTime),
valueBalance(tx.valueBalance), vShieldedSpend(tx.vShieldedSpend), vShieldedOutput(tx.vShieldedOutput),
vjoinsplit(tx.vjoinsplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
vJoinSplit(tx.vJoinSplit), joinSplitPubKey(tx.joinSplitPubKey), joinSplitSig(tx.joinSplitSig),
bindingSig(tx.bindingSig)
{
assert(evilDeveloperFlag);
@ -247,7 +247,7 @@ CTransaction::CTransaction(CMutableTransaction &&tx) : nVersion(tx.nVersion), fO
vin(std::move(tx.vin)), vout(std::move(tx.vout)), nLockTime(tx.nLockTime), nExpiryHeight(tx.nExpiryHeight),
valueBalance(tx.valueBalance),
vShieldedSpend(std::move(tx.vShieldedSpend)), vShieldedOutput(std::move(tx.vShieldedOutput)),
vjoinsplit(std::move(tx.vjoinsplit)),
vJoinSplit(std::move(tx.vJoinSplit)),
joinSplitPubKey(std::move(tx.joinSplitPubKey)), joinSplitSig(std::move(tx.joinSplitSig))
{
UpdateHash();
@ -264,7 +264,7 @@ CTransaction& CTransaction::operator=(const CTransaction &tx) {
*const_cast<CAmount*>(&valueBalance) = tx.valueBalance;
*const_cast<std::vector<SpendDescription>*>(&vShieldedSpend) = tx.vShieldedSpend;
*const_cast<std::vector<OutputDescription>*>(&vShieldedOutput) = tx.vShieldedOutput;
*const_cast<std::vector<JSDescription>*>(&vjoinsplit) = tx.vjoinsplit;
*const_cast<std::vector<JSDescription>*>(&vJoinSplit) = tx.vJoinSplit;
*const_cast<uint256*>(&joinSplitPubKey) = tx.joinSplitPubKey;
*const_cast<joinsplit_sig_t*>(&joinSplitSig) = tx.joinSplitSig;
*const_cast<binding_sig_t*>(&bindingSig) = tx.bindingSig;
@ -291,7 +291,7 @@ CAmount CTransaction::GetValueOut() const
}
}
for (std::vector<JSDescription>::const_iterator it(vjoinsplit.begin()); it != vjoinsplit.end(); ++it)
for (std::vector<JSDescription>::const_iterator it(vJoinSplit.begin()); it != vJoinSplit.end(); ++it)
{
// NB: vpub_old "takes" money from the transparent value pool just as outputs do
nValueOut += it->vpub_old;
@ -315,7 +315,7 @@ CAmount CTransaction::GetShieldedValueIn() const
}
}
for (std::vector<JSDescription>::const_iterator it(vjoinsplit.begin()); it != vjoinsplit.end(); ++it)
for (std::vector<JSDescription>::const_iterator it(vJoinSplit.begin()); it != vJoinSplit.end(); ++it)
{
// NB: vpub_new "gives" money to the transparent value pool just as inputs do
nValue += it->vpub_new;

12
src/primitives/transaction.h
View File

@ -555,7 +555,7 @@ public:
const CAmount valueBalance;
const std::vector<SpendDescription> vShieldedSpend;
const std::vector<OutputDescription> vShieldedOutput;
const std::vector<JSDescription> vjoinsplit;
const std::vector<JSDescription> vJoinSplit;
const uint256 joinSplitPubKey;
const joinsplit_sig_t joinSplitSig = {{0}};
const binding_sig_t bindingSig = {{0}};
@ -612,8 +612,8 @@ public:
}
if (nVersion >= 2) {
auto os = WithVersion(&s, static_cast<int>(header));
::SerReadWrite(os, *const_cast<std::vector<JSDescription>*>(&vjoinsplit), ser_action);
if (vjoinsplit.size() > 0) {
::SerReadWrite(os, *const_cast<std::vector<JSDescription>*>(&vJoinSplit), ser_action);
if (vJoinSplit.size() > 0) {
READWRITE(*const_cast<uint256*>(&joinSplitPubKey));
READWRITE(*const_cast<joinsplit_sig_t*>(&joinSplitSig));
}
@ -702,7 +702,7 @@ struct CMutableTransaction
CAmount valueBalance;
std::vector<SpendDescription> vShieldedSpend;
std::vector<OutputDescription> vShieldedOutput;
std::vector<JSDescription> vjoinsplit;
std::vector<JSDescription> vJoinSplit;
uint256 joinSplitPubKey;
CTransaction::joinsplit_sig_t joinSplitSig = {{0}};
CTransaction::binding_sig_t bindingSig = {{0}};
@ -758,8 +758,8 @@ struct CMutableTransaction
}
if (nVersion >= 2) {
auto os = WithVersion(&s, static_cast<int>(header));
::SerReadWrite(os, vjoinsplit, ser_action);
if (vjoinsplit.size() > 0) {
::SerReadWrite(os, vJoinSplit, ser_action);
if (vJoinSplit.size() > 0) {
READWRITE(joinSplitPubKey);
READWRITE(joinSplitSig);
}

10
src/rpc/rawtransaction.cpp
View File

@ -60,9 +60,9 @@ void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fInclud
UniValue TxJoinSplitToJSON(const CTransaction& tx) {
bool useGroth = tx.fOverwintered && tx.nVersion >= SAPLING_TX_VERSION;
UniValue vjoinsplit(UniValue::VARR);
for (unsigned int i = 0; i < tx.vjoinsplit.size(); i++) {
const JSDescription& jsdescription = tx.vjoinsplit[i];
UniValue vJoinSplit(UniValue::VARR);
for (unsigned int i = 0; i < tx.vJoinSplit.size(); i++) {
const JSDescription& jsdescription = tx.vJoinSplit[i];
UniValue joinsplit(UniValue::VOBJ);
joinsplit.push_back(Pair("vpub_old", ValueFromAmount(jsdescription.vpub_old)));
@ -110,9 +110,9 @@ UniValue TxJoinSplitToJSON(const CTransaction& tx) {
joinsplit.push_back(Pair("ciphertexts", ciphertexts));
}
vjoinsplit.push_back(joinsplit);
vJoinSplit.push_back(joinsplit);
}
return vjoinsplit;
return vJoinSplit;
}
UniValue TxShieldedSpendsToJSON(const CTransaction& tx) {

12
src/script/interpreter.cpp
View File

@ -1038,7 +1038,7 @@ public:
// Serialize nLockTime
::Serialize(s, txTo.nLockTime);
// Serialize vjoinsplit
// Serialize vJoinSplit
if (txTo.nVersion >= 2) {
//
// SIGHASH_* functions will hash portions of
@ -1046,8 +1046,8 @@ public:
// keeps the JoinSplit cryptographically bound
// to the transaction.
//
::Serialize(s, txTo.vjoinsplit);
if (txTo.vjoinsplit.size() > 0) {
::Serialize(s, txTo.vJoinSplit);
if (txTo.vJoinSplit.size() > 0) {
::Serialize(s, txTo.joinSplitPubKey);
CTransaction::joinsplit_sig_t nullSig = {};
@ -1096,8 +1096,8 @@ uint256 GetOutputsHash(const CTransaction& txTo) {
uint256 GetJoinSplitsHash(const CTransaction& txTo) {
CBLAKE2bWriter ss(SER_GETHASH, static_cast<int>(txTo.GetHeader()), ZCASH_JOINSPLITS_HASH_PERSONALIZATION);
for (unsigned int n = 0; n < txTo.vjoinsplit.size(); n++) {
ss << txTo.vjoinsplit[n];
for (unsigned int n = 0; n < txTo.vJoinSplit.size(); n++) {
ss << txTo.vJoinSplit[n];
}
ss << txTo.joinSplitPubKey;
return ss.GetHash();
@ -1188,7 +1188,7 @@ uint256 SignatureHash(
hashOutputs = ss.GetHash();
}
if (!txTo.vjoinsplit.empty()) {
if (!txTo.vJoinSplit.empty()) {
hashJoinSplits = cache ? cache->hashJoinSplits : GetJoinSplitsHash(txTo);
}

26
src/test/coins_tests.cpp
View File

@ -237,7 +237,7 @@ public:
sproutNullifier = GetRandHash();
JSDescription jsd;
jsd.nullifiers[0] = sproutNullifier;
mutableTx.vjoinsplit.emplace_back(jsd);
mutableTx.vJoinSplit.emplace_back(jsd);
saplingNullifier = GetRandHash();
SpendDescription sd;
@ -640,7 +640,7 @@ BOOST_AUTO_TEST_CASE(chained_joinsplits)
{
CMutableTransaction mtx;
mtx.vjoinsplit.push_back(js2);
mtx.vJoinSplit.push_back(js2);
BOOST_CHECK(!cache.HaveShieldedRequirements(mtx));
}
@ -649,35 +649,35 @@ BOOST_AUTO_TEST_CASE(chained_joinsplits)
// js2 is trying to anchor to js1 but js1
// appears afterwards -- not a permitted ordering
CMutableTransaction mtx;
mtx.vjoinsplit.push_back(js2);
mtx.vjoinsplit.push_back(js1);
mtx.vJoinSplit.push_back(js2);
mtx.vJoinSplit.push_back(js1);
BOOST_CHECK(!cache.HaveShieldedRequirements(mtx));
}
{
CMutableTransaction mtx;
mtx.vjoinsplit.push_back(js1);
mtx.vjoinsplit.push_back(js2);
mtx.vJoinSplit.push_back(js1);
mtx.vJoinSplit.push_back(js2);
BOOST_CHECK(cache.HaveShieldedRequirements(mtx));
}
{
CMutableTransaction mtx;
mtx.vjoinsplit.push_back(js1);
mtx.vjoinsplit.push_back(js2);
mtx.vjoinsplit.push_back(js3);
mtx.vJoinSplit.push_back(js1);
mtx.vJoinSplit.push_back(js2);
mtx.vJoinSplit.push_back(js3);
BOOST_CHECK(cache.HaveShieldedRequirements(mtx));
}
{
CMutableTransaction mtx;
mtx.vjoinsplit.push_back(js1);
mtx.vjoinsplit.push_back(js1b);
mtx.vjoinsplit.push_back(js2);
mtx.vjoinsplit.push_back(js3);
mtx.vJoinSplit.push_back(js1);
mtx.vJoinSplit.push_back(js1b);
mtx.vJoinSplit.push_back(js2);
mtx.vJoinSplit.push_back(js3);
BOOST_CHECK(cache.HaveShieldedRequirements(mtx));
}

4
src/test/sighash_tests.cpp
View File

@ -124,7 +124,7 @@ void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t co
tx.vout.clear();
tx.vShieldedSpend.clear();
tx.vShieldedOutput.clear();
tx.vjoinsplit.clear();
tx.vJoinSplit.clear();
tx.nLockTime = (insecure_rand() % 2) ? insecure_rand() : 0;
int ins = (insecure_rand() % 4) + 1;
int outs = fSingle ? ins : (insecure_rand() % 4) + 1;
@ -193,7 +193,7 @@ void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t co
jsdesc.macs[0] = GetRandHash();
jsdesc.macs[1] = GetRandHash();
tx.vjoinsplit.push_back(jsdesc);
tx.vJoinSplit.push_back(jsdesc);
}
unsigned char joinSplitPrivKey[crypto_sign_SECRETKEYBYTES];

30
src/test/transaction_tests.cpp
View File

@ -484,8 +484,8 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
BOOST_CHECK(!CheckTransactionWithoutProofVerification(newTx, state));
BOOST_CHECK(state.GetRejectReason() == "bad-txns-vout-empty");
newTx.vjoinsplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vjoinsplit[0];
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[1] = GetRandHash();
@ -512,9 +512,9 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
CMutableTransaction newTx(tx);
CValidationState state;
newTx.vjoinsplit.push_back(JSDescription());
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vjoinsplit[0];
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->vpub_old = -1;
BOOST_CHECK(!CheckTransaction(newTx, state, verifier));
@ -538,9 +538,9 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
jsdesc->vpub_new = (MAX_MONEY / 2) + 10;
newTx.vjoinsplit.push_back(JSDescription());
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc2 = &newTx.vjoinsplit[1];
JSDescription *jsdesc2 = &newTx.vJoinSplit[1];
jsdesc2->vpub_new = (MAX_MONEY / 2) + 10;
BOOST_CHECK(!CheckTransaction(newTx, state, verifier));
@ -551,8 +551,8 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
CMutableTransaction newTx(tx);
CValidationState state;
newTx.vjoinsplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vjoinsplit[0];
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[1] = jsdesc->nullifiers[0];
@ -562,9 +562,9 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
jsdesc->nullifiers[1] = GetRandHash();
newTx.vjoinsplit.push_back(JSDescription());
jsdesc = &newTx.vjoinsplit[0]; // Fixes #2026. Related PR #2078.
JSDescription *jsdesc2 = &newTx.vjoinsplit[1];
newTx.vJoinSplit.push_back(JSDescription());
jsdesc = &newTx.vJoinSplit[0]; // Fixes #2026. Related PR #2078.
JSDescription *jsdesc2 = &newTx.vJoinSplit[1];
jsdesc2->nullifiers[0] = GetRandHash();
jsdesc2->nullifiers[1] = jsdesc->nullifiers[0];
@ -577,8 +577,8 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
CMutableTransaction newTx(tx);
CValidationState state;
newTx.vjoinsplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vjoinsplit[0];
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[1] = GetRandHash();
@ -831,11 +831,11 @@ BOOST_AUTO_TEST_CASE(test_IsStandardV2)
BOOST_CHECK(IsStandardTx(t, reason, chainparams));
// ... and with one JoinSplit.
t.vjoinsplit.push_back(JSDescription());
t.vJoinSplit.push_back(JSDescription());
BOOST_CHECK(IsStandardTx(t, reason, chainparams));
// ... and when that JoinSplit takes from a transparent input.
JSDescription *jsdesc = &t.vjoinsplit[0];
JSDescription *jsdesc = &t.vJoinSplit[0];
jsdesc->vpub_old = 10*CENT;
t.vout[0].nValue -= 10*CENT;
BOOST_CHECK(IsStandardTx(t, reason, chainparams));

10
src/transaction_builder.cpp
View File

@ -508,12 +508,12 @@ void TransactionBuilder::CreateJSDescriptions()
JSDescription prevJoinSplit;
// Keep track of previous JoinSplit and its commitments
if (mtx.vjoinsplit.size() > 0) {
prevJoinSplit = mtx.vjoinsplit.back();
if (mtx.vJoinSplit.size() > 0) {
prevJoinSplit = mtx.vJoinSplit.back();
}
// If there is no change, the chain has terminated so we can reset the tracked treestate.
if (jsChange == 0 && mtx.vjoinsplit.size() > 0) {
if (jsChange == 0 && mtx.vJoinSplit.size() > 0) {
intermediates.clear();
previousCommitments.clear();
}
@ -679,7 +679,7 @@ void TransactionBuilder::CreateJSDescription(
std::array<size_t, ZC_NUM_JS_OUTPUTS>& outputMap)
{
LogPrint("zrpcunsafe", "CreateJSDescription: creating joinsplit at index %d (vpub_old=%s, vpub_new=%s, in[0]=%s, in[1]=%s, out[0]=%s, out[1]=%s)\n",
mtx.vjoinsplit.size(),
mtx.vJoinSplit.size(),
FormatMoney(vpub_old), FormatMoney(vpub_new),
FormatMoney(vjsin[0].note.value()), FormatMoney(vjsin[1].note.value()),
FormatMoney(vjsout[0].value), FormatMoney(vjsout[1].value));
@ -708,7 +708,7 @@ void TransactionBuilder::CreateJSDescription(
}
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// TODO: Sprout payment disclosure
}

10
src/txmempool.cpp
View File

@ -105,7 +105,7 @@ bool CTxMemPool::addUnchecked(const uint256& hash, const CTxMemPoolEntry &entry,
const CTransaction& tx = mapTx.find(hash)->GetTx();
for (unsigned int i = 0; i < tx.vin.size(); i++)
mapNextTx[tx.vin[i].prevout] = CInPoint(&tx, i);
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
mapSproutNullifiers[nf] = &tx;
}
@ -158,7 +158,7 @@ void CTxMemPool::remove(const CTransaction &origTx, std::list<CTransaction>& rem
}
BOOST_FOREACH(const CTxIn& txin, tx.vin)
mapNextTx.erase(txin.prevout);
BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription& joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256& nf, joinsplit.nullifiers) {
mapSproutNullifiers.erase(nf);
}
@ -219,7 +219,7 @@ void CTxMemPool::removeWithAnchor(const uint256 &invalidRoot, ShieldedType type)
const CTransaction& tx = it->GetTx();
switch (type) {
case SPROUT:
BOOST_FOREACH(const JSDescription& joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription& joinsplit, tx.vJoinSplit) {
if (joinsplit.anchor == invalidRoot) {
transactionsToRemove.push_back(tx);
break;
@ -262,7 +262,7 @@ void CTxMemPool::removeConflicts(const CTransaction &tx, std::list<CTransaction>
}
}
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
std::map<uint256, const CTransaction*>::iterator it = mapSproutNullifiers.find(nf);
if (it != mapSproutNullifiers.end()) {
@ -407,7 +407,7 @@ void CTxMemPool::check(const CCoinsViewCache *pcoins) const
boost::unordered_map<uint256, SproutMerkleTree, CCoinsKeyHasher> intermediates;
BOOST_FOREACH(const JSDescription &joinsplit, tx.vjoinsplit) {
BOOST_FOREACH(const JSDescription &joinsplit, tx.vJoinSplit) {
BOOST_FOREACH(const uint256 &nf, joinsplit.nullifiers) {
assert(!pcoins->GetNullifier(nf, SPROUT));
}

14
src/utiltest.cpp
View File

@ -48,7 +48,7 @@ CMutableTransaction GetValidSproutReceiveTransaction(ZCJoinSplit& params,
uint256 rt;
JSDescription jsdesc {false, params, mtx.joinSplitPubKey, rt,
inputs, outputs, 2*value, 0, false};
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Consider: The following is a bit misleading (given the name of this function)
// and should perhaps be changed, but currently a few tests in test_wallet.cpp
@ -97,8 +97,8 @@ CWalletTx GetInvalidCommitmentSproutReceive(ZCJoinSplit& params,
CMutableTransaction mtx = GetValidSproutReceiveTransaction(
params, sk, value, randomInputs, version
);
mtx.vjoinsplit[0].commitments[0] = uint256();
mtx.vjoinsplit[0].commitments[1] = uint256();
mtx.vJoinSplit[0].commitments[0] = uint256();
mtx.vJoinSplit[0].commitments[1] = uint256();
CTransaction tx {mtx};
CWalletTx wtx {NULL, tx};
return wtx;
@ -108,11 +108,11 @@ libzcash::SproutNote GetSproutNote(ZCJoinSplit& params,
const libzcash::SproutSpendingKey& sk,
const CTransaction& tx, size_t js, size_t n) {
ZCNoteDecryption decryptor {sk.receiving_key()};
auto hSig = tx.vjoinsplit[js].h_sig(params, tx.joinSplitPubKey);
auto hSig = tx.vJoinSplit[js].h_sig(params, tx.joinSplitPubKey);
auto note_pt = libzcash::SproutNotePlaintext::decrypt(
decryptor,
tx.vjoinsplit[js].ciphertexts[n],
tx.vjoinsplit[js].ephemeralKey,
tx.vJoinSplit[js].ciphertexts[n],
tx.vJoinSplit[js].ephemeralKey,
hSig,
(unsigned char) n);
return note_pt.note(sk.address());
@ -169,7 +169,7 @@ CWalletTx GetValidSproutSpend(ZCJoinSplit& params,
uint256 rt = tree.root();
JSDescription jsdesc {false, params, mtx.joinSplitPubKey, rt,
inputs, outputs, 0, value, false};
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Empty output script.
uint32_t consensusBranchId = SPROUT_BRANCH_ID;

14
src/wallet/asyncrpcoperation_mergetoaddress.cpp
View File

@ -532,12 +532,12 @@ bool AsyncRPCOperation_mergetoaddress::main_impl()
JSDescription prevJoinSplit;
// Keep track of previous JoinSplit and its commitments
if (tx_.vjoinsplit.size() > 0) {
prevJoinSplit = tx_.vjoinsplit.back();
if (tx_.vJoinSplit.size() > 0) {
prevJoinSplit = tx_.vJoinSplit.back();
}
// If there is no change, the chain has terminated so we can reset the tracked treestate.
if (jsChange == 0 && tx_.vjoinsplit.size() > 0) {
if (jsChange == 0 && tx_.vJoinSplit.size() > 0) {
intermediates.clear();
previousCommitments.clear();
}
@ -645,7 +645,7 @@ bool AsyncRPCOperation_mergetoaddress::main_impl()
wtxHeight = mapBlockIndex[wtx.hashBlock]->nHeight;
wtxDepth = wtx.GetDepthInMainChain();
}
LogPrint("zrpcunsafe", "%s: spending note (txid=%s, vjoinsplit=%d, jsoutindex=%d, amount=%s, height=%d, confirmations=%d)\n",
LogPrint("zrpcunsafe", "%s: spending note (txid=%s, vJoinSplit=%d, jsoutindex=%d, amount=%s, height=%d, confirmations=%d)\n",
getId(),
jso.hash.ToString().substr(0, 10),
jso.js,
@ -877,7 +877,7 @@ UniValue AsyncRPCOperation_mergetoaddress::perform_joinsplit(
LogPrint("zrpcunsafe", "%s: creating joinsplit at index %d (vpub_old=%s, vpub_new=%s, in[0]=%s, in[1]=%s, out[0]=%s, out[1]=%s)\n",
getId(),
tx_.vjoinsplit.size(),
tx_.vJoinSplit.size(),
FormatMoney(info.vpub_old), FormatMoney(info.vpub_new),
FormatMoney(info.vjsin[0].note.value()), FormatMoney(info.vjsin[1].note.value()),
FormatMoney(info.vjsout[0].value), FormatMoney(info.vjsout[1].value));
@ -910,7 +910,7 @@ UniValue AsyncRPCOperation_mergetoaddress::perform_joinsplit(
}
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Empty output script.
CScript scriptCode;
@ -973,7 +973,7 @@ UniValue AsyncRPCOperation_mergetoaddress::perform_joinsplit(
memcpy(&buffer[0], &joinSplitPrivKey_[0], 32); // private key in first half of 64 byte buffer
std::vector<unsigned char> vch(&buffer[0], &buffer[0] + 32);
uint256 joinSplitPrivKey = uint256(vch);
size_t js_index = tx_.vjoinsplit.size() - 1;
size_t js_index = tx_.vJoinSplit.size() - 1;
uint256 placeholder;
for (int i = 0; i < ZC_NUM_JS_OUTPUTS; i++) {
uint8_t mapped_index = outputMap[i];

2
src/wallet/asyncrpcoperation_saplingmigration.cpp
View File

@ -116,7 +116,7 @@ bool AsyncRPCOperation_saplingmigration::main_impl() {
availableFunds -= fromNoteAmount;
for (const SproutNoteEntry& sproutEntry : fromNotes) {
std::string data(sproutEntry.memo.begin(), sproutEntry.memo.end());
LogPrint("zrpcunsafe", "%s: Adding Sprout note input (txid=%s, vjoinsplit=%d, jsoutindex=%d, amount=%s, memo=%s)\n",
LogPrint("zrpcunsafe", "%s: Adding Sprout note input (txid=%s, vJoinSplit=%d, jsoutindex=%d, amount=%s, memo=%s)\n",
getId(),
sproutEntry.jsop.hash.ToString().substr(0, 10),
sproutEntry.jsop.js,

16
src/wallet/asyncrpcoperation_sendmany.cpp
View File

@ -674,12 +674,12 @@ bool AsyncRPCOperation_sendmany::main_impl() {
JSDescription prevJoinSplit;
// Keep track of previous JoinSplit and its commitments
if (tx_.vjoinsplit.size() > 0) {
prevJoinSplit = tx_.vjoinsplit.back();
if (tx_.vJoinSplit.size() > 0) {
prevJoinSplit = tx_.vJoinSplit.back();
}
// If there is no change, the chain has terminated so we can reset the tracked treestate.
if (jsChange==0 && tx_.vjoinsplit.size() > 0) {
if (jsChange==0 && tx_.vJoinSplit.size() > 0) {
intermediates.clear();
previousCommitments.clear();
}
@ -784,7 +784,7 @@ bool AsyncRPCOperation_sendmany::main_impl() {
wtxHeight = mapBlockIndex[wtx.hashBlock]->nHeight;
wtxDepth = wtx.GetDepthInMainChain();
}
LogPrint("zrpcunsafe", "%s: spending note (txid=%s, vjoinsplit=%d, jsoutindex=%d, amount=%s, height=%d, confirmations=%d)\n",
LogPrint("zrpcunsafe", "%s: spending note (txid=%s, vJoinSplit=%d, jsoutindex=%d, amount=%s, height=%d, confirmations=%d)\n",
getId(),
jso.hash.ToString().substr(0, 10),
jso.js,
@ -1048,7 +1048,7 @@ bool AsyncRPCOperation_sendmany::find_unspent_notes() {
for (SproutNoteEntry & entry : sproutEntries) {
z_sprout_inputs_.push_back(SendManyInputJSOP(entry.jsop, entry.note, CAmount(entry.note.value())));
std::string data(entry.memo.begin(), entry.memo.end());
LogPrint("zrpcunsafe", "%s: found unspent Sprout note (txid=%s, vjoinsplit=%d, jsoutindex=%d, amount=%s, memo=%s)\n",
LogPrint("zrpcunsafe", "%s: found unspent Sprout note (txid=%s, vJoinSplit=%d, jsoutindex=%d, amount=%s, memo=%s)\n",
getId(),
entry.jsop.hash.ToString().substr(0, 10),
entry.jsop.js,
@ -1144,7 +1144,7 @@ UniValue AsyncRPCOperation_sendmany::perform_joinsplit(
LogPrint("zrpcunsafe", "%s: creating joinsplit at index %d (vpub_old=%s, vpub_new=%s, in[0]=%s, in[1]=%s, out[0]=%s, out[1]=%s)\n",
getId(),
tx_.vjoinsplit.size(),
tx_.vJoinSplit.size(),
FormatMoney(info.vpub_old), FormatMoney(info.vpub_new),
FormatMoney(info.vjsin[0].note.value()), FormatMoney(info.vjsin[1].note.value()),
FormatMoney(info.vjsout[0].value), FormatMoney(info.vjsout[1].value)
@ -1180,7 +1180,7 @@ UniValue AsyncRPCOperation_sendmany::perform_joinsplit(
}
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Empty output script.
CScript scriptCode;
@ -1247,7 +1247,7 @@ UniValue AsyncRPCOperation_sendmany::perform_joinsplit(
memcpy(&buffer[0], &joinSplitPrivKey_[0], 32); // private key in first half of 64 byte buffer
std::vector<unsigned char> vch(&buffer[0], &buffer[0] + 32);
uint256 joinSplitPrivKey = uint256(vch);
size_t js_index = tx_.vjoinsplit.size() - 1;
size_t js_index = tx_.vJoinSplit.size() - 1;
uint256 placeholder;
for (int i = 0; i < ZC_NUM_JS_OUTPUTS; i++) {
uint8_t mapped_index = outputMap[i];

8
src/wallet/asyncrpcoperation_shieldcoinbase.cpp
View File

@ -61,7 +61,7 @@ AsyncRPCOperation_shieldcoinbase::AsyncRPCOperation_shieldcoinbase(
UniValue contextInfo) :
builder_(builder), tx_(contextualTx), inputs_(inputs), fee_(fee), contextinfo_(contextInfo)
{
assert(contextualTx.nVersion >= 2); // transaction format version must support vjoinsplit
assert(contextualTx.nVersion >= 2); // transaction format version must support vJoinSplit
if (fee < 0 || fee > MAX_MONEY) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Fee is out of range");
@ -392,7 +392,7 @@ UniValue AsyncRPCOperation_shieldcoinbase::perform_joinsplit(ShieldCoinbaseJSInf
LogPrint("zrpcunsafe", "%s: creating joinsplit at index %d (vpub_old=%s, vpub_new=%s, in[0]=%s, in[1]=%s, out[0]=%s, out[1]=%s)\n",
getId(),
tx_.vjoinsplit.size(),
tx_.vJoinSplit.size(),
FormatMoney(info.vpub_old), FormatMoney(info.vpub_new),
FormatMoney(info.vjsin[0].note.value()), FormatMoney(info.vjsin[1].note.value()),
FormatMoney(info.vjsout[0].value), FormatMoney(info.vjsout[1].value)
@ -428,7 +428,7 @@ UniValue AsyncRPCOperation_shieldcoinbase::perform_joinsplit(ShieldCoinbaseJSInf
}
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Empty output script.
CScript scriptCode;
@ -494,7 +494,7 @@ UniValue AsyncRPCOperation_shieldcoinbase::perform_joinsplit(ShieldCoinbaseJSInf
memcpy(&buffer[0], &joinSplitPrivKey_[0], 32); // private key in first half of 64 byte buffer
std::vector<unsigned char> vch(&buffer[0], &buffer[0] + 32);
uint256 joinSplitPrivKey = uint256(vch);
size_t js_index = tx_.vjoinsplit.size() - 1;
size_t js_index = tx_.vJoinSplit.size() - 1;
uint256 placeholder;
for (int i = 0; i < ZC_NUM_JS_OUTPUTS; i++) {
uint8_t mapped_index = outputMap[i];

16
src/wallet/gtest/test_wallet.cpp
View File

@ -451,11 +451,11 @@ TEST(WalletTests, CheckSproutNoteCommitmentAgainstNotePlaintext) {
auto note = GetSproutNote(sk, wtx, 0, 1);
auto nullifier = note.nullifier(sk);
auto hSig = wtx.vjoinsplit[0].h_sig(
auto hSig = wtx.vJoinSplit[0].h_sig(
*params, wtx.joinSplitPubKey);
ASSERT_THROW(wallet.GetSproutNoteNullifier(
wtx.vjoinsplit[0],
wtx.vJoinSplit[0],
address,
dec,
hSig, 1), libzcash::note_decryption_failed);
@ -472,11 +472,11 @@ TEST(WalletTests, GetSproutNoteNullifier) {
auto note = GetSproutNote(sk, wtx, 0, 1);
auto nullifier = note.nullifier(sk);
auto hSig = wtx.vjoinsplit[0].h_sig(
auto hSig = wtx.vJoinSplit[0].h_sig(
*params, wtx.joinSplitPubKey);
auto ret = wallet.GetSproutNoteNullifier(
wtx.vjoinsplit[0],
wtx.vJoinSplit[0],
address,
dec,
hSig, 1);
@ -485,7 +485,7 @@ TEST(WalletTests, GetSproutNoteNullifier) {
wallet.AddSproutSpendingKey(sk);
ret = wallet.GetSproutNoteNullifier(
wtx.vjoinsplit[0],
wtx.vJoinSplit[0],
address,
dec,
hSig, 1);
@ -1072,7 +1072,7 @@ TEST(WalletTests, SpentSaplingNoteIsFromMe) {
auto tx2 = builder2.Build().GetTxOrThrow();
EXPECT_EQ(tx2.vin.size(), 0);
EXPECT_EQ(tx2.vout.size(), 0);
EXPECT_EQ(tx2.vjoinsplit.size(), 0);
EXPECT_EQ(tx2.vJoinSplit.size(), 0);
EXPECT_EQ(tx2.vShieldedSpend.size(), 1);
EXPECT_EQ(tx2.vShieldedOutput.size(), 2);
EXPECT_EQ(tx2.valueBalance, 10000);
@ -1919,7 +1919,7 @@ TEST(WalletTests, MarkAffectedSaplingTransactionsDirty) {
EXPECT_EQ(tx1.vin.size(), 1);
EXPECT_EQ(tx1.vout.size(), 0);
EXPECT_EQ(tx1.vjoinsplit.size(), 0);
EXPECT_EQ(tx1.vJoinSplit.size(), 0);
EXPECT_EQ(tx1.vShieldedSpend.size(), 0);
EXPECT_EQ(tx1.vShieldedOutput.size(), 1);
EXPECT_EQ(tx1.valueBalance, -40000);
@ -1974,7 +1974,7 @@ TEST(WalletTests, MarkAffectedSaplingTransactionsDirty) {
EXPECT_EQ(tx2.vin.size(), 0);
EXPECT_EQ(tx2.vout.size(), 0);
EXPECT_EQ(tx2.vjoinsplit.size(), 0);
EXPECT_EQ(tx2.vJoinSplit.size(), 0);
EXPECT_EQ(tx2.vShieldedSpend.size(), 1);
EXPECT_EQ(tx2.vShieldedOutput.size(), 2);
EXPECT_EQ(tx2.valueBalance, 10000);

2
src/wallet/paymentdisclosure.h
View File

@ -74,7 +74,7 @@ struct PaymentDisclosurePayload {
uint8_t version; // 0 = experimental, 1 = first production version, etc.
uint256 esk; // zcash/NoteEncryption.cpp
uint256 txid; // primitives/transaction.h
uint64_t js; // Index into CTransaction.vjoinsplit
uint64_t js; // Index into CTransaction.vJoinSplit
uint8_t n; // Index into JSDescription fields of length ZC_NUM_JS_OUTPUTS
libzcash::SproutPaymentAddress zaddr; // zcash/Address.hpp
std::string message; // parameter to RPC call

10
src/wallet/rpcdisclosure.cpp
View File

@ -98,13 +98,13 @@ UniValue z_getpaymentdisclosure(const UniValue& params, bool fHelp)
const CWalletTx& wtx = pwalletMain->mapWallet[hash];
// Check if shielded tx
if (wtx.vjoinsplit.empty()) {
if (wtx.vJoinSplit.empty()) {
throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not a shielded transaction");
}
// Check js_index
int js_index = params[1].get_int();
if (js_index < 0 || js_index >= wtx.vjoinsplit.size()) {
if (js_index < 0 || js_index >= wtx.vJoinSplit.size()) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid js_index");
}
@ -220,7 +220,7 @@ UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp)
}
// Check if shielded tx
if (tx.vjoinsplit.empty()) {
if (tx.vJoinSplit.empty()) {
throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not a shielded transaction");
}
@ -229,7 +229,7 @@ UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp)
o.push_back(Pair("txid", pd.payload.txid.ToString()));
// Check js_index
if (pd.payload.js >= tx.vjoinsplit.size()) {
if (pd.payload.js >= tx.vJoinSplit.size()) {
errs.push_back("Payment disclosure refers to an invalid joinsplit index");
}
o.push_back(Pair("jsIndex", pd.payload.js));
@ -260,7 +260,7 @@ UniValue z_validatepaymentdisclosure(const UniValue& params, bool fHelp)
try {
// Decrypt the note to get value and memo field
JSDescription jsdesc = tx.vjoinsplit[pd.payload.js];
JSDescription jsdesc = tx.vJoinSplit[pd.payload.js];
uint256 h_sig = jsdesc.h_sig(*pzcashParams, tx.joinSplitPubKey);
ZCPaymentDisclosureNoteDecryption decrypter;

14
src/wallet/rpcwallet.cpp
View File

@ -3063,7 +3063,7 @@ UniValue zc_raw_joinsplit(const UniValue& params, bool fHelp)
assert(jsdesc.Verify(*pzcashParams, verifier, joinSplitPubKey));
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
// Empty output script.
CScript scriptCode;
@ -3828,7 +3828,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp)
if (mtx.fOverwintered && (mtx.nVersion >= SAPLING_TX_VERSION)) {
jsdesc.proof = GrothProof();
}
mtx.vjoinsplit.push_back(jsdesc);
mtx.vJoinSplit.push_back(jsdesc);
}
}
CTransaction tx(mtx);
@ -3896,7 +3896,7 @@ UniValue z_sendmany(const UniValue& params, bool fHelp)
CMutableTransaction contextualTx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), nextBlockHeight);
bool isShielded = !fromTaddr || zaddrRecipients.size() > 0;
if (contextualTx.nVersion == 1 && isShielded) {
contextualTx.nVersion = 2; // Tx format should support vjoinsplits
contextualTx.nVersion = 2; // Tx format should support vJoinSplits
}
// Create operation and add to global queue
@ -3990,9 +3990,9 @@ UniValue z_getmigrationstatus(const UniValue& params, bool fHelp) {
// * one or more Sprout JoinSplits with nonzero vpub_new field; and
// * no Sapling Spends, and;
// * one or more Sapling Outputs.
if (tx.vjoinsplit.size() > 0 && tx.vShieldedSpend.empty() && tx.vShieldedOutput.size() > 0) {
if (tx.vJoinSplit.size() > 0 && tx.vShieldedSpend.empty() && tx.vShieldedOutput.size() > 0) {
bool nonZeroVPubNew = false;
for (const auto& js : tx.vjoinsplit) {
for (const auto& js : tx.vJoinSplit) {
if (js.vpub_new > 0) {
nonZeroVPubNew = true;
break;
@ -4235,7 +4235,7 @@ UniValue z_shieldcoinbase(const UniValue& params, bool fHelp)
CMutableTransaction contextualTx = CreateNewContextualCMutableTransaction(
Params().GetConsensus(), nextBlockHeight);
if (contextualTx.nVersion == 1) {
contextualTx.nVersion = 2; // Tx format should support vjoinsplits
contextualTx.nVersion = 2; // Tx format should support vJoinSplit
}
// Create operation and add to global queue
@ -4648,7 +4648,7 @@ UniValue z_mergetoaddress(const UniValue& params, bool fHelp)
nextBlockHeight);
bool isSproutShielded = sproutNoteInputs.size() > 0 || isToSproutZaddr;
if (contextualTx.nVersion == 1 && isSproutShielded) {
contextualTx.nVersion = 2; // Tx format should support vjoinsplit
contextualTx.nVersion = 2; // Tx format should support vJoinSplit
}
// Builder (used if Sapling addresses are involved)

44
src/wallet/wallet.cpp
View File

@ -705,7 +705,7 @@ bool CWallet::IsNoteSproutChange(
// - Notes created by consolidation transactions (e.g. using
// z_mergetoaddress).
// - Notes sent from one address to itself.
for (const JSDescription & jsd : mapWallet[jsop.hash].vjoinsplit) {
for (const JSDescription & jsd : mapWallet[jsop.hash].vJoinSplit) {
for (const uint256 & nullifier : jsd.nullifiers) {
if (nullifierSet.count(std::make_pair(address, nullifier))) {
return true;
@ -797,7 +797,7 @@ set<uint256> CWallet::GetConflicts(const uint256& txid) const
std::pair<TxNullifiers::const_iterator, TxNullifiers::const_iterator> range_n;
for (const JSDescription& jsdesc : wtx.vjoinsplit) {
for (const JSDescription& jsdesc : wtx.vJoinSplit) {
for (const uint256& nullifier : jsdesc.nullifiers) {
if (mapTxSproutNullifiers.count(nullifier) <= 1) {
continue; // No conflict if zero or one spends
@ -1004,7 +1004,7 @@ void CWallet::AddToSpends(const uint256& wtxid)
for (const CTxIn& txin : thisTx.vin) {
AddToTransparentSpends(txin.prevout, wtxid);
}
for (const JSDescription& jsdesc : thisTx.vjoinsplit) {
for (const JSDescription& jsdesc : thisTx.vJoinSplit) {
for (const uint256& nullifier : jsdesc.nullifiers) {
AddToSproutSpends(nullifier, wtxid);
}
@ -1142,8 +1142,8 @@ void CWallet::IncrementNoteWitnesses(const CBlockIndex* pindex,
auto hash = tx.GetHash();
bool txIsOurs = mapWallet.count(hash);
// Sprout
for (size_t i = 0; i < tx.vjoinsplit.size(); i++) {
const JSDescription& jsdesc = tx.vjoinsplit[i];
for (size_t i = 0; i < tx.vJoinSplit.size(); i++) {
const JSDescription& jsdesc = tx.vJoinSplit[i];
for (uint8_t j = 0; j < jsdesc.commitments.size(); j++) {
const uint256& note_commitment = jsdesc.commitments[j];
sproutTree.append(note_commitment);
@ -1400,10 +1400,10 @@ bool CWallet::UpdateNullifierNoteMap()
if (!item.second.nullifier) {
if (GetNoteDecryptor(item.second.address, dec)) {
auto i = item.first.js;
auto hSig = wtxItem.second.vjoinsplit[i].h_sig(
auto hSig = wtxItem.second.vJoinSplit[i].h_sig(
*pzcashParams, wtxItem.second.joinSplitPubKey);
item.second.nullifier = GetSproutNoteNullifier(
wtxItem.second.vjoinsplit[i],
wtxItem.second.vJoinSplit[i],
item.second.address,
dec,
hSig,
@ -1729,7 +1729,7 @@ void CWallet::MarkAffectedTransactionsDirty(const CTransaction& tx)
if (mapWallet.count(txin.prevout.hash))
mapWallet[txin.prevout.hash].MarkDirty();
}
for (const JSDescription& jsdesc : tx.vjoinsplit) {
for (const JSDescription& jsdesc : tx.vJoinSplit) {
for (const uint256& nullifier : jsdesc.nullifiers) {
if (mapSproutNullifiersToNotes.count(nullifier) &&
mapWallet.count(mapSproutNullifiersToNotes[nullifier].hash)) {
@ -1808,15 +1808,15 @@ mapSproutNoteData_t CWallet::FindMySproutNotes(const CTransaction &tx) const
uint256 hash = tx.GetHash();
mapSproutNoteData_t noteData;
for (size_t i = 0; i < tx.vjoinsplit.size(); i++) {
auto hSig = tx.vjoinsplit[i].h_sig(*pzcashParams, tx.joinSplitPubKey);
for (uint8_t j = 0; j < tx.vjoinsplit[i].ciphertexts.size(); j++) {
for (size_t i = 0; i < tx.vJoinSplit.size(); i++) {
auto hSig = tx.vJoinSplit[i].h_sig(*pzcashParams, tx.joinSplitPubKey);
for (uint8_t j = 0; j < tx.vJoinSplit[i].ciphertexts.size(); j++) {
for (const NoteDecryptorMap::value_type& item : mapNoteDecryptors) {
try {
auto address = item.first;
JSOutPoint jsoutpt {hash, i, j};
auto nullifier = GetSproutNoteNullifier(
tx.vjoinsplit[i],
tx.vJoinSplit[i],
address,
item.second,
hSig, j);
@ -2047,7 +2047,7 @@ bool CWallet::IsFromMe(const CTransaction& tx) const
if (GetDebit(tx, ISMINE_ALL) > 0) {
return true;
}
for (const JSDescription& jsdesc : tx.vjoinsplit) {
for (const JSDescription& jsdesc : tx.vJoinSplit) {
for (const uint256& nullifier : jsdesc.nullifiers) {
if (IsSproutNullifierFromMe(nullifier)) {
return true;
@ -2196,8 +2196,8 @@ void CWalletTx::SetSproutNoteData(mapSproutNoteData_t &noteData)
{
mapSproutNoteData.clear();
for (const std::pair<JSOutPoint, SproutNoteData> nd : noteData) {
if (nd.first.js < vjoinsplit.size() &&
nd.first.n < vjoinsplit[nd.first.js].ciphertexts.size()) {
if (nd.first.js < vJoinSplit.size() &&
nd.first.n < vJoinSplit[nd.first.js].ciphertexts.size()) {
// Store the address and nullifier for the Note
mapSproutNoteData[nd.first] = nd.second;
} else {
@ -2289,7 +2289,7 @@ void CWalletTx::GetAmounts(list<COutputEntry>& listReceived,
if (isFromMyTaddr) {
CAmount myVpubOld = 0;
CAmount myVpubNew = 0;
for (const JSDescription& js : vjoinsplit) {
for (const JSDescription& js : vJoinSplit) {
bool fMyJSDesc = false;
// Check input side
@ -2303,7 +2303,7 @@ void CWalletTx::GetAmounts(list<COutputEntry>& listReceived,
// Check output side
if (!fMyJSDesc) {
for (const std::pair<JSOutPoint, SproutNoteData> nd : this->mapSproutNoteData) {
if (nd.first.js < vjoinsplit.size() && nd.first.n < vjoinsplit[nd.first.js].ciphertexts.size()) {
if (nd.first.js < vJoinSplit.size() && nd.first.n < vJoinSplit[nd.first.js].ciphertexts.size()) {
fMyJSDesc = true;
break;
}
@ -2436,7 +2436,7 @@ void CWallet::WitnessNoteCommitment(std::vector<uint256> commitments,
BOOST_FOREACH(const CTransaction& tx, block.vtx)
{
BOOST_FOREACH(const JSDescription& jsdesc, tx.vjoinsplit)
BOOST_FOREACH(const JSDescription& jsdesc, tx.vJoinSplit)
{
BOOST_FOREACH(const uint256 &note_commitment, jsdesc.commitments)
{
@ -4552,7 +4552,7 @@ void CWallet::GetFilteredNotes(
continue;
}
int i = jsop.js; // Index into CTransaction.vjoinsplit
int i = jsop.js; // Index into CTransaction.vJoinSplit
int j = jsop.n; // Index into JSDescription.ciphertexts
// Get cached decryptor
@ -4563,12 +4563,12 @@ void CWallet::GetFilteredNotes(
}
// determine amount of funds in the note
auto hSig = wtx.vjoinsplit[i].h_sig(*pzcashParams, wtx.joinSplitPubKey);
auto hSig = wtx.vJoinSplit[i].h_sig(*pzcashParams, wtx.joinSplitPubKey);
try {
SproutNotePlaintext plaintext = SproutNotePlaintext::decrypt(
decryptor,
wtx.vjoinsplit[i].ciphertexts[j],
wtx.vjoinsplit[i].ephemeralKey,
wtx.vJoinSplit[i].ciphertexts[j],
wtx.vJoinSplit[i].ephemeralKey,
hSig,
(unsigned char) j);

2
src/wallet/wallet.h
View File

@ -167,7 +167,7 @@ class JSOutPoint
public:
// Transaction hash
uint256 hash;
// Index into CTransaction.vjoinsplit
// Index into CTransaction.vJoinSplit
uint64_t js;
// Index into JSDescription fields of length ZC_NUM_JS_OUTPUTS
uint8_t n;