@dynamic-labs-sdk/client 1.31.1 → 1.32.0

package/dist/index.esm.js

@@ -1,10 +1,10 @@
-import { $ as updateNoncePoolStorage, A as getWalletProviders, C as initializeWaasClientsForEagerRecovery, Ct as BaseError, Et as version, F as onEvent, G as splitWalletProviderKey, H as CHAINS_INFO_MAP, I as onceEvent, M as getWalletProviderRegistry, N as emitEvent, P as offEvent, Q as fetchAndStoreNonces, R as getWalletAccounts, St as getCore, Tt as name, U as formatWalletAccountId, V as getChainFromVerifiedCredentialChain, W as normalizeAddress, Z as getNonce, _ as upsertElevatedAccessToken, _t as randomString, a as retryOnFail, at as MfaInvalidOtpError, b as InvalidParamError, bt as setDefaultClient, c as createApiClient, ct as APIError, d as scrubParameters, dt as SDK_API_CORE_VERSION, et as createStorageKeySchema, f as DEFAULT_PII_FIELDS, g as updateAuthFromVerifyResponse, gt as getElevatedAccessToken, h as extractSessionId, ht as ValueMustBeDefinedError, i as isSignedIn, it as MfaRateLimitedError, j as WalletProviderPriority, l as __refreshAuth_wrapped, m as getOperatingSystem, mt as assertDefined, n as generateSessionKeys, nt as UnauthorizedError, o as getWalletProviderFromWalletAccount, ot as LinkCredentialError, p as getUserAgent, pt as isCookieEnabled, q as isUserMissingMfaAuth, r as fetchProjectSettings, rt as SandboxMaximumThresholdReachedError, s as NoWalletProviderFoundError, st as InvalidExternalAuthError, t as __logoutWithReason_wrapped, tt as NONCE_POOL_SIZE, u as instrumentFunction, ut as DYNAMIC_ICONIC_SPRITE_URL, v as parseElevatedAccessToken, vt as getPlatform, wt as TokenScope, x as checkAndRaiseWalletAccountsChangedEvent, y as decodeJwt, yt as getDefaultClient } from "./logoutWithReason-BqsgA8gI.esm.js";
-import { a as TransactionBroadcastError, i as NotWaasWalletAccountError } from "./migrateFromFireblocks-zazAx6WV.esm.js";
-import { Q as WaasChainEnum } from "./waas-C2PbR02F.esm.js";
-import { A as createEventEmitter, B as REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY, C as getKeychainIndexedDBName, D as assertSafeNavigationUrl, E as createKeychainService, F as createAppForegroundSubscriber, H as subscribeWithSelector, I as FETCH_PROJECT_SETTINGS_TRACKER_KEY, J as UnavailableInServerSideError, K as createLocalStorageAdapter, L as GENERATE_SESSION_KEYS_TRACKER_KEY, N as CannotTrackError, P as createDeferredPromise, R as INITIALIZE_STORAGE_SYNC_TRACKER_KEY, S as MergeAccountsConfirmationError, T as assertSafeDeeplinkUrl, U as isEqualShallow, V as getBuffer, W as createStorage, _ as consumeCaptchaToken, a as removeUnverifiedWalletAccount, b as WalletAlreadyLinkedToAnotherUserError, c as getAppMetadata, d as setUnverifiedWalletAccounts, f as createVisit, g as MethodNotImplementedError, h as __setCaptchaToken_wrapped, i as verifyMessageSignatureOwnership, j as createCrossTabBroadcast, k as createLogger, l as reconcileWalletAccountsAgainstClient, m as hasExtension, o as createSignInMessageStatement, p as getNetworkProviderBuilderRegistry, q as isServerSideRendering, r as getNetworksData, s as formatSignInMessage, t as getNetworkProviderFromNetworkId, u as updateWalletProviderKeysForVerifiedCredentials, v as isCaptchaRequired, w as createRealtimeService, x as NoNetworkProvidersError, y as WalletScreeningBlockedError, z as REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY } from "./getNetworkProviderFromNetworkId-CbMpiSub.esm.js";
-import { n as getWalletProviderByKey, t as getVerifiedCredentialForWalletAccount } from "./getVerifiedCredentialForWalletAccount-C_GcjgC8.esm.js";
-import { a as WaasRbacStaleRetryUnsafeError, i as preconnectWaasIframe, n as isPendingRecoveryCodesAcknowledgment, o as WaasOnboardingIncompleteError, r as isDeviceRegistrationRequired, s as WaasLoadFailedError, t as isUserOnboardingComplete } from "./isUserOnboardingComplete-C4bE5xqM.esm.js";
-import { n as getMfaMethods, r as __consumeMfaToken_wrapped, t as isMfaRequiredForAction } from "./isMfaRequiredForAction-D1a1Nudo.esm.js";
+import { $ as updateNoncePoolStorage, A as getWalletProviders, C as initializeWaasClientsForEagerRecovery, Ct as BaseError, Et as version, F as onEvent, G as splitWalletProviderKey, H as CHAINS_INFO_MAP, I as onceEvent, M as getWalletProviderRegistry, N as emitEvent, P as offEvent, Q as fetchAndStoreNonces, R as getWalletAccounts, St as getCore, Tt as name, U as formatWalletAccountId, V as getChainFromVerifiedCredentialChain, W as normalizeAddress, Z as getNonce, _ as upsertElevatedAccessToken, _t as randomString, a as retryOnFail, at as MfaInvalidOtpError, b as InvalidParamError, bt as setDefaultClient, c as createApiClient, ct as APIError, d as scrubParameters, dt as SDK_API_CORE_VERSION, et as createStorageKeySchema, f as DEFAULT_PII_FIELDS, g as updateAuthFromVerifyResponse, gt as getElevatedAccessToken, h as extractSessionId, ht as ValueMustBeDefinedError, i as isSignedIn, it as MfaRateLimitedError, j as WalletProviderPriority, l as __refreshAuth_wrapped, m as getOperatingSystem, mt as assertDefined, n as generateSessionKeys, nt as UnauthorizedError, o as getWalletProviderFromWalletAccount, ot as LinkCredentialError, p as getUserAgent, pt as isCookieEnabled, q as isUserMissingMfaAuth, r as fetchProjectSettings, rt as SandboxMaximumThresholdReachedError, s as NoWalletProviderFoundError, st as InvalidExternalAuthError, t as __logoutWithReason_wrapped, tt as NONCE_POOL_SIZE, u as instrumentFunction, ut as DYNAMIC_ICONIC_SPRITE_URL, v as parseElevatedAccessToken, vt as getPlatform, wt as TokenScope, x as checkAndRaiseWalletAccountsChangedEvent, y as decodeJwt, yt as getDefaultClient } from "./logoutWithReason-x8mE7EAy.esm.js";
+import { a as TransactionBroadcastError, i as NotWaasWalletAccountError } from "./migrateFromFireblocks-BapjEhra.esm.js";
+import { Q as WaasChainEnum } from "./waas-DzcYsWU8.esm.js";
+import { A as createLogger, B as REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY, C as MergeAccountsConfirmationError, D as createKeychainService, E as assertSafeDeeplinkUrl, F as createDeferredPromise, G as createStorage, H as getBuffer, I as createAppForegroundSubscriber, J as isServerSideRendering, L as FETCH_PROJECT_SETTINGS_TRACKER_KEY, M as createCrossTabBroadcast, O as assertSafeNavigationUrl, P as CannotTrackError, R as GENERATE_SESSION_KEYS_TRACKER_KEY, S as NoNetworkProvidersError, T as createRealtimeService, U as subscribeWithSelector, V as REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY, W as isEqualShallow, Y as UnavailableInServerSideError, _ as MethodNotImplementedError, a as verifyMessageSignatureOwnership, b as WalletScreeningBlockedError, c as formatSignInMessage, d as updateWalletProviderKeysForVerifiedCredentials, f as setUnverifiedWalletAccounts, g as __setCaptchaToken_wrapped, h as hasExtension, i as getUriConnectionStarterRegistry, j as createEventEmitter, l as getAppMetadata, m as getNetworkProviderBuilderRegistry, o as removeUnverifiedWalletAccount, p as createVisit, q as createLocalStorageAdapter, r as getNetworksData, s as createSignInMessageStatement, t as getNetworkProviderFromNetworkId, u as reconcileWalletAccountsAgainstClient, v as consumeCaptchaToken, w as getKeychainIndexedDBName, x as WalletAlreadyLinkedToAnotherUserError, y as isCaptchaRequired, z as INITIALIZE_STORAGE_SYNC_TRACKER_KEY } from "./getNetworkProviderFromNetworkId-TTqmAiJh.esm.js";
+import { n as getWalletProviderByKey, t as getVerifiedCredentialForWalletAccount } from "./getVerifiedCredentialForWalletAccount-C--Dza_K.esm.js";
+import { a as WaasRbacStaleRetryUnsafeError, i as preconnectWaasIframe, n as isPendingRecoveryCodesAcknowledgment, o as WaasOnboardingIncompleteError, r as isDeviceRegistrationRequired, s as WaasLoadFailedError, t as isUserOnboardingComplete } from "./isUserOnboardingComplete-Dmck83_2.esm.js";
+import { n as getMfaMethods, r as __consumeMfaToken_wrapped, t as isMfaRequiredForAction } from "./isMfaRequiredForAction-BPEXPqSt.esm.js";
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
 import { AuthModeEnum, CaptchaProviderEnum as CaptchaProviderEnum$1, ChainEnum, ExchangeKeyEnum, JwtVerifiedCredentialFormatEnum as JwtVerifiedCredentialFormatEnum$1, MFAAction as MFAAction$1, MfaBackupCodeAcknowledgement, ProviderEnum as ProviderEnum$1, TokenScope as TokenScope$1, WaasBackupOptionsEnum, WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
 import * as z from "zod/mini";
@@ -556,7 +556,7 @@ const initializeClient = async (client = getDefaultClient()) => {
 		*/
 		if (isCookieEnabled(client)) await __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 __logoutWithReason_wrapped({ reason: "session-refresh-unauthorized" }, client);
 			} else throw error;
 		});
