@dynamic-labs/sdk-react-core 0.18.100-viem.2 → 0.18.100-viem.21

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';
@@ -43,12 +43,7 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
             const walletNetwork = yield walletConnector.getNetwork();
             const walletChain = walletConnector.connectedChain;
             const walletObject = {
-                address: 
-                // We use `storedConnectedWalletInfo.lastWalletAddress` as a workaround to Braavos issue
-                // Braavos during initialization returns an empty string as a wallet address
-                walletAddress ||
-                    storedConnectedWalletInfo.lastWalletAddress ||
-                    '',
+                address: walletAddress || '',
                 chain: walletChain || '',
                 connected: true,
                 connector: walletConnector,
@@ -85,11 +80,10 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
     }, [connectedWallets]);
     const connectedWallet = connectedWallets[0] || null;
     // Keeps connected wallet data inside localStorage
-    const applyConnectedWalletToStore = ({ walletId, walletAddress, walletConnectorKey, walletChain, provider, }) => {
+    const applyConnectedWalletToStore = ({ walletId, walletConnectorKey, walletChain, provider, }) => {
         const nextConnectedWalletsInfo = [...connectedWalletsInfo];
         nextConnectedWalletsInfo.push({
             id: walletId,
-            lastWalletAddress: walletAddress,
             provider,
             walletChain,
             walletConnectorKey,
@@ -116,18 +110,13 @@ const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingO
                 return;
             }
         }
-        if (!currentWalletConnectorAddress) {
-            logger.error('Could not refresh the wallet. The wallet address is not available');
-            return;
-        }
-        const currentWalletConnectoNetwork = yield walletConnector.getNetwork();
+        const currentWalletConnectorNetwork = yield walletConnector.getNetwork();
         updateConnectedWalletById(walletId, {
             address: currentWalletConnectorAddress,
-            network: currentWalletConnectoNetwork,
+            network: currentWalletConnectorNetwork,
         });
     });
