@dynamic-labs-sdk/client 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1,8 +1,8 @@
-const require_getNetworkProviderFromNetworkId = require('./getNetworkProviderFromNetworkId-D26TNjm4.cjs');
-const require_InvalidParamError = require('./InvalidParamError-CPzPxL0l.cjs');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-C94BZhqL.cjs');
-const require_NotWaasWalletAccountError = require('./NotWaasWalletAccountError-BcIbGm0s.cjs');
-const require_isMfaRequiredForAction = require('./isMfaRequiredForAction-kxGzZLB_.cjs');
+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');
 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");
@@ -2290,10 +2290,10 @@ const __unlinkSocialAccount_wrapped = require_InvalidParamError.instrumentFuncti
 * @returns A promise that resolves to an array of token balances.
 * @not-instrumented
 */
-const getBalances = async ({ walletAccount, networkId, includePrices, includeNative, filterSpamTokens, whitelistedContracts, forceRefresh }, client = require_InvalidParamError.getDefaultClient()) => {
+const getBalances = 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) {
+	if (!networkId && !networkIds) {
 		const activeNetworkId = await require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client).getActiveNetworkId();
 		networkId = Number(activeNetworkId.networkId);
 	}
@@ -2306,6 +2306,7 @@ const getBalances = async ({ walletAccount, networkId, includePrices, includeNat
 		includeNative,
 		includePrices,
 		networkId,
+		networkIds,
 		whitelistedContracts
 	});
 };
@@ -3375,10 +3376,12 @@ const fetchLegacyWalletBook = async (client) => {
 };
 
 //#endregion
