@dynamic-labs/sdk-react-core 0.18.100-viem.0 → 0.18.100-viem.10

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

@@ -68,7 +68,8 @@ const useAuthLayoutChecks = (walletConnector) => {
         view === 'login-with-email-or-wallet-full-wallet-list' ||
         view === 'wallet-group' ||
         view === 'pending-connect' ||
-        view === 'account-exists';
+        view === 'account-exists' ||
+        (view === 'merge-user-accounts' && !user);
     const showQrCodePreHeader = view === 'qr-code' && showQrCodeMessage && !showQrCodeImage;
     return {
         isWalletListTypeView,

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

@@ -64,7 +64,8 @@ const useAuthLayoutChecks = (walletConnector) => {
         view === 'login-with-email-or-wallet-full-wallet-list' ||
         view === 'wallet-group' ||
         view === 'pending-connect' ||
-        view === 'account-exists';
+        view === 'account-exists' ||
+        (view === 'merge-user-accounts' && !user);
     const showQrCodePreHeader = view === 'qr-code' && showQrCodeMessage && !showQrCodeImage;
     return {
         isWalletListTypeView,

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

@@ -130,16 +130,15 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
             network: currentWalletConnectoNetwork,
         });
     });
-    const shouldSkipCreatingVisit = React.useMemo(() => (authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly) ||
-        connectedWallet, [authMode, connectedWallet, enableVisitTrackingOnConnectOnly]);
-    const connectWallet = (walletConnector, fetchPublicAddressOpts) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const shouldSkipCreatingVisit = authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly;
+    const connectWallet = (walletConnector, fetchPublicAddressOpts, shouldCallCallback = true) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         const publicWalletAddress = yield walletConnector.fetchPublicAddress(fetchPublicAddressOpts);
         if (!publicWalletAddress) {
             const error = new Error();
             error.code = 'missing-public-address';
             throw error;
         }
-        if (onBeforeConnectSuccessConfirmation) {
+        if (onBeforeConnectSuccessConfirmation && shouldCallCallback) {
             const shouldProceedWithConnection = yield onBeforeConnectSuccessConfirmation({
                 address: publicWalletAddress,
                 chain: walletConnector.connectedChain,
@@ -168,21 +167,20 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
                 walletConnectorKey: walletConnector.name,
                 walletId,
             });
+            if (!shouldSkipCreatingVisit) {
+                // send information to backend to kick off background jobs
+                // so verify/sign on the next step could go by more quickly
+                // this is async work, but DO NOT AWAIT
+                api.createVisit({
+                    authMode,
+                    chain: walletChain || '',
+                    environmentId,
+                    publicWalletAddress,
+                    walletName: walletConnector.name,
+                    walletProvider: getWalletProvider.getWalletProvider(walletConnector),
+                });
+            }
         }
-        if (shouldSkipCreatingVisit) {
-            return Promise.resolve(publicWalletAddress);
-        }
-        // send information to backend to kick off background jobs
-        // so verify/sign on the next step could go by more quickly
-        // this is async work, but DO NOT AWAIT
-        api.createVisit({
-            authMode,
-            chain: walletChain || '',
-            environmentId,
-            publicWalletAddress,
-            walletName: walletConnector.name,
-            walletProvider: getWalletProvider.getWalletProvider(walletConnector),
-        });
         return Promise.resolve(publicWalletAddress);
     });
     const unlinkConnectedWallet = (walletId) => {

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

@@ -21,7 +21,7 @@ type Props = {
     setShowAuthFlow: Dispatch<SetStateAction<boolean>>;
 };
 export declare const useConnectWallet: ({ authMode, clearPrimaryWalletId, enableVisitTrackingOnConnectOnly, environmentId, primaryWalletId, setPrimaryWalletId, wallets, onUnlink, onBeforeConnectSuccessConfirmation, setShowAuthFlow, }: Props) => {
-    connectWallet: (walletConnector: WalletConnector, fetchPublicAddressOpts?: FetchPublicAddressOpts) => Promise<string | undefined>;
+    connectWallet: (walletConnector: WalletConnector, fetchPublicAddressOpts?: FetchPublicAddressOpts, shouldCallCallback?: boolean) => Promise<string | undefined>;
     connectedWallet: Wallet;
     connectedWallets: Wallet[];
     connectedWalletsInfo: ConnectedWalletConnectorType[] | [];

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

@@ -1,5 +1,5 @@
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
-import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useState, useCallback, useEffect } from 'react';
 import { getWalletConnectorByName, logger } from '@dynamic-labs/wallet-connector-core';
 import '@dynamic-labs/sdk-api';
 import '../../../shared/logger.js';
@@ -126,16 +126,15 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
             network: currentWalletConnectoNetwork,
         });
     });
