@dynamic-labs/sdk-react-core 4.78.0 → 4.79.0

package/src/lib/utils/hooks/useGoogleDriveBackupReadiness/index.d.ts

@@ -0,0 +1 @@
+export { useGoogleDriveBackupReadiness, type GoogleDriveBackupReadiness, type GoogleDriveBackupReadinessStatus, type UseGoogleDriveBackupReadinessReturn, } from './useGoogleDriveBackupReadiness';

package/src/lib/utils/hooks/useGoogleDriveBackupReadiness/useGoogleDriveBackupReadiness.cjs

@@ -0,0 +1,222 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var React = require('react');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+require('@dynamic-labs-sdk/client/core');
+require('eventemitter3');
+require('@dynamic-labs/utils');
+require('@dynamic-labs-sdk/client');
+require('../../../config/ApiEndpoint.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+require('../../../shared/logger.cjs');
+require('@dynamic-labs/wallet-book');
+require('../../constants/colors.cjs');
+require('../../constants/values.cjs');
+require('../../../shared/consts/index.cjs');
+require('@dynamic-labs/multi-wallet');
+require('react-international-phone');
+require('../../../store/state/nonce/nonce.cjs');
+var api = require('../../../data/api/api.cjs');
+require('@dynamic-labs/locale');
+var dynamicContextProps = require('../../../store/state/dynamicContextProps/dynamicContextProps.cjs');
+require('../../../store/state/primaryWalletId/primaryWalletId.cjs');
+require('../../../store/state/connectedWalletsInfo/connectedWalletsInfo.cjs');
+require('../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.cjs');
+require('../../../events/dynamicEvents.cjs');
+var useUser = require('../../../client/extension/user/useUser/useUser.cjs');
+var useRefreshAuth = require('../useRefreshAuth/useRefreshAuth.cjs');
+var useSocialAccounts = require('../useSocialAccounts/useSocialAccounts.cjs');
+var googleDriveScopes = require('../useWalletBackup/googleDriveScopes.cjs');
+
+const IDLE = {
+    isChecking: false,
+    missingScopes: [],
+    status: 'idle',
+};
+// Returns the UUID of the user_oauth_accounts row backing the linked Google
+// credential. The path param of /sdk/.../oauthAccounts/:id/accessToken expects
+// this UUID — *not* the third-party `oauthAccountId` (Google's numeric profile
+// ID), which is what JwtVerifiedCredential.oauthAccountId stores.
+const findGoogleOauthAccountId = (credentials) => {
+    var _a, _b;
+    return (_b = (_a = credentials === null || credentials === void 0 ? void 0 : credentials.find((cred) => cred.format === 'oauth' && cred.oauthProvider === sdkApiCore.ProviderEnum.Google)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined;
+};
+/**
+ * Pre-flight readiness check for backing up MPC keyshares to Google Drive.
+ *
+ * Recommended pattern: call `check()` when the user opens the "Backup to
+ * Google Drive" CTA. If `status` is `'needs-access'`, prompt the user and
+ * call `requestAccess()` to re-prompt the Google consent screen. Then
+ * proceed with `useWalletBackup().backupWallet(...)`.
+ *
+ * Status values:
+ * - `'idle'`: never checked / after `reset()`.
+ * - `'ready'`: stored scopes include both required Drive scopes; backup
+ *   should succeed (barring transient errors).
+ * - `'needs-access'`: backup likely won't succeed without user intervention.
+ *   Covers (a) missing scopes — `missingScopes` lists the gap, (b) no Google
+ *   account linked — `missingScopes` is populated with the full required set
+ *   so callers can render copy directly, and (c) legacy tokens captured
+ *   before scope tracking shipped (`scopes: []` from the API) — indicated
+ *   by an empty `missingScopes` array. Call `requestAccess()` to recover.
+ * - `'error'`: the underlying fetch or relink rejected. `error` holds
+ *   the cause.
+ *
+ * `isChecking` is true while a `check()` or `requestAccess()` is in flight.
+ *
+ * `missingScopes` lists the scopes the user still needs to grant. When no
+ * Google account is linked, this is the full required set; when scopes are
+ * known to be partially missing, only the missing ones; for legacy
+ * "unknown scopes" tokens, the array is empty.
+ *
+ * @example
+ * ```tsx
+ * function BackupButton({ wallet }) {
+ *   const { status, missingScopes, isChecking, check, requestAccess } =
+ *     useGoogleDriveBackupReadiness();
+ *   const { backupWallet, lastBackupError, clearBackupError } = useWalletBackup();
+ *
+ *   // Layer 2: post-flight fallback — needed for legacy users where the stored
+ *   // `scopes` is empty so pre-flight returned 'unknown'. Because `lastBackupError`
+ *   // is React state it won't update until the next render; read it in a
+ *   // useEffect rather than synchronously after `await backupWallet(...)`.
+ *   useEffect(() => {
+ *     if (lastBackupError && isInsufficientGoogleDriveScopesError(lastBackupError)) {
+ *       clearBackupError();
+ *       requestAccess(); // re-prompt consent, then caller can retry backupWallet
+ *     }
+ *   }, [lastBackupError]);
+ *
+ *   const onBackup = async () => {
+ *     // Layer 1: pre-flight readiness — saves an MPC reshare ceremony when
+ *     // we can already tell the upload will fail.
+ *     let r = await check();
+ *     if (r.status === 'needs-access') {
+ *       r = await requestAccess(); // popup re-consent
+ *       if (r.status !== 'ready') return; // user cancelled or relink failed
+ *     }
+ *
+ *     await backupWallet(wallet, 'GoogleDrive');
+ *     // If the backup failed due to missing scopes, the useEffect above will
+ *     // fire on the next render with the updated lastBackupError.
+ *   };
+ *
+ *   return (
+ *     <>
+ *       {status === 'needs-access' && (
+ *         <p>We need access to: {missingScopes.join(', ')}</p>
+ *       )}
+ *       <button onClick={onBackup} disabled={isChecking}>Backup to Drive</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+const useGoogleDriveBackupReadiness = () => {
+    const user = useUser.useUser();
+    const environmentId = dynamicContextProps.useEnvironmentId();
+    const refresh = useRefreshAuth.useRefreshAuth();
+    const { linkSocialAccount } = useSocialAccounts.useSocialAccounts();
+    const [readiness, setReadiness] = React.useState(IDLE);
+    const performCheck = React.useCallback((verifiedCredentials) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const oauthAccountId = findGoogleOauthAccountId(verifiedCredentials);
+        if (!oauthAccountId) {
+            // No Google credential linked — every required scope is effectively
+            // missing, so populate the full set so callers can render
+            // "we need access to ..." UX without checking the empty case.
+            const result = {
+                isChecking: false,
+                missingScopes: googleDriveScopes.GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES,
+                status: 'needs-access',
+            };
+            setReadiness(result);
+            return result;
+        }
+        try {
+            const { accessToken, scopes } = yield api.sdkApi().getEndUserOauthAccessToken({
+                environmentId,
+                oauthAccountId,
+            });
+            // Empty scopes = legacy token captured before scope tracking; we
+            // can't confirm the upload will work, so surface as needs-access
+            // (with empty missingScopes to differentiate from the explicit
+            // missing case). requestAccess() forces a fresh token so the
+            // column populates.
+            if (scopes.length === 0) {
+                const result = {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: [],
+                    status: 'needs-access',
+                };
+                setReadiness(result);
+                return result;
+            }
+            const missing = googleDriveScopes.findMissingGoogleDriveBackupScopes(scopes);
+            const result = missing.length === 0
+                ? {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: [],
+                    status: 'ready',
+                }
+                : {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: missing,
+                    status: 'needs-access',
+                };
+            setReadiness(result);
+            return result;
+        }
+        catch (error) {
+            const result = {
+                error,
+                isChecking: false,
+                missingScopes: [],
+                status: 'error',
+            };
+            setReadiness(result);
+            return result;
+        }
+    }), [environmentId]);
+    const check = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        setReadiness((prev) => (Object.assign(Object.assign({}, prev), { isChecking: true })));
+        return performCheck(user === null || user === void 0 ? void 0 : user.verifiedCredentials);
+    }), [performCheck, user]);
+    const requestAccess = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        setReadiness((prev) => (Object.assign(Object.assign({}, prev), { isChecking: true })));
+        try {
+            yield linkSocialAccount(sdkApiCore.ProviderEnum.Google, {
+                forcePopup: true,
+                showWidgetAfterConnection: false,
+            });
+            const updatedUser = yield refresh();
+            return performCheck((_a = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.verifiedCredentials) !== null && _a !== void 0 ? _a : user === null || user === void 0 ? void 0 : user.verifiedCredentials);
+        }
+        catch (error) {
+            const result = {
+                error,
+                isChecking: false,
+                missingScopes: [],
+                status: 'error',
+            };
+            setReadiness(result);
+            return result;
+        }
+    }), [linkSocialAccount, performCheck, refresh, user]);
+    const reset = React.useCallback(() => setReadiness(IDLE), []);
+    return Object.assign(Object.assign({}, readiness), { check,
+        requestAccess,
+        reset });
+};
+
+exports.useGoogleDriveBackupReadiness = useGoogleDriveBackupReadiness;

package/src/lib/utils/hooks/useGoogleDriveBackupReadiness/useGoogleDriveBackupReadiness.d.ts

@@ -0,0 +1,85 @@
+export type GoogleDriveBackupReadinessStatus = 'idle' | 'ready' | 'needs-access' | 'error';
+export type GoogleDriveBackupReadiness = {
+    status: GoogleDriveBackupReadinessStatus;
+    isChecking: boolean;
+    missingScopes: readonly string[];
+    accessToken?: string;
+    error?: unknown;
+};
+export type UseGoogleDriveBackupReadinessReturn = GoogleDriveBackupReadiness & {
+    check: () => Promise<GoogleDriveBackupReadiness>;
+    requestAccess: () => Promise<GoogleDriveBackupReadiness>;
+    reset: () => void;
+};
+/**
+ * Pre-flight readiness check for backing up MPC keyshares to Google Drive.
+ *
+ * Recommended pattern: call `check()` when the user opens the "Backup to
+ * Google Drive" CTA. If `status` is `'needs-access'`, prompt the user and
+ * call `requestAccess()` to re-prompt the Google consent screen. Then
+ * proceed with `useWalletBackup().backupWallet(...)`.
+ *
+ * Status values:
+ * - `'idle'`: never checked / after `reset()`.
+ * - `'ready'`: stored scopes include both required Drive scopes; backup
+ *   should succeed (barring transient errors).
+ * - `'needs-access'`: backup likely won't succeed without user intervention.
+ *   Covers (a) missing scopes — `missingScopes` lists the gap, (b) no Google
+ *   account linked — `missingScopes` is populated with the full required set
+ *   so callers can render copy directly, and (c) legacy tokens captured
+ *   before scope tracking shipped (`scopes: []` from the API) — indicated
+ *   by an empty `missingScopes` array. Call `requestAccess()` to recover.
+ * - `'error'`: the underlying fetch or relink rejected. `error` holds
+ *   the cause.
+ *
+ * `isChecking` is true while a `check()` or `requestAccess()` is in flight.
+ *
+ * `missingScopes` lists the scopes the user still needs to grant. When no
+ * Google account is linked, this is the full required set; when scopes are
+ * known to be partially missing, only the missing ones; for legacy
+ * "unknown scopes" tokens, the array is empty.
+ *
+ * @example
+ * ```tsx
+ * function BackupButton({ wallet }) {
+ *   const { status, missingScopes, isChecking, check, requestAccess } =
+ *     useGoogleDriveBackupReadiness();
+ *   const { backupWallet, lastBackupError, clearBackupError } = useWalletBackup();
+ *
+ *   // Layer 2: post-flight fallback — needed for legacy users where the stored
+ *   // `scopes` is empty so pre-flight returned 'unknown'. Because `lastBackupError`
+ *   // is React state it won't update until the next render; read it in a
+ *   // useEffect rather than synchronously after `await backupWallet(...)`.
+ *   useEffect(() => {
+ *     if (lastBackupError && isInsufficientGoogleDriveScopesError(lastBackupError)) {
+ *       clearBackupError();
+ *       requestAccess(); // re-prompt consent, then caller can retry backupWallet
+ *     }
+ *   }, [lastBackupError]);
+ *
+ *   const onBackup = async () => {
+ *     // Layer 1: pre-flight readiness — saves an MPC reshare ceremony when
+ *     // we can already tell the upload will fail.
+ *     let r = await check();
+ *     if (r.status === 'needs-access') {
+ *       r = await requestAccess(); // popup re-consent
+ *       if (r.status !== 'ready') return; // user cancelled or relink failed
+ *     }
+ *
+ *     await backupWallet(wallet, 'GoogleDrive');
+ *     // If the backup failed due to missing scopes, the useEffect above will
+ *     // fire on the next render with the updated lastBackupError.
+ *   };
+ *
+ *   return (
+ *     <>
+ *       {status === 'needs-access' && (
+ *         <p>We need access to: {missingScopes.join(', ')}</p>
+ *       )}
+ *       <button onClick={onBackup} disabled={isChecking}>Backup to Drive</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare const useGoogleDriveBackupReadiness: () => UseGoogleDriveBackupReadinessReturn;

package/src/lib/utils/hooks/useGoogleDriveBackupReadiness/useGoogleDriveBackupReadiness.js

@@ -0,0 +1,218 @@
+'use client'
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { useState, useCallback } from 'react';
+import { ProviderEnum } from '@dynamic-labs/sdk-api-core';
+import '@dynamic-labs-sdk/client/core';
+import 'eventemitter3';
+import '@dynamic-labs/utils';
+import '@dynamic-labs-sdk/client';
+import '../../../config/ApiEndpoint.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.js';
+import '../../../shared/logger.js';
+import '@dynamic-labs/wallet-book';
+import '../../constants/colors.js';
+import '../../constants/values.js';
+import '../../../shared/consts/index.js';
+import '@dynamic-labs/multi-wallet';
+import 'react-international-phone';
+import '../../../store/state/nonce/nonce.js';
+import { sdkApi } from '../../../data/api/api.js';
+import '@dynamic-labs/locale';
+import { useEnvironmentId } from '../../../store/state/dynamicContextProps/dynamicContextProps.js';
+import '../../../store/state/primaryWalletId/primaryWalletId.js';
+import '../../../store/state/connectedWalletsInfo/connectedWalletsInfo.js';
+import '../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.js';
+import '../../../events/dynamicEvents.js';
+import { useUser } from '../../../client/extension/user/useUser/useUser.js';
+import { useRefreshAuth } from '../useRefreshAuth/useRefreshAuth.js';
+import { useSocialAccounts } from '../useSocialAccounts/useSocialAccounts.js';
+import { findMissingGoogleDriveBackupScopes, GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES } from '../useWalletBackup/googleDriveScopes.js';
+
+const IDLE = {
+    isChecking: false,
+    missingScopes: [],
+    status: 'idle',
+};
+// Returns the UUID of the user_oauth_accounts row backing the linked Google
+// credential. The path param of /sdk/.../oauthAccounts/:id/accessToken expects
+// this UUID — *not* the third-party `oauthAccountId` (Google's numeric profile
+// ID), which is what JwtVerifiedCredential.oauthAccountId stores.
+const findGoogleOauthAccountId = (credentials) => {
+    var _a, _b;
+    return (_b = (_a = credentials === null || credentials === void 0 ? void 0 : credentials.find((cred) => cred.format === 'oauth' && cred.oauthProvider === ProviderEnum.Google)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined;
+};
+/**
+ * Pre-flight readiness check for backing up MPC keyshares to Google Drive.
+ *
+ * Recommended pattern: call `check()` when the user opens the "Backup to
+ * Google Drive" CTA. If `status` is `'needs-access'`, prompt the user and
+ * call `requestAccess()` to re-prompt the Google consent screen. Then
+ * proceed with `useWalletBackup().backupWallet(...)`.
+ *
+ * Status values:
+ * - `'idle'`: never checked / after `reset()`.
+ * - `'ready'`: stored scopes include both required Drive scopes; backup
+ *   should succeed (barring transient errors).
+ * - `'needs-access'`: backup likely won't succeed without user intervention.
+ *   Covers (a) missing scopes — `missingScopes` lists the gap, (b) no Google
+ *   account linked — `missingScopes` is populated with the full required set
+ *   so callers can render copy directly, and (c) legacy tokens captured
+ *   before scope tracking shipped (`scopes: []` from the API) — indicated
+ *   by an empty `missingScopes` array. Call `requestAccess()` to recover.
+ * - `'error'`: the underlying fetch or relink rejected. `error` holds
+ *   the cause.
+ *
+ * `isChecking` is true while a `check()` or `requestAccess()` is in flight.
+ *
+ * `missingScopes` lists the scopes the user still needs to grant. When no
+ * Google account is linked, this is the full required set; when scopes are
+ * known to be partially missing, only the missing ones; for legacy
+ * "unknown scopes" tokens, the array is empty.
+ *
+ * @example
+ * ```tsx
+ * function BackupButton({ wallet }) {
+ *   const { status, missingScopes, isChecking, check, requestAccess } =
+ *     useGoogleDriveBackupReadiness();
+ *   const { backupWallet, lastBackupError, clearBackupError } = useWalletBackup();
+ *
+ *   // Layer 2: post-flight fallback — needed for legacy users where the stored
+ *   // `scopes` is empty so pre-flight returned 'unknown'. Because `lastBackupError`
+ *   // is React state it won't update until the next render; read it in a
+ *   // useEffect rather than synchronously after `await backupWallet(...)`.
+ *   useEffect(() => {
+ *     if (lastBackupError && isInsufficientGoogleDriveScopesError(lastBackupError)) {
+ *       clearBackupError();
+ *       requestAccess(); // re-prompt consent, then caller can retry backupWallet
+ *     }
+ *   }, [lastBackupError]);
+ *
+ *   const onBackup = async () => {
+ *     // Layer 1: pre-flight readiness — saves an MPC reshare ceremony when
+ *     // we can already tell the upload will fail.
+ *     let r = await check();
+ *     if (r.status === 'needs-access') {
+ *       r = await requestAccess(); // popup re-consent
+ *       if (r.status !== 'ready') return; // user cancelled or relink failed
+ *     }
+ *
+ *     await backupWallet(wallet, 'GoogleDrive');
+ *     // If the backup failed due to missing scopes, the useEffect above will
+ *     // fire on the next render with the updated lastBackupError.
+ *   };
+ *
+ *   return (
+ *     <>
+ *       {status === 'needs-access' && (
+ *         <p>We need access to: {missingScopes.join(', ')}</p>
+ *       )}
+ *       <button onClick={onBackup} disabled={isChecking}>Backup to Drive</button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+const useGoogleDriveBackupReadiness = () => {
+    const user = useUser();
+    const environmentId = useEnvironmentId();
+    const refresh = useRefreshAuth();
+    const { linkSocialAccount } = useSocialAccounts();
+    const [readiness, setReadiness] = useState(IDLE);
+    const performCheck = useCallback((verifiedCredentials) => __awaiter(void 0, void 0, void 0, function* () {
+        const oauthAccountId = findGoogleOauthAccountId(verifiedCredentials);
+        if (!oauthAccountId) {
+            // No Google credential linked — every required scope is effectively
+            // missing, so populate the full set so callers can render
+            // "we need access to ..." UX without checking the empty case.
+            const result = {
+                isChecking: false,
+                missingScopes: GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES,
+                status: 'needs-access',
+            };
+            setReadiness(result);
+            return result;
+        }
+        try {
+            const { accessToken, scopes } = yield sdkApi().getEndUserOauthAccessToken({
+                environmentId,
+                oauthAccountId,
+            });
+            // Empty scopes = legacy token captured before scope tracking; we
+            // can't confirm the upload will work, so surface as needs-access
+            // (with empty missingScopes to differentiate from the explicit
+            // missing case). requestAccess() forces a fresh token so the
+            // column populates.
+            if (scopes.length === 0) {
+                const result = {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: [],
+                    status: 'needs-access',
+                };
+                setReadiness(result);
+                return result;
+            }
+            const missing = findMissingGoogleDriveBackupScopes(scopes);
+            const result = missing.length === 0
+                ? {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: [],
+                    status: 'ready',
+                }
+                : {
+                    accessToken,
+                    isChecking: false,
+                    missingScopes: missing,
+                    status: 'needs-access',
+                };
+            setReadiness(result);
+            return result;
+        }
+        catch (error) {
+            const result = {
+                error,
+                isChecking: false,
+                missingScopes: [],
+                status: 'error',
+            };
+            setReadiness(result);
+            return result;
+        }
+    }), [environmentId]);
+    const check = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        setReadiness((prev) => (Object.assign(Object.assign({}, prev), { isChecking: true })));
+        return performCheck(user === null || user === void 0 ? void 0 : user.verifiedCredentials);
+    }), [performCheck, user]);
+    const requestAccess = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        setReadiness((prev) => (Object.assign(Object.assign({}, prev), { isChecking: true })));
+        try {
+            yield linkSocialAccount(ProviderEnum.Google, {
+                forcePopup: true,
+                showWidgetAfterConnection: false,
+            });
+            const updatedUser = yield refresh();
+            return performCheck((_a = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.verifiedCredentials) !== null && _a !== void 0 ? _a : user === null || user === void 0 ? void 0 : user.verifiedCredentials);
+        }
+        catch (error) {
+            const result = {
+                error,
+                isChecking: false,
+                missingScopes: [],
+                status: 'error',
+            };
+            setReadiness(result);
+            return result;
+        }
+    }), [linkSocialAccount, performCheck, refresh, user]);
+    const reset = useCallback(() => setReadiness(IDLE), []);
+    return Object.assign(Object.assign({}, readiness), { check,
+        requestAccess,
+        reset });
+};
+
+export { useGoogleDriveBackupReadiness };

package/src/lib/utils/hooks/useSocialAuth/useSocialAuth.cjs

@@ -20,6 +20,7 @@ var logger = require('../../../shared/logger.cjs');
 require('@dynamic-labs/wallet-book');
 require('../../constants/colors.cjs');
 require('../../constants/values.cjs');
+var instrumentAuthLoginFailed = require('../../../shared/utils/functions/instrumentAuthLoginFailed/instrumentAuthLoginFailed.cjs');
 require('../../../shared/consts/index.cjs');
 var dynamicEvents = require('../../../events/dynamicEvents.cjs');
 var ErrorContext = require('../../../context/ErrorContext/ErrorContext.cjs');
@@ -178,9 +179,12 @@ const useSocialAuth = ({ onSettled, onError, onFarcasterUrl, }) => {
     }, [onError, onSettled]);
     const handleError = React.useCallback((provider, code, message, options) => {
         const error = { code, message };
-        logger.logger.error(message);
+        instrumentAuthLoginFailed.instrumentAuthLoginFailed(error, {
+            authOrigin: 'social-auth',
+            provider,
+        });
         setError(error);
-        setErrorMessage(code);
+        setErrorMessage(code, error, 'social-auth');
         onFailed(provider, { error }, options);
     }, [onFailed, setErrorMessage]);
     const checkValidProvider = React.useCallback((provider, authMode) => {

package/src/lib/utils/hooks/useSocialAuth/useSocialAuth.js

@@ -16,6 +16,7 @@ import { logger } from '../../../shared/logger.js';
 import '@dynamic-labs/wallet-book';
 import '../../constants/colors.js';
 import '../../constants/values.js';
+import { instrumentAuthLoginFailed } from '../../../shared/utils/functions/instrumentAuthLoginFailed/instrumentAuthLoginFailed.js';
 import '../../../shared/consts/index.js';
 import { dynamicEvents } from '../../../events/dynamicEvents.js';
 import { useErrorContext } from '../../../context/ErrorContext/ErrorContext.js';
@@ -174,9 +175,12 @@ const useSocialAuth = ({ onSettled, onError, onFarcasterUrl, }) => {
     }, [onError, onSettled]);
     const handleError = useCallback((provider, code, message, options) => {
         const error = { code, message };
-        logger.error(message);
+        instrumentAuthLoginFailed(error, {
+            authOrigin: 'social-auth',
+            provider,
+        });
         setError(error);
-        setErrorMessage(code);
+        setErrorMessage(code, error, 'social-auth');
         onFailed(provider, { error }, options);
     }, [onFailed, setErrorMessage]);
     const checkValidProvider = useCallback((provider, authMode) => {

package/src/lib/utils/hooks/useUserAuth/useUserAuth.cjs

@@ -20,6 +20,7 @@ require('@dynamic-labs/wallet-book');
 require('../../constants/colors.cjs');
 require('../../constants/values.cjs');
 var hasPendingMfaAction = require('../../../shared/utils/functions/hasPendingMfaAction/hasPendingMfaAction.cjs');
+var instrumentAuthLoginFailed = require('../../../shared/utils/functions/instrumentAuthLoginFailed/instrumentAuthLoginFailed.cjs');
 require('../../../shared/consts/index.cjs');
 require('@dynamic-labs/multi-wallet');
 require('react-international-phone');
@@ -134,6 +135,10 @@ const useUserAuth = ({ authMethod, }) => {
     }), [authMethod, clearStackAndPushInitialView, handleLogOut]);
     const handleAuthError = React.useCallback((error, { options = {}, onError, }) => {
         var _a, _b;
+        instrumentAuthLoginFailed.instrumentAuthLoginFailed(error, {
+            authOrigin: 'user-auth',
+            provider: authMethod,
+        });
         if (error instanceof client.MfaInvalidOtpError ||
             error instanceof client.MfaRateLimitedError) {
             throw error;
@@ -196,12 +201,13 @@ const useUserAuth = ({ authMethod, }) => {
             return;
         }
         if (error.code) {
-            setErrorMessage(error.code);
+            setErrorMessage(error.code, error, 'user-auth');
         }
         else {
             setError(error.message);
         }
     }, [
+        authMethod,
         pushView,
         setDeniedOauthProvider,
         setDeniedOauthUsername,

package/src/lib/utils/hooks/useUserAuth/useUserAuth.js

@@ -16,6 +16,7 @@ import '@dynamic-labs/wallet-book';
 import '../../constants/colors.js';
 import '../../constants/values.js';
 import { hasPendingMfaAction } from '../../../shared/utils/functions/hasPendingMfaAction/hasPendingMfaAction.js';
+import { instrumentAuthLoginFailed } from '../../../shared/utils/functions/instrumentAuthLoginFailed/instrumentAuthLoginFailed.js';
 import '../../../shared/consts/index.js';
 import '@dynamic-labs/multi-wallet';
 import 'react-international-phone';
@@ -130,6 +131,10 @@ const useUserAuth = ({ authMethod, }) => {
     }), [authMethod, clearStackAndPushInitialView, handleLogOut]);
     const handleAuthError = useCallback((error, { options = {}, onError, }) => {
         var _a, _b;
+        instrumentAuthLoginFailed(error, {
+            authOrigin: 'user-auth',
+            provider: authMethod,
+        });
         if (error instanceof MfaInvalidOtpError ||
             error instanceof MfaRateLimitedError) {
             throw error;
@@ -192,12 +197,13 @@ const useUserAuth = ({ authMethod, }) => {
             return;
         }
         if (error.code) {
-            setErrorMessage(error.code);
+            setErrorMessage(error.code, error, 'user-auth');
         }
         else {
             setError(error.message);
         }
     }, [
+        authMethod,
         pushView,
         setDeniedOauthProvider,
         setDeniedOauthUsername,

package/src/lib/utils/hooks/useVerifyWallet/useVerifyWallet.cjs

@@ -19,6 +19,7 @@ var localStorage = require('../../constants/localStorage.cjs');
 require('../../constants/colors.cjs');
 require('../../constants/values.cjs');
 require('@dynamic-labs/sdk-api-core');
+var instrumentAuthLoginFailed = require('../../../shared/utils/functions/instrumentAuthLoginFailed/instrumentAuthLoginFailed.cjs');
 require('../../../shared/consts/index.cjs');
 var authMode = require('../../../store/state/authMode/authMode.cjs');
 var useInternalDynamicContext = require('../../../context/DynamicContext/useDynamicContext/useInternalDynamicContext/useInternalDynamicContext.cjs');
@@ -290,12 +291,15 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             handleDisconnectWallet({ walletConnector });
             clearStackAndPushInitialView();
         }
-        logger.logger.error(e);
+        instrumentAuthLoginFailed.instrumentAuthLoginFailed(e, {
+            authOrigin: 'wallet-verify',
+            provider: walletConnector === null || walletConnector === void 0 ? void 0 : walletConnector.key,
+        });
         if (debugError) {
             setError(`${e.message}\n ${e.stack}`);
         }
         else {
-            setErrorMessage(e.code);
+            setErrorMessage(e.code, e, 'wallet-verify');
         }
     };
     return (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes, }) {