# Test phases:
run_test_phase "${REPOROOT}/qa/zcash/ensure-no-dot-so-in-depends.py"
-run_test_phase "${REPOROOT}/src/zerocash/tests/merkleTest"
run_test_phase "${REPOROOT}/src/zerocash/tests/utilTest"
# If make check fails, show test-suite.log as part of our run_test_phase
bin_PROGRAMS += \
zerocash/GenerateParamsForFiles \
- zerocash/tests/merkleTest \
zerocash/tests/utilTest \
zerocash/tests/zerocashTest \
zerocash/tests/test_zerocash_pour_ppzksnark
$(LIBBITCOIN_CRYPTO) \
$(LIBZEROCASH_LIBS)
-# tests for our incremental merkle tree
-zerocash_tests_merkleTest_SOURCES = zerocash/tests/merkleTest.cpp
-zerocash_tests_merkleTest_LDADD = \
- $(BOOST_LIBS) \
- $(LIBZEROCASH) \
- $(LIBBITCOIN_CRYPTO) \
- $(LIBZEROCASH_LIBS)
-
# tests for utilities that come with zerocash
zerocash_tests_utilTest_SOURCES = zerocash/tests/utilTest.cpp
zerocash_tests_utilTest_LDADD = \
zerocash_tests_zerocashTest_LDADD = \
$(BOOST_LIBS) \
$(LIBZEROCASH) \
+ $(LIBBITCOIN_UTIL) \
$(LIBBITCOIN_CRYPTO) \
$(LIBZEROCASH_LIBS)
#include <boost/foreach.hpp>
#include <boost/unordered_map.hpp>
-#include "zerocash/IncrementalMerkleTree.h"
#include "zcash/IncrementalMerkleTree.hpp"
/**
#include "json/json_spirit_writer_template.h"
#include "zerocash/ZerocashParams.h"
-#include "zerocash/IncrementalMerkleTree.h"
#include "zerocash/PourInput.h"
#include "zerocash/PourOutput.h"
#include "zerocash/Address.h"
// Also, it's generally libzerocash's job to ensure
// the integrity of the scheme through its own tests.
- static const unsigned int TEST_TREE_DEPTH = 3;
-
// construct the r1cs keypair
- auto keypair = ZerocashParams::GenerateNewKeyPair(TEST_TREE_DEPTH);
+ auto keypair = ZerocashParams::GenerateNewKeyPair(INCREMENTAL_MERKLE_TREE_DEPTH);
ZerocashParams p(
- TEST_TREE_DEPTH,
+ INCREMENTAL_MERKLE_TREE_DEPTH,
&keypair
);
// construct a merkle tree
- IncrementalMerkleTree merkleTree(TEST_TREE_DEPTH);
+ ZCIncrementalMerkleTree merkleTree;
Address addr = Address::CreateNewRandomAddress();
Coin coin(addr.getPublicAddress(), 100);
// commitment from coin
- std::vector<bool> commitment(ZC_CM_SIZE * 8);
- convertBytesVectorToVector(coin.getCoinCommitment().getCommitmentValue(), commitment);
+ uint256 commitment(coin.getCoinCommitment().getCommitmentValue());
// insert commitment into the merkle tree
- std::vector<bool> index;
- merkleTree.insertElement(commitment, index);
+ merkleTree.append(commitment);
// compute the merkle root we will be working with
- vector<unsigned char> rt(ZC_ROOT_SIZE);
- {
- vector<bool> root_bv(ZC_ROOT_SIZE * 8);
- merkleTree.getRootValue(root_bv);
- convertVectorToBytesVector(root_bv, rt);
- }
+ uint256 rt = merkleTree.root();
- merkle_authentication_path path(TEST_TREE_DEPTH);
- merkleTree.getWitness(index, path);
+ auto witness = merkleTree.witness();
+ auto path = witness.path();
// create CPourTx
CScript scriptPubKey;
boost::array<PourInput, NUM_POUR_INPUTS> inputs = {
- PourInput(coin, addr, convertVectorToInt(index), path),
- PourInput(TEST_TREE_DEPTH) // dummy input of zero value
+ PourInput(coin, addr, path),
+ PourInput(INCREMENTAL_MERKLE_TREE_DEPTH) // dummy input of zero value
};
boost::array<PourOutput, NUM_POUR_OUTPUTS> outputs = {
PourOutput(50),
#include <utility>
#include <vector>
-#include "zerocash/IncrementalMerkleTree.h"
-
class CBlockFileInfo;
class CBlockIndex;
struct CDiskTxPos;
uint256 commitment = uint256(commitment_v);
assert(pwalletMain != NULL);
- libsnark::merkle_authentication_path path(INCREMENTAL_MERKLE_TREE_DEPTH); // We don't care during receive... yet! :)
- size_t path_index = 0;
+ libzcash::MerklePath path;
uint256 anchor;
- auto found_in_chain = pwalletMain->WitnessBucketCommitment(commitment, path, path_index, anchor);
+ auto found_in_chain = pwalletMain->WitnessBucketCommitment(commitment, path, anchor);
CAmount value_of_bucket = decrypted_bucket.getValue();
std::vector<unsigned char> commitment_v = input_coin.getCoinCommitment().getCommitmentValue();
uint256 commitment = uint256(commitment_v);
- libsnark::merkle_authentication_path path(INCREMENTAL_MERKLE_TREE_DEPTH);
- size_t path_index = 0;
+ libzcash::MerklePath path;
assert(pwalletMain != NULL);
- if (!pwalletMain->WitnessBucketCommitment(commitment, path, path_index, anchor)) {
+ if (!pwalletMain->WitnessBucketCommitment(commitment, path, anchor)) {
throw std::runtime_error("Couldn't find bucket in the blockchain");
}
- vpourin.push_back(PourInput(input_coin, zcaddress, path_index, path));
+ vpourin.push_back(PourInput(input_coin, zcaddress, path));
}
while (vpourin.size() < NUM_POUR_INPUTS) {
}
bool CWallet::WitnessBucketCommitment(uint256 &commitment,
- libsnark::merkle_authentication_path& path,
- size_t &path_index,
+ libzcash::MerklePath &path,
uint256 &final_anchor)
{
- bool res = false;
- std::vector<bool> commitment_index;
-
CBlockIndex* pindex = chainActive.Genesis();
- libzerocash::IncrementalMerkleTree tree(INCREMENTAL_MERKLE_TREE_DEPTH);
+ ZCIncrementalMerkleTree tree;
+ boost::optional<ZCIncrementalWitness> witness = boost::none;
uint256 current_anchor;
while (pindex) {
{
BOOST_FOREACH(const uint256 &bucket_commitment, pour.commitments)
{
- std::vector<bool> commitment_bv(ZC_CM_SIZE * 8);
- std::vector<bool> index;
- std::vector<unsigned char> commitment_value(bucket_commitment.begin(), bucket_commitment.end());
- libzerocash::convertBytesVectorToVector(commitment_value, commitment_bv);
- assert(tree.insertElement(commitment_bv, index));
-
- if (bucket_commitment == commitment) {
- // We've found it! Now, we construct a witness.
- res = true;
- commitment_index = index;
+ if (witness) {
+ witness->append(bucket_commitment);
+ } else {
+ tree.append(bucket_commitment);
+
+ if (bucket_commitment == commitment) {
+ witness = tree.witness();
+ }
}
}
}
}
- {
- std::vector<unsigned char> newrt_v(32);
- tree.getRootValue(newrt_v);
- current_anchor = uint256(newrt_v);
+ if (witness) {
+ current_anchor = witness->root();
+ } else {
+ current_anchor = tree.root();
}
// Consistency check: we should be able to find the current tree
pindex = chainActive.Next(pindex);
}
- if (res) {
- assert(tree.getWitness(commitment_index, path));
- }
+ if (witness) {
+ path = witness->path();
+ final_anchor = current_anchor;
- path_index = libzerocash::convertVectorToInt(commitment_index);
- final_anchor = current_anchor;
+ return true;
+ }
- return res;
+ return false;
}
/**
void SyncTransaction(const CTransaction& tx, const CBlock* pblock);
bool AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate);
void EraseFromWallet(const uint256 &hash);
- bool WitnessBucketCommitment(uint256 &commitment, libsnark::merkle_authentication_path& path, size_t &path_index, uint256 &final_anchor);
+ bool WitnessBucketCommitment(uint256 &commitment, libzcash::MerklePath& path, uint256 &final_anchor);
int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
void ReacceptWalletTransactions();
void ResendWalletTransactions(int64_t nBestBlockTime);
* @copyright MIT license (see LICENSE file)
*****************************************************************************/
-#include "IncrementalMerkleTree.h"
#include "PourInput.h"
namespace libzerocash {
this->old_coin = Coin(this->old_address.getPublicAddress(), 0);
- // dummy merkle tree
- IncrementalMerkleTree merkleTree(tree_depth);
+ ZCIncrementalMerkleTree merkleTree;
+ merkleTree.append(uint256(this->old_coin.getCoinCommitment().getCommitmentValue()));
- // commitment from coin
- std::vector<bool> commitment(ZC_CM_SIZE * 8);
- convertBytesVectorToVector(this->old_coin.getCoinCommitment().getCommitmentValue(), commitment);
+ auto witness = merkleTree.witness();
+ auto merkle_path = witness.path();
- // insert commitment into the merkle tree
- std::vector<bool> index;
- merkleTree.insertElement(commitment, index);
-
- merkleTree.getWitness(index, this->path);
-
- this->merkle_index = 1;
+ this->path = merkle_path.authentication_path;
+ this->merkle_index = convertVectorToInt(merkle_path.index);
}
PourInput::PourInput(Coin old_coin,
Address old_address,
- size_t merkle_index,
- merkle_authentication_path path) : old_coin(old_coin), merkle_index(merkle_index), path(path) {
- this->old_address = old_address;
+ const libzcash::MerklePath &path) : old_address(old_address), old_coin(old_coin), path(path.authentication_path) {
+ this->merkle_index = convertVectorToInt(path.index);
};
} /* namespace libzerocash */
\ No newline at end of file
#include "Coin.h"
#include "ZerocashParams.h"
+#include "zcash/IncrementalMerkleTree.hpp"
+
namespace libzerocash {
class PourInput {
PourInput(Coin old_coin,
Address old_address,
- size_t merkle_index,
- merkle_authentication_path path);
+ const libzcash::MerklePath& path);
Coin old_coin;
Address old_address;
+++ /dev/null
-/** @file
- *****************************************************************************
-
- Test for Merkle tree.
-
- *****************************************************************************
- * @author This file is part of libzerocash, developed by the Zerocash
- * project and contributors (see AUTHORS).
- * @copyright MIT license (see LICENSE file)
- *****************************************************************************/
-
-#include "zerocash/IncrementalMerkleTree.h"
-
-#include <iostream>
-#include <vector>
-
-#define BOOST_TEST_MODULE merkleTest
-#include <boost/test/included/unit_test.hpp>
-
-using namespace libzerocash;
-using namespace std;
-
-void constructNonzeroTestVector(std::vector< std::vector<bool> > &values, uint32_t size)
-{
- values.resize(0);
- std::vector<bool> dummy;
- dummy.resize(256);
- dummy[0] = true;
-
- for (uint32_t i = 0; i < size; i++)
- {
- values.push_back(dummy);
- }
-}
-
-void constructZeroTestVector(std::vector< std::vector<bool> > &values, uint32_t size)
-{
- values.resize(0);
- std::vector<bool> dummy;
- dummy.resize(256);
-
- for (uint32_t i = 0; i < size; i++)
- {
- values.push_back(dummy);
- }
-}
-
-BOOST_AUTO_TEST_CASE( testRootOfTreeOfZerosIsZero ) {
- IncrementalMerkleTree incTree;
- std::vector< std::vector<bool> > values;
- std::vector<bool> actual_root;
-
- constructZeroTestVector(values, 2);
-
- // Create an IncrementalMerkleTree over the values.
- if (incTree.insertVector(values) == false) {
- BOOST_ERROR("Could not insert into the tree.");
- }
- incTree.prune();
- incTree.getRootValue(actual_root);
-
- std::vector<bool> expected_root(32*8, 0);
- BOOST_CHECK( expected_root == actual_root );
-}
-
-void add_values_to_reference(IncrementalMerkleTree &tree, std::vector< std::vector<bool> > &values) {
- IncrementalMerkleTree newtree(20);
-
- if (newtree.insertVector(values) == false) {
- BOOST_ERROR("Could not insert into the tree.");
- }
-
- tree.setTo(newtree);
-}
-
-BOOST_AUTO_TEST_CASE( test_add_values_to_reference ) {
- IncrementalMerkleTree incTree(20);
- IncrementalMerkleTree incTree2(20);
-
- std::vector< std::vector<bool> > values;
- constructNonzeroTestVector(values, 2);
-
- if (incTree.insertVector(values) == false) {
- BOOST_ERROR("Could not insert into the tree.");
- }
-
- add_values_to_reference(incTree2, values);
-
- {
- std::vector<bool> root1, root2;
- incTree.getRootValue(root1);
- incTree2.getRootValue(root2);
-
- BOOST_CHECK(root1 == root2);
- }
-}
-
-BOOST_AUTO_TEST_CASE( testRootOfTreeOfNonZeroIsNonZero ) {
- IncrementalMerkleTree incTree;
- std::vector< std::vector<bool> > values;
- std::vector<bool> actual_root;
-
- constructNonzeroTestVector(values, 2);
-
- // Create an IncrementalMerkleTree over the values.
- if (incTree.insertVector(values) == false) {
- BOOST_ERROR("Could not insert into the tree.");
- }
- incTree.prune();
- incTree.getRootValue(actual_root);
-
- std::vector<bool> expected_root(32*8, 0);
- BOOST_CHECK( expected_root != actual_root );
-}
-
-BOOST_AUTO_TEST_CASE( testSerializationEdgeCase ) {
-
-}
-
-BOOST_AUTO_TEST_CASE( testCompactRepresentation ) {
- for (uint32_t num_entries = 0; num_entries < 100; num_entries++) {
- size_t test_depth = 64;
-
- if (num_entries == 2) {
- // This is a particular failure I'm testing with weird
- // padding caused by this depth.
- test_depth = 20;
- }
-
- std::vector< std::vector<bool> > values;
- std::vector<bool> root1, root2;
- IncrementalMerkleTree incTree(test_depth);
-
- constructNonzeroTestVector(values, num_entries);
-
- BOOST_REQUIRE( incTree.insertVector(values) );
- BOOST_REQUIRE( incTree.prune() );
-
- IncrementalMerkleTreeCompact compact = incTree.getCompactRepresentation();
-
- BOOST_REQUIRE( compact.getTreeHeight() == test_depth );
-
- // Calculate what the path to the next-added element should be.
- std::vector<unsigned char> path_bytes(8);
- std::vector<bool> path_bits;
- libzerocash::convertIntToBytesVector(num_entries, path_bytes);
- libzerocash::convertBytesVectorToVector(path_bytes, path_bits);
-
- if (test_depth == 64) {
- // Make sure the paths match.
- BOOST_REQUIRE( compact.getHashList() == path_bits );
- }
-
- // Make sure there's a hash for every '1' bit down the path.
- BOOST_REQUIRE( compact.getHashVec().size() == libzerocash::countOnes(path_bits) );
-
- /* Test serializing and deserializing. */
- std::vector<unsigned char> serializedCompact = compact.serialize();
- IncrementalMerkleTreeCompact deserializedCompact = IncrementalMerkleTreeCompact::deserialize(serializedCompact);
- BOOST_REQUIRE(compact.getTreeHeight() == deserializedCompact.getTreeHeight());
- BOOST_REQUIRE(compact.getHashList() == deserializedCompact.getHashList());
- BOOST_REQUIRE(compact.getHashVec() == deserializedCompact.getHashVec());
-
- // Make sure 'restoring' the tree results in the same root.
- IncrementalMerkleTree newTree(compact);
- incTree.getRootValue(root1);
- incTree.getRootValue(root2);
- BOOST_REQUIRE( root1 == root2 );
- }
-}
-
-BOOST_AUTO_TEST_CASE( testCompactDeserializationFailures ) {
- IncrementalMerkleTree incTree(64);
- std::vector< std::vector<bool> > values;
- constructNonzeroTestVector(values, 5);
- BOOST_REQUIRE( incTree.insertVector(values) );
- BOOST_REQUIRE( incTree.prune() );
- IncrementalMerkleTreeCompact compact = incTree.getCompactRepresentation();
-
- /* Base the following tests off of this valid serialization. */
- std::vector<unsigned char> serialized = compact.serialize();
-
- /* Should fail if we truncate any number of bytes off the end. */
- for (size_t trunc_len = 0; trunc_len < serialized.size(); trunc_len++) {
- std::vector<unsigned char> truncated(serialized.begin(), serialized.begin() + trunc_len);
- BOOST_CHECK_THROW(
- IncrementalMerkleTreeCompact::deserialize(truncated),
- std::out_of_range
- );
- }
-
- /* Should fail if we append any number of extra bytes on the end. */
- std::vector<unsigned char> extra_byte = serialized;
- extra_byte.push_back(0x00);
- BOOST_CHECK_THROW(
- IncrementalMerkleTreeCompact::deserialize(extra_byte),
- std::runtime_error
- );
-}
#include "zerocash/PourOutput.h"
#include "zerocash/utils/util.h"
+#include "uint256.h"
+
using namespace std;
using namespace libsnark;
-#define TEST_TREE_DEPTH 4
-
BOOST_AUTO_TEST_CASE( SaveAndLoadKeysFromFiles ) {
cout << "\nSaveAndLoadKeysFromFiles TEST\n" << endl;
cout << "Creating Params...\n" << endl;
libzerocash::timer_start("Param Generation");
- auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(TEST_TREE_DEPTH);
+ auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::ZerocashParams p(
- TEST_TREE_DEPTH,
+ INCREMENTAL_MERKLE_TREE_DEPTH,
&keypair
);
libzerocash::timer_stop("Param Generation");
libzerocash::timer_stop("Saving Verification Key");
libzerocash::timer_start("Loading Proving Key");
- auto pk_loaded = libzerocash::ZerocashParams::LoadProvingKeyFromFile(pk_path, TEST_TREE_DEPTH);
+ auto pk_loaded = libzerocash::ZerocashParams::LoadProvingKeyFromFile(pk_path, INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::timer_stop("Loading Proving Key");
libzerocash::timer_start("Loading Verification Key");
- auto vk_loaded = libzerocash::ZerocashParams::LoadVerificationKeyFromFile(vk_path, TEST_TREE_DEPTH);
+ auto vk_loaded = libzerocash::ZerocashParams::LoadVerificationKeyFromFile(vk_path, INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::timer_stop("Loading Verification Key");
cout << "Comparing Proving and Verification key.\n" << endl;
}
cout << "Creating Merkle Tree...\n" << endl;
- libzerocash::IncrementalMerkleTree merkleTree(coinValues, TEST_TREE_DEPTH);
+ libzerocash::IncrementalMerkleTree merkleTree(coinValues, INCREMENTAL_MERKLE_TREE_DEPTH);
cout << "Successfully created Merkle Tree.\n" << endl;
std::vector<bool> index;
cout << "Creating Witness 1...\n" << endl;
- merkle_authentication_path witness_1(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_1(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::convertIntToVector(1, index);
merkleTree.getWitness(index, witness_1);
cout << "Successfully created Witness 1.\n" << endl;
cout << "Creating Witness 2...\n" << endl;
- merkle_authentication_path witness_2(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_2(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::convertIntToVector(3, index);
merkleTree.getWitness(index, witness_2);
cout << "Successfully created Witness 2.\n" << endl;
BOOST_AUTO_TEST_CASE( PourInputOutputTest ) {
// dummy input
{
- libzerocash::PourInput input(TEST_TREE_DEPTH);
+ libzerocash::PourInput input(INCREMENTAL_MERKLE_TREE_DEPTH);
BOOST_CHECK(input.old_coin.getValue() == 0);
BOOST_CHECK(input.old_address.getPublicAddress() == input.old_coin.getPublicAddress());
std::vector<uint64_t> inputs, // values of the inputs (max 2)
std::vector<uint64_t> outputs) // values of the outputs (max 2)
{
- using pour_input_state = std::tuple<libzerocash::Address, libzerocash::Coin, std::vector<bool>>;
+ using pour_input_state = std::tuple<libzerocash::Address, libzerocash::Coin, ZCIncrementalWitness>;
// Construct incremental merkle tree
- libzerocash::IncrementalMerkleTree merkleTree(TEST_TREE_DEPTH);
+ ZCIncrementalMerkleTree merkleTree;
// Dummy sig_pk
vector<unsigned char> as(ZC_SIG_PK_SIZE, 'a');
libzerocash::Coin coin(addr.getPublicAddress(), *it);
// commitment from coin
- std::vector<bool> commitment(ZC_CM_SIZE * 8);
- libzerocash::convertBytesVectorToVector(coin.getCoinCommitment().getCommitmentValue(), commitment);
+ uint256 commitment(coin.getCoinCommitment().getCommitmentValue());
// insert commitment into the merkle tree
- std::vector<bool> index;
- merkleTree.insertElement(commitment, index);
+ merkleTree.append(commitment);
+
+ // and append to any witnesses
+ for(vector<pour_input_state>::iterator wit = input_state.begin(); wit != input_state.end(); ++wit) {
+ std::get<2>(*wit).append(commitment);
+ }
// store the state temporarily
- input_state.push_back(std::make_tuple(addr, coin, index));
+ input_state.push_back(std::make_tuple(addr, coin, merkleTree.witness()));
}
// compute the merkle root we will be working with
- vector<unsigned char> rt(ZC_ROOT_SIZE);
- {
- vector<bool> root_bv(ZC_ROOT_SIZE * 8);
- merkleTree.getRootValue(root_bv);
- libzerocash::convertVectorToBytesVector(root_bv, rt);
- }
+ auto rt_u = merkleTree.root();
+ std::vector<unsigned char> rt(rt_u.begin(), rt_u.end());
// get witnesses for all the input coins and construct the pours
for(vector<pour_input_state>::iterator it = input_state.begin(); it != input_state.end(); ++it) {
- merkle_authentication_path path(TEST_TREE_DEPTH);
-
- auto index = std::get<2>(*it);
- merkleTree.getWitness(index, path);
+ auto witness = std::get<2>(*it);
+ auto path = witness.path();
- pour_inputs.push_back(libzerocash::PourInput(std::get<1>(*it), std::get<0>(*it), libzerocash::convertVectorToInt(index), path));
+ pour_inputs.push_back(libzerocash::PourInput(std::get<1>(*it), std::get<0>(*it), path));
}
// construct dummy outputs with the given values
}
BOOST_AUTO_TEST_CASE( PourVpubInTest ) {
- auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(TEST_TREE_DEPTH);
+ auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::ZerocashParams p(
- TEST_TREE_DEPTH,
+ INCREMENTAL_MERKLE_TREE_DEPTH,
&keypair
);
cout << "Creating Params...\n" << endl;
libzerocash::timer_start("Param Generation");
- auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(TEST_TREE_DEPTH);
+ auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::ZerocashParams p(
- TEST_TREE_DEPTH,
+ INCREMENTAL_MERKLE_TREE_DEPTH,
&keypair
);
libzerocash::timer_stop("Param Generation");
cout << "Creating Merkle Tree...\n" << endl;
libzerocash::timer_start("Merkle Tree");
- libzerocash::IncrementalMerkleTree merkleTree(coinValues, TEST_TREE_DEPTH);
+ libzerocash::IncrementalMerkleTree merkleTree(coinValues, INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::timer_stop("Merkle Tree");
cout << "Successfully created Merkle Tree.\n" << endl;
- merkle_authentication_path witness_1(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_1(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::timer_start("Witness");
std::vector<bool> index;
}
cout << "\n" << endl;
- merkle_authentication_path witness_2(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_2(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::convertIntToVector(3, index);
if (merkleTree.getWitness(index, witness_2) == false) {
cout << "Could not get witness" << endl;
cout << "\nSIMPLE TRANSACTION TEST\n" << endl;
libzerocash::timer_start("Param Generation");
- auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(TEST_TREE_DEPTH);
+ auto keypair = libzerocash::ZerocashParams::GenerateNewKeyPair(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::ZerocashParams p(
- TEST_TREE_DEPTH,
+ INCREMENTAL_MERKLE_TREE_DEPTH,
&keypair
);
libzerocash::timer_stop("Param Generation");
}
cout << "Creating Merkle Tree...\n" << endl;
- libzerocash::IncrementalMerkleTree merkleTree(coinValues, TEST_TREE_DEPTH);
+ libzerocash::IncrementalMerkleTree merkleTree(coinValues, INCREMENTAL_MERKLE_TREE_DEPTH);
cout << "Successfully created Merkle Tree.\n" << endl;
std::vector<bool> index;
cout << "Creating Witness 1...\n" << endl;
- merkle_authentication_path witness_1(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_1(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::convertIntToVector(1, index);
if (merkleTree.getWitness(index, witness_1) == false) {
BOOST_ERROR("Could not get witness");
cout << "Successfully created Witness 1.\n" << endl;
cout << "Creating Witness 2...\n" << endl;
- merkle_authentication_path witness_2(TEST_TREE_DEPTH);
+ merkle_authentication_path witness_2(INCREMENTAL_MERKLE_TREE_DEPTH);
libzerocash::convertIntToVector(3, index);
if (merkleTree.getWitness(index, witness_2) == false) {
cout << "Could not get witness" << endl;
projects / VerusCoin.git / commitdiff