NostrPool.h

Go to the documentation of this file.

#ifndef _NOSTR_POOL_H
#define _NOSTR_POOL_H
#include <Arduino.h>
#include <NostrTransport.h>
#include <functional>
#include <initializer_list>
#include <map>
#include <mutex>
#include <vector>
#include "NostrString.h"
#include "NostrLimits.h"
#include "ArduinoJson.h"
#include "NostrEvent.h"
#include "NostrString.h"
 
 
namespace nostr {
    class NostrRelay;
 
    using NostrCloseCallback =
        std::function<void(const NostrString &, const NostrString &)>;
    using NostrNoticeCallback =
        std::function<void(NostrRelay *, const NostrString &)>;
    using NostrEOSECallback = std::function<void(const NostrString &)>;
 
    using NostrEventCallback =
        std::function<void(const NostrString &, SignedNostrEvent *event)>;
    using NostrEventStatusCallback =
        std::function<void(const NostrString &, bool, const NostrString& )>;
    using NostrSeenCallback = std::function<bool(const SignedNostrEvent &)>;
    struct NostrRelaySubscriptionState {
        bool active = true;
        bool eose = false;
        bool closed = false;
        bool disconnected = false;
    };
 
    class NostrSubscription {
       public:
        bool eose = false;
        NostrCloseCallback closeCallback = nullptr;
        NostrEOSECallback eoseCallback = nullptr;
        NostrEventCallback eventCallback = nullptr;
        NostrEventStatusCallback statusCallback = nullptr;
 
       private:
        friend class NostrPool;
        NostrString request;
        std::map<NostrString, NostrRelaySubscriptionState> relayStates;
    };
 
    typedef struct s_EventStatusCallbackEntry {
        NostrEventStatusCallback statusCallback;
        long long timestampSeconds;
        NostrString eventId;
    } EventStatusCallbackEntry;
 
    class NostrRelay {
        friend class NostrPool;
 
       public:
        bool send(NostrString message);
        NostrRelay(Connection *conn, NostrString url, const NostrLimits &limits)
            : conn(conn), url(url), limits(limits){};
        Connection *getConnection() const { return conn; }
        NostrString getUrl() const{
            return url;
        }
       protected:
         Connection *conn;
         NostrString url;
         std::vector<NostrString> messageQueue;
         size_t queuedMessageBytes = 0;
         NostrLimits limits;
         bool connectedOnce = false;
         bool restoreSubscriptions = false;
         void processQueue();
    };
 
    class NostrPool {
      
       public:
         NostrPool(Transport *transport, int eventStatusTimeoutSeconds = 60 * 10, const NostrLimits &limits = NostrLimits()) {
             this->transport = transport;
             this->eventStatusTimeoutSeconds = eventStatusTimeoutSeconds;
             this->limits = limits;
        };
        ~NostrPool();
 
        NostrPool(const NostrPool &) = delete;
        NostrPool &operator=(const NostrPool &) = delete;
        NostrPool(NostrPool &&) = delete;
        NostrPool &operator=(NostrPool &&) = delete;
 
        NostrString subscribeMany(
            std::initializer_list<NostrString> urls,
            std::initializer_list<
                std::map<NostrString, std::initializer_list<NostrString>>>
                filters,
            NostrEventCallback eventCallback = nullptr,
            NostrCloseCallback closeCallback = nullptr,
            NostrEOSECallback eoseCallback = nullptr
      
        );
        NostrString subscribeMany(
            const std::vector<NostrString> &urls,
            std::initializer_list<
                std::map<NostrString, std::initializer_list<NostrString>>>
                filters,
            NostrEventCallback eventCallback = nullptr,
            NostrCloseCallback closeCallback = nullptr,
            NostrEOSECallback eoseCallback = nullptr);
 
        NostrString subscribeMany(std::initializer_list<NostrString> urls, JsonArray filters,
                                  NostrEventCallback eventCallback = nullptr, NostrCloseCallback closeCallback = nullptr, NostrEOSECallback eoseCallback = nullptr
 
        );
        NostrString subscribeMany(const std::vector<NostrString> &urls, JsonArray filters,
                                  NostrEventCallback eventCallback = nullptr,
                                  NostrCloseCallback closeCallback = nullptr,
                                  NostrEOSECallback eoseCallback = nullptr);
        bool publish(std::initializer_list<NostrString> rs,
                     SignedNostrEvent *event,
                     NostrEventStatusCallback statusCallback = nullptr);
        bool publish(const std::vector<NostrString> &rs, SignedNostrEvent *event,
                     NostrEventStatusCallback statusCallback = nullptr);
 
        void loop();
 
        void setVerifyIncomingEvents(bool verify) { verifyIncomingEvents = verify; }
 
        bool getVerifyIncomingEvents() const { return verifyIncomingEvents; }
 
        void setSeenTracker(NostrSeenCallback callback);
 
        void closeSubscription(NostrString subId);
 
        const NostrSubscription *getSubscription(const NostrString &subId) const;
 
        bool hasSubscription(const NostrString &subId) const;
 
        NostrRelay *ensureRelay(NostrString url);
 
        std::vector<NostrString> getRelays();
 
        void disconnectRelay(NostrString url);
 
        void close();
 
  
        const std::vector<NostrRelay *> *getConnectedRelays() const;
 
      private:
        class DispatchGuard {
          public:
            explicit DispatchGuard(NostrPool *pool) : pool(pool) { ++pool->dispatchDepth; }
            ~DispatchGuard() {
                if (--pool->dispatchDepth == 0) pool->flushDeferredMutations();
            }
 
          private:
            NostrPool *pool;
        };
 
        NostrNoticeCallback noticeCallback = nullptr;
        long long subs = 0;
        std::map<NostrString, NostrSubscription> subscriptions;
        std::vector<NostrRelay *> relays;
        void onEvent(NostrRelay *relay, NostrString message);
        void recomputeSubscriptionEose(const NostrString &subId);
        int eventStatusTimeoutSeconds = 60 * 10;
        std::vector<EventStatusCallbackEntry> eventStatusCallbackEntries;
        Transport *transport;
        NostrLimits limits;
        bool verifyIncomingEvents = false;
        NostrSeenCallback seen = [](const SignedNostrEvent &) { return false; };
        std::mutex seenMutex;
        unsigned int dispatchDepth = 0;
        bool deferredClose = false;
        std::vector<NostrString> deferredRelayDisconnects;
        void disconnectRelayNow(const NostrString &url);
        void performClose();
        void flushDeferredMutations();
    };
}  // namespace nostr
#endif