From 1a4067e5d18c3aa5dab3214c3fee37603c3a923a Mon Sep 17 00:00:00 2001
From: Believethehype <1097224+believethehype@users.noreply.github.com>
Date: Tue, 20 Aug 2024 18:40:46 +0200
Subject: [PATCH] going back to rust-sdk 0.33

---
 nostr_dvm/subscription.py                     |  9 +++----
 nostr_dvm/tasks/advanced_search.py            |  7 +++--
 ...t_discovery_currently_popular_followers.py |  5 ++--
 ...ent_discovery_currently_popular_gallery.py |  5 ++--
 ...ntent_discovery_currently_popular_mostr.py |  5 ++--
 ...iscovery_currently_popular_nonfollowers.py |  5 ++--
 ...ntent_discovery_latest_one_per_follower.py |  8 +++---
 nostr_dvm/tasks/discovery_censor_wot.py       |  8 +++---
 nostr_dvm/tasks/discovery_inactive_follows.py |  8 +++---
 nostr_dvm/tasks/discovery_nonfollowers.py     |  8 +++---
 .../discovery_trending_notes_gleasonator.py   |  6 ++---
 nostr_dvm/utils/database_utils.py             |  5 ++--
 nostr_dvm/utils/nip88_utils.py                | 14 ++++------
 nostr_dvm/utils/nip89_utils.py                | 12 +++------
 nostr_dvm/utils/nostr_utils.py                | 27 +++++++------------
 nostr_dvm/utils/nut_wallet_utils.py           | 11 +++-----
 nostr_dvm/utils/wot_utils.py                  |  9 +++----
 setup.py                                      |  4 +--
 tests/ditto.py                                |  5 ++--
 tests/gui/nicegui/nostrAI_search_client.py    |  7 +++--
 tests/test_events.py                          |  8 +++---
 tests/wot.py                                  |  5 ++--
 22 files changed, 68 insertions(+), 113 deletions(-)

diff --git a/nostr_dvm/subscription.py b/nostr_dvm/subscription.py
index 755a3af..624a227 100644
--- a/nostr_dvm/subscription.py
+++ b/nostr_dvm/subscription.py
@@ -7,8 +7,7 @@ import time
 from datetime import timedelta
 
 from nostr_sdk import (Keys, Client, Timestamp, Filter, nip04_decrypt, HandleNotification, EventBuilder, PublicKey,
-                       Options, Tag, Event, nip04_encrypt, NostrSigner, EventId, Nip19Event, nip44_decrypt, Kind,
-                       EventSource)
+                       Options, Tag, Event, nip04_encrypt, NostrSigner, EventId, Nip19Event, nip44_decrypt, Kind)
 
 from nostr_dvm.utils.database_utils import fetch_user_metadata
 from nostr_dvm.utils.definitions import EventDefinitions
@@ -249,8 +248,7 @@ class Subscription:
 
                     subscriptionfilter = Filter().kind(EventDefinitions.KIND_NIP88_SUBSCRIBE_EVENT).author(
                         PublicKey.parse(subscriber)).limit(1)
-                    source = EventSource.relays(timedelta(seconds=5))
-                    evts = await self.client.get_events_of([subscriptionfilter], source)
+                    evts = await self.client.get_events_of([subscriptionfilter], timedelta(seconds=3))
                     if len(evts) > 0:
                         event7001id = evts[0].id().to_hex()
                         print(evts[0].as_json())
@@ -287,8 +285,7 @@ class Subscription:
 
                         if tier_dtag == "" or len(zaps) == 0:
                             tierfilter = Filter().id(EventId.parse(subscription_event_id))
-                            source = EventSource.relays(timedelta(seconds=5))
-                            evts = await self.client.get_events_of([tierfilter], source)
+                            evts = await self.client.get_events_of([tierfilter], timedelta(seconds=3))
                             if len(evts) > 0:
                                 for tag in evts[0].tags():
                                     if tag.as_vec()[0] == "d":
diff --git a/nostr_dvm/tasks/advanced_search.py b/nostr_dvm/tasks/advanced_search.py
index 81df7e4..685b75d 100644
--- a/nostr_dvm/tasks/advanced_search.py
+++ b/nostr_dvm/tasks/advanced_search.py
@@ -1,8 +1,7 @@
 import json
 import os
 from datetime import timedelta
