const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-Btejc5g3.cjs');
const require_updateAuthFromVerifyResponse = require('./updateAuthFromVerifyResponse-CElYpi97.cjs');
let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
let zod_mini = require("zod/mini");
zod_mini = require_isMfaRequiredForAction.__toESM(zod_mini);
let buffer = require("buffer");
let eventemitter3 = require("eventemitter3");
eventemitter3 = require_isMfaRequiredForAction.__toESM(eventemitter3);

//#region src/utils/isEqualShallow/isEqualShallow.ts
/**
* Shallow compare two objects.
*
* Source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
* @notInstrumented
*/
const isEqualShallow = (objA, objB) => {
	if (Object.is(objA, objB)) return true;
	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return objA === objB;
	if (objA instanceof Map && objB instanceof Map) {
		if (objA.size !== objB.size) return false;
		for (const [key, value] of objA) if (!Object.is(value, objB.get(key))) return false;
		return true;
	}
	if (objA instanceof Set && objB instanceof Set) {
		if (objA.size !== objB.size) return false;
		for (const value of objA) if (!objB.has(value)) return false;
		return true;
	}
	const keysA = Object.keys(objA);
	if (keysA.length !== Object.keys(objB).length) return false;
	for (const keyA of keysA) if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) return false;
	if (objA.constructor !== objB.constructor) return false;
	return true;
};

//#endregion
//#region src/utils/observable/subscribeWithSelector/subscribeWithSelector.ts
/**
* Allows subscribing to a slice of the state.
* The slice is a computation of the states.
*
* The callback will only be called when the slice has changed.
* Change is determined by shallow comparison.
*
* Returns a function to unsubscribe the callback.
* @notInstrumented
*/
const subscribeWithSelector = (observable, selector) => (callback) => {
	let lastSlice = selector(observable.get());
	return observable.subscribe((value) => {
		const nextSlice = selector(value);
		if (isEqualShallow(nextSlice, lastSlice)) return;
		lastSlice = nextSlice;
		callback(nextSlice);
	});
};

//#endregion
//#region src/services/storage/createLocalStorageAdapter/createLocalStorageAdapter.ts
/**
* Creates a localStorage adapter.
* @notInstrumented
*/
const createLocalStorageAdapter = () => ({
	getItem: async (key) => localStorage.getItem(key),
	removeItem: async (key) => localStorage.removeItem(key),
	setItem: async (key, value) => localStorage.setItem(key, value)
});

//#endregion
//#region src/errors/InvalidStorageSet.ts
var InvalidStorageSet = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor({ key, value }) {
		super({
			cause: null,
			code: "invalid_storage_set",
			docsUrl: null,
			metaMessages: [`key: ${key}`, value],
			name: "InvalidStorageSet",
			shortMessage: "Tried to store a value that does not match the schema"
		});
	}
};

//#endregion
//#region src/services/storage/createStorage/formatForStorage/isValidDateISOString/isValidDateISOString.ts
/**
* Returns whether the given string is a valid ISO date string.
*
* Does not support timezone offsets.
* @notInstrumented
*/
const isValidDateISOString = (value) => {
	const date = new Date(value);
	return !isNaN(date.getTime()) && date.toISOString() === value;
};

//#endregion
//#region src/services/storage/createStorage/formatForStorage/storageFormat.ts
const DATE_PREFIX = "__DATE__";
/** @notInstrumented */
const formatForStorage = (value) => {
	const item = { value };
	return JSON.stringify(item, (_, entry) => {
		if (isValidDateISOString(entry)) return `${DATE_PREFIX}${entry}`;
		return entry;
	});
};
/** @notInstrumented */
const parseFromStorage = (value) => {
	try {
		return JSON.parse(value, (_, entry) => {
			if (typeof entry === "string" && entry.startsWith(DATE_PREFIX)) return new Date(entry.slice(8));
			return entry;
		});
	} catch (error) {
		return null;
	}
};

//#endregion
//#region src/services/storage/createStorage/createStorage.ts
/**
* Creates a Storage service to interact with storage adapter.
* Reads the `storageTier` from each key's config and passes it
* to the adapter on every operation, defaulting to `'default'`.
* @notInstrumented
*/
const createStorage = ({ prefix = "", storageAdapter }) => {
	const getPrefixedKey = (key) => prefix ? `${prefix}_${key}` : key;
	const getAdapterOptions = (storageTier) => ({ storageTier: storageTier ?? "default" });
	return {
		getItem: async (storageKeySchema) => {
			const prefixedKey = getPrefixedKey(storageKeySchema.key);
			const options = getAdapterOptions(storageKeySchema.config?.storageTier);
			const rawItem = await storageAdapter.getItem(prefixedKey, options);
			const parsedItem = rawItem ? parseFromStorage(rawItem) : null;
			/**
			* The item saved to localStorage may be malformed.
			* In this case, we remove it and return null.
			*/
			if (parsedItem !== null) {
				const parsed = storageKeySchema.schema.safeParse(parsedItem.value);
				if (parsed.success) return parsed.data;
			}
			/**
			* The item saved to localStorage may be malformed.
			* In this case, we remove it and return null.
			*/
			await storageAdapter.removeItem(prefixedKey, options);
			return null;
		},
		removeItem: async (storageKeySchema) => {
			await storageAdapter.removeItem(getPrefixedKey(storageKeySchema.key), getAdapterOptions(storageKeySchema.config?.storageTier));
		},
		setItem: async (storageKeySchema, value) => {
			const parsed = storageKeySchema.schema.safeParse(value);
			if (!parsed.success) throw new InvalidStorageSet({
				key: storageKeySchema.key,
				value: JSON.stringify(value)
			});
			const item = formatForStorage(parsed.data);
			await storageAdapter.setItem(getPrefixedKey(storageKeySchema.key), item, getAdapterOptions(storageKeySchema.config?.storageTier));
		}
	};
};

//#endregion
//#region src/utils/getBuffer/getBuffer.ts
/** @notInstrumented */
const getBuffer = () => typeof Buffer !== "undefined" ? Buffer : buffer.Buffer;

