feat: added logic to handle errors depending on progress

src/entries/Background/db.ts

@@ -115,6 +115,7 @@ export async function setNotaryRequestError(
 export async function setNotaryRequestProgress(
   id: string,
   progress: RequestProgress,
+  errorMessage?: string,
 ): Promise<RequestHistory | null> {
   const existing = await historyDb.get(id);
 
@@ -123,6 +124,7 @@ export async function setNotaryRequestProgress(
   const newReq: RequestHistory = {
     ...existing,
     progress,
+    errorMessage,
   };
 
   await historyDb.put(id, newReq);

src/entries/Background/rpc.ts

@@ -170,7 +170,10 @@ export enum RequestProgress {
   Error,
 }
 
-export function progressText(progress: RequestProgress): string {
+export function progressText(
+  progress: RequestProgress,
+  errorMessage?: string,
+): string {
   switch (progress) {
     case RequestProgress.CreatingProver:
       return 'Creating prover...';
@@ -185,7 +188,9 @@ export function progressText(progress: RequestProgress): string {
     case RequestProgress.FinalizingOutputs:
       return 'Finalizing notarization outputs...';
     case RequestProgress.Error:
-      return 'Notarization Failed';
+      return errorMessage
+        ? errorMessage
+        : 'Error: Notarization Failed';
   }
 }
 
@@ -211,6 +216,7 @@ export type RequestHistory = {
   secretHeaders?: string[];
   secretResps?: string[];
   cid?: string;
+  errorMessage?: string;
   metadata?: {
     [k: string]: string;
   };
@@ -431,9 +437,9 @@ async function handleUpdateRequestProgress(
   request: BackgroundAction,
   sendResponse: (data?: any) => void,
 ) {
-  const { id, progress } = request.data;
+  const { id, progress, errorMessage } = request.data;
 
-  const newReq = await setNotaryRequestProgress(id, progress);
+  const newReq = await setNotaryRequestProgress(id, progress, errorMessage);
   if (!newReq) return;
   await pushToRedux(addRequestHistory(await getNotaryRequest(id)));
 

src/entries/Offscreen/rpc.ts

@@ -451,35 +451,50 @@ async function createProver(options: {
 
   const hostname = urlify(url)?.hostname || '';
   const notary = NotaryServer.from(notaryUrl);
-  try {
-    updateRequestProgress(id, RequestProgress.CreatingProver);
-    const prover: TProver = await new Prover({
+
+  let prover: TProver;
+  prover = await handleProgress(
+    id,
+    RequestProgress.CreatingProver,
+    () => new Prover({
       id,
       serverDns: hostname,
       maxSentData,
       maxRecvData,
-    });
+    }),
+    'Error creating prover'
+  );
 
-    updateRequestProgress(id, RequestProgress.GettingSession);
-    const sessionUrl = await notary.sessionUrl(maxSentData, maxRecvData);
+  const sessionUrl = await handleProgress(
+    id,
+    RequestProgress.GettingSession,
+    () => notary.sessionUrl(maxSentData, maxRecvData),
+    'Error getting session from Notary'
+  );
 
-    updateRequestProgress(id, RequestProgress.SettingUpProver);
-    await prover.setup(sessionUrl);
+  await handleProgress(
+    id,
+    RequestProgress.SettingUpProver,
+    () => prover.setup(sessionUrl),
+    'Error setting up prover'
+  );
 
-    updateRequestProgress(id, RequestProgress.SendingRequest);
-    await prover.sendRequest(websocketProxyUrl + `?token=${hostname}`, {
-      url,
-      method,
-      headers,
-      body,
-    });
+  await handleProgress(
+    id,
+    RequestProgress.SendingRequest,
+    () =>
+      prover.sendRequest(websocketProxyUrl + `?token=${hostname}`, {
+        url,
+        method,
+        headers,
+        body,
+      }),
+    'Error sending request'
+  );
 
-    return prover;
-  } catch (error: any) {
-    updateRequestProgress(id, RequestProgress.Error);
-    throw error;
-  }
+  return prover;
 }
+
 async function verifyProof(
   proof: PresentationJSON,
 ): Promise<{ sent: string; recv: string }> {
@@ -508,13 +523,39 @@ async function verifyProof(
   return result;
 }
 
-function updateRequestProgress(id: string, progress: RequestProgress) {
-  devlog(`Request ${id}: ${progressText(progress)}`);
+function updateRequestProgress(
+  id: string,
+  progress: RequestProgress,
+  errorMessage?: string,
+) {
+  const progressMessage =
+    progress === RequestProgress.Error
+      ? `${errorMessage || 'Notarization Failed'}`
+      : progressText(progress);
+  console.log('ERROR MESSAGE', progressMessage);
+  devlog(`Request ${id}: ${progressMessage}`);
+
   browser.runtime.sendMessage({
     type: BackgroundActiontype.update_request_progress,
     data: {
       id,
-      progress: progress,
+      progress,
+      errorMessage,
     },
   });
 }
+
+async function handleProgress<T>(
+  id: string,
+  progress: RequestProgress,
+  action: () => Promise<T>,
+  errorMessage: string,
+): Promise<T> {
+  try {
+    updateRequestProgress(id, progress);
+    return await action();
+  } catch (error: any) {
+    updateRequestProgress(id, RequestProgress.Error, errorMessage);
+    throw error;
+  }
+}

src/entries/SidePanel/SidePanel.tsx

@@ -319,7 +319,7 @@ function StepContent(
         <Icon className="animate-spin" fa="fa-solid fa-spinner" size={1} />
         <span className="text-sm">
           {notaryRequest?.progress === 6
-            ? 'Error: Notarization Failed'
+            ? `${progressText(notaryRequest.progress, notaryRequest?.errorMessage)}`
             : notaryRequest?.progress
               ? `(${(
                   ((notaryRequest.progress + 1) / 6.06) *

src/pages/History/index.tsx

@@ -107,7 +107,7 @@ export function OneRequestHistory(props: {
               />
               <span className="">
                 {request?.progress === 6
-                  ? 'Error: Notarization Failed'
+                  ? `${progressText(request.progress, request.errorMessage)}`
                   : request?.progress
                     ? `(${(
                         ((request.progress + 1) / 6.06) *