proof.cpp

Go to the documentation of this file.

// Copyright (c) 2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <avalanche/proof.h>
 
#include <avalanche/validation.h>
#include <coins.h>
#include <common/args.h>
#include <hash.h>
#include <policy/policy.h>
#include <script/standard.h>
#include <streams.h>
#include <util/strencodings.h>
#include <util/translation.h>
#include <validation.h>
 
#include <tinyformat.h>
 
#include <limits>
#include <numeric>
#include <unordered_set>
#include <variant>
 
namespace avalanche {
 
StakeCommitment::StakeCommitment(int64_t expirationTime,
                                 const CPubKey &master) {
    HashWriter ss{};
    ss << expirationTime;
    ss << master;
    const uint256 &hash = ss.GetHash();
    memcpy(m_data, hash.data(), sizeof(m_data));
}
 
void Stake::computeStakeId() {
    HashWriter ss{};
    ss << *this;
    stakeid = StakeId(ss.GetHash());
}
 
uint256 Stake::getHash(const StakeCommitment &commitment) const {
    HashWriter ss{};
    ss << commitment;
    ss << *this;
    return ss.GetHash();
}
 
bool SignedStake::verify(const StakeCommitment &commitment) const {
    return stake.getPubkey().VerifySchnorr(stake.getHash(commitment), sig);
}
 
bool Proof::FromHex(Proof &proof, const std::string &hexProof,
                    bilingual_str &errorOut) {
    if (!IsHex(hexProof)) {
        errorOut = _("Proof must be an hexadecimal string.");
        return false;
    }
 
    DataStream ss{ParseHex(hexProof)};
 
    try {
        ss >> proof;
    } catch (std::exception &e) {
        errorOut = strprintf(_("Proof has invalid format: %s"), e.what());
        return false;
    }
 
    return true;
}
 
std::string Proof::ToHex() const {
    DataStream ss{};
    ss << *this;
    return HexStr(ss);
}
 
void Proof::computeProofId() {
    HashWriter ss{};
    ss << sequence;
    ss << expirationTime;
    ss << payoutScriptPubKey;
 
    WriteCompactSize(ss, stakes.size());
    for (const SignedStake &s : stakes) {
        ss << s.getStake();
    }
 
    limitedProofId = LimitedProofId(ss.GetHash());
    proofid = limitedProofId.computeProofId(master);
}
 
void Proof::computeScore() {
    score = amountToScore(getStakedAmount());
}
 
uint32_t Proof::amountToScore(Amount amount) {
    amount = MoneyClamp(amount);
    // After clamping, (100 * amount) is guaranteed not to overflow int64_t,
    // and the resulting score fits in uint32_t.
    static_assert(MAX_MONEY <=
                  (std::numeric_limits<int64_t>::max() / 100) * SATOSHI);
    static_assert((100 * MAX_MONEY) / COIN <=
                  std::numeric_limits<uint32_t>::max());
    return (100 * amount) / COIN;
}
 
Amount Proof::getStakedAmount() const {
    // Each add is at most MAX_MONEY + MAX_MONEY, which fits in int64_t.
    static_assert(MAX_MONEY <=
                  (std::numeric_limits<int64_t>::max() / 2) * SATOSHI);
    return std::accumulate(
        stakes.begin(), stakes.end(), Amount::zero(),
        [](Amount total, const SignedStake &ss) {
            return MoneyClamp(total + MoneyClamp(ss.getStake().getAmount()));
        });
}
 
static bool IsStandardPayoutScript(const CScript &scriptPubKey) {
    // Check the script's standardness against the default max OP_RETURN size,
    // so that a proof's validity is not affected by a local relay policy
    // parameter (see -datacarriersize config option)
    TxoutType scriptType;
    return IsStandard(scriptPubKey, MAX_OP_RETURN_RELAY, scriptType);
}
 
bool Proof::verify(const Amount &stakeUtxoDustThreshold,
                   ProofValidationState &state) const {
    if (stakes.empty()) {
        return state.Invalid(ProofValidationResult::NO_STAKE, "no-stake");
    }
 
    if (stakes.size() > AVALANCHE_MAX_PROOF_STAKES) {
        return state.Invalid(
            ProofValidationResult::TOO_MANY_UTXOS, "too-many-utxos",
            strprintf("%u > %u", stakes.size(), AVALANCHE_MAX_PROOF_STAKES));
    }
 
    if (!IsStandardPayoutScript(payoutScriptPubKey)) {
        return state.Invalid(ProofValidationResult::INVALID_PAYOUT_SCRIPT,
                             "payout-script-non-standard");
    }
 
    if (!master.VerifySchnorr(limitedProofId, signature)) {
        return state.Invalid(ProofValidationResult::INVALID_PROOF_SIGNATURE,
                             "invalid-proof-signature");
    }
 
    StakeId prevId = uint256::ZERO;
    std::unordered_set<COutPoint, SaltedOutpointHasher> utxos;
    for (const SignedStake &ss : stakes) {
        const Stake &s = ss.getStake();
        if (s.getAmount() < stakeUtxoDustThreshold) {
            return state.Invalid(ProofValidationResult::DUST_THRESHOLD,
                                 "amount-below-dust-threshold",
                                 strprintf("%s < %s", s.getAmount().ToString(),
                                           stakeUtxoDustThreshold.ToString()));
        }
 
        if (s.getId() < prevId) {
            return state.Invalid(ProofValidationResult::WRONG_STAKE_ORDERING,
                                 "wrong-stake-ordering");
        }
        prevId = s.getId();
 
        if (!utxos.insert(s.getUTXO()).second) {
            return state.Invalid(ProofValidationResult::DUPLICATE_STAKE,
                                 "duplicated-stake");
        }
 
        if (!ss.verify(getStakeCommitment())) {
            return state.Invalid(
                ProofValidationResult::INVALID_STAKE_SIGNATURE,
                "invalid-stake-signature",
                strprintf("TxId: %s", s.getUTXO().GetTxId().ToString()));
        }
    }
 
    return true;
}
 
bool Proof::verify(const Amount &stakeUtxoDustThreshold,
                   const ChainstateManager &chainman,
                   ProofValidationState &state) const {
    AssertLockHeld(cs_main);
    if (!verify(stakeUtxoDustThreshold, state)) {
        // state is set by verify.
        return false;
    }
 
    const CBlockIndex *activeTip = chainman.ActiveTip();
    const int64_t tipMedianTimePast =
        activeTip ? activeTip->GetMedianTimePast() : 0;
    if (expirationTime > 0 && tipMedianTimePast >= expirationTime) {
        return state.Invalid(ProofValidationResult::EXPIRED, "expired-proof");
    }
 
    const int64_t activeHeight = chainman.ActiveHeight();
    const int64_t stakeUtxoMinConfirmations =
        gArgs.GetIntArg("-avaproofstakeutxoconfirmations",
                        AVALANCHE_DEFAULT_STAKE_UTXO_CONFIRMATIONS);
 
    for (const SignedStake &ss : stakes) {
        const Stake &s = ss.getStake();
        const COutPoint &utxo = s.getUTXO();
 
        auto coin{chainman.ActiveChainstate().CoinsTip().GetCoin(utxo)};
        if (!coin) {
            // The coins are not in the UTXO set.
            return state.Invalid(ProofValidationResult::MISSING_UTXO,
                                 "utxo-missing-or-spent");
        }
 
        if ((s.getHeight() + stakeUtxoMinConfirmations - 1) > activeHeight) {
            return state.Invalid(
                ProofValidationResult::IMMATURE_UTXO, "immature-utxo",
                strprintf("TxId: %s, block height: %d, chaintip height: %d",
                          s.getUTXO().GetTxId().ToString(), s.getHeight(),
                          activeHeight));
        }
 
        if (s.isCoinbase() != coin->IsCoinBase()) {
            return state.Invalid(
                ProofValidationResult::COINBASE_MISMATCH, "coinbase-mismatch",
                strprintf("expected %s, found %s",
                          s.isCoinbase() ? "true" : "false",
                          coin->IsCoinBase() ? "true" : "false"));
        }
 
        if (s.getHeight() != coin->GetHeight()) {
            return state.Invalid(ProofValidationResult::HEIGHT_MISMATCH,
                                 "height-mismatch",
                                 strprintf("expected %u, found %u",
                                           s.getHeight(), coin->GetHeight()));
        }
 
        const CTxOut &out = coin->GetTxOut();
        if (s.getAmount() != out.nValue) {
            // Wrong amount.
            return state.Invalid(
                ProofValidationResult::AMOUNT_MISMATCH, "amount-mismatch",
                strprintf("expected %s, found %s", s.getAmount().ToString(),
                          out.nValue.ToString()));
        }
 
        CTxDestination dest;
        if (!ExtractDestination(out.scriptPubKey, dest)) {
            // Can't extract destination.
            return state.Invalid(
                ProofValidationResult::NON_STANDARD_DESTINATION,
                "non-standard-destination");
        }
 
        PKHash *pkhash = std::get_if<PKHash>(&dest);
        if (!pkhash) {
            // Only PKHash are supported.
            return state.Invalid(
                ProofValidationResult::DESTINATION_NOT_SUPPORTED,
                "destination-type-not-supported");
        }
 
        const CPubKey &pubkey = s.getPubkey();
        if (*pkhash != PKHash(pubkey)) {
            // Wrong pubkey.
            return state.Invalid(ProofValidationResult::DESTINATION_MISMATCH,
                                 "destination-mismatch");
        }
    }
 
    return true;
}
 
} // namespace avalanche