@dynamic-labs-sdk/client 1.31.1 → 1.32.0

package/dist/index.cjs

@@ -1,10 +1,10 @@
-const require_logoutWithReason = require('./logoutWithReason-D6ruPOvJ.cjs');
-const require_migrateFromFireblocks = require('./migrateFromFireblocks-CCNTDCmW.cjs');
-const require_waas = require('./waas-ZWlJHeXc.cjs');
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-DNIuJp20.cjs');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-B5LUGiDP.cjs');
-const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-C2ZuLDT9.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-YjJLLFFs.cjs');
+const require_logoutWithReason = require('./logoutWithReason-yDqQ0UIt.cjs');
+const require_migrateFromFireblocks = require('./migrateFromFireblocks-qYPrnWF8.cjs');
+const require_waas = require('./waas-WID2Fy_N.cjs');
+const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-5UBZwUg2.cjs');
+const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-BSxiaaVp.cjs');
+const require_isUserOnboardingComplete = require('./isUserOnboardingComplete-DtxIznZD.cjs');
+const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-62zh3W-2.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,44 @@ 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 `connectWalletOption`.
+*
+* 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
+* // Throws, since Phantom connects on both SOL and EVM
+* await connectWalletOption({ walletKey: 'phantom' });
+*
+* // Connects the wallet's Solana account
+* await connectWalletOption({ chain: 'SOL', walletKey: 'phantom' });
+* ```
+* @see connectWalletOption
+* @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 {
@@ -1362,6 +1400,48 @@ var CoinbaseTravelRuleRequiredError = class extends require_logoutWithReason.Bas
 	}
 };
 
+//#endregion
+//#region src/errors/ConnectionUriHandlerMissingError.ts
+/**
+* Thrown when the only connection path for a wallet is a URI pairing and no
+* `onConnectionUri` handler was passed to `connectWalletOption`.
+*
+* The pairing URI has to reach the user — as a QR code on desktop, or by opening
+* the wallet's deeplink on mobile — for the wallet to be able to
+* approve the connection.
+*
+* @example
+* ```ts
+* // Throws, since the wallet can only be reached through a URI pairing
+* await connectWalletOption({ walletKey: 'trust' });
+*
+* // Connects, once the user approves the pairing
+* await connectWalletOption({
+*   onConnectionUri: ({ uri }) => renderQrCode(uri),
+*   walletKey: 'trust',
+* });
+* ```
+* @see connectWalletOption
+* @see ConnectionUriHandlerParams
+*/
+var ConnectionUriHandlerMissingError = class extends require_logoutWithReason.BaseError {
+	constructor({ chain, type, walletKey }) {
+		super({
+			cause: null,
+			code: "connection_uri_handler_missing",
+			docsUrl: null,
+			metaMessages: [
+				`Wallet key: ${walletKey}`,
+				`Chain: ${chain}`,
+				`URI connection type: ${type}`,
+				"Pass onConnectionUri to render the pairing URI it hands you as a QR code, or to open it as a link on mobile."
+			],
+			name: "ConnectionUriHandlerMissingError",
+			shortMessage: `Connecting to ${walletKey} requires a URI pairing, so the onConnectionUri param is required.`
+		});
+	}
+};
+
 //#endregion
 //#region src/errors/DeeplinkConnectAndVerifyUnsupportedError.ts
 var DeeplinkConnectAndVerifyUnsupportedError = class extends require_logoutWithReason.BaseError {
@@ -1603,6 +1683,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 connectWalletOption({ walletKey: 'rainbow' });
+* } catch (error) {
+*   if (error instanceof NoConnectionOptionAvailableError) {
+*     promptWalletInstall(error.installationUrls);
+*   }
+* }
+* ```
+* @see connectWalletOption
+* @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 +1925,93 @@ var WalletAccountNotSelectedError = class extends require_logoutWithReason.BaseE
 	}
 };
 
