adjustments for nostrsdk 0.39

.gitignore

@@ -199,3 +199,4 @@ tests/cat4.png
 tests/gifs/data.mdb
 tests/gifs/lock.mdb
 tests/gif_library.py
+/.idea

examples/ollama_dvm/test_client.py

@@ -51,7 +51,8 @@ async def nostr_client():
         Timestamp.now())  # events to us specific
     dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_GENERATE_TEXT,
                                   EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now()))  # public events
-    await client.subscribe([dm_zap_filter, dvm_filter])
+    await client.subscribe(dm_zap_filter)
+    await client.subscribe(dvm_filter)
 
 
     await nostr_client_test_llm("Tell me a joke about a purple Ostrich!")

examples/tts_dvm/test_client.py

@@ -56,7 +56,8 @@ async def nostr_client():
         Timestamp.now())  # events to us specific
     dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_TEXT_TO_SPEECH,
                                   EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now()))  # public events
-    await client.subscribe([dm_zap_filter, dvm_filter])
+    await client.subscribe(dm_zap_filter)
+    await client.subscribe(dvm_filter)
 
 
     await nostr_client_test_tts("Hello, this is a test. Mic check one, two.")

examples/unleashed_dvm/test_client.py

@@ -54,7 +54,8 @@ async def nostr_client():
         Timestamp.now())  # events to us specific
     dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_GENERATE_TEXT,
                                   EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now()))  # public events
-    await client.subscribe([dm_zap_filter, dvm_filter])
+    await client.subscribe(dm_zap_filter)
+    await client.subscribe(dvm_filter)
 
 
     #nostr_client_test("What has Pablo been up to?")

nostr_dvm/bot.py

@@ -2,10 +2,9 @@ import asyncio
 import json
 import os
 import signal
-from multiprocessing.connection import Connection
 
 from nostr_sdk import (Keys, Timestamp, Filter, nip04_decrypt, nip44_decrypt, HandleNotification, EventBuilder, PublicKey,
-                       Options, Tag, Event, EventId, Nip19Event, Kind, KindEnum, NostrSigner, nip44_encrypt, Nip44Version,
+                       Options, Tag, Event, EventId, Nip19Event, Kind, NostrSigner, nip44_encrypt, Nip44Version,
                        UnsignedEvent, UnwrappedGift, uniffi_set_event_loop, ClientBuilder, make_private_msg)
 
 from nostr_dvm.utils.admin_utils import admin_make_database_updates
@@ -35,7 +34,7 @@ class Bot:
 
         self.client = None
         asyncio.run(self.run_bot(dvm_config, admin_config))
-        uniffi_set_event_loop(asyncio.get_running_loop())
+        #uniffi_set_event_loop(asyncio.get_running_loop())
 
         # add_sql_table_column(dvm_config.DB)
 
@@ -74,7 +73,7 @@ class Bot:
 
         zap_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_ZAP]).since(Timestamp.now())
         dm_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_DM]).since(Timestamp.now())
-        nip17_filter = Filter().pubkey(pk).kinds([Kind.from_enum(KindEnum.GIFT_WRAP())]).limit(0)
+        nip17_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_GIFTWRAP]).limit(0)
         kinds = [EventDefinitions.KIND_NIP90_GENERIC, EventDefinitions.KIND_FEEDBACK]
         for dvm in self.dvm_config.SUPPORTED_DVMS:
             if dvm.KIND not in kinds:
@@ -83,7 +82,10 @@ class Bot:
             kinds.append(Kind(6050))
         dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()))
 
-        await self.client.subscribe([zap_filter, dm_filter, nip17_filter, dvm_filter], None)
+        await self.client.subscribe(zap_filter, None)
+        await self.client.subscribe(dm_filter, None)
+        await self.client.subscribe(nip17_filter, None)
+        await self.client.subscribe(dvm_filter, None)
 
         create_sql_table(self.dvm_config.DB)
         await admin_make_database_updates(adminconfig=self.admin_config, dvmconfig=self.dvm_config, client=self.client)
@@ -108,7 +110,7 @@ class Bot:
                         await handle_dm(nostr_event, False)
                     except Exception as e:
                         print(f"Error during content NIP04 decryption: {e}")
-                elif nostr_event.kind().as_enum() == KindEnum.GIFT_WRAP():
+                elif nostr_event.kind().as_u16()  == EventDefinitions.KIND_GIFTWRAP.as_u16():
                     try:
                         await handle_dm(nostr_event, True)
                     except Exception as e:
@@ -133,7 +135,7 @@ class Bot:
                         rumor: UnsignedEvent = unwrapped_gift.rumor()
 
                         if rumor.created_at().as_secs() >= Timestamp.now().as_secs():
-                            if rumor.kind().as_enum() == KindEnum.PRIVATE_DIRECT_MESSAGE():
+                            if rumor.kind().as_u16() == EventDefinitions.KIND_PRIVATE_DM.as_u16():
                                 print(f"Received new msg [sealed]: {decrypted_text}")
                                 decrypted_text = rumor.content()
                                 sealed = " [sealed] "
@@ -637,7 +639,7 @@ class Bot:
                                     if param == "user":
                                         if value.startswith("@") or value.startswith("nostr:") or value.startswith(
                                                 "npub"):
-                                            value = PublicKey.from_bech32(
+                                            value = PublicKey.parse(
                                                 value.replace("@", "").replace("nostr:", "")).to_hex()
                                     tag = Tag.parse(["param", param, value])
                                 tags.append(tag)
@@ -718,7 +720,7 @@ class Bot:
                             else:
                                 if param == "user":
                                     if value.startswith("@") or value.startswith("nostr:") or value.startswith("npub"):
-                                        value = PublicKey.from_bech32(
+                                        value = PublicKey.parse(
                                             value.replace("@", "").replace("nostr:", "")).to_hex()
                                 tag = Tag.parse(["param", param, value])
                             tags.append(tag)
@@ -766,6 +768,8 @@ class Bot:
 
             return None
 
+
+
         asyncio.create_task(self.client.handle_notifications(NotificationHandler()))
 
         try:
@@ -793,3 +797,6 @@ class Bot:
         except KeyboardInterrupt:
             print('Stay weird!')
             os.kill(os.getpid(), signal.SIGTERM)
+
+
+

nostr_dvm/dvm.py

@@ -78,7 +78,8 @@ class DVM:
         dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()))
         create_sql_table(self.dvm_config.DB)
         await admin_make_database_updates(adminconfig=self.admin_config, dvmconfig=self.dvm_config, client=self.client)
