mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-05-28 01:36:42 +00:00
138 lines
4.6 KiB
Go
138 lines
4.6 KiB
Go
package consensusstatemanager
|
|
|
|
import (
|
|
"sort"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/coinbase"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/merkle"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/model"
|
|
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
|
|
"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
func (csm *consensusStateManager) verifyUTXO(block *externalapi.DomainBlock, blockHash *externalapi.DomainHash,
|
|
pastUTXODiff *model.UTXODiff, acceptanceData model.AcceptanceData, multiset model.Multiset) error {
|
|
|
|
err := csm.validateUTXOCommitment(block, blockHash, multiset)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = csm.validateAcceptedIDMerkleRoot(block, blockHash, acceptanceData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
coinbaseTransaction := block.Transactions[0]
|
|
err = csm.validateCoinbaseTransaction(blockHash, coinbaseTransaction)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = csm.validateBlockTransactionsAgainstPastUTXO(block, blockHash, pastUTXODiff, err)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (csm *consensusStateManager) validateBlockTransactionsAgainstPastUTXO(block *externalapi.DomainBlock,
|
|
blockHash *externalapi.DomainHash, pastUTXODiff *model.UTXODiff, err error) error {
|
|
|
|
selectedParentMedianTime, err := csm.pastMedianTimeManager.PastMedianTime(blockHash)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i, transaction := range block.Transactions {
|
|
if i == transactionhelper.CoinbaseTransactionIndex {
|
|
continue
|
|
}
|
|
err = csm.populateTransactionWithUTXOEntriesFromVirtualOrDiff(transaction, pastUTXODiff)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = csm.transactionValidator.ValidateTransactionInContextAndPopulateMassAndFee(
|
|
transaction, blockHash, selectedParentMedianTime)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (csm *consensusStateManager) validateAcceptedIDMerkleRoot(block *externalapi.DomainBlock,
|
|
blockHash *externalapi.DomainHash, acceptanceData model.AcceptanceData) error {
|
|
|
|
calculatedAcceptedIDMerkleRoot := calculateAcceptedIDMerkleRoot(acceptanceData)
|
|
if block.Header.AcceptedIDMerkleRoot != *calculatedAcceptedIDMerkleRoot {
|
|
return errors.Wrapf(ruleerrors.ErrBadMerkleRoot, "block %s accepted ID merkle root is invalid - block "+
|
|
"header indicates %s, but calculated value is %s",
|
|
blockHash, &block.Header.UTXOCommitment, calculatedAcceptedIDMerkleRoot)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (csm *consensusStateManager) validateUTXOCommitment(
|
|
block *externalapi.DomainBlock, blockHash *externalapi.DomainHash, multiset model.Multiset) error {
|
|
|
|
multisetHash := multiset.Hash()
|
|
if block.Header.UTXOCommitment != *multisetHash {
|
|
return errors.Wrapf(ruleerrors.ErrBadUTXOCommitment, "block %s UTXO commitment is invalid - block "+
|
|
"header indicates %s, but calculated value is %s", blockHash, &block.Header.UTXOCommitment, multisetHash)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func calculateAcceptedIDMerkleRoot(multiblockAcceptanceData model.AcceptanceData) *externalapi.DomainHash {
|
|
var acceptedTransactions []*externalapi.DomainTransaction
|
|
|
|
for _, blockAcceptanceData := range multiblockAcceptanceData {
|
|
for _, transactionAcceptance := range blockAcceptanceData.TransactionAcceptanceData {
|
|
if !transactionAcceptance.IsAccepted {
|
|
continue
|
|
}
|
|
acceptedTransactions = append(acceptedTransactions, transactionAcceptance.Transaction)
|
|
}
|
|
}
|
|
sort.Slice(acceptedTransactions, func(i, j int) bool {
|
|
return transactionid.Less(
|
|
consensusserialization.TransactionID(acceptedTransactions[i]),
|
|
consensusserialization.TransactionID(acceptedTransactions[j]))
|
|
})
|
|
|
|
return merkle.CalculateIDMerkleRoot(acceptedTransactions)
|
|
}
|
|
func (csm *consensusStateManager) validateCoinbaseTransaction(blockHash *externalapi.DomainHash,
|
|
coinbaseTransaction *externalapi.DomainTransaction) error {
|
|
_, coinbaseData, err := coinbase.ExtractCoinbaseDataAndBlueScore(coinbaseTransaction)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
expectedCoinbaseTransaction, err := csm.coinbaseManager.ExpectedCoinbaseTransaction(blockHash, coinbaseData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
coinbaseTransactionHash := consensusserialization.TransactionHash(coinbaseTransaction)
|
|
expectedCoinbaseTransactionHash := consensusserialization.TransactionHash(expectedCoinbaseTransaction)
|
|
if *coinbaseTransactionHash != *expectedCoinbaseTransactionHash {
|
|
return errors.Wrap(ruleerrors.ErrBadCoinbaseTransaction, "coinbase transaction is not built as expected")
|
|
}
|
|
|
|
return nil
|
|
}
|