@dynamic-labs-sdk/evm 1.31.0 → 1.31.2

package/dist/metamask/warnMetaMaskEvmIntegrationIncomplete/warnMetaMaskEvmIntegrationIncomplete.d.ts

@@ -0,0 +1,18 @@
+import type { DynamicClient } from '@dynamic-labs-sdk/client';
+/**
+ * Warns when `addMetaMaskEvmExtension()` hasn't been added, since a wallet
+ * connected via `connectWithMetaMaskUriEvm` without it won't be restored
+ * after a page reload.
+ *
+ * @example
+ * ```ts
+ * warnMetaMaskEvmIntegrationIncomplete(client);
+ * ```
+ * @param client - The Dynamic client instance.
+ * @returns void
+ * @see connectWithMetaMaskUriEvm
+ * @see addMetaMaskEvmExtension
+ * @notInstrumented
+ */
+export declare const warnMetaMaskEvmIntegrationIncomplete: (client: DynamicClient) => void;
+//# sourceMappingURL=warnMetaMaskEvmIntegrationIncomplete.d.ts.map

package/dist/metamask/warnMetaMaskEvmIntegrationIncomplete/warnMetaMaskEvmIntegrationIncomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnMetaMaskEvmIntegrationIncomplete.d.ts","sourceRoot":"","sources":["../../../src/metamask/warnMetaMaskEvmIntegrationIncomplete/warnMetaMaskEvmIntegrationIncomplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAK9D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oCAAoC,GAC/C,QAAQ,aAAa,KACpB,IAeF,CAAC"}

package/dist/metamask.cjs

@@ -1,216 +1,59 @@
-const require_package = require('./package-CIdQu8lB.cjs');
+const require_package = require('./package-cXTEEW7P.cjs');
 const require_evmTransferAmount = require('./evmTransferAmount-Ddvx91b0.cjs');
 require('./createPublicClientFromNetworkData-BAC8YTrK.cjs');
 const require_createWalletProviderFromEIP1193Provider = require('./createWalletProviderFromEIP1193Provider-E1WbEBET.cjs');