-        await self.client.subscribe([dvm_filter, zap_filter], None)
+        await self.client.subscribe(dvm_filter, None)
+        await self.client.subscribe(zap_filter, None)
 
         if self.dvm_config.ENABLE_NUTZAP:
             nutzap_wallet = NutZapWallet()
@@ -232,7 +233,7 @@ class DVM:
                         await send_job_status_reaction(nip90_event, "error", False, amount, self.client, cashu_message,
                                                        self.dvm_config)
                         return
-                # if user is whitelisted or task is free, just do the job
+                # if user is whitelisted or task is free, just dxo the job
                 if (user.iswhitelisted or task_is_free or cashu_redeemed) and (
                         p_tag_str == "" or p_tag_str ==
                         self.dvm_config.PUBLIC_KEY):

nostr_dvm/subscription.py

@@ -70,7 +70,9 @@ class Subscription:
                 [EventDefinitions.KIND_NIP90_DVM_SUBSCRIPTION]).since(
                 Timestamp.now())
 
-        await self.client.subscribe([zap_filter, dvm_filter, cancel_subscription_filter], None)
+        await self.client.subscribe(zap_filter, None)
+        await self.client.subscribe(dvm_filter, None)
+        await self.client.subscribe(cancel_subscription_filter, None)
 
         create_subscription_sql_table(dvm_config.DB)
 
@@ -248,7 +250,7 @@ class Subscription:
 
                     subscriptionfilter = Filter().kind(EventDefinitions.KIND_NIP88_SUBSCRIBE_EVENT).author(
                         PublicKey.parse(subscriber)).limit(1)
-                    evts = await self.client.fetch_events([subscriptionfilter], relay_timeout)
+                    evts = await self.client.fetch_events(subscriptionfilter, relay_timeout)
                     if len(evts.to_vec()) > 0:
                         event7001id = evts.to_vec()[0].id().to_hex()
                         print(evts.to_vec()[0].as_json())
@@ -285,7 +287,7 @@ class Subscription:
 
                         if tier_dtag == "" or len(zaps) == 0:
                             tierfilter = Filter().id(EventId.parse(subscription_event_id))
-                            evts = await self.client.fetch_events([tierfilter], relay_timeout)
+                            evts = await self.client.fetch_events(tierfilter, relay_timeout)
                             if len(evts.to_vec()) > 0:
                                 for tag in evts[0].tags().to_vec():
                                     if tag.as_vec()[0] == "d":

nostr_dvm/tasks/advanced_search.py

@@ -124,7 +124,7 @@ class AdvancedSearch(DVMTaskInterface):
             notes_filter = Filter().kind(Kind(1)).authors(userkeys).search(options["search"]).since(
                 search_since).until(search_until).limit(options["max_results"])
 
-        events = await cli.fetch_events([notes_filter], relay_timeout)
+        events = await cli.fetch_events(notes_filter, relay_timeout)
 
         result_list = []
         if len(events.to_vec()) > 0:

nostr_dvm/tasks/content_discovery_currently_latest_longform.py

@@ -121,7 +121,7 @@ class DicoverContentLatestLongForm(DVMTaskInterface):
         since = Timestamp.from_secs(timestamp_hour_ago)
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_LONGFORM).since(since)
-        events = await cli.database().query([filter1])
+        events = await cli.database().query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}

nostr_dvm/tasks/content_discovery_currently_latest_wiki.py

@@ -121,7 +121,7 @@ class DicoverContentLatestWiki(DVMTaskInterface):
         since = Timestamp.from_secs(timestamp_hour_ago)
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_WIKI).since(since)
-        events = await cli.database().query([filter1])
+        events = await cli.database().query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}

nostr_dvm/tasks/content_discovery_currently_popular.py

@@ -116,7 +116,7 @@ class DicoverContentCurrentlyPopular(DVMTaskInterface):
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
 
-        events = await database.query([filter1])
+        events = await database.query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -125,7 +125,7 @@ class DicoverContentCurrentlyPopular(DVMTaskInterface):
                 filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REPOST,
                                        definitions.EventDefinitions.KIND_REACTION,
                                        definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                reactions = await database.query([filt])
+                reactions = await database.query(filt)
 
                 if len(reactions.to_vec()) >= self.min_reactions:
                     ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

nostr_dvm/tasks/content_discovery_currently_popular_by_top_zaps.py

@@ -113,7 +113,7 @@ class DicoverContentCurrentlyPopularZaps(DVMTaskInterface):
         since = Timestamp.from_secs(timestamp_hour_ago)
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
-        events = await database.query([filter1])
+        events = await database.query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
 
@@ -121,7 +121,7 @@ class DicoverContentCurrentlyPopularZaps(DVMTaskInterface):
         for event in events.to_vec():
             if event.created_at().as_secs() > timestamp_hour_ago:
                 filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP]).event(event.id()).since(since)
-                zaps = await database.query([filt])
+                zaps = await database.query(filt)
                 invoice_amount = 0
                 event_author = event.author().to_hex()
                 if len(zaps.to_vec()) >= self.min_reactions:

nostr_dvm/tasks/content_discovery_currently_popular_followers.py

@@ -109,7 +109,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
 
         user = PublicKey.parse(options["user"])
         followers_filter = Filter().author(user).kinds([Kind(3)])
-        followers = await cli.fetch_events([followers_filter], relay_timeout)
+        followers = await cli.fetch_events(followers_filter, relay_timeout)
         # print(followers)
 
         # Negentropy reconciliation
@@ -135,7 +135,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
                     followings.append(following)
 
             filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).authors(followings).since(since)
