ndk-mobile: nip55 support -- thanks to @chebizarro

Author: pablof7z

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "packages/expo-nip55"]
+	path = packages/expo-nip55
+	url = https://github.com/pablof7z/expo-nip55

ndk-mobile/package.json

@@ -21,6 +21,7 @@
     "@bacons/text-decoder": "^0.0.0",
     "@nostr-dev-kit/ndk": "workspace:*",
     "@nostr-dev-kit/ndk-wallet": "workspace:*",
+    "expo-nip55": "workspace:*",
     "react-native-get-random-values": "~1.11.0",
     "typescript-lru-cache": "^2.0.0",
     "zustand": "^5.0.2"

ndk-mobile/src/cache-adapter/sqlite.ts

@@ -232,7 +232,6 @@ export class NDKCacheAdapterSqlite implements NDKCacheAdapter {
             this.bufferFlushTimer = setTimeout(() => this.flushWriteBuffer(), this.bufferFlushTimeout);
         }
     }
-
 
     async setEvent(event: NDKEvent, filters: NDKFilter[], relay?: NDKRelay): Promise<void> {
         this.onReady(async () => {

ndk-mobile/src/hooks/index.ts

@@ -3,3 +3,4 @@ export * from './session.js';
 export * from './wallet.js';
 export * from './ndk.js';
 export * from './user-profile.js';
+export * from './nip55.js';

ndk-mobile/src/hooks/nip55.tsx

@@ -0,0 +1,16 @@
+import { SignerAppInfo } from "expo-nip55";
+import { getInstalledSignerApps } from "expo-nip55";
+import { useState, useEffect } from "react";
+
+export function useNip55() {
+    const [signerApps, setSignerApps] = useState<SignerAppInfo[]>([]);
+
+    useEffect(() => {
+        getInstalledSignerApps().then(setSignerApps);
+    }, [])
+
+    return {
+        isAvailable: signerApps.length > 0,
+        apps: signerApps,
+    }
+}

ndk-mobile/src/hooks/session.ts

@@ -30,9 +30,14 @@ const useNDKSessionInit = () => {
 
 const useFollows = () => useNDKSession(s => s.follows);
 const useMuteList = () => {
-    const muteList = useNDKSession(s => s.muteList);
-    const mutePubkey = useNDKSession(s => s.mutePubkey);
-    return { muteList, mutePubkey };
+    const muteListEvent = useNDKSession(s => s.muteListEvent);
+    const mutedPubkeys = useNDKSession(s => s.mutedPubkeys);
+    const mutedHashtags = useNDKSession(s => s.mutedHashtags);
+    const mutedWords = useNDKSession(s => s.mutedWords);
+    const mutedEventIds = useNDKSession(s => s.mutedEventIds);
+    const mute = useNDKSession(s => s.mute);
+
+    return { mutedPubkeys, mutedHashtags, mutedWords, mutedEventIds, mute, muteListEvent };
 }
 const useSessionEvents = () => useNDKSession(s => s.events);
 const useWOT = () => useNDKSession(s => s.wot);

ndk-mobile/src/hooks/subscribe.ts

@@ -1,7 +1,7 @@
 import '@bacons/text-decoder/install';
 import { createStore } from 'zustand/vanilla';
 import { useStore } from 'zustand';
-import NDK, { NDKEvent, NDKFilter, NDKKind, NDKRelaySet, NDKSubscription, NDKSubscriptionOptions, wrapEvent } from '@nostr-dev-kit/ndk';
+import { NDKEvent, NDKFilter, NDKRelaySet, NDKSubscription, NDKSubscriptionOptions, wrapEvent } from '@nostr-dev-kit/ndk';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import { useNDK } from './ndk.js';
 import { useNDKSession } from '../stores/session/index.js';
@@ -173,6 +173,7 @@ const createSubscribeStore = <T extends NDKEvent>(bufferMs: number | false = 30)
  * @returns {boolean} eose - End of stored events flag
  * @returns {boolean} isSubscribed - Subscription status
  */
+
 export const useSubscribe = <T extends NDKEvent>(
     filters: NDKFilter[] | false,
     opts: UseSubscribeOptions = {},
@@ -181,7 +182,6 @@ export const useSubscribe = <T extends NDKEvent>(
     dependencies.push(!!filters);
 
     const { ndk } = useNDK();
-    const muteList = useNDKSession(s => s.muteList);
     const store = useMemo(() => createSubscribeStore<T>(opts?.bufferMs), dependencies);
     const storeInstance = useStore(store);
 
@@ -202,22 +202,23 @@ export const useSubscribe = <T extends NDKEvent>(
         return undefined;
     }, [ndk, opts.relays]);
 
+    const isMutedEvent = useMuteFilter();
+
     useEffect(() => {
         // go through the events and remove any that are from muted pubkeys
         storeInstance.events.forEach((event) => {
-            if (muteList.has(event.pubkey)) {
+            if (isMutedEvent(event)) {
                 storeInstance.removeEventId(event.id);
             }
         });
-
-    }, [ muteList.size ])
+    }, [ isMutedEvent ])
 
     const handleEvent = useCallback(
         (event: NDKEvent) => {
             const id = event.tagId();
 
             // if it's from a muted pubkey, we don't accept it
-            if (opts?.includeMuted !== true && muteList.has(event.pubkey)) return false;
+            if (opts?.includeMuted !== true && isMutedEvent(event)) return false;
 
             if (opts?.includeDeleted !== true && event.isParamReplaceable() && event.hasTag('deleted')) {
                 // We mark the event but we don't add the actual event, since
@@ -240,7 +241,7 @@ export const useSubscribe = <T extends NDKEvent>(
             storeInstance.addEvent(event as T);
             eventIds.current.set(id, event.created_at!);
         },
-        [muteList, ...dependencies]
+        [isMutedEvent, ...dependencies]
     );
 
     const handleEose = () => {
@@ -285,3 +286,50 @@ export const useSubscribe = <T extends NDKEvent>(
         subscription: storeInstance.subscriptionRef,
     };
 };
+
+
+/**
+ * Provides a function that filters events, according to the user's mute list.
+ */
+export function useMuteFilter() {
+    const mutedPubkeys = useNDKSession(s => s.mutedPubkeys);
+    const mutedHashtags = useNDKSession(s => s.mutedHashtags);
+    const mutedWords = useNDKSession(s => s.mutedWords);
+    const mutedEventIds = useNDKSession(s => s.mutedEventIds);
+
+    const isMutedEvent = useMemo(() => {
+        const mutedWordsRegex = mutedWords.size > 0 ? new RegExp(Array.from(mutedWords).join('|'), 'i') : null;
+        const _mutedHashtags = new Set<string>();
+        mutedHashtags.forEach(h => _mutedHashtags.add(h.toLowerCase()));
+
+        return (event: NDKEvent) => {
+            const start = performance.now();
+            const tags = new Set(event.getMatchingTags('t').map(tag => tag[1].toLowerCase()));
+            const taggedEvents = new Set(event.getMatchingTags('e').map(tag => tag[1]));
+            taggedEvents.add(event.id);
+            const hasMutedHashtag = setHasAnyIntersection(_mutedHashtags, tags);
+            let res = false;
+
+            if (
+                hasMutedHashtag ||
+                mutedPubkeys.has(event.pubkey) ||
+                (mutedWordsRegex && event.content.match(mutedWordsRegex))
+            ) res = true;
+
+            if (!res && setHasAnyIntersection(mutedEventIds, taggedEvents)) {
+                res = true;
+            }
+            
+            return res;
+        }
+    }, [mutedPubkeys, mutedHashtags, mutedWords, mutedEventIds]);
+
+    return isMutedEvent;
+}
+
+const setHasAnyIntersection = (set1: Set<string>, set2: Set<string>) => {
+    for (const item of set1) {
+        if (set2.has(item)) return true;
+    }
+    return false;
+}