@dynamic-labs-sdk/metamask 1.31.0 → 1.31.2

package/dist/getOrCreateMetaMaskClientInstanceManager-DbH0IJjn.native.esm.js

@@ -0,0 +1,621 @@
+import { createEventEmitter, createRuntimeServiceAccessKey, createSequenceQueue, createStorageKeySchema, getAppMetadata, getCore, getNativeLinkScheme, getPlatform } from "@dynamic-labs-sdk/client/core";
+import { BaseError, getNetworksData } from "@dynamic-labs-sdk/client";
+import { createMultichainClient, getTransportType } from "@metamask/connect-multichain";
+import * as z from "zod/mini";
+
+//#region package.json
+var name = "@dynamic-labs-sdk/metamask";
+var version = "1.31.2";
+
+//#endregion
+//#region src/errors/MetaMaskUnscopedNetworkError/MetaMaskUnscopedNetworkError.ts
+/**
+* Thrown when attempting to switch a MetaMask multichain wallet provider to
+* a network whose CAIP-2 scope was requested at connect time but never
+* granted an account by MetaMask in the current session (e.g. the user only
+* approved mainnet, not a preconfigured devnet, during pairing). Switching
+* to it anyway would silently break every subsequent signing/sending call
+* on that network, since MetaMask rejects those against an ungranted scope.
+*
+* @example
+* ```ts
+* try {
+*   await switchActiveNetwork({ networkId: '103', walletAccount });
+* } catch (error) {
+*   if (error instanceof MetaMaskUnscopedNetworkError) {
+*     // Tell the user to approve this network in MetaMask, then retry.
+*   }
+* }
+* ```
+* @see assertMetaMaskNetworkIsGranted
+* @see resolveActiveMetaMaskScope
+*/
+var MetaMaskUnscopedNetworkError = class extends BaseError {
+	constructor({ networkId, scope }) {
+		super({
+			cause: null,
+			code: "metamask_unscoped_network",
+			docsUrl: null,
+			metaMessages: [`scope: ${scope}`],
+			name: "MetaMaskUnscopedNetworkError",
+			shortMessage: `Cannot switch to network "${networkId}": MetaMask did not grant an account for scope "${scope}" in the current session.`
+		});
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+/**
+* Chains MetaMask's multichain client can build a CAIP-2 scope for. Shared by
+* every scope/network-mapping helper so the supported set only needs to
+* change in one place.
+*/
+const SUPPORTED_METAMASK_CHAINS = ["EVM", "SOL"];
+
+//#endregion
+//#region src/errors/UnsupportedMetaMaskChainError/UnsupportedMetaMaskChainError.ts
+/** Thrown when a chain has no MetaMask multichain scope mapping defined. */
+var UnsupportedMetaMaskChainError = class extends BaseError {
+	constructor({ chain, supportedChains }) {
+		super({
+			cause: null,
+			code: "metamask_unsupported_chain",
+			docsUrl: null,
+			name: "UnsupportedMetaMaskChainError",
+			shortMessage: `Unsupported chain "${chain}" for MetaMask. Supported chains: ${supportedChains.join(", ")}`
+		});
+	}
+};
+
+//#endregion
+//#region src/getMetaMaskScopeForNetworkId/getMetaMaskScopeForNetworkId.ts
+/**
+* Maps a single Dynamic-configured network to its CAIP-2 MetaMask
+* multichain scope -- the same per-network mapping `getMetaMaskScopes`
+* applies to every configured network at once, extracted so callers that
+* already have one `networkId` (e.g. the "active network" registry) don't
+* need to rebuild and filter the whole configured list to find it.
+*
+* EVM's `networkId` IS the CAIP-2 reference (`eip155:<networkId>`); SOL's
+* `networkId` is an internal routing id, so the network's base58 genesis
+* hash is used instead (`solana:<genesisHash>`). Returns `undefined` when no
+* configured SOL network matches, or matches but has no genesis hash --
+* these are normal ("this networkId isn't usable as a MetaMask scope"), not
+* error conditions.
+*
+* @example
+* ```ts
+* const scope = getMetaMaskScopeForNetworkId(
+*   { chain: 'SOL', networkId: '101' },
+*   client
+* );
+* // 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+* ```
+*
+* @returns The CAIP-2 scope for `networkId`, or `undefined` if it can't be
+* expressed as one (e.g. a SOL network with no genesis hash configured).
+* @throws {UnsupportedMetaMaskChainError} If `chain` isn't a chain MetaMask
+* scopes can be built for.
+* @see getMetaMaskScopes
+* @see getNetworkIdFromMetaMaskScope
+* @notInstrumented
+*/
+const getMetaMaskScopeForNetworkId = ({ chain, networkId }, client) => {
+	if (chain === "EVM") return `eip155:${networkId}`;
+	if (chain === "SOL") {
+		const network = getNetworksData(client).find((candidate) => candidate.chain === "SOL" && candidate.networkId === networkId);
+		return network?.genesisHash ? `solana:${network.genesisHash}` : void 0;
+	}
+	throw new UnsupportedMetaMaskChainError({
+		chain,
+		supportedChains: SUPPORTED_METAMASK_CHAINS
+	});
+};
+
+//#endregion
+//#region src/getMetaMaskScopes/getMetaMaskScopes.ts
+/**
+* Builds the CAIP-2 scopes to request for a chain's MetaMask multichain
+* session, one per configured network. SOL scopes use the network's genesis
+* hash (not `networkId`, which is an internal routing id for SOL) since
+* that's the CAIP-2 reference MetaMask expects.
+*
+* @example
+* ```ts
+* const scopes = getMetaMaskScopes({ chain: 'EVM' }, client);
+* // ['eip155:1', 'eip155:137']
+* ```
+*
+* @returns The CAIP-2 scopes for every configured network of `chain` that
+* can be expressed as one.
+* @throws {UnsupportedMetaMaskChainError} If `chain` isn't a chain MetaMask
+* scopes can be built for.
+* @see getMetaMaskScopeForNetworkId
+* @see getMetaMaskSupportedNetworks
+* @notInstrumented
+*/
+const getMetaMaskScopes = ({ chain }, client) => {
+	if (!chain || !SUPPORTED_METAMASK_CHAINS.includes(chain)) throw new UnsupportedMetaMaskChainError({
+		chain,
+		supportedChains: SUPPORTED_METAMASK_CHAINS
+	});
+	return getNetworksData(client).filter((network) => network.chain === chain).flatMap((network) => {
+		const scope = getMetaMaskScopeForNetworkId({
+			chain: network.chain,
+			networkId: network.networkId
+		}, client);
+		return scope ? [scope] : [];
+	});
+};
+
+//#endregion
+//#region src/errors/MetaMaskClientNotInitializedError/MetaMaskClientNotInitializedError.ts
+/**
+* Thrown when `getMetaMaskClient()` is called but the underlying
+* `@metamask/connect-multichain` client failed to initialize -- this should
+* be unreachable in practice, since `getMetaMaskClient` always triggers
+* `refreshMetaMaskClient` first when no client promise exists yet, but it
+* guards against a future change silently returning `undefined` instead.
+*/
+var MetaMaskClientNotInitializedError = class extends BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "metamask_client_not_initialized",
+			docsUrl: null,
+			name: "MetaMaskClientNotInitializedError",
+			shortMessage: "MetaMask client not initialized"
+		});
+	}
+};
+
+//#endregion
+//#region src/getMetaMaskSupportedNetworks/getMetaMaskSupportedNetworks.ts
+/**
+* Builds the `api.supportedNetworks` map for MetaMask's multichain client:
+* EVM networks keyed by their CAIP-2 `eip155:<networkId>` scope, SOL networks
+* keyed by their CAIP-2 `solana:<genesisHash>` scope (SOL's `networkId` is an
+* internal routing id, not usable as a CAIP-2 reference).
+*
+* @example
+* ```ts
+* const supportedNetworks = getMetaMaskSupportedNetworks(client);
+* // { 'eip155:1': 'https://...', 'solana:5eykt4...': 'https://...' }
+* ```
+*
+* @returns The RPC URL for every configured EVM/SOL network, keyed by its
+* MetaMask-recognized network identifier.
+* @see getMetaMaskScopes
+* @see createMetaMaskClientInstanceManager
+* @notInstrumented
+*/
+const getMetaMaskSupportedNetworks = (client) => {
+	const { logger } = getCore(client);
+	const networks = getNetworksData(client).filter((network) => SUPPORTED_METAMASK_CHAINS.includes(network.chain));
+	const supportedNetworks = {};
+	for (const network of networks) {
+		if (network.chain === "EVM") supportedNetworks[`eip155:${network.networkId}`] = network.rpcUrls.http[0];
+		if (network.chain === "SOL" && network.genesisHash) supportedNetworks[`solana:${network.genesisHash}`] = network.rpcUrls.http[0];
+	}
+	logger.debug("[MetaMask:Client] Resolved supported networks", { supportedNetworks });
+	return supportedNetworks;
+};
+
+//#endregion
+//#region src/metaMaskStorage/createInitialMetaMaskStoreValue/createInitialMetaMaskStoreValue.ts
+/**
+* Builds the persisted store blob's value for when there is nothing stored
+* yet, or after a clear. A function rather than a shared constant, so every
+* caller gets its own object and can't mutate a value other callers rely on.
+*
+* @example
+* ```ts
+* const initial = createInitialMetaMaskStoreValue();
+* // { entries: {}, schemaVersion: 1 }
+* ```
+*
+* @returns A fresh, empty `MetaMaskStoreValue`.
+* @see createMetaMaskStorageClient
+* @see clearMetaMaskStorage
+* @notInstrumented
+*/
+const createInitialMetaMaskStoreValue = () => ({
+	entries: {},
+	schemaVersion: 1
+});
+
+//#endregion
+//#region src/metaMaskStorage/queueMetaMaskStorageWrite/queueMetaMaskStorageWrite.ts
+/**
+* Single shared queue serializing every read-modify-write against
+* `metaMaskStoreStorageKeySchema` -- `createMetaMaskStorageClient`'s adapter
+* reads/writes/anonId operations and `clearMetaMaskStorage`'s reset all go
+* through this same instance, so a write that started before a clear can't
+* land after it and resurrect the data the clear was meant to erase.
+*
+* @example
+* ```ts
+* await queueMetaMaskStorageWrite(() => storage.setItem(key, value), client);
+* ```
+*
+* @returns A `SequenceQueue` that runs one queued task at a time, in order.
+* @see createMetaMaskStorageClient
+* @see clearMetaMaskStorage
+* @notInstrumented
+*/
+const queueMetaMaskStorageWrite = createSequenceQueue();
+
+//#endregion
+//#region src/metaMaskStorage/metaMaskStorage.schema.ts
+/**
+* Single storage key holding every value the MetaMask multichain SDK writes
+* through our `StoreAdapter` (sessions, nonces, cached accounts/chain,
+* pending pairing requests, transport ids, ...), keyed by whatever key string
+* the SDK itself hands us -- the SDK controls every key name, including ones
+* that embed an unpredictable id (`session:<id>`), so this can't be split
+* into one storage key per SDK key.
+*
+* `entries[ANON_ID_ENTRY_KEY]` also lives in here, alongside `extensionId`
+* and the other transport keys.
+*
+* `clearMetaMaskStorage` resets this key back to its initial value; nothing
+* else needs to know the individual key names the SDK is using.
+*/
+const metaMaskStoreStorageKeySchema = createStorageKeySchema({
+	key: "metaMaskStore",
+	schema: z.object({
+		entries: z.record(z.string(), z.string()),
+		schemaVersion: z.literal(1)
+	})
+});
+/**
+* Reserved `entries` key the MetaMask SDK itself never writes to, used to
+* carry the SDK's anonymous analytics id inside the same store blob.
+*/
+const ANON_ID_ENTRY_KEY = "anonId";
+
+//#endregion
+//#region src/metaMaskStorage/clearMetaMaskStorage/clearMetaMaskStorage.ts
+const FAILED_TO_CLEAR_STORAGE_MESSAGE = "[MetaMask:Session] Failed to clear the persisted store; the next pairing may resume a stale session instead of showing a new one";
+/**
+* Resets the MetaMask SDK's persisted store blob back to its initial
+* (empty) value, so the next connect call starts a fresh pairing and emits a
+* `display_uri` instead of silently resuming a session that no longer works.
+*
+* @example
+* ```ts
+* await clearMetaMaskStorage(client);
+* // Next connectWithMetaMaskUri call will emit a fresh URI immediately.
+* ```
+*
+* @param client - The Dynamic client instance. Required (rather than
+* defaulting to the last-initialized client) so a storage-clear failure is
+* always logged against the client that actually requested it.
+* @returns A promise that resolves once the blob is reset. Never rejects -- a
+* storage failure must not take down the connect flow that depends on it.
+* @see connectWithMetaMaskUri
+* @see createMetaMaskStorageClient
+* @notInstrumented
+*/
+const clearMetaMaskStorage = async (client) => {
+	const { logger, storage } = getCore(client);
+	try {
+		await queueMetaMaskStorageWrite(() => storage.setItem(metaMaskStoreStorageKeySchema, createInitialMetaMaskStoreValue()), client);
+		logger.debug("[MetaMask:Session] Cleared persisted store");
+	} catch (error) {
+		logger.warn(FAILED_TO_CLEAR_STORAGE_MESSAGE, { error });
+	}
+};
+
+//#endregion
+//#region src/errors/MetaMaskStorageError/MetaMaskStorageError.ts
+/** Thrown when the underlying storage service rejects a read/write/delete for the MetaMask multichain client's own store (e.g. quota exceeded, private-browsing restrictions). */
+var MetaMaskStorageError = class extends BaseError {
+	constructor({ cause, key, operation }) {
+		super({
+			cause: cause instanceof Error ? cause : null,
+			code: "metamask_storage_error",
+			docsUrl: null,
+			name: "MetaMaskStorageError",
+			shortMessage: `Failed to ${operation} MetaMask multichain client storage key "${key}"`
+		});
+	}
+};
+
+//#endregion
+//#region src/metaMaskStorage/createMetaMaskStorageClient/createMetaMaskStorageClient.ts
+const TRANSPORT_TYPE_KEY = "multichain-transport";
+const EXTENSION_ID_KEY = "extensionId";
+/** Maps this SDK's platform literal onto the one `@metamask/connect-multichain`'s `StoreAdapter` expects. */
+const toStoreAdapterPlatform = (platform) => platform === "react-native" ? "rn" : "web";
+/**
+* Builds a storage-service-backed store for the MetaMask multichain client,
+* in place of its own default web adapter (IndexedDB) and React Native
+* adapter (raw `AsyncStorage`), so every platform persists through the same
+* core `Storage` service and `clearMetaMaskStorage` can reliably wipe it.
+*
+* The SDK controls every key name it reads/writes through `adapter`,
+* including ones that embed an unpredictable id (`session:<id>`), so every
+* key it uses is folded into a single stored blob (`metaMaskStoreStorageKeySchema`)
+* rather than one storage key per SDK key. `DEBUG` is never persisted at all,
+* answered live from the client's own logger.
+*
+* @example
+* ```ts
+* const storeClient = createMetaMaskStorageClient(client);
+* const multichainClient = createMultichainClient({ storage: storeClient });
+* ```
+*
+* @returns A `StoreClient` backed by the client's core `Storage` service.
+* @throws {MetaMaskStorageError} If the underlying `Storage` service's
+* `getItem`/`setItem` calls fail for any of the adapter's read/write/delete
+* operations.
+* @see createInitialMetaMaskStoreValue
+* @see clearMetaMaskStorage
+* @notInstrumented
+*/
+const createMetaMaskStorageClient = (client) => {
+	const { logger, storage } = getCore(client);
+	const read = async (key) => {
+		try {
+			const { entries } = await storage.getItem(metaMaskStoreStorageKeySchema) ?? createInitialMetaMaskStoreValue();
+			return entries[key] ?? null;
+		} catch (error) {
+			throw new MetaMaskStorageError({
+				cause: error,
+				key,
+				operation: "get"
+			});
+		}
+	};
+	const write = async (key, value) => {
+		try {
+			await queueMetaMaskStorageWrite(async () => {
+				const current = await storage.getItem(metaMaskStoreStorageKeySchema) ?? createInitialMetaMaskStoreValue();
+				await storage.setItem(metaMaskStoreStorageKeySchema, {
+					...current,
+					entries: {
+						...current.entries,
+						[key]: value
+					}
+				});
+			}, client);
+		} catch (error) {
+			throw new MetaMaskStorageError({
+				cause: error,
+				key,
+				operation: "set"
+			});
+		}
+	};
+	const remove = async (key) => {
+		try {
+			await queueMetaMaskStorageWrite(async () => {
+				const current = await storage.getItem(metaMaskStoreStorageKeySchema) ?? createInitialMetaMaskStoreValue();
+				const remainingEntries = Object.fromEntries(Object.entries(current.entries).filter(([entryKey]) => entryKey !== key));
+				await storage.setItem(metaMaskStoreStorageKeySchema, {
+					...current,
+					entries: remainingEntries
+				});
+			}, client);
+		} catch (error) {
+			throw new MetaMaskStorageError({
+				cause: error,
+				key,
+				operation: "delete"
+			});
+		}
+	};
+	const adapter = {
+		delete: remove,
+		get: read,
+		platform: toStoreAdapterPlatform(getPlatform()),
+		set: write
+	};
+	return {
+		adapter,
+		getAnonId: () => queueMetaMaskStorageWrite(async () => {
+			const current = await storage.getItem(metaMaskStoreStorageKeySchema) ?? createInitialMetaMaskStoreValue();
+			const existing = current.entries[ANON_ID_ENTRY_KEY];
+			if (existing) return existing;
+			const anonId = crypto.randomUUID();
+			await storage.setItem(metaMaskStoreStorageKeySchema, {
+				...current,
+				entries: {
+					...current.entries,
+					[ANON_ID_ENTRY_KEY]: anonId
+				}
+			});
+			return anonId;
+		}, client),
+		getDebug: () => Promise.resolve(logger.isEnabled("debug") ? "metamask-sdk:*" : null),
+		getExtensionId: () => adapter.get(EXTENSION_ID_KEY),
+		getTransportType: async () => {
+			const value = await adapter.get(TRANSPORT_TYPE_KEY);
+			return value ? getTransportType(value) : null;
+		},
+		removeAnonId: () => remove(ANON_ID_ENTRY_KEY),
+		removeExtensionId: () => adapter.delete(EXTENSION_ID_KEY),
+		removeTransportType: () => adapter.delete(TRANSPORT_TYPE_KEY),
+		setAnonId: (anonId) => write(ANON_ID_ENTRY_KEY, anonId),
+		setExtensionId: (extensionId) => adapter.set(EXTENSION_ID_KEY, extensionId),
+		setTransportType: (transportType) => adapter.set(TRANSPORT_TYPE_KEY, transportType)
+	};
+};
+
+//#endregion
+//#region src/utils/clearMetaMaskSdkSingleton/clearMetaMaskSdkSingleton.ts
+const METAMASK_SDK_SINGLETON_GLOBAL_KEY = "__METAMASK_CONNECT_MULTICHAIN_SINGLETON__";
+/**
+* Deletes the upstream `@metamask/connect-multichain` SDK's own cached
+* client instance off `globalThis`.
+*
+* The SDK's `createMultichainClient` reuses a private `globalThis` singleton
+* and only merges in a subset of options on repeat calls -- notably not
+* `storage` -- so it keeps talking to its original `StoreAdapter` even after
+* a fresh `clearMetaMaskStorage` call. Deleting this key forces a genuinely
+* new instance (and storage adapter) on the next `createMultichainClient` call.
+*
+* @example
+* ```ts
+* clearMetaMaskSdkSingleton();
+* // Next createMultichainClient call builds a fresh client and adapter.
+* ```
+*
+* @returns Nothing -- the singleton key is deleted synchronously.
+* @see createMetaMaskClientInstanceManager
+* @see clearMetaMaskStorage
+* @notInstrumented
+*/
+const clearMetaMaskSdkSingleton = () => {
+	delete globalThis[METAMASK_SDK_SINGLETON_GLOBAL_KEY];
+};
+
+//#endregion
+//#region src/utils/createMetaMaskPreferredOpenLink/createMetaMaskPreferredOpenLink.ts
+/**
+* Builds the `preferredOpenLink` callback handed to `@metamask/connect-multichain`,
+* routing wallet deeplinks through the core `deeplink` service instead of the
+* SDK's own default handling, so every platform (web, React Native, Expo)
+* opens them the same way the rest of the SDK does.
+*
+* @example
+* ```ts
+* const preferredOpenLink = createMetaMaskPreferredOpenLink(client);
+* preferredOpenLink('https://metamask.app.link/...');
+* ```
+*
+* @returns A callback that opens a MetaMask-issued deeplink through the
+* core `deeplink` service.
+* @see createMetaMaskClientInstanceManager
+* @see createMetaMaskStorageClient
+* @notInstrumented
+*/
+const createMetaMaskPreferredOpenLink = (client) => (deeplink) => {
+	const { logger, openDeeplink } = getCore(client);
+	logger.debug("[MetaMask:Client] Opening MetaMask deeplink", { deeplink });
+	openDeeplink(deeplink).then(() => logger.debug("[MetaMask:Client] Deeplink opened")).catch((error) => logger.error("[MetaMask:Client] Failed to open deeplink", {
+		deeplink,
+		error
+	}));
+};
+
+//#endregion
+//#region src/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/createMetaMaskClientInstanceManager.ts
+/**
+* Creates the per-client manager that lazily builds, tears down, and rebuilds
+* the shared `@metamask/connect-multichain` client instance, and forwards its
+* `display_uri` event to callers that don't hold a reference to the raw SDK
+* client.
+*
+* @example
+* ```ts
+* const manager = createMetaMaskClientInstanceManager(client);
+* const metaMaskClient = await manager.getMetaMaskClient();
+* ```
+*
+* @returns A `MetaMaskClientInstanceManager` scoped to `client`.
+* @throws {MetaMaskClientNotInitializedError} From `getMetaMaskClient` if a
+* build was never started -- a defensive guard, since `refreshMetaMaskClient`
+* always starts one. A build that starts but fails instead rejects
+* `getMetaMaskClient()` with its original error.
+* @see createMetaMaskStorageClient
+* @see clearMetaMaskStorage
+* @notInstrumented
+*/
+const createMetaMaskClientInstanceManager = (client) => {
+	let metaMaskClientPromise;
+	let clearEventListeners;
+	const { logger } = getCore(client);
+	const events = createEventEmitter();
+	const refreshMetaMaskClient = () => {
+		if (metaMaskClientPromise) return;
+		const { appName, appLogoUrl, appUniversalLink, appNativeLink } = getAppMetadata(client);
+		const supportedNetworks = getMetaMaskSupportedNetworks(client);
+		const nativeScheme = getNativeLinkScheme({ nativeLink: appNativeLink });
+		const debug = logger.isEnabled("debug");
+		logger.debug("[MetaMask:Client] Creating MetaMask client", {
+			appLogoUrl,
+			appName,
+			appUniversalLink,
+			debug,
+			nativeScheme,
+			supportedNetworks
+		});
+		if (clearEventListeners) clearEventListeners();
+		clearMetaMaskSdkSingleton();
+		const builtClientPromise = createMultichainClient({
+			api: { supportedNetworks },
+			dapp: {
+				iconUrl: appLogoUrl,
+				name: appName,
+				nativeScheme,
+				url: appUniversalLink ?? ""
+			},
+			debug,
+			mobile: { preferredOpenLink: createMetaMaskPreferredOpenLink(client) },
+			storage: createMetaMaskStorageClient(client),
+			ui: { headless: true }
+		}).then((metaMaskClient) => {
+			const createEventMapper = (event) => {
+				return (...args) => {
+					logger.debug(`[MetaMask:Events] ${event} event received`, { args });
+					events.emit(event, ...args);
+				};
+			};
+			const onDisplayUri = createEventMapper("display_uri");
+			metaMaskClient.on("display_uri", onDisplayUri);
+			const detachListeners = () => {
+				metaMaskClient.off("display_uri", onDisplayUri);
+			};
+			if (metaMaskClientPromise !== builtClientPromise) {
+				detachListeners();
+				return metaMaskClient;
+			}
+			clearEventListeners = detachListeners;
+			return metaMaskClient;
+		});
+		metaMaskClientPromise = builtClientPromise;
+		builtClientPromise.catch(() => {
+			if (metaMaskClientPromise === builtClientPromise) metaMaskClientPromise = null;
+		});
+	};
+	return {
+		clearMetaMaskStorageAndInstance: async () => {
+			await clearMetaMaskStorage(client);
+			metaMaskClientPromise = null;
+			refreshMetaMaskClient();
+		},
+		events,
+		getMetaMaskClient: async () => {
+			if (!metaMaskClientPromise) refreshMetaMaskClient();
+			if (!metaMaskClientPromise) throw new MetaMaskClientNotInitializedError();
+			return metaMaskClientPromise;
+		}
+	};
+};
+
+//#endregion
+//#region src/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager.ts
+const META_MASK_CLIENT_INSTANCE_MANAGER_KEY = "META_MASK_CLIENT_INSTANCE_MANAGER";
+/**
+* Returns this client's `MetaMaskClientInstanceManager`, creating it on first
+* access. Every chain's MetaMask wallet provider (EVM, Solana, ...) calls
+* this to reach the SAME manager -- and therefore the same shared multichain
+* session -- rather than each building its own.
+*
+* @example
+* ```ts
+* const manager = getOrCreateMetaMaskClientInstanceManager(client);
+* const metaMaskClient = await manager.getMetaMaskClient();
+* ```
+* @param client - The Dynamic client instance.
+* @returns The client's `MetaMaskClientInstanceManager`.
+* @see createMetaMaskClientInstanceManager
+* @see disconnectMetaMaskWalletProvider
+*/
+const getOrCreateMetaMaskClientInstanceManager = createRuntimeServiceAccessKey(META_MASK_CLIENT_INSTANCE_MANAGER_KEY, (client) => createMetaMaskClientInstanceManager(client));
+
+//#endregion
+export { UnsupportedMetaMaskChainError as a, name as c, getMetaMaskScopeForNetworkId as i, version as l, clearMetaMaskStorage as n, SUPPORTED_METAMASK_CHAINS as o, getMetaMaskScopes as r, MetaMaskUnscopedNetworkError as s, getOrCreateMetaMaskClientInstanceManager as t };
+//# sourceMappingURL=getOrCreateMetaMaskClientInstanceManager-DbH0IJjn.native.esm.js.map