-            events = await cli.database().query([filter1])
+            events = await cli.database().query(filter1)
             if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
                 print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
 
@@ -146,7 +146,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
                     [definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
                      definitions.EventDefinitions.KIND_REPOST,
                      definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                reactions = await cli.database().query([filt])
+                reactions = await cli.database().query(filt)
                 if len(reactions.to_vec()) >= self.min_reactions:
                     ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
 

nostr_dvm/tasks/content_discovery_currently_popular_gallery.py

@@ -116,7 +116,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NIP68_IMAGEEVENT).since(since)
 
-        ge_events = await databasegallery.query([filter1])
+        ge_events = await databasegallery.query(filter1)
         
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(ge_events.to_vec())) + " Events")
@@ -155,7 +155,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
         for id in ids:
             ids_str.append(id.to_hex())
 
-        filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tag(SingleLetterTag.uppercase(Alphabet.E),
+        filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tags(SingleLetterTag.uppercase(Alphabet.E),
                                                                              ids_str).since(since)
 
         dbopts = SyncOptions().direction(SyncDirection.DOWN)
@@ -163,14 +163,14 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
         await cli.sync(filter_nip22, dbopts)
 
         filter2 = Filter().ids(ids)
-        events = await cli.fetch_events([filter2], relay_timeout)
+        events = await cli.fetch_events(filter2, relay_timeout)
         
 
 
         for event in events.to_vec():
             if event.created_at().as_secs() > timestamp_since:
                 filt1 = Filter().kinds([definitions.EventDefinitions.KIND_DELETION]).event(event.id()).limit(1)
-                deletions = await databasegallery.query([filt1])
+                deletions = await databasegallery.query(filt1)
                 if len(deletions.to_vec()) > 0:
                     print("Deleted event, skipping")
                     continue
@@ -179,11 +179,14 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
                                        definitions.EventDefinitions.KIND_REACTION,
                                        definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
 
-                filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tag(
+                filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tags(
                     SingleLetterTag.uppercase(Alphabet.E),
                     [event.id().to_hex()])
 
-                reactions = await databasegallery.query([filt, filter_nip22])
+                reactions = await databasegallery.query(filt)
+                reactions2 = await databasegallery.query(filter_nip22)
+                reactions.merge(reactions2)
+
                 
                 #print("Reactions:" + str(len(reactions.to_vec())))
                 if len(reactions.to_vec()) >= self.min_reactions:

nostr_dvm/tasks/content_discovery_currently_popular_mostr.py

@@ -119,7 +119,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
 
-        events = await database.query([filter1])
+        events = await database.query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -131,7 +131,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
                     [EventDefinitions.KIND_ZAP, EventDefinitions.KIND_REPOST,
                      EventDefinitions.KIND_REACTION,
                      EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                reactions = await database.query([filt])
+                reactions = await database.query(filt)
 
                 if len(reactions.to_vec()) >= self.min_reactions:
                     ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
@@ -209,7 +209,10 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
 
             # RECONCOILE NOT POSSIBLE ON THESE RELAYS SO WE FETCH AB BUNCH (will be stored in db)
             try:
-                events = await cli.fetch_events([filter1, filter2, filter3], relay_timeout_long)
+                events1 = await cli.fetch_events(filter1, relay_timeout_long)
+                events2 = await cli.fetch_events(filter2, relay_timeout_long)
+                events3 = await cli.fetch_events(filter3, relay_timeout_long)
+                events = events1.merge(events2).merge(events3)
             except Exception as e:
                 print(e)
             # Do not delete profiles

nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py

@@ -157,7 +157,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
         await cli.connect()
         user = PublicKey.parse(options["user"])
         followers_filter = Filter().author(user).kinds([Kind(3)])
-        followers = await cli.fetch_events([followers_filter], relay_timeout)
+        followers = await cli.fetch_events(followers_filter, relay_timeout)
         if len(followers.to_vec()) > 0:
             newest = 0
             best_entry = followers.to_vec()[0]
@@ -183,7 +183,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
 
-        events = await self.database.query([filter1])
+        events = await self.database.query(filter1)
 
         print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -196,7 +196,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
                 [definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
                  definitions.EventDefinitions.KIND_REPOST,
                  definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-            reactions = await self.database.query([filt])
+            reactions = await self.database.query(filt)
             if len(reactions.to_vec()) >= self.min_reactions:
                 ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
 

nostr_dvm/tasks/content_discovery_currently_popular_topic.py

@@ -4,7 +4,7 @@ import os
 from datetime import timedelta
 
 from nostr_sdk import Timestamp, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
-    ClientBuilder, Filter, SyncOptions, SyncDirection, init_logger, LogLevel, Kind
+    ClientBuilder, Filter, SyncOptions, SyncDirection, init_logger, LogLevel, Kind, Events
 
 from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
 from nostr_dvm.utils import definitions
@@ -154,12 +154,19 @@ class DicoverContentCurrentlyPopularbyTopic(DVMTaskInterface):
         timestamp_since = Timestamp.now().as_secs() - self.db_since
         since = Timestamp.from_secs(timestamp_since)
 
-        filters = []
+        if len(self.search_list) == 0:
-        for word in self.search_list:
+            print("Search List empty")
-            filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(word)
+            return {}
-            filters.append(filter)
+
+        filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(self.search_list[0])
+        events = await self.database.query(filter)
+        for word in self.search_list[1:]:
+            filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(word)
+            evts = await self.database.query(filter)
+            events.merge(evts)
+
+
 
-        events = await self.database.query(filters)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -172,7 +179,7 @@ class DicoverContentCurrentlyPopularbyTopic(DVMTaskInterface):
                         [definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
                          definitions.EventDefinitions.KIND_REPOST,
                          definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                    reactions = await self.database.query([filt])
+                    reactions = await self.database.query(filt)
                     if len(reactions.to_vec()) >= self.min_reactions:
                         ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
 

nostr_dvm/tasks/content_discovery_currently_popular_tweets.py

@@ -141,7 +141,7 @@ class DicoverContentCurrentlyPopularTweets(DVMTaskInterface):
 
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
-        events = await self.database.query([filter1])
+        events = await self.database.query(filter1)
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -161,7 +161,7 @@ class DicoverContentCurrentlyPopularTweets(DVMTaskInterface):
                         [definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
                          definitions.EventDefinitions.KIND_REPOST,
                          definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                    reactions = await self.database.query([filt])
+                    reactions = await self.database.query(filt)
                     if len(reactions.to_vec()) >= self.min_reactions:
                         ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
 

nostr_dvm/tasks/content_discovery_latest_one_per_follower.py

@@ -88,7 +88,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
-        followers = await cli.fetch_events([followers_filter], relay_timeout)
+        followers = await cli.fetch_events(followers_filter, relay_timeout)
 
         if len(followers.to_vec()) > 0:
             result_list = []
@@ -128,17 +128,21 @@ class Discoverlatestperfollower(DVMTaskInterface):
                     await cli.add_relay(relay)
                 await cli.connect()
 
-                filters = []
+                user = PublicKey.parse(users[i])
-                for i in range(i, i + st):
+                filter1 = (Filter().author(user).kind(Kind(1))
+                           .limit(1))
+                event_from_authors = await cli.fetch_events(filter1, relay_timeout_long)
+
+                for i in range(i+1, i + st):
                     try:
                         user = PublicKey.parse(users[i])
                         filter1 = (Filter().author(user).kind(Kind(1))
                                    .limit(1))
-                        filters.append(filter1)
+                        events = await cli.fetch_events(filter1, relay_timeout_long)
+                        event_from_authors.merge(events)
                     except Exception as e:
                         print(e)
 
-                event_from_authors = await cli.fetch_events(filters, relay_timeout_long)
                 for author in event_from_authors.to_vec():
                     if instance.dic[author.author().to_hex()] is None:
                         instance.dic[author.author().to_hex()] = author

nostr_dvm/tasks/content_discovery_on_this_day.py

@@ -113,7 +113,7 @@ class DicoverContentOnThisDay(DVMTaskInterface):
 
         filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).until(until)
 
-        events = await database.query([filter1])
+        events = await database.query(filter1)
         print(len(events.to_vec()))
         if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
             print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
@@ -123,7 +123,7 @@ class DicoverContentOnThisDay(DVMTaskInterface):
                 filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REPOST,
                                        definitions.EventDefinitions.KIND_REACTION,
                                        definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-                reactions = await database.query([filt])
+                reactions = await database.query(filt)
 
                 if len(reactions.to_vec()) >= self.min_reactions:
                     ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

nostr_dvm/tasks/discovery_bot_farms.py

@@ -89,7 +89,7 @@ class DiscoveryBotFarms(DVMTaskInterface):
         # Query events from database
 
         filter1 = Filter().kind(Kind(0))
-        events = await cli.database().query([filter1])
+        events = await cli.database().query(filter1)
         result_list = []
         print("Events: " + str(len(events.to_vec())))
 

nostr_dvm/tasks/discovery_censor_wot.py

@@ -92,7 +92,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))
-            followers = await cli.fetch_events([followers_filter], relay_timeout)
+            followers = await cli.fetch_events(followers_filter, relay_timeout)
 
             if len(followers.to_vec()) > 0:
                 result_list = []
@@ -113,7 +113,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)
-        reports = await cli.fetch_events([kind1984_filter], relay_timeout)
+        reports = await cli.fetch_events(kind1984_filter, relay_timeout)
 
         bad_actors = []
         ns.dic = {}

nostr_dvm/tasks/discovery_inactive_follows.py

@@ -1,7 +1,6 @@
 import asyncio
 import json
 import os
-from datetime import timedelta
 from threading import Thread
 
 from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
@@ -77,7 +76,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
         opts = (Options().relay_limits(relaylimits))
 
         cli = ClientBuilder().signer(NostrSigner.keys(keys)).opts(opts).build()
-        for relay in self.dvm_config.RELAY_LIST:
+        for relay in self.dvm_config.SYNC_DB_RELAY_LIST:
             await cli.add_relay(relay)
         await cli.add_relay("wss://nostr.band")
 
@@ -87,8 +86,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
-        followers = await cli.fetch_events([followers_filter], relay_timeout)
+        followers = await cli.fetch_events(followers_filter, relay_timeout)
-
         if len(followers.to_vec()) > 0:
             result_list = []
             newest = 0
@@ -100,10 +98,6 @@ class DiscoverInactiveFollows(DVMTaskInterface):
                     newest = entry.created_at().as_secs()
                     best_entry = entry
 
-            print(best_entry.as_json())
-            print(len(best_entry.tags().to_vec()))
-            print(best_entry.created_at().as_secs())
-            print(Timestamp.now().as_secs())
             followings = []
             ns.dic = {}
             tagcount = 0
@@ -124,15 +118,16 @@ class DiscoverInactiveFollows(DVMTaskInterface):
 
                 keys = Keys.parse(self.dvm_config.PRIVATE_KEY)
                 cli = Client(NostrSigner.keys(keys))
-                for relay in self.dvm_config.RELAY_LIST:
+                for relay in self.dvm_config.SYNC_DB_RELAY_LIST:
                     await cli.add_relay(relay)
                 await cli.connect()
-
-                filters = []
-                for i in range(i, i + st):
                 filter1 = Filter().author(PublicKey.parse(users[i])).since(notactivesince).limit(1)
-                    filters.append(filter1)
+                event_from_authors = await cli.fetch_events(filter1, relay_timeout_long)
-                event_from_authors = await cli.fetch_events(filters, relay_timeout_long)
+                for j in range(i+1, i + st):
+                    filter1 = Filter().author(PublicKey.parse(users[j])).since(notactivesince).limit(1)
+                    events = await cli.fetch_events(filter1, relay_timeout_long)
+                    event_from_authors.merge(events)
+
                 for author in event_from_authors.to_vec():
                     instance.dic[author.author().to_hex()] = "True"
                 print(str(i) + "/" + str(len(users)))

nostr_dvm/tasks/discovery_nonfollowers.py

@@ -82,7 +82,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
         step = 20
 
         followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
-        followers = await cli.fetch_events([followers_filter], relay_timeout)
+        followers = await cli.fetch_events(followers_filter, relay_timeout)
 
         if len(followers.to_vec()) > 0:
             result_list = []
@@ -111,11 +111,12 @@ class DiscoverNonFollowers(DVMTaskInterface):
                     await cli.add_relay(relay)
                 await cli.connect()
 
-                for i in range(i, i + st):
-                    filters = []
                 filter1 = Filter().author(PublicKey.parse(users[i])).kind(Kind(3))
-                    filters.append(filter1)
+                followers = await cli.fetch_events(filter1, relay_timeout)
-                    followers = await cli.fetch_events(filters, relay_timeout)
+                for i in range(i+1, i + st):
+                    filter1 = Filter().author(PublicKey.parse(users[i])).kind(Kind(3))
+                    follower = await cli.fetch_events(filter1, relay_timeout)
+                    followers.merge(follower)
 
                     if len(followers.to_vec()) > 0:
                         result_list = []

nostr_dvm/tasks/discovery_trending_notes_gleasonator.py

@@ -79,10 +79,10 @@ 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),
+        notes_filter = Filter().authors(authors).kind(Kind(1985)).custom_tags(SingleLetterTag.lowercase(Alphabet.L),
                                                                              ltags)
 
-        events = await cli.fetch_events([notes_filter], relay_timeout_long)
+        events = await cli.fetch_events(notes_filter, relay_timeout_long)
 
         result_list = []
         if len(events.to_vec()) > 0:

nostr_dvm/tasks/people_discovery_mywot.py

@@ -247,7 +247,7 @@ async def analyse_users(user_ids=None, dunbar=100000000):
 
         database = NostrDatabase.lmdb("db/nostr_followlists.db")
         followers_filter = Filter().authors(user_keys).kind(Kind(3))
-        followers = await database.query([followers_filter])
+        followers = await database.query(followers_filter)
         allfriends = []
         if len(followers.to_vec()) > 0:
             for follower in followers.to_vec():

nostr_dvm/tasks/people_discovery_wot.py

@@ -251,7 +251,7 @@ async def analyse_users(user_ids=None, dunbar=100000000):
 
         database = NostrDatabase.lmdb("db/nostr_followlists.db")
         followers_filter = Filter().authors(user_keys).kind(Kind(3))
-        followers = await database.query([followers_filter])
+        followers = await database.query(followers_filter)
         allfriends = []
         if len(followers.to_vec()) > 0:
             for follower in followers.to_vec():

nostr_dvm/tasks/search_users.py

@@ -94,7 +94,7 @@ class SearchUser(DVMTaskInterface):
         # Query events from database
 
         filter1 = Filter().kind(Kind(0))
-        events = await cli.database().query([filter1])
+        events = await cli.database().query(filter1)
 
         result_list = []
         print("Events: " + str(len(events.to_vec())))

nostr_dvm/utils/database_utils.py

@@ -279,7 +279,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)
-    events = await client.fetch_events([profile_filter], relay_timeout)
+    events = await client.fetch_events(profile_filter, relay_timeout)
     if len(events.to_vec()) > 0:
         latest_entry = events.to_vec()[0]
         latest_time = 0

