|
|
import { SimplePool } from 'nostr-tools/pool'; |
|
|
import { EventStore } from 'applesauce-core'; |
|
|
import { PrivateKeySigner } from 'applesauce-signers'; |
|
|
import { getDefaultRelays, FALLBACK_RELAYS } from "./constants.js"; |
|
|
|
|
|
// Dedicated pool for fallback relay queries (separate from main pool to avoid conflicts) |
|
|
let fallbackPool = null; |
|
|
|
|
|
function getFallbackPool() { |
|
|
if (!fallbackPool) { |
|
|
fallbackPool = new SimplePool(); |
|
|
} |
|
|
return fallbackPool; |
|
|
} |
|
|
|
|
|
// Nostr client wrapper using nostr-tools |
|
|
class NostrClient { |
|
|
constructor() { |
|
|
this.pool = new SimplePool(); |
|
|
this.eventStore = new EventStore(); |
|
|
this.isConnected = false; |
|
|
this.signer = null; |
|
|
// Use dynamic relay list (supports standalone mode) |
|
|
this.relays = [...getDefaultRelays()]; |
|
|
} |
|
|
|
|
|
// Refresh relay list from config (call when relay URL changes) |
|
|
refreshRelays() { |
|
|
const newRelays = getDefaultRelays(); |
|
|
if (JSON.stringify(this.relays) !== JSON.stringify(newRelays)) { |
|
|
console.log("Relay list updated:", newRelays); |
|
|
this.relays = [...newRelays]; |
|
|
} |
|
|
} |
|
|
|
|
|
// Reset client for new relay (close old connections, refresh relay list, create new pool) |
|
|
reset() { |
|
|
console.log("[NostrClient] Resetting for new relay..."); |
|
|
// Close ALL existing connections by destroying the pool |
|
|
if (this.pool) { |
|
|
try { |
|
|
// Close connections to old relays first |
|
|
this.pool.close(this.relays); |
|
|
} catch (e) { |
|
|
console.warn("[NostrClient] Error closing old relay connections:", e); |
|
|
} |
|
|
// Destroy the pool reference completely |
|
|
this.pool = null; |
|
|
} |
|
|
// Create completely fresh pool |
|
|
this.pool = new SimplePool(); |
|
|
this.isConnected = false; |
|
|
// Refresh relay list |
|
|
this.relays = [...getDefaultRelays()]; |
|
|
console.log("[NostrClient] Reset complete, new relays:", this.relays); |
|
|
} |
|
|
|
|
|
async connect() { |
|
|
console.log("Starting connection to", this.relays.length, "relays..."); |
|
|
|
|
|
try { |
|
|
// SimplePool doesn't require explicit connect |
|
|
this.isConnected = true; |
|
|
console.log("✓ Successfully initialized relay pool"); |
|
|
|
|
|
// Wait a bit for connections to stabilize |
|
|
await new Promise((resolve) => setTimeout(resolve, 1000)); |
|
|
} catch (error) { |
|
|
console.error("✗ Connection failed:", error); |
|
|
throw error; |
|
|
} |
|
|
} |
|
|
|
|
|
async connectToRelay(relayUrl) { |
|
|
console.log(`Adding relay: ${relayUrl}`); |
|
|
|
|
|
try { |
|
|
if (!this.relays.includes(relayUrl)) { |
|
|
this.relays.push(relayUrl); |
|
|
} |
|
|
console.log(`✓ Successfully added relay ${relayUrl}`); |
|
|
return true; |
|
|
} catch (error) { |
|
|
console.error(`✗ Failed to add relay ${relayUrl}:`, error); |
|
|
return false; |
|
|
} |
|
|
} |
|
|
|
|
|
subscribe(filters, callback) { |
|
|
console.log("Creating subscription with filters:", filters); |
|
|
|
|
|
const sub = this.pool.subscribeMany( |
|
|
this.relays, |
|
|
filters, |
|
|
{ |
|
|
onevent(event) { |
|
|
console.log("Event received:", event); |
|
|
callback(event); |
|
|
}, |
|
|
oneose() { |
|
|
console.log("EOSE received"); |
|
|
window.dispatchEvent(new CustomEvent('nostr-eose', { |
|
|
detail: { subscriptionId: sub.id } |
|
|
})); |
|
|
} |
|
|
} |
|
|
); |
|
|
|
|
|
return sub; |
|
|
} |
|
|
|
|
|
unsubscribe(subscription) { |
|
|
console.log(`Closing subscription`); |
|
|
if (subscription && subscription.close) { |
|
|
subscription.close(); |
|
|
} |
|
|
} |
|
|
|
|
|
disconnect() { |
|
|
console.log("Disconnecting relay pool"); |
|
|
if (this.pool) { |
|
|
this.pool.close(this.relays); |
|
|
} |
|
|
this.isConnected = false; |
|
|
} |
|
|
|
|
|
// Publish an event |
|
|
async publish(event, specificRelays = null) { |
|
|
if (!this.isConnected) { |
|
|
console.warn("Not connected to any relays, attempting to connect first"); |
|
|
await this.connect(); |
|
|
} |
|
|
|
|
|
try { |
|
|
const relaysToUse = specificRelays || this.relays; |
|
|
const promises = this.pool.publish(relaysToUse, event); |
|
|
await Promise.allSettled(promises); |
|
|
console.log("✓ Event published successfully"); |
|
|
// Store the published event in IndexedDB |
|
|
await putEvents([event]); |
|
|
console.log("Event stored in IndexedDB"); |
|
|
return { success: true, okCount: 1, errorCount: 0 }; |
|
|
} catch (error) { |
|
|
console.error("✗ Failed to publish event:", error); |
|
|
throw error; |
|
|
} |
|
|
} |
|
|
|
|
|
// Get pool for advanced usage |
|
|
getPool() { |
|
|
return this.pool; |
|
|
} |
|
|
|
|
|
// Get event store |
|
|
getEventStore() { |
|
|
return this.eventStore; |
|
|
} |
|
|
|
|
|
// Get signer |
|
|
getSigner() { |
|
|
return this.signer; |
|
|
} |
|
|
|
|
|
// Set signer |
|
|
setSigner(signer) { |
|
|
this.signer = signer; |
|
|
} |
|
|
} |
|
|
|
|
|
// Create a global client instance |
|
|
export const nostrClient = new NostrClient(); |
|
|
|
|
|
// Export the class for creating new instances |
|
|
export { NostrClient }; |
|
|
|
|
|
// Export signer classes |
|
|
export { PrivateKeySigner }; |
|
|
|
|
|
// Export NIP-07 helper |
|
|
export class Nip07Signer { |
|
|
async getPublicKey() { |
|
|
if (window.nostr) { |
|
|
return await window.nostr.getPublicKey(); |
|
|
} |
|
|
throw new Error('NIP-07 extension not found'); |
|
|
} |
|
|
|
|
|
async signEvent(event) { |
|
|
if (window.nostr) { |
|
|
return await window.nostr.signEvent(event); |
|
|
} |
|
|
throw new Error('NIP-07 extension not found'); |
|
|
} |
|
|
|
|
|
async nip04Encrypt(pubkey, plaintext) { |
|
|
if (window.nostr && window.nostr.nip04) { |
|
|
return await window.nostr.nip04.encrypt(pubkey, plaintext); |
|
|
} |
|
|
throw new Error('NIP-07 extension does not support NIP-04'); |
|
|
} |
|
|
|
|
|
async nip04Decrypt(pubkey, ciphertext) { |
|
|
if (window.nostr && window.nostr.nip04) { |
|
|
return await window.nostr.nip04.decrypt(pubkey, ciphertext); |
|
|
} |
|
|
throw new Error('NIP-07 extension does not support NIP-04'); |
|
|
} |
|
|
|
|
|
async nip44Encrypt(pubkey, plaintext) { |
|
|
if (window.nostr && window.nostr.nip44) { |
|
|
return await window.nostr.nip44.encrypt(pubkey, plaintext); |
|
|
} |
|
|
throw new Error('NIP-07 extension does not support NIP-44'); |
|
|
} |
|
|
|
|
|
async nip44Decrypt(pubkey, ciphertext) { |
|
|
if (window.nostr && window.nostr.nip44) { |
|
|
return await window.nostr.nip44.decrypt(pubkey, ciphertext); |
|
|
} |
|
|
throw new Error('NIP-07 extension does not support NIP-44'); |
|
|
} |
|
|
} |
|
|
|
|
|
// Merge two event arrays, deduplicating by event id |
|
|
// Newer events (by created_at) take precedence for same id |
|
|
function mergeAndDeduplicateEvents(cached, relay) { |
|
|
const eventMap = new Map(); |
|
|
|
|
|
// Add cached events first |
|
|
for (const event of cached) { |
|
|
eventMap.set(event.id, event); |
|
|
} |
|
|
|
|
|
// Add/update with relay events (they may be newer) |
|
|
for (const event of relay) { |
|
|
const existing = eventMap.get(event.id); |
|
|
if (!existing || event.created_at >= existing.created_at) { |
|
|
eventMap.set(event.id, event); |
|
|
} |
|
|
} |
|
|
|
|
|
// Return sorted by created_at descending (newest first) |
|
|
return Array.from(eventMap.values()).sort((a, b) => b.created_at - a.created_at); |
|
|
} |
|
|
|
|
|
// IndexedDB helpers for unified event storage |
|
|
// This provides a local cache that all components can access |
|
|
const DB_NAME = "nostrCache"; |
|
|
const DB_VERSION = 2; // Incremented for new indexes |
|
|
const STORE_EVENTS = "events"; |
|
|
|
|
|
function openDB() { |
|
|
return new Promise((resolve, reject) => { |
|
|
try { |
|
|
const req = indexedDB.open(DB_NAME, DB_VERSION); |
|
|
req.onupgradeneeded = (event) => { |
|
|
const db = req.result; |
|
|
const oldVersion = event.oldVersion; |
|
|
|
|
|
// Create or update the events store |
|
|
let store; |
|
|
if (!db.objectStoreNames.contains(STORE_EVENTS)) { |
|
|
store = db.createObjectStore(STORE_EVENTS, { keyPath: "id" }); |
|
|
} else { |
|
|
// Get existing store during upgrade |
|
|
store = req.transaction.objectStore(STORE_EVENTS); |
|
|
} |
|
|
|
|
|
// Create indexes if they don't exist |
|
|
if (!store.indexNames.contains("byKindAuthor")) { |
|
|
store.createIndex("byKindAuthor", ["kind", "pubkey"], { |
|
|
unique: false, |
|
|
}); |
|
|
} |
|
|
if (!store.indexNames.contains("byKindAuthorCreated")) { |
|
|
store.createIndex( |
|
|
"byKindAuthorCreated", |
|
|
["kind", "pubkey", "created_at"], |
|
|
{ unique: false }, |
|
|
); |
|
|
} |
|
|
if (!store.indexNames.contains("byKind")) { |
|
|
store.createIndex("byKind", "kind", { unique: false }); |
|
|
} |
|
|
if (!store.indexNames.contains("byAuthor")) { |
|
|
store.createIndex("byAuthor", "pubkey", { unique: false }); |
|
|
} |
|
|
if (!store.indexNames.contains("byCreatedAt")) { |
|
|
store.createIndex("byCreatedAt", "created_at", { unique: false }); |
|
|
} |
|
|
}; |
|
|
req.onsuccess = () => resolve(req.result); |
|
|
req.onerror = () => reject(req.error); |
|
|
} catch (e) { |
|
|
console.error("Failed to open IndexedDB", e); |
|
|
reject(e); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
async function getLatestProfileEvent(pubkey) { |
|
|
try { |
|
|
const db = await openDB(); |
|
|
return await new Promise((resolve, reject) => { |
|
|
const tx = db.transaction(STORE_EVENTS, "readonly"); |
|
|
const idx = tx.objectStore(STORE_EVENTS).index("byKindAuthorCreated"); |
|
|
const range = IDBKeyRange.bound( |
|
|
[0, pubkey, -Infinity], |
|
|
[0, pubkey, Infinity], |
|
|
); |
|
|
const req = idx.openCursor(range, "prev"); // newest first |
|
|
req.onsuccess = () => { |
|
|
const cursor = req.result; |
|
|
resolve(cursor ? cursor.value : null); |
|
|
}; |
|
|
req.onerror = () => reject(req.error); |
|
|
}); |
|
|
} catch (e) { |
|
|
console.warn("IDB getLatestProfileEvent failed", e); |
|
|
return null; |
|
|
} |
|
|
} |
|
|
|
|
|
async function putEvent(event) { |
|
|
try { |
|
|
const db = await openDB(); |
|
|
await new Promise((resolve, reject) => { |
|
|
const tx = db.transaction(STORE_EVENTS, "readwrite"); |
|
|
tx.oncomplete = () => resolve(); |
|
|
tx.onerror = () => reject(tx.error); |
|
|
tx.objectStore(STORE_EVENTS).put(event); |
|
|
}); |
|
|
} catch (e) { |
|
|
console.warn("IDB putEvent failed", e); |
|
|
} |
|
|
} |
|
|
|
|
|
// Store multiple events in IndexedDB |
|
|
async function putEvents(events) { |
|
|
if (!events || events.length === 0) return; |
|
|
|
|
|
try { |
|
|
const db = await openDB(); |
|
|
await new Promise((resolve, reject) => { |
|
|
const tx = db.transaction(STORE_EVENTS, "readwrite"); |
|
|
tx.oncomplete = () => resolve(); |
|
|
tx.onerror = () => reject(tx.error); |
|
|
|
|
|
const store = tx.objectStore(STORE_EVENTS); |
|
|
for (const event of events) { |
|
|
store.put(event); |
|
|
} |
|
|
}); |
|
|
console.log(`Stored ${events.length} events in IndexedDB`); |
|
|
} catch (e) { |
|
|
console.warn("IDB putEvents failed", e); |
|
|
} |
|
|
} |
|
|
|
|
|
// Query events from IndexedDB by filters |
|
|
async function queryEventsFromDB(filters) { |
|
|
try { |
|
|
const db = await openDB(); |
|
|
const results = []; |
|
|
|
|
|
console.log("QueryEventsFromDB: Starting query with filters:", filters); |
|
|
|
|
|
for (const filter of filters) { |
|
|
console.log("QueryEventsFromDB: Processing filter:", filter); |
|
|
|
|
|
const events = await new Promise((resolve, reject) => { |
|
|
const tx = db.transaction(STORE_EVENTS, "readonly"); |
|
|
const store = tx.objectStore(STORE_EVENTS); |
|
|
const allEvents = []; |
|
|
|
|
|
// Determine which index to use based on filter |
|
|
let req; |
|
|
if (filter.kinds && filter.kinds.length > 0 && filter.authors && filter.authors.length > 0) { |
|
|
// Use byKindAuthor index for the most specific query |
|
|
const kind = filter.kinds[0]; |
|
|
const author = filter.authors[0]; |
|
|
console.log(`QueryEventsFromDB: Using byKindAuthorCreated index for kind=${kind}, author=${author.substring(0, 8)}...`); |
|
|
|
|
|
const idx = store.index("byKindAuthorCreated"); |
|
|
const range = IDBKeyRange.bound( |
|
|
[kind, author, -Infinity], |
|
|
[kind, author, Infinity] |
|
|
); |
|
|
req = idx.openCursor(range, "prev"); // newest first |
|
|
} else if (filter.kinds && filter.kinds.length > 0) { |
|
|
// Use byKind index |
|
|
console.log(`QueryEventsFromDB: Using byKind index for kind=${filter.kinds[0]}`); |
|
|
const idx = store.index("byKind"); |
|
|
req = idx.openCursor(IDBKeyRange.only(filter.kinds[0])); |
|
|
} else if (filter.authors && filter.authors.length > 0) { |
|
|
// Use byAuthor index |
|
|
console.log(`QueryEventsFromDB: Using byAuthor index for author=${filter.authors[0].substring(0, 8)}...`); |
|
|
const idx = store.index("byAuthor"); |
|
|
req = idx.openCursor(IDBKeyRange.only(filter.authors[0])); |
|
|
} else { |
|
|
// Scan all events |
|
|
console.log("QueryEventsFromDB: Scanning all events (no specific index)"); |
|
|
req = store.openCursor(); |
|
|
} |
|
|
|
|
|
req.onsuccess = (event) => { |
|
|
const cursor = event.target.result; |
|
|
if (cursor) { |
|
|
const evt = cursor.value; |
|
|
|
|
|
// Apply additional filters |
|
|
let matches = true; |
|
|
|
|
|
// Filter by kinds |
|
|
if (filter.kinds && filter.kinds.length > 0 && !filter.kinds.includes(evt.kind)) { |
|
|
matches = false; |
|
|
} |
|
|
|
|
|
// Filter by authors |
|
|
if (filter.authors && filter.authors.length > 0 && !filter.authors.includes(evt.pubkey)) { |
|
|
matches = false; |
|
|
} |
|
|
|
|
|
// Filter by since |
|
|
if (filter.since && evt.created_at < filter.since) { |
|
|
matches = false; |
|
|
} |
|
|
|
|
|
// Filter by until |
|
|
if (filter.until && evt.created_at > filter.until) { |
|
|
matches = false; |
|
|
} |
|
|
|
|
|
// Filter by IDs |
|
|
if (filter.ids && filter.ids.length > 0 && !filter.ids.includes(evt.id)) { |
|
|
matches = false; |
|
|
} |
|
|
|
|
|
if (matches) { |
|
|
allEvents.push(evt); |
|
|
} |
|
|
|
|
|
// Apply limit |
|
|
if (filter.limit && allEvents.length >= filter.limit) { |
|
|
console.log(`QueryEventsFromDB: Reached limit of ${filter.limit}, found ${allEvents.length} matching events`); |
|
|
resolve(allEvents); |
|
|
return; |
|
|
} |
|
|
|
|
|
cursor.continue(); |
|
|
} else { |
|
|
console.log(`QueryEventsFromDB: Cursor exhausted, found ${allEvents.length} matching events`); |
|
|
resolve(allEvents); |
|
|
} |
|
|
}; |
|
|
|
|
|
req.onerror = () => { |
|
|
console.error("QueryEventsFromDB: Cursor error:", req.error); |
|
|
reject(req.error); |
|
|
}; |
|
|
}); |
|
|
|
|
|
console.log(`QueryEventsFromDB: Found ${events.length} events for this filter`); |
|
|
results.push(...events); |
|
|
} |
|
|
|
|
|
// Sort by created_at (newest first) and apply global limit |
|
|
results.sort((a, b) => b.created_at - a.created_at); |
|
|
|
|
|
console.log(`QueryEventsFromDB: Returning ${results.length} total events`); |
|
|
return results; |
|
|
} catch (e) { |
|
|
console.error("QueryEventsFromDB failed:", e); |
|
|
return []; |
|
|
} |
|
|
} |
|
|
|
|
|
function parseProfileFromEvent(event) { |
|
|
try { |
|
|
const profile = JSON.parse(event.content || "{}"); |
|
|
return { |
|
|
name: profile.name || profile.display_name || "", |
|
|
picture: profile.picture || "", |
|
|
banner: profile.banner || "", |
|
|
about: profile.about || "", |
|
|
nip05: profile.nip05 || "", |
|
|
lud16: profile.lud16 || profile.lud06 || "", |
|
|
}; |
|
|
} catch (e) { |
|
|
return { |
|
|
name: "", |
|
|
picture: "", |
|
|
banner: "", |
|
|
about: "", |
|
|
nip05: "", |
|
|
lud16: "", |
|
|
}; |
|
|
} |
|
|
} |
|
|
|
|
|
// Fetch user profile metadata (kind 0) |
|
|
export async function fetchUserProfile(pubkey) { |
|
|
console.log(`Starting profile fetch for pubkey: ${pubkey}`); |
|
|
console.log(`[fetchUserProfile] Current relay list:`, nostrClient.relays); |
|
|
|
|
|
// 1) Try cached profile first and resolve immediately if present |
|
|
try { |
|
|
const cachedEvent = await getLatestProfileEvent(pubkey); |
|
|
if (cachedEvent) { |
|
|
console.log("Using cached profile event"); |
|
|
const profile = parseProfileFromEvent(cachedEvent); |
|
|
return profile; |
|
|
} |
|
|
} catch (e) { |
|
|
console.warn("Failed to load cached profile", e); |
|
|
} |
|
|
|
|
|
const filters = [{ |
|
|
kinds: [0], |
|
|
authors: [pubkey], |
|
|
limit: 1 |
|
|
}]; |
|
|
|
|
|
// 2) Fetch profile from local relay first |
|
|
try { |
|
|
const events = await fetchEvents(filters, { timeout: 10000 }); |
|
|
|
|
|
if (events.length > 0) { |
|
|
const profileEvent = events[0]; |
|
|
console.log("Profile fetched from local relay:", profileEvent); |
|
|
return processProfileEvent(profileEvent, pubkey); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("Failed to fetch profile from local relay:", error); |
|
|
} |
|
|
|
|
|
// 3) Try fallback relays if local relay doesn't have the profile |
|
|
console.log("Profile not found on local relay, trying fallback relays:", FALLBACK_RELAYS); |
|
|
try { |
|
|
const profileEvent = await fetchProfileFromFallbackRelays(pubkey, filters); |
|
|
if (profileEvent) { |
|
|
return processProfileEvent(profileEvent, pubkey); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("Failed to fetch profile from fallback relays:", error); |
|
|
} |
|
|
|
|
|
// 4) No profile found anywhere |
|
|
console.log("No profile found for pubkey:", pubkey); |
|
|
return null; |
|
|
} |
|
|
|
|
|
// Helper to fetch profile from fallback relays |
|
|
async function fetchProfileFromFallbackRelays(pubkey, filters) { |
|
|
console.log(`[fetchProfileFromFallbackRelays] Querying fallback relays:`, FALLBACK_RELAYS); |
|
|
console.log(`[fetchProfileFromFallbackRelays] Using filters:`, JSON.stringify(filters)); |
|
|
return new Promise((resolve) => { |
|
|
const events = []; |
|
|
const pool = getFallbackPool(); |
|
|
let sub; |
|
|
|
|
|
const timeoutId = setTimeout(() => { |
|
|
if (sub) sub.close(); |
|
|
// Return the most recent profile event |
|
|
if (events.length > 0) { |
|
|
events.sort((a, b) => b.created_at - a.created_at); |
|
|
resolve(events[0]); |
|
|
} else { |
|
|
resolve(null); |
|
|
} |
|
|
}, 5000); |
|
|
|
|
|
sub = pool.subscribeMany( |
|
|
FALLBACK_RELAYS, |
|
|
filters, |
|
|
{ |
|
|
onevent(event) { |
|
|
console.log("[fetchProfileFromFallbackRelays] Event received:", event.id?.substring(0, 8), "kind:", event.kind, "pubkey:", event.pubkey?.substring(0, 8)); |
|
|
events.push(event); |
|
|
}, |
|
|
oneose() { |
|
|
console.log(`[fetchProfileFromFallbackRelays] EOSE received, got ${events.length} events`); |
|
|
clearTimeout(timeoutId); |
|
|
if (sub) sub.close(); |
|
|
if (events.length > 0) { |
|
|
events.sort((a, b) => b.created_at - a.created_at); |
|
|
console.log("[fetchProfileFromFallbackRelays] Returning best event:", events[0].id?.substring(0, 8)); |
|
|
resolve(events[0]); |
|
|
} else { |
|
|
console.log("[fetchProfileFromFallbackRelays] No events found"); |
|
|
resolve(null); |
|
|
} |
|
|
} |
|
|
} |
|
|
); |
|
|
}); |
|
|
} |
|
|
|
|
|
// Helper to process and cache a profile event |
|
|
async function processProfileEvent(profileEvent, pubkey) { |
|
|
// Cache the event |
|
|
await putEvent(profileEvent); |
|
|
|
|
|
// Publish the profile event to the local relay |
|
|
try { |
|
|
console.log("Publishing profile event to local relay:", profileEvent.id); |
|
|
await nostrClient.publish(profileEvent); |
|
|
console.log("Profile event successfully saved to local relay"); |
|
|
} catch (publishError) { |
|
|
console.warn("Failed to publish profile to local relay:", publishError); |
|
|
} |
|
|
|
|
|
// Parse profile data |
|
|
const profile = parseProfileFromEvent(profileEvent); |
|
|
|
|
|
// Notify listeners that an updated profile is available |
|
|
try { |
|
|
if (typeof window !== "undefined" && window.dispatchEvent) { |
|
|
window.dispatchEvent( |
|
|
new CustomEvent("profile-updated", { |
|
|
detail: { pubkey, profile, event: profileEvent }, |
|
|
}), |
|
|
); |
|
|
} |
|
|
} catch (e) { |
|
|
console.warn("Failed to dispatch profile-updated event", e); |
|
|
} |
|
|
|
|
|
return profile; |
|
|
} |
|
|
|
|
|
// Fetch user's relay list (NIP-65 kind 10002) |
|
|
export async function fetchUserRelayList(pubkey) { |
|
|
console.log(`[nostr] Fetching relay list for pubkey: ${pubkey?.substring(0, 8)}...`); |
|
|
|
|
|
const filters = [{ |
|
|
kinds: [10002], |
|
|
authors: [pubkey], |
|
|
limit: 1 |
|
|
}]; |
|
|
|
|
|
// Try local relay first |
|
|
try { |
|
|
const events = await fetchEvents(filters, { timeout: 10000, useCache: true }); |
|
|
if (events.length > 0) { |
|
|
const relayListEvent = events.sort((a, b) => b.created_at - a.created_at)[0]; |
|
|
console.log("[nostr] Relay list found on local relay"); |
|
|
return parseRelayListFromEvent(relayListEvent); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("[nostr] Failed to fetch relay list from local relay:", error); |
|
|
} |
|
|
|
|
|
// Try fallback relays |
|
|
console.log("[nostr] Relay list not found locally, trying fallback relays..."); |
|
|
try { |
|
|
const relayListEvent = await fetchFromFallbackRelays(filters); |
|
|
if (relayListEvent) { |
|
|
// Cache and publish to local relay |
|
|
await putEvent(relayListEvent); |
|
|
try { |
|
|
await nostrClient.publish(relayListEvent); |
|
|
} catch (e) { |
|
|
console.warn("[nostr] Failed to publish relay list to local relay:", e); |
|
|
} |
|
|
return parseRelayListFromEvent(relayListEvent); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("[nostr] Failed to fetch relay list from fallback relays:", error); |
|
|
} |
|
|
|
|
|
console.log("[nostr] No relay list found for pubkey"); |
|
|
return null; |
|
|
} |
|
|
|
|
|
// Parse relay list from kind 10002 event |
|
|
function parseRelayListFromEvent(event) { |
|
|
if (!event || event.kind !== 10002) return null; |
|
|
|
|
|
const relays = { |
|
|
read: [], |
|
|
write: [], |
|
|
all: [] |
|
|
}; |
|
|
|
|
|
for (const tag of event.tags) { |
|
|
if (tag[0] === 'r' && tag[1]) { |
|
|
const url = tag[1]; |
|
|
const marker = tag[2]; // 'read', 'write', or undefined (both) |
|
|
|
|
|
if (marker === 'read') { |
|
|
relays.read.push(url); |
|
|
} else if (marker === 'write') { |
|
|
relays.write.push(url); |
|
|
} else { |
|
|
// No marker means both read and write |
|
|
relays.read.push(url); |
|
|
relays.write.push(url); |
|
|
} |
|
|
relays.all.push({ url, read: marker !== 'write', write: marker !== 'read' }); |
|
|
} |
|
|
} |
|
|
|
|
|
console.log(`[nostr] Parsed relay list: ${relays.all.length} relays`); |
|
|
return relays; |
|
|
} |
|
|
|
|
|
// Generic helper to fetch from fallback relays |
|
|
async function fetchFromFallbackRelays(filters) { |
|
|
return new Promise((resolve) => { |
|
|
const events = []; |
|
|
const pool = getFallbackPool(); |
|
|
let sub; |
|
|
|
|
|
const timeoutId = setTimeout(() => { |
|
|
if (sub) sub.close(); |
|
|
if (events.length > 0) { |
|
|
events.sort((a, b) => b.created_at - a.created_at); |
|
|
resolve(events[0]); |
|
|
} else { |
|
|
resolve(null); |
|
|
} |
|
|
}, 5000); |
|
|
|
|
|
sub = pool.subscribeMany( |
|
|
FALLBACK_RELAYS, |
|
|
filters, |
|
|
{ |
|
|
onevent(event) { |
|
|
events.push(event); |
|
|
}, |
|
|
oneose() { |
|
|
clearTimeout(timeoutId); |
|
|
if (sub) sub.close(); |
|
|
if (events.length > 0) { |
|
|
events.sort((a, b) => b.created_at - a.created_at); |
|
|
resolve(events[0]); |
|
|
} else { |
|
|
resolve(null); |
|
|
} |
|
|
} |
|
|
} |
|
|
); |
|
|
}); |
|
|
} |
|
|
|
|
|
// Fetch user's contact list (kind 3) - includes follows and may have relay hints |
|
|
export async function fetchUserContactList(pubkey) { |
|
|
console.log(`[nostr] Fetching contact list for pubkey: ${pubkey?.substring(0, 8)}...`); |
|
|
|
|
|
const filters = [{ |
|
|
kinds: [3], |
|
|
authors: [pubkey], |
|
|
limit: 1 |
|
|
}]; |
|
|
|
|
|
// Try local relay first |
|
|
try { |
|
|
const events = await fetchEvents(filters, { timeout: 10000, useCache: true }); |
|
|
if (events.length > 0) { |
|
|
const contactEvent = events.sort((a, b) => b.created_at - a.created_at)[0]; |
|
|
console.log("[nostr] Contact list found on local relay"); |
|
|
return parseContactListFromEvent(contactEvent); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("[nostr] Failed to fetch contact list from local relay:", error); |
|
|
} |
|
|
|
|
|
// Try fallback relays |
|
|
console.log("[nostr] Contact list not found locally, trying fallback relays..."); |
|
|
try { |
|
|
const contactEvent = await fetchFromFallbackRelays(filters); |
|
|
if (contactEvent) { |
|
|
await putEvent(contactEvent); |
|
|
try { |
|
|
await nostrClient.publish(contactEvent); |
|
|
} catch (e) { |
|
|
console.warn("[nostr] Failed to publish contact list to local relay:", e); |
|
|
} |
|
|
return parseContactListFromEvent(contactEvent); |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn("[nostr] Failed to fetch contact list from fallback relays:", error); |
|
|
} |
|
|
|
|
|
console.log("[nostr] No contact list found for pubkey"); |
|
|
return null; |
|
|
} |
|
|
|
|
|
// Parse contact list from kind 3 event |
|
|
function parseContactListFromEvent(event) { |
|
|
if (!event || event.kind !== 3) return null; |
|
|
|
|
|
const follows = []; |
|
|
const relayHints = {}; |
|
|
|
|
|
for (const tag of event.tags) { |
|
|
if (tag[0] === 'p' && tag[1]) { |
|
|
const pubkey = tag[1]; |
|
|
const relayUrl = tag[2] || null; |
|
|
const petname = tag[3] || null; |
|
|
|
|
|
follows.push({ pubkey, relayUrl, petname }); |
|
|
|
|
|
if (relayUrl) { |
|
|
if (!relayHints[relayUrl]) { |
|
|
relayHints[relayUrl] = []; |
|
|
} |
|
|
relayHints[relayUrl].push(pubkey); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
// Also parse the content field which may contain relay preferences (legacy format) |
|
|
let legacyRelays = {}; |
|
|
try { |
|
|
if (event.content) { |
|
|
legacyRelays = JSON.parse(event.content); |
|
|
} |
|
|
} catch (e) { |
|
|
// Content is not JSON, ignore |
|
|
} |
|
|
|
|
|
console.log(`[nostr] Parsed contact list: ${follows.length} follows, ${Object.keys(relayHints).length} relay hints`); |
|
|
return { follows, relayHints, legacyRelays, event }; |
|
|
} |
|
|
|
|
|
// Fetch events |
|
|
export async function fetchEvents(filters, options = {}) { |
|
|
console.log(`Starting event fetch with filters:`, JSON.stringify(filters, null, 2)); |
|
|
console.log(`Current relays:`, nostrClient.relays); |
|
|
|
|
|
// Ensure client is connected |
|
|
if (!nostrClient.isConnected || nostrClient.relays.length === 0) { |
|
|
console.warn("Client not connected, initializing..."); |
|
|
await initializeNostrClient(); |
|
|
} |
|
|
|
|
|
const { |
|
|
timeout = 30000, |
|
|
useCache = true, // Option to query from cache first |
|
|
} = options; |
|
|
|
|
|
// Try to get cached events first if requested |
|
|
let cachedEvents = []; |
|
|
if (useCache) { |
|
|
try { |
|
|
cachedEvents = await queryEventsFromDB(filters); |
|
|
if (cachedEvents.length > 0) { |
|
|
console.log(`Found ${cachedEvents.length} cached events in IndexedDB`); |
|
|
} |
|
|
} catch (e) { |
|
|
console.warn("Failed to query cached events", e); |
|
|
} |
|
|
} |
|
|
|
|
|
return new Promise((resolve, reject) => { |
|
|
const relayEvents = []; |
|
|
let sub = null; |
|
|
|
|
|
const timeoutId = setTimeout(() => { |
|
|
console.log(`Timeout reached after ${timeout}ms, returning ${relayEvents.length} relay events`); |
|
|
if (sub) sub.close(); |
|
|
|
|
|
// Store all received events in IndexedDB before resolving |
|
|
if (relayEvents.length > 0) { |
|
|
putEvents(relayEvents).catch(e => console.warn("Failed to cache events", e)); |
|
|
} |
|
|
|
|
|
// Merge cached events with relay events, deduplicate by id |
|
|
const mergedEvents = mergeAndDeduplicateEvents(cachedEvents, relayEvents); |
|
|
resolve(mergedEvents); |
|
|
}, timeout); |
|
|
|
|
|
try { |
|
|
// Generate a subscription ID for logging |
|
|
const subId = Math.random().toString(36).substring(7); |
|
|
|
|
|
// Validate filters before sending |
|
|
if (!Array.isArray(filters) || filters.length === 0) { |
|
|
console.error(`❌ Invalid filters: not an array or empty`, filters); |
|
|
resolve(cachedEvents); |
|
|
return; |
|
|
} |
|
|
|
|
|
// Ensure each filter is a valid object |
|
|
const validFilters = filters.filter(f => f && typeof f === 'object' && !Array.isArray(f)); |
|
|
if (validFilters.length !== filters.length) { |
|
|
console.warn(`⚠️ Some filters were invalid, filtered ${filters.length} -> ${validFilters.length}`, filters); |
|
|
} |
|
|
|
|
|
if (validFilters.length === 0) { |
|
|
console.error(`❌ No valid filters remaining`); |
|
|
resolve(cachedEvents); |
|
|
return; |
|
|
} |
|
|
|
|
|
console.log(`📤 REQ [${subId}] to ${nostrClient.relays.join(', ')}:`, JSON.stringify(["REQ", subId, ...validFilters], null, 2)); |
|
|
|
|
|
sub = nostrClient.pool.subscribeMany( |
|
|
nostrClient.relays, |
|
|
validFilters, |
|
|
{ |
|
|
onevent(event) { |
|
|
console.log(`📥 EVENT received for REQ [${subId}]:`, { |
|
|
id: event.id?.substring(0, 8) + '...', |
|
|
kind: event.kind, |
|
|
pubkey: event.pubkey?.substring(0, 8) + '...', |
|
|
created_at: event.created_at, |
|
|
content_preview: event.content?.substring(0, 50) |
|
|
}); |
|
|
relayEvents.push(event); |
|
|
|
|
|
// Store event immediately in IndexedDB |
|
|
putEvent(event).catch(e => console.warn("Failed to cache event", e)); |
|
|
}, |
|
|
oneose() { |
|
|
console.log(`✅ EOSE received for REQ [${subId}], got ${relayEvents.length} relay events`); |
|
|
clearTimeout(timeoutId); |
|
|
if (sub) sub.close(); |
|
|
|
|
|
// Store all events in IndexedDB before resolving |
|
|
if (relayEvents.length > 0) { |
|
|
putEvents(relayEvents).catch(e => console.warn("Failed to cache events", e)); |
|
|
} |
|
|
|
|
|
// Merge cached events with relay events, deduplicate by id |
|
|
const mergedEvents = mergeAndDeduplicateEvents(cachedEvents, relayEvents); |
|
|
console.log(`Merged ${cachedEvents.length} cached + ${relayEvents.length} relay = ${mergedEvents.length} total events`); |
|
|
resolve(mergedEvents); |
|
|
} |
|
|
} |
|
|
); |
|
|
} catch (error) { |
|
|
clearTimeout(timeoutId); |
|
|
console.error("Failed to fetch events:", error); |
|
|
reject(error); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
// Fetch all events with timestamp-based pagination (including delete events) |
|
|
export async function fetchAllEvents(options = {}) { |
|
|
const { |
|
|
limit = 100, |
|
|
since = null, |
|
|
until = null, |
|
|
authors = null, |
|
|
kinds = null, |
|
|
...rest |
|
|
} = options; |
|
|
|
|
|
const now = Math.floor(Date.now() / 1000); |
|
|
const thirtyDaysAgo = now - (30 * 24 * 60 * 60); |
|
|
const sixMonthsAgo = now - (180 * 24 * 60 * 60); |
|
|
|
|
|
// Start with 30 days if no since specified |
|
|
const initialSince = since || thirtyDaysAgo; |
|
|
|
|
|
const filters = [{ ...rest }]; |
|
|
filters[0].since = initialSince; |
|
|
if (until) filters[0].until = until; |
|
|
if (authors) filters[0].authors = authors; |
|
|
if (kinds) filters[0].kinds = kinds; |
|
|
if (limit) filters[0].limit = limit; |
|
|
|
|
|
let events = await fetchEvents(filters, { |
|
|
timeout: 30000 |
|
|
}); |
|
|
|
|
|
// If we got few results and weren't already using a longer window, retry with 6 months |
|
|
const fewResultsThreshold = Math.min(20, limit / 2); |
|
|
if (events.length < fewResultsThreshold && initialSince > sixMonthsAgo && !since) { |
|
|
console.log(`[fetchAllEvents] Only got ${events.length} events, retrying with 6-month window...`); |
|
|
filters[0].since = sixMonthsAgo; |
|
|
events = await fetchEvents(filters, { |
|
|
timeout: 30000 |
|
|
}); |
|
|
console.log(`[fetchAllEvents] 6-month window returned ${events.length} events`); |
|
|
} |
|
|
|
|
|
return events; |
|
|
} |
|
|
|
|
|
// Fetch user's events with timestamp-based pagination |
|
|
export async function fetchUserEvents(pubkey, options = {}) { |
|
|
const { |
|
|
limit = 100, |
|
|
since = null, |
|
|
until = null |
|
|
} = options; |
|
|
|
|
|
const filters = [{ |
|
|
authors: [pubkey] |
|
|
}]; |
|
|
|
|
|
if (since) filters[0].since = since; |
|
|
if (until) filters[0].until = until; |
|
|
if (limit) filters[0].limit = limit; |
|
|
|
|
|
const events = await fetchEvents(filters, { |
|
|
timeout: 30000 |
|
|
}); |
|
|
|
|
|
return events; |
|
|
} |
|
|
|
|
|
// NIP-50 search function |
|
|
export async function searchEvents(searchQuery, options = {}) { |
|
|
const { |
|
|
limit = 100, |
|
|
since = null, |
|
|
until = null, |
|
|
kinds = null |
|
|
} = options; |
|
|
|
|
|
const filters = [{ |
|
|
search: searchQuery |
|
|
}]; |
|
|
|
|
|
if (since) filters[0].since = since; |
|
|
if (until) filters[0].until = until; |
|
|
if (kinds) filters[0].kinds = kinds; |
|
|
if (limit) filters[0].limit = limit; |
|
|
|
|
|
const events = await fetchEvents(filters, { |
|
|
timeout: 30000 |
|
|
}); |
|
|
|
|
|
return events; |
|
|
} |
|
|
|
|
|
// Fetch a specific event by ID |
|
|
export async function fetchEventById(eventId, options = {}) { |
|
|
const { |
|
|
timeout = 10000, |
|
|
} = options; |
|
|
|
|
|
console.log(`Fetching event by ID: ${eventId}`); |
|
|
|
|
|
try { |
|
|
const filters = [{ |
|
|
ids: [eventId] |
|
|
}]; |
|
|
|
|
|
console.log('Fetching event with filters:', filters); |
|
|
|
|
|
const events = await fetchEvents(filters, { timeout }); |
|
|
|
|
|
console.log(`Fetched ${events.length} events`); |
|
|
|
|
|
// Return the first event if found, null otherwise |
|
|
return events.length > 0 ? events[0] : null; |
|
|
} catch (error) { |
|
|
console.error("Failed to fetch event by ID:", error); |
|
|
throw error; |
|
|
} |
|
|
} |
|
|
|
|
|
// Fetch delete events that target a specific event ID |
|
|
export async function fetchDeleteEventsByTarget(eventId, options = {}) { |
|
|
const { |
|
|
timeout = 10000 |
|
|
} = options; |
|
|
|
|
|
console.log(`Fetching delete events for target: ${eventId}`); |
|
|
|
|
|
try { |
|
|
const filters = [{ |
|
|
kinds: [5], // Kind 5 is deletion |
|
|
'#e': [eventId] // e-tag referencing the target event |
|
|
}]; |
|
|
|
|
|
console.log('Fetching delete events with filters:', filters); |
|
|
|
|
|
const events = await fetchEvents(filters, { timeout }); |
|
|
|
|
|
console.log(`Fetched ${events.length} delete events`); |
|
|
|
|
|
return events; |
|
|
} catch (error) { |
|
|
console.error("Failed to fetch delete events:", error); |
|
|
throw error; |
|
|
} |
|
|
} |
|
|
|
|
|
// Initialize client connection |
|
|
export async function initializeNostrClient() { |
|
|
// Refresh relay list to pick up any changes (important for standalone mode) |
|
|
nostrClient.refreshRelays(); |
|
|
await nostrClient.connect(); |
|
|
} |
|
|
|
|
|
// Query events from cache and relay combined |
|
|
// This is the main function components should use |
|
|
export async function queryEvents(filters, options = {}) { |
|
|
const { |
|
|
timeout = 30000, |
|
|
cacheFirst = true, // Try cache first before hitting relay |
|
|
cacheOnly = false, // Only use cache, don't query relay |
|
|
} = options; |
|
|
|
|
|
let cachedEvents = []; |
|
|
|
|
|
// Try cache first |
|
|
if (cacheFirst || cacheOnly) { |
|
|
try { |
|
|
cachedEvents = await queryEventsFromDB(filters); |
|
|
console.log(`Found ${cachedEvents.length} events in cache`); |
|
|
|
|
|
if (cacheOnly || cachedEvents.length > 0) { |
|
|
return cachedEvents; |
|
|
} |
|
|
} catch (e) { |
|
|
console.warn("Failed to query cache", e); |
|
|
} |
|
|
} |
|
|
|
|
|
// If cache didn't have results and we're not cache-only, query relay |
|
|
if (!cacheOnly) { |
|
|
const relayEvents = await fetchEvents(filters, { timeout, useCache: false }); |
|
|
console.log(`Fetched ${relayEvents.length} events from relay`); |
|
|
return relayEvents; |
|
|
} |
|
|
|
|
|
return cachedEvents; |
|
|
} |
|
|
|
|
|
// Export cache query function for direct access |
|
|
export { queryEventsFromDB }; |
|
|
|
|
|
// Clear the IndexedDB cache (call when switching relays) |
|
|
export async function clearIndexedDBCache() { |
|
|
console.log("[nostr] Clearing IndexedDB cache..."); |
|
|
try { |
|
|
const db = await openDB(); |
|
|
const tx = db.transaction(STORE_EVENTS, "readwrite"); |
|
|
const store = tx.objectStore(STORE_EVENTS); |
|
|
await new Promise((resolve, reject) => { |
|
|
const req = store.clear(); |
|
|
req.onsuccess = () => resolve(); |
|
|
req.onerror = () => reject(req.error); |
|
|
}); |
|
|
console.log("[nostr] IndexedDB cache cleared"); |
|
|
} catch (e) { |
|
|
console.warn("[nostr] Failed to clear IndexedDB cache", e); |
|
|
} |
|
|
} |
|
|
|
|
|
// Debug function to check database contents |
|
|
export async function debugIndexedDB() { |
|
|
try { |
|
|
const db = await openDB(); |
|
|
const tx = db.transaction(STORE_EVENTS, "readonly"); |
|
|
const store = tx.objectStore(STORE_EVENTS); |
|
|
|
|
|
const allEvents = await new Promise((resolve, reject) => { |
|
|
const req = store.getAll(); |
|
|
req.onsuccess = () => resolve(req.result); |
|
|
req.onerror = () => reject(req.error); |
|
|
}); |
|
|
|
|
|
const byKind = allEvents.reduce((acc, e) => { |
|
|
acc[e.kind] = (acc[e.kind] || 0) + 1; |
|
|
return acc; |
|
|
}, {}); |
|
|
|
|
|
console.log("===== IndexedDB Contents ====="); |
|
|
console.log(`Total events: ${allEvents.length}`); |
|
|
console.log("Events by kind:", byKind); |
|
|
console.log("Kind 0 events:", allEvents.filter(e => e.kind === 0)); |
|
|
console.log("All event IDs:", allEvents.map(e => ({ id: e.id.substring(0, 8), kind: e.kind, pubkey: e.pubkey.substring(0, 8) }))); |
|
|
console.log("=============================="); |
|
|
|
|
|
return { |
|
|
total: allEvents.length, |
|
|
byKind, |
|
|
events: allEvents |
|
|
}; |
|
|
} catch (e) { |
|
|
console.error("Failed to debug IndexedDB:", e); |
|
|
return null; |
|
|
} |
|
|
}
|
|
|
|