-const require_getEvmNetworksData = require('./getEvmNetworksData-DBJIMiOH.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
 let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+let _dynamic_labs_sdk_metamask_core = require("@dynamic-labs-sdk/metamask/core");
 let _dynamic_labs_sdk_metamask = require("@dynamic-labs-sdk/metamask");
-let _metamask_connect_evm = require("@metamask/connect-evm");
 
-//#region src/metamask/utils/getSupportedNetworks/getSupportedNetworks.ts
-/** @notInstrumented */
-const getSupportedNetworks = (client) => {
-	const evmNetworks = require_getEvmNetworksData.getEvmNetworksData(client).sort((a, b) => {
-		if (a.networkId === "1") return -1;
-		if (b.networkId === "1") return 1;
-		return 0;
-	});
-	(0, _dynamic_labs_sdk_client_core.assertNonEmptyArray)(evmNetworks, "No EVM networks have been configured. Make sure to add at least one EVM network to your project settings in the Dynamic Dashboard.");
-	const supportedNetworks = {};
-	for (const network of evmNetworks) {
-		const hexChainId = `0x${Number.parseInt(network.networkId, 10).toString(16)}`;
-		supportedNetworks[hexChainId] = network.rpcUrls.http[0];
-	}
-	return supportedNetworks;
-};
-
-//#endregion
-//#region src/metamask/utils/warnWhenChainNotConfigured/warnWhenChainNotConfigured.ts
-/**
-* Warns when the chain MetaMask reports -- via its `connect` or
-* `chainChanged` events -- is not among the project's configured EVM
-* networks. MetaMask's SDK gates every signing request
-* (`personal_sign`, `eth_sendTransaction`, `eth_signTypedData_v4`) on
-* `supportedNetworks` and throws before the wallet is ever contacted when
-* the chain isn't listed, while `eth_accounts`/`eth_chainId` bypass that
-* gate entirely -- so connect appears to succeed and only signing fails,
-* with no deeplink and no obvious cause. This warn surfaces the mismatch
-* the moment it arises instead of leaving it to be diagnosed from a
-* cryptic signing failure.
-* @notInstrumented
-*/
-const warnWhenChainNotConfigured = ({ chainId, supportedNetworks }, client) => {
-	const configuredChainIds = Object.keys(supportedNetworks);
-	if (configuredChainIds.includes(chainId)) return;
-	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.warn(`[metamask] Wallet chain ${chainId} is not in the project's configured EVM networks (${configuredChainIds.join(", ")}). Signing requests will fail before MetaMask opens until this network is added to your project's EVM networks in the Dynamic Dashboard.`);
-};
-
-//#endregion
-//#region src/metamask/utils/createMetaMaskEvmController/createMetaMaskEvmController.ts
+//#region src/errors/MetaMaskDirectConnectNotSupportedError/MetaMaskDirectConnectNotSupportedError.ts
 /**
-* Builds a fully-initialised `MetaMaskEvmController` for the given Dynamic
-* client. Runs the SDK in headless mode so consumers render their own QR /
-* deep-link surface, and registers `display_uri` handling as an
-* `eventHandlers` callback at construction time so the first URI emission
-* cannot be lost to a subscription race. Dapp metadata is sourced from the
-* client's `getAppMetadata`. The MWP deep-link hand-off is routed through the
-* client's configured `openDeeplink`, so this works on both web and native.
-* The MetaMask SDK's own verbose logging is tied to the Dynamic client's log
-* level, so turning on `debug` logging for the Dynamic SDK also surfaces
-* MetaMask's internal SDK trace output.
-*
-* @notInstrumented
+* Thrown when `connect()` is called directly on the MetaMask SDK placeholder
+* wallet provider (the entry `addMetaMaskEvmExtension` registers so MetaMask
+* still shows up in the wallet picker when no browser extension is
+* installed). That placeholder has no generic connect flow of its own --
+* connecting requires the QR / deeplink pairing flow, so callers must drive
+* `connectWithMetaMaskUriEvm` (or `connectAndVerifyWithMetaMaskUriEvm`)
+* instead of the picker's default connect.
 */
-const createMetaMaskEvmController = async (client) => {
-	const supportedNetworks = getSupportedNetworks(client);
-	const { appName, appLogoUrl, appUniversalLink, appNativeLink } = (0, _dynamic_labs_sdk_client_core.getAppMetadata)(client);
-	const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
-	await (0, _dynamic_labs_sdk_metamask.clearMetaMaskSessionStorage)(client);
-	const listeners = /* @__PURE__ */ new Set();
-	let latestDisplayUri;
-	const sdk = await (0, _metamask_connect_evm.createEVMClient)({
-		api: { supportedNetworks },
-		dapp: {
-			iconUrl: appLogoUrl,
-			name: appName,
-			nativeScheme: (0, _dynamic_labs_sdk_client_core.getNativeLinkScheme)({ nativeLink: appNativeLink }),
-			url: appUniversalLink ?? ""
-		},
-		debug: logger.isEnabled("debug"),
-		eventHandlers: {
-			chainChanged: (chainId) => {
-				warnWhenChainNotConfigured({
-					chainId,
-					supportedNetworks
-				}, client);
-			},
-			connect: ({ chainId }) => {
-				latestDisplayUri = void 0;
-				warnWhenChainNotConfigured({
-					chainId,
-					supportedNetworks
-				}, client);
-			},
-			disconnect: () => {
-				latestDisplayUri = void 0;
-			},
-			displayUri: (uri) => {
-				latestDisplayUri = uri;
-				for (const listener of listeners) listener(uri);
-			}
-		},
-		mobile: { preferredOpenLink: (deeplink) => {
-			const { logger: logger$1 } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
-			logger$1.debug("[metamask] opening MWP deeplink", deeplink);
-			(0, _dynamic_labs_sdk_client_core.getCore)(client).openDeeplink(deeplink).then(() => {
-				logger$1.debug("[metamask] opened MWP deeplink", deeplink);
-			}).catch((error) => {
-				logger$1.warn("[metamask] failed to open MWP deeplink", error);
-			});
-		} },
-		ui: {
-			headless: true,
-			preferExtension: true
-		}
-	});
-	latestDisplayUri = void 0;
-	const onDisplayUri = (listener) => {
-		listeners.add(listener);
-		if (latestDisplayUri !== void 0) listener(latestDisplayUri);
-		return () => {
-			listeners.delete(listener);
-		};
-	};
-	const chainIds = Object.keys(supportedNetworks);
-	let inFlightConnect = null;
-	const connect = () => {
-		if (inFlightConnect) return inFlightConnect;
-		inFlightConnect = (async () => {
-			try {
-				if (sdk.status === "connecting") try {
-					await sdk.disconnect();
-				} catch (error) {
-					(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[metamask] pre-connect disconnect rejected (expected when aborting a pairing the wallet never accepted)", error);
-				}
-				await sdk.connect({ chainIds });
-			} finally {
-				inFlightConnect = null;
-			}
-		})();
-		return inFlightConnect;
-	};
-	return {
-		clearCachedDisplayUri: () => {
-			latestDisplayUri = void 0;
-		},
-		connect,
-		getLatestDisplayUri: () => latestDisplayUri,
-		onDisplayUri,
-		sdk
-	};
+var MetaMaskDirectConnectNotSupportedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "metamask_direct_connect_not_supported",
+			docsUrl: null,
+			name: "MetaMaskDirectConnectNotSupportedError",
+			shortMessage: "MetaMask cannot be connected directly; call connectWithMetaMaskUriEvm (or connectAndVerifyWithMetaMaskUriEvm) to get a QR/URI pairing flow instead"
+		});
+	}
 };
 
 //#endregion
