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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
#pragma once
#include <mutex>
#include <string>
#include <tuple>
#include <vector>
#include <nlohmann/json.hpp>
#include <plog/Log.h>
#include <websocketpp/client.hpp>
#include <websocketpp/config/asio_client.hpp>
#include "client/web_socket_client.hpp"
namespace nostr
{
typedef std::vector<std::string> RelayList;
typedef std::unordered_map<std::string, std::vector<std::string>> TagMap;
// TODO: Add null checking to seralization and deserialization methods.
/**
* @brief A Nostr event.
* @remark All data transmitted over the Nostr protocol is encoded in JSON blobs. This struct
* is common to every Nostr event kind. The significance of each event is determined by the
* `tags` and `content` fields.
*/
struct Event
{
std::string id; ///< SHA-256 hash of the event data.
std::string pubkey; ///< Public key of the event creator.
std::time_t createdAt; ///< Unix timestamp of the event creation.
int kind; ///< Event kind.
std::vector<std::vector<std::string>> tags; ///< Arbitrary event metadata.
std::string content; ///< Event content.
std::string sig; ///< Event signature created with the private key of the event creator.
/**
* @brief Serializes the event to a JSON object.
* @returns A stringified JSON object representing the event.
* @throws `std::invalid_argument` if the event object is invalid.
*/
std::string serialize();
/**
* @brief Deserializes the event from a JSON string.
* @param jsonString A stringified JSON object representing the event.
*/
void deserialize(std::string jsonString);
private:
/**
* @brief Validates the event.
* @throws `std::invalid_argument` if the event object is invalid.
* @remark The `createdAt` field defaults to the present if it is not already set.
*/
void validate();
/**
* @brief Generates an ID for the event.
* @param serializedData The serialized JSON string of all of the event data except the ID and
* the signature.
* @return A valid Nostr event ID.
* @remark The ID is a 32-bytes lowercase hex-encoded sha256 of the serialized event data.
*/
std::string generateId(std::string serializedData) const;
};
/**
* @brief A set of filters for querying Nostr relays.
* @remark The `limit` field should always be included to keep the response size reasonable. The
* `since` field is not required, and the `until` field will default to the present. At least one
* of the other fields must be set for a valid filter.
*/
struct Filters
{
std::vector<std::string> ids; ///< Event IDs.
std::vector<std::string> authors; ///< Event author npubs.
std::vector<int> kinds; ///< Kind numbers.
TagMap tags; ///< Tag names mapped to lists of tag values.
std::time_t since; ///< Unix timestamp. Matching events must be newer than this.
std::time_t until; ///< Unix timestamp. Matching events must be older than this.
int limit; ///< The maximum number of events the relay should return on the initial query.
/**
* @brief Serializes the filters to a JSON object.
* @returns A stringified JSON object representing the filters.
* @throws `std::invalid_argument` if the filter object is invalid.
*/
std::string serialize();
private:
/**
* @brief Validates the filters.
* @throws `std::invalid_argument` if the filter object is invalid.
* @remark The `until` field defaults to the present if it is not already set.
*/
void validate();
};
class NostrService
{
public:
NostrService(plog::IAppender* appender, client::IWebSocketClient* client);
NostrService(plog::IAppender* appender, client::IWebSocketClient* client, RelayList relays);
~NostrService();
RelayList defaultRelays() const;
RelayList activeRelays() const;
/**
* @brief Opens connections to the default Nostr relays of the instance, as specified in
* the constructor.
* @return A list of the relay URLs to which connections were successfully opened.
*/
RelayList openRelayConnections();
/**
* @brief Opens connections to the specified Nostr relays.
* @returns A list of the relay URLs to which connections were successfully opened.
*/
RelayList openRelayConnections(RelayList relays);
/**
* @brief Closes all open relay connections.
*/
void closeRelayConnections();
/**
* @brief Closes any open connections to the specified Nostr relays.
*/
void closeRelayConnections(RelayList relays);
/**
* @brief Publishes a Nostr event to all open relay connections.
* @returns A tuple of `RelayList` objects, of the form `<successes, failures>`, indicating
* to which relays the event was published successfully, and to which relays the event failed
* to publish.
*/
std::tuple<RelayList, RelayList> publishEvent(Event event);
// TODO: Add methods for reading events from relays.
private:
std::mutex _propertyMutex;
RelayList _defaultRelays;
RelayList _activeRelays;
client::IWebSocketClient* _client;
/**
* @brief Determines which of the given relays are currently connected.
* @returns A list of the URIs of currently-open relay connections from the given list.
*/
RelayList getConnectedRelays(RelayList relays);
/**
* @brief Determines which of the given relays are not currently connected.
* @returns A list of the URIs of currently-unconnected relays from the given list.
*/
RelayList getUnconnectedRelays(RelayList relays);
/**
* @brief Determines whether the given relay is currently connected.
* @returns True if the relay is connected, false otherwise.
*/
bool isConnected(std::string relay);
/**
* @brief Removes the given relay from the instance's list of active relays.
*/
void eraseActiveRelay(std::string relay);
/**
* @brief Opens a connection from the client to the given relay.
*/
void connect(std::string relay);
/**
* @brief Closes the connection from the client to the given relay.
*/
void disconnect(std::string relay);
};
} // namespace nostr
|
