@dynamic-labs-sdk/client 1.7.0 → 1.8.1

package/android/src/test/java/xyz/dynamic/client/webview/DynamicWebViewModuleTest.kt

@@ -0,0 +1,191 @@
+package xyz.dynamic.client.webview
+
+import android.app.Activity
+import android.net.Uri
+import android.os.Looper
+import android.webkit.WebView
+import androidx.webkit.JavaScriptReplyProxy
+import androidx.webkit.WebMessageCompat
+import androidx.webkit.WebViewCompat
+import androidx.webkit.WebViewFeature
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import io.mockk.CapturingSlot
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.unmockkAll
+import io.mockk.verify
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+
+// The androidx.webkit + Arguments statics are mocked (they delegate to the
+// device WebView / JNI). A real Robolectric Activity backs WebView construction
+// so open() reaches the live-host state needed to exercise invalidate().
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [35])
+class DynamicWebViewModuleTest {
+
+    private lateinit var activity: Activity
+    private lateinit var reactContext: ReactApplicationContext
+    private lateinit var module: DynamicWebViewModule
+    private lateinit var eventEmitter: RCTDeviceEventEmitter
+    private lateinit var webSlot: CapturingSlot<WebView>
+    private lateinit var listenerSlot: CapturingSlot<WebViewCompat.WebMessageListener>
+
+    @Before
+    fun setUp() {
+        activity = Robolectric.buildActivity(Activity::class.java).setup().get()
+        reactContext = mockk(relaxed = true)
+        every { reactContext.currentActivity } returns activity
+        every { reactContext.runOnUiQueueThread(any()) } answers { firstArg<Runnable>().run() }
+
+        eventEmitter = mockk(relaxed = true)
+        every {
+            reactContext.getJSModule(RCTDeviceEventEmitter::class.java)
+        } returns eventEmitter
+
+        mockkStatic(Arguments::class)
+        every { Arguments.createMap() } answers { JavaOnlyMap() }
+        every { Arguments.createArray() } answers { JavaOnlyArray() }
+
+        mockkStatic(WebViewFeature::class)
+        every { WebViewFeature.isFeatureSupported(any()) } returns false
+        every {
+            WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)
+        } returns true
+
+        mockkStatic(WebViewCompat::class)
+        webSlot = slot()
+        listenerSlot = slot()
+        every {
+            WebViewCompat.addWebMessageListener(
+                capture(webSlot),
+                any(),
+                any(),
+                capture(listenerSlot),
+            )
+        } just Runs
+        every {
+            WebViewCompat.addDocumentStartJavaScript(any(), any(), any())
+        } returns mockk(relaxed = true)
+        every { WebViewCompat.setProfile(any(), any()) } just Runs
+
+        module = DynamicWebViewModule(reactContext)
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    private fun idleMain() = shadowOf(Looper.getMainLooper()).idle()
+
+    // region invalidate (#12 — ConcurrentModificationException)
+
+    @Test
+    fun invalidate_closesEveryActiveHostWithoutConcurrentModification() {
+        val p1 = mockk<Promise>(relaxed = true)
+        val p2 = mockk<Promise>(relaxed = true)
+
+        module.open("a", "https://app.dynamicauth.com/x", p1)
+        module.open("b", "https://app.dynamicauth.com/y", p2)
+        idleMain() // run the posted opens → two live hosts
+
+        module.invalidate()
+        idleMain() // run the posted close-all; the .toList() snapshot avoids CME
+
+        // Both hosts torn down (cancelled) proves the iteration completed across
+        // >1 host — without the snapshot this throws ConcurrentModificationException.
+        verify { p1.reject("webview_cancelled", any<String>(), any<WritableMap>()) }
+        verify { p2.reject("webview_cancelled", any<String>(), any<WritableMap>()) }
+    }
+
+    // endregion
+
+    // region emitMessage payload mapping (#13 — array payloads)
+
+    @Test
+    fun putBridgeData_mapsArrayPayloadOntoDataField() {
+        val target = JavaOnlyMap()
+        putBridgeData(target, JavaOnlyArray().apply { pushString("x") })
+        assertEquals(ReadableType.Array, target.getType("data"))
+    }
+
+    @Test
+    fun putBridgeData_mapsMapStringNullAndUnknownFallthrough() {
+        val map = JavaOnlyMap()
+
+        putBridgeData(map, JavaOnlyMap())
+        assertEquals(ReadableType.Map, map.getType("data"))
+
+        putBridgeData(map, "s")
+        assertEquals(ReadableType.String, map.getType("data"))
+
+        putBridgeData(map, null)
+        assertEquals(ReadableType.Null, map.getType("data"))
+
+        putBridgeData(map, 42)
+        assertEquals(ReadableType.Null, map.getType("data"))
+    }
+
+    // endregion
+
+    // region pre-listener event buffering (F4 — handshake not dropped)
+
+    // Drives a bridge message into the host's WebMessageListener so it flows
+    // through onBridgeMessage -> onMessage -> module.emitMessage.
+    private fun deliverBridgeMessage(payload: String) {
+        listenerSlot.captured.onPostMessage(
+            webSlot.captured,
+            mockk<WebMessageCompat> { every { data } returns payload },
+            Uri.parse("https://app.dynamicauth.com"),
+            true,
+            mockk<JavaScriptReplyProxy>(relaxed = true),
+        )
+    }
+
+    @Test
+    fun emitMessage_buffersBeforeFirstListenerThenFlushesOnSubscribe() {
+        module.open("a", "https://app.dynamicauth.com/x", mockk(relaxed = true))
+        idleMain()
+
+        // Handshake arrives before any JS listener subscribed → must be buffered,
+        // not emitted (RCTDeviceEventEmitter.emit would otherwise drop it).
+        deliverBridgeMessage("{\"type\":\"iframe-ready\"}")
+        verify(exactly = 0) { eventEmitter.emit(any(), any()) }
+
+        // First subscriber attaches → buffered event flushes.
+        module.addListener(DynamicWebViewModule.MESSAGE_EVENT_NAME)
+        verify { eventEmitter.emit(DynamicWebViewModule.MESSAGE_EVENT_NAME, any()) }
+    }
+
+    @Test
+    fun emitMessage_emitsDirectlyAfterListenerAttached() {
+        module.open("a", "https://app.dynamicauth.com/x", mockk(relaxed = true))
+        idleMain()
+        module.addListener(DynamicWebViewModule.MESSAGE_EVENT_NAME)
+
+        deliverBridgeMessage("{\"type\":\"sign\"}")
+
+        verify { eventEmitter.emit(DynamicWebViewModule.MESSAGE_EVENT_NAME, any()) }
+    }
+
+    // endregion
+}

