@dynamic-labs-sdk/client 0.1.0-alpha.9 → 0.1.1

package/index.cjs.js

@@ -1,16 +1,16 @@
 'use strict';
 
 var assertPackageVersion = require('@dynamic-labs-sdk/assert-package-version');
-var logout = require('./logout.cjs.js');
+var constants = require('./constants.cjs.js');
 var sdkApiCore = require('@dynamic-labs/sdk-api-core');
 var getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId.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 getWalletProviderByKey = require('./getWalletProviderByKey.cjs.js');
-var isMfaRequiredForAction = require('./isMfaRequiredForAction.cjs.js');
 require('buffer');
 
 function _interopNamespaceDefault(e) {
@@ -46,6 +46,163 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
     user: 'userChanged'
 };
 
+/**
+ * This error is thrown when the `retryOnFail` function is called with an invalid
+ * number of retries (i.e. less than 0).
+ */ class InvalidRetryOnFailCallError extends constants.BaseError {
+    constructor(maxRetries){
+        super({
+            cause: null,
+            code: 'invalid_retry_on_fail_call_error',
+            docsUrl: null,
+            name: 'InvalidRetryOnFailCallError',
+            shortMessage: `Invalid retries parameter for retryOnFail call: ${maxRetries}`
+        });
+    }
+}
+
+const retryOnFail = async ({ delay = 0, fn, maxRetries })=>{
+    for(let retry = 0; retry <= maxRetries; retry++){
+        try {
+            return await fn();
+        } catch (error) {
+            if (retry >= maxRetries) {
+                throw error;
+            }
+            if (delay > 0) {
+                await new Promise((resolve)=>setTimeout(resolve, delay));
+            }
+        }
+    }
+    /**
+   * Reaching this point should never happen and this
+   * error is thrown to help us debug the issue.
+   */ throw new InvalidRetryOnFailCallError(maxRetries);
+};
+
+/**
+ * Checks if the user is currently signed in to the Dynamic client.
+ *
+ * The client is considered to be in a signed in state if a user has
+ * authenticated or if the client has at least one wallet connected.
+ *
+ * @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 = constants.getDefaultClient())=>Boolean(client.user || getVerifiedCredentialForWalletAccount.getWalletAccounts(client).length > 0);
+
+/**
+ * The schema to track the expiration time of the project settings.
+ */ const projectSettingsExpirationStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
+    key: 'projectSettingsExpiration',
+    schema: z__namespace.number()
+});
+
+/**
+ * Expiration time of the project settings in milliseconds.
+ */ const PROJECT_SETTINGS_EXPIRATION_TIME = 1000 * 60 * 5; // 5 minutes
+/**
+ * Fetches and updates the project settings from the API.
+ *
+ * This function retrieves the latest project configuration settings
+ * from Dynamic's servers, including authentication options, enabled chains,
+ * and security configurations. The settings are cached for performance.
+ *
+ * @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 = 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.
+    // This avoids unnecessary API calls and speeds up the initial load.
+    if (hasProjectSettings && !isExpired && isSignedIn(client)) {
+        return client.projectSettings;
+    }
+    const apiClient = constants.createApiClient({}, client);
+    core.logger.debug('[fetchProjectSettings] Fetching project settings...');
+    const doFetch = async ()=>apiClient.getEnvironmentSettings({
+            environmentId: core.environmentId,
+            sdkVersion: `${constants.CLIENT_SDK_NAME}/${core.version}`
+        }, {
+            credentials: 'omit'
+        });
+    const projectSettings = await retryOnFail({
+        fn: doFetch,
+        maxRetries: 2
+    });
+    core.state.set({
+        projectSettings: projectSettings != null ? projectSettings : null
+    });
+    await core.storage.setItem(projectSettingsExpirationStorageKeySchema, Date.now() + PROJECT_SETTINGS_EXPIRATION_TIME);
+    return projectSettings;
+};
+
+/**
+ * Takes a base64url-encoded string (e.g. "nMueRPiAm51YXEjRtka8S_8Ura3HaqbmqDqMJCZmvkM")
+ * and return the corresponding bytes, as an array buffer.
+ */ const base64UrlDecode = (s)=>{
+    // Go from base64url encoding to base64 encoding
+    s = (s == null ? void 0 : s.replace(/-/g, '+').replace(/_/g, '/')) || '';
+    // use `atob` to decode base64
+    return Uint8Array.from(atob(s), (c)=>c.charCodeAt(0));
+};
+
+/**
+ * Accepts a public key array buffer, and returns a buffer with the compressed version of the public key
+ */ const compressRawPublicKey = (rawPublicKey)=>{
+    const rawPublicKeyBytes = new Uint8Array(rawPublicKey);
+    const len = rawPublicKeyBytes.byteLength;
+    // Drop the y coordinate
+    const compressedBytes = rawPublicKeyBytes.slice(0, 1 + len >>> 1);
+    // Encode the parity of `y` in first bit
+    compressedBytes[0] = 0x2 | rawPublicKeyBytes[len - 1] & 0x01;
+    return compressedBytes.buffer;
+};
+
+const p256Keygen = async ()=>{
+    // Create a new P-256 keypair
+    const p256Keypair = await crypto.subtle.generateKey({
+        name: 'ECDSA',
+        namedCurve: 'P-256'
+    }, true, [
+        'sign',
+        'verify'
+    ]);
+    // Export the raw public key. By default this will export in uncompressed format
+    const rawPublicKey = await crypto.subtle.exportKey('raw', p256Keypair.publicKey);
+    // We need to export with JWK format because exporting EC private keys with "raw" isn't supported
+    const privateKeyJwk = await crypto.subtle.exportKey('jwk', p256Keypair.privateKey);
+    const compressedPublicKeyBuffer = compressRawPublicKey(rawPublicKey);
+    const privateKeyBuffer = base64UrlDecode(privateKeyJwk.d);
+    return {
+        private: isMfaRequiredForAction.bufferToHex(privateKeyBuffer),
+        privateJwk: privateKeyJwk,
+        public: isMfaRequiredForAction.bufferToHex(compressedPublicKeyBuffer)
+    };
+};
+
+const generateSessionKeys = async (client)=>{
+    const { private: privateKey, public: publicKey, privateJwk: privateKeyJwk } = await p256Keygen();
+    const core = constants.getCore(client);
+    // stringify and encode the session keys to store in storage
+    const stringifiedSessionKeys = JSON.stringify({
+        privateKey,
+        privateKeyJwk,
+        publicKey,
+        registered: false
+    });
+    const encodedSessionKeys = constants.getBuffer().from(stringifiedSessionKeys).toString('base64');
+    core.state.set({
+        sessionKeys: encodedSessionKeys
+    });
+    return {
+        privateKey,
+        privateKeyJwk,
+        publicKey
+    };
+};
+
 /**
  * Creates a new runtime services instance that manages service registration and retrieval.
  *
@@ -59,6 +216,92 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
     };
 };
 
+const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
+    const core = constants.getCore(client);
+    const walletProvidersMap = new Map();
+    const walletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts(client);
+    walletAccounts.forEach((walletAccount)=>{
+        if (walletProvidersMap.has(walletAccount.walletProviderKey)) {
+            return;
+        }
+        try {
+            const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
+                walletAccount
+            }, client);
+            walletProvidersMap.set(walletAccount.walletProviderKey, walletProvider);
+        } catch (error) {
+            core.logger.debug('Wallet provider not found for wallet account', {
+                error,
+                walletAccount: walletAccount.address
+            });
+        }
+    });
+    return Array.from(walletProvidersMap.values());
+};
+
+/**
+ * Disconnect and terminate each wallet provider, if available.
+ */ const disconnectAndTerminateWalletProviders = async (client)=>{
+    const core = constants.getCore(client);
+    const walletProviders = getAvailableWalletProvidersFromWalletAccounts(client);
+    await Promise.all(walletProviders.map(async (walletProvider)=>{
+        if (walletProvider.terminate) {
+            await walletProvider.terminate();
+        }
+        if (walletProvider.disconnect) {
+            try {
+                await walletProvider.disconnect();
+            } catch (err) {
+                core.logger.error(`Error disconnecting from wallet ${walletProvider.key}`, err);
+            }
+        }
+    }));
+};
+
+/**
+ * Logs out the current user and clears all authentication data.
+ *
+ * @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 = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    core.logger.debug('[logout] Logging out...');
+    await disconnectAndTerminateWalletProviders(client);
+    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
+    });
+    getVerifiedCredentialForWalletAccount.emitEvent({
+        event: 'logout'
+    }, client);
+    // Refetch project settings
+    void fetchProjectSettings(client);
+    // Regenerate session keys
+    void generateSessionKeys(client);
+};
+
 /**
  * A replacement for setTimeout that supports delays longer than 2147483647ms (~24.8 days).
  */ const setLongTimeout = (callback, delay)=>{
@@ -87,7 +330,7 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 /**
  * Sets up a timeout to log out the user when their token expires.
  */ const initializeAuth = (client)=>{
-    const core = logout.getCore(client);
+    const core = constants.getCore(client);
     let clearExpirationTimeout = null;
     const onChangeExpiration = getNetworkProviderFromNetworkId.subscribeWithSelector(core.state, (state)=>state.sessionExpiresAt);
     const checkExpiration = ()=>{
@@ -99,7 +342,7 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
         const now = new Date();
         const timeUntilExpiration = expiration.getTime() - now.getTime();
         if (timeUntilExpiration <= 0) {
-            void logout.logout(client);
+            void logout(client);
             return;
         }
         // Wait for token expiration
@@ -110,13 +353,13 @@ var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 };
 
 const raiseStateEvents = (client)=>{
-    const core = logout.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;
-            logout.emitEvent({
+            getVerifiedCredentialForWalletAccount.emitEvent({
                 args: {
                     [key]: value[key]
                 },
@@ -126,17 +369,32 @@ const raiseStateEvents = (client)=>{
     });
 };
 
-const SDK_API_CORE_VERSION = logout.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 = logout.createStorageKeySchema({
+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 = logout.createStorageKeySchema({
+const sessionStorageKeySchema = getNetworkProviderFromNetworkId.createStorageKeySchema({
     key: 'session',
     schema: z__namespace.object({
         /**
@@ -163,10 +421,11 @@ const sessionKeySchema = logout.createStorageKeySchema({
 });
 
 const hydrateStateWithStorage = async (client)=>{
-    const core = logout.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;
@@ -179,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 = logout.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,
@@ -207,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
         });
     });
 };
@@ -221,7 +492,7 @@ const initializeStorageSync = async (client)=>{
     syncStateWithStorage(client);
 };
 
-class ClientAlreadyInitializedError extends logout.BaseError {
+class ClientAlreadyInitializedError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -245,8 +516,9 @@ class ClientAlreadyInitializedError extends logout.BaseError {
  * @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 = logout.getDefaultClient())=>{
-    const core = logout.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();
     }
@@ -258,14 +530,14 @@ class ClientAlreadyInitializedError extends logout.BaseError {
     const initializeStorageSyncPromise = initializeStorageSync(client);
     const fetchProjectSettingsPromise = initializeStorageSyncPromise.then(async ()=>{
         if (!core.state.get().projectSettings) {
-            await logout.fetchProjectSettings(client);
+            await fetchProjectSettings(client);
         }
     });
     /**
    * Generate session keys if they don't exist
    */ const generateSessionKeysPromise = fetchProjectSettingsPromise.then(async ()=>{
         if (!core.state.get().sessionKeys) {
-            await logout.generateSessionKeys(client);
+            await generateSessionKeys(client);
         }
     });
     /**
@@ -280,24 +552,38 @@ class ClientAlreadyInitializedError extends logout.BaseError {
    * 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 ()=>{
-        if (logout.isCookieEnabled(client)) {
-            await NotWaasWalletAccountError.refreshUser(client);
+        /**
+       * 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: 'refresh-user-state-from-cookie',
+        name: getNetworkProviderFromNetworkId.REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY,
         promise: refreshUserStateFromCookiePromise
     });
     try {
@@ -347,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();
     };
@@ -357,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),
@@ -381,7 +676,7 @@ const createDeferredPromise = ()=>{
 
 const createEventEmitter = ()=>new EventEmitter();
 
-class UnavailableInServerSideError extends logout.BaseError {
+class UnavailableInServerSideError extends constants.BaseError {
     constructor(unavailableFeature){
         super({
             cause: null,
@@ -435,7 +730,64 @@ class UnavailableInServerSideError extends logout.BaseError {
         register: (options)=>browser.startRegistration(options)
     });
 
-class InvalidStorageValue extends logout.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,
@@ -534,7 +886,8 @@ class InvalidStorageValue extends logout.BaseError {
         sessionKeys: null,
         token: null,
         unverifiedWalletAccounts: [],
-        user: null
+        user: null,
+        walletProviderKeyMap: {}
     });
 
 /**
@@ -544,7 +897,9 @@ class InvalidStorageValue extends logout.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}`,
@@ -557,6 +912,7 @@ class InvalidStorageValue extends logout.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();
@@ -565,6 +921,7 @@ class InvalidStorageValue extends logout.BaseError {
     var _config_coreConfig_getApiHeaders;
     return {
         apiBaseUrl,
+        debouncedMutex,
         environmentId: config.environmentId,
         eventEmitter,
         extensions: new Set(),
@@ -579,7 +936,7 @@ class InvalidStorageValue extends logout.BaseError {
         runtimeServices,
         state,
         storage,
-        version: logout.version
+        version: constants.version
     };
 };
 
@@ -622,15 +979,20 @@ class InvalidStorageValue extends logout.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);
     }
-    logout.setDefaultClient(client);
+    constants.setDefaultClient(client);
     return client;
 };
 
-class InvalidRedirectStorageStateError extends logout.BaseError {
+class InvalidRedirectStorageStateError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -642,7 +1004,7 @@ class InvalidRedirectStorageStateError extends logout.BaseError {
     }
 }
 
-class MissingRedirectStorageStateError extends logout.BaseError {
+class MissingRedirectStorageStateError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -654,7 +1016,7 @@ class MissingRedirectStorageStateError extends logout.BaseError {
     }
 }
 
-class MissingSocialUrlParamError extends logout.BaseError {
+class MissingSocialUrlParamError extends constants.BaseError {
     constructor(param){
         super({
             cause: null,
@@ -666,7 +1028,20 @@ class MissingSocialUrlParamError extends logout.BaseError {
     }
 }
 
-class NetworkSwitchingUnavailableError extends logout.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({
@@ -683,7 +1058,7 @@ class NetworkSwitchingUnavailableError extends logout.BaseError {
     }
 }
 
-class NoAddressFoundError extends logout.BaseError {
+class NoAddressFoundError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -695,7 +1070,7 @@ class NoAddressFoundError extends logout.BaseError {
     }
 }
 
-class NoPasskeyCredentialsFoundError extends logout.BaseError {
+class NoPasskeyCredentialsFoundError extends constants.BaseError {
     constructor(){
         super({
             cause: null,
@@ -707,7 +1082,19 @@ class NoPasskeyCredentialsFoundError extends logout.BaseError {
     }
 }
 
-class NoWebAuthNSupportError extends logout.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,
@@ -719,7 +1106,7 @@ class NoWebAuthNSupportError extends logout.BaseError {
     }
 }
 
-class UnrecognizedNetworkError extends logout.BaseError {
+class UnrecognizedNetworkError extends constants.BaseError {
     constructor({ networkId, originalError, walletProviderKey }){
         const cause = originalError instanceof Error ? originalError : null;
         super({
@@ -735,7 +1122,7 @@ class UnrecognizedNetworkError extends logout.BaseError {
     }
 }
 
-class UserNotAuthenticatedError extends logout.BaseError {
+class UserNotAuthenticatedError extends constants.BaseError {
     constructor({ shortMessage } = {}){
         super({
             cause: null,
@@ -747,7 +1134,7 @@ class UserNotAuthenticatedError extends logout.BaseError {
     }
 }
 
-class UserRejectedError extends logout.BaseError {
+class UserRejectedError extends constants.BaseError {
     constructor({ action }){
         super({
             cause: null,
@@ -759,7 +1146,7 @@ class UserRejectedError extends logout.BaseError {
     }
 }
 
-class WalletAccountAlreadyVerifiedError extends logout.BaseError {
+class WalletAccountAlreadyVerifiedError extends constants.BaseError {
     constructor(address){
         super({
             cause: null,
@@ -771,33 +1158,22 @@ class WalletAccountAlreadyVerifiedError extends logout.BaseError {
     }
 }
 
-class WalletAccountNotSelectedError extends logout.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 logout.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 logout.BaseError {
+class WalletProviderMethodUnavailableError extends constants.BaseError {
     constructor({ methodName, walletProviderKey }){
         super({
             cause: null,
@@ -818,9 +1194,9 @@ class WalletProviderMethodUnavailableError extends logout.BaseError {
  * @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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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: {
@@ -828,7 +1204,7 @@ class WalletProviderMethodUnavailableError extends logout.BaseError {
             sessionPublicKey
         }
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     return response;
@@ -840,9 +1216,9 @@ class WalletProviderMethodUnavailableError extends logout.BaseError {
  * @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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({
+ */ const deletePasskey = async ({ passkeyId }, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({
         includeMfaToken: true
     }, client);
     await apiClient.deletePasskey({
@@ -861,9 +1237,9 @@ class WalletProviderMethodUnavailableError extends logout.BaseError {
  *
  * @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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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
     });
@@ -871,21 +1247,22 @@ class WalletProviderMethodUnavailableError extends logout.BaseError {
 };
 
 const getPasskeyRegistrationOptions = async (client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const options = await apiClient.getPasskeyRegistrationOptions({
         environmentId: core.environmentId
     });
     return options;
 };
 
-const serverRegisterPasskey = async ({ registration }, client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+const serverRegisterPasskey = async ({ registration, createMfaToken }, client)=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.registerPasskey({
         environmentId: core.environmentId,
-        passkeyRegisterRequest: logout._extends({}, registration, {
-            response: logout._extends({}, registration.response, {
+        passkeyRegisterRequest: constants._extends({}, registration, {
+            createMfaToken,
+            response: constants._extends({}, registration.response, {
                 clientDataJson: registration.response.clientDataJSON
             })
         })
@@ -900,11 +1277,12 @@ const serverRegisterPasskey = async ({ registration }, client)=>{
  * passwordless authentication. The user will be prompted to create a passkey
  * using their device's biometric authentication or security key.
  *
+ * @param [params.createMfaToken] - 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 registration response.
  * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
- */ const registerPasskey = async (client = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
+ */ const registerPasskey = async ({ createMfaToken } = {}, client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     if (!core.passkey.isSupported()) {
         throw new NoWebAuthNSupportError();
     }
@@ -913,31 +1291,33 @@ const serverRegisterPasskey = async ({ registration }, client)=>{
         optionsJSON: options
     });
     const response = await serverRegisterPasskey({
+        createMfaToken,
         registration
     }, client);
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
     return response;
 };
 
-const getPasskeyAuthenticationSignInOptions = async (client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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 = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.signinWithPasskey({
         environmentId: core.environmentId,
-        passkeyAuthRequest: logout._extends({}, authentication, {
+        passkeyAuthRequest: constants._extends({}, authentication, {
             createMfaToken,
-            response: logout._extends({}, authentication.response, {
+            response: constants._extends({}, authentication.response, {
                 clientDataJson: authentication.response.clientDataJSON
             })
         })
@@ -955,107 +1335,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 = logout.getDefaultClient())=>{
-    const core = logout.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 = logout._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 = logout.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.
- *
- * This function processes the OAuth callback URL with authorization codes
- * and completes the user authentication with the social provider.
+ * Retrieves all social accounts associated with the current user.
  *
- * @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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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 = logout.getDefaultClient())=>{
-    const core = logout.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);
@@ -1077,9 +1417,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)=>{
-    logout.assertDefined(provider.clientId, 'Client ID not found');
-    logout.assertDefined(provider.provider, 'Provider type not found');
-    logout.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');
@@ -1103,15 +1443,15 @@ const APPLE_RESPONSE_TYPE = 'code id_token';
 };
 
 /** Helper function to build the OAuth base URL for a given provider. */ const getOAuthBaseUrl = (provider)=>{
-    logout.assertDefined(provider.provider, 'Provider type not found');
+    constants.assertDefined(provider.provider, 'Provider type not found');
     const providerType = provider.provider;
     if (providerType === sdkApiCore.ProviderEnum.Telegram) {
-        logout.assertDefined(provider.authorizationUrl, 'Telegram authorization URL not found');
+        constants.assertDefined(provider.authorizationUrl, 'Telegram authorization URL not found');
         return new URL(provider.authorizationUrl);
     }
-    logout.assertDefined(provider.baseAuthUrl, 'Base auth URL not found');
+    constants.assertDefined(provider.baseAuthUrl, 'Base auth URL not found');
     if (providerType === sdkApiCore.ProviderEnum.Shopify) {
-        logout.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);
     }
@@ -1125,17 +1465,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
-    logout.assertDefined(projectSettings, 'Project settings not found');
-    logout.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);
-    logout.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 = logout.randomString(32);
-    const codeVerifier = logout.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) {
@@ -1156,25 +1496,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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
@@ -1182,6 +1524,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.
  *
@@ -1191,9 +1663,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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
@@ -1201,13 +1673,239 @@ 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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
+ */ const waitForClientInitialized = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
     await core.initTrack.waitForAll();
 };
 
@@ -1221,16 +1919,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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) {
@@ -1258,7 +1956,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 = logout.getDefaultClient())=>{
+ */ const acknowledgeRecoveryCodes = async (client = constants.getDefaultClient())=>{
     return updateUser({
         userFields: {
             mfaBackupCodeAcknowledgement: sdkApiCore.MfaBackupCodeAcknowledgement.Complete
@@ -1275,9 +1973,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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,
@@ -1286,10 +1984,10 @@ const providersRequiringPkce = [
                 createMfaToken: createMfaTokenOptions
             }
         });
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 mfaToken: response.mfaToken
             },
@@ -1297,7 +1995,7 @@ const providersRequiringPkce = [
         }, client);
         return response;
     } catch (error) {
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 error
             },
@@ -1307,23 +2005,24 @@ const providersRequiringPkce = [
     }
 };
 
-const getPasskeyAuthenticationOptions = async (client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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 = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const response = await apiClient.authenticateMfaPasskeyDevice({
         environmentId: core.environmentId,
-        passkeyAuthRequest: logout._extends({}, authentication, {
+        passkeyAuthRequest: constants._extends({}, authentication, {
             createMfaToken,
-            response: logout._extends({}, authentication.response, {
+            response: constants._extends({}, authentication.response, {
                 clientDataJson: authentication.response.clientDataJSON
             })
         })
@@ -1342,22 +2041,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 = logout.getDefaultClient())=>{
-    const core = logout.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)=>logout._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 = logout._extends({}, options, {
+        const formattedOptions = constants._extends({}, options, {
             allowCredentials
         });
         const authentication = await core.passkey.authenticate({
@@ -1367,10 +2068,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
             authentication,
             createMfaToken
         }, client);
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 mfaToken: response.mfaToken
             },
@@ -1378,7 +2079,7 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
         }, client);
         return response;
     } catch (error) {
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 error
             },
@@ -1399,9 +2100,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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,
@@ -1411,10 +2112,10 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
                 id: deviceId
             }
         });
-        getWalletProviderByKey.updateAuthFromVerifyResponse({
+        getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
             response
         }, client);
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 deviceId,
                 mfaToken: response.mfaToken
@@ -1423,7 +2124,7 @@ const serverAuthenticatePasskey = async ({ authentication, createMfaToken }, cli
         }, client);
         return response;
     } catch (error) {
-        logout.emitEvent({
+        getVerifiedCredentialForWalletAccount.emitEvent({
             args: {
                 deviceId,
                 error
@@ -1442,9 +2143,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+ */ const createNewMfaRecoveryCodes = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.createNewRecoveryCodes({
         environmentId: core.environmentId
     });
@@ -1460,11 +2161,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
-    logout.assertDefined(deviceId, 'deviceId is required');
-    logout.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,
@@ -1480,9 +2181,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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
     });
@@ -1499,9 +2200,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+ */ const getMfaRecoveryCodes = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.getRecoveryCodes({
         environmentId: core.environmentId
     });
@@ -1515,9 +2216,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 = logout.getDefaultClient())=>{
+ */ const isPendingRecoveryCodesAcknowledgment = (client = constants.getDefaultClient())=>{
     const user = client.user;
-    logout.assertDefined(user, 'User not logged in');
+    constants.assertDefined(user, 'User not logged in');
     return user.mfaBackupCodeAcknowledgement !== sdkApiCore.MfaBackupCodeAcknowledgement.Complete;
 };
 
@@ -1529,10 +2230,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 = logout.getDefaultClient())=>{
+ */ const isUserMissingMfaAuth = (client = constants.getDefaultClient())=>{
     var _user_scope;
     const user = client.user;
-    logout.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'));
 };
 
@@ -1545,9 +2246,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+ */ const registerTotpMfaDevice = async (client = constants.getDefaultClient())=>{
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     return apiClient.registerTotpMfaDevice({
         environmentId: core.environmentId
     });
@@ -1562,10 +2263,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
-    logout.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,
@@ -1581,9 +2282,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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),
@@ -2528,9 +3229,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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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,
@@ -2550,8 +3251,8 @@ const supportedCountries = {
 };
 
 const verifyOTPForUserSignIn = async ({ otpVerification, verificationToken }, client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const verifyRequest = {
         verificationToken,
         verificationUUID: otpVerification.verificationUUID
@@ -2569,8 +3270,8 @@ const verifyOTPForUserSignIn = async ({ otpVerification, verificationToken }, cl
 };
 
 const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken }, client)=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const verifyRequest = {
         verificationToken,
         verificationUUID: otpVerification.verificationUUID
@@ -2596,17 +3297,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 = logout.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);
 };
 
 /**
@@ -2622,8 +3342,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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const assertWalletAccountSigningAvailability = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { addresses } = await walletProvider.getConnectedAddresses();
@@ -2635,50 +3355,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 = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
-    const walletProvider = logout.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 setUnverifiedWalletAccounts = ({ unverifiedWalletAccountsToUpdate }, client)=>{
-    const core = logout.getCore(client);
-    const unverifiedWalletAccountsToUpdateIds = unverifiedWalletAccountsToUpdate.map(({ id })=>id);
-    const filteredUnverifiedWalletAccounts = core.state.get().unverifiedWalletAccounts.filter((unverifiedWalletAccount)=>!unverifiedWalletAccountsToUpdateIds.includes(unverifiedWalletAccount.id));
-    core.state.set({
-        unverifiedWalletAccounts: [
-            ...filteredUnverifiedWalletAccounts,
-            ...unverifiedWalletAccountsToUpdate
-        ]
-    });
-};
-
 /**
  * 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.
@@ -2703,6 +3379,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.
  *
@@ -2712,70 +3392,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 = logout.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 = logout.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: logout.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) {
-        setUnverifiedWalletAccounts({
+    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();
@@ -2791,21 +3470,22 @@ const getChainIdForAccountVerification = async ({ walletProvider })=>{
 
 const getSignInMessage = async ({ walletAccount }, client)=>{
     var _core_metadata;
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
+    const core = constants.getCore(client);
+    const apiClient = constants.createApiClient({}, client);
     const appUrl = (_core_metadata = core.metadata) == null ? void 0 : _core_metadata.url;
-    logout.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
     });
-    logout.assertDefined(nonce, 'Failed to get nonce');
-    const walletProvider = logout.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: logout.CHAINS_INFO_MAP[walletProvider.chain].blockchainName,
+        blockchainName: constants.CHAINS_INFO_MAP[walletProvider.chain].blockchainName,
         chainId: await getChainIdForAccountVerification({
             walletProvider
         }),
@@ -2813,6 +3493,7 @@ const getSignInMessage = async ({ walletAccount }, client)=>{
         issuedAt: new Date().toISOString(),
         nonce,
         requestId: core.environmentId,
+        statement,
         uri: url.toString()
     });
     return messageToSign;
@@ -2827,8 +3508,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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const proveWalletAccountOwnership = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'signMessage');
@@ -2841,22 +3522,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 = logout.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)=>logout.normalizeAddress(left, chain) === logout.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.
@@ -2869,54 +3557,49 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
+ */ const verifyWalletAccount = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    var _response_user;
     if (walletAccount.verifiedCredentialId) {
         throw new WalletAccountAlreadyVerifiedError(walletAccount.address);
     }
-    const core = logout.getCore(client);
-    const apiClient = logout.createApiClient({}, client);
-    const walletProvider = logout.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 = logout.getWalletAccounts(client).find(({ address })=>isSameAddress(address, walletAccount.address, walletAccount.chain));
-    logout.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;
 };
 
@@ -2930,9 +3613,9 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
+ */ const connectAndVerifyWithWalletProvider = async ({ walletProviderKey }, client = constants.getDefaultClient())=>{
     const walletAccount = await connectWithWalletProvider({
-        addToUserWalletAccounts: false,
+        addToDynamicWalletAccounts: false,
         walletProviderKey
     }, client);
     await verifyWalletAccount({
@@ -2941,7 +3624,7 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
     /*
    * 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);
@@ -2956,8 +3639,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  *
  * @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 = logout.getDefaultClient())=>{
-    const allWalletProviders = getWalletProviderByKey.getWalletProviders(client);
+ */ 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));
@@ -2965,7 +3648,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
             chain: walletProvider.chain,
             groupKey: walletProvider.groupKey,
             key: walletProvider.key,
-            metadata: walletProvider.metadata
+            metadata: walletProvider.metadata,
+            walletProviderType: walletProvider.walletProviderType
         }));
 };
 
@@ -2978,13 +3662,54 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.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.
  *
@@ -2995,8 +3720,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const getActiveNetworkData = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { networkId } = await walletProvider.getActiveNetworkId();
@@ -3013,8 +3738,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const getActiveNetworkId = ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     return walletProvider.getActiveNetworkId();
@@ -3029,8 +3754,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const getBalance = async ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     const { networkId } = await walletProvider.getActiveNetworkId();
@@ -3054,17 +3779,43 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
+ */ const getBalanceForAddress = async ({ address, chain, networkId }, client = constants.getDefaultClient())=>{
     const networkProvider = getNetworkProviderFromNetworkId.getNetworkProviderFromNetworkId({
         chain,
         networkId
     }, client);
-    logout.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.
  *
@@ -3074,8 +3825,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const isProgrammaticNetworkSwitchAvailable = ({ walletAccount }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey: walletAccount.walletProviderKey
     }, client);
     return walletProvider.switchActiveNetwork !== undefined;
@@ -3092,8 +3843,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.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) {
@@ -3110,45 +3861,30 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
     });
 };
 
-/**
- * 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 = logout.getDefaultClient())=>{
-    const walletAccounts = logout.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 = logout.getDefaultClient())=>{
-    const core = logout.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 = logout.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 {
-        const updatedWalletAccount = logout._extends({}, walletAccount, {
+        const updatedWalletAccount = constants._extends({}, walletAccount, {
             lastSelectedAt: new Date()
         });
-        setUnverifiedWalletAccounts({
+        getNetworkProviderFromNetworkId.setUnverifiedWalletAccounts({
             unverifiedWalletAccountsToUpdate: [
                 updatedWalletAccount
             ]
@@ -3166,9 +3902,22 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const core = logout.getCore(client);
-    const apiClient = logout.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
@@ -3181,7 +3930,7 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
             walletId: walletAccount.verifiedCredentialId
         }
     });
-    getWalletProviderByKey.updateAuthFromVerifyResponse({
+    getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({
         response
     }, client);
 };
@@ -3196,8 +3945,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = logout.getWalletProviderFromWalletAccount({
+ */ const signMessage = async ({ walletAccount, message }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({
         walletAccount
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'signMessage');
@@ -3220,8 +3969,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletAccounts = logout.getWalletAccounts(client);
+ */ const getWalletAccountFromAddress = ({ address, chain }, client = constants.getDefaultClient())=>{
+    const walletAccounts = getVerifiedCredentialForWalletAccount.getWalletAccounts(client);
     return walletAccounts.find((walletAccount)=>walletAccount.address === address && walletAccount.chain === chain);
 };
 
@@ -3234,8 +3983,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const offWalletProviderEvent = ({ callback, event, walletProviderKey }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'events');
@@ -3252,8 +4001,8 @@ const isSameAddress = (left, right, chain)=>logout.normalizeAddress(left, chain)
  * @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 = logout.getDefaultClient())=>{
-    const walletProvider = getWalletProviderByKey.getWalletProviderByKey({
+ */ const onWalletProviderEvent = ({ callback, event, walletProviderKey }, client = constants.getDefaultClient())=>{
+    const walletProvider = getVerifiedCredentialForWalletAccount.getWalletProviderByKey({
         walletProviderKey
     }, client);
     assertWalletProviderMethodDefined(walletProvider, 'events');
@@ -3290,43 +4039,43 @@ const isIPhone = ()=>typeof window === 'undefined' || typeof navigator === 'unde
     return /iPad/.test(navigator.userAgent) || /Mac/.test(navigator.userAgent) && maxTouchPoints === 5;
 };
 
-assertPackageVersion.assertPackageVersion(logout.name, logout.version);
-
-exports.BaseError = logout.BaseError;
-exports.InvalidExternalAuthError = logout.InvalidExternalAuthError;
-exports.MfaInvalidOtpError = logout.MfaInvalidOtpError;
-exports.MfaRateLimitedError = logout.MfaRateLimitedError;
-exports.SandboxMaximumThresholdReachedError = logout.SandboxMaximumThresholdReachedError;
-exports.fetchProjectSettings = logout.fetchProjectSettings;
-exports.getDefaultClient = logout.getDefaultClient;
-exports.getWalletAccounts = logout.getWalletAccounts;
-exports.isSignedIn = logout.isSignedIn;
-exports.logout = logout.logout;
-exports.offEvent = logout.offEvent;
-exports.onEvent = logout.onEvent;
-exports.onceEvent = logout.onceEvent;
+assertPackageVersion.assertPackageVersion(constants.name, constants.version);
+
+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.NotWaasWalletAccountError = NotWaasWalletAccountError.NotWaasWalletAccountError;
-exports.refreshUser = NotWaasWalletAccountError.refreshUser;
-exports.InvalidParamError = InvalidParamError.InvalidParamError;
+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.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;
@@ -3334,39 +4083,54 @@ 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;
 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;
 exports.proveWalletAccountOwnership = proveWalletAccountOwnership;
@@ -3379,9 +4143,9 @@ 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;