chore: push unfinished changes

package-lock.json

@@ -25,7 +25,7 @@
         "jszip": "3.10.1",
         "lodash": "4.17.21",
         "mui-file-input": "4.0.4",
-        "nostr-tools": "2.3.1",
+        "nostr-tools": "2.7.0",
         "react": "^18.2.0",
         "react-dnd": "16.0.1",
         "react-dnd-html5-backend": "16.0.1",
@@ -34,7 +34,8 @@
         "react-router-dom": "6.22.1",
         "react-toastify": "10.0.4",
         "redux": "5.0.1",
-        "tseep": "1.2.1"
+        "tseep": "1.2.1",
+        "uuid": "10.0.0"
       },
       "devDependencies": {
         "@types/crypto-js": "^4.2.2",
@@ -42,6 +43,7 @@
         "@types/lodash": "4.14.202",
         "@types/react": "^18.2.56",
         "@types/react-dom": "^18.2.19",
+        "@types/uuid": "9.0.8",
         "@typescript-eslint/eslint-plugin": "^7.0.2",
         "@typescript-eslint/parser": "^7.0.2",
         "@vitejs/plugin-react": "^4.2.1",
@@ -2138,6 +2140,12 @@
       "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.3.tgz",
       "integrity": "sha512-EwmlvuaxPNej9+T4v5AuBPJa2x2UOJVdjCtDHgcDqitUeOtjnJKJ+apYjVcAoBEMjKW1VVFGZLUb5+qqa09XFA=="
     },
