forked from kaspanet/kaspad
-
Notifications
You must be signed in to change notification settings - Fork 7
/
domains.go
127 lines (109 loc) · 4.25 KB
/
domains.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
package hashes
import (
"crypto/sha256"
"lukechampine.com/blake3"
)
const (
transcationHashDomain = "TransactionHash"
transcationIDDomain = "TransactionID"
transcationSigningDomain = "TransactionSigningHash"
transcationSigningECDSADomain = "TransactionSigningHashECDSA"
blockDomain = "BlockHash"
proofOfWorkDomain = "ProofOfWorkHash"
heavyHashDomain = "HeavyHash"
merkleBranchDomain = "MerkleBranchHash"
)
// transactionSigningECDSADomainHash is a hashed version of transcationSigningECDSADomain that is used
// to make it a constant size. This is needed because this domain is used by sha256 hash writer, and
// sha256 doesn't support variable size domain separation.
var transactionSigningECDSADomainHash = sha256.Sum256([]byte(transcationSigningECDSADomain))
// NewTransactionHashWriter Returns a new HashWriter used for transaction hashes
func NewTransactionHashWriter() HashWriter {
var fixedSizeKey [32]byte
copy(fixedSizeKey[:], transcationHashDomain)
blake := blake3.New(32, fixedSizeKey[:])
return HashWriter{blake}
}
// func NewTransactionHashWriter() HashWriter {
// blake, err := blake2b.New256([]byte(transcationHashDomain))
// if err != nil {
// panic(errors.Wrapf(err, "this should never happen. %s is less than 64 bytes", transcationHashDomain))
// }
// return HashWriter{blake}
// }
// NewTransactionIDWriter Returns a new HashWriter used for transaction IDs
func NewTransactionIDWriter() HashWriter {
var fixedSizeKey [32]byte
copy(fixedSizeKey[:], transcationIDDomain)
blake := blake3.New(32, fixedSizeKey[:])
return HashWriter{blake}
}
// func NewTransactionIDWriter() HashWriter {
// blake, err := blake2b.New256([]byte(transcationIDDomain))
// if err != nil {
// panic(errors.Wrapf(err, "this should never happen. %s is less than 64 bytes", transcationIDDomain))
// }
// return HashWriter{blake}
// }
// NewTransactionSigningHashWriter Returns a new HashWriter used for signing on a transaction
func NewTransactionSigningHashWriter() HashWriter {
var fixedSizeKey [32]byte
copy(fixedSizeKey[:], transcationSigningDomain)
blake := blake3.New(32, fixedSizeKey[:])
return HashWriter{blake}
}
// func NewTransactionSigningHashWriter() HashWriter {
// blake, err := blake2b.New256([]byte(transcationSigningDomain))
// if err != nil {
// panic(errors.Wrapf(err, "this should never happen. %s is less than 64 bytes", transcationSigningDomain))
// }
// return HashWriter{blake}
// }
// NewTransactionSigningHashECDSAWriter Returns a new HashWriter used for signing on a transaction with ECDSA
func NewTransactionSigningHashECDSAWriter() HashWriter {
hashWriter := HashWriter{sha256.New()}
hashWriter.InfallibleWrite(transactionSigningECDSADomainHash[:])
return hashWriter
}
// NewBlockHashWriter Returns a new HashWriter used for hashing blocks
func NewBlockHashWriter() HashWriter {
var fixedSizeKey [32]byte
copy(fixedSizeKey[:], blockDomain)
blake := blake3.New(32, fixedSizeKey[:])
return HashWriter{blake}
}
// func NewBlockHashWriter() HashWriter {
// blake, err := blake2b.New256([]byte(blockDomain))
// if err != nil {
// panic(errors.Wrapf(err, "this should never happen. %s is less than 64 bytes", blockDomain))
// }
// return HashWriter{blake}
// }
// NewPoWHashWriter Returns a new HashWriter used for the PoW function
func PoWHashWriter() HashWriter {
blake := blake3.New(32, nil)
return HashWriter{blake}
}
// func NewPoWHashWriter() ShakeHashWriter {
// shake256 := sha3.NewCShake256(nil, []byte(proofOfWorkDomain))
// return ShakeHashWriter{shake256}
// }
// NewHeavyHashWriter Returns a new HashWriter used for the HeavyHash function
func HeavyHashWriter() HashWriter {
blake := blake3.New(32, nil)
return HashWriter{blake}
}
// NewMerkleBranchHashWriter Returns a new HashWriter used for a merkle tree branch
func NewMerkleBranchHashWriter() HashWriter {
var fixedSizeKey [32]byte
copy(fixedSizeKey[:], merkleBranchDomain)
blake := blake3.New(32, fixedSizeKey[:])
return HashWriter{blake}
}
// func NewMerkleBranchHashWriter() HashWriter {
// blake, err := blake2b.New256([]byte(merkleBranchDomain))
// if err != nil {
// panic(errors.Wrapf(err, "this should never happen. %s is less than 64 bytes", merkleBranchDomain))
// }
// return HashWriter{blake}
// }