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

package/logout.cjs.js

@@ -1,1086 +0,0 @@
-'use strict';
-
-var sdkApiCore = require('@dynamic-labs/sdk-api-core');
-var buffer = require('buffer');
-var z = require('zod/mini');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
-
-var name = "@dynamic-labs-sdk/client";
-var version = "0.1.0-alpha.9";
-var dependencies = {
-    "@dynamic-labs/sdk-api-core": "0.0.762"};
-
-const getCore = (client)=>{
-    // @ts-expect-error - this was hidden from the public API
-    return client.__core;
-};
-
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for(var i = 1; i < arguments.length; i++){
-            var source = arguments[i];
-            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
-        }
-        return target;
-    };
-    return _extends.apply(this, arguments);
-}
-
-const getDetails = ({ details, cause })=>{
-    if (cause instanceof BaseError) {
-        return cause.details;
-    }
-    if (cause == null ? void 0 : cause.message) {
-        return cause.message;
-    }
-    return details;
-};
-/**
- * Formats the error message with all available information
- */ const formatMessage = ({ shortMessage, details, docsUrl, metaMessages })=>{
-    return [
-        shortMessage,
-        '',
-        ...metaMessages ? [
-            ...metaMessages,
-            ''
-        ] : [],
-        ...docsUrl ? [
-            `Docs: ${docsUrl}`
-        ] : [],
-        ...details ? [
-            `Details: ${details}`
-        ] : [],
-        `Version: ${version}`,
-        `Timestamp: ${new Date().toISOString()}`
-    ].join('\n');
-};
-/**
- * Base error class that provides structured error handling with detailed information
- */ class BaseError extends Error {
-    /**
-   * Walks the cause chain of the error and returns the root error
-   */ walk() {
-        const cause = this.cause;
-        if (cause instanceof BaseError) {
-            return cause.walk();
-        }
-        return cause;
-    }
-    toString() {
-        return this.formattedMessage;
-    }
-    constructor(args){
-        const details = getDetails(args);
-        const formattedMessage = formatMessage(_extends({}, args, {
-            details
-        }));
-        var _args_shortMessage;
-        super((_args_shortMessage = args.shortMessage) != null ? _args_shortMessage : formattedMessage, args.cause ? {
-            cause: args.cause
-        } : undefined);
-        this.name = 'BaseError';
-        this.formattedMessage = formattedMessage;
-        this.details = details;
-        var _args_name;
-        this.name = (_args_name = args.name) != null ? _args_name : this.name;
-        var _args_cause;
-        this.cause = (_args_cause = args.cause) != null ? _args_cause : this.cause;
-        this.code = args.code;
-    }
-}
-
-class ClientNotFoundError extends BaseError {
-    constructor(){
-        super({
-            cause: null,
-            code: 'client_not_found_error',
-            docsUrl: null,
-            name: 'ClientNotFoundError',
-            shortMessage: 'No Dynamic client has been created yet. Make sure you have called createDynamicClient() first.'
-        });
-    }
-}
-
-let defaultClient = null;
-let numOfInitializedClients = 0;
-/**
- * Returns the DynamicClient instance that was initialized with createDynamicClient.
- *
- * If more than one instance of DynamicClient was initialized, you should not use this function.
- * Instead, you should pass the client instance you stored to the function that needs it.
- */ const getDefaultClient = ()=>{
-    if (!defaultClient) {
-        throw new ClientNotFoundError();
-    }
-    if (numOfInitializedClients > 1) {
-        const core = getCore(defaultClient);
-        core.logger.debug('Multiple instances of DynamicClient found. If you are only using one client (recommended), make sure you are not calling ' + '"createDynamicClient" multiple times. If you are using multiple clients, make sure you are passing which client to use as ' + 'the last param of all Dynamic functions.');
-    }
-    return defaultClient;
-};
-const setDefaultClient = (client)=>{
-    defaultClient = client;
-    numOfInitializedClients++;
-};
-
-/**
- * Sefelly sets the cookie in the browser.
- */ const setCookie = (cookie)=>{
-    // eslint-disable-next-line no-restricted-globals
-    document.cookie = cookie;
-};
-
-const DYNAMIC_API_VERSION_HEADER = 'x-dyn-api-version';
-const DYNAMIC_REQUEST_ID_HEADER = 'x-dyn-request-id';
-const DYNAMIC_SDK_VERSION_HEADER = 'x-dyn-version';
-const MFA_TOKEN_HEADER = 'x-mfa-auth-token';
-const SESSION_PUBLIC_KEY_HEADER = 'x-dyn-session-public-key';
-const DYNAMIC_SDK_API_VERSION = dependencies['@dynamic-labs/sdk-api-core'];
-const CLIENT_SDK_NAME = 'ClientSDK';
-
-const randomString = (length)=>{
-    const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-    let result = '';
-    for(let i = length; i > 0; --i){
-        result += CHARS[Math.floor(Math.random() * CHARS.length)];
-    }
-    return result;
-};
-
-class ValueMustBeDefinedError extends BaseError {
-    constructor(message){
-        super({
-            cause: null,
-            code: 'value_must_be_defined_error',
-            docsUrl: null,
-            name: 'ValueMustBeDefined',
-            shortMessage: message
-        });
-    }
-}
-
-/**
- * Asserts that a value is not null or undefined, throwing an error if it is.
- * This function acts as a type guard, narrowing the type to exclude null and undefined.
- *
- * @template T - The type of the value being checked
- * @param value - The value to check for null or undefined
- * @param message - The error message to throw if the value is null or undefined
- * @throws Throws an error with the provided message if value is null or undefined
- * @example
- * ```typescript
- * const maybeString: string | null = getValue();
- * assertDefined(maybeString, 'String value is required');
- * // maybeString is now typed as string (null is excluded)
- * ```
- */ function assertDefined(value, message) {
-    if (value === null || value === undefined) {
-        throw new ValueMustBeDefinedError(message);
-    }
-}
-
-/**
- * Returns true if the client is using Dynamic cookies or a BYO JWT cookie.
- */ const isCookieEnabled = (client)=>{
-    var _securitySettings_auth, _securitySettings_externalAuth;
-    assertDefined(client.projectSettings, 'Project settings are not defined');
-    const securitySettings = client.projectSettings.security;
-    if (!securitySettings) return false;
-    // client uses Dynamic cookies
-    const dynamicCookiesEnabled = (((_securitySettings_auth = securitySettings.auth) == null ? void 0 : _securitySettings_auth.storage) || []).includes(sdkApiCore.AuthStorageEnum.Cookie);
-    // BYO JWT client puts their non-Dynamic JWT in a cookie
-    const byoJwtCookieEnabled = Boolean((_securitySettings_externalAuth = securitySettings.externalAuth) == null ? void 0 : _securitySettings_externalAuth.cookieName);
-    // should return true for both of these scenarios
-    // because we also need to do `credentials: true` in api.ts when
-    // a byo jwt client sets their named cookie for their jwt and
-    // needs to send it to our backend
-    return dynamicCookiesEnabled || byoJwtCookieEnabled;
-};
-
-const getBuffer = ()=>typeof Buffer !== 'undefined' ? Buffer : buffer.Buffer;
-
-const getSessionKeys = (client)=>{
-    const core = getCore(client);
-    const encodedKeys = core.state.get().sessionKeys;
-    if (!encodedKeys) {
-        return undefined;
-    }
-    try {
-        const decodedKeys = JSON.parse(getBuffer().from(encodedKeys, 'base64').toString());
-        return decodedKeys;
-    } catch (error) {
-        core.logger.error('Error decoding session keys', error);
-        return undefined;
-    }
-};
-
-class APIError extends BaseError {
-    static async fromResponse(response) {
-        const errorBody = await response.json();
-        if ('code' in errorBody && typeof errorBody.code === 'string' && 'error' in errorBody && typeof errorBody.error === 'string') {
-            return new APIError(errorBody.error, errorBody.code);
-        }
-        return null;
-    }
-    constructor(message, code){
-        super({
-            cause: null,
-            code,
-            docsUrl: null,
-            name: 'APIError',
-            shortMessage: message
-        });
-    }
-}
-
-class InvalidExternalAuthError extends BaseError {
-    constructor({ cause }){
-        super({
-            cause,
-            code: 'invalid_external_auth_error',
-            docsUrl: 'https://www.dynamic.xyz/docs/external-auth/third-party-auth-overview',
-            name: 'InvalidExternalAuthError',
-            shortMessage: 'Error authenticating with external JWT'
-        });
-    }
-}
-
-class MfaInvalidOtpError extends BaseError {
-    constructor({ cause }){
-        super({
-            cause,
-            code: 'mfa_invalid_otp_error',
-            docsUrl: null,
-            name: 'MfaInvalidOtpError',
-            shortMessage: 'Invalid OTP'
-        });
-    }
-}
-
-class MfaRateLimitedError extends BaseError {
-    constructor({ cause }){
-        super({
-            cause,
-            code: 'mfa_rate_limited_error',
-            docsUrl: null,
-            name: 'MfaRateLimitedError',
-            shortMessage: 'Rate limited'
-        });
-    }
-}
-
-class SandboxMaximumThresholdReachedError extends BaseError {
-    constructor({ cause }){
-        super({
-            cause,
-            code: 'sandbox_maximum_threshold_reached_error',
-            docsUrl: 'https://www.dynamic.xyz/docs/developer-dashboard/sandbox-vs-live#sandbox-vs-live',
-            name: 'SandboxMaximumThresholdReachedError',
-            shortMessage: 'Your sandbox environment has reached the maximum MAU. Please use a live environment for production traffic.'
-        });
-    }
-}
-
-/**
- * Default error mapper for the client that handles common API error codes.
- *
- * This mapper transforms specific API error codes into more specific error types:
- * - `mfa_invalid_code` → `MfaInvalidOtpError`
- * - `mfa_rate_limited` → `MfaRateLimitedError`
- *
- * @param error - The error to be mapped
- * @returns A transformed error if the error code matches a known pattern, or null if no transformation is needed
- *
- * @example
- * ```typescript
- * // This will be automatically applied to all API errors
- * const apiClient = createApiClient({}, client);
- *
- * // The clientErrorMapper will automatically convert mfa_invalid_code errors
- * // to MfaInvalidOtpError instances
- * ```
- */ const clientErrorMapper = (error)=>{
-    if (error instanceof APIError) {
-        if (error.code === 'mfa_invalid_code') {
-            return new MfaInvalidOtpError({
-                cause: error
-            });
-        }
-        if (error.code === 'mfa_rate_limited') {
-            return new MfaRateLimitedError({
-                cause: error
-            });
-        }
-        if (error.code === 'invalid_external_auth') {
-            return new InvalidExternalAuthError({
-                cause: error
-            });
-        }
-        if (error.code === 'sandbox_maximum_threshold_reached') {
-            return new SandboxMaximumThresholdReachedError({
-                cause: error
-            });
-        }
-    }
-    return null;
-};
-
-/**
- * Creates middleware that converts HTTP error responses to APIError instances
- * and optionally applies custom error mappers to transform them into specific error types.
- *
- * @param options.errorMappers - Array of error mappers to apply to API errors
- * @returns A middleware function that handles error conversion and mapping
- */ const createConvertToApiErrorMiddleware = ({ errorMappers = [] })=>({
-        post: async (context)=>{
-            if (context.response.status >= 400) {
-                const apiError = await APIError.fromResponse(context.response);
-                if (apiError) {
-                    let errorToThrow = apiError;
-                    for (const mapper of errorMappers){
-                        const newError = mapper(apiError);
-                        if (newError) {
-                            errorToThrow = newError;
-                            break;
-                        }
-                    }
-                    throw errorToThrow;
-                }
-            }
-            return context.response;
-        }
-    });
-
-const createLogoutOnUnauthorizedRequestMiddleware = (client)=>({
-        post: async (context)=>{
-            /**
-     * We should logout the user if the request is unauthorized.
-     * But we need to ignore the revoke session request to prevent infinite logout loops
-     * because the revoke session request will be performed by the logout function below.
-     */ if (context.response.status === 401 && !context.url.endsWith('/revoke')) {
-                await logout(client);
-            }
-            return context.response;
-        }
-    });
-
-/**
- * Returns a new instance of the SDK API client.
- *
- * This is not meant for storing, as it is very light we can create it whenever needed.
- */ const createApiClient = (options = {}, client)=>{
-    var _getSessionKeys;
-    const core = getCore(client);
-    const coreState = core.state.get();
-    const settings = {
-        basePath: core.apiBaseUrl,
-        headers: _extends({
-            'Content-Type': 'application/json',
-            [DYNAMIC_API_VERSION_HEADER]: DYNAMIC_SDK_API_VERSION,
-            [DYNAMIC_REQUEST_ID_HEADER]: randomString(50),
-            [DYNAMIC_SDK_VERSION_HEADER]: `${CLIENT_SDK_NAME}/${version}`
-        }, core.getApiHeaders(), options.headers)
-    };
-    if (client.token) {
-        settings.headers.Authorization = `Bearer ${client.token}`;
-    }
-    if (client.projectSettings && isCookieEnabled(client)) {
-        settings.credentials = 'include';
-    }
-    if (options.includeMfaToken && coreState.mfaToken) {
-        settings.headers[MFA_TOKEN_HEADER] = coreState.mfaToken;
-    }
-    const sessionPublicKey = (_getSessionKeys = getSessionKeys(client)) == null ? void 0 : _getSessionKeys.publicKey;
-    // This check is required to avoid overriding the session public key header
-    // that is set by any of our other SDKs using the Dynamic Client SDK.
-    const isSessionPublicKeyHeaderPresent = settings.headers[SESSION_PUBLIC_KEY_HEADER] !== undefined;
-    if (sessionPublicKey && !isSessionPublicKeyHeaderPresent) {
-        settings.headers[SESSION_PUBLIC_KEY_HEADER] = sessionPublicKey;
-    }
-    return new sdkApiCore.SDKApi(new sdkApiCore.Configuration(_extends({}, settings, {
-        fetchApi: core.fetch,
-        middleware: [
-            createLogoutOnUnauthorizedRequestMiddleware(client),
-            createConvertToApiErrorMiddleware({
-                errorMappers: [
-                    ...options.errorMappers || [],
-                    clientErrorMapper
-                ]
-            })
-        ]
-    })));
-};
-
-/**
- * Adds an event listener for Dynamic client events.
- *
- * This function allows you to listen for various events emitted by the Dynamic client,
- * such as authentication state changes, wallet connections, and more.
- *
- * @param params.event - The event name to listen for.
- * @param params.listener - The callback function to execute when the event is fired.
- * @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 onEvent = ({ event, listener }, client = getDefaultClient())=>{
-    const { eventEmitter } = getCore(client);
-    eventEmitter.on(event, listener);
-    return ()=>{
-        eventEmitter.off(event, listener);
-    };
-};
-/**
- * Removes an event listener from Dynamic client events.
- *
- * This function unsubscribes a previously registered event listener
- * from the specified Dynamic client event.
- *
- * @param params.event - The event name to remove the listener from.
- * @param params.listener - The callback function to remove.
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- */ const offEvent = ({ event, listener }, client = getDefaultClient())=>{
-    const { eventEmitter } = getCore(client);
-    eventEmitter.off(event, listener);
-};
-/**
- * Adds a one-time event listener for Dynamic client events.
- *
- * This function listens for an event that will automatically remove itself
- * after being triggered once.
- *
- * @param params.event - The event name to listen for.
- * @param params.listener - The callback function to execute when the event is fired.
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns A function that can be called to remove the listener before it fires.
- */ const onceEvent = ({ event, listener }, client = getDefaultClient())=>{
-    const { eventEmitter } = getCore(client);
-    eventEmitter.once(event, listener);
-    return ()=>{
-        eventEmitter.off(event, listener);
-    };
-};
-/**
- * Emits a Dynamic client event.
- *
- * This function triggers an event that will be received by all registered
- * listeners for the specified event type.
- *
- * @param params.event - The event name to emit.
- * @param params.args - The arguments to pass to event listeners.
- * @param client - The Dynamic client instance.
- */ const emitEvent = ({ event, args }, client)=>{
-    const { eventEmitter } = getCore(client);
-    eventEmitter.emit(event, args);
-};
-
-/**
- * This error is thrown when the `retryOnFail` function is called with an invalid
- * number of retries (i.e. less than 0).
- */ class InvalidRetryOnFailCallError extends 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);
-};
-
-const normalizeAddress = (address, chain)=>{
-    let normalizedAddress = address;
-    if (normalizedAddress == null ? void 0 : normalizedAddress.startsWith('0x')) {
-        normalizedAddress = normalizedAddress.slice(2);
-    }
-    /**
-   * These are standard from CAIP-2: https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md
-   * see also: https://github.com/ChainAgnostic/namespaces
-   * note: no standard namespace currently exists for flow
-   */ const chainsThatRequireLowercaseAddress = [
-        'EVM',
-        'FLOW'
-    ];
-    normalizedAddress = chainsThatRequireLowercaseAddress.includes(chain) ? normalizedAddress == null ? void 0 : normalizedAddress.toLowerCase() : normalizedAddress;
-    return normalizedAddress;
-};
-
-const createWalletAccountId = (chain, address)=>`${chain}-${normalizeAddress(address, chain)}`;
-
-const convertUnverifiedWalletAccountToWalletAccount = (unverifiedWalletAccount)=>({
-        address: unverifiedWalletAccount.address,
-        chain: unverifiedWalletAccount.chain,
-        id: createWalletAccountId(unverifiedWalletAccount.chain, unverifiedWalletAccount.address),
-        lastSelectedAt: unverifiedWalletAccount.lastSelectedAt,
-        verifiedCredentialId: null,
-        walletProviderKey: unverifiedWalletAccount.walletProviderKey
-    });
-
-const CHAINS_INFO_MAP = {
-    ALGO: {
-        apiChainName: 'algo',
-        blockchainName: 'Algorand',
-        verifiedCredentialChainName: 'algorand'
-    },
-    BTC: {
-        apiChainName: 'btc',
-        blockchainName: 'Bitcoin',
-        verifiedCredentialChainName: 'bip122'
-    },
-    COSMOS: {
-        apiChainName: 'cosmos',
-        blockchainName: 'Cosmos',
-        verifiedCredentialChainName: 'cosmos'
-    },
-    EVM: {
-        apiChainName: 'evm',
-        // eslint-disable-next-line custom-rules/ban-ethereum-eth-terms
-        blockchainName: 'Ethereum',
-        verifiedCredentialChainName: 'eip155'
-    },
-    FLOW: {
-        apiChainName: 'flow',
-        blockchainName: 'Flow',
-        verifiedCredentialChainName: 'flow'
-    },
-    SOL: {
-        apiChainName: 'solana',
-        blockchainName: 'Solana',
-        verifiedCredentialChainName: 'solana',
-        waasChainNameOverride: 'SVM'
-    },
-    SPARK: {
-        apiChainName: 'spark',
-        blockchainName: 'Spark',
-        verifiedCredentialChainName: 'spark'
-    },
-    STARK: {
-        apiChainName: 'starknet',
-        blockchainName: 'Starknet',
-        verifiedCredentialChainName: 'starknet'
-    },
-    SUI: {
-        apiChainName: 'sui',
-        blockchainName: 'Sui',
-        verifiedCredentialChainName: 'sui'
-    }
-};
-
-const getChainFromVerifiedCredentialChain = (verifiedCredentialChain)=>{
-    const chains = Object.keys(CHAINS_INFO_MAP);
-    const chain = chains.find((chain)=>CHAINS_INFO_MAP[chain].verifiedCredentialChainName === verifiedCredentialChain);
-    assertDefined(chain, `Unknown chain: ${verifiedCredentialChain}`);
-    return chain;
-};
-
-/**
- * Format the wallet name and chain to get a wallet provider key.
- */ const formatWalletProviderKey = (walletName, chain)=>{
-    const sanitizedWalletName = walletName.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
-    return `${sanitizedWalletName}${chain.toLocaleLowerCase()}`;
-};
-
-const convertVerifiedCredentialToWalletAccount = (verified)=>{
-    assertDefined(verified.address, 'Missing address in verified credential');
-    assertDefined(verified.chain, 'Missing chain in verified credential');
-    assertDefined(verified.walletName, 'Missing wallet name in verified credential');
-    const chain = getChainFromVerifiedCredentialChain(verified.chain);
-    const hasChainInWalletName = verified.walletName.endsWith(chain.toLowerCase());
-    // we need to make sure the walletProviderKey follows the correct format ([walletName][chain])
-    // some walletNames will follow the legacy format (e.g. "phantom" instead of "phantomsol", "metamask" instead of "metamaskevm")
-    // so we need to make sure we parse it correctly
-    const walletProviderKey = hasChainInWalletName ? verified.walletName : formatWalletProviderKey(verified.walletName, chain);
-    var _verified_lastSelectedAt;
-    return {
-        address: verified.address,
-        chain,
-        id: createWalletAccountId(chain, verified.address),
-        lastSelectedAt: (_verified_lastSelectedAt = verified.lastSelectedAt) != null ? _verified_lastSelectedAt : null,
-        verifiedCredentialId: verified.id,
-        walletProviderKey
-    };
-};
-
-const getWalletAccountsFromState = (state)=>{
-    const { unverifiedWalletAccounts, user } = state;
-    const walletAccountsMap = new Map();
-    /**
-   * Handle the unverified wallet accounts before the user verified credentials
-   * so the later verified wallet accounts can override the unverified wallet accounts
-   */ unverifiedWalletAccounts.forEach((unverifiedWalletAccount)=>{
-        const walletAccount = convertUnverifiedWalletAccountToWalletAccount(unverifiedWalletAccount);
-        walletAccountsMap.set(walletAccount.id, walletAccount);
-    });
-    var _user_verifiedCredentials;
-    /**
-   * Handle user verified credentials
-   */ const verifiedCredentials = (_user_verifiedCredentials = user == null ? void 0 : user.verifiedCredentials) != null ? _user_verifiedCredentials : [];
-    verifiedCredentials.filter((verified)=>verified.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Blockchain).map((verifiedWalletAccount)=>convertVerifiedCredentialToWalletAccount(verifiedWalletAccount)).forEach((verifiedWalletAccount)=>walletAccountsMap.set(verifiedWalletAccount.id, verifiedWalletAccount));
-    return Array.from(walletAccountsMap.values());
-};
-
-/**
- * Retrieves all wallet accounts associated with the current session.
- *
- * This function returns both verified and unverified wallet accounts,
- * combining data from user credentials and local unverified accounts.
- * You can differentiate between verified and unverified wallet accounts by
- * checking the `verifiedCredentialId` property.
- *
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns An array of wallet accounts associated with the session.
- */ const getWalletAccounts = (client = getDefaultClient())=>getWalletAccountsFromState(getCore(client).state.get());
-
-/**
- * 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 = getDefaultClient())=>Boolean(client.user || getWalletAccounts(client).length > 0);
-
-const createStorageKeySchema = (params)=>{
-    return params;
-};
-
-/**
- * The schema to track the expiration time of the project settings.
- */ const projectSettingsExpirationScheme = 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 = getDefaultClient())=>{
-    const core = getCore(client);
-    const currentExpiration = await core.storage.getItem(projectSettingsExpirationScheme);
-    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 = createApiClient({}, client);
-    const doFetch = async ()=>apiClient.getEnvironmentSettings({
-            environmentId: core.environmentId,
-            sdkVersion: `${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(projectSettingsExpirationScheme, 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));
-};
-
-/**
- * Converts an ArrayBuffer to a hex-encoded string
- */ const bufferToHex = (buffer)=>[
-        ...new Uint8Array(buffer)
-    ].map((x)=>x.toString(16).padStart(2, '0')).join('');
-
-/**
- * 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: bufferToHex(privateKeyBuffer),
-        privateJwk: privateKeyJwk,
-        public: bufferToHex(compressedPublicKeyBuffer)
-    };
-};
-
-const generateSessionKeys = async (client)=>{
-    const { private: privateKey, public: publicKey, privateJwk: privateKeyJwk } = await p256Keygen();
-    const core = getCore(client);
-    // stringify and encode the session keys to store in storage
-    const stringifiedSessionKeys = JSON.stringify({
-        privateKey,
-        privateKeyJwk,
-        publicKey,
-        registered: false
-    });
-    const encodedSessionKeys = getBuffer().from(stringifiedSessionKeys).toString('base64');
-    core.state.set({
-        sessionKeys: encodedSessionKeys
-    });
-    return {
-        privateKey,
-        privateKeyJwk,
-        publicKey
-    };
-};
-
-class NoWalletProviderFoundError extends BaseError {
-    constructor({ walletProviderKey }){
-        super({
-            cause: null,
-            code: 'no_wallet_provider_found_error',
-            docsUrl: null,
-            name: 'NoWalletProviderFoundError',
-            shortMessage: `No wallet provider found with key: ${walletProviderKey}`
-        });
-    }
-}
-
-/**
- * Creates a service accessor function that manages service instantiation and caching.
- * The returned function will either retrieve an existing service from the registry or
- * create a new one using the provided builder function.
- *
- * @template - The type of service to be created/accessed
- * @param key - Unique identifier for the service in the registry
- * @param builder - Function that creates the service instance when called with a DynamicClient
- */ const createRuntimeServiceAccessKey = (key, builder)=>(client)=>{
-        const { runtimeServices } = getCore(client);
-        const currentService = runtimeServices.getByKey(key);
-        if (currentService) {
-            return currentService;
-        }
-        const service = builder(client);
-        runtimeServices.register(key, service);
-        return service;
-    };
-
-/**
- * Creates a new wallet provider registry that manages wallet providers with priority-based registration.
- *
- * @returns The wallet provider registry instance
- *
- * @example
- * ```typescript
- * const registry = createWalletProviderRegistry();
- *
- * registry.register({
- *   priority: WalletProviderPriority.WALLET_SDK,
- *   walletProvider: myWalletProvider
- * });
- *
- * const provider = registry.getByKey('my-wallet-key');
- * const providers = registry.listProviders();
- * ```
- */ const createWalletProviderRegistry = (client)=>{
-    const registry = new Map();
-    return {
-        getByKey: (key)=>{
-            var _registry_get;
-            return (_registry_get = registry.get(key)) == null ? void 0 : _registry_get.walletProvider;
-        },
-        listProviders: ()=>Array.from(registry.values()).map((v)=>v.walletProvider),
-        register: (args)=>{
-            const existingEntry = registry.get(args.walletProvider.key);
-            if (existingEntry) {
-                if (existingEntry.priority < args.priority) {
-                    registry.set(args.walletProvider.key, args);
-                    emitEvent({
-                        args: {
-                            walletProviderKey: args.walletProvider.key
-                        },
-                        event: 'walletProviderChanged'
-                    }, client);
-                }
-            } else {
-                registry.set(args.walletProvider.key, args);
-                emitEvent({
-                    args: {
-                        walletProvider: args.walletProvider
-                    },
-                    event: 'walletProviderRegistered'
-                }, client);
-                emitEvent({
-                    args: {
-                        walletProviderKey: args.walletProvider.key
-                    },
-                    event: 'walletProviderChanged'
-                }, client);
-            }
-        },
-        unregister: (key)=>{
-            registry.delete(key);
-            emitEvent({
-                args: {
-                    walletProviderKey: key
-                },
-                event: 'walletProviderUnregistered'
-            }, client);
-        }
-    };
-};
-
-/**
- * This function provides access to a shared instance of the wallet provider registry.
- *
- * It ensures that the same registry instance is used throughout the client to maintaining
- * consistency of registered wallet providers across different parts of the codebase.
- *
- * @returns The wallet provider registry instance
- *
- * @example
- * ```typescript
- * // Get the registry instance
- * const registry = getWalletProviderRegistry();
- *
- * // Register a wallet provider
- * registry.register({
- *   priority: WalletProviderPriority.WALLET_SDK,
- *   walletProvider: myWalletProvider
- * });
- *
- * // Retrieve a specific provider
- * const provider = registry.getByKey('metamaskevm');
- * ```
- */ const getWalletProviderRegistry = createRuntimeServiceAccessKey('walletProviderRegistry', (client)=>createWalletProviderRegistry(client));
-
-exports.WalletProviderPriority = void 0;
-(function(WalletProviderPriority) {
-    /**
-   * Highest priority should be used by wallet providers that implement
-   * the most reliable wallet integration.
-   * example: The SDK provided by the wallet provider.
-   */ WalletProviderPriority[WalletProviderPriority["WALLET_SDK"] = 100] = "WALLET_SDK";
-    /**
-   * Medium priority should be used by wallet providers that implement
-   * a wallet integration via some reliable standard.
-   * example: A wallet provider that uses EIP6963 announcement.
-   */ WalletProviderPriority[WalletProviderPriority["WALLET_SELF_ANNOUNCEMENT_STANDARD"] = 50] = "WALLET_SELF_ANNOUNCEMENT_STANDARD";
-    /**
-   * Low priority should be used by wallet providers that implement
-   * a wallet integration on a less reliable standard.
-   * example: A wallet provider that uses window.ethereum, where the
-   * window key can be overridden by other extensions.
-   */ WalletProviderPriority[WalletProviderPriority["WINDOW_INJECT"] = 20] = "WINDOW_INJECT";
-})(exports.WalletProviderPriority || (exports.WalletProviderPriority = {}));
-
-const getWalletProviderFromWalletAccount = ({ walletAccount }, client)=>{
-    const walletProviderRegistry = getWalletProviderRegistry(client);
-    const walletProvider = walletProviderRegistry.getByKey(walletAccount.walletProviderKey);
-    if (!walletProvider) {
-        throw new NoWalletProviderFoundError({
-            walletProviderKey: walletAccount.walletProviderKey
-        });
-    }
-    return walletProvider;
-};
-
-const getAvailableWalletProvidersFromWalletAccounts = (client)=>{
-    const core = getCore(client);
-    const walletProvidersMap = new Map();
-    const walletAccounts = getWalletAccounts(client);
-    walletAccounts.forEach((walletAccount)=>{
-        if (walletProvidersMap.has(walletAccount.walletProviderKey)) {
-            return;
-        }
-        try {
-            const walletProvider = 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 = 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);
-            }
-        }
-    }));
-};
-
-const DYNAMIC_AUTH_COOKIE_NAME = 'DYNAMIC_JWT_TOKEN';
-
-/**
- * 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 = getDefaultClient())=>{
-    const core = getCore(client);
-    await disconnectAndTerminateWalletProviders(client);
-    if (client.user !== null) {
-        const apiClient = 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 (isCookieEnabled(client)) {
-            setCookie(`${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
-    });
-    emitEvent({
-        event: 'logout'
-    }, client);
-    // Refetch project settings
-    void fetchProjectSettings(client);
-    // Regenerate session keys
-    void generateSessionKeys(client);
-};
-
-exports.APIError = APIError;
-exports.BaseError = BaseError;
-exports.CHAINS_INFO_MAP = CHAINS_INFO_MAP;
-exports.CLIENT_SDK_NAME = CLIENT_SDK_NAME;
-exports.ClientNotFoundError = ClientNotFoundError;
-exports.DYNAMIC_AUTH_COOKIE_NAME = DYNAMIC_AUTH_COOKIE_NAME;
-exports.DYNAMIC_SDK_API_VERSION = DYNAMIC_SDK_API_VERSION;
-exports.InvalidExternalAuthError = InvalidExternalAuthError;
-exports.MfaInvalidOtpError = MfaInvalidOtpError;
-exports.MfaRateLimitedError = MfaRateLimitedError;
-exports.NoWalletProviderFoundError = NoWalletProviderFoundError;
-exports.SandboxMaximumThresholdReachedError = SandboxMaximumThresholdReachedError;
-exports.ValueMustBeDefinedError = ValueMustBeDefinedError;
-exports._extends = _extends;
-exports.assertDefined = assertDefined;
-exports.bufferToHex = bufferToHex;
-exports.createApiClient = createApiClient;
-exports.createRuntimeServiceAccessKey = createRuntimeServiceAccessKey;
-exports.createStorageKeySchema = createStorageKeySchema;
-exports.createWalletAccountId = createWalletAccountId;
-exports.dependencies = dependencies;
-exports.emitEvent = emitEvent;
-exports.fetchProjectSettings = fetchProjectSettings;
-exports.formatWalletProviderKey = formatWalletProviderKey;
-exports.generateSessionKeys = generateSessionKeys;
-exports.getBuffer = getBuffer;
-exports.getChainFromVerifiedCredentialChain = getChainFromVerifiedCredentialChain;
-exports.getCore = getCore;
-exports.getDefaultClient = getDefaultClient;
-exports.getSessionKeys = getSessionKeys;
-exports.getWalletAccounts = getWalletAccounts;
-exports.getWalletAccountsFromState = getWalletAccountsFromState;
-exports.getWalletProviderFromWalletAccount = getWalletProviderFromWalletAccount;
-exports.getWalletProviderRegistry = getWalletProviderRegistry;
-exports.isCookieEnabled = isCookieEnabled;
-exports.isSignedIn = isSignedIn;
-exports.logout = logout;
-exports.name = name;
-exports.normalizeAddress = normalizeAddress;
-exports.offEvent = offEvent;
-exports.onEvent = onEvent;
-exports.onceEvent = onceEvent;
-exports.randomString = randomString;
-exports.setCookie = setCookie;
-exports.setDefaultClient = setDefaultClient;
-exports.version = version;