update NIP-60 implementation

Author: pablof7z

docs/mobile/index.md

@@ -25,39 +25,27 @@ When using this library don't import `@nostr-dev-kit/ndk` directly, instead impo
 
 Initialize NDK using the init function, probably when your app loads.
 
-```tsx
-function App() {
-    const { ndk, init: initializeNDK } = useNDK();
-
-    useEffect(() => {
-        initializeNDK({
-            /* Any parameter you'd want to pass to NDK */
-            explicitRelayUrls: [...],
-            // ...
-        }
-    }, []);
-}
-```
-
-### Settings
-
 Throughout the use of a normal app, you will probably want to store some settings, such us, the user that is logged in. `ndk-mobile` can take care of this for you automatically if you pass a `settingsStore` to the initialization. For example, using `expo-secure-store` you can:
 
 ```tsx
 import * as SecureStore from 'expo-secure-store';
 
+const ndk = new NDK({
+    /* Any parameter you'd want to pass to NDK */
+    explicitRelayUrls: [...],
+    // ...
+})
+
 const settingsStore = {
     get: SecureStore.getItemAsync,
     set: SecureStore.setItemAsync,
     delete: SecureStore.deleteItemAsync,
     getSync: SecureStore.getItem,
 };
 
-// and then, when you initialiaze NDK:
-initializeNDK({
-    ......,
-    settingsStore
-})
+function App() {
+    useNDKInit(ndk, settingsStore);
+}
 ```
 
 Now, once your user logs in, their login information will be stored locally so when your app restarts, the user will be logged in automatically.
