@dynamic-labs/sdk-react-core 0.19.0-alpha.1 → 0.19.0-alpha.3

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

@@ -1,7 +1,8 @@
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
-import { useState, useMemo } from 'react';
+import { useState, useRef, useMemo } from 'react';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
 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 +20,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(() => {
@@ -39,89 +62,195 @@ const useSocialAccounts = () => {
             ];
         })));
     }, [user === null || user === void 0 ? void 0 : user.verifiedCredentials]);
-    const handleError = (message) => {
+    const handleError = (code, message) => {
         logger.error(message);
         setIsProcessing(false);
-        setError(message);
+        setError({ code, 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;
+            handleError(SocialOAuthErrorCode.NO_PROVIDER, 'Provider is required');
+            return false;
+        }
+        if (!socialProviders.includes(provider)) {
+            handleError(SocialOAuthErrorCode.INVALID_PROVIDER, `Invalid social provider. Valid providers are: ${socialProviders.join(', ')}`);
+            return false;
+        }
+        return true;
+    };
+    const checkValidOAuthLinking = (provider) => {
+        if (!isSocialKycEnabled(projectSettings)) {
+            handleError(SocialOAuthErrorCode.SOCIAL_LINKING_NOT_ENABLED, '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;
+            handleError(SocialOAuthErrorCode.ACCOUNT_ALREADY_LINKED, `Account already linked for provider: ${provider}`);
+            return false;
         }
         const oauthProvider = oauthProviders.find((p) => p.provider === provider);
         if (!oauthProvider) {
-            handleError(`Provider is not enabled on the dashboard: ${provider}`);
+            handleError(SocialOAuthErrorCode.PROVIDER_NOT_ENABLED, `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 });
             }
-            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) {
+            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 = providersWaitingOauthMessages.current) === null || _c === void 0 ? void 0 : _c[provider])) {
+                handleError(SocialOAuthErrorCode.SESSION_TIMEOUT, `Linking ${provider} account session timeout.`);
+                return;
+            }
+            clearListeners();
+            const { code, error } = message;
+            if (error && error !== 'undefined') {
+                handleError(SocialOAuthErrorCode.OAUTH_ERROR, `Failed to link ${provider} social account: ${error}`);
+                return;
+            }
+            if (!code) {
+                handleError(SocialOAuthErrorCode.NO_AUTH_CODE, `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}`);
+                handleError(SocialOAuthErrorCode.VERIFICATION_ERROR, `Failed to link social account: ${provider}`);
                 return;
             }
             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(SocialOAuthErrorCode.NO_OAUTH_URL, `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(() => {
+                var _a;
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed)) {
+                    return;
+                }
+                // window was closed by user, before completing oauth
+                if ((_a = providersWaitingOauthMessages.current) === null || _a === void 0 ? void 0 : _a[provider]) {
+                    clearListeners();
+                    handleError(SocialOAuthErrorCode.OAUTH_WINDOW_CLOSED, `Linking ${provider} account window closed.`);
+                }
+                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(SocialOAuthErrorCode.OAUTH_WINDOW_TIMEOUT, `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];
         if (!verifiedCredential) {
-            handleError(`No account linked for provider: ${provider}`);
+            handleError(SocialOAuthErrorCode.NO_ACCOUNT_LINKED, `No account linked for provider: ${provider}`);
             return;
         }
         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}`);
+                handleError(SocialOAuthErrorCode.UNLINK_ERROR, `Failed to unlink social account: ${provider} | ${verifiedCredential.id}`);
                 return;
             }
             yield updateUserProfileByJWT(jwt);
             setIsProcessing(false);
         }
         catch (err) {
-            handleError(`Failed to unlink social account: ${provider} | ${verifiedCredential.id}`);
+            handleError(SocialOAuthErrorCode.GENERAL_ERROR, `Failed to unlink social account: ${provider} | ${verifiedCredential.id}`);
         }
     });
     const isLinked = (provider) => Boolean(verifiedOAuthCredentialsMap[provider]);

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

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var usePromise = require('../usePromise/usePromise.cjs');
+
+const increaseGasPrice = (gasPrice, increasePercentage) => {
+    const increaseFactor = 100 + increasePercentage;
+    return gasPrice.mul(increaseFactor).div(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 {ethers.providers.Provider} props.provider - The provider to use for getting the current gas price.
+ * @param {ethers.utils.Deferrable<ethers.providers.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 {ethers.utils.Deferrable<ethers.providers.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;
+    }
+    return Object.assign(Object.assign({}, transaction), { gasPrice: increaseGasPrice(gasPrice, increasePercentage) });
+};
+
+exports.useTransactionWithGasPrice = useTransactionWithGasPrice;

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

@@ -0,0 +1,43 @@
+import { usePromise } from '../usePromise/usePromise.js';
+
+const increaseGasPrice = (gasPrice, increasePercentage) => {
+    const increaseFactor = 100 + increasePercentage;
+    return gasPrice.mul(increaseFactor).div(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 {ethers.providers.Provider} props.provider - The provider to use for getting the current gas price.
+ * @param {ethers.utils.Deferrable<ethers.providers.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 {ethers.utils.Deferrable<ethers.providers.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;
+    }
+    return Object.assign(Object.assign({}, transaction), { gasPrice: increaseGasPrice(gasPrice, increasePercentage) });
+};
+
+export { useTransactionWithGasPrice };

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

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

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

@@ -0,0 +1,3 @@
+export * from './useUserUpdateRequest';
+export * from './useUpdateUserWithModal';
+export * from './useUpdateUser';

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUser/index.d.ts

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

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUser/useUpdateUser.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../../_virtual/_tslib.cjs');
+var React = require('react');
+var yup = require('yup');
+var useInternalDynamicContext = require('../../../../context/DynamicContext/useInternalDynamicContext.cjs');
+var EmailVerificationContext = require('../../../../context/EmailVerificationContext/EmailVerificationContext.cjs');
+var api = require('../../../../data/api.cjs');
+var decodeJwt = require('../../../../shared/utils/functions/decodeJwt/decodeJwt.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../../context/ViewContext/ViewContext.cjs');
+require('../../../../shared/logger.cjs');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/utils');
+require('../../../constants/colors.cjs');
+require('../../../../shared/utils/classes/storage/localStorage.cjs');
+require('ethers');
+require('../../../../shared/consts/index.cjs');
+var isEmailVerificationRequired = require('../../../functions/authenication/isEmailVerificationRequired/isEmailVerificationRequired.cjs');
+require('../../../../context/ErrorContext/ErrorContext.cjs');
+require('@dynamic-labs/multi-wallet');
+require('@dynamic-labs/sdk-api');
+require('../../../../context/AccessDeniedContext/AccessDeniedContext.cjs');
+require('../../../../context/AccountExistsContext/AccountExistsContext.cjs');
+require('../../../../context/CaptchaContext/CaptchaContext.cjs');
+var useEmailVerificationRequest = require('../../authenticationHooks/useEmailVerificationRequest/useEmailVerificationRequest.cjs');
+var useUpdateUserProfileByJWTCallback = require('../../useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.cjs');
+
+// User Fields Schema without captchaToken and policiesConsent properties
+const userFieldsSchema = yup.object().shape({
+    alias: yup.string(),
+    btcWallet: yup.string(),
+    ckbWallet: yup.string(),
+    country: yup.string(),
+    discordNotification: yup.boolean(),
+    dogeWallet: yup.string(),
+    email: yup.string(),
+    emailNotification: yup.boolean(),
+    firstName: yup.string(),
+    jobTitle: yup.string(),
+    kasWallet: yup.string(),
+    kdaWallet: yup.string(),
+    lastName: yup.string(),
+    ltcWallet: yup.string(),
+    newsletterNotification: yup.boolean(),
+    phoneNumber: yup.string(),
+    tShirtSize: yup.string(),
+    team: yup.string(),
+    username: yup.string(),
+});
+const useUpdateUser = (validationSchemaStripUnknown) => {
+    const { authToken, onboardingOnlyJwt, environmentId } = useInternalDynamicContext.useInternalDynamicContext();
+    const jwtToken = onboardingOnlyJwt || authToken;
+    const { setVerificationUUID, setEmail } = EmailVerificationContext.useEmailVerificationContext();
+    const { verifyEmail } = useEmailVerificationRequest.useEmailVerificationRequest();
+    const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback.useUpdateUserProfileByJWTCallback();
+    return React.useCallback((userFields, userEnvironmentId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const validatedUserFields = yield userFieldsSchema.validate(userFields, {
+            stripUnknown: validationSchemaStripUnknown,
+        });
+        const updateUserProfileResponse = yield api.updateUserProfileFields(jwtToken, userEnvironmentId || environmentId, validatedUserFields);
+        // check if decoded JWT still somehow has missing fields, we can't proceed if it does
+        const decodedJwt = decodeJwt.decodeJwt(updateUserProfileResponse.jwt);
+        const missingFields = (_a = decodedJwt === null || decodedJwt === void 0 ? void 0 : decodedJwt.missingFields) !== null && _a !== void 0 ? _a : [];
+        const _isEmailVerificationRequired = isEmailVerificationRequired.isEmailVerificationRequired(updateUserProfileResponse);
+        if (!_isEmailVerificationRequired) {
+            // If email verification is not needed then we can update the user profile immediately.
+            yield updateUserProfileByJWT(updateUserProfileResponse.jwt);
+            return {
+                isEmailVerificationRequired: false,
+                missingFields,
+                updateUserProfileResponse,
+            };
+        }
+        // We update EmailContext to use this information in the Email Verification view
+        setEmail((_b = updateUserProfileResponse.emailVerification) === null || _b === void 0 ? void 0 : _b.email);
+        setVerificationUUID((_c = updateUserProfileResponse.emailVerification) === null || _c === void 0 ? void 0 : _c.verificationUUID);
+        // DYN-2046 - Customers have the opportunity to programmatically use our email verification and profile editing.
+        // VerifyEmailFN was scoped to bypass the problem with memoization of the state at the beginning of Promise.
+        // setEmail and setVerificationUUID in the above lines will are not visible in this promise.
+        const scopedVerifyEmailFn = (verificationToken) => {
+            var _a;
+            return verifyEmail(verificationToken, (_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.verificationUUID);
+        };
+        return {
+            isEmailVerificationRequired: true,
+            missingFields,
+            updateUserProfileResponse,
+            verifyEmailFn: scopedVerifyEmailFn,
+        };
+    }), [
+        environmentId,
+        jwtToken,
+        setEmail,
+        setVerificationUUID,
+        validationSchemaStripUnknown,
+        updateUserProfileByJWT,
+        verifyEmail,
+    ]);
+};
+
+exports.useUpdateUser = useUpdateUser;

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUser/useUpdateUser.d.ts

@@ -0,0 +1,9 @@
+import { ProjectSettingsKyc, UpdateSelfResponse, UserFields } from '@dynamic-labs/sdk-api';
+export type UpdateUserFieldsArg = Omit<UserFields, 'captchaToken' | 'policiesConsent'>;
+export type UpdateUserReturnPayload = {
+    isEmailVerificationRequired: boolean;
+    missingFields: ProjectSettingsKyc[];
+    updateUserProfileResponse: UpdateSelfResponse;
+    verifyEmailFn?: (verificationToken: string) => Promise<UpdateSelfResponse>;
+};
+export declare const useUpdateUser: (validationSchemaStripUnknown: boolean) => (userFields: UpdateUserFieldsArg, userEnvironmentId?: string) => Promise<UpdateUserReturnPayload>;

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUser/useUpdateUser.js

@@ -0,0 +1,103 @@
+import { __awaiter } from '../../../../../../_virtual/_tslib.js';
+import { useCallback } from 'react';
+import { object, string, boolean } from 'yup';
+import { useInternalDynamicContext } from '../../../../context/DynamicContext/useInternalDynamicContext.js';
+import { useEmailVerificationContext } from '../../../../context/EmailVerificationContext/EmailVerificationContext.js';
+import { updateUserProfileFields } from '../../../../data/api.js';
+import { decodeJwt } from '../../../../shared/utils/functions/decodeJwt/decodeJwt.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../../context/ViewContext/ViewContext.js';
+import '../../../../shared/logger.js';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/utils';
+import '../../../constants/colors.js';
+import '../../../../shared/utils/classes/storage/localStorage.js';
+import 'ethers';
+import '../../../../shared/consts/index.js';
+import { isEmailVerificationRequired } from '../../../functions/authenication/isEmailVerificationRequired/isEmailVerificationRequired.js';
+import '../../../../context/ErrorContext/ErrorContext.js';
+import '@dynamic-labs/multi-wallet';
+import '@dynamic-labs/sdk-api';
+import '../../../../context/AccessDeniedContext/AccessDeniedContext.js';
+import '../../../../context/AccountExistsContext/AccountExistsContext.js';
+import '../../../../context/CaptchaContext/CaptchaContext.js';
+import { useEmailVerificationRequest } from '../../authenticationHooks/useEmailVerificationRequest/useEmailVerificationRequest.js';
+import { useUpdateUserProfileByJWTCallback } from '../../useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.js';
+
+// User Fields Schema without captchaToken and policiesConsent properties
+const userFieldsSchema = object().shape({
+    alias: string(),
+    btcWallet: string(),
+    ckbWallet: string(),
+    country: string(),
+    discordNotification: boolean(),
+    dogeWallet: string(),
+    email: string(),
+    emailNotification: boolean(),
+    firstName: string(),
+    jobTitle: string(),
+    kasWallet: string(),
+    kdaWallet: string(),
+    lastName: string(),
+    ltcWallet: string(),
+    newsletterNotification: boolean(),
+    phoneNumber: string(),
+    tShirtSize: string(),
+    team: string(),
+    username: string(),
+});
+const useUpdateUser = (validationSchemaStripUnknown) => {
+    const { authToken, onboardingOnlyJwt, environmentId } = useInternalDynamicContext();
+    const jwtToken = onboardingOnlyJwt || authToken;
+    const { setVerificationUUID, setEmail } = useEmailVerificationContext();
+    const { verifyEmail } = useEmailVerificationRequest();
+    const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback();
+    return useCallback((userFields, userEnvironmentId) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const validatedUserFields = yield userFieldsSchema.validate(userFields, {
+            stripUnknown: validationSchemaStripUnknown,
+        });
+        const updateUserProfileResponse = yield updateUserProfileFields(jwtToken, userEnvironmentId || environmentId, validatedUserFields);
+        // check if decoded JWT still somehow has missing fields, we can't proceed if it does
+        const decodedJwt = decodeJwt(updateUserProfileResponse.jwt);
+        const missingFields = (_a = decodedJwt === null || decodedJwt === void 0 ? void 0 : decodedJwt.missingFields) !== null && _a !== void 0 ? _a : [];
+        const _isEmailVerificationRequired = isEmailVerificationRequired(updateUserProfileResponse);
+        if (!_isEmailVerificationRequired) {
+            // If email verification is not needed then we can update the user profile immediately.
+            yield updateUserProfileByJWT(updateUserProfileResponse.jwt);
+            return {
+                isEmailVerificationRequired: false,
+                missingFields,
+                updateUserProfileResponse,
+            };
+        }
+        // We update EmailContext to use this information in the Email Verification view
+        setEmail((_b = updateUserProfileResponse.emailVerification) === null || _b === void 0 ? void 0 : _b.email);
+        setVerificationUUID((_c = updateUserProfileResponse.emailVerification) === null || _c === void 0 ? void 0 : _c.verificationUUID);
+        // DYN-2046 - Customers have the opportunity to programmatically use our email verification and profile editing.
+        // VerifyEmailFN was scoped to bypass the problem with memoization of the state at the beginning of Promise.
+        // setEmail and setVerificationUUID in the above lines will are not visible in this promise.
+        const scopedVerifyEmailFn = (verificationToken) => {
+            var _a;
+            return verifyEmail(verificationToken, (_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.verificationUUID);
+        };
+        return {
+            isEmailVerificationRequired: true,
+            missingFields,
+            updateUserProfileResponse,
+            verifyEmailFn: scopedVerifyEmailFn,
+        };
+    }), [
+        environmentId,
+        jwtToken,
+        setEmail,
+        setVerificationUUID,
+        validationSchemaStripUnknown,
+        updateUserProfileByJWT,
+        verifyEmail,
+    ]);
+};
+
+export { useUpdateUser };

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUserWithModal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useUpdateUserWithModal';
+export * from './types';

package/src/lib/utils/hooks/useUserUpdateRequest/useUpdateUserWithModal/types.d.ts

@@ -0,0 +1,7 @@
+import { UserFields } from '@dynamic-labs/sdk-api';
+export type UpdateUserWithModalOptions = {
+    title?: string;
+    subtitle?: string;
+    submitText?: string;
+};
+export type UpdateUserWithModalFields = (keyof UserFields)[];