@dynamic-labs-sdk/client 1.31.0 → 1.31.2

package/dist/index.cjs

@@ -1,10 +1,10 @@
-const require_logoutWithReason = require('./logoutWithReason-DlA15deT.cjs');
-const require_migrateFromFireblocks = require('./migrateFromFireblocks-CqIpxGRS.cjs');
-const require_waas = require('./waas-BOKafCeH.cjs');
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-BoNAPSjx.cjs');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-C2o5idph.cjs');
-const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-BRTOnK8V.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-yM84r7l7.cjs');
+const require_logoutWithReason = require('./logoutWithReason-C_T7KddM.cjs');
+const require_migrateFromFireblocks = require('./migrateFromFireblocks-C9Kuke5V.cjs');
+const require_waas = require('./waas-Bxsd0-HG.cjs');
+const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-DueBnAl6.cjs');
+const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-Bx0HlvfW.cjs');
+const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-7GzNYU2g.cjs');
+const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-DnKzPDZk.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
@@ -557,7 +557,7 @@ const initializeClient = async (client = require_logoutWithReason.getDefaultClie
 		*/
 		if (require_logoutWithReason.isCookieEnabled(client)) await require_logoutWithReason.__refreshAuth_wrapped(client).catch(async (error) => {
 			if (error.status === 401) {
-				core.logger.error("Session expired during initialization", error);
+				core.logger.warn("Session expired during initialization", error);
 				if (client.user) await require_logoutWithReason.__logoutWithReason_wrapped({ reason: "session-refresh-unauthorized" }, client);
 			} else throw error;
 		});
@@ -1204,6 +1204,46 @@ const __createDynamicClient_wrapped = require_logoutWithReason.instrumentFunctio
 	}
 });
 
+//#endregion
+//#region src/errors/AmbiguousWalletChainError.ts
+/**
+* Thrown when a wallet can be connected on more than one of the client's
+* enabled chains and no chain was passed to `connectWallet`.
+*
+* Multi-chain wallets such as MetaMask or Phantom connect to a different
+* account per chain, so the chain has to be an explicit choice rather than one
+* Dynamic makes on the customer's behalf.
+*
+* @example
+* ```ts
+* try {
+*   await connectWallet({ walletKey: 'phantom' });
+* } catch (error) {
+*   if (error instanceof AmbiguousWalletChainError) {
+*     await connectWallet({ chain: 'SOL', walletKey: 'phantom' });
+*   }
+* }
+* ```
+* @see connectWallet
+* @see getWalletOptionsCatalogue
+*/
+var AmbiguousWalletChainError = class extends require_logoutWithReason.BaseError {
+	constructor({ chains, walletKey }) {
+		super({
+			cause: null,
+			code: "ambiguous_wallet_chain",
+			docsUrl: null,
+			metaMessages: [
+				`Wallet key: ${walletKey}`,
+				`Available chains: ${chains.join(", ")}`,
+				"Pass the chain param to pick which one to connect on."
+			],
+			name: "AmbiguousWalletChainError",
+			shortMessage: `Wallet ${walletKey} can be connected on more than one chain, so the chain param is required.`
+		});
+	}
+};
+
 //#endregion
 //#region src/errors/CheckoutSessionTokenMissingError.ts
 var CheckoutSessionTokenMissingError = class extends require_logoutWithReason.BaseError {
@@ -1603,6 +1643,54 @@ var NoAddressFoundError = class extends require_logoutWithReason.BaseError {
 	}
 };
 
+//#endregion
+//#region src/errors/NoConnectionOptionAvailableError.ts
+/**
+* Thrown when a wallet exists in the catalogue but has no connection option
+* this client can drive.
+*
+* Happens when the wallet is not installed on the device and no URI pairing is
+* available for it — either the wallet does not support one, or the chain
+* extension providing that pairing was not added to the client.
+*
+* @example
+* ```ts
+* try {
+*   await connectWallet({ walletKey: 'rainbow' });
+* } catch (error) {
+*   if (error instanceof NoConnectionOptionAvailableError) {
+*     promptWalletInstall(error.installationUrls);
+*   }
+* }
+* ```
+* @see connectWallet
+* @see getWalletOptionsCatalogue
+*/
+var NoConnectionOptionAvailableError = class extends require_logoutWithReason.BaseError {
+	/**
+	* Install / download links for the wallet, when the wallet book carries any
+	* for this device. Prompt the user to install the wallet with these.
+	*/
+	installationUrls;
+	constructor({ chain, installationUrls, walletKey }) {
+		super({
+			cause: null,
+			code: "no_connection_option_available",
+			docsUrl: null,
+			metaMessages: [
+				`Wallet key: ${walletKey}`,
+				...chain ? [`Chain: ${chain}`] : [],
+				"The wallet is not installed and no URI pairing is available for it on this client.",
+				"URI pairing requires the chain extension that provides it — addWalletConnect<Chain>Extension for WalletConnect, addMetaMask<Chain>Extension for MetaMask.",
+				"Use this error's installationUrls to prompt the user to install the wallet."
+			],
+			name: "NoConnectionOptionAvailableError",
+			shortMessage: `No connection option available for wallet: ${walletKey}`
+		});
+		this.installationUrls = installationUrls;
+	}
+};
+
 //#endregion
 //#region src/errors/NoPasskeyCredentialsFoundError.ts
 var NoPasskeyCredentialsFoundError = class extends require_logoutWithReason.BaseError {
@@ -1797,6 +1885,46 @@ var WalletAccountNotSelectedError = class extends require_logoutWithReason.BaseE
 	}
 };
 