nostr_dvm/utils/definitions.py

@@ -13,6 +13,8 @@ class EventDefinitions:
     KIND_REPOST = Kind(6)
     KIND_REACTION = Kind(7)
     KIND_NIP68_IMAGEEVENT = Kind(20)
+    KIND_GIFTWRAP = Kind(59)
+    KIND_PRIVATE_DM = Kind(60)
     KIND_NIP94_METADATA = Kind(1063)
     KIND_NIP22_COMMENT = Kind(1111)
     KIND_NIP93_GALLERYENTRY = Kind(1163)

nostr_dvm/utils/gallery_utils.py

@@ -43,7 +43,7 @@ async def convert_nip93_to_nip68(private_key, relay_list, user_to_import_npub=No
 
     nip93_filter = Filter().kind(Kind(1163)).author(PublicKey.parse(user_to_import_npub))
 
-    events =  await client.fetch_events([nip93_filter], timedelta(5))
+    events =  await client.fetch_events(nip93_filter, timedelta(5))
 
     events_vec = events.to_vec()
     reversed_events_vec = reversed(events_vec)
@@ -80,7 +80,7 @@ async def convert_nip93_to_nip68(private_key, relay_list, user_to_import_npub=No
                     except Exception as e:
                         print(relay_hint)
                 e_filter = Filter().id(EventId.parse(eventid)).limit(1)
-                content_events = await client.fetch_events([e_filter], timedelta(5))
+                content_events = await client.fetch_events(e_filter, timedelta(5))
                 if len(content_events.to_vec()) > 0:
                     content_event = content_events.to_vec()[0]
                     content =  re.sub(r'^https?:\/\/.*[\r\n]*', '', content_event.content(), flags=re.MULTILINE).rstrip()

nostr_dvm/utils/nip88_utils.py

@@ -36,7 +36,7 @@ def nip88_create_d_tag(name, pubkey, image):
 
 async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
     idfilter = Filter().id(EventId.parse(eventid)).limit(1)
-    nip88events = await client.fetch_events([idfilter], relay_timeout)
+    nip88events = await client.fetch_events(idfilter, relay_timeout)
     d_tag = ""
     if len(nip88events.to_vec()) == 0:
         print("Event not found. Potentially gone.")
@@ -59,7 +59,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)
-    nip88events = await client.fetch_events([idfilter], relay_timeout)
+    nip88events = await client.fetch_events(idfilter, relay_timeout)
     d_tag = ""
     if len(nip88events.to_vec()) == 0:
         print("Event not found. Potentially gone.")
@@ -97,9 +97,9 @@ 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),
+        PublicKey.parse(receiver_public_key_hex)).custom_tags(SingleLetterTag.uppercase(Alphabet.P),
                                                              [user.to_hex()]).limit(1)