//#endregion
//#region src/utils/isServerSideRendering/isServerSideRendering.ts
/**
* Indicates if the code is running in a server-side environment.
* @notInstrumented
*/
const isServerSideRendering = () => typeof window === "undefined";

//#endregion
//#region src/modules/initializeClient/consts.ts
const REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY = "refresh-user-state-from-cookie";
const INITIALIZE_STORAGE_SYNC_TRACKER_KEY = "initialize-storage-sync";
const FETCH_PROJECT_SETTINGS_TRACKER_KEY = "fetch-project-settings";
const GENERATE_SESSION_KEYS_TRACKER_KEY = "generate-session-keys";
const REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY = "refresh-user-state-from-valid-token";

//#endregion
//#region src/utils/deferredPromise/createDeferredPromise.ts
/** @notInstrumented */
const createDeferredPromise = () => {
	let resolve;
	let reject;
	return {
		promise: new Promise((_resolve, _reject) => {
			resolve = _resolve;
			reject = _reject;
		}),
		reject: (reason) => reject?.(reason),
		resolve: (value) => resolve?.(value)
	};
};

//#endregion
//#region src/errors/CannotTrackError.ts
var CannotTrackError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor() {
		super({
			cause: null,
			code: "cannot_track_error",
			docsUrl: null,
			name: "CannotTrackError",
			shortMessage: "All track calls must be performed in the same node tick"
		});
	}
};

//#endregion
//#region src/services/crossTabBroadcast/crossTabBroadcast.schema.ts
/**
* Schema for validating cross-tab broadcast messages.
*/
const CrossTabBroadcastMessageSchema = zod_mini.object({
	args: zod_mini.optional(zod_mini.unknown()),
	event: zod_mini.string()
});

//#endregion
//#region src/services/crossTabBroadcast/createCrossTabBroadcast/createCrossTabBroadcast.ts
/**
* Creates a cross-tab broadcast service instance using the BroadcastChannel API.
*
* Enables communication between multiple tabs/windows of the same application.
* Messages are validated against the schema and invalid messages are silently ignored.
*
* In SSR or when BroadcastChannel is unavailable, returns a no-op implementation.
*
* @param params - Configuration parameters
* @param params.channelName - The name of the broadcast channel to use
* @returns A cross-tab broadcast service instance
* @notInstrumented
*/
const createCrossTabBroadcast = ({ channelName }) => {
	if (isServerSideRendering() || typeof BroadcastChannel === "undefined") return {
		off: () => {},
		on: () => {},
		send: () => {}
	};
	const channel = new BroadcastChannel(channelName);
	const eventEmitter = new eventemitter3.default();
	const handleMessage = (messageEvent) => {
		const parsed = CrossTabBroadcastMessageSchema.safeParse(messageEvent.data);
		if (!parsed.success) return;
		const { args, event } = parsed.data;
		eventEmitter.emit(event, args);
	};
	channel.addEventListener("message", handleMessage);
	return {
		off: (event, callback) => {
			eventEmitter.off(event, callback);
		},
		on: (event, callback) => {
			eventEmitter.on(event, callback);
		},
		send: ({ args, event }) => {
			channel.postMessage({
				args,
				event
			});
		}
	};
};