@@ -1203,6 +1203,44 @@ const __createDynamicClient_wrapped = instrumentFunction({
 	}
 });
 
+//#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 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 BaseError {
@@ -1361,6 +1399,48 @@ var CoinbaseTravelRuleRequiredError = class extends BaseError {
 	}
 };
 
+//#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 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 BaseError {
@@ -1602,6 +1682,54 @@ var NoAddressFoundError = class extends 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 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 BaseError {
@@ -1796,6 +1924,93 @@ var WalletAccountNotSelectedError = class extends BaseError {
 	}
 };
 
+//#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 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 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 BaseError {
@@ -2521,6 +2736,10 @@ const __authenticateWithSocial_wrapped = instrumentFunction({
 * 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`.
 *
@@ -2540,9 +2759,12 @@ const __authenticateWithSocial_wrapped = instrumentFunction({
 *
 * @notInstrumented
 */
-const clearSocialRedirectParams = () => {
+const clearSocialRedirectParams = ({ expectedState } = {}) => {
 	if (isServerSideRendering()) throw new 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
@@ -2626,6 +2848,14 @@ const __processSocialCallback_wrapped = instrumentFunction({
 * 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();
@@ -2639,16 +2869,30 @@ const __processSocialCallback_wrapped = instrumentFunction({
 * @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 = getDefaultClient()) => __processSocialCallback_wrapped({
-	requestedScopes,
-	url
-}, client);
+const completeSocialRedirect = async ({ url, requestedScopes }, client = 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) {
+			getCore(client).logger.debug("[completeSocialRedirect] failed to clear the social redirect params", clearError);
+		}
+		throw error;
+	}
+};
 const __completeSocialRedirect_impl = completeSocialRedirect;
 const __completeSocialRedirect_wrapped = instrumentFunction({
 	fn: __completeSocialRedirect_impl,
@@ -7241,20 +7485,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 = () => 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
@@ -7267,13 +7537,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;
@@ -7300,6 +7568,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 = () => getOperatingSystem() === "ios" || isIOSUserAgent() || isIPad();
+
 //#endregion
 //#region src/modules/walletOptionsCatalogue/getInstallationLinkForCurrentPlatform/getInstallationLinkForCurrentPlatform.ts
 /**
@@ -8446,6 +8739,29 @@ const __confirmTransaction_wrapped = 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 */
@@ -8845,6 +9161,457 @@ const __connectAndVerifyWithWalletProvider_wrapped = instrumentFunction({
 	}
 });
 
+//#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 = 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 = 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
+	});
+	assertSafeDeeplinkUrl(urlToOpen);
+	await getCore(client).openDeeplink(urlToOpen);
+};
+const __redirectToInAppBrowser_impl = redirectToInAppBrowser;
+const __redirectToInAppBrowser_wrapped = instrumentFunction({
+	fn: __redirectToInAppBrowser_impl,
+	functionName: "redirectToInAppBrowser",
+	getCore: () => {
+		try {
+			return getCore(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 = 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 = 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 = instrumentFunction({
+	fn: __connectWalletOption_impl,
+	functionName: "connectWalletOption",
+	getCore: () => {
+		try {
+			return getCore(getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/wallets/getAvailableWalletProvidersData/getAvailableWalletProvidersData.ts
 /**
@@ -10043,36 +10810,6 @@ const __withdrawFromYieldVault_wrapped = instrumentFunction({
 	}
 });
 
-//#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 = [
@@ -10154,5 +10891,5 @@ const parseUserAgent = ({ userAgent }) => {
 assertPackageVersion(name, version);
 
 //#endregion
-export { BaseError, COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS, CaptchaProviderEnum, CheckoutSessionTokenMissingError, ClientAlreadyInitializedError, CoinbaseBeneficiaryWalletType, CoinbaseIsSelfTransfer, CoinbaseTransferMfaFailedError, CoinbaseTransferMfaRequiredError, CoinbaseTravelRuleFieldName, CoinbaseTravelRuleRequiredError, DeeplinkConnectAndVerifyUnsupportedError, DeviceRegistrationIdentityMismatchError, FeeEstimationFailedError, FlowSessionTokenMissingError, GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES, InvalidDeviceRegistrationRedirectError, InvalidExternalAuthError, InvalidParamError, InvalidRedirectStorageStateError, InvalidSocialCallbackOriginError, JwtVerifiedCredentialFormatEnum, LinkCredentialError, MFAAction, MergeAccountsConfirmationError, MfaInvalidOtpError, MfaRateLimitedError, MissingRedirectStorageStateError, MissingSocialUrlParamError, MissingUserVerificationError, NetworkAddingUnavailableError, NetworkNotAddedError, NetworkSwitchingUnavailableError, NoAddressFoundError, NoNetworkProvidersError, NoPasskeyCredentialsFoundError, NoSmartWalletAccountSignerFoundError, NoWebAuthNSupportError, NotWaasWalletAccountError, ProviderEnum, SandboxMaximumThresholdReachedError, ScreeningNotRequiredError, SimulationFailedError, TokenScope, TokenSwapError, TransactionBroadcastError, UnauthorizedError, UnavailableInServerSideError, UnrecognizedNetworkError, UserCancelledSocialPopUpError, UserNotAuthenticatedError, UserRejectedError, WaasChainEnum, WaasLoadFailedError, WaasOnboardingIncompleteError, WaasRbacStaleRetryUnsafeError, WalletAccountAlreadyVerifiedError, WalletAccountNotSelectedError, WalletAlreadyLinkedToAnotherUserError, WalletProviderMethodUnavailableError, WalletScreeningBlockedError, __acknowledgeRecoveryCodes_wrapped as acknowledgeRecoveryCodes, addCoinbaseOnrampOrderEventListener, __addNetwork_wrapped as addNetwork, appendConnectionUriToDeeplink, assertWalletAccountSigningAvailability, assertWalletProviderMethodDefined, __attachCheckoutTransactionSource_wrapped as attachCheckoutTransactionSource, __attachFlowSource_wrapped as attachFlowSource, authenticateMfaRecoveryCode, authenticatePasskeyMFA, authenticateTotpMfaDevice, __authenticateWithSocial_wrapped as authenticateWithSocial, __broadcastCheckoutTransaction_wrapped as broadcastCheckoutTransaction, __broadcastFlow_wrapped as broadcastFlow, canConnectWithHardwareWallet, __cancelCheckoutTransaction_wrapped as cancelCheckoutTransaction, __cancelFlow_wrapped as cancelFlow, __checkStepUpAuth_wrapped as checkStepUpAuth, checkUserScopes, __claimYieldRewards_wrapped as claimYieldRewards, clearDeviceRegistrationRedirectParams, clearSocialRedirectParams, __completeDeviceRegistration_wrapped as completeDeviceRegistration, __completeSocialAuthentication_wrapped as completeSocialAuthentication, __completeSocialRedirect_wrapped as completeSocialRedirect, __confirmTransaction_wrapped as confirmTransaction, __connectAndVerifyWithWalletProvider_wrapped as connectAndVerifyWithWalletProvider, __connectWithWalletProvider_wrapped as connectWithWalletProvider, __consumeMfaToken_wrapped as consumeMfaToken, __createCheckoutTransaction_wrapped as createCheckoutTransaction, createCoinbaseExchangeTransfer, __createCoinbaseOnrampOrder_wrapped as createCoinbaseOnrampOrder, __createCryptoDotComPayment_wrapped as createCryptoDotComPayment, __createDynamicClient_wrapped as createDynamicClient, createKrakenExchangeTransfer, __createNewMfaRecoveryCodes_wrapped as createNewMfaRecoveryCodes, __deleteMfaDevice_wrapped as deleteMfaDevice, __deletePasskey_wrapped as deletePasskey, __deleteUser_wrapped as deleteUser, __depositToYieldVault_wrapped as depositToYieldVault, detectDeviceRegistrationRedirect, detectOAuthRedirect, detectSocialRedirectUrl, excludeInstalledFromCatalog, __executeSwapTransaction_wrapped as executeSwapTransaction, fetchProjectSettings, findMissingGoogleDriveBackupScopes, getActiveNetworkData, getActiveNetworkId, getAvailableWalletProvidersData, getBalance, getBalanceForAddress, getBalances, getCaptchaSettings, getCheckoutTransaction, getCheckoutTransactionQuote, getCoinbaseAccounts, getCoinbaseBuyUrl, getConnectedAddresses, getDefaultClient, getDeviceRegistrationTokenFromUrl, getElevatedAccessToken, getFlow, getFlowQuote, __getGoogleDriveBackupReadiness_wrapped as getGoogleDriveBackupReadiness, getInstallationLinkForCurrentPlatform, getKrakenAccounts, getKrakenWhitelistedAddresses, getMfaDevices, getMfaMethods, getMfaRecoveryCodes, getMissingVerificationForCoinbaseOnrampOrder, __getMoonPayCurrencies_wrapped as getMoonPayCurrencies, __getMoonPayUrl_wrapped as getMoonPayUrl, getMultichainBalances, getMultichainTokenBalances, getNativeBalance, getNetworksData, getOwnerWalletAccountForSmartWalletAccount, getPasskeys, getPrimaryWalletAccount, getRegisteredDevices, getSelectedWalletAccount, getSwapQuote, getSwapStatus, getTokenBalances, getTransactionHistory, getUserSocialAccounts, getWalletAccountAddressByType, getWalletAccountFromAddress, getWalletAccounts, getWalletConnectCatalog, getWalletConnectCatalogWalletByWalletProviderKey, getWalletOptionsCatalogue, getWalletProviderDataByKey, getYieldDetails, getYieldPosition, getYieldRewards, hasAllGoogleDriveBackupScopes, hasExtension, __initializeClient_wrapped as initializeClient, isAnyWalletAccountConnected, isCaptchaRequired, isDeeplinkWalletProvider, isDeviceRegistrationRequired, isExternalWalletScreeningEnabled, isHardwareWalletAccount, isInsufficientGoogleDriveScopesError, isMfaRequiredForAction, isMobile, isPendingRecoveryCodesAcknowledgment, isProgrammaticNetworkSwitchAvailable, isSignedIn, isUserMissingMfaAuth, isUserOnboardingComplete, isWalletAccountVerified, listYieldVaults, logout, matchWalletProvidersToCatalogGroup, mergeUserAccounts, offEvent, offWalletProviderEvent, onEvent, onWalletProviderEvent, onceEvent, parseUserAgent, __prepareCheckoutTransaction_wrapped as prepareCheckoutTransaction, __prepareFlowSigning_wrapped as prepareFlowSigning, __proveWalletAccountOwnership_wrapped as proveWalletAccountOwnership, __refreshAuth_wrapped as refreshAuth, __refreshUser_wrapped as refreshUser, __registerPasskey_wrapped as registerPasskey, __registerTotpMfaDevice_wrapped as registerTotpMfaDevice, __removeWalletAccount_wrapped as removeWalletAccount, __requestExternalAuthElevatedToken_wrapped as requestExternalAuthElevatedToken, requiresConversion, __revokeAllRegisteredDevices_wrapped as revokeAllRegisteredDevices, __revokeRegisteredDevice_wrapped as revokeRegisteredDevice, screenTransaction, __selectPrimaryWalletAccount_wrapped as selectPrimaryWalletAccount, __sendEmailOTP_wrapped as sendEmailOTP, __sendSmsOTP_wrapped as sendSmsOTP, __setCaptchaToken_wrapped as setCaptchaToken, __setDefaultMfaDevice_wrapped as setDefaultMfaDevice, __setInstrumentationEnabled_wrapped as setInstrumentationEnabled, __setSelectedWalletAccount_wrapped as setSelectedWalletAccount, __signInWithExternalJwt_wrapped as signInWithExternalJwt, __signInWithPasskey_wrapped as signInWithPasskey, __signInWithSocialPopUp_wrapped as signInWithSocialPopUp, __signInWithSocialRedirect_wrapped as signInWithSocialRedirect, __signMessage_wrapped as signMessage, __submitCheckoutTransaction_wrapped as submitCheckoutTransaction, __submitFlowTransaction_wrapped as submitFlowTransaction, supportedCountries, __switchActiveNetwork_wrapped as switchActiveNetwork, trackCheckoutTransaction, __transferAmount_wrapped as transferAmount, __transferWalletAccount_wrapped as transferWalletAccount, __unlinkSocialAccount_wrapped as unlinkSocialAccount, __updateUser_wrapped as updateUser, __verifyOTP_wrapped as verifyOTP, __verifyWalletAccount_wrapped as verifyWalletAccount, waitForClientInitialized, __withdrawFromYieldVault_wrapped as withdrawFromYieldVault };
+export { AmbiguousWalletChainError, BaseError, COINBASE_TRAVEL_RULE_FIELD_DESCRIPTIONS, CaptchaProviderEnum, CheckoutSessionTokenMissingError, ClientAlreadyInitializedError, CoinbaseBeneficiaryWalletType, CoinbaseIsSelfTransfer, CoinbaseTransferMfaFailedError, CoinbaseTransferMfaRequiredError, CoinbaseTravelRuleFieldName, CoinbaseTravelRuleRequiredError, ConnectionUriHandlerMissingError, DeeplinkConnectAndVerifyUnsupportedError, DeviceRegistrationIdentityMismatchError, FeeEstimationFailedError, FlowSessionTokenMissingError, GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES, InvalidDeviceRegistrationRedirectError, InvalidExternalAuthError, InvalidParamError, InvalidRedirectStorageStateError, InvalidSocialCallbackOriginError, JwtVerifiedCredentialFormatEnum, LinkCredentialError, MFAAction, MergeAccountsConfirmationError, MfaInvalidOtpError, MfaRateLimitedError, MissingRedirectStorageStateError, MissingSocialUrlParamError, MissingUserVerificationError, NetworkAddingUnavailableError, NetworkNotAddedError, NetworkSwitchingUnavailableError, NoAddressFoundError, NoConnectionOptionAvailableError, NoNetworkProvidersError, NoPasskeyCredentialsFoundError, NoSmartWalletAccountSignerFoundError, NoWebAuthNSupportError, NotWaasWalletAccountError, ProviderEnum, SandboxMaximumThresholdReachedError, ScreeningNotRequiredError, SimulationFailedError, TokenScope, TokenSwapError, TransactionBroadcastError, UnauthorizedError, UnavailableInServerSideError, UnrecognizedNetworkError, UserCancelledSocialPopUpError, UserNotAuthenticatedError, UserRejectedError, WaasChainEnum, WaasLoadFailedError, WaasOnboardingIncompleteError, WaasRbacStaleRetryUnsafeError, WalletAccountAlreadyVerifiedError, WalletAccountNotSelectedError, WalletAlreadyLinkedToAnotherUserError, WalletBrowserRedirectHandlerMissingError, WalletOptionNotFoundError, WalletProviderMethodUnavailableError, WalletScreeningBlockedError, __acknowledgeRecoveryCodes_wrapped as acknowledgeRecoveryCodes, addCoinbaseOnrampOrderEventListener, __addNetwork_wrapped as addNetwork, appendConnectionUriToDeeplink, assertWalletAccountSigningAvailability, assertWalletProviderMethodDefined, __attachCheckoutTransactionSource_wrapped as attachCheckoutTransactionSource, __attachFlowSource_wrapped as attachFlowSource, authenticateMfaRecoveryCode, authenticatePasskeyMFA, authenticateTotpMfaDevice, __authenticateWithSocial_wrapped as authenticateWithSocial, __broadcastCheckoutTransaction_wrapped as broadcastCheckoutTransaction, __broadcastFlow_wrapped as broadcastFlow, canConnectWithHardwareWallet, __cancelCheckoutTransaction_wrapped as cancelCheckoutTransaction, __cancelFlow_wrapped as cancelFlow, __checkStepUpAuth_wrapped as checkStepUpAuth, checkUserScopes, __claimYieldRewards_wrapped as claimYieldRewards, clearDeviceRegistrationRedirectParams, clearSocialRedirectParams, __completeDeviceRegistration_wrapped as completeDeviceRegistration, __completeSocialAuthentication_wrapped as completeSocialAuthentication, __completeSocialRedirect_wrapped as completeSocialRedirect, __confirmTransaction_wrapped as confirmTransaction, __connectAndVerifyWithWalletProvider_wrapped as connectAndVerifyWithWalletProvider, __connectWalletOption_wrapped as connectWalletOption, __connectWithWalletProvider_wrapped as connectWithWalletProvider, __consumeMfaToken_wrapped as consumeMfaToken, __createCheckoutTransaction_wrapped as createCheckoutTransaction, createCoinbaseExchangeTransfer, __createCoinbaseOnrampOrder_wrapped as createCoinbaseOnrampOrder, __createCryptoDotComPayment_wrapped as createCryptoDotComPayment, __createDynamicClient_wrapped as createDynamicClient, createKrakenExchangeTransfer, __createNewMfaRecoveryCodes_wrapped as createNewMfaRecoveryCodes, __deleteMfaDevice_wrapped as deleteMfaDevice, __deletePasskey_wrapped as deletePasskey, __deleteUser_wrapped as deleteUser, __depositToYieldVault_wrapped as depositToYieldVault, detectDeviceRegistrationRedirect, detectOAuthRedirect, detectSocialRedirectUrl, excludeInstalledFromCatalog, __executeSwapTransaction_wrapped as executeSwapTransaction, fetchProjectSettings, findMissingGoogleDriveBackupScopes, getActiveNetworkData, getActiveNetworkId, getAvailableWalletProvidersData, getBalance, getBalanceForAddress, getBalances, getCaptchaSettings, getCheckoutTransaction, getCheckoutTransactionQuote, getCoinbaseAccounts, getCoinbaseBuyUrl, getConnectedAddresses, getDefaultClient, getDeviceRegistrationTokenFromUrl, getElevatedAccessToken, getFlow, getFlowQuote, __getGoogleDriveBackupReadiness_wrapped as getGoogleDriveBackupReadiness, getInstallationLinkForCurrentPlatform, getKrakenAccounts, getKrakenWhitelistedAddresses, getMfaDevices, getMfaMethods, getMfaRecoveryCodes, getMissingVerificationForCoinbaseOnrampOrder, __getMoonPayCurrencies_wrapped as getMoonPayCurrencies, __getMoonPayUrl_wrapped as getMoonPayUrl, getMultichainBalances, getMultichainTokenBalances, getNativeBalance, getNetworksData, getOwnerWalletAccountForSmartWalletAccount, getPasskeys, getPreferredWalletDeepLink, getPrimaryWalletAccount, getRegisteredDevices, getSelectedWalletAccount, getSwapQuote, getSwapStatus, getTokenBalances, getTransactionHistory, getUserSocialAccounts, getWalletAccountAddressByType, getWalletAccountFromAddress, getWalletAccounts, getWalletConnectCatalog, getWalletConnectCatalogWalletByWalletProviderKey, getWalletOptionsCatalogue, getWalletProviderDataByKey, getYieldDetails, getYieldPosition, getYieldRewards, hasAllGoogleDriveBackupScopes, hasExtension, __initializeClient_wrapped as initializeClient, isAnyWalletAccountConnected, isCaptchaRequired, isDeeplinkWalletProvider, isDeviceRegistrationRequired, isExternalWalletScreeningEnabled, isHardwareWalletAccount, isInsufficientGoogleDriveScopesError, isMfaRequiredForAction, isMobile, isPendingRecoveryCodesAcknowledgment, isProgrammaticNetworkSwitchAvailable, isSignedIn, isUserMissingMfaAuth, isUserOnboardingComplete, isWalletAccountVerified, listYieldVaults, logout, matchWalletProvidersToCatalogGroup, mergeUserAccounts, offEvent, offWalletProviderEvent, onEvent, onWalletProviderEvent, onceEvent, parseUserAgent, __prepareCheckoutTransaction_wrapped as prepareCheckoutTransaction, __prepareFlowSigning_wrapped as prepareFlowSigning, __proveWalletAccountOwnership_wrapped as proveWalletAccountOwnership, __redirectToInAppBrowser_wrapped as redirectToInAppBrowser, __refreshAuth_wrapped as refreshAuth, __refreshUser_wrapped as refreshUser, __registerPasskey_wrapped as registerPasskey, __registerTotpMfaDevice_wrapped as registerTotpMfaDevice, __removeWalletAccount_wrapped as removeWalletAccount, __requestExternalAuthElevatedToken_wrapped as requestExternalAuthElevatedToken, requiresConversion, __revokeAllRegisteredDevices_wrapped as revokeAllRegisteredDevices, __revokeRegisteredDevice_wrapped as revokeRegisteredDevice, screenTransaction, __selectPrimaryWalletAccount_wrapped as selectPrimaryWalletAccount, __sendEmailOTP_wrapped as sendEmailOTP, __sendSmsOTP_wrapped as sendSmsOTP, __setCaptchaToken_wrapped as setCaptchaToken, __setDefaultMfaDevice_wrapped as setDefaultMfaDevice, __setInstrumentationEnabled_wrapped as setInstrumentationEnabled, __setSelectedWalletAccount_wrapped as setSelectedWalletAccount, __signInWithExternalJwt_wrapped as signInWithExternalJwt, __signInWithPasskey_wrapped as signInWithPasskey, __signInWithSocialPopUp_wrapped as signInWithSocialPopUp, __signInWithSocialRedirect_wrapped as signInWithSocialRedirect, __signMessage_wrapped as signMessage, __submitCheckoutTransaction_wrapped as submitCheckoutTransaction, __submitFlowTransaction_wrapped as submitFlowTransaction, supportedCountries, __switchActiveNetwork_wrapped as switchActiveNetwork, trackCheckoutTransaction, __transferAmount_wrapped as transferAmount, __transferWalletAccount_wrapped as transferWalletAccount, __unlinkSocialAccount_wrapped as unlinkSocialAccount, __updateUser_wrapped as updateUser, __verifyOTP_wrapped as verifyOTP, __verifyWalletAccount_wrapped as verifyWalletAccount, waitForClientInitialized, __withdrawFromYieldVault_wrapped as withdrawFromYieldVault };
 //# sourceMappingURL=index.esm.js.map