/
blockSubscribe.go
156 lines (138 loc) · 4.1 KB
/
blockSubscribe.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
146
147
148
149
150
151
152
153
154
155
156
// Copyright 2022 github.com/gagliardetto
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package ws
import (
"fmt"
solana "github.com/jwrookie/jwsolana-go"
"github.com/jwrookie/jwsolana-go/rpc"
)
type BlockResult struct {
Context struct {
Slot uint64
} `json:"context"`
Value struct {
Slot uint64 `json:"slot"`
Err interface{} `json:"err,omitempty"`
Block *rpc.GetBlockResult `json:"block,omitempty"`
} `json:"value"`
}
type BlockSubscribeFilter interface {
isBlockSubscribeFilter()
}
var _ BlockSubscribeFilter = BlockSubscribeFilterAll("")
type BlockSubscribeFilterAll string
func (_ BlockSubscribeFilterAll) isBlockSubscribeFilter() {}
type BlockSubscribeFilterMentionsAccountOrProgram struct {
Pubkey solana.PublicKey `json:"pubkey"`
}
func (_ BlockSubscribeFilterMentionsAccountOrProgram) isBlockSubscribeFilter() {}
func NewBlockSubscribeFilterAll() BlockSubscribeFilter {
return BlockSubscribeFilterAll("")
}
func NewBlockSubscribeFilterMentionsAccountOrProgram(pubkey solana.PublicKey) *BlockSubscribeFilterMentionsAccountOrProgram {
return &BlockSubscribeFilterMentionsAccountOrProgram{
Pubkey: pubkey,
}
}
type BlockSubscribeOpts struct {
Commitment rpc.CommitmentType
Encoding solana.EncodingType `json:"encoding,omitempty"`
// Level of transaction detail to return.
TransactionDetails rpc.TransactionDetailsType
Version uint64
// Whether to populate the rewards array. If parameter not provided, the default includes rewards.
Rewards *bool
}
// NOTE: Unstable, disabled by default
//
// Subscribe to receive notification anytime a new block is Confirmed or Finalized.
//
// **This subscription is unstable and only available if the validator was started
// with the `--rpc-pubsub-enable-block-subscription` flag. The format of this
// subscription may change in the future**
func (cl *Client) BlockSubscribe(
filter BlockSubscribeFilter,
opts *BlockSubscribeOpts,
) (*BlockSubscription, error) {
var params []interface{}
if filter != nil {
switch v := filter.(type) {
case BlockSubscribeFilterAll:
params = append(params, "all")
case *BlockSubscribeFilterMentionsAccountOrProgram:
params = append(params, rpc.M{"mentionsAccountOrProgram": v.Pubkey})
}
}
if opts != nil {
obj := make(rpc.M)
if opts.Commitment != "" {
obj["commitment"] = opts.Commitment
}
if opts.Encoding != "" {
if !solana.IsAnyOfEncodingType(
opts.Encoding,
// Valid encodings:
// solana.EncodingJSON, // TODO
// solana.EncodingJSONParsed, // TODO
solana.EncodingBase58,
solana.EncodingBase64,
solana.EncodingBase64Zstd,
) {
return nil, fmt.Errorf("provided encoding is not supported: %s", opts.Encoding)
}
obj["encoding"] = opts.Encoding
}
if opts.TransactionDetails != "" {
obj["transactionDetails"] = opts.TransactionDetails
}
if opts.Rewards != nil {
obj["showRewards"] = opts.Rewards
}
obj["maxSupportedTransactionVersion"] = opts.Version
if len(obj) > 0 {
params = append(params, obj)
}
}
genSub, err := cl.subscribe(
params,
nil,
"blockSubscribe",
"blockUnsubscribe",
func(msg []byte) (interface{}, error) {
var res BlockResult
err := decodeResponseFromMessage(msg, &res)
return &res, err
},
)
if err != nil {
return nil, err
}
return &BlockSubscription{
sub: genSub,
}, nil
}
type BlockSubscription struct {
sub *Subscription
}
func (sw *BlockSubscription) Recv() (*BlockResult, error) {
select {
case d := <-sw.sub.stream:
return d.(*BlockResult), nil
case err := <-sw.sub.err:
return nil, err
}
}
func (sw *BlockSubscription) Unsubscribe() {
sw.sub.Unsubscribe()
}