forked from Nexell-AI-Network/nexelliad
/
acceptancedata.go
executable file
·145 lines (117 loc) · 4.21 KB
/
acceptancedata.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
package externalapi
// AcceptanceData stores data about which transactions were accepted by a block.
// It's ordered in the same way as the block merge set blues.
type AcceptanceData []*BlockAcceptanceData
// If this doesn't compile, it means the type definition has been changed, so it's
// an indication to update Equal and Clone accordingly.
var _ AcceptanceData = []*BlockAcceptanceData{}
// Equal returns whether ad equals to other
func (ad AcceptanceData) Equal(other AcceptanceData) bool {
if len(ad) != len(other) {
return false
}
for i, blockAcceptanceData := range ad {
if !blockAcceptanceData.Equal(other[i]) {
return false
}
}
return true
}
// Clone clones the AcceptanceData
func (ad AcceptanceData) Clone() AcceptanceData {
clone := make(AcceptanceData, len(ad))
for i, blockAcceptanceData := range ad {
clone[i] = blockAcceptanceData.Clone()
}
return clone
}
// BlockAcceptanceData stores all transactions in a block with an indication
// if they were accepted or not by some other block
type BlockAcceptanceData struct {
BlockHash *DomainHash
TransactionAcceptanceData []*TransactionAcceptanceData
}
// If this doesn't compile, it means the type definition has been changed, so it's
// an indication to update Equal and Clone accordingly.
var _ = &BlockAcceptanceData{&DomainHash{}, []*TransactionAcceptanceData{}}
// Equal returns whether bad equals to other
func (bad *BlockAcceptanceData) Equal(other *BlockAcceptanceData) bool {
if bad == nil || other == nil {
return bad == other
}
if !bad.BlockHash.Equal(other.BlockHash) {
return false
}
if len(bad.TransactionAcceptanceData) != len(other.TransactionAcceptanceData) {
return false
}
for i, acceptanceData := range bad.TransactionAcceptanceData {
if !acceptanceData.Equal(other.TransactionAcceptanceData[i]) {
return false
}
}
return true
}
// Clone returns a clone of BlockAcceptanceData
func (bad *BlockAcceptanceData) Clone() *BlockAcceptanceData {
if bad == nil {
return nil
}
clone := &BlockAcceptanceData{
BlockHash: bad.BlockHash,
TransactionAcceptanceData: make([]*TransactionAcceptanceData, len(bad.TransactionAcceptanceData)),
}
for i, acceptanceData := range bad.TransactionAcceptanceData {
clone.TransactionAcceptanceData[i] = acceptanceData.Clone()
}
return clone
}
// TransactionAcceptanceData stores a transaction together with an indication
// if it was accepted or not by some block
type TransactionAcceptanceData struct {
Transaction *DomainTransaction
Fee uint64
IsAccepted bool
TransactionInputUTXOEntries []UTXOEntry
}
// If this doesn't compile, it means the type definition has been changed, so it's
// an indication to update Equal and Clone accordingly.
var _ = &TransactionAcceptanceData{&DomainTransaction{}, 0, false, []UTXOEntry{}}
// Equal returns whether tad equals to other
func (tad *TransactionAcceptanceData) Equal(other *TransactionAcceptanceData) bool {
if tad == nil || other == nil {
return tad == other
}
if !tad.Transaction.Equal(other.Transaction) {
return false
}
if tad.Fee != other.Fee {
return false
}
if tad.IsAccepted != other.IsAccepted {
return false
}
if len(tad.TransactionInputUTXOEntries) != len(other.TransactionInputUTXOEntries) {
return false
}
for i, thisUTXOEntry := range tad.TransactionInputUTXOEntries {
otherUTXOEntry := other.TransactionInputUTXOEntries[i]
if !thisUTXOEntry.Equal(otherUTXOEntry) {
return false
}
}
return true
}
// Clone returns a clone of TransactionAcceptanceData
func (tad *TransactionAcceptanceData) Clone() *TransactionAcceptanceData {
cloneTransactionInputUTXOEntries := make([]UTXOEntry, len(tad.TransactionInputUTXOEntries))
for i, utxoEntry := range tad.TransactionInputUTXOEntries {
cloneTransactionInputUTXOEntries[i] = utxoEntry
}
return &TransactionAcceptanceData{
Transaction: tad.Transaction.Clone(),
Fee: tad.Fee,
IsAccepted: tad.IsAccepted,
TransactionInputUTXOEntries: cloneTransactionInputUTXOEntries,
}
}