-    evts = await client.fetch_events([subscriptionfilter], relay_timeout)
+    evts = await client.fetch_events(subscriptionfilter, relay_timeout)
     if len(evts.to_vec()) > 0:
         print(evts.to_vec()[0].as_json())
         matchesdtag = False
@@ -120,7 +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)
-            cancel_events = await client.fetch_events([cancel_filter], relay_timeout)
+            cancel_events = await client.fetch_events(cancel_filter, relay_timeout)
             if len(cancel_events.to_vec()) > 0:
                 if cancel_events.to_vec()[0].created_at().as_secs() > evts[0].created_at().as_secs():
                     subscription_status["expires"] = True

nostr_dvm/utils/nip89_utils.py

@@ -41,7 +41,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.parse(eventid)).limit(1)
-    nip89events = await client.fetch_events([idfilter], relay_timeout)
+    nip89events = await client.fetch_events(idfilter, relay_timeout)
     d_tag = ""
     if len(nip89events.to_vec()) == 0:
         print("Event not found. Potentially gone.")
@@ -92,8 +92,8 @@ async def nip89_fetch_all_dvms(client):
     for i in range(5000, 5999):
         ktags.append(str(i))
 
-    filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags)
+    filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tags(SingleLetterTag.lowercase(Alphabet.K), ktags)
-    events = await client.fetch_events([filter], relay_timeout)
+    events = await client.fetch_events(filter, relay_timeout)
     for event in events.to_vec():
         print(event.as_json())
 
