Differential D10077 Diff 29918 src/avalanche/test/util.cpp

Changeset View

Standalone View

src/avalanche/test/util.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	bool hasDustStake(const Proof &proof) {
return false;		return false;
}		}

ProofId TestProofBuilder::getReverseOrderProofId(ProofBuilder &pb) {		ProofId TestProofBuilder::getReverseOrderProofId(ProofBuilder &pb) {
CHashWriter ss(SER_GETHASH, 0);		CHashWriter ss(SER_GETHASH, 0);
ss << pb.sequence;		ss << pb.sequence;
ss << pb.expirationTime;		ss << pb.expirationTime;

// Reverse the sorting order
std::sort(pb.stakes.begin(), pb.stakes.end(),
[](const ProofBuilder::StakeSigner &lhs,
const ProofBuilder::StakeSigner &rhs) {
return lhs.stake.getId() > rhs.stake.getId();
});

WriteCompactSize(ss, pb.stakes.size());		WriteCompactSize(ss, pb.stakes.size());
for (const auto &s : pb.stakes) {		for (auto it = pb.stakes.rbegin(); it != pb.stakes.rend(); it++) {
ss << s.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.master;

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()) {
		// We need a forward iterator, so pb.stakes.rbegin() is not an
		// option.
		auto handle = pb.stakes.extract(std::prev(pb.stakes.end()));
		signedStakes.push_back(handle.value().sign(proofid));
		}

		return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
		std::move(signedStakes));
		}

		ProofId TestProofBuilder::getDuplicatedStakeProofId(ProofBuilder &pb) {
		CHashWriter ss(SER_GETHASH, 0);
		ss << pb.sequence;
		ss << pb.expirationTime;

		WriteCompactSize(ss, 2 * pb.stakes.size());
for (auto &s : pb.stakes) {		for (auto &s : pb.stakes) {
signedStakes.push_back(s.sign(proofid));		ss << s.stake;
		ss << s.stake;
		}

		CHashWriter ss2(SER_GETHASH, 0);
		ss2 << ss.GetHash();
		ss2 << pb.master;

		return ProofId(ss2.GetHash());
		}

		Proof TestProofBuilder::buildDuplicatedStakes(ProofBuilder &pb) {
		const ProofId proofid = TestProofBuilder::getDuplicatedStakeProofId(pb);

		std::vector<SignedStake> signedStakes;
		signedStakes.reserve(2 * pb.stakes.size());

		while (!pb.stakes.empty()) {
		auto handle = pb.stakes.extract(pb.stakes.begin());
		SignedStake signedStake = handle.value().sign(proofid);
		signedStakes.push_back(signedStake);
		signedStakes.push_back(signedStake);
}		}

pb.stakes.clear();
return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),		return Proof(pb.sequence, pb.expirationTime, std::move(pb.master),
std::move(signedStakes));		std::move(signedStakes));
}		}

} // namespace avalanche		} // namespace avalanche