@dynamic-labs-sdk/client 1.3.0 → 1.5.0

package/dist/index.cjs

@@ -1,14 +1,14 @@
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-BA0CHZzu.cjs');
-const require_InvalidParamError = require('./InvalidParamError-DQvZQdQ9.cjs');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-DSSDwOyq.cjs');
-const require_NotWaasWalletAccountError = require('./NotWaasWalletAccountError-Ciq7b-Y6.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-CMClgbT0.cjs');
+const require_InvalidParamError = require('./InvalidParamError-DKJhDrK8.cjs');
+const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-BJ27N-7S.cjs');
+const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-gCx0smU8.cjs');
+const require_NotWaasWalletAccountError = require('./NotWaasWalletAccountError-CHzpa9kk.cjs');
+const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-CLMvTTwl.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
-zod_mini = require_getNetworkProviderFromNetworkId.__toESM(zod_mini);
+zod_mini = require_InvalidParamError.__toESM(zod_mini);
 let eventemitter3 = require("eventemitter3");
-eventemitter3 = require_getNetworkProviderFromNetworkId.__toESM(eventemitter3);
+eventemitter3 = require_InvalidParamError.__toESM(eventemitter3);
 let _simplewebauthn_browser = require("@simplewebauthn/browser");
 
 //#region src/modules/state/raiseStateEvents/events.ts
@@ -28,11 +28,33 @@ const stateChangeEvents = {
 };
 
 //#endregion
-//#region src/utils/getNonce/prefetchNoncesIfNeeded/prefetchNoncesIfNeeded.ts
-/** @not-instrumented */
-const prefetchNoncesIfNeeded = async (client) => {
-	if (require_InvalidParamError.getCore(client).state.get().prefetchedNonces.length >= require_InvalidParamError.NONCE_POOL_SIZE) return;
-	await require_InvalidParamError.fetchAndStoreNonces(client);
+//#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
@@ -52,6 +74,14 @@ const createRuntimeServices = () => {
 	};
 };
 
