/
msgcftypes.go
136 lines (115 loc) · 4.31 KB
/
msgcftypes.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
// Copyright (c) 2017 The btcsuite developers
// Copyright (c) 2017 The Lightning Network Developers
// Copyright (c) 2018-2020 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package wire
import (
"fmt"
"io"
)
// MaxFilterTypesPerMsg is the maximum number of filter types allowed per
// message.
const MaxFilterTypesPerMsg = 256
// FilterType is used to represent a filter type.
type FilterType uint8
const (
// GCSFilterRegular is the regular filter type.
GCSFilterRegular FilterType = iota
// GCSFilterExtended is the extended filter type.
GCSFilterExtended
)
// MsgCFTypes is the cftypes message.
type MsgCFTypes struct {
SupportedFilters []FilterType
}
// BtcDecode decodes r using the wire protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgCFTypes) BtcDecode(r io.Reader, pver uint32) error {
const op = "MsgCFTypes.BtcDecode"
if pver < NodeCFVersion {
msg := fmt.Sprintf("cftypes message invalid for protocol "+
"version %d", pver)
return messageError(op, ErrMsgInvalidForPVer, msg)
}
// Read the number of filter types supported. The count may not exceed the
// total number of filters that can be represented by a FilterType byte.
count, err := ReadVarInt(r, pver)
if err != nil {
return err
}
if count > MaxFilterTypesPerMsg {
msg := fmt.Sprintf("too many filter types for message "+
"[count %v, max %v]", count, MaxFilterTypesPerMsg)
return messageError(op, ErrTooManyFilterTypes, msg)
}
// Read each filter type.
msg.SupportedFilters = make([]FilterType, count)
for i := range msg.SupportedFilters {
err = readElement(r, (*uint8)(&msg.SupportedFilters[i]))
if err != nil {
return err
}
}
return nil
}
// BtcEncode encodes the receiver to w using the wire protocol encoding. This is
// part of the Message interface implementation.
func (msg *MsgCFTypes) BtcEncode(w io.Writer, pver uint32) error {
const op = "MsgCFTypes.BtcEncode"
if pver < NodeCFVersion {
msg := fmt.Sprintf("cftypes message invalid for protocol "+
"version %d", pver)
return messageError(op, ErrMsgInvalidForPVer, msg)
}
if len(msg.SupportedFilters) > MaxFilterTypesPerMsg {
msg := fmt.Sprintf("too many filter types for message "+
"[count %v, max %v]", len(msg.SupportedFilters), MaxFilterTypesPerMsg)
return messageError(op, ErrTooManyFilterTypes, msg)
}
// Write length of supported filters slice.
err := WriteVarInt(w, pver, uint64(len(msg.SupportedFilters)))
if err != nil {
return err
}
for i := range msg.SupportedFilters {
err = binarySerializer.PutUint8(w, uint8(msg.SupportedFilters[i]))
if err != nil {
return err
}
}
return nil
}
// Deserialize decodes a filter from r into the receiver using a format that is
// suitable for long-term storage such as a database. This function differs from
// BtcDecode in that BtcDecode decodes from the wire protocol as it was sent
// across the network. The wire encoding can technically differ depending on
// the protocol version and doesn't even really need to match the format of a
// stored filter at all. As of the time this comment was written, the encoded
// filter is the same in both instances, but there is a distinct difference and
// separating the two allows the API to be flexible enough to deal with changes.
func (msg *MsgCFTypes) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// and the stable long-term storage format. As a result, make use of
// BtcDecode.
return msg.BtcDecode(r, 0)
}
// Command returns the protocol command string for the message. This is part
// of the Message interface implementation.
func (msg *MsgCFTypes) Command() string {
return CmdCFTypes
}
// MaxPayloadLength returns the maximum length the payload can be for the
// receiver. This is part of the Message interface implementation.
func (msg *MsgCFTypes) MaxPayloadLength(pver uint32) uint32 {
// 3 bytes for filter count, 1 byte up to 256 bytes filter types.
return uint32(VarIntSerializeSize(MaxFilterTypesPerMsg)) +
MaxFilterTypesPerMsg
}
// NewMsgCFTypes returns a new cftypes message that conforms to the Message
// interface. See MsgCFTypes for details.
func NewMsgCFTypes(filterTypes []FilterType) *MsgCFTypes {
return &MsgCFTypes{
SupportedFilters: filterTypes,
}
}