-
Notifications
You must be signed in to change notification settings - Fork 11
/
verify_and_build_utxo.go
executable file
·185 lines (147 loc) · 7.37 KB
/
verify_and_build_utxo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
package consensusstatemanager
import (
"sort"
"github.com/Nexellia-Network/nexelliad/domain/consensus/utils/transactionhelper"
"github.com/Nexellia-Network/nexelliad/domain/consensus/utils/consensushashing"
"github.com/Nexellia-Network/nexelliad/domain/consensus/utils/merkle"
"github.com/Nexellia-Network/nexelliad/domain/consensus/model"
"github.com/Nexellia-Network/nexelliad/domain/consensus/model/externalapi"
"github.com/Nexellia-Network/nexelliad/domain/consensus/ruleerrors"
"github.com/pkg/errors"
)
func (csm *consensusStateManager) verifyUTXO(stagingArea *model.StagingArea, block *externalapi.DomainBlock,
blockHash *externalapi.DomainHash, pastUTXODiff externalapi.UTXODiff, acceptanceData externalapi.AcceptanceData,
multiset model.Multiset) error {
log.Tracef("verifyUTXO start for block %s", blockHash)
defer log.Tracef("verifyUTXO end for block %s", blockHash)
log.Debugf("Validating UTXO commitment for block %s", blockHash)
err := csm.validateUTXOCommitment(block, blockHash, multiset)
if err != nil {
return err
}
log.Debugf("UTXO commitment validation passed for block %s", blockHash)
log.Debugf("Validating acceptedIDMerkleRoot for block %s", blockHash)
err = csm.validateAcceptedIDMerkleRoot(block, blockHash, acceptanceData)
if err != nil {
return err
}
log.Debugf("AcceptedIDMerkleRoot validation passed for block %s", blockHash)
coinbaseTransaction := block.Transactions[0]
log.Debugf("Validating coinbase transaction %s for block %s",
consensushashing.TransactionID(coinbaseTransaction), blockHash)
err = csm.validateCoinbaseTransaction(stagingArea, blockHash, coinbaseTransaction)
if err != nil {
return err
}
log.Debugf("Coinbase transaction validation passed for block %s", blockHash)
log.Debugf("Validating transactions against past UTXO for block %s", blockHash)
err = csm.validateBlockTransactionsAgainstPastUTXO(stagingArea, block, pastUTXODiff)
if err != nil {
return err
}
log.Tracef("Transactions against past UTXO validation passed for block %s", blockHash)
return nil
}
func (csm *consensusStateManager) validateBlockTransactionsAgainstPastUTXO(stagingArea *model.StagingArea,
block *externalapi.DomainBlock, pastUTXODiff externalapi.UTXODiff) error {
blockHash := consensushashing.BlockHash(block)
log.Tracef("validateBlockTransactionsAgainstPastUTXO start for block %s", blockHash)
defer log.Tracef("validateBlockTransactionsAgainstPastUTXO end for block %s", blockHash)
selectedParentMedianTime, err := csm.pastMedianTimeManager.PastMedianTime(stagingArea, blockHash)
if err != nil {
return err
}
log.Tracef("The past median time of %s is %d", blockHash, selectedParentMedianTime)
for i, transaction := range block.Transactions {
transactionID := consensushashing.TransactionID(transaction)
log.Tracef("Validating transaction %s in block %s against "+
"the block's past UTXO", transactionID, blockHash)
if i == transactionhelper.CoinbaseTransactionIndex {
log.Tracef("Skipping transaction %s because it is the coinbase", transactionID)
continue
}
log.Tracef("Populating transaction %s with UTXO entries", transactionID)
err = csm.populateTransactionWithUTXOEntriesFromVirtualOrDiff(stagingArea, transaction, pastUTXODiff)
if err != nil {
return err
}
log.Tracef("Validating transaction %s and populating it with fee", transactionID)
err = csm.transactionValidator.ValidateTransactionInContextAndPopulateFee(
stagingArea, transaction, blockHash)
if err != nil {
return err
}
log.Tracef("Validation against the block's past UTXO "+
"passed for transaction %s in block %s", transactionID, blockHash)
}
return nil
}
func (csm *consensusStateManager) validateAcceptedIDMerkleRoot(block *externalapi.DomainBlock,
blockHash *externalapi.DomainHash, acceptanceData externalapi.AcceptanceData) error {
log.Tracef("validateAcceptedIDMerkleRoot start for block %s", blockHash)
defer log.Tracef("validateAcceptedIDMerkleRoot end for block %s", blockHash)
calculatedAcceptedIDMerkleRoot := calculateAcceptedIDMerkleRoot(acceptanceData)
if !block.Header.AcceptedIDMerkleRoot().Equal(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 {
log.Tracef("validateUTXOCommitment start for block %s", blockHash)
defer log.Tracef("validateUTXOCommitment end for block %s", blockHash)
if blockHash.Equal(csm.genesisHash) {
return nil
}
multisetHash := multiset.Hash()
if !block.Header.UTXOCommitment().Equal(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 externalapi.AcceptanceData) *externalapi.DomainHash {
log.Tracef("calculateAcceptedIDMerkleRoot start")
defer log.Tracef("calculateAcceptedIDMerkleRoot end")
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 consensushashing.TransactionID(acceptedTransactions[i]).Less(
consensushashing.TransactionID(acceptedTransactions[j]))
})
return merkle.CalculateIDMerkleRoot(acceptedTransactions)
}
func (csm *consensusStateManager) validateCoinbaseTransaction(stagingArea *model.StagingArea,
blockHash *externalapi.DomainHash, coinbaseTransaction *externalapi.DomainTransaction) error {
log.Tracef("validateCoinbaseTransaction start for block %s", blockHash)
defer log.Tracef("validateCoinbaseTransaction end for block %s", blockHash)
log.Tracef("Extracting coinbase data for coinbase transaction %s in block %s",
consensushashing.TransactionID(coinbaseTransaction), blockHash)
_, coinbaseData, _, err := csm.coinbaseManager.ExtractCoinbaseDataBlueScoreAndSubsidy(coinbaseTransaction)
if err != nil {
return err
}
log.Tracef("Calculating the expected coinbase transaction for the given coinbase data and block %s", blockHash)
expectedCoinbaseTransaction, _, err :=
csm.coinbaseManager.ExpectedCoinbaseTransaction(stagingArea, blockHash, coinbaseData)
if err != nil {
return err
}
coinbaseTransactionHash := consensushashing.TransactionHash(coinbaseTransaction)
expectedCoinbaseTransactionHash := consensushashing.TransactionHash(expectedCoinbaseTransaction)
log.Tracef("given coinbase hash: %s, expected coinbase hash: %s",
coinbaseTransactionHash, expectedCoinbaseTransactionHash)
if !coinbaseTransactionHash.Equal(expectedCoinbaseTransactionHash) {
return errors.Wrap(ruleerrors.ErrBadCoinbaseTransaction, "coinbase transaction is not built as expected")
}
return nil
}