packages/single-invoice/src/lib/single-invoice.svelte (1)

420-435: Fix potential race condition in account assignment.

The account assignment after the early return could be stale if the wallet state changes between the check and the assignment.

Apply this diff to fix the race condition:

 const handleWalletConnection = async () => {
-  if (!account?.address) return;
+  const currentAccount = getAccount(wagmiConfig);
+  if (!currentAccount?.address) return;
 
-  account = getAccount(wagmiConfig);
+  account = currentAccount;
 
   if (isDecryptionEnabled && requestId) {
     const isEncrypted = await isRequestEncrypted(requestId);
     if (isEncrypted) {
       await ensureDecryption();
     }
   }
 
   if (requestId && requestNetwork) {
     await getOneRequest(requestId);
   }
 };

packages/single-invoice/src/lib/single-invoice.svelte (2)

437-453: Improve cleanup atomicity in wallet disconnection.

The cleanup of local storage items should be atomic to prevent inconsistent states.

Apply this diff to improve the cleanup process:

 const handleWalletDisconnection = () => {
+  // First, clean up decryption state to prevent any ongoing operations
+  if (cipherProvider) {
+    cipherProvider.disconnectWallet();
+    // Clean up all storage items atomically
+    const storageItems = [
+      'lit-wallet-sig',
+      'lit-session-key',
+      'isDecryptionEnabled'
+    ];
+    storageItems.forEach(item => {
+      if (item === 'isDecryptionEnabled') {
+        localStorage.setItem(item, 'false');
+      } else {
+        localStorage.removeItem(item);
+      }
+    });
+  }
+
+  // Then reset all state variables
   account = undefined;
   address = undefined;
   request = undefined;
   requestData = null;
   signer = null;
   approved = false;
   isPayee = false;
-
-  // Clean up decryption state
-  if (cipherProvider) {
-    cipherProvider.disconnectWallet();
-    localStorage.removeItem("lit-wallet-sig");
-    localStorage.removeItem("lit-session-key");
-    localStorage.setItem("isDecryptionEnabled", "false");
-  }
 };

---

812-821: Address the FIXME comment by implementing proper rounding.

The current implementation truncates decimal numbers without rounding, which could lead to precision loss.

Would you like me to generate an implementation that properly rounds decimal numbers? Here's a suggested implementation:

-// FIXME: Add rounding functionality
 function truncateNumberString(
   value: string,
   maxDecimalDigits: number
 ): string {
   const [integerPart, decimalPart] = value.split(".");
-  return decimalPart
-    ? `${integerPart}.${decimalPart.substring(0, maxDecimalDigits)}`
-    : value;
+  if (!decimalPart) return value;
+  
+  const roundedDecimal = Number(`0.${decimalPart}`)
+    .toFixed(maxDecimalDigits);
+  
+  // Remove leading "0." from the rounded result
+  return `${integerPart}.${roundedDecimal.substring(2)}`;
 }

packages/invoice-dashboard/src/lib/view-requests.svelte (1)

501-564: Improve error handling in loadRequests.

The function could benefit from more robust error handling and cleanup in failure cases.

Apply this diff to improve error handling:

 const loadRequests = async (
   sliderValue: string,
   currentAccount: GetAccountReturnType | undefined,
   currentRequestNetwork: RequestNetwork | undefined | null
 ) => {
   if (!currentAccount?.address || !currentRequestNetwork || !cipherProvider)
     return;

   loading = true;
   const previousNetworks = [...selectedNetworks];

   try {
     if (sliderValue === "on") {
       if (localStorage?.getItem("isDecryptionEnabled") === "false") {
         queryClient.invalidateQueries();
       }
       try {
         const signer = await getEthersSigner(wagmiConfig);
         if (signer && currentAccount?.address) {
           loadSessionSignatures =
             localStorage?.getItem("lit-wallet-sig") === null;
           const signatures = await cipherProvider?.getSessionSignatures(
             signer,
             currentAccount.address,
             window.location.host,
             "Sign in to Lit Protocol through Request Network"
           );

           // Save both signatures
           localStorage?.setItem(
             "lit-wallet-sig",
             JSON.stringify({
               address: currentAccount.address,
               timestamp: Date.now(),
               sig: signatures.walletSig,
             })
           );
           localStorage?.setItem("lit-session-key", signatures.sessionKey);

           cipherProvider?.enableDecryption(true);
           localStorage?.setItem("isDecryptionEnabled", JSON.stringify(true));
         }
       } catch (error) {
         console.error("Failed to enable decryption:", error);
         toast.error("Failed to enable decryption.");
+        // Clean up any partial state
+        localStorage?.removeItem("lit-wallet-sig");
+        localStorage?.removeItem("lit-session-key");
+        localStorage?.setItem("isDecryptionEnabled", "false");
         return;
       } finally {
         loadSessionSignatures = false;
       }
     } else {
       if (localStorage?.getItem("isDecryptionEnabled") === "true") {
         queryClient.invalidateQueries();
       }
       cipherProvider?.enableDecryption(false);
       localStorage?.setItem("isDecryptionEnabled", JSON.stringify(false));
     }
     await getRequests(currentAccount, currentRequestNetwork);
     selectedNetworks = previousNetworks; // Restore selection
   } catch (error) {
+    console.error("Failed to load requests:", error);
+    toast.error("Failed to load requests. Please try again.");
+    // Restore previous state
+    selectedNetworks = previousNetworks;
   } finally {
     loading = false;
   }
-  await getRequests(currentAccount, currentRequestNetwork);
-  loading = false;
 };

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro