@dynamic-labs/sdk-react-core 4.63.1 → 4.65.0

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

@@ -0,0 +1,197 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var React = require('react');
+var client = require('@dynamic-labs-sdk/client');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+require('@dynamic-labs-sdk/client/core');
+require('../../../client/client.cjs');
+require('../../../config/ApiEndpoint.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+var logger = require('../../../shared/logger.cjs');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/utils');
+require('../../constants/colors.cjs');
+require('../../constants/values.cjs');
+require('../../../shared/consts/index.cjs');
+require('@dynamic-labs/multi-wallet');
+require('react-international-phone');
+require('../../../store/state/nonce/nonce.cjs');
+require('@dynamic-labs/locale');
+require('../../../store/state/dynamicContextProps/dynamicContextProps.cjs');
+require('../../../store/state/primaryWalletId/primaryWalletId.cjs');
+require('../../../store/state/connectedWalletsInfo/connectedWalletsInfo.cjs');
+require('../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.cjs');
+require('../../../events/dynamicEvents.cjs');
+var useUser = require('../../../client/extension/user/useUser/useUser.cjs');
+var useConnectAndSign = require('../authenticationHooks/useConnectAndSign/useConnectAndSign.cjs');
+var UserWalletsContext = require('../../../context/UserWalletsContext/UserWalletsContext.cjs');
+
+const INITIAL_STATE = {
+    error: null,
+    isLoading: false,
+    otpVerification: null,
+};
+const isCountryCode = (value) => value !== undefined && value in client.supportedCountries;
+const isOtpCapableCredential = (cred) => cred.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Email ||
+    cred.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.PhoneNumber;
+const resolveTargetCredential = (credentials, credentialId) => {
+    var _a, _b;
+    if (credentialId) {
+        return ((_a = credentials.find((cred) => cred.id === credentialId)) !== null && _a !== void 0 ? _a : `Credential with id "${credentialId}" not found`);
+    }
+    return ((_b = credentials.find((cred) => cred.signInEnabled && isOtpCapableCredential(cred))) !== null && _b !== void 0 ? _b : 'No sign-in enabled email or SMS credential found for step-up authentication');
+};
+const sendEmailOtp = (credential) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (!credential.email) {
+        throw new Error('Email credential is missing email address');
+    }
+    return client.sendEmailOTP({ email: credential.email });
+});
+const sendSmsOtp = (credential) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const normalizedPhoneCountryCode = (_a = credential.phoneCountryCode) === null || _a === void 0 ? void 0 : _a.replace(/^\+/, '');
+    const matchedCountryCode = Object.keys(client.supportedCountries).find((key) => client.supportedCountries[key].code === normalizedPhoneCountryCode);
+    const isoCountryCode = isCountryCode(credential.isoCountryCode)
+        ? credential.isoCountryCode
+        : matchedCountryCode;
+    if (!credential.phoneNumber || !isoCountryCode) {
+        throw new Error('SMS credential is missing phone number or country code');
+    }
+    return client.sendSmsOTP({ isoCountryCode, phoneNumber: credential.phoneNumber });
+});
+const dispatchOtp = (credential) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    return credential.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Email
+        ? sendEmailOtp(credential)
+        : sendSmsOtp(credential);
+});
+/**
+ * Perform step-up authentication for an already-authenticated user via OTP.
+ *
+ * Automatically selects the first sign-in enabled email or SMS credential on
+ * the user, or targets a specific credential when `credentialId` is provided.
+ *
+ * @param params.credentialId - Optional id of a specific verified credential to
+ *   use. Must be an email or SMS credential. Defaults to the first sign-in
+ *   enabled email or SMS credential on the authenticated user.
+ *
+ * @returns `sendOtp` – sends the OTP to the resolved credential.
+ * @returns `verifyOtp` – verifies the OTP code supplied by the user.
+ * @returns `state` – current loading / error / otpVerification state.
+ * @returns `resetState` – resets state back to its initial value.
+ *
+ * @example
+ * ```tsx
+ * const { sendOtp, verifyOtp, state } = useStepUpAuthentication();
+ *
+ * // Step 1: send OTP
+ * await sendOtp();
+ *
+ * // Step 2: after the user enters the code
+ * const result = await verifyOtp({ verificationToken: '123456' });
+ * ```
+ */
+const useStepUpAuthentication = ({ credentialId, } = {}) => {
+    const user = useUser.useUser();
+    const [state, setState] = React.useState(INITIAL_STATE);
+    const connectAndSign = useConnectAndSign.useConnectAndSign();
+    const { userWallets } = UserWalletsContext.useInternalUserWallets();
+    // Ref keeps the latest otpVerification available inside the verifyOtp
+    // callback without creating a stale closure over state.
+    const otpVerificationRef = React.useRef(null);
+    const resetState = React.useCallback(() => {
+        otpVerificationRef.current = null;
+        setState(INITIAL_STATE);
+    }, []);
+    const setError = React.useCallback((errorMessage) => {
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+        logger.logger.error(errorMessage);
+    }, []);
+    const sendOtp = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const credentials = user === null || user === void 0 ? void 0 : user.verifiedCredentials;
+        if (!(credentials === null || credentials === void 0 ? void 0 : credentials.length)) {
+            setError('No verified credentials found for the authenticated user');
+            return null;
+        }
+        const result = resolveTargetCredential(credentials, credentialId);
+        if (typeof result === 'string') {
+            setError(result);
+            return null;
+        }
+        if (!isOtpCapableCredential(result)) {
+            setError(`Credential format "${result.format}" does not support OTP verification. Only email and SMS credentials are supported`);
+            return null;
+        }
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const otpVerification = yield dispatchOtp(result);
+            otpVerificationRef.current = otpVerification;
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false, otpVerification })));
+            return otpVerification;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to send OTP';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.logger.error('Failed to send OTP for step-up authentication', { error });
+            return null;
+        }
+    }), [credentialId, setError, user === null || user === void 0 ? void 0 : user.verifiedCredentials]);
+    const verifyOtp = React.useCallback((_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ requestedScopes, verificationToken, }) {
+        const otpVerification = otpVerificationRef.current;
+        if (!otpVerification) {
+            setError('OTP verification has not been initiated. Call sendOtp() first');
+            return null;
+        }
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const response = yield client.verifyOTP({
+                otpVerification,
+                requestedScopes,
+                verificationToken,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false })));
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to verify OTP';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.logger.error('Failed to verify OTP for step-up authentication', {
+                error,
+            });
+            return null;
+        }
+    }), [setError]);
+    const verifyWallet = React.useCallback((_b) => _tslib.__awaiter(void 0, [_b], void 0, function* ({ requestedScopes }) {
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        const wallet = userWallets.find((w) => w.id === credentialId);
+        if (!wallet) {
+            setError(`Wallet with id "${credentialId}" not found`);
+            return;
+        }
+        try {
+            yield connectAndSign({
+                requestedScopes,
+                walletConnector: wallet.connector,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : 'Failed to verify wallet for step-up authentication';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.logger.error('Failed to verify wallet for step-up authentication', {
+                error,
+            });
+        }
+    }), [connectAndSign, credentialId, setError, userWallets]);
+    return { resetState, sendOtp, state, verifyOtp, verifyWallet };
+};
+
+exports.useStepUpAuthentication = useStepUpAuthentication;

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

@@ -0,0 +1,51 @@
+import type { OTPVerification } from '@dynamic-labs-sdk/client';
+import { TokenScope, VerifyResponse } from '@dynamic-labs/sdk-api-core';
+export type StepUpAuthenticationState = {
+    error: string | null;
+    isLoading: boolean;
+    otpVerification: OTPVerification | null;
+};
+export type VerifyOtpParams = {
+    requestedScopes?: TokenScope[];
+    verificationToken: string;
+};
+export type VerifyWalletParams = {
+    requestedScopes?: TokenScope[];
+};
+export type UseStepUpAuthenticationParams = {
+    credentialId?: string;
+};
+export type UseStepUpAuthenticationReturn = {
+    resetState: () => void;
+    sendOtp: () => Promise<OTPVerification | null>;
+    state: StepUpAuthenticationState;
+    verifyOtp: (params: VerifyOtpParams) => Promise<VerifyResponse | null>;
+    verifyWallet: (params: VerifyWalletParams) => Promise<void>;
+};
+/**
+ * Perform step-up authentication for an already-authenticated user via OTP.
+ *
+ * Automatically selects the first sign-in enabled email or SMS credential on
+ * the user, or targets a specific credential when `credentialId` is provided.
+ *
+ * @param params.credentialId - Optional id of a specific verified credential to
+ *   use. Must be an email or SMS credential. Defaults to the first sign-in
+ *   enabled email or SMS credential on the authenticated user.
+ *
+ * @returns `sendOtp` – sends the OTP to the resolved credential.
+ * @returns `verifyOtp` – verifies the OTP code supplied by the user.
+ * @returns `state` – current loading / error / otpVerification state.
+ * @returns `resetState` – resets state back to its initial value.
+ *
+ * @example
+ * ```tsx
+ * const { sendOtp, verifyOtp, state } = useStepUpAuthentication();
+ *
+ * // Step 1: send OTP
+ * await sendOtp();
+ *
+ * // Step 2: after the user enters the code
+ * const result = await verifyOtp({ verificationToken: '123456' });
+ * ```
+ */
+export declare const useStepUpAuthentication: ({ credentialId, }?: UseStepUpAuthenticationParams) => UseStepUpAuthenticationReturn;

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

@@ -0,0 +1,193 @@
+'use client'
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { useState, useRef, useCallback } from 'react';
+import { verifyOTP, sendEmailOTP, supportedCountries, sendSmsOTP } from '@dynamic-labs-sdk/client';
+import { JwtVerifiedCredentialFormatEnum } from '@dynamic-labs/sdk-api-core';
+import '@dynamic-labs-sdk/client/core';
+import '../../../client/client.js';
+import '../../../config/ApiEndpoint.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.js';
+import { logger } from '../../../shared/logger.js';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/utils';
+import '../../constants/colors.js';
+import '../../constants/values.js';
+import '../../../shared/consts/index.js';
+import '@dynamic-labs/multi-wallet';
+import 'react-international-phone';
+import '../../../store/state/nonce/nonce.js';
+import '@dynamic-labs/locale';
+import '../../../store/state/dynamicContextProps/dynamicContextProps.js';
+import '../../../store/state/primaryWalletId/primaryWalletId.js';
+import '../../../store/state/connectedWalletsInfo/connectedWalletsInfo.js';
+import '../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.js';
+import '../../../events/dynamicEvents.js';
+import { useUser } from '../../../client/extension/user/useUser/useUser.js';
+import { useConnectAndSign } from '../authenticationHooks/useConnectAndSign/useConnectAndSign.js';
+import { useInternalUserWallets } from '../../../context/UserWalletsContext/UserWalletsContext.js';
+
+const INITIAL_STATE = {
+    error: null,
+    isLoading: false,
+    otpVerification: null,
+};
+const isCountryCode = (value) => value !== undefined && value in supportedCountries;
+const isOtpCapableCredential = (cred) => cred.format === JwtVerifiedCredentialFormatEnum.Email ||
+    cred.format === JwtVerifiedCredentialFormatEnum.PhoneNumber;
+const resolveTargetCredential = (credentials, credentialId) => {
+    var _a, _b;
+    if (credentialId) {
+        return ((_a = credentials.find((cred) => cred.id === credentialId)) !== null && _a !== void 0 ? _a : `Credential with id "${credentialId}" not found`);
+    }
+    return ((_b = credentials.find((cred) => cred.signInEnabled && isOtpCapableCredential(cred))) !== null && _b !== void 0 ? _b : 'No sign-in enabled email or SMS credential found for step-up authentication');
+};
+const sendEmailOtp = (credential) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!credential.email) {
+        throw new Error('Email credential is missing email address');
+    }
+    return sendEmailOTP({ email: credential.email });
+});
+const sendSmsOtp = (credential) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const normalizedPhoneCountryCode = (_a = credential.phoneCountryCode) === null || _a === void 0 ? void 0 : _a.replace(/^\+/, '');
+    const matchedCountryCode = Object.keys(supportedCountries).find((key) => supportedCountries[key].code === normalizedPhoneCountryCode);
+    const isoCountryCode = isCountryCode(credential.isoCountryCode)
+        ? credential.isoCountryCode
+        : matchedCountryCode;
+    if (!credential.phoneNumber || !isoCountryCode) {
+        throw new Error('SMS credential is missing phone number or country code');
+    }
+    return sendSmsOTP({ isoCountryCode, phoneNumber: credential.phoneNumber });
+});
+const dispatchOtp = (credential) => __awaiter(void 0, void 0, void 0, function* () {
+    return credential.format === JwtVerifiedCredentialFormatEnum.Email
+        ? sendEmailOtp(credential)
+        : sendSmsOtp(credential);
+});
+/**
+ * Perform step-up authentication for an already-authenticated user via OTP.
+ *
+ * Automatically selects the first sign-in enabled email or SMS credential on
+ * the user, or targets a specific credential when `credentialId` is provided.
+ *
+ * @param params.credentialId - Optional id of a specific verified credential to
+ *   use. Must be an email or SMS credential. Defaults to the first sign-in
+ *   enabled email or SMS credential on the authenticated user.
+ *
+ * @returns `sendOtp` – sends the OTP to the resolved credential.
+ * @returns `verifyOtp` – verifies the OTP code supplied by the user.
+ * @returns `state` – current loading / error / otpVerification state.
+ * @returns `resetState` – resets state back to its initial value.
+ *
+ * @example
+ * ```tsx
+ * const { sendOtp, verifyOtp, state } = useStepUpAuthentication();
+ *
+ * // Step 1: send OTP
+ * await sendOtp();
+ *
+ * // Step 2: after the user enters the code
+ * const result = await verifyOtp({ verificationToken: '123456' });
+ * ```
+ */
+const useStepUpAuthentication = ({ credentialId, } = {}) => {
+    const user = useUser();
+    const [state, setState] = useState(INITIAL_STATE);
+    const connectAndSign = useConnectAndSign();
+    const { userWallets } = useInternalUserWallets();
+    // Ref keeps the latest otpVerification available inside the verifyOtp
+    // callback without creating a stale closure over state.
+    const otpVerificationRef = useRef(null);
+    const resetState = useCallback(() => {
+        otpVerificationRef.current = null;
+        setState(INITIAL_STATE);
+    }, []);
+    const setError = useCallback((errorMessage) => {
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+        logger.error(errorMessage);
+    }, []);
+    const sendOtp = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const credentials = user === null || user === void 0 ? void 0 : user.verifiedCredentials;
+        if (!(credentials === null || credentials === void 0 ? void 0 : credentials.length)) {
+            setError('No verified credentials found for the authenticated user');
+            return null;
+        }
+        const result = resolveTargetCredential(credentials, credentialId);
+        if (typeof result === 'string') {
+            setError(result);
+            return null;
+        }
+        if (!isOtpCapableCredential(result)) {
+            setError(`Credential format "${result.format}" does not support OTP verification. Only email and SMS credentials are supported`);
+            return null;
+        }
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const otpVerification = yield dispatchOtp(result);
+            otpVerificationRef.current = otpVerification;
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false, otpVerification })));
+            return otpVerification;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to send OTP';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.error('Failed to send OTP for step-up authentication', { error });
+            return null;
+        }
+    }), [credentialId, setError, user === null || user === void 0 ? void 0 : user.verifiedCredentials]);
+    const verifyOtp = useCallback((_a) => __awaiter(void 0, [_a], void 0, function* ({ requestedScopes, verificationToken, }) {
+        const otpVerification = otpVerificationRef.current;
+        if (!otpVerification) {
+            setError('OTP verification has not been initiated. Call sendOtp() first');
+            return null;
+        }
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const response = yield verifyOTP({
+                otpVerification,
+                requestedScopes,
+                verificationToken,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false })));
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to verify OTP';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.error('Failed to verify OTP for step-up authentication', {
+                error,
+            });
+            return null;
+        }
+    }), [setError]);
+    const verifyWallet = useCallback((_b) => __awaiter(void 0, [_b], void 0, function* ({ requestedScopes }) {
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        const wallet = userWallets.find((w) => w.id === credentialId);
+        if (!wallet) {
+            setError(`Wallet with id "${credentialId}" not found`);
+            return;
+        }
+        try {
+            yield connectAndSign({
+                requestedScopes,
+                walletConnector: wallet.connector,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : 'Failed to verify wallet for step-up authentication';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.error('Failed to verify wallet for step-up authentication', {
+                error,
+            });
+        }
+    }), [connectAndSign, credentialId, setError, userWallets]);
+    return { resetState, sendOtp, state, verifyOtp, verifyWallet };
+};
+
+export { useStepUpAuthentication };

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

@@ -134,7 +134,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
     // We need this boolean to distinguish between logic for verify or linking.
     const verifyOnly = !user;
     const shouldFallbackToConnectOnly = enableConnectOnlyFallback && (verifyOnly || !multiWalletEnabled);
-    const generateJWT = (walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const generateJWT = (walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         const verifyArgs = yield getVerifyArgs.getVerifyArgs({
             displaySiweStatement,
             environmentId,
@@ -156,6 +156,11 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             verifyResponse = wallets.verifyWallet(environmentId, Object.assign(Object.assign({}, verifyArgs), { captchaToken,
                 oauth }));
         }
+        else if (user && requestedScopes) {
+            verifyResponse = wallets.walletsVerify(environmentId, Object.assign(Object.assign({}, verifyArgs), { captchaToken,
+                oauth,
+                requestedScopes }));
+        }
         else {
             verifyResponse = wallets.linkWallet(environmentId, verifyArgs);
         }
@@ -285,7 +290,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             setErrorMessage(e.code);
         }
     };
-    return (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, }) {
+    return (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes, }) {
         const walletProvider = walletConnectorCore.getWalletProvider(walletConnector);
         dynamicEvents.dynamicEvents.emit('authInit', {
             address: publicWalletAddress,
@@ -294,7 +299,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             type: 'wallet',
         });
         try {
-            const { verifyFunction, verifyArgs } = yield generateJWT(walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride);
+            const { verifyFunction, verifyArgs } = yield generateJWT(walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes);
             yield initAuth({
                 isSignIn: verifyOnly,
                 onError: (e) => {

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

@@ -7,5 +7,5 @@ type UseVerifyWalletArgs = {
     displaySiweStatement: boolean;
     setIsSingleWalletAccount: Dispatch<SetStateAction<boolean>>;
 };
-export declare const useVerifyWallet: ({ displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, }: UseVerifyWalletArgs) => ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, }: VerifyCallbackArgs) => Promise<void>;
+export declare const useVerifyWallet: ({ displaySiweStatement, environmentId, projectSettings, setIsSingleWalletAccount, }: UseVerifyWalletArgs) => ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes, }: VerifyCallbackArgs) => Promise<void>;
 export {};

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

@@ -34,7 +34,7 @@ import '../../../client/client.js';
 import '@dynamic-labs-sdk/client';
 import '../../../config/ApiEndpoint.js';
 import '@dynamic-labs/locale';
-import { verifyWallet, linkWallet } from '../../../data/api/wallets/wallets.js';
+import { verifyWallet, walletsVerify, linkWallet } from '../../../data/api/wallets/wallets.js';
 import '../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.js';
 import { useAccessDeniedContext } from '../../../context/AccessDeniedContext/AccessDeniedContext.js';
 import { useAccountExistsContext } from '../../../context/AccountExistsContext/AccountExistsContext.js';
@@ -130,7 +130,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
     // We need this boolean to distinguish between logic for verify or linking.
     const verifyOnly = !user;
     const shouldFallbackToConnectOnly = enableConnectOnlyFallback && (verifyOnly || !multiWalletEnabled);
-    const generateJWT = (walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride) => __awaiter(void 0, void 0, void 0, function* () {
+    const generateJWT = (walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes) => __awaiter(void 0, void 0, void 0, function* () {
         const verifyArgs = yield getVerifyArgs({
             displaySiweStatement,
             environmentId,
@@ -152,6 +152,11 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             verifyResponse = verifyWallet(environmentId, Object.assign(Object.assign({}, verifyArgs), { captchaToken,
                 oauth }));
         }
+        else if (user && requestedScopes) {
+            verifyResponse = walletsVerify(environmentId, Object.assign(Object.assign({}, verifyArgs), { captchaToken,
+                oauth,
+                requestedScopes }));
+        }
         else {
             verifyResponse = linkWallet(environmentId, verifyArgs);
         }
@@ -281,7 +286,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             setErrorMessage(e.code);
         }
     };
-    return (_a) => __awaiter(void 0, [_a], void 0, function* ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, }) {
+    return (_a) => __awaiter(void 0, [_a], void 0, function* ({ walletConnector, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes, }) {
         const walletProvider = getWalletProvider(walletConnector);
         dynamicEvents.emit('authInit', {
             address: publicWalletAddress,
@@ -290,7 +295,7 @@ const useVerifyWallet = ({ displaySiweStatement, environmentId, projectSettings,
             type: 'wallet',
         });
         try {
-            const { verifyFunction, verifyArgs } = yield generateJWT(walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride);
+            const { verifyFunction, verifyArgs } = yield generateJWT(walletConnector, walletProvider, getAddressOpts, publicWalletAddress, captchaToken, oauth, signedMessageOverride, messageToSignOverride, requestedScopes);
             yield initAuth({
                 isSignIn: verifyOnly,
                 onError: (e) => {

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

@@ -30,6 +30,35 @@ const useWalletPassword = () => {
     const resetState = React.useCallback(() => {
         setState(INITIAL_STATE);
     }, []);
+    const setPassword = React.useCallback((params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const { accountAddress, chainName, newPassword } = params;
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const connector = getWaasWalletConnector(chainName);
+            if (!connector) {
+                const errorMessage = 'Wallet connector not found';
+                setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+                logger.logger.error(errorMessage, { accountAddress, chainName });
+                return false;
+            }
+            yield connector.setPassword({
+                accountAddress,
+                newPassword,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false })));
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to set password';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.logger.error('Failed to set wallet password', {
+                accountAddress,
+                chainName,
+                error,
+            });
+            return false;
+        }
+    }), [getWaasWalletConnector]);
     const updatePassword = React.useCallback((params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         const { accountAddress, chainName, newPassword, existingPassword } = params;
         setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
@@ -143,6 +172,7 @@ const useWalletPassword = () => {
     return {
         checkWalletLockState,
         resetState,
+        setPassword,
         state,
         unlockWallet,
         updatePassword,

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

@@ -1,5 +1,10 @@
 import { WalletRecoveryState } from '@dynamic-labs-wallet/browser-wallet-client';
 import { ChainEnum } from '@dynamic-labs/sdk-api-core';
+export type SetPasswordParams = {
+    accountAddress: string;
+    chainName: ChainEnum;
+    newPassword: string;
+};
 export type UpdatePasswordParams = {
     accountAddress: string;
     chainName: ChainEnum;
@@ -21,6 +26,7 @@ export type WalletPasswordState = {
     recoveryState: WalletRecoveryState | null;
 };
 export type UseWalletPasswordReturn = {
+    setPassword: (params: SetPasswordParams) => Promise<boolean>;
     updatePassword: (params: UpdatePasswordParams) => Promise<boolean>;
     unlockWallet: (params: UnlockWalletParams) => Promise<boolean>;
     checkWalletLockState: (params: CheckWalletLockStateParams) => Promise<WalletRecoveryState | null>;

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

@@ -26,6 +26,35 @@ const useWalletPassword = () => {
     const resetState = useCallback(() => {
         setState(INITIAL_STATE);
     }, []);
+    const setPassword = useCallback((params) => __awaiter(void 0, void 0, void 0, function* () {
+        const { accountAddress, chainName, newPassword } = params;
+        setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
+        try {
+            const connector = getWaasWalletConnector(chainName);
+            if (!connector) {
+                const errorMessage = 'Wallet connector not found';
+                setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+                logger.error(errorMessage, { accountAddress, chainName });
+                return false;
+            }
+            yield connector.setPassword({
+                accountAddress,
+                newPassword,
+            });
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: false })));
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to set password';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { error: errorMessage, isLoading: false })));
+            logger.error('Failed to set wallet password', {
+                accountAddress,
+                chainName,
+                error,
+            });
+            return false;
+        }
+    }), [getWaasWalletConnector]);
     const updatePassword = useCallback((params) => __awaiter(void 0, void 0, void 0, function* () {
         const { accountAddress, chainName, newPassword, existingPassword } = params;
         setState((prev) => (Object.assign(Object.assign({}, prev), { error: null, isLoading: true })));
@@ -139,6 +168,7 @@ const useWalletPassword = () => {
     return {
         checkWalletLockState,
         resetState,
+        setPassword,
         state,
         unlockWallet,
         updatePassword,

package/src/lib/views/SendBalanceView/SendBalanceView.cjs

@@ -132,6 +132,7 @@ const getSupportedChainName = (connectedChain) => {
         BTC: sdkApiCore.ChainEnum.Btc,
         EVM: sdkApiCore.ChainEnum.Evm,
         SOL: sdkApiCore.ChainEnum.Sol,
+        STELLAR: sdkApiCore.ChainEnum.Stellar,
         SUI: sdkApiCore.ChainEnum.Sui,
         TON: sdkApiCore.ChainEnum.Ton,
         TRON: sdkApiCore.ChainEnum.Tron,

package/src/lib/views/SendBalanceView/SendBalanceView.js

@@ -128,6 +128,7 @@ const getSupportedChainName = (connectedChain) => {
         BTC: ChainEnum.Btc,
         EVM: ChainEnum.Evm,
         SOL: ChainEnum.Sol,
+        STELLAR: ChainEnum.Stellar,
         SUI: ChainEnum.Sui,
         TON: ChainEnum.Ton,
         TRON: ChainEnum.Tron,