@@ -101,8 +101,8 @@ async def nip89_fetch_all_dvms(client):
 async def nip89_fetch_events_pubkey(client, pubkey, kind):
     ktags = [str(kind.as_u16())]
     nip89filter = (Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(PublicKey.parse(pubkey)).
-                   custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags))
+                   custom_tags(SingleLetterTag.lowercase(Alphabet.K), ktags))
-    events = await client.fetch_events([nip89filter], relay_timeout)
+    events = await client.fetch_events(nip89filter, relay_timeout)
 
     dvms = {}
     for event in events.to_vec():
@@ -152,7 +152,7 @@ async def delete_nip_89(dvm_config, pow=True):
         await client.add_relay(relay)
     await client.connect()
     filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(keys.public_key())
-    events = await client.fetch_events([filter], timedelta(seconds=5))
+    events = await client.fetch_events(filter, timedelta(seconds=5))
 
     if len(events.to_vec()) == 0:
         print("Couldn't find note on relays. Seems they are gone.")

nostr_dvm/utils/nostr_utils.py

@@ -16,14 +16,14 @@ async def get_event_by_id(event_id_str: str, client: Client, config=None) -> Eve
     split = event_id_str.split(":")
     if len(split) == 3:
         pk = PublicKey.parse(split[1])
-        id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
+        id_filter = Filter().author(pk).custom_tags(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
-        events = await client.fetch_events([id_filter], relay_timeout)
+        events = await client.fetch_events(id_filter, relay_timeout)
     else:
         event_id = EventId.parse(event_id_str)
 
         id_filter = Filter().id(event_id).limit(1)
 
-        events = await client.fetch_events([id_filter], relay_timeout)
+        events = await client.fetch_events(id_filter, relay_timeout)
 
     if len(events.to_vec()) > 0:
         return events.to_vec()[0]
@@ -32,8 +32,8 @@ async def get_event_by_id(event_id_str: str, client: Client, config=None) -> Eve
         return None
 
 
-async def get_events_async(client, filter, timeout):
+async def get_events_async(client, filter1, timeout):
-    events = await client.fetch_events([filter], timedelta(seconds=timeout))
+    events = await client.fetch_events(filter1, timedelta(seconds=timeout))
     return events.to_vec()
 
 
@@ -44,8 +44,8 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
         split = event_id.split(":")
         if len(split) == 3:
             pk = PublicKey.parse(split[1])
-            id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
+            id_filter = Filter().author(pk).custom_tags(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
-            events = await client.fetch_events([id_filter], relay_timeout)
+            events = await client.fetch_events(id_filter, relay_timeout)
         else:
 
             if str(event_id).startswith("nevent"):
@@ -57,7 +57,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)
-            events = await client.fetch_events([id_filter], relay_timeout)
+            events = await client.fetch_events(id_filter, relay_timeout)
 
     if len(events.to_vec()) > 0:
         return events.to_vec()
@@ -66,9 +66,10 @@ 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))
-    events = await client.fetch_events([id_filter], relay_timeout)
+    events = await client.fetch_events(id_filter, relay_timeout)
     if len(events.to_vec()) > 0:
         return events.to_vec()
     else:
@@ -89,7 +90,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)
-    events = await client.fetch_events([job_id_filter], relay_timeout)
+    events = await client.fetch_events(job_id_filter, relay_timeout)
 
     if len(events.to_vec()) > 0:
         return events.to_vec()[0]
@@ -104,8 +105,8 @@ async def get_inbox_relays(event_to_send: Event, client: Client, dvm_config):
             ptag = PublicKey.parse(tag.as_vec()[1])
             ptags.append(ptag)
 
-    filter = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
+    filter1 = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
-    events = await client.fetch_events([filter], relay_timeout)
+    events = await client.fetch_events(filter1, relay_timeout)
     if len(events.to_vec()) == 0:
         return []
     else:
@@ -128,8 +129,8 @@ async def get_dm_relays(event_to_send: Event, client: Client, dvm_config):
             ptag = PublicKey.parse(tag.as_vec()[1])
             ptags.append(ptag)
 
-    filter = Filter().kinds([Kind(10050)]).authors(ptags)
+    filter1 = Filter().kinds([Kind(10050)]).authors(ptags)
-    events = await client.fetch_events([filter], relay_timeout)
+    events = await client.fetch_events(filter1, relay_timeout)
     if len(events.to_vec()) == 0:
         return []
     else:
