Page MenuHomePhabricator
Differential D10092 Diff 29921 src/avalanche/test/util.cpp

Changeset View

Standalone View

View Options

src/avalanche/test/util.cpp

Show All 11 Lines
#include <validation.h> #include <validation.h>
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <limits> #include <limits>
namespace avalanche { namespace avalanche {
Proof buildRandomProof(uint32_t score, const CPubKey &master) { Proof buildRandomProof(uint32_t score, const CKey &masterKey) {
auto key = CKey::MakeCompressedKey(); auto key = CKey::MakeCompressedKey();
const COutPoint o(TxId(GetRandHash()), 0); const COutPoint o(TxId(GetRandHash()), 0);
const Amount v = (int64_t(score) * COIN) / 100; const Amount v = (int64_t(score) * COIN) / 100;
const int height = 1234; const int height = 1234;
const bool is_coinbase = false; const bool is_coinbase = false;
{ {
CScript script = GetScriptForDestination(PKHash(key.GetPubKey())); CScript script = GetScriptForDestination(PKHash(key.GetPubKey()));
LOCK(cs_main); LOCK(cs_main);
CCoinsViewCache &coins = ::ChainstateActive().CoinsTip(); CCoinsViewCache &coins = ::ChainstateActive().CoinsTip();
coins.AddCoin(o, Coin(CTxOut(v, script), height, is_coinbase), false); coins.AddCoin(o, Coin(CTxOut(v, script), height, is_coinbase), false);
} }
ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), master); ProofBuilder pb(0, std::numeric_limits<uint32_t>::max(), masterKey);
BOOST_CHECK(pb.addUTXO(o, v, height, is_coinbase, std::move(key))); BOOST_CHECK(pb.addUTXO(o, v, height, is_coinbase, std::move(key)));
return pb.build(); return pb.build();
} }
bool hasDustStake(const Proof &proof) { bool hasDustStake(const Proof &proof) {
for (const SignedStake &s : proof.getStakes()) { for (const SignedStake &s : proof.getStakes()) {
if (s.getStake().getAmount() < PROOF_DUST_THRESHOLD) { if (s.getStake().getAmount() < PROOF_DUST_THRESHOLD) {
return true; return true;
Show All 9 LinesProofId TestProofBuilder::getReverseOrderProofId(ProofBuilder &pb) {
WriteCompactSize(ss, pb.stakes.size()); WriteCompactSize(ss, pb.stakes.size());
for (auto it = pb.stakes.rbegin(); it != pb.stakes.rend(); it++) { for (auto it = pb.stakes.rbegin(); it != pb.stakes.rend(); it++) {
ss << it->stake; ss << it->stake;
} }
CHashWriter ss2(SER_GETHASH, 0); CHashWriter ss2(SER_GETHASH, 0);
ss2 << ss.GetHash(); ss2 << ss.GetHash();
ss2 << pb.master; ss2 << pb.masterKey.GetPubKey();
return ProofId(ss2.GetHash()); return ProofId(ss2.GetHash());
} }
Proof TestProofBuilder::buildWithReversedOrderStakes(ProofBuilder &pb) { Proof TestProofBuilder::buildWithReversedOrderStakes(ProofBuilder &pb) {
const ProofId proofid = TestProofBuilder::getReverseOrderProofId(pb); const ProofId proofid = TestProofBuilder::getReverseOrderProofId(pb);
std::vector<SignedStake> signedStakes; std::vector<SignedStake> signedStakes;
signedStakes.reserve(pb.stakes.size()); signedStakes.reserve(pb.stakes.size());
while (!pb.stakes.empty()) { while (!pb.stakes.empty()) {
// We need a forward iterator, so pb.stakes.rbegin() is not an // We need a forward iterator, so pb.stakes.rbegin() is not an
// option. // option.
auto handle = pb.stakes.extract(std::prev(pb.stakes.end())); auto handle = pb.stakes.extract(std::prev(pb.stakes.end()));
signedStakes.push_back(handle.value().sign(proofid)); signedStakes.push_back(handle.value().sign(proofid));
} }
return Proof(pb.sequence, pb.expirationTime, std::move(pb.master), return Proof(pb.sequence, pb.expirationTime, pb.masterKey.GetPubKey(),
std::move(signedStakes)); std::move(signedStakes));
} }
ProofId TestProofBuilder::getDuplicatedStakeProofId(ProofBuilder &pb) { ProofId TestProofBuilder::getDuplicatedStakeProofId(ProofBuilder &pb) {
CHashWriter ss(SER_GETHASH, 0); CHashWriter ss(SER_GETHASH, 0);
ss << pb.sequence; ss << pb.sequence;
ss << pb.expirationTime; ss << pb.expirationTime;
WriteCompactSize(ss, 2 * pb.stakes.size()); WriteCompactSize(ss, 2 * pb.stakes.size());
for (auto &s : pb.stakes) { for (auto &s : pb.stakes) {
ss << s.stake; ss << s.stake;
ss << s.stake; ss << s.stake;
} }
CHashWriter ss2(SER_GETHASH, 0); CHashWriter ss2(SER_GETHASH, 0);
ss2 << ss.GetHash(); ss2 << ss.GetHash();
ss2 << pb.master; ss2 << pb.masterKey.GetPubKey();
return ProofId(ss2.GetHash()); return ProofId(ss2.GetHash());
} }
Proof TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) { Proof TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) {
const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb); const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb);
std::vector<SignedStake> signedStakes; std::vector<SignedStake> signedStakes;
signedStakes.reserve(2 * pb.stakes.size()); signedStakes.reserve(2 * pb.stakes.size());
while (!pb.stakes.empty()) { while (!pb.stakes.empty()) {
auto handle = pb.stakes.extract(pb.stakes.begin()); auto handle = pb.stakes.extract(pb.stakes.begin());
SignedStake signedStake = handle.value().sign(proofid); SignedStake signedStake = handle.value().sign(proofid);
signedStakes.push_back(signedStake); signedStakes.push_back(signedStake);
signedStakes.push_back(signedStake); signedStakes.push_back(signedStake);
} }
return Proof(pb.sequence, pb.expirationTime, std::move(pb.master), return Proof(pb.sequence, pb.expirationTime, pb.masterKey.GetPubKey(),
std::move(signedStakes)); std::move(signedStakes));
} }
} // namespace avalanche } // namespace avalanche