-//#region src/metamask/utils/getOrCreateMetaMaskEvmController/getOrCreateMetaMaskEvmController.ts
-const RUNTIME_SERVICE_KEY = "metaMaskEvmController";
+//#region src/metamask/getMetaMaskEvmSdkWalletProviderKey/getMetaMaskEvmSdkWalletProviderKey.ts
+const METAMASK_EVM_SDK_DISPLAY_NAME = "MetaMask";
 /**
-* Per-`DynamicClient` accessor for the lazily-constructed MetaMask EVM
-* controller. Wraps `createMetaMaskEvmController` with the standard
-* `runtimeServices` cache so every caller — the EIP-1193 wallet-provider
-* façade, the `display_uri` subscription helper, and the
-* `connectWithMetaMaskEvm` URI-returning helper — shares the same
-* controller (and therefore the same SDK instance, display-URI cache, and
-* listener registry) per Dynamic client.
-*
-* This matches the pattern used by the WalletConnect `getSignClient`
-* accessor: the first call triggers construction; subsequent calls
-* (within the same client) return the cached promise without re-running
-* the builder.
-*
-* The cache is **per-Dynamic-client, not per-SDK-instance**:
-* `@metamask/connect-evm`'s `createEVMClient` is itself a singleton —
-* a second call returns the same underlying SDK — so when multiple
-* Dynamic clients coexist they end up sharing the same MetaMask SDK
-* instance (and therefore the same active pairing session) regardless
-* of this cache. The wrapper exists to own the controller's
-* `display_uri` cache and listener registry per Dynamic client, which
-* the SDK itself does not expose.
+* Deterministic wallet provider key for the MetaMask SDK's connect-less EVM
+* placeholder. Computed without building the wallet provider itself, so
+* `addMetaMaskEvmExtension` can check for a matching wallet account before
+* paying the cost of `createMetaMaskEvmWalletProvider`.
 *
+* @example
+* ```ts
+* const key = getMetaMaskEvmSdkWalletProviderKey();
+* ```
+* @returns The deterministic wallet provider key.
+* @see createMetaMaskEvmWalletProvider
+* @see reconcileMetaMaskWalletProvider
 * @notInstrumented
 */