@@ -157,8 +158,8 @@ async def get_main_relays(event_to_send: Event, client: Client, dvm_config):
             await client.add_relay(relay)
 
     await client.connect()
-    filter = Filter().kinds([EventDefinitions.KIND_FOLLOW_LIST]).authors(ptags)
+    filter1 = Filter().kinds([EventDefinitions.KIND_FOLLOW_LIST]).authors(ptags)
-    events = await client.fetch_events([filter], relay_timeout)
+    events = await client.fetch_events(filter1, relay_timeout)
     if len(events.to_vec()) == 0:
         return []
     else:
@@ -207,9 +208,7 @@ async def send_event_outbox(event: Event, client, dvm_config) -> SendEventOutput
 
     # 5. Otherwise, we create a new Outbox client with the inbox relays and send the event there
     relaylimits = RelayLimits.disable()
-    connection = Connection().embedded_tor().target(ConnectionTarget.ONION)    
+    connection = Connection().addr("127.0.0.1:9050").target(ConnectionTarget.ONION)
-    
-    # connection = Connection().addr("127.0.0.1:9050").target(ConnectionTarget.ONION)
     opts = Options().relay_limits(relaylimits).connection(connection)
     sk = SecretKey.parse(dvm_config.PRIVATE_KEY)
     keys = Keys.parse(sk.to_hex())

nostr_dvm/utils/nut_wallet_utils.py

@@ -116,7 +116,7 @@ class NutZapWallet:
 
         wallet_filter = Filter().kind(EventDefinitions.KIND_NUT_WALLET).author(keys.public_key())
         # relay_timeout = EventSource.relays(timedelta(seconds=10))
-        wallets = await client.fetch_events([wallet_filter], timedelta(seconds=10))
+        wallets = await client.fetch_events(wallet_filter, timedelta(seconds=10))
 
         if len(wallets.to_vec()) > 0:
 
@@ -190,7 +190,7 @@ class NutZapWallet:
 
             # Now all proof events
             proof_filter = Filter().kind(Kind(7375)).author(keys.public_key())
-            proof_events = await client.fetch_events([proof_filter], timedelta(seconds=5))
+            proof_events = await client.fetch_events(proof_filter, timedelta(seconds=5))
 
             latest_proof_sec = 0
             latest_proof_event_id = EventId
@@ -443,7 +443,7 @@ class NutZapWallet:
 
     async def fetch_mint_info_event(self, pubkey, client):
         mint_info_filter = Filter().kind(Kind(10019)).author(PublicKey.parse(pubkey))
-        preferences = await client.fetch_events([mint_info_filter], timedelta(seconds=5))
+        preferences = await client.fetch_events(mint_info_filter, timedelta(seconds=5))
         mints = []
         relays = []
         pubkey = ""

nostr_dvm/utils/nwc_tools.py

@@ -70,7 +70,7 @@ async def nwc_test(nwc_server):
         keys = Keys.parse(check_and_set_private_key("test"))
 
         # we zap npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8's profile 21 sats and say Cool stuff
-        pubkey = PublicKey.from_bech32("npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8")
+        pubkey = PublicKey.parse("npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8")
         bolt11 = zaprequest("hype@bitcoinfixesthis.org", 21, "Cool Stuff", None,
                             pubkey, keys, DVMConfig.RELAY_LIST)
 

nostr_dvm/utils/wot_utils.py

