feat(mobile): add integration with gateway backend for notifications feature

apps/mobile/package.json

@@ -90,6 +90,7 @@
     "react-native-device-info": "^14.0.1",
     "react-native-draggable-flatlist": "^4.0.1",
     "react-native-gesture-handler": "~2.20.2",
+    "react-native-get-random-values": "^1.11.0",
     "react-native-keychain": "^9.2.2",
     "react-native-mmkv": "^3.1.0",
     "react-native-pager-view": "^6.5.1",
@@ -103,6 +104,7 @@
     "react-redux": "^9.1.2",
     "redux": "^5.0.1",
     "redux-persist": "^6.0.0",
+    "siwe": "^3.0.0",
     "tamagui": "^1.117.1",
     "timezone-mock": "^1.3.6",
     "tsconfig-paths-webpack-plugin": "^4.2.0"
@@ -135,6 +137,7 @@
     "@types/lodash": "^4.17.13",
     "@types/node": "^22.9.1",
     "@types/react": "~18.3.12",
+    "@types/react-native-get-random-values": "^1",
     "babel-loader": "^8.4.1",
     "eslint": "^9.19.0",
     "eslint-config-prettier": "^9.1.0",

apps/mobile/src/hooks/useDelegateKey.ts

@@ -0,0 +1,176 @@
+import { useState, useCallback } from 'react'
+import DeviceInfo from 'react-native-device-info'
+import 'react-native-get-random-values'
+import { HDNodeWallet, Wallet } from 'ethers'
+import { useAuthGetNonceV1Query, useAuthVerifyV1Mutation } from '@safe-global/store/gateway/AUTO_GENERATED/auth'
+import {
+  useNotificationsDeleteSubscriptionV2Mutation,
+  useNotificationsUpsertSubscriptionsV2Mutation,
+} from '@safe-global/store/gateway/AUTO_GENERATED/notifications'
+
+import Logger from '@/src/utils/logger'
+import { Address } from '@/src/types/address'
+import { selectActiveSafe } from '@/src/store/activeSafeSlice'
+import { useAppSelector } from '@/src/store/hooks'
+import { useSiwe } from './useSiwe'
+import { useSign } from './useSign'
+import { isAndroid } from '../config/constants'
+import { selectFCMToken } from '../store/notificationsSlice'
+
+const ERROR_MSG = 'useDelegateKey: Something went wrong'
+
+export function useDelegateKey() {
+  // Local states
+  const [loading, setLoading] = useState<boolean>(false)
+  const [error, setError] = useState<unknown>(null)
+
+  // Queries
+  const [authVerifyV1] = useAuthVerifyV1Mutation()
+  const [notificationsUpsertSubscriptionsV2] = useNotificationsUpsertSubscriptionsV2Mutation()
+  const [notificationsDeleteSubscriptionsV2] = useNotificationsDeleteSubscriptionV2Mutation()
+  // Custom hooks
+  const { signMessage } = useSiwe()
+  const { getPrivateKey } = useSign()
+
+  // Redux states
+  const activeSafe = useAppSelector(selectActiveSafe)
+  const fcmToken = useAppSelector(selectFCMToken)
+
+  // Step 0 - Get the nonce to be included in the message to be sent to the backend
+  const { data } = useAuthGetNonceV1Query()
+
+  const createDelegate = useCallback(
+    async (ownerAddress: Address) => {
+      setLoading(true)
+      setError(null)
+      const nonce = data?.nonce
+      // Step 1 - Try to get the owner's private key
+      const ownerPrivateKey = await getPrivateKey()
+
+      try {
+        if (!ownerAddress || !activeSafe || !nonce || !fcmToken) {
+          throw Logger.info(ERROR_MSG)
+        }
+
+        // Step 2 - Create a new random (delegated) private key in case the owner's private key is not available
+        //TODO: Double check if we have a wallet stored already avoiding to create a new one
+        const signerAccount = ownerPrivateKey ? new Wallet(ownerPrivateKey) : Wallet.createRandom()
+
+        if (!signerAccount) {
+          throw Logger.error(ERROR_MSG, error)
+        }
+
+        // Step 3 - Create a message following the SIWE standard
+        const siweMessage = `SafeWallet wants you to sign in with your Ethereum account:
+${signerAccount.address}
+
+Sign in with Ethereum to the app.
+
+URI: https://safe.global
+Version: 1
+Chain ID: ${activeSafe.chainId}
+Nonce: ${nonce}
+Issued At: ${new Date().toISOString()}`
+
+        // Step 4 - Triggers the backend to create the delegate
+        await createOnBackEnd({
+          safeAddress: activeSafe.address,
+          signer: signerAccount,
+          message: siweMessage,
+          chainId: activeSafe.chainId,
+          fcmToken,
+        })
+      } catch (err) {
+        Logger.error('useDelegateKey: Something went wrong', err)
+        setError(err)
+        return
+      } finally {
+        setLoading(false)
+      }
+    },
+    [data, activeSafe, fcmToken],
+  )
+
+  const deleteDelegate = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      await deleteOnBackEnd()
+    } catch (err) {
+      Logger.error('useDelegateKey: Something went wrong', err)
+      setError(err)
+      return
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  const createOnBackEnd = useCallback(
+    async ({
+      safeAddress,
+      signer,
+      message,
+      chainId,
+      fcmToken,
+    }: {
+      safeAddress: Address
+      signer: HDNodeWallet | Wallet
+      message: string
+      chainId: string
+      fcmToken: string
+    }) => {
+      const signature = await signMessage({ signer, message })
+      try {
+        await authVerifyV1({
+          siweDto: {
+            message,
+            signature,
+          },
+        })
+
+        const deviceUuid = await DeviceInfo.getUniqueId()
+
+        await notificationsUpsertSubscriptionsV2({
+          upsertSubscriptionsDto: {
+            cloudMessagingToken: fcmToken,
+            safes: [
+              {
+                chainId,
+                address: safeAddress,
+                notificationTypes: ['MESSAGE_CONFIRMATION_REQUEST', 'CONFIRMATION_REQUEST'],
+              },
+            ],
+            deviceType: isAndroid ? 'ANDROID' : 'IOS',
+            deviceUuid,
+          },
+        })
+      } catch (err) {
+        Logger.error('CreateDelegateFailed', err)
+        setError(err)
+        return
+      }
+    },
+    [],
+  )
+
+  const deleteOnBackEnd = useCallback(async () => {
+    try {
+      await notificationsDeleteSubscriptionsV2({
+        deviceUuid: await DeviceInfo.getUniqueId(),
+        chainId: activeSafe.chainId,
+        safeAddress: activeSafe.address,
+      })
+    } catch (err) {
+      Logger.error('DeleteDelegateFailed', err)
+      setError(err)
+      return
+    }
+  }, [])
+
+  return {
+    loading,
+    error,
+    createDelegate,
+    deleteDelegate,
+  }
+}