-//#region src/modules/legacyWalletBook/getWalletConnectCatalog/shouldFilterWallet/shouldFilterWallet.ts
+//#region src/modules/legacyWalletBook/shouldFilterWallet/shouldFilterWallet.ts
 /**
-* Embedded wallet keys that should be filtered out from the WalletConnect catalog.
-* These wallets are not meant to be displayed in wallet selection lists.
+* Embedded wallet keys that should be filtered out from any external-wallet
+* catalogue. These wallets are not products the user "connects" to from the
+* wallet selection list — they are embedded sign-in methods that live behind
+* different SDK entry points.
 * @not-instrumented
 */
 const EMBEDDED_WALLET_KEYS = [
@@ -3394,19 +3397,48 @@ const EMBEDDED_WALLET_KEYS = [
 	"mpcwallet"
 ];
 /**
-* Checks if a wallet should be filtered out from the WalletConnect catalog.
+* Generic "is this wallet eligible for an external-wallet catalogue" check.
+* Filters out:
+*
+* 1. Embedded sign-in methods (see {@link EMBEDDED_WALLET_KEYS}).
+* 2. Wallets that only ship a browser-extension injection (`injectedConfig`)
+*    with no mobile or desktop links — these have no surface a customer
+*    catalogue UI can drive to.
+*
+* Channel-specific eligibility (WalletConnect support, in-app browser URL,
+* installation links, …) is the caller's responsibility — wrap this helper
+* with an additional check, e.g.
+* {@link shouldFilterWalletForWalletConnect}.
 *
 * @returns True if the wallet should be filtered out, false otherwise.
 * @not-instrumented
 */
 const shouldFilterWallet = ({ wallet, walletKey }) => {
 	if (EMBEDDED_WALLET_KEYS.includes(walletKey)) return true;
-	if (!wallet.walletConnect || !wallet.walletConnect.sdks.includes("sign_v2")) return true;
 	const hasInjectedConfig = wallet.injectedConfig && wallet.injectedConfig.length > 0;
 	const hasMobileLinks = Boolean(wallet.mobile?.androidId || wallet.mobile?.iosId || wallet.mobile?.native || wallet.mobile?.universal);
 	const hasDesktopLinks = Boolean(wallet.desktop?.chromeId || wallet.desktop?.edgeId || wallet.desktop?.firefoxId || wallet.desktop?.operaId || wallet.desktop?.safariId || wallet.desktop?.universal);
-	if (hasInjectedConfig && !hasMobileLinks && !hasDesktopLinks) return true;
-	return false;
+	return Boolean(hasInjectedConfig && !hasMobileLinks && !hasDesktopLinks);
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/getWalletConnectCatalog/shouldFilterWalletForWalletConnect/shouldFilterWalletForWalletConnect.ts
+/**
+* WalletConnect-specific filter. Applies the generic
+* {@link shouldFilterWallet} eligibility rules and additionally drops
+* wallets that do not advertise WalletConnect `sign_v2` support — the
+* protocol version Dynamic pairs against.
+*
+* @returns True if the wallet should be excluded from the WalletConnect
+*   catalog, false otherwise.
+* @not-instrumented
+*/
+const shouldFilterWalletForWalletConnect = ({ wallet, walletKey }) => {
+	if (shouldFilterWallet({
+		wallet,
+		walletKey
+	})) return true;
+	return !wallet.walletConnect?.sdks.includes("sign_v2");
 };
 
 //#endregion
@@ -3614,7 +3646,7 @@ const transformWalletBook = ({ walletBook }) => {
 	for (const [groupKey, group] of Object.entries(walletBook.groups)) groups[groupKey] = transformGroup({ group });
 	const wallets = {};
 	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
-		if (shouldFilterWallet({
+		if (shouldFilterWalletForWalletConnect({
 			wallet,
 			walletKey
 		})) continue;
@@ -3646,6 +3678,118 @@ const getWalletConnectCatalog = async (client = require_InvalidParamError.getDef
 	return transformWalletBook({ walletBook: await fetchLegacyWalletBook(client) });
 };
 
+//#endregion
+//#region src/modules/legacyWalletBook/matchWalletProvidersToCatalogGroup/matchWalletProvidersToCatalogGroup.ts
+const normalize$1 = (value) => value.toLowerCase().replace(/\s+/g, "").replace(/wallet/g, "");
+/**
+* Returns the wallet providers that belong to the same wallet group as the
+* given WalletConnect catalog entry. Useful for de-duplicating "installed"
+* vs "available via WalletConnect" wallets when rendering a combined list.
+*
+* Matching is done on normalized identifiers — lowercased, whitespace removed,
+* and the literal substring "wallet" stripped — so that variations like:
+*   - catalog key `"trust"` + catalog name `"Trust Wallet"`
+*   - provider `groupKey: "trustwallet"` + `displayName: "Trust Wallet"`
+* collapse into a single match.
+*
+* @param params.catalogGroupKey - Key of the catalog group (e.g. `"metamask"`).
+* @param [params.catalogGroupName] - Optional display name (e.g. `"Trust Wallet"`); matched as a fallback when the key is opaque.
+* @param params.walletProviders - Currently available wallet providers (from `getAvailableWalletProvidersData`).
+* @returns The subset of `walletProviders` that match the catalog group.
+* @not-instrumented
+*/
+const matchWalletProvidersToCatalogGroup = ({ catalogGroupKey, catalogGroupName, walletProviders }) => {
+	const targets = new Set([normalize$1(catalogGroupKey)]);
+	if (catalogGroupName) targets.add(normalize$1(catalogGroupName));
+	return walletProviders.filter((provider) => {
+		return [normalize$1(provider.groupKey), normalize$1(provider.metadata.displayName)].some((candidate) => targets.has(candidate));
+	});
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/excludeInstalledFromCatalog/collectInstalledGroupIds/collectInstalledGroupIds.ts
+/**
+* Scans the catalog and returns the set of group identifiers for which at
+* least one installed wallet provider matches.
+*
+* Walks the catalog twice on purpose:
+* - First through `wallets`, to cover wallets that point to a `groupId`
+*   with no matching entry in `groups` (we fall back to the wallet's own
+*   name for matching in that case).
+* - Then through `groups`, to catch orphan group entries that have no
+*   wallet referencing them.
+*
+* The check is skipped for any group already known to be installed, so a
+* multi-chain wallet (same `groupId` across EVM + SOL entries) only runs
+* the match once.
+*
+* @not-instrumented
+*/
+const collectInstalledGroupIds = ({ catalog, walletProviders }) => {
+	const installedGroupIds = /* @__PURE__ */ new Set();
+	for (const [walletKey, wallet] of Object.entries(catalog.wallets)) {
+		const groupId = wallet.groupId || walletKey;
+		if (installedGroupIds.has(groupId)) continue;
+		if (matchWalletProvidersToCatalogGroup({
+			catalogGroupKey: groupId,
+			catalogGroupName: catalog.groups[groupId]?.name || wallet.name,
+			walletProviders
+		}).length > 0) installedGroupIds.add(groupId);
+	}
+	for (const [groupKey, group] of Object.entries(catalog.groups)) {
+		if (installedGroupIds.has(groupKey)) continue;
+		if (matchWalletProvidersToCatalogGroup({
+			catalogGroupKey: groupKey,
+			catalogGroupName: group.name,
+			walletProviders
+		}).length > 0) installedGroupIds.add(groupKey);
+	}
+	return installedGroupIds;
+};
+
+//#endregion
+//#region src/modules/legacyWalletBook/excludeInstalledFromCatalog/excludeInstalledFromCatalog.ts
+/**
+* Returns a new WalletConnect catalog with the wallets and groups that the
+* user already has installed removed.
+*
+* Useful when rendering a combined wallet list (installed + WalletConnect
+* catalog) where each wallet should appear exactly once: installed wallets
+* win and the corresponding catalog entries get hidden.
+*
+* Matching is delegated to {@link collectInstalledGroupIds}, so a single
+* installed provider removes every wallet that shares its group — e.g. an
+* installed MetaMask hides both the EVM and SOL catalog entries.
+*
+* The original catalog object is not mutated.
+*
+* @param params.catalog - The full WalletConnect catalog (typically from `getWalletConnectCatalog`).
+* @param params.walletProviders - Currently available wallet providers.
+* @returns A new catalog with only the wallets and groups the user does not have installed.
+* @not-instrumented
+*/
+const excludeInstalledFromCatalog = ({ catalog, walletProviders }) => {
+	const installedGroupIds = collectInstalledGroupIds({
+		catalog,
+		walletProviders
+	});
+	const wallets = {};
+	for (const [walletKey, wallet] of Object.entries(catalog.wallets)) {
+		const groupId = wallet.groupId || walletKey;
+		if (installedGroupIds.has(groupId)) continue;
+		wallets[walletKey] = wallet;
+	}
+	const groups = {};
+	for (const [groupKey, group] of Object.entries(catalog.groups)) {
+		if (installedGroupIds.has(groupKey)) continue;
+		groups[groupKey] = group;
+	}
+	return {
+		groups,
+		wallets
+	};
+};
+
 //#endregion
 //#region src/modules/wallets/walletProvider/extractChainFromNormalizedName/extractChainFromNormalizedName.ts
 /**
@@ -3692,6 +3836,808 @@ const getWalletConnectCatalogWalletByWalletProviderKey = async ({ walletProvider
 	}
 };
 
+//#endregion
+//#region src/modules/walletOptionsCatalogue/resolveWalletBookWalletOptionKey/resolveWalletBookWalletOptionKey.ts
+/**
+* Resolves which wallet option (group) a wallet book entry belongs to. Used
+* by the catalogue's wallet-book-driven transformers (`walletConnect`,
+* `inAppBrowser`, `installation`) to bucket their emitted options.
+*
+* Wallet book entries inconsistently use `group` / `chainGroup` /
+* `walletGroup` for the same idea. The wallet key itself acts as the wallet
+* option key when no group field is set.
+*
+* @param params.wallet - The wallet entry.
+* @param params.walletKey - The wallet's key in `walletBook.wallets`.
+* @returns The wallet option key.
+* @not-instrumented
+*/
+const resolveWalletBookWalletOptionKey = ({ wallet, walletKey }) => wallet.group ?? wallet.chainGroup ?? wallet.walletGroup ?? walletKey;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/getInAppBrowserUrl.ts
+/**
+* Returns the wallet's in-app browser URL template, preferring the v2
+* field. `inAppBrowser` is deprecated but some wallet book entries
+* still carry only the v1 value, so it acts as a fallback. Trailing
+* `?? undefined` collapses the schema's `string | null` typing down to
+* the `string | undefined` return contract.
+*
+* @param params.wallet - The wallet book wallet entry.
+* @returns The in-app browser URL, or `undefined` if neither field is set.
+* @not-instrumented
+*/
+const getInAppBrowserUrl = ({ wallet }) => wallet.mobile?.inAppBrowserV2 ?? wallet.mobile?.inAppBrowser ?? void 0;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/buildInAppBrowserOptions.ts
+/**
+* Builds the `inAppBrowser` catalogue options from the wallet book. A wallet
+* qualifies when it exposes a mobile in-app-browser URL — typically a
+* `cb_url={{encodedDappURI}}`-style template the customer fills in with the
+* current page URL before opening.
+*
+* Reuses the generic `shouldFilterWallet` rules — embedded sign-in methods
+* and injected-only wallets are dropped — so the catalogue's notion of
+* "external wallet" stays consistent across option types.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns Tagged `inAppBrowser` options paired with their wallet option keys.
+* @not-instrumented
+*/
+const buildInAppBrowserOptions = ({ walletBook }) => {
+	const result = [];
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWallet({
+			wallet,
+			walletKey
+		})) continue;
+		const url = getInAppBrowserUrl({ wallet });
+		if (!url) continue;
+		result.push({
+			option: {
+				chain: getChainFromWalletSchema({
+					wallet,
+					walletKey
+				}),
+				type: "inAppBrowser",
+				url
+			},
+			walletOptionKey: resolveWalletBookWalletOptionKey({
+				wallet,
+				walletKey
+			})
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInstallationUrls/buildInstallationUrls.ts
+const PLAY_STORE_URL_TEMPLATE = "https://play.google.com/store/apps/details?id=";
+const APP_STORE_URL_TEMPLATE = "https://apps.apple.com/app/";
+const CHROME_WEB_STORE_URL_TEMPLATE = "https://chrome.google.com/webstore/detail/";
+const FIREFOX_ADDONS_URL_TEMPLATE = "https://addons.mozilla.org/firefox/addon/";
+const EDGE_ADDONS_URL_TEMPLATE = "https://microsoftedge.microsoft.com/addons/detail/";
+/**
+* Builds the install/download URL bag for a wallet book entry. Returns the
+* concrete URLs assembled from each store's ID field — Play Store, App
+* Store, Chrome Web Store, Firefox Add-ons, Edge Add-ons — plus the wallet's
+* own `desktop.universal` / `desktop.native` URLs when set.
+*
+* Fields the wallet book does not carry are left undefined; callers should
+* skip emitting an installation option for a wallet whose URL bag is empty.
+*
+* @param params.wallet - The wallet book entry.
+* @returns The URL bag, omitting fields the wallet does not provide.
+* @not-instrumented
+*/
+const buildInstallationUrls = ({ wallet }) => {
+	const androidId = wallet.mobile?.androidId;
+	const iosId = wallet.mobile?.iosId;
+	const chromeId = wallet.desktop?.chromeId;
+	const firefoxId = wallet.desktop?.firefoxId;
+	const edgeId = wallet.desktop?.edgeId;
+	const native = wallet.desktop?.universal ?? wallet.desktop?.native;
+	return {
+		android: androidId ? `${PLAY_STORE_URL_TEMPLATE}${androidId}` : void 0,
+		chrome: chromeId ? `${CHROME_WEB_STORE_URL_TEMPLATE}${chromeId}` : void 0,
+		edge: edgeId ? `${EDGE_ADDONS_URL_TEMPLATE}${edgeId}` : void 0,
+		firefox: firefoxId ? `${FIREFOX_ADDONS_URL_TEMPLATE}${firefoxId}` : void 0,
+		ios: iosId ? `${APP_STORE_URL_TEMPLATE}${iosId}` : void 0,
+		native: native || void 0
+	};
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildInstallationUrlsByWalletOptionKey/buildInstallationUrlsByWalletOptionKey.ts
+/**
+* `buildInstallationUrls` always returns an object, but it can be fully
+* `undefined`-valued when the wallet book entry has no installable surface.
+* Skip those wallets — emitting an empty URL bag helps nobody.
+*/
+const hasAnyInstallationUrl = ({ urls }) => Object.values(urls).some(Boolean);
+/**
+* Collects install / download URLs for every wallet book entry that has
+* at least one installable surface, keyed by the wallet option key the
+* wallet groups under. The catalogue assembly step merges this map into
+* the per-key wallet option shell so `WalletOption.installationUrls` is
+* populated alongside (or instead of) `connectionOptions`.
+*
+* First-seen URLs win when multiple wallet book entries resolve to the
+* same wallet option key — wallet book authors put the most accurate
+* install links on the canonical entry, so the first-seen one is the
+* right pick.
+*
+* Reuses the generic `shouldFilterWallet` rules so embedded wallets do
+* not appear here either — they're not user-installable products.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns A map from wallet option key to its install URL bag.
+* @not-instrumented
+*/
+const buildInstallationUrlsByWalletOptionKey = ({ walletBook }) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWallet({
+			wallet,
+			walletKey
+		})) continue;
+		const urls = buildInstallationUrls({ wallet });
+		if (!hasAnyInstallationUrl({ urls })) continue;
+		const walletOptionKey = resolveWalletBookWalletOptionKey({
+			wallet,
+			walletKey
+		});
+		if (!map.has(walletOptionKey)) map.set(walletOptionKey, urls);
+	}
+	return map;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWalletConnectOptions/buildWalletConnectOptions.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.
+*/
+const hasUsableDeeplink = ({ wallet }) => Boolean(wallet.mobile?.native || wallet.mobile?.universal);
+/**
+* Builds the `walletConnect` 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.
+*
+* @param params.walletBook - The fetched wallet book.
+* @returns Tagged `walletConnect` options paired with their wallet option keys.
+* @not-instrumented
+*/
+const buildWalletConnectOptions = ({ walletBook }) => {
+	const result = [];
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) {
+		if (shouldFilterWalletForWalletConnect({
+			wallet,
+			walletKey
+		})) continue;
+		if (!hasUsableDeeplink({ wallet })) continue;
+		const walletOptionKey = resolveWalletBookWalletOptionKey({
+			wallet,
+			walletKey
+		});
+		const chain = getChainFromWalletSchema({
+			wallet,
+			walletKey
+		});
+		result.push({
+			option: {
+				chain,
+				deeplinks: {
+					native: wallet.mobile?.native,
+					universal: wallet.mobile?.universal
+				},
+				type: "walletConnect"
+			},
+			walletOptionKey
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWalletOption/buildWalletOption.ts
+/**
+* Assembles a `WalletOption` for a resolved wallet option key, populated
+* with the connection options the transformers produced for it plus an
+* optional install / download URL bag.
+*
+* Display merge rules (provider self-announced metadata wins where set):
+*
+* - `name`: `displayOverride.name` ?? wallet book group name ?? bare key.
+* - `iconUrl`: `displayOverride.iconUrl` ?? wallet book group sprite URL ?? `''`.
+* - `primaryColor`: wallet book group brand color only (providers do not
+*   ship a primary color in their announcement metadata).
+* - `installationUrls`: copied through if present.
+*
+* Why provider precedence: a registered wallet provider knows its own
+* brand best (EIP-6963 / Wallet Standard / vendor SDK announcement is the
+* wallet authoring its own identity). The wallet book fills in fields the
+* announcement does not carry — currently only `primaryColor`.
+*
+* @param params.connectionOptions - The connections to attach to this wallet option.
+* @param [params.displayOverride] - Provider-announced display info that overrides the wallet book's name and iconUrl.
+* @param [params.installationUrls] - Install/download URL bag for this wallet.
+* @param params.walletBook - The fetched wallet book.
+* @param params.walletOptionKey - The wallet option key.
+* @returns The constructed wallet option.
+* @not-instrumented
+*/
+const buildWalletOption = ({ connectionOptions, displayOverride, installationUrls, walletBook, walletOptionKey }) => {
+	const group = walletBook.groups[walletOptionKey];
+	const groupSpriteId = group?.brand?.spriteId;
+	const groupIconUrl = groupSpriteId ? getSpriteUrl({ spriteId: groupSpriteId }) : void 0;
+	return {
+		connectionOptions,
+		iconUrl: displayOverride?.iconUrl ?? groupIconUrl ?? "",
+		installationUrls,
+		key: walletOptionKey,
+		name: displayOverride?.name ?? group?.name ?? walletOptionKey,
+		primaryColor: group?.brand?.primaryColor
+	};
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.ts
+/**
+* Maps a registered wallet provider's registration priority to the
+* `WithWalletProviderSource` value that should appear on its catalogue option.
+*
+* Priority mapping (set by each chain extension when it calls
+* `registry.register`):
+*
+* - `WALLET_SDK` → `'sdk'` — branded SDKs wrapped by chain extensions
+*   (Base Account via `@base-org/account`, MetaMask Connect, …).
+* - `WALLET_SELF_ANNOUNCEMENT_STANDARD` → `'selfAnnounced'` — in-page
+*   self-announcement standards (EIP-6963 on EVM, Wallet Standard on
+*   Solana / Sui / …).
+* - `WINDOW_INJECT` → `'windowInjected'` — legacy `window.*` injection.
+*
+* Returns `undefined` for providers whose registration priority does not
+* correspond to a connectable external-wallet source — callers filter these
+* out before emitting catalogue options.
+*
+* @param params.entry - The registry entry to classify.
+* @returns The matching source, or `undefined` if this entry should not
+*   surface a `withWalletProvider` option.
+* @not-instrumented
+*/
+const classifyWithWalletProviderSource = ({ entry }) => {
+	const { priority } = entry;
+	if (priority === 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";
+};
+
+//#endregion
+//#region src/modules/wallets/utils/stripChainSuffix/stripChainSuffix.ts
+/**
+* Removes the lowercased chain suffix that `normalizeWalletNameWithChain`
+* appends. Used by `findWalletOptionKeyForProviderKey` to recover the wallet
+* book wallet key candidate from a `walletProviderKey`. If the suffix is
+* not present (some chain extensions already bake the chain into the
+* display name), the input is returned unchanged.
+*
+* @param params.chain - The chain whose suffix should be stripped.
+* @param params.normalizedName - The normalized wallet-name-with-chain string.
+* @returns The name with the chain suffix removed, or the input unchanged.
+* @not-instrumented
+*/
+const stripChainSuffix = ({ chain, normalizedName }) => {
+	const suffix = chain.toLowerCase();
+	if (normalizedName.endsWith(suffix)) return normalizedName.slice(0, -suffix.length);
+	return normalizedName;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/normalizeWalletDisplayName/normalizeWalletDisplayName.ts
+/**
+* Normalizes a wallet's self-announced `displayName` into a stable wallet
+* option key. Used by `findWalletOptionKeyForProviderKey` as the off-book
+* fallback — registered providers whose `walletProviderKey` does not
+* resolve to any wallet book entry still surface in the catalogue under a
+* key derived from the name they ship in their metadata.
+*
+* The normalization (lowercase + whitespace-strip) intentionally matches
+* how the legacy wallet book composes its `wallets.<key>` keys, so a
+* self-described provider's option will merge cleanly with its book entry
+* if one ever lands later.
+*
+* Multi-chain registrations of the same wallet (e.g. Phantom announced via
+* EIP-6963 on EVM and via Wallet Standard on Solana) collapse onto the
+* same wallet option through this normalization, since each registration
+* announces the same `displayName`.
+*
+* @param displayName - The provider's `metadata.displayName`.
+* @returns The normalized wallet option key (lowercased, no whitespace).
+* @not-instrumented
+*/
+const normalizeWalletDisplayName = (displayName) => displayName.toLowerCase().replace(/\s+/g, "");
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.ts
+const normalize = (value) => value.toLowerCase().replace(/\s+/g, "");
+/**
+* Looks for a wallet book entry whose `name` or `shortName` normalizes to
+* the same string as `candidate`. Used as a fallback by
+* `findWalletOptionKeyForProviderKey` for providers whose
+* `walletProviderKey` strips down to a value that does not match any
+* `walletBook.wallets` key directly (e.g. an extension whose display name
+* happens to match the wallet's `shortName` instead of its book key).
+*
+* @param params.candidate - The lowercased, chain-suffix-stripped candidate.
+* @param params.walletBook - The fetched wallet book.
+* @returns The matching wallet book wallet key, or `undefined`.
+* @not-instrumented
+*/
+const findByNameMatch = ({ candidate, walletBook }) => {
+	for (const [walletKey, wallet] of Object.entries(walletBook.wallets)) if (normalize(wallet.name) === candidate || normalize(wallet.shortName) === candidate) return walletKey;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/resolveWalletOptionKey/resolveWalletOptionKey.ts
+/**
+* Picks the wallet option (group) key for a wallet book wallet. The wallet
+* book carries the group association under a few different field names
+* (`group`, `chainGroup`, `walletGroup`) depending on the wallet's
+* provenance — this helper centralises the lookup. When none of those
+* fields are set, the wallet key itself acts as its own wallet option key.
+*
+* @param params.fallback - Wallet key to return if no group field is set.
+* @param params.wallet - The wallet book wallet entry.
+* @returns The resolved wallet option key.
+* @not-instrumented
+*/
+const resolveWalletOptionKey = ({ fallback, wallet }) => wallet.group ?? wallet.chainGroup ?? wallet.walletGroup ?? fallback;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findWalletOptionKeyForProviderKey.ts
+/**
+* Resolves a registered wallet provider to the wallet option key it should
+* be bucketed under. Always returns a key — providers with no wallet book
+* match fall back to their self-announced `metadata.displayName`, so the
+* catalogue surfaces them as self-described tiles instead of silently
+* dropping them.
+*
+* Resolution order (each step short-circuits on first hit):
+*
+* 1. **Direct wallet book lookup with chain suffix** — try
+*    `walletBook.wallets[normalizedWalletNameWithChain]` as-is. Wallet
+*    book entries are inconsistent about whether they keep the chain
+*    suffix (e.g. `metamaskevm`) or strip it (e.g. `metamask`), so try
+*    the suffixed form first.
+* 2. **Direct wallet book lookup without chain suffix** — strip the
+*    suffix and retry.
+* 3. **Name match heuristic with chain suffix** — scan
+*    `walletBook.wallets` for an entry whose normalized `name` or
+*    `shortName` equals the suffixed candidate.
+* 4. **Name match heuristic without chain suffix** — same scan on the
+*    stripped candidate.
+* 5. **Display-name fallback** — derive a stable key from
+*    `walletProvider.metadata.displayName` via
+*    {@link normalizeWalletDisplayName}. Multi-chain registrations of the
+*    same self-described wallet (e.g. Phantom on EVM and Solana) collapse
+*    onto the same tile because each announces the same display name.
+*
+* @param params.chain - The provider's chain (used to strip the suffix).
+* @param params.walletBook - The fetched wallet book.
+* @param params.walletProvider - The registered wallet provider.
+* @returns The wallet option key for this provider.
+* @not-instrumented
+*/
+const findWalletOptionKeyForProviderKey = ({ chain, walletBook, walletProvider }) => {
+	const { normalizedWalletNameWithChain } = require_getVerifiedCredentialForWalletAccount.splitWalletProviderKey(walletProvider.key);
+	const candidates = [normalizedWalletNameWithChain, stripChainSuffix({
+		chain,
+		normalizedName: normalizedWalletNameWithChain
+	})];
+	for (const candidate of candidates) {
+		const directHit = walletBook.wallets[candidate];
+		if (directHit) return resolveWalletOptionKey({
+			fallback: candidate,
+			wallet: directHit
+		});
+	}
+	for (const candidate of candidates) {
+		const nameMatchKey = findByNameMatch({
+			candidate,
+			walletBook
+		});
+		if (nameMatchKey) return resolveWalletOptionKey({
+			fallback: nameMatchKey,
+			wallet: walletBook.wallets[nameMatchKey]
+		});
+	}
+	return normalizeWalletDisplayName(walletProvider.metadata.displayName);
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/buildWithWalletProviderOptions/buildWithWalletProviderOptions.ts
+/**
+* Converts each registered wallet provider entry into a
+* `WithWalletProviderConnectionOption` paired with its target wallet
+* option key and the provider's display override. Every classifiable
+* entry surfaces in the catalogue; the outer transformer uses the
+* carried `displayOverride` to override any wallet book branding for
+* that key (provider self-announcement wins over book).
+*
+* Entries whose registration priority is not recognised by
+* `classifyWithWalletProviderSource` are dropped from the catalogue and
+* an error is logged so Datadog surfaces the unknown registration path —
+* in production this should never happen, every chain extension is
+* expected to register with one of the documented priorities.
+*
+* @param params.entries - Snapshot of the registry's entries.
+* @param params.walletBook - The fetched wallet book.
+* @param client - The Dynamic client (used for logging unclassifiable entries).
+* @returns An array of tagged options, in input order.
+* @not-instrumented
+*/
+const buildWithWalletProviderOptions = ({ entries, walletBook }, client) => {
+	const result = [];
+	for (const entry of entries) {
+		const source = classifyWithWalletProviderSource({ entry });
+		if (!source) {
+			require_InvalidParamError.getCore(client).logger.error("buildWithWalletProviderOptions: registered wallet provider has an unrecognised priority — unable to identify how this wallet was registered", {
+				chain: entry.walletProvider.chain,
+				displayName: entry.walletProvider.metadata.displayName,
+				priority: entry.priority,
+				walletProviderKey: entry.walletProvider.key,
+				walletProviderType: entry.walletProvider.walletProviderType
+			});
+			continue;
+		}
+		const walletOptionKey = findWalletOptionKeyForProviderKey({
+			chain: entry.walletProvider.chain,
+			walletBook,
+			walletProvider: entry.walletProvider
+		});
+		result.push({
+			displayOverride: {
+				iconUrl: entry.walletProvider.metadata.icon,
+				name: entry.walletProvider.metadata.displayName
+			},
+			option: {
+				chain: entry.walletProvider.chain,
+				source,
+				type: "withWalletProvider",
+				walletProviderKey: entry.walletProvider.key
+			},
+			walletOptionKey
+		});
+	}
+	return result;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/excludedWalletOptionKeys/excludedWalletOptionKeys.ts
+/**
+* Wallet option keys `getWalletOptionsCatalogue` drops before returning.
+* Curated, product-level suppression.
+*
+* Example: Base Account SDK is the recommended entry point for
+* Coinbase-managed users, so the legacy Coinbase Wallet entries are
+* suppressed in favor of the SDK-backed `baseaccount` tile. Both the
+* wallet book group key (`coinbase`) and the normalized display-name
+* key (`coinbasewallet`) are listed so suppression holds regardless of
+* how the resolver lands on a key.
+*
+* Used in: `getWalletOptionsCatalogue`.
+*/
+const EXCLUDED_WALLET_OPTION_KEYS = new Set(["coinbase", "coinbasewallet"]);
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.ts
+/**
+* Buckets tagged connection options by their wallet option key. Preserves
+* first-seen order so that the caller's choice of
+* `walletOptionOrdering: 'relevance'` naturally inherits the upstream input
+* order (wallet book order for walletConnect/inAppBrowser/installation,
+* registry order for withWalletProvider).
+*
+* Carries through the first-seen `displayOverride` per wallet option
+* key, so the shell builder can apply provider-announced metadata on
+* top of any wallet book entry.
+*
+* @param params.options - The tagged options to group.
+* @returns A map from wallet option key to its grouped option bucket,
+*   iterable in first-seen order.
+* @not-instrumented
+*/
+const groupOptionsByWalletOption = ({ options }) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const { displayOverride, option, walletOptionKey } of options) {
+		const existing = map.get(walletOptionKey);
+		if (existing) {
+			existing.connectionOptions.push(option);
+			if (!existing.displayOverride && displayOverride) existing.displayOverride = displayOverride;
+		} else map.set(walletOptionKey, {
+			connectionOptions: [option],
+			displayOverride
+		});
+	}
+	return map;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getConnectionOptionPriority/getConnectionOptionPriority.ts
+/**
+* Numeric priority for each `WalletConnectionOption` type. Lower values rank
+* first. Used to sort each wallet option's `connectionOptions` array so the
+* best connection path lands at index 0. Has no bearing on how the outer
+* wallet-option list is ordered — that's controlled by
+* `WalletOptionOrdering`.
+*
+* `withWalletProvider > walletConnect > inAppBrowser`
+*/
+const CONNECTION_OPTION_PRIORITY = {
+	inAppBrowser: 2,
+	walletConnect: 1,
+	withWalletProvider: 0
+};
+/**
+* Returns the numeric priority of a `WalletConnectionOption` for sorting.
+* Lower numbers rank first.
+*
+* @param params.option - The connection option to inspect.
+* @returns The numeric priority — lower is better.
+* @not-instrumented
+*/
+const getConnectionOptionPriority = ({ option }) => CONNECTION_OPTION_PRIORITY[option.type];
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/sortConnectionOptions/sortConnectionOptions.ts
+/**
+* Sorts a wallet option's `connectionOptions` so the most preferred option lands at
+* index 0. Primary sort is by option-type priority
+* (`withWalletProvider` > `walletConnect` > `inAppBrowser`);
+* within a type, ties break alphabetically by `chain` for deterministic
+* output across calls.
+*
+* Returns a new array — the input is not mutated.
+*
+* @param params.options - The options to sort.
+* @returns A new array in priority order.
+* @not-instrumented
+*/
+const sortConnectionOptions = ({ options }) => [...options].sort((a, b) => {
+	const priorityDelta = getConnectionOptionPriority({ option: a }) - getConnectionOptionPriority({ option: b });
+	if (priorityDelta !== 0) return priorityDelta;
+	return a.chain.localeCompare(b.chain);
+});
+
+//#endregion
+//#region src/modules/legacyWalletBook/priorityWalletKeys/priorityWalletKeys.ts
+/**
+* Hand-curated list of wallet book group keys that should surface at the top
+* of catalogue listings. Lower index = higher priority. Anything not in this
+* list falls through to the secondary sort (alphabetical by name).
+*
+* Used by `sortWalletOptions` (relevance mode) and by the react-demo's
+* WalletConnect picker. Keep both in sync when adding entries.
+*/
+const PRIORITY_WALLET_KEYS = [
+	"metamask",
+	"coinbase",
+	"baseaccount",
+	"phantom",
+	"magiceden",
+	"trust",
+	"okxwallet",
+	"rainbow",
+	"argentx",
+	"backpack",
+	"xverse",
+	"onekey",
+	"solflare",
+	"braavos",
+	"brave",
+	"unisat",
+	"bitgetwallet",
+	"coin98"
+];
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getPriorityIndex/getPriorityIndex.ts
+/**
+* Returns the index of a wallet option in `PRIORITY_WALLET_KEYS`, or
+* `Number.POSITIVE_INFINITY` when the wallet is not in the hand-curated
+* priority list. Lower index = higher priority.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns Numeric priority index — lower is better.
+* @not-instrumented
+*/
+const getPriorityIndex = ({ walletOption }) => {
+	const index = PRIORITY_WALLET_KEYS.indexOf(walletOption.key);
+	return index === -1 ? Number.POSITIVE_INFINITY : index;
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/compareByRelevance/compareByRelevance.ts
+/**
+* Compares two wallet options for relevance ordering: priority-list index
+* first, then alphabetical-by-name as the tie-break. Suitable for passing
+* straight to `Array.prototype.sort`.
+*
+* @param params.a - First wallet option.
+* @param params.b - Second wallet option.
+* @returns Negative when `a` ranks first, positive when `b` ranks first.
+* @not-instrumented
+*/
+const compareByRelevance = ({ a, b }) => {
+	const aIndex = getPriorityIndex({ walletOption: a });
+	const bIndex = getPriorityIndex({ walletOption: b });
+	if (aIndex !== bIndex) return aIndex - bIndex;
+	return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/hasAnyConnectionOption/hasAnyConnectionOption.ts
+/**
+* True when the wallet option has at least one connection — i.e. the user
+* can sign in right now. Install-only wallet options surface in the
+* catalogue too (they carry `installationUrls`) but have an empty
+* `connectionOptions` array; this predicate distinguishes them from
+* actually connectable wallets in the relevance sort.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns True when `connectionOptions` is non-empty.
+* @not-instrumented
+*/
+const hasAnyConnectionOption = ({ walletOption }) => walletOption.connectionOptions.length > 0;
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/hasInstalledProvider/hasInstalledProvider.ts
+/**
+* True when the wallet option has a `withWalletProvider` connection — i.e.
+* the user already has the wallet available in the page (browser extension,
+* Wallet Standard announcement, window injection, or an SDK-backed provider
+* one of our chain extensions registered). `connectionOptions` is
+* pre-sorted, so a registered provider always sits at index 0 when present.
+*
+* @param params.walletOption - The wallet option to inspect.
+* @returns True when an installed provider is available.
+* @not-instrumented
+*/
+const hasInstalledProvider = ({ walletOption }) => walletOption.connectionOptions[0]?.type === "withWalletProvider";
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/sortWalletOptions/sortWalletOptions.ts
+/**
+* Sorts the outer wallet-option list. This is the only ordering controlled
+* by the customer; the inner `connectionOptions` array of each wallet
+* option is ordered separately by `sortConnectionOptions` using a fixed
+* option-type priority.
+*
+* - `'relevance'` (default): bucket wallet options into three tiers, in
+*   this order:
+*     1. **Installed provider** — user already has the wallet available
+*        (`withWalletProvider` at index 0).
+*     2. **Connectable** — has at least one connection (`walletConnect`
+*        or `inAppBrowser`) but no installed provider.
+*     3. **Install-only** — no connection at all; only `installationUrls`.
+*   Within each tier, rank by the hand-curated {@link PRIORITY_WALLET_KEYS}
+*   list (MetaMask, Coinbase, Phantom, …); unknown wallets fall through to
+*   alphabetical-by-name order at the tail of their tier.
+* - `'alphabetical'`: case-insensitive sort by wallet option `name`,
+*   without bucketing.
+*
+* Returns a new array — the input is not mutated.
+*
+* @param params.walletOptions - The wallet options to sort.
+* @param params.ordering - The requested ordering.
+* @returns A new array in the requested order.
+* @not-instrumented
+*/
+const sortWalletOptions = ({ walletOptions, ordering }) => {
+	if (ordering === "alphabetical") return [...walletOptions].sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" }));
+	const installed = [];
+	const connectable = [];
+	const installOnly = [];
+	for (const walletOption of walletOptions) if (hasInstalledProvider({ walletOption })) installed.push(walletOption);
+	else if (hasAnyConnectionOption({ walletOption })) connectable.push(walletOption);
+	else installOnly.push(walletOption);
+	installed.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	connectable.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	installOnly.sort((a, b) => compareByRelevance({
+		a,
+		b
+	}));
+	return [
+		...installed,
+		...connectable,
+		...installOnly
+	];
+};
+
+//#endregion
+//#region src/modules/walletOptionsCatalogue/getWalletOptionsCatalogue/getWalletOptionsCatalogue.ts
+const EMPTY_WALLET_BOOK = {
+	groups: {},
+	wallets: {}
+};
+/**
+* Returns 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.
+*
+* The wallet book is fetched only when an enabled flag needs it
+* (`includeWalletConnect`, `includeInAppBrowser`). Calls that only need
+* `includeWithWalletProvider` skip the fetch entirely.
+*
+* @param [params] - Inclusion flags + ordering preference.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise that resolves to the wallet options catalogue.
+* @not-instrumented
+*/
+const getWalletOptionsCatalogue = async (params = {}, client = require_InvalidParamError.getDefaultClient()) => {
+	const includeWithWalletProvider = params.includeWithWalletProvider ?? true;
+	const includeWalletConnect = params.includeWalletConnect ?? false;
+	const includeInAppBrowser = params.includeInAppBrowser ?? false;
+	const includeInstallation = params.includeInstallation ?? false;
+	const walletOptionOrdering = params.walletOptionOrdering ?? "relevance";
+	if (!includeWithWalletProvider && !includeWalletConnect && !includeInAppBrowser && !includeInstallation) return [];
+	const walletBook = includeWalletConnect || includeInAppBrowser || includeInstallation ? await fetchLegacyWalletBook(client) : EMPTY_WALLET_BOOK;
+	const allConnectionOptions = [];
+	if (includeWithWalletProvider) {
+		const entries = require_getVerifiedCredentialForWalletAccount.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();
+	const grouped = groupOptionsByWalletOption({ options: allConnectionOptions });
+	const allWalletOptionKeys = new Set([...grouped.keys(), ...installationUrlsByKey.keys()]);
+	const walletOptions = [];
+	for (const walletOptionKey of allWalletOptionKeys) {
+		if (EXCLUDED_WALLET_OPTION_KEYS.has(walletOptionKey)) continue;
+		const groupedEntry = grouped.get(walletOptionKey);
+		const connectionOptions = groupedEntry ? sortConnectionOptions({ options: groupedEntry.connectionOptions }) : [];
+		walletOptions.push(buildWalletOption({
+			connectionOptions,
+			displayOverride: groupedEntry?.displayOverride,
+			installationUrls: installationUrlsByKey.get(walletOptionKey),
+			walletBook,
+			walletOptionKey
+		}));
+	}
+	return sortWalletOptions({
+		ordering: walletOptionOrdering,
+		walletOptions
+	});
+};
+
 //#endregion
 //#region src/modules/user/updateUser/updateUser.ts
 /**
@@ -5721,9 +6667,9 @@ const getChainIdForAccountVerification = async ({ walletProvider }) => {
 /** @not-instrumented */
 const getSignInMessage = async ({ nonce: nonceOverride, walletAccount }, client) => {
 	const core = require_InvalidParamError.getCore(client);
-	const universalLink = core.metadata?.universalLink;
-	require_InvalidParamError.assertDefined(universalLink, "Universal link is not set");
-	const url = new URL(universalLink);
+	const { appUniversalLink } = require_getNetworkProviderFromNetworkId.getAppMetadata(client);
+	require_InvalidParamError.assertDefined(appUniversalLink, "Universal link is not set");
+	const url = new URL(appUniversalLink);
 	const domain = url.host;
 	const nonce = nonceOverride ?? await require_InvalidParamError.getNonce(client);
 	const walletProvider = require_getVerifiedCredentialForWalletAccount.getWalletProviderFromWalletAccount({ walletAccount }, client);
@@ -6684,6 +7630,7 @@ exports.deleteUser = __deleteUser_wrapped;
 exports.detectDeviceRegistrationRedirect = detectDeviceRegistrationRedirect;
 exports.detectOAuthRedirect = detectOAuthRedirect;
 exports.detectSocialRedirectUrl = detectSocialRedirectUrl;
+exports.excludeInstalledFromCatalog = excludeInstalledFromCatalog;
 exports.executeSwapTransaction = __executeSwapTransaction_wrapped;
 exports.fetchProjectSettings = require_getNetworkProviderFromNetworkId.fetchProjectSettings;
 exports.findMissingGoogleDriveBackupScopes = findMissingGoogleDriveBackupScopes;
@@ -6722,6 +7669,7 @@ exports.getWalletAccountFromAddress = getWalletAccountFromAddress;
 exports.getWalletAccounts = require_getVerifiedCredentialForWalletAccount.getWalletAccounts;
 exports.getWalletConnectCatalog = getWalletConnectCatalog;
 exports.getWalletConnectCatalogWalletByWalletProviderKey = getWalletConnectCatalogWalletByWalletProviderKey;
+exports.getWalletOptionsCatalogue = getWalletOptionsCatalogue;
 exports.getWalletProviderDataByKey = getWalletProviderDataByKey;
 exports.hasAllGoogleDriveBackupScopes = hasAllGoogleDriveBackupScopes;
 exports.hasExtension = require_getNetworkProviderFromNetworkId.hasExtension;
@@ -6740,6 +7688,7 @@ exports.isUserMissingMfaAuth = require_getVerifiedCredentialForWalletAccount.isU
 exports.isUserOnboardingComplete = isUserOnboardingComplete;
 exports.isWalletAccountVerified = isWalletAccountVerified;
 exports.logout = logout;
+exports.matchWalletProvidersToCatalogGroup = matchWalletProvidersToCatalogGroup;
 exports.offEvent = require_getVerifiedCredentialForWalletAccount.offEvent;
 exports.offWalletProviderEvent = offWalletProviderEvent;
 exports.onEvent = require_getVerifiedCredentialForWalletAccount.onEvent;