@@ -81,4 +69,4 @@ function LoginScreen() {
 
 ## Example
 
-For a real application using this look at [Olas](https://github.com/pablof7z/snapstr).
+For a real application using this look at [Olas](https://github.com/pablof7z/olas).

docs/wallet/index.md

@@ -15,9 +15,9 @@ As a developer, the first thing you need to do to use a wallet in your app is to
 Once you instantiate the desired wallet, you simply pass it to ndk.
 
 ```ts
-const wallet = new NDKNWCWallet(ndk);
-await wallet.initWithPairingCode("nostr+walletconnect:....");
+const wallet = new NDKNWCWallet(ndk, { timeout: 5000, pairingCode: "nostr+walletconnect:...." });
 ndk.wallet = wallet;
+wallet.on("timeout", (method: string) => console.log('Unable to complete the operation in time', { method }))
 ```
 
 Now whenever you want to pay something, the wallet will be called. Refer to the Nutsack adapter to see more details of the interface.

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

@@ -120,4 +120,16 @@ export const migrations = [
         },
     },
 
+    {
+        version: 6,
+        up: async (db: SQLite.SQLiteDatabase) => {
+            await db.execAsync(`DROP TABLE IF EXISTS wallet_nutzaps;`); // XXX
+            await db.execAsync(`CREATE TABLE IF NOT EXISTS wallet_nutzaps (
+                event_id TEXT PRIMARY KEY UNIQUE,
+                status TEXT,
+                claimed_at INTEGER,
+                tx_event_id TEXT
+            );`);
+        },
+    },
 ];

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

@@ -50,17 +50,15 @@ type PendingCallback = (...arg: any) => any;
 function filterForCache(subscription: NDKSubscription) {
     if (!subscription.cacheUnconstrainFilter) return subscription.filters;
 
-    const filterCopy = [...subscription.filters];
+    const filterCopy = subscription.filters.map(filter => ({ ...filter }));
 
     // remove the keys that are in the cacheUnconstrainFilter
-    filterCopy.filter((filter) => {
+    return filterCopy.filter((filter) => {
         for (const key of subscription.cacheUnconstrainFilter) {
             delete filter[key];
         }
         return Object.keys(filter).length > 0;
     });
-
-    return filterCopy;
 }
 
 export class NDKCacheAdapterSqlite implements NDKCacheAdapter {
@@ -84,12 +82,15 @@ export class NDKCacheAdapterSqlite implements NDKCacheAdapter {
     constructor(dbName: string, maxProfiles: number = 200) {
         this.dbName = dbName ?? 'ndk-cache';
         this.profileCache = new LRUCache({ maxSize: maxProfiles });
-        this.initialize();
-    }
-
-    private async initialize() {
         this.db = SQLite.openDatabaseSync(this.dbName);
+    }
 
+    /**
+     * Initialize the cache adapter.
+     * 
+     * This should be called before using it.
+     */
+    public async initialize() {
         let { user_version: schemaVersion } = (this.db.getFirstSync(`PRAGMA user_version;`)) as { user_version: number };
 
         if (!schemaVersion) {

ndk-mobile/src/db/index.ts

@@ -0,0 +1,9 @@
+import * as nutzaps from './wallet/nutzaps.js';
+
+const wallet = {
+    nutzaps
+}
+
+export {
+    wallet
+};

ndk-mobile/src/db/wallet/nutzaps.ts

@@ -0,0 +1,40 @@
+import NDK, { NDKNutzap } from "@nostr-dev-kit/ndk";
+import * as SQLite from "expo-sqlite";
+import { NDKCacheAdapterSqlite } from "../../cache-adapter/sqlite.js";
+
+function withDb(ndk: NDK) {
+    const db = (ndk.cacheAdapter as NDKCacheAdapterSqlite).db;
+    if (!(db instanceof SQLite.SQLiteDatabase)) {
+        throw new Error("Database is not an instance of SQLiteDatabase");
+    }
+    return db;
+}
+
+export interface NDKDBNutzap {
+    event_id: string;
+    status: string;
+    claim_at: number;
+    claimed_at: number;
+}
+
+export function getNutzaps(ndk: NDK): NDKDBNutzap[] {
+    const db = withDb(ndk);
+    const nutzaps = db.getAllSync("SELECT * FROM wallet_nutzaps") as NDKDBNutzap[];
+
+    console.log('known nutzaps', nutzaps.length);
+    console.table(nutzaps);
+    
+    return nutzaps;
+}
+
+export function saveNutzap(ndk: NDK, nutzap: NDKNutzap, status?: string, claimedAt?: number, txEventId?: string) {
+    const db = withDb(ndk);
+
+    console.log('[DB] saving nutzap', nutzap.id, status, claimedAt, txEventId);
+
+    db.runSync(
+        `INSERT OR REPLACE INTO wallet_nutzaps (event_id, status, claimed_at, tx_event_id) 
+        VALUES (?, ?, ?, ?)`, 
+        [nutzap.id, status, claimedAt, txEventId]
+    );
+}

ndk-mobile/src/hooks/ndk.ts

@@ -1,18 +1,25 @@
-import { NDKEvent } from '@nostr-dev-kit/ndk';
+import NDK, { NDKEvent } from '@nostr-dev-kit/ndk';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useNDKStore } from '../stores/ndk.js';
+import { SettingsStore } from '../types.js';
 
 export const useNDK = () => {
     const ndk = useNDKStore(s => s.ndk);
-    const init = useNDKStore(s => s.init);
     const login = useNDKStore(s => s.login);
     const logout = useNDKStore(s => s.logout);
 
-    return { ndk, init, login, logout };
+    return { ndk, login, logout };
+}
+
+export const useNDKInit = (ndk: NDK, settingsStore: SettingsStore) => {
+    const storeInit = useNDKStore(s => s.init);
+
+    useEffect(() => {
+        storeInit(ndk, settingsStore);
+    }, []);
 }
 
 export const useNDKCurrentUser = () => useNDKStore(s => s.currentUser);
-export const useNDKCacheInitialized = () => useNDKStore(s => s.cacheInitialized);
 
 export function useNDKUnpublishedEvents() {
     const { ndk } = useNDK();

ndk-mobile/src/hooks/session.ts

@@ -1,31 +1,30 @@
 import NDK, { NDKEvent, NDKKind, NDKUser } from '@nostr-dev-kit/ndk';
+import { useState, useEffect } from 'react';
 import { useNDK } from './ndk.js';
-import { NDKEventWithFrom } from './subscribe.js';
+import { NDKEventWithFrom, NDKEventWithAsyncFrom } from './subscribe.js';
 import { useNDKSession } from '../stores/session/index.js';
 import { useNDKWallet } from './wallet.js';
 import { walletFromLoadingString } from '@nostr-dev-kit/ndk-wallet';
 import { SessionInitOpts, SessionInitCallbacks } from '../stores/session/types.js';
 import { SettingsStore } from '../types.js';
 
 const useNDKSessionInit = () => {
-    const init = useNDKSession(s => s.init);
+    return useNDKSession(s => s.init);
+}
 
+const useNDKSessionInitWallet = () => {
     const { setActiveWallet } = useNDKWallet();
 
-    const wrappedInit = (ndk: NDK, user: NDKUser, settingsStore: SettingsStore, opts: SessionInitOpts, on: SessionInitCallbacks) => {
-        init(ndk, user, settingsStore, opts, on);
-
+    const initWallet = (ndk: NDK, settingsStore: SettingsStore) => {
         const walletString = settingsStore?.getSync('wallet');
         if (walletString) {
             walletFromLoadingString(ndk, walletString).then((wallet) => {
                 if (wallet) setActiveWallet(wallet);
-            }).catch((e) => {
-                console.error('error setting active wallet', e);
             });
         }
     }
 
-    return wrappedInit;
+    return initWallet;
 }
 
 const useFollows = () => useNDKSession(s => s.follows);
@@ -51,9 +50,10 @@ const useWOT = () => useNDKSession(s => s.wot);
  */
 const useNDKSessionEventKind = <T extends NDKEvent>(
     EventClass: NDKEventWithFrom<any>,
-    kind: NDKKind,
+    kind?: NDKKind,
     { create }: { create: boolean } = { create: false }
 ): T | undefined => {
+    kind ??= EventClass.kind;
     const { ndk } = useNDK();
     const events = useNDKSession(s => s.events);
     const kindEvents = events.get(kind) || [];
@@ -69,6 +69,27 @@ const useNDKSessionEventKind = <T extends NDKEvent>(
     return firstEvent ? EventClass.from(firstEvent) : undefined;
 };
 
+const useNDKSessionEventKindAsync = <T>(
+    EventClass: NDKEventWithAsyncFrom<any>,
+    kind?: NDKKind,
+    { create }: { create: boolean } = { create: false }
+): T | undefined => {
+    kind ??= EventClass.kind;
+    const events = useNDKSession(s => s.events);
+    const kindEvents = events.get(kind) || [];
+    const firstEvent = kindEvents[0];
+    const [res, setRes] = useState<T | undefined>(undefined);
+
+    useEffect(() => {
+        if (!firstEvent) return;
+        EventClass.from(firstEvent).then((event) => {
+            setRes(event);
+        });
+    }, [firstEvent]);
+
+    return res;
+};
+
 const useNDKSessionEvents = <T extends NDKEvent>(
     kinds: NDKKind[],
     eventClass?: NDKEventWithFrom<any>,
@@ -92,4 +113,6 @@ export {
     useNDKSessionEventKind,
     useNDKSessionEvents,
     useNDKSessionInit,
+    useNDKSessionInitWallet,
+    useNDKSessionEventKindAsync,
 };

ndk-mobile/src/hooks/subscribe.ts

@@ -10,6 +10,7 @@ import { useNDKSession } from '../stores/session/index.js';
  * Extends NDKEvent with a 'from' method to wrap events with a kind-specific handler
  */
 export type NDKEventWithFrom<T extends NDKEvent> = T & { from: (event: NDKEvent) => T };
+export type NDKEventWithAsyncFrom<T extends NDKEvent> = T & { from: (event: NDKEvent) => Promise<T> };
 
 export type UseSubscribeOptions = NDKSubscriptionOptions & {
     /**
@@ -303,7 +304,6 @@ export function useMuteFilter() {
         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);

ndk-mobile/src/hooks/wallet.ts

@@ -3,6 +3,16 @@ import { useWalletStore } from '../stores/wallet.js';
 import { useNDK, useNDKCurrentUser } from './ndk.js';
 import { useNDKStore } from '../stores/ndk.js';
 import { useEffect, useCallback } from 'react';
+import { getNutzaps, saveNutzap } from '../db/wallet/nutzaps.js';
+import NDK from '@nostr-dev-kit/ndk';
+
+const getKnownNutzaps = (ndk: NDK) => {
+    const nutzaps = getNutzaps(ndk);
+    return new Set(nutzaps
+        .filter(n => n.status === 'redeemed' || n.status === 'spent')
+        .map(n => n.event_id)
+    );
+}
 
 /**
  * @param start - Whether to start the nutzap monitor if it hasn't been started yet.
@@ -22,11 +32,33 @@ const useNDKNutzapMonitor = (start: boolean = true) => {
         if (!activeWallet?.walletId) return;
         if (nutzapMonitor) return;
 
+        const knownNutzaps = getKnownNutzaps(ndk);
         const monitor = new NDKNutzapMonitor(ndk, currentUser);
-        console.log("[NDK-WALLET] Starting nutzap monitor");
+
         setNutzapMonitor(monitor);
-        if (activeWallet instanceof NDKCashuWallet) monitor.addWallet(activeWallet);
-        monitor.start();
+
+        if (activeWallet instanceof NDKCashuWallet) monitor.wallet = activeWallet;
+
+        monitor.on("seen", (event) => {
+            saveNutzap(ndk, event);
+        });
+
+        monitor.on("redeem", (event) => {
+            saveNutzap(ndk, event, "redeemed", Math.floor(Date.now()/1000));
+        });
+
+        monitor.on("spent", (event) => {
+            saveNutzap(ndk, event, "spent");
+        });
+
+        monitor.on("failed", (event) => {
+            saveNutzap(ndk, event, "failed");
+        });
+        
+        monitor.start(undefined, {
+            knownNutzaps: knownNutzaps,
+            pageSize: 10,
+        });
     }, [ nutzapMonitor, setNutzapMonitor, activeWallet?.walletId, currentUser?.pubkey, ndk, start ])
 
     return { nutzapMonitor, setNutzapMonitor };
@@ -43,8 +75,7 @@ const useNDKWallet = () => {
     const storeLastUpdatedAt = useCallback((wallet: NDKWallet) => {
         if (!(wallet instanceof NDKCashuWallet)) return;
         const now = Math.floor(Date.now()/1000);
-        settingsStore.set('wallet_'+wallet.walletId+'_last_updated_at', now.toString());
-        console.log("[NDK-WALLET] Stored last updated at for wallet", wallet.walletId, "as", now);
+        settingsStore.set('wallet_last_updated_at', now.toString());
     }, [ settingsStore ]);
 
     const setActiveWallet = useCallback((wallet: NDKWallet) => {
@@ -69,18 +100,22 @@ const useNDKWallet = () => {
             wallet.on('ready', updateBalance);
             wallet.on('balance_updated', updateBalance);
         } else {
+            settingsStore.delete('wallet');
+            settingsStore.delete('wallet_last_updated_at');
+            
             setBalance(null);
         }
 
         if (wallet instanceof NDKCashuWallet) {
-            const lastUpdatedAt = settingsStore?.getSync('wallet_' + wallet.walletId + '_last_updated_at');
-            console.log("[NDK-WALLET] Starting wallet", wallet.walletId, "with since", lastUpdatedAt);
+            const lastUpdatedAt = settingsStore?.getSync('wallet_last_updated_at');
             wallet.start({ subId: 'wallet', since: lastUpdatedAt ? parseInt(lastUpdatedAt) : undefined });
         }
 
-        if (wallet) wallet.updateBalance?.();
+        if (wallet) {
+            wallet.updateBalance?.();
+            loadingString = wallet.toLoadingString?.();
+        }
 
-        if (wallet) loadingString = wallet.toLoadingString?.();
         if (loadingString) 
             settingsStore.set('wallet', loadingString);
         else