-    const shouldSkipCreatingVisit = useMemo(() => (authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly) ||
-        connectedWallet, [authMode, connectedWallet, enableVisitTrackingOnConnectOnly]);
+    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) {
@@ -164,31 +153,32 @@ 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) => {
+    const unlinkConnectedWallet = (walletId) => __awaiter(void 0, void 0, void 0, function* () {
+        const connectedWalletToUnlink = connectedWallets.find((wallet) => wallet.id === walletId);
+        yield (connectedWalletToUnlink === null || connectedWalletToUnlink === void 0 ? void 0 : connectedWalletToUnlink.connector.endSession());
         const filteredWallets = connectedWalletsInfo.filter((wallet) => wallet.id !== walletId);
         if (walletId === primaryWalletId) {
             clearPrimaryWalletId();
         }
         setConnectedWalletsInfo(filteredWallets);
         onUnlink === null || onUnlink === void 0 ? void 0 : onUnlink(walletId, filteredWallets);
-    };
+    });
     const getConnectedWalletById = useCallback((walletId) => connectedWallets.find((wallet) => wallet.id === walletId), [connectedWallets]);
     return {
         connectWallet,

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/useFetchProjectSettings/useFetchProjectSettings.cjs

@@ -44,7 +44,16 @@ const useFetchProjectSettings = ({ authToken, environmentId, maxRetries = 2, dyn
             environmentId &&
             retries < maxRetries) {
             setLoading(true);
-            api.sendDynamicProps(environmentId, { dynamicContextProps });
+            // we ReactNode components are not being serialized properly
+            // remove them for now and deal with them later
+            // context: https://linear.app/dynamic-labs/issue/GVTY-328/[starknet]-sdk-api-is-not-serializing-react-components
+            // future work: https://linear.app/dynamic-labs/issue/GVTY-330/bug-figure-out-why-react-components-are-not
+            const updatedDynamicProps = {
+                settings: Object.assign(Object.assign({}, dynamicContextProps.settings), { customPrivacyPolicy: Boolean(dynamicContextProps.settings.customPrivacyPolicy), customTermsOfServices: Boolean(dynamicContextProps.settings.customTermsOfServices), policiesConsentInnerComponent: Boolean(dynamicContextProps.settings.policiesConsentInnerComponent) }),
+            };
+            api.sendDynamicProps(environmentId, {
+                dynamicContextProps: updatedDynamicProps,
+            });
             api.fetchProjectSettings(environmentId)
                 .then((response) => {
                 if (!response)

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

@@ -40,7 +40,16 @@ const useFetchProjectSettings = ({ authToken, environmentId, maxRetries = 2, dyn
             environmentId &&
             retries < maxRetries) {
             setLoading(true);
-            sendDynamicProps(environmentId, { dynamicContextProps });
+            // we ReactNode components are not being serialized properly
+            // remove them for now and deal with them later
+            // context: https://linear.app/dynamic-labs/issue/GVTY-328/[starknet]-sdk-api-is-not-serializing-react-components
+            // future work: https://linear.app/dynamic-labs/issue/GVTY-330/bug-figure-out-why-react-components-are-not
+            const updatedDynamicProps = {
+                settings: Object.assign(Object.assign({}, dynamicContextProps.settings), { customPrivacyPolicy: Boolean(dynamicContextProps.settings.customPrivacyPolicy), customTermsOfServices: Boolean(dynamicContextProps.settings.customTermsOfServices), policiesConsentInnerComponent: Boolean(dynamicContextProps.settings.policiesConsentInnerComponent) }),
+            };
+            sendDynamicProps(environmentId, {
+                dynamicContextProps: updatedDynamicProps,
+            });
             fetchProjectSettings(environmentId)
                 .then((response) => {
                 if (!response)

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

@@ -6,7 +6,7 @@ var useInternalDynamicContext = require('../../../context/DynamicContext/useInte
 var ViewContext = require('../../../context/ViewContext/ViewContext.cjs');
 
 const useHandleWalletsToConnect = () => {
-    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, isFullyConnected, } = useInternalDynamicContext.useInternalDynamicContext();
+    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, selectedWalletConnector, isFullyConnected, } = useInternalDynamicContext.useInternalDynamicContext();
     const { setView, goToInitialView } = ViewContext.useViewContext();
     const handleWalletsToConnect = () => {
         if (!walletsToConnectByChain) {
@@ -19,6 +19,20 @@ const useHandleWalletsToConnect = () => {
             setShowAuthFlow(false);
             return goToInitialView();
         }
+        if (!selectedWalletConnector || !selectedWalletConnector.connectedChain) {
+            setShowAuthFlow(false);
+            return goToInitialView();
+        }
+        // Assuming based on the logic above that we have at least one more chain/wallet to connect
+        // If the current connected wallet is already connected to the bridge,
+        // we can go directly to bridge-next-wallet-connection since we know there is a different chain to connect
+        const walletChainsToConnect = walletsToConnectByChain
+            .filter((wallet) => wallet.numberOfWallets > 0)
+            .map((wallet) => wallet.chain.toString());
+        if (!walletChainsToConnect.includes(selectedWalletConnector.connectedChain)) {
+            setView('bridge-next-wallet-connection');
+            return;
+        }
         const [firstWallet, ...restOfTheWallets] = walletsToConnectByChain;
         if (firstWallet.numberOfWallets > 1) {
             const updatedWallets = [

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

@@ -2,7 +2,7 @@ import { useInternalDynamicContext } from '../../../context/DynamicContext/useIn
 import { useViewContext } from '../../../context/ViewContext/ViewContext.js';
 
 const useHandleWalletsToConnect = () => {
-    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, isFullyConnected, } = useInternalDynamicContext();
+    const { walletsToConnectByChain, setWalletsToConnectByChain, setShowAuthFlow, setIsFullyConnected, selectedWalletConnector, isFullyConnected, } = useInternalDynamicContext();
     const { setView, goToInitialView } = useViewContext();
     const handleWalletsToConnect = () => {
         if (!walletsToConnectByChain) {
@@ -15,6 +15,20 @@ const useHandleWalletsToConnect = () => {
             setShowAuthFlow(false);
             return goToInitialView();
         }
+        if (!selectedWalletConnector || !selectedWalletConnector.connectedChain) {
+            setShowAuthFlow(false);
+            return goToInitialView();
+        }
+        // Assuming based on the logic above that we have at least one more chain/wallet to connect
+        // If the current connected wallet is already connected to the bridge,
+        // we can go directly to bridge-next-wallet-connection since we know there is a different chain to connect
+        const walletChainsToConnect = walletsToConnectByChain
+            .filter((wallet) => wallet.numberOfWallets > 0)
+            .map((wallet) => wallet.chain.toString());
+        if (!walletChainsToConnect.includes(selectedWalletConnector.connectedChain)) {
+            setView('bridge-next-wallet-connection');
+            return;
+        }
         const [firstWallet, ...restOfTheWallets] = walletsToConnectByChain;
         if (firstWallet.numberOfWallets > 1) {
             const updatedWallets = [

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

@@ -15,14 +15,20 @@ require('react/jsx-runtime');
 require('../../../context/ViewContext/ViewContext.cjs');
 require('@dynamic-labs/wallet-book');
 require('@dynamic-labs/utils');
+var localStorage$1 = require('../../constants/localStorage.cjs');
 require('../../constants/colors.cjs');
-require('../../../shared/utils/classes/storage/localStorage.cjs');
+var localStorage = require('../../../shared/utils/classes/storage/localStorage.cjs');
 require('viem');
 require('../../../shared/consts/index.cjs');
 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 socialProviders = [
     'discord',
@@ -33,12 +39,20 @@ const socialProviders = [
     'twitch',
     'twitter',
 ];
-const useSocialAccounts = () => {
+// 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(() => {
@@ -57,6 +71,23 @@ const useSocialAccounts = () => {
         setIsProcessing(false);
         setError(message);
     };
+    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');
@@ -68,38 +99,73 @@ const useSocialAccounts = () => {
         }
         return true;
     };
-    const linkSocialAccount = (provider) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        setError(undefined);
-        setIsProcessing(true);
+    const checkValidOAuthLinking = (provider) => {
         if (!isSocialKycEnabled.isSocialKycEnabled(projectSettings)) {
             handleError('Social linking is not enabled on the dashboard');
-            return;
+            return false;
         }
         if (!checkValidProvider(provider)) {
-            return;
+            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;
+            }
+            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 (((_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) {
+            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}`);
@@ -108,18 +174,58 @@ 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 (!checkValidProvider(provider)) {
@@ -131,9 +237,11 @@ const useSocialAccounts = () => {
             return;
         }
         try {
+            const primaryWalletId = localStorage.LocalStorage.getFromLS(localStorage$1.PRIMARY_WALLET_ID);
             const jwt = yield api.unlinkOAuth({
                 environmentId,
-                verifiedCrentialId: (_e = verifiedCredential.id) !== null && _e !== void 0 ? _e : '',
+                primaryWalletId,
+                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 {};