+//#endregion
+//#region src/errors/WalletOptionNotFoundError.ts
+/**
+* Thrown when `connectWallet` is given a wallet key that no wallet option in
+* the catalogue matches.
+*
+* A wallet is only surfaced for the chains this client has an extension for, so
+* this also covers keys that are valid in the wallet book but not reachable
+* with the client's current chain extensions.
+*
+* @example
+* ```ts
+* try {
+*   await connectWallet({ walletKey: 'metmask' });
+* } catch (error) {
+*   if (error instanceof WalletOptionNotFoundError) {
+*     showUnknownWalletMessage();
+*   }
+* }
+* ```
+* @see connectWallet
+* @see getWalletOptionsCatalogue
+*/
+var WalletOptionNotFoundError = class extends require_logoutWithReason.BaseError {
+	constructor({ walletKey }) {
+		super({
+			cause: null,
+			code: "wallet_option_not_found",
+			docsUrl: null,
+			metaMessages: [
+				`Wallet key: ${walletKey}`,
+				"The key must match a wallet option surfaced by getWalletOptionsCatalogue (e.g. \"metamask\", \"phantom\").",
+				"A wallet is only surfaced on chains this client has an extension for, so make sure the relevant chain extension is added."
+			],
+			name: "WalletOptionNotFoundError",
+			shortMessage: `No wallet option found for key: ${walletKey}`
+		});
+	}
+};
+
 //#endregion
 //#region src/errors/WalletProviderMethodUnavailableError.ts
 var WalletProviderMethodUnavailableError = class extends require_logoutWithReason.BaseError {
@@ -2522,6 +2650,10 @@ const __authenticateWithSocial_wrapped = require_logoutWithReason.instrumentFunc
 * browser. Calling it during server-side rendering (no `window`) throws
 * `UnavailableInServerSideError`.
 *
+* @param [params.expectedState] - When given, the parameters are only removed
+* while the current URL still carries this `dynamicOauthState`. Use it to
+* clean up after a specific callback without touching a newer one that has
+* meanwhile landed in the address bar.
 * @returns Nothing. The current URL is rewritten in place via
 * `window.history.replaceState`.
 *
@@ -2541,9 +2673,12 @@ const __authenticateWithSocial_wrapped = require_logoutWithReason.instrumentFunc
 *
 * @notInstrumented
 */
-const clearSocialRedirectParams = () => {
+const clearSocialRedirectParams = ({ expectedState } = {}) => {
 	if (require_getNetworkProviderFromNetworkId.isServerSideRendering()) throw new require_getNetworkProviderFromNetworkId.UnavailableInServerSideError("clearSocialRedirectParams");
-	window.history.replaceState({}, "", removeDynamicOauthParamsFromUrl(window.location.href));
+	const currentHref = window.location.href;
+	const currentState = new URL(currentHref).searchParams.get("dynamicOauthState");
+	if (expectedState !== void 0 && currentState !== expectedState) return;
+	window.history.replaceState({}, "", removeDynamicOauthParamsFromUrl(currentHref));
 };
 
 //#endregion
@@ -2627,6 +2762,14 @@ const __processSocialCallback_wrapped = require_logoutWithReason.instrumentFunct
 * authenticating (or linking) the user with the social provider. This is the
 * final step after `signInWithSocialRedirect` + `detectSocialRedirectUrl`.
 *
+* A callback URL whose stored redirect state is missing or does not match can
+* never complete, so its OAuth parameters are stripped from the browser URL
+* before the error is rethrown. Callers that decide whether to complete a
+* redirect by inspecting the URL therefore see the failure once instead of
+* retrying the same doomed callback on every render. The clean-up is scoped to
+* the state of the callback it failed on, so a newer callback sitting in the
+* address bar is left alone.
+*
 * @example
 * ```ts
 * const redirectUrl = detectSocialRedirectUrl();
@@ -2640,16 +2783,30 @@ const __processSocialCallback_wrapped = require_logoutWithReason.instrumentFunct
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the authenticated user or null.
 * @throws MissingSocialUrlParamError If required OAuth parameters are missing.
+* @throws MissingRedirectStorageStateError If no stored redirect state exists.
 * @throws InvalidRedirectStorageStateError If the stored state doesn't match.
 * @see signInWithSocialRedirect
 * @see detectSocialRedirectUrl
 * @see clearSocialRedirectParams
 * @instrumented
 */
-const completeSocialRedirect = ({ url, requestedScopes }, client = require_logoutWithReason.getDefaultClient()) => __processSocialCallback_wrapped({
-	requestedScopes,
-	url
-}, client);
+const completeSocialRedirect = async ({ url, requestedScopes }, client = require_logoutWithReason.getDefaultClient()) => {
+	try {
+		return await __processSocialCallback_wrapped({
+			requestedScopes,
+			url
+		}, client);
+	} catch (error) {
+		const hasUnusableRedirectState = error instanceof MissingRedirectStorageStateError || error instanceof InvalidRedirectStorageStateError;
+		const failedState = url.searchParams.get("dynamicOauthState");
+		if (hasUnusableRedirectState && failedState !== null) try {
+			clearSocialRedirectParams({ expectedState: failedState });
+		} catch (clearError) {
+			require_logoutWithReason.getCore(client).logger.debug("[completeSocialRedirect] failed to clear the social redirect params", clearError);
+		}
+		throw error;
+	}
+};
 const __completeSocialRedirect_impl = completeSocialRedirect;
 const __completeSocialRedirect_wrapped = require_logoutWithReason.instrumentFunction({
 	fn: __completeSocialRedirect_impl,
@@ -7242,20 +7399,46 @@ const hasAllGoogleDriveBackupScopes = (grantedScopes) => findMissingGoogleDriveB
 const isInsufficientGoogleDriveScopesError = (err) => err instanceof Error && err.message.includes(ACCESS_DENIED_PHRASE);
 
 //#endregion
-//#region src/utils/isMobile/isMobile.ts
+//#region src/utils/isAndroid/isAndroid.ts
+/**
+* Tells whether the SDK is running on Android.
+*
+* The operating system comes from {@link getOperatingSystem}, which reads
+* `Platform.OS` in React Native and the user agent on web.
+*
+* @example
+* ```ts
+* if (isAndroid()) {
+*   return installationUrls.android;
+* }
+* ```
+*
+* @returns `true` when the current device runs Android.
+* @see getOperatingSystem
+* @see isIOS
+* @notInstrumented
+*/
+const isAndroid = () => require_logoutWithReason.getOperatingSystem() === "android";
+
+//#endregion
+//#region src/utils/userAgentChecks/userAgentChecks.ts
 /**
 * Sourced from http://detectmobilebrowsers.com/
+*
+* iOS devices are matched by {@link isIOSUserAgent} instead of a bare `ios`
+* alternative, which would also match unrelated words such as `kiosk`.
 * @notInstrumented
 */
-const userAgentRegex1 = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ios|ipad|playbook|silk/i;
+const userAgentRegex1 = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i;
 const userAgentRegex2 = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i;
-/** @notInstrumented */
-const isMobile = (maxTouchPointsOverride) => {
-	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
-	return userAgentRegex1.test(navigator.userAgent) || userAgentRegex2.test(navigator.userAgent.substring(0, 4)) || isIPad(maxTouchPointsOverride) || isIPhone();
-};
-/** @notInstrumented */
-const isIPhone = () => typeof window === "undefined" || typeof navigator === "undefined" ? false : /iPhone|ios/.test(navigator.userAgent);
+/**
+* Matches the device names Apple's handhelds report, plus the standalone `ios`
+* token that embedded web views and custom in-app browsers use in place of a
+* device name. The token must stand alone so that unrelated words containing
+* `ios` (`kiosk`, for instance) don't match.
+* @notInstrumented
+*/
+const isIOSUserAgent = () => typeof window === "undefined" || typeof navigator === "undefined" ? false : /iPhone|iPod|(?:^|[^a-z])ios(?:[^a-z]|$)/i.test(navigator.userAgent);
 /**
 * @param [optional] maxTouchPointsOverride - this is used for testing since
 * it seems that JSDOM doesn't support maxTouchPoints, so it was impossible
@@ -7268,13 +7451,11 @@ const isIPad = (maxTouchPointsOverride) => {
 	return /iPad/.test(navigator.userAgent) || /Mac/.test(navigator.userAgent) && maxTouchPoints === 5;
 };
 /** @notInstrumented */
-const isIOS = (maxTouchPointsOverride) => {
+const isMobileUserAgent = (maxTouchPointsOverride) => {
 	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
-	return isIPhone() || isIPad(maxTouchPointsOverride);
+	return userAgentRegex1.test(navigator.userAgent) || userAgentRegex2.test(navigator.userAgent.substring(0, 4)) || isIPad(maxTouchPointsOverride) || isIOSUserAgent();
 };
 /** @notInstrumented */
-const isAndroid = () => isMobile() && !isIOS();
-/** @notInstrumented */
 const isSafariBrowser = () => {
 	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
 	const { userAgent } = navigator;
@@ -7301,6 +7482,31 @@ const isChromeBrowser = () => {
 	return /\bChrome\//.test(navigator.userAgent) && !isEdgeBrowser() && !isOperaBrowser();
 };
 
+//#endregion
+//#region src/utils/isIOS/isIOS.ts
+/**
+* Tells whether the SDK is running on iOS or iPadOS.
+*
+* The operating system comes from {@link getOperatingSystem}, which reads
+* `Platform.OS` in React Native and the user agent on web. Two user agents
+* escape it: an iPad in desktop mode announces itself as macOS, and embedded
+* web views may carry a lowercase `ios` token instead of a device name.
+*
+* @example
+* ```ts
+* if (isIOS()) {
+*   return installationUrls.ios;
+* }
+* ```
+*
+* @returns `true` when the current device runs iOS or iPadOS.
+* @see getOperatingSystem
+* @see isIPad
+* @see isIOSUserAgent
+* @notInstrumented
+*/
+const isIOS = () => require_logoutWithReason.getOperatingSystem() === "ios" || isIOSUserAgent() || isIPad();
+
 //#endregion
 //#region src/modules/walletOptionsCatalogue/getInstallationLinkForCurrentPlatform/getInstallationLinkForCurrentPlatform.ts
 /**
@@ -7341,6 +7547,77 @@ const getInstallationLinkForCurrentPlatform = ({ installationUrls }) => {
 	if (isChromeBrowser()) return installationUrls.chrome;
 };
 
+//#endregion
+//#region src/modules/wallets/networks/getEnabledChains/getEnabledChains.ts
+/**
+* Returns the chains this client can operate on — a chain is enabled once
+* one of its extensions has been added (`addEvmExtension`,
+* `addSolanaExtension`, …), since every chain extension registers a
+* network provider builder for its chain.
+*
+* Reading the builder registry keeps chain awareness out of the client
+* package: the set is whatever the extensions registered, so no
+* chain-specific branch is needed here.
+*
+* @param client - The Dynamic client instance.
+* @returns The set of chains the client has an extension for.
+* @example
+* ```typescript
+* // client created with addEvmExtension only
+* getEnabledChains(client); // Set { 'EVM' }
+* ```
+* @see {@link getNetworkProviderBuilderRegistry} for the registry the chains are read from.
+* @see {@link getNetworkProviders} for the other consumer of that registry.
+* @notInstrumented
+*/
+const getEnabledChains = (client) => {
+	const networkProviderBuilderRegistry = require_getNetworkProviderFromNetworkId.getNetworkProviderBuilderRegistry(client);
+	return new Set(networkProviderBuilderRegistry.get().keys());
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/getWalletConnectCatalog/getChainsFromWalletSchema/getChainsFromWalletSchema.ts
+/**
+* Returns every chain a wallet book entry advertises support for —
+* deduped, in `injectedConfig` order, then `chains` order. Used by the
+* catalogue's WalletConnect builder so a multi-chain wallet (e.g. Trust
+* supports EVM + SOL) gets one option per chain rather than one option
+* for whichever chain `getChainFromWalletSchema` happened to pick first.
+*
+* Falls back to {@link getChainFromWalletSchema}'s single-result behavior
+* (`['EVM']` default) when neither field is populated, so the helper
+* never returns an empty array — every eligible wallet emits at least
+* one option.
+*
+* @param params.wallet - The wallet schema from the wallet book.
+* @param [params.walletKey] - The wallet key identifier (used as last-resort fallback).
+* @returns Ordered, deduped array of Chains.
+* @notInstrumented
+*/
+const getChainsFromWalletSchema = ({ wallet, walletKey }) => {
+	const chains = /* @__PURE__ */ new Set();
+	for (const entry of wallet.injectedConfig ?? []) {
+		if (!entry.chain) continue;
+		const chain = getChainFromWalletBookIdentifier({ identifier: entry.chain });
+		if (chain) chains.add(chain);
+	}
+	for (const identifier of wallet.chains ?? []) {
+		const prefix = extractChainPrefix({ chainIdentifier: identifier });
+		try {
+			const chain = require_logoutWithReason.getChainFromVerifiedCredentialChain(prefix);
+			chains.add(chain);
+		} catch {}
+	}
+	if (chains.size === 0) {
+		const chain = getChainFromWalletSchema({
+			wallet,
+			walletKey
+		});
+		chains.add(chain);
+	}
+	return Array.from(chains);
+};
+
 //#endregion
 //#region src/modules/walletOptionsCatalogue/resolveWalletBookWalletOptionKey/resolveWalletBookWalletOptionKey.ts
 /**
@@ -7386,11 +7663,17 @@ const getInAppBrowserUrl = ({ wallet }) => wallet.mobile?.inAppBrowserV2 ?? wall
 * and injected-only wallets are dropped — so the catalogue's notion of
 * "external wallet" stays consistent across option types.
 *
+* A wallet's in-app browser opens a single session, so it emits one option
+* tagged with the first chain it advertises that the client has an
+* extension for — a multi-chain wallet is still reachable when only one of
+* its chains is enabled.
+*
+* @param params.enabledChains - Chains the client has an extension for.
 * @param params.walletBook - The fetched wallet book.
 * @returns Tagged `inAppBrowser` options paired with their wallet option keys.
 * @notInstrumented
 */
-const buildInAppBrowserOptions = ({ walletBook }) => {
+const buildInAppBrowserOptions = ({ enabledChains, walletBook }) => {
 	const result = [];
 	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
 		if (shouldFilterWallet({
@@ -7399,12 +7682,14 @@ const buildInAppBrowserOptions = ({ walletBook }) => {
 		})) continue;
 		const url = getInAppBrowserUrl({ wallet });
 		if (!url) continue;
+		const chain = getChainsFromWalletSchema({
+			wallet,
+			walletKey
+		}).find((advertisedChain) => enabledChains.has(advertisedChain));
+		if (!chain) continue;
 		result.push({
 			option: {
-				chain: getChainFromWalletSchema({
-					wallet,
-					walletKey
-				}),
+				chain,
 				type: "inAppBrowser",
 				url
 			},
@@ -7477,17 +7762,25 @@ const hasAnyInstallationUrl = ({ urls }) => Object.values(urls).some(Boolean);
 * Reuses the generic `shouldFilterWallet` rules so embedded wallets do
 * not appear here either — they're not user-installable products.
 *
+* Wallets that advertise no chain this client has an extension for are
+* skipped: installing them would not make them connectable.
+*
+* @param params.enabledChains - Chains the client has an extension for.
 * @param params.walletBook - The fetched wallet book.
 * @returns A map from wallet option key to its install URL bag.
 * @notInstrumented
 */
-const buildInstallationUrlsByWalletOptionKey = ({ walletBook }) => {
+const buildInstallationUrlsByWalletOptionKey = ({ enabledChains, walletBook }) => {
 	const map = /* @__PURE__ */ new Map();
 	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
 		if (shouldFilterWallet({
 			wallet,
 			walletKey
 		})) continue;
+		if (!getChainsFromWalletSchema({
+			wallet,
+			walletKey
+		}).some((chain) => enabledChains.has(chain))) continue;
 		const urls = buildInstallationUrls({ wallet });
 		if (!hasAnyInstallationUrl({ urls })) continue;
 		const walletOptionKey = resolveWalletBookWalletOptionKey({
@@ -7579,49 +7872,6 @@ const buildMetaMaskSdkUriOptions = ({ walletBook }) => {
 	return [];
 };
 
-//#endregion
-//#region src/modules/legacyWalletBook/getWalletConnectCatalog/getChainsFromWalletSchema/getChainsFromWalletSchema.ts
-/**
-* Returns every chain a wallet book entry advertises support for —
-* deduped, in `injectedConfig` order, then `chains` order. Used by the
-* catalogue's WalletConnect builder so a multi-chain wallet (e.g. Trust
-* supports EVM + SOL) gets one option per chain rather than one option
-* for whichever chain `getChainFromWalletSchema` happened to pick first.
-*
-* Falls back to {@link getChainFromWalletSchema}'s single-result behavior
-* (`['EVM']` default) when neither field is populated, so the helper
-* never returns an empty array — every eligible wallet emits at least
-* one option.
-*
-* @param params.wallet - The wallet schema from the wallet book.
-* @param [params.walletKey] - The wallet key identifier (used as last-resort fallback).
-* @returns Ordered, deduped array of Chains.
-* @notInstrumented
-*/
-const getChainsFromWalletSchema = ({ wallet, walletKey }) => {
-	const chains = /* @__PURE__ */ new Set();
-	for (const entry of wallet.injectedConfig ?? []) {
-		if (!entry.chain) continue;
-		const chain = getChainFromWalletBookIdentifier({ identifier: entry.chain });
-		if (chain) chains.add(chain);
-	}
-	for (const identifier of wallet.chains ?? []) {
-		const prefix = extractChainPrefix({ chainIdentifier: identifier });
-		try {
-			const chain = require_logoutWithReason.getChainFromVerifiedCredentialChain(prefix);
-			chains.add(chain);
-		} catch {}
-	}
-	if (chains.size === 0) {
-		const chain = getChainFromWalletSchema({
-			wallet,
-			walletKey
-		});
-		chains.add(chain);
-	}
-	return Array.from(chains);
-};
-
 //#endregion
 //#region src/modules/walletOptionsCatalogue/buildWalletConnectOptions/buildWalletConnectOptions.ts
 /**
@@ -8006,6 +8256,31 @@ const buildWithWalletProviderOptions = ({ entries, walletBook }, client) => {
 */
 const EXCLUDED_WALLET_OPTION_KEYS = new Set(["coinbase", "coinbasewallet"]);
 
+//#endregion
+//#region src/modules/walletOptionsCatalogue/filterConnectionOptionsByEnabledChains/filterConnectionOptionsByEnabledChains.ts
+/**
+* Drops options whose chain has no extension on this client. The wallet
+* book advertises every chain a wallet supports, so options derived from
+* it have to be narrowed to the chains the client can actually connect
+* on — otherwise the catalogue surfaces a connection the customer has no
+* primitive to drive.
+*
+* @param params.enabledChains - Chains the client has an extension for.
+* @param params.options - The tagged options to narrow.
+* @returns The options on enabled chains, in input order.
+* @example
+* ```typescript
+* filterConnectionOptionsByEnabledChains({
+*   enabledChains: new Set(['EVM']),
+*   options: [evmOption, solOption],
+* }); // [evmOption]
+* ```
+* @see {@link getEnabledChains} for how the enabled chains are derived.
+* @see {@link getWalletOptionsCatalogue} for the catalogue that applies this filter.
+* @notInstrumented
+*/
+const filterConnectionOptionsByEnabledChains = ({ enabledChains, options }) => options.filter(({ option }) => enabledChains.has(option.chain));
+
 //#endregion
 //#region src/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.ts
 /**
@@ -8250,6 +8525,10 @@ const EMPTY_WALLET_BOOK = {
 * pass `includeMobileOptions: true` to additionally surface
 * WalletConnect, in-app-browser, and install links.
 *
+* Options sourced from the wallet book are scoped to the chains this
+* client has an extension for — a wallet is only surfaced on chains the
+* customer can actually connect on.
+*
 * Pass `excludedConnectionOptionTypes` to drop specific connection types
 * from the catalogue (e.g. `['inAppBrowser']` on desktop). Wallets whose
 * only connection was an excluded type fall through to the install-only
@@ -8265,6 +8544,7 @@ const getWalletOptionsCatalogue = async (params = {}, client = require_logoutWit
 	const walletOptionOrdering = params.walletOptionOrdering ?? "relevance";
 	const excludedConnectionOptionTypes = new Set(params.excludedConnectionOptionTypes ?? []);
 	const walletBook = includeMobileOptions ? await fetchLegacyWalletBook(client) : EMPTY_WALLET_BOOK;
+	const enabledChains = getEnabledChains(client);
 	const allConnectionOptions = [];
 	if (!excludedConnectionOptionTypes.has("withWalletProvider")) {
 		const entries = require_logoutWithReason.getWalletProviderRegistry(client).listProviderEntries();
@@ -8274,11 +8554,22 @@ const getWalletOptionsCatalogue = async (params = {}, client = require_logoutWit
 		}, client));
 	}
 	if (includeMobileOptions) {
-		if (!excludedConnectionOptionTypes.has("walletConnect")) allConnectionOptions.push(...buildWalletConnectOptions({ walletBook }));
-		if (!excludedConnectionOptionTypes.has("metamaskSdkUri")) allConnectionOptions.push(...buildMetaMaskSdkUriOptions({ walletBook }));
-		if (!excludedConnectionOptionTypes.has("inAppBrowser")) allConnectionOptions.push(...buildInAppBrowserOptions({ walletBook }));
+		const walletBookOptions = [];
+		if (!excludedConnectionOptionTypes.has("walletConnect")) walletBookOptions.push(...buildWalletConnectOptions({ walletBook }));
+		if (!excludedConnectionOptionTypes.has("metamaskSdkUri")) walletBookOptions.push(...buildMetaMaskSdkUriOptions({ walletBook }));
+		if (!excludedConnectionOptionTypes.has("inAppBrowser")) walletBookOptions.push(...buildInAppBrowserOptions({
+			enabledChains,
+			walletBook
+		}));
+		allConnectionOptions.push(...filterConnectionOptionsByEnabledChains({
+			enabledChains,
+			options: walletBookOptions
+		}));
 	}
-	const installationUrlsByKey = includeMobileOptions ? buildInstallationUrlsByWalletOptionKey({ walletBook }) : /* @__PURE__ */ new Map();
+	const installationUrlsByKey = includeMobileOptions ? buildInstallationUrlsByWalletOptionKey({
+		enabledChains,
+		walletBook
+	}) : /* @__PURE__ */ new Map();
 	const grouped = groupOptionsByWalletOption({ options: allConnectionOptions });
 	const allWalletOptionKeys = new Set([...grouped.keys(), ...installationUrlsByKey.keys()]);
 	const walletOptions = [];
@@ -8362,6 +8653,29 @@ const __confirmTransaction_wrapped = require_logoutWithReason.instrumentFunction
 	}
 });
 
+//#endregion
+//#region src/utils/isMobile/isMobile.ts
+/**
+* Tells whether the SDK is running on a mobile device.
+*
+* This is the web implementation, which sniffs the browser's user agent. It
+* lives on its own so the React Native bundler can resolve
+* `isMobile.native.ts` instead, which always reports `true`.
+*
+* @example
+* ```ts
+* if (isMobile()) {
+*   // hand the pairing to the wallet app instead of rendering a QR code
+* }
+* ```
+*
+* @returns `true` when the user agent belongs to a mobile device.
+* @see isMobileUserAgent
+* @see getPlatform
+* @notInstrumented
+*/
+const isMobile = () => isMobileUserAgent();
+
 //#endregion
 //#region src/modules/wallets/utils/getAddressesWithTypesFromConnectionResult/getAddressesWithTypesFromConnectionResult.ts
 /** @notInstrumented */
@@ -9358,6 +9672,109 @@ const __selectPrimaryWalletAccount_wrapped = require_logoutWithReason.instrument
 	}
 });
 
+//#endregion
+//#region src/utils/buildInAppBrowserUrl/buildInAppBrowserUrl.ts
+/**
+* Placeholder the wallet book leaves in in-app-browser URLs for the app URL
+* the wallet should open.
+*/
+const DAPP_URL_PLACEHOLDER = "{{encodedDappURI}}";
+/**
+* Fills a wallet's in-app-browser URL template with the app URL to open.
+*
+* Wallet book entries carry the entry point as a template (e.g.
+* `https://go.base.app/dapp?cb_url={{encodedDappURI}}`), so the URL is only
+* usable once every occurrence of the placeholder is substituted in,
+* percent-encoded. Templates without the placeholder are returned untouched —
+* some wallets open a fixed landing page.
+*
+* @example
+* ```ts
+* buildInAppBrowserUrl({
+*   appUrl: 'https://myapp.xyz/login',
+*   inAppBrowserUrl: 'https://go.base.app/dapp?cb_url={{encodedDappURI}}',
+* });
+* // Returns: 'https://go.base.app/dapp?cb_url=https%3A%2F%2Fmyapp.xyz%2Flogin'
+* ```
+*
+* @param params.appUrl - The URL of your app for the wallet's browser to open.
+* @param params.inAppBrowserUrl - The wallet's in-app-browser URL template.
+* @returns The in-app-browser URL to open.
+* @see redirectToInAppBrowser
+* @see getWalletOptionsCatalogue
+* @notInstrumented
+*/
+const buildInAppBrowserUrl = ({ appUrl, inAppBrowserUrl }) => inAppBrowserUrl.replaceAll(DAPP_URL_PLACEHOLDER, encodeURIComponent(appUrl));
+
+//#endregion
+//#region src/modules/wallets/redirectToInAppBrowser/redirectToInAppBrowser.ts
+/**
+* Leaves your app for a wallet's in-app browser, which reloads `appUrl`
+* inside it.
+*
+* Call this from `handleWalletBrowserRedirect` with the URL of the page the
+* wallet should reload. The wallet's in-app-browser entry point is read from
+* the wallet options catalogue, so you only need the wallet's key. The wallet
+* is only injected on that reload, so the connection is made on the next page
+* load rather than in the current one.
+*
+* @example
+* ```ts
+* await connectWallet({
+*   handleWalletBrowserRedirect: ({ chain, walletKey }) =>
+*     redirectToInAppBrowser({ appUrl: window.location.href, chain, walletKey }),
+*   walletKey: 'coinbase',
+* });
+* ```
+*
+* @param params.appUrl - The URL of your app for the wallet's browser to open.
+* @param params.walletKey - The wallet to open, keyed as in the wallet options catalogue.
+* @param [params.chain] - The chain to open the wallet's browser for. Required only when the wallet exposes an in-app browser on more than one enabled chain.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise that resolves once the redirect is triggered.
+* @throws WalletOptionNotFoundError If no wallet option matches the key.
+* @throws NoConnectionOptionAvailableError If the wallet exposes no in-app browser on the requested chain.
+* @throws AmbiguousWalletChainError If the wallet exposes an in-app browser on more than one chain and no chain was passed.
+* @throws UnsafeDeeplinkUrlError If the wallet's in-app-browser URL has a scheme that can execute script.
+* @see connectWallet
+* @see WalletBrowserRedirectHandlerParams
+* @instrumented
+*/
+const redirectToInAppBrowser = async ({ appUrl, chain, walletKey }, client = require_logoutWithReason.getDefaultClient()) => {
+	const walletOption = (await getWalletOptionsCatalogue({ includeMobileOptions: true }, client)).find(({ key }) => key === walletKey);
+	if (!walletOption) throw new WalletOptionNotFoundError({ walletKey });
+	const inAppBrowserOptions = walletOption.connectionOptions.filter((option) => option.type === "inAppBrowser" && (!chain || option.chain === chain));
+	if (inAppBrowserOptions.length === 0) throw new NoConnectionOptionAvailableError({
+		chain,
+		installationUrls: walletOption.installationUrls,
+		walletKey
+	});
+	const availableChains = [...new Set(inAppBrowserOptions.map((option) => option.chain))];
+	if (!chain && availableChains.length > 1) throw new AmbiguousWalletChainError({
+		chains: availableChains,
+		walletKey
+	});
+	const [inAppBrowserOption] = inAppBrowserOptions;
+	const urlToOpen = buildInAppBrowserUrl({
+		appUrl,
+		inAppBrowserUrl: inAppBrowserOption.url
+	});
+	require_getNetworkProviderFromNetworkId.assertSafeDeeplinkUrl(urlToOpen);
+	await require_logoutWithReason.getCore(client).openDeeplink(urlToOpen);
+};
+const __redirectToInAppBrowser_impl = redirectToInAppBrowser;
+const __redirectToInAppBrowser_wrapped = require_logoutWithReason.instrumentFunction({
+	fn: __redirectToInAppBrowser_impl,
+	functionName: "redirectToInAppBrowser",
+	getCore: () => {
+		try {
+			return require_logoutWithReason.getCore(require_logoutWithReason.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/wallets/disconnectWalletAccount/disconnectWalletAccount.ts
 /**
@@ -9989,6 +10406,40 @@ const appendConnectionUriToDeeplink = ({ connectionUri, deeplinkUrl }) => {
 	return url.href;
 };
 
+//#endregion
+//#region src/utils/getPreferredWalletDeepLink/getPreferredWalletDeepLink.ts
+/**
+* Picks the most appropriate deep link variant for the current platform.
+*
+* Mobile (Android, iOS, tablets) prefers `native` because the OS treats
+* custom URL schemes as first-class app links and gives the wallet a faster
+* round-trip back to the dApp. Desktop prefers `universal` because browsers
+* cannot resolve mobile-only custom schemes and need an `https://` link
+* that opens the wallet's web flow.
+*
+* In either case, the alternative is used as a fallback when the preferred
+* variant is missing. Returns `undefined` only when both variants are
+* absent.
+*
+* @example
+* ```ts
+* const deepLink = getPreferredWalletDeepLink({
+*   deeplinks: wallet.deeplinks,
+* });
+* ```
+*
+* @param params.deeplinks - The deep link variants for a wallet (typically `WalletConnectCatalogWallet.deeplinks`).
+* @returns The preferred deep link URL, or `undefined` if neither variant is available.
+* @see appendConnectionUriToDeeplink
+* @see getConnectionUriDeeplink
+* @notInstrumented
+*/
+const getPreferredWalletDeepLink = ({ deeplinks }) => {
+	const { native, universal } = deeplinks;
+	if (isMobile()) return native ?? universal;
+	return universal ?? native;
+};
+
 //#endregion
 //#region src/utils/parseUserAgent/parseUserAgent.ts
 const browserMatchers = [
@@ -10070,6 +10521,7 @@ const parseUserAgent = ({ userAgent }) => {
 (0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(require_logoutWithReason.name, require_logoutWithReason.version);
 
 //#endregion
+exports.AmbiguousWalletChainError = AmbiguousWalletChainError;
 exports.BaseError = require_logoutWithReason.BaseError;
 exports.COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS = COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS;
 exports.CaptchaProviderEnum = CaptchaProviderEnum;
@@ -10104,6 +10556,7 @@ exports.NetworkAddingUnavailableError = NetworkAddingUnavailableError;
 exports.NetworkNotAddedError = NetworkNotAddedError;
 exports.NetworkSwitchingUnavailableError = NetworkSwitchingUnavailableError;
 exports.NoAddressFoundError = NoAddressFoundError;
+exports.NoConnectionOptionAvailableError = NoConnectionOptionAvailableError;
 exports.NoNetworkProvidersError = require_getNetworkProviderFromNetworkId.NoNetworkProvidersError;
 exports.NoPasskeyCredentialsFoundError = NoPasskeyCredentialsFoundError;
 exports.NoSmartWalletAccountSignerFoundError = NoSmartWalletAccountSignerFoundError;
@@ -10129,6 +10582,7 @@ exports.WaasRbacStaleRetryUnsafeError = require_isUserOnboardingComplete.WaasRba
 exports.WalletAccountAlreadyVerifiedError = WalletAccountAlreadyVerifiedError;
 exports.WalletAccountNotSelectedError = WalletAccountNotSelectedError;
 exports.WalletAlreadyLinkedToAnotherUserError = require_getNetworkProviderFromNetworkId.WalletAlreadyLinkedToAnotherUserError;
+exports.WalletOptionNotFoundError = WalletOptionNotFoundError;
 exports.WalletProviderMethodUnavailableError = WalletProviderMethodUnavailableError;
 exports.WalletScreeningBlockedError = require_getNetworkProviderFromNetworkId.WalletScreeningBlockedError;
 exports.acknowledgeRecoveryCodes = __acknowledgeRecoveryCodes_wrapped;
@@ -10211,6 +10665,7 @@ exports.getNativeBalance = getNativeBalance;
 exports.getNetworksData = require_getNetworkProviderFromNetworkId.getNetworksData;
 exports.getOwnerWalletAccountForSmartWalletAccount = getOwnerWalletAccountForSmartWalletAccount;
 exports.getPasskeys = getPasskeys;
+exports.getPreferredWalletDeepLink = getPreferredWalletDeepLink;
 exports.getPrimaryWalletAccount = getPrimaryWalletAccount;
 exports.getRegisteredDevices = getRegisteredDevices;
 exports.getSelectedWalletAccount = getSelectedWalletAccount;
@@ -10260,6 +10715,7 @@ exports.parseUserAgent = parseUserAgent;
 exports.prepareCheckoutTransaction = __prepareCheckoutTransaction_wrapped;
 exports.prepareFlowSigning = __prepareFlowSigning_wrapped;
 exports.proveWalletAccountOwnership = __proveWalletAccountOwnership_wrapped;
+exports.redirectToInAppBrowser = __redirectToInAppBrowser_wrapped;
 exports.refreshAuth = require_logoutWithReason.__refreshAuth_wrapped;
 exports.refreshUser = __refreshUser_wrapped;
 exports.registerPasskey = __registerPasskey_wrapped;