+
+
+
+
+
+
+ {{ identity.profileDisplay.value?.name || 'Anonymous' }}
+ Connected
+
+
+
+
+
+
+
+
-
+
+
+
+
diff --git a/src/components/nostr/IdentityDialog.vue b/src/components/nostr/IdentityDialog.vue
new file mode 100644
index 0000000..ad6b7eb
--- /dev/null
+++ b/src/components/nostr/IdentityDialog.vue
@@ -0,0 +1,453 @@
+
+
+
+
+
diff --git a/src/components/nostr/PasswordDialog.vue b/src/components/nostr/PasswordDialog.vue
new file mode 100644
index 0000000..ff0f25e
--- /dev/null
+++ b/src/components/nostr/PasswordDialog.vue
@@ -0,0 +1,105 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/src/composables/useIdentity.ts b/src/composables/useIdentity.ts
new file mode 100644
index 0000000..ecc3e69
--- /dev/null
+++ b/src/composables/useIdentity.ts
@@ -0,0 +1,193 @@
+import { ref, computed } from 'vue'
+import { IdentityManager, type NostrIdentity, type NostrProfile } from '@/lib/nostr/identity'
+
+const currentIdentity = ref
(null)
+const currentProfile = ref(null)
+const isAuthenticated = computed(() => !!currentIdentity.value)
+
+export function useIdentity() {
+ const isLoading = ref(false)
+ const error = ref(null)
+
+ /**
+ * Initialize identity on app start
+ */
+ async function initialize(password?: string): Promise {
+ try {
+ isLoading.value = true
+ error.value = null
+
+ const identity = await IdentityManager.loadIdentity(password)
+ if (identity) {
+ currentIdentity.value = identity
+ currentProfile.value = IdentityManager.loadProfile()
+ }
+ } catch (err) {
+ error.value = err instanceof Error ? err.message : 'Failed to initialize identity'
+ } finally {
+ isLoading.value = false
+ }
+ }
+
+ /**
+ * Generate new identity
+ */
+ async function generateNewIdentity(password?: string): Promise {
+ try {
+ isLoading.value = true
+ error.value = null
+
+ const identity = IdentityManager.generateIdentity()
+ await IdentityManager.saveIdentity(identity, password)
+
+ currentIdentity.value = identity
+ currentProfile.value = null
+
+ return identity
+ } catch (err) {
+ error.value = err instanceof Error ? err.message : 'Failed to generate identity'
+ throw err
+ } finally {
+ isLoading.value = false
+ }
+ }
+
+ /**
+ * Import existing identity
+ */
+ async function importIdentity(privateKey: string, password?: string): Promise {
+ try {
+ isLoading.value = true
+ error.value = null
+
+ const identity = IdentityManager.importIdentity(privateKey)
+ await IdentityManager.saveIdentity(identity, password)
+
+ currentIdentity.value = identity
+ currentProfile.value = IdentityManager.loadProfile()
+
+ return identity
+ } catch (err) {
+ error.value = err instanceof Error ? err.message : 'Failed to import identity'
+ throw err
+ } finally {
+ isLoading.value = false
+ }
+ }
+
+ /**
+ * Update user profile
+ */
+ async function updateProfile(profile: NostrProfile): Promise {
+ try {
+ isLoading.value = true
+ error.value = null
+
+ IdentityManager.saveProfile(profile)
+ currentProfile.value = profile
+ } catch (err) {
+ error.value = err instanceof Error ? err.message : 'Failed to update profile'
+ throw err
+ } finally {
+ isLoading.value = false
+ }
+ }
+
+ /**
+ * Sign out and clear identity
+ */
+ function signOut(): void {
+ IdentityManager.clearIdentity()
+ currentIdentity.value = null
+ currentProfile.value = null
+ error.value = null
+ }
+
+ /**
+ * Check if identity is stored
+ */
+ function hasStoredIdentity(): boolean {
+ return IdentityManager.hasStoredIdentity()
+ }
+
+ /**
+ * Check if stored identity is encrypted
+ */
+ function isStoredIdentityEncrypted(): boolean {
+ return IdentityManager.isStoredIdentityEncrypted()
+ }
+
+ /**
+ * Load identity with password (for encrypted identities)
+ */
+ async function loadWithPassword(password: string): Promise {
+ try {
+ isLoading.value = true
+ error.value = null
+
+ const identity = await IdentityManager.loadIdentity(password)
+ if (identity) {
+ currentIdentity.value = identity
+ currentProfile.value = IdentityManager.loadProfile()
+ }
+ } catch (err) {
+ error.value = err instanceof Error ? err.message : 'Failed to load identity'
+ throw err
+ } finally {
+ isLoading.value = false
+ }
+ }
+
+ /**
+ * Get current identity info
+ */
+ const identityInfo = computed(() => {
+ if (!currentIdentity.value) return null
+
+ return {
+ npub: currentIdentity.value.npub,
+ publicKey: currentIdentity.value.publicKey,
+ shortPubkey: currentIdentity.value.publicKey.slice(0, 8) + '...' + currentIdentity.value.publicKey.slice(-8)
+ }
+ })
+
+ /**
+ * Get profile display info
+ */
+ const profileDisplay = computed(() => {
+ if (!currentProfile.value && !identityInfo.value) return null
+
+ return {
+ name: currentProfile.value?.name || currentProfile.value?.display_name || identityInfo.value?.shortPubkey || 'Anonymous',
+ displayName: currentProfile.value?.display_name || currentProfile.value?.name,
+ about: currentProfile.value?.about,
+ picture: currentProfile.value?.picture,
+ website: currentProfile.value?.website,
+ lightningAddress: currentProfile.value?.lud16
+ }
+ })
+
+ return {
+ // State
+ currentIdentity: computed(() => currentIdentity.value),
+ currentProfile: computed(() => currentProfile.value),
+ isAuthenticated,
+ isLoading,
+ error,
+ identityInfo,
+ profileDisplay,
+
+ // Actions
+ initialize,
+ generateNewIdentity,
+ importIdentity,
+ updateProfile,
+ signOut,
+ hasStoredIdentity,
+ isStoredIdentityEncrypted,
+ loadWithPassword
+ }
+}
+
+// Export singleton instance for global state
+export const identity = useIdentity()
\ No newline at end of file
diff --git a/src/composables/useSocial.ts b/src/composables/useSocial.ts
new file mode 100644
index 0000000..620f864
--- /dev/null
+++ b/src/composables/useSocial.ts
@@ -0,0 +1,156 @@
+import { ref } from 'vue'
+import { NostrClient, type NostrNote } from '@/lib/nostr/client'
+import { createTextNote, createReaction, createProfileMetadata } from '@/lib/nostr/events'
+import { identity } from '@/composables/useIdentity'
+import { toast } from 'vue-sonner'
+
+export function useSocial(relayUrls: string[]) {
+ const client = new NostrClient({ relays: relayUrls })
+ const isPublishing = ref(false)
+ const profiles = ref(new Map())
+
+ /**
+ * Publish a text note
+ */
+ async function publishNote(content: string, replyTo?: string): Promise {
+ if (!identity.isAuthenticated.value || !identity.currentIdentity.value) {
+ throw new Error('Must be logged in to publish notes')
+ }
+
+ try {
+ isPublishing.value = true
+
+ await client.connect()
+ const event = createTextNote(content, identity.currentIdentity.value, replyTo)
+ await client.publishEvent(event)
+
+ toast.success(replyTo ? 'Reply published!' : 'Note published!')
+ } catch (error) {
+ const message = error instanceof Error ? error.message : 'Failed to publish note'
+ toast.error(message)
+ throw error
+ } finally {
+ isPublishing.value = false
+ }
+ }
+
+ /**
+ * Publish a reaction to a note
+ */
+ async function publishReaction(targetEventId: string, targetAuthor: string, reaction: string = '👍'): Promise {
+ if (!identity.isAuthenticated.value || !identity.currentIdentity.value) {
+ throw new Error('Must be logged in to react to notes')
+ }
+
+ try {
+ await client.connect()
+ const event = createReaction(targetEventId, targetAuthor, reaction, identity.currentIdentity.value)
+ await client.publishEvent(event)
+
+ toast.success('Reaction added!')
+ } catch (error) {
+ const message = error instanceof Error ? error.message : 'Failed to add reaction'
+ toast.error(message)
+ throw error
+ }
+ }
+
+ /**
+ * Publish profile metadata
+ */
+ async function publishProfile(profileData: any): Promise {
+ if (!identity.isAuthenticated.value || !identity.currentIdentity.value) {
+ throw new Error('Must be logged in to update profile')
+ }
+
+ try {
+ isPublishing.value = true
+
+ await client.connect()
+ const event = createProfileMetadata(profileData, identity.currentIdentity.value)
+ await client.publishEvent(event)
+
+ toast.success('Profile updated on Nostr!')
+ } catch (error) {
+ const message = error instanceof Error ? error.message : 'Failed to update profile'
+ toast.error(message)
+ throw error
+ } finally {
+ isPublishing.value = false
+ }
+ }
+
+ /**
+ * Fetch replies to a note
+ */
+ async function fetchReplies(noteId: string): Promise {
+ try {
+ await client.connect()
+ return await client.fetchReplies(noteId)
+ } catch (error) {
+ console.error('Failed to fetch replies:', error)
+ throw error
+ }
+ }
+
+ /**
+ * Fetch and cache user profiles
+ */
+ async function fetchProfiles(pubkeys: string[]): Promise {
+ // Filter out already cached profiles
+ const uncachedPubkeys = pubkeys.filter(pubkey => !profiles.value.has(pubkey))
+
+ if (uncachedPubkeys.length === 0) return
+
+ try {
+ await client.connect()
+ const fetchedProfiles = await client.fetchProfiles(uncachedPubkeys)
+
+ // Update cache
+ fetchedProfiles.forEach((profile, pubkey) => {
+ profiles.value.set(pubkey, profile)
+ })
+ } catch (error) {
+ console.error('Failed to fetch profiles:', error)
+ }
+ }
+
+ /**
+ * Get cached profile or return default
+ */
+ function getProfile(pubkey: string) {
+ return profiles.value.get(pubkey) || {
+ name: pubkey.slice(0, 8) + '...',
+ display_name: undefined,
+ about: undefined,
+ picture: undefined
+ }
+ }
+
+ /**
+ * Get display name for a pubkey
+ */
+ function getDisplayName(pubkey: string): string {
+ const profile = getProfile(pubkey)
+ return profile.display_name || profile.name || pubkey.slice(0, 8) + '...'
+ }
+
+ return {
+ // State
+ isPublishing,
+ profiles,
+
+ // Actions
+ publishNote,
+ publishReaction,
+ publishProfile,
+ fetchReplies,
+ fetchProfiles,
+ getProfile,
+ getDisplayName
+ }
+}
+
+// Export singleton instance for global use
+const relayUrls = JSON.parse(import.meta.env.VITE_NOSTR_RELAYS as string)
+export const social = useSocial(relayUrls)
\ No newline at end of file
diff --git a/src/lib/crypto/encryption.ts b/src/lib/crypto/encryption.ts
new file mode 100644
index 0000000..6a7630f
--- /dev/null
+++ b/src/lib/crypto/encryption.ts
@@ -0,0 +1,134 @@
+/**
+ * Secure encryption utilities using Web Crypto API
+ * Provides AES-GCM encryption for sensitive data storage
+ */
+
+export interface EncryptedData {
+ encryptedData: string
+ iv: string
+ salt: string
+}
+
+export class SecureStorage {
+ private static readonly ALGORITHM = 'AES-GCM'
+ private static readonly KEY_LENGTH = 256
+ private static readonly IV_LENGTH = 12
+ private static readonly SALT_LENGTH = 16
+ private static readonly ITERATIONS = 100000
+
+ /**
+ * Derive encryption key from password using PBKDF2
+ */
+ private static async deriveKey(password: string, salt: Uint8Array): Promise {
+ const encoder = new TextEncoder()
+ const passwordData = encoder.encode(password)
+
+ // Import password as key material
+ const keyMaterial = await crypto.subtle.importKey(
+ 'raw',
+ passwordData,
+ 'PBKDF2',
+ false,
+ ['deriveBits', 'deriveKey']
+ )
+
+ // Derive AES key using PBKDF2
+ return crypto.subtle.deriveKey(
+ {
+ name: 'PBKDF2',
+ salt,
+ iterations: this.ITERATIONS,
+ hash: 'SHA-256'
+ },
+ keyMaterial,
+ {
+ name: this.ALGORITHM,
+ length: this.KEY_LENGTH
+ },
+ false,
+ ['encrypt', 'decrypt']
+ )
+ }
+
+ /**
+ * Encrypt data with password
+ */
+ static async encrypt(data: string, password: string): Promise {
+ try {
+ const encoder = new TextEncoder()
+ const dataBytes = encoder.encode(data)
+
+ // Generate random salt and IV
+ const salt = crypto.getRandomValues(new Uint8Array(this.SALT_LENGTH))
+ const iv = crypto.getRandomValues(new Uint8Array(this.IV_LENGTH))
+
+ // Derive encryption key
+ const key = await this.deriveKey(password, salt)
+
+ // Encrypt the data
+ const encryptedBuffer = await crypto.subtle.encrypt(
+ {
+ name: this.ALGORITHM,
+ iv
+ },
+ key,
+ dataBytes
+ )
+
+ // Convert to base64 for storage
+ return {
+ encryptedData: btoa(String.fromCharCode(...new Uint8Array(encryptedBuffer))),
+ iv: btoa(String.fromCharCode(...iv)),
+ salt: btoa(String.fromCharCode(...salt))
+ }
+ } catch (error) {
+ throw new Error(`Encryption failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
+ }
+ }
+
+ /**
+ * Decrypt data with password
+ */
+ static async decrypt(encryptedData: EncryptedData, password: string): Promise {
+ try {
+ // Convert from base64
+ const encrypted = new Uint8Array(
+ atob(encryptedData.encryptedData).split('').map(c => c.charCodeAt(0))
+ )
+ const iv = new Uint8Array(
+ atob(encryptedData.iv).split('').map(c => c.charCodeAt(0))
+ )
+ const salt = new Uint8Array(
+ atob(encryptedData.salt).split('').map(c => c.charCodeAt(0))
+ )
+
+ // Derive decryption key
+ const key = await this.deriveKey(password, salt)
+
+ // Decrypt the data
+ const decryptedBuffer = await crypto.subtle.decrypt(
+ {
+ name: this.ALGORITHM,
+ iv
+ },
+ key,
+ encrypted
+ )
+
+ // Convert back to string
+ const decoder = new TextDecoder()
+ return decoder.decode(decryptedBuffer)
+ } catch (error) {
+ throw new Error(`Decryption failed: ${error instanceof Error ? error.message : 'Invalid password or corrupted data'}`)
+ }
+ }
+
+ /**
+ * Check if Web Crypto API is available
+ */
+ static isSupported(): boolean {
+ return typeof crypto !== 'undefined' &&
+ typeof crypto.subtle !== 'undefined' &&
+ typeof crypto.getRandomValues !== 'undefined'
+ }
+}
\ No newline at end of file
diff --git a/src/lib/nostr/client.ts b/src/lib/nostr/client.ts
index 7f30922..2749c90 100644
--- a/src/lib/nostr/client.ts
+++ b/src/lib/nostr/client.ts
@@ -1,4 +1,5 @@
-import { SimplePool, type Filter, type Event } from 'nostr-tools'
+import { SimplePool, type Filter, type Event, type UnsignedEvent } from 'nostr-tools'
+import { extractReactions, extractReplyCounts, getReplyInfo, EventKinds } from './events'
export interface NostrClientConfig {
relays: string[]
@@ -6,8 +7,12 @@ export interface NostrClientConfig {
export interface NostrNote extends Event {
// Add any additional note-specific fields we want to track
- replyCount?: number
- reactionCount?: number
+ replyCount: number
+ reactionCount: number
+ reactions: { [reaction: string]: number }
+ isReply: boolean
+ replyTo?: string
+ mentions: string[]
}
export class NostrClient {
@@ -51,23 +56,146 @@ export class NostrClient {
async fetchNotes(options: {
limit?: number
since?: number // Unix timestamp in seconds
+ authors?: string[]
+ includeReplies?: boolean
} = {}): Promise {
- const { limit = 20, since = Math.floor((Date.now() - 24 * 60 * 60 * 1000) / 1000) } = options
+ const {
+ limit = 20,
+ since = Math.floor((Date.now() - 24 * 60 * 60 * 1000) / 1000),
+ authors,
+ includeReplies = false
+ } = options
+ const filters: Filter[] = [
+ {
+ kinds: [EventKinds.TEXT_NOTE],
+ since,
+ limit,
+ ...(authors && { authors })
+ }
+ ]
+
+ // Also fetch reactions and replies for engagement data
+ const engagementFilters: Filter[] = [
+ {
+ kinds: [EventKinds.REACTION, EventKinds.TEXT_NOTE],
+ since,
+ limit: limit * 5 // Get more for engagement calculation
+ }
+ ]
+
+ try {
+ // Get events from all relays
+ const [noteEvents, engagementEvents] = await Promise.all([
+ Promise.all(
+ this.relays.map(async (relay) => {
+ try {
+ return await this.pool.querySync([relay], filters)
+ } catch (error) {
+ console.warn(`Failed to fetch notes from relay ${relay}:`, error)
+ return []
+ }
+ })
+ ),
+ Promise.all(
+ this.relays.map(async (relay) => {
+ try {
+ return await this.pool.querySync([relay], engagementFilters)
+ } catch (error) {
+ console.warn(`Failed to fetch engagement from relay ${relay}:`, error)
+ return []
+ }
+ })
+ )
+ ])
+
+ // Flatten and deduplicate events by ID
+ const uniqueNotes = Array.from(
+ new Map(
+ noteEvents.flat().map(event => [event.id, event])
+ ).values()
+ )
+
+ const allEngagementEvents = engagementEvents.flat()
+
+ // Extract engagement data
+ const reactions = extractReactions(allEngagementEvents)
+ const replyCounts = extractReplyCounts(allEngagementEvents)
+
+ // Process notes with engagement data
+ let processedNotes = uniqueNotes
+ .map((event: Event): NostrNote => {
+ const replyInfo = getReplyInfo(event)
+ const eventReactions = reactions.get(event.id) || {}
+ const reactionCount = Object.values(eventReactions).reduce((sum, count) => sum + count, 0)
+
+ return {
+ ...event,
+ replyCount: replyCounts.get(event.id) || 0,
+ reactionCount,
+ reactions: eventReactions,
+ isReply: replyInfo.isReply,
+ replyTo: replyInfo.replyTo,
+ mentions: replyInfo.mentions
+ }
+ })
+
+ // Filter out replies if not requested
+ if (!includeReplies) {
+ processedNotes = processedNotes.filter(note => !note.isReply)
+ }
+
+ return processedNotes
+ .sort((a: NostrNote, b: NostrNote) => b.created_at - a.created_at) // Sort by newest first
+ .slice(0, limit) // Apply limit after processing
+ } catch (error) {
+ console.error('Failed to fetch notes:', error)
+ throw error
+ }
+ }
+
+ /**
+ * Publish an event to all connected relays
+ */
+ async publishEvent(event: UnsignedEvent): Promise {
+ if (!this._isConnected) {
+ throw new Error('Not connected to any relays')
+ }
+
+ try {
+ const results = await Promise.allSettled(
+ this.relays.map(relay => this.pool.publish([relay], event))
+ )
+
+ const failures = results.filter(result => result.status === 'rejected')
+ if (failures.length === results.length) {
+ throw new Error('Failed to publish to any relay')
+ }
+
+ console.log(`Published event ${event.id} to ${results.length - failures.length}/${results.length} relays`)
+ } catch (error) {
+ console.error('Failed to publish event:', error)
+ throw error
+ }
+ }
+
+ /**
+ * Fetch replies to a specific note
+ */
+ async fetchReplies(noteId: string, limit: number = 50): Promise {
const filter: Filter = {
- kinds: [1], // Regular notes
- since,
+ kinds: [EventKinds.TEXT_NOTE],
+ '#e': [noteId],
limit
}
try {
- // Get events from all relays
const events = await Promise.all(
this.relays.map(async (relay) => {
try {
return await this.pool.querySync([relay], filter)
} catch (error) {
- console.warn(`Failed to fetch from relay ${relay}:`, error)
+ console.warn(`Failed to fetch replies from relay ${relay}:`, error)
return []
}
})
@@ -81,14 +209,70 @@ export class NostrClient {
)
return uniqueEvents
- .sort((a: Event, b: Event) => b.created_at - a.created_at) // Sort by newest first
- .map((event: Event): NostrNote => ({
- ...event,
- replyCount: 0, // We'll implement this later
- reactionCount: 0 // We'll implement this later
- }))
+ .sort((a: Event, b: Event) => a.created_at - b.created_at) // Chronological order for replies
+ .map((event: Event): NostrNote => {
+ const replyInfo = getReplyInfo(event)
+ return {
+ ...event,
+ replyCount: 0, // Individual replies don't need reply counts in this context
+ reactionCount: 0, // We could add this later
+ reactions: {},
+ isReply: replyInfo.isReply,
+ replyTo: replyInfo.replyTo,
+ mentions: replyInfo.mentions
+ }
+ })
} catch (error) {
- console.error('Failed to fetch notes:', error)
+ console.error('Failed to fetch replies:', error)
+ throw error
+ }
+ }
+
+ /**
+ * Fetch user profiles
+ */
+ async fetchProfiles(pubkeys: string[]): Promise> {
+ if (pubkeys.length === 0) return new Map()
+
+ const filter: Filter = {
+ kinds: [EventKinds.PROFILE_METADATA],
+ authors: pubkeys
+ }
+
+ try {
+ const events = await Promise.all(
+ this.relays.map(async (relay) => {
+ try {
+ return await this.pool.querySync([relay], filter)
+ } catch (error) {
+ console.warn(`Failed to fetch profiles from relay ${relay}:`, error)
+ return []
+ }
+ })
+ )
+
+ const profiles = new Map()
+ const allEvents = events.flat()
+
+ // Get the latest profile for each pubkey
+ pubkeys.forEach(pubkey => {
+ const userEvents = allEvents
+ .filter(event => event.pubkey === pubkey)
+ .sort((a, b) => b.created_at - a.created_at)
+
+ if (userEvents.length > 0) {
+ try {
+ const profile = JSON.parse(userEvents[0].content)
+ profiles.set(pubkey, profile)
+ } catch (error) {
+ console.warn(`Failed to parse profile for ${pubkey}:`, error)
+ }
+ }
+ })
+
+ return profiles
+ } catch (error) {
+ console.error('Failed to fetch profiles:', error)
throw error
}
}
@@ -96,7 +280,7 @@ export class NostrClient {
// Subscribe to new notes in real-time
subscribeToNotes(onNote: (note: NostrNote) => void): () => void {
const filters = [{
- kinds: [1],
+ kinds: [EventKinds.TEXT_NOTE],
since: Math.floor(Date.now() / 1000)
}]
@@ -107,10 +291,15 @@ export class NostrClient {
filters,
{
onevent: (event: Event) => {
+ const replyInfo = getReplyInfo(event)
onNote({
...event,
replyCount: 0,
- reactionCount: 0
+ reactionCount: 0,
+ reactions: {},
+ isReply: replyInfo.isReply,
+ replyTo: replyInfo.replyTo,
+ mentions: replyInfo.mentions
})
}
}
diff --git a/src/lib/nostr/events.ts b/src/lib/nostr/events.ts
new file mode 100644
index 0000000..4b25904
--- /dev/null
+++ b/src/lib/nostr/events.ts
@@ -0,0 +1,156 @@
+import { finalizeEvent, type EventTemplate, type UnsignedEvent } from 'nostr-tools'
+import type { NostrIdentity } from './identity'
+import { hexToBytes } from '@/lib/utils/crypto'
+
+/**
+ * Nostr event kinds
+ */
+export const EventKinds = {
+ TEXT_NOTE: 1,
+ REACTION: 7,
+ ZAP: 9735,
+ PROFILE_METADATA: 0,
+ CONTACT_LIST: 3,
+ REPOST: 6,
+ DELETE: 5
+} as const
+
+/**
+ * Create a text note event
+ */
+export function createTextNote(content: string, identity: NostrIdentity, replyTo?: string): UnsignedEvent {
+ const eventTemplate: EventTemplate = {
+ kind: EventKinds.TEXT_NOTE,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [],
+ content
+ }
+
+ // Add reply tags if this is a reply
+ if (replyTo) {
+ eventTemplate.tags.push(['e', replyTo, '', 'reply'])
+ }
+
+ return finalizeEvent(eventTemplate, hexToBytes(identity.privateKey))
+}
+
+/**
+ * Create a reaction event (like/dislike)
+ */
+export function createReaction(
+ targetEventId: string,
+ targetAuthor: string,
+ reaction: string,
+ identity: NostrIdentity
+): UnsignedEvent {
+ const eventTemplate: EventTemplate = {
+ kind: EventKinds.REACTION,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [
+ ['e', targetEventId],
+ ['p', targetAuthor]
+ ],
+ content: reaction
+ }
+
+ return finalizeEvent(eventTemplate, hexToBytes(identity.privateKey))
+}
+
+/**
+ * Create a profile metadata event
+ */
+export function createProfileMetadata(profile: Record, identity: NostrIdentity): UnsignedEvent {
+ const eventTemplate: EventTemplate = {
+ kind: EventKinds.PROFILE_METADATA,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [],
+ content: JSON.stringify(profile)
+ }
+
+ return finalizeEvent(eventTemplate, hexToBytes(identity.privateKey))
+}
+
+/**
+ * Create a contact list event (following)
+ */
+export function createContactList(contacts: string[], identity: NostrIdentity): UnsignedEvent {
+ const eventTemplate: EventTemplate = {
+ kind: EventKinds.CONTACT_LIST,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: contacts.map(pubkey => ['p', pubkey]),
+ content: ''
+ }
+
+ return finalizeEvent(eventTemplate, hexToBytes(identity.privateKey))
+}
+
+/**
+ * Create a delete event
+ */
+export function createDeleteEvent(eventIds: string[], identity: NostrIdentity, reason?: string): UnsignedEvent {
+ const eventTemplate: EventTemplate = {
+ kind: EventKinds.DELETE,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: eventIds.map(id => ['e', id]),
+ content: reason || ''
+ }
+
+ return finalizeEvent(eventTemplate, hexToBytes(identity.privateKey))
+}
+
+/**
+ * Extract reply information from event tags
+ */
+export function getReplyInfo(event: any): { isReply: boolean; replyTo?: string; mentions: string[] } {
+ const eTags = event.tags.filter((tag: string[]) => tag[0] === 'e')
+ const pTags = event.tags.filter((tag: string[]) => tag[0] === 'p')
+
+ // Find reply target (last e tag with "reply" marker or last e tag)
+ const replyTag = eTags.find((tag: string[]) => tag[3] === 'reply') || eTags[eTags.length - 1]
+
+ return {
+ isReply: !!replyTag,
+ replyTo: replyTag?.[1],
+ mentions: pTags.map((tag: string[]) => tag[1])
+ }
+}
+
+/**
+ * Extract reactions from events
+ */
+export function extractReactions(events: any[]): Map {
+ const reactions = new Map()
+
+ events
+ .filter(event => event.kind === EventKinds.REACTION)
+ .forEach(event => {
+ const targetEventId = event.tags.find((tag: string[]) => tag[0] === 'e')?.[1]
+ if (!targetEventId) return
+
+ const reaction = event.content || '👍'
+ const current = reactions.get(targetEventId) || {}
+ current[reaction] = (current[reaction] || 0) + 1
+ reactions.set(targetEventId, current)
+ })
+
+ return reactions
+}
+
+/**
+ * Extract reply counts from events
+ */
+export function extractReplyCounts(events: any[]): Map {
+ const replyCounts = new Map()
+
+ events
+ .filter(event => event.kind === EventKinds.TEXT_NOTE)
+ .forEach(event => {
+ const replyInfo = getReplyInfo(event)
+ if (replyInfo.isReply && replyInfo.replyTo) {
+ const current = replyCounts.get(replyInfo.replyTo) || 0
+ replyCounts.set(replyInfo.replyTo, current + 1)
+ }
+ })
+
+ return replyCounts
+}
\ No newline at end of file
diff --git a/src/lib/nostr/identity.ts b/src/lib/nostr/identity.ts
new file mode 100644
index 0000000..c6d2ac3
--- /dev/null
+++ b/src/lib/nostr/identity.ts
@@ -0,0 +1,210 @@
+import { generateSecretKey, getPublicKey, nip19 } from 'nostr-tools'
+import { SecureStorage, type EncryptedData } from '@/lib/crypto/encryption'
+import { bytesToHex, hexToBytes } from '@/lib/utils/crypto'
+
+export interface NostrIdentity {
+ privateKey: string
+ publicKey: string
+ npub: string
+ nsec: string
+}
+
+export interface NostrProfile {
+ name?: string
+ display_name?: string
+ about?: string
+ picture?: string
+ banner?: string
+ website?: string
+ nip05?: string
+ lud16?: string // Lightning address
+}
+
+export class IdentityManager {
+ private static readonly STORAGE_KEY = 'nostr_identity'
+ private static readonly PROFILE_KEY = 'nostr_profile'
+
+ /**
+ * Generate a new Nostr identity
+ */
+ static generateIdentity(): NostrIdentity {
+ const privateKey = generateSecretKey()
+ const publicKey = getPublicKey(privateKey)
+
+ return {
+ privateKey: bytesToHex(privateKey),
+ publicKey,
+ npub: nip19.npubEncode(publicKey),
+ nsec: nip19.nsecEncode(privateKey)
+ }
+ }
+
+ /**
+ * Import identity from private key (hex or nsec format)
+ */
+ static importIdentity(privateKeyInput: string): NostrIdentity {
+ let privateKeyBytes: Uint8Array
+
+ try {
+ // Try to decode as nsec first
+ if (privateKeyInput.startsWith('nsec')) {
+ const decoded = nip19.decode(privateKeyInput)
+ if (decoded.type === 'nsec') {
+ privateKeyBytes = decoded.data
+ } else {
+ throw new Error('Invalid nsec format')
+ }
+ } else {
+ // Try as hex string
+ if (privateKeyInput.length !== 64) {
+ throw new Error('Private key must be 64 hex characters')
+ }
+ privateKeyBytes = hexToBytes(privateKeyInput)
+ }
+
+ if (privateKeyBytes.length !== 32) {
+ throw new Error('Private key must be 32 bytes')
+ }
+
+ const publicKey = getPublicKey(privateKeyBytes)
+
+ return {
+ privateKey: bytesToHex(privateKeyBytes),
+ publicKey,
+ npub: nip19.npubEncode(publicKey),
+ nsec: nip19.nsecEncode(privateKeyBytes)
+ }
+ } catch (error) {
+ throw new Error(`Failed to import identity: ${error instanceof Error ? error.message : 'Unknown error'}`)
+ }
+ }
+
+ /**
+ * Save identity to localStorage (encrypted)
+ */
+ static async saveIdentity(identity: NostrIdentity, password?: string): Promise {
+ try {
+ let dataToStore: any = identity
+
+ if (password) {
+ if (!SecureStorage.isSupported()) {
+ throw new Error('Secure encryption is not supported in this browser')
+ }
+
+ // Encrypt sensitive data using Web Crypto API
+ const sensitiveData = JSON.stringify({
+ privateKey: identity.privateKey,
+ nsec: identity.nsec
+ })
+
+ const encryptedData = await SecureStorage.encrypt(sensitiveData, password)
+
+ dataToStore = {
+ publicKey: identity.publicKey,
+ npub: identity.npub,
+ encrypted: true,
+ encryptedData
+ }
+ }
+
+ localStorage.setItem(this.STORAGE_KEY, JSON.stringify(dataToStore))
+ } catch (error) {
+ throw new Error(`Failed to save identity: ${error instanceof Error ? error.message : 'Unknown error'}`)
+ }
+ }
+
+ /**
+ * Load identity from localStorage
+ */
+ static async loadIdentity(password?: string): Promise {
+ try {
+ const stored = localStorage.getItem(this.STORAGE_KEY)
+ if (!stored) return null
+
+ const storedData = JSON.parse(stored)
+
+ if (storedData.encrypted && password) {
+ if (!SecureStorage.isSupported()) {
+ throw new Error('Secure encryption is not supported in this browser')
+ }
+
+ // Decrypt sensitive data
+ const decryptedSensitiveData = await SecureStorage.decrypt(storedData.encryptedData, password)
+ const { privateKey, nsec } = JSON.parse(decryptedSensitiveData)
+
+ return {
+ privateKey,
+ publicKey: storedData.publicKey,
+ npub: storedData.npub,
+ nsec
+ }
+ } else if (storedData.encrypted && !password) {
+ throw new Error('Password required to decrypt stored identity')
+ }
+
+ // Non-encrypted identity (legacy support)
+ const identity = storedData as NostrIdentity
+
+ // Validate the loaded identity
+ if (!identity.privateKey || !identity.publicKey) {
+ throw new Error('Invalid stored identity')
+ }
+
+ return identity
+ } catch (error) {
+ console.error('Failed to load identity:', error)
+ throw error
+ }
+ }
+
+ /**
+ * Clear stored identity
+ */
+ static clearIdentity(): void {
+ localStorage.removeItem(this.STORAGE_KEY)
+ localStorage.removeItem(this.PROFILE_KEY)
+ }
+
+ /**
+ * Check if identity exists in storage
+ */
+ static hasStoredIdentity(): boolean {
+ return !!localStorage.getItem(this.STORAGE_KEY)
+ }
+
+ /**
+ * Check if stored identity is encrypted
+ */
+ static isStoredIdentityEncrypted(): boolean {
+ try {
+ const stored = localStorage.getItem(this.STORAGE_KEY)
+ if (!stored) return false
+
+ const storedData = JSON.parse(stored)
+ return !!storedData.encrypted
+ } catch {
+ return false
+ }
+ }
+
+ /**
+ * Save user profile
+ */
+ static saveProfile(profile: NostrProfile): void {
+ localStorage.setItem(this.PROFILE_KEY, JSON.stringify(profile))
+ }
+
+ /**
+ * Load user profile
+ */
+ static loadProfile(): NostrProfile | null {
+ try {
+ const stored = localStorage.getItem(this.PROFILE_KEY)
+ return stored ? JSON.parse(stored) : null
+ } catch (error) {
+ console.error('Failed to load profile:', error)
+ return null
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
index 4c51992..48e9e65 100644
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@@ -13,3 +13,6 @@ export function valueUpdater>(updaterOrValue: T, ref: Ref
? updaterOrValue(ref.value)
: updaterOrValue
}
+
+// Toast function using vue-sonner
+export { toast } from 'vue-sonner'
diff --git a/src/lib/utils/crypto.ts b/src/lib/utils/crypto.ts
new file mode 100644
index 0000000..1a62f52
--- /dev/null
+++ b/src/lib/utils/crypto.ts
@@ -0,0 +1,42 @@
+/**
+ * Crypto utility functions for browser environments
+ */
+
+/**
+ * Convert hex string to Uint8Array
+ */
+export function hexToBytes(hex: string): Uint8Array {
+ if (hex.length % 2 !== 0) {
+ throw new Error('Hex string must have even length')
+ }
+
+ const bytes = hex.match(/.{2}/g)?.map(byte => parseInt(byte, 16))
+ if (!bytes) {
+ throw new Error('Invalid hex string')
+ }
+
+ return new Uint8Array(bytes)
+}
+
+/**
+ * Convert Uint8Array to hex string
+ */
+export function bytesToHex(bytes: Uint8Array): string {
+ return Array.from(bytes)
+ .map(b => b.toString(16).padStart(2, '0'))
+ .join('')
+}
+
+/**
+ * Convert string to Uint8Array
+ */
+export function stringToBytes(str: string): Uint8Array {
+ return new TextEncoder().encode(str)
+}
+
+/**
+ * Convert Uint8Array to string
+ */
+export function bytesToString(bytes: Uint8Array): string {
+ return new TextDecoder().decode(bytes)
+}
\ No newline at end of file