//#endregion
//#region src/services/logger/createLogger/createLogger.ts
/**
* Log levels and their corresponding numeric values
*/
const LOG_LEVELS = {
	debug: 0,
	error: 3,
	info: 1,
	warn: 2
};
const defaultConsole = console;
/**
* Creates a logger instance with configurable log level and event emission capabilities.
* @returns A logger instance with debug, info, warn, and error methods
* @notInstrumented
*/
const createLogger = (options = {}) => {
	const eventEmitter = new eventemitter3.EventEmitter();
	const minLevel = options.level ?? "warn";
	const shouldLog = (level) => {
		return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
	};
	const formatMessage = (level, message) => {
		return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}: ${message}`;
	};
	const log = (level, consoleMethod, message, ...args) => {
		eventEmitter.emit("log", level, message, ...args);
		if (!shouldLog(level)) return;
		consoleMethod(formatMessage(level, message), ...args);
	};
	return {
		debug: (message, ...args) => log("debug", defaultConsole.debug, message, ...args),
		error: (message, ...args) => log("error", defaultConsole.error, message, ...args),
		info: (message, ...args) => log("info", defaultConsole.info, message, ...args),
		off: eventEmitter.off.bind(eventEmitter),
		on: eventEmitter.on.bind(eventEmitter),
		warn: (message, ...args) => log("warn", defaultConsole.warn, message, ...args)
	};
};

//#endregion
//#region src/utils/bufferToHex/bufferToHex.ts
/**
* Converts an ArrayBuffer or Uint8Array to a hex-encoded string
* @notInstrumented
*/
const bufferToHex = (buffer$1) => [...buffer$1 instanceof Uint8Array ? buffer$1 : new Uint8Array(buffer$1)].map((x) => x.toString(16).padStart(2, "0")).join("");

//#endregion
//#region src/utils/compressRawPublicKey/compressRawPublicKey.ts
/**
* Accepts a public key array buffer, and returns a buffer with the compressed version of the public key
* @notInstrumented
*/
const compressRawPublicKey = (rawPublicKey) => {
	const rawPublicKeyBytes = new Uint8Array(rawPublicKey);
	const len = rawPublicKeyBytes.byteLength;
	const compressedBytes = rawPublicKeyBytes.slice(0, 1 + len >>> 1);
	compressedBytes[0] = 2 | rawPublicKeyBytes[len - 1] & 1;
	return compressedBytes.buffer;
};

//#endregion
//#region src/services/keychain/createKeychainService/KeyNotFoundError.ts
var KeyNotFoundError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor(keyName) {
		super({
			cause: null,
			code: "key_not_found",
			docsUrl: null,
			name: "KeyNotFoundError",
			shortMessage: `Key "${keyName}" not found in keychain`
		});
	}
};

//#endregion
//#region src/services/keychain/createKeychainService/utils/constants.ts
const STORE_NAME = "keys";

//#endregion
//#region src/services/keychain/createKeychainService/utils/deleteIndexedDBItem.ts
/** @notInstrumented */
const deleteIndexedDBItem = ({ db, keyName }) => new Promise((resolve, reject) => {
	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(keyName);
	request.onsuccess = () => resolve();
	request.onerror = () => reject(request.error);
});

//#endregion
//#region src/services/keychain/createKeychainService/utils/getIndexedDBItem.ts
/** @notInstrumented */
const getIndexedDBItem = ({ db, keyName }) => new Promise((resolve, reject) => {
	const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(keyName);
	request.onsuccess = () => resolve(request.result);
	request.onerror = () => reject(request.error);
});

//#endregion
//#region src/services/keychain/createKeychainService/utils/setIndexedDBItem.ts
/** @notInstrumented */
const setIndexedDBItem = ({ db, entry }) => new Promise((resolve, reject) => {
	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(entry);
	request.onsuccess = () => resolve();
	request.onerror = () => reject(request.error);
});

//#endregion
//#region src/services/keychain/createKeychainService/utils/openDatabase.ts
/** @notInstrumented */
const openDatabase = (dbName) => new Promise((resolve, reject) => {
	const request = indexedDB.open(dbName, 1);
	request.onupgradeneeded = () => {
		const db = request.result;
		if (!db.objectStoreNames.contains(STORE_NAME)) db.createObjectStore(STORE_NAME, { keyPath: "keyName" });
	};
	request.onsuccess = () => resolve(request.result);
	request.onerror = () => reject(request.error);
});

//#endregion
//#region src/services/keychain/createKeychainService/utils/withDatabase/withDatabase.ts
/**
* Scopes a database connection to the lifetime of a callback.
* Opens a connection, passes it to the operation, and guarantees
* the connection is closed when the operation completes or throws.
* @notInstrumented
*/
const withDatabase = async ({ dbName, operation }) => {
	const db = await openDatabase(dbName);
	try {
		return await operation(db);
	} finally {
		db.close();
	}
};

//#endregion
//#region src/services/keychain/createKeychainService/createKeychainService.ts
const DEFAULT_DB_NAME = "dynamic_keychain";
/** @notInstrumented */
const createKeychainService = (params) => {
	const dbName = params?.dbName ?? DEFAULT_DB_NAME;
	const generateKey = async (keyName) => {
		const keyPair = await crypto.subtle.generateKey({
			name: "ECDSA",
			namedCurve: "P-256"
		}, false, ["sign"]);
		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", keyPair.publicKey)));
		await withDatabase({
			dbName,
			operation: (db) => setIndexedDBItem({
				db,
				entry: {
					keyName,
					privateKey: keyPair.privateKey,
					publicKeyHex
				}
			})
		});
		return publicKeyHex;
	};
	const importKey = async (keyName, jwk) => {
		const privateKey = await crypto.subtle.importKey("jwk", jwk, {
			name: "ECDSA",
			namedCurve: "P-256"
		}, false, ["sign"]);
		const publicJwk = {
			crv: jwk.crv,
			kty: jwk.kty,
			x: jwk.x,
			y: jwk.y
		};
		const publicCryptoKey = await crypto.subtle.importKey("jwk", publicJwk, {
			name: "ECDSA",
			namedCurve: "P-256"
		}, true, ["verify"]);
		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", publicCryptoKey)));
		await withDatabase({
			dbName,
			operation: (db) => setIndexedDBItem({
				db,
				entry: {
					keyName,
					privateKey,
					publicKeyHex
				}
			})
		});
		return publicKeyHex;
	};
	const getPublicKey = async (keyName) => {
		return (await withDatabase({
			dbName,
			operation: (db) => getIndexedDBItem({
				db,
				keyName
			})
		}))?.publicKeyHex ?? null;
	};
	const sign = async (keyName, message) => {
		const entry = await withDatabase({
			dbName,
			operation: (db) => getIndexedDBItem({
				db,
				keyName
			})
		});
		if (!entry) throw new KeyNotFoundError(keyName);
		const data = new TextEncoder().encode(message);
		return bufferToHex(await crypto.subtle.sign({
			hash: { name: "SHA-256" },
			name: "ECDSA"
		}, entry.privateKey, data));
	};
	const hasKey = async (keyName) => {
		return await withDatabase({
			dbName,
			operation: (db) => getIndexedDBItem({
				db,
				keyName
			})
		}) !== void 0;
	};
	const removeKey = async (keyName) => {
		await withDatabase({
			dbName,
			operation: (db) => deleteIndexedDBItem({
				db,
				keyName
			})
		});
	};
	return {
		generateKey,
		getPublicKey,
		hasKey,
		importKey,
		removeKey,
		sign
	};
};

//#endregion
//#region src/errors/InvalidRealtimePublishError.ts
var InvalidRealtimePublishError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor({ channel }) {
		super({
			cause: null,
			code: "invalid_realtime_publish",
			docsUrl: null,
			metaMessages: [`channel: ${channel}`],
			name: "InvalidRealtimePublishError",
			shortMessage: "Tried to publish data that does not match the channel schema"
		});
	}
};

//#endregion
//#region src/errors/RealtimeNotConnectedError.ts
var RealtimeNotConnectedError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor() {
		super({
			cause: null,
			code: "realtime_not_connected_error",
			docsUrl: null,
			name: "RealtimeNotConnectedError",
			shortMessage: "Realtime service is not connected. Call connect() before subscribing or publishing."
		});
	}
};

//#endregion
//#region src/services/realtime/createRealtimeService/createRealtimeService.ts
const ABLY_STATE_TO_REALTIME_STATE = {
	closed: "closed",
	closing: "closing",
	connected: "connected",
	connecting: "connecting",
	disconnected: "disconnected",
	failed: "failed",
	initialized: "idle",
	suspended: "suspended"
};
const mapAblyState = (ablyState) => ABLY_STATE_TO_REALTIME_STATE[ablyState] ?? "idle";
/**
* Creates a realtime pub/sub service backed by Ably.
*
* The service starts idle. Call `connect({ client })` to establish
* a connection, passing the DynamicClient explicitly.
*
* SSR environments receive a no-op implementation.
* @notInstrumented
*/
const createRealtimeService = () => {
	if (isServerSideRendering()) return {
		connect: () => Promise.resolve(),
		disconnect: () => {},
		getConnectionState: () => "idle",
		off: () => {},
		on: () => {},
		publish: () => Promise.resolve(),
		subscribe: () => Promise.resolve(),
		unsubscribe: () => {}
	};
	const eventEmitter = new eventemitter3.default();
	const channels = /* @__PURE__ */ new Map();
	const handlerMap = /* @__PURE__ */ new WeakMap();
	let ablyClient;
	let connectionState = "idle";
	let isConnecting = false;
	const setConnectionState = (state) => {
		connectionState = state;
		eventEmitter.emit("connectionStateChange", state);
	};
	const getOrCreateChannel = (channelName) => {
		const existing = channels.get(channelName);
		if (existing) return existing;
		if (!ablyClient) throw new RealtimeNotConnectedError();
		const channel = ablyClient.channels.get(channelName);
		channels.set(channelName, channel);
		return channel;
	};
	const connect = async ({ client, headers }) => {
		if (isConnecting) return;
		isConnecting = true;
		try {
			const core = require_updateAuthFromVerifyResponse.getCore(client);
			if (ablyClient) {
				ablyClient.close();
				channels.clear();
			}
			const { BaseRealtime: AblyBaseRealtime, FetchRequest, WebSocketTransport } = await import("ably/modular");
			ablyClient = new AblyBaseRealtime({
				authCallback: (_tokenParams, callback) => {
					require_updateAuthFromVerifyResponse.createApiClient({ headers }, client).getRealtimeAuthToken({ environmentId: core.environmentId }).then((response) => {
						callback(null, response.token);
					}).catch((err) => {
						callback(err instanceof Error ? err.message : String(err), null);
					});
				},
				autoConnect: false,
				plugins: {
					FetchRequest,
					WebSocketTransport
				}
			});
			ablyClient.connection.on((stateChange) => {
				setConnectionState(mapAblyState(stateChange.current));
			});
			ablyClient.connect();
		} finally {
			isConnecting = false;
		}
	};
	const disconnect = () => {
		if (!ablyClient) return;
		for (const channel of channels.values()) channel.detach().catch(() => {});
		channels.clear();
		ablyClient.close();
		ablyClient = void 0;
	};
	const subscribe = async ({ channelSchema, callback }) => {
		const channel = getOrCreateChannel(channelSchema.channel);
		const handler = (message) => {
			const parsed = channelSchema.schema.safeParse(message.data);
			if (!parsed.success) return;
			callback({ data: parsed.data });
		};
		handlerMap.set(callback, handler);
		await channel.subscribe(handler);
	};
	const unsubscribe = ({ channelSchema, callback }) => {
		const channel = channels.get(channelSchema.channel);
		if (!channel) return;
		const handler = handlerMap.get(callback);
		if (handler) {
			channel.unsubscribe(handler);
			handlerMap.delete(callback);
		}
	};
	const publish = async ({ channelSchema, data }) => {
		const parsed = channelSchema.schema.safeParse(data);
		if (!parsed.success) throw new InvalidRealtimePublishError({ channel: channelSchema.channel });
		await getOrCreateChannel(channelSchema.channel).publish("message", parsed.data);
	};
	return {
		connect,
		disconnect,
		getConnectionState: () => connectionState,
		off: (event, callback) => {
			eventEmitter.off(event, callback);
		},
		on: (event, callback) => {
			eventEmitter.on(event, callback);
		},
		publish,
		subscribe,
		unsubscribe
	};
};

//#endregion
//#region src/utils/getKeychainIndexedDBName/getKeychainIndexedDBName.ts
/**
* Builds the IndexedDB database name used by the keychain service for a given
* environment. Centralizing this avoids drift between the SDK and any
* extension code that needs to read or migrate the same database.
*
* @param params.environmentId - The Dynamic environment id.
* @returns The IndexedDB database name for the keychain.
* @notInstrumented
*/
const getKeychainIndexedDBName = ({ environmentId }) => `dynamic_${environmentId}_keychain`;

//#endregion
//#region src/errors/NoNetworkProvidersError.ts
var NoNetworkProvidersError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor() {
		super({
			cause: null,
			code: "no_network_providers",
			docsUrl: null,
			name: "NoNetworkProvidersError",
			shortMessage: "No networks were registered in the client"
		});
	}
};

//#endregion
//#region src/errors/WalletAlreadyLinkedToAnotherUserError.ts
var WalletAlreadyLinkedToAnotherUserError = class extends require_updateAuthFromVerifyResponse.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"
		});
	}
};

//#endregion
//#region src/modules/captcha/isCaptchaRequired/isCaptchaRequired.ts
/** @notInstrumented */
const isCaptchaRequired = (client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
	const projectSettings = client.projectSettings;
	require_updateAuthFromVerifyResponse.assertDefined(projectSettings, "Project settings are not available");
	return projectSettings.security.hCaptcha?.enabled ?? false;
};

//#endregion
//#region src/modules/captcha/consumeCaptchaToken/consumeCaptchaToken.ts
/**
* Retrieves the current captcha token from the client state and sets it to null.
* @notInstrumented
*/
const consumeCaptchaToken = (client) => {
	const core = require_updateAuthFromVerifyResponse.getCore(client);
	const captchaToken = core.state.get().captchaToken;
	if (isCaptchaRequired(client)) require_updateAuthFromVerifyResponse.assertDefined(captchaToken, "Captcha token is required");
	core.state.set({ captchaToken: null });
	return captchaToken ?? void 0;
};

//#endregion
//#region src/errors/MethodNotImplementedError.ts
var MethodNotImplementedError = class extends require_updateAuthFromVerifyResponse.BaseError {
	constructor(methodName) {
		super({
			cause: null,
			code: "method_not_implemented_error",
			docsUrl: null,
			name: "MethodNotImplementedError",
			shortMessage: `This method is not implemented: ${methodName}`
		});
	}
};

//#endregion
//#region src/modules/captcha/setCaptchaToken/setCaptchaToken.ts
/**
* Sets the given captcha token in the client state.
*
* @param params.captchaToken - The captcha token to set.
* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
* @instrumented
* @redact-params
*/
const setCaptchaToken = ({ captchaToken }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
	require_updateAuthFromVerifyResponse.getCore(client).state.set({ captchaToken });
};
const __setCaptchaToken_impl = setCaptchaToken;
const __setCaptchaToken_wrapped = require_updateAuthFromVerifyResponse.instrumentFunction({
	fn: __setCaptchaToken_impl,
	functionName: "setCaptchaToken",
	getCore: () => {
		try {
			return require_updateAuthFromVerifyResponse.getCore(require_updateAuthFromVerifyResponse.getDefaultClient());
		} catch {
			return;
		}
	},
	redactAll: true
});

//#endregion
//#region src/modules/extension/hasExtension/hasExtension.ts
/**
* Checks if a specific extension has been applied to the Dynamic client.
*
* Extensions add optional features to the Dynamic SDK,
* such as EVM, Solana, or other chain support.
*
* @param params.extensionKey - The unique key identifying the extension to check for.
* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
* @returns True if the extension is applied, false otherwise.
* @notInstrumented
*/
const hasExtension = ({ extensionKey }, client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
	return require_updateAuthFromVerifyResponse.getCore(client).extensions.has(extensionKey);
};

//#endregion
//#region src/modules/auth/createVisit/createVisit.ts
/** @notInstrumented */
const createVisit = async ({ walletAccount, authMode = _dynamic_labs_sdk_api_core.AuthModeEnum.Only }, client) => {
	const core = require_updateAuthFromVerifyResponse.getCore(client);
	const apiClient = require_updateAuthFromVerifyResponse.createApiClient({}, client);
	const walletProvider = require_updateAuthFromVerifyResponse.getWalletProviderFromWalletAccount({ walletAccount }, client);
	try {
		const walletName = require_updateAuthFromVerifyResponse.normalizeWalletNameWithChain({
			chain: walletProvider.chain,
			displayName: walletProvider.metadata.displayName
		});
		const connectRequest = {
			address: walletAccount.address,
			authMode,
			chain: walletProvider.chain,
			provider: walletProvider.walletProviderType,
			walletName
		};
		await apiClient.createVisit({
			connectRequest,
			environmentId: core.environmentId
		});
	} catch (error) {
		core.logger.error("Error creating visit", { error });
	}
};

//#endregion
//#region src/modules/wallets/unverifiedWalletAccounts/setUnverifiedWalletAccounts/setUnverifiedWalletAccounts.ts
/**
* Updates the unverified wallet account in the client state.
* This will add new wallet accounts and override those with matching ids,
* but will leave other preexisting wallet accounts unchanged.
* @notInstrumented
*/
const setUnverifiedWalletAccounts = ({ unverifiedWalletAccountsToUpdate }, client) => {
	if (unverifiedWalletAccountsToUpdate.length === 0) return;
	const core = require_updateAuthFromVerifyResponse.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] });
};

//#endregion
//#region src/modules/wallets/walletProvider/walletProviderKeyMap/updateWalletProviderKeysForVerifiedCredentials/updateWalletProviderKeysForVerifiedCredentials.ts
/** @notInstrumented */
const updateWalletProviderKeysForVerifiedCredentials = ({ keysToUpdate }, client) => {
	const core = require_updateAuthFromVerifyResponse.getCore(client);
	core.state.set({ walletProviderKeyMap: {
		...core.state.get().walletProviderKeyMap,
		...keysToUpdate
	} });
};

//#endregion
//#region src/modules/wallets/reconcileWalletAccountsAgainstClient/reconcileWalletAccountsAgainstClient.ts
/**
* Reconciles freshly-connected wallet accounts against the client state. For
* each candidate it classifies as new, a re-connect of an existing unverified
* account, or a re-connect of an already-verified account, then runs the
* appropriate state mutation (`setUnverifiedWalletAccounts`,
* `updateWalletProviderKeysForVerifiedCredentials`, `createVisit` for truly-new
* entries) and emits a single `walletAccountsChanged` event if anything
* actually changed. Returns the candidates with `verifiedCredentialId`
* populated when the address already corresponded to a verified credential.
*
* @notInstrumented
*/
const reconcileWalletAccountsAgainstClient = ({ addToDynamicWalletAccounts = true, walletAccounts, walletProviderKey }, client) => {
	if (walletAccounts.length === 0) return [];
	const existingWalletAccounts = require_updateAuthFromVerifyResponse.getWalletAccounts(client);
	const newWalletAccounts = [];
	const unverifiedWalletAccountsToUpdate = [];
	const verifiedCredentialIdToWalletProviderKeyMap = {};
	const reconciledWalletAccounts = walletAccounts.map((candidate) => {
		const matchingExistingWalletAccount = existingWalletAccounts.find((existingWalletAccount) => existingWalletAccount.id === candidate.id);
		if (!matchingExistingWalletAccount) {
			newWalletAccounts.push(candidate);
			return candidate;
		}
		const isWalletProviderKeyChanged = matchingExistingWalletAccount.walletProviderKey !== walletProviderKey;
		if (matchingExistingWalletAccount.verifiedCredentialId) {
			if (isWalletProviderKeyChanged) verifiedCredentialIdToWalletProviderKeyMap[matchingExistingWalletAccount.verifiedCredentialId] = walletProviderKey;
			return {
				...candidate,
				verifiedCredentialId: matchingExistingWalletAccount.verifiedCredentialId
			};
		}
		if (isWalletProviderKeyChanged) unverifiedWalletAccountsToUpdate.push(candidate);
		return candidate;
	});
	let walletAccountsChanged = false;
	if (Object.keys(verifiedCredentialIdToWalletProviderKeyMap).length > 0) {
		updateWalletProviderKeysForVerifiedCredentials({ keysToUpdate: verifiedCredentialIdToWalletProviderKeyMap }, client);
		walletAccountsChanged = true;
	}
	if (addToDynamicWalletAccounts) {
		const accountsToWrite = [...unverifiedWalletAccountsToUpdate, ...newWalletAccounts];
		if (accountsToWrite.length > 0) {
			setUnverifiedWalletAccounts({ unverifiedWalletAccountsToUpdate: accountsToWrite }, client);
			walletAccountsChanged = true;
			for (const newWalletAccount of newWalletAccounts) createVisit({ walletAccount: newWalletAccount }, client);
		}
	}
	if (walletAccountsChanged) require_updateAuthFromVerifyResponse.emitWalletAccountsChangedEvent(client);
	return reconciledWalletAccounts;
};

//#endregion
//#region src/utils/getAppMetadata/getAppMetadata.ts
/**
* Reads the customer-supplied app name, logo, native link, and universal link.
* — preferring `core.metadata` (set on the client) over project-settings fallbacks.
*
* @param client - The Dynamic client whose configuration drives the result.
* @notInstrumented
*/
const getAppMetadata = (client) => {
	const core = require_updateAuthFromVerifyResponse.getCore(client);
	const generalSettings = client.projectSettings?.general;
	return {
		appLogoUrl: core.metadata?.iconUrl ?? generalSettings?.appLogo ?? void 0,
		appName: core.metadata?.name ?? generalSettings?.displayName ?? "",
		appNativeLink: core.metadata?.nativeLink,
		appUniversalLink: core.metadata?.universalLink
	};
};

//#endregion
//#region src/modules/wallets/utils/formatSignInMessage/formatSignInMessage.ts
/**
* Formats a sign in message to prove ownership of an address.
* @notInstrumented
*/
const formatSignInMessage = async ({ domain, blockchainName, address, uri, chainId, nonce, issuedAt, requestId, statement, resources }) => {
	const prefix = [`${domain} wants you to sign in with your ${blockchainName} account:`, address].join("\n");
	const prefixWithStatementGap = statement ? "\n\n" : "\n";
	const prefixWithStatement = `${[prefix, statement].join(prefixWithStatementGap)}\n`;
	const suffixFields = [];
	suffixFields.push(`URI: ${uri}`);
	suffixFields.push("Version: 1");
	if (chainId) suffixFields.push(`Chain ID: ${chainId}`);
	suffixFields.push(`Nonce: ${nonce}`);
	if (issuedAt) suffixFields.push(`Issued At: ${issuedAt}`);
	if (requestId) suffixFields.push(`Request ID: ${requestId}`);
	if (resources?.length) suffixFields.push(`Resources:${resources.map((resource) => "\n- " + resource).join()}`);
	return [prefixWithStatement, suffixFields.join("\n")].join("\n");
};

//#endregion
//#region src/modules/wallets/utils/getSignInMessage/createSignInMessageStatement/createSignInMessageStatement.ts
/** @notInstrumented */
const createSignInMessageStatement = (client) => {
	const { appName } = getAppMetadata(client);
	return `Welcome to ${appName}. Signing is the only way we can truly know that you are the owner of the wallet you are connecting. Signing is a safe, gas-less transaction that does not in any way give ${appName} permission to perform any transactions with your wallet.`;
};

//#endregion
//#region src/modules/wallets/unverifiedWalletAccounts/removeUnverifiedWalletAccount/removeUnverifiedWalletAccount.ts
/**
* Removes an unverified wallet account from the client's state.
* @notInstrumented
*/
const removeUnverifiedWalletAccount = ({ unverifiedWalletAccount }, client) => {
	const core = require_updateAuthFromVerifyResponse.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.
	*/
	require_updateAuthFromVerifyResponse.checkAndRaiseWalletAccountsChangedEvent({ previousState }, client);
};

//#endregion
//#region src/utils/isError/isError.ts
/**
* Check if the given value is an Error object
* @notInstrumented
*/
const isError = (error) => error instanceof Error;

//#endregion
//#region src/utils/isErrorWithCode/isErrorWithCode.ts
/**
* Check if the given value is an Error object with a specific code
* @notInstrumented
*/
const isErrorWithCode = (error, code) => {
	if (!isError(error)) return false;
	return "code" in error && error.code === code;
};

//#endregion
//#region src/modules/wallets/verifyMessageSignatureOwnership/verifyMessageSignatureOwnership.ts
/**
* Verifies a signed message by calling either the verifyLink, verifyTransfer or verify API function,
* depending on whether the user is signing in, linking or transferring a wallet.
*
* Does NOT call updateAuthFromVerifyResponse, it should be called from the return of this function.
* @notInstrumented
*/
const verifyMessageSignatureOwnership = async ({ messageToSign, walletAddress, addressesWithTypes, signature, chain, isTransfer = false, walletDisplayName, walletProviderType, networkId, requestedScopes }, client) => {
	const core = require_updateAuthFromVerifyResponse.getCore(client);
	const apiClient = require_updateAuthFromVerifyResponse.createApiClient({}, client);
	const walletName = require_updateAuthFromVerifyResponse.normalizeWalletNameWithChain({
		chain,
		displayName: walletDisplayName
	});
	let verifyApiFunction;
	if (!client.user) verifyApiFunction = apiClient.walletsSignin.bind(apiClient);
	else if (isTransfer) verifyApiFunction = apiClient.verifyTransfer.bind(apiClient);
	else if (client.user && requestedScopes) verifyApiFunction = apiClient.walletsVerify.bind(apiClient);
	else verifyApiFunction = apiClient.verifyLink.bind(apiClient);
	try {
		return await verifyApiFunction({
			environmentId: core.environmentId,
			verifyRequest: {
				additionalWalletAddresses: addressesWithTypes?.map((address) => ({
					address: address.address,
					publicKey: address.publicKey,
					type: address.type
				})),
				captchaToken: consumeCaptchaToken(client),
				chain,
				messageToSign,
				network: networkId,
				publicWalletAddress: walletAddress,
				requestedScopes,
				signedMessage: signature,
				walletName,
				walletProvider: walletProviderType
			}
		});
	} catch (error) {
		core.logger.error("Failed to verify message signature ownership", error);
		if (isErrorWithCode(error, "reassign_wallet_confirm") || isErrorWithCode(error, "merge_accounts_confirmation")) throw new WalletAlreadyLinkedToAnotherUserError({ cause: error });
		throw error;
	}
};

//#endregion
//#region src/modules/wallets/networks/getSdkChainFromApiChainName/getSdkChainFromApiChainName.ts
/**
* Maps the chain name from the API to the SDK chain name
* @notInstrumented
*/
const getSdkChainFromApiChainName = (chainName) => {
	return Object.keys(require_updateAuthFromVerifyResponse.CHAINS_INFO_MAP).find((chain) => require_updateAuthFromVerifyResponse.CHAINS_INFO_MAP[chain].apiChainName === chainName) || null;
};

//#endregion
//#region src/modules/wallets/networks/getNetworksData/getNetworksData.ts
/**
* Retrieves all available network configurations from project settings.
*
* This function returns detailed configuration data for all networks enabled
* in your Dynamic project, including RPC URLs, native currencies, and metadata.
*
* If a `transformers.networkData` callback was provided in the client configuration,
* it will be applied to each network before returning the data. This allows you to
* customize network properties (such as RPC URLs) in a centralized way.
*
* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
* @returns An array of network configuration data for all enabled networks.
* @notInstrumented
*/
const getNetworksData = (client = require_updateAuthFromVerifyResponse.getDefaultClient()) => {
	const { state, transformers } = require_updateAuthFromVerifyResponse.getCore(client);
	const networkDataTransformer = transformers?.networkData ?? ((networkData) => networkData);
	const { projectSettings } = state.get();
	require_updateAuthFromVerifyResponse.assertDefined(projectSettings, "projectSettings not found");
	const networks = projectSettings.networks;
	if (!networks) return [];
	return networks.map((network) => {
		if (!network.chainName) return [];
		const chain = getSdkChainFromApiChainName(network.chainName);
		if (!network?.networks?.length || !chain) return [];
		return network.networks.map((networkConfiguration) => {
			return networkDataTransformer({
				blockExplorerUrls: networkConfiguration.blockExplorerUrls,
				chain,
				cluster: networkConfiguration.cluster,
				displayName: networkConfiguration.vanityName || networkConfiguration.name,
				genesisHash: networkConfiguration.genesisHash,
				iconUrl: networkConfiguration.iconUrls[0],
				name: networkConfiguration.name,
				nativeCurrency: {
					decimals: networkConfiguration.nativeCurrency.decimals,
					iconUrl: networkConfiguration.nativeCurrency.iconUrl,
					name: networkConfiguration.nativeCurrency.name,
					symbol: networkConfiguration.nativeCurrency.symbol
				},
				networkId: networkConfiguration.networkId,
				rpcUrls: { http: [...networkConfiguration.privateCustomerRpcUrls ?? [], ...networkConfiguration.rpcUrls ?? []] },
				testnet: networkConfiguration.isTestnet ?? false
			});
		});
	}).flat();
};

//#endregion
//#region src/modules/wallets/networks/networkProviderBuilderRegistry/createNetworkProviderBuilderRegistry/createNetworkProviderBuilderRegistry.ts
/** @notInstrumented */
const createNetworkProviderBuilderRegistry = () => {
	const registry = /* @__PURE__ */ new Map();
	return {
		get: () => registry,
		register: (networkProviderBuilder) => {
			registry.set(networkProviderBuilder.chain, networkProviderBuilder);
		}
	};
};

//#endregion
//#region src/modules/wallets/networks/networkProviderBuilderRegistry/getNetworkProviderBuilderRegistry/getNetworkProviderBuilderRegistry.ts
const getNetworkProviderBuilderRegistry = require_updateAuthFromVerifyResponse.createRuntimeServiceAccessKey("networkProviderBuilderRegistry", createNetworkProviderBuilderRegistry);

//#endregion
//#region src/modules/wallets/networks/getNetworkProviders/getNetworkProviders.ts
/**
* Retrieves all registered network providers for enabled chains.
* @notInstrumented
*/
const getNetworkProviders = (client) => {
	const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
	const registeredNetworkProviderBuilders = Array.from(networkProviderBuilderRegistry.get().values());
	const networksData = getNetworksData(client);
	return registeredNetworkProviderBuilders.map(({ builder, chain }) => {
		return networksData.filter((networkData) => networkData.chain === chain).map(builder);
	}).flat();
};

//#endregion
//#region src/modules/wallets/networks/getNetworkProviderFromNetworkId/getNetworkProviderFromNetworkId.ts
/** @notInstrumented */
const getNetworkProviderFromNetworkId = ({ networkId, chain }, client) => {
	const networkProviders = getNetworkProviders(client);
	if (networkProviders.length === 0) throw new NoNetworkProvidersError();
	const networkProvider = networkProviders.find((networkProvider$1) => networkProvider$1.networkId === networkId && networkProvider$1.chain === chain);
	require_updateAuthFromVerifyResponse.assertDefined(networkProvider, `No network provider found for chain ${chain} with network id ${networkId}`);
	return networkProvider;
};

//#endregion
Object.defineProperty(exports, 'CannotTrackError', {
  enumerable: true,
  get: function () {
    return CannotTrackError;
  }
});
Object.defineProperty(exports, 'CrossTabBroadcastMessageSchema', {
  enumerable: true,
  get: function () {
    return CrossTabBroadcastMessageSchema;
  }
});
Object.defineProperty(exports, 'FETCH_PROJECT_SETTINGS_TRACKER_KEY', {
  enumerable: true,
  get: function () {
    return FETCH_PROJECT_SETTINGS_TRACKER_KEY;
  }
});
Object.defineProperty(exports, 'GENERATE_SESSION_KEYS_TRACKER_KEY', {
  enumerable: true,
  get: function () {
    return GENERATE_SESSION_KEYS_TRACKER_KEY;
  }
});
Object.defineProperty(exports, 'INITIALIZE_STORAGE_SYNC_TRACKER_KEY', {
  enumerable: true,
  get: function () {
    return INITIALIZE_STORAGE_SYNC_TRACKER_KEY;
  }
});
Object.defineProperty(exports, 'InvalidStorageSet', {
  enumerable: true,
  get: function () {
    return InvalidStorageSet;
  }
});
Object.defineProperty(exports, 'MethodNotImplementedError', {
  enumerable: true,
  get: function () {
    return MethodNotImplementedError;
  }
});
Object.defineProperty(exports, 'NoNetworkProvidersError', {
  enumerable: true,
  get: function () {
    return NoNetworkProvidersError;
  }
});
Object.defineProperty(exports, 'REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY', {
  enumerable: true,
  get: function () {
    return REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY;
  }
});
Object.defineProperty(exports, 'REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY', {
  enumerable: true,
  get: function () {
    return REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY;
  }
});
Object.defineProperty(exports, 'WalletAlreadyLinkedToAnotherUserError', {
  enumerable: true,
  get: function () {
    return WalletAlreadyLinkedToAnotherUserError;
  }
});
Object.defineProperty(exports, '__setCaptchaToken_wrapped', {
  enumerable: true,
  get: function () {
    return __setCaptchaToken_wrapped;
  }
});
Object.defineProperty(exports, 'consumeCaptchaToken', {
  enumerable: true,
  get: function () {
    return consumeCaptchaToken;
  }
});
Object.defineProperty(exports, 'createCrossTabBroadcast', {
  enumerable: true,
  get: function () {
    return createCrossTabBroadcast;
  }
});
Object.defineProperty(exports, 'createDeferredPromise', {
  enumerable: true,
  get: function () {
    return createDeferredPromise;
  }
});
Object.defineProperty(exports, 'createKeychainService', {
  enumerable: true,
  get: function () {
    return createKeychainService;
  }
});
Object.defineProperty(exports, 'createLocalStorageAdapter', {
  enumerable: true,
  get: function () {
    return createLocalStorageAdapter;
  }
});
Object.defineProperty(exports, 'createLogger', {
  enumerable: true,
  get: function () {
    return createLogger;
  }
});
Object.defineProperty(exports, 'createRealtimeService', {
  enumerable: true,
  get: function () {
    return createRealtimeService;
  }
});
Object.defineProperty(exports, 'createSignInMessageStatement', {
  enumerable: true,
  get: function () {
    return createSignInMessageStatement;
  }
});
Object.defineProperty(exports, 'createStorage', {
  enumerable: true,
  get: function () {
    return createStorage;
  }
});
Object.defineProperty(exports, 'createVisit', {
  enumerable: true,
  get: function () {
    return createVisit;
  }
});
Object.defineProperty(exports, 'formatSignInMessage', {
  enumerable: true,
  get: function () {
    return formatSignInMessage;
  }
});
Object.defineProperty(exports, 'getAppMetadata', {
  enumerable: true,
  get: function () {
    return getAppMetadata;
  }
});
Object.defineProperty(exports, 'getBuffer', {
  enumerable: true,
  get: function () {
    return getBuffer;
  }
});
Object.defineProperty(exports, 'getKeychainIndexedDBName', {
  enumerable: true,
  get: function () {
    return getKeychainIndexedDBName;
  }
});
Object.defineProperty(exports, 'getNetworkProviderBuilderRegistry', {
  enumerable: true,
  get: function () {
    return getNetworkProviderBuilderRegistry;
  }
});
Object.defineProperty(exports, 'getNetworkProviderFromNetworkId', {
  enumerable: true,
  get: function () {
    return getNetworkProviderFromNetworkId;
  }
});
Object.defineProperty(exports, 'getNetworkProviders', {
  enumerable: true,
  get: function () {
    return getNetworkProviders;
  }
});
Object.defineProperty(exports, 'getNetworksData', {
  enumerable: true,
  get: function () {
    return getNetworksData;
  }
});
Object.defineProperty(exports, 'hasExtension', {
  enumerable: true,
  get: function () {
    return hasExtension;
  }
});
Object.defineProperty(exports, 'isCaptchaRequired', {
  enumerable: true,
  get: function () {
    return isCaptchaRequired;
  }
});
Object.defineProperty(exports, 'isEqualShallow', {
  enumerable: true,
  get: function () {
    return isEqualShallow;
  }
});
Object.defineProperty(exports, 'isServerSideRendering', {
  enumerable: true,
  get: function () {
    return isServerSideRendering;
  }
});
Object.defineProperty(exports, 'reconcileWalletAccountsAgainstClient', {
  enumerable: true,
  get: function () {
    return reconcileWalletAccountsAgainstClient;
  }
});
Object.defineProperty(exports, 'removeUnverifiedWalletAccount', {
  enumerable: true,
  get: function () {
    return removeUnverifiedWalletAccount;
  }
});
Object.defineProperty(exports, 'setUnverifiedWalletAccounts', {
  enumerable: true,
  get: function () {
    return setUnverifiedWalletAccounts;
  }
});
Object.defineProperty(exports, 'subscribeWithSelector', {
  enumerable: true,
  get: function () {
    return subscribeWithSelector;
  }
});
Object.defineProperty(exports, 'updateWalletProviderKeysForVerifiedCredentials', {
  enumerable: true,
  get: function () {
    return updateWalletProviderKeysForVerifiedCredentials;
  }
});
Object.defineProperty(exports, 'verifyMessageSignatureOwnership', {
  enumerable: true,
  get: function () {
    return verifyMessageSignatureOwnership;
  }
});
//# sourceMappingURL=getNetworkProviderFromNetworkId-CS4r9hi7.cjs.map