+    "node_modules/@types/uuid": {
+      "version": "9.0.8",
+      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-9.0.8.tgz",
+      "integrity": "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA==",
+      "dev": true
+    },
     "node_modules/@typescript-eslint/eslint-plugin": {
       "version": "7.1.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-7.1.0.tgz",
@@ -4137,9 +4145,9 @@
       }
     },
     "node_modules/nostr-tools": {
-      "version": "2.3.1",
+      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/nostr-tools/-/nostr-tools-2.3.1.tgz",
+      "resolved": "https://registry.npmjs.org/nostr-tools/-/nostr-tools-2.7.0.tgz",
-      "integrity": "sha512-qjKx2C3EzwiQOe2LPSPyCnp07pGz1pWaWjDXcm+L2y2c8iTECbvlzujDANm3nJUjWL5+LVRUVDovTZ1a/DC4Bg==",
+      "integrity": "sha512-jJoL2J1CBiKDxaXZww27nY/Wsuxzx7AULxmGKFce4sskDu1tohNyfnzYQ8BvDyvkstU8kNZUAXPL32tre33uig==",
       "dependencies": {
         "@noble/ciphers": "^0.5.1",
         "@noble/curves": "1.2.0",
@@ -5211,6 +5219,18 @@
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
     },
+    "node_modules/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
     "node_modules/v8-compile-cache-lib": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",

package.json

@@ -31,7 +31,7 @@
     "jszip": "3.10.1",
     "lodash": "4.17.21",
     "mui-file-input": "4.0.4",
-    "nostr-tools": "2.3.1",
+    "nostr-tools": "2.7.0",
     "react": "^18.2.0",
     "react-dnd": "16.0.1",
     "react-dnd-html5-backend": "16.0.1",
@@ -40,7 +40,8 @@
     "react-router-dom": "6.22.1",
     "react-toastify": "10.0.4",
     "redux": "5.0.1",
-    "tseep": "1.2.1"
+    "tseep": "1.2.1",
+    "uuid": "10.0.0"
   },
   "devDependencies": {
     "@types/crypto-js": "^4.2.2",
@@ -48,6 +49,7 @@
     "@types/lodash": "4.14.202",
     "@types/react": "^18.2.56",
     "@types/react-dom": "^18.2.19",
+    "@types/uuid": "9.0.8",
     "@typescript-eslint/eslint-plugin": "^7.0.2",
     "@typescript-eslint/parser": "^7.0.2",
     "@vitejs/plugin-react": "^4.2.1",

src/components/username.tsx

@@ -1,9 +1,9 @@
-import { Typography, IconButton, Box, useTheme } from '@mui/material'
+import { Box, IconButton, Typography, useTheme } from '@mui/material'
 import { useSelector } from 'react-redux'
+import { useNavigate } from 'react-router-dom'
+import { getProfileRoute } from '../routes'
 import { State } from '../store/rootReducer'
 import { hexToNpub } from '../utils'
-import { Link } from 'react-router-dom'
-import { getProfileRoute } from '../routes'
 
 type Props = {
   username: string
@@ -60,6 +60,7 @@ type UserProps = {
  */
 export const UserComponent = ({ pubkey, name, image }: UserProps) => {
   const theme = useTheme()
+  const navigate = useNavigate()
 
   const npub = hexToNpub(pubkey)
   const roboImage = `https://robohash.org/${npub}.png?set=set3`
@@ -67,6 +68,10 @@ export const UserComponent = ({ pubkey, name, image }: UserProps) => {
   return (
     <Box
       sx={{ display: 'flex', alignItems: 'center', gap: '10px', flexGrow: 1 }}
+      onClick={(e) => {
+        e.stopPropagation()
+        navigate(getProfileRoute(pubkey))
+      }}
     >
       <img
         src={image || roboImage}
@@ -78,7 +83,6 @@ export const UserComponent = ({ pubkey, name, image }: UserProps) => {
           borderColor: `#${pubkey.substring(0, 6)}`
         }}
       />
-      <Link to={getProfileRoute(pubkey)}>
       <Typography
         component="label"
         sx={{
@@ -89,7 +93,6 @@ export const UserComponent = ({ pubkey, name, image }: UserProps) => {
       >
         {name}
       </Typography>
-      </Link>
     </Box>
   )
 }

src/controllers/MetadataController.ts

@@ -46,6 +46,7 @@ export class MetadataController extends EventEmitter {
 
     const pool = new SimplePool()
 
+    // todo: use nostrController to get event
     // Try to get the metadata event from a special relay (wss://purplepag.es)
     const metadataEvent = await pool
       .get([this.specialMetadataRelay], eventFilter)
@@ -68,6 +69,7 @@ export class MetadataController extends EventEmitter {
       }
     }
 
+    // todo use nostr controller to find event from connected relays
     // If no valid metadata event is found from the special relay, get the most popular relays
     const mostPopularRelays = await this.nostrController.getMostPopularRelays()
 
@@ -141,6 +143,22 @@ export class MetadataController extends EventEmitter {
   }
 
   public findRelayListMetadata = async (hexKey: string) => {
+    let relayEvent: Event | null = null
+
+    // Attempt to retrieve the metadata event from the local cache
+    const cachedRelayListMetadataEvent =
+      await localCache.getUserRelayListMetadata(hexKey)
+
+    if (cachedRelayListMetadataEvent) {
+      const oneWeekInMS = 7 * 24 * 60 * 60 * 1000 // Number of milliseconds in one week
+
+      // Check if the cached event is not older than one week
+      if (Date.now() - cachedRelayListMetadataEvent.cachedAt < oneWeekInMS) {
+        relayEvent = cachedRelayListMetadataEvent.event
+      }
+    }
+
+    // define filter for relay list
     const eventFilter: Filter = {
       kinds: [kinds.RelayList],
       authors: [hexKey]
@@ -148,19 +166,38 @@ export class MetadataController extends EventEmitter {
 
     const pool = new SimplePool()
 
-    let relayEvent = await pool
+    // Try to get the relayList event from a special relay (wss://purplepag.es)
+    if (!relayEvent) {
+      relayEvent = await pool
         .get([this.specialMetadataRelay], eventFilter)
+        .then((event) => {
+          if (event) {
+            // update the event in local cache
+            localCache.addUserRelayListMetadata(event)
+          }
+          return event
+        })
         .catch((err) => {
           console.error(err)
           return null
         })
+    }
 
     if (!relayEvent) {
+      // If no valid relayList event is found from the special relay, get the most popular relays
       const mostPopularRelays =
         await this.nostrController.getMostPopularRelays()
 
+      // Query the most popular relays for relayList event
       relayEvent = await pool
         .get(mostPopularRelays, eventFilter)
+        .then((event) => {
+          if (event) {
+            // update the event in local cache
+            localCache.addUserRelayListMetadata(event)
+          }
+          return event
+        })
         .catch((err) => {
           console.error(err)
           return null

src/controllers/NostrController.ts

@@ -2,46 +2,50 @@ import NDK, {
   NDKEvent,
   NDKNip46Signer,
   NDKPrivateKeySigner,
+  NDKSubscription,
   NDKUser,
-  NostrEvent,
+  NostrEvent
-  NDKSubscription
 } from '@nostr-dev-kit/ndk'
+import axios from 'axios'
 import {
   Event,
   EventTemplate,
-  SimplePool,
-  UnsignedEvent,
   Filter,
   Relay,
+  SimplePool,
+  UnsignedEvent,
   finalizeEvent,
+  kinds,
   nip04,
   nip19,
-  kinds
+  nip44
 } from 'nostr-tools'
+import { toast } from 'react-toastify'
 import { EventEmitter } from 'tseep'
 import {
-  updateNsecbunkerPubkey,
   setMostPopularRelaysAction,
+  setRelayConnectionStatusAction,
   setRelayInfoAction,
-  setRelayConnectionStatusAction
+  updateNsecbunkerPubkey
 } from '../store/actions'
 import { AuthState, LoginMethods } from '../store/auth/types'
 import store from '../store/store'
 import {
-  SignedEvent,
+  RelayConnectionState,
-  RelayMap,
-  RelayStats,
-  RelayReadStats,
-  RelayInfoObject,
   RelayConnectionStatus,
-  RelayConnectionState
+  RelayInfoObject,
+  RelayMap,
+  RelayReadStats,
+  RelayStats,
+  Rumor,
+  SignedEvent
 } from '../types'
 import {
   compareObjects,
   getNsecBunkerDelegatedKey,
+  randomNow,
   verifySignedEvent
 } from '../utils'
-import axios from 'axios'
 
 export class NostrController extends EventEmitter {
   private static instance: NostrController
@@ -56,7 +60,8 @@ export class NostrController extends EventEmitter {
   }
 
   private getNostrObject = () => {
-    if (window.nostr) return window.nostr
+    // fix: this is not picking up type declaration from src/system/index.d.ts
+    if (window.nostr) return window.nostr as any
 
     throw new Error(
       `window.nostr object not present. Make sure you have an nostr extension installed/working properly.`
@@ -260,6 +265,157 @@ export class NostrController extends EventEmitter {
     return publishedRelays
   }
 
+  /**
+   * Asynchronously retrieves an event from a set of relays based on a provided filter.
+   * If no relays are specified, it defaults to using connected relays.
+   *
+   * @param {Filter} filter - The filter criteria to find the event.
+   * @param {string[]} [relays] - An optional array of relay URLs to search for the event.
+   * @returns {Promise<Event | null>} - Returns a promise that resolves to the found event or null if not found.
+   */
+  getEvent = async (
+    filter: Filter,
+    relays?: string[]
+  ): Promise<Event | null> => {
+    // If no relays are provided or the provided array is empty, use connected relays if available.
+    if (!relays || relays.length === 0) {
+      relays = this.connectedRelays
+        ? this.connectedRelays.map((relay) => relay.url)
+        : []
+    }
+
+    // If still no relays are available, reject the promise with an error message.
+    if (relays.length === 0) {
+      return Promise.reject('Provide some relays to find the event')
+    }
+
+    // Create a new instance of SimplePool to handle the relay connections and event retrieval.
+    const pool = new SimplePool()
+
+    // Attempt to retrieve the event from the specified relays using the filter criteria.
+    const event = await pool.get(relays, filter).catch((err) => {
+      // Log any errors that occur during the event retrieval process.
+      console.log('An error occurred in finding the event', err)
+      // Show an error toast notification to the user.
+      toast.error('An error occurred in finding the event')
+      // Return null if an error occurs, indicating that no event was found.
+      return null
+    })
+
+    // Return the found event, or null if an error occurred.
+    return event
+  }
+
+  createSeal = async (rumor: Rumor, receiver: string) => {
+    const encryptedContent = await this.nip44Encrypt(
+      receiver,
+      JSON.stringify(rumor)
+    )
+
+    const unsignedEvent: UnsignedEvent = {
+      kind: 13,
+      content: encryptedContent,
+      created_at: randomNow(),
+      tags: [],
+      pubkey: (store.getState().auth as AuthState).usersPubkey!
+    }
+
+    const signedEvent = await this.signEvent(unsignedEvent)
+    return signedEvent
+  }
+
+  nip44Encrypt = async (receiver: string, content: string) => {
+    const loginMethod = (store.getState().auth as AuthState).loginMethod
+
+    if (loginMethod === LoginMethods.extension) {
+      const nostr = this.getNostrObject()
+
+      if (!nostr.nip44) {
+        throw new Error(
+          `Your nostr extension does not support nip44 encryption & decryption`
+        )
+      }
+
+      const encrypted = await nostr.nip44.encrypt(receiver, content)
+      return encrypted as string
+    }
+
+    if (loginMethod === LoginMethods.privateKey) {
+      const keys = (store.getState().auth as AuthState).keyPair
+
+      if (!keys) {
+        throw new Error(
+          `Login method is ${LoginMethods.privateKey} but private & public key pair is not found.`
+        )
+      }
+
+      const { private: nsec } = keys
+      const privateKey = nip19.decode(nsec).data as Uint8Array
+
+      const nip44ConversationKey = nip44.v2.utils.getConversationKey(
+        privateKey,
+        receiver
+      )
+      const encrypted = nip44.v2.encrypt(content, nip44ConversationKey)
+
+      return encrypted
+    }
+
+    if (loginMethod === LoginMethods.nsecBunker) {
+      throw new Error(
+        `nip44 encryption is not yet supported for login method '${LoginMethods.nsecBunker}'`
+      )
+    }
+
+    throw new Error('Login method is undefined')
+  }
+
+  nip44Decrypt = async (sender: string, content: string) => {
+    const loginMethod = (store.getState().auth as AuthState).loginMethod
+
+    if (loginMethod === LoginMethods.extension) {
+      const nostr = this.getNostrObject()
+
+      if (!nostr.nip44) {
+        throw new Error(
+          `Your nostr extension does not support nip44 encryption & decryption`
+        )
+      }
+
+      const decrypted = await nostr.nip44.decrypt(sender, content)
+      return decrypted as string
+    }
+
+    if (loginMethod === LoginMethods.privateKey) {
+      const keys = (store.getState().auth as AuthState).keyPair
+
+      if (!keys) {
+        throw new Error(
+          `Login method is ${LoginMethods.privateKey} but private & public key pair is not found.`
+        )
+      }
+
+      const { private: nsec } = keys
+      const privateKey = nip19.decode(nsec).data as Uint8Array
+
+      const nip44ConversationKey = nip44.v2.utils.getConversationKey(
+        privateKey,
+        sender
+      )
+      const decrypted = nip44.v2.decrypt(content, nip44ConversationKey)
+
+      return decrypted
+    }
+
+    if (loginMethod === LoginMethods.nsecBunker) {
+      throw new Error(
+        `nip44 decryption is not yet supported for login method '${LoginMethods.nsecBunker}'`
+      )
+    }
+
+    throw new Error('Login method is undefined')
+  }
+
   /**
    * Signs an event with private key (if it is present in local storage) or
    * with browser extension (if it is present) or
@@ -330,7 +486,7 @@ export class NostrController extends EventEmitter {
     }
   }
 
-  nip04Encrypt = async (receiver: string, content: string) => {
+  nip04Encrypt = async (receiver: string, content: string): Promise<string> => {
     const loginMethod = (store.getState().auth as AuthState).loginMethod
 
     if (loginMethod === LoginMethods.extension) {
@@ -385,7 +541,7 @@ export class NostrController extends EventEmitter {
    * @param content - The encrypted content to decrypt.
    * @returns A promise that resolves to the decrypted content.
    */
-  nip04Decrypt = async (sender: string, content: string) => {
+  nip04Decrypt = async (sender: string, content: string): Promise<string> => {
     const loginMethod = (store.getState().auth as AuthState).loginMethod
 
     if (loginMethod === LoginMethods.extension) {

src/layouts/Main.tsx

@@ -10,7 +10,8 @@ import {
   clearState,
   getRoboHashPicture,
   loadState,
-  saveNsecBunkerDelegatedKey
+  saveNsecBunkerDelegatedKey,
+  subscribeForSigits
 } from '../utils'
 import { LoadingSpinner } from '../components/LoadingSpinner'
 import { Dispatch } from '../store/store'
@@ -100,6 +101,8 @@ export const MainLayout = () => {
 
       if (pubkey) {
         dispatch(setUserRobotImage(getRoboHashPicture(pubkey)))
+
+        subscribeForSigits(pubkey)
       }
     }
   }, [authState])

src/pages/create/index.tsx

@@ -18,12 +18,18 @@ import {
   Tooltip,
   Typography
 } from '@mui/material'
+import type { Identifier, XYCoord } from 'dnd-core'
+import saveAs from 'file-saver'
 import JSZip from 'jszip'
 import { MuiFileInput } from 'mui-file-input'
-import { useEffect, useRef, useState } from 'react'
+import { Event, kinds } from 'nostr-tools'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { DndProvider, useDrag, useDrop } from 'react-dnd'
+import { HTML5Backend } from 'react-dnd-html5-backend'
 import { useSelector } from 'react-redux'
 import { useLocation, useNavigate } from 'react-router-dom'
 import { toast } from 'react-toastify'
+import { v4 as uuidV4 } from 'uuid'
 import { LoadingSpinner } from '../../components/LoadingSpinner'
 import { UserComponent } from '../../components/username'
 import { MetadataController, NostrController } from '../../controllers'
@@ -33,24 +39,21 @@ import { Meta, ProfileMetadata, User, UserRole } from '../../types'
 import {
   encryptArrayBuffer,
   generateEncryptionKey,
+  generateKeys,
   generateKeysFile,
   getHash,
   hexToNpub,
   isOnline,
+  now,
   npubToHex,
   queryNip05,
-  sendDM,
+  sendNotification,
   shorten,
   signEventForMetaFile,
+  updateUsersAppData,
   uploadToFileStorage
 } from '../../utils'
 import styles from './style.module.scss'
-import { DndProvider } from 'react-dnd'
-import { HTML5Backend } from 'react-dnd-html5-backend'
-import type { Identifier, XYCoord } from 'dnd-core'
-import { useDrag, useDrop } from 'react-dnd'
-import saveAs from 'file-saver'
-import { Event, kinds } from 'nostr-tools'
 
 export const CreatePage = () => {
   const navigate = useNavigate()
@@ -75,6 +78,15 @@ export const CreatePage = () => {
 
   const nostrController = NostrController.getInstance()
 
+  // Set up event listener for authentication event
+  nostrController.on('nsecbunker-auth', (url) => {
+    setAuthUrl(url)
+  })
+
+  const uuid = useMemo(() => {
+    return uuidV4()
+  }, [])
+
   useEffect(() => {
     if (uploadedFile) {
       setSelectedFiles([uploadedFile])
@@ -283,16 +295,28 @@ export const CreatePage = () => {
     return fileHashes
   }
 
-  // Create a zip file with the selected files and sign the event
+  // initialize a zip file with the selected files and generate creator's signature
-  const createZipFile = async (fileHashes: {
+  const initZipFileAndCreatorSignature = async (
+    encryptionKey: string,
+    fileHashes: {
       [key: string]: string
-  }): Promise<{ zip: JSZip; createSignature: string } | null> => {
+    }
+  ): Promise<{ zip: JSZip; createSignature: string } | null> => {
     const zip = new JSZip()
 
     selectedFiles.forEach((file) => {
       zip.file(`files/${file.name}`, file)
     })
 
+    // generate key pairs for decryption
+    const pubkeys = users.map((user) => user.pubkey)
+    // also add creator in the list
+    if (pubkeys.includes(usersPubkey!)) {
+      pubkeys.push(usersPubkey!)
+    }
+
+    const keys = await generateKeys(pubkeys, encryptionKey)
+
     const signers = users.filter((user) => user.role === UserRole.signer)
     const viewers = users.filter((user) => user.role === UserRole.viewer)
 
@@ -302,7 +326,8 @@ export const CreatePage = () => {
       JSON.stringify({
         signers: signers.map((signer) => hexToNpub(signer.pubkey)),
         viewers: viewers.map((viewer) => hexToNpub(viewer.pubkey)),
-        fileHashes
+        fileHashes,
+        keys
       }),
       nostrController,
       setIsLoading
@@ -320,38 +345,6 @@ export const CreatePage = () => {
     }
   }
 
-  // Add metadata and file hashes to the zip file
-  const addMetaToZip = async (
-    zip: JSZip,
-    createSignature: string
-  ): Promise<string | null> => {
-    // create content for meta file
-    const meta: Meta = {
-      title,
-      createSignature,
-      docSignatures: {}
-    }
-
-    try {
-      const stringifiedMeta = JSON.stringify(meta, null, 2)
-      zip.file('meta.json', stringifiedMeta)
-
-      const metaHash = await getHash(stringifiedMeta)
-      if (!metaHash) return null
-
-      const metaHashJson = {
-        [usersPubkey!]: metaHash
-      }
-
-      zip.file('hashes.json', JSON.stringify(metaHashJson, null, 2))
-      return metaHash
-    } catch (err) {
-      console.error(err)
-      toast.error('An error occurred in converting meta json to string')
-      return null
-    }
-  }
-
   // Handle errors during zip file generation
   const handleZipError = (err: any) => {
     console.log('Error in zip:>> ', err)
@@ -390,7 +383,7 @@ export const CreatePage = () => {
     encryptionKey: string
   ): Promise<File | null> => {
     // Get the current timestamp in seconds
-    const unixNow = Math.floor(Date.now() / 1000)
+    const unixNow = now()
     const blob = new Blob([encryptedArrayBuffer])
     // Create a File object with the Blob data
     const file = new File([blob], `compressed.sigit`, {
@@ -432,9 +425,9 @@ export const CreatePage = () => {
 
   const handleOnlineFlow = async (
     encryptedArrayBuffer: ArrayBuffer,
-    encryptionKey: string
+    meta: Meta
   ) => {
-    const unixNow = Math.floor(Date.now() / 1000)
+    const unixNow = now()
     const blob = new Blob([encryptedArrayBuffer])
     // Create a File object with the Blob data
     const file = new File([blob], `compressed-${unixNow}.sigit`, {
@@ -444,7 +437,12 @@ export const CreatePage = () => {
     const fileUrl = await uploadFile(file)
     if (!fileUrl) return
 
-    await sendDMs(fileUrl, encryptionKey)
+    const updatedEvent = await updateUsersAppData(fileUrl, meta)
+    if (!updatedEvent) return
+
+    await sendDMs(fileUrl, meta)
+
+    navigate(appPrivateRoutes.sign, { state: { sigit: { fileUrl, meta } } })
   }
 
   // Handle errors during file upload
@@ -471,33 +469,21 @@ export const CreatePage = () => {
   }
 
   // Send DMs to signers and viewers with the file URL
-  const sendDMs = async (fileUrl: string, encryptionKey: string) => {
+  const sendDMs = async (fileUrl: string, meta: Meta) => {
     setLoadingSpinnerDesc('Sending DM to signers/viewers')
 
     const signers = users.filter((user) => user.role === UserRole.signer)
     const viewers = users.filter((user) => user.role === UserRole.viewer)
 
-    if (signers.length > 0) {
+    const receivers =
-      await sendDM(
+      signers.length > 0
-        fileUrl,
+        ? [signers[0].pubkey]
-        encryptionKey,
+        : viewers.map((viewer) => viewer.pubkey)
-        signers[0].pubkey,
+
-        nostrController,
+    const promises = receivers.map((receiver) =>
-        true,
+      sendNotification(receiver, meta, fileUrl)
-        setAuthUrl
     )
-    } else {
+    await Promise.allSettled(promises)
-      for (const viewer of viewers) {
-        await sendDM(
-          fileUrl,
-          encryptionKey,
-          viewer.pubkey,
-          nostrController,
-          false,
-          setAuthUrl
-        )
-      }
-    }
   }
 
   // Manage offline scenarios for signing or viewing the file
@@ -524,21 +510,30 @@ export const CreatePage = () => {
     const fileHashes = await generateFileHashes()
     if (!fileHashes) return
 
-    const createZipResponse = await createZipFile(fileHashes)
+    const encryptionKey = await generateEncryptionKey()
+
+    const createZipResponse = await initZipFileAndCreatorSignature(
+      encryptionKey,
+      fileHashes
+    )
     if (!createZipResponse) return
 
     const { zip, createSignature } = createZipResponse
 
-    const metaHash = await addMetaToZip(zip, createSignature)
+    // create content for meta file
-    if (!metaHash) return
+    const meta: Meta = {
+      uuid,
+      title,
+      modifiedAt: now(),
+      createSignature,
+      docSignatures: {}
+    }
 
     setLoadingSpinnerDesc('Generating zip file')
 
     const arrayBuffer = await generateZipFile(zip)
     if (!arrayBuffer) return
 
-    const encryptionKey = await generateEncryptionKey()
-
     setLoadingSpinnerDesc('Encrypting zip file')
     const encryptedArrayBuffer = await encryptZipFile(
       arrayBuffer,
@@ -546,12 +541,11 @@ export const CreatePage = () => {
     )
 
     if (await isOnline()) {
-      await handleOnlineFlow(encryptedArrayBuffer, encryptionKey)
+      await handleOnlineFlow(encryptedArrayBuffer, meta)
     } else {
+      // todo: fix offline flow
       await handleOfflineFlow(encryptedArrayBuffer, encryptionKey)
     }
-
-    navigate(appPrivateRoutes.sign, { state: { arrayBuffer } })
   }
 
   if (authUrl) {

src/pages/home/index.tsx

@@ -1,21 +1,59 @@
-import {
+import { Add, CalendarMonth, Description, Upload } from '@mui/icons-material'
-  Add,
-  CalendarMonth,
-  Description,
-  PersonOutline,
-  Upload
-} from '@mui/icons-material'
 import { Box, Button, Tooltip, Typography } from '@mui/material'
+import JSZip from 'jszip'
+import { Dispatch, SetStateAction, useEffect, useRef, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
+import { toast } from 'react-toastify'
 import { appPrivateRoutes, appPublicRoutes } from '../../routes'
 import styles from './style.module.scss'
-import { useRef } from 'react'
+import { MetadataController, NostrController } from '../../controllers'
-import JSZip from 'jszip'
+import {
-import { toast } from 'react-toastify'
+  formatTimestamp,
+  getUsersAppData,
+  hexToNpub,
+  npubToHex,
+  parseJson,
+  shorten
+} from '../../utils'
+import { LoadingSpinner } from '../../components/LoadingSpinner'
+import {
+  CreateSignatureEventContent,
+  Meta,
+  ProfileMetadata,
+  Sigit
+} from '../../types'
+import { Event, kinds, verifyEvent } from 'nostr-tools'
+import { UserComponent } from '../../components/username'
 
 export const HomePage = () => {
   const navigate = useNavigate()
   const fileInputRef = useRef<HTMLInputElement>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [loadingSpinnerDesc] = useState(`Finding user's app data`)
+  const [authUrl, setAuthUrl] = useState<string>()
+  const [sigits, setSigits] = useState<Sigit[]>([])
+
+  const [profiles, setProfiles] = useState<{ [key: string]: ProfileMetadata }>(
+    {}
+  )
+
+  useEffect(() => {
+    const nostrController = NostrController.getInstance()
+    // Set up event listener for authentication event
+    nostrController.on('nsecbunker-auth', (url) => {
+      setAuthUrl(url)
+    })
+
+    getUsersAppData()
+      .then((res) => {
+        if (res) {
+          setSigits(Object.values(res))
+        }
+      })
+      .finally(() => {
+        setIsLoading(false)
+      })
+  }, [])
 
   const handleUploadClick = () => {
     if (fileInputRef.current) {
@@ -63,7 +101,20 @@ export const HomePage = () => {
     }
   }
 
+  if (authUrl) {
     return (
+      <iframe
+        title="Nsecbunker auth"
+        src={authUrl}
+        width="100%"
+        height="500px"
+      />
+    )
+  }
+
+  return (
+    <>
+      {isLoading && <LoadingSpinner desc={loadingSpinnerDesc} />}
       <Box className={styles.container}>
         <Box className={styles.header}>
           <Typography variant="h3" className={styles.title}>
@@ -129,15 +180,114 @@ export const HomePage = () => {
           </Box>
         </Box>
         <Box className={styles.submissions}>
-        <PlaceHolder />
+          {sigits.map((sigit) => (
-        <PlaceHolder />
+            <DisplaySigit
-        <PlaceHolder />
+              key={sigit.meta.uuid}
+              sigit={sigit}
+              profiles={profiles}
+              setProfiles={setProfiles}
+            />
+          ))}
         </Box>
       </Box>
+    </>
   )
 }
 
-const PlaceHolder = () => {
+type SigitProps = {
+  sigit: Sigit
+  profiles: { [key: string]: ProfileMetadata }
+  setProfiles: Dispatch<SetStateAction<{ [key: string]: ProfileMetadata }>>
+}
+
+const DisplaySigit = ({ sigit, profiles, setProfiles }: SigitProps) => {
+  const navigate = useNavigate()
+
+  const [createdAt, setCreatedAt] = useState('')
+  const [submittedBy, setSubmittedBy] = useState<string>()
+  const [signers, setSigners] = useState<`npub1${string}`[]>([])
+
+  useEffect(() => {
+    const extractInfo = async () => {
+      const createSignatureEvent = await parseJson<Event>(
+        sigit.meta.createSignature
+      ).catch((err) => {
+        console.log('err in parsing the createSignature event:>> ', err)
+        toast.error(
+          err.message || 'error occurred in parsing the create signature event'
+        )
+        return null
+      })
+
+      if (!createSignatureEvent) return
+
+      // created_at in nostr events are stored in seconds
+      // convert it to ms before formatting
+      setCreatedAt(formatTimestamp(createSignatureEvent.created_at * 1000))
+
+      const createSignatureContent =
+        await parseJson<CreateSignatureEventContent>(
+          createSignatureEvent.content
+        ).catch((err) => {
+          console.log(
+            `err in parsing the createSignature event's content :>> `,
+            err
+          )
+          return null
+        })
+
+      if (!createSignatureContent) return
+
+      setSubmittedBy(createSignatureEvent.pubkey)
+      setSigners(createSignatureContent.signers)
+    }
+    extractInfo()
+  }, [sigit])
+
+  useEffect(() => {
+    const hexKeys: string[] = []
+
+    if (submittedBy) {
+      hexKeys.push(npubToHex(submittedBy)!)
+    }
+    hexKeys.push(...signers.map((signer) => npubToHex(signer)!))
+
+    const metadataController = new MetadataController()
+    hexKeys.forEach((key) => {
+      if (!(key in profiles)) {
+        const handleMetadataEvent = (event: Event) => {
+          const metadataContent =
+            metadataController.extractProfileMetadataContent(event)
+
+          if (metadataContent)
+            setProfiles((prev) => ({
+              ...prev,
+              [key]: metadataContent
+            }))
+        }
+
+        metadataController.on(key, (kind: number, event: Event) => {
+          if (kind === kinds.Metadata) {
+            handleMetadataEvent(event)
+          }
+        })
+
+        metadataController
+          .findMetadata(key)
+          .then((metadataEvent) => {
+            if (metadataEvent) handleMetadataEvent(metadataEvent)
+          })
+          .catch((err) => {
+            console.error(`error occurred in finding metadata for: ${key}`, err)
+          })
+      }
+    })
+  }, [submittedBy, signers])
+
+  const handleNavigation = () => {
+    navigate(appPrivateRoutes.sign, { state: { sigit } })
+  }
+
   return (
     <Box
       className={styles.item}
@@ -147,14 +297,11 @@ const PlaceHolder = () => {
           md: 'row'
         }
       }}
+      onClick={handleNavigation}
     >
       <Box
         className={styles.titleBox}
         sx={{
-          flexDirection: {
-            xs: 'row',
-            md: 'column'
-          },
           borderBottomLeftRadius: {
             xs: 'initial',
             md: 'inherit'
@@ -165,33 +312,101 @@ const PlaceHolder = () => {
           }
         }}
       >
-        <Typography variant="body1" className={styles.titleBoxItem}>
+        <Typography variant="body1" className={styles.title}>
           <Description />
-          Title
+          {sigit.meta.title}
         </Typography>
-        <Typography variant="body2" className={styles.titleBoxItem}>
+        {submittedBy &&
-          <PersonOutline />
+          (function () {
-          Sigit
+            const profile = profiles[submittedBy]
-        </Typography>
+            return (
-        <Typography variant="body2" className={styles.titleBoxItem}>
+              <UserComponent
+                pubkey={submittedBy}
+                name={
+                  profile?.display_name ||
+                  profile?.name ||
+                  shorten(hexToNpub(submittedBy))
+                }
+                image={profile?.picture}
+              />
+            )
+          })()}
+        <Typography variant="body2" className={styles.date}>
           <CalendarMonth />
-          07 Jun 10:23 AM
+          {createdAt}
         </Typography>
       </Box>
       <Box className={styles.signers}>
-        <Box className={styles.signerItem}>
+        {signers.map((signer) => {
-          <Typography variant="button" className={styles.status}>
+          const pubkey = npubToHex(signer)!
-            Sent
+          const profile = profiles[pubkey]
-          </Typography>
+
-          <Typography variant="body1">placeholder@sigit.io</Typography>
+          return (
-        </Box>
+            <DisplaySigner
-        <Box className={styles.signerItem}>
+              key={signer}
-          <Typography variant="button" className={styles.status}>
+              meta={sigit.meta}
-            Awaiting
+              profile={profile}
-          </Typography>
+              pubkey={pubkey}
-          <Typography variant="body1">placeholder@sigit.io</Typography>
+            />
-        </Box>
+          )
+        })}
       </Box>
     </Box>
   )
 }
+
+enum SignStatus {
+  Signed = 'Signed',
+  Pending = 'Pending',
+  Invalid = 'Invalid Sign'
+}
+
+type DisplaySignerProps = {
+  meta: Meta
+  profile: ProfileMetadata
+  pubkey: string
+}
+
+const DisplaySigner = ({ meta, profile, pubkey }: DisplaySignerProps) => {
+  const [signStatus, setSignedStatus] = useState<SignStatus>()
+
+  useEffect(() => {
+    const updateSignStatus = async () => {
+      const npub = hexToNpub(pubkey)
+      if (npub in meta.docSignatures) {
+        parseJson<Event>(meta.docSignatures[npub])
+          .then((event) => {
+            const isValidSignature = verifyEvent(event)
+            if (isValidSignature) {
+              setSignedStatus(SignStatus.Signed)
+            } else {
+              setSignedStatus(SignStatus.Invalid)
+            }
+          })
+          .catch((err) => {
+            console.log(`err in parsing the docSignatures for ${npub}:>> `, err)
+            setSignedStatus(SignStatus.Invalid)
+          })
+      } else {
+        setSignedStatus(SignStatus.Pending)
+      }
+    }
+
+    updateSignStatus()
+  }, [meta, pubkey])
+
+  return (
+    <Box className={styles.signerItem}>
+      <Typography variant="button" className={styles.status}>
+        {signStatus}
+      </Typography>
+      <UserComponent
+        pubkey={pubkey}
+        name={
+          profile?.display_name || profile?.name || shorten(hexToNpub(pubkey))
+        }
+        image={profile?.picture}
+      />
+    </Box>
+  )
+}

src/pages/home/style.module.scss

@@ -28,23 +28,38 @@
 
     .item {
       display: flex;
+      gap: 10px;
       background-color: #efeae6;
       border-radius: 1rem;
+      cursor: pointer;
 
       .titleBox {
         display: flex;
-        align-items: flex-start;
+        flex-direction: column;
-        justify-content: space-between;
+        align-items: center;
+        gap: 10px;
         padding: 10px;
         background-color: #cdc8c499;
         border-top-left-radius: inherit;
-        border-bottom-left-radius: inherit;
 
-        .titleBoxItem {
+        .title {
           display: flex;
           justify-content: center;
           align-items: center;
           color: var(--mui-palette-primary-light);
+          font-size: 1.5rem;
+
+          svg {
+            font-size: 1.5rem;
+          }
+        }
+
+        .date {
+          display: flex;
+          justify-content: center;
+          align-items: center;
+          color: var(--mui-palette-primary-light);
+          font-size: 1rem;
 
           svg {
             font-size: 1rem;
@@ -58,7 +73,7 @@
         flex: 1;
         justify-content: center;
         gap: 10px;
-        padding: 10px 0;
+        padding: 10px;
         color: var(--mui-palette-primary-light);
 
         .signerItem {

src/pages/sign/index.tsx

@@ -7,27 +7,34 @@ import { MuiFileInput } from 'mui-file-input'
 import { Event, verifyEvent } from 'nostr-tools'
 import { useEffect, useState } from 'react'
 import { useSelector } from 'react-redux'
-import { useLocation, useNavigate, useSearchParams } from 'react-router-dom'
+import { useLocation, useNavigate } from 'react-router-dom'
 import { toast } from 'react-toastify'
 import { LoadingSpinner } from '../../components/LoadingSpinner'
 import { NostrController } from '../../controllers'
 import { appPublicRoutes } from '../../routes'
 import { State } from '../../store/rootReducer'
-import { CreateSignatureEventContent, Meta, SignedEvent } from '../../types'
+import {
+  CreateSignatureEventContent,
+  Meta,
+  Sigit,
+  SignedEvent
+} from '../../types'
 import {
   decryptArrayBuffer,
   encryptArrayBuffer,
+  extractEncryptionKey,
   generateEncryptionKey,
   generateKeysFile,
   getHash,
   hexToNpub,
   isOnline,
+  now,
   npubToHex,
   parseJson,
   readContentOfZipEntry,
-  sendDM,
+  sendNotification,
   signEventForMetaFile,
-  uploadToFileStorage
+  updateUsersAppData
 } from '../../utils'
 import { DisplayMeta } from './internal/displayMeta'
 import styles from './style.module.scss'
@@ -40,10 +47,11 @@ enum SignedStatus {
 export const SignPage = () => {
   const navigate = useNavigate()
   const location = useLocation()
-  const { arrayBuffer: decryptedArrayBuffer, uploadedZip } =
+  const {
-    location.state || {}
+    sigit,
-
+    arrayBuffer: decryptedArrayBuffer,
-  const [searchParams, setSearchParams] = useSearchParams()
+    uploadedZip
+  } = location.state || {}
 
   const [displayInput, setDisplayInput] = useState(false)
 
@@ -54,6 +62,7 @@ export const SignPage = () => {
   const [isLoading, setIsLoading] = useState(true)
   const [loadingSpinnerDesc, setLoadingSpinnerDesc] = useState('')
 
+  const [fileUrl, setFileUrl] = useState<string>()
   const [meta, setMeta] = useState<Meta | null>(null)
   const [signedStatus, setSignedStatus] = useState<SignedStatus>()
 
@@ -160,13 +169,93 @@ export const SignPage = () => {
   }, [signers, signedBy, usersPubkey, submittedBy])
 
   useEffect(() => {
-    const fileUrl = searchParams.get('file')
+    const handleUpdatedMeta = async (meta: Meta) => {
-    const key = searchParams.get('key')
+      const createSignatureEvent = await parseJson<Event>(
+        meta.createSignature
+      ).catch((err) => {
+        console.log('err in parsing the createSignature event:>> ', err)
+        toast.error(
+          err.message || 'error occurred in parsing the create signature event'
+        )
+        setIsLoading(false)
+        return null
+      })
 
-    if (fileUrl && key) {
+      if (!createSignatureEvent) return
+
+      const isValidCreateSignature = verifyEvent(createSignatureEvent)
+
+      if (!isValidCreateSignature) {
+        toast.error('Create signature is invalid')
+        setIsLoading(false)
+        return
+      }
+
+      const createSignatureContent =
+        await parseJson<CreateSignatureEventContent>(
+          createSignatureEvent.content
+        ).catch((err) => {
+          console.log(
+            `err in parsing the createSignature event's content :>> `,
+            err
+          )
+          toast.error(
+            err.message ||
+              `error occurred in parsing the create signature event's content`
+          )
+          setIsLoading(false)
+          return null
+        })
+
+      if (!createSignatureContent) return
+
+      setSigners(createSignatureContent.signers)
+      setViewers(createSignatureContent.viewers)
+      setCreatorFileHashes(createSignatureContent.fileHashes)
+      setSubmittedBy(createSignatureEvent.pubkey)
+
+      setSignedBy(Object.keys(meta.docSignatures) as `npub1${string}`[])
+    }
+
+    if (meta) {
+      handleUpdatedMeta(meta)
+    }
+  }, [meta])
+
+  useEffect(() => {
+    if (sigit) {
+      const processSigit = async () => {
         setIsLoading(true)
-      setLoadingSpinnerDesc('Fetching file from file server')
+        setLoadingSpinnerDesc(
+          'Extracting encryption key from creator signature'
+        )
 
+        const { fileUrl, meta } = sigit as Sigit
+
+        const encryptionKey = await extractEncryptionKey(
+          meta.createSignature
+        ).then(async (res) => {
+          if (!res) return null
+
+          const { sender, encryptedKey } = res
+          const decrypted = await nostrController
+            .nip04Decrypt(sender, encryptedKey)
+            .catch((err) => {
+              console.log('An error occurred in decrypting encryption key', err)
+              toast.error('An error occurred in decrypting encryption key')
+              return null
+            })
+
+          return decrypted
+        })
+
+        if (!encryptionKey) {
+          setIsLoading(false)
+          return
+        }
+
+        setLoadingSpinnerDesc('Fetching file from file server')
+        setFileUrl(fileUrl)
         axios
           .get(fileUrl, {
             responseType: 'arraybuffer'
@@ -176,17 +265,18 @@ export const SignPage = () => {
             const file = new File([res.data], fileName!)
 
             const encryptedArrayBuffer = await file.arrayBuffer()
-
             const arrayBuffer = await decryptArrayBuffer(
               encryptedArrayBuffer,
-            key
+              encryptionKey
             ).catch((err) => {
               console.log('err in decryption:>> ', err)
-            toast.error(err.message || 'An error occurred in decrypting file.')
+              toast.error(
+                err.message || 'An error occurred in decrypting file.'
+              )
               return null
             })
 
-          if (arrayBuffer) handleDecryptedArrayBuffer(arrayBuffer)
+            if (arrayBuffer) handleDecryptedArrayBuffer(arrayBuffer, meta)
           })
           .catch((err) => {
             console.error(`error occurred in getting file from ${fileUrl}`, err)
@@ -197,6 +287,9 @@ export const SignPage = () => {
           .finally(() => {
             setIsLoading(false)
           })
+      }
+
+      processSigit()
     } else if (decryptedArrayBuffer) {
       handleDecryptedArrayBuffer(decryptedArrayBuffer).finally(() =>
         setIsLoading(false)
@@ -217,7 +310,7 @@ export const SignPage = () => {
       setIsLoading(false)
       setDisplayInput(true)
     }
-  }, [searchParams, decryptedArrayBuffer, uploadedZip])
+  }, [decryptedArrayBuffer, uploadedZip])
 
   const parseKeysJson = async (zip: JSZip) => {
     const keysFileContent = await readContentOfZipEntry(
@@ -312,7 +405,10 @@ export const SignPage = () => {
     return null
   }
 
-  const handleDecryptedArrayBuffer = async (arrayBuffer: ArrayBuffer) => {
+  const handleDecryptedArrayBuffer = async (
+    arrayBuffer: ArrayBuffer,
+    meta?: Meta
+  ) => {
     const decryptedZipFile = new File([arrayBuffer], 'decrypted.zip')
 
     setLoadingSpinnerDesc('Parsing zip file')
@@ -328,6 +424,11 @@ export const SignPage = () => {
     setZip(zip)
     setDisplayInput(false)
 
+    let parsedMetaJson: Meta | null = null
+
+    if (meta) {
+      parsedMetaJson = meta
+    } else {
       setLoadingSpinnerDesc('Parsing meta.json')
 
       const metaFileContent = await readContentOfZipEntry(
@@ -341,64 +442,16 @@ export const SignPage = () => {
         return
       }
 
-    const parsedMetaJson = await parseJson<Meta>(metaFileContent).catch(
+      parsedMetaJson = await parseJson<Meta>(metaFileContent).catch((err) => {
-      (err) => {
         console.log('err in parsing the content of meta.json :>> ', err)
         toast.error(
           err.message || 'error occurred in parsing the content of meta.json'
         )
         setIsLoading(false)
         return null
-      }
-    )
-
-    if (!parsedMetaJson) return
-
-    const createSignatureEvent = await parseJson<Event>(
-      parsedMetaJson.createSignature
-    ).catch((err) => {
-      console.log('err in parsing the createSignature event:>> ', err)
-      toast.error(
-        err.message || 'error occurred in parsing the create signature event'
-      )
-      setIsLoading(false)
-      return null
       })
-
-    if (!createSignatureEvent) return
-
-    const isValidCreateSignature = verifyEvent(createSignatureEvent)
-
-    if (!isValidCreateSignature) {
-      toast.error('Create signature is invalid')
-      setIsLoading(false)
-      return
     }
 
-    const createSignatureContent = await parseJson<CreateSignatureEventContent>(
-      createSignatureEvent.content
-    ).catch((err) => {
-      console.log(
-        `err in parsing the createSignature event's content :>> `,
-        err
-      )
-      toast.error(
-        err.message ||
-          `error occurred in parsing the create signature event's content`
-      )
-      setIsLoading(false)
-      return null
-    })
-
-    if (!createSignatureContent) return
-
-    setSigners(createSignatureContent.signers)
-    setViewers(createSignatureContent.viewers)
-    setCreatorFileHashes(createSignatureContent.fileHashes)
-    setSubmittedBy(createSignatureEvent.pubkey)
-
-    setSignedBy(Object.keys(parsedMetaJson.docSignatures) as `npub1${string}`[])
-
     setMeta(parsedMetaJson)
   }
 
@@ -417,20 +470,6 @@ export const SignPage = () => {
     if (!zip || !meta) return
 
     setIsLoading(true)
-    setLoadingSpinnerDesc('parsing hashes.json file')
-
-    const hashesFileContent = await readHashesFile()
-    if (!hashesFileContent) return
-
-    if (!hashesFileContent) {
-      setIsLoading(false)
-      return
-    }
-
-    const hashes = await parseHashes(hashesFileContent)
-    if (!hashes) return
-
-    setLoadingSpinnerDesc('Generating hashes for files')
 
     setLoadingSpinnerDesc('Signing nostr event')
 
@@ -441,56 +480,16 @@ export const SignPage = () => {
     if (!signedEvent) return
 
     const updatedMeta = updateMetaSignatures(meta, signedEvent)
-
+    setMeta(updatedMeta)
-    const stringifiedMeta = JSON.stringify(updatedMeta, null, 2)
-    zip.file('meta.json', stringifiedMeta)
-
-    const metaHash = await getHash(stringifiedMeta)
-    if (!metaHash) return
-
-    const updatedHashes = updateHashes(hashes, metaHash)
-    zip.file('hashes.json', JSON.stringify(updatedHashes, null, 2))
-
-    const arrayBuffer = await generateZipArrayBuffer(zip)
-    if (!arrayBuffer) return
-
-    const key = await generateEncryptionKey()
-
-    setLoadingSpinnerDesc('Encrypting zip file')
-    const encryptedArrayBuffer = await encryptArrayBuffer(arrayBuffer, key)
 
     if (await isOnline()) {
-      await handleOnlineFlow(encryptedArrayBuffer, key)
+      if (fileUrl) await handleOnlineFlow(fileUrl, updatedMeta)
     } else {
-      handleDecryptedArrayBuffer(arrayBuffer).finally(() => setIsLoading(false))
+      // todo: fix offline flow
+      // handleDecryptedArrayBuffer(arrayBuffer).finally(() => setIsLoading(false))
     }
   }
 
-  // Read the content of the hashes.json file
-  const readHashesFile = async (): Promise<string | null> => {
-    return await readContentOfZipEntry(zip!, 'hashes.json', 'string').catch(
-      (err) => {
-        console.log('Error reading hashes.json file:', err)
-        setIsLoading(false)
-        return null
-      }
-    )
-  }
-
-  // Parse the JSON content of the hashes file
-  const parseHashes = async (
-    hashesFileContent: string
-  ): Promise<Record<string, string> | null> => {
-    return await parseJson<Record<string, string>>(hashesFileContent).catch(
-      (err) => {
-        console.log('Error parsing hashes.json content:', err)
-        toast.error(err.message || 'Error parsing hashes.json content')
-        setIsLoading(false)
-        return null
-      }
-    )
-  }
-
   // Sign the event for the meta file
   const signEventForMeta = async (prevSig: string) => {
     return await signEventForMetaFile(
@@ -507,40 +506,10 @@ export const SignPage = () => {
       ...metaCopy.docSignatures,
       [hexToNpub(signedEvent.pubkey)]: JSON.stringify(signedEvent, null, 2)
     }
+    metaCopy.modifiedAt = now()
     return metaCopy
   }
 
-  // Update the hashes with the new meta hash
-  const updateHashes = (
-    hashes: Record<string, string>,
-    metaHash: string
-  ): Record<string, string> => {
-    return {
-      ...hashes,
-      [usersPubkey!]: metaHash
-    }
-  }
-
-  // Generate the zip array buffer
-  const generateZipArrayBuffer = async (
-    zip: JSZip
-  ): Promise<ArrayBuffer | null> => {
-    return await zip
-      .generateAsync({
-        type: 'arraybuffer',
-        compression: 'DEFLATE',
-        compressionOptions: {
-          level: 6
-        }
-      })
-      .catch((err) => {
-        console.log('Error generating zip file:', err)
-        setIsLoading(false)
-        toast.error(err.message || 'Error generating zip file')
-        return null
-      })
-  }
-
   // create final zip file
   const createFinalZipFile = async (
     encryptedArrayBuffer: ArrayBuffer,
@@ -617,58 +586,49 @@ export const SignPage = () => {
   }
 
   // Handle the online flow: upload file and send DMs
-  const handleOnlineFlow = async (
+  const handleOnlineFlow = async (fileUrl: string, meta: Meta) => {
-    encryptedArrayBuffer: ArrayBuffer,
+    setLoadingSpinnerDesc('Updating users app data')
-    encryptionKey: string
+    const updatedEvent = await updateUsersAppData(fileUrl, meta)
-  ) => {
+    if (!updatedEvent) {
-    const unixNow = Math.floor(Date.now() / 1000)
+      setIsLoading(false)
-    const blob = new Blob([encryptedArrayBuffer])
+      return
-    // Create a File object with the Blob data
+    }
-    const file = new File([blob], `compressed-${unixNow}.sigit`, {
-      type: 'application/sigit'
-    })
 
-    const fileUrl = await uploadFile(file)
+    const userSet = new Set<`npub1${string}`>()
-    if (!fileUrl) return
+    if (submittedBy) {
+      userSet.add(hexToNpub(submittedBy))
+    }
 
     const isLastSigner = checkIsLastSigner(signers)
-
     if (isLastSigner) {
-      await sendDMToAllUsers(fileUrl, encryptionKey)
+      signers.forEach((signer) => {
+        userSet.add(signer)
+      })
+
+      viewers.forEach((viewer) => {
+        userSet.add(viewer)
+      })
     } else {
-      await sendDMToNextSigner(fileUrl, encryptionKey)
+      const usersNpub = hexToNpub(usersPubkey!)
-    }
+      const currentSignerIndex = signers.indexOf(usersNpub)
+      const prevSigners = signers.slice(0, currentSignerIndex)
 
-    // update search params with updated file url and encryption key
+      prevSigners.forEach((signer) => {
-    setSearchParams({
+        userSet.add(signer)
-      file: fileUrl,
-      key: encryptionKey
       })
 
-    setIsLoading(false)
+      const nextSigner = signers[currentSignerIndex + 1]
+      userSet.add(nextSigner)
     }
 
-  // Handle errors during file upload
+    setLoadingSpinnerDesc('Sending notifications')
-  const handleUploadError = (err: any) => {
+    const users = Array.from(userSet)
-    console.log('Error in upload:>> ', err)
+    const promises = users.map((user) =>
+      sendNotification(npubToHex(user)!, meta, fileUrl)
+    )
+    await Promise.allSettled(promises)
+
     setIsLoading(false)
-    toast.error(err.message || 'Error occurred in uploading file')
-    return null
-  }
-
-  // Upload the file to file storage
-  const uploadFile = async (file: File): Promise<string | null> => {
-    setIsLoading(true)
-    setLoadingSpinnerDesc('Uploading sigit file to file storage.')
-
-    const fileUrl = await uploadToFileStorage(file, nostrController)
-      .then((url) => {
-        toast.success('Sigit uploaded to file storage')
-        return url
-      })
-      .catch(handleUploadError)
-
-    return fileUrl
   }
 
   // Check if the current user is the last signer
@@ -679,51 +639,6 @@ export const SignPage = () => {
     return signerIndex === lastSignerIndex
   }
 
-  // Send DM to all users (signers and viewers)
-  const sendDMToAllUsers = async (fileUrl: string, encryptionKey: string) => {
-    const userSet = new Set<`npub1${string}`>()
-
-    if (submittedBy) {
-      userSet.add(hexToNpub(submittedBy))
-    }
-
-    signers.forEach((signer) => {
-      userSet.add(signer)
-    })
-
-    viewers.forEach((viewer) => {
-      userSet.add(viewer)
-    })
-
-    const users = Array.from(userSet)
-
-    for (const user of users) {
-      await sendDM(
-        fileUrl,
-        encryptionKey,
-        npubToHex(user)!,
-        nostrController,
-        false,
-        setAuthUrl
-      )
-    }
-  }
-
-  // Send DM to the next signer
-  const sendDMToNextSigner = async (fileUrl: string, encryptionKey: string) => {
-    const usersNpub = hexToNpub(usersPubkey!)
-    const signerIndex = signers.indexOf(usersNpub)
-    const nextSigner = signers[signerIndex + 1]
-    await sendDM(
-      fileUrl,
-      encryptionKey,
-      npubToHex(nextSigner)!,
-      nostrController,
-      true,
-      setAuthUrl
-    )
-  }
-
   const handleExport = async () => {
     if (!meta || !zip || !usersPubkey) return
 

src/services/cache/index.ts

@@ -1,22 +1,32 @@
 import { IDBPDatabase, openDB } from 'idb'
 import { Event } from 'nostr-tools'
-import { CachedMetadataEvent } from '../../types'
+import { CachedEvent } from '../../types'
-import { SchemaV1 } from './schema'
+import { SchemaV2 } from './schema'
 
 class LocalCache {
   // Static property to hold the single instance of LocalCache
   private static instance: LocalCache | null = null
-  private db!: IDBPDatabase<SchemaV1>
+  private db!: IDBPDatabase<SchemaV2>
 
   // Private constructor to prevent direct instantiation
   private constructor() {}
 
   // Method to initialize the database
   private async init() {
-    this.db = await openDB<SchemaV1>('sigit-cache', 1, {
+    this.db = await openDB<SchemaV2>('sigit-cache', 2, {
-      upgrade(db) {
+      upgrade(db, oldVersion) {
+        if (oldVersion < 1) {
           db.createObjectStore('userMetadata', { keyPath: 'event.pubkey' })
         }
+
+        if (oldVersion < 2) {
+          const v6 = db as unknown as IDBPDatabase<SchemaV2>
+
+          v6.createObjectStore('userRelayListMetadata', {
+            keyPath: 'event.pubkey'
+          })
+        }
+      }
     })
   }
 
@@ -37,9 +47,7 @@ class LocalCache {
   }
 
   // Method to get user metadata by key
-  public async getUserMetadata(
+  public async getUserMetadata(key: string): Promise<CachedEvent | null> {
-    key: string
-  ): Promise<CachedMetadataEvent | null> {
     const data = await this.db.get('userMetadata', key)
     return data || null
   }
@@ -49,6 +57,21 @@ class LocalCache {
     await this.db.delete('userMetadata', key)
   }
 
+  public async addUserRelayListMetadata(event: Event) {
+    await this.db.put('userRelayListMetadata', { event, cachedAt: Date.now() })
+  }
+
+  public async getUserRelayListMetadata(
+    key: string
+  ): Promise<CachedEvent | null> {
+    const data = await this.db.get('userRelayListMetadata', key)
+    return data || null
+  }
+
+  public async deleteUserRelayListMetadata(key: string) {
+    await this.db.delete('userRelayListMetadata', key)
+  }
+
   // Method to clear cache data
   public async clearCacheData() {
     // Clear the 'userMetadata' store in the IndexedDB database

src/services/cache/schema.ts

@@ -1,9 +1,16 @@
 import { DBSchema } from 'idb'
-import { CachedMetadataEvent } from '../../types'
+import { CachedEvent } from '../../types'
 
 export interface SchemaV1 extends DBSchema {
   userMetadata: {
     key: string
-    value: CachedMetadataEvent
+    value: CachedEvent
+  }
+}
+
+export interface SchemaV2 extends SchemaV1 {
+  userRelayListMetadata: {
+    key: string
+    value: CachedEvent
   }
 }

src/types/cache.ts

@@ -1,6 +1,6 @@
 import { Event } from 'nostr-tools'
 
-export interface CachedMetadataEvent {
+export interface CachedEvent {
   event: Event
   cachedAt: number
 }

src/types/core.ts

@@ -9,7 +9,9 @@ export interface User {
 }
 
 export interface Meta {
+  uuid: string
   title: string
+  modifiedAt: number
   createSignature: string
   docSignatures: { [key: `npub1${string}`]: string }
   exportSignature?: string
@@ -19,8 +21,14 @@ export interface CreateSignatureEventContent {
   signers: `npub1${string}`[]
   viewers: `npub1${string}`[]
   fileHashes: { [key: string]: string }
+  keys: { sender: string; keys: { [user: `npub1${string}`]: string } }
 }
 
 export interface SignedEventContent {
   prevSig: string
 }
+
+export interface Sigit {
+  fileUrl: string
+  meta: Meta
+}

src/types/nostr.ts

@@ -1,3 +1,5 @@
+import { UnsignedEvent } from 'nostr-tools'
+
 export interface SignedEvent {
   kind: number
   tags: string[][]
@@ -12,3 +14,5 @@ export interface NostrJoiningBlock {
   block: number
   encodedEventPointer: string
 }
+
+export type Rumor = UnsignedEvent & { id: string }

src/types/system/index.d.ts

@@ -0,0 +1,7 @@
+import type { WindowNostr } from 'nostr-tools/nip07'
+
+declare global {
+  interface Window {
+    nostr?: WindowNostr
+  }
+}

src/utils/misc.ts

@@ -1,13 +1,20 @@
 import axios from 'axios'
 import {
+  Event,
   EventTemplate,
   generateSecretKey,
   getPublicKey,
-  nip04
+  nip04,
+  verifyEvent
 } from 'nostr-tools'
-import { MetadataController, NostrController } from '../controllers'
 import { toast } from 'react-toastify'
+import { MetadataController, NostrController } from '../controllers'
 import { appPrivateRoutes } from '../routes'
+import { hexToNpub } from './nostr'
+import { parseJson } from './string'
+import { CreateSignatureEventContent } from '../types'
+import store from '../store/store'
+import { AuthState } from '../store/auth/types'
 
 /**
  * Uploads a file to a file storage service.
@@ -254,3 +261,88 @@ export const generateKeysFile = async (
     return null
   }
 }
+
+/**
+ * Encrypt decryption key for each users pubkey.
+ *
+ * @param pubkeys - An array of public keys.
+ * @param key - The key that will be encrypted for each user.
+ * @returns A promise that resolves to a JSON object containing a random pubkey as sender and encrypted keys for each user, or null if an error occurs.
+ */
+export const generateKeys = async (
+  pubkeys: string[],
+  key: string
+): Promise<{
+  sender: string
+  keys: { [user: `npub1${string}`]: string }
+} | null> => {
+  // Generate a random private key to act as the sender
+  const privateKey = generateSecretKey()
+
+  const keys: { [user: `npub1${string}`]: string } = {}
+
+  // Encrypt the key for each user's public key
+  for (const pubkey of pubkeys) {
+    const npub = hexToNpub(pubkey)
+
+    const encryptedKey = await nip04
+      .encrypt(privateKey, pubkey, key)
+      .catch((err) => {
+        console.log(`An error occurred in encrypting key for ${npub}`, err)
+        toast.error('An error occurred in key encryption')
+        return null
+      })
+
+    if (!encryptedKey) return null
+
+    keys[npub] = encryptedKey
+  }
+
+  return { sender: getPublicKey(privateKey), keys }
+}
+
+export const extractEncryptionKey = async (createSignature: string) => {
+  const createSignatureEvent = await parseJson<Event>(createSignature).catch(
+    (err) => {
+      console.log('err in parsing the createSignature event:>> ', err)
+      toast.error(
+        err.message || 'error occurred in parsing the create signature event'
+      )
+      return null
+    }
+  )
+
+  if (!createSignatureEvent) return null
+
+  const isValidCreateSignature = verifyEvent(createSignatureEvent)
+  if (!isValidCreateSignature) {
+    toast.error('Create signature is invalid')
+    return null
+  }
+
+  const createSignatureContent = await parseJson<CreateSignatureEventContent>(
+    createSignatureEvent.content
+  ).catch((err) => {
+    console.log(`err in parsing the createSignature event's content :>> `, err)
+    toast.error(
+      `error occurred in parsing the create signature event's content`
+    )
+    return null
+  })
+
+  if (!createSignatureContent) return null
+
+  const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
+  const usersNpub = hexToNpub(usersPubkey)
+
+  const { sender, keys } = createSignatureContent.keys
+
+  if (usersNpub in keys) {
+    return {
+      sender,
+      encryptedKey: keys[usersNpub]
+    }
+  }
+
+  return null
+}

src/utils/nostr.ts

@@ -1,7 +1,28 @@
-import { nip19, verifyEvent } from 'nostr-tools'
-import { SignedEvent } from '../types'
 import axios from 'axios'
+import {
+  Event,
+  EventTemplate,
+  Filter,
+  SimplePool,
+  UnsignedEvent,
+  finalizeEvent,
+  generateSecretKey,
+  getEventHash,
+  getPublicKey,
+  kinds,
+  nip19,
+  nip44,
+  verifyEvent
+} from 'nostr-tools'
+import { toast } from 'react-toastify'
 import { NIP05_REGEX } from '../constants'
+import { MetadataController, NostrController } from '../controllers'
+import { AuthState } from '../store/auth/types'
+import { RelaysState } from '../store/relays/types'
+import store from '../store/store'
+import { Meta, Rumor, Sigit, SignedEvent } from '../types'
+import { getHash } from './hash'
+import { parseJson } from './string'
 
 /**
  * @param hexKey hex private or public key
@@ -181,3 +202,416 @@ export const getRoboHashPicture = (
   const npub = hexToNpub(pubkey)
   return `https://robohash.org/${npub}.png?set=set${set}`
 }
+
+const TWO_DAYS = 2 * 24 * 60 * 60
+
+export const now = () => Math.round(Date.now() / 1000)
+export const randomNow = () => Math.round(now() - Math.random() * TWO_DAYS)
+
+/**
+ * Generate nip44 conversation key
+ * @param privateKey
+ * @param publicKey
+ * @returns
+ */
+export const nip44ConversationKey = (
+  privateKey: Uint8Array,
+  publicKey: string
+) => nip44.v2.utils.getConversationKey(privateKey, publicKey)
+
+export const nip44Encrypt = (
+  data: EventTemplate,
+  privateKey: Uint8Array,
+  publicKey: string
+) =>
+  nip44.v2.encrypt(
+    JSON.stringify(data),
+    nip44ConversationKey(privateKey, publicKey)
+  )
+
+export const nip44Decrypt = (data: Event, privateKey: Uint8Array) =>
+  JSON.parse(
+    nip44.v2.decrypt(
+      data.content,
+      nip44ConversationKey(privateKey, data.pubkey)
+    )
+  )
+
+// Function to count leading zero bits
+export const countLeadingZeroes = (hex: string) => {
+  let count = 0
+
+  for (let i = 0; i < hex.length; i++) {
+    const nibble = parseInt(hex[i], 16)
+    if (nibble === 0) {
+      count += 4
+    } else {
+      count += Math.clz32(nibble) - 28
+      break
+    }
+  }
+
+  return count
+}
+
+/**
+ * Function to create a wrapped event with PoW
+ * @param event Original event to be wrapped
+ * @param receiver Public key of the receiver
+ * @param difficulty PoW difficulty level (default is 20)
+ * @returns
+ */
+//
+export const createWrap = (
+  event: Event,
+  receiver: string,
+  difficulty: number = 10
+) => {
+  // Generate a random secret key and its corresponding public key
+  const randomKey = generateSecretKey()
+  const pubkey = getPublicKey(randomKey)
+
+  // Encrypt the event content using nip44 encryption
+  const content = nip44Encrypt(event, randomKey, receiver)
+
+  // Initialize nonce and leadingZeroes for PoW calculation
+  let nonce = 0
+  let leadingZeroes = 0
+
+  // Loop until a valid PoW hash is found
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Create an unsigned event with the necessary fields
+    const unsignedEvent: UnsignedEvent = {
+      kind: 1059, // Event kind
+      content, // Encrypted content
+      pubkey, // Public key of the creator
+      created_at: randomNow(), // Current timestamp
+      tags: [
+        // Tags including receiver and nonce
+        ['p', receiver],
+        ['nonce', nonce.toString(), difficulty.toString()]
+      ]
+    }
+
+    // Calculate the SHA-256 hash of the unsigned event
+    const hash = getEventHash(unsignedEvent)
+
+    // Count the number of leading zero bits in the hash
+    leadingZeroes = countLeadingZeroes(hash)
+
+    // Check if the leading zero bits meet the required difficulty
+    if (leadingZeroes >= difficulty) {
+      // Finalize the event (sign it) and return the result
+      return finalizeEvent(unsignedEvent, randomKey)
+    }
+
+    // Increment the nonce for the next iteration
+    nonce++
+  }
+}
+
+export const getUsersAppData = async () => {
+  const relays: string[] = []
+
+  const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
+  const relayMap = store.getState().relays?.map
+
+  const nostrController = NostrController.getInstance()
+
+  // check if relaysMap in redux store is undefined
+  if (!relayMap) {
+    // todo: use metadata controller
+
+    const metadataController = new MetadataController()
+    const relaySet = await metadataController
+      .findRelayListMetadata(usersPubkey)
+      .catch((err) => {
+        console.log(
+          `An error occurred while finding relay list metadata for ${hexToNpub(usersPubkey)}`,
+          err
+        )
+        return null
+      })
+
+    // Return if metadata retrieval failed
+    if (!relaySet) return
+
+    // Ensure relay list is not empty
+    if (relaySet.write.length === 0) return
+
+    relays.push(...relaySet.write)
+  } else {
+    // filter write relays from user's relayMap stored in redux store
+    const writeRelays = Object.keys(relayMap).filter(
+      (key) => relayMap[key].write
+    )
+
+    relays.push(...writeRelays)
+  }
+
+  // generate an identifier for user's nip78
+  const hash = await getHash('sigit' + usersPubkey)
+  if (!hash) return null
+
+  const filter: Filter = {
+    kinds: [kinds.Application],
+    '#d': [hash]
+  }
+
+  const encryptedContent = await nostrController
+    .getEvent(filter, relays)
+    .then((event) => {
+      if (event) return event.content
+
+      // if person is using sigit for first time its possible that event is null
+      // so we'll return empty stringified object
+      return '{}'
+    })
+    .catch((err) => {
+      console.log(`An error occurred in finding kind 30078 event`, err)
+      toast.error(
+        'An error occurred in finding kind 30078 event for data storage'
+      )
+      return null
+    })
+
+  if (!encryptedContent) return null
+
+  if (encryptedContent === '{}') {
+    return {}
+  }
+
+  const decrypted = await nostrController
+    .nip04Decrypt(usersPubkey, encryptedContent)
+    .catch((err) => {
+      console.log('An error occurred while decrypting app data', err)
+      toast.error('An error occurred while decrypting app data')
+      return null
+    })
+
+  if (!decrypted) return null
+
+  const parsedContent = await parseJson<{
+    [uuid: string]: Sigit
+  }>(decrypted).catch((err) => {
+    console.log(
+      'An error occurred in parsing the content of kind 30078 event',
+      err
+    )
+    toast.error('An error occurred in parsing the content of kind 30078 event')
+    return null
+  })
+
+  if (!parsedContent) return null
+
+  return parsedContent
+}
+
+export const updateUsersAppData = async (fileUrl: string, meta: Meta) => {
+  const appData = await getUsersAppData()
+  if (!appData) return null
+
+  if (meta.uuid in appData) {
+    // update meta only if income meta is more recent than already existing one
+    const existingMeta = appData[meta.uuid].meta
+    if (existingMeta.modifiedAt < meta.modifiedAt) {
+      appData[meta.uuid] = {
+        fileUrl,
+        meta
+      }
+    }
+  } else {
+    appData[meta.uuid] = {
+      fileUrl,
+      meta
+    }
+  }
+
+  appData[meta.uuid] = {
+    fileUrl,
+    meta
+  }
+
+  const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
+
+  const nostrController = NostrController.getInstance()
+  const encryptedContent = await nostrController
+    .nip04Encrypt(usersPubkey, JSON.stringify(appData))
+    .catch((err) => {
+      console.log(
+        'An error occurred in encryption of content for app data',
+        err
+      )
+      toast.error(
+        err.message || 'An error occurred in encryption of content for app data'
+      )
+      return null
+    })
+
+  if (!encryptedContent) return null
+
+  // generate the identifier for user's appData event
+  const hash = await getHash('sigit' + usersPubkey)
+  if (!hash) return null
+
+  const updatedEvent: UnsignedEvent = {
+    kind: kinds.Application,
+    pubkey: usersPubkey!,
+    created_at: now(),
+    tags: [['d', hash]],
+    content: encryptedContent
+  }
+
+  const signedEvent = await nostrController
+    .signEvent(updatedEvent)
+    .catch((err) => {
+      console.log('An error occurred in signing event', err)
+      toast.error(err.message || 'An error occurred in signing event')
+      return null
+    })
+
+  if (!signedEvent) return null
+
+  const relayMap = (store.getState().relays as RelaysState).map!
+  const writeRelays = Object.keys(relayMap).filter((key) => relayMap[key].write)
+
+  const publishResult = await nostrController
+    .publishEvent(signedEvent, writeRelays)
+    .catch((errResults) => {
+      console.log('err :>> ', errResults)
+      toast.error('An error occurred while publishing App data')
+
+      errResults.forEach((errResult: any) => {
+        toast.error(
+          `Publishing to ${errResult.relay} caused the following error: ${errResult.error}`
+        )
+      })
+
+      return null
+    })
+
+  if (!publishResult) return null
+
+  return signedEvent
+}
+
+export const subscribeForSigits = async (pubkey: string) => {
+  // Get relay list metadata
+  const metadataController = new MetadataController()
+  const relaySet = await metadataController
+    .findRelayListMetadata(pubkey)
+    .catch((err) => {
+      console.log(
+        `An error occurred while finding relay list metadata for ${hexToNpub(receiver)}`,
+        err
+      )
+      return null
+    })
+
+  // Return if metadata retrieval failed
+  if (!relaySet) return
+
+  // Ensure relay list is not empty
+  if (relaySet.read.length === 0) return
+
+  const filter: Filter = {
+    kinds: [1059],
+    '#p': [pubkey]
+  }
+  const pool = new SimplePool()
+
+  pool.subscribeMany(relaySet.read, [filter], {
+    onevent: (event) => {
+      processReceivedEvent(event)
+    }
+  })
+}
+
+const processReceivedEvent = async (event: Event, difficulty: number = 10) => {
+  // validate PoW
+  // Count the number of leading zero bits in the hash
+  const leadingZeroes = countLeadingZeroes(event.id)
+  if (leadingZeroes < difficulty) return
+
+  const nostrController = NostrController.getInstance()
+  const stringifiedSealEvent = await nostrController.nip44Decrypt(
+    event.pubkey,
+    event.content
+  )
+  const sealEvent = await parseJson<Event>(stringifiedSealEvent)
+  const stringifiedRumor = await nostrController.nip44Decrypt(
+    sealEvent.pubkey,
+    sealEvent.content
+  )
+  const rumor = await parseJson<Rumor>(stringifiedRumor)
+  if (rumor.content === 'sigit-notification') {
+    const uTag = rumor.tags.find((tag) => tag[0] === 'u')
+    if (!uTag) return
+    const fileUrl = uTag[1]
+
+    const mTag = rumor.tags.find((tag) => tag[0] === 'm')
+    if (!mTag) return
+    const metaString = mTag[1]
+
+    const meta = await parseJson<Meta>(metaString)
+    updateUsersAppData(fileUrl, meta)
+  }
+}
+
+export const sendNotification = async (
+  receiver: string,
+  meta: Meta,
+  fileUrl: string
+) => {
+  const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
+
+  const unsignedEvent: UnsignedEvent = {
+    kind: kinds.ShortTextNote,
+    pubkey: usersPubkey,
+    content: 'sigit-notification',
+    tags: [
+      ['u', fileUrl],
+      ['m', JSON.stringify(meta)]
+    ],
+    created_at: now()
+  }
+
+  const rumor: Rumor = {
+    ...unsignedEvent,
+    id: getEventHash(unsignedEvent)
+  }
+
+  const nostrController = NostrController.getInstance()
+  const seal = await nostrController.createSeal(rumor, receiver)
+  const wrappedEvent = createWrap(seal, receiver)
+
+  // Get relay list metadata
+  const metadataController = new MetadataController()
+  const relaySet = await metadataController
+    .findRelayListMetadata(receiver)
+    .catch((err) => {
+      console.log(
+        `An error occurred while finding relay list metadata for ${hexToNpub(receiver)}`,
+        err
+      )
+      return null
+    })
+
+  // Return if metadata retrieval failed
+  if (!relaySet) return
+
+  // Ensure relay list is not empty
+  if (relaySet.read.length === 0) return
+
+  // Publish the notification event to the recipient's read relays
+  await nostrController
+    .publishEvent(wrappedEvent, relaySet.read)
+    .catch((errResults) => {
+      console.log(
+        `An error occurred while publishing notification event for ${hexToNpub(receiver)}`,
+        errResults
+      )
+      return null
+    })
+}

src/utils/string.ts

@@ -93,3 +93,21 @@ export const parseJson = <T>(content: string): Promise<T> => {
  */
 export const capitalizeFirstLetter = (str: string) =>
   str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
+
+export const formatTimestamp = (timestamp: number) => {
+  const date = new Date(timestamp)
+
+  // Extract date parts
+  const day = date.getDate().toString().padStart(2, '0')
+  const month = date.toLocaleString('default', { month: 'short' })
+  const year = date.getFullYear()
+
+  // Format time parts
+  const hours = date.getHours()
+  const minutes = date.getMinutes().toString().padStart(2, '0')
+  const ampm = hours >= 12 ? 'PM' : 'AM'
+  const formattedHours = (hours % 12 || 12).toString().padStart(2, '0')
+
+  // Combine parts into the desired format
+  return `${day} ${month} ${year} ${formattedHours}:${minutes} ${ampm}`
+}