-from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
-    EventSource
+from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -132,8 +131,8 @@ class AdvancedSearch(DVMTaskInterface):
         else:
             notes_filter = Filter().kind(Kind(1)).authors(userkeys).search(options["search"]).since(
                 search_since).until(search_until).limit(options["max_results"])
-        source = EventSource.relays(timedelta(seconds=5))
-        events = await cli.get_events_of([notes_filter], timedelta(seconds=source))
+
+        events = await cli.get_events_of([notes_filter], timedelta(seconds=5))
 
         result_list = []
         if len(events) > 0:
diff --git a/nostr_dvm/tasks/content_discovery_currently_popular_followers.py b/nostr_dvm/tasks/content_discovery_currently_popular_followers.py
index a3720cd..b3a7fc1 100644
--- a/nostr_dvm/tasks/content_discovery_currently_popular_followers.py
+++ b/nostr_dvm/tasks/content_discovery_currently_popular_followers.py
@@ -4,7 +4,7 @@ import os
 from datetime import timedelta
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
     ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
-    RelayOptions, RelayLimits, EventSource
+    RelayOptions, RelayLimits
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils import definitions
@@ -113,8 +113,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
 
         user = PublicKey.parse(options["user"])
         followers_filter = Filter().author(user).kinds([Kind(3)])
-        source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
-        followers = await cli.get_events_of([followers_filter], source)
+        followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
         #print(followers)
 
         # Negentropy reconciliation
diff --git a/nostr_dvm/tasks/content_discovery_currently_popular_gallery.py b/nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
index 380ff73..8aad1f7 100644
--- a/nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
+++ b/nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
@@ -4,7 +4,7 @@ import os
 from datetime import timedelta
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
     ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
-    RelayOptions, RelayLimits, EventSource
+    RelayOptions, RelayLimits
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils import definitions
@@ -172,8 +172,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
 
 
         filter2 = Filter().ids(ids)
