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

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

@@ -1,7 +1,7 @@
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
-import { useState, useMemo } from 'react';
+import { useState, useRef, useMemo } from 'react';
 import { useInternalDynamicContext } from '../../../context/DynamicContext/useInternalDynamicContext.js';
-import { unlinkOAuth, verifyOAuth } from '../../../data/api.js';
+import { getOauthLoginUrl, unlinkOAuth, verifyOAuth } from '../../../data/api.js';
 import { useUpdateUserProfileByJWTCallback } from '../useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.js';
 import '@dynamic-labs/sdk-api';
 import { logger } from '../../../shared/logger.js';
@@ -19,13 +19,35 @@ import '@dynamic-labs/multi-wallet';
 import { getAuthToken } from '../../functions/getAuthToken/getAuthToken.js';
 import { getEnabledOAuthProviders } from '../../functions/getEnabledOAuthProviders/index.js';
 import { isSocialKycEnabled } from '../../functions/isSocialKycEnabled/isSocialKycEnabled.js';
+import { randomString } from '../../functions/randomString/randomString.js';
+import { stringifyURIQuery } from '../../functions/stringifyURIQuery/stringifyURIQuery.js';
+import { digestSHA256 } from '../../functions/digestSHA256/digestSHA256.js';
+import { encodeBase64URL } from '../../functions/encodeBase64URL/encodeBase64URL.js';
+import { getRedirectURIOrigin } from '../../functions/getRedirectURIOrigin/getRedirectURIOrigin.js';
 
-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();
     const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback();
     const [isProcessing, setIsProcessing] = useState(false);
     const [error, setError] = useState();
