/
types.go
124 lines (107 loc) · 2.59 KB
/
types.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
package lib
import (
"fmt"
"github.com/btcsuite/btcd/btcec"
)
// A PKID is an ID associated with a public key. In the DB, various fields are
// indexed using the PKID rather than the user's public key directly in order to
// create one layer of indirection between the public key and the user's data. This
// makes it easy for the user to transfer certain data to a new public key.
type PKID [33]byte
type PublicKey [33]byte
func NewPKID(pkidBytes []byte) *PKID {
if len(pkidBytes) == 0 {
return nil
}
pkid := &PKID{}
copy(pkid[:], pkidBytes)
return pkid
}
func (pkid *PKID) ToBytes() []byte {
return pkid[:]
}
func (pkid *PKID) NewPKID() *PKID {
newPkid := &PKID{}
copy(newPkid[:], pkid[:])
return newPkid
}
func NewPublicKey(publicKeyBytes []byte) *PublicKey {
if len(publicKeyBytes) != btcec.PubKeyBytesLenCompressed {
return nil
}
publicKey := &PublicKey{}
copy(publicKey[:], publicKeyBytes)
return publicKey
}
func (publicKey *PublicKey) ToBytes() []byte {
return publicKey[:]
}
func PublicKeyToPKID(publicKey []byte) *PKID {
if len(publicKey) == 0 {
return nil
}
pkid := &PKID{}
copy(pkid[:], publicKey)
return pkid
}
func PKIDToPublicKey(pkid *PKID) []byte {
if pkid == nil {
return nil
}
return pkid[:]
}
const HashSizeBytes = 32
// BlockHash is a convenient alias for a block hash.
type BlockHash [HashSizeBytes]byte
func NewBlockHash(input []byte) *BlockHash {
blockHash := &BlockHash{}
copy(blockHash[:], input)
return blockHash
}
func (bh *BlockHash) String() string {
return fmt.Sprintf("%064x", HashToBigint(bh))
}
func (bh *BlockHash) ToBytes() []byte {
res := make([]byte, HashSizeBytes)
copy(res, bh[:])
return res
}
// IsEqual returns true if target is the same as hash.
func (bh *BlockHash) IsEqual(target *BlockHash) bool {
if bh == nil && target == nil {
return true
}
if bh == nil || target == nil {
return false
}
return *bh == *target
}
func (bh *BlockHash) NewBlockHash() *BlockHash {
newBlockhash := &BlockHash{}
copy(newBlockhash[:], bh[:])
return newBlockhash
}
//var _ sql.Scanner = (*BlockHash)(nil)
//
//// Scan scans the time parsing it if necessary using timeFormat.
//func (bb *BlockHash) Scan(src interface{}) (err error) {
// switch src := src.(type) {
// case []byte:
// copy(bb[:], src)
// return err
// case nil:
// return nil
// default:
// return fmt.Errorf("unsupported data type: %T", src)
// }
//}
//
//var _ driver.Valuer = (*BlockHash)(nil)
//
//// Scan scans the time parsing it if necessary using timeFormat.
//func (bb *BlockHash) Value() (driver.Value, error) {
// if bb == nil {
// bb = &BlockHash{}
// }
// return bb[:], nil
//}