package/dist/{InvalidParamError-Crwntjl7.native.esm.js → InvalidParamError-BKnC9rcJ.esm.js}

@@ -1,11 +1,11 @@
-import { AuthStorageEnum, Configuration, SDKApi, isDeviceNonceSignatureRequiredForUrl } from "@dynamic-labs/sdk-api-core";
+import { AuthStorageEnum, Configuration, JwtVerifiedCredentialFormatEnum, SDKApi, WalletProviderEnum, isDeviceNonceSignatureRequiredForUrl } from "@dynamic-labs/sdk-api-core";
 
 //#region package.json
 var name = "@dynamic-labs-sdk/client";
-var version = "1.7.0";
+var version = "1.8.1";
 var dependencies = {
 	"@dynamic-labs-sdk/assert-package-version": "workspace:*",
-	"@dynamic-labs-wallet/browser-wallet-client": "1.0.7",
+	"@dynamic-labs-wallet/browser-wallet-client": "1.0.16",
 	"@dynamic-labs-wallet/forward-mpc-client": "0.10.1",
 	"@dynamic-labs/sdk-api-core": "catalog:",
 	"@simplewebauthn/browser": "13.1.0",
@@ -139,15 +139,14 @@ const DYNAMIC_SDK_SESSION_ID_HEADER = "x-dyn-session-id";
 const CLIENT_SDK_NAME = "ClientSDK";
 
 //#endregion
-//#region src/utils/randomString/randomString.native.ts
+//#region src/utils/randomString/randomString.ts
 const DEFAULT_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 /** @not-instrumented */
 const randomString = ({ chars = DEFAULT_CHARS, length }) => {
-	/**
-	* React native does not include crypto.getRandomValues, so we use Math.random instead.
-	*/
+	const bytes = new Uint8Array(length);
+	crypto.getRandomValues(bytes);
 	let result = "";
-	for (let i = 0; i < length; i++) result += chars[Math.floor(Math.random() * chars.length)];
+	for (let i = 0; i < length; i++) result += chars[bytes[i] % chars.length];
 	return result;
 };
 
@@ -1017,6 +1016,152 @@ const fetchAndStoreNonces = async (client) => {
 	});
 };
 
