forked from nbd-wtf/go-nostr
-
Notifications
You must be signed in to change notification settings - Fork 0
/
example.go
129 lines (116 loc) · 3 KB
/
example.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
package main
import (
"context"
"encoding/json"
"fmt"
"io"
"os"
"strings"
"time"
"github.com/studiokaiji/go-nostr"
"github.com/studiokaiji/go-nostr/nip19"
)
func main() {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
// connect to relay
url := "wss://nostr.zebedee.cloud"
relay, err := nostr.RelayConnect(ctx, url)
if err != nil {
panic(err)
}
reader := os.Stdin
var npub string
var b [64]byte
fmt.Fprintf(os.Stderr, "using %s\n----\nexample subscription for three most recent notes mentioning user\npaste npub key: ", url)
if n, err := reader.Read(b[:]); err == nil {
npub = strings.TrimSpace(fmt.Sprintf("%s", b[:n]))
} else {
panic(err)
}
// create filters
var filters nostr.Filters
if _, v, err := nip19.Decode(npub); err == nil {
t := make(map[string][]string)
// making a "p" tag for the above public key.
// this filters for messages tagged with the user, mainly replies.
t["p"] = []string{v.(string)}
filters = []nostr.Filter{{
Kinds: []int{1},
Tags: t,
// limit = 3, get the three most recent notes
Limit: 3,
}}
} else {
panic("not a valid npub!")
}
// create a subscription and submit to relay
// results will be returned on the sub.Events channel
sub, _ := relay.Subscribe(ctx, filters)
// we will append the returned events to this slice
evs := make([]nostr.Event, 0)
go func() {
<-sub.EndOfStoredEvents
cancel()
}()
for ev := range sub.Events {
evs = append(evs, *ev)
}
filename := "example_output.json"
if f, err := os.Create(filename); err == nil {
fmt.Fprintf(os.Stderr, "returned events saved to %s\n", filename)
// encode the returned events in a file
enc := json.NewEncoder(f)
enc.SetIndent("", " ")
enc.Encode(evs)
f.Close()
} else {
panic(err)
}
fmt.Fprintf(os.Stderr, "----\nexample publication of note.\npaste nsec key (leave empty to autogenerate): ")
var nsec string
if n, err := reader.Read(b[:]); err == nil {
nsec = strings.TrimSpace(fmt.Sprintf("%s", b[:n]))
} else {
panic(err)
}
var sk string
ev := nostr.Event{}
if _, s, e := nip19.Decode(nsec); e == nil {
sk = s.(string)
} else {
sk = nostr.GeneratePrivateKey()
}
if pub, e := nostr.GetPublicKey(sk); e == nil {
ev.PubKey = pub
if npub, e := nip19.EncodePublicKey(pub); e == nil {
fmt.Fprintln(os.Stderr, "using:", npub)
}
} else {
panic(e)
}
ev.CreatedAt = nostr.Now()
ev.Kind = 1
var content string
fmt.Fprintln(os.Stderr, "enter content of note, ending with an empty newline (ctrl+d):")
for {
if n, err := reader.Read(b[:]); err == nil {
content = fmt.Sprintf("%s%s", content, fmt.Sprintf("%s", b[:n]))
} else if err == io.EOF {
break
} else {
panic(err)
}
}
ev.Content = strings.TrimSpace(content)
ev.Sign(sk)
for _, url := range []string{"wss://nostr.zebedee.cloud"} {
ctx := context.WithValue(context.Background(), "url", url)
relay, e := nostr.RelayConnect(ctx, url)
if e != nil {
fmt.Println(e)
continue
}
fmt.Println("posting to: ", url)
relay.Publish(ctx, ev)
}
}