src/controllers/MetadataController.ts

@@ -145,20 +145,11 @@ export class MetadataController extends EventEmitter {
    * or a fallback RelaySet with Sigit's Relay
    */
   public findRelayListMetadata = async (hexKey: string): Promise<RelaySet> => {
-    try {
-      const relayEvent =
-        (await findRelayListInCache(hexKey)) ||
-        (await findRelayListAndUpdateCache(DEFAULT_LOOK_UP_RELAY_LIST, hexKey))
+    const relayEvent =
+      (await findRelayListInCache(hexKey)) ||
+      (await findRelayListAndUpdateCache(DEFAULT_LOOK_UP_RELAY_LIST, hexKey))
 
-      return relayEvent
-        ? getUserRelaySet(relayEvent.tags)
-        : getDefaultRelaySet()
-    } catch (error) {
-      throw new Error(
-        `An error occurred while finding relay list metadata for ${hexKey}`,
-        { cause: error }
-      )
-    }
+    return relayEvent ? getUserRelaySet(relayEvent.tags) : getDefaultRelaySet()
   }
 
   public extractProfileMetadataContent = (event: Event) => {

src/controllers/RelayController.ts

@@ -2,8 +2,7 @@ import { Event, Filter, Relay } from 'nostr-tools'
 import {
   settleAllFullfilfedPromises,
   normalizeWebSocketURL,
-  publishToRelay,
-  isPromiseFulfilled
+  timeout
 } from '../utils'
 import { SIGIT_RELAY } from '../utils/const'
 
@@ -262,17 +261,17 @@ export class RelayController {
     event: Event,
     relayUrls: string[] = []
   ): Promise<string[]> => {
-    /**
-     * Ensure that the default Sigit Relay is included.
-     * Copy the array instead of mutating it.
-     */
-    const updatedRelayUrls = !relayUrls.includes(SIGIT_RELAY)
-      ? [...relayUrls, SIGIT_RELAY]
-      : [...relayUrls]
+    if (!relayUrls.includes(SIGIT_RELAY)) {
+      /**
+       * NOTE: To avoid side-effects on external relayUrls array passed as argument
+       * re-assigned relayUrls with added sigit relay instead of just appending to same array
+       */
+      relayUrls = [...relayUrls, SIGIT_RELAY] // Add app relay to relays array if not exists already
+    }
 
     // connect to all specified relays
     const relays = await settleAllFullfilfedPromises(
-      updatedRelayUrls,
+      relayUrls,
       this.connectRelay
     )
 
@@ -281,15 +280,26 @@ export class RelayController {
       throw new Error('No relay is connected to publish event!')
     }
 
-    const settledPromises: PromiseSettledResult<string>[] =
-      await Promise.allSettled(
-        relays.map(async (relay) => publishToRelay(relay, event))
-      )
+    const publishedOnRelays: string[] = [] // List to track which relays successfully published the event
+
+    // Create a promise for publishing the event to each connected relay
+    const publishPromises = relays.map(async (relay) => {
+      try {
+        await Promise.race([
+          relay.publish(event), // Publish the event to the relay
+          timeout(20 * 1000) // Set a timeout to handle cases where publishing takes too long
+        ])
+        publishedOnRelays.push(relay.url) // Add the relay URL to the list of successfully published relays
+      } catch (err) {
+        console.error(`Failed to publish event on relay: ${relay.url}`, err)
+      }
+    })
+
+    // Wait for all publish operations to complete (either fulfilled or rejected)
+    await Promise.allSettled(publishPromises)
 
     // Return the list of relay URLs where the event was published
-    return settledPromises
-      .filter(isPromiseFulfilled)
-      .map((res) => res.value) as string[]
+    return publishedOnRelays
   }
 }
 

src/pages/create/index.tsx

@@ -84,7 +84,6 @@ import {
   faUpload
 } from '@fortawesome/free-solid-svg-icons'
 import { SigitFile } from '../../utils/file.ts'
-import { checkNotifications } from '../../utils/notifications.ts'
 
 export const CreatePage = () => {
   const navigate = useNavigate()
@@ -721,7 +720,7 @@ export const CreatePage = () => {
         : viewers.map((viewer) => viewer.pubkey)
     ).filter((receiver) => receiver !== usersPubkey)
 
-    return receivers.map(async (receiver) => sendNotification(receiver, meta))
+    return receivers.map((receiver) => sendNotification(receiver, meta))
   }
 
   const handleCreate = async () => {
@@ -785,8 +784,16 @@ export const CreatePage = () => {
         if (!event) return
 
         setLoadingSpinnerDesc('Sending notifications to counterparties')
-        const notifications = await Promise.allSettled(sendNotifications(meta))
-        checkNotifications(notifications)
+        const promises = sendNotifications(meta)
+
+        await Promise.all(promises)
+          .then(() => {
+            toast.success('Notifications sent successfully')
+          })
+          .catch(() => {
+            toast.error('Failed to publish notifications')
+          })
+
         navigate(appPrivateRoutes.sign, { state: { meta: meta } })
       } else {
         const zip = new JSZip()

src/pages/sign/index.tsx

@@ -53,7 +53,6 @@ import {
   SigitFile
 } from '../../utils/file.ts'
 import { ARRAY_BUFFER, DEFLATE } from '../../utils/const.ts'
-import { checkNotifications } from '../../utils/notifications.ts'
 enum SignedStatus {
   Fully_Signed,
   User_Is_Next_Signer,
@@ -664,22 +663,57 @@ export const SignPage = () => {
 
   // Handle the online flow: update users app data and send notifications
   const handleOnlineFlow = async (meta: Meta) => {
-    try {
-      setLoadingSpinnerDesc('Updating users app data')
-      const updatedEvent = await updateUsersAppData(meta)
-      if (!updatedEvent) {
-        throw new Error('There was an error updating user app data.')
-      }
-      setLoadingSpinnerDesc('Sending notifications')
-
-      const notifications = await notifyUsers(meta)
-      checkNotifications(notifications)
-    } catch (error) {
-      console.error(error)
-      toast.error('There was an error finalising signatures.')
-    } finally {
+    setLoadingSpinnerDesc('Updating users app data')
+    const updatedEvent = await updateUsersAppData(meta)
+    if (!updatedEvent) {
       setIsLoading(false)
+      return
     }
+
+    const userSet = new Set<`npub1${string}`>()
+    if (submittedBy && submittedBy !== usersPubkey) {
+      userSet.add(hexToNpub(submittedBy))
+    }
+
+    const usersNpub = hexToNpub(usersPubkey!)
+    const isLastSigner = checkIsLastSigner(signers)
+    if (isLastSigner) {
+      signers.forEach((signer) => {
+        if (signer !== usersNpub) {
+          userSet.add(signer)
+        }
+      })
+
+      viewers.forEach((viewer) => {
+        userSet.add(viewer)
+      })
+    } else {
+      const currentSignerIndex = signers.indexOf(usersNpub)
+      const prevSigners = signers.slice(0, currentSignerIndex)
+
+      prevSigners.forEach((signer) => {
+        userSet.add(signer)
+      })
+
+      const nextSigner = signers[currentSignerIndex + 1]
+      userSet.add(nextSigner)
+    }
+
+    setLoadingSpinnerDesc('Sending notifications')
+    const users = Array.from(userSet)
+    const promises = users.map((user) =>
+      sendNotification(npubToHex(user)!, meta)
+    )
+    await Promise.all(promises)
+      .then(() => {
+        toast.success('Notifications sent successfully')
+        setMeta(meta)
+      })
+      .catch(() => {
+        toast.error('Failed to publish notifications')
+      })
+
+    setIsLoading(false)
   }
 
   // Check if the current user is the last signer
@@ -837,64 +871,6 @@ export const SignPage = () => {
     }
   }
 
-  const getUsersToNotify = (): `npub1${string}`[] => {
-    const userSet = new Set<`npub1${string}`>()
-    if (submittedBy && submittedBy !== usersPubkey) {
-      userSet.add(hexToNpub(submittedBy))
-    }
-
-    const usersNpub = hexToNpub(usersPubkey!)
-    const isLastSigner = checkIsLastSigner(signers)
-    if (isLastSigner) {
-      signers.forEach((signer) => {
-        if (signer !== usersNpub) {
-          userSet.add(signer)
-        }
-      })
-
-      viewers.forEach((viewer) => userSet.add(viewer))
-    } else {
-      const currentSignerIndex = signers.indexOf(usersNpub)
-      const prevSigners = signers.slice(0, currentSignerIndex)
-
-      prevSigners.forEach((signer) => {
-        userSet.add(signer)
-      })
-
-      const nextSigner = signers[currentSignerIndex + 1]
-      userSet.add(nextSigner)
-    }
-    return Array.from(userSet)
-  }
-
-  const notifyUsers = async (meta: Meta) => {
-    try {
-      const usersToNotify = getUsersToNotify()
-      return await Promise.allSettled(
-        usersToNotify.map(async (user) =>
-          sendNotification(npubToHex(user)!, meta)
-        )
-      )
-    } catch (error) {
-      throw new Error('There was a problem sending notifications to users', {
-        cause: error
-      })
-    }
-  }
-
-  const handleRenotifyUsers = async () => {
-    try {
-      setIsLoading(true)
-      const notifications = await notifyUsers(meta!)
-      checkNotifications(notifications)
-    } catch (error) {
-      console.error(error)
-      toast.error('There was an error re-notifying users')
-    } finally {
-      setIsLoading(false)
-    }
-  }
-
   if (authUrl) {
     return (
       <iframe
@@ -991,12 +967,6 @@ export const SignPage = () => {
                 </Button>
               </Box>
             )}
-
-            <Box sx={{ mt: 1, display: 'flex', justifyContent: 'center' }}>
-              <Button onClick={handleRenotifyUsers} variant="contained">
-                Re-notify Next Signer
-              </Button>
-            </Box>
           </>
         )}
       </Container>

src/utils/nostr.ts

@@ -916,33 +916,50 @@ const processReceivedEvent = async (event: Event, difficulty: number = 5) => {
  * @param meta - Metadata associated with the notification.
  */
 export const sendNotification = async (receiver: string, meta: Meta) => {
-  try {
-    // Retrieve the user's public key from the state
-    const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
-    // Create an unsigned event object with the provided metadata
-    const unsignedEvent: UnsignedEvent = {
-      kind: 938,
-      pubkey: usersPubkey,
-      content: JSON.stringify(meta),
-      tags: [],
-      created_at: unixNow()
-    }
+  // Retrieve the user's public key from the state
+  const usersPubkey = (store.getState().auth as AuthState).usersPubkey!
 
-    // Wrap the unsigned event with the receiver's information
-    const wrappedEvent = createWrap(unsignedEvent, receiver)
-
-    // Instantiate the MetadataController to retrieve relay list metadata
-    const metadataController = new MetadataController()
-
-    const relaySet = await metadataController.findRelayListMetadata(receiver)
-
-    return await Promise.race([
-      relayController.publish(wrappedEvent, relaySet.read),
-      timeout(40 * 1000)
-    ])
-  } catch (error) {
-    throw new Error(`Failed to publish a notification for ${receiver}`, {
-      cause: error
-    })
+  // Create an unsigned event object with the provided metadata
+  const unsignedEvent: UnsignedEvent = {
+    kind: 938,
+    pubkey: usersPubkey,
+    content: JSON.stringify(meta),
+    tags: [],
+    created_at: unixNow()
   }
+
+  // Wrap the unsigned event with the receiver's information
+  const wrappedEvent = createWrap(unsignedEvent, receiver)
+
+  // Instantiate the MetadataController to retrieve relay list metadata
+  const metadataController = new MetadataController()
+  const relaySet = await metadataController
+    .findRelayListMetadata(receiver)
+    .catch((err) => {
+      // Log an error if retrieving relay list metadata fails
+      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 Promise.race([
+    relayController.publish(wrappedEvent, relaySet.read),
+    timeout(40 * 1000)
+  ]).catch((err) => {
+    // Log an error if publishing the notification event fails
+    console.log(
+      `An error occurred while publishing notification event for ${hexToNpub(receiver)}`,
+      err
+    )
+    throw err
+  })
 }

src/utils/notifications.ts

@@ -1,26 +0,0 @@
-import { isPromiseFulfilled, isPromiseRejected } from './utils.ts'
-import { toast } from 'react-toastify'
-
-const checkNotifications = (
-  notifications: PromiseSettledResult<string[]>[]
-) => {
-  if (notifications.every(isPromiseFulfilled)) {
-    toast.success('Notifications sent successfully')
-  } else {
-    logRejectedNotifications(notifications)
-    toast.error(
-      'Some notifications failed to publish. Please rebroadcast them again.'
-    )
-  }
-}
-
-const logRejectedNotifications = (
-  notifications: PromiseSettledResult<string[]>[]
-) => {
-  notifications
-    .filter(isPromiseRejected)
-    .map((res: PromiseRejectedResult) => (res.reason as Error).message)
-    .forEach((message: string) => console.log(message))
-}
-
-export { checkNotifications }

src/utils/relays.ts

@@ -1,6 +1,6 @@
-import { Event, Filter, kinds, Relay, UnsignedEvent } from 'nostr-tools'
+import { Event, Filter, kinds, UnsignedEvent } from 'nostr-tools'
 import { RelayList } from 'nostr-tools/kinds'
-import { getRelayInfo, timeout, unixNow } from '.'
+import { getRelayInfo, unixNow } from '.'
 import { NostrController, relayController } from '../controllers'
 import { localCache } from '../services'
 import { RelayMap, RelaySet } from '../types'
@@ -229,16 +229,6 @@ const publishRelayMap = async (
   return Promise.reject('Publishing updated relay map was unsuccessful.')
 }
 
-const publishToRelay = async (relay: Relay, event: Event): Promise<string> => {
-  try {
-    await Promise.race([relay.publish(event), timeout(20 * 1000)])
-    return relay.url
-  } catch (err) {
-    console.error(`Failed to publish event on relay: ${relay.url}`, err)
-    throw new Error(`Failed to publish event on relay: ${relay.url}`)
-  }
-}
-
 export {
   findRelayListAndUpdateCache,
   findRelayListInCache,
@@ -248,6 +238,5 @@ export {
   getUserRelaySet,
   isOlderThanOneDay,
   isOlderThanOneWeek,
-  publishRelayMap,
-  publishToRelay
+  publishRelayMap
 }

src/utils/utils.ts

@@ -118,15 +118,3 @@ export const settleAllFullfilfedPromises = async <Item, FulfilledItem = Item>(
     return acc
   }, [])
 }
-
-export const isPromiseFulfilled = <T>(
-  result: PromiseSettledResult<T>
-): result is PromiseFulfilledResult<T> => {
-  return result.status === 'fulfilled'
-}
-
-export const isPromiseRejected = <T>(
-  result: PromiseSettledResult<T>
-): result is PromiseRejectedResult => {
-  return result.status === 'rejected'
-}