@dynamic-labs-sdk/client 1.2.1 → 1.4.0

package/dist/index.native.esm.js

@@ -1,8 +1,8 @@
-import { A as extractSessionId, B as name, C as isCookieEnabled, D as instrumentFunction, E as __getElevatedAccessToken_wrapped, F as getDefaultClient, I as setDefaultClient, O as DEFAULT_PII_FIELDS, P as NONCE_POOL_SIZE, R as BaseError, T as ValueMustBeDefinedError, V as version, _ as MfaRateLimitedError, a as DYNAMIC_ICONIC_SPRITE_URL, b as InvalidExternalAuthError, c as CHAINS_INFO_MAP, d as UnauthorizedError, g as SandboxMaximumThresholdReachedError, h as getNonce, j as randomString, k as getUserAgent, l as fetchAndStoreNonces, o as SDK_API_CORE_VERSION, s as getChainFromVerifiedCredentialChain, t as InvalidParamError, u as createApiClient, v as MfaInvalidOtpError, w as assertDefined, x as APIError, y as LinkCredentialError, z as getCore } from "./InvalidParamError-BYnLW_9s.native.esm.js";
-import { A as GENERATE_SESSION_KEYS_TRACKER_KEY, B as createStorage, D as CannotTrackError, F as getBuffer, G as subscribeWithSelector, H as createLocalStorageAdapter, I as __logoutWithReason_wrapped, K as isEqualShallow, L as generateSessionKeys, M as REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY, N as REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY, O as createDeferredPromise, P as isServerSideRendering, R as fetchProjectSettings, S as createKeychainService, T as createCrossTabBroadcast, U as isSignedIn, W as retryOnFail, _ as MethodNotImplementedError, a as updateWalletProviderKeysForVerifiedCredentials, b as getKeychainIndexedDBName, c as createSignInMessageStatement, d as createVisit, f as hasExtension, g as getAppMetadata, h as isCaptchaRequired, i as getNetworksData, j as INITIALIZE_STORAGE_SYNC_TRACKER_KEY, k as FETCH_PROJECT_SETTINGS_TRACKER_KEY, l as formatSignInMessage, m as consumeCaptchaToken, o as verifyMessageSignatureOwnership, p as __setCaptchaToken_wrapped, s as removeUnverifiedWalletAccount, t as getNetworkProviderFromNetworkId, u as setUnverifiedWalletAccounts, v as WalletAlreadyLinkedToAnotherUserError, w as createLogger, x as createRealtimeService, y as NoNetworkProvidersError, z as createStorageKeySchema } from "./getNetworkProviderFromNetworkId-a0atbFHU.native.esm.js";
-import { A as onceEvent, C as formatWalletAccountId, D as emitEvent, O as offEvent, T as splitWalletProviderKey, a as parseElevatedAccessToken, b as getWalletAccounts, d as isUserMissingMfaAuth, f as checkAndRaiseWalletAccountsChangedEvent, h as getWalletProviderFromWalletAccount, i as upsertElevatedAccessToken, k as onEvent, n as getWalletProviderByKey, o as restoreUserSharesForAllWalletAccounts, p as emitWalletAccountsChangedEvent, r as updateAuthFromVerifyResponse, t as getVerifiedCredentialForWalletAccount, u as getWalletProviders, w as normalizeAddress, y as NoWalletProviderFoundError } from "./getVerifiedCredentialForWalletAccount-CEvtJ3xW.native.esm.js";
-import { n as __refreshAuth_wrapped, t as NotWaasWalletAccountError } from "./NotWaasWalletAccountError-33QOxTKa.native.esm.js";
-import { n as getMfaMethods, r as __consumeMfaToken_wrapped, t as isMfaRequiredForAction } from "./isMfaRequiredForAction-BfabCDxI.native.esm.js";
+import { A as getUserAgent, B as getCore, C as isCookieEnabled, D as instrumentFunction, E as __getElevatedAccessToken_wrapped, F as NONCE_POOL_SIZE, H as version, I as getDefaultClient, L as setDefaultClient, M as randomString, O as scrubParameters, T as ValueMustBeDefinedError, V as name, _ as MfaRateLimitedError, a as DYNAMIC_ICONIC_SPRITE_URL, b as InvalidExternalAuthError, c as CHAINS_INFO_MAP, d as UnauthorizedError, g as SandboxMaximumThresholdReachedError, h as getNonce, j as extractSessionId, k as DEFAULT_PII_FIELDS, l as fetchAndStoreNonces, o as SDK_API_CORE_VERSION, s as getChainFromVerifiedCredentialChain, t as InvalidParamError, u as createApiClient, v as MfaInvalidOtpError, w as assertDefined, x as APIError, y as LinkCredentialError, z as BaseError } from "./InvalidParamError-CDmVW2DS.native.esm.js";
+import { A as FETCH_PROJECT_SETTINGS_TRACKER_KEY, B as createStorageKeySchema, C as createKeychainService, E as createCrossTabBroadcast, F as isServerSideRendering, G as retryOnFail, I as getBuffer, K as subscribeWithSelector, L as __logoutWithReason_wrapped, M as INITIALIZE_STORAGE_SYNC_TRACKER_KEY, N as REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY, O as CannotTrackError, P as REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY, R as generateSessionKeys, S as createRealtimeService, T as createLogger, U as createLocalStorageAdapter, V as createStorage, W as isSignedIn, _ as getAppMetadata, a as verifyMessageSignatureOwnership, b as NoNetworkProvidersError, c as formatSignInMessage, d as setUnverifiedWalletAccounts, f as createVisit, g as isCaptchaRequired, h as consumeCaptchaToken, i as getNetworksData, j as GENERATE_SESSION_KEYS_TRACKER_KEY, k as createDeferredPromise, l as reconcileWalletAccountsAgainstClient, m as __setCaptchaToken_wrapped, o as removeUnverifiedWalletAccount, p as hasExtension, q as isEqualShallow, s as createSignInMessageStatement, t as getNetworkProviderFromNetworkId, u as updateWalletProviderKeysForVerifiedCredentials, v as MethodNotImplementedError, x as getKeychainIndexedDBName, y as WalletAlreadyLinkedToAnotherUserError, z as fetchProjectSettings } from "./getNetworkProviderFromNetworkId-JGrKwBj7.native.esm.js";
+import { A as onceEvent, C as formatWalletAccountId, D as emitEvent, O as offEvent, T as splitWalletProviderKey, _ as getWalletProviderRegistry, a as parseElevatedAccessToken, b as getWalletAccounts, d as isUserMissingMfaAuth, f as checkAndRaiseWalletAccountsChangedEvent, g as WalletProviderPriority, h as getWalletProviderFromWalletAccount, i as upsertElevatedAccessToken, k as onEvent, n as getWalletProviderByKey, o as restoreUserSharesForAllWalletAccounts, r as updateAuthFromVerifyResponse, t as getVerifiedCredentialForWalletAccount, u as getWalletProviders, w as normalizeAddress, y as NoWalletProviderFoundError } from "./getVerifiedCredentialForWalletAccount-CyykSi-M.native.esm.js";
+import { n as __refreshAuth_wrapped, t as NotWaasWalletAccountError } from "./NotWaasWalletAccountError-Chpne8_Q.native.esm.js";
+import { n as getMfaMethods, r as __consumeMfaToken_wrapped, t as isMfaRequiredForAction } from "./isMfaRequiredForAction-DUvZEpjA.native.esm.js";
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
 import { AuthModeEnum, ExchangeKeyEnum, JwtVerifiedCredentialFormatEnum, MFAAction, MfaBackupCodeAcknowledgement, ProviderEnum, TokenScope, WaasBackupOptionsEnum, WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
 import * as z from "zod/mini";
@@ -25,6 +25,36 @@ const stateChangeEvents = {
 	user: "userChanged"
 };
 
+//#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'
+* ```
+* @not-instrumented
+*/
+const appendConnectionUriToDeeplink = ({ connectionUri, deeplinkUrl }) => {
+	const url = new URL(deeplinkUrl);
+	url.searchParams.set("uri", connectionUri);
+	return url.href;
+};
+
 //#endregion
 //#region src/utils/getNonce/prefetchNoncesIfNeeded/prefetchNoncesIfNeeded.ts
 /** @not-instrumented */
@@ -626,10 +656,13 @@ const connectLoggerToInstrumentation = ({ environmentId, extensions, instrumenta
 		const { token, user } = state.get();
 		instrumentation.log({
 			environmentId,
-			parameters: {
-				args,
-				message
-			},
+			parameters: scrubParameters({
+				piiFields: instrumentation.config.piiFields,
+				value: {
+					args,
+					message
+				}
+			}),
 			registeredExtensionKeys: Array.from(extensions),
 			sdkSessionId,
 			sdkVersion,
@@ -1615,6 +1648,7 @@ const __checkStepUpAuth_wrapped = instrumentFunction({
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the assertion response containing the elevated access token.
 * @instrumented
+* @redact-params
 */
 const requestExternalAuthElevatedToken = async ({ externalJwt }, client = getDefaultClient()) => {
 	const core = getCore(client);
@@ -1642,7 +1676,8 @@ const __requestExternalAuthElevatedToken_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -1794,6 +1829,7 @@ const serverRegisterPasskey = async ({ registration, createMfaToken }, client) =
 * @returns A promise that resolves to the registration response.
 * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
 * @instrumented
+* @redact-params
 */
 const registerPasskey = async ({ createMfaToken } = {}, client = getDefaultClient()) => {
 	const core = getCore(client);
@@ -1816,7 +1852,8 @@ const __registerPasskey_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -1861,6 +1898,7 @@ const serverSigninPasskey = async ({ authentication, createMfaToken }, client) =
 * @returns A promise that resolves to the authentication response.
 * @throws NoWebAuthNSupportError If WebAuthn is not supported by the browser.
 * @instrumented
+* @redact-params
 */
 const signInWithPasskey = async ({ relatedOriginRpId } = {}, client = getDefaultClient()) => {
 	const core = getCore(client);
@@ -1880,7 +1918,8 @@ const __signInWithPasskey_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -2337,6 +2376,7 @@ const getPrimaryWalletAccount = (client = getDefaultClient()) => {
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the verify response.
 * @instrumented
+* @redact-params
 */
 const unlinkSocialAccount = async ({ verifiedCredentialId }, client = getDefaultClient()) => {
 	const core = getCore(client);
@@ -2362,7 +2402,8 @@ const __unlinkSocialAccount_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -2377,10 +2418,10 @@ const __unlinkSocialAccount_wrapped = instrumentFunction({
 * @returns A promise that resolves to an array of token balances.
 * @not-instrumented
 */
-const getBalances = async ({ walletAccount, networkId, includePrices, includeNative, filterSpamTokens, whitelistedContracts, forceRefresh }, client = getDefaultClient()) => {
+const getBalances = async ({ walletAccount, networkId, networkIds, includePrices, includeNative, filterSpamTokens, whitelistedContracts, forceRefresh }, client = getDefaultClient()) => {
 	const core = getCore(client);
 	const apiClient = createApiClient({}, client);
-	if (!networkId) {
+	if (!networkId && !networkIds) {
 		const activeNetworkId = await getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
 		networkId = Number(activeNetworkId.networkId);
 	}
@@ -2393,6 +2434,7 @@ const getBalances = async ({ walletAccount, networkId, includePrices, includeNat
 		includeNative,
 		includePrices,
 		networkId,
+		networkIds,
 		whitelistedContracts
 	});
 };
@@ -2443,6 +2485,52 @@ const createCheckoutApiClient = async ({ transactionId }, client) => {
 	};
 };
 
+//#endregion
+//#region src/modules/checkout/utils/clearCheckoutSessionToken/clearCheckoutSessionToken.ts
+/**
+* Removes the locally stored checkout session token for the given transaction.
+*
+* The checkout session token is the anonymous credential that authorizes
+* mutations to a single in-flight checkout transaction. Once the transaction
+* has reached a terminal state (cancelled, expired, failed, completed) it can
+* no longer be advanced, and the token is dead weight that should not be
+* persisted in browser storage — leaving it around lets a later XSS payload
+* exfiltrate a credential with no further use, and it can also confuse the
+* SDK on subsequent loads into believing an active session exists.
+*
+* The server-side revocation lives in dashboard-api; this is the SDK-side
+* defense-in-depth.
+*
+* @not-instrumented
+*/
+const clearCheckoutSessionToken = async ({ transactionId }, client) => {
+	await getCore(client).storage.removeItem(createCheckoutSessionTokenStorageKey(transactionId));
+};
+
+//#endregion
+//#region src/modules/checkout/utils/withCheckoutSessionTokenCleanupOn401/withCheckoutSessionTokenCleanupOn401.ts
+/**
+* Checkout mutation routes are guarded server-side only by session-token
+* validation, so a 401 means the token is dead (revoked, expired, deleted,
+* or invalid). Leaving a dead token in `localStorage` widens the XSS
+* exfiltration surface for no benefit and makes the next SDK load attempt
+* requests that are guaranteed to fail.
+*
+* @not-instrumented
+*/
+const withCheckoutSessionTokenCleanupOn401 = async ({ call, transactionId }, client) => {
+	try {
+		return await call();
+	} catch (error) {
+		if (error instanceof APIError && error.status === 401) try {
+			await clearCheckoutSessionToken({ transactionId }, client);
+		} catch (cleanupError) {
+			getCore(client).logger.error("Failed to clear checkout session token after 401", cleanupError);
+		}
+		throw error;
+	}
+};
+
 //#endregion
 //#region src/modules/checkout/attachCheckoutTransactionSource/attachCheckoutTransactionSource.ts
 /**
@@ -2467,12 +2555,15 @@ const attachCheckoutTransactionSource = async (params, client = getDefaultClient
 		attachSourceRequest.fromChainId = params.fromChainId;
 		attachSourceRequest.fromChainName = params.fromChainName;
 	}
-	return apiClient.attachSource({
-		attachSourceRequest,
-		environmentId,
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
+	return withCheckoutSessionTokenCleanupOn401({
+		call: () => apiClient.attachSource({
+			attachSourceRequest,
+			environmentId,
+			transactionId,
+			xDynamicCheckoutSessionToken: sessionToken
+		}),
+		transactionId
+	}, client);
 };
 const __attachCheckoutTransactionSource_impl = attachCheckoutTransactionSource;
 const __attachCheckoutTransactionSource_wrapped = instrumentFunction({
@@ -2503,12 +2594,15 @@ const __attachCheckoutTransactionSource_wrapped = instrumentFunction({
 */
 const broadcastCheckoutTransaction = async ({ transactionId, txHash }, client = getDefaultClient()) => {
 	const { apiClient, environmentId, sessionToken } = await createCheckoutApiClient({ transactionId }, client);
-	return apiClient.recordCheckoutBroadcast({
-		environmentId,
-		recordBroadcastRequest: { txHash },
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
+	return withCheckoutSessionTokenCleanupOn401({
+		call: () => apiClient.recordCheckoutBroadcast({
+			environmentId,
+			recordBroadcastRequest: { txHash },
+			transactionId,
+			xDynamicCheckoutSessionToken: sessionToken
+		}),
+		transactionId
+	}, client);
 };
 const __broadcastCheckoutTransaction_impl = broadcastCheckoutTransaction;
 const __broadcastCheckoutTransaction_wrapped = instrumentFunction({
@@ -2535,12 +2629,15 @@ const __broadcastCheckoutTransaction_wrapped = instrumentFunction({
 */
 const cancelCheckoutTransaction = async ({ transactionId }, client = getDefaultClient()) => {
 	const { apiClient, environmentId, sessionToken } = await createCheckoutApiClient({ transactionId }, client);
-	const result = await apiClient.cancelCheckoutTransaction({
-		environmentId,
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
-	await getCore(client).storage.removeItem(createCheckoutSessionTokenStorageKey(transactionId));
+	const result = await withCheckoutSessionTokenCleanupOn401({
+		call: () => apiClient.cancelCheckoutTransaction({
+			environmentId,
+			transactionId,
+			xDynamicCheckoutSessionToken: sessionToken
+		}),
+		transactionId
+	}, client);
+	await clearCheckoutSessionToken({ transactionId }, client);
 	return result;
 };
 const __cancelCheckoutTransaction_impl = cancelCheckoutTransaction;
@@ -2641,16 +2738,19 @@ const getCheckoutTransaction = async ({ transactionId }, client = getDefaultClie
 */
 const getCheckoutTransactionQuote = async ({ fromChainId, fromTokenAddress, slippage, transactionId }, client = getDefaultClient()) => {
 	const { apiClient, environmentId, sessionToken } = await createCheckoutApiClient({ transactionId }, client);
-	return apiClient.quoteCheckoutTransaction({
-		environmentId,
-		quoteRequest: {
-			fromChainId,
-			fromTokenAddress,
-			slippage
-		},
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
+	return withCheckoutSessionTokenCleanupOn401({
+		call: () => apiClient.quoteCheckoutTransaction({
+			environmentId,
+			quoteRequest: {
+				fromChainId,
+				fromTokenAddress,
+				slippage
+			},
+			transactionId,
+			xDynamicCheckoutSessionToken: sessionToken
+		}),
+		transactionId
+	}, client);
 };
 
 //#endregion
@@ -2667,15 +2767,18 @@ const getCheckoutTransactionQuote = async ({ fromChainId, fromTokenAddress, slip
 */
 const prepareCheckoutTransaction = async ({ assertBalanceForGasCost, assertBalanceForTransferAmount, transactionId }, client = getDefaultClient()) => {
 	const { apiClient, environmentId, sessionToken } = await createCheckoutApiClient({ transactionId }, client);
-	return apiClient.prepareCheckoutTransaction({
-		environmentId,
-		prepareSigningRequest: {
-			assertBalanceForGasCost: assertBalanceForGasCost ?? false,
-			assertBalanceForTransferAmount: assertBalanceForTransferAmount ?? false
-		},
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
+	return withCheckoutSessionTokenCleanupOn401({
+		call: () => apiClient.prepareCheckoutTransaction({
+			environmentId,
+			prepareSigningRequest: {
+				assertBalanceForGasCost: assertBalanceForGasCost ?? false,
+				assertBalanceForTransferAmount: assertBalanceForTransferAmount ?? false
+			},
+			transactionId,
+			xDynamicCheckoutSessionToken: sessionToken
+		}),
+		transactionId
+	}, client);
 };
 const __prepareCheckoutTransaction_impl = prepareCheckoutTransaction;
 const __prepareCheckoutTransaction_wrapped = instrumentFunction({
@@ -3462,10 +3565,12 @@ const fetchLegacyWalletBook = async (client) => {
 };
 
 //#endregion
-//#region src/modules/legacyWalletBook/getWalletConnectCatalog/shouldFilterWallet/shouldFilterWallet.ts
+//#region src/modules/legacyWalletBook/shouldFilterWallet/shouldFilterWallet.ts
 /**
-* Embedded wallet keys that should be filtered out from the WalletConnect catalog.
-* These wallets are not meant to be displayed in wallet selection lists.
+* Embedded wallet keys that should be filtered out from any external-wallet
+* catalogue. These wallets are not products the user "connects" to from the
+* wallet selection list — they are embedded sign-in methods that live behind
+* different SDK entry points.
 * @not-instrumented
 */
 const EMBEDDED_WALLET_KEYS = [
@@ -3481,19 +3586,48 @@ const EMBEDDED_WALLET_KEYS = [
 	"mpcwallet"
 ];
 /**
-* Checks if a wallet should be filtered out from the WalletConnect catalog.
+* Generic "is this wallet eligible for an external-wallet catalogue" check.
+* Filters out:
+*
+* 1. Embedded sign-in methods (see {@link EMBEDDED_WALLET_KEYS}).
+* 2. Wallets that only ship a browser-extension injection (`injectedConfig`)
+*    with no mobile or desktop links — these have no surface a customer
+*    catalogue UI can drive to.
+*
+* Channel-specific eligibility (WalletConnect support, in-app browser URL,
+* installation links, …) is the caller's responsibility — wrap this helper
+* with an additional check, e.g.
+* {@link shouldFilterWalletForWalletConnect}.
 *
 * @returns True if the wallet should be filtered out, false otherwise.
 * @not-instrumented
 */
 const shouldFilterWallet = ({ wallet, walletKey }) => {
 	if (EMBEDDED_WALLET_KEYS.includes(walletKey)) return true;
-	if (!wallet.walletConnect || !wallet.walletConnect.sdks.includes("sign_v2")) return true;
 	const hasInjectedConfig = wallet.injectedConfig && wallet.injectedConfig.length > 0;
 	const hasMobileLinks = Boolean(wallet.mobile?.androidId || wallet.mobile?.iosId || wallet.mobile?.native || wallet.mobile?.universal);
 	const hasDesktopLinks = Boolean(wallet.desktop?.chromeId || wallet.desktop?.edgeId || wallet.desktop?.firefoxId || wallet.desktop?.operaId || wallet.desktop?.safariId || wallet.desktop?.universal);
-	if (hasInjectedConfig && !hasMobileLinks && !hasDesktopLinks) return true;
-	return false;
+	return Boolean(hasInjectedConfig && !hasMobileLinks && !hasDesktopLinks);
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/getWalletConnectCatalog/shouldFilterWalletForWalletConnect/shouldFilterWalletForWalletConnect.ts
+/**
+* WalletConnect-specific filter. Applies the generic
+* {@link shouldFilterWallet} eligibility rules and additionally drops
+* wallets that do not advertise WalletConnect `sign_v2` support — the
+* protocol version Dynamic pairs against.
+*
+* @returns True if the wallet should be excluded from the WalletConnect
+*   catalog, false otherwise.
+* @not-instrumented
+*/
+const shouldFilterWalletForWalletConnect = ({ wallet, walletKey }) => {
+	if (shouldFilterWallet({
+		wallet,
+		walletKey
+	})) return true;
+	return !wallet.walletConnect?.sdks.includes("sign_v2");
 };
 
 //#endregion
@@ -3701,7 +3835,7 @@ const transformWalletBook = ({ walletBook }) => {
 	for (const [groupKey, group] of Object.entries(walletBook.groups)) groups[groupKey] = transformGroup({ group });
 	const wallets = {};
 	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
-		if (shouldFilterWallet({
+		if (shouldFilterWalletForWalletConnect({
 			wallet,
 			walletKey
 		})) continue;
@@ -3735,7 +3869,7 @@ const getWalletConnectCatalog = async (client = getDefaultClient()) => {
 
 //#endregion
 //#region src/modules/legacyWalletBook/matchWalletProvidersToCatalogGroup/matchWalletProvidersToCatalogGroup.ts
-const normalize = (value) => value.toLowerCase().replace(/\s+/g, "").replace(/wallet/g, "");
+const normalize$1 = (value) => value.toLowerCase().replace(/\s+/g, "").replace(/wallet/g, "");
 /**
 * Returns the wallet providers that belong to the same wallet group as the
 * given WalletConnect catalog entry. Useful for de-duplicating "installed"
@@ -3754,10 +3888,10 @@ const normalize = (value) => value.toLowerCase().replace(/\s+/g, "").replace(/wa
 * @not-instrumented
 */
 const matchWalletProvidersToCatalogGroup = ({ catalogGroupKey, catalogGroupName, walletProviders }) => {
-	const targets = new Set([normalize(catalogGroupKey)]);
-	if (catalogGroupName) targets.add(normalize(catalogGroupName));
+	const targets = new Set([normalize$1(catalogGroupKey)]);
+	if (catalogGroupName) targets.add(normalize$1(catalogGroupName));
 	return walletProviders.filter((provider) => {
-		return [normalize(provider.groupKey), normalize(provider.metadata.displayName)].some((candidate) => targets.has(candidate));
+		return [normalize$1(provider.groupKey), normalize$1(provider.metadata.displayName)].some((candidate) => targets.has(candidate));
 	});
 };
 
@@ -3891,6 +4025,812 @@ const getWalletConnectCatalogWalletByWalletProviderKey = async ({ walletProvider
 	}
 };
 
+//#endregion
+//#region src/modules/walletOptionsCatalogue/resolveWalletBookWalletOptionKey/resolveWalletBookWalletOptionKey.ts
+/**
+* Resolves which wallet option (group) a wallet book entry belongs to. Used
+* by the catalogue's wallet-book-driven transformers (URI deeplink,
+* `inAppBrowser`, `installation`) to bucket their emitted options.
+*
+* Wallet book entries inconsistently use `group` / `chainGroup` /
+* `walletGroup` for the same idea. The wallet key itself acts as the wallet
+* option key when no group field is set.
+*
+* @param params.wallet - The wallet entry.
+* @param params.walletKey - The wallet's key in `walletBook.wallets`.
+* @returns The wallet option key.
+* @not-instrumented
+*/
+const resolveWalletBookWalletOptionKey = ({ wallet, walletKey }) => wallet.group ?? wallet.chainGroup ?? wallet.walletGroup ?? walletKey;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/getInAppBrowserUrl.ts
+/**
+* Returns the wallet's in-app browser URL template, preferring the v2
+* field. `inAppBrowser` is deprecated but some wallet book entries
+* still carry only the v1 value, so it acts as a fallback. Trailing
+* `?? undefined` collapses the schema's `string | null` typing down to
+* the `string | undefined` return contract.
+*
+* @param params.wallet - The wallet book wallet entry.
+* @returns The in-app browser URL, or `undefined` if neither field is set.
+* @not-instrumented
+*/
+const getInAppBrowserUrl = ({ wallet }) => wallet.mobile?.inAppBrowserV2 ?? wallet.mobile?.inAppBrowser ?? void 0;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/buildInAppBrowserOptions.ts
+/**
+* Builds the `inAppBrowser` catalogue options from the wallet book. A wallet
+* qualifies when it exposes a mobile in-app-browser URL — typically a
+* `cb_url={{encodedDappURI}}`-style template the customer fills in with the
+* current page URL before opening.
+*
+* Reuses the generic `shouldFilterWallet` rules — embedded sign-in methods
+* and injected-only wallets are dropped — so the catalogue's notion of
+* "external wallet" stays consistent across option types.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns Tagged `inAppBrowser` options paired with their wallet option keys.
+* @not-instrumented
+*/
+const buildInAppBrowserOptions = ({ walletBook }) => {
+	const result = [];
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWallet({
+			wallet,
+			walletKey
+		})) continue;
+		const url = getInAppBrowserUrl({ wallet });
+		if (!url) continue;
+		result.push({
+			option: {
+				chain: getChainFromWalletSchema({
+					wallet,
+					walletKey
+				}),
+				type: "inAppBrowser",
+				url
+			},
+			walletOptionKey: resolveWalletBookWalletOptionKey({
+				wallet,
+				walletKey
+			})
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInstallationUrls/buildInstallationUrls.ts
+const PLAY_STORE_URL_TEMPLATE = "https://play.google.com/store/apps/details?id=";
+const APP_STORE_URL_TEMPLATE = "https://apps.apple.com/app/";
+const CHROME_WEB_STORE_URL_TEMPLATE = "https://chrome.google.com/webstore/detail/";
+const FIREFOX_ADDONS_URL_TEMPLATE = "https://addons.mozilla.org/firefox/addon/";
+const EDGE_ADDONS_URL_TEMPLATE = "https://microsoftedge.microsoft.com/addons/detail/";
+/**
+* Builds the install/download URL bag for a wallet book entry. Returns the
+* concrete URLs assembled from each store's ID field — Play Store, App
+* Store, Chrome Web Store, Firefox Add-ons, Edge Add-ons — plus the wallet's
+* own `desktop.universal` / `desktop.native` URLs when set.
+*
+* Fields the wallet book does not carry are left undefined; callers should
+* skip emitting an installation option for a wallet whose URL bag is empty.
+*
+* @param params.wallet - The wallet book entry.
+* @returns The URL bag, omitting fields the wallet does not provide.
+* @not-instrumented
+*/
+const buildInstallationUrls = ({ wallet }) => {
+	const androidId = wallet.mobile?.androidId;
+	const iosId = wallet.mobile?.iosId;
+	const chromeId = wallet.desktop?.chromeId;
+	const firefoxId = wallet.desktop?.firefoxId;
+	const edgeId = wallet.desktop?.edgeId;
+	const native = wallet.desktop?.universal ?? wallet.desktop?.native;
+	return {
+		android: androidId ? `${PLAY_STORE_URL_TEMPLATE}${androidId}` : void 0,
+		chrome: chromeId ? `${CHROME_WEB_STORE_URL_TEMPLATE}${chromeId}` : void 0,
+		edge: edgeId ? `${EDGE_ADDONS_URL_TEMPLATE}${edgeId}` : void 0,
+		firefox: firefoxId ? `${FIREFOX_ADDONS_URL_TEMPLATE}${firefoxId}` : void 0,
+		ios: iosId ? `${APP_STORE_URL_TEMPLATE}${iosId}` : void 0,
+		native: native || void 0
+	};
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInstallationUrlsByWalletOptionKey/buildInstallationUrlsByWalletOptionKey.ts
+/**
+* `buildInstallationUrls` always returns an object, but it can be fully
+* `undefined`-valued when the wallet book entry has no installable surface.
+* Skip those wallets — emitting an empty URL bag helps nobody.
+*/
+const hasAnyInstallationUrl = ({ urls }) => Object.values(urls).some(Boolean);
+/**
+* Collects install / download URLs for every wallet book entry that has
+* at least one installable surface, keyed by the wallet option key the
+* wallet groups under. The catalogue assembly step merges this map into
+* the per-key wallet option shell so `WalletOption.installationUrls` is
+* populated alongside (or instead of) `connectionOptions`.
+*
+* First-seen URLs win when multiple wallet book entries resolve to the
+* same wallet option key — wallet book authors put the most accurate
+* install links on the canonical entry, so the first-seen one is the
+* right pick.
+*
+* Reuses the generic `shouldFilterWallet` rules so embedded wallets do
+* not appear here either — they're not user-installable products.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns A map from wallet option key to its install URL bag.
+* @not-instrumented
+*/
+const buildInstallationUrlsByWalletOptionKey = ({ walletBook }) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWallet({
+			wallet,
+			walletKey
+		})) continue;
+		const urls = buildInstallationUrls({ wallet });
+		if (!hasAnyInstallationUrl({ urls })) continue;
+		const walletOptionKey = resolveWalletBookWalletOptionKey({
+			wallet,
+			walletKey
+		});
+		if (!map.has(walletOptionKey)) map.set(walletOptionKey, urls);
+	}
+	return map;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/resolveUriConnectionType.ts
+/**
+* Picks the connection-option `type` discriminator for a wallet-book-
+* derived URI deeplink option. MetaMask is steered toward its own
+* MetaMask SDK URI connection extension (`metamaskSdkUri`) so we route
+* customers off generic WalletConnect for that wallet; every other
+* wallet uses the standard `walletConnect` discriminator.
+*
+* @param params.walletOptionKey - The resolved wallet option key.
+* @returns The connection-option discriminator to emit.
+* @not-instrumented
+*/
+const resolveUriConnectionType = ({ walletOptionKey }) => walletOptionKey === "metamask" ? "metamaskSdkUri" : "walletConnect";
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/buildUriDeeplinkOptions.ts
+/**
+* A wallet only deserves a URI-deeplink catalogue option if it has at
+* least one mobile deeplink — that's the value-add the option provides
+* over the bare pairing URI. Wallets that exist in the wallet book but
+* don't expose a deeplink (rare, but present) are silently skipped.
+*/
+const hasUsableDeeplink = ({ wallet }) => Boolean(wallet.mobile?.native || wallet.mobile?.universal);
+/**
+* Builds the URI-deeplink catalogue options from a fetched wallet book.
+* Applies the WalletConnect-specific eligibility filter
+* (`shouldFilterWalletForWalletConnect`) so embedded wallets and entries
+* without `sign_v2` support are excluded — same surface as
+* `getWalletConnectCatalog`.
+*
+* Each emitted option carries the wallet's mobile deeplinks. Customers
+* combine these with their chain's connection URI via
+* `appendConnectionUriToDeeplink` to open the wallet's app:
+*
+* - `'walletConnect'`: mint via `connectWithWalletConnect<Chain>`.
+* - `'metamaskSdkUri'`: mint via `connectWithMetaMaskUriEvm` or
+*   `connectWithMetaMaskUriSolana`. Emitted only for the MetaMask
+*   wallet entry — see `resolveUriConnectionType`.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns Tagged options paired with their wallet option keys.
+* @not-instrumented
+*/
+const buildUriDeeplinkOptions = ({ walletBook }) => {
+	const result = [];
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWalletForWalletConnect({
+			wallet,
+			walletKey
+		})) continue;
+		if (!hasUsableDeeplink({ wallet })) continue;
+		const walletOptionKey = resolveWalletBookWalletOptionKey({
+			wallet,
+			walletKey
+		});
+		const chain = getChainFromWalletSchema({
+			wallet,
+			walletKey
+		});
+		result.push({
+			option: {
+				chain,
+				deeplinks: {
+					native: wallet.mobile?.native,
+					universal: wallet.mobile?.universal
+				},
+				type: resolveUriConnectionType({ walletOptionKey })
+			},
+			walletOptionKey
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWalletOption/buildWalletOption.ts
+/**
+* Assembles a `WalletOption` for a resolved wallet option key, populated
+* with the connection options the transformers produced for it plus an
+* optional install / download URL bag.
+*
+* Display merge rules (provider self-announced metadata wins where set):
+*
+* - `name`: `displayOverride.name` ?? wallet book group name ?? bare key.
+* - `iconUrl`: `displayOverride.iconUrl` ?? wallet book group sprite URL ?? `''`.
+* - `primaryColor`: wallet book group brand color only (providers do not
+*   ship a primary color in their announcement metadata).
+* - `installationUrls`: copied through if present.
+*
+* Why provider precedence: a registered wallet provider knows its own
+* brand best (EIP-6963 / Wallet Standard / vendor SDK announcement is the
+* wallet authoring its own identity). The wallet book fills in fields the
+* announcement does not carry — currently only `primaryColor`.
+*
+* @param params.connectionOptions - The connections to attach to this wallet option.
+* @param [params.displayOverride] - Provider-announced display info that overrides the wallet book's name and iconUrl.
+* @param [params.installationUrls] - Install/download URL bag for this wallet.
+* @param params.walletBook - The fetched wallet book.
+* @param params.walletOptionKey - The wallet option key.
+* @returns The constructed wallet option.
+* @not-instrumented
+*/
+const buildWalletOption = ({ connectionOptions, displayOverride, installationUrls, walletBook, walletOptionKey }) => {
+	const group = walletBook.groups[walletOptionKey];
+	const groupSpriteId = group?.brand?.spriteId;
+	const groupIconUrl = groupSpriteId ? getSpriteUrl({ spriteId: groupSpriteId }) : void 0;
+	return {
+		connectionOptions,
+		iconUrl: displayOverride?.iconUrl ?? groupIconUrl ?? "",
+		installationUrls,
+		key: walletOptionKey,
+		name: displayOverride?.name ?? group?.name ?? walletOptionKey,
+		primaryColor: group?.brand?.primaryColor
+	};
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.ts
+/**
+* Maps a registered wallet provider's registration priority to the
+* `WithWalletProviderSource` value that should appear on its catalogue option.
+*
+* Priority mapping (set by each chain extension when it calls
+* `registry.register`):
+*
+* - `WALLET_SDK` → `'sdk'` — branded SDKs wrapped by chain extensions
+*   (Base Account via `@base-org/account`, MetaMask Connect, …).
+* - `WALLET_SELF_ANNOUNCEMENT_STANDARD` → `'selfAnnounced'` — in-page
+*   self-announcement standards (EIP-6963 on EVM, Wallet Standard on
+*   Solana / Sui / …).
+* - `WINDOW_INJECT` → `'windowInjected'` — legacy `window.*` injection.
+*
+* Returns `undefined` for providers whose registration priority does not
+* correspond to a connectable external-wallet source — callers filter these
+* out before emitting catalogue options.
+*
+* @param params.entry - The registry entry to classify.
+* @returns The matching source, or `undefined` if this entry should not
+*   surface a `withWalletProvider` option.
+* @not-instrumented
+*/
+const classifyWithWalletProviderSource = ({ entry }) => {
+	const { priority } = entry;
+	if (priority === WalletProviderPriority.WALLET_SDK) return "sdk";
+	if (priority === WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD) return "selfAnnounced";
+	if (priority === WalletProviderPriority.WINDOW_INJECT) return "windowInjected";
+};
+
+//#endregion
+//#region src/modules/wallets/utils/stripChainSuffix/stripChainSuffix.ts
+/**
+* Removes the lowercased chain suffix that `normalizeWalletNameWithChain`
+* appends. Used by `findWalletOptionKeyForProviderKey` to recover the wallet
+* book wallet key candidate from a `walletProviderKey`. If the suffix is
+* not present (some chain extensions already bake the chain into the
+* display name), the input is returned unchanged.
+*
+* @param params.chain - The chain whose suffix should be stripped.
+* @param params.normalizedName - The normalized wallet-name-with-chain string.
+* @returns The name with the chain suffix removed, or the input unchanged.
+* @not-instrumented
+*/
+const stripChainSuffix = ({ chain, normalizedName }) => {
+	const suffix = chain.toLowerCase();
+	if (normalizedName.endsWith(suffix)) return normalizedName.slice(0, -suffix.length);
+	return normalizedName;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/normalizeWalletDisplayName/normalizeWalletDisplayName.ts
+/**
+* Normalizes a wallet's self-announced `displayName` into a stable wallet
+* option key. Used by `findWalletOptionKeyForProviderKey` as the off-book
+* fallback — registered providers whose `walletProviderKey` does not
+* resolve to any wallet book entry still surface in the catalogue under a
+* key derived from the name they ship in their metadata.
+*
+* The normalization (lowercase + whitespace-strip) intentionally matches
+* how the legacy wallet book composes its `wallets.<key>` keys, so a
+* self-described provider's option will merge cleanly with its book entry
+* if one ever lands later.
+*
+* Multi-chain registrations of the same wallet (e.g. Phantom announced via
+* EIP-6963 on EVM and via Wallet Standard on Solana) collapse onto the
+* same wallet option through this normalization, since each registration
+* announces the same `displayName`.
+*
+* @param displayName - The provider's `metadata.displayName`.
+* @returns The normalized wallet option key (lowercased, no whitespace).
+* @not-instrumented
+*/
+const normalizeWalletDisplayName = (displayName) => displayName.toLowerCase().replace(/\s+/g, "");
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.ts
+const normalize = (value) => value.toLowerCase().replace(/\s+/g, "");
+/**
+* Looks for a wallet book entry whose `name` or `shortName` normalizes to
+* the same string as `candidate`. Used as a fallback by
+* `findWalletOptionKeyForProviderKey` for providers whose
+* `walletProviderKey` strips down to a value that does not match any
+* `walletBook.wallets` key directly (e.g. an extension whose display name
+* happens to match the wallet's `shortName` instead of its book key).
+*
+* @param params.candidate - The lowercased, chain-suffix-stripped candidate.
+* @param params.walletBook - The fetched wallet book.
+* @returns The matching wallet book wallet key, or `undefined`.
+* @not-instrumented
+*/
+const findByNameMatch = ({ candidate, walletBook }) => {
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) if (normalize(wallet.name) === candidate || normalize(wallet.shortName) === candidate) return walletKey;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/resolveWalletOptionKey/resolveWalletOptionKey.ts
+/**
+* Picks the wallet option (group) key for a wallet book wallet. The wallet
+* book carries the group association under a few different field names
+* (`group`, `chainGroup`, `walletGroup`) depending on the wallet's
+* provenance — this helper centralises the lookup. When none of those
+* fields are set, the wallet key itself acts as its own wallet option key.
+*
+* @param params.fallback - Wallet key to return if no group field is set.
+* @param params.wallet - The wallet book wallet entry.
+* @returns The resolved wallet option key.
+* @not-instrumented
+*/
+const resolveWalletOptionKey = ({ fallback, wallet }) => wallet.group ?? wallet.chainGroup ?? wallet.walletGroup ?? fallback;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findWalletOptionKeyForProviderKey.ts
+/**
+* Resolves a registered wallet provider to the wallet option key it should
+* be bucketed under. Always returns a key — providers with no wallet book
+* match fall back to their self-announced `metadata.displayName`, so the
+* catalogue surfaces them as self-described tiles instead of silently
+* dropping them.
+*
+* Resolution order (each step short-circuits on first hit):
+*
+* 1. **Direct wallet book lookup with chain suffix** — try
+*    `walletBook.wallets[normalizedWalletNameWithChain]` as-is. Wallet
+*    book entries are inconsistent about whether they keep the chain
+*    suffix (e.g. `metamaskevm`) or strip it (e.g. `metamask`), so try
+*    the suffixed form first.
+* 2. **Direct wallet book lookup without chain suffix** — strip the
+*    suffix and retry.
+* 3. **Name match heuristic with chain suffix** — scan
+*    `walletBook.wallets` for an entry whose normalized `name` or
+*    `shortName` equals the suffixed candidate.
+* 4. **Name match heuristic without chain suffix** — same scan on the
+*    stripped candidate.
+* 5. **Display-name fallback** — derive a stable key from
+*    `walletProvider.metadata.displayName` via
+*    {@link normalizeWalletDisplayName}. Multi-chain registrations of the
+*    same self-described wallet (e.g. Phantom on EVM and Solana) collapse
+*    onto the same tile because each announces the same display name.
+*
+* @param params.chain - The provider's chain (used to strip the suffix).
+* @param params.walletBook - The fetched wallet book.
+* @param params.walletProvider - The registered wallet provider.
+* @returns The wallet option key for this provider.
+* @not-instrumented
+*/
+const findWalletOptionKeyForProviderKey = ({ chain, walletBook, walletProvider }) => {
+	const { normalizedWalletNameWithChain } = splitWalletProviderKey(walletProvider.key);
+	const candidates = [normalizedWalletNameWithChain, stripChainSuffix({
+		chain,
+		normalizedName: normalizedWalletNameWithChain
+	})];
+	for (const candidate of candidates) {
+		const directHit = walletBook.wallets[candidate];
+		if (directHit) return resolveWalletOptionKey({
+			fallback: candidate,
+			wallet: directHit
+		});
+	}
+	for (const candidate of candidates) {
+		const nameMatchKey = findByNameMatch({
+			candidate,
+			walletBook
+		});
+		if (nameMatchKey) return resolveWalletOptionKey({
+			fallback: nameMatchKey,
+			wallet: walletBook.wallets[nameMatchKey]
+		});
+	}
+	return normalizeWalletDisplayName(walletProvider.metadata.displayName);
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWithWalletProviderOptions/buildWithWalletProviderOptions.ts
+/**
+* Converts each registered wallet provider entry into a
+* `WithWalletProviderConnectionOption` paired with its target wallet
+* option key and the provider's display override. Every classifiable
+* entry surfaces in the catalogue; the outer transformer uses the
+* carried `displayOverride` to override any wallet book branding for
+* that key (provider self-announcement wins over book).
+*
+* Entries whose registration priority is not recognised by
+* `classifyWithWalletProviderSource` are dropped from the catalogue and
+* an error is logged so Datadog surfaces the unknown registration path —
+* in production this should never happen, every chain extension is
+* expected to register with one of the documented priorities.
+*
+* @param params.entries - Snapshot of the registry's entries.
+* @param params.walletBook - The fetched wallet book.
+* @param client - The Dynamic client (used for logging unclassifiable entries).
+* @returns An array of tagged options, in input order.
+* @not-instrumented
+*/
+const buildWithWalletProviderOptions = ({ entries, walletBook }, client) => {
+	const result = [];
+	for (const entry of entries) {
+		const source = classifyWithWalletProviderSource({ entry });
+		if (!source) {
+			getCore(client).logger.error("buildWithWalletProviderOptions: registered wallet provider has an unrecognised priority — unable to identify how this wallet was registered", {
+				chain: entry.walletProvider.chain,
+				displayName: entry.walletProvider.metadata.displayName,
+				priority: entry.priority,
+				walletProviderKey: entry.walletProvider.key,
+				walletProviderType: entry.walletProvider.walletProviderType
+			});
+			continue;
+		}
+		const walletOptionKey = findWalletOptionKeyForProviderKey({
+			chain: entry.walletProvider.chain,
+			walletBook,
+			walletProvider: entry.walletProvider
+		});
+		result.push({
+			displayOverride: {
+				iconUrl: entry.walletProvider.metadata.icon,
+				name: entry.walletProvider.metadata.displayName
+			},
+			option: {
+				chain: entry.walletProvider.chain,
+				source,
+				type: "withWalletProvider",
+				walletProviderKey: entry.walletProvider.key
+			},
+			walletOptionKey
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/excludedWalletOptionKeys/excludedWalletOptionKeys.ts
+/**
+* Wallet option keys `getWalletOptionsCatalogue` drops before returning.
+* Curated, product-level suppression.
+*
+* Example: Base Account SDK is the recommended entry point for
+* Coinbase-managed users, so the legacy Coinbase Wallet entries are
+* suppressed in favor of the SDK-backed `baseaccount` tile. Both the
+* wallet book group key (`coinbase`) and the normalized display-name
+* key (`coinbasewallet`) are listed so suppression holds regardless of
+* how the resolver lands on a key.
+*
+* Used in: `getWalletOptionsCatalogue`.
+*/
+const EXCLUDED_WALLET_OPTION_KEYS = new Set(["coinbase", "coinbasewallet"]);
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.ts
+/**
+* Buckets tagged connection options by their wallet option key. Preserves
+* first-seen order so that the caller's choice of
+* `walletOptionOrdering: 'relevance'` naturally inherits the upstream input
+* order (wallet book order for walletConnect/inAppBrowser/installation,
+* registry order for withWalletProvider).
+*
+* Carries through the first-seen `displayOverride` per wallet option
+* key, so the shell builder can apply provider-announced metadata on
+* top of any wallet book entry.
+*
+* @param params.options - The tagged options to group.
+* @returns A map from wallet option key to its grouped option bucket,
+*   iterable in first-seen order.
+* @not-instrumented
+*/
+const groupOptionsByWalletOption = ({ options }) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const { displayOverride, option, walletOptionKey } of options) {
+		const existing = map.get(walletOptionKey);
+		if (existing) {
+			existing.connectionOptions.push(option);
+			if (!existing.displayOverride && displayOverride) existing.displayOverride = displayOverride;
+		} else map.set(walletOptionKey, {
+			connectionOptions: [option],
+			displayOverride
+		});
+	}
+	return map;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getConnectionOptionPriority/getConnectionOptionPriority.ts
+/**
+* Numeric priority for each `WalletConnectionOption` type. Lower values rank
+* first. Used to sort each wallet option's `connectionOptions` array so the
+* best connection path lands at index 0. Has no bearing on how the outer
+* wallet-option list is ordered — that's controlled by
+* `WalletOptionOrdering`.
+*
+* `withWalletProvider > walletConnect / metamaskSdkUri > inAppBrowser`
+*/
+const CONNECTION_OPTION_PRIORITY = {
+	inAppBrowser: 2,
+	metamaskSdkUri: 1,
+	walletConnect: 1,
+	withWalletProvider: 0
+};
+/**
+* Returns the numeric priority of a `WalletConnectionOption` for sorting.
+* Lower numbers rank first.
+*
+* @param params.option - The connection option to inspect.
+* @returns The numeric priority — lower is better.
+* @not-instrumented
+*/
+const getConnectionOptionPriority = ({ option }) => CONNECTION_OPTION_PRIORITY[option.type];
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/sortConnectionOptions/sortConnectionOptions.ts
+/**
+* Sorts a wallet option's `connectionOptions` so the most preferred option lands at
+* index 0. Primary sort is by option-type priority
+* (`withWalletProvider` > URI deeplink > `inAppBrowser`);
+* within a type, ties break alphabetically by `chain` for deterministic
+* output across calls.
+*
+* Returns a new array — the input is not mutated.
+*
+* @param params.options - The options to sort.
+* @returns A new array in priority order.
+* @not-instrumented
+*/
+const sortConnectionOptions = ({ options }) => [...options].sort((a, b) => {
+	const priorityDelta = getConnectionOptionPriority({ option: a }) - getConnectionOptionPriority({ option: b });
+	if (priorityDelta !== 0) return priorityDelta;
+	return a.chain.localeCompare(b.chain);
+});
+
+//#endregion
+//#region src/modules/legacyWalletBook/priorityWalletKeys/priorityWalletKeys.ts
+/**
+* Hand-curated list of wallet book group keys that should surface at the top
+* of catalogue listings. Lower index = higher priority. Anything not in this
+* list falls through to the secondary sort (alphabetical by name).
+*
+* Used by `sortWalletOptions` (relevance mode) and by the react-demo's
+* WalletConnect picker. Keep both in sync when adding entries.
+*/
+const PRIORITY_WALLET_KEYS = [
+	"metamask",
+	"coinbase",
+	"baseaccount",
+	"phantom",
+	"magiceden",
+	"trust",
+	"okxwallet",
+	"rainbow",
+	"argentx",
+	"backpack",
+	"xverse",
+	"onekey",
+	"solflare",
+	"braavos",
+	"brave",
+	"unisat",
+	"bitgetwallet",
+	"coin98"
+];
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getPriorityIndex/getPriorityIndex.ts
+/**
+* Returns the index of a wallet option in `PRIORITY_WALLET_KEYS`, or
+* `Number.POSITIVE_INFINITY` when the wallet is not in the hand-curated
+* priority list. Lower index = higher priority.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns Numeric priority index — lower is better.
+* @not-instrumented
+*/
+const getPriorityIndex = ({ walletOption }) => {
+	const index = PRIORITY_WALLET_KEYS.indexOf(walletOption.key);
+	return index === -1 ? Number.POSITIVE_INFINITY : index;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/compareByRelevance/compareByRelevance.ts
+/**
+* Compares two wallet options for relevance ordering: priority-list index
+* first, then alphabetical-by-name as the tie-break. Suitable for passing
+* straight to `Array.prototype.sort`.
+*
+* @param params.a - First wallet option.
+* @param params.b - Second wallet option.
+* @returns Negative when `a` ranks first, positive when `b` ranks first.
+* @not-instrumented
+*/
+const compareByRelevance = ({ a, b }) => {
+	const aIndex = getPriorityIndex({ walletOption: a });
+	const bIndex = getPriorityIndex({ walletOption: b });
+	if (aIndex !== bIndex) return aIndex - bIndex;
+	return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/hasAnyConnectionOption/hasAnyConnectionOption.ts
+/**
+* True when the wallet option has at least one connection — i.e. the user
+* can sign in right now. Install-only wallet options surface in the
+* catalogue too (they carry `installationUrls`) but have an empty
+* `connectionOptions` array; this predicate distinguishes them from
+* actually connectable wallets in the relevance sort.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns True when `connectionOptions` is non-empty.
+* @not-instrumented
+*/
+const hasAnyConnectionOption = ({ walletOption }) => walletOption.connectionOptions.length > 0;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/hasInstalledProvider/hasInstalledProvider.ts
+/**
+* True when the wallet option has a `withWalletProvider` connection — i.e.
+* the user already has the wallet available in the page (browser extension,
+* Wallet Standard announcement, window injection, or an SDK-backed provider
+* one of our chain extensions registered). `connectionOptions` is
+* pre-sorted, so a registered provider always sits at index 0 when present.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns True when an installed provider is available.
+* @not-instrumented
+*/
+const hasInstalledProvider = ({ walletOption }) => walletOption.connectionOptions[0]?.type === "withWalletProvider";
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/sortWalletOptions/sortWalletOptions.ts
+/**
+* Sorts the outer wallet-option list. This is the only ordering controlled
+* by the customer; the inner `connectionOptions` array of each wallet
+* option is ordered separately by `sortConnectionOptions` using a fixed
+* option-type priority.
+*
+* - `'relevance'` (default): bucket wallet options into three tiers, in
+*   this order:
+*     1. **Installed provider** — user already has the wallet available
+*        (`withWalletProvider` at index 0).
+*     2. **Connectable** — has at least one connection (URI deeplink
+*        or `inAppBrowser`) but no installed provider.
+*     3. **Install-only** — no connection at all; only `installationUrls`.
+*   Within each tier, rank by the hand-curated {@link PRIORITY_WALLET_KEYS}
+*   list (MetaMask, Coinbase, Phantom, …); unknown wallets fall through to
+*   alphabetical-by-name order at the tail of their tier.
+* - `'alphabetical'`: case-insensitive sort by wallet option `name`,
+*   without bucketing.
+*
+* Returns a new array — the input is not mutated.
+*
+* @param params.walletOptions - The wallet options to sort.
+* @param params.ordering - The requested ordering.
+* @returns A new array in the requested order.
+* @not-instrumented
+*/
+const sortWalletOptions = ({ walletOptions, ordering }) => {
+	if (ordering === "alphabetical") return [...walletOptions].sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" }));
+	const installed = [];
+	const connectable = [];
+	const installOnly = [];
+	for (const walletOption of walletOptions) if (hasInstalledProvider({ walletOption })) installed.push(walletOption);
+	else if (hasAnyConnectionOption({ walletOption })) connectable.push(walletOption);
+	else installOnly.push(walletOption);
+	installed.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	connectable.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	installOnly.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	return [
+		...installed,
+		...connectable,
+		...installOnly
+	];
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getWalletOptionsCatalogue/getWalletOptionsCatalogue.ts
+const EMPTY_WALLET_BOOK = {
+	groups: {},
+	wallets: {}
+};
+/**
+* Returns the catalogue of external wallet options a user can sign in
+* with through this client. Always includes installed wallet providers;
+* pass `includeMobileOptions: true` to additionally surface
+* WalletConnect, in-app-browser, and install links.
+*
+* @param [params] - Inclusion flag + ordering preference.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise that resolves to the wallet options catalogue.
+* @not-instrumented
+*/
+const getWalletOptionsCatalogue = async (params = {}, client = getDefaultClient()) => {
+	const includeMobileOptions = params.includeMobileOptions ?? false;
+	const walletOptionOrdering = params.walletOptionOrdering ?? "relevance";
+	const walletBook = includeMobileOptions ? await fetchLegacyWalletBook(client) : EMPTY_WALLET_BOOK;
+	const allConnectionOptions = [];
+	const entries = getWalletProviderRegistry(client).listProviderEntries();
+	allConnectionOptions.push(...buildWithWalletProviderOptions({
+		entries,
+		walletBook
+	}, client));
+	if (includeMobileOptions) allConnectionOptions.push(...buildUriDeeplinkOptions({ walletBook }), ...buildInAppBrowserOptions({ walletBook }));
+	const installationUrlsByKey = includeMobileOptions ? buildInstallationUrlsByWalletOptionKey({ walletBook }) : /* @__PURE__ */ new Map();
+	const grouped = groupOptionsByWalletOption({ options: allConnectionOptions });
+	const allWalletOptionKeys = new Set([...grouped.keys(), ...installationUrlsByKey.keys()]);
+	const walletOptions = [];
+	for (const walletOptionKey of allWalletOptionKeys) {
+		if (EXCLUDED_WALLET_OPTION_KEYS.has(walletOptionKey)) continue;
+		const groupedEntry = grouped.get(walletOptionKey);
+		const connectionOptions = groupedEntry ? sortConnectionOptions({ options: groupedEntry.connectionOptions }) : [];
+		walletOptions.push(buildWalletOption({
+			connectionOptions,
+			displayOverride: groupedEntry?.displayOverride,
+			installationUrls: installationUrlsByKey.get(walletOptionKey),
+			walletBook,
+			walletOptionKey
+		}));
+	}
+	return sortWalletOptions({
+		ordering: walletOptionOrdering,
+		walletOptions
+	});
+};
+
 //#endregion
 //#region src/modules/user/updateUser/updateUser.ts
 /**
@@ -4149,6 +5089,7 @@ const authenticateTotpMfaDevice = async ({ deviceId, code, createMfaTokenOptions
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the newly generated recovery codes.
 * @instrumented
+* @redact-params
 */
 const createNewMfaRecoveryCodes = async (client = getDefaultClient()) => {
 	const core = getCore(client);
@@ -4164,7 +5105,8 @@ const __createNewMfaRecoveryCodes_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -5391,6 +6333,7 @@ const verifyOTPForUserUpdate = async ({ otpVerification, verificationToken, requ
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the verify response object upon successful verification.
 * @instrumented
+* @redact-params
 */
 const verifyOTP = async ({ otpVerification, verificationToken, requestedScopes }, client = getDefaultClient()) => {
 	let response;
@@ -5416,7 +6359,8 @@ const __verifyOTP_wrapped = instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -5840,13 +6784,12 @@ const getAddressesWithTypesFromConnectionResult = (connectionResult) => {
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the connected wallet account.
 * @throws NoAddressFoundError If the request to connect was successful but no address is connected to your app.
-* @instrumented
+*  @instrumented
 */
 const connectWithWalletProvider = async ({ walletProviderKey, addToDynamicWalletAccounts = true, hardwareWalletVendor }, client = getDefaultClient()) => {
 	const walletProvider = getWalletProviderByKey({ walletProviderKey }, client);
 	assertWalletProviderMethodDefined(walletProvider, "connect");
 	const { addresses } = await walletProvider.connect();
-	const currentAddresses = getWalletAccounts(client).map(({ address }) => address);
 	const mainAddress = addresses?.length ? addresses[0].address : null;
 	/**
 	* This error is thrown in case the wallet has no addresses connected
@@ -5854,27 +6797,25 @@ const connectWithWalletProvider = async ({ walletProviderKey, addToDynamicWallet
 	* user on the next steps.
 	*/
 	if (!mainAddress) throw new NoAddressFoundError();
-	const walletAccount = {
-		address: mainAddress,
-		addressesWithTypes: getAddressesWithTypesFromConnectionResult({ addresses }),
-		chain: walletProvider.chain,
-		hardwareWalletVendor,
-		id: formatWalletAccountId({
+	const [reconciledWalletAccount] = reconcileWalletAccountsAgainstClient({
+		addToDynamicWalletAccounts,
+		walletAccounts: [{
 			address: mainAddress,
+			addressesWithTypes: getAddressesWithTypesFromConnectionResult({ addresses }),
 			chain: walletProvider.chain,
+			hardwareWalletVendor,
+			id: formatWalletAccountId({
+				address: mainAddress,
+				chain: walletProvider.chain,
+				walletProviderKey
+			}),
+			lastSelectedAt: null,
+			verifiedCredentialId: null,
 			walletProviderKey
-		}),
-		lastSelectedAt: null,
-		verifiedCredentialId: null,
+		}],
 		walletProviderKey
-	};
-	if (currentAddresses.includes(mainAddress)) return walletAccount;
-	if (addToDynamicWalletAccounts) {
-		setUnverifiedWalletAccounts({ unverifiedWalletAccountsToUpdate: [walletAccount] }, client);
-		emitWalletAccountsChangedEvent(client);
-		createVisit({ walletAccount }, client);
-	}
-	return walletAccount;
+	}, client);
+	return reconciledWalletAccount;
 };
 const __connectWithWalletProvider_impl = connectWithWalletProvider;
 const __connectWithWalletProvider_wrapped = instrumentFunction({
@@ -6805,5 +7746,5 @@ const parseUserAgent = ({ userAgent }) => {
 assertPackageVersion(name, version);
 
 //#endregion
-export { BaseError, CheckoutSessionTokenMissingError, ClientAlreadyInitializedError, DeeplinkConnectAndVerifyUnsupportedError, FeeEstimationFailedError, GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES, InvalidDeviceRegistrationRedirectError, InvalidExternalAuthError, InvalidParamError, InvalidRedirectStorageStateError, InvalidSocialCallbackOriginError, LinkCredentialError, MFAAction, MfaInvalidOtpError, MfaRateLimitedError, MissingRedirectStorageStateError, MissingSocialUrlParamError, MissingUserVerificationError, NetworkAddingUnavailableError, NetworkNotAddedError, NetworkSwitchingUnavailableError, NoAddressFoundError, NoNetworkProvidersError, NoPasskeyCredentialsFoundError, NoSmartWalletAccountSignerFoundError, NoWebAuthNSupportError, NotWaasWalletAccountError, SandboxMaximumThresholdReachedError, SimulationFailedError, TokenSwapError, UnauthorizedError, UnavailableInServerSideError, UnrecognizedNetworkError, UserCancelledSocialPopUpError, UserNotAuthenticatedError, UserRejectedError, WalletAccountAlreadyVerifiedError, WalletAccountNotSelectedError, WalletAlreadyLinkedToAnotherUserError, WalletProviderMethodUnavailableError, __acknowledgeRecoveryCodes_wrapped as acknowledgeRecoveryCodes, addCoinbaseOnrampOrderEventListener, __addNetwork_wrapped as addNetwork, assertWalletAccountSigningAvailability, assertWalletProviderMethodDefined, __attachCheckoutTransactionSource_wrapped as attachCheckoutTransactionSource, authenticateMfaRecoveryCode, authenticatePasskeyMFA, authenticateTotpMfaDevice, __authenticateWithSocial_wrapped as authenticateWithSocial, __broadcastCheckoutTransaction_wrapped as broadcastCheckoutTransaction, canConnectWithHardwareWallet, __cancelCheckoutTransaction_wrapped as cancelCheckoutTransaction, __checkStepUpAuth_wrapped as checkStepUpAuth, __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, __createCoinbaseOnrampOrder_wrapped as createCoinbaseOnrampOrder, __createCryptoDotComPayment_wrapped as createCryptoDotComPayment, __createDynamicClient_wrapped as createDynamicClient, __createKrakenExchangeTransfer_wrapped as createKrakenExchangeTransfer, __createNewMfaRecoveryCodes_wrapped as createNewMfaRecoveryCodes, __deleteMfaDevice_wrapped as deleteMfaDevice, __deletePasskey_wrapped as deletePasskey, __deleteUser_wrapped as deleteUser, detectDeviceRegistrationRedirect, detectOAuthRedirect, detectSocialRedirectUrl, excludeInstalledFromCatalog, __executeSwapTransaction_wrapped as executeSwapTransaction, fetchProjectSettings, findMissingGoogleDriveBackupScopes, getActiveNetworkData, getActiveNetworkId, getAvailableWalletProvidersData, getBalance, getBalanceForAddress, getBalances, getCheckoutTransaction, getCheckoutTransactionQuote, getCoinbaseBuyUrl, getConnectedAddresses, getDefaultClient, getDeviceRegistrationTokenFromUrl, __getElevatedAccessToken_wrapped as getElevatedAccessToken, __getGoogleDriveBackupReadiness_wrapped as getGoogleDriveBackupReadiness, getKrakenAccounts, getKrakenWhitelistedAddresses, getMfaDevices, getMfaMethods, getMfaRecoveryCodes, getMissingVerificationForCoinbaseOnrampOrder, getMultichainBalances, getNetworksData, getOwnerWalletAccountForSmartWalletAccount, getPasskeys, getPrimaryWalletAccount, getRegisteredDevices, getSwapQuote, getSwapStatus, getTransactionHistory, getUserSocialAccounts, getWalletAccountAddressByType, getWalletAccountFromAddress, getWalletAccounts, getWalletConnectCatalog, getWalletConnectCatalogWalletByWalletProviderKey, getWalletProviderDataByKey, hasAllGoogleDriveBackupScopes, hasExtension, __initializeClient_wrapped as initializeClient, isCaptchaRequired, isDeeplinkWalletProvider, isDeviceRegistrationRequired, isHardwareWalletAccount, isInsufficientGoogleDriveScopesError, isMfaRequiredForAction, isMobile, isPendingRecoveryCodesAcknowledgment, isProgrammaticNetworkSwitchAvailable, isSignedIn, isUserMissingMfaAuth, isUserOnboardingComplete, isWalletAccountVerified, logout, matchWalletProvidersToCatalogGroup, offEvent, offWalletProviderEvent, onEvent, onWalletProviderEvent, onceEvent, parseUserAgent, __prepareCheckoutTransaction_wrapped as prepareCheckoutTransaction, __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, __selectPrimaryWalletAccount_wrapped as selectPrimaryWalletAccount, __sendEmailOTP_wrapped as sendEmailOTP, __sendSmsOTP_wrapped as sendSmsOTP, __setCaptchaToken_wrapped as setCaptchaToken, __setDefaultMfaDevice_wrapped as setDefaultMfaDevice, __setInstrumentationEnabled_wrapped as setInstrumentationEnabled, __signInWithExternalJwt_wrapped as signInWithExternalJwt, __signInWithPasskey_wrapped as signInWithPasskey, __signInWithSocialPopUp_wrapped as signInWithSocialPopUp, __signInWithSocialRedirect_wrapped as signInWithSocialRedirect, __signMessage_wrapped as signMessage, __submitCheckoutTransaction_wrapped as submitCheckoutTransaction, 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 };
+export { BaseError, CheckoutSessionTokenMissingError, ClientAlreadyInitializedError, DeeplinkConnectAndVerifyUnsupportedError, FeeEstimationFailedError, GOOGLE_DRIVE_BACKUP_REQUIRED_SCOPES, InvalidDeviceRegistrationRedirectError, InvalidExternalAuthError, InvalidParamError, InvalidRedirectStorageStateError, InvalidSocialCallbackOriginError, LinkCredentialError, MFAAction, MfaInvalidOtpError, MfaRateLimitedError, MissingRedirectStorageStateError, MissingSocialUrlParamError, MissingUserVerificationError, NetworkAddingUnavailableError, NetworkNotAddedError, NetworkSwitchingUnavailableError, NoAddressFoundError, NoNetworkProvidersError, NoPasskeyCredentialsFoundError, NoSmartWalletAccountSignerFoundError, NoWebAuthNSupportError, NotWaasWalletAccountError, SandboxMaximumThresholdReachedError, SimulationFailedError, TokenSwapError, UnauthorizedError, UnavailableInServerSideError, UnrecognizedNetworkError, UserCancelledSocialPopUpError, UserNotAuthenticatedError, UserRejectedError, WalletAccountAlreadyVerifiedError, WalletAccountNotSelectedError, WalletAlreadyLinkedToAnotherUserError, WalletProviderMethodUnavailableError, __acknowledgeRecoveryCodes_wrapped as acknowledgeRecoveryCodes, addCoinbaseOnrampOrderEventListener, __addNetwork_wrapped as addNetwork, appendConnectionUriToDeeplink, assertWalletAccountSigningAvailability, assertWalletProviderMethodDefined, __attachCheckoutTransactionSource_wrapped as attachCheckoutTransactionSource, authenticateMfaRecoveryCode, authenticatePasskeyMFA, authenticateTotpMfaDevice, __authenticateWithSocial_wrapped as authenticateWithSocial, __broadcastCheckoutTransaction_wrapped as broadcastCheckoutTransaction, canConnectWithHardwareWallet, __cancelCheckoutTransaction_wrapped as cancelCheckoutTransaction, __checkStepUpAuth_wrapped as checkStepUpAuth, __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, __createCoinbaseOnrampOrder_wrapped as createCoinbaseOnrampOrder, __createCryptoDotComPayment_wrapped as createCryptoDotComPayment, __createDynamicClient_wrapped as createDynamicClient, __createKrakenExchangeTransfer_wrapped as createKrakenExchangeTransfer, __createNewMfaRecoveryCodes_wrapped as createNewMfaRecoveryCodes, __deleteMfaDevice_wrapped as deleteMfaDevice, __deletePasskey_wrapped as deletePasskey, __deleteUser_wrapped as deleteUser, detectDeviceRegistrationRedirect, detectOAuthRedirect, detectSocialRedirectUrl, excludeInstalledFromCatalog, __executeSwapTransaction_wrapped as executeSwapTransaction, fetchProjectSettings, findMissingGoogleDriveBackupScopes, getActiveNetworkData, getActiveNetworkId, getAvailableWalletProvidersData, getBalance, getBalanceForAddress, getBalances, getCheckoutTransaction, getCheckoutTransactionQuote, getCoinbaseBuyUrl, getConnectedAddresses, getDefaultClient, getDeviceRegistrationTokenFromUrl, __getElevatedAccessToken_wrapped as getElevatedAccessToken, __getGoogleDriveBackupReadiness_wrapped as getGoogleDriveBackupReadiness, getKrakenAccounts, getKrakenWhitelistedAddresses, getMfaDevices, getMfaMethods, getMfaRecoveryCodes, getMissingVerificationForCoinbaseOnrampOrder, getMultichainBalances, getNetworksData, getOwnerWalletAccountForSmartWalletAccount, getPasskeys, getPrimaryWalletAccount, getRegisteredDevices, getSwapQuote, getSwapStatus, getTransactionHistory, getUserSocialAccounts, getWalletAccountAddressByType, getWalletAccountFromAddress, getWalletAccounts, getWalletConnectCatalog, getWalletConnectCatalogWalletByWalletProviderKey, getWalletOptionsCatalogue, getWalletProviderDataByKey, hasAllGoogleDriveBackupScopes, hasExtension, __initializeClient_wrapped as initializeClient, isCaptchaRequired, isDeeplinkWalletProvider, isDeviceRegistrationRequired, isHardwareWalletAccount, isInsufficientGoogleDriveScopesError, isMfaRequiredForAction, isMobile, isPendingRecoveryCodesAcknowledgment, isProgrammaticNetworkSwitchAvailable, isSignedIn, isUserMissingMfaAuth, isUserOnboardingComplete, isWalletAccountVerified, logout, matchWalletProvidersToCatalogGroup, offEvent, offWalletProviderEvent, onEvent, onWalletProviderEvent, onceEvent, parseUserAgent, __prepareCheckoutTransaction_wrapped as prepareCheckoutTransaction, __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, __selectPrimaryWalletAccount_wrapped as selectPrimaryWalletAccount, __sendEmailOTP_wrapped as sendEmailOTP, __sendSmsOTP_wrapped as sendSmsOTP, __setCaptchaToken_wrapped as setCaptchaToken, __setDefaultMfaDevice_wrapped as setDefaultMfaDevice, __setInstrumentationEnabled_wrapped as setInstrumentationEnabled, __signInWithExternalJwt_wrapped as signInWithExternalJwt, __signInWithPasskey_wrapped as signInWithPasskey, __signInWithSocialPopUp_wrapped as signInWithSocialPopUp, __signInWithSocialRedirect_wrapped as signInWithSocialRedirect, __signMessage_wrapped as signMessage, __submitCheckoutTransaction_wrapped as submitCheckoutTransaction, 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 };
 //# sourceMappingURL=index.native.esm.js.map