/
notify.go
executable file
·147 lines (124 loc) · 3.61 KB
/
notify.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
package discord
import (
"bytes"
"fmt"
"github.com/SuSy-One/susy-v2/node/pkg/vaa"
"github.com/diamondburned/arikawa/v3/api"
"github.com/diamondburned/arikawa/v3/discord"
"go.uber.org/zap"
"strings"
"sync"
)
type DiscordNotifier struct {
c *api.Client
chans []discord.Channel
logger *zap.Logger
groupToIDMu sync.RWMutex
groupToID map[string]string
}
// NewDiscordNotifier returns and initializes a new Discord notifier.
//
// During initialization, a list of all guilds and channels is fetched.
// Newly added guilds and channels won't be detected at runtime.
func NewDiscordNotifier(botToken string, channelName string, logger *zap.Logger) (*DiscordNotifier, error) {
c := api.NewClient("Bot " + botToken)
chans := make([]discord.Channel, 0)
guilds, err := c.Guilds(0)
if err != nil {
return nil, fmt.Errorf("failed to retrieve guilds: %w", err)
}
for _, guild := range guilds {
gcn, err := c.Channels(guild.ID)
if err != nil {
return nil, fmt.Errorf("failed to retrieve channels for %s: %w", guild.ID, err)
}
for _, cn := range gcn {
if cn.Name == channelName {
chans = append(chans, cn)
}
}
}
logger.Info("notification channels", zap.Any("channels", chans))
return &DiscordNotifier{
c: c,
chans: chans,
logger: logger,
groupToID: make(map[string]string),
}, nil
}
func wrapCode(in string) string {
return fmt.Sprintf("`%s`", in)
}
func (d *DiscordNotifier) LookupGroupID(groupName string) (string, error) {
d.groupToIDMu.RLock()
if id, ok := d.groupToID[groupName]; ok {
d.groupToIDMu.RUnlock()
return id, nil
}
d.groupToIDMu.RUnlock()
guilds, err := d.c.Guilds(0)
if err != nil {
return "", fmt.Errorf("failed to retrieve guilds: %w", err)
}
for _, guild := range guilds {
gcn, err := d.c.Roles(guild.ID)
if err != nil {
return "", fmt.Errorf("failed to retrieve roles for %s: %w", guild.ID, err)
}
for _, cn := range gcn {
if cn.Name == groupName {
m := cn.ID.String()
d.groupToIDMu.Lock()
d.groupToID[groupName] = m
d.groupToIDMu.Unlock()
return m, nil
}
}
}
return "", fmt.Errorf("failed to find group %s", groupName)
}
func (d *DiscordNotifier) MissingSignaturesOnTransaction(v *vaa.VAA, hasSigs, wantSigs int, quorum bool, missing []string) error {
if len(missing) == 0 {
panic("no missing nodes specified")
}
var quorumText string
if quorum {
quorumText = fmt.Sprintf("✔️ yes (%d/%d)", hasSigs, wantSigs)
} else {
quorumText = fmt.Sprintf("🚨️ **NO** (%d/%d)", hasSigs, wantSigs)
}
var messageText string
if !quorum {
messageText = "**NO QUORUM** - Wormhole likely failed to achieve consensus on this message @here"
}
missingText := &bytes.Buffer{}
for _, m := range missing {
groupID, err := d.LookupGroupID(m)
if err != nil {
d.logger.Error("failed to lookup group id", zap.Error(err), zap.String("name", m))
groupID = m
} else {
groupID = fmt.Sprintf("<@&%s>", groupID)
}
if _, err := fmt.Fprintf(missingText, "- %s\n", groupID); err != nil {
panic(err)
}
}
for _, cn := range d.chans {
if _, err := d.c.SendMessage(cn.ID, messageText,
discord.Embed{
Title: "Message with missing signatures",
Fields: []discord.EmbedField{
{Name: "Message ID", Value: wrapCode(v.MessageID()), Inline: true},
{Name: "Digest", Value: wrapCode(v.HexDigest()), Inline: true},
{Name: "Quorum", Value: quorumText, Inline: true},
{Name: "Source Chain", Value: strings.Title(v.EmitterChain.String()), Inline: false},
{Name: "Missing Guardians", Value: missingText.String(), Inline: false},
},
},
); err != nil {
return err
}
}
return nil
}