(core) + (tauri): cherry picks & version bump (#5005)

* (tauri) Update account summary when account state changes (#5002)

* Handle accountState == `offline` (#4996)

* (core) Add new `handle_subscription_payment` rpc method (#4998)

* Bump version to `1.27.0-rc5`

Author: agentpietrucha

nym-vpn-app/src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "nym-vpn-app"
-version = "1.27.0-rc4"
+version = "1.27.0-rc5"
 description = "NymVPN desktop client"
 authors = [
     "Nym Technologies SA <contact@nymtech.net>",

nym-vpn-app/src-tauri/Cargo.toml

@@ -209,3 +209,12 @@ pub async fn get_account_summary(
         e.into()
     })
 }
+
+#[instrument(skip_all)]
+#[tauri::command]
+pub async fn handle_subscription_payment(vpnd: State<'_, VpndClient>) -> Result<(), BackendError> {
+    vpnd.handle_subscription_payment().await.map_err(|e| {
+        error!("failed to handle subscription payment: {e}");
+        e.into()
+    })
+}

nym-vpn-app/src-tauri/src/commands/account.rs

@@ -327,6 +327,7 @@ async fn main() -> Result<()> {
             account::store_deeplink_account,
             account::get_autologin_deeplink,
             account::get_account_summary,
+            account::handle_subscription_payment,
             cmd_daemon::daemon_status,
             cmd_daemon::set_network,
             cmd_daemon::system_messages,

nym-vpn-app/src-tauri/src/main.rs

@@ -985,6 +985,17 @@ impl VpndClient {
         Ok(summary.map(Into::into))
     }
 
+    pub async fn handle_subscription_payment(&self) -> Result<(), VpndError> {
+        let mut vpnd = self.vpnd().await?;
+
+        vpnd.handle_subscription_payment()
+            .or_else(async |e| {
+                self.handle_rpc_error("handle_subscription_payment", e)
+                    .await
+            })
+            .await
+    }
+
     /// Run network diagnostics
     #[instrument(skip_all)]
     pub async fn run_diagnostic(

nym-vpn-app/src-tauri/src/vpnd/client.rs

@@ -1,5 +1,5 @@
 import { openUrl } from '@tauri-apps/plugin-opener';
-import { useEffect, useRef, useState } from 'react';
+import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { invoke } from '@tauri-apps/api/core';
 import { useNavigate } from 'react-router';
@@ -9,6 +9,7 @@ import { useDeepLink } from '../../hooks';
 import { routes } from '../../router';
 import { CCache } from '../../cache';
 import { StateDispatch, TAccountMode } from '../../types';
+import { DeeplinkTimeout } from '../../errors';
 
 function PrivyButton() {
   const { t, i18n } = useTranslation('login');
@@ -20,16 +21,6 @@ function PrivyButton() {
   const dispatch = useMainDispatch() as StateDispatch;
 
   const [loading, setLoading] = useState(false);
-  const timeoutIdRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  useEffect(() => {
-    return () => {
-      if (timeoutIdRef.current !== null) {
-        clearTimeout(timeoutIdRef.current);
-        timeoutIdRef.current = null;
-      }
-    };
-  }, []);
 
   const refreshAccountMode = async () => {
     const accountMode = await invoke<TAccountMode>('get_account_mode');
@@ -46,17 +37,7 @@ function PrivyButton() {
     openUrl(loginUrl);
 
     try {
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        timeoutIdRef.current = setTimeout(
-          () => reject(new Error('Login timeout')),
-          300000,
-        );
-      });
-
-      const deeplinkurl = await Promise.race([
-        startListening(),
-        timeoutPromise,
-      ]);
+      const deeplinkurl = await startListening(300000);
 
       await invoke('store_deeplink_account', {
         callbackUrl: deeplinkurl,
@@ -75,7 +56,7 @@ function PrivyButton() {
       dispatch({ type: 'reset-error' });
     } catch (error) {
       console.error('Privy login error: ', error);
-      if (error instanceof Error && error.message === 'Login timeout') {
+      if (error instanceof DeeplinkTimeout) {
         push({
           message: t('privy.error.timeout'),
           type: 'error',
@@ -91,10 +72,6 @@ function PrivyButton() {
         });
       }
     } finally {
-      if (timeoutIdRef.current !== null) {
-        clearTimeout(timeoutIdRef.current);
-        timeoutIdRef.current = null;
-      }
       setLoading(false);
     }
   };

nym-vpn-app/src/components/privy/PrivyButton.tsx

@@ -8,10 +8,14 @@ export type AutologinKind = Extract<
 
 export type AutologinContextType = {
   autologin: (kind: AutologinKind) => Promise<void>;
+  closeDialog: () => void;
 };
 
 const initialState: AutologinContextType = {
   autologin: async () => Promise.resolve(),
+  closeDialog: () => {
+    /* SCARECROW */
+  },
 };
 
 export const AutologinContext =

nym-vpn-app/src/contexts/autologin/context.ts

@@ -32,16 +32,23 @@ export function AutologinProvider({ children }: { children: React.ReactNode }) {
       } catch (error) {
         console.error('Failed to get autologin deeplink', error);
         push({
-          message: t('autologin.initialization-error'),
+          message: t('autologin.initialization-error', { ns: 'errors' }),
           type: 'error',
           duration: 3000,
         });
       }
     },
-    [i18n.language, t, push],
+    [i18n.language, push, t],
   );
 
-  const ctx = useMemo(() => ({ autologin }), [autologin]);
+  const closeDialog = useCallback(() => {
+    setOpen(false);
+  }, []);
+
+  const ctx = useMemo(
+    () => ({ autologin, closeDialog }),
+    [autologin, closeDialog],
+  );
 
   return (
     <AutologinContext.Provider value={ctx}>

nym-vpn-app/src/contexts/autologin/provider.tsx

@@ -3,6 +3,7 @@ import React, { useEffect, useReducer } from 'react';
 import { InitState, SystemMessage } from '../../types';
 import { initFirstBatch, initSecondBatch } from '../../state/init';
 import { useTauriEvents } from '../../state/useTauriEvents';
+import { useAccountSummaryOnAccountState } from '../../state/useAccountSummaryOnAccountState';
 import { useInAppNotify } from '../in-app-notification';
 import { daemonStatusUpdate, networkEnvChanged } from '../../state/helper';
 import { CCache } from '../../cache';
@@ -38,6 +39,12 @@ function MainStateProvider({ children, init }: Props) {
 
   const { push } = useInAppNotify();
   useTauriEvents(dispatch, push);
+  useAccountSummaryOnAccountState(
+    state.accountState,
+    state.accountSyncing,
+    state.initialized,
+    dispatch,
+  );
 
   // initialize app state
   useEffect(() => {

nym-vpn-app/src/contexts/main/provider.tsx

@@ -0,0 +1,8 @@
+/** Thrown when `useDeepLink`’s `startListening` exceeds the given timeout. */
+export class DeeplinkTimeout extends Error {
+  constructor(message = 'Deeplink timed out') {
+    super(message);
+    this.name = 'DeeplinkTimeout';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}