+//#endregion
+//#region src/utils/setCookie/setCookie.ts
+/**
+* Sefelly sets the cookie in the browser.
+* @not-instrumented
+*/
+const setCookie = (cookie) => {
+	document.cookie = cookie;
+};
+
+//#endregion
+//#region src/modules/clientEvents/clientEvents.ts
+/**
+* Adds an event listener for Dynamic client events.
+*
+* This function allows you to listen for various events emitted by the Dynamic client,
+* such as authentication state changes, wallet connections, and more.
+*
+* @param params.event - The event name to listen for.
+* @param params.listener - The callback function to execute when the event is fired.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A function that can be called to remove the listener.
+* @not-instrumented
+*/
+const onEvent = ({ event, listener }, client = getDefaultClient()) => {
+	const { eventEmitter } = getCore(client);
+	eventEmitter.on(event, listener);
+	return () => {
+		eventEmitter.off(event, listener);
+	};
+};
+/**
+* Removes an event listener from Dynamic client events.
+*
+* This function unsubscribes a previously registered event listener
+* from the specified Dynamic client event.
+*
+* @param params.event - The event name to remove the listener from.
+* @param params.listener - The callback function to remove.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @not-instrumented
+*/
+const offEvent = ({ event, listener }, client = getDefaultClient()) => {
+	const { eventEmitter } = getCore(client);
+	eventEmitter.off(event, listener);
+};
+/**
+* Adds a one-time event listener for Dynamic client events.
+*
+* This function listens for an event that will automatically remove itself
+* after being triggered once.
+*
+* @param params.event - The event name to listen for.
+* @param params.listener - The callback function to execute when the event is fired.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A function that can be called to remove the listener before it fires.
+* @not-instrumented
+*/
+const onceEvent = ({ event, listener }, client = getDefaultClient()) => {
+	const { eventEmitter } = getCore(client);
+	eventEmitter.once(event, listener);
+	return () => {
+		eventEmitter.off(event, listener);
+	};
+};
+/**
+* Emits a Dynamic client event.
+*
+* This function triggers an event that will be received by all registered
+* listeners for the specified event type.
+*
+* @param params.event - The event name to emit.
+* @param params.args - The arguments to pass to event listeners.
+* @param client - The Dynamic client instance.
+* @not-instrumented
+*/
+const emitEvent = ({ event, args }, client) => {
+	const { eventEmitter } = getCore(client);
+	eventEmitter.emit(event, args);
+};
+
+//#endregion
+//#region src/errors/InvalidWalletProviderKeyError.ts
+var InvalidWalletProviderKeyError = class extends BaseError {
+	constructor(value) {
+		super({
+			cause: null,
+			code: "invalid_wallet_provider_key",
+			docsUrl: null,
+			name: "InvalidWalletProviderKeyError",
+			shortMessage: `Invalid wallet provider key: ${value}. Key must be in the format of <normalizedWalletNameWithChain>:<walletProviderType>[:<suffix>]`
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/wallets/walletProvider/splitWalletProviderKey/splitWalletProviderKey.ts
+/** @not-instrumented */
+const splitWalletProviderKey = (walletProviderKey) => {
+	const [normalizedWalletNameWithChain, walletProviderType, suffix, ...rest] = walletProviderKey.split(":");
+	if (!normalizedWalletNameWithChain || !Object.values(WalletProviderEnum).includes(walletProviderType) || rest.length > 0) throw new InvalidWalletProviderKeyError(walletProviderKey);
+	return {
+		normalizedWalletNameWithChain,
+		suffix,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/modules/wallets/utils/normalizeAddress/normalizeAddress.ts
+/** @not-instrumented */
+const normalizeAddress = ({ address, chain }) => {
+	let normalizedAddress = address;
+	if (normalizedAddress?.startsWith("0x")) normalizedAddress = normalizedAddress.slice(2);
+	normalizedAddress = ["EVM", "FLOW"].includes(chain) ? normalizedAddress?.toLowerCase() : normalizedAddress;
+	return normalizedAddress;
+};
+
+//#endregion
+//#region src/modules/wallets/utils/formatWalletAccountId/formatWalletAccountId.ts
+/** @not-instrumented */
+const formatWalletAccountId = ({ address, chain, walletProviderKey }) => {
+	const { normalizedWalletNameWithChain } = splitWalletProviderKey(walletProviderKey);
+	return `${normalizedWalletNameWithChain}:${normalizeAddress({
+		address,
+		chain
+	})}`;
+};
+
+//#endregion
+//#region src/modules/wallets/utils/convertUnverifiedWalletAccountToWalletAccount/convertUnverifiedWalletAccountToWalletAccount.ts
+/** @not-instrumented */
+const convertUnverifiedWalletAccountToWalletAccount = ({ unverifiedWalletAccount }) => ({
+	address: unverifiedWalletAccount.address,
+	addressesWithTypes: unverifiedWalletAccount.addressesWithTypes,
+	chain: unverifiedWalletAccount.chain,
+	id: formatWalletAccountId({
+		address: unverifiedWalletAccount.address,
+		chain: unverifiedWalletAccount.chain,
+		walletProviderKey: unverifiedWalletAccount.walletProviderKey
+	}),
+	lastSelectedAt: unverifiedWalletAccount.lastSelectedAt,
+	verifiedCredentialId: null,
+	walletProviderKey: unverifiedWalletAccount.walletProviderKey
+});
+
 //#endregion
 //#region src/modules/wallets/constants.ts
 const CHAINS_INFO_MAP = {
@@ -1120,6 +1265,292 @@ const getChainFromVerifiedCredentialChain = (verifiedCredentialChain) => {
 	return chain;
 };
 
+//#endregion
+//#region src/modules/wallets/utils/normalizeWalletNameWithChain/normalizeWalletNameWithChain.ts
+/**
+* Format the raw wallet name and chain to get the value we can use for
+* verified credentials' `walletName` field.
+* @not-instrumented
+*/
+const normalizeWalletNameWithChain = ({ displayName, chain }) => {
+	const sanitizedWalletName = displayName.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+	const chainLowered = chain.toLocaleLowerCase();
+	if (sanitizedWalletName.endsWith(chainLowered)) return sanitizedWalletName;
+	return `${sanitizedWalletName}${chainLowered}`;
+};
+
+//#endregion
+//#region src/modules/wallets/utils/formatWalletProviderKey/formatWalletProviderKey.ts
+/**
+* Assembles the wallet provider key from the wallet name, chain, and wallet provider type.
+*
+* The suffix is optional and can be used to add a uniquely identifying string to the key, which
+* might be necessary for some wallet providers (like Wallet Connect).
+*
+* IMPORTANT: Do NOT add a suffix unless absolutely necessary, as it will cause the wallet account
+* to not be able to find its wallet provider when connecting to a new device (it won't be possible
+* to determine the full key just from the Verified Credential data).
+* @not-instrumented
+*/
+const formatWalletProviderKey = ({ suffix, chain, displayName, walletProviderType }) => {
+	return `${normalizeWalletNameWithChain({
+		chain,
+		displayName
+	})}:${walletProviderType}${suffix ? `:${suffix}` : ""}`;
+};
+
+//#endregion
+//#region src/modules/wallets/walletProvider/walletProviderKeyMap/getWalletProviderKeyFromVerifiedCredential/getWalletProviderKeyFromVerifiedCredential.ts
+/** @not-instrumented */
+const getWalletProviderKeyFromVerifiedCredential = ({ verifiedCredential }, client) => {
+	const { walletProviderKeyMap } = getCore(client).state.get();
+	const storedWalletProviderKey = walletProviderKeyMap[verifiedCredential.id];
+	if (storedWalletProviderKey) return { walletProviderKey: storedWalletProviderKey };
+	/**
+	* We fallback to comprising the wallet provider key from walletName and walletProvider.
+	*
+	* Some wallet provider types (like Wallet Connect) also use a special suffix for their wallet provider
+	* keys, so this won't be enough for them.
+	* Therefore, for those specific wallet providers, the wallet account will remain without a wallet provider
+	* and will require reconnection.
+	* Read walletProvider.types.ts for more info.
+	*/
+	assertDefined(verifiedCredential.walletName, `Failed to get wallet provider for verified credential with ID ${verifiedCredential.id}: missing walletName`);
+	assertDefined(verifiedCredential.walletProvider, `Failed to get wallet provider for verified credential with ID ${verifiedCredential.id}: missing walletProvider`);
+	assertDefined(verifiedCredential.chain, `Failed to get wallet provider for verified credential with ID ${verifiedCredential.id}: missing chain`);
+	return { walletProviderKey: formatWalletProviderKey({
+		chain: getChainFromVerifiedCredentialChain(verifiedCredential.chain),
+		displayName: verifiedCredential.walletName,
+		walletProviderType: verifiedCredential.walletProvider
+	}) };
+};
+
+//#endregion
+//#region src/modules/wallets/utils/convertVerifiedCredentialToWalletAccount/convertVerifiedCredentialToWalletAccount.ts
+/** @not-instrumented */
+const convertVerifiedCredentialToWalletAccount = ({ verifiedCredential }, client) => {
+	assertDefined(verifiedCredential.address, "Missing address in verified credential");
+	assertDefined(verifiedCredential.chain, "Missing chain in verified credential");
+	const chain = getChainFromVerifiedCredentialChain(verifiedCredential.chain);
+	const { walletProviderKey } = getWalletProviderKeyFromVerifiedCredential({ verifiedCredential }, client);
+	const walletAccountId = formatWalletAccountId({
+		address: verifiedCredential.address,
+		chain,
+		walletProviderKey
+	});
+	return {
+		address: verifiedCredential.address,
+		addressesWithTypes: verifiedCredential.walletAdditionalAddresses,
+		chain,
+		hardwareWalletVendor: verifiedCredential.walletProperties?.hardwareWallet,
+		id: walletAccountId,
+		lastSelectedAt: verifiedCredential.lastSelectedAt ?? null,
+		verifiedCredentialId: verifiedCredential.id,
+		walletProviderKey
+	};
+};
+
+//#endregion
+//#region src/modules/wallets/getWalletAccounts/getWalletAccountsFromState/getWalletAccountsFromState.ts
+/** @not-instrumented */
+const getWalletAccountsFromState = ({ unverifiedWalletAccounts, user }, client) => {
+	const walletAccountsMap = /* @__PURE__ */ new Map();
+	/**
+	* Handle the unverified wallet accounts before the user verified credentials
+	* so the later verified wallet accounts can override the unverified wallet accounts
+	*/
+	unverifiedWalletAccounts.forEach((unverifiedWalletAccount) => {
+		const walletAccount = convertUnverifiedWalletAccountToWalletAccount({ unverifiedWalletAccount });
+		walletAccountsMap.set(walletAccount.id, walletAccount);
+	});
+	(user?.verifiedCredentials ?? []).filter((verified) => verified.format === JwtVerifiedCredentialFormatEnum.Blockchain).forEach((verifiedWalletAccount) => {
+		const walletAccount = convertVerifiedCredentialToWalletAccount({ verifiedCredential: verifiedWalletAccount }, client);
+		walletAccountsMap.set(walletAccount.id, walletAccount);
+	});
+	return Array.from(walletAccountsMap.values());
+};
+
+//#endregion
+//#region src/modules/wallets/getWalletAccounts/getWalletAccounts.ts
+/**
+* Retrieves all wallet accounts associated with the current session.
+*
+* This function returns both verified and unverified wallet accounts,
+* combining data from user credentials and local unverified accounts.
+* You can differentiate between verified and unverified wallet accounts by
+* checking the `verifiedCredentialId` property.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns An array of wallet accounts associated with the session.
+* @not-instrumented
+*/
+const getWalletAccounts = (client = getDefaultClient()) => {
+	const { unverifiedWalletAccounts, user } = getCore(client).state.get();
+	return getWalletAccountsFromState({
+		unverifiedWalletAccounts,
+		user
+	}, client);
+};
+
+//#endregion
+//#region src/errors/NoWalletProviderFoundError.ts
+var NoWalletProviderFoundError = class extends BaseError {
+	constructor({ walletProviderKey }) {
+		super({
+			cause: null,
+			code: "no_wallet_provider_found_error",
+			docsUrl: null,
+			name: "NoWalletProviderFoundError",
+			shortMessage: `No wallet provider found with key: ${walletProviderKey}`
+		});
+	}
+};
+
+//#endregion
+//#region src/services/runtimeServices/createRuntimeServiceAccessKey/createRuntimeServiceAccessKey.ts
+/**
+* Creates a service accessor function that manages service instantiation and caching.
+* The returned function will either retrieve an existing service from the registry or
+* create a new one using the provided builder function.
+*
+* @template - The type of service to be created/accessed
+* @param key - Unique identifier for the service in the registry
+* @param builder - Function that creates the service instance when called with a DynamicClient
+* @not-instrumented
+*/
+const createRuntimeServiceAccessKey = (key, builder) => (client) => {
+	const { runtimeServices } = getCore(client);
+	const currentService = runtimeServices.getByKey(key);
+	if (currentService) return currentService;
+	const service = builder(client);
+	runtimeServices.register(key, service);
+	return service;
+};
+
+//#endregion
+//#region src/modules/wallets/walletProviderRegistry/createWalletProviderRegistry/createWalletProviderRegistry.ts
+/**
+* Creates a new wallet provider registry that manages wallet providers with priority-based registration.
+*
+* @returns The wallet provider registry instance
+*
+* @example
+* ```typescript
+* const registry = createWalletProviderRegistry();
+*
+* registry.register({
+*   priority: WalletProviderPriority.WALLET_SDK,
+*   walletProvider: myWalletProvider
+* });
+*
+* const provider = registry.getByKey('my-wallet-key');
+* const providers = registry.listProviders();
+* ```
+* @not-instrumented
+*/
+const createWalletProviderRegistry = (client) => {
+	const registry = /* @__PURE__ */ new Map();
+	return {
+		getByKey: (key) => registry.get(key)?.walletProvider,
+		listProviderEntries: () => Array.from(registry.values()),
+		listProviders: () => Array.from(registry.values()).map((v) => v.walletProvider),
+		register: (args) => {
+			const existingEntry = registry.get(args.walletProvider.key);
+			if (existingEntry) {
+				if (existingEntry.priority < args.priority) {
+					registry.set(args.walletProvider.key, args);
+					emitEvent({
+						args: { walletProviderKey: args.walletProvider.key },
+						event: "walletProviderChanged"
+					}, client);
+				}
+			} else {
+				registry.set(args.walletProvider.key, args);
+				emitEvent({
+					args: { walletProvider: args.walletProvider },
+					event: "walletProviderRegistered"
+				}, client);
+				emitEvent({
+					args: { walletProviderKey: args.walletProvider.key },
+					event: "walletProviderChanged"
+				}, client);
+			}
+		},
+		unregister: (key) => {
+			registry.delete(key);
+			emitEvent({
+				args: { walletProviderKey: key },
+				event: "walletProviderUnregistered"
+			}, client);
+		}
+	};
+};
+
+//#endregion
+//#region src/modules/wallets/walletProviderRegistry/getWalletProviderRegistry/getWalletProviderRegistry.ts
+/**
+* This function provides access to a shared instance of the wallet provider registry.
+*
+* It ensures that the same registry instance is used throughout the client to maintaining
+* consistency of registered wallet providers across different parts of the codebase.
+*
+* @returns The wallet provider registry instance
+*
+* @example
+* ```typescript
+* // Get the registry instance
+* const registry = getWalletProviderRegistry();
+*
+* // Register a wallet provider
+* registry.register({
+*   priority: WalletProviderPriority.WALLET_SDK,
+*   walletProvider: myWalletProvider
+* });
+*
+* // Retrieve a specific provider
+* const provider = registry.getByKey('metamaskevm');
+* ```
+*/
+const getWalletProviderRegistry = createRuntimeServiceAccessKey("walletProviderRegistry", (client) => createWalletProviderRegistry(client));
+
+//#endregion
+//#region src/modules/wallets/walletProviderRegistry/walletProviderRegistry.types.ts
+let WalletProviderPriority = /* @__PURE__ */ function(WalletProviderPriority$1) {
+	/**
+	* Highest priority should be used by wallet providers that implement
+	* the most reliable wallet integration.
+	* example: The SDK provided by the wallet provider.
+	*/
+	WalletProviderPriority$1[WalletProviderPriority$1["WALLET_SDK"] = 100] = "WALLET_SDK";
+	/**
+	* Medium priority should be used by wallet providers that implement
+	* a wallet integration via some reliable standard.
+	* example: A wallet provider that uses EIP6963 announcement.
+	*/
+	WalletProviderPriority$1[WalletProviderPriority$1["WALLET_SELF_ANNOUNCEMENT_STANDARD"] = 50] = "WALLET_SELF_ANNOUNCEMENT_STANDARD";
+	/**
+	* Low priority should be used by wallet providers that implement
+	* a wallet integration on a less reliable standard.
+	* example: A wallet provider that uses window.ethereum, where the
+	* window key can be overridden by other extensions.
+	*/
+	WalletProviderPriority$1[WalletProviderPriority$1["WINDOW_INJECT"] = 20] = "WINDOW_INJECT";
+	return WalletProviderPriority$1;
+}({});
+
+//#endregion
+//#region src/modules/wallets/utils/getWalletProviderFromWalletAccount/getWalletProviderFromWalletAccount.ts
+/** @not-instrumented */
+const getWalletProviderFromWalletAccount = ({ walletAccount }, client) => {
+	const walletProvider = getWalletProviderRegistry(client).getByKey(walletAccount.walletProviderKey);
+	if (!walletProvider) throw new NoWalletProviderFoundError({ walletProviderKey: walletAccount.walletProviderKey });
+	return walletProvider;
+};
+
+//#endregion
+//#region src/modules/auth/consts.ts
+const DYNAMIC_AUTH_COOKIE_NAME = "DYNAMIC_JWT_TOKEN";
+
 //#endregion
 //#region src/constants.ts
 const SDK_API_CORE_VERSION = dependencies["@dynamic-labs/sdk-api-core"];
@@ -1150,5 +1581,5 @@ var InvalidParamError = class extends BaseError {
 };
 
 //#endregion
-export { getUserAgent as A, getCore as B, isCookieEnabled as C, instrumentFunction as D, __getElevatedAccessToken_wrapped as E, NONCE_POOL_SIZE as F, version as H, getDefaultClient as I, setDefaultClient as L, randomString as M, CLIENT_SDK_NAME as N, scrubParameters as O, DYNAMIC_SDK_API_VERSION as P, ClientNotFoundError as R, getSessionKeys as S, ValueMustBeDefinedError as T, name as V, MfaRateLimitedError as _, DYNAMIC_ICONIC_SPRITE_URL as a, InvalidExternalAuthError as b, CHAINS_INFO_MAP as c, UnauthorizedError as d, createDeviceSignatureHeadersMiddleware as f, SandboxMaximumThresholdReachedError as g, getNonce as h, DYNAMIC_WAAS_METADATA as i, extractSessionId as j, DEFAULT_PII_FIELDS as k, fetchAndStoreNonces as l, getDeviceSigner as m, DEFAULT_WAAS_BASE_API_URL as n, SDK_API_CORE_VERSION as o, getHeadersForNonceSignedByDeviceSigners as p, DEFAULT_WAAS_BASE_MPC_RELAY_API_URL as r, getChainFromVerifiedCredentialChain as s, InvalidParamError as t, createApiClient as u, MfaInvalidOtpError as v, assertDefined as w, APIError as x, LinkCredentialError as y, BaseError as z };
-//# sourceMappingURL=InvalidParamError-Crwntjl7.native.esm.js.map
+export { DYNAMIC_SDK_API_VERSION as $, UnauthorizedError as A, APIError as B, emitEvent as C, setCookie as D, onceEvent as E, SandboxMaximumThresholdReachedError as F, __getElevatedAccessToken_wrapped as G, isCookieEnabled as H, MfaRateLimitedError as I, DEFAULT_PII_FIELDS as J, instrumentFunction as K, MfaInvalidOtpError as L, getHeadersForNonceSignedByDeviceSigners as M, getDeviceSigner as N, fetchAndStoreNonces as O, getNonce as P, CLIENT_SDK_NAME as Q, LinkCredentialError as R, InvalidWalletProviderKeyError as S, onEvent as T, assertDefined as U, getSessionKeys as V, ValueMustBeDefinedError as W, extractSessionId as X, getUserAgent as Y, randomString as Z, getChainFromVerifiedCredentialChain as _, DYNAMIC_ICONIC_SPRITE_URL as a, getCore as at, normalizeAddress as b, getWalletProviderFromWalletAccount as c, createRuntimeServiceAccessKey as d, NONCE_POOL_SIZE as et, NoWalletProviderFoundError as f, normalizeWalletNameWithChain as g, formatWalletProviderKey as h, DYNAMIC_WAAS_METADATA as i, BaseError as it, createDeviceSignatureHeadersMiddleware as j, createApiClient as k, WalletProviderPriority as l, getWalletAccountsFromState as m, DEFAULT_WAAS_BASE_API_URL as n, setDefaultClient as nt, SDK_API_CORE_VERSION as o, name as ot, getWalletAccounts as p, scrubParameters as q, DEFAULT_WAAS_BASE_MPC_RELAY_API_URL as r, ClientNotFoundError as rt, DYNAMIC_AUTH_COOKIE_NAME as s, version as st, InvalidParamError as t, getDefaultClient as tt, getWalletProviderRegistry as u, CHAINS_INFO_MAP as v, offEvent as w, splitWalletProviderKey as x, formatWalletAccountId as y, InvalidExternalAuthError as z };
+//# sourceMappingURL=InvalidParamError-BKnC9rcJ.esm.js.map