@dynamic-labs/sdk-react-core 0.16.0

package/src/lib/utils/hooks/useUpdateEffect/useUpdateEffect.es.js

@@ -0,0 +1,14 @@
+import { useEffect } from 'react';
+import { useIsFirstRender } from '../useIsFirstRender/useIsFirstRender.es.js';
+
+const useUpdateEffect = (effect, deps) => {
+    const isFirst = useIsFirstRender();
+    useEffect(() => {
+        if (!isFirst) {
+            return effect();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+};
+
+export { useUpdateEffect };

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

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

package/src/lib/utils/hooks/useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.cjs.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs.js');
+var useCreateUserProfileByJWTCallback = require('../useCreateUserProfileByJWTCallback/useCreateUserProfileByJWTCallback.cjs.js');
+
+const useUpdateUserProfileByJWTCallback = () => {
+    const { createUserProfileByJWT } = useCreateUserProfileByJWTCallback.useCreateUserProfileByJWTCallback();
+    const { setCallback } = useInternalDynamicContext.useInternalDynamicContext();
+    const updateUserProfileByJWT = React.useCallback((jwt) => {
+        createUserProfileByJWT(jwt);
+        setCallback('userProfileUpdate');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return { updateUserProfileByJWT };
+};
+
+exports.useUpdateUserProfileByJWTCallback = useUpdateUserProfileByJWTCallback;

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

@@ -0,0 +1,3 @@
+export declare const useUpdateUserProfileByJWTCallback: () => {
+    updateUserProfileByJWT: (jwt: string) => void;
+};

package/src/lib/utils/hooks/useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.es.js

@@ -0,0 +1,16 @@
+import { useCallback } from 'react';
+import { useInternalDynamicContext } from '../../../context/DynamicContext/useInternalDynamicContext.es.js';
+import { useCreateUserProfileByJWTCallback } from '../useCreateUserProfileByJWTCallback/useCreateUserProfileByJWTCallback.es.js';
+
+const useUpdateUserProfileByJWTCallback = () => {
+    const { createUserProfileByJWT } = useCreateUserProfileByJWTCallback();
+    const { setCallback } = useInternalDynamicContext();
+    const updateUserProfileByJWT = useCallback((jwt) => {
+        createUserProfileByJWT(jwt);
+        setCallback('userProfileUpdate');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return { updateUserProfileByJWT };
+};
+
+export { useUpdateUserProfileByJWTCallback };

package/src/lib/utils/hooks/useUserDataForm/useUserDataForm.cjs.js

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs.js');
+var React = require('react');
+var yup = require('yup');
+var multiWallet = require('@dynamic-labs/multi-wallet');
+require('@dynamic-labs/sdk-api');
+var logger = require('../../../shared/logger.cjs.js');
+require('@dynamic-labs/iconic');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs.js');
+var index = require('../../../shared/utils/functions/getValueByKey/index.cjs.js');
+require('../../constants/colors.cjs.js');
+var index$1 = require('../../../shared/consts/index.cjs.js');
+var fieldsConfig = require('../../../views/CollectUserDataView/fieldsConfig.cjs.js');
+var MockContext = require('../../../context/MockContext/MockContext.cjs.js');
+
+// Hook that returns the prepared data to work with the formik
+// In order to update or display user information
+const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies = true, fields, }) => {
+    var _a;
+    const { mockedSDK } = MockContext.useMockContext();
+    const [fetch, setFetch] = React.useState(false);
+    const enforcePolicies = shouldEnforcePolicies &&
+        ((_a = fields.find((setting) => setting.name === 'policiesConsent')) === null || _a === void 0 ? void 0 : _a.enabled);
+    const formikValidationSchema = React.useMemo(() => yup.object().shape(Object.fromEntries(fields.map(({ name, required }) => [
+        name,
+        required
+            ? index.getValueByKey(fieldsConfig.fieldsConfig, name).validation.required('required')
+            : index.getValueByKey(fieldsConfig.fieldsConfig, name).validation,
+    ]))), [fields]);
+    const formikInitialValues = React.useMemo(() => Object.fromEntries(fields.map(({ name }) => {
+        var _a, _b, _c;
+        const info = (userProfile !== null && userProfile !== void 0 ? userProfile : {});
+        const mapNameToDefaultValue = {
+            country: index$1.countryCodes[0].code,
+            policiesConsent: false,
+            tShirtSize: index$1.tShirtSizes[0],
+            team: index$1.teamNames[0],
+        };
+        const defaultValue = (_a = mapNameToDefaultValue[name]) !== null && _a !== void 0 ? _a : '';
+        return [name, (_c = (_b = index.getValueByKey(info, name)) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : defaultValue];
+    })) || {}, [fields, userProfile]);
+    const onFormSubmit = React.useCallback((values, formikHelper) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        if (mockedSDK)
+            return;
+        try {
+            if (!(userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId))
+                throw new multiWallet.DynamicError('Invalid environment ID');
+            setFetch(true);
+            let updatedUserFields = values;
+            if (enforcePolicies) {
+                updatedUserFields = Object.assign(Object.assign({}, updatedUserFields), { policiesConsent: true });
+                delete updatedUserFields.policiesConsentArray;
+            }
+            yield (onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(updatedUserFields));
+        }
+        catch (e) {
+            logger.logger.error(e);
+            onError === null || onError === void 0 ? void 0 : onError(e);
+            if (e.name === 'EmailAlreadyExistsError') {
+                formikHelper.setErrors({ email: 'Email already exists' });
+            }
+            else if (e.name === 'UsernameAlreadyExistsError') {
+                formikHelper.setErrors({ username: 'Username already exists' });
+            }
+            else {
+                formikHelper.setErrors({
+                    api: 'Something went wrong. Please try again.',
+                });
+            }
+        }
+        finally {
+            setFetch(false);
+        }
+    }), [mockedSDK, userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId, enforcePolicies, onSubmit, onError]);
+    return {
+        enforcePolicies,
+        fetch,
+        formikInitialValues,
+        formikValidationSchema,
+        onFormSubmit,
+    };
+};
+
+exports.useUserDataForm = useUserDataForm;

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

@@ -0,0 +1,41 @@
+import { FormikHelpers } from 'formik';
+import { ProjectSettingsKyc } from '@dynamic-labs/sdk-api';
+import { UserProfile } from '../../../shared';
+export type UserDataFormValues = {
+    email?: string;
+    policiesConsent?: boolean;
+    policiesConsentArray?: [];
+    username?: string;
+};
+export type UseUserDataFormProps = {
+    fields: ProjectSettingsKyc[];
+    onError?: (e: Error) => void;
+    onSubmit?: (formValues: UserDataFormValues) => void | Promise<void>;
+    shouldEnforcePolicies?: boolean;
+    userProfile?: UserProfile;
+};
+export declare const useUserDataForm: ({ onSubmit, onError, userProfile, shouldEnforcePolicies, fields, }: UseUserDataFormProps) => {
+    enforcePolicies: boolean | undefined;
+    fetch: boolean;
+    formikInitialValues: {
+        [k: string]: string;
+    };
+    formikValidationSchema: import("yup").ObjectSchema<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+    }>, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+    }>>, import("yup/lib/object").AssertsShape<import("yup/lib/object").Assign<import("yup/lib/object").ObjectShape, {
+        [k: string]: import("yup").StringSchema<string | undefined, import("yup/lib/types").AnyObject, string | undefined> | import("yup").BooleanSchema<boolean | undefined, import("yup/lib/types").AnyObject, boolean | undefined>;
+    }>>>;
+    onFormSubmit: (values: {
+        email?: string;
+        policiesConsent?: boolean;
+        policiesConsentArray?: [];
+        username?: string;
+    }, formikHelper: FormikHelpers<{
+        api?: string;
+        email?: string;
+        policiesConsent?: boolean;
+        username?: string;
+    }>) => Promise<void>;
+};

package/src/lib/utils/hooks/useUserDataForm/useUserDataForm.es.js

@@ -0,0 +1,84 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.es.js';
+import { useState, useMemo, useCallback } from 'react';
+import { object } from 'yup';
+import { DynamicError } from '@dynamic-labs/multi-wallet';
+import '@dynamic-labs/sdk-api';
+import { logger } from '../../../shared/logger.es.js';
+import '@dynamic-labs/iconic';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.es.js';
+import { getValueByKey } from '../../../shared/utils/functions/getValueByKey/index.es.js';
+import '../../constants/colors.es.js';
+import { countryCodes, tShirtSizes, teamNames } from '../../../shared/consts/index.es.js';
+import { fieldsConfig } from '../../../views/CollectUserDataView/fieldsConfig.es.js';
+import { useMockContext } from '../../../context/MockContext/MockContext.es.js';
+
+// Hook that returns the prepared data to work with the formik
+// In order to update or display user information
+const useUserDataForm = ({ onSubmit, onError, userProfile, shouldEnforcePolicies = true, fields, }) => {
+    var _a;
+    const { mockedSDK } = useMockContext();
+    const [fetch, setFetch] = useState(false);
+    const enforcePolicies = shouldEnforcePolicies &&
+        ((_a = fields.find((setting) => setting.name === 'policiesConsent')) === null || _a === void 0 ? void 0 : _a.enabled);
+    const formikValidationSchema = useMemo(() => object().shape(Object.fromEntries(fields.map(({ name, required }) => [
+        name,
+        required
+            ? getValueByKey(fieldsConfig, name).validation.required('required')
+            : getValueByKey(fieldsConfig, name).validation,
+    ]))), [fields]);
+    const formikInitialValues = useMemo(() => Object.fromEntries(fields.map(({ name }) => {
+        var _a, _b, _c;
+        const info = (userProfile !== null && userProfile !== void 0 ? userProfile : {});
+        const mapNameToDefaultValue = {
+            country: countryCodes[0].code,
+            policiesConsent: false,
+            tShirtSize: tShirtSizes[0],
+            team: teamNames[0],
+        };
+        const defaultValue = (_a = mapNameToDefaultValue[name]) !== null && _a !== void 0 ? _a : '';
+        return [name, (_c = (_b = getValueByKey(info, name)) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : defaultValue];
+    })) || {}, [fields, userProfile]);
+    const onFormSubmit = useCallback((values, formikHelper) => __awaiter(void 0, void 0, void 0, function* () {
+        if (mockedSDK)
+            return;
+        try {
+            if (!(userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId))
+                throw new DynamicError('Invalid environment ID');
+            setFetch(true);
+            let updatedUserFields = values;
+            if (enforcePolicies) {
+                updatedUserFields = Object.assign(Object.assign({}, updatedUserFields), { policiesConsent: true });
+                delete updatedUserFields.policiesConsentArray;
+            }
+            yield (onSubmit === null || onSubmit === void 0 ? void 0 : onSubmit(updatedUserFields));
+        }
+        catch (e) {
+            logger.error(e);
+            onError === null || onError === void 0 ? void 0 : onError(e);
+            if (e.name === 'EmailAlreadyExistsError') {
+                formikHelper.setErrors({ email: 'Email already exists' });
+            }
+            else if (e.name === 'UsernameAlreadyExistsError') {
+                formikHelper.setErrors({ username: 'Username already exists' });
+            }
+            else {
+                formikHelper.setErrors({
+                    api: 'Something went wrong. Please try again.',
+                });
+            }
+        }
+        finally {
+            setFetch(false);
+        }
+    }), [mockedSDK, userProfile === null || userProfile === void 0 ? void 0 : userProfile.environmentId, enforcePolicies, onSubmit, onError]);
+    return {
+        enforcePolicies,
+        fetch,
+        formikInitialValues,
+        formikValidationSchema,
+        onFormSubmit,
+    };
+};
+
+export { useUserDataForm };

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

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs.js');
+var React = require('react');
+var yup = require('yup');
+var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs.js');
+var api = require('../../../data/api.cjs.js');
+var isEmailVerificationRequired = require('../../functions/authenication/isEmailVerificationRequired/isEmailVerificationRequired.cjs.js');
+var EmailVerificationContext = require('../../../context/EmailVerificationContext/EmailVerificationContext.cjs.js');
+var useEmailVerificationRequest = require('../authenticationHooks/useEmailVerificationRequest/useEmailVerificationRequest.cjs.js');
+var useUpdateUserProfileByJWTCallback = require('../useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.cjs.js');
+
+// User Fields Schema without captchaToken and policiesConsent properties
+const userFieldsSchema = yup.object().shape({
+    email: yup.string(),
+    alias: yup.string(),
+    firstName: yup.string(),
+    lastName: yup.string(),
+    jobTitle: yup.string(),
+    phoneNumber: yup.string(),
+    tShirtSize: yup.string(),
+    team: yup.string(),
+    country: yup.string(),
+});
+// Hook exposed to the public
+const useUserUpdateRequestInternal = ({ validationSchemaStripUnknown, }) => {
+    const { authToken, onboardingOnlyJwt, environmentId } = useInternalDynamicContext.useInternalDynamicContext();
+    const jwtToken = onboardingOnlyJwt || authToken;
+    const { setVerificationUUID, setEmail } = EmailVerificationContext.useEmailVerificationContext();
+    const { verifyEmail: verifyEmailFn } = useEmailVerificationRequest.useEmailVerificationRequest();
+    const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback.useUpdateUserProfileByJWTCallback();
+    const updateUser = React.useCallback((userFields, userEnvironmentId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const validatedUserFields = yield userFieldsSchema.validate(userFields, {
+            stripUnknown: validationSchemaStripUnknown,
+        });
+        const updateUserProfileResponse = yield api.updateUserProfileFields(jwtToken, userEnvironmentId || environmentId, validatedUserFields);
+        const _isEmailVerificationRequired = isEmailVerificationRequired.isEmailVerificationRequired(updateUserProfileResponse);
+        if (!_isEmailVerificationRequired) {
+            // If email verification is not needed then we can update the user profile immediately.
+            updateUserProfileByJWT(updateUserProfileResponse.jwt);
+            return {
+                isEmailVerificationRequired: _isEmailVerificationRequired,
+                updateUserProfileResponse,
+            };
+        }
+        // We update EmailContext to use this information in the Email Verification view
+        setEmail((_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.email);
+        setVerificationUUID((_b = updateUserProfileResponse.emailVerification) === null || _b === void 0 ? void 0 : _b.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 verifyEmailFn(verificationToken, (_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.verificationUUID);
+        };
+        return {
+            isEmailVerificationRequired: _isEmailVerificationRequired,
+            updateUserProfileResponse,
+            verifyEmailFn: scopedVerifyEmailFn,
+        };
+    }), [
+        environmentId,
+        jwtToken,
+        setEmail,
+        setVerificationUUID,
+        validationSchemaStripUnknown,
+        updateUserProfileByJWT,
+        verifyEmailFn,
+    ]);
+    return { updateUser };
+};
+// Hook exposed to the clients
+// We do not want customers to be able to edit properties such as policiesConsent or captchaToken
+const useUserUpdateRequest = () => 
+// eslint-disable-next-line react-hooks/rules-of-hooks
+useUserUpdateRequestInternal({ validationSchemaStripUnknown: true });
+
+exports.useUserUpdateRequest = useUserUpdateRequest;
+exports.useUserUpdateRequestInternal = useUserUpdateRequestInternal;

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

@@ -0,0 +1,26 @@
+import { UserFields } from '@dynamic-labs/sdk-api';
+export type UpdateUserFieldsArg = Omit<UserFields, 'captchaToken' | 'policiesConsent'>;
+export declare const useUserUpdateRequestInternal: ({ validationSchemaStripUnknown, }: {
+    validationSchemaStripUnknown: boolean;
+}) => {
+    updateUser: (userFields: UpdateUserFieldsArg, userEnvironmentId?: string) => Promise<{
+        isEmailVerificationRequired: false;
+        updateUserProfileResponse: import("@dynamic-labs/sdk-api").UpdateSelfResponse;
+        verifyEmailFn?: undefined;
+    } | {
+        isEmailVerificationRequired: true;
+        updateUserProfileResponse: import("@dynamic-labs/sdk-api").UpdateSelfResponse;
+        verifyEmailFn: (verificationToken: string) => Promise<import("@dynamic-labs/sdk-api").UpdateSelfResponse>;
+    }>;
+};
+export declare const useUserUpdateRequest: () => {
+    updateUser: (userFields: UpdateUserFieldsArg, userEnvironmentId?: string) => Promise<{
+        isEmailVerificationRequired: false;
+        updateUserProfileResponse: import("@dynamic-labs/sdk-api").UpdateSelfResponse;
+        verifyEmailFn?: undefined;
+    } | {
+        isEmailVerificationRequired: true;
+        updateUserProfileResponse: import("@dynamic-labs/sdk-api").UpdateSelfResponse;
+        verifyEmailFn: (verificationToken: string) => Promise<import("@dynamic-labs/sdk-api").UpdateSelfResponse>;
+    }>;
+};

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

@@ -0,0 +1,77 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.es.js';
+import { useCallback } from 'react';
+import { object, string } from 'yup';
+import { useInternalDynamicContext } from '../../../context/DynamicContext/useInternalDynamicContext.es.js';
+import { updateUserProfileFields } from '../../../data/api.es.js';
+import { isEmailVerificationRequired } from '../../functions/authenication/isEmailVerificationRequired/isEmailVerificationRequired.es.js';
+import { useEmailVerificationContext } from '../../../context/EmailVerificationContext/EmailVerificationContext.es.js';
+import { useEmailVerificationRequest } from '../authenticationHooks/useEmailVerificationRequest/useEmailVerificationRequest.es.js';
+import { useUpdateUserProfileByJWTCallback } from '../useUpdateUserProfileByJWTCallback/useUpdateUserProfileByJWTCallback.es.js';
+
+// User Fields Schema without captchaToken and policiesConsent properties
+const userFieldsSchema = object().shape({
+    email: string(),
+    alias: string(),
+    firstName: string(),
+    lastName: string(),
+    jobTitle: string(),
+    phoneNumber: string(),
+    tShirtSize: string(),
+    team: string(),
+    country: string(),
+});
+// Hook exposed to the public
+const useUserUpdateRequestInternal = ({ validationSchemaStripUnknown, }) => {
+    const { authToken, onboardingOnlyJwt, environmentId } = useInternalDynamicContext();
+    const jwtToken = onboardingOnlyJwt || authToken;
+    const { setVerificationUUID, setEmail } = useEmailVerificationContext();
+    const { verifyEmail: verifyEmailFn } = useEmailVerificationRequest();
+    const { updateUserProfileByJWT } = useUpdateUserProfileByJWTCallback();
+    const updateUser = useCallback((userFields, userEnvironmentId) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const validatedUserFields = yield userFieldsSchema.validate(userFields, {
+            stripUnknown: validationSchemaStripUnknown,
+        });
+        const updateUserProfileResponse = yield updateUserProfileFields(jwtToken, userEnvironmentId || environmentId, validatedUserFields);
+        const _isEmailVerificationRequired = isEmailVerificationRequired(updateUserProfileResponse);
+        if (!_isEmailVerificationRequired) {
+            // If email verification is not needed then we can update the user profile immediately.
+            updateUserProfileByJWT(updateUserProfileResponse.jwt);
+            return {
+                isEmailVerificationRequired: _isEmailVerificationRequired,
+                updateUserProfileResponse,
+            };
+        }
+        // We update EmailContext to use this information in the Email Verification view
+        setEmail((_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.email);
+        setVerificationUUID((_b = updateUserProfileResponse.emailVerification) === null || _b === void 0 ? void 0 : _b.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 verifyEmailFn(verificationToken, (_a = updateUserProfileResponse.emailVerification) === null || _a === void 0 ? void 0 : _a.verificationUUID);
+        };
+        return {
+            isEmailVerificationRequired: _isEmailVerificationRequired,
+            updateUserProfileResponse,
+            verifyEmailFn: scopedVerifyEmailFn,
+        };
+    }), [
+        environmentId,
+        jwtToken,
+        setEmail,
+        setVerificationUUID,
+        validationSchemaStripUnknown,
+        updateUserProfileByJWT,
+        verifyEmailFn,
+    ]);
+    return { updateUser };
+};
+// Hook exposed to the clients
+// We do not want customers to be able to edit properties such as policiesConsent or captchaToken
+const useUserUpdateRequest = () => 
+// eslint-disable-next-line react-hooks/rules-of-hooks
+useUserUpdateRequestInternal({ validationSchemaStripUnknown: true });
+
+export { useUserUpdateRequest, useUserUpdateRequestInternal };

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

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

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

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs.js');
+var multiWallet = require('@dynamic-labs/multi-wallet');
+var api = require('../../../data/api.cjs.js');
+var index = require('../../functions/storeAuthToken/index.cjs.js');
+var localStorage = require('../../constants/localStorage.cjs.js');
+require('../../constants/colors.cjs.js');
+var decodeJwt = require('../../../shared/utils/functions/decodeJwt/decodeJwt.cjs.js');
+var logger = require('../../../shared/logger.cjs.js');
+var setToLS = require('../../../shared/utils/functions/storage/setToLS.cjs.js');
+require('@dynamic-labs/iconic');
+require('react/jsx-runtime');
+var ViewContext = require('../../../context/ViewContext/ViewContext.cjs.js');
+require('react');
+var getVerifyArgs = require('../../functions/getVerifyArgs/getVerifyArgs.cjs.js');
+var createUserProfile = require('../../functions/createUserProfile/createUserProfile.cjs.js');
+var isSupportedNetwork = require('../../functions/isSupportedNetwork/isSupportedNetwork.cjs.js');
+require('@dynamic-labs/sdk-api');
+var isProgrammableNetworkSwitchSupported = require('../../functions/isProgrammableNetworkSwitchSupported/isProgrammableNetworkSwitchSupported.cjs.js');
+var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs.js');
+var ErrorContext = require('../../../context/ErrorContext/ErrorContext.cjs.js');
+var getSiweStatement = require('../../functions/getSiweStatement/getSiweStatement.cjs.js');
+var getWalletProvider = require('../../functions/getWalletProvider/getWalletProvider.cjs.js');
+require('../../../shared/consts/index.cjs.js');
+
+// This logic is used to both verify or link a wallet
+// Since we are re-using the different screens to authenticate or link the wallet.
+// This logic is the best place to determine whether we should verify or verify and link.
+const useVerifyWallet = ({ consumeNonce, displayTermsOfService, environmentId, projectSettings, setIsSingleWalletAccount, }) => {
+    const { setView } = ViewContext.useViewContext();
+    const { setErrorMessage, setError } = ErrorContext.useErrorContext();
+    const { setUser, multiWalletWidgetState, debugError, multiWallet: multiWalletEnabled, appName, primaryWalletId, setCallback, setShowAuthFlow, setPrimaryWalletId, siweStatement, connectedWallet, authMode, setOnboardingOnlyJwt, authToken, loginWithEmail, } = useInternalDynamicContext.useInternalDynamicContext();
+    // If the user is not already logged it means that we only need to verify
+    // We need this boolean for the part of the logic where we already persisted a new authToken,
+    // and need to distinguish between logic for verify or linking.
+    const verifyOnly = !authToken;
+    const generateJWT = (walletConnector, walletProvider, fetchPublicAddressOpts, publicWalletAddress, captchaToken) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        let Jwt;
+        const nonce = consumeNonce();
+        if (nonce === undefined)
+            throw new multiWallet.DynamicError('Missing nonce');
+        const verifyArgs = yield getVerifyArgs.getVerifyArgs({
+            displayTermsOfService,
+            environmentId,
+            fetchPublicAddressOpts,
+            nonce,
+            publicWalletAddress,
+            siweStatement: getSiweStatement.getSiweStatement({ appName, siweStatement }),
+            walletConnector,
+            walletProvider,
+        });
+        if (authToken === undefined || !multiWalletEnabled) {
+            Jwt = yield api.verifyWallet(environmentId, Object.assign(Object.assign({}, verifyArgs), { captchaToken }));
+        }
+        else {
+            Jwt = yield api.linkWallet(environmentId, verifyArgs, authToken);
+        }
+        if (Jwt === undefined)
+            throw new multiWallet.DynamicError('Could not obtain a valid JWT');
+        // TODO DYN-523: add verification here that the JWT is valid with the publicKey
+        return Jwt;
+    });
+    // Overrides the stored primary wallet id when the
+    // user logs in for the first time.
+    // Or when the user is linking an additional
+    // account on the same wallet as the primary wallet.
+    const updatePrimaryWalletId = (walletConnector, user) => {
+        const newSelectedCredentialWallet = user.verifiedCredentials.find((cred) => cred.id === user.lastVerifiedCredentialId &&
+            cred.format === 'blockchain');
+        if (newSelectedCredentialWallet) {
+            const currentPrimaryWallet = user.verifiedCredentials.find((a) => a.id === primaryWalletId);
+            if (verifyOnly ||
+                primaryWalletId === undefined ||
+                (multiWalletWidgetState === 'awaiting_signature' &&
+                    newSelectedCredentialWallet.walletName ===
+                        (currentPrimaryWallet === null || currentPrimaryWallet === void 0 ? void 0 : currentPrimaryWallet.walletName)) ||
+                ((currentPrimaryWallet === null || currentPrimaryWallet === void 0 ? void 0 : currentPrimaryWallet.chain) === 'flow' &&
+                    walletConnector.connectedChain === 'FLOW')) {
+                setPrimaryWalletId(newSelectedCredentialWallet.id);
+            }
+        }
+    };
+    const handleError = (e, walletConnector) => {
+        var _a;
+        // This is a special case where the user is trying to link a wallet
+        // and the wallet is already linked and we don't want to kill the session.
+        if (e.name === 'WalletUsedError') {
+            setShowAuthFlow(true);
+            setView('wallet-used');
+            setIsSingleWalletAccount(false);
+            if (e.code === 'reassign_wallet_error') {
+                setIsSingleWalletAccount(true);
+            }
+            return;
+        }
+        (_a = walletConnector.endSession) === null || _a === void 0 ? void 0 : _a.call(walletConnector);
+        if (e.name === 'ChainalysisError') {
+            setView('chainalysis-blocked-wallet');
+            return;
+        }
+        if (e.name === 'NoAccessError') {
+            setView('no-access');
+            return;
+        }
+        if (connectedWallet && authMode === 'connect-only') {
+            throw new multiWallet.DynamicError(e.message);
+        }
+        setView(loginWithEmail ? 'login-with-email-or-wallet' : 'wallet-list');
+        logger.logger.error(e);
+        if (debugError) {
+            setError(`${e.message}\n ${e.stack}`);
+        }
+        else {
+            setErrorMessage(e.code);
+        }
+    };
+    return ({ walletConnector, fetchPublicAddressOpts, publicWalletAddress, captchaToken, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const walletProvider = getWalletProvider.getWalletProvider(walletConnector);
+        const network = yield walletConnector.getNetwork();
+        const _isSupportedNetwork = isSupportedNetwork.isSupportedNetwork({
+            network,
+            walletConnector,
+        });
+        try {
+            const Jwt = yield generateJWT(walletConnector, walletProvider, fetchPublicAddressOpts, publicWalletAddress, captchaToken);
+            const decodedJwt = decodeJwt.decodeJwt(Jwt);
+            if (decodedJwt === undefined)
+                throw new multiWallet.DynamicError('Invalid token!');
+            const user = yield createUserProfile.createUserProfile(decodedJwt);
+            const isKycRequired = decodedJwt.missingFields.length;
+            setOnboardingOnlyJwt(Jwt);
+            setToLS.setToLS(localStorage.LAST_USED_WALLET, walletConnector.name);
+            updatePrimaryWalletId(walletConnector, user);
+            // Routes user to "Not Supported Network" screen if the user is not on the supported network
+            if (projectSettings &&
+                verifyOnly &&
+                !_isSupportedNetwork &&
+                !isKycRequired) {
+                const _isProgrammableNetworkSwitchSupported = isProgrammableNetworkSwitchSupported.isProgrammableNetworkSwitchSupported(walletConnector);
+                if (_isProgrammableNetworkSwitchSupported) {
+                    return setView('network-not-supported');
+                }
+                return setView('network-not-supported-manual');
+            }
+            // TODO: how can projectSettings be undefined?
+            if (verifyOnly && projectSettings && isKycRequired) {
+                setShowAuthFlow(true);
+                return setView('collect-user-data');
+            }
+            index.storeAuthToken(Jwt);
+            setOnboardingOnlyJwt(undefined);
+            setUser(user); // The user should only be set if no KYC is needed.
+            setShowAuthFlow(false);
+            /* istanbul ignore else */
+            if (verifyOnly) {
+                setCallback('authSuccess');
+            }
+            else {
+                setCallback('linkSuccess');
+            }
+        }
+        catch (e) {
+            handleError(e, walletConnector);
+        }
+    });
+};
+
+exports.useVerifyWallet = useVerifyWallet;

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

@@ -0,0 +1,9 @@
+import { Dispatch, SetStateAction } from 'react';
+import { ProjectSettingsProps, VerifyProps, VerifyCallbackArgs } from '../../../shared/types';
+type UseVerifyWalletArgs = VerifyProps & ProjectSettingsProps & {
+    consumeNonce: () => string | undefined;
+    displayTermsOfService: boolean;
+    setIsSingleWalletAccount: Dispatch<SetStateAction<boolean>>;
+};
+export declare const useVerifyWallet: ({ consumeNonce, displayTermsOfService, environmentId, projectSettings, setIsSingleWalletAccount, }: UseVerifyWalletArgs) => ({ walletConnector, fetchPublicAddressOpts, publicWalletAddress, captchaToken, }: VerifyCallbackArgs) => Promise<void>;
+export {};