-const getOrCreateMetaMaskEvmController = (0, _dynamic_labs_sdk_client_core.createRuntimeServiceAccessKey)(RUNTIME_SERVICE_KEY, (client) => createMetaMaskEvmController(client));
-
-//#endregion
-//#region src/metamask/utils/subscribeMetaMaskEvmFacadeListener/subscribeMetaMaskEvmFacadeListener.ts
-const NOOP_UNSUBSCRIBE = () => void 0;
-/**
-* Subscribes a facade listener to the underlying MetaMask SDK provider,
-* forwarding events through per-event adapters:
-*
-* - `accountsChanged` — clones the readonly addresses array
-*   `@metamask/connect-evm` hands the listener, since the Dynamic SDK
-*   facade contract emits a mutable `Address[]`.
-* - `chainChanged` — passes the chain id through verbatim.
-* - `disconnected` — bridged to the SDK's canonical `disconnect`
-*   event, which the SDK actually emits.
-*
-* Returns the unsubscribe function returned by the SDK provider so the
-* caller can clean it up later (for example, when the facade's
-* `removeAllListeners` is invoked).
-*
-* @notInstrumented
-*/
-const subscribeMetaMaskEvmFacadeListener = ({ client, pending, provider }) => {
-	if (pending.event === "accountsChanged") return provider.on("accountsChanged", (addresses) => pending.listener([...addresses]));
-	if (pending.event === "chainChanged") return provider.on("chainChanged", (chainId) => pending.listener(chainId));
-	if (pending.event === "disconnected") return provider.on("disconnect", () => pending.listener());
-	const exhaustiveCheck = pending;
-	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[metamask] subscribeMetaMaskEvmFacadeListener: unhandled event", exhaustiveCheck.event);
-	return NOOP_UNSUBSCRIBE;
-};
+const getMetaMaskEvmSdkWalletProviderKey = () => (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+	chain: "EVM",
+	displayName: METAMASK_EVM_SDK_DISPLAY_NAME,
+	walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode
+});
 
 //#endregion
 //#region src/metamask/createMetaMaskEvmWalletProvider/createMetaMaskEvmWalletProvider.ts