apps/mobile/src/hooks/useSign/useSign.ts

@@ -25,8 +25,8 @@ export function useSign() {
       await Keychain.setGenericPassword(
         'signer_address',
         JSON.stringify({
-          encryptyedPassword: encryptyedPrivateKey.encryptedText,
-          iv: encryptyedPrivateKey.iv,
+          encryptedPassword: encryptedPrivateKey.encryptedText,
+          iv: encryptedPrivateKey.iv,
         }),
         {
           accessControl: Keychain.ACCESS_CONTROL.BIOMETRY_CURRENT_SET_OR_DEVICE_PASSCODE,

apps/mobile/src/hooks/useSiwe.ts

@@ -0,0 +1,36 @@
+import { HDNodeWallet, Wallet } from 'ethers'
+import { useCallback } from 'react'
+import { SiweMessage } from 'siwe'
+
+interface SiweMessageProps {
+  address: string
+  chainId: number
+  nonce: string
+  statement: string
+}
+
+export function useSiwe() {
+  const createSiweMessage = useCallback(({ address, chainId, nonce, statement }: SiweMessageProps) => {
+    const message = new SiweMessage({
+      address,
+      chainId,
+      domain: 'global.safe.mobileapp',
+      statement,
+      nonce,
+      uri: 'https://safe.global',
+      version: '1',
+      issuedAt: new Date().toISOString(),
+    })
+    return message.prepareMessage()
+  }, [])
+
+  const signMessage = useCallback(async ({ signer, message }: { signer: HDNodeWallet | Wallet; message: string }) => {
+    const signature = await signer.signMessage(message)
+    return signature
+  }, [])
+
+  return {
+    createSiweMessage,
+    signMessage,
+  }
+}

apps/mobile/src/services/notifications/FCMService.ts

@@ -20,6 +20,9 @@ class FCMService {
   async saveFCMToken(): Promise<void> {
     try {
       const fcmToken = await messaging().getToken()
+
+      Logger.info('FCMService :: fcmToken', fcmToken)
+
       if (fcmToken) {
         store.dispatch(savePushToken(fcmToken))
       }
@@ -52,16 +55,17 @@ class FCMService {
   }
 
   async registerAppWithFCM(): Promise<void> {
-    if (!messaging().registerDeviceForRemoteMessages) {
-      await messaging()
-        .registerDeviceForRemoteMessages()
-        .then((status: unknown) => {
-          Logger.info('registerDeviceForRemoteMessages status', status)
-        })
-        .catch((error) => {
-          Logger.error('registerAppWithFCM: Something went wrong', error)
-        })
-    }
+    // if (!messaging().registerDeviceForRemoteMessages) {
+    console.log('registerAppWithFCM :: CALLED')
+    await messaging()
+      .registerDeviceForRemoteMessages()
+      .then((status: unknown) => {
+        Logger.info('registerDeviceForRemoteMessages status', status)
+      })
+      .catch((error) => {
+        Logger.error('registerAppWithFCM: Something went wrong', error)
+      })
+    // }
   }
 }
 export default new FCMService()

apps/mobile/src/store/constants.ts

@@ -343,3 +343,6 @@ export enum PressActionId {
 }
 
 export const LAUNCH_ACTIVITY = 'global.safe.mobileapp.ui.MainActivity'
+
+export const asymmetricKey = 'safe'
+export const keychainGenericPassword = 'safeuser'

packages/store/src/gateway/cgwClient.ts

@@ -11,6 +11,12 @@ export const getBaseUrl = () => {
 }
 export const rawBaseQuery = fetchBaseQuery({
   baseUrl: '/',
+  credentials: 'include',
+  headers: {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    'Set-Cookie': 'HttpOnly;Secure;SameSite=None',
+  },
 })
 
 export const dynamicBaseQuery: BaseQueryFn<string | FetchArgs, unknown, FetchBaseQueryError> = async (