+//#endregion
+//#region src/utils/getNonce/prefetchNoncesIfNeeded/prefetchNoncesIfNeeded.ts
+/** @not-instrumented */
+const prefetchNoncesIfNeeded = async (client) => {
+	if (require_InvalidParamError.getCore(client).state.get().prefetchedNonces.length >= require_InvalidParamError.NONCE_POOL_SIZE) return;
+	await require_InvalidParamError.fetchAndStoreNonces(client);
+};
+
 //#endregion
 //#region src/modules/auth/initializeAuth/setLongTimeout/setLongTimeout.ts
 /**
@@ -92,7 +122,7 @@ const initializeAuth = (client) => {
 		const now = /* @__PURE__ */ new Date();
 		const timeUntilExpiration = expiration.getTime() - now.getTime();
 		if (timeUntilExpiration <= 0) {
-			require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "token-expired" }, client);
+			require_InvalidParamError.__logoutWithReason_wrapped({ reason: "token-expired" }, client);
 			return;
 		}
 		clearExpirationTimeout = setLongTimeout({
@@ -130,7 +160,7 @@ const setupCrossTabEventSync = (client) => {
 	};
 	core.eventEmitter.on("deviceRegistrationCompleted", handleDeviceRegistrationCompleted);
 	const handleCrossTabDeviceRegistrationCompleted = () => {
-		require_getVerifiedCredentialForWalletAccount.emitEvent({ event: "deviceRegistrationCompletedInAnotherTab" }, client);
+		require_InvalidParamError.emitEvent({ event: "deviceRegistrationCompletedInAnotherTab" }, client);
 	};
 	core.crossTabBroadcast.on("deviceRegistrationCompleted", handleCrossTabDeviceRegistrationCompleted);
 };
@@ -157,7 +187,7 @@ const walletProviderKeyMapSchema = zod_mini.record(zod_mini.string(), zod_mini.s
 
 //#endregion
 //#region src/modules/storageSync/schema.ts
-const stateStorageKeySchema = require_getNetworkProviderFromNetworkId.createStorageKeySchema({
+const stateStorageKeySchema = require_InvalidParamError.createStorageKeySchema({
 	key: "state",
 	schema: zod_mini.object({
 		apiVersion: zod_mini.string(),
@@ -169,7 +199,7 @@ const stateStorageKeySchema = require_getNetworkProviderFromNetworkId.createStor
 		walletProviderKeyMap: walletProviderKeyMapSchema
 	})
 });
-const sessionStorageKeySchema = require_getNetworkProviderFromNetworkId.createStorageKeySchema({
+const sessionStorageKeySchema = require_InvalidParamError.createStorageKeySchema({
 	config: { storageTier: "secure" },
 	key: "session",
 	schema: zod_mini.object({
@@ -263,7 +293,7 @@ const raiseStateEvents = (client) => {
 	require_InvalidParamError.getCore(client).state.subscribe((value, previous) => {
 		Object.entries(stateChangeEvents).forEach(([key, event]) => {
 			if (require_getNetworkProviderFromNetworkId.isEqualShallow(value[key], previous[key])) return;
-			require_getVerifiedCredentialForWalletAccount.emitEvent({
+			require_InvalidParamError.emitEvent({
 				args: { [key]: value[key] },
 				event
 			}, client);
@@ -429,10 +459,10 @@ const initializeClient = async (client = require_InvalidParamError.getDefaultCli
 			logger: core.logger,
 			state: core.state,
 			storage: core.storage
-		}).catch(() => require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "keychain-migration-failed" }, client));
-		if (core.state.get().sessionKeys && !await core.keychain.hasKey("session")) await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "keychain-key-missing" }, client);
+		}).catch(() => require_InvalidParamError.__logoutWithReason_wrapped({ reason: "keychain-migration-failed" }, client));
+		if (core.state.get().sessionKeys && !await core.keychain.hasKey("session")) await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "keychain-key-missing" }, client);
 	}).then(async () => {
-		if (!core.state.get().projectSettings) await require_getNetworkProviderFromNetworkId.fetchProjectSettings(client);
+		if (!core.state.get().projectSettings) await require_InvalidParamError.fetchProjectSettings(client);
 	});
 	fetchProjectSettingsPromise.then(() => prefetchNoncesIfNeeded(client)).catch((error) => {
 		core.logger.error("Failed to prefetch nonces:", error);
@@ -441,7 +471,7 @@ const initializeClient = async (client = require_InvalidParamError.getDefaultCli
 	* Generate session keys if they don't exist
 	*/
 	const generateSessionKeysPromise = fetchProjectSettingsPromise.then(async () => {
-		if (!core.state.get().sessionKeys) await require_getNetworkProviderFromNetworkId.generateSessionKeys(client);
+		if (!core.state.get().sessionKeys) await require_InvalidParamError.generateSessionKeys(client);
 	});
 	/**
 	* Refresh user state on initialization when cookie is enabled.
@@ -466,7 +496,7 @@ const initializeClient = async (client = require_InvalidParamError.getDefaultCli
 		if (require_InvalidParamError.isCookieEnabled(client)) await require_NotWaasWalletAccountError.__refreshAuth_wrapped(client).catch(async (error) => {
 			if (error.status === 401) {
 				core.logger.error("Session expired during initialization", error);
-				if (client.user) await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "session-refresh-unauthorized" }, client);
+				if (client.user) await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "session-refresh-unauthorized" }, client);
 			} else throw error;
 		});
 	});
@@ -477,7 +507,7 @@ const initializeClient = async (client = require_InvalidParamError.getDefaultCli
 	*/
 	const refreshUserStateFromValidTokenPromise = refreshUserStateFromCookiePromise.then(async () => {
 		if (core.state.get().token && !core.state.get().user) await __refreshUser_wrapped(client).catch(async () => {
-			await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "user-refresh-failed" }, client);
+			await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "user-refresh-failed" }, client);
 		});
 	});
 	core.initTrack.track({
@@ -628,10 +658,13 @@ const connectLoggerToInstrumentation = ({ environmentId, extensions, instrumenta
 		const { token, user } = state.get();
 		instrumentation.log({
 			environmentId,
-			parameters: {
-				args,
-				message
-			},
+			parameters: require_InvalidParamError.scrubParameters({
+				piiFields: instrumentation.config.piiFields,
+				value: {
+					args,
+					message
+				}
+			}),
 			registeredExtensionKeys: Array.from(extensions),
 			sdkSessionId,
 			sdkVersion,
@@ -1543,6 +1576,7 @@ const __checkStepUpAuth_wrapped = require_InvalidParamError.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 = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
@@ -1570,7 +1604,8 @@ const __requestExternalAuthElevatedToken_wrapped = require_InvalidParamError.ins
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -1629,7 +1664,7 @@ const logout = async (client = require_InvalidParamError.getDefaultClient()) =>
 	* `logoutWithReason` — this wrapper is intentionally not instrumented so that
 	* Datadog sees a single function name per logout regardless of entry point.
 	*/
-	return require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "user-intent" }, client);
+	return require_InvalidParamError.__logoutWithReason_wrapped({ reason: "user-intent" }, client);
 };
 
 //#endregion
@@ -1722,6 +1757,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 = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
@@ -1744,7 +1780,8 @@ const __registerPasskey_wrapped = require_InvalidParamError.instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -1789,6 +1826,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 = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
@@ -1808,7 +1846,8 @@ const __signInWithPasskey_wrapped = require_InvalidParamError.instrumentFunction
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -1847,7 +1886,7 @@ const removeDynamicOauthParamsFromUrl = (url) => {
 //#endregion
 //#region src/modules/auth/social/oauth/redirectStateStorageSchema/redirectStateStorageSchema.ts
 /** The schema to track the state of the OAuth flow. */
-const redirectStateStorageKeySchema = require_getNetworkProviderFromNetworkId.createStorageKeySchema({
+const redirectStateStorageKeySchema = require_InvalidParamError.createStorageKeySchema({
 	key: "redirectState",
 	schema: zod_mini.object({
 		codeVerifier: zod_mini.optional(zod_mini.string()),
@@ -2235,7 +2274,7 @@ const detectOAuthRedirect = (params, client = require_InvalidParamError.getDefau
 * @not-instrumented
 */
 const getPrimaryWalletAccount = (client = require_InvalidParamError.getDefaultClient()) => {
-	const sortedLastSelectedWalletAccounts = require_getVerifiedCredentialForWalletAccount.getWalletAccounts(client).filter((walletAccount) => Boolean(walletAccount.lastSelectedAt)).sort((a, b) => b.lastSelectedAt.getTime() - a.lastSelectedAt.getTime());
+	const sortedLastSelectedWalletAccounts = require_InvalidParamError.getWalletAccounts(client).filter((walletAccount) => Boolean(walletAccount.lastSelectedAt)).sort((a, b) => b.lastSelectedAt.getTime() - a.lastSelectedAt.getTime());
 	if (sortedLastSelectedWalletAccounts.length === 0) return null;
 	const [primaryWalletAccount] = sortedLastSelectedWalletAccounts;
 	return primaryWalletAccount;
@@ -2250,6 +2289,7 @@ const getPrimaryWalletAccount = (client = require_InvalidParamError.getDefaultCl
 * @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 = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
@@ -2275,26 +2315,34 @@ const __unlinkSocialAccount_wrapped = require_InvalidParamError.instrumentFuncti
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
-//#region src/modules/balances/getBalances/getBalances.ts
+//#region src/modules/balances/getTokenBalances/getTokenBalances.ts
 /**
-* Retrieves the token balances for a wallet account.
+* Retrieves the token balances for a wallet account on one chain. Fetched
+* from the Dynamic API.
+*
+* Use this for ERC-20-style token balances scoped to a single wallet
+* account. Supports optional spam filtering, price inclusion, native-token
+* inclusion, and one-or-many networks within the wallet's chain.
 *
-* This function fetches the balances of the tokens for the specified wallet account.
+* For native-only balance, use {@link getNativeBalance}. For a
+* multi-chain portfolio across many addresses, use
+* {@link getMultichainTokenBalances}.
 *
 * @param params.walletAccount - The wallet account to get the balances for.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to an array of token balances.
 * @not-instrumented
 */
-const getBalances = async ({ walletAccount, networkId, networkIds, includePrices, includeNative, filterSpamTokens, whitelistedContracts, forceRefresh }, client = require_InvalidParamError.getDefaultClient()) => {
+const getTokenBalances = async ({ walletAccount, networkId, networkIds, includePrices, includeNative, filterSpamTokens, whitelistedContracts, forceRefresh }, client = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
 	const apiClient = require_InvalidParamError.createApiClient({}, client);
 	if (!networkId && !networkIds) {
-		const activeNetworkId = await require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
+		const activeNetworkId = await require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
 		networkId = Number(activeNetworkId.networkId);
 	}
 	return await apiClient.getAccountBalances({
@@ -2312,19 +2360,22 @@ const getBalances = async ({ walletAccount, networkId, networkIds, includePrices
 };
 
 //#endregion
-//#region src/modules/balances/getMultichainBalances/getMultichainBalances.ts
+//#region src/modules/balances/getMultichainTokenBalances/getMultichainTokenBalances.ts
 /**
-* Retrieves token balances across multiple blockchain networks.
+* Retrieves token balances across multiple chains, networks, and addresses
+* in a single batched API request.
 *
-* This function fetches cryptocurrency and token balances for the user's
-* wallet addresses across different chains, networks and addresses specified in the request.
+* Use this for portfolio-style views that need to render a user's holdings
+* across their entire multi-chain wallet set. For a single account on one
+* chain, use {@link getTokenBalances}; for native-only balance, use
+* {@link getNativeBalance}.
 *
 * @param params.balanceRequest - The balance request configuration specifying which chains, networks and addresses to query.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to the chain balances across multiple networks.
 * @not-instrumented
 */
-const getMultichainBalances = async ({ balanceRequest }, client = require_InvalidParamError.getDefaultClient()) => {
+const getMultichainTokenBalances = async ({ balanceRequest }, client = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
 	return (await require_InvalidParamError.createApiClient({}, client).postMultichainAccountBalances({
 		environmentId: core.environmentId,
@@ -2336,7 +2387,7 @@ const getMultichainBalances = async ({ balanceRequest }, client = require_Invali
 //#region src/modules/checkout/utils/createCheckoutSessionTokenStorageKey/createCheckoutSessionTokenStorageKey.ts
 /** @not-instrumented */
 const createCheckoutSessionTokenStorageKey = (transactionId) => {
-	return require_getNetworkProviderFromNetworkId.createStorageKeySchema({
+	return require_InvalidParamError.createStorageKeySchema({
 		key: `checkoutSessionToken:${transactionId}`,
 		schema: zod_mini.string()
 	});
@@ -2357,6 +2408,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 require_InvalidParamError.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 require_InvalidParamError.APIError && error.status === 401) try {
+			await clearCheckoutSessionToken({ transactionId }, client);
+		} catch (cleanupError) {
+			require_InvalidParamError.getCore(client).logger.error("Failed to clear checkout session token after 401", cleanupError);
+		}
+		throw error;
+	}
+};
+
 //#endregion
 //#region src/modules/checkout/attachCheckoutTransactionSource/attachCheckoutTransactionSource.ts
 /**
@@ -2381,12 +2478,15 @@ const attachCheckoutTransactionSource = async (params, client = require_InvalidP
 		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 = require_InvalidParamError.instrumentFunction({
@@ -2417,12 +2517,15 @@ const __attachCheckoutTransactionSource_wrapped = require_InvalidParamError.inst
 */
 const broadcastCheckoutTransaction = async ({ transactionId, txHash }, client = require_InvalidParamError.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 = require_InvalidParamError.instrumentFunction({
@@ -2449,12 +2552,15 @@ const __broadcastCheckoutTransaction_wrapped = require_InvalidParamError.instrum
 */
 const cancelCheckoutTransaction = async ({ transactionId }, client = require_InvalidParamError.getDefaultClient()) => {
 	const { apiClient, environmentId, sessionToken } = await createCheckoutApiClient({ transactionId }, client);
-	const result = await apiClient.cancelCheckoutTransaction({
-		environmentId,
-		transactionId,
-		xDynamicCheckoutSessionToken: sessionToken
-	});
-	await require_InvalidParamError.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;
@@ -2555,16 +2661,19 @@ const getCheckoutTransaction = async ({ transactionId }, client = require_Invali
 */
 const getCheckoutTransactionQuote = async ({ fromChainId, fromTokenAddress, slippage, transactionId }, client = require_InvalidParamError.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
@@ -2581,15 +2690,18 @@ const getCheckoutTransactionQuote = async ({ fromChainId, fromTokenAddress, slip
 */
 const prepareCheckoutTransaction = async ({ assertBalanceForGasCost, assertBalanceForTransferAmount, transactionId }, client = require_InvalidParamError.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 = require_InvalidParamError.instrumentFunction({
@@ -2678,9 +2790,9 @@ const ensureCorrectActiveNetwork = async ({ requiredNetworkId, walletProvider },
 * @returns The transaction hash.
 * @instrumented
 */
-const executeSwapTransaction = async ({ walletAccount, signingPayload, onStepChange }, client = require_InvalidParamError.getDefaultClient()) => {
+const executeSwapTransaction = async ({ walletAccount, signingPayload, onStepChange, sponsorshipMode }, client = require_InvalidParamError.getDefaultClient()) => {
 	if (!SWAP_SUPPORTED_CHAINS.includes(walletAccount.chain)) throw new require_InvalidParamError.InvalidParamError(`Chain ${walletAccount.chain} is not supported for swap transactions`);
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	assertWalletProviderMethodDefined(walletProvider, "executeSwapTransaction");
 	await ensureCorrectActiveNetwork({
 		requiredNetworkId: signingPayload.chainId,
@@ -2689,6 +2801,7 @@ const executeSwapTransaction = async ({ walletAccount, signingPayload, onStepCha
 	const { transactionHash } = await walletProvider.executeSwapTransaction({
 		onStepChange,
 		signingPayload,
+		sponsorshipMode,
 		walletAccount
 	});
 	return { transactionHash };
@@ -2808,7 +2921,7 @@ const completeDeviceRegistration = async ({ deviceToken }, client = require_Inva
 	const core = require_InvalidParamError.getCore(client);
 	const response = await require_InvalidParamError.createApiClient({ headers: { [DEVICE_REGISTRATION_TOKEN_HEADER]: deviceToken } }, client).deviceRegistration({ environmentId: core.environmentId });
 	require_getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({ response }, client);
-	require_getVerifiedCredentialForWalletAccount.emitEvent({ event: "deviceRegistrationCompleted" }, client);
+	require_InvalidParamError.emitEvent({ event: "deviceRegistrationCompleted" }, client);
 	return response;
 };
 const __completeDeviceRegistration_impl = completeDeviceRegistration;
@@ -2873,7 +2986,7 @@ const detectDeviceRegistrationRedirect = ({ url }) => {
 /** @not-instrumented */
 const getRegisteredDevices = async (client = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
-	const apiClient = require_InvalidParamError.createApiClient({}, client);
+	const apiClient = require_InvalidParamError.createApiClient({ skipSessionExpiryLogout: true }, client);
 	try {
 		return (await apiClient.listDeviceRegistrations({ environmentId: core.environmentId })).deviceRegistrations;
 	} catch (error) {
@@ -2906,7 +3019,7 @@ const isDeviceRegistrationRequired = (user) => Boolean(user.scope?.includes("dev
 const revokeAllRegisteredDevices = async (client = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
 	await require_InvalidParamError.createApiClient({}, client).deleteAllDeviceRegistrations({ environmentId: core.environmentId });
-	await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "all-devices-revoked" }, client);
+	await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "all-devices-revoked" }, client);
 };
 const __revokeAllRegisteredDevices_impl = revokeAllRegisteredDevices;
 const __revokeAllRegisteredDevices_wrapped = require_InvalidParamError.instrumentFunction({
@@ -2930,7 +3043,7 @@ const revokeRegisteredDevice = async ({ deviceRegistrationId }, client = require
 	if ((await require_InvalidParamError.createApiClient({}, client).deleteDeviceRegistration({
 		deviceRegistrationId,
 		environmentId: core.environmentId
-	})).currentDeviceRevoked) await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "device-revoked" }, client);
+	})).currentDeviceRevoked) await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "device-revoked" }, client);
 };
 const __revokeRegisteredDevice_impl = revokeRegisteredDevice;
 const __revokeRegisteredDevice_wrapped = require_InvalidParamError.instrumentFunction({
@@ -3152,6 +3265,115 @@ const __createCryptoDotComPayment_wrapped = require_InvalidParamError.instrument
 	}
 });
 
+//#endregion
+//#region src/modules/funding/moonpay/getMoonPayCurrencies/getMoonPayCurrencies.ts
+/**
+* Fetches the list of crypto currencies supported by MoonPay for the given chain
+* and network, filtered to active currencies only. Requires a MoonPay publishable
+* API key to be configured for the environment.
+*
+* @param params - The chain and optional network ID to filter currencies by.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns An array of supported MoonPay currencies.
+* @instrumented
+*/
+const getMoonPayCurrencies = async (params, client = require_InvalidParamError.getDefaultClient()) => {
+	const core = require_InvalidParamError.getCore(client);
+	return (await require_InvalidParamError.createApiClient({ includeMfaToken: true }, client).getMoonPayCurrencies({
+		chain: params.chain,
+		environmentId: core.environmentId,
+		...params.networkId ? { networkId: params.networkId } : {}
+	})).currencies ?? [];
+};
+const __getMoonPayCurrencies_impl = getMoonPayCurrencies;
+const __getMoonPayCurrencies_wrapped = require_InvalidParamError.instrumentFunction({
+	fn: __getMoonPayCurrencies_impl,
+	functionName: "getMoonPayCurrencies",
+	getCore: () => {
+		try {
+			return require_InvalidParamError.getCore(require_InvalidParamError.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
+//#endregion
+//#region src/modules/funding/moonpay/errors/MoonPayInvalidUrlError.ts
+var MoonPayInvalidUrlError = class extends require_InvalidParamError.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "moonpay_invalid_url_error",
+			docsUrl: null,
+			name: "MoonPayInvalidUrlError",
+			shortMessage: "MoonPay is configured but returned an invalid or untrusted URL. This may indicate a misconfiguration — please contact support if the issue persists."
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/funding/moonpay/errors/MoonPayProviderNotAvailableError.ts
+var MoonPayProviderNotAvailableError = class extends require_InvalidParamError.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "moonpay_provider_not_available_error",
+			docsUrl: null,
+			name: "MoonPayProviderNotAvailableError",
+			shortMessage: "MoonPay provider not available. Ensure MoonPay is enabled and a publishable API key is configured in the Dynamic dashboard."
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/funding/moonpay/getMoonPayUrl/getMoonPayUrl.ts
+/**
+* Returns the signed MoonPay URL for the given wallet and token.
+*
+* Uses the Dynamic onramp API to retrieve the pre-signed URL that can be
+* opened in a browser tab to allow the user to purchase crypto via MoonPay.
+*
+* @param params - Parameters including chain, wallet address, and optional token/currency filters.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The signed MoonPay URL.
+* @instrumented
+*/
+const getMoonPayUrl = async (params, client = require_InvalidParamError.getDefaultClient()) => {
+	const core = require_InvalidParamError.getCore(client);
+	const moonPayProvider = (await require_InvalidParamError.createApiClient({ includeMfaToken: true }, client).getSupportedOnramps({
+		chain: params.chain,
+		currency: params.currency,
+		environmentId: core.environmentId,
+		includeDisabled: true,
+		merchantName: params.merchantName,
+		networkId: params.networkId,
+		token: params.token,
+		tokenAmount: params.tokenAmount,
+		walletAddress: params.walletAddress
+	})).onramps?.find((provider) => provider.provider === _dynamic_labs_sdk_api_core.ProviderEnum.MoonPay);
+	if (!moonPayProvider?.url) throw new MoonPayProviderNotAvailableError();
+	const parsedUrl = new URL(moonPayProvider.url);
+	const isValidHost = parsedUrl.hostname === "moonpay.com" || parsedUrl.hostname.endsWith(".moonpay.com");
+	if (parsedUrl.protocol !== "https:" || !isValidHost) {
+		core.logger.error("[getMoonPayUrl] Invalid URL returned by onramp API", { url: moonPayProvider.url });
+		throw new MoonPayInvalidUrlError();
+	}
+	return moonPayProvider.url;
+};
+const __getMoonPayUrl_impl = getMoonPayUrl;
+const __getMoonPayUrl_wrapped = require_InvalidParamError.instrumentFunction({
+	fn: __getMoonPayUrl_impl,
+	functionName: "getMoonPayUrl",
+	getCore: () => {
+		try {
+			return require_InvalidParamError.getCore(require_InvalidParamError.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/funding/kraken/createKrakenExchangeTransfer/createKrakenExchangeTransfer.ts
 /**
@@ -3320,7 +3542,7 @@ const fetchWithTimeout = async (client) => {
 /**
 * The schema to store the cached wallet book data.
 */
-const walletBookCacheStorageKeySchema = require_getNetworkProviderFromNetworkId.createStorageKeySchema({
+const walletBookCacheStorageKeySchema = require_InvalidParamError.createStorageKeySchema({
 	key: "legacyWalletBookCache",
 	schema: zod_mini.object({
 		groups: zod_mini.record(zod_mini.string(), zod_mini.any()),
@@ -3355,7 +3577,7 @@ const fetchLegacyWalletBook = async (client) => {
 	const core = require_InvalidParamError.getCore(client);
 	core.logger.debug("[fetchLegacyWalletBook] Fetching wallet book...");
 	try {
-		const walletBook = await require_getNetworkProviderFromNetworkId.retryOnFail({
+		const walletBook = await require_InvalidParamError.retryOnFail({
 			delay: RETRY_DELAY_MS,
 			fn: async () => fetchWithTimeout(client),
 			maxRetries: MAX_RETRIES
@@ -3469,30 +3691,39 @@ const transformGroup = ({ group }) => {
 };
 
 //#endregion
-//#region src/modules/legacyWalletBook/getWalletConnectCatalog/getChainFromWalletSchema/getChainFromWalletSchema.ts
+//#region src/utils/getChainFromWalletBookIdentifier/getChainFromWalletBookIdentifier.ts
 /**
-* Maps wallet book injected config chain identifiers to Chain type.
+* Resolves a wallet-book chain identifier (as found in
+* `injectedConfig[].chain` or as an alias embedded in a wallet key) to a
+* {@link Chain}. Looks up by `apiChainName` first, then by any
+* `legacyWalletBookAliases` declared on the corresponding `CHAINS_INFO_MAP`
+* entry.
+*
+* Returns `undefined` when the identifier doesn't match any known chain,
+* letting the caller pick its own fallback (e.g. defaulting to EVM, or
+* trying a different lookup strategy).
+*
+* Centralised here rather than in `legacyWalletBook` so all chain naming
+* knowledge stays alongside `CHAINS_INFO_MAP`.
 * @not-instrumented
 */
-const INJECTED_CHAIN_TO_CHAIN_MAP = {
-	algo: "ALGO",
-	aptos: "APTOS",
-	bitcoin: "BTC",
-	btc: "BTC",
-	cosmos: "COSMOS",
-	eclipse: "ECLIPSE",
-	evm: "EVM",
-	flow: "FLOW",
-	sol: "SOL",
-	spark: "SPARK",
-	starknet: "STARK",
-	sui: "SUI",
-	ton: "TON",
-	tron: "TRON"
+const getChainFromWalletBookIdentifier = ({ identifier }) => {
+	const normalised = identifier.toLowerCase();
+	return Object.keys(require_InvalidParamError.CHAINS_INFO_MAP).find((chain) => {
+		const info = require_InvalidParamError.CHAINS_INFO_MAP[chain];
+		return info.apiChainName === normalised || info.legacyWalletBookAliases?.includes(normalised) === true;
+	});
 };
+
+//#endregion
+//#region src/modules/legacyWalletBook/getWalletConnectCatalog/getChainFromWalletSchema/getChainFromWalletSchema.ts
 /**
 * Extracts the chain prefix from a chain identifier string.
 * For example, "eip155:1" -> "eip155", "solana:..." -> "solana"
+*
+* Exported so {@link getChainsFromWalletSchema} can apply the same
+* parsing to its multi-chain pass without duplicating the logic.
+* @not-instrumented
 */
 const extractChainPrefix = ({ chainIdentifier }) => {
 	const colonIndex = chainIdentifier.indexOf(":");
@@ -3500,80 +3731,22 @@ const extractChainPrefix = ({ chainIdentifier }) => {
 	return chainIdentifier.substring(0, colonIndex);
 };
 /**
-* Maps chain name patterns found in wallet keys to Chain type.
-* These are common suffixes or embedded chain identifiers in wallet keys.
-*/
-const WALLET_KEY_CHAIN_PATTERNS = [
-	{
-		chain: "SOL",
-		pattern: "sol"
-	},
-	{
-		chain: "SOL",
-		pattern: "solana"
-	},
-	{
-		chain: "BTC",
-		pattern: "btc"
-	},
-	{
-		chain: "BTC",
-		pattern: "bitcoin"
-	},
-	{
-		chain: "STARK",
-		pattern: "stark"
-	},
-	{
-		chain: "STARK",
-		pattern: "starknet"
-	},
-	{
-		chain: "SUI",
-		pattern: "sui"
-	},
-	{
-		chain: "APTOS",
-		pattern: "aptos"
-	},
-	{
-		chain: "COSMOS",
-		pattern: "cosmos"
-	},
-	{
-		chain: "FLOW",
-		pattern: "flow"
-	},
-	{
-		chain: "ALGO",
-		pattern: "algo"
-	},
-	{
-		chain: "TRON",
-		pattern: "tron"
-	},
-	{
-		chain: "TON",
-		pattern: "ton"
-	},
-	{
-		chain: "SPARK",
-		pattern: "spark"
-	},
-	{
-		chain: "ECLIPSE",
-		pattern: "eclipse"
-	}
-];
-/**
-* Attempts to extract the chain from a wallet key by looking for embedded chain identifiers.
+* Attempts to extract the chain from a wallet key by looking for embedded
+* chain identifiers (apiChainName + legacyWalletBookAliases from CHAINS_INFO_MAP).
+*
+* Derives patterns dynamically so adding a chain in `CHAINS_INFO_MAP`
+* picks it up here — no parallel hardcoded list.
 *
 * @param params.walletKey - The wallet key identifier.
 * @returns The chain type if found, undefined otherwise.
 */
 const getChainFromWalletKey = ({ walletKey }) => {
 	const lowerKey = walletKey.toLowerCase();
-	for (const { chain, pattern } of WALLET_KEY_CHAIN_PATTERNS) if (lowerKey.includes(pattern)) return chain;
+	const chains = Object.keys(require_InvalidParamError.CHAINS_INFO_MAP);
+	for (const chain of chains) {
+		const info = require_InvalidParamError.CHAINS_INFO_MAP[chain];
+		if ([info.apiChainName, ...info.legacyWalletBookAliases ?? []].some((pattern) => lowerKey.includes(pattern))) return chain;
+	}
 };
 /**
 * Gets the chain from a wallet book entry.
@@ -3587,8 +3760,11 @@ const getChainFromWalletKey = ({ walletKey }) => {
 */
 const getChainFromWalletSchema = ({ wallet, walletKey }) => {
 	if (wallet.injectedConfig && wallet.injectedConfig.length > 0) {
-		const injectedChain = wallet.injectedConfig[0].chain?.toLowerCase();
-		if (injectedChain && INJECTED_CHAIN_TO_CHAIN_MAP[injectedChain]) return INJECTED_CHAIN_TO_CHAIN_MAP[injectedChain];
+		const injectedChain = wallet.injectedConfig[0].chain;
+		if (injectedChain) {
+			const chain = getChainFromWalletBookIdentifier({ identifier: injectedChain });
+			if (chain) return chain;
+		}
 	}
 	if (wallet.chains && wallet.chains.length > 0) {
 		const firstChain = wallet.chains[0];
@@ -3821,7 +3997,7 @@ const extractChainFromNormalizedName = ({ normalizedWalletNameWithChain }) => {
 * @not-instrumented
 */
 const getWalletConnectCatalogWalletByWalletProviderKey = async ({ walletProviderKey }, client = require_InvalidParamError.getDefaultClient()) => {
-	const { normalizedWalletNameWithChain } = require_getVerifiedCredentialForWalletAccount.splitWalletProviderKey(walletProviderKey);
+	const { normalizedWalletNameWithChain } = require_InvalidParamError.splitWalletProviderKey(walletProviderKey);
 	const chain = extractChainFromNormalizedName({ normalizedWalletNameWithChain });
 	if (!chain) return;
 	let walletProviderName = normalizedWalletNameWithChain.toLowerCase();
@@ -3836,11 +4012,111 @@ const getWalletConnectCatalogWalletByWalletProviderKey = async ({ walletProvider
 	}
 };
 
+//#endregion
+//#region src/utils/isMobile/isMobile.ts
+/**
+* Sourced from http://detectmobilebrowsers.com/
+* @not-instrumented
+*/
+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 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;
+/** @not-instrumented */
+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();
+};
+/** @not-instrumented */
+const isIPhone = () => typeof window === "undefined" || typeof navigator === "undefined" ? false : /iPhone|ios/.test(navigator.userAgent);
+/**
+* @param [optional] maxTouchPointsOverride - this is used for testing since
+* it seems that JSDOM doesn't support maxTouchPoints, so it was impossible
+* to mock it
+* @not-instrumented
+*/
+const isIPad = (maxTouchPointsOverride) => {
+	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+	const maxTouchPoints = maxTouchPointsOverride || navigator.maxTouchPoints;
+	return /iPad/.test(navigator.userAgent) || /Mac/.test(navigator.userAgent) && maxTouchPoints === 5;
+};
+/** @not-instrumented */
+const isIOS = (maxTouchPointsOverride) => {
+	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+	return isIPhone() || isIPad(maxTouchPointsOverride);
+};
+/** @not-instrumented */
+const isAndroid = () => isMobile() && !isIOS();
+/** @not-instrumented */
+const isSafariBrowser = () => {
+	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+	const { userAgent } = navigator;
+	return userAgent.includes("Safari") && !userAgent.includes("Chrome") && !userAgent.includes("Chromium");
+};
+/** @not-instrumented */
+const isEdgeBrowser = () => {
+	if (globalThis.window === void 0 || globalThis.navigator === void 0) return false;
+	return /\bEdg\//.test(navigator.userAgent);
+};
+/** @not-instrumented */
+const isOperaBrowser = () => {
+	if (globalThis.window === void 0 || globalThis.navigator === void 0) return false;
+	return /\b(OPR|Opera)\//.test(navigator.userAgent);
+};
+/** @not-instrumented */
+const isFirefoxBrowser = () => {
+	if (globalThis.window === void 0 || globalThis.navigator === void 0) return false;
+	return /\bFirefox\//.test(navigator.userAgent);
+};
+/** @not-instrumented */
+const isChromeBrowser = () => {
+	if (globalThis.window === void 0 || globalThis.navigator === void 0) return false;
+	return /\bChrome\//.test(navigator.userAgent) && !isEdgeBrowser() && !isOperaBrowser();
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getInstallationLinkForCurrentPlatform/getInstallationLinkForCurrentPlatform.ts
+/**
+* Resolves the {@link InstallationUrls} field that matches the platform
+* the SDK is currently running on:
+*
+* - iOS → `ios`
+* - Android → `android`
+* - Edge → `edge`
+* - Opera → `opera`
+* - Firefox → `firefox`
+* - Safari → `safari`
+* - Chrome (or other Chromium-based browsers) → `chrome`
+*
+* Returns `undefined` when no entry exists for the detected platform —
+* callers typically render a "not available on this device" affordance
+* in that case rather than offering a download targeted at a different
+* browser/OS.
+*
+* Each branch returns exactly the field for the detected platform — no
+* fallback to a different browser's URL. If you'd rather surface every
+* link a wallet's manifest publishes so the user can pick where to
+* install, read `installationUrls` directly instead of going through
+* this helper.
+*
+* @param params.installationUrls - The wallet option's `installationUrls`
+*   record (from `getWalletOptionsCatalogue`).
+* @returns The install URL for the detected platform, or `undefined`.
+* @not-instrumented
+*/
+const getInstallationLinkForCurrentPlatform = ({ installationUrls }) => {
+	if (isIOS()) return installationUrls.ios;
+	if (isAndroid()) return installationUrls.android;
+	if (isEdgeBrowser()) return installationUrls.edge;
+	if (isOperaBrowser()) return installationUrls.opera;
+	if (isFirefoxBrowser()) return installationUrls.firefox;
+	if (isSafariBrowser()) return installationUrls.safari;
+	if (isChromeBrowser()) return installationUrls.chrome;
+};
+
 //#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 (`walletConnect`,
+* by the catalogue's wallet-book-driven transformers (URI deeplink,
 * `inAppBrowser`, `installation`) to bucket their emitted options.
 *
 * Wallet book entries inconsistently use `group` / `chainGroup` /
@@ -3995,24 +4271,150 @@ const buildInstallationUrlsByWalletOptionKey = ({ walletBook }) => {
 };
 
 //#endregion
-//#region src/modules/walletOptionsCatalogue/buildWalletConnectOptions/buildWalletConnectOptions.ts
+//#region src/modules/legacyWalletBook/hasUsableDeeplink/hasUsableDeeplink.ts
 /**
-* A wallet only deserves a `walletConnect` catalogue option if it has at
-* least one mobile deeplink — that's the value-add the option provides over
-* the bare WC pairing URI. Wallets that exist in the wallet book but don't
-* expose a deeplink (rare, but present) are silently skipped.
+* Whether a wallet book entry exposes at least one mobile deeplink the
+* catalogue can drive — either a native scheme (`metamask://`) or a
+* universal link (`https://metamask.app.link`). Used by the URI-deeplink
+* builders (`buildWalletConnectOptions`, `buildMetaMaskSdkUriOptions`)
+* to skip wallets that have no app to launch.
+*
+* @param params.wallet - The wallet schema from the wallet book.
+* @returns True when the wallet has a native or universal mobile link.
+* @not-instrumented
 */
 const hasUsableDeeplink = ({ wallet }) => Boolean(wallet.mobile?.native || wallet.mobile?.universal);
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildMetaMaskSdkUriOptions/buildMetaMaskSdkUriOptions.ts
+/**
+* Wallet option key the MetaMask SDK URI extension targets.
+*/
+const METAMASK_WALLET_OPTION_KEY = "metamask";
+/**
+* Chains the MetaMask SDK URI pairing supports.
+*
+* Unlike WalletConnect — whose per-wallet chain support is read from the
+* wallet book — the MetaMask SDK URI is a single Dynamic integration whose
+* chain coverage is defined by which `connectWithMetaMaskUri<Chain>`
+* primitives the SDK ships (EVM + SOL). The MetaMask wallet-book entry only
+* advertises its EVM (`eip155`) chains, so deriving the chain from the book
+* would never surface the Solana pairing; the SDK's own capabilities are
+* listed explicitly instead.
+*/
+const METAMASK_SDK_URI_SUPPORTED_CHAINS = ["EVM", "SOL"];
+/**
+* Builds the `metamaskSdkUri`-discriminator catalogue options from a
+* fetched wallet book. The MetaMask SDK URI extension only targets the
+* MetaMask wallet, so the builder iterates the book looking for the
+* entry whose resolved wallet option key is `'metamask'`.
+*
+* Applies the generic `shouldFilterWallet` rules (drops embedded keys +
+* injected-only-without-links entries). Crucially does NOT require WC
+* `sign_v2` support — MetaMask SDK URI is a different protocol from
+* WalletConnect, so the WC-specific filter does not apply here.
+*
+* Emits one `metamaskSdkUri` option per chain the MetaMask SDK URI pairing
+* supports (see {@link METAMASK_SDK_URI_SUPPORTED_CHAINS}) so the picker can
+* offer both the EVM and Solana pairings for the single MetaMask entry.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns Tagged `metamaskSdkUri` options for MetaMask if eligible, otherwise an empty array.
+* @not-instrumented
+*/
+const buildMetaMaskSdkUriOptions = ({ walletBook }) => {
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		const walletOptionKey = resolveWalletBookWalletOptionKey({
+			wallet,
+			walletKey
+		});
+		if (walletOptionKey !== METAMASK_WALLET_OPTION_KEY) continue;
+		if (shouldFilterWallet({
+			wallet,
+			walletKey
+		})) continue;
+		if (!hasUsableDeeplink({ wallet })) continue;
+		const deeplinks = {
+			native: wallet.mobile?.native,
+			universal: wallet.mobile?.universal
+		};
+		return METAMASK_SDK_URI_SUPPORTED_CHAINS.map((chain) => ({
+			option: {
+				chain,
+				deeplinks,
+				type: "metamaskSdkUri"
+			},
+			walletOptionKey
+		}));
+	}
+	return [];
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/getWalletConnectCatalog/getChainsFromWalletSchema/getChainsFromWalletSchema.ts
 /**
-* Builds the `walletConnect` catalogue options from a fetched wallet book.
-* Applies the WalletConnect-specific eligibility filter
+* Returns every chain a wallet book entry advertises support for —
+* deduped, in `injectedConfig` order, then `chains` order. Used by the
+* catalogue's WalletConnect builder so a multi-chain wallet (e.g. Trust
+* supports EVM + SOL) gets one option per chain rather than one option
+* for whichever chain `getChainFromWalletSchema` happened to pick first.
+*
+* Falls back to {@link getChainFromWalletSchema}'s single-result behavior
+* (`['EVM']` default) when neither field is populated, so the helper
+* never returns an empty array — every eligible wallet emits at least
+* one option.
+*
+* @param params.wallet - The wallet schema from the wallet book.
+* @param [params.walletKey] - The wallet key identifier (used as last-resort fallback).
+* @returns Ordered, deduped array of Chains.
+* @not-instrumented
+*/
+const getChainsFromWalletSchema = ({ wallet, walletKey }) => {
+	const chains = /* @__PURE__ */ new Set();
+	for (const entry of wallet.injectedConfig ?? []) {
+		if (!entry.chain) continue;
+		const chain = getChainFromWalletBookIdentifier({ identifier: entry.chain });
+		if (chain) chains.add(chain);
+	}
+	for (const identifier of wallet.chains ?? []) {
+		const prefix = extractChainPrefix({ chainIdentifier: identifier });
+		try {
+			const chain = require_InvalidParamError.getChainFromVerifiedCredentialChain(prefix);
+			chains.add(chain);
+		} catch {}
+	}
+	if (chains.size === 0) {
+		const chain = getChainFromWalletSchema({
+			wallet,
+			walletKey
+		});
+		chains.add(chain);
+	}
+	return Array.from(chains);
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWalletConnectOptions/buildWalletConnectOptions.ts
+/**
+* Chains Dynamic ships a WalletConnect extension for. Anything else a
+* wallet book entry advertises (Cosmos, BTC, …) gets filtered out — the
+* catalogue should not surface a chain the SDK has no `connectWithWalletConnect<Chain>`
+* primitive for.
+*/
+const WALLETCONNECT_SUPPORTED_CHAINS = new Set(["EVM", "SOL"]);
+/**
+* Builds the `walletConnect`-discriminator 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 `connectWithWalletConnect<Chain>` URI via
-* `appendWalletConnectUriToDeepLink` to open the wallet's app.
+* Skips the MetaMask wallet entry: MetaMask is steered to its own URI
+* connection extension via `buildMetaMaskSdkUriOptions`. Keeping the two
+* builders separate means each protocol owns its own eligibility rules
+* (WC needs `sign_v2`; MM SDK URI does not), so excluding one
+* discriminator via `excludedConnectionOptionTypes` doesn't accidentally
+* gate the other.
 *
 * @param params.walletBook - The fetched wallet book.
 * @returns Tagged `walletConnect` options paired with their wallet option keys.
@@ -4030,11 +4432,12 @@ const buildWalletConnectOptions = ({ walletBook }) => {
 			wallet,
 			walletKey
 		});
-		const chain = getChainFromWalletSchema({
+		if (walletOptionKey === "metamask") continue;
+		const chains = getChainsFromWalletSchema({
 			wallet,
 			walletKey
-		});
-		result.push({
+		}).filter((chain) => WALLETCONNECT_SUPPORTED_CHAINS.has(chain));
+		for (const chain of chains) result.push({
 			option: {
 				chain,
 				deeplinks: {
@@ -4058,12 +4461,19 @@ const buildWalletConnectOptions = ({ walletBook }) => {
 *
 * 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).
+* - `name`: `displayOverride.name` ?? wallet book group name ?? wallet
+*   book wallet name ?? bare key.
+* - `iconUrl`: `displayOverride.iconUrl` ?? wallet book group sprite URL
+*   ?? wallet book wallet sprite URL ?? `''`.
+* - `primaryColor`: wallet book group brand color ?? wallet book wallet
+*   brand color (providers do not ship a primary color in their
+*   announcement metadata).
 * - `installationUrls`: copied through if present.
 *
+* The per-wallet fallback handles wallets that exist as individual entries
+* in the book (e.g. Rainbow) rather than as members of a multi-wallet group
+* — those don't get a `walletBook.groups[…]` shell.
+*
 * 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
@@ -4081,16 +4491,42 @@ const buildWalletOption = ({ connectionOptions, displayOverride, installationUrl
 	const group = walletBook.groups[walletOptionKey];
 	const groupSpriteId = group?.brand?.spriteId;
 	const groupIconUrl = groupSpriteId ? getSpriteUrl({ spriteId: groupSpriteId }) : void 0;
+	const walletEntry = walletBook.wallets[walletOptionKey];
+	const walletSpriteId = walletEntry?.brand?.spriteId;
+	const walletIconUrl = walletSpriteId ? getSpriteUrl({ spriteId: walletSpriteId }) : void 0;
 	return {
 		connectionOptions,
-		iconUrl: displayOverride?.iconUrl ?? groupIconUrl ?? "",
+		iconUrl: displayOverride?.iconUrl ?? groupIconUrl ?? walletIconUrl ?? "",
 		installationUrls,
 		key: walletOptionKey,
-		name: displayOverride?.name ?? group?.name ?? walletOptionKey,
-		primaryColor: group?.brand?.primaryColor
+		name: displayOverride?.name ?? group?.name ?? walletEntry?.name ?? walletOptionKey,
+		primaryColor: group?.brand?.primaryColor ?? walletEntry?.brand?.primaryColor
 	};
 };
 
+//#endregion
+//#region src/modules/wallets/hasWalletProviderConnectMethod/hasWalletProviderConnectMethod.ts
+/**
+* Returns true when the given wallet provider exposes a `connect` method,
+* which is the signal we use to decide whether it belongs in the external
+* wallet picker as an `available provider`.
+*
+* Providers that don't expose `connect` (embedded wallets,
+* account-abstraction wrappers, MetaMask SDK / WalletConnect-backed
+* providers) are still sign-in capable, but via different SDK entry
+* points — they should not appear in the external picker as a
+* `withWalletProvider`-style option.
+*
+* Centralizing the predicate means future tweaks (e.g. a registry of
+* provider keys to exclude) land in one place and every consumer stays
+* in lockstep.
+*
+* @param params.walletProvider - The wallet provider to test.
+* @returns True when the provider exposes a `connect` method.
+* @not-instrumented
+*/
+const hasWalletProviderConnectMethod = ({ walletProvider }) => Boolean(walletProvider.connect);
+
 //#endregion
 //#region src/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.ts
 /**
@@ -4118,9 +4554,9 @@ const buildWalletOption = ({ connectionOptions, displayOverride, installationUrl
 */
 const classifyWithWalletProviderSource = ({ entry }) => {
 	const { priority } = entry;
-	if (priority === require_getVerifiedCredentialForWalletAccount.WalletProviderPriority.WALLET_SDK) return "sdk";
-	if (priority === require_getVerifiedCredentialForWalletAccount.WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD) return "selfAnnounced";
-	if (priority === require_getVerifiedCredentialForWalletAccount.WalletProviderPriority.WINDOW_INJECT) return "windowInjected";
+	if (priority === require_InvalidParamError.WalletProviderPriority.WALLET_SDK) return "sdk";
+	if (priority === require_InvalidParamError.WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD) return "selfAnnounced";
+	if (priority === require_InvalidParamError.WalletProviderPriority.WINDOW_INJECT) return "windowInjected";
 };
 
 //#endregion
@@ -4170,7 +4606,7 @@ const normalizeWalletDisplayName = (displayName) => displayName.toLowerCase().re
 
 //#endregion
 //#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.ts
-const normalize = (value) => value.toLowerCase().replace(/\s+/g, "");
+const normalize = (value) => value === void 0 ? void 0 : 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
@@ -4240,7 +4676,7 @@ const resolveWalletOptionKey = ({ fallback, wallet }) => wallet.group ?? wallet.
 * @not-instrumented
 */
 const findWalletOptionKeyForProviderKey = ({ chain, walletBook, walletProvider }) => {
-	const { normalizedWalletNameWithChain } = require_getVerifiedCredentialForWalletAccount.splitWalletProviderKey(walletProvider.key);
+	const { normalizedWalletNameWithChain } = require_InvalidParamError.splitWalletProviderKey(walletProvider.key);
 	const candidates = [normalizedWalletNameWithChain, stripChainSuffix({
 		chain,
 		normalizedName: normalizedWalletNameWithChain
@@ -4290,6 +4726,7 @@ const findWalletOptionKeyForProviderKey = ({ chain, walletBook, walletProvider }
 const buildWithWalletProviderOptions = ({ entries, walletBook }, client) => {
 	const result = [];
 	for (const entry of entries) {
+		if (!hasWalletProviderConnectMethod({ walletProvider: entry.walletProvider })) continue;
 		const source = classifyWithWalletProviderSource({ entry });
 		if (!source) {
 			require_InvalidParamError.getCore(client).logger.error("buildWithWalletProviderOptions: registered wallet provider has an unrecognised priority — unable to identify how this wallet was registered", {
@@ -4382,10 +4819,11 @@ const groupOptionsByWalletOption = ({ options }) => {
 * wallet-option list is ordered — that's controlled by
 * `WalletOptionOrdering`.
 *
-* `withWalletProvider > walletConnect > inAppBrowser`
+* `withWalletProvider > walletConnect / metamaskSdkUri > inAppBrowser`
 */
 const CONNECTION_OPTION_PRIORITY = {
 	inAppBrowser: 2,
+	metamaskSdkUri: 1,
 	walletConnect: 1,
 	withWalletProvider: 0
 };
@@ -4404,7 +4842,7 @@ const getConnectionOptionPriority = ({ option }) => CONNECTION_OPTION_PRIORITY[o
 /**
 * Sorts a wallet option's `connectionOptions` so the most preferred option lands at
 * index 0. Primary sort is by option-type priority
-* (`withWalletProvider` > `walletConnect` > `inAppBrowser`);
+* (`withWalletProvider` > URI deeplink > `inAppBrowser`);
 * within a type, ties break alphabetically by `chain` for deterministic
 * output across calls.
 *
@@ -4528,7 +4966,7 @@ const hasInstalledProvider = ({ walletOption }) => walletOption.connectionOption
 *   this order:
 *     1. **Installed provider** — user already has the wallet available
 *        (`withWalletProvider` at index 0).
-*     2. **Connectable** — has at least one connection (`walletConnect`
+*     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}
@@ -4578,45 +5016,40 @@ const EMPTY_WALLET_BOOK = {
 	wallets: {}
 };
 /**
-* Returns a catalogue of the external wallet options a user can sign in
-* with through this client. Each wallet option carries an ordered
-* `connectionOptions` array — `withWalletProvider` (direct), `walletConnect`
-* (deeplink/QR), or `inAppBrowser` (mobile webview). Wallet options without
-* any matching connections are omitted.
-*
-* `includeWithWalletProvider` defaults to `true`; all other inclusion flags
-* are opt-in. `walletOptionOrdering` defaults to `'relevance'` (Dynamic's
-* recommended order); pass `'alphabetical'` to sort by wallet option name
-* within each option-priority tier.
+* 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.
 *
-* The wallet book is fetched only when an enabled flag needs it
-* (`includeWalletConnect`, `includeInAppBrowser`). Calls that only need
-* `includeWithWalletProvider` skip the fetch entirely.
+* Pass `excludedConnectionOptionTypes` to drop specific connection types
+* from the catalogue (e.g. `['inAppBrowser']` on desktop). Wallets whose
+* only connection was an excluded type fall through to the install-only
+* tier of the relevance ordering.
 *
-* @param [params] - Inclusion flags + ordering preference.
+* @param [params] - Inclusion flag + ordering preference + exclusions.
 * @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 = require_InvalidParamError.getDefaultClient()) => {
-	const includeWithWalletProvider = params.includeWithWalletProvider ?? true;
-	const includeWalletConnect = params.includeWalletConnect ?? false;
-	const includeInAppBrowser = params.includeInAppBrowser ?? false;
-	const includeInstallation = params.includeInstallation ?? false;
+	const includeMobileOptions = params.includeMobileOptions ?? false;
 	const walletOptionOrdering = params.walletOptionOrdering ?? "relevance";
-	if (!includeWithWalletProvider && !includeWalletConnect && !includeInAppBrowser && !includeInstallation) return [];
-	const walletBook = includeWalletConnect || includeInAppBrowser || includeInstallation ? await fetchLegacyWalletBook(client) : EMPTY_WALLET_BOOK;
+	const excludedConnectionOptionTypes = new Set(params.excludedConnectionOptionTypes ?? []);
+	const walletBook = includeMobileOptions ? await fetchLegacyWalletBook(client) : EMPTY_WALLET_BOOK;
 	const allConnectionOptions = [];
-	if (includeWithWalletProvider) {
-		const entries = require_getVerifiedCredentialForWalletAccount.getWalletProviderRegistry(client).listProviderEntries();
+	if (!excludedConnectionOptionTypes.has("withWalletProvider")) {
+		const entries = require_InvalidParamError.getWalletProviderRegistry(client).listProviderEntries();
 		allConnectionOptions.push(...buildWithWalletProviderOptions({
 			entries,
 			walletBook
 		}, client));
 	}
-	if (includeWalletConnect) allConnectionOptions.push(...buildWalletConnectOptions({ walletBook }));
-	if (includeInAppBrowser) allConnectionOptions.push(...buildInAppBrowserOptions({ walletBook }));
-	const installationUrlsByKey = includeInstallation ? buildInstallationUrlsByWalletOptionKey({ walletBook }) : /* @__PURE__ */ new Map();
+	if (includeMobileOptions) {
+		if (!excludedConnectionOptionTypes.has("walletConnect")) allConnectionOptions.push(...buildWalletConnectOptions({ walletBook }));
+		if (!excludedConnectionOptionTypes.has("metamaskSdkUri")) allConnectionOptions.push(...buildMetaMaskSdkUriOptions({ walletBook }));
+		if (!excludedConnectionOptionTypes.has("inAppBrowser")) allConnectionOptions.push(...buildInAppBrowserOptions({ walletBook }));
+	}
+	const installationUrlsByKey = includeMobileOptions ? buildInstallationUrlsByWalletOptionKey({ walletBook }) : /* @__PURE__ */ new Map();
 	const grouped = groupOptionsByWalletOption({ options: allConnectionOptions });
 	const allWalletOptionKeys = new Set([...grouped.keys(), ...installationUrlsByKey.keys()]);
 	const walletOptions = [];
@@ -4741,13 +5174,13 @@ const authenticateMfaRecoveryCode = async ({ code, createMfaTokenOptions, reques
 			}
 		});
 		require_getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({ response }, client);
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: { mfaToken: response.mfaToken },
 			event: "mfaCompletionSuccess"
 		}, client);
 		return response;
 	} catch (error) {
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: { error },
 			event: "mfaCompletionFailure"
 		}, client);
@@ -4821,13 +5254,13 @@ const authenticatePasskeyMFA = async ({ createMfaToken, relatedOriginRpId, reque
 			requestedScopes
 		}, client);
 		require_getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({ response }, client);
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: { mfaToken: response.mfaToken },
 			event: "mfaCompletionSuccess"
 		}, client);
 		return response;
 	} catch (error) {
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: { error },
 			event: "mfaCompletionFailure"
 		}, client);
@@ -4865,7 +5298,7 @@ const authenticateTotpMfaDevice = async ({ deviceId, code, createMfaTokenOptions
 			}
 		});
 		require_getVerifiedCredentialForWalletAccount.updateAuthFromVerifyResponse({ response }, client);
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: {
 				deviceId,
 				mfaToken: response.mfaToken
@@ -4874,7 +5307,7 @@ const authenticateTotpMfaDevice = async ({ deviceId, code, createMfaTokenOptions
 		}, client);
 		return response;
 	} catch (error) {
-		require_getVerifiedCredentialForWalletAccount.emitEvent({
+		require_InvalidParamError.emitEvent({
 			args: {
 				deviceId,
 				error
@@ -4896,6 +5329,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 = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
@@ -4911,7 +5345,8 @@ const __createNewMfaRecoveryCodes_wrapped = require_InvalidParamError.instrument
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -6138,6 +6573,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 = require_InvalidParamError.getDefaultClient()) => {
 	let response;
@@ -6163,7 +6599,8 @@ const __verifyOTP_wrapped = require_InvalidParamError.instrumentFunction({
 		} catch {
 			return;
 		}
-	}
+	},
+	redactAll: true
 });
 
 //#endregion
@@ -6260,7 +6697,7 @@ const getSwapStatus = async (params, client = require_InvalidParamError.getDefau
 const deleteUser = async (client = require_InvalidParamError.getDefaultClient()) => {
 	const core = require_InvalidParamError.getCore(client);
 	await require_InvalidParamError.createApiClient({ includeMfaToken: true }, client).hardDeleteUser({ environmentId: core.environmentId });
-	await require_getNetworkProviderFromNetworkId.__logoutWithReason_wrapped({ reason: "user-deleted" }, client);
+	await require_InvalidParamError.__logoutWithReason_wrapped({ reason: "user-deleted" }, client);
 };
 const __deleteUser_impl = deleteUser;
 const __deleteUser_wrapped = require_InvalidParamError.instrumentFunction({
@@ -6493,7 +6930,7 @@ const isInsufficientGoogleDriveScopesError = (err) => err instanceof Error && er
 * @not-instrumented
 */
 const assertWalletAccountSigningAvailability = async ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
-	const { addresses } = await require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client).getConnectedAddresses();
+	const { addresses } = await require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client).getConnectedAddresses();
 	if (addresses.length > 0 && !addresses.includes(walletAccount.address)) throw new WalletAccountNotSelectedError({
 		expectedAddress: walletAccount.address,
 		selectedAddress: addresses[0]
@@ -6517,7 +6954,7 @@ const assertWalletAccountSigningAvailability = async ({ walletAccount }, client
 * @instrumented
 */
 const confirmTransaction = async ({ walletAccount, transactionHash }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	assertWalletProviderMethodDefined(walletProvider, "confirmTransaction");
 	await walletProvider.confirmTransaction({
 		transactionHash,
@@ -6537,33 +6974,6 @@ const __confirmTransaction_wrapped = require_InvalidParamError.instrumentFunctio
 	}
 });
 
-//#endregion
-//#region src/utils/isMobile/isMobile.ts
-/**
-* Sourced from http://detectmobilebrowsers.com/
-* @not-instrumented
-*/
-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 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;
-/** @not-instrumented */
-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();
-};
-/** @not-instrumented */
-const isIPhone = () => typeof window === "undefined" || typeof navigator === "undefined" ? false : /iPhone|ios/.test(navigator.userAgent);
-/**
-* @param [optional] maxTouchPointsOverride - this is used for testing since
-* it seems that JSDOM doesn't support maxTouchPoints, so it was impossible
-* to mock it
-* @not-instrumented
-*/
-const isIPad = (maxTouchPointsOverride) => {
-	if (typeof window === "undefined" || typeof navigator === "undefined") return false;
-	const maxTouchPoints = maxTouchPointsOverride || navigator.maxTouchPoints;
-	return /iPad/.test(navigator.userAgent) || /Mac/.test(navigator.userAgent) && maxTouchPoints === 5;
-};
-
 //#endregion
 //#region src/modules/wallets/utils/getAddressesWithTypesFromConnectionResult/getAddressesWithTypesFromConnectionResult.ts
 /** @not-instrumented */
@@ -6587,13 +6997,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 = require_InvalidParamError.getDefaultClient()) => {
 	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderByKey({ walletProviderKey }, client);
 	assertWalletProviderMethodDefined(walletProvider, "connect");
 	const { addresses } = await walletProvider.connect();
-	const currentAddresses = require_getVerifiedCredentialForWalletAccount.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
@@ -6601,27 +7010,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: require_getVerifiedCredentialForWalletAccount.formatWalletAccountId({
+	const [reconciledWalletAccount] = require_getNetworkProviderFromNetworkId.reconcileWalletAccountsAgainstClient({
+		addToDynamicWalletAccounts,
+		walletAccounts: [{
 			address: mainAddress,
+			addressesWithTypes: getAddressesWithTypesFromConnectionResult({ addresses }),
 			chain: walletProvider.chain,
+			hardwareWalletVendor,
+			id: require_InvalidParamError.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) {
-		require_getNetworkProviderFromNetworkId.setUnverifiedWalletAccounts({ unverifiedWalletAccountsToUpdate: [walletAccount] }, client);
-		require_getVerifiedCredentialForWalletAccount.emitWalletAccountsChangedEvent(client);
-		require_getNetworkProviderFromNetworkId.createVisit({ walletAccount }, client);
-	}
-	return walletAccount;
+	}, client);
+	return reconciledWalletAccount;
 };
 const __connectWithWalletProvider_impl = connectWithWalletProvider;
 const __connectWithWalletProvider_wrapped = require_InvalidParamError.instrumentFunction({
@@ -6672,7 +7079,7 @@ const getSignInMessage = async ({ nonce: nonceOverride, walletAccount }, client)
 	const url = new URL(appUniversalLink);
 	const domain = url.host;
 	const nonce = nonceOverride ?? await require_InvalidParamError.getNonce(client);
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	if (walletProvider.chain === "STARK")
  /**
 	* Starknet requires the strings to be 31 chars long
@@ -6711,7 +7118,7 @@ const getSignInMessage = async ({ nonce: nonceOverride, walletAccount }, client)
 * @instrumented
 */
 const proveWalletAccountOwnership = async ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	assertWalletProviderMethodDefined(walletProvider, "signMessage");
 	const messageToSign = await getSignInMessage({
 		nonce: walletProvider.getConnectProofNonce?.(),
@@ -6742,10 +7149,10 @@ const __proveWalletAccountOwnership_wrapped = require_InvalidParamError.instrume
 //#endregion
 //#region src/modules/wallets/utils/isSameAddress/isSameAddress.ts
 /** @not-instrumented */
-const isSameAddress = ({ chain, left, right }) => require_getVerifiedCredentialForWalletAccount.normalizeAddress({
+const isSameAddress = ({ chain, left, right }) => require_InvalidParamError.normalizeAddress({
 	address: left,
 	chain
-}) === require_getVerifiedCredentialForWalletAccount.normalizeAddress({
+}) === require_InvalidParamError.normalizeAddress({
 	address: right,
 	chain
 });
@@ -6755,7 +7162,7 @@ const isSameAddress = ({ chain, left, right }) => require_getVerifiedCredentialF
 /** @not-instrumented */
 const verifyWalletAccountForSignInOrTransfer = async ({ walletAccount, isTransfer, requestedScopes }, client) => {
 	if (walletAccount.verifiedCredentialId) throw new WalletAccountAlreadyVerifiedError(walletAccount.address);
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	const { messageToSign, signature } = await __proveWalletAccountOwnership_wrapped({ walletAccount }, client);
 	const formattedSignature = walletAccount.hardwareWalletVendor ? formatSignatureForHardwareWallet({
 		hardwareWalletVendor: walletAccount.hardwareWalletVendor,
@@ -6790,7 +7197,7 @@ const verifyWalletAccountForSignInOrTransfer = async ({ walletAccount, isTransfe
 	* Remove the now verified wallet account from the unverified wallet accounts
 	*/
 	require_getNetworkProviderFromNetworkId.removeUnverifiedWalletAccount({ unverifiedWalletAccount: walletAccount }, client);
-	const verifiedWalletAccount = require_getVerifiedCredentialForWalletAccount.getWalletAccounts(client).find(({ address }) => isSameAddress({
+	const verifiedWalletAccount = require_InvalidParamError.getWalletAccounts(client).find(({ address }) => isSameAddress({
 		chain: walletAccount.chain,
 		left: address,
 		right: walletAccount.address
@@ -6908,7 +7315,7 @@ const __connectAndVerifyWithWalletProvider_wrapped = require_InvalidParamError.i
 * @not-instrumented
 */
 const getAvailableWalletProvidersData = (client = require_InvalidParamError.getDefaultClient()) => {
-	return require_getVerifiedCredentialForWalletAccount.getWalletProviders(client).filter((walletProvider) => Boolean(walletProvider.connect)).map((walletProvider) => ({
+	return require_getVerifiedCredentialForWalletAccount.getWalletProviders(client).filter((walletProvider) => hasWalletProviderConnectMethod({ walletProvider })).map((walletProvider) => ({
 		chain: walletProvider.chain,
 		groupKey: walletProvider.groupKey,
 		key: walletProvider.key,
@@ -6940,7 +7347,7 @@ const getConnectedAddresses = ({ walletProviderKey }, client = require_InvalidPa
 const getOwnerWalletAccountForSmartWalletAccount = ({ smartWalletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
 	const smartWalletVerifiedCredential = require_getVerifiedCredentialForWalletAccount.getVerifiedCredentialForWalletAccount({ walletAccount: smartWalletAccount }, client);
 	require_InvalidParamError.assertDefined(smartWalletVerifiedCredential?.signerRefId, "Invalid smart wallet account");
-	return require_getVerifiedCredentialForWalletAccount.getWalletAccounts(client).find((walletAccount) => walletAccount.verifiedCredentialId === smartWalletVerifiedCredential.signerRefId);
+	return require_InvalidParamError.getWalletAccounts(client).find((walletAccount) => walletAccount.verifiedCredentialId === smartWalletVerifiedCredential.signerRefId);
 };
 
 //#endregion
@@ -6971,6 +7378,22 @@ const getWalletProviderDataByKey = ({ walletProviderKey }, client = require_Inva
 	};
 };
 
+//#endregion
+//#region src/modules/wallets/isAnyWalletAccountConnected/isAnyWalletAccountConnected.ts
+/**
+* Checks whether the session has at least one connected wallet account.
+*
+* Both verified and unverified wallet accounts count as connected. This is a
+* single building block for a custom signed-in check — combine it with whatever
+* else your app considers "signed in" (e.g. `client.user`, completed onboarding,
+* a required embedded wallet, …).
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True if the session has at least one wallet account, false otherwise.
+* @not-instrumented
+*/
+const isAnyWalletAccountConnected = (client = require_InvalidParamError.getDefaultClient()) => require_InvalidParamError.getWalletAccounts(client).length > 0;
+
 //#endregion
 //#region src/modules/wallets/hardwareWallet/canConnectWithHardwareWallet/canConnectWithHardwareWallet.ts
 /**
@@ -7062,7 +7485,7 @@ const __addNetwork_wrapped = require_InvalidParamError.instrumentFunction({
 * @not-instrumented
 */
 const getActiveNetworkData = async ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	const { networkId } = await walletProvider.getActiveNetworkId();
 	return { networkData: require_getNetworkProviderFromNetworkId.getNetworksData(client).find((data) => data.networkId === networkId && data.chain === walletProvider.chain) };
 };
@@ -7078,24 +7501,28 @@ const getActiveNetworkData = async ({ walletAccount }, client = require_InvalidP
 * @not-instrumented
 */
 const getActiveNetworkId = ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
-	return require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
+	return require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
 };
 
 //#endregion
-//#region src/modules/wallets/networks/getBalance/getBalance.ts
+//#region src/modules/wallets/networks/getNativeBalance/getNativeBalance.ts
 /**
-* Retrieves the native token balance for a wallet account.
+* Retrieves the native token balance for a wallet account on its active
+* network. Reads directly from the chain's network provider (RPC), not
+* the Dynamic API.
 *
-* This function fetches the balance of the native cryptocurrency
-* (e.g., ETH, SOL, BTC, etc.) for the specified wallet account.
+* Use this when you only need the user's gas / native-currency balance
+* (ETH, SOL, BTC, etc.). For token balances, use
+* {@link getTokenBalances}; for a multi-chain portfolio snapshot, use
+* {@link getMultichainTokenBalances}.
 *
 * @param params.walletAccount - The wallet account to get the balance for.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns A promise that resolves to an object containing the balance as a string or null.
 * @not-instrumented
 */
-const getBalance = async ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+const getNativeBalance = async ({ walletAccount }, client = require_InvalidParamError.getDefaultClient()) => {
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	const { networkId } = await walletProvider.getActiveNetworkId();
 	return require_getNetworkProviderFromNetworkId.getNetworkProviderFromNetworkId({
 		chain: walletProvider.chain,
@@ -7254,9 +7681,9 @@ const __selectPrimaryWalletAccount_wrapped = require_InvalidParamError.instrumen
 */
 const disconnectWalletAccount = async ({ walletAccount }, client) => {
 	try {
-		await require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client).disconnectWalletAccount?.({ walletAccount });
+		await require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client).disconnectWalletAccount?.({ walletAccount });
 	} catch (error) {
-		if (error instanceof require_getVerifiedCredentialForWalletAccount.NoWalletProviderFoundError) return;
+		if (error instanceof require_InvalidParamError.NoWalletProviderFoundError) return;
 		throw error;
 	}
 };
@@ -7316,7 +7743,7 @@ const __removeWalletAccount_wrapped = require_InvalidParamError.instrumentFuncti
 * @instrumented
 */
 const signMessage = async ({ walletAccount, message }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	assertWalletProviderMethodDefined(walletProvider, "signMessage");
 	const { signature } = await walletProvider.signMessage({
 		message,
@@ -7355,7 +7782,7 @@ const __signMessage_wrapped = require_InvalidParamError.instrumentFunction({
 * @instrumented
 */
 const transferAmount = async ({ walletAccount, amount, recipient, token }, client = require_InvalidParamError.getDefaultClient()) => {
-	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
+	const walletProvider = require_InvalidParamError.getWalletProviderFromWalletAccount({ walletAccount }, client);
 	assertWalletProviderMethodDefined(walletProvider, "transferAmount");
 	const { transactionHash } = await walletProvider.transferAmount({
 		amount,
@@ -7428,7 +7855,7 @@ const __transferWalletAccount_wrapped = require_InvalidParamError.instrumentFunc
 * @not-instrumented
 */
 const getWalletAccountFromAddress = ({ address, chain }, client = require_InvalidParamError.getDefaultClient()) => {
-	return require_getVerifiedCredentialForWalletAccount.getWalletAccounts(client).find((walletAccount) => walletAccount.address === address && walletAccount.chain === chain);
+	return require_InvalidParamError.getWalletAccounts(client).find((walletAccount) => walletAccount.address === address && walletAccount.chain === chain);
 };
 
 //#endregion
@@ -7600,6 +8027,7 @@ exports.WalletProviderMethodUnavailableError = WalletProviderMethodUnavailableEr
 exports.acknowledgeRecoveryCodes = __acknowledgeRecoveryCodes_wrapped;
 exports.addCoinbaseOnrampOrderEventListener = addCoinbaseOnrampOrderEventListener;
 exports.addNetwork = __addNetwork_wrapped;
+exports.appendConnectionUriToDeeplink = appendConnectionUriToDeeplink;
 exports.assertWalletAccountSigningAvailability = assertWalletAccountSigningAvailability;
 exports.assertWalletProviderMethodDefined = assertWalletProviderMethodDefined;
 exports.attachCheckoutTransactionSource = __attachCheckoutTransactionSource_wrapped;
@@ -7632,14 +8060,14 @@ exports.detectOAuthRedirect = detectOAuthRedirect;
 exports.detectSocialRedirectUrl = detectSocialRedirectUrl;
 exports.excludeInstalledFromCatalog = excludeInstalledFromCatalog;
 exports.executeSwapTransaction = __executeSwapTransaction_wrapped;
-exports.fetchProjectSettings = require_getNetworkProviderFromNetworkId.fetchProjectSettings;
+exports.fetchProjectSettings = require_InvalidParamError.fetchProjectSettings;
 exports.findMissingGoogleDriveBackupScopes = findMissingGoogleDriveBackupScopes;
 exports.getActiveNetworkData = getActiveNetworkData;
 exports.getActiveNetworkId = getActiveNetworkId;
 exports.getAvailableWalletProvidersData = getAvailableWalletProvidersData;
-exports.getBalance = getBalance;
+exports.getBalance = getNativeBalance;
 exports.getBalanceForAddress = getBalanceForAddress;
-exports.getBalances = getBalances;
+exports.getBalances = getTokenBalances;
 exports.getCheckoutTransaction = getCheckoutTransaction;
 exports.getCheckoutTransactionQuote = getCheckoutTransactionQuote;
 exports.getCoinbaseBuyUrl = getCoinbaseBuyUrl;
@@ -7648,13 +8076,18 @@ exports.getDefaultClient = require_InvalidParamError.getDefaultClient;
 exports.getDeviceRegistrationTokenFromUrl = getDeviceRegistrationTokenFromUrl;
 exports.getElevatedAccessToken = require_InvalidParamError.__getElevatedAccessToken_wrapped;
 exports.getGoogleDriveBackupReadiness = __getGoogleDriveBackupReadiness_wrapped;
+exports.getInstallationLinkForCurrentPlatform = getInstallationLinkForCurrentPlatform;
 exports.getKrakenAccounts = getKrakenAccounts;
 exports.getKrakenWhitelistedAddresses = getKrakenWhitelistedAddresses;
 exports.getMfaDevices = getMfaDevices;
 exports.getMfaMethods = require_isMfaRequiredForAction.getMfaMethods;
 exports.getMfaRecoveryCodes = getMfaRecoveryCodes;
 exports.getMissingVerificationForCoinbaseOnrampOrder = getMissingVerificationForCoinbaseOnrampOrder;
-exports.getMultichainBalances = getMultichainBalances;
+exports.getMoonPayCurrencies = __getMoonPayCurrencies_wrapped;
+exports.getMoonPayUrl = __getMoonPayUrl_wrapped;
+exports.getMultichainBalances = getMultichainTokenBalances;
+exports.getMultichainTokenBalances = getMultichainTokenBalances;
+exports.getNativeBalance = getNativeBalance;
 exports.getNetworksData = require_getNetworkProviderFromNetworkId.getNetworksData;
 exports.getOwnerWalletAccountForSmartWalletAccount = getOwnerWalletAccountForSmartWalletAccount;
 exports.getPasskeys = getPasskeys;
@@ -7662,11 +8095,12 @@ exports.getPrimaryWalletAccount = getPrimaryWalletAccount;
 exports.getRegisteredDevices = getRegisteredDevices;
 exports.getSwapQuote = getSwapQuote;
 exports.getSwapStatus = getSwapStatus;
+exports.getTokenBalances = getTokenBalances;
 exports.getTransactionHistory = getTransactionHistory;
 exports.getUserSocialAccounts = getUserSocialAccounts;
 exports.getWalletAccountAddressByType = getWalletAccountAddressByType;
 exports.getWalletAccountFromAddress = getWalletAccountFromAddress;
-exports.getWalletAccounts = require_getVerifiedCredentialForWalletAccount.getWalletAccounts;
+exports.getWalletAccounts = require_InvalidParamError.getWalletAccounts;
 exports.getWalletConnectCatalog = getWalletConnectCatalog;
 exports.getWalletConnectCatalogWalletByWalletProviderKey = getWalletConnectCatalogWalletByWalletProviderKey;
 exports.getWalletOptionsCatalogue = getWalletOptionsCatalogue;
@@ -7674,6 +8108,7 @@ exports.getWalletProviderDataByKey = getWalletProviderDataByKey;
 exports.hasAllGoogleDriveBackupScopes = hasAllGoogleDriveBackupScopes;
 exports.hasExtension = require_getNetworkProviderFromNetworkId.hasExtension;
 exports.initializeClient = __initializeClient_wrapped;
+exports.isAnyWalletAccountConnected = isAnyWalletAccountConnected;
 exports.isCaptchaRequired = require_getNetworkProviderFromNetworkId.isCaptchaRequired;
 exports.isDeeplinkWalletProvider = isDeeplinkWalletProvider;
 exports.isDeviceRegistrationRequired = isDeviceRegistrationRequired;
@@ -7683,17 +8118,17 @@ exports.isMfaRequiredForAction = require_isMfaRequiredForAction.isMfaRequiredFor
 exports.isMobile = isMobile;
 exports.isPendingRecoveryCodesAcknowledgment = isPendingRecoveryCodesAcknowledgment;
 exports.isProgrammaticNetworkSwitchAvailable = isProgrammaticNetworkSwitchAvailable;
-exports.isSignedIn = require_getNetworkProviderFromNetworkId.isSignedIn;
+exports.isSignedIn = require_InvalidParamError.isSignedIn;
 exports.isUserMissingMfaAuth = require_getVerifiedCredentialForWalletAccount.isUserMissingMfaAuth;
 exports.isUserOnboardingComplete = isUserOnboardingComplete;
 exports.isWalletAccountVerified = isWalletAccountVerified;
 exports.logout = logout;
 exports.matchWalletProvidersToCatalogGroup = matchWalletProvidersToCatalogGroup;
-exports.offEvent = require_getVerifiedCredentialForWalletAccount.offEvent;
+exports.offEvent = require_InvalidParamError.offEvent;
 exports.offWalletProviderEvent = offWalletProviderEvent;
-exports.onEvent = require_getVerifiedCredentialForWalletAccount.onEvent;
+exports.onEvent = require_InvalidParamError.onEvent;
 exports.onWalletProviderEvent = onWalletProviderEvent;
-exports.onceEvent = require_getVerifiedCredentialForWalletAccount.onceEvent;
+exports.onceEvent = require_InvalidParamError.onceEvent;
 exports.parseUserAgent = parseUserAgent;
 exports.prepareCheckoutTransaction = __prepareCheckoutTransaction_wrapped;
 exports.proveWalletAccountOwnership = __proveWalletAccountOwnership_wrapped;