@@ -53,7 +53,7 @@ async def get_following(pks, max_time_request=10, newer_than_time=None, dvm_conf
 
     await cli.connect()
 
-    events = await cli.fetch_events([filter], relay_timeout)
+    events = await cli.fetch_events(filter, relay_timeout)
 
     for relay in dvm_config.SYNC_DB_RELAY_LIST:
         await cli.force_remove_relay(relay)
@@ -596,7 +596,7 @@ async def get_metadata(npub):
 
     profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
 
-    events_struct = await client.fetch_events([profile_filter], relay_timeout)
+    events_struct = await client.fetch_events(profile_filter, relay_timeout)
     events = events_struct.to_vec()
     if len(events) > 0:
         try:

setup.py

@@ -14,7 +14,7 @@ setup(
     long_description=LONG_DESCRIPTION,
     packages=find_packages(include=['nostr_dvm', 'nostr_dvm.*']),
 
-    install_requires=["nostr-sdk==0.38.0",
+    install_requires=["nostr-sdk==0.39.0",
                       "bech32==1.2.0",
                       "pycryptodome==3.20.0",
                       "yt-dlp==2024.11.04",

tests/bot.py

@@ -70,18 +70,14 @@ def playground():
     bot_config.SUPPORTED_DVMS.append(translator)  # We add translator to the bot
     framework.add(translator)
 
-
-    framework.run()
-
     admin_config = AdminConfig()
     admin_config.REBROADCAST_NIP65_RELAY_LIST = True
     admin_config.UPDATE_PROFILE = True
     x = threading.Thread(target=Bot, args=([bot_config, admin_config]))
     x.start()
 
-    # Keep the main function alive for libraries that require it, like openai
-    # keep_alive()
 
+    framework.run()
 
 
 

tests/db.py

@@ -32,7 +32,7 @@ async def reconcile_db():
 async def do_some_work():
     database = NostrDatabase.lmdb("nostr.db")
     f = Filter().author(keys.public_key()).limit(10)
-    events = await database.query([f])
+    events = await database.query(f)
 
     for event in events.to_vec():
         print(event.as_json())

tests/ditto.py

@@ -24,9 +24,9 @@ async def main():
     ltags = ["#e", "pub.ditto.trends"]
     itags = [str(SingleLetterTag.lowercase(Alphabet.E))]
     authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
-    notes_filter = Filter().authors(authors).custom_tag(SingleLetterTag.lowercase(Alphabet.L), ltags)
+    notes_filter = Filter().authors(authors).custom_tags(SingleLetterTag.lowercase(Alphabet.L), ltags)
 
-    events_struct = await cli.fetch_events([notes_filter], relay_timeout_long)
+    events_struct = await cli.fetch_events(notes_filter, relay_timeout_long)
     events = events_struct.to_vec()
 
 

tests/generic_dvm_autotopic_feed.py

@@ -163,7 +163,7 @@ def playground(announce=False):
         print(options["request_event_author"])
         filterauth = Filter().kind(definitions.EventDefinitions.KIND_NOTE).author(author).limit(100)
 
-        event_struct = await cli.fetch_events([filterauth], relay_timeout)
+        event_struct = await cli.fetch_events(filterauth, relay_timeout)
         text = ""
 
         if len(event_struct.to_vec()) == 0:
@@ -204,11 +204,16 @@ def playground(announce=False):
         if len(keywords) == 0:
             return json.dumps([])
 
-        filters = []
+        filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(
-        for keyword in keywords:
+            " " + keywords[0].lstrip().rstrip() + " ")
-            filters.append(Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(" " + keyword.lstrip().rstrip() + " "))
+        events = await database.query(filter)
+
+        for keyword in keywords[1:]:
+            filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(" " + keyword.lstrip().rstrip() + " ")
+            evts = await database.query(filter)
+            events.merge(evts)
+
 
-        events = await database.query(filters)
 
         print("[" + dvm.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
         ns.finallist = {}
@@ -221,7 +226,7 @@ def playground(announce=False):
                 [definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
                  definitions.EventDefinitions.KIND_REPOST,
                  definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
-            reactions = await database.query([filt])
+            reactions = await database.query(filt)
             if len(reactions.to_vec()) >= 1:
                 ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
 

tests/simplebot.py

@@ -27,14 +27,15 @@ async def test():
 
     now = Timestamp.now()
 
-    nip04_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.ENCRYPTED_DIRECT_MESSAGE())).since(now)
+    nip04_filter = Filter().pubkey(pk).kind(Kind(KindEnum.ENCRYPTED_DIRECT_MESSAGE())).since(now)
-    nip59_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.GIFT_WRAP())).limit(0)
+    nip59_filter = Filter().pubkey(pk).kind(Kind((KindEnum.GIFT_WRAP()))).limit(0)
-    await client.subscribe([nip04_filter, nip59_filter], None)
+    await client.subscribe(nip04_filter)
+    await client.subscribe(nip59_filter)
 
     class NotificationHandler(HandleNotification):
         async def handle(self, relay_url, subscription_id, event: Event):
             print(f"Received new event from {relay_url}: {event.as_json()}")
-            if event.kind().as_enum() == KindEnum.ENCRYPTED_DIRECT_MESSAGE():
+            if event.kind().as_u16() == KindEnum.ENCRYPTED_DIRECT_MESSAGE():
                 print("Decrypting NIP04 event")
                 try:
                     msg = nip04_decrypt(sk, event.author(), event.content())

tests/test_dvm_client.py

@@ -414,7 +414,8 @@ async def nostr_client():
         if kind not in kinds:
             kinds.append(Kind(kind))
     dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
-    await client.subscribe([dm_zap_filter, dvm_filter], None)
+    await client.subscribe(dm_zap_filter, None)
+    await client.subscribe(dvm_filter, None)
 
     # await nostr_client_test_translation("This is the result of the DVM in spanish", "text", "es", 20, 20)
     # await nostr_client_test_translation("note1p8cx2dz5ss5gnk7c59zjydcncx6a754c0hsyakjvnw8xwlm5hymsnc23rs", "event", "es", 20,20)

tests/test_events.py

@@ -53,7 +53,7 @@ async def test_referred_events(client, event_id, kinds=None):
     else:
         job_id_filter = Filter().event(EventId.parse(event_id))
 
-    event_struct = await client.fetch_events([job_id_filter], relay_timeout)
+    event_struct = await client.fetch_events(job_id_filter, relay_timeout)
     events = event_struct.to_vec()
 
     if len(events) > 0:
@@ -129,7 +129,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)
-    event_struct = await client.fetch_events([filterts], relay_timeout)
+    event_struct = await client.fetch_events(filterts, relay_timeout)
     events = event_struct.to_vec()
 
     if len(events) > 0:

tests/wot.py

@@ -32,7 +32,7 @@ async def getmetadata(npub):
     await client.connect()
 
     profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
-    event_struct = await client.fetch_events([profile_filter], relay_timeout)
+    event_struct = await client.fetch_events(profile_filter, relay_timeout)
     events = event_struct.to_vec()
     if len(events) > 0:
         try:
@@ -82,7 +82,7 @@ async def analyse_users(user_ids=None):
 
         database = NostrDatabase.lmdb("db/nostr_followlists.db")
         followers_filter = Filter().authors(user_keys).kind(Kind(3))
-        followers = await database.query([followers_filter])
+        followers = await database.query(followers_filter)
         allfriends = []
         if len(followers.to_vec()) > 0:
             for follower in followers.to_vec():

tutorials/03_client.py

@@ -72,7 +72,11 @@ async def nostr_client(target_dvm_npub):
             kinds.append(Kind(kind))
 
     dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
-    await client.subscribe([dm_zap_filter, dvm_filter], None)
+    await client.subscribe(dm_zap_filter, None)
+    await client.subscribe(dvm_filter, None)
+
+
+
 
     # This will send a request to the DVM
     await nostr_client_generic_test(target_dvm_npub)

tutorials/09_nutzap_client.py

@@ -58,7 +58,7 @@ async def nostr_client(target_dvm_npub):
             kinds.append(Kind(kind))
 
     dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
-    await client.subscribe([dvm_filter], None)
+    await client.subscribe(dvm_filter, None)
 
     # This will send a request to the DVM
     await nostr_client_generic_test(target_dvm_npub)

tutorials/10_delete_nip89.py

@@ -25,7 +25,7 @@ async def delete_nip_89(private_key, relay_list, pow=True):
         await client.add_relay(relay)
     await client.connect()
     filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(keys.public_key())
-    events = await client.fetch_events([filter], timedelta(seconds=5))
+    events = await client.fetch_events(filter, timedelta(seconds=5))
     
     if len(events.to_vec()) == 0:
         print("Couldn't find note on relays. Seems they are gone.")