@@ -219,70 +62,149 @@ const METAMASK_ICON = `${_dynamic_labs_sdk_client_core.DYNAMIC_ICONIC_SPRITE_URL
 /**
 * Builds the `EvmWalletProvider` registered AFTER a successful MetaMask
 * SDK URI pairing. Wraps the SDK's EIP-1193 provider behind the Dynamic
-* facade (`disconnect` → `disconnected` event bridge, `removeAllListeners`
-* shim) and drops `connect` so the provider is filtered out of the
+* facade and drops `connect` so the provider is filtered out of the
 * wallet picker by `getAvailableWalletProvidersData` — mirroring how
 * WalletConnect URI sessions register a signing-only provider. The facade's
 * `request` also traces dispatch/resolution at debug level, since a signing
 * request that never gets a deep-link back to the wallet otherwise leaves
 * no signal on the Dynamic side.
 *
+* `on` is a no-op: the facade doesn't yet bridge MetaMask's own
+* `accountsChanged`/`chainChanged`/`disconnected` events through to the
+* EIP-1193 listener contract.
+*
+* `switchActiveNetwork` routes through `assertMetaMaskNetworkIsGranted`
+* before persisting -- see its inline comment for why (every configured
+* network is an *optional* MetaMask scope, so signing/sending calls on an
+* ungranted one would otherwise fail). The facade's `request` similarly
+* routes its active-network lookup through `resolveActiveMetaMaskScope`
+* rather than reading the registry directly, so a default network MetaMask
+* never granted self-heals before it reaches a real signing/sending call.
+*
+* `switchActiveNetwork`/`disconnectWalletAccount` are local, Dynamic-side
+* actions with no live wallet event to bridge, so they emit `networkChanged`/
+* `disconnected` themselves via `metaMaskEvents` -- otherwise `events` would
+* never fire for MetaMask at all (unlike every other EVM wallet provider,
+* whose events come from bridging the wallet's own EIP-1193 events).
+*
 * @notInstrumented
 */
-const createMetaMaskEvmWalletProvider = async (client) => {
-	const controller = await getOrCreateMetaMaskEvmController(client);
-	if (controller.sdk.getAccount() === void 0) throw new _dynamic_labs_sdk_metamask.MetaMaskWalletNotConnectedError();
-	const provider = controller.sdk.getProvider();
-	const subscriberCleanups = /* @__PURE__ */ new Set();
-	return {
-		...require_createWalletProviderFromEIP1193Provider.createWalletProviderFromEIP1193Provider({
-			displayName: METAMASK_DISPLAY_NAME,
-			eip1193: {
-				on: (event, listener) => {
-					const pending = {
-						event,
-						listener
-					};
-					subscriberCleanups.add(subscribeMetaMaskEvmFacadeListener({
-						client,
-						pending,
-						provider
-					}));
-				},
-				removeAllListeners: () => {
-					for (const unsubscribe of subscriberCleanups) try {
-						unsubscribe();
-					} catch (error) {
-						(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.error("[metamask] removeAllListeners: unsubscribe failed", error);
-					}
-					subscriberCleanups.clear();
-				},
-				request: async (request) => {
-					const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
-					logger.debug("[metamask] eip1193 request dispatched", {
+const createMetaMaskEvmWalletProvider = (client) => {
+	const metaMaskClientInstanceManager = (0, _dynamic_labs_sdk_metamask_core.getOrCreateMetaMaskClientInstanceManager)(client);
+	const walletProviderKey = getMetaMaskEvmSdkWalletProviderKey();
+	const metaMaskEvents = (0, _dynamic_labs_sdk_metamask_core.createMetaMaskWalletProviderEventEmitter)();
+	const walletProvider = require_createWalletProviderFromEIP1193Provider.createWalletProviderFromEIP1193Provider({
+		displayName: METAMASK_DISPLAY_NAME,
+		eip1193: {
+			on: () => {},
+			removeAllListeners: () => {},
+			request: async (request) => {
+				const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+				const metaMaskClient = await metaMaskClientInstanceManager.getMetaMaskClient();
+				try {
+					const { networkId } = await (0, _dynamic_labs_sdk_metamask_core.resolveActiveMetaMaskScope)({
+						chain: "EVM",
+						metaMaskClient,
+						walletProviderKey
+					}, client);
+					logger.debug("[MetaMask:Provider] eip1193 request dispatched", {
 						method: request.method,
-						status: controller.sdk.status
+						networkId,
+						status: metaMaskClient.status
+					});
+					if (request.method === "eth_chainId") return `0x${Number(networkId).toString(16)}`;
+					const result = await metaMaskClient.invokeMethod({
+						request,
+						scope: `eip155:${networkId}`
 					});
-					try {
-						const result = await provider.request(request);
-						logger.debug("[metamask] eip1193 request resolved", { method: request.method });
-						return result;
-					} catch (error) {
-						logger.warn("[metamask] eip1193 request rejected", {
-							error,
-							method: request.method
-						});
-						throw error;
-					}
+					logger.debug("[MetaMask:Provider] eip1193 request resolved", { method: request.method });
+					return result;
+				} catch (error) {
+					logger.warn("[MetaMask:Provider] eip1193 request rejected", {
+						error,
+						method: request.method
+					});
+					throw error;
 				}
-			},
-			icon: METAMASK_ICON,
-			walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode
-		}, client),
-		connect: void 0
+			}
+		},
+		icon: METAMASK_ICON,
+		walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode
+	}, client);
+	const switchActiveNetwork = async ({ networkId }) => {
+		await (0, _dynamic_labs_sdk_metamask_core.assertMetaMaskNetworkIsGranted)({
+			chain: "EVM",
+			metaMaskClient: await metaMaskClientInstanceManager.getMetaMaskClient(),
+			networkId
+		}, client);
+		const { networkId: previousNetworkId } = await (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+			client,
+			walletProviderKey
+		});
+		await (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+			client,
+			networkId,
+			walletProviderKey
+		});
+		if (networkId !== previousNetworkId) metaMaskEvents.emitNetworkChanged({ networkId });
+	};
+	const disconnectWalletAccount = async () => {
+		await (0, _dynamic_labs_sdk_metamask_core.disconnectMetaMaskWalletProvider)({
+			chain: "EVM",
+			walletProviderKey
+		}, client);
+		metaMaskEvents.emitDisconnected();
+	};
+	const destroy = async (args) => {
+		await walletProvider.destroy?.(args);
+		metaMaskEvents.cleanupEventEmitter();
+	};
+	return {
+		...walletProvider,
+		connect: async () => {
+			throw new MetaMaskDirectConnectNotSupportedError();
+		},
+		destroy,
+		disconnectWalletAccount,
+		get events() {
+			return metaMaskEvents.getEventEmitter();
+		},
+		switchActiveNetwork
 	};
 };
 
+//#endregion
+//#region src/metamask/addMetaMaskEvmExtension/addMetaMaskEvmExtension.ts
+const METAMASK_EVM_EXTENSION_KEY = "metaMaskEvm";
+/**
+* Integrates MetaMask Connect (MetaMask's multichain SDK) with the Dynamic
+* client for EVM, letting users connect MetaMask on platforms where the
+* browser extension isn't available — e.g. scanning a QR code, or opening
+* the MetaMask mobile app from a website or React Native app. Call this
+* once during setup.
+*
+* @example
+* ```ts
+* const client = createDynamicClient({ environmentId: '...' });
+*
+* addMetaMaskEvmExtension(client);
+* ```
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns void
+* @see connectWithMetaMaskUriEvm
+* @see addEvmExtension
+* @notInstrumented
+*/
+const addMetaMaskEvmExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: METAMASK_EVM_EXTENSION_KEY }, client)) return;
+	require_evmTransferAmount.registerEvmNetworkProviderBuilder(client);
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: METAMASK_EVM_EXTENSION_KEY }, client);
+	(0, _dynamic_labs_sdk_metamask_core.reconcileMetaMaskWalletProvider)({
+		walletProviderBuilder: createMetaMaskEvmWalletProvider,
+		walletProviderKey: getMetaMaskEvmSdkWalletProviderKey()
+	}, client);
+};
+
 //#endregion
 //#region src/metamask/connectAndVerifyWithMetaMaskUriEvm/connectAndVerifyWithMetaMaskUriEvm.ts
 /**
@@ -304,7 +226,6 @@ const connectAndVerifyWithMetaMaskUriEvm = async (client = (0, _dynamic_labs_sdk
 	const { approval, uri } = await (0, _dynamic_labs_sdk_metamask.connectWithMetaMaskUri)({
 		addToDynamicWalletAccounts: false,
 		chain: "EVM",
-		getController: getOrCreateMetaMaskEvmController,
 		walletProviderBuilder: createMetaMaskEvmWalletProvider
 	}, client);
 	const verifiedApproval = async () => {
@@ -319,6 +240,35 @@ const connectAndVerifyWithMetaMaskUriEvm = async (client = (0, _dynamic_labs_sdk
 	};
 };
 
+//#endregion
+//#region src/metamask/warnMetaMaskEvmIntegrationIncomplete/warnMetaMaskEvmIntegrationIncomplete.ts
+/**
+* Warns when `addMetaMaskEvmExtension()` hasn't been added, since a wallet
+* connected via `connectWithMetaMaskUriEvm` without it won't be restored
+* after a page reload.
+*
+* @example
+* ```ts
+* warnMetaMaskEvmIntegrationIncomplete(client);
+* ```
+* @param client - The Dynamic client instance.
+* @returns void
+* @see connectWithMetaMaskUriEvm
+* @see addMetaMaskEvmExtension
+* @notInstrumented
+*/
+const warnMetaMaskEvmIntegrationIncomplete = (client) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: METAMASK_EVM_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.warn(`MetaMask integration is incomplete: addMetaMaskEvmExtension() is missing. Add it during setup:
+
+import { addMetaMaskEvmExtension } from '@dynamic-labs-sdk/evm/metamask';
+import { createDynamicClient } from '@dynamic-labs-sdk/client';
+
+const client = createDynamicClient({ environmentId: '...' });
+
+addMetaMaskEvmExtension(client);`);
+};
+
 //#endregion
 //#region src/metamask/connectWithMetaMaskUriEvm/connectWithMetaMaskUriEvm.ts
 /**
@@ -332,11 +282,11 @@ const connectAndVerifyWithMetaMaskUriEvm = async (client = (0, _dynamic_labs_sdk
 * @notInstrumented
 */
 const connectWithMetaMaskUriEvm = ({ addToDynamicWalletAccounts = true } = {}, client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	warnMetaMaskEvmIntegrationIncomplete(client);
 	require_evmTransferAmount.registerEvmNetworkProviderBuilder(client);
 	return (0, _dynamic_labs_sdk_metamask.connectWithMetaMaskUri)({
 		addToDynamicWalletAccounts,
 		chain: "EVM",
-		getController: getOrCreateMetaMaskEvmController,
 		walletProviderBuilder: createMetaMaskEvmWalletProvider
 	}, client);
 };
@@ -353,18 +303,51 @@ const connectWithMetaMaskUriEvm = ({ addToDynamicWalletAccounts = true } = {}, c
 */
 const getMetaMaskEvmExtensionWalletProviderKey = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => (0, _dynamic_labs_sdk_metamask.getMetaMaskExtensionWalletProviderKey)({ chain: "EVM" }, client);
 
+//#endregion
+//#region src/metamask/registerMetaMaskEvmUriConnectionStarter/registerMetaMaskEvmUriConnectionStarter.ts
+/**
+* Registers the MetaMask SDK URI pairing for EVM with the client, so higher
+* level connection APIs can mint a MetaMask URI for EVM without depending on
+* this package.
+*
+* Call it during app setup to opt into the MetaMask URI path — it is kept out
+* of the EVM extension so apps that never pair with MetaMask over a URI don't
+* bundle the MetaMask SDK.
+*
+* @example
+* ```ts
+* registerMetaMaskEvmUriConnectionStarter();
+* ```
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns Nothing.
+* @see connectWithMetaMaskUriEvm
+* @see getUriConnectionStarterRegistry
+* @notInstrumented
+*/
+const registerMetaMaskEvmUriConnectionStarter = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	(0, _dynamic_labs_sdk_client_core.getUriConnectionStarterRegistry)(client).register({
+		chain: "EVM",
+		start: ({ addToDynamicWalletAccounts }) => connectWithMetaMaskUriEvm({ addToDynamicWalletAccounts }, client),
+		type: "metamaskSdkUri"
+	});
+};
+
 //#endregion
 //#region src/exports/metamask.ts
 (0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(require_package.name, require_package.version);
 
 //#endregion
+exports.MetaMaskDirectConnectNotSupportedError = MetaMaskDirectConnectNotSupportedError;
 Object.defineProperty(exports, 'MetaMaskDisplayUriMissingError', {
   enumerable: true,
   get: function () {
     return _dynamic_labs_sdk_metamask.MetaMaskDisplayUriMissingError;
   }
 });
+exports.addMetaMaskEvmExtension = addMetaMaskEvmExtension;
 exports.connectAndVerifyWithMetaMaskUriEvm = connectAndVerifyWithMetaMaskUriEvm;
 exports.connectWithMetaMaskUriEvm = connectWithMetaMaskUriEvm;
 exports.getMetaMaskEvmExtensionWalletProviderKey = getMetaMaskEvmExtensionWalletProviderKey;
+exports.registerMetaMaskEvmUriConnectionStarter = registerMetaMaskEvmUriConnectionStarter;
 //# sourceMappingURL=metamask.cjs.map