@dynamic-labs-sdk/client 1.6.0 → 1.8.0

package/dist/{getNetworkProviderFromNetworkId-B7DIqT2T.native.esm.js → getNetworkProviderFromNetworkId-DVmF7pH2.native.esm.js}

@@ -1,12 +1,154 @@
-import { $ as instrumentFunction, D as CHAINS_INFO_MAP, S as getWalletAccounts, T as normalizeWalletNameWithChain, X as assertDefined, c as createApiClient, ct as getDefaultClient, dt as BaseError, f as getWalletProviderFromWalletAccount, ft as getCore, h as createRuntimeServiceAccessKey } from "./InvalidParamError-BIptAjbC.native.esm.js";
-import { f as checkAndRaiseWalletAccountsChangedEvent, p as emitWalletAccountsChangedEvent } from "./getVerifiedCredentialForWalletAccount-CLyC2nOl.native.esm.js";
-import { i as NativeModuleNotLinkedError } from "./isMfaRequiredForAction-B2vKX31S.native.esm.js";
+import { B as getCore, C as isCookieEnabled, D as instrumentFunction, I as getDefaultClient, N as CLIENT_SDK_NAME, c as CHAINS_INFO_MAP, u as createApiClient, w as assertDefined, z as BaseError } from "./InvalidParamError-Bc6OZBog.native.esm.js";
+import { D as emitEvent, S as normalizeWalletNameWithChain, b as getWalletAccounts, f as checkAndRaiseWalletAccountsChangedEvent, h as getWalletProviderFromWalletAccount, j as setCookie, m as DYNAMIC_AUTH_COOKIE_NAME, p as emitWalletAccountsChangedEvent, v as createRuntimeServiceAccessKey } from "./getVerifiedCredentialForWalletAccount-BVrGV8qf.native.esm.js";
+import { i as NativeModuleNotLinkedError } from "./isMfaRequiredForAction-DQDoPsi6.native.esm.js";
 import { AuthModeEnum } from "@dynamic-labs/sdk-api-core";
 import * as z from "zod/mini";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { getGenericPassword, resetGenericPassword, setGenericPassword } from "react-native-keychain";
 import { Buffer as Buffer$1 } from "buffer";
 import EventEmitter, { EventEmitter as EventEmitter$1 } from "eventemitter3";
 import { TurboModuleRegistry } from "react-native";
 
