@dynamic-labs-sdk/metamask 1.31.0 → 1.31.2

package/dist/assertMetaMaskNetworkIsGranted/assertMetaMaskNetworkIsGranted.d.ts

@@ -0,0 +1,37 @@
+import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';
+import type { MultichainCore } from '@metamask/connect-multichain';
+export type AssertMetaMaskNetworkIsGrantedParams = {
+    chain: Chain;
+    metaMaskClient: MultichainCore;
+    networkId: string;
+};
+/**
+ * Guards a MetaMask wallet provider's `switchActiveNetwork` against ever
+ * pointing at a network MetaMask didn't actually grant an account for.
+ * Every configured network is requested as an *optional* CAIP-25 scope (see
+ * `getMetaMaskScopes`), so MetaMask may silently approve only a subset --
+ * switching the active network to one outside that subset would leave every
+ * subsequent signing/sending call targeting a scope the wallet will reject.
+ *
+ * @example
+ * ```ts
+ * await assertMetaMaskNetworkIsGranted(
+ *   { chain: 'SOL', metaMaskClient, networkId: '103' },
+ *   client
+ * );
+ * // Throws MetaMaskUnscopedNetworkError if MetaMask never granted an
+ * // account for network "103" in the current session.
+ * ```
+ *
+ * @param client - The Dynamic client instance whose logger this reports
+ * against.
+ * @returns A promise that resolves once the target network is confirmed granted.
+ * @throws {MetaMaskUnscopedNetworkError} If `networkId` has no granted
+ * account in the current session (including when it has no configured
+ * MetaMask scope at all).
+ * @see resolveActiveMetaMaskScope
+ * @see MetaMaskUnscopedNetworkError
+ * @notInstrumented
+ */
+export declare const assertMetaMaskNetworkIsGranted: ({ chain, metaMaskClient, networkId }: AssertMetaMaskNetworkIsGrantedParams, client: DynamicClient) => Promise<void>;
+//# sourceMappingURL=assertMetaMaskNetworkIsGranted.d.ts.map

package/dist/assertMetaMaskNetworkIsGranted/assertMetaMaskNetworkIsGranted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertMetaMaskNetworkIsGranted.d.ts","sourceRoot":"","sources":["../../src/assertMetaMaskNetworkIsGranted/assertMetaMaskNetworkIsGranted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAMnE,MAAM,MAAM,oCAAoC,GAAG;IACjD,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,8BAA8B,yCACH,oCAAoC,UAClE,aAAa,KACpB,OAAO,CAAC,IAAI,CA6Bd,CAAC"}

package/dist/assertMetaMaskNetworkIsGranted/index.d.ts

@@ -0,0 +1,2 @@
+export { assertMetaMaskNetworkIsGranted } from './assertMetaMaskNetworkIsGranted';
+//# sourceMappingURL=index.d.ts.map

package/dist/assertMetaMaskNetworkIsGranted/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assertMetaMaskNetworkIsGranted/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.d.ts

@@ -1,9 +1,9 @@
 import type { DynamicClient } from '@dynamic-labs-sdk/client';
 /**
- * Deletes the MetaMask SDK's IndexedDB session storage so the next connect call
- * emits a fresh `display_uri` synchronously instead of spending the SDK's
- * 10-second resume timeout reviving a dead pairing. Safe in SSR (no-op) and
- * when the DB is held open by another tab (resolves on `blocked`).
+ * Resets the MetaMask SDK's persisted session so the next connect call
+ * emits a fresh `display_uri` instead of resuming a stale pairing.
+ *
+ * @deprecated The clearMetaMaskSessionStorage is not needed anymore since the SDK itself will handle the storage
  *
  * @example
  * ```ts
@@ -14,9 +14,9 @@ import type { DynamicClient } from '@dynamic-labs-sdk/client';
  * @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 database is deleted (or immediately in SSR).
+ * @returns A promise that resolves once the persisted session is reset.
  * @see connectWithMetaMaskUri
- * @see getMetaMaskExtensionWalletProviderKey
+ * @see createMetaMaskClientInstanceManager
  * @notInstrumented
  */
 export declare const clearMetaMaskSessionStorage: (client: DynamicClient) => Promise<void>;

