@dynamic-labs-sdk/client 0.1.0-alpha.8 → 0.1.0

package/index.cjs.js

@@ -1,16 +1,16 @@
 'use strict';
 
 var assertPackageVersion = require('@dynamic-labs-sdk/assert-package-version');
-var getChainFromVerifiedCredentialChain = require('./getChainFromVerifiedCredentialChain.cjs.js');
+var constants = require('./constants.cjs.js');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId.cjs.js');
-var getWalletProviderByKey = require('./getWalletProviderByKey.cjs.js');
+var getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount.cjs.js');
 var z = require('zod/mini');
 var isMfaRequiredForAction = require('./isMfaRequiredForAction.cjs.js');
+var NotWaasWalletAccountError = require('./NotWaasWalletAccountError.cjs.js');
 var EventEmitter = require('eventemitter3');
 var browser = require('@simplewebauthn/browser');
 var InvalidParamError = require('./InvalidParamError.cjs.js');
-var refreshUser = require('./refreshUser.cjs.js');
 require('buffer');
 
 function _interopNamespaceDefault(e) {
@@ -49,7 +49,7 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 /**
  * This error is thrown when the `retryOnFail` function is called with an invalid
  * number of retries (i.e. less than 0).
- */ class InvalidRetryOnFailCallError extends getChainFromVerifiedCredentialChain.BaseError {
+ */ class InvalidRetryOnFailCallError extends constants.BaseError {
     constructor(maxRetries){
         super({
             cause: null,
@@ -74,7 +74,10 @@ const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
             }
         }
     }
-    throw new InvalidRetryOnFailCallError(maxRetries);
+    /**
+   * Reaching this point should never happen and this
+   * error is thrown to help us debug the issue.
+   */ throw new InvalidRetryOnFailCallError(maxRetries);
 };
 
 /**
@@ -85,11 +88,11 @@ const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns True if the user is signed in, false otherwise.
- */ const isSignedIn = (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>Boolean(client.user || getWalletProviderByKey.getWalletAccounts(client).length > 0);
+ */ const isSignedIn = (client = constants.getDefaultClient())=>Boolean(client.user || getVerifiedCredentialForWalletAccount.getWalletAccounts(client).length > 0);
 
 /**
  * The schema to track the expiration time of the project settings.
- */ const projectSettingsExpirationScheme = getNetworkProviderFromNetworkId.createStorageKeySchema({
+ */ const projectSettingsExpirationStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
     key: 'projectSettingsExpiration',
     schema: z__namespace.number()
 });
@@ -106,9 +109,9 @@ const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the updated project settings.
- */ const fetchProjectSettings = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const currentExpiration = await core.storage.getItem(projectSettingsExpirationScheme);
+ */ const fetchProjectSettings = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const currentExpiration = await core.storage.getItem(projectSettingsExpirationStorageKeySchema);
     const hasProjectSettings = Boolean(client.projectSettings);
     const isExpired = currentExpiration && currentExpiration < Date.now();
     // We want to cache the project settings if its valid and user is connected.
@@ -116,10 +119,11 @@ const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
     if (hasProjectSettings && !isExpired && isSignedIn(client)) {
         return client.projectSettings;
     }
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const apiClient = constants.createApiClient({}, client);
+    core.logger.debug('[fetchProjectSettings] Fetching project settings...');
     const doFetch = async ()=>apiClient.getEnvironmentSettings({
             environmentId: core.environmentId,
-            sdkVersion: `${getChainFromVerifiedCredentialChain.CLIENT_SDK_NAME}/${core.version}`
+            sdkVersion: `${constants.CLIENT_SDK_NAME}/${core.version}`
         }, {
             credentials: 'omit'
         });
@@ -130,7 +134,7 @@ const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
     core.state.set({
         projectSettings: projectSettings != null ? projectSettings : null
     });
-    await core.storage.setItem(projectSettingsExpirationScheme, Date.now() + PROJECT_SETTINGS_EXPIRATION_TIME);
+    await core.storage.setItem(projectSettingsExpirationStorageKeySchema, Date.now() + PROJECT_SETTINGS_EXPIRATION_TIME);
     return projectSettings;
 };
 
@@ -180,7 +184,7 @@ const p256Keygen = async ()=>{
 
 const generateSessionKeys = async (client)=>{
     const { private: privateKey, public: publicKey, privateJwk: privateKeyJwk } = await p256Keygen();
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     // stringify and encode the session keys to store in storage
     const stringifiedSessionKeys = JSON.stringify({
         privateKey,
@@ -188,7 +192,7 @@ const generateSessionKeys = async (client)=>{
         publicKey,
         registered: false
     });
-    const encodedSessionKeys = getChainFromVerifiedCredentialChain.getBuffer().from(stringifiedSessionKeys).toString('base64');
+    const encodedSessionKeys = constants.getBuffer().from(stringifiedSessionKeys).toString('base64');
     core.state.set({
         sessionKeys: encodedSessionKeys
     });
@@ -213,15 +217,15 @@ const generateSessionKeys = async (client)=>{
 };
 
 const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     const walletProvidersMap = new Map();
-    const walletAccounts = getWalletProviderByKey.getWalletAccounts(client);
+    const walletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts(client);
     walletAccounts.forEach((walletAccount)=>{
         if (walletProvidersMap.has(walletAccount.walletProviderKey)) {
             return;
         }
         try {
-            const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+            const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
                 walletAccount
             }, client);
             walletProvidersMap.set(walletAccount.walletProviderKey, walletProvider);
@@ -238,7 +242,7 @@ const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
 /**
  * Disconnect and terminate each wallet provider, if available.
  */ const disconnectAndTerminateWalletProviders = async (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     const walletProviders = getAvailableWalletProvidersFromWalletAccounts(client);
     await Promise.all(walletProviders.map(async (walletProvider)=>{
         if (walletProvider.terminate) {
@@ -259,30 +263,37 @@ const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the logout process is complete.
- */ const logout = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const logout = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    core.logger.debug('[logout] Logging out...');
     await disconnectAndTerminateWalletProviders(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    try {
-        await apiClient.revokeSession({
-            environmentId: core.environmentId
-        });
-    } catch (error) {
-        core.logger.error('Failed to revoke session', error);
-    }
-    /**
-   * This deletes the auth cookie if it exists.
-   * If the cookie doesn't exist, this sets a new cookie that expires immediately.
-   */ if (getChainFromVerifiedCredentialChain.isCookieEnabled(client)) {
-        getWalletProviderByKey.setCookie(`${getWalletProviderByKey.DYNAMIC_AUTH_COOKIE_NAME}=; Max-Age=-99999999; path=/; SameSite=Lax`);
+    if (client.user !== null) {
+        const apiClient = constants.createApiClient({}, client);
+        try {
+            await apiClient.revokeSession({
+                environmentId: core.environmentId
+            });
+        } catch (error) {
+            core.logger.error('Failed to revoke session', error);
+        }
+        /**
+     * This deletes the auth cookie if it exists.
+     * If the cookie doesn't exist, this sets a new cookie that expires immediately.
+     */ if (constants.isCookieEnabled(client)) {
+            getVerifiedCredentialForWalletAccount.setCookie(`${getVerifiedCredentialForWalletAccount.DYNAMIC_AUTH_COOKIE_NAME}=; Max-Age=-99999999; path=/; SameSite=Lax`);
+        }
     }
     core.state.set({
+        captchaToken: null,
         legacyToken: null,
+        mfaToken: null,
         sessionExpiresAt: null,
+        sessionKeys: null,
         token: null,
+        unverifiedWalletAccounts: [],
         user: null
     });
-    getWalletProviderByKey.emitEvent({
+    getVerifiedCredentialForWalletAccount.emitEvent({
         event: 'logout'
     }, client);
     // Refetch project settings
@@ -319,7 +330,7 @@ const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
 /**
  * Sets up a timeout to log out the user when their token expires.
  */ const initializeAuth = (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     let clearExpirationTimeout = null;
     const onChangeExpiration = getNetworkProviderFromNetworkId.subscribeWithSelector(core.state, (state)=>state.sessionExpiresAt);
     const checkExpiration = ()=>{
@@ -342,13 +353,13 @@ const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
 };
 
 const raiseStateEvents = (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     core.state.subscribe((value, previous)=>{
         const eventEntries = Object.entries(stateChangeEvents);
         eventEntries.forEach(([key, event])=>{
             // Check if this key had a change
             if (getNetworkProviderFromNetworkId.isEqualShallow(value[key], previous[key])) return;
-            getWalletProviderByKey.emitEvent({
+            getVerifiedCredentialForWalletAccount.emitEvent({
                 args: {
                     [key]: value[key]
                 },
@@ -358,17 +369,32 @@ const raiseStateEvents = (client)=>{
     });
 };
 
-const SDK_API_CORE_VERSION = getChainFromVerifiedCredentialChain.dependencies['@dynamic-labs/sdk-api-core'];
+const unverifiedWalletAccountSchema = z__namespace.object({
+    address: z__namespace.string(),
+    addressesWithTypes: z__namespace.optional(z__namespace.array(z__namespace.object({
+        address: z__namespace.string(),
+        publicKey: z__namespace.optional(z__namespace.string()),
+        type: z__namespace.custom((val)=>typeof val === 'string')
+    }))),
+    chain: z__namespace.custom((val)=>typeof val === 'string'),
+    id: z__namespace.string(),
+    lastSelectedAt: z__namespace.nullable(z__namespace.date()),
+    walletProviderKey: z__namespace.string()
+});
+
+const walletProviderKeyMapSchema = z__namespace.record(z__namespace.string(), z__namespace.string());
 
 const stateStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
     key: 'state',
     schema: z__namespace.object({
         apiVersion: z__namespace.string(),
         projectSettings: z__namespace.custom(),
-        user: z__namespace.custom()
+        unverifiedWalletAccounts: z__namespace.array(unverifiedWalletAccountSchema),
+        user: z__namespace.custom(),
+        walletProviderKeyMap: walletProviderKeyMapSchema
     })
 });
-const sessionKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
+const sessionStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
     key: 'session',
     schema: z__namespace.object({
         /**
@@ -395,10 +421,11 @@ const sessionKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema(
 });
 
 const hydrateStateWithStorage = async (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
+    const previousState = core.state.get();
     const stateChanges = {};
     // ================ TOKEN =================
-    const session = await core.storage.getItem(sessionKeySchema);
+    const session = await core.storage.getItem(sessionStorageKeySchema);
     const isSessionValid = (session == null ? void 0 : session.sessionExpiration) && session.sessionExpiration > Date.now();
     if (isSessionValid) {
         stateChanges.token = session.token;
@@ -411,25 +438,35 @@ const hydrateStateWithStorage = async (client)=>{
     // ================ STATE =================
     const storedState = await core.storage.getItem(stateStorageKeySchema);
     // Only hydrate state if it came from an API with the same version as the current SDK
-    if ((storedState == null ? void 0 : storedState.apiVersion) === SDK_API_CORE_VERSION) {
+    if ((storedState == null ? void 0 : storedState.apiVersion) === constants.SDK_API_CORE_VERSION) {
+        stateChanges.unverifiedWalletAccounts = storedState.unverifiedWalletAccounts;
+        stateChanges.walletProviderKeyMap = storedState.walletProviderKeyMap;
         // Variables that should only be hydrated if the session is valid
         if (isSessionValid) {
             stateChanges.user = storedState.user;
+        }
+        var _storedState_unverifiedWalletAccounts;
+        // if there's a session/user or connected unverified wallets, we should hydrate project settings
+        // so we don't refetch it on initial load
+        if (isSessionValid || ((_storedState_unverifiedWalletAccounts = storedState.unverifiedWalletAccounts) != null ? _storedState_unverifiedWalletAccounts : []).length > 0) {
             stateChanges.projectSettings = storedState.projectSettings;
         }
     }
     if (Object.keys(stateChanges).length > 0) {
         core.state.set(stateChanges);
     }
+    getVerifiedCredentialForWalletAccount.checkAndRaiseWalletAccountsChangedEvent({
+        previousState
+    }, client);
 };
 
 const syncStateWithStorage = (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
     core.state.subscribe((state)=>{
         if (state.sessionExpiresAt === null) {
-            void core.storage.removeItem(sessionKeySchema);
+            void core.storage.removeItem(sessionStorageKeySchema);
         } else {
-            void core.storage.setItem(sessionKeySchema, {
+            void core.storage.setItem(sessionStorageKeySchema, {
                 captchaToken: state.captchaToken,
                 legacyToken: state.legacyToken,
                 mfaToken: state.mfaToken,
@@ -439,9 +476,11 @@ const syncStateWithStorage = (client)=>{
             });
         }
         void core.storage.setItem(stateStorageKeySchema, {
-            apiVersion: SDK_API_CORE_VERSION,
+            apiVersion: constants.SDK_API_CORE_VERSION,
             projectSettings: state.projectSettings,
-            user: state.user
+            unverifiedWalletAccounts: state.unverifiedWalletAccounts,
+            user: state.user,
+            walletProviderKeyMap: state.walletProviderKeyMap
         });
     });
 };
@@ -453,7 +492,7 @@ const initializeStorageSync = async (client)=>{
     syncStateWithStorage(client);
 };
 
-class ClientAlreadyInitializedError extends getChainFromVerifiedCredentialChain.BaseError {
+class ClientAlreadyInitializedError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -477,8 +516,9 @@ class ClientAlreadyInitializedError extends getChainFromVerifiedCredentialChain.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when initialization is complete.
  * @throws ClientAlreadyInitializedError If the client is already initialized.
- */ const initializeClient = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const initializeClient = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    core.logger.debug('[initializeClient] Initializing client. Current init status', core.state.get().initStatus);
     if (core.state.get().initStatus !== 'uninitialized') {
         throw new ClientAlreadyInitializedError();
     }
@@ -493,23 +533,59 @@ class ClientAlreadyInitializedError extends getChainFromVerifiedCredentialChain.
             await fetchProjectSettings(client);
         }
     });
-    const generateSessionKeysPromise = fetchProjectSettingsPromise.then(async ()=>{
+    /**
+   * Generate session keys if they don't exist
+   */ const generateSessionKeysPromise = fetchProjectSettingsPromise.then(async ()=>{
         if (!core.state.get().sessionKeys) {
             await generateSessionKeys(client);
         }
     });
+    /**
+   * Refresh user state on initialization when cookie is enabled.
+   * This is necessary for supporting multiple subdomain domains.
+   *
+   * When a user logs in on sub1.example.com, they will have a cookie set. However, when they access
+   * sub2.example.com, the cookie will be present but the user state will not be present.
+   * We need to fetch the user to access the expiration date of the cookie on the new subdomain.
+   *
+   * This is also needed in case a user logs in with a new user on sub1.example.com and then accesses
+   * sub2.example.com that had the original logged-in user. We need to fetch the user to refresh
+   * the user state with the correct logged-in user.
+   */ const refreshUserStateFromCookiePromise = fetchProjectSettingsPromise.then(async ()=>{
+        /**
+       * When cookies are enabled, we need to refresh the user as part of the initialization process
+       * to ensure the user is logged in and sync the auth state with the server.
+       *
+       * This call can fail with a 401 error if the user is not logged in and the SDK should finish its initialization process
+       * without throwing an error because that is an expected behavior.
+       */ if (constants.isCookieEnabled(client)) {
+            await NotWaasWalletAccountError.refreshUser(client).catch(async (error)=>{
+                if (error.status === 401) {
+                    if (client.user) {
+                        await logout(client);
+                    }
+                } else {
+                    throw error;
+                }
+            });
+        }
+    });
     core.initTrack.track({
-        name: 'initialize-storage-sync',
+        name: getNetworkProviderFromNetworkId.INITIALIZE_STORAGE_SYNC_TRACKER_KEY,
         promise: initializeStorageSyncPromise
     });
     core.initTrack.track({
-        name: 'fetch-project-settings',
+        name: getNetworkProviderFromNetworkId.FETCH_PROJECT_SETTINGS_TRACKER_KEY,
         promise: fetchProjectSettingsPromise
     });
     core.initTrack.track({
-        name: 'generate-session-keys',
+        name: getNetworkProviderFromNetworkId.GENERATE_SESSION_KEYS_TRACKER_KEY,
         promise: generateSessionKeysPromise
     });
+    core.initTrack.track({
+        name: getNetworkProviderFromNetworkId.REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY,
+        promise: refreshUserStateFromCookiePromise
+    });
     try {
         await core.initTrack.waitForAll();
         core.state.set({
@@ -557,7 +633,7 @@ const createDeferredPromise = ()=>{
     /**
    * Checks if all processes are initialized and resolves the main promise if they are.
    */ const checkIfAllSettled = ()=>{
-        const allSettled = Array.from(tracker.values()).every((status)=>status === 'resolved');
+        const allSettled = Array.from(tracker.values()).every(({ status })=>status === 'resolved');
         if (!allSettled) return;
         allSettledPromise.resolve();
     };
@@ -567,19 +643,28 @@ const createDeferredPromise = ()=>{
         }
         // Disable tracking in the next node tick
         void Promise.resolve().then(()=>isTrackEnabled = false);
-        tracker.set(name, 'pending');
+        tracker.set(name, {
+            promise,
+            status: 'pending'
+        });
         promise.then(()=>{
-            tracker.set(name, 'resolved');
+            tracker.set(name, {
+                promise,
+                status: 'resolved'
+            });
             eventEmitter.emit('resolved', name);
             checkIfAllSettled();
         }).catch((error)=>{
-            tracker.set(name, 'failed');
+            tracker.set(name, {
+                promise,
+                status: 'failed'
+            });
             eventEmitter.emit('failed', name, error);
             allSettledPromise.reject(error);
         });
     };
     const waitForAll = ()=>allSettledPromise.promise;
-    const getTracker = ()=>tracker;
+    const getTracker = (trackerKey)=>tracker.get(trackerKey);
     return {
         getTracker,
         off: eventEmitter.off.bind(eventEmitter),
@@ -591,7 +676,7 @@ const createDeferredPromise = ()=>{
 
 const createEventEmitter = ()=>new EventEmitter();
 
-class UnavailableInServerSideError extends getChainFromVerifiedCredentialChain.BaseError {
+class UnavailableInServerSideError extends constants.BaseError {
     constructor(unavailableFeature){
         super({
             cause: null,
@@ -645,7 +730,64 @@ class UnavailableInServerSideError extends getChainFromVerifiedCredentialChain.B
         register: (options)=>browser.startRegistration(options)
     });
 
-class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError {
+const createDebouncedMutex = ()=>{
+    const mutexState = new Map();
+    return async ({ lockKey, callback, debounceTime = 0 })=>{
+        const resolutionPromise = createDeferredPromise();
+        // Prefill the state for this key if it doesn't exist to avoid needing to check for existence later.
+        if (!mutexState.has(lockKey)) {
+            mutexState.set(lockKey, {
+                nextCallback: null,
+                queuePromise: Promise.resolve(),
+                resolutionPromises: [],
+                timer: null
+            });
+        }
+        const currentState = mutexState.get(lockKey);
+        // This should never happen, but we'll assert it for TS safety.
+        constants.assertDefined(currentState, `Mutex state for key ${lockKey} not found`);
+        currentState.resolutionPromises.push(resolutionPromise);
+        if (currentState.timer) {
+            clearTimeout(currentState.timer);
+        }
+        // The last invocation wins. Always.
+        currentState.nextCallback = callback;
+        const addCallbackToQueue = async ()=>{
+            currentState.queuePromise = currentState.queuePromise.then(async ()=>{
+                if (!currentState.nextCallback) {
+                    return;
+                }
+                // We can't just use the callback param directly because later invocations
+                // should override previous ones.
+                // Scenario to illustrate this (none of these will use the timer param for simplicity):
+                // 1. Very long running promise callback A runs
+                // 2. While it's running, we invoke callback B, which queues itself with "then" and overrides nextCallback with B.
+                // 3. While A is still running, we invoke callback C, same thing happens, now nextCallback is C.
+                // 4. A resolves, nextCallback is invoked with C.
+                // 5. After C resolves, nextCallback is invoked with null, so it doesn't run.
+                // Conclusion: B was never executed and only the last invocation runs.
+                const { nextCallback } = currentState;
+                currentState.nextCallback = null;
+                const promisesToResolve = currentState.resolutionPromises;
+                currentState.resolutionPromises = [];
+                try {
+                    await nextCallback();
+                    promisesToResolve.forEach((resolutionPromise)=>resolutionPromise.resolve());
+                } catch (error) {
+                    promisesToResolve.forEach((resolutionPromise)=>resolutionPromise.reject(error));
+                }
+            });
+        };
+        if (debounceTime > 0) {
+            currentState.timer = setTimeout(addCallbackToQueue, debounceTime);
+        } else {
+            await addCallbackToQueue();
+        }
+        return resolutionPromise.promise;
+    };
+};
+
+class InvalidStorageValue extends constants.BaseError {
     constructor(key, value){
         super({
             cause: null,
@@ -744,7 +886,8 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
         sessionKeys: null,
         token: null,
         unverifiedWalletAccounts: [],
-        user: null
+        user: null,
+        walletProviderKeyMap: {}
     });
 
 /**
@@ -754,7 +897,9 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
     var _config_coreConfig_apiBaseUrl;
     const apiBaseUrl = (_config_coreConfig_apiBaseUrl = (_config_coreConfig = config.coreConfig) == null ? void 0 : _config_coreConfig.apiBaseUrl) != null ? _config_coreConfig_apiBaseUrl : DEFAULT_API_BASE_URL;
     var _config_coreConfig_logger;
-    const logger = (_config_coreConfig_logger = (_config_coreConfig1 = config.coreConfig) == null ? void 0 : _config_coreConfig1.logger) != null ? _config_coreConfig_logger : getNetworkProviderFromNetworkId.createLogger();
+    const logger = (_config_coreConfig_logger = (_config_coreConfig1 = config.coreConfig) == null ? void 0 : _config_coreConfig1.logger) != null ? _config_coreConfig_logger : getNetworkProviderFromNetworkId.createLogger({
+        level: config.logLevel
+    });
     var _config_coreConfig_storageAdapter;
     const storage = getNetworkProviderFromNetworkId.createStorage({
         prefix: `dynamic_${config.environmentId}`,
@@ -767,6 +912,7 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
     var _config_coreConfig_navigate;
     const navigate = (_config_coreConfig_navigate = (_config_coreConfig5 = config.coreConfig) == null ? void 0 : _config_coreConfig5.navigate) != null ? _config_coreConfig_navigate : createNavigationHandler();
     const state = createObservableState(getInitialState);
+    const debouncedMutex = createDebouncedMutex();
     const eventEmitter = createEventEmitter();
     const initTrack = createAsyncTrack();
     const runtimeServices = createRuntimeServices();
@@ -775,6 +921,7 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
     var _config_coreConfig_getApiHeaders;
     return {
         apiBaseUrl,
+        debouncedMutex,
         environmentId: config.environmentId,
         eventEmitter,
         extensions: new Set(),
@@ -789,7 +936,7 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
         runtimeServices,
         state,
         storage,
-        version: getChainFromVerifiedCredentialChain.version
+        version: constants.version
     };
 };
 
@@ -832,15 +979,20 @@ class InvalidStorageValue extends getChainFromVerifiedCredentialChain.BaseError
         }
     };
     var _config_autoInitialize;
-    const shouldAutoInitialize = (_config_autoInitialize = config.autoInitialize) != null ? _config_autoInitialize : !isServerSideRendering();
+    // Define if SDK should auto initialize, default to true
+    const autoInitialize = (_config_autoInitialize = config.autoInitialize) != null ? _config_autoInitialize : true;
+    // Prevent the auto initialization in SSR
+    const shouldAutoInitialize = isServerSideRendering() ? false : autoInitialize;
+    core.logger.debug('[createDynamicClient] Creating client...');
     if (shouldAutoInitialize) {
+        core.logger.debug('[createDynamicClient] Initializing client...');
         void initializeClient(client);
     }
-    getChainFromVerifiedCredentialChain.setDefaultClient(client);
+    constants.setDefaultClient(client);
     return client;
 };
 
-class InvalidRedirectStorageStateError extends getChainFromVerifiedCredentialChain.BaseError {
+class InvalidRedirectStorageStateError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -852,7 +1004,7 @@ class InvalidRedirectStorageStateError extends getChainFromVerifiedCredentialCha
     }
 }
 
-class MissingRedirectStorageStateError extends getChainFromVerifiedCredentialChain.BaseError {
+class MissingRedirectStorageStateError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -864,7 +1016,7 @@ class MissingRedirectStorageStateError extends getChainFromVerifiedCredentialCha
     }
 }
 
-class MissingSocialUrlParamError extends getChainFromVerifiedCredentialChain.BaseError {
+class MissingSocialUrlParamError extends constants.BaseError {
     constructor(param){
         super({
             cause: null,
@@ -876,7 +1028,20 @@ class MissingSocialUrlParamError extends getChainFromVerifiedCredentialChain.Bas
     }
 }
 
-class NetworkSwitchingUnavailableError extends getChainFromVerifiedCredentialChain.BaseError {
+class MissingUserVerificationError extends constants.BaseError {
+    constructor({ informationToVerify, message }){
+        super({
+            cause: null,
+            code: 'missing_user_verification_error',
+            docsUrl: null,
+            name: 'MissingUserVerificationError',
+            shortMessage: message != null ? message : `The user is missing verification for ${informationToVerify}. Please verify the user's ${informationToVerify}`
+        });
+        this.informationToVerify = informationToVerify;
+    }
+}
+
+class NetworkSwitchingUnavailableError extends constants.BaseError {
     constructor({ walletProviderKey, originalError, extraMessages }){
         const cause = originalError instanceof Error ? originalError : null;
         super({
@@ -893,7 +1058,7 @@ class NetworkSwitchingUnavailableError extends getChainFromVerifiedCredentialCha
     }
 }
 
-class NoAddressFoundError extends getChainFromVerifiedCredentialChain.BaseError {
+class NoAddressFoundError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -905,7 +1070,7 @@ class NoAddressFoundError extends getChainFromVerifiedCredentialChain.BaseError
     }
 }
 
-class NoPasskeyCredentialsFoundError extends getChainFromVerifiedCredentialChain.BaseError {
+class NoPasskeyCredentialsFoundError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -917,7 +1082,19 @@ class NoPasskeyCredentialsFoundError extends getChainFromVerifiedCredentialChain
     }
 }
 
-class NoWebAuthNSupportError extends getChainFromVerifiedCredentialChain.BaseError {
+class NoSmartWalletAccountSignerFoundError extends constants.BaseError {
+    constructor(smartWalletAddress){
+        super({
+            cause: null,
+            code: 'no_smart_wallet_account_signer_found_error',
+            docsUrl: null,
+            name: 'NoSmartWalletAccountSignerFoundError',
+            shortMessage: `No signer wallet account found for smart wallet account ${smartWalletAddress}`
+        });
+    }
+}
+
+class NoWebAuthNSupportError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -929,7 +1106,7 @@ class NoWebAuthNSupportError extends getChainFromVerifiedCredentialChain.BaseErr
     }
 }
 
-class UnrecognizedNetworkError extends getChainFromVerifiedCredentialChain.BaseError {
+class UnrecognizedNetworkError extends constants.BaseError {
     constructor({ networkId, originalError, walletProviderKey }){
         const cause = originalError instanceof Error ? originalError : null;
         super({
@@ -945,7 +1122,7 @@ class UnrecognizedNetworkError extends getChainFromVerifiedCredentialChain.BaseE
     }
 }
 
-class UserNotAuthenticatedError extends getChainFromVerifiedCredentialChain.BaseError {
+class UserNotAuthenticatedError extends constants.BaseError {
     constructor({ shortMessage } = {}){
         super({
             cause: null,
@@ -957,7 +1134,7 @@ class UserNotAuthenticatedError extends getChainFromVerifiedCredentialChain.Base
     }
 }
 
-class UserRejectedError extends getChainFromVerifiedCredentialChain.BaseError {
+class UserRejectedError extends constants.BaseError {
     constructor({ action }){
         super({
             cause: null,
@@ -969,7 +1146,7 @@ class UserRejectedError extends getChainFromVerifiedCredentialChain.BaseError {
     }
 }
 
-class WalletAccountAlreadyVerifiedError extends getChainFromVerifiedCredentialChain.BaseError {
+class WalletAccountAlreadyVerifiedError extends constants.BaseError {
     constructor(address){
         super({
             cause: null,
@@ -981,33 +1158,22 @@ class WalletAccountAlreadyVerifiedError extends getChainFromVerifiedCredentialCh
     }
 }
 
-class WalletAccountNotSelectedError extends getChainFromVerifiedCredentialChain.BaseError {
+class WalletAccountNotSelectedError extends constants.BaseError {
     constructor(params){
+        const currentAccountInfo = params.selectedAddress ? ` (currently ${params.selectedAddress})` : '';
         super({
             cause: null,
             code: 'wallet_account_not_selected_error',
             docsUrl: null,
             name: 'WalletAccountNotSelected',
-            shortMessage: `This wallet only supports signing with its selected account (currently ${params.selectedAddress}). Please select account ${params.expectedAddress} in your wallet app and try again`
+            shortMessage: `This wallet only supports signing with its selected account${currentAccountInfo}. Please select account ${params.expectedAddress} in your wallet app and try again`
         });
         this.expectedAddress = params.expectedAddress;
         this.selectedAddress = params.selectedAddress;
     }
 }
 
-class WalletAlreadyLinkedToAnotherUserError extends getChainFromVerifiedCredentialChain.BaseError {
-    constructor({ cause }){
-        super({
-            cause,
-            code: 'wallet_already_linked_to_another_user_error',
-            docsUrl: null,
-            name: 'WalletAlreadyLinkedToAnotherUserError',
-            shortMessage: 'This wallet is already linked to another user'
-        });
-    }
-}
-
-class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentialChain.BaseError {
+class WalletProviderMethodUnavailableError extends constants.BaseError {
     constructor({ methodName, walletProviderKey }){
         super({
             cause: null,
@@ -1028,9 +1194,9 @@ class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentia
  * @param [params.externalJwt] - Optional external JWT token to authenticate with. Not required when using cookie based auth.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the authentication response from the server.
- */ const signInWithExternalJwt = async ({ externalJwt, sessionPublicKey } = {}, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const signInWithExternalJwt = async ({ externalJwt, sessionPublicKey } = {}, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.externalAuthSignin({
         environmentId: core.environmentId,
         externalAuthSigninRequest: {
@@ -1038,7 +1204,7 @@ class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentia
             sessionPublicKey
         }
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     return response;
@@ -1050,9 +1216,11 @@ class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentia
  * @param params.passkeyId - The unique identifier of the passkey to delete.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the passkey is successfully deleted.
- */ const deletePasskey = async ({ passkeyId }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const deletePasskey = async ({ passkeyId }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
+        includeMfaToken: true
+    }, client);
     await apiClient.deletePasskey({
         deleteUserPasskeyRequest: {
             passkeyId
@@ -1069,9 +1237,9 @@ class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentia
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an array of the user's registered passkeys.
- */ const getPasskeys = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const getPasskeys = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.getUserPasskeys({
         environmentId: core.environmentId
     });
@@ -1079,8 +1247,8 @@ class WalletProviderMethodUnavailableError extends getChainFromVerifiedCredentia
 };
 
 const getPasskeyRegistrationOptions = async (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const options = await apiClient.getPasskeyRegistrationOptions({
         environmentId: core.environmentId
     });
@@ -1088,12 +1256,12 @@ const getPasskeyRegistrationOptions = async (client)=>{
 };
 
 const serverRegisterPasskey = async ({ registration }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.registerPasskey({
         environmentId: core.environmentId,
-        passkeyRegisterRequest: getChainFromVerifiedCredentialChain._extends({}, registration, {
-            response: getChainFromVerifiedCredentialChain._extends({}, registration.response, {
+        passkeyRegisterRequest: constants._extends({}, registration, {
+            response: constants._extends({}, registration.response, {
                 clientDataJson: registration.response.clientDataJSON
             })
         })
@@ -1111,8 +1279,8 @@ const serverRegisterPasskey = async ({ registration }, client)=>{
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the registration response.
  * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
- */ const registerPasskey = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const registerPasskey = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     if (!core.passkey.isSupported()) {
         throw new NoWebAuthNSupportError();
     }
@@ -1123,29 +1291,30 @@ const serverRegisterPasskey = async ({ registration }, client)=>{
     const response = await serverRegisterPasskey({
         registration
     }, client);
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     return response;
 };
 
-const getPasskeyAuthenticationSignInOptions = async (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+const getPasskeyAuthenticationSignInOptions = async ({ relatedOriginRpId } = {}, client)=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const options = await apiClient.getPasskeyAuthenticationSigninOptions({
-        environmentId: core.environmentId
+        environmentId: core.environmentId,
+        relatedOriginRpId: relatedOriginRpId
     });
     return options;
 };
 
 const serverSigninPasskey = async ({ authentication, createMfaToken }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.signinWithPasskey({
         environmentId: core.environmentId,
-        passkeyAuthRequest: getChainFromVerifiedCredentialChain._extends({}, authentication, {
+        passkeyAuthRequest: constants._extends({}, authentication, {
             createMfaToken,
-            response: getChainFromVerifiedCredentialChain._extends({}, authentication.response, {
+            response: constants._extends({}, authentication.response, {
                 clientDataJson: authentication.response.clientDataJSON
             })
         })
@@ -1163,107 +1332,67 @@ const serverSigninPasskey = async ({ authentication, createMfaToken }, client)=>
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the authentication response.
  * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
- */ const signInWithPasskey = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const signInWithPasskey = async ({ relatedOriginRpId } = {}, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     if (!core.passkey.isSupported()) {
         throw new NoWebAuthNSupportError();
     }
-    const options = await getPasskeyAuthenticationSignInOptions(client);
-    const formattedOptions = getChainFromVerifiedCredentialChain._extends({}, options);
+    const options = await getPasskeyAuthenticationSignInOptions({
+        relatedOriginRpId
+    }, client);
+    const formattedOptions = constants._extends({}, options);
     const authentication = await core.passkey.authenticate({
         optionsJSON: formattedOptions
     });
     const response = await serverSigninPasskey({
         authentication
     }, client);
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     return response;
 };
 
-/** The schema to track the state of the OAuth flow. */ const redirectStateStorageSchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
-    key: 'redirectState',
-    schema: z__namespace.object({
-        codeVerifier: z__namespace.optional(z__namespace.string()),
-        provider: z__namespace.enum(sdkApiCore.ProviderEnum),
-        state: z__namespace.string()
-    })
-});
-
 /**
- * Completes the social authentication flow after OAuth redirect.
+ * Retrieves all social accounts associated with the current user.
  *
- * This function processes the OAuth callback URL with authorization codes
- * and completes the user authentication with the social provider.
- *
- * @param params.url - The callback URL containing OAuth response parameters.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns A promise that resolves to the authenticated user or null.
- * @throws MissingSocialUrlParamError If required OAuth parameters are missing.
- * @throws InvalidRedirectStorageStateError If the stored state doesn't match.
- */ const completeSocialRedirectSignIn = async ({ url }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    await core.initTrack.waitForAll();
-    const dynamicOauthState = url.searchParams.get('dynamicOauthState');
-    const dynamicOauthCode = url.searchParams.get('dynamicOauthCode');
-    if (!dynamicOauthState) {
-        throw new MissingSocialUrlParamError('dynamicOauthState');
-    }
-    if (!dynamicOauthCode) {
-        throw new MissingSocialUrlParamError('dynamicOauthCode');
-    }
-    const storedSocialRedirectState = await core.storage.getItem(redirectStateStorageSchema);
-    if (!storedSocialRedirectState) {
-        throw new MissingRedirectStorageStateError();
-    }
-    if (storedSocialRedirectState.state !== dynamicOauthState) {
-        throw new InvalidRedirectStorageStateError();
-    }
-    const { provider, codeVerifier } = storedSocialRedirectState;
-    await core.storage.removeItem(redirectStateStorageSchema);
-    const response = await apiClient.oauthSignIn({
-        environmentId: core.environmentId,
-        oauthRequest: {
-            captchaToken: getNetworkProviderFromNetworkId.consumeCaptchaToken(client),
-            code: dynamicOauthCode,
-            codeVerifier,
-            state: dynamicOauthState
-        },
-        providerType: provider
+ * @returns An array of `SocialAccount` objects associated with the user.
+ */ const getUserSocialAccounts = (client = constants.getDefaultClient())=>{
+    const { user } = client;
+    constants.assertDefined(user, 'User is not authenticated');
+    var _user_verifiedCredentials_filter;
+    const socialCredentials = (_user_verifiedCredentials_filter = user.verifiedCredentials.filter((credential)=>credential.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Oauth)) != null ? _user_verifiedCredentials_filter : [];
+    return socialCredentials.map((credential)=>{
+        var _credential_oauthAccountId, _credential_oauthDisplayName, _credential_oauthEmails, _credential_oauthAccountPhotos, _credential_oauthUsername;
+        return {
+            accountId: (_credential_oauthAccountId = credential.oauthAccountId) != null ? _credential_oauthAccountId : undefined,
+            displayName: (_credential_oauthDisplayName = credential.oauthDisplayName) != null ? _credential_oauthDisplayName : undefined,
+            emails: (_credential_oauthEmails = credential.oauthEmails) != null ? _credential_oauthEmails : [],
+            photos: (_credential_oauthAccountPhotos = credential.oauthAccountPhotos) != null ? _credential_oauthAccountPhotos : [],
+            provider: credential.oauthProvider,
+            username: (_credential_oauthUsername = credential.oauthUsername) != null ? _credential_oauthUsername : undefined,
+            verifiedCredentialId: credential.id
+        };
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
-        response
-    }, client);
-    return response.user;
 };
 
-/**
- * Detects if the current URL is an OAuth redirect from a social provider.
- *
- * This function examines the URL parameters to determine if it contains
- * OAuth callback data from a social authentication flow.
- *
- * @param params.url - The URL to check for OAuth redirect parameters.
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns A promise that resolves to true if the URL is an OAuth redirect, false otherwise.
- */ const detectOAuthRedirect = async ({ url }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const dynamicOauthState = url.searchParams.get('dynamicOauthState');
-    const dynamicOauthCode = url.searchParams.get('dynamicOauthCode');
-    if (!dynamicOauthState || !dynamicOauthCode) {
-        return false;
-    }
-    // Wait for SDK to load
-    await core.initTrack.waitForAll();
-    const storedSocialRedirectState = await core.storage.getItem(redirectStateStorageSchema);
-    if (!storedSocialRedirectState || storedSocialRedirectState.state !== dynamicOauthState) {
-        return false;
-    }
-    return true;
+const removeDynamicOauthParamsFromUrl = (url)=>{
+    const urlObject = new URL(url);
+    urlObject.searchParams.delete('dynamicOauthState');
+    urlObject.searchParams.delete('dynamicOauthCode');
+    return urlObject.toString();
 };
 
+/** The schema to track the state of the OAuth flow. */ const redirectStateStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
+    key: 'redirectState',
+    schema: z__namespace.object({
+        codeVerifier: z__namespace.optional(z__namespace.string()),
+        provider: z__namespace.enum(sdkApiCore.ProviderEnum),
+        state: z__namespace.string()
+    })
+});
+
 const digestSHA256 = (str)=>{
     const encoder = new TextEncoder();
     const data = encoder.encode(str);
@@ -1285,9 +1414,9 @@ const digestSHA256 = (str)=>{
 const APPLE_RESPONSE_MODE = 'form_post';
 const APPLE_RESPONSE_TYPE = 'code id_token';
 /** Helper function to add OAuth URL parameters to a given base URL. */ const addOAuthUrlParams = (provider, baseUrl)=>{
-    getChainFromVerifiedCredentialChain.assertDefined(provider.clientId, 'Client ID not found');
-    getChainFromVerifiedCredentialChain.assertDefined(provider.provider, 'Provider type not found');
-    getChainFromVerifiedCredentialChain.assertDefined(provider.redirectUrl, 'Redirect URL not found');
+    constants.assertDefined(provider.clientId, 'Client ID not found');
+    constants.assertDefined(provider.provider, 'Provider type not found');
+    constants.assertDefined(provider.redirectUrl, 'Redirect URL not found');
     const providerType = provider.provider;
     baseUrl.searchParams.set('client_id', provider.clientId);
     baseUrl.searchParams.set('response_type', 'code');
@@ -1311,15 +1440,15 @@ const APPLE_RESPONSE_TYPE = 'code id_token';
 };
 
 /** Helper function to build the OAuth base URL for a given provider. */ const getOAuthBaseUrl = (provider)=>{
-    getChainFromVerifiedCredentialChain.assertDefined(provider.provider, 'Provider type not found');
+    constants.assertDefined(provider.provider, 'Provider type not found');
     const providerType = provider.provider;
     if (providerType === sdkApiCore.ProviderEnum.Telegram) {
-        getChainFromVerifiedCredentialChain.assertDefined(provider.authorizationUrl, 'Telegram authorization URL not found');
+        constants.assertDefined(provider.authorizationUrl, 'Telegram authorization URL not found');
         return new URL(provider.authorizationUrl);
     }
-    getChainFromVerifiedCredentialChain.assertDefined(provider.baseAuthUrl, 'Base auth URL not found');
+    constants.assertDefined(provider.baseAuthUrl, 'Base auth URL not found');
     if (providerType === sdkApiCore.ProviderEnum.Shopify) {
-        getChainFromVerifiedCredentialChain.assertDefined(provider.shopifyStore, 'Shopify store value not found in provider');
+        constants.assertDefined(provider.shopifyStore, 'Shopify store value not found in provider');
         const loginBaseUrl = provider.baseAuthUrl.replace('{{shopifyStore}}', provider.shopifyStore);
         return new URL(loginBaseUrl);
     }
@@ -1333,17 +1462,17 @@ const providersRequiringPkce = [
 /** Helper function to build the OAuth URL for a given provider. */ const buildOAuthUrl = async (/** The core instance. */ core, /** The provider to build the OAuth URL for. */ provider)=>{
     const { projectSettings } = core.state.get();
     // Check if the provider is supported
-    getChainFromVerifiedCredentialChain.assertDefined(projectSettings, 'Project settings not found');
-    getChainFromVerifiedCredentialChain.assertDefined(projectSettings.providers, 'Project providers not found');
+    constants.assertDefined(projectSettings, 'Project settings not found');
+    constants.assertDefined(projectSettings.providers, 'Project providers not found');
     const socialProvider = projectSettings.providers.find((p)=>p.provider === provider);
-    getChainFromVerifiedCredentialChain.assertDefined(socialProvider, `Social provider ${provider} not supported`);
+    constants.assertDefined(socialProvider, `Social provider ${provider} not supported`);
     // Build the OAuth URL
     const loginBaseUrl = getOAuthBaseUrl(socialProvider);
     const socialProviderUrl = addOAuthUrlParams(socialProvider, loginBaseUrl);
     // Add PKCE and state parameters
     const usingPkce = providersRequiringPkce.includes(provider);
-    const state = getChainFromVerifiedCredentialChain.randomString(32);
-    const codeVerifier = getChainFromVerifiedCredentialChain.randomString(43);
+    const state = constants.randomString(32);
+    const codeVerifier = constants.randomString(43);
     socialProviderUrl.searchParams.set('state', state);
     socialProviderUrl.searchParams.set('response_type', 'code');
     if (usingPkce) {
@@ -1364,25 +1493,27 @@ const providersRequiringPkce = [
  * This function redirects the user to the specified social provider's
  * authorization page to complete OAuth authentication flow.
  * After the oauth flow is complete, the user will be redirected back to your app.
+ * You can then call `detectOAuthRedirect` to check if the user got redirected back to your app due to the oauth flow,
+ * and finally call `completeSocialAuthentication` to complete the social authentication flow.
  *
  * @param params.provider - The social provider to authenticate with (e.g., 'google', 'github').
  * @param params.redirectUrl - The URL to redirect back to after authentication.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- */ const signInWithSocialRedirect = async ({ provider, redirectUrl }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const authenticateWithSocial = async ({ provider, redirectUrl }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     await core.initTrack.waitForAll();
     const providerType = provider;
     const { url, state, codeVerifier } = await buildOAuthUrl(core, providerType);
     await apiClient.initAuth({
         environmentId: core.environmentId,
         oauthInitAuthRequest: {
-            redirectUrl,
+            redirectUrl: removeDynamicOauthParamsFromUrl(redirectUrl),
             state
         },
         providerType
     });
-    await core.storage.setItem(redirectStateStorageSchema, {
+    await core.storage.setItem(redirectStateStorageKeySchema, {
         codeVerifier,
         provider: providerType,
         state
@@ -1390,6 +1521,136 @@ const providersRequiringPkce = [
     await core.navigate(url.toString());
 };
 
+/**
+ * Completes the social authentication flow after OAuth redirect.
+ *
+ * This function processes the OAuth callback URL with authorization codes
+ * and completes the user authentication with the social provider.
+ *
+ * @param params.url - The callback URL containing OAuth response parameters.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to the authenticated user or null.
+ * @throws MissingSocialUrlParamError If required OAuth parameters are missing.
+ * @throws InvalidRedirectStorageStateError If the stored state doesn't match.
+ */ const completeSocialAuthentication = async ({ url }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    await core.initTrack.waitForAll();
+    const dynamicOauthState = url.searchParams.get('dynamicOauthState');
+    const dynamicOauthCode = url.searchParams.get('dynamicOauthCode');
+    if (!dynamicOauthState) {
+        throw new MissingSocialUrlParamError('dynamicOauthState');
+    }
+    if (!dynamicOauthCode) {
+        throw new MissingSocialUrlParamError('dynamicOauthCode');
+    }
+    const storedSocialRedirectState = await core.storage.getItem(redirectStateStorageKeySchema);
+    if (!storedSocialRedirectState) {
+        throw new MissingRedirectStorageStateError();
+    }
+    if (storedSocialRedirectState.state !== dynamicOauthState) {
+        throw new InvalidRedirectStorageStateError();
+    }
+    const { provider, codeVerifier } = storedSocialRedirectState;
+    await core.storage.removeItem(redirectStateStorageKeySchema);
+    let response;
+    // if user is alreadyauthenticated, we're verifying the social auth to link it to the user
+    if (client.user) {
+        response = await apiClient.oauthVerify({
+            environmentId: core.environmentId,
+            oauthRequest: {
+                code: dynamicOauthCode,
+                codeVerifier,
+                state: dynamicOauthState
+            },
+            providerType: provider
+        });
+    } else {
+        // if user is not authenticated, we're signing in with the social auth
+        response = await apiClient.oauthSignIn({
+            environmentId: core.environmentId,
+            oauthRequest: {
+                captchaToken: getNetworkProviderFromNetworkId.consumeCaptchaToken(client),
+                code: dynamicOauthCode,
+                codeVerifier,
+                state: dynamicOauthState
+            },
+            providerType: provider
+        });
+    }
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
+        response
+    }, client);
+    return response.user;
+};
+
+/**
+ * Detects if the current URL is an OAuth redirect from a social provider.
+ *
+ * This function examines the URL parameters to determine if it contains
+ * OAuth callback data from a social authentication flow.
+ *
+ * @param params.url - The URL to check for OAuth redirect parameters.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to true if the URL is an OAuth redirect, false otherwise.
+ */ const detectOAuthRedirect = async ({ url }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const dynamicOauthState = url.searchParams.get('dynamicOauthState');
+    const dynamicOauthCode = url.searchParams.get('dynamicOauthCode');
+    if (!dynamicOauthState || !dynamicOauthCode) {
+        return false;
+    }
+    // Wait for SDK to load
+    await core.initTrack.waitForAll();
+    const storedSocialRedirectState = await core.storage.getItem(redirectStateStorageKeySchema);
+    if (!storedSocialRedirectState || storedSocialRedirectState.state !== dynamicOauthState) {
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Get the primary wallet account.
+ * The primary wallet account is the one that was last selected by the user.
+ * This information is stored in both unverified and verified wallet accounts.
+ * This function consolidates this information to determine which wallet was most recently selected.
+ */ const getPrimaryWalletAccount = (client = constants.getDefaultClient())=>{
+    const walletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts(client);
+    const sortedLastSelectedWalletAccounts = walletAccounts.filter((walletAccount)=>Boolean(walletAccount.lastSelectedAt)).sort((a, b)=>b.lastSelectedAt.getTime() - a.lastSelectedAt.getTime());
+    if (sortedLastSelectedWalletAccounts.length === 0) {
+        return null;
+    }
+    const [primaryWalletAccount] = sortedLastSelectedWalletAccounts;
+    return primaryWalletAccount;
+};
+
+/**
+ * Unlinks a social account from the user's account.
+ *
+ * @param params.verifiedCredentialId - The verified credential ID of the social account to unlink.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to the verify response.
+ */ const unlinkSocialAccount = async ({ verifiedCredentialId }, client = constants.getDefaultClient())=>{
+    var _primaryWalletAccount_verifiedCredentialId;
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    // the api seems to require us to pass the primary wallet id when
+    // unlinking a social account if the user has wallets
+    const primaryWalletAccount = getPrimaryWalletAccount(client);
+    const walletId = primaryWalletAccount == null ? void 0 : (_primaryWalletAccount_verifiedCredentialId = primaryWalletAccount.verifiedCredentialId) == null ? void 0 : _primaryWalletAccount_verifiedCredentialId.replace('-zerodev', '');
+    const response = await apiClient.verifyUnlink({
+        environmentId: core.environmentId,
+        verifyUnlinkRequest: {
+            verifiedCredentialId,
+            walletId: walletId != null ? walletId : undefined
+        }
+    });
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
+        response
+    }, client);
+    return response;
+};
+
 /**
  * Retrieves token balances across multiple blockchain networks.
  *
@@ -1399,9 +1660,9 @@ const providersRequiringPkce = [
  * @param params.balanceRequest - The balance request configuration specifying which chains, networks and addresses to query.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the chain balances across multiple networks.
- */ const getMultichainBalances = async ({ balanceRequest }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const getMultichainBalances = async ({ balanceRequest }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.postMultichainAccountBalances({
         environmentId: core.environmentId,
         multichainAccountBalancesRequest: balanceRequest
@@ -1409,6 +1670,242 @@ const providersRequiringPkce = [
     return response.chainBalances;
 };
 
+/**
+ * Adds a listener for Coinbase onramp order events.
+ *
+ * @param params.listener - The listener function to call when an event is received.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A function to remove the listener.
+ * @throws {ValueMustBeDefinedError} If the window is not available.
+ * @docs https://docs.cdp.coinbase.com/onramp-&-offramp/onramp-apis/apple-pay-onramp-api#events-names
+ */ const addCoinbaseOnrampOrderEventListener = ({ listener }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    if (typeof window === 'undefined') {
+        throw new constants.ValueMustBeDefinedError('Window is not available to listen for Coinbase onramp order events');
+    }
+    const handleMessageEvent = (event)=>{
+        if (event.origin !== 'https://pay.coinbase.com') {
+            return;
+        }
+        core.logger.debug('[addCoinbaseOnrampOrderEventListener] pay.coinbase.com event received', {
+            event
+        });
+        try {
+            var _coinbaseOnrampOrderEventData_eventName;
+            const coinbaseOnrampOrderEventData = JSON.parse(event.data);
+            if (!((_coinbaseOnrampOrderEventData_eventName = coinbaseOnrampOrderEventData.eventName) == null ? void 0 : _coinbaseOnrampOrderEventData_eventName.startsWith('onramp_api.'))) {
+                return;
+            }
+            listener({
+                data: coinbaseOnrampOrderEventData.data,
+                eventName: coinbaseOnrampOrderEventData.eventName
+            });
+        } catch (error) {
+            core.logger.debug('[addCoinbaseOnrampOrderEventListener] Failed to parse Coinbase onramp order event data', {
+                error
+            });
+        }
+    };
+    window.addEventListener('message', handleMessageEvent);
+    return ()=>{
+        window.removeEventListener('message', handleMessageEvent);
+    };
+};
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+/**
+ * This function is used to get a list of fields that are missing verification for a Coinbase onramp order
+ *
+ * - If the user is missing information for an email or phone number, the field will be returned with the error code MISSING_INFORMATION
+ * - If the user is missing verification for an email or phone number, the field will be returned with the error code MISSING_VERIFICATION
+ *   and the existing unverified email or phone number will be included in the data field.
+ * - If the user's phone number has not been verified in the last 60 days, the field will be returned with the error code VERIFICATION_EXPIRED
+ *   and the existing phone number will be included in the data field.
+ *
+ * @param params.paymentMethod - The payment method that will be used to create the onramp order
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns FieldMissingVerificationForCoinbaseOnramp[] - An array of fields that are missing verification for a Coinbase onramp order
+ * @throws {InvalidParamError} - If the payment method is not valid
+ * @throws {ValueMustBeDefinedError} - If the user is not authenticated
+ */ const getMissingVerificationForCoinbaseOnrampOrder = ({ paymentMethod }, client = constants.getDefaultClient())=>{
+    // adding the payment method as a param for now just so a user has to pass an object as the first param
+    // that way, when we add more payment methods, we can easily add them to the param object
+    // and not have to change the function signature
+    if (paymentMethod !== 'GUEST_CHECKOUT_APPLE_PAY') {
+        throw new InvalidParamError.InvalidParamError(`Invalid payment method: ${paymentMethod}`);
+    }
+    const { user } = client;
+    constants.assertDefined(user, 'User is not authenticated');
+    const fieldsMissingVerification = [];
+    const emailVerifiedCredential = user.verifiedCredentials.find((credential)=>credential.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Email);
+    if (!user.email) {
+        // when user has no email at all (verified or not)
+        fieldsMissingVerification.push({
+            errorCode: 'MISSING_INFORMATION',
+            field: 'email'
+        });
+    } else if (!emailVerifiedCredential) {
+        // when user has an email but it is not verified
+        fieldsMissingVerification.push({
+            data: user.email,
+            errorCode: 'MISSING_VERIFICATION',
+            field: 'email'
+        });
+    }
+    const phoneVerifiedCredential = user.verifiedCredentials.find((credential)=>credential.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.PhoneNumber);
+    const phoneNumberVerifiedInPast60Days = (phoneVerifiedCredential == null ? void 0 : phoneVerifiedCredential.verifiedAt) && phoneVerifiedCredential.verifiedAt >= new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
+    if (!user.phoneNumber) {
+        // when user has no phone number at all (verified or not)
+        fieldsMissingVerification.push({
+            errorCode: 'MISSING_INFORMATION',
+            field: 'phoneNumber'
+        });
+    } else if (!phoneVerifiedCredential) {
+        // when user has a phone number but it is not verified
+        fieldsMissingVerification.push({
+            data: user.phoneNumber,
+            errorCode: 'MISSING_VERIFICATION',
+            field: 'phoneNumber'
+        });
+    } else if (!phoneNumberVerifiedInPast60Days) {
+        // when user has a verified phone number but it is not verified in the last 60 days
+        fieldsMissingVerification.push({
+            data: user.phoneNumber,
+            errorCode: 'VERIFICATION_EXPIRED',
+            field: 'phoneNumber'
+        });
+    }
+    return fieldsMissingVerification;
+};
+
+const validateUserCredentialsForCoinbaseOnrampOrder = (client)=>{
+    const { user } = client;
+    constants.assertDefined(user, 'User is not authenticated');
+    const fieldsMissingVerification = getMissingVerificationForCoinbaseOnrampOrder({
+        paymentMethod: 'GUEST_CHECKOUT_APPLE_PAY'
+    }, client);
+    const missingEmailVerification = fieldsMissingVerification.find((field)=>field.field === 'email');
+    if (missingEmailVerification) {
+        throw new MissingUserVerificationError({
+            informationToVerify: 'email',
+            message: 'User must have a verified email to create a Coinbase onramp order'
+        });
+    }
+    const missingPhoneNumberVerification = fieldsMissingVerification.find((field)=>field.field === 'phoneNumber');
+    if (missingPhoneNumberVerification && missingPhoneNumberVerification.errorCode !== 'VERIFICATION_EXPIRED') {
+        throw new MissingUserVerificationError({
+            informationToVerify: 'phoneNumber',
+            message: 'User must have a verified phone number to create a Coinbase onramp order'
+        });
+    }
+    // this is a requirement for Coinbase Onramp
+    // https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/create-an-onramp-order#body-phone-number-verified-at
+    if (missingPhoneNumberVerification && missingPhoneNumberVerification.errorCode === 'VERIFICATION_EXPIRED') {
+        throw new MissingUserVerificationError({
+            informationToVerify: 'phoneNumber',
+            message: "The user's phone number has not been verified in the last 60 days. Please re-verify the user's phone number"
+        });
+    }
+    return user;
+};
+
+/**
+ * Creates a Coinbase onramp order
+ *
+ * @param orderParams CoinbaseCreateOnrampOrderRequest - The parameters for the onramp order.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The created order
+ * @throws {MissingUserVerificationError} If the user is missing verification for email or phone
+ */ const createCoinbaseOnrampOrder = async (orderParams, client = constants.getDefaultClient())=>{
+    const user = validateUserCredentialsForCoinbaseOnrampOrder(client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
+        includeMfaToken: true
+    }, client);
+    const { isSandbox } = orderParams, restOrderParams = _object_without_properties_loose(orderParams, [
+        "isSandbox"
+    ]);
+    var _orderParams_partnerUserRef;
+    const orderResponse = await apiClient.createCoinbaseOnrampOrder({
+        coinbaseOnrampOrderCreateRequest: constants._extends({}, restOrderParams, {
+            // to create a sandbox order, we need to prefix the partner user ref with 'sandbox-'
+            // https://docs.cdp.coinbase.com/onramp-&-offramp/onramp-apis/apple-pay-onramp-api#testing
+            partnerUserRef: (_orderParams_partnerUserRef = orderParams.partnerUserRef) != null ? _orderParams_partnerUserRef : isSandbox ? `sandbox-${user.id}` : user.id,
+            paymentMethod: orderParams.paymentMethod
+        }),
+        environmentId: core.environmentId
+    });
+    if (!isSandbox || !orderResponse.paymentLink) {
+        return orderResponse;
+    }
+    return constants._extends({}, orderResponse, {
+        paymentLink: constants._extends({}, orderResponse.paymentLink, {
+            url: `${orderResponse.paymentLink.url}&useApplePaySandbox=true`
+        })
+    });
+};
+
+/**
+ * Gets a Coinbase buy URL
+ *
+ * @param buyUrlParams CoinbaseOnrampGetBuyUrlRequest - The parameters for the buy URL.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns an object containing the buy URL
+ */ const getCoinbaseBuyUrl = async (buyUrlParams, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
+        includeMfaToken: true
+    }, client);
+    const response = await apiClient.generateCoinbaseOnrampBuyUrl({
+        coinbaseOnrampGetBuyUrlRequest: buyUrlParams,
+        environmentId: core.environmentId
+    });
+    return response;
+};
+
+/**
+ * Creates a crypto.com payment
+ *
+ * @param paymentParams CryptoDotComPaymentCreateRequest - The parameters for the payment.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The created payment
+ */ const createCryptoDotComPayment = async (paymentParams, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
+        includeMfaToken: true
+    }, client);
+    const response = await apiClient.createCryptoDotComPayment({
+        cryptoDotComPaymentCreateRequest: constants._extends({}, paymentParams, {
+            // eslint-disable-next-line custom-rules/ban-chain-enum
+            chain: paymentParams.chain
+        }),
+        environmentId: core.environmentId
+    });
+    return response;
+};
+
+/**
+ * Allows waiting until all modules of the client have been properly initialized
+ * and are ready for use.
+ *
+ * @returns a promise that resolves once the client is fully initialized.
+ */ const waitForClientInitialized = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    await core.initTrack.waitForAll();
+};
+
 /**
  * Updates the current user's profile information.
  *
@@ -1419,16 +1916,16 @@ const providersRequiringPkce = [
  * @param params.userFields - The user fields to update.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to OTP verification details if verification is required, or undefined.
- */ const updateUser = async ({ userFields }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({
+ */ const updateUser = async ({ userFields }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
         includeMfaToken: true
     }, client);
     const response = await apiClient.updateSelf({
         environmentId: core.environmentId,
         userFields
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     if (response.emailVerification) {
@@ -1456,7 +1953,7 @@ const providersRequiringPkce = [
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the acknowledgment is complete.
- */ const acknowledgeRecoveryCodes = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const acknowledgeRecoveryCodes = async (client = constants.getDefaultClient())=>{
     return updateUser({
         userFields: {
             mfaBackupCodeAcknowledgement: sdkApiCore.MfaBackupCodeAcknowledgement.Complete
@@ -1473,9 +1970,9 @@ const providersRequiringPkce = [
  * @param params.code - The recovery code to authenticate with.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the MFA authentication response with token.
- */ const authenticateMfaRecoveryCode = async ({ code, createMfaTokenOptions }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const authenticateMfaRecoveryCode = async ({ code, createMfaTokenOptions }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     try {
         const response = await apiClient.authMfaRecovery({
             environmentId: core.environmentId,
@@ -1484,10 +1981,10 @@ const providersRequiringPkce = [
                 createMfaToken: createMfaTokenOptions
             }
         });
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 mfaToken: response.mfaToken
             },
@@ -1495,7 +1992,7 @@ const providersRequiringPkce = [
         }, client);
         return response;
     } catch (error) {
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 error
             },
@@ -1505,23 +2002,24 @@ const providersRequiringPkce = [
     }
 };
 
-const getPasskeyAuthenticationOptions = async (client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+const getPasskeyAuthenticationOptions = async ({ relatedOriginRpId } = {}, client)=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const options = await apiClient.getPasskeyAuthenticationOptions({
-        environmentId: core.environmentId
+        environmentId: core.environmentId,
+        relatedOriginRpId
     });
     return options;
 };
 
 const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.authenticateMfaPasskeyDevice({
         environmentId: core.environmentId,
-        passkeyAuthRequest: getChainFromVerifiedCredentialChain._extends({}, authentication, {
+        passkeyAuthRequest: constants._extends({}, authentication, {
             createMfaToken,
-            response: getChainFromVerifiedCredentialChain._extends({}, authentication.response, {
+            response: constants._extends({}, authentication.response, {
                 clientDataJson: authentication.response.clientDataJSON
             })
         })
@@ -1540,22 +2038,24 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @returns A promise that resolves to the MFA authentication response.
  * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
  * @throws NoPasskeyCredentialsFoundError If no passkey credentials are found.
- */ const authenticatePasskeyMFA = async ({ createMfaToken } = {}, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const authenticatePasskeyMFA = async ({ createMfaToken, relatedOriginRpId } = {}, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     try {
         var _options_allowCredentials;
         if (!core.passkey.isSupported()) {
             throw new NoWebAuthNSupportError();
         }
-        const options = await getPasskeyAuthenticationOptions(client);
-        const allowCredentials = (_options_allowCredentials = options.allowCredentials) == null ? void 0 : _options_allowCredentials.map((credential)=>getChainFromVerifiedCredentialChain._extends({}, credential, {
+        const options = await getPasskeyAuthenticationOptions({
+            relatedOriginRpId
+        }, client);
+        const allowCredentials = (_options_allowCredentials = options.allowCredentials) == null ? void 0 : _options_allowCredentials.map((credential)=>constants._extends({}, credential, {
                 type: 'public-key'
             }));
         if (!(allowCredentials == null ? void 0 : allowCredentials.length)) {
             throw new NoPasskeyCredentialsFoundError();
         }
         // Ensure allowCredentials has the required type property
-        const formattedOptions = getChainFromVerifiedCredentialChain._extends({}, options, {
+        const formattedOptions = constants._extends({}, options, {
             allowCredentials
         });
         const authentication = await core.passkey.authenticate({
@@ -1565,10 +2065,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
             authentication,
             createMfaToken
         }, client);
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 mfaToken: response.mfaToken
             },
@@ -1576,7 +2076,7 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
         }, client);
         return response;
     } catch (error) {
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 error
             },
@@ -1597,9 +2097,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @param [params.createMfaTokenOptions] - Optional configuration for MFA token creation.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the MFA authentication response.
- */ const authenticateTotpMfaDevice = async ({ deviceId, code, createMfaTokenOptions }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const authenticateTotpMfaDevice = async ({ deviceId, code, createMfaTokenOptions }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     try {
         const response = await apiClient.authMfaTotpDevice({
             environmentId: core.environmentId,
@@ -1609,10 +2109,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
                 id: deviceId
             }
         });
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 deviceId,
                 mfaToken: response.mfaToken
@@ -1621,7 +2121,7 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
         }, client);
         return response;
     } catch (error) {
-        getWalletProviderByKey.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 deviceId,
                 error
@@ -1640,9 +2140,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the newly generated recovery codes.
- */ const createNewMfaRecoveryCodes = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const createNewMfaRecoveryCodes = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.createNewRecoveryCodes({
         environmentId: core.environmentId
     });
@@ -1658,11 +2158,11 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @param params.mfaAuthToken - The MFA authentication token required for device deletion.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the MFA device is successfully deleted.
- */ const deleteMfaDevice = async ({ deviceId, mfaAuthToken }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    getChainFromVerifiedCredentialChain.assertDefined(deviceId, 'deviceId is required');
-    getChainFromVerifiedCredentialChain.assertDefined(mfaAuthToken, 'mfaAuthToken is required');
+ */ const deleteMfaDevice = async ({ deviceId, mfaAuthToken }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    constants.assertDefined(deviceId, 'deviceId is required');
+    constants.assertDefined(mfaAuthToken, 'mfaAuthToken is required');
     return apiClient.deleteMfaDevice({
         environmentId: core.environmentId,
         mfaDeviceId: deviceId,
@@ -1678,9 +2178,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an array of the user's registered MFA devices.
- */ const getMfaDevices = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const getMfaDevices = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const { devices } = await apiClient.getUserMfaDevices({
         environmentId: core.environmentId
     });
@@ -1697,9 +2197,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the user's MFA recovery codes.
- */ const getMfaRecoveryCodes = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const getMfaRecoveryCodes = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.getRecoveryCodes({
         environmentId: core.environmentId
     });
@@ -1713,9 +2213,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns True if recovery codes are pending acknowledgment, false otherwise.
- */ const isPendingRecoveryCodesAcknowledgment = (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const isPendingRecoveryCodesAcknowledgment = (client = constants.getDefaultClient())=>{
     const user = client.user;
-    getChainFromVerifiedCredentialChain.assertDefined(user, 'User not logged in');
+    constants.assertDefined(user, 'User not logged in');
     return user.mfaBackupCodeAcknowledgement !== sdkApiCore.MfaBackupCodeAcknowledgement.Complete;
 };
 
@@ -1727,10 +2227,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns True if the user needs additional MFA authentication, false otherwise.
- */ const isUserMissingMfaAuth = (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const isUserMissingMfaAuth = (client = constants.getDefaultClient())=>{
     var _user_scope;
     const user = client.user;
-    getChainFromVerifiedCredentialChain.assertDefined(user, 'User not logged in');
+    constants.assertDefined(user, 'User not logged in');
     return Boolean((_user_scope = user.scope) == null ? void 0 : _user_scope.includes('requiresAdditionalAuth'));
 };
 
@@ -1743,9 +2243,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the TOTP registration response containing setup information,
  * like the secret key and the OTP Auth URI.
- */ const registerTotpMfaDevice = async (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const registerTotpMfaDevice = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.registerTotpMfaDevice({
         environmentId: core.environmentId
     });
@@ -1760,10 +2260,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @param params.deviceId - The unique identifier of the MFA device to set as default.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the default MFA device is successfully set.
- */ const setDefaultMfaDevice = async ({ deviceId }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    getChainFromVerifiedCredentialChain.assertDefined(deviceId, 'deviceId is required');
+ */ const setDefaultMfaDevice = async ({ deviceId }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    constants.assertDefined(deviceId, 'deviceId is required');
     // All that this endpoint does is set the default device to the one provided.
     return apiClient.updateUserMfaDevice({
         environmentId: core.environmentId,
@@ -1779,9 +2279,9 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
  * @param params.email - The email address to send the OTP to.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an OTPVerification object containing the email and verification UUID.
- */ const sendEmailOTP = async ({ email }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const sendEmailOTP = async ({ email }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const { verificationUUID } = await apiClient.createEmailVerification({
         emailVerificationCreateRequest: {
             captchaToken: getNetworkProviderFromNetworkId.consumeCaptchaToken(client),
@@ -2726,9 +3226,9 @@ const supportedCountries = {
  * @param params.phoneNumber - The phone number to send the OTP to.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an OTPVerification object containing the phone details and verification UUID.
- */ const sendSmsOTP = async ({ isoCountryCode, phoneNumber }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const sendSmsOTP = async ({ isoCountryCode, phoneNumber }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const phoneCountryCode = supportedCountries[isoCountryCode].code;
     const { verificationUUID } = await apiClient.createSmsVerification({
         environmentId: core.environmentId,
@@ -2748,8 +3248,8 @@ const supportedCountries = {
 };
 
 const verifyOTPForUserSignIn = async ({ otpVerification, verificationToken }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const verifyRequest = {
         verificationToken,
         verificationUUID: otpVerification.verificationUUID
@@ -2767,8 +3267,8 @@ const verifyOTPForUserSignIn = async ({ otpVerification, verificationToken }, cl
 };
 
 const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const verifyRequest = {
         verificationToken,
         verificationUUID: otpVerification.verificationUUID
@@ -2794,17 +3294,36 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, cl
  * @param params.otpVerification - The OTP verification object containing verification details.
  * @param params.verificationToken - The token received from the OTP verification process.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns A promise that resolves to the user object upon successful verification.
- */ const verifyOTP = async ({ otpVerification, verificationToken }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ * @returns A promise that resolves to the verify response object upon successful verification.
+ */ const verifyOTP = async ({ otpVerification, verificationToken }, client = constants.getDefaultClient())=>{
     const verifyOTPFunction = client.user ? verifyOTPForUserUpdate : verifyOTPForUserSignIn;
     const response = await verifyOTPFunction({
         otpVerification,
         verificationToken
     }, client);
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
-    return response.user;
+    return response;
+};
+
+/**
+ * Deletes the current user's account permanently.
+ *
+ * This function performs a hard delete of the user account. Upon successful deletion,
+ * the user will be automatically logged out and all authentication data will be cleared.
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves when the user account is successfully deleted.
+ */ const deleteUser = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
+        includeMfaToken: true
+    }, client);
+    await apiClient.hardDeleteUser({
+        environmentId: core.environmentId
+    });
+    await logout(client);
 };
 
 /**
@@ -2820,8 +3339,8 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, cl
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves if the wallet is available for signing.
  * @throws WalletAccountNotSelectedError If the wallet account is not currently selected.
- */ const assertWalletAccountSigningAvailability = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const assertWalletAccountSigningAvailability = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { addresses } = await walletProvider.getConnectedAddresses();
@@ -2833,49 +3352,6 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, cl
     }
 };
 
-/*  
-  In older SDK versions we used to have the concept of "connect-only" vs "connect-and-sign". 
-  The only difference in backend is it stores some extra data for connect-only, 
-  so we can just default to using it.
-*/ const createVisit = async ({ walletAccount, authMode = sdkApiCore.AuthModeEnum.Only }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
-        walletAccount
-    }, client);
-    try {
-        const connectRequest = {
-            address: walletAccount.address,
-            authMode,
-            // eslint-disable-next-line custom-rules/ban-chain-enum
-            chain: walletProvider.chain,
-            provider: walletProvider.getWalletProviderType(),
-            walletName: walletAccount.walletProviderKey
-        };
-        await apiClient.createVisit({
-            connectRequest,
-            environmentId: core.environmentId
-        });
-    } catch (error) {
-        core.logger.error('Error creating visit', {
-            error
-        });
-    }
-};
-
-/**
- * Updates the unverified wallet account in the client state.
- */ const setUnverifiedWalletAccount = ({ unverifiedWalletAccountToUpdate }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const filteredUnverifiedWalletAccounts = core.state.get().unverifiedWalletAccounts.filter((unverifiedWalletAccount)=>unverifiedWalletAccount.id !== unverifiedWalletAccountToUpdate.id);
-    core.state.set({
-        unverifiedWalletAccounts: [
-            ...filteredUnverifiedWalletAccounts,
-            unverifiedWalletAccountToUpdate
-        ]
-    });
-};
-
 /**
  * Asserts that a specific wallet provider method is defined, throwing an error if it's not.
  * This function acts as a type guard, narrowing the type to ensure the method exists.
@@ -2900,6 +3376,10 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, cl
     }
 }
 
+const getAddressesWithTypesFromConnectionResult = (connectionResult)=>{
+    return connectionResult.addresses.filter((address)=>!!address.address && !!address.type);
+};
+
 /**
  * Connects to a wallet provider and returns the connected wallet account.
  *
@@ -2909,68 +3389,69 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, cl
  * @see connectAndVerifyWithWalletProvider
  *
  * @param params.walletProviderKey - The unique key identifying the wallet provider to connect to (e.g. 'metamaskevm', 'phantomsol').
- * @param [params.addToUserWalletAccounts] - Whether to add the connected wallet account to the user's wallet accounts. Defaults to true.
+ * @param [params.addToDynamicWalletAccounts] - Whether to add the connected wallet account to the user's wallet accounts. Defaults to true.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the connected wallet account.
  * @throws NoAddressFoundError If the request to connect was successful but no address is connected to your app.
- */ const connectWithWalletProvider = async ({ walletProviderKey, addToUserWalletAccounts = true }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const connectWithWalletProvider = async ({ walletProviderKey, addToDynamicWalletAccounts = true }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'connect');
-    const { addresses: [selectedAddress] } = await walletProvider.connect();
-    const currentAddresses = getWalletProviderByKey.getWalletAccounts(client).map(({ address })=>address);
+    const { addresses } = await walletProvider.connect();
+    const currentAddresses = getVerifiedCredentialForWalletAccount.getWalletAccounts(client).map(({ address })=>address);
+    const mainAddress = (addresses == null ? void 0 : addresses.length) ? addresses[0].address : null;
     /**
    * This error is thrown in case the wallet has no addresses connected
    * to the dapp. Then the error is thrown so the consumer can instruct the
    * user on the next steps.
-   */ if (!selectedAddress) {
+   */ if (!mainAddress) {
         throw new NoAddressFoundError();
     }
     const walletAccount = {
-        address: selectedAddress,
+        address: mainAddress,
+        addressesWithTypes: getAddressesWithTypesFromConnectionResult({
+            addresses
+        }),
         chain: walletProvider.chain,
-        id: getWalletProviderByKey.createWalletAccountId(walletProvider.chain, selectedAddress),
+        id: getVerifiedCredentialForWalletAccount.formatWalletAccountId({
+            address: mainAddress,
+            chain: walletProvider.chain,
+            walletProviderKey
+        }),
         lastSelectedAt: null,
         verifiedCredentialId: null,
-        walletProviderKey: walletProvider.key
+        walletProviderKey
     };
-    if (currentAddresses.includes(selectedAddress)) {
+    if (currentAddresses.includes(mainAddress)) {
         return walletAccount;
     }
-    if (addToUserWalletAccounts) {
-        setUnverifiedWalletAccount({
-            unverifiedWalletAccountToUpdate: walletAccount
+    if (addToDynamicWalletAccounts) {
+        getNetworkProviderFromNetworkId.setUnverifiedWalletAccounts({
+            unverifiedWalletAccountsToUpdate: [
+                walletAccount
+            ]
         }, client);
-        getWalletProviderByKey.emitWalletAccountsChangedEvent(client);
+        getVerifiedCredentialForWalletAccount.emitWalletAccountsChangedEvent(client);
         /*
      * send information to backend to kick off background jobs
      * this is an async work, but does not need to be awaited
-     */ void createVisit({
+     */ void getNetworkProviderFromNetworkId.createVisit({
             walletAccount
         }, client);
     }
     return walletAccount;
 };
 
-/**
- * Check if the given value is an Error object
- */ const isError = (error)=>error instanceof Error;
-
-/**
- * Check if the given value is an Error object with a specific code
- */ const isErrorWithCode = (error, code)=>{
-    if (!isError(error)) return false;
-    return 'code' in error && error.code === code;
-};
-
 const getChainIdForAccountVerification = async ({ walletProvider })=>{
-    // If it's a Solana wallet, we should not specify a chainId
-    // since it breaks the message signature in some wallets (e.g. Trust Wallet)
-    if (walletProvider.chain === 'SOL') {
-        return undefined;
-    }
-    if (walletProvider.chain === 'SUI') {
+    // for some chains, we don't need to specify a chain id for account verification because it's
+    // not required and it might break the message signature in some wallets (e.g. Trust Wallet SOL)
+    const chainsThatDontNeedChainId = [
+        'BTC',
+        'SOL',
+        'SUI'
+    ];
+    if (chainsThatDontNeedChainId.includes(walletProvider.chain)) {
         return undefined;
     }
     const { networkId } = await walletProvider.getActiveNetworkId();
@@ -2986,21 +3467,22 @@ const getChainIdForAccountVerification = async ({ walletProvider })=>{
 
 const getSignInMessage = async ({ walletAccount }, client)=>{
     var _core_metadata;
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const appUrl = (_core_metadata = core.metadata) == null ? void 0 : _core_metadata.url;
-    getChainFromVerifiedCredentialChain.assertDefined(appUrl, 'App URL is not set');
+    constants.assertDefined(appUrl, 'App URL is not set');
     const url = new URL(appUrl);
     const { nonce } = await apiClient.getNonce({
         environmentId: core.environmentId
     });
-    getChainFromVerifiedCredentialChain.assertDefined(nonce, 'Failed to get nonce');
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+    constants.assertDefined(nonce, 'Failed to get nonce');
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
+    const statement = getNetworkProviderFromNetworkId.createSignInMessageStatement(client);
     const messageToSign = await getNetworkProviderFromNetworkId.formatSignInMessage({
         address: walletAccount.address,
-        blockchainName: getChainFromVerifiedCredentialChain.CHAINS_INFO_MAP[walletProvider.chain].blockchainName,
+        blockchainName: constants.CHAINS_INFO_MAP[walletProvider.chain].blockchainName,
         chainId: await getChainIdForAccountVerification({
             walletProvider
         }),
@@ -3008,6 +3490,7 @@ const getSignInMessage = async ({ walletAccount }, client)=>{
         issuedAt: new Date().toISOString(),
         nonce,
         requestId: core.environmentId,
+        statement,
         uri: url.toString()
     });
     return messageToSign;
@@ -3022,8 +3505,8 @@ const getSignInMessage = async ({ walletAccount }, client)=>{
  * @param params.walletAccount - The wallet account to prove ownership of.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an object containing the message and signature.
- */ const proveWalletAccountOwnership = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const proveWalletAccountOwnership = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'signMessage');
@@ -3036,22 +3519,29 @@ const getSignInMessage = async ({ walletAccount }, client)=>{
     });
     return {
         messageToSign,
-        signedMessage: signature
+        signature
     };
 };
 
 /**
  * Removes an unverified wallet account from the client's state.
  */ const removeUnverifiedWalletAccount = ({ unverifiedWalletAccount }, client)=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+    const core = constants.getCore(client);
+    const previousState = core.state.get();
     const { unverifiedWalletAccounts } = core.state.get();
     const filteredUnverifiedWalletAccounts = unverifiedWalletAccounts.filter((account)=>account.id !== unverifiedWalletAccount.id);
     core.state.set({
         unverifiedWalletAccounts: filteredUnverifiedWalletAccounts
     });
+    /**
+   * We check before raising because the wallet account we are removing might still
+   * be present in wallet accounts due to having been moved to verified credentials.
+   */ getVerifiedCredentialForWalletAccount.checkAndRaiseWalletAccountsChangedEvent({
+        previousState
+    }, client);
 };
 
-const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddress(left, chain) === getWalletProviderByKey.normalizeAddress(right, chain);
+const isSameAddress = (left, right, chain)=>getVerifiedCredentialForWalletAccount.normalizeAddress(left, chain) === getVerifiedCredentialForWalletAccount.normalizeAddress(right, chain);
 
 /**
  * Verifies ownership of a wallet account and adds it to the user's profile.
@@ -3064,54 +3554,49 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @returns A promise that resolves to the verified wallet account.
  * @throws WalletAccountAlreadyVerifiedError If the wallet is already verified.
  * @throws WalletAlreadyLinkedToAnotherUserError If the wallet is linked to another user.
- */ const verifyWalletAccount = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const verifyWalletAccount = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    var _response_user;
     if (walletAccount.verifiedCredentialId) {
         throw new WalletAccountAlreadyVerifiedError(walletAccount.address);
     }
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
-    const { signedMessage, messageToSign } = await proveWalletAccountOwnership({
+    const { messageToSign, signature } = await proveWalletAccountOwnership({
         walletAccount
     }, client);
-    const verifyApiFunction = client.user ? apiClient.verifyLink.bind(apiClient) : apiClient.verify.bind(apiClient);
-    try {
-        const response = await verifyApiFunction({
-            environmentId: core.environmentId,
-            verifyRequest: {
-                captchaToken: getNetworkProviderFromNetworkId.consumeCaptchaToken(client),
-                // eslint-disable-next-line custom-rules/ban-chain-enum
-                chain: walletAccount.chain,
-                messageToSign,
-                publicWalletAddress: walletAccount.address,
-                signedMessage,
-                walletName: walletProvider.key,
-                walletProvider: walletProvider.getWalletProviderType()
-            }
-        });
-        /**
-     * Remove the now verified wallet account from the unverified wallet accounts
-     */ removeUnverifiedWalletAccount({
-            unverifiedWalletAccount: walletAccount
-        }, client);
-        /**
-     * Adds the user with the new wallet verified credential
-     * This will add the new verified wallet account to the client`s state
-     */ getWalletProviderByKey.updateAuthFromVerifyResponse({
-            response
-        }, client);
-    } catch (error) {
-        if (isErrorWithCode(error, 'reassign_wallet_confirm') || isErrorWithCode(error, 'merge_accounts_confirmation')) {
-            throw new WalletAlreadyLinkedToAnotherUserError({
-                cause: error
-            });
+    const response = await getNetworkProviderFromNetworkId.verifySignInMessage({
+        addressesWithTypes: walletAccount.addressesWithTypes,
+        chain: walletAccount.chain,
+        messageToSign,
+        signature,
+        walletAddress: walletAccount.address,
+        walletDisplayName: walletProvider.metadata.displayName,
+        walletProviderType: walletProvider.walletProviderType
+    }, client);
+    const walletVerifiedCredential = (_response_user = response.user) == null ? void 0 : _response_user.verifiedCredentials.find((verifiedCredential)=>{
+        var _verifiedCredential_address;
+        return isSameAddress((_verifiedCredential_address = verifiedCredential.address) != null ? _verifiedCredential_address : '', walletAccount.address, walletAccount.chain);
+    });
+    constants.assertDefined(walletVerifiedCredential, `After verifying, still unable to find verified wallet credential for wallet account ${walletAccount.address} on chain ${walletAccount.chain}`);
+    getNetworkProviderFromNetworkId.updateWalletProviderKeysForVerifiedCredentials({
+        keysToUpdate: {
+            [walletVerifiedCredential.id]: walletProvider.key
         }
-        throw error;
-    }
-    const verifiedWalletAccount = getWalletProviderByKey.getWalletAccounts(client).find(({ address })=>isSameAddress(address, walletAccount.address, walletAccount.chain));
-    getChainFromVerifiedCredentialChain.assertDefined(verifiedWalletAccount, 'Verified wallet account not found');
+    }, client);
+    /**
+   * Adds the user with the new wallet verified credential
+   * This will add the new verified wallet account to the client`s state
+   */ getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
+        response
+    }, client);
+    /**
+   * Remove the now verified wallet account from the unverified wallet accounts
+   */ removeUnverifiedWalletAccount({
+        unverifiedWalletAccount: walletAccount
+    }, client);
+    const verifiedWalletAccount = getVerifiedCredentialForWalletAccount.getWalletAccounts(client).find(({ address })=>isSameAddress(address, walletAccount.address, walletAccount.chain));
+    constants.assertDefined(verifiedWalletAccount, `Unable to find wallet account ${walletAccount.address} on chain ${walletAccount.chain} for verified credential ${walletVerifiedCredential.id}`);
     return verifiedWalletAccount;
 };
 
@@ -3125,9 +3610,9 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletProviderKey - The unique key identifying the wallet provider to connect to.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the connected and verified wallet account.
- */ const connectAndVerifyWithWalletProvider = async ({ walletProviderKey }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const connectAndVerifyWithWalletProvider = async ({ walletProviderKey }, client = constants.getDefaultClient())=>{
     const walletAccount = await connectWithWalletProvider({
-        addToUserWalletAccounts: false,
+        addToDynamicWalletAccounts: false,
         walletProviderKey
     }, client);
     await verifyWalletAccount({
@@ -3136,7 +3621,7 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
     /*
    * send information to backend to kick off background jobs
    * this is an async work, but does not need to be awaited
-   */ void createVisit({
+   */ void getNetworkProviderFromNetworkId.createVisit({
         authMode: sdkApiCore.AuthModeEnum.AndSign,
         walletAccount
     }, client);
@@ -3151,16 +3636,17 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  *
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns An array of wallet provider data including chain, keys, and metadata.
- */ const getAvailableWalletProvidersData = (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const allWalletProviders = getWalletProviderByKey.getWalletProviders(client);
-    // this is to avoid returning the wallet providers that are not available to connect
-    // like the Dynamic Waas providers or AA providers
+ */ const getAvailableWalletProvidersData = (client = constants.getDefaultClient())=>{
+    const allWalletProviders = getVerifiedCredentialForWalletAccount.getWalletProviders(client);
+    // This is to avoid returning the wallet providers that are connected via different means
+    // than by the "connect" method — like the Dynamic Waas providers, AA providers, or WalletConnect providers.
     const filteredWalletProviders = allWalletProviders.filter((walletProvider)=>Boolean(walletProvider.connect));
     return filteredWalletProviders.map((walletProvider)=>({
             chain: walletProvider.chain,
             groupKey: walletProvider.groupKey,
             key: walletProvider.key,
-            metadata: walletProvider.metadata
+            metadata: walletProvider.metadata,
+            walletProviderType: walletProvider.walletProviderType
         }));
 };
 
@@ -3173,13 +3659,54 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletProviderKey - The unique key of the wallet provider to query.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns An array of connected wallet addresses.
- */ const getConnectedAddresses = ({ walletProviderKey }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const getConnectedAddresses = ({ walletProviderKey }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     return walletProvider.getConnectedAddresses();
 };
 
+const getOwnerWalletAccountForSmartWalletAccount = ({ smartWalletAccount }, client = constants.getDefaultClient())=>{
+    const smartWalletVerifiedCredential = getVerifiedCredentialForWalletAccount.getVerifiedCredentialForWalletAccount({
+        walletAccount: smartWalletAccount
+    }, client);
+    constants.assertDefined(smartWalletVerifiedCredential == null ? void 0 : smartWalletVerifiedCredential.signerRefId, 'Invalid smart wallet account');
+    return getVerifiedCredentialForWalletAccount.getWalletAccounts(client).find((walletAccount)=>walletAccount.verifiedCredentialId === smartWalletVerifiedCredential.signerRefId);
+};
+
+const getWalletAccountAddressByType = ({ type, walletAccount })=>{
+    var _walletAccount_addressesWithTypes_find, _walletAccount_addressesWithTypes;
+    return (_walletAccount_addressesWithTypes = walletAccount.addressesWithTypes) == null ? void 0 : (_walletAccount_addressesWithTypes_find = _walletAccount_addressesWithTypes.find((address)=>address.type === type)) == null ? void 0 : _walletAccount_addressesWithTypes_find.address;
+};
+
+/**
+ * Retrieves data for a specific wallet provider that can be used for display or connection.
+ *
+ * @param params.walletProviderKey - The key of the wallet provider to retrieve data for.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The data for the wallet provider.
+ */ const getWalletProviderDataByKey = ({ walletProviderKey }, client = constants.getDefaultClient())=>{
+    const { chain, groupKey, key, metadata, walletProviderType } = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
+        walletProviderKey
+    }, client);
+    return {
+        chain,
+        groupKey,
+        key,
+        metadata,
+        walletProviderType
+    };
+};
+
+/**
+ * Checks if a wallet account has been verified by a user.
+ *
+ * @param walletAccount - The wallet account to check.
+ * @returns True if the wallet account has been verified, false otherwise.
+ */ const isWalletAccountVerified = ({ walletAccount })=>{
+    return walletAccount.verifiedCredentialId !== null;
+};
+
 /**
  * Retrieves the network configuration data for the currently active network.
  *
@@ -3190,8 +3717,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletAccount - The wallet account to get network data for.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the network data, or undefined if not found.
- */ const getActiveNetworkData = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const getActiveNetworkData = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { networkId } = await walletProvider.getActiveNetworkId();
@@ -3208,8 +3735,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletAccount - The wallet account to get the network ID for.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to the active network ID for the wallet account.
- */ const getActiveNetworkId = ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const getActiveNetworkId = ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     return walletProvider.getActiveNetworkId();
@@ -3224,8 +3751,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletAccount - The wallet account to get the balance for.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an object containing the balance as a string or null.
- */ const getBalance = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const getBalance = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { networkId } = await walletProvider.getActiveNetworkId();
@@ -3249,17 +3776,43 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.networkId - The specific network ID within the chain.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an object containing the balance as a string or null.
- */ const getBalanceForAddress = async ({ address, chain, networkId }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
+ */ const getBalanceForAddress = async ({ address, chain, networkId }, client = constants.getDefaultClient())=>{
     const networkProvider = getNetworkProviderFromNetworkId.getNetworkProviderFromNetworkId({
         chain,
         networkId
     }, client);
-    getChainFromVerifiedCredentialChain.assertDefined(networkProvider, `No network found for chain ${chain} and network id ${networkId}. Please ensure you've enabled this network in the Dashboard.`);
+    constants.assertDefined(networkProvider, `No network found for chain ${chain} and network id ${networkId}. Please ensure you've enabled this network in the Dashboard.`);
     return networkProvider.getBalance({
         address
     });
 };
 
+/**
+ * Retrieves the transaction history for a given wallet address, chain and network.
+ *
+ * This function fetches the transaction history for a specified wallet address and chain,
+ * returning a list of transactions associated with that address along with nextOffset for pagination.
+ *
+ * @param params.address - The wallet address to query transactions for.
+ * @param params.chain - The chain to query transactions for.
+ * @param [params.limit] - The maximum number of transactions to return.
+ * @param params.networkId - The network ID to query transactions for.
+ * @param [params.offset] - The offset to use for pagination.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to the transaction history along with nextOffset for the given wallet address and chain.
+ */ const getTransactionHistory = async (params, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    const response = await apiClient.getWalletTransactions({
+        address: params.address,
+        // eslint-disable-next-line custom-rules/ban-chain-enum
+        chainName: params.chain,
+        environmentId: core.environmentId,
+        networkId: params.networkId
+    });
+    return response;
+};
+
 /**
  * Checks if programmatic network switching is available for a wallet account.
  *
@@ -3269,8 +3822,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletAccount - The wallet account to check network switching support for.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns True if programmatic network switching is available, false otherwise.
- */ const isProgrammaticNetworkSwitchAvailable = ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const isProgrammaticNetworkSwitchAvailable = ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey: walletAccount.walletProviderKey
     }, client);
     return walletProvider.switchActiveNetwork !== undefined;
@@ -3287,8 +3840,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the network switch is complete.
  * @throws NetworkSwitchingUnavailableError If the wallet provider doesn't support network switching.
- */ const switchActiveNetwork = async ({ networkId, walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const switchActiveNetwork = async ({ networkId, walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey: walletAccount.walletProviderKey
     }, client);
     if (walletProvider.switchActiveNetwork === undefined) {
@@ -3305,45 +3858,33 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
     });
 };
 
-/**
- * Get the primary wallet account.
- * The primary wallet account is the one that was last selected by the user.
- * This information is stored in both unverified and verified wallet accounts.
- * This function consolidates this information to determine which wallet was most recently selected.
- */ const getPrimaryWalletAccount = (client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletAccounts = getWalletProviderByKey.getWalletAccounts(client);
-    const sortedLastSelectedWalletAccounts = walletAccounts.filter((walletAccount)=>Boolean(walletAccount.lastSelectedAt)).sort((a, b)=>b.lastSelectedAt.getTime() - a.lastSelectedAt.getTime());
-    if (sortedLastSelectedWalletAccounts.length === 0) {
-        return null;
-    }
-    const [primaryWalletAccount] = sortedLastSelectedWalletAccounts;
-    return primaryWalletAccount;
-};
-
 /**
  * Make the wallet account provided as the primary wallet account.
- */ const selectPrimaryWalletAccount = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
+ */ const selectPrimaryWalletAccount = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     const currentPrimaryWalletAccount = getPrimaryWalletAccount(client);
     if ((currentPrimaryWalletAccount == null ? void 0 : currentPrimaryWalletAccount.id) === walletAccount.id) {
         return;
     }
     if (walletAccount.verifiedCredentialId) {
-        const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+        const apiClient = constants.createApiClient({}, client);
         const response = await apiClient.selectUserWallet({
             environmentId: core.environmentId,
             userWalletSelectionRequest: {
                 walletId: walletAccount.verifiedCredentialId
             }
         });
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
     } else {
-        setUnverifiedWalletAccount({
-            unverifiedWalletAccountToUpdate: getChainFromVerifiedCredentialChain._extends({}, walletAccount, {
-                lastSelectedAt: new Date()
-            })
+        const updatedWalletAccount = constants._extends({}, walletAccount, {
+            lastSelectedAt: new Date()
+        });
+        getNetworkProviderFromNetworkId.setUnverifiedWalletAccounts({
+            unverifiedWalletAccountsToUpdate: [
+                updatedWalletAccount
+            ]
         }, client);
     }
 };
@@ -3358,9 +3899,22 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletAccount - The wallet account to remove.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves when the wallet account is successfully removed.
- */ const removeWalletAccount = async ({ walletAccount }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const core = getChainFromVerifiedCredentialChain.getCore(client);
-    const apiClient = getChainFromVerifiedCredentialChain.createApiClient({}, client);
+ */ const removeWalletAccount = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
+    try {
+        const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
+            walletAccount
+        }, client);
+        await (walletProvider.disconnectWalletAccount == null ? void 0 : walletProvider.disconnectWalletAccount.call(walletProvider, {
+            walletAccount
+        }));
+    } catch (error) {
+        if (error instanceof getVerifiedCredentialForWalletAccount.NoWalletProviderFoundError) {
+            return;
+        }
+        throw error;
+    }
     if (!walletAccount.verifiedCredentialId) {
         removeUnverifiedWalletAccount({
             unverifiedWalletAccount: walletAccount
@@ -3373,7 +3927,7 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
             walletId: walletAccount.verifiedCredentialId
         }
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
 };
@@ -3388,8 +3942,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.message - The message to sign.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A promise that resolves to an object containing the signature.
- */ const signMessage = async ({ walletAccount, message }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderFromWalletAccount({
+ */ const signMessage = async ({ walletAccount, message }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'signMessage');
@@ -3412,8 +3966,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.chain - The blockchain the wallet belongs to.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns The matching wallet account, or undefined if not found.
- */ const getWalletAccountFromAddress = ({ address, chain }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletAccounts = getWalletProviderByKey.getWalletAccounts(client);
+ */ const getWalletAccountFromAddress = ({ address, chain }, client = constants.getDefaultClient())=>{
+    const walletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts(client);
     return walletAccounts.find((walletAccount)=>walletAccount.address === address && walletAccount.chain === chain);
 };
 
@@ -3426,8 +3980,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.event - The event name to remove the listener from.
  * @param params.walletProviderKey - The unique key identifying the wallet provider to remove the listener from.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- */ const offWalletProviderEvent = ({ callback, event, walletProviderKey }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const offWalletProviderEvent = ({ callback, event, walletProviderKey }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'events');
@@ -3444,8 +3998,8 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
  * @param params.walletProviderKey - The unique key identifying the wallet provider to listen to.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns A function that can be called to remove the listener.
- */ const onWalletProviderEvent = ({ callback, event, walletProviderKey }, client = getChainFromVerifiedCredentialChain.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const onWalletProviderEvent = ({ callback, event, walletProviderKey }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'events');
@@ -3458,40 +4012,67 @@ const isSameAddress = (left, right, chain)=>getWalletProviderByKey.normalizeAddr
     };
 };
 
-assertPackageVersion.assertPackageVersion(getChainFromVerifiedCredentialChain.name, getChainFromVerifiedCredentialChain.version);
+/* eslint-disable no-useless-escape */ /* eslint-disable no-restricted-globals */ /**
+ * Sourced from http://detectmobilebrowsers.com/
+ */ const userAgentRegex1 = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ios|ipad|playbook|silk/i;
+const userAgentRegex2 = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i;
+// This is a regex that covers both iphone, android and any other mobile device.
+const isMobile = (maxTouchPointsOverride)=>{
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        return false;
+    }
+    return userAgentRegex1.test(navigator.userAgent) || userAgentRegex2.test(navigator.userAgent.substring(0, 4)) || isIPad(maxTouchPointsOverride) || isIPhone();
+};
+const isIPhone = ()=>typeof window === 'undefined' || typeof navigator === 'undefined' ? false : /iPhone|ios/.test(navigator.userAgent);
+/**
+ * @param [optional] maxTouchPointsOverride - this is used for testing since
+ * it seems that JSDOM doesn't support maxTouchPoints, so it was impossible
+ * to mock it
+ */ const isIPad = (maxTouchPointsOverride)=>{
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        return false;
+    }
+    const maxTouchPoints = maxTouchPointsOverride || navigator.maxTouchPoints;
+    return /iPad/.test(navigator.userAgent) || /Mac/.test(navigator.userAgent) && maxTouchPoints === 5;
+};
+
+assertPackageVersion.assertPackageVersion(constants.name, constants.version);
 
-exports.BaseError = getChainFromVerifiedCredentialChain.BaseError;
-exports.InvalidExternalAuthError = getChainFromVerifiedCredentialChain.InvalidExternalAuthError;
-exports.MfaInvalidOtpError = getChainFromVerifiedCredentialChain.MfaInvalidOtpError;
-exports.MfaRateLimitedError = getChainFromVerifiedCredentialChain.MfaRateLimitedError;
-exports.SandboxMaximumThresholdReachedError = getChainFromVerifiedCredentialChain.SandboxMaximumThresholdReachedError;
-exports.getDefaultClient = getChainFromVerifiedCredentialChain.getDefaultClient;
+exports.BaseError = constants.BaseError;
+exports.InvalidExternalAuthError = constants.InvalidExternalAuthError;
+exports.MfaInvalidOtpError = constants.MfaInvalidOtpError;
+exports.MfaRateLimitedError = constants.MfaRateLimitedError;
+exports.SandboxMaximumThresholdReachedError = constants.SandboxMaximumThresholdReachedError;
+exports.getDefaultClient = constants.getDefaultClient;
 Object.defineProperty(exports, "MFAAction", {
   enumerable: true,
   get: function () { return sdkApiCore.MFAAction; }
 });
 exports.NoNetworkProvidersError = getNetworkProviderFromNetworkId.NoNetworkProvidersError;
+exports.WalletAlreadyLinkedToAnotherUserError = getNetworkProviderFromNetworkId.WalletAlreadyLinkedToAnotherUserError;
 exports.getNetworksData = getNetworkProviderFromNetworkId.getNetworksData;
 exports.hasExtension = getNetworkProviderFromNetworkId.hasExtension;
 exports.isCaptchaRequired = getNetworkProviderFromNetworkId.isCaptchaRequired;
 exports.setCaptchaToken = getNetworkProviderFromNetworkId.setCaptchaToken;
-exports.getWalletAccounts = getWalletProviderByKey.getWalletAccounts;
-exports.offEvent = getWalletProviderByKey.offEvent;
-exports.onEvent = getWalletProviderByKey.onEvent;
-exports.onceEvent = getWalletProviderByKey.onceEvent;
+exports.getWalletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts;
+exports.offEvent = getVerifiedCredentialForWalletAccount.offEvent;
+exports.onEvent = getVerifiedCredentialForWalletAccount.onEvent;
+exports.onceEvent = getVerifiedCredentialForWalletAccount.onceEvent;
 exports.consumeMfaToken = isMfaRequiredForAction.consumeMfaToken;
 exports.getMfaMethods = isMfaRequiredForAction.getMfaMethods;
 exports.isMfaRequiredForAction = isMfaRequiredForAction.isMfaRequiredForAction;
+exports.NotWaasWalletAccountError = NotWaasWalletAccountError.NotWaasWalletAccountError;
+exports.refreshUser = NotWaasWalletAccountError.refreshUser;
 exports.InvalidParamError = InvalidParamError.InvalidParamError;
-exports.NotWaasWalletAccountError = refreshUser.NotWaasWalletAccountError;
-exports.refreshUser = refreshUser.refreshUser;
 exports.ClientAlreadyInitializedError = ClientAlreadyInitializedError;
 exports.InvalidRedirectStorageStateError = InvalidRedirectStorageStateError;
 exports.MissingRedirectStorageStateError = MissingRedirectStorageStateError;
 exports.MissingSocialUrlParamError = MissingSocialUrlParamError;
+exports.MissingUserVerificationError = MissingUserVerificationError;
 exports.NetworkSwitchingUnavailableError = NetworkSwitchingUnavailableError;
 exports.NoAddressFoundError = NoAddressFoundError;
 exports.NoPasskeyCredentialsFoundError = NoPasskeyCredentialsFoundError;
+exports.NoSmartWalletAccountSignerFoundError = NoSmartWalletAccountSignerFoundError;
 exports.NoWebAuthNSupportError = NoWebAuthNSupportError;
 exports.UnavailableInServerSideError = UnavailableInServerSideError;
 exports.UnrecognizedNetworkError = UnrecognizedNetworkError;
@@ -3499,21 +4080,25 @@ exports.UserNotAuthenticatedError = UserNotAuthenticatedError;
 exports.UserRejectedError = UserRejectedError;
 exports.WalletAccountAlreadyVerifiedError = WalletAccountAlreadyVerifiedError;
 exports.WalletAccountNotSelectedError = WalletAccountNotSelectedError;
-exports.WalletAlreadyLinkedToAnotherUserError = WalletAlreadyLinkedToAnotherUserError;
 exports.WalletProviderMethodUnavailableError = WalletProviderMethodUnavailableError;
 exports.acknowledgeRecoveryCodes = acknowledgeRecoveryCodes;
+exports.addCoinbaseOnrampOrderEventListener = addCoinbaseOnrampOrderEventListener;
 exports.assertWalletAccountSigningAvailability = assertWalletAccountSigningAvailability;
 exports.assertWalletProviderMethodDefined = assertWalletProviderMethodDefined;
 exports.authenticateMfaRecoveryCode = authenticateMfaRecoveryCode;
 exports.authenticatePasskeyMFA = authenticatePasskeyMFA;
 exports.authenticateTotpMfaDevice = authenticateTotpMfaDevice;
-exports.completeSocialRedirectSignIn = completeSocialRedirectSignIn;
+exports.authenticateWithSocial = authenticateWithSocial;
+exports.completeSocialAuthentication = completeSocialAuthentication;
 exports.connectAndVerifyWithWalletProvider = connectAndVerifyWithWalletProvider;
 exports.connectWithWalletProvider = connectWithWalletProvider;
+exports.createCoinbaseOnrampOrder = createCoinbaseOnrampOrder;
+exports.createCryptoDotComPayment = createCryptoDotComPayment;
 exports.createDynamicClient = createDynamicClient;
 exports.createNewMfaRecoveryCodes = createNewMfaRecoveryCodes;
 exports.deleteMfaDevice = deleteMfaDevice;
 exports.deletePasskey = deletePasskey;
+exports.deleteUser = deleteUser;
 exports.detectOAuthRedirect = detectOAuthRedirect;
 exports.fetchProjectSettings = fetchProjectSettings;
 exports.getActiveNetworkData = getActiveNetworkData;
@@ -3521,18 +4106,27 @@ exports.getActiveNetworkId = getActiveNetworkId;
 exports.getAvailableWalletProvidersData = getAvailableWalletProvidersData;
 exports.getBalance = getBalance;
 exports.getBalanceForAddress = getBalanceForAddress;
+exports.getCoinbaseBuyUrl = getCoinbaseBuyUrl;
 exports.getConnectedAddresses = getConnectedAddresses;
 exports.getMfaDevices = getMfaDevices;
 exports.getMfaRecoveryCodes = getMfaRecoveryCodes;
+exports.getMissingVerificationForCoinbaseOnrampOrder = getMissingVerificationForCoinbaseOnrampOrder;
 exports.getMultichainBalances = getMultichainBalances;
+exports.getOwnerWalletAccountForSmartWalletAccount = getOwnerWalletAccountForSmartWalletAccount;
 exports.getPasskeys = getPasskeys;
 exports.getPrimaryWalletAccount = getPrimaryWalletAccount;
+exports.getTransactionHistory = getTransactionHistory;
+exports.getUserSocialAccounts = getUserSocialAccounts;
+exports.getWalletAccountAddressByType = getWalletAccountAddressByType;
 exports.getWalletAccountFromAddress = getWalletAccountFromAddress;
+exports.getWalletProviderDataByKey = getWalletProviderDataByKey;
 exports.initializeClient = initializeClient;
+exports.isMobile = isMobile;
 exports.isPendingRecoveryCodesAcknowledgment = isPendingRecoveryCodesAcknowledgment;
 exports.isProgrammaticNetworkSwitchAvailable = isProgrammaticNetworkSwitchAvailable;
 exports.isSignedIn = isSignedIn;
 exports.isUserMissingMfaAuth = isUserMissingMfaAuth;
+exports.isWalletAccountVerified = isWalletAccountVerified;
 exports.logout = logout;
 exports.offWalletProviderEvent = offWalletProviderEvent;
 exports.onWalletProviderEvent = onWalletProviderEvent;
@@ -3546,9 +4140,10 @@ exports.sendSmsOTP = sendSmsOTP;
 exports.setDefaultMfaDevice = setDefaultMfaDevice;
 exports.signInWithExternalJwt = signInWithExternalJwt;
 exports.signInWithPasskey = signInWithPasskey;
-exports.signInWithSocialRedirect = signInWithSocialRedirect;
 exports.signMessage = signMessage;
 exports.switchActiveNetwork = switchActiveNetwork;
+exports.unlinkSocialAccount = unlinkSocialAccount;
 exports.updateUser = updateUser;
 exports.verifyOTP = verifyOTP;
 exports.verifyWalletAccount = verifyWalletAccount;
+exports.waitForClientInitialized = waitForClientInitialized;