+//#region src/utils/isEqualShallow/isEqualShallow.ts
+/**
+* Shallow compare two objects.
+*
+* Source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+* @not-instrumented
+*/
+const isEqualShallow = (objA, objB) => {
+	if (Object.is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return objA === objB;
+	if (objA instanceof Map && objB instanceof Map) {
+		if (objA.size !== objB.size) return false;
+		for (const [key, value] of objA) if (!Object.is(value, objB.get(key))) return false;
+		return true;
+	}
+	if (objA instanceof Set && objB instanceof Set) {
+		if (objA.size !== objB.size) return false;
+		for (const value of objA) if (!objB.has(value)) return false;
+		return true;
+	}
+	const keysA = Object.keys(objA);
+	if (keysA.length !== Object.keys(objB).length) return false;
+	for (const keyA of keysA) if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) return false;
+	if (objA.constructor !== objB.constructor) return false;
+	return true;
+};
+
+//#endregion
+//#region src/utils/observable/subscribeWithSelector/subscribeWithSelector.ts
+/**
+* Allows subscribing to a slice of the state.
+* The slice is a computation of the states.
+*
+* The callback will only be called when the slice has changed.
+* Change is determined by shallow comparison.
+*
+* Returns a function to unsubscribe the callback.
+* @not-instrumented
+*/
+const subscribeWithSelector = (observable, selector) => (callback) => {
+	let lastSlice = selector(observable.get());
+	return observable.subscribe((value) => {
+		const nextSlice = selector(value);
+		if (isEqualShallow(nextSlice, lastSlice)) return;
+		lastSlice = nextSlice;
+		callback(nextSlice);
+	});
+};
+
+//#endregion
+//#region src/utils/retryOnFail/InvalidRetryOnFailCallError.ts
+/**
+* This error is thrown when the `retryOnFail` function is called with an invalid
+* number of retries (i.e. less than 0).
+*/
+var InvalidRetryOnFailCallError = class extends BaseError {
+	constructor(maxRetries) {
+		super({
+			cause: null,
+			code: "invalid_retry_on_fail_call_error",
+			docsUrl: null,
+			name: "InvalidRetryOnFailCallError",
+			shortMessage: `Invalid retries parameter for retryOnFail call: ${maxRetries}`
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/retryOnFail/retryOnFail.ts
+/** @not-instrumented */
+const retryOnFail = async ({ delay = 0, fn, maxRetries }) => {
+	for (let retry = 0; retry <= maxRetries; retry++) try {
+		return await fn();
+	} catch (error) {
+		if (retry >= maxRetries) throw error;
+		if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	/**
+	* Reaching this point should never happen and this
+	* error is thrown to help us debug the issue.
+	*/
+	throw new InvalidRetryOnFailCallError(maxRetries);
+};
+
+//#endregion
+//#region src/modules/auth/isSignedIn/isSignedIn.ts
+/**
+* Checks if the user is currently signed in to the Dynamic client.
+*
+* The client is considered to be in a signed in state if a user has
+* authenticated or if the client has at least one wallet connected.
+*
+* @deprecated What counts as "signed in" is your app's business logic, not the
+* SDK's. This helper bakes in one opinion (a user OR any connected wallet),
+* which rarely matches every app and forces a dependency on us for every
+* variation. Compose your own check from the underlying primitives instead —
+* e.g. `Boolean(client.user) || isAnyWalletAccountConnected(client)` — and
+* layer in whatever your app requires (device registration, completed
+* onboarding, satisfied MFA, a required embedded wallet, …). See the
+* "Check if signed in" guide:
+* https://www.dynamic.xyz/docs/javascript/user-session-management
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True if the user is signed in, false otherwise.
+* @not-instrumented
+*/
+const isSignedIn = (client = getDefaultClient()) => Boolean(client.user || getWalletAccounts(client).length > 0);
+
+//#endregion
+//#region src/services/storage/createLocalStorageAdapter/createLocalStorageAdapter.native.ts
+const NAMESPACE = "dynamic";
+const namespaceKey = (key) => `${NAMESPACE}:${key}`;
+/**
+* Creates a localStorage adapter for React Native.
+* Routes operations based on the `storageTier` option:
+* - `'default'`: uses AsyncStorage
+* - `'secure'`: uses react-native-keychain
+* @not-instrumented
+*/
+const createLocalStorageAdapter = () => {
+	return {
+		getItem: async (key, options) => {
+			if (options.storageTier === "secure") {
+				const result = await getGenericPassword({ service: key });
+				if (!result) return null;
+				return result.password;
+			} else return AsyncStorage.getItem(namespaceKey(key));
+		},
+		removeItem: async (key, options) => {
+			if (options.storageTier === "secure") await resetGenericPassword({ service: key });
+			else await AsyncStorage.removeItem(namespaceKey(key));
+		},
+		setItem: async (key, value, options) => {
+			if (options.storageTier === "secure") await setGenericPassword(key, value, { service: key });
+			else await AsyncStorage.setItem(namespaceKey(key), value);
+		}
+	};
+};
+
+//#endregion
 //#region src/errors/InvalidStorageSet.ts
 var InvalidStorageSet = class extends BaseError {
 	constructor({ key, value }) {
@@ -105,54 +247,183 @@ const createStorage = ({ prefix = "", storageAdapter }) => {
 };
 
 //#endregion
-//#region src/utils/isEqualShallow/isEqualShallow.ts
+//#region src/services/storage/createStorageKeySchema/createStorageKeySchema.ts
+/** @not-instrumented */
+const createStorageKeySchema = (params) => {
+	return params;
+};
+
+//#endregion
+//#region src/modules/projectSettings/fetchProjectSettings/projectSettingsExpirationScheme.ts
 /**
-* Shallow compare two objects.
+* The schema to track the expiration time of the project settings.
+*/
+const projectSettingsExpirationStorageKeySchema = createStorageKeySchema({
+	key: "projectSettingsExpiration",
+	schema: z.number()
+});
+
+//#endregion
+//#region src/modules/projectSettings/fetchProjectSettings/fetchProjectSettings.ts
+/**
+* Expiration time of the project settings in milliseconds.
+*/
+const PROJECT_SETTINGS_EXPIRATION_TIME = 1e3 * 60 * 5;
+/**
+* Fetches and updates the project settings from the API.
 *
-* Source: https://github.com/pmndrs/zustand/blob/main/src/vanilla/shallow.ts
+* This function retrieves the latest project configuration settings
+* from Dynamic's servers, including authentication options, enabled chains,
+* and security configurations. The settings are cached for performance.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns A promise that resolves to the updated project settings.
 * @not-instrumented
 */
-const isEqualShallow = (objA, objB) => {
-	if (Object.is(objA, objB)) return true;
-	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return objA === objB;
-	if (objA instanceof Map && objB instanceof Map) {
-		if (objA.size !== objB.size) return false;
-		for (const [key, value] of objA) if (!Object.is(value, objB.get(key))) return false;
-		return true;
-	}
-	if (objA instanceof Set && objB instanceof Set) {
-		if (objA.size !== objB.size) return false;
-		for (const value of objA) if (!objB.has(value)) return false;
-		return true;
-	}
-	const keysA = Object.keys(objA);
-	if (keysA.length !== Object.keys(objB).length) return false;
-	for (const keyA of keysA) if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) return false;
-	if (objA.constructor !== objB.constructor) return false;
-	return true;
+const fetchProjectSettings = async (client = getDefaultClient()) => {
+	const core = getCore(client);
+	const currentExpiration = await core.storage.getItem(projectSettingsExpirationStorageKeySchema);
+	if (Boolean(client.projectSettings) && !(currentExpiration && currentExpiration < Date.now()) && isSignedIn(client)) return client.projectSettings;
+	const apiClient = createApiClient({}, client);
+	core.logger.debug("[fetchProjectSettings] Fetching project settings...");
+	const doFetch = async () => apiClient.getEnvironmentSettings({
+		environmentId: core.environmentId,
+		sdkVersion: `${CLIENT_SDK_NAME}/${core.version}`
+	}, { credentials: "omit" });
+	const projectSettings = await retryOnFail({
+		fn: doFetch,
+		maxRetries: 2
+	});
+	core.state.set({ projectSettings: projectSettings ?? null });
+	await core.storage.setItem(projectSettingsExpirationStorageKeySchema, Date.now() + PROJECT_SETTINGS_EXPIRATION_TIME);
+	return projectSettings;
 };
 
 //#endregion
-//#region src/utils/observable/subscribeWithSelector/subscribeWithSelector.ts
+//#region src/modules/sessionKeys/generateSessionKeys/generateSessionKeys.ts
+/** @not-instrumented */
+const generateSessionKeys = async (client) => {
+	const core = getCore(client);
+	await core.keychain.removeKey("session");
+	const publicKey = await core.keychain.generateKey("session");
+	assertDefined(publicKey, "Public key not found");
+	core.state.set({ sessionKeys: publicKey });
+	return { publicKey };
+};
+
+//#endregion
+//#region src/modules/wallets/utils/getAvailableWalletProvidersFromWalletAccounts/getAvailableWalletProvidersFromWalletAccounts.ts
+/** @not-instrumented */
+const getAvailableWalletProvidersFromWalletAccounts = (client) => {
+	const core = getCore(client);
+	const walletProvidersMap = /* @__PURE__ */ new Map();
+	getWalletAccounts(client).forEach((walletAccount) => {
+		if (walletProvidersMap.has(walletAccount.walletProviderKey)) return;
+		try {
+			const walletProvider = getWalletProviderFromWalletAccount({ walletAccount }, client);
+			walletProvidersMap.set(walletAccount.walletProviderKey, walletProvider);
+		} catch (error) {
+			core.logger.debug("Wallet provider not found for wallet account", {
+				error,
+				walletAccount: walletAccount.address
+			});
+		}
+	});
+	return Array.from(walletProvidersMap.values());
+};
+
+//#endregion
+//#region src/modules/wallets/destroyWalletProviders/destroyWalletProviders.ts
 /**
-* Allows subscribing to a slice of the state.
-* The slice is a computation of the states.
+* Tear down every wallet provider on the client.
 *
-* The callback will only be called when the slice has changed.
-* Change is determined by shallow comparison.
+* Each provider's `destroy` is responsible for its own local + remote
+* cleanup. We swallow errors so a failing destroy on one provider does not
+* block teardown of the others (e.g. during logout).
 *
-* Returns a function to unsubscribe the callback.
 * @not-instrumented
 */
-const subscribeWithSelector = (observable, selector) => (callback) => {
-	let lastSlice = selector(observable.get());
-	return observable.subscribe((value) => {
-		const nextSlice = selector(value);
-		if (isEqualShallow(nextSlice, lastSlice)) return;
-		lastSlice = nextSlice;
-		callback(nextSlice);
+const destroyWalletProviders = async ({ reason }, client) => {
+	const core = getCore(client);
+	const walletProviders = getAvailableWalletProvidersFromWalletAccounts(client);
+	await Promise.all(walletProviders.map(async (walletProvider) => {
+		if (!walletProvider.destroy) return;
+		try {
+			await walletProvider.destroy({ reason });
+		} catch (err) {
+			core.logger.error(`Error destroying wallet provider ${walletProvider.key}`, err);
+		}
+	}));
+};
+
+//#endregion
+//#region src/modules/auth/logoutWithReason/logoutWithReason.ts
+/**
+* Logs the user out with an explicit reason.
+*
+* Revokes the session, clears auth state, terminates wallet providers, and
+* emits the `logout` client event with the given reason. The reason is also
+* captured as an argument on the function-instrumentation event, which is
+* how Datadog distinguishes between different logout causes.
+*
+* Use this instead of the public `logout` when triggering a logout from
+* internal or extension code — the caller owns the reason string, so the
+* telemetry correctly attributes *why* the logout happened.
+*
+* @param params - The logout params.
+* @param params.reason - Why the logout is being triggered. Extension authors
+*   needing a reason outside the SDK catalog can cast with `as LogoutReason`.
+* @param client - The Dynamic client instance.
+* @instrumented
+*/
+const logoutWithReason = async ({ reason }, client) => {
+	const core = getCore(client);
+	core.logger.debug("[logoutWithReason] Logging out...", { reason });
+	await destroyWalletProviders({ reason }, client);
+	if (client.user !== null) {
+		const apiClient = createApiClient({}, client);
+		try {
+			await apiClient.revokeSession({ environmentId: core.environmentId });
+		} catch (error) {
+			core.logger.error("Failed to revoke session", error);
+		}
+		/**
+		* This deletes the auth cookie if it exists.
+		* If the cookie doesn't exist, this sets a new cookie that expires immediately.
+		*/
+		if (isCookieEnabled(client)) setCookie(`${DYNAMIC_AUTH_COOKIE_NAME}=; Max-Age=-99999999; path=/; SameSite=Lax`);
+	}
+	await core.keychain.removeKey("session");
+	core.state.set({
+		captchaToken: null,
+		elevatedAccessTokens: [],
+		legacyToken: null,
+		mfaToken: null,
+		sessionExpiresAt: null,
+		sessionKeys: null,
+		token: null,
+		unverifiedWalletAccounts: [],
+		user: null
 	});
+	emitEvent({
+		args: { reason },
+		event: "logout"
+	}, client);
+	fetchProjectSettings(client);
+	generateSessionKeys(client);
 };
+const __logoutWithReason_impl = logoutWithReason;
+const __logoutWithReason_wrapped = instrumentFunction({
+	fn: __logoutWithReason_impl,
+	functionName: "logoutWithReason",
+	getCore: () => {
+		try {
+			return getCore(getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
 
 //#endregion
 //#region src/utils/getBuffer/getBuffer.ts
@@ -304,7 +575,7 @@ const createLogger = (options = {}) => {
 
 //#endregion
 //#region src/turboModules/NativeKeychain.ts
-var NativeKeychain_default = TurboModuleRegistry.getEnforcing("Keychain");
+var NativeKeychain_default = TurboModuleRegistry.getEnforcing("DynamicClientKeychain");
 
 //#endregion
 //#region src/utils/base64urlFromBytes/base64urlFromBytes.ts
@@ -443,7 +714,7 @@ var KeyNotFoundError = class extends BaseError {
 * @not-instrumented
 */
 const createKeychainService = () => {
-	if (NativeKeychain_default == null) throw new NativeModuleNotLinkedError({ moduleName: "Keychain" });
+	if (NativeKeychain_default == null) throw new NativeModuleNotLinkedError({ moduleName: "DynamicClientKeychain" });
 	const nativeModule = NativeKeychain_default;
 	const generateKey = async (keyName) => {
 		return bufferToHex(compressRawPublicKey(bytesFromBase64url((await nativeModule.generateKeyPair(keyName)).publicKey).buffer));
@@ -1111,5 +1382,5 @@ const getNetworkProviderFromNetworkId = ({ networkId, chain }, client) => {
 };
 
 //#endregion
-export { GENERATE_SESSION_KEYS_TRACKER_KEY as A, createKeychainService as C, CannotTrackError as D, CrossTabBroadcastMessageSchema as E, getBuffer as F, subscribeWithSelector as I, isEqualShallow as L, REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY as M, REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY as N, createDeferredPromise as O, isServerSideRendering as P, createStorage as R, createRealtimeService as S, createCrossTabBroadcast as T, getAppMetadata as _, verifyMessageSignatureOwnership as a, NoNetworkProvidersError as b, formatSignInMessage as c, setUnverifiedWalletAccounts as d, createVisit as f, isCaptchaRequired as g, consumeCaptchaToken as h, getNetworksData as i, INITIALIZE_STORAGE_SYNC_TRACKER_KEY as j, FETCH_PROJECT_SETTINGS_TRACKER_KEY as k, reconcileWalletAccountsAgainstClient as l, __setCaptchaToken_wrapped as m, getNetworkProviders as n, removeUnverifiedWalletAccount as o, hasExtension as p, getNetworkProviderBuilderRegistry as r, createSignInMessageStatement as s, getNetworkProviderFromNetworkId as t, updateWalletProviderKeysForVerifiedCredentials as u, MethodNotImplementedError as v, createLogger as w, getKeychainIndexedDBName as x, WalletAlreadyLinkedToAnotherUserError as y, InvalidStorageSet as z };
-//# sourceMappingURL=getNetworkProviderFromNetworkId-B7DIqT2T.native.esm.js.map
+export { GENERATE_SESSION_KEYS_TRACKER_KEY as A, createStorage as B, createKeychainService as C, CannotTrackError as D, CrossTabBroadcastMessageSchema as E, getBuffer as F, subscribeWithSelector as G, createLocalStorageAdapter as H, __logoutWithReason_wrapped as I, isEqualShallow as K, generateSessionKeys as L, REFRESH_USER_STATE_FROM_COOKIE_TRACKER_KEY as M, REFRESH_USER_STATE_FROM_VALID_TOKEN_TRACKER_KEY as N, createDeferredPromise as O, isServerSideRendering as P, fetchProjectSettings as R, createRealtimeService as S, createCrossTabBroadcast as T, isSignedIn as U, InvalidStorageSet as V, retryOnFail as W, getAppMetadata as _, verifyMessageSignatureOwnership as a, NoNetworkProvidersError as b, formatSignInMessage as c, setUnverifiedWalletAccounts as d, createVisit as f, isCaptchaRequired as g, consumeCaptchaToken as h, getNetworksData as i, INITIALIZE_STORAGE_SYNC_TRACKER_KEY as j, FETCH_PROJECT_SETTINGS_TRACKER_KEY as k, reconcileWalletAccountsAgainstClient as l, __setCaptchaToken_wrapped as m, getNetworkProviders as n, removeUnverifiedWalletAccount as o, hasExtension as p, getNetworkProviderBuilderRegistry as r, createSignInMessageStatement as s, getNetworkProviderFromNetworkId as t, updateWalletProviderKeysForVerifiedCredentials as u, MethodNotImplementedError as v, createLogger as w, getKeychainIndexedDBName as x, WalletAlreadyLinkedToAnotherUserError as y, createStorageKeySchema as z };
+//# sourceMappingURL=getNetworkProviderFromNetworkId-DVmF7pH2.native.esm.js.map