package/dist/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clearMetaMaskSessionStorage.d.ts","sourceRoot":"","sources":["../../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAY9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,WAG9B,aAAa,KACpB,OAAO,CAAC,IAAI,CA2Bd,CAAC"}
+{"version":3,"file":"clearMetaMaskSessionStorage.d.ts","sourceRoot":"","sources":["../../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAI9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,WAE9B,aAAa,KACpB,OAAO,CAAC,IAAI,CAAiC,CAAC"}

package/dist/connectWithMetaMaskUri/connectWithMetaMaskUri.d.ts

@@ -1,19 +1,16 @@
 import type { Chain, DynamicClient, WalletProviderUriConnectionResult } from '@dynamic-labs-sdk/client';
 import type { WalletProvider } from '@dynamic-labs-sdk/client/core';
-import type { MetaMaskController } from '../metamask.types';
 export type ConnectWithMetaMaskUriParams = {
     /** Whether to add the connected wallet account to the Dynamic client. Defaults to `true`. */
     addToDynamicWalletAccounts?: boolean;
     /** Chain being connected; used to scope the extension-installed lookup. */
     chain: Chain;
-    /** Returns the chain-specific `MetaMaskController` that drives the pairing. */
-    getController: (client: DynamicClient) => Promise<MetaMaskController>;
     /**
      * Builds the chain-specific `WalletProvider` AFTER the pairing has been
      * approved. Must NOT include a `connect` method — the provider is registered
      * purely for signing routing and would otherwise leak into the wallet picker.
      */
-    walletProviderBuilder: (client: DynamicClient) => Promise<WalletProvider>;
+    walletProviderBuilder: (client: DynamicClient) => WalletProvider;
 };
 /**
  * Drives a MetaMask SDK pairing for any chain and returns `{ approval, uri }`
@@ -28,23 +25,21 @@ export type ConnectWithMetaMaskUriParams = {
  * ```ts
  * const { uri, approval } = await connectWithMetaMaskUri({
  *   chain: 'EVM',
- *   getController: (client) => getEvmMetaMaskController(client),
  *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),
  * });
  * // Render QR code with `uri`, then await approval()
  * ```
  *
  * @param params.chain - Chain being connected; used to scope the extension-installed lookup.
- * @param params.getController - Returns the chain-specific MetaMaskController for the pairing.
  * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.
  * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.
  * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
  * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).
  * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.
  * @throws {NoAddressFoundError} If no address is returned after pairing approval.
- * @see clearMetaMaskSessionStorage
+ * @see clearMetaMaskStorage
  * @see getMetaMaskExtensionWalletProviderKey
  * @notInstrumented
  */
-export declare const connectWithMetaMaskUri: ({ addToDynamicWalletAccounts, chain, getController, walletProviderBuilder, }: ConnectWithMetaMaskUriParams, client?: DynamicClient) => Promise<WalletProviderUriConnectionResult>;
+export declare const connectWithMetaMaskUri: ({ addToDynamicWalletAccounts, chain, walletProviderBuilder, }: ConnectWithMetaMaskUriParams, client?: DynamicClient) => Promise<WalletProviderUriConnectionResult>;
 //# sourceMappingURL=connectWithMetaMaskUri.d.ts.map

package/dist/connectWithMetaMaskUri/connectWithMetaMaskUri.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connectWithMetaMaskUri.d.ts","sourceRoot":"","sources":["../../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,aAAa,EAEb,iCAAiC,EAClC,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAapE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,MAAM,4BAA4B,GAAG;IACzC,6FAA6F;IAC7F,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2EAA2E;IAC3E,KAAK,EAAE,KAAK,CAAC;IACb,+EAA+E;IAC/E,aAAa,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACtE;;;;OAIG;IACH,qBAAqB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC3E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,sBAAsB,iFAM9B,4BAA4B,WACvB,aAAa,KACpB,OAAO,CAAC,iCAAiC,CAmF3C,CAAC"}
+{"version":3,"file":"connectWithMetaMaskUri.d.ts","sourceRoot":"","sources":["../../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,aAAa,EAEb,iCAAiC,EAClC,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAgBpE,MAAM,MAAM,4BAA4B,GAAG;IACzC,6FAA6F;IAC7F,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2EAA2E;IAC3E,KAAK,EAAE,KAAK,CAAC;IACb;;;;OAIG;IACH,qBAAqB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,cAAc,CAAC;CAClE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,sBAAsB,kEAK9B,4BAA4B,WACvB,aAAa,KACpB,OAAO,CAAC,iCAAiC,CA8G3C,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Chain } from '@dynamic-labs-sdk/client';
+/**
+ * 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.
+ */
+export declare const SUPPORTED_METAMASK_CHAINS: Chain[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAqB,KAAK,EAAE,CAAC"}

package/dist/core.cjs

@@ -0,0 +1,465 @@
+const require_getOrCreateMetaMaskClientInstanceManager = require('./getOrCreateMetaMaskClientInstanceManager-C2FCB8yy.cjs');
+let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+
+//#region src/getScopeAccountsFromMetaMaskClient/getScopeAccountsFromMetaMaskClient.ts
+/**
+* Reads the accounts MetaMask granted for a single CAIP-2 scope out of the
+* current session, replacing direct `provider.getSession()` access so chain
+* packages never touch the raw session shape. Empty when there's no session
+* or the scope wasn't granted.
+*
+* @example
+* ```ts
+* const accounts = await getScopeAccountsFromMetaMaskClient(
+*   { metaMaskClient, scope: 'eip155:1' },
+*   client
+* );
+* // ['eip155:1:0x...']
+* ```
+*
+* @param client - The Dynamic client instance whose logger this reports
+* against. Required (rather than defaulting to the last-initialized client)
+* so a missing/empty-scope result is always traceable to the client that
+* requested it.
+* @returns The accounts granted for `scope`, or an empty array if there's no
+* session or the scope wasn't granted.
+* @see createMetaMaskMultichainClient
+* @see getGrantedMetaMaskScopes
+* @notInstrumented
+*/
+const getScopeAccountsFromMetaMaskClient = async ({ metaMaskClient, scope }, client) => {
+	const session = await metaMaskClient.provider.getSession();
+	const accounts = session?.sessionScopes[scope]?.accounts ?? [];
+	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[MetaMask:Scopes] Resolved scope accounts", {
+		accountCount: accounts.length,
+		hasSession: session != null,
+		scope
+	});
+	return accounts;
+};
+
+//#endregion
+//#region src/assertMetaMaskNetworkIsGranted/assertMetaMaskNetworkIsGranted.ts
+/**
+* Guards a MetaMask wallet provider's `switchActiveNetwork` against ever
+* pointing at a network MetaMask didn't actually grant an account for.
+* Every configured network is requested as an *optional* CAIP-25 scope (see
+* `getMetaMaskScopes`), so MetaMask may silently approve only a subset --
+* switching the active network to one outside that subset would leave every
+* subsequent signing/sending call targeting a scope the wallet will reject.
+*
+* @example
+* ```ts
+* await assertMetaMaskNetworkIsGranted(
+*   { chain: 'SOL', metaMaskClient, networkId: '103' },
+*   client
+* );
+* // Throws MetaMaskUnscopedNetworkError if MetaMask never granted an
+* // account for network "103" in the current session.
+* ```
+*
+* @param client - The Dynamic client instance whose logger this reports
+* against.
+* @returns A promise that resolves once the target network is confirmed granted.
+* @throws {MetaMaskUnscopedNetworkError} If `networkId` has no granted
+* account in the current session (including when it has no configured
+* MetaMask scope at all).
+* @see resolveActiveMetaMaskScope
+* @see MetaMaskUnscopedNetworkError
+* @notInstrumented
+*/
+const assertMetaMaskNetworkIsGranted = async ({ chain, metaMaskClient, networkId }, client) => {
+	const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const scope = require_getOrCreateMetaMaskClientInstanceManager.getMetaMaskScopeForNetworkId({
+		chain,
+		networkId
+	}, client);
+	const accounts = scope ? await getScopeAccountsFromMetaMaskClient({
+		metaMaskClient,
+		scope
+	}, client) : [];
+	logger.debug("[MetaMask:Scopes] Checked whether target network is granted", {
+		accountCount: accounts.length,
+		chain,
+		networkId,
+		scope
+	});
+	if (accounts.length === 0) {
+		logger.warn("[MetaMask:Scopes] Rejected switch to an unscoped network", {
+			chain,
+			networkId,
+			scope
+		});
+		throw new require_getOrCreateMetaMaskClientInstanceManager.MetaMaskUnscopedNetworkError({
+			networkId,
+			scope: scope ?? "unknown"
+		});
+	}
+};
+
+//#endregion
+//#region src/createMetaMaskWalletProviderEventEmitter/createMetaMaskWalletProviderEventEmitter.ts
+/**
+* MetaMask's multichain session never triggers `createWalletProviderEventEmitter`'s
+* usual external-listener flow -- there is no live wallet event to bridge, only our
+* own local actions (e.g. `switchActiveNetwork`) that need to notify subscribers
+* themselves. `setupEventListeners` here just captures the handler references so
+* they can be invoked directly, instead of from a real event source.
+*
+* @example
+* ```ts
+* const metaMaskEvents = createMetaMaskWalletProviderEventEmitter();
+* metaMaskEvents.getEventEmitter().on('networkChanged', ({ networkId }) => {});
+* metaMaskEvents.emitNetworkChanged({ networkId: '137' });
+* ```
+* @returns A `MetaMaskWalletProviderEventEmitter` ready to emit synthetic
+* `networkChanged`/`disconnected` events.
+* @see MetaMaskWalletProviderEventEmitter
+* @see createWalletProviderEventEmitter
+* @notInstrumented
+*/
+const createMetaMaskWalletProviderEventEmitter = () => {
+	let handleDisconnected;
+	let handleNetworkChanged;
+	const emitter = (0, _dynamic_labs_sdk_client_core.createWalletProviderEventEmitter)({
+		removeEventListeners: () => {},
+		setupEventListeners: (handlers) => {
+			handleDisconnected = handlers.handleDisconnected;
+			handleNetworkChanged = handlers.handleNetworkChanged;
+		},
+		supportedEvents: ["disconnected", "networkChanged"]
+	});
+	emitter.getEventEmitter();
+	return {
+		...emitter,
+		emitDisconnected: () => handleDisconnected(),
+		emitNetworkChanged: (params) => handleNetworkChanged(params)
+	};
+};
+
+//#endregion
+//#region src/disconnectMetaMaskWalletProvider/disconnectMetaMaskWalletProvider.ts
+/**
+* Shared `disconnectWalletAccount` for every chain's MetaMask wallet provider
+* (EVM, Solana, ...). `getOrCreateMetaMaskClientInstanceManager` hands every chain
+* the SAME client instance -- one multichain session shared across chains --
+* so this only asks MetaMask to drop this chain's own scopes rather than
+* tearing the whole session down under a still-connected chain.
+*
+* `disconnect`'s teardown in `@metamask/connect-multichain` is itself
+* scope-aware: it only actually ends the shared session once every chain's
+* scopes are gone, reflected by `metaMaskClient.status` flipping to
+* `'disconnected'`. Only then do we clear the persisted session and evict
+* the cached client, so a chain that's still connected is left untouched.
+*
+* @example
+* ```ts
+* await disconnectMetaMaskWalletProvider(
+*   { chain: 'EVM', walletProviderKey: 'metamask-evm' },
+*   client
+* );
+* ```
+* @param params.chain - Chain of the wallet account being disconnected.
+* @param params.walletProviderKey - Key of the chain-specific wallet provider to unregister.
+* @param client - The Dynamic client instance. Required (rather than
+* defaulting to the last-initialized client) since this always runs from
+* inside an already-resolved chain wallet provider, which already has one.
+* @returns A promise that resolves once local cleanup is done. Never rejects
+* on the remote signal failing -- that's logged, not surfaced, since the
+* wallet account is being removed either way.
+* @see clearMetaMaskStorage
+* @see getMetaMaskScopes
+* @notInstrumented
+*/
+const disconnectMetaMaskWalletProvider = async ({ chain, walletProviderKey }, client) => {
+	const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const metaMaskClient = await require_getOrCreateMetaMaskClientInstanceManager.getOrCreateMetaMaskClientInstanceManager(client).getMetaMaskClient();
+	const scopes = require_getOrCreateMetaMaskClientInstanceManager.getMetaMaskScopes({ chain }, client);
+	logger.debug("[MetaMask:Disconnect] Disconnecting wallet account", {
+		chain,
+		scopes,
+		walletProviderKey
+	});
+	try {
+		await metaMaskClient.disconnect(scopes);
+	} catch (error) {
+		logger.error("[MetaMask:Disconnect] Remote signal failed", {
+			error,
+			walletProviderKey
+		});
+	}
+	(0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client).unregister(walletProviderKey);
+	logger.debug("[MetaMask:Disconnect] Shared session status after disconnect", {
+		status: metaMaskClient.status,
+		walletProviderKey
+	});
+	if (metaMaskClient.status === "disconnected") await require_getOrCreateMetaMaskClientInstanceManager.clearMetaMaskStorage(client);
+};
+
+//#endregion
+//#region src/reconcileMetaMaskWalletProvider/reconcileMetaMaskWalletProvider.ts
+/**
+* Keeps a chain's MetaMask SDK wallet provider registered for as
+* long as the user has a wallet account under its exact key, and
+* unregisters it once that wallet account disappears (e.g. on disconnect).
+* This is needed because always adding the MetaMask SDK wallet provider
+* would conflict with the browser extension wallet provider, so we only add
+* it once the user has a wallet account that was connected via QR code.
+* The placeholder is only built (via `walletProviderBuilder`) the first time
+* it must be registered, mirroring how WalletConnect only builds a wallet
+* provider for a session that actually exists.
+*
+* @example
+* ```ts
+* reconcileMetaMaskWalletProvider(
+*   {
+*     walletProviderBuilder: createMetaMaskEvmWalletProvider,
+*     walletProviderKey: getMetaMaskEvmSdkWalletProviderKey(),
+*   },
+*   client
+* );
+* ```
+* @param params.walletProviderBuilder - Builds the SDK placeholder wallet provider once it must be registered.
+* @param params.walletProviderKey - The placeholder's deterministic wallet provider key.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns void
+* @see connectWithMetaMaskUri
+* @see WalletProviderPriority
+* @notInstrumented
+*/
+const reconcileMetaMaskWalletProvider = ({ walletProviderBuilder, walletProviderKey }, client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const walletProviderRegistry = (0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client);
+	const reconcile = () => {
+		const isSdkPlaceholderRegistered = walletProviderRegistry.getByKey(walletProviderKey) !== void 0;
+		const shouldBeRegistered = (0, _dynamic_labs_sdk_client.getWalletAccounts)(client).some((walletAccount) => walletAccount.walletProviderKey === walletProviderKey);
+		if (isSdkPlaceholderRegistered && !shouldBeRegistered) {
+			walletProviderRegistry.unregister(walletProviderKey);
+			return;
+		}
+		if (!isSdkPlaceholderRegistered && shouldBeRegistered) walletProviderRegistry.register({
+			priority: _dynamic_labs_sdk_client_core.WalletProviderPriority.WALLET_SDK,
+			walletProvider: walletProviderBuilder(client)
+		});
+	};
+	(0, _dynamic_labs_sdk_client.onEvent)({
+		event: "walletAccountsChanged",
+		listener: () => reconcile()
+	}, client);
+	reconcile();
+};
+
+//#endregion
+//#region src/getGrantedMetaMaskScopes/getGrantedMetaMaskScopes.ts
+/**
+* Enumerates every CAIP-2 scope in the current session that MetaMask
+* actually granted at least one account for. Every scope requested at
+* `connect()` time (see `getMetaMaskScopes`) is sent as an *optional*
+* CAIP-25 scope, never a required one, so MetaMask is free to approve only a
+* subset -- `session.sessionScopes` still has a key for every requested
+* scope, just with an empty `accounts` array for the ones that weren't
+* granted. This filters those out, replacing direct `provider.getSession()`
+* access so chain packages never touch the raw session shape.
+*
+* @example
+* ```ts
+* const granted = await getGrantedMetaMaskScopes({ metaMaskClient }, client);
+* // [{ scope: 'eip155:1', accounts: ['eip155:1:0x...'] }]
+* ```
+*
+* @param client - The Dynamic client instance whose logger this reports
+* against. Required (rather than defaulting to the last-initialized client)
+* so an empty result is always traceable to the client that requested it.
+* @returns The scopes with at least one granted account, and their accounts.
+* @see createMetaMaskMultichainClient
+* @see resolveActiveMetaMaskScope
+* @notInstrumented
+*/
+const getGrantedMetaMaskScopes = async ({ metaMaskClient }, client) => {
+	const session = await metaMaskClient.provider.getSession();
+	const sessionScopes = session?.sessionScopes ?? {};
+	const grantedScopes = Object.entries(sessionScopes).filter(([, scopeData]) => (scopeData.accounts ?? []).length > 0).map(([scope, scopeData]) => ({
+		accounts: scopeData.accounts ?? [],
+		scope
+	}));
+	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[MetaMask:Scopes] Resolved granted scopes", {
+		grantedScopeCount: grantedScopes.length,
+		hasSession: session != null
+	});
+	return grantedScopes;
+};
+
+//#endregion
+//#region src/getNetworkIdFromMetaMaskScope/getNetworkIdFromMetaMaskScope.ts
+/**
+* Reverse of `getMetaMaskScopeForNetworkId`: maps a granted CAIP-2 scope
+* back to the Dynamic `networkId` it came from, for the given chain.
+*
+* Returns `undefined` -- not a throw -- when `scope` doesn't belong to
+* `chain` (e.g. an `eip155:` scope while scanning for `SOL`). For `SOL`,
+* this also covers a `solana:` scope matching no configured network. This
+* is the normal, expected outcome when scanning a session's granted scopes
+* for a single chain: a MetaMask multichain session is shared across every
+* connected chain
+*
+* @example
+* ```ts
+* const networkId = getNetworkIdFromMetaMaskScope(
+*   { chain: 'EVM', scope: 'eip155:1' },
+*   client
+* );
+* // '1'
+* ```
+*
+* @returns The matching Dynamic `networkId`, or `undefined` if `scope`
+* doesn't belong to `chain` (or, for `SOL`, matches no configured network).
+* @see getMetaMaskScopeForNetworkId
+* @see resolveActiveMetaMaskScope
+* @throws {UnsupportedMetaMaskChainError} If `chain` isn't a chain MetaMask
+* scopes can be built for.
+* @notInstrumented
+*/
+const getNetworkIdFromMetaMaskScope = ({ chain, scope }, client) => {
+	const [namespace, reference] = scope.split(":");
+	if (chain === "EVM") return namespace === "eip155" ? reference : void 0;
+	if (chain === "SOL") {
+		if (namespace !== "solana") return;
+		return (0, _dynamic_labs_sdk_client.getNetworksData)(client).find((candidate) => candidate.chain === "SOL" && candidate.genesisHash === reference)?.networkId;
+	}
+	throw new require_getOrCreateMetaMaskClientInstanceManager.UnsupportedMetaMaskChainError({
+		chain,
+		supportedChains: require_getOrCreateMetaMaskClientInstanceManager.SUPPORTED_METAMASK_CHAINS
+	});
+};
+
+//#endregion
+//#region src/resolveActiveMetaMaskScope/resolveActiveMetaMaskScope.ts
+/**
+* Resolves the network a MetaMask wallet provider should treat as active,
+* self-healing when the last-known-active network (see
+* `getActiveNetworkIdFromLastKnownRegistry`) turns out to have no granted
+* account.
+*
+* Every configured network is requested as an *optional* CAIP-25 scope (see
+* `getMetaMaskScopes`), so MetaMask is free to grant an account for only a
+* subset -- and the registry's own default (the first configured network for
+* the chain) has no awareness of which subset that was. If the active
+* network's scope is empty, this scans every OTHER scope this chain
+* requested, restricted to the ones MetaMask actually granted, and adopts
+* whichever is found (preferring a non-testnet network) as the new active
+* network -- persisting the correction so future calls don't repeat the
+* scan. If nothing was granted for this chain at all, the original
+* (accounts: []) result is returned unchanged, preserving the existing
+* "no address found" behavior when there's truly nothing to fall back to.
+*
+* @example
+* ```ts
+* const { accounts } = await resolveActiveMetaMaskScope(
+*   { chain: 'SOL', metaMaskClient, walletProviderKey },
+*   client
+* );
+* // accounts is non-empty even if the registry's default network wasn't
+* // the one MetaMask actually granted.
+* ```
+*
+* @param [client] - The Dynamic client instance whose logger this reports
+* against. Required (rather than defaulting to the last-initialized client)
+* so a fallback decision is always traceable to the client that requested it.
+* @returns The resolved active network's id, CAIP-2 scope, and granted accounts.
+* @see assertMetaMaskNetworkIsGranted
+* @see getGrantedMetaMaskScopes
+* @notInstrumented
+*/
+const resolveActiveMetaMaskScope = async ({ chain, metaMaskClient, walletProviderKey }, client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const { networkId: activeNetworkId } = await (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+		client,
+		walletProviderKey
+	});
+	const activeScope = require_getOrCreateMetaMaskClientInstanceManager.getMetaMaskScopeForNetworkId({
+		chain,
+		networkId: activeNetworkId
+	}, client);
+	const activeAccounts = activeScope ? await getScopeAccountsFromMetaMaskClient({
+		metaMaskClient,
+		scope: activeScope
+	}, client) : [];
+	if (activeAccounts.length > 0) {
+		logger.debug("[MetaMask:Scopes] Active network scope already has granted accounts", {
+			activeNetworkId,
+			chain,
+			scope: activeScope
+		});
+		return {
+			accounts: activeAccounts,
+			networkId: activeNetworkId,
+			scope: activeScope
+		};
+	}
+	logger.debug("[MetaMask:Scopes] Active network scope has no granted accounts, scanning other requested scopes for this chain", {
+		activeNetworkId,
+		chain,
+		scope: activeScope
+	});
+	const requestedScopes = new Set(require_getOrCreateMetaMaskClientInstanceManager.getMetaMaskScopes({ chain }, client));
+	const grantedScopes = await getGrantedMetaMaskScopes({ metaMaskClient }, client);
+	const configuredNetworks = (0, _dynamic_labs_sdk_client.getNetworksData)(client).filter((network) => network.chain === chain);
+	const testnetByNetworkId = new Map(configuredNetworks.map((network) => [network.networkId, network.testnet]));
+	const configuredOrderByNetworkId = new Map(configuredNetworks.map((network, index) => [network.networkId, index]));
+	const candidates = grantedScopes.filter(({ scope }) => requestedScopes.has(scope)).flatMap(({ accounts, scope }) => {
+		const networkId = getNetworkIdFromMetaMaskScope({
+			chain,
+			scope
+		}, client);
+		return networkId ? [{
+			accounts,
+			networkId,
+			scope
+		}] : [];
+	}).sort((a, b) => (configuredOrderByNetworkId.get(a.networkId) ?? 0) - (configuredOrderByNetworkId.get(b.networkId) ?? 0));
+	const fallback = candidates.find(({ networkId }) => !testnetByNetworkId.get(networkId)) ?? candidates[0];
+	if (fallback === void 0) {
+		logger.debug("[MetaMask:Scopes] No granted scope with accounts found for chain", {
+			activeNetworkId,
+			chain,
+			requestedScopes: [...requestedScopes]
+		});
+		return {
+			accounts: activeAccounts,
+			networkId: activeNetworkId,
+			scope: activeScope
+		};
+	}
+	logger.debug("[MetaMask:Scopes] Falling back to a granted scope after the active scope had no accounts", {
+		activeNetworkId,
+		activeScope,
+		chain,
+		fallbackNetworkId: fallback.networkId,
+		fallbackScope: fallback.scope
+	});
+	await (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+		client,
+		networkId: fallback.networkId,
+		walletProviderKey
+	});
+	return {
+		accounts: fallback.accounts,
+		networkId: fallback.networkId,
+		scope: fallback.scope
+	};
+};
+
+//#endregion
+//#region src/exports/core.ts
+(0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(require_getOrCreateMetaMaskClientInstanceManager.name, require_getOrCreateMetaMaskClientInstanceManager.version);
+
+//#endregion
+exports.assertMetaMaskNetworkIsGranted = assertMetaMaskNetworkIsGranted;
+exports.clearMetaMaskStorage = require_getOrCreateMetaMaskClientInstanceManager.clearMetaMaskStorage;
+exports.createMetaMaskWalletProviderEventEmitter = createMetaMaskWalletProviderEventEmitter;
+exports.disconnectMetaMaskWalletProvider = disconnectMetaMaskWalletProvider;
+exports.getOrCreateMetaMaskClientInstanceManager = require_getOrCreateMetaMaskClientInstanceManager.getOrCreateMetaMaskClientInstanceManager;
+exports.reconcileMetaMaskWalletProvider = reconcileMetaMaskWalletProvider;
+exports.resolveActiveMetaMaskScope = resolveActiveMetaMaskScope;
+//# sourceMappingURL=core.cjs.map