-        source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
-        events = await cli.get_events_of([filter2], source)
+        events = await cli.get_events_of([filter2], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
 
         print(len(events))
 
diff --git a/nostr_dvm/tasks/content_discovery_currently_popular_mostr.py b/nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
index b522bf4..30475e8 100644
--- a/nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
+++ b/nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
@@ -4,7 +4,7 @@ import os
 from datetime import timedelta
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
     ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
-    RelayOptions, EventSource
+    RelayOptions
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils import definitions
@@ -256,8 +256,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
         #await cli.reconcile(filter3, dbopts)
 
         # RECONCOILE NOT POSSIBLE ON THESE RELAYS SO WE FETCH AB BUNCH (will be stored in db)
-        source = EventSource.relays(timedelta(seconds=10))
-        events = await cli.get_events_of([filter1, filter2, filter3], source)
+        events = await cli.get_events_of([filter1, filter2, filter3], None)
 
         # Do not delete profiles
         await cli.database().delete(Filter().kinds([EventDefinitions.KIND_NOTE, EventDefinitions.KIND_ZAP, EventDefinitions.KIND_REPOST, EventDefinitions.KIND_REACTION]).until(Timestamp.from_secs(
diff --git a/nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py b/nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
index 0115e3d..6381cac 100644
--- a/nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
+++ b/nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
@@ -4,7 +4,7 @@ import os
 from datetime import timedelta
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
     ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
-    RelayLimits, EventSource
+    RelayLimits
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils import definitions
@@ -154,8 +154,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
         await cli.connect()
         user = PublicKey.parse(options["user"])
         followers_filter = Filter().author(user).kinds([Kind(3)])
-        source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
-        followers = await cli.get_events_of([followers_filter], source)
+        followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
         if len(followers) > 0:
             newest = 0
             best_entry = followers[0]
diff --git a/nostr_dvm/tasks/content_discovery_latest_one_per_follower.py b/nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
index a0a8e98..d96fbe3 100644
--- a/nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
+++ b/nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
@@ -5,7 +5,7 @@ from datetime import timedelta
 from threading import Thread
 
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
-    RelayLimits, Event, EventSource
+    RelayLimits, Event
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -92,8 +92,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
-        source = EventSource.relays(timedelta(seconds=5))
-        followers = await cli.get_events_of([followers_filter], source)
+        followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
 
         if len(followers) > 0:
             result_list = []
@@ -141,8 +140,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
                     filter1 = (Filter().author(PublicKey.from_hex(users[i])).kind(Kind(1))
                                .limit(1))
                     filters.append(filter1)
-                source = EventSource.relays(timedelta(seconds=10))
-                event_from_authors = await cli.get_events_of(filters, source)
+                event_from_authors = await cli.get_events_of(filters, timedelta(seconds=10))
                 for author in event_from_authors:
                     if instance.dic[author.author().to_hex()] is None:
                         instance.dic[author.author().to_hex()] = author
diff --git a/nostr_dvm/tasks/discovery_censor_wot.py b/nostr_dvm/tasks/discovery_censor_wot.py
index 308776f..1c8df34 100644
--- a/nostr_dvm/tasks/discovery_censor_wot.py
+++ b/nostr_dvm/tasks/discovery_censor_wot.py
@@ -4,7 +4,7 @@ from datetime import timedelta
 from threading import Thread
 
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
-    RelayLimits, Event, EventSource
+    RelayLimits, Event
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -97,8 +97,7 @@ class DiscoverReports(DVMTaskInterface):
         # if we don't add users, e.g. by a wot, we check all our followers.
         if len(pubkeys) == 0:
             followers_filter = Filter().author(PublicKey.parse(options["sender"])).kind(Kind(3))
-            source = EventSource.relays(timedelta(seconds=5))
-            followers = await cli.get_events_of([followers_filter], source)
+            followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
 
             if len(followers) > 0:
                 result_list = []
@@ -119,8 +118,7 @@ class DiscoverReports(DVMTaskInterface):
             options["since_days"])  # TODO make this an option, 180 days for now
         since = Timestamp.from_secs(ago)
         kind1984_filter = Filter().authors(pubkeys).kind(Kind(1984)).since(since)
-        source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
-        reports = await cli.get_events_of([kind1984_filter], source)
+        reports = await cli.get_events_of([kind1984_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
 
         bad_actors = []
         ns.dic = {}
diff --git a/nostr_dvm/tasks/discovery_inactive_follows.py b/nostr_dvm/tasks/discovery_inactive_follows.py
index a301bd8..ff562c1 100644
--- a/nostr_dvm/tasks/discovery_inactive_follows.py
+++ b/nostr_dvm/tasks/discovery_inactive_follows.py
@@ -5,7 +5,7 @@ from datetime import timedelta
 from threading import Thread
 
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
-    RelayLimits, EventSource
+    RelayLimits
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -92,8 +92,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
-        source = EventSource.relays(timedelta(seconds=5))
-        followers = await cli.get_events_of([followers_filter], source)
+        followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
 
         if len(followers) > 0:
             result_list = []
@@ -141,8 +140,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
                 for i in range(i, i + st):
                     filter1 = Filter().author(PublicKey.from_hex(users[i])).since(notactivesince).limit(1)
                     filters.append(filter1)
-                source = EventSource.relays(timedelta(seconds=10))
-                event_from_authors = await cli.get_events_of(filters, source)
+                event_from_authors = await cli.get_events_of(filters, timedelta(seconds=10))
                 for author in event_from_authors:
                     instance.dic[author.author().to_hex()] = "True"
                 print(str(i) + "/" + str(len(users)))
diff --git a/nostr_dvm/tasks/discovery_nonfollowers.py b/nostr_dvm/tasks/discovery_nonfollowers.py
index 5fef75c..c5f5aed 100644
--- a/nostr_dvm/tasks/discovery_nonfollowers.py
+++ b/nostr_dvm/tasks/discovery_nonfollowers.py
@@ -5,7 +5,7 @@ from datetime import timedelta
 from threading import Thread
 
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
-    RelayLimits, EventSource
+    RelayLimits
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -81,8 +81,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.from_hex(options["user"])).kind(Kind(3))
-        source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
-        followers = await cli.get_events_of([followers_filter], source)
+        followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
 
         if len(followers) > 0:
             result_list = []
@@ -119,8 +118,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
                     filters = []
                     filter1 = Filter().author(PublicKey.from_hex(users[i])).kind(Kind(3))
                     filters.append(filter1)
-                    source = EventSource.relays(timedelta(seconds=3))
-                    followers = await cli.get_events_of(filters, source)
+                    followers = await cli.get_events_of(filters, timedelta(seconds=3))
 
                     if len(followers) > 0:
                         result_list = []
diff --git a/nostr_dvm/tasks/discovery_trending_notes_gleasonator.py b/nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
index 077c485..0570b24 100644
--- a/nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
+++ b/nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
@@ -3,7 +3,7 @@ import os
 from datetime import timedelta
 
 from nostr_sdk import Tag, Kind, init_logger, LogLevel, Filter, Timestamp, RelayOptions, Client, NostrSigner, Keys, \
-    SecretKey, Options, SingleLetterTag, Alphabet, PublicKey, EventSource
+    SecretKey, Options, SingleLetterTag, Alphabet, PublicKey
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils.admin_utils import AdminConfig
@@ -11,6 +11,7 @@ from nostr_dvm.utils.definitions import EventDefinitions
 from nostr_dvm.utils.dvmconfig import DVMConfig, build_default_config
 from nostr_dvm.utils.nip88_utils import NIP88Config
 from nostr_dvm.utils.nip89_utils import NIP89Config, check_and_set_d_tag
+from nostr_dvm.utils.nostr_utils import check_and_set_private_key
 from nostr_dvm.utils.output_utils import post_process_list_to_events
 
 """
@@ -83,9 +84,8 @@ class TrendingNotesGleasonator(DVMTaskInterface):
         ltags = ["#e", "pub.ditto.trends"]
         authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
         notes_filter = Filter().authors(authors).kind(Kind(1985)).custom_tag(SingleLetterTag.lowercase(Alphabet.L), ltags)
-        source = EventSource.relays(timedelta(seconds=10))
 
-        events = await cli.get_events_of([notes_filter], source)
+        events = await cli.get_events_of([notes_filter], timedelta(seconds=10))
 
         result_list = []
         if len(events) > 0:
diff --git a/nostr_dvm/utils/database_utils.py b/nostr_dvm/utils/database_utils.py
index e1756ba..594078b 100644
--- a/nostr_dvm/utils/database_utils.py
+++ b/nostr_dvm/utils/database_utils.py
@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from datetime import timedelta
 from logging import Filter
 
-from nostr_sdk import Timestamp, Keys, PublicKey, EventBuilder, Filter, Kind, EventSource
+from nostr_sdk import Timestamp, Keys, PublicKey, EventBuilder, Filter, Kind
 from nostr_dvm.utils.nostr_utils import send_event
 
 
@@ -254,8 +254,7 @@ async def fetch_user_metadata(npub, client):
     pk = PublicKey.parse(npub)
     print(f"\nGetting profile metadata for {pk.to_bech32()}...")
     profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
-    source = EventSource.relays(timedelta(seconds=1))
-    events = await client.get_events_of([profile_filter], source)
+    events = await client.get_events_of([profile_filter], timedelta(seconds=1))
     if len(events) > 0:
         latest_entry = events[0]
         latest_time = 0
diff --git a/nostr_dvm/utils/nip88_utils.py b/nostr_dvm/utils/nip88_utils.py
index f392c23..9dbf049 100644
--- a/nostr_dvm/utils/nip88_utils.py
+++ b/nostr_dvm/utils/nip88_utils.py
@@ -5,7 +5,7 @@ from pathlib import Path
 
 import dotenv
 from nostr_sdk import Filter, Tag, Keys, EventBuilder, Client, EventId, PublicKey, Event, Timestamp, SingleLetterTag, \
-    Alphabet, Kind, EventSource
+    Alphabet, Kind
 
 from nostr_dvm.utils import definitions
 from nostr_dvm.utils.definitions import EventDefinitions
@@ -37,8 +37,7 @@ def nip88_create_d_tag(name, pubkey, image):
 
 async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
     idfilter = Filter().id(EventId.from_hex(eventid)).limit(1)
-    source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
-    nip88events = await client.get_events_of([idfilter], source)
+    nip88events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
     d_tag = ""
     if len(nip88events) == 0:
         print("Event not found. Potentially gone.")
@@ -61,8 +60,7 @@ async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
 
 async def fetch_nip88_event(keys, eventid, client, dvmconfig):
     idfilter = Filter().id(EventId.parse(eventid)).limit(1)
-    source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
-    nip88events = await client.get_events_of([idfilter], source)
+    nip88events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
     d_tag = ""
     if len(nip88events) == 0:
         print("Event not found. Potentially gone.")
@@ -101,8 +99,7 @@ async def nip88_has_active_subscription(user: PublicKey, tiereventdtag, client:
     subscriptionfilter = Filter().kind(definitions.EventDefinitions.KIND_NIP88_PAYMENT_RECIPE).pubkey(
         PublicKey.parse(receiver_public_key_hex)).custom_tag(SingleLetterTag.uppercase(Alphabet.P),
                                                              [user.to_hex()]).limit(1)
-    source = EventSource.relays(timedelta(seconds=5))
-    evts = await client.get_events_of([subscriptionfilter],source)
+    evts = await client.get_events_of([subscriptionfilter], timedelta(seconds=3))
     if len(evts) > 0:
         print(evts[0].as_json())
         matchesdtag = False
@@ -123,8 +120,7 @@ async def nip88_has_active_subscription(user: PublicKey, tiereventdtag, client:
             cancel_filter = Filter().kind(EventDefinitions.KIND_NIP88_STOP_SUBSCRIPTION_EVENT).author(
                 user).pubkey(PublicKey.parse(receiver_public_key_hex)).event(
                 EventId.parse(subscription_status["subscriptionId"])).limit(1)
-            source = EventSource.relays(timedelta(seconds=5))
-            cancel_events = await client.get_events_of([cancel_filter], source)
+            cancel_events = await client.get_events_of([cancel_filter], timedelta(seconds=3))
             if len(cancel_events) > 0:
                 if cancel_events[0].created_at().as_secs() > evts[0].created_at().as_secs():
                     subscription_status["expires"] = True
diff --git a/nostr_dvm/utils/nip89_utils.py b/nostr_dvm/utils/nip89_utils.py
index 1419f5f..4d44890 100644
--- a/nostr_dvm/utils/nip89_utils.py
+++ b/nostr_dvm/utils/nip89_utils.py
@@ -4,8 +4,7 @@ from hashlib import sha256
 from pathlib import Path
 
 import dotenv
-from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Client, EventId, SingleLetterTag, Kind, \
-    EventSource
+from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Client, EventId, SingleLetterTag, Kind
 
 from nostr_dvm.utils.definitions import EventDefinitions
 from nostr_dvm.utils.nostr_utils import send_event
@@ -40,8 +39,7 @@ async def nip89_announce_tasks(dvm_config, client):
 
 async def fetch_nip89_parameters_for_deletion(keys, eventid, client, dvmconfig, pow=False):
     idfilter = Filter().id(EventId.from_hex(eventid)).limit(1)
-    source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
-    nip89events = await client.get_events_of([idfilter], source)
+    nip89events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
     d_tag = ""
     if len(nip89events) == 0:
         print("Event not found. Potentially gone.")
@@ -87,8 +85,7 @@ async def nip89_fetch_all_dvms(client):
         ktags.append(str(i))
 
     filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags)
-    source = EventSource.relays(timedelta(seconds=5))
-    events = await client.get_events_of([filter], source)
+    events = await client.get_events_of([filter], timedelta(seconds=5))
     for event in events:
         print(event.as_json())
 
@@ -97,8 +94,7 @@ async def nip89_fetch_events_pubkey(client, pubkey, kind):
     ktags = [str(kind.as_u64())]
     nip89filter = (Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(PublicKey.parse(pubkey)).
                    custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags))
-    source = EventSource.relays(timedelta(seconds=5))
-    events = await client.get_events_of([nip89filter], source)
+    events = await client.get_events_of([nip89filter], timedelta(seconds=4))
 
     dvms = {}
     for event in events:
diff --git a/nostr_dvm/utils/nostr_utils.py b/nostr_dvm/utils/nostr_utils.py
index 5c49b64..857707e 100644
--- a/nostr_dvm/utils/nostr_utils.py
+++ b/nostr_dvm/utils/nostr_utils.py
@@ -6,7 +6,7 @@ from typing import List
 
 import dotenv
 from nostr_sdk import Filter, Client, Alphabet, EventId, Event, PublicKey, Tag, Keys, nip04_decrypt, Metadata, Options, \
-    Nip19Event, SingleLetterTag, RelayOptions, RelayLimits, SecretKey, NostrSigner, EventSource
+    Nip19Event, SingleLetterTag, RelayOptions, RelayLimits, SecretKey, NostrSigner
 
 from nostr_dvm.utils.definitions import EventDefinitions
 
@@ -16,8 +16,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
     if len(split) == 3:
         pk = PublicKey.from_hex(split[1])
         id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
-        source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
-        events = await client.get_events_of([id_filter], source)
+        events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
     else:
         if str(event_id).startswith('note'):
             event_id = EventId.from_bech32(event_id)
@@ -33,9 +32,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
 
         id_filter = Filter().id(event_id).limit(1)
         #events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
-
-        source = EventSource.relays(timedelta(seconds=5))
-        events = await client.get_events_of([id_filter], source)
+        events = await client.get_events_of([id_filter], timedelta(seconds=5))
 
 
     if len(events) > 0:
@@ -46,8 +43,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
         return None
 
 async def get_events_async(client, filter, timeout):
-    source = EventSource.relays(timedelta(seconds=timeout))
-    events = await client.get_events_of([filter], source)
+    events = await client.get_events_of([filter], timedelta(seconds=timeout))
     return events
 
 
@@ -59,8 +55,7 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
         if len(split) == 3:
             pk = PublicKey.from_hex(split[1])
             id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
-            source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
-            events = await client.get_events_of([id_filter], source)
+            events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
             #events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
         else:
             if str(event_id).startswith('note'):
@@ -77,8 +72,7 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
             search_ids.append(event_id)
 
             id_filter = Filter().ids(search_ids)
-            source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
-            events = await client.get_events_of([id_filter], source)
+            events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
 
     #events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
     if len(events) > 0:
@@ -90,8 +84,7 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
 async def get_events_by_id(event_ids: list, client: Client, config=None) -> list[Event] | None:
     id_filter = Filter().ids(event_ids)
     #events = asyncio.run(get_events_async(client, id_filter, config.RELAY_TIMEOUT))
-    source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
-    events = await client.get_events_of([id_filter], source)
+    events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
     if len(events) > 0:
         return events
     else:
@@ -116,8 +109,7 @@ async def get_referenced_event_by_id(event_id, client, dvm_config, kinds) -> Eve
         job_id_filter = Filter().kinds(kinds).event(event_id).limit(1)
     else:
         job_id_filter = Filter().event(event_id).limit(1)
-    source = EventSource.relays(timedelta(seconds=dvm_config.RELAY_TIMEOUT))
-    events = await client.get_events_of([job_id_filter], source)
+    events = await client.get_events_of([job_id_filter], timedelta(seconds=dvm_config.RELAY_TIMEOUT))
     #events = await get_events_async(client, job_id_filter, dvm_config.RELAY_TIMEOUT)
     #events = client.get_events_of([job_id_filter], timedelta(seconds=dvm_config.RELAY_TIMEOUT))
 
@@ -135,8 +127,7 @@ async def get_inbox_relays(event_to_send: Event, client: Client, dvm_config):
             ptags.append(ptag)
 
     filter = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
-    source = EventSource.relays(timedelta(seconds=dvm_config.RELAY_TIMEOUT))
-    events = await client.get_events_of([filter], source)
+    events = await client.get_events_of([filter], timedelta(dvm_config.RELAY_TIMEOUT))
     if len(events) == 0:
         return []
     else:
diff --git a/nostr_dvm/utils/nut_wallet_utils.py b/nostr_dvm/utils/nut_wallet_utils.py
index d2f1ec0..b2b8685 100644
--- a/nostr_dvm/utils/nut_wallet_utils.py
+++ b/nostr_dvm/utils/nut_wallet_utils.py
@@ -11,7 +11,7 @@ from nostr_dvm.utils.dvmconfig import DVMConfig
 from nostr_dvm.utils.nostr_utils import check_and_set_private_key
 from nostr_dvm.utils.zap_utils import pay_bolt11_ln_bits, zaprequest
 from nostr_sdk import Tag, Keys, nip44_encrypt, nip44_decrypt, Nip44Version, EventBuilder, Client, Filter, Kind, \
-    EventId, nip04_decrypt, nip04_encrypt, Options, NostrSigner, PublicKey, init_logger, LogLevel, Metadata, EventSource
+    EventId, nip04_decrypt, nip04_encrypt, Options, NostrSigner, PublicKey, init_logger, LogLevel, Metadata
 from nostr_dvm.utils.print import bcolors
 
 class NutWallet(object):
@@ -120,8 +120,7 @@ class NutZapWallet:
         nut_wallet = None
 
         wallet_filter = Filter().kind(EventDefinitions.KIND_NUT_WALLET).author(keys.public_key())
-        source = EventSource.relays(timedelta(seconds=10))
-        wallets = await client.get_events_of([wallet_filter], source)
+        wallets = await client.get_events_of([wallet_filter], timedelta(10))
 
         if len(wallets) > 0:
 
@@ -195,8 +194,7 @@ class NutZapWallet:
 
             # Now all proof events
             proof_filter = Filter().kind(Kind(7375)).author(keys.public_key())
-            source = EventSource.relays(timedelta(seconds=5))
-            proof_events = await client.get_events_of([proof_filter], source)
+            proof_events = await client.get_events_of([proof_filter], timedelta(5))
 
             latest_proof_sec = 0
             latest_proof_event_id = EventId
@@ -449,8 +447,7 @@ class NutZapWallet:
 
     async def fetch_mint_info_event(self, pubkey, client):
         mint_info_filter = Filter().kind(Kind(10019)).author(PublicKey.parse(pubkey))
-        source = EventSource.relays(timedelta(seconds=5))
-        preferences = await client.get_events_of([mint_info_filter], source)
+        preferences = await client.get_events_of([mint_info_filter], timedelta(5))
         mints = []
         relays = []
         pubkey = ""
diff --git a/nostr_dvm/utils/wot_utils.py b/nostr_dvm/utils/wot_utils.py
index 2a33354..9d7d1f7 100644
--- a/nostr_dvm/utils/wot_utils.py
+++ b/nostr_dvm/utils/wot_utils.py
@@ -16,8 +16,7 @@ import random
 from scipy.sparse import lil_matrix, csr_matrix, isspmatrix_csr
 
 
-from nostr_sdk import Options, Keys, NostrSigner, NostrDatabase, ClientBuilder, SecretKey, Kind, PublicKey, Filter, \
-    EventSource
+from nostr_sdk import Options, Keys, NostrSigner, NostrDatabase, ClientBuilder, SecretKey, Kind, PublicKey, Filter
 
 from nostr_dvm.utils.dvmconfig import DVMConfig
 from nostr_dvm.utils.nostr_utils import check_and_set_private_key
@@ -61,8 +60,7 @@ async def get_following(pks, max_time_request=10, newer_than_time=None):
 
     await cli.connect()
 
-    source = EventSource.relays(datetime.timedelta(seconds=100))
-    events = await cli.get_events_of([filter], source)
+    events = await cli.get_events_of([filter], datetime.timedelta(seconds=max_time_request))
 
     # initializing the graph structure
     following = nx.DiGraph()
@@ -600,8 +598,7 @@ async def get_metadata(npub):
     await client.connect()
 
     profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
-    source = EventSource.relays(datetime.timedelta(seconds=4))
-    events = await client.get_events_of([profile_filter], source)
+    events = await client.get_events_of([profile_filter], datetime.timedelta(seconds=4))
     if len(events) > 0:
         try:
             profile = json.loads(events[0].content())
diff --git a/setup.py b/setup.py
index caeb0c2..44b70a4 100644
--- a/setup.py
+++ b/setup.py
@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '0.8.3'
+VERSION = '0.8.4'
 DESCRIPTION = 'A framework to build and run Nostr NIP90 Data Vending Machines'
 LONG_DESCRIPTION = ('A framework to build and run Nostr NIP90 Data Vending Machines. See the github repository for more information')
 
@@ -14,7 +14,7 @@ setup(
     long_description=LONG_DESCRIPTION,
     packages=find_packages(include=['nostr_dvm', 'nostr_dvm.*']),
 
-    install_requires=["nostr-sdk==0.34.0",
+    install_requires=["nostr-sdk==0.33.0",
                       "bech32==1.2.0",
                       "pycryptodome==3.20.0",
                       "yt-dlp==2024.5.27",
diff --git a/tests/ditto.py b/tests/ditto.py
index 15b408e..164c4b5 100644
--- a/tests/ditto.py
+++ b/tests/ditto.py
@@ -3,7 +3,7 @@ import json
 from datetime import timedelta
 
 from nostr_sdk import Options, SecretKey, NostrSigner, Keys, Client, RelayOptions, Alphabet, SingleLetterTag, Filter, \
-    Kind, PublicKey, init_logger, LogLevel, Tag, EventSource
+    Kind, PublicKey, init_logger, LogLevel, Tag
 
 from nostr_dvm.utils.nostr_utils import check_and_set_private_key
 
@@ -29,8 +29,7 @@ async def main():
     authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
     notes_filter = Filter().authors(authors).custom_tag(SingleLetterTag.lowercase(Alphabet.L), ltags)
 
-    source = EventSource.relays(timedelta(seconds=10))
-    events = await cli.get_events_of([notes_filter], source)
+    events = await cli.get_events_of([notes_filter], timedelta(seconds=10))
 
     result_list = []
     if len(events) > 0:
diff --git a/tests/gui/nicegui/nostrAI_search_client.py b/tests/gui/nicegui/nostrAI_search_client.py
index a38db1e..3588d1d 100644
--- a/tests/gui/nicegui/nostrAI_search_client.py
+++ b/tests/gui/nicegui/nostrAI_search_client.py
@@ -4,7 +4,7 @@ import time
 from datetime import timedelta
 from nicegui import run, ui
 from nostr_sdk import Keys, Client, Tag, EventBuilder, Filter, \
-    Options, Timestamp, NostrSigner, EventId, Nip19Event, PublicKey, EventSource
+    Options, Timestamp, NostrSigner, EventId, Nip19Event, PublicKey
 
 from nostr_dvm.utils import dvmconfig
 from nostr_dvm.utils.dvmconfig import DVMConfig
@@ -65,9 +65,8 @@ async def init():
             [EventDefinitions.KIND_FEEDBACK]).since(now).event(eventid)
         lastfeedback = ""
         while not response:
-            source = EventSource.relays(timedelta(seconds=3))
-            events = await client.get_events_of([feedbackfilter], source)
-            fevents = await client.get_events_of([feedbackfilter2], source)
+            events = await client.get_events_of([feedbackfilter], timedelta(seconds=3))
+            fevents = await client.get_events_of([feedbackfilter2], timedelta(seconds=3))
             if len(fevents) > 0:
                 if lastfeedback != fevents[0].content():
                     for tag in fevents[0].tags():
diff --git a/tests/test_events.py b/tests/test_events.py
index c005656..13caaa8 100644
--- a/tests/test_events.py
+++ b/tests/test_events.py
@@ -5,7 +5,7 @@ from pathlib import Path
 
 import dotenv
 from nostr_sdk import Keys, Client, Tag, EventBuilder, Filter, HandleNotification, Timestamp, nip04_decrypt, \
-    nip04_encrypt, EventId, Options, PublicKey, Event, NostrSigner, Nip19Event, SecretKey, Kind, EventSource
+    nip04_encrypt, EventId, Options, PublicKey, Event, NostrSigner, Nip19Event, SecretKey, Kind
 
 from nostr_dvm.utils import definitions, dvmconfig
 from nostr_dvm.utils.dvmconfig import DVMConfig
@@ -61,8 +61,7 @@ async def test_referred_events(client, event_id, kinds=None):
     else:
         job_id_filter = Filter().event(EventId.from_hex(event_id))
 
-    source = EventSource.relays(timedelta(seconds=5))
-    events = await client.get_events_of([job_id_filter], source)
+    events = await client.get_events_of([job_id_filter], timedelta(seconds=5))
 
     if len(events) > 0:
         for event in events:
@@ -142,8 +141,7 @@ async def test_search_by_user_since_days(client, pubkey, days, prompt):
     since = Timestamp.from_secs(dif)
 
     filterts = Filter().search(prompt).author(pubkey).kinds([Kind(1)]).since(since)
-    source = EventSource.relays(timedelta(seconds=4))
-    events = await client.get_events_of([filterts], source)
+    events = await client.get_events_of([filterts], timedelta(seconds=5))
 
     if len(events) > 0:
         for event in events:
diff --git a/tests/wot.py b/tests/wot.py
index 3082426..4213c9d 100644
--- a/tests/wot.py
+++ b/tests/wot.py
@@ -13,7 +13,7 @@ warnings.filterwarnings('ignore')
 
 from nostr_sdk import RelayLimits, PublicKey, Options, Client, SecretKey, Keys, NostrSigner, RelayOptions, Filter, \
     PublicKey, Kind, \
-    NegentropyOptions, NegentropyDirection, ClientBuilder, NostrDatabase, init_logger, LogLevel, EventSource
+    NegentropyOptions, NegentropyDirection, ClientBuilder, NostrDatabase, init_logger, LogLevel
 
 
 # init_logger(LogLevel.INFO)
@@ -35,8 +35,7 @@ async def getmetadata(npub):
     await client.connect()
 
     profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
-    source = EventSource.relays(timedelta(seconds=4))
-    events = await client.get_events_of([profile_filter], source)
+    events = await client.get_events_of([profile_filter], timedelta(seconds=4))
     if len(events) > 0:
         try:
             profile = json.loads(events[0].content())