+    const providersWaitingOauthMessages = useRef({});
+    const authWindowInterval = useRef();
     const userJwt = (_a = getAuthToken()) !== null && _a !== void 0 ? _a : onboardingOnlyJwt;
     const oauthProviders = getEnabledOAuthProviders(projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.providers);
     const verifiedOAuthCredentialsMap = useMemo(() => {
@@ -44,39 +66,101 @@ const useSocialAccounts = () => {
         setIsProcessing(false);
         setError(message);
     };
-    const linkSocialAccount = (provider) => __awaiter(void 0, void 0, void 0, function* () {
-        setError(undefined);
-        setIsProcessing(true);
-        if (!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(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) => __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(8);
+        const verifier = randomString(43);
+        const clearListeners = () => {
+            removeOAuthIFrame();
+            window.removeEventListener('message', handleAuthWindowMessage);
+            providersWaitingOauthMessages.current = Object.assign(Object.assign({}, providersWaitingOauthMessages.current), { [provider]: false });
+        };
         const handleAuthWindowMessage = (event) => __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.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.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 verifyOAuth(environmentId, provider, {
                 code,
+                codeVerifier: verifier,
+                state,
             }, String(userJwt));
             if (!jwt) {
                 handleError(`Failed to link social account: ${provider}`);
@@ -85,22 +169,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 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(loginUrl)}/sdkoauth`;
+        addOAuthIFrame(oauthIFrameUrl);
+        let oauthLoginUrl = loginUrl;
+        if (providersRequiringPkce.includes(provider)) {
+            const digest = yield digestSHA256(verifier);
+            const pkceParams = stringifyURIQuery({
+                code_challenge: 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) => __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];
@@ -111,7 +234,7 @@ const useSocialAccounts = () => {
         try {
             const jwt = yield 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/useTransactionEstimatedGas/index.d.ts

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

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

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var usePromise = require('../usePromise/usePromise.cjs');
+
+/**
+ * Hook to estimate the gas required for a transaction.
+ *
+ * This hook uses the `usePromise` hook to asynchronously estimate the gas required for a transaction.
+ * It first tries to estimate the gas without the 'from' field in the transaction, as the Alchemy API
+ * checks the origin address funds and can return an error if the origin wallet has no funds for the transaction.
+ * If the error 'UNPREDICTABLE_GAS_LIMIT' is encountered, it tries to estimate the gas again with the
+ * original transaction.
+ *
+ * @see {@link https://docs.alchemy.com/reference/eth-estimategas}
+ * @see {@link https://docs.ethers.org/v5/troubleshooting/errors/#help-UNPREDICTABLE_GAS_LIMIT}
+ *
+ * @param {ethers.providers.Web3Provider} provider - The Web3 provider to use for estimating the gas.
+ * @param {ethers.utils.Deferrable<ethers.providers.TransactionRequest>} transaction - The transaction for
+ * which to estimate the gas.
+ *
+ * @returns {PromiseState<ethers.BigNumber>} A promise that resolves to the estimated gas for the transaction.
+ */
+const useTransactionEstimatedGas = (provider, transaction) => usePromise.usePromise(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { from } = transaction, transactionWithoutFrom = _tslib.__rest(transaction, ["from"]);
+    return provider.estimateGas(Object.assign(Object.assign({}, transactionWithoutFrom), { account: from }));
+}), { deps: [transaction, provider] });
+
+exports.useTransactionEstimatedGas = useTransactionEstimatedGas;

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

@@ -0,0 +1,20 @@
+import { PublicClient, TransactionRequest } from 'viem';
+/**
+ * Hook to estimate the gas required for a transaction.
+ *
+ * This hook uses the `usePromise` hook to asynchronously estimate the gas required for a transaction.
+ * It first tries to estimate the gas without the 'from' field in the transaction, as the Alchemy API
+ * checks the origin address funds and can return an error if the origin wallet has no funds for the transaction.
+ * If the error 'UNPREDICTABLE_GAS_LIMIT' is encountered, it tries to estimate the gas again with the
+ * original transaction.
+ *
+ * @see {@link https://docs.alchemy.com/reference/eth-estimategas}
+ * @see {@link https://docs.ethers.org/v5/troubleshooting/errors/#help-UNPREDICTABLE_GAS_LIMIT}
+ *
+ * @param {ethers.providers.Web3Provider} provider - The Web3 provider to use for estimating the gas.
+ * @param {ethers.utils.Deferrable<ethers.providers.TransactionRequest>} transaction - The transaction for
+ * which to estimate the gas.
+ *
+ * @returns {PromiseState<ethers.BigNumber>} A promise that resolves to the estimated gas for the transaction.
+ */
+export declare const useTransactionEstimatedGas: (provider: PublicClient, transaction: TransactionRequest) => import("../usePromise").PromiseState<bigint, Error>;

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

@@ -0,0 +1,27 @@
+import { __awaiter, __rest } from '../../../../../_virtual/_tslib.js';
+import { usePromise } from '../usePromise/usePromise.js';
+
+/**
+ * Hook to estimate the gas required for a transaction.
+ *
+ * This hook uses the `usePromise` hook to asynchronously estimate the gas required for a transaction.
+ * It first tries to estimate the gas without the 'from' field in the transaction, as the Alchemy API
+ * checks the origin address funds and can return an error if the origin wallet has no funds for the transaction.
+ * If the error 'UNPREDICTABLE_GAS_LIMIT' is encountered, it tries to estimate the gas again with the
+ * original transaction.
+ *
+ * @see {@link https://docs.alchemy.com/reference/eth-estimategas}
+ * @see {@link https://docs.ethers.org/v5/troubleshooting/errors/#help-UNPREDICTABLE_GAS_LIMIT}
+ *
+ * @param {ethers.providers.Web3Provider} provider - The Web3 provider to use for estimating the gas.
+ * @param {ethers.utils.Deferrable<ethers.providers.TransactionRequest>} transaction - The transaction for
+ * which to estimate the gas.
+ *
+ * @returns {PromiseState<ethers.BigNumber>} A promise that resolves to the estimated gas for the transaction.
+ */
+const useTransactionEstimatedGas = (provider, transaction) => usePromise(() => __awaiter(void 0, void 0, void 0, function* () {
+    const { from } = transaction, transactionWithoutFrom = __rest(transaction, ["from"]);
+    return provider.estimateGas(Object.assign(Object.assign({}, transactionWithoutFrom), { account: from }));
+}), { deps: [transaction, provider] });
+
+export { useTransactionEstimatedGas };

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

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

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

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var usePromise = require('../usePromise/usePromise.cjs');
+
+const increaseGasPrice = (gasPrice, increasePercentage) => {
+    const increaseFactor = 100 + increasePercentage;
+    return (gasPrice * BigInt(increaseFactor)) / BigInt(100);
+};
+/**
+ * A React Hook that returns a transaction object with the gas price set to the current gas price from the provider.
+ * The gas price is increased by a certain percentage specified by the user. The hook also allows the user to enable
+ * or disable this functionality.
+ *
+ * @param {Object} props - The properties for the hook.
+ * @param {PublicClient} props.provider - The provider to use for getting the current gas price.
+ * @param {TransactionRequest} props.transaction - The transaction object.
+ * @param {number} props.increasePercentage - The percentage by which to increase the current gas price.
+ * @param {boolean} [props.enabled=true] - A flag to enable or disable the gas price increase functionality.
+ *
+ * @returns {TransactionRequest} A new transaction object with the gas price.
+ * If the `enabled` flag is set to false, or if the gas price is not available, or if the transaction already has a
+ * gas price set, the original transaction object is returned.
+ *
+ * @example
+ * const updatedTransaction = useTransactionWithGasPrice({
+ *   provider: myProvider,
+ *   transaction: myTransaction,
+ *   increasePercentage: 10,
+ *   enabled: true,
+ * });
+ */
+const useTransactionWithGasPrice = ({ increasePercentage = 0, provider, transaction, enabled = true, }) => {
+    const isGasPriceDefinedInTransaction = Boolean(transaction.gasPrice);
+    const shouldLoadGasPrice = enabled && increasePercentage > 0 && !isGasPriceDefinedInTransaction;
+    const { data: gasPrice } = usePromise.usePromise(() => provider.getGasPrice(), {
+        deps: [transaction, provider],
+        enabled: shouldLoadGasPrice,
+    });
+    if (!gasPrice) {
+        return transaction;
+    }
+    if (transaction.type === 'legacy' ||
+        transaction.type === 'eip2930' ||
+        transaction.type === undefined ||
+        transaction.maxFeePerGas === undefined) {
+        return Object.assign(Object.assign({}, transaction), { gasPrice: increaseGasPrice(gasPrice, increasePercentage) });
+    }
+    if (transaction.type === 'eip1559') {
+        return Object.assign(Object.assign({}, transaction), { maxFeePerGas: increaseGasPrice(gasPrice, increasePercentage) });
+    }
+    return transaction;
+};
+
+exports.useTransactionWithGasPrice = useTransactionWithGasPrice;

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

@@ -0,0 +1,32 @@
+import { PublicClient, TransactionRequest } from 'viem';
+type UseTransactionWithGasPriceProps = {
+    provider: PublicClient;
+    transaction: TransactionRequest;
+    increasePercentage?: number;
+    enabled?: boolean;
+};
+/**
+ * A React Hook that returns a transaction object with the gas price set to the current gas price from the provider.
+ * The gas price is increased by a certain percentage specified by the user. The hook also allows the user to enable
+ * or disable this functionality.
+ *
+ * @param {Object} props - The properties for the hook.
+ * @param {PublicClient} props.provider - The provider to use for getting the current gas price.
+ * @param {TransactionRequest} props.transaction - The transaction object.
+ * @param {number} props.increasePercentage - The percentage by which to increase the current gas price.
+ * @param {boolean} [props.enabled=true] - A flag to enable or disable the gas price increase functionality.
+ *
+ * @returns {TransactionRequest} A new transaction object with the gas price.
+ * If the `enabled` flag is set to false, or if the gas price is not available, or if the transaction already has a
+ * gas price set, the original transaction object is returned.
+ *
+ * @example
+ * const updatedTransaction = useTransactionWithGasPrice({
+ *   provider: myProvider,
+ *   transaction: myTransaction,
+ *   increasePercentage: 10,
+ *   enabled: true,
+ * });
+ */
+export declare const useTransactionWithGasPrice: ({ increasePercentage, provider, transaction, enabled, }: UseTransactionWithGasPriceProps) => TransactionRequest;
+export {};

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

@@ -0,0 +1,52 @@
+import { usePromise } from '../usePromise/usePromise.js';
+
+const increaseGasPrice = (gasPrice, increasePercentage) => {
+    const increaseFactor = 100 + increasePercentage;
+    return (gasPrice * BigInt(increaseFactor)) / BigInt(100);
+};
+/**
+ * A React Hook that returns a transaction object with the gas price set to the current gas price from the provider.
+ * The gas price is increased by a certain percentage specified by the user. The hook also allows the user to enable
+ * or disable this functionality.
+ *
+ * @param {Object} props - The properties for the hook.
+ * @param {PublicClient} props.provider - The provider to use for getting the current gas price.
+ * @param {TransactionRequest} props.transaction - The transaction object.
+ * @param {number} props.increasePercentage - The percentage by which to increase the current gas price.
+ * @param {boolean} [props.enabled=true] - A flag to enable or disable the gas price increase functionality.
+ *
+ * @returns {TransactionRequest} A new transaction object with the gas price.
+ * If the `enabled` flag is set to false, or if the gas price is not available, or if the transaction already has a
+ * gas price set, the original transaction object is returned.
+ *
+ * @example
+ * const updatedTransaction = useTransactionWithGasPrice({
+ *   provider: myProvider,
+ *   transaction: myTransaction,
+ *   increasePercentage: 10,
+ *   enabled: true,
+ * });
+ */
+const useTransactionWithGasPrice = ({ increasePercentage = 0, provider, transaction, enabled = true, }) => {
+    const isGasPriceDefinedInTransaction = Boolean(transaction.gasPrice);
+    const shouldLoadGasPrice = enabled && increasePercentage > 0 && !isGasPriceDefinedInTransaction;
+    const { data: gasPrice } = usePromise(() => provider.getGasPrice(), {
+        deps: [transaction, provider],
+        enabled: shouldLoadGasPrice,
+    });
+    if (!gasPrice) {
+        return transaction;
+    }
+    if (transaction.type === 'legacy' ||
+        transaction.type === 'eip2930' ||
+        transaction.type === undefined ||
+        transaction.maxFeePerGas === undefined) {
+        return Object.assign(Object.assign({}, transaction), { gasPrice: increaseGasPrice(gasPrice, increasePercentage) });
+    }
+    if (transaction.type === 'eip1559') {
+        return Object.assign(Object.assign({}, transaction), { maxFeePerGas: increaseGasPrice(gasPrice, increasePercentage) });
+    }
+    return transaction;
+};
+
+export { useTransactionWithGasPrice };

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

@@ -145,6 +145,7 @@ const useVerifyWallet = ({ consumeNonce, displaySiweStatement, environmentId, pr
     return ({ walletConnector, fetchPublicAddressOpts, publicWalletAddress, captchaToken, oauth, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         const walletProvider = getWalletProvider.getWalletProvider(walletConnector);
         try {
+            setIsVerificationInProgress(true);
             const Jwt = yield generateJWT(walletConnector, walletProvider, fetchPublicAddressOpts, publicWalletAddress, captchaToken, oauth);
             const decodedJwt = decodeJwt.decodeJwt(Jwt);
             if (decodedJwt === undefined)

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

@@ -141,6 +141,7 @@ const useVerifyWallet = ({ consumeNonce, displaySiweStatement, environmentId, pr
     return ({ walletConnector, fetchPublicAddressOpts, publicWalletAddress, captchaToken, oauth, }) => __awaiter(void 0, void 0, void 0, function* () {
         const walletProvider = getWalletProvider(walletConnector);
         try {
+            setIsVerificationInProgress(true);
             const Jwt = yield generateJWT(walletConnector, walletProvider, fetchPublicAddressOpts, publicWalletAddress, captchaToken, oauth);
             const decodedJwt = decodeJwt(Jwt);
             if (decodedJwt === undefined)

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

@@ -17,7 +17,7 @@ export type UseWalletEventListenersArgs = {
     setSelectedWalletWithAction(walletWithAction: WalletWithAction | null): void;
     user: UserProfile | undefined;
     authMode: AuthModeType;
-    refreshConnectedWallet: (walletId: string, walletConnector: WalletConnector) => Promise<void>;
+    refreshConnectedWallet: (walletId: string, walletConnector: WalletConnector, shouldCallCallback?: boolean) => Promise<void>;
 };
 export declare const useWalletEventListeners: ({ computeConnectedStateForWallets, handleLogOut, multiWallet, multiWalletWidgetState, primaryWallet, secondaryWallets, selectedWalletConnector, selectedWalletWithAction, setSelectedWalletConnector, setSelectedWalletWithAction, setMultiWalletWidgetState, user, setPrimaryWalletId, authMode, refreshConnectedWallet, }: UseWalletEventListenersArgs) => {
     loadingNetwork: boolean;

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

@@ -67,11 +67,11 @@ const useWalletUiUtils = ({ appLogoUrl, appName, getAppOrigin, }) => {
         }
         return openSignMessage((resolve, reject) => (jsxRuntime.jsx(SignMessageConfirmationModal.SignMessageConfirmationModal, { appLogoUrl: appLogoUrl, appName: appName, appOrigin: getAppOrigin(), message: message, handler: handler, onSignMessage: resolve, onReject: reject })));
     }, [appLogoUrl, appName, getAppOrigin, openSignMessage, shouldConfirmAction]);
-    const sendTransaction = React.useCallback(({ transaction, handler }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const sendTransaction = React.useCallback(({ transaction, handler, provider, connector }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         if (!shouldConfirmAction()) {
             return handler(transaction);
         }
-        return openSendTransaction((resolve, reject) => (jsxRuntime.jsx(TransactionConfirmationModal.TransactionConfirmationModal, { title: 'Send Transaction', transaction: transaction, handler: handler, onTransactionResponseSuccess: resolve, onReject: reject })));
+        return openSendTransaction((resolve, reject) => (jsxRuntime.jsx(TransactionConfirmationModal.TransactionConfirmationModal, { walletConnector: connector, title: 'Send Transaction', transaction: transaction, handler: handler, onTransactionResponseSuccess: resolve, onReject: reject, provider: provider })));
     }), [openSendTransaction, shouldConfirmAction]);
     const disabledConfirmationOnce = React.useCallback(() => {
         confirmationStateRef.current = 'disabled';

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

@@ -1,4 +1,8 @@
 import { ReactNode } from 'react';
 import { WalletUiUtils } from '@dynamic-labs/types';
+import { WalletConnector } from '@dynamic-labs/wallet-connector-core';
 import { WalletUiUtilsHookProps } from './useWalletUiUtils.types';
-export declare const useWalletUiUtils: ({ appLogoUrl, appName, getAppOrigin, }: WalletUiUtilsHookProps) => [ReactNode | undefined, WalletUiUtils];
+export declare const useWalletUiUtils: ({ appLogoUrl, appName, getAppOrigin, }: WalletUiUtilsHookProps) => [
+    ReactNode | undefined,
+    WalletUiUtils<WalletConnector>
+];

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

@@ -63,11 +63,11 @@ const useWalletUiUtils = ({ appLogoUrl, appName, getAppOrigin, }) => {
         }
         return openSignMessage((resolve, reject) => (jsx(SignMessageConfirmationModal, { appLogoUrl: appLogoUrl, appName: appName, appOrigin: getAppOrigin(), message: message, handler: handler, onSignMessage: resolve, onReject: reject })));
     }, [appLogoUrl, appName, getAppOrigin, openSignMessage, shouldConfirmAction]);
-    const sendTransaction = useCallback(({ transaction, handler }) => __awaiter(void 0, void 0, void 0, function* () {
+    const sendTransaction = useCallback(({ transaction, handler, provider, connector }) => __awaiter(void 0, void 0, void 0, function* () {
         if (!shouldConfirmAction()) {
             return handler(transaction);
         }
-        return openSendTransaction((resolve, reject) => (jsx(TransactionConfirmationModal, { title: 'Send Transaction', transaction: transaction, handler: handler, onTransactionResponseSuccess: resolve, onReject: reject })));
+        return openSendTransaction((resolve, reject) => (jsx(TransactionConfirmationModal, { walletConnector: connector, title: 'Send Transaction', transaction: transaction, handler: handler, onTransactionResponseSuccess: resolve, onReject: reject, provider: provider })));
     }), [openSendTransaction, shouldConfirmAction]);
     const disabledConfirmationOnce = useCallback(() => {
         confirmationStateRef.current = 'disabled';

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

@@ -1,6 +1,6 @@
 import { ProjectSettings } from '@dynamic-labs/sdk-api';
 import { NetworkConfigurationMap, WalletUiUtils } from '@dynamic-labs/types';
-import { WalletConnectorsMethod } from '@dynamic-labs/wallet-connector-core';
+import { WalletConnector, WalletConnectorsMethod } from '@dynamic-labs/wallet-connector-core';
 import { WalletBookSchema } from '@dynamic-labs/wallet-book';
 type Props = {
     appLogoUrl?: string;
@@ -11,7 +11,7 @@ type Props = {
     walletBook: WalletBookSchema;
     walletConnectV1Bridge?: string;
     walletConnectorsProp?: WalletConnectorsMethod[];
-    walletUiUtils: WalletUiUtils;
+    walletUiUtils: WalletUiUtils<WalletConnector>;
 };
 export declare const useWallets: ({ projectSettings, appLogoUrl, appName, flowNetwork, networkConfigurations, walletBook, walletConnectV1Bridge, walletUiUtils, walletConnectorsProp, }: Props) => {
     wallets: import("../../../shared").WalletOption[];

package/src/lib/views/CaptchaVerifyUser/CaptchaVerifyUser.cjs

@@ -5,11 +5,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('../../../../_virtual/_tslib.cjs');
 var jsxRuntime = require('react/jsx-runtime');
 var iconic = require('@dynamic-labs/iconic');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 require('react');
 var Typography = require('../../components/Typography/Typography.cjs');
 require('@dynamic-labs/sdk-api');
 require('../../shared/logger.cjs');
-require('@dynamic-labs/wallet-connector-core');
 var ViewContext = require('../../context/ViewContext/ViewContext.cjs');
 require('@dynamic-labs/wallet-book');
 require('@dynamic-labs/utils');
@@ -47,7 +47,7 @@ require('../../components/MenuList/Dropdown/Dropdown.cjs');
 var Captcha = require('../../components/Captcha/Captcha.cjs');
 
 const CaptchaVerifyUser = () => {
-    const { consumeNonce, displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, selectedWalletConnector: walletConnector, } = useInternalDynamicContext.useInternalDynamicContext();
+    const { consumeNonce, displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, selectedWalletConnector: walletConnector, walletUiUtils, } = useInternalDynamicContext.useInternalDynamicContext();
     const { setView } = ViewContext.useViewContext();
     const { setCaptchaToken } = CaptchaContext.useCaptchaContext();
     const verifyWallet = useVerifyWallet.useVerifyWallet({
@@ -65,7 +65,13 @@ const CaptchaVerifyUser = () => {
         if (!publicWalletAddress) {
             return;
         }
-        setView('pending-signature');
+        if (!walletConnectorCore.isEmbeddedConnector(walletConnector) ||
+            walletConnectorCore.isBloctoConnector(walletConnector)) {
+            setView('pending-signature');
+        }
+        else {
+            walletUiUtils.disabledConfirmationOnce();
+        }
         if (requiresTwoStepAuthentication.requiresTwoStepAuthentication(walletConnector)) {
             setCaptchaToken(captchaToken);
             return;

package/src/lib/views/CaptchaVerifyUser/CaptchaVerifyUser.js

@@ -1,11 +1,11 @@
 import { __awaiter } from '../../../../_virtual/_tslib.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { CaptchaWaveIcon } from '@dynamic-labs/iconic';
+import { isEmbeddedConnector, isBloctoConnector } from '@dynamic-labs/wallet-connector-core';
 import 'react';
 import { Typography } from '../../components/Typography/Typography.js';
 import '@dynamic-labs/sdk-api';
 import '../../shared/logger.js';
-import '@dynamic-labs/wallet-connector-core';
 import { useViewContext } from '../../context/ViewContext/ViewContext.js';
 import '@dynamic-labs/wallet-book';
 import '@dynamic-labs/utils';
@@ -43,7 +43,7 @@ import '../../components/MenuList/Dropdown/Dropdown.js';
 import { Captcha } from '../../components/Captcha/Captcha.js';
 
 const CaptchaVerifyUser = () => {
-    const { consumeNonce, displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, selectedWalletConnector: walletConnector, } = useInternalDynamicContext();
+    const { consumeNonce, displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, selectedWalletConnector: walletConnector, walletUiUtils, } = useInternalDynamicContext();
     const { setView } = useViewContext();
     const { setCaptchaToken } = useCaptchaContext();
     const verifyWallet = useVerifyWallet({
@@ -61,7 +61,13 @@ const CaptchaVerifyUser = () => {
         if (!publicWalletAddress) {
             return;
         }
-        setView('pending-signature');
+        if (!isEmbeddedConnector(walletConnector) ||
+            isBloctoConnector(walletConnector)) {
+            setView('pending-signature');
+        }
+        else {
+            walletUiUtils.disabledConfirmationOnce();
+        }
         if (requiresTwoStepAuthentication(walletConnector)) {
             setCaptchaToken(captchaToken);
             return;