-    const shouldSkipCreatingVisit = useMemo(() => (authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly) ||
-        connectedWallet, [authMode, connectedWallet, enableVisitTrackingOnConnectOnly]);
-    const connectWallet = (walletConnector, fetchPublicAddressOpts) => __awaiter(void 0, void 0, void 0, function* () {
+    const shouldSkipCreatingVisit = authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly;
+    const connectWallet = (walletConnector, fetchPublicAddressOpts, shouldCallCallback = true) => __awaiter(void 0, void 0, void 0, function* () {
         const publicWalletAddress = yield walletConnector.fetchPublicAddress(fetchPublicAddressOpts);
         if (!publicWalletAddress) {
             const error = new Error();
             error.code = 'missing-public-address';
             throw error;
         }
-        if (onBeforeConnectSuccessConfirmation) {
+        if (onBeforeConnectSuccessConfirmation && shouldCallCallback) {
             const shouldProceedWithConnection = yield onBeforeConnectSuccessConfirmation({
                 address: publicWalletAddress,
                 chain: walletConnector.connectedChain,
@@ -164,21 +163,20 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
                 walletConnectorKey: walletConnector.name,
                 walletId,
             });
+            if (!shouldSkipCreatingVisit) {
+                // send information to backend to kick off background jobs
+                // so verify/sign on the next step could go by more quickly
+                // this is async work, but DO NOT AWAIT
+                createVisit({
+                    authMode,
+                    chain: walletChain || '',
+                    environmentId,
+                    publicWalletAddress,
+                    walletName: walletConnector.name,
+                    walletProvider: getWalletProvider(walletConnector),
+                });
+            }
         }
-        if (shouldSkipCreatingVisit) {
-            return Promise.resolve(publicWalletAddress);
-        }
-        // send information to backend to kick off background jobs
-        // so verify/sign on the next step could go by more quickly
-        // this is async work, but DO NOT AWAIT
-        createVisit({
-            authMode,
-            chain: walletChain || '',
-            environmentId,
-            publicWalletAddress,
-            walletName: walletConnector.name,
-            walletProvider: getWalletProvider(walletConnector),
-        });
         return Promise.resolve(publicWalletAddress);
     });
     const unlinkConnectedWallet = (walletId) => {

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

@@ -22,7 +22,7 @@ var isProgrammableNetworkSwitchSupported = require('../../functions/isProgrammab
 
 const useConnectedWalletsNetworkValidation = () => {
     const { connectedWallets, selectedWalletConnector, setSelectedWalletConnector, setShowAuthFlow, showAuthFlow, walletsToConnectByChain, isBridgeFlow, } = useInternalDynamicContext.useInternalDynamicContext();
-    const { view, setView } = ViewContext.useViewContext();
+    const { setView } = ViewContext.useViewContext();
     React.useEffect(() => {
         if (!isBridgeFlow) {
             return;
@@ -53,16 +53,17 @@ const useConnectedWalletsNetworkValidation = () => {
             }
             setView(networkNotSupportedView);
         }
+        // we need it to remove 'showAuthFlow' property. we don't want to react to it,
+        // because closing modal on network switch causes it to re-open
+        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
-        isBridgeFlow,
         connectedWallets,
-        view,
+        isBridgeFlow,
         selectedWalletConnector,
-        walletsToConnectByChain,
-        showAuthFlow,
-        setView,
         setSelectedWalletConnector,
         setShowAuthFlow,
+        setView,
+        walletsToConnectByChain,
     ]);
 };
 

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

@@ -18,7 +18,7 @@ import { isProgrammableNetworkSwitchSupported } from '../../functions/isProgramm
 
 const useConnectedWalletsNetworkValidation = () => {
     const { connectedWallets, selectedWalletConnector, setSelectedWalletConnector, setShowAuthFlow, showAuthFlow, walletsToConnectByChain, isBridgeFlow, } = useInternalDynamicContext();
-    const { view, setView } = useViewContext();
+    const { setView } = useViewContext();
     useEffect(() => {
         if (!isBridgeFlow) {
             return;
@@ -49,16 +49,17 @@ const useConnectedWalletsNetworkValidation = () => {
             }
             setView(networkNotSupportedView);
         }
+        // we need it to remove 'showAuthFlow' property. we don't want to react to it,
+        // because closing modal on network switch causes it to re-open
+        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
-        isBridgeFlow,
         connectedWallets,
-        view,
+        isBridgeFlow,
         selectedWalletConnector,
-        walletsToConnectByChain,
-        showAuthFlow,
-        setView,
         setSelectedWalletConnector,
         setShowAuthFlow,
+        setView,
+        walletsToConnectByChain,
     ]);
 };
 

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

@@ -19,6 +19,7 @@ require('viem');
 var useLocalStorage = require('../../../shared/utils/hooks/useLocalStorage/useLocalStorage.cjs');
 require('../../../shared/consts/index.cjs');
 var validators = require('../../../context/DynamicContext/validators.cjs');
+var mergeCustomerEvmNetworksWithServerNetworks = require('./utils/mergeCustomerEvmNetworksWithServerNetworks/mergeCustomerEvmNetworksWithServerNetworks.cjs');
 
 const MAX_RETRIES = 2;
 const useFetchNetworkConfigurations = ({ authToken, environmentId, evmNetworks: customerEvmNetworks, maxRetries = MAX_RETRIES, }) => {
@@ -113,13 +114,7 @@ const useFetchNetworkConfigurations = ({ authToken, environmentId, evmNetworks:
                     serverNetworks.length &&
                     customerEvmNetworks !== undefined &&
                     customerEvmNetworks.length) {
-                    mergedEvmNetworks = customerEvmNetworks.slice();
-                    serverNetworks.forEach((network) => {
-                        const existingNetwork = mergedEvmNetworks === null || mergedEvmNetworks === void 0 ? void 0 : mergedEvmNetworks.find((item) => item.chainId === network.chainId);
-                        if (!existingNetwork) {
-                            mergedEvmNetworks === null || mergedEvmNetworks === void 0 ? void 0 : mergedEvmNetworks.push(network);
-                        }
-                    });
+                    mergedEvmNetworks = mergeCustomerEvmNetworksWithServerNetworks.mergeCustomerEvmNetworksWithServerNetworks(customerEvmNetworks, serverNetworks);
                 }
                 setLsNetworks({
                     configurations: {

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

@@ -15,6 +15,7 @@ import 'viem';
 import { useLocalStorage } from '../../../shared/utils/hooks/useLocalStorage/useLocalStorage.js';
 import '../../../shared/consts/index.js';
 import { validateLocalStorageExpiry } from '../../../context/DynamicContext/validators.js';
+import { mergeCustomerEvmNetworksWithServerNetworks } from './utils/mergeCustomerEvmNetworksWithServerNetworks/mergeCustomerEvmNetworksWithServerNetworks.js';
 
 const MAX_RETRIES = 2;
 const useFetchNetworkConfigurations = ({ authToken, environmentId, evmNetworks: customerEvmNetworks, maxRetries = MAX_RETRIES, }) => {
@@ -109,13 +110,7 @@ const useFetchNetworkConfigurations = ({ authToken, environmentId, evmNetworks:
                     serverNetworks.length &&
                     customerEvmNetworks !== undefined &&
                     customerEvmNetworks.length) {
-                    mergedEvmNetworks = customerEvmNetworks.slice();
-                    serverNetworks.forEach((network) => {
-                        const existingNetwork = mergedEvmNetworks === null || mergedEvmNetworks === void 0 ? void 0 : mergedEvmNetworks.find((item) => item.chainId === network.chainId);
-                        if (!existingNetwork) {
-                            mergedEvmNetworks === null || mergedEvmNetworks === void 0 ? void 0 : mergedEvmNetworks.push(network);
-                        }
-                    });
+                    mergedEvmNetworks = mergeCustomerEvmNetworksWithServerNetworks(customerEvmNetworks, serverNetworks);
                 }
                 setLsNetworks({
                     configurations: {

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

@@ -0,0 +1 @@
+export * from './mergeCustomerEvmNetworksWithServerNetworks';

package/src/lib/utils/hooks/useFetchNetworkConfigurations/utils/mergeCustomerEvmNetworksWithServerNetworks/index.d.ts

@@ -0,0 +1 @@
+export { mergeCustomerEvmNetworksWithServerNetworks } from './mergeCustomerEvmNetworksWithServerNetworks';

package/src/lib/utils/hooks/useFetchNetworkConfigurations/utils/mergeCustomerEvmNetworksWithServerNetworks/mergeCustomerEvmNetworksWithServerNetworks.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const mergeCustomerEvmNetworksWithServerNetworks = (customerEvmNetworks, serverNetworks) => {
+    const evmNetworks = [...customerEvmNetworks];
+    serverNetworks.forEach((network) => {
+        const existingNetwork = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.find((item) => item.chainId === network.chainId);
+        if (!existingNetwork) {
+            evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.unshift(network);
+        }
+    });
+    return evmNetworks;
+};
+
+exports.mergeCustomerEvmNetworksWithServerNetworks = mergeCustomerEvmNetworksWithServerNetworks;

package/src/lib/utils/hooks/useFetchNetworkConfigurations/utils/mergeCustomerEvmNetworksWithServerNetworks/mergeCustomerEvmNetworksWithServerNetworks.d.ts

@@ -0,0 +1,2 @@
+import { GenericNetwork } from '@dynamic-labs/types';
+export declare const mergeCustomerEvmNetworksWithServerNetworks: (customerEvmNetworks: GenericNetwork[], serverNetworks: GenericNetwork[]) => GenericNetwork[];

package/src/lib/utils/hooks/useFetchNetworkConfigurations/utils/mergeCustomerEvmNetworksWithServerNetworks/mergeCustomerEvmNetworksWithServerNetworks.js

@@ -0,0 +1,12 @@
+const mergeCustomerEvmNetworksWithServerNetworks = (customerEvmNetworks, serverNetworks) => {
+    const evmNetworks = [...customerEvmNetworks];
+    serverNetworks.forEach((network) => {
+        const existingNetwork = evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.find((item) => item.chainId === network.chainId);
+        if (!existingNetwork) {
+            evmNetworks === null || evmNetworks === void 0 ? void 0 : evmNetworks.unshift(network);
+        }
+    });
+    return evmNetworks;
+};
+
+export { mergeCustomerEvmNetworksWithServerNetworks };

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

@@ -20,11 +20,15 @@ require('../../../shared/consts/index.cjs');
 var primaryWalletIdValidator = require('../useWalletConnectors/utils/primaryWalletIdValidator/primaryWalletIdValidator.cjs');
 require('@dynamic-labs/multi-wallet');
 
-const usePrimaryWalletId = () => {
-    const [primaryWalletId, setPrimaryWalletIdState, clearPrimaryWalletId] = useLocalStorage.useLocalStorage(localStorage.PRIMARY_WALLET_ID, undefined, primaryWalletIdValidator.primaryWalletIdValidator);
+const usePrimaryWalletId = (internalEvents) => {
+    const [primaryWalletId, setPrimaryWalletIdState, clearPrimaryWalletIdStorage,] = useLocalStorage.useLocalStorage(localStorage.PRIMARY_WALLET_ID, undefined, primaryWalletIdValidator.primaryWalletIdValidator);
     const setPrimaryWalletId = React.useCallback((walletId) => {
         setPrimaryWalletIdState(walletId);
     }, [setPrimaryWalletIdState]);
+    const clearPrimaryWalletId = () => {
+        clearPrimaryWalletIdStorage();
+        internalEvents.emit('clearPrimaryWallet');
+    };
     return {
         clearPrimaryWalletId,
         primaryWalletId,

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

@@ -1,4 +1,5 @@
-export declare const usePrimaryWalletId: () => {
+import { InternalEventEmitter } from '../../../context/DynamicContext/internalEvents';
+export declare const usePrimaryWalletId: (internalEvents: InternalEventEmitter) => {
     clearPrimaryWalletId: () => void;
     primaryWalletId: string | undefined;
     setPrimaryWalletId: (walletId: string) => void;

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

@@ -16,11 +16,15 @@ import '../../../shared/consts/index.js';
 import { primaryWalletIdValidator } from '../useWalletConnectors/utils/primaryWalletIdValidator/primaryWalletIdValidator.js';
 import '@dynamic-labs/multi-wallet';
 
-const usePrimaryWalletId = () => {
-    const [primaryWalletId, setPrimaryWalletIdState, clearPrimaryWalletId] = useLocalStorage(PRIMARY_WALLET_ID, undefined, primaryWalletIdValidator);
+const usePrimaryWalletId = (internalEvents) => {
+    const [primaryWalletId, setPrimaryWalletIdState, clearPrimaryWalletIdStorage,] = useLocalStorage(PRIMARY_WALLET_ID, undefined, primaryWalletIdValidator);
     const setPrimaryWalletId = useCallback((walletId) => {
         setPrimaryWalletIdState(walletId);
     }, [setPrimaryWalletIdState]);
+    const clearPrimaryWalletId = () => {
+        clearPrimaryWalletIdStorage();
+        internalEvents.emit('clearPrimaryWallet');
+    };
     return {
         clearPrimaryWalletId,
         primaryWalletId,

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

@@ -23,13 +23,35 @@ require('@dynamic-labs/multi-wallet');
 var getAuthToken = require('../../functions/getAuthToken/getAuthToken.cjs');
 var index = require('../../functions/getEnabledOAuthProviders/index.cjs');
 var isSocialKycEnabled = require('../../functions/isSocialKycEnabled/isSocialKycEnabled.cjs');
+var randomString = require('../../functions/randomString/randomString.cjs');
+var stringifyURIQuery = require('../../functions/stringifyURIQuery/stringifyURIQuery.cjs');
+var digestSHA256 = require('../../functions/digestSHA256/digestSHA256.cjs');
+var encodeBase64URL = require('../../functions/encodeBase64URL/encodeBase64URL.cjs');
+var getRedirectURIOrigin = require('../../functions/getRedirectURIOrigin/getRedirectURIOrigin.cjs');
 
-const useSocialAccounts = () => {
+const socialProviders = [
+    'discord',
+    'facebook',
+    'github',
+    'google',
+    'instagram',
+    'twitch',
+    'twitter',
+];
+// pkce params are only required for twitter and break if added for other providers, like google
+// so we should only add provider that support pkce to this list
+const providersRequiringPkce = ['twitter', 'github'];
+const providersWithoutWindowOpenerRefence = ['twitter'];
+const useSocialAccounts = ({ sessionTimeout } = {
+    sessionTimeout: 10000,
+}) => {
     var _a;
     const { environmentId, user, projectSettings, onboardingOnlyJwt } = useInternalDynamicContext.useInternalDynamicContext();
     const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback.useUpdateUserProfileByJWTCallback();
     const [isProcessing, setIsProcessing] = React.useState(false);
     const [error, setError] = React.useState();
+    const providersWaitingOauthMessages = React.useRef({});
+    const authWindowInterval = React.useRef();
     const userJwt = (_a = getAuthToken.getAuthToken()) !== null && _a !== void 0 ? _a : onboardingOnlyJwt;
     const oauthProviders = index.getEnabledOAuthProviders(projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.providers);
     const verifiedOAuthCredentialsMap = React.useMemo(() => {
@@ -48,39 +70,101 @@ const useSocialAccounts = () => {
         setIsProcessing(false);
         setError(message);
     };
-    const linkSocialAccount = (provider) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        setError(undefined);
-        setIsProcessing(true);
-        if (!isSocialKycEnabled.isSocialKycEnabled(projectSettings)) {
-            handleError('Social linking is not enabled on the dashboard');
+    const addOAuthIFrame = (url) => {
+        const container = document.getElementById('oauth-iframe-container');
+        let oauthIFrame = document.getElementById('oauth-iframe');
+        if (!container || oauthIFrame) {
             return;
         }
+        oauthIFrame = document.createElement('iframe');
+        oauthIFrame.setAttribute('id', 'oauth-iframe');
+        oauthIFrame.setAttribute('src', url);
+        container.appendChild(oauthIFrame);
+    };
+    const removeOAuthIFrame = () => {
+        const oauthIFrame = document.getElementById('oauth-iframe');
+        if (oauthIFrame) {
+            oauthIFrame.remove();
+        }
+    };
+    const checkValidProvider = (provider) => {
         if (!provider) {
             handleError('Provider is required');
-            return;
+            return false;
+        }
+        if (!socialProviders.includes(provider)) {
+            handleError(`Invalid social provider. Valid providers are: ${socialProviders.join(', ')}`);
+            return false;
+        }
+        return true;
+    };
+    const checkValidOAuthLinking = (provider) => {
+        if (!isSocialKycEnabled.isSocialKycEnabled(projectSettings)) {
+            handleError('Social linking is not enabled on the dashboard');
+            return false;
+        }
+        if (!checkValidProvider(provider)) {
+            return false;
         }
         const verifiedCredential = verifiedOAuthCredentialsMap[provider];
         if (verifiedCredential) {
             handleError(`Account already linked for provider: ${provider}`);
-            return;
+            return false;
         }
         const oauthProvider = oauthProviders.find((p) => p.provider === provider);
         if (!oauthProvider) {
             handleError(`Provider is not enabled on the dashboard: ${provider}`);
+            return false;
+        }
+        return true;
+    };
+    const linkSocialAccount = (provider) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        clearInterval(authWindowInterval.current);
+        setError(undefined);
+        setIsProcessing(true);
+        // invalid linking request
+        if (!checkValidOAuthLinking(provider)) {
             return;
         }
+        const state = randomString.randomString(8);
+        const verifier = randomString.randomString(43);
+        const clearListeners = () => {
+            removeOAuthIFrame();
+            window.removeEventListener('message', handleAuthWindowMessage);
+            providersWaitingOauthMessages.current = Object.assign(Object.assign({}, providersWaitingOauthMessages.current), { [provider]: false });
+        };
         const handleAuthWindowMessage = (event) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-            var _b, _c, _d;
-            if (((_b = event.data) === null || _b === void 0 ? void 0 : _b.type) === 'authorization_response') {
-                logger.logger.debug('Message received', { data: event.data });
+            var _c;
+            const message = event.data;
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage) {
+                logger.logger.debug('Message received', { data: message });
+            }
+            const isValidMessage = isAuthorizationMessage && (message === null || message === void 0 ? void 0 : message.provider) === provider;
+            // don't process imvalid messages for provider
+            if (!isValidMessage) {
+                return;
             }
-            if (((_c = event.data) === null || _c === void 0 ? void 0 : _c.type) !== 'authorization_response' ||
-                ((_d = event.data) === null || _d === void 0 ? void 0 : _d.provider) !== provider) {
+            setIsProcessing(true);
+            if (!((_c = providersWaitingOauthMessages.current) === null || _c === void 0 ? void 0 : _c[provider])) {
+                handleError(`Linking ${provider} account session timeout.`);
+                return;
+            }
+            clearListeners();
+            const { code, error } = message;
+            if (error && error !== 'undefined') {
+                handleError(`Failed to link ${provider} social account: ${error}`);
+                return;
+            }
+            if (!code) {
+                handleError(`Failed to link ${provider} social account: no authorization code`);
                 return;
             }
-            const { code } = event.data;
             const jwt = yield api.verifyOAuth(environmentId, provider, {
                 code,
+                codeVerifier: verifier,
+                state,
             }, String(userJwt));
             if (!jwt) {
                 handleError(`Failed to link social account: ${provider}`);
@@ -89,22 +173,61 @@ const useSocialAccounts = () => {
             yield updateUserProfileByJWT(jwt);
             setIsProcessing(false);
         });
-        window.addEventListener('message', handleAuthWindowMessage);
-        const authWindow = window.open(oauthProvider.authorizationUrl, '_blank', 'width=500,height=600');
-        const authWindowInterval = setInterval(() => {
-            if (authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed) {
-                window.removeEventListener('message', handleAuthWindowMessage);
-                clearInterval(authWindowInterval);
+        const loginUrl = yield api.getOauthLoginUrl(environmentId, provider, String(userJwt));
+        if (!loginUrl) {
+            handleError(`Failed to get login url to link social account: ${provider}`);
+            return;
+        }
+        // we need to use an iframe to be the intermediary in communications between the popup and the sdk
+        // because of twitter limitations with accessing the window.opener and BroadcastChannel not working between
+        // different origins (our api redirect page and the app where the sdk is running)
+        const oauthIFrameUrl = `${getRedirectURIOrigin.getRedirectURIOrigin(loginUrl)}/sdkoauth`;
+        addOAuthIFrame(oauthIFrameUrl);
+        let oauthLoginUrl = loginUrl;
+        if (providersRequiringPkce.includes(provider)) {
+            const digest = yield digestSHA256.digestSHA256(verifier);
+            const pkceParams = stringifyURIQuery.stringifyURIQuery({
+                code_challenge: encodeBase64URL.encodeBase64URL(digest),
+                code_challenge_method: 'S256',
+                state: state,
+            });
+            oauthLoginUrl = `${loginUrl}&${pkceParams}`;
+        }
+        if (!((_b = providersWaitingOauthMessages.current) === null || _b === void 0 ? void 0 : _b[provider])) {
+            window.addEventListener('message', handleAuthWindowMessage);
+            providersWaitingOauthMessages.current = Object.assign(Object.assign({}, providersWaitingOauthMessages.current), { [provider]: true });
+        }
+        const authWindow = window.open(oauthLoginUrl, '_blank', 'width=500,height=600');
+        if (!providersWithoutWindowOpenerRefence.includes(provider)) {
+            // For provider that support window.opener, we need to clear all states/listeners when the window is closed
+            authWindowInterval.current = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed)) {
+                    return;
+                }
+                clearInterval(authWindowInterval.current);
                 setIsProcessing(false);
-            }
-        }, 1000);
+            });
+        }
+        else {
+            // For provider that don't support window.opener, we need to use a timeout to try to detect when the
+            // window is closed
+            authWindowInterval.current = setInterval(() => {
+                var _a;
+                // user didn't complete oauth
+                if ((_a = providersWaitingOauthMessages.current) === null || _a === void 0 ? void 0 : _a[provider]) {
+                    clearListeners();
+                    handleError(`Linking ${provider} account window timeout.`);
+                }
+                setIsProcessing(false);
+                clearInterval(authWindowInterval.current);
+            }, sessionTimeout);
+        }
     });
     const unlinkSocialAccount = (provider) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        var _e;
+        var _d;
         setError(undefined);
         setIsProcessing(true);
-        if (!provider) {
-            handleError('Provider is required');
+        if (!checkValidProvider(provider)) {
             return;
         }
         const verifiedCredential = verifiedOAuthCredentialsMap[provider];
@@ -115,7 +238,7 @@ const useSocialAccounts = () => {
         try {
             const jwt = yield api.unlinkOAuth({
                 environmentId,
-                verifiedCrentialId: (_e = verifiedCredential.id) !== null && _e !== void 0 ? _e : '',
+                verifiedCrentialId: (_d = verifiedCredential.id) !== null && _d !== void 0 ? _d : '',
             }, String(userJwt));
             if (!jwt) {
                 handleError(`Failed to unlink social account: ${provider} | ${verifiedCredential.id}`);

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

@@ -1,6 +1,9 @@
 import { ProviderEnum } from '@dynamic-labs/sdk-api';
 import { SocialAccountInformation } from '@dynamic-labs/types';
-export declare const useSocialAccounts: () => {
+type UseSocialAccountsProps = {
+    sessionTimeout: number;
+};
+export declare const useSocialAccounts: ({ sessionTimeout }?: UseSocialAccountsProps) => {
     readonly error: string | undefined;
     readonly getLinkedAccountInformation: (provider: ProviderEnum) => SocialAccountInformation | undefined;
     readonly isLinked: (provider: ProviderEnum) => boolean;
@@ -8,3 +11,4 @@ export declare const useSocialAccounts: () => {
     readonly linkSocialAccount: (provider: ProviderEnum) => Promise<void>;
     readonly unlinkSocialAccount: (provider: ProviderEnum) => Promise<void>;
 };
+export {};