/
serialization.go
72 lines (61 loc) · 2.29 KB
/
serialization.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
package utxoindex
import (
"encoding/binary"
"github.com/gordanet/gord/domain/consensus/database/serialization"
"github.com/gordanet/gord/domain/consensus/model/externalapi"
"github.com/pkg/errors"
"google.golang.org/protobuf/proto"
"io"
)
func serializeOutpoint(outpoint *externalapi.DomainOutpoint) ([]byte, error) {
dbOutpoint := serialization.DomainOutpointToDbOutpoint(outpoint)
return proto.Marshal(dbOutpoint)
}
func deserializeOutpoint(serializedOutpoint []byte) (*externalapi.DomainOutpoint, error) {
var dbOutpoint serialization.DbOutpoint
err := proto.Unmarshal(serializedOutpoint, &dbOutpoint)
if err != nil {
return nil, err
}
return serialization.DbOutpointToDomainOutpoint(&dbOutpoint)
}
func serializeUTXOEntry(utxoEntry externalapi.UTXOEntry) ([]byte, error) {
dbUTXOEntry := serialization.UTXOEntryToDBUTXOEntry(utxoEntry)
return proto.Marshal(dbUTXOEntry)
}
func deserializeUTXOEntry(serializedUTXOEntry []byte) (externalapi.UTXOEntry, error) {
var dbUTXOEntry serialization.DbUtxoEntry
err := proto.Unmarshal(serializedUTXOEntry, &dbUTXOEntry)
if err != nil {
return nil, err
}
return serialization.DBUTXOEntryToUTXOEntry(&dbUTXOEntry)
}
const hashesLengthSize = 8
func serializeHashes(hashes []*externalapi.DomainHash) []byte {
serializedHashes := make([]byte, hashesLengthSize+externalapi.DomainHashSize*len(hashes))
binary.LittleEndian.PutUint64(serializedHashes[:hashesLengthSize], uint64(len(hashes)))
for i, hash := range hashes {
start := hashesLengthSize + externalapi.DomainHashSize*i
end := start + externalapi.DomainHashSize
copy(serializedHashes[start:end], hash.ByteSlice())
}
return serializedHashes
}
func deserializeHashes(serializedHashes []byte) ([]*externalapi.DomainHash, error) {
length := binary.LittleEndian.Uint64(serializedHashes[:hashesLengthSize])
hashes := make([]*externalapi.DomainHash, length)
for i := uint64(0); i < length; i++ {
start := hashesLengthSize + externalapi.DomainHashSize*i
end := start + externalapi.DomainHashSize
if end > uint64(len(serializedHashes)) {
return nil, errors.Wrapf(io.ErrUnexpectedEOF, "unexpected EOF while deserializing hashes")
}
var err error
hashes[i], err = externalapi.NewDomainHashFromByteSlice(serializedHashes[start:end])
if err != nil {
return nil, err
}
}
return hashes, nil
}