+//#endregion
+//#region src/errors/WalletBrowserRedirectHandlerMissingError.ts
+/**
+* Thrown when the connection option resolved for a wallet is its in-app
+* browser, no `handleWalletBrowserRedirect` handler was passed to
+* `connectWalletOption`, and there is no current page URL to redirect into
+* that browser — as on React Native and during server-side rendering.
+*
+* That path connects by reloading your app inside the wallet's own browser,
+* so it needs the URL of the page to reload.
+*
+* @example
+* ```ts
+* // Throws on React Native, where there is no page URL to reuse
+* await connectWalletOption({ walletKey: 'coinbase' });
+*
+* // Connects, redirecting into the wallet's browser
+* await connectWalletOption({
+*   handleWalletBrowserRedirect: ({ chain, walletKey }) =>
+*     redirectToInAppBrowser({
+*       appUrl: 'https://mydapp.xyz/login',
+*       chain,
+*       walletKey,
+*     }),
+*   walletKey: 'coinbase',
+* });
+* ```
+* @see connectWalletOption
+* @see redirectToInAppBrowser
+*/
+var WalletBrowserRedirectHandlerMissingError = class extends require_logoutWithReason.BaseError {
+	constructor({ chain, walletKey }) {
+		super({
+			cause: null,
+			code: "wallet_browser_redirect_handler_missing",
+			docsUrl: null,
+			metaMessages: [
+				`Wallet key: ${walletKey}`,
+				`Chain: ${chain}`,
+				"Pass handleWalletBrowserRedirect and call redirectToInAppBrowser from it with the URL of the page to reload inside the wallet's browser."
+			],
+			name: "WalletBrowserRedirectHandlerMissingError",
+			shortMessage: `Connecting to ${walletKey} requires opening its in-app browser, so the handleWalletBrowserRedirect param is required where there is no page URL to redirect.`
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/WalletOptionNotFoundError.ts
+/**
+* Thrown when `connectWalletOption` 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 connectWalletOption({ walletKey: 'metmask' });
+* } catch (error) {
+*   if (error instanceof WalletOptionNotFoundError) {
+*     showUnknownWalletMessage();
+*   }
+* }
+* ```
+* @see connectWalletOption
+* @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 +2737,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 +2760,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 +2849,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 +2870,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 +7486,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 +7538,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 +7569,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
 /**
@@ -8447,6 +8740,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 */
@@ -8846,6 +9162,457 @@ const __connectAndVerifyWithWalletProvider_wrapped = require_logoutWithReason.in
 	}
 });
 
+//#endregion
+//#region src/utils/appendConnectionUriToDeeplink/appendConnectionUriToDeeplink.ts
+/**
+* Appends a wallet connection URI to a deeplink URL.
+*
+* Generic across URI-deeplink connection options — works for both
+* WalletConnect pairing URIs and MetaMask SDK URIs. Determines the
+* appropriate query parameter separator based on whether the deeplink
+* already contains query parameters.
+*
+* @param params.deeplinkUrl - The base deeplink URL (e.g., `walletapp://wc` or `walletapp://wc?param=value`).
+* @param params.connectionUri - The connection URI to append.
+* @returns The deeplink URL with the connection URI appended as a query parameter.
+*
+* @example
+* ```ts
+* appendConnectionUriToDeeplink({ deeplinkUrl: 'walletapp://wc', connectionUri: 'wc:123-456' })
+* // Returns: 'walletapp://wc?uri=wc%3A123-456'
+*
+* appendConnectionUriToDeeplink({ deeplinkUrl: 'walletapp://wc?param=value', connectionUri: 'wc:123-456' })
+* // Returns: 'walletapp://wc?param=value&uri=wc%3A123-456'
+* ```
+* @notInstrumented
+*/
+const appendConnectionUriToDeeplink = ({ connectionUri, deeplinkUrl }) => {
+	const url = new URL(deeplinkUrl);
+	url.searchParams.set("uri", connectionUri);
+	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/modules/wallets/connectWithUriConnectionOption/getConnectionUriDeeplink/getConnectionUriDeeplink.ts
+/**
+* Builds the single deeplink that hands a pairing URI to the wallet, picking
+* the shape the URI's protocol expects.
+*
+* A WalletConnect URI travels as the `uri` query parameter of the wallet's own
+* deeplink, whereas the MetaMask SDK mints a launch link that already targets
+* MetaMask, so it is handed over untouched.
+*
+* @example
+* ```ts
+* const deeplink = getConnectionUriDeeplink({
+*   deeplinks: connectionOption.deeplinks,
+*   type: connectionOption.type,
+*   uri,
+* });
+* ```
+*
+* @param params.deeplinks - The wallet's deeplink variants, as carried by the wallet book.
+* @param params.type - The URI connection type that minted the URI.
+* @param params.uri - The pairing URI.
+* @returns The deeplink to open, or `undefined` when the wallet publishes no deeplink to carry the URI.
+* @see getPreferredWalletDeepLink
+* @see appendConnectionUriToDeeplink
+* @notInstrumented
+*/
+const getConnectionUriDeeplink = ({ deeplinks, type, uri }) => {
+	if (type === "metamaskSdkUri") return uri;
+	const deeplinkUrl = getPreferredWalletDeepLink({ deeplinks });
+	if (!deeplinkUrl) return;
+	return appendConnectionUriToDeeplink({
+		connectionUri: uri,
+		deeplinkUrl
+	});
+};
+
+//#endregion
+//#region src/modules/wallets/connectWithUriConnectionOption/connectWithUriConnectionOption.ts
+/**
+* Connects to a wallet through a URI pairing and returns the connected wallet
+* account.
+*
+* Mints the pairing URI with the starter the chain extension registered for
+* the option's chain and URI type, hands it to `onConnectionUri` as the
+* wallet's deeplink carrying the pairing so the customer can render a QR code
+* or open the wallet app, then waits for the user to approve the pairing on
+* the wallet side.
+*
+* The handler is awaited, so an async handler that fails to open the wallet
+* rejects the connection rather than letting the pairing resolve into an
+* account nobody asked for.
+*
+* @example
+* ```ts
+* const walletAccount = await connectWithUriConnectionOption(
+*   {
+*     addToDynamicWalletAccounts: true,
+*     connectionOption,
+*     onConnectionUri: ({ uri }) => renderQrCode(uri),
+*     walletKey: 'trust',
+*   },
+*   client
+* );
+* ```
+*
+* @param params.addToDynamicWalletAccounts - Whether the connected wallet account should be added to the client's wallet accounts.
+* @param params.connectionOption - The URI deeplink connection option to drive.
+* @param params.onConnectionUri - Called with the pairing URI once it is minted. Awaited before the approval is waited on.
+* @param params.walletKey - The wallet being connected, keyed as in the wallet options catalogue.
+* @param client - The Dynamic client instance.
+* @returns A promise that resolves to the connected wallet account.
+* @throws ConnectionUriHandlerMissingError If no onConnectionUri handler was passed.
+* @throws NoConnectionOptionAvailableError If no URI connection starter is registered for the option's chain and type.
+* @throws NoAddressFoundError If the pairing was approved but no address was shared with your app.
+* @see getUriConnectionStarterRegistry
+* @see getWalletOptionsCatalogue
+* @notInstrumented
+*/
+const connectWithUriConnectionOption = async ({ addToDynamicWalletAccounts, connectionOption, onConnectionUri, walletKey }, client) => {
+	const { chain, deeplinks, type } = connectionOption;
+	if (!onConnectionUri) throw new ConnectionUriHandlerMissingError({
+		chain,
+		type,
+		walletKey
+	});
+	const starter = require_getNetworkProviderFromNetworkId.getUriConnectionStarterRegistry(client).get({
+		chain,
+		type
+	});
+	if (!starter) throw new NoConnectionOptionAvailableError({
+		chain,
+		walletKey
+	});
+	const { approval, uri } = await starter.start({ addToDynamicWalletAccounts });
+	const walletAccountsPromise = approval();
+	walletAccountsPromise.catch(() => void 0);
+	await onConnectionUri({ uri: getConnectionUriDeeplink({
+		deeplinks,
+		type,
+		uri
+	}) ?? uri });
+	const { walletAccounts } = await walletAccountsPromise;
+	const [walletAccount] = walletAccounts;
+	if (!walletAccount) throw new NoAddressFoundError();
+	return walletAccount;
+};
+
+//#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 connectWalletOption({
+*   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 connectWalletOption
+* @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/resolveWalletConnectionOption/resolveWalletConnectionOption.ts
+/**
+* Picks the connection option `connectWalletOption` should drive for a wallet.
+*
+* Reads the wallet options catalogue, keeps the options this client can
+* actually drive — a registered wallet provider, an in-app-browser entry, or
+* a URI pairing whose starter a chain extension has registered — and returns
+* the best one by the catalogue's ordering.
+*
+* @example
+* ```ts
+* const connectionOption = await resolveWalletConnectionOption(
+*   { walletKey: 'metamask' },
+*   client
+* );
+* ```
+*
+* @param params.walletKey - The wallet to connect, keyed as in the wallet options catalogue.
+* @param [params.chain] - The chain to connect on. Required only when the wallet resolves on more than one enabled chain.
+* @param client - The Dynamic client instance.
+* @returns A promise that resolves to the connection option to drive.
+* @throws WalletOptionNotFoundError If no wallet option matches the key.
+* @throws AmbiguousWalletChainError If the wallet resolves on more than one chain and no chain was passed.
+* @throws NoConnectionOptionAvailableError If the wallet has no connection option this client can drive on the requested chain.
+* @see connectWalletOption
+* @see getWalletOptionsCatalogue
+* @notInstrumented
+*/
+const resolveWalletConnectionOption = async ({ walletKey, chain }, client) => {
+	const walletOption = (await getWalletOptionsCatalogue({ includeMobileOptions: true }, client)).find(({ key }) => key === walletKey);
+	if (!walletOption) throw new WalletOptionNotFoundError({ walletKey });
+	const uriConnectionStarterRegistry = require_getNetworkProviderFromNetworkId.getUriConnectionStarterRegistry(client);
+	const availableOptions = walletOption.connectionOptions.filter((option) => !chain || option.chain === chain).filter((option) => {
+		if (option.type !== "walletConnect" && option.type !== "metamaskSdkUri") return true;
+		const starter = uriConnectionStarterRegistry.get({
+			chain: option.chain,
+			type: option.type
+		});
+		return Boolean(starter);
+	});
+	if (availableOptions.length === 0) throw new NoConnectionOptionAvailableError({
+		chain,
+		installationUrls: walletOption.installationUrls,
+		walletKey
+	});
+	const availableChains = [...new Set(availableOptions.map((option) => option.chain))];
+	if (!chain && availableChains.length > 1) throw new AmbiguousWalletChainError({
+		chains: availableChains,
+		walletKey
+	});
+	const [connectionOption] = availableOptions;
+	return connectionOption;
+};
+
+//#endregion
+//#region src/utils/getCurrentPageUrl/getCurrentPageUrl.ts
+/**
+* Returns the URL of the page the app is running in.
+*
+* @example
+* ```ts
+* const appUrl = getCurrentPageUrl() ?? 'https://mydapp.xyz';
+* ```
+*
+* @returns The current page URL, or null where there is no page to read it from, such as on React Native and during server-side rendering.
+* @see isServerSideRendering
+* @see redirectToInAppBrowser
+* @notInstrumented
+*/
+const getCurrentPageUrl = () => {
+	if (typeof window === "undefined") return null;
+	const href = window.location?.href;
+	if (typeof href !== "string") return null;
+	return href;
+};
+
+//#endregion
+//#region src/highLevelFunctions/connectWalletOption/connectWalletOption.ts
+/**
+* Connects to an external wallet by its wallet options catalogue key and
+* returns the connected wallet account.
+*
+* Picks the connection path for the wallet so the customer does not have to:
+* a registered wallet provider when the user has the wallet installed,
+* otherwise a URI pairing (WalletConnect or the MetaMask SDK), with the
+* pairing URI handed to `onConnectionUri` while the returned promise waits for
+* the user to approve on the wallet side.
+*
+* Wallets that can only be reached through their own in-app browser — no
+* extension, no URI pairing — resolve to a redirect instead: the wallet and
+* chain are handed to `handleWalletBrowserRedirect`, which leaves for that
+* browser with `redirectToInAppBrowser`. Without that handler, the current
+* page is redirected into the wallet's browser directly, so the handler is
+* only needed to pick a different page to come back to, or where there is no
+* page URL to reuse (React Native, server-side rendering). The returned
+* promise never settles either way, since the connection completes on the
+* next page load inside the wallet's browser.
+*
+* Note: This function does not verify the wallet account — use
+* `verifyWalletAccount` afterwards to link it to the user.
+*
+* @example
+* ```ts
+* const walletAccount = await connectWalletOption({
+*   handleWalletBrowserRedirect: ({ chain, walletKey }) =>
+*     redirectToInAppBrowser({ appUrl: 'https://mydapp.xyz', chain, walletKey }),
+*   onConnectionUri: ({ uri }) => renderQrCode(uri),
+*   walletKey: 'metamask',
+* });
+* console.log(walletAccount.address);
+* ```
+*
+* @param params.walletKey - The wallet to connect, keyed as in the wallet options catalogue (e.g. 'metamask', 'phantom').
+* @param [params.chain] - The chain to connect on. Required only when the wallet resolves on more than one enabled chain.
+* @param [params.onConnectionUri] - Called with the pairing URI when the connection runs through a URI pairing.
+* @param [params.handleWalletBrowserRedirect] - Called with the wallet and chain when the wallet can only be connected through its own in-app browser. Defaults to redirecting the current page into that browser.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise that resolves to the connected wallet account, or that never settles on the in-app-browser path.
+* @throws WalletOptionNotFoundError If no wallet option matches the key.
+* @throws AmbiguousWalletChainError If the wallet resolves on more than one chain and no chain was passed.
+* @throws NoConnectionOptionAvailableError If the wallet has no connection option this client can drive on the requested chain.
+* @throws ConnectionUriHandlerMissingError If the wallet resolves to a URI pairing and no onConnectionUri handler was passed.
+* @throws WalletBrowserRedirectHandlerMissingError If the wallet resolves to its in-app browser, no handleWalletBrowserRedirect handler was passed, and there is no current page URL to redirect.
+* @throws UnsafeDeeplinkUrlError If the wallet's in-app-browser URL has a scheme that can execute script.
+* @see verifyWalletAccount
+* @see redirectToInAppBrowser
+* @see getWalletOptionsCatalogue
+* @instrumented
+*/
+const connectWalletOption = async ({ walletKey, chain, handleWalletBrowserRedirect, onConnectionUri }, client = require_logoutWithReason.getDefaultClient()) => {
+	const connectionOption = await resolveWalletConnectionOption({
+		chain,
+		walletKey
+	}, client);
+	if (connectionOption.type === "withWalletProvider") return __connectWithWalletProvider_wrapped({ walletProviderKey: connectionOption.walletProviderKey }, client);
+	if (connectionOption.type === "inAppBrowser") {
+		const { chain: inAppBrowserChain } = connectionOption;
+		if (handleWalletBrowserRedirect) handleWalletBrowserRedirect({
+			chain: inAppBrowserChain,
+			walletKey
+		});
+		else {
+			const currentPageUrl = getCurrentPageUrl();
+			if (!currentPageUrl) throw new WalletBrowserRedirectHandlerMissingError({
+				chain: inAppBrowserChain,
+				walletKey
+			});
+			await __redirectToInAppBrowser_wrapped({
+				appUrl: currentPageUrl,
+				chain: inAppBrowserChain,
+				walletKey
+			}, client);
+		}
+		return new Promise(() => void 0);
+	}
+	return connectWithUriConnectionOption({
+		addToDynamicWalletAccounts: true,
+		connectionOption,
+		onConnectionUri,
+		walletKey
+	}, client);
+};
+const __connectWalletOption_impl = connectWalletOption;
+const __connectWalletOption_wrapped = require_logoutWithReason.instrumentFunction({
+	fn: __connectWalletOption_impl,
+	functionName: "connectWalletOption",
+	getCore: () => {
+		try {
+			return require_logoutWithReason.getCore(require_logoutWithReason.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/wallets/getAvailableWalletProvidersData/getAvailableWalletProvidersData.ts
 /**
@@ -10044,36 +10811,6 @@ const __withdrawFromYieldVault_wrapped = require_logoutWithReason.instrumentFunc
 	}
 });
 
-//#endregion
-//#region src/utils/appendConnectionUriToDeeplink/appendConnectionUriToDeeplink.ts
-/**
-* Appends a wallet connection URI to a deeplink URL.
-*
-* Generic across URI-deeplink connection options — works for both
-* WalletConnect pairing URIs and MetaMask SDK URIs. Determines the
-* appropriate query parameter separator based on whether the deeplink
-* already contains query parameters.
-*
-* @param params.deeplinkUrl - The base deeplink URL (e.g., `walletapp://wc` or `walletapp://wc?param=value`).
-* @param params.connectionUri - The connection URI to append.
-* @returns The deeplink URL with the connection URI appended as a query parameter.
-*
-* @example
-* ```ts
-* appendConnectionUriToDeeplink({ deeplinkUrl: 'walletapp://wc', connectionUri: 'wc:123-456' })
-* // Returns: 'walletapp://wc?uri=wc%3A123-456'
-*
-* appendConnectionUriToDeeplink({ deeplinkUrl: 'walletapp://wc?param=value', connectionUri: 'wc:123-456' })
-* // Returns: 'walletapp://wc?param=value&uri=wc%3A123-456'
-* ```
-* @notInstrumented
-*/
-const appendConnectionUriToDeeplink = ({ connectionUri, deeplinkUrl }) => {
-	const url = new URL(deeplinkUrl);
-	url.searchParams.set("uri", connectionUri);
-	return url.href;
-};
-
 //#endregion
 //#region src/utils/parseUserAgent/parseUserAgent.ts
 const browserMatchers = [
@@ -10155,6 +10892,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;
@@ -10166,6 +10904,7 @@ exports.CoinbaseTransferMfaFailedError = CoinbaseTransferMfaFailedError;
 exports.CoinbaseTransferMfaRequiredError = CoinbaseTransferMfaRequiredError;
 exports.CoinbaseTravelRuleFieldName = CoinbaseTravelRuleFieldName;
 exports.CoinbaseTravelRuleRequiredError = CoinbaseTravelRuleRequiredError;
+exports.ConnectionUriHandlerMissingError = ConnectionUriHandlerMissingError;
 exports.DeeplinkConnectAndVerifyUnsupportedError = DeeplinkConnectAndVerifyUnsupportedError;
 exports.DeviceRegistrationIdentityMismatchError = DeviceRegistrationIdentityMismatchError;
 exports.FeeEstimationFailedError = FeeEstimationFailedError;
@@ -10189,6 +10928,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;
@@ -10214,6 +10954,8 @@ exports.WaasRbacStaleRetryUnsafeError = require_isUserOnboardingComplete.WaasRba
 exports.WalletAccountAlreadyVerifiedError = WalletAccountAlreadyVerifiedError;
 exports.WalletAccountNotSelectedError = WalletAccountNotSelectedError;
 exports.WalletAlreadyLinkedToAnotherUserError = require_getNetworkProviderFromNetworkId.WalletAlreadyLinkedToAnotherUserError;
+exports.WalletBrowserRedirectHandlerMissingError = WalletBrowserRedirectHandlerMissingError;
+exports.WalletOptionNotFoundError = WalletOptionNotFoundError;
 exports.WalletProviderMethodUnavailableError = WalletProviderMethodUnavailableError;
 exports.WalletScreeningBlockedError = require_getNetworkProviderFromNetworkId.WalletScreeningBlockedError;
 exports.acknowledgeRecoveryCodes = __acknowledgeRecoveryCodes_wrapped;
@@ -10243,6 +10985,7 @@ exports.completeSocialAuthentication = __completeSocialAuthentication_wrapped;
 exports.completeSocialRedirect = __completeSocialRedirect_wrapped;
 exports.confirmTransaction = __confirmTransaction_wrapped;
 exports.connectAndVerifyWithWalletProvider = __connectAndVerifyWithWalletProvider_wrapped;
+exports.connectWalletOption = __connectWalletOption_wrapped;
 exports.connectWithWalletProvider = __connectWithWalletProvider_wrapped;
 exports.consumeMfaToken = require_isMfaRequiredForAction.__consumeMfaToken_wrapped;
 exports.createCheckoutTransaction = __createCheckoutTransaction_wrapped;
@@ -10296,6 +11039,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;
@@ -10345,6 +11089,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;