@dynamic-labs-sdk/client 0.24.1 → 0.25.1

package/dist/{getNetworkProviderFromNetworkId-COxYamJy.cjs.js → getNetworkProviderFromNetworkId-ClfETwqS.cjs.js}

@@ -25,8 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_InvalidParamError = require('./InvalidParamError-9IR2C0up.cjs.js');
-const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-Df_wN20i.cjs.js');
+const require_InvalidParamError = require('./InvalidParamError-BqDEZ6er.cjs.js');
+const require_getVerifiedCredentialForWalletAccount = require('./getVerifiedCredentialForWalletAccount-DEiU9FZG.cjs.js');
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
 let zod_mini = require("zod/mini");
 zod_mini = __toESM(zod_mini);
@@ -95,10 +95,59 @@ const __subscribeWithSelector_wrapped = require_InvalidParamError.instrumentFunc
 	}
 });
 
+//#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 require_InvalidParamError.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.
+*
+* @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 = require_InvalidParamError.getDefaultClient()) => Boolean(client.user || require_getVerifiedCredentialForWalletAccount.__getWalletAccounts_wrapped(client).length > 0);
+
 //#endregion
 //#region src/services/storage/createLocalStorageAdapter/createLocalStorageAdapter.ts
 /**
-* Creates a localStorage adapter
+* Creates a localStorage adapter.
 * @instrumented
 */
 const createLocalStorageAdapter = () => ({
@@ -173,14 +222,19 @@ const parseFromStorage = (value) => {
 //#endregion
 //#region src/services/storage/createStorage/createStorage.ts
 /**
-* Creates a Storage service to interact with storage adapter
+* Creates a Storage service to interact with storage adapter.
+* Reads the `storageTier` from each key's config and passes it
+* to the adapter on every operation, defaulting to `'default'`.
 * @instrumented
 */
 const createStorage = ({ prefix = "", storageAdapter }) => {
 	const getPrefixedKey = (key) => prefix ? `${prefix}_${key}` : key;
+	const getAdapterOptions = (storageTier) => ({ storageTier: storageTier ?? "default" });
 	return {
 		getItem: async (storageKeySchema) => {
-			const rawItem = await storageAdapter.getItem(getPrefixedKey(storageKeySchema.key));
+			const prefixedKey = getPrefixedKey(storageKeySchema.key);
+			const options = getAdapterOptions(storageKeySchema.config?.storageTier);
+			const rawItem = await storageAdapter.getItem(prefixedKey, options);
 			const parsedItem = rawItem ? parseFromStorage(rawItem) : null;
 			/**
 			* The item saved to localStorage may be malformed.
@@ -194,11 +248,11 @@ const createStorage = ({ prefix = "", storageAdapter }) => {
 			* The item saved to localStorage may be malformed.
 			* In this case, we remove it and return null.
 			*/
-			await storageAdapter.removeItem(getPrefixedKey(storageKeySchema.key));
+			await storageAdapter.removeItem(prefixedKey, options);
 			return null;
 		},
 		removeItem: async (storageKeySchema) => {
-			await storageAdapter.removeItem(getPrefixedKey(storageKeySchema.key));
+			await storageAdapter.removeItem(getPrefixedKey(storageKeySchema.key), getAdapterOptions(storageKeySchema.config?.storageTier));
 		},
 		setItem: async (storageKeySchema, value) => {
 			const parsed = storageKeySchema.schema.safeParse(value);
@@ -207,7 +261,7 @@ const createStorage = ({ prefix = "", storageAdapter }) => {
 				value: JSON.stringify(value)
 			});
 			const item = formatForStorage(parsed.data);
-			await storageAdapter.setItem(getPrefixedKey(storageKeySchema.key), item);
+			await storageAdapter.setItem(getPrefixedKey(storageKeySchema.key), item, getAdapterOptions(storageKeySchema.config?.storageTier));
 		}
 	};
 };
@@ -243,6 +297,64 @@ const __createStorageKeySchema_wrapped = require_InvalidParamError.instrumentFun
 	}
 });
 
+//#endregion
+//#region src/modules/projectSettings/fetchProjectSettings/projectSettingsExpirationScheme.ts
+/**
+* The schema to track the expiration time of the project settings.
+*/
+const projectSettingsExpirationStorageKeySchema = __createStorageKeySchema_wrapped({
+	key: "projectSettingsExpiration",
+	schema: zod_mini.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.
+*
+* 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.
+* @instrumented
+*/
+const fetchProjectSettings = async (client = require_InvalidParamError.getDefaultClient()) => {
+	const core = require_InvalidParamError.getCore(client);
+	const currentExpiration = await core.storage.getItem(projectSettingsExpirationStorageKeySchema);
+	if (Boolean(client.projectSettings) && !(currentExpiration && currentExpiration < Date.now()) && isSignedIn(client)) return client.projectSettings;
+	const apiClient = require_InvalidParamError.__createApiClient_wrapped({}, client);
+	core.logger.debug("[fetchProjectSettings] Fetching project settings...");
+	const doFetch = async () => apiClient.getEnvironmentSettings({
+		environmentId: core.environmentId,
+		sdkVersion: `${require_InvalidParamError.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;
+};
+const __fetchProjectSettings_impl = fetchProjectSettings;
+const __fetchProjectSettings_wrapped = require_InvalidParamError.instrumentFunction({
+	fn: __fetchProjectSettings_impl,
+	functionName: "fetchProjectSettings",
+	getCore: () => {
+		try {
+			return require_InvalidParamError.getCore(require_InvalidParamError.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/modules/sessionKeys/generateSessionKeys/generateSessionKeys.ts
 /** @instrumented */
@@ -265,6 +377,115 @@ const __generateSessionKeys_wrapped = require_InvalidParamError.instrumentFuncti
 	}
 });
 
+//#endregion
+//#region src/modules/wallets/utils/getAvailableWalletProvidersFromWalletAccounts/getAvailableWalletProvidersFromWalletAccounts.ts
+/** @not-instrumented */
+const getAvailableWalletProvidersFromWalletAccounts = (client) => {
+	const core = require_InvalidParamError.getCore(client);
+	const walletProvidersMap = /* @__PURE__ */ new Map();
+	require_getVerifiedCredentialForWalletAccount.__getWalletAccounts_wrapped(client).forEach((walletAccount) => {
+		if (walletProvidersMap.has(walletAccount.walletProviderKey)) return;
+		try {
+			const walletProvider = require_getVerifiedCredentialForWalletAccount.__getWalletProviderFromWalletAccount_wrapped({ 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/disconnectAndTerminateWalletProviders/disconnectAndTerminateWalletProviders.ts
+/**
+* Disconnect and terminate each wallet provider, if available.
+* @not-instrumented
+*/
+const disconnectAndTerminateWalletProviders = async ({ reason }, client) => {
+	const core = require_InvalidParamError.getCore(client);
+	const walletProviders = getAvailableWalletProvidersFromWalletAccounts(client);
+	await Promise.all(walletProviders.map(async (walletProvider) => {
+		if (walletProvider.terminate) await walletProvider.terminate({ reason });
+		if (walletProvider.disconnect) try {
+			await walletProvider.disconnect();
+		} catch (err) {
+			core.logger.error(`Error disconnecting from wallet ${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 = require_InvalidParamError.getCore(client);
+	core.logger.debug("[logoutWithReason] Logging out...", { reason });
+	await disconnectAndTerminateWalletProviders({ reason }, client);
+	if (client.user !== null) {
+		const apiClient = require_InvalidParamError.__createApiClient_wrapped({}, 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 (require_InvalidParamError.isCookieEnabled(client)) require_getVerifiedCredentialForWalletAccount.setCookie(`${require_getVerifiedCredentialForWalletAccount.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
+	});
+	require_getVerifiedCredentialForWalletAccount.emitEvent({
+		args: { reason },
+		event: "logout"
+	}, client);
+	__fetchProjectSettings_wrapped(client);
+	__generateSessionKeys_wrapped(client);
+};
+const __logoutWithReason_impl = logoutWithReason;
+const __logoutWithReason_wrapped = require_InvalidParamError.instrumentFunction({
+	fn: __logoutWithReason_impl,
+	functionName: "logoutWithReason",
+	getCore: () => {
+		try {
+			return require_InvalidParamError.getCore(require_InvalidParamError.getDefaultClient());
+		} catch {
+			return;
+		}
+	}
+});
+
 //#endregion
 //#region src/utils/getBuffer/getBuffer.ts
 /** @not-instrumented */
@@ -472,7 +693,7 @@ const compressRawPublicKey = (rawPublicKey) => {
 };
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/KeyNotFoundError.ts
+//#region src/services/keychain/createKeychainService/KeyNotFoundError.ts
 var KeyNotFoundError = class extends require_InvalidParamError.BaseError {
 	constructor(keyName) {
 		super({
@@ -486,38 +707,38 @@ var KeyNotFoundError = class extends require_InvalidParamError.BaseError {
 };
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/constants.ts
+//#region src/services/keychain/createKeychainService/utils/constants.ts
 const STORE_NAME = "keys";
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/deleteIndexedDBItem.ts
+//#region src/services/keychain/createKeychainService/utils/deleteIndexedDBItem.ts
 /** @not-instrumented */
-const deleteIndexedDBItem = (db, keyName) => new Promise((resolve, reject) => {
+const deleteIndexedDBItem = ({ db, keyName }) => new Promise((resolve, reject) => {
 	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).delete(keyName);
 	request.onsuccess = () => resolve();
 	request.onerror = () => reject(request.error);
 });
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/getIndexedDBItem.ts
+//#region src/services/keychain/createKeychainService/utils/getIndexedDBItem.ts
 /** @not-instrumented */
-const getIndexedDBItem = (db, keyName) => new Promise((resolve, reject) => {
+const getIndexedDBItem = ({ db, keyName }) => new Promise((resolve, reject) => {
 	const request = db.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).get(keyName);
 	request.onsuccess = () => resolve(request.result);
 	request.onerror = () => reject(request.error);
 });
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/setIndexedDBItem.ts
+//#region src/services/keychain/createKeychainService/utils/setIndexedDBItem.ts
 /** @not-instrumented */
-const setIndexedDBItem = (db, entry) => new Promise((resolve, reject) => {
+const setIndexedDBItem = ({ db, entry }) => new Promise((resolve, reject) => {
 	const request = db.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(entry);
 	request.onsuccess = () => resolve();
 	request.onerror = () => reject(request.error);
 });
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/openDatabase.ts
+//#region src/services/keychain/createKeychainService/utils/openDatabase.ts
 /** @not-instrumented */
 const openDatabase = (dbName) => new Promise((resolve, reject) => {
 	const request = indexedDB.open(dbName, 1);
@@ -530,7 +751,7 @@ const openDatabase = (dbName) => new Promise((resolve, reject) => {
 });
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/utils/withDatabase/withDatabase.ts
+//#region src/services/keychain/createKeychainService/utils/withDatabase/withDatabase.ts
 /**
 * Scopes a database connection to the lifetime of a callback.
 * Opens a connection, passes it to the operation, and guarantees
@@ -547,10 +768,10 @@ const withDatabase = async ({ dbName, operation }) => {
 };
 
 //#endregion
-//#region src/services/keychain/createIndexedDBKeychainService/createIndexedDBKeychainService.ts
+//#region src/services/keychain/createKeychainService/createKeychainService.ts
 const DEFAULT_DB_NAME = "dynamic_keychain";
 /** @instrumented */
-const createIndexedDBKeychainService = (params) => {
+const createKeychainService = (params) => {
 	const dbName = params?.dbName ?? DEFAULT_DB_NAME;
 	const generateKey = async (keyName) => {
 		const keyPair = await crypto.subtle.generateKey({
@@ -560,10 +781,13 @@ const createIndexedDBKeychainService = (params) => {
 		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", keyPair.publicKey)));
 		await withDatabase({
 			dbName,
-			operation: (db) => setIndexedDBItem(db, {
-				keyName,
-				privateKey: keyPair.privateKey,
-				publicKeyHex
+			operation: (db) => setIndexedDBItem({
+				db,
+				entry: {
+					keyName,
+					privateKey: keyPair.privateKey,
+					publicKeyHex
+				}
 			})
 		});
 		return publicKeyHex;
@@ -586,10 +810,13 @@ const createIndexedDBKeychainService = (params) => {
 		const publicKeyHex = bufferToHex(compressRawPublicKey(await crypto.subtle.exportKey("raw", publicCryptoKey)));
 		await withDatabase({
 			dbName,
-			operation: (db) => setIndexedDBItem(db, {
-				keyName,
-				privateKey,
-				publicKeyHex
+			operation: (db) => setIndexedDBItem({
+				db,
+				entry: {
+					keyName,
+					privateKey,
+					publicKeyHex
+				}
 			})
 		});
 		return publicKeyHex;
@@ -597,13 +824,19 @@ const createIndexedDBKeychainService = (params) => {
 	const getPublicKey = async (keyName) => {
 		return (await withDatabase({
 			dbName,
-			operation: (db) => getIndexedDBItem(db, keyName)
+			operation: (db) => getIndexedDBItem({
+				db,
+				keyName
+			})
 		}))?.publicKeyHex ?? null;
 	};
 	const sign = async (keyName, message) => {
 		const entry = await withDatabase({
 			dbName,
-			operation: (db) => getIndexedDBItem(db, keyName)
+			operation: (db) => getIndexedDBItem({
+				db,
+				keyName
+			})
 		});
 		if (!entry) throw new KeyNotFoundError(keyName);
 		const data = new TextEncoder().encode(message);
@@ -615,13 +848,19 @@ const createIndexedDBKeychainService = (params) => {
 	const hasKey = async (keyName) => {
 		return await withDatabase({
 			dbName,
-			operation: (db) => getIndexedDBItem(db, keyName)
+			operation: (db) => getIndexedDBItem({
+				db,
+				keyName
+			})
 		}) !== void 0;
 	};
 	const removeKey = async (keyName) => {
 		await withDatabase({
 			dbName,
-			operation: (db) => deleteIndexedDBItem(db, keyName)
+			operation: (db) => deleteIndexedDBItem({
+				db,
+				keyName
+			})
 		});
 	};
 	return {
@@ -633,18 +872,6 @@ const createIndexedDBKeychainService = (params) => {
 		sign
 	};
 };
-const __createIndexedDBKeychainService_impl = createIndexedDBKeychainService;
-const __createIndexedDBKeychainService_wrapped = require_InvalidParamError.instrumentFunction({
-	fn: __createIndexedDBKeychainService_impl,
-	functionName: "createIndexedDBKeychainService",
-	getCore: () => {
-		try {
-			return require_InvalidParamError.getCore(require_InvalidParamError.getDefaultClient());
-		} catch {
-			return;
-		}
-	}
-});
 
 //#endregion
 //#region src/errors/InvalidRealtimePublishError.ts
@@ -726,7 +953,7 @@ const createRealtimeService = () => {
 		channels.set(channelName, channel);
 		return channel;
 	};
-	const connect = async ({ client }) => {
+	const connect = async ({ client, headers }) => {
 		if (isConnecting) return;
 		isConnecting = true;
 		try {
@@ -738,7 +965,7 @@ const createRealtimeService = () => {
 			const { BaseRealtime: AblyBaseRealtime, FetchRequest, WebSocketTransport } = await import("ably/modular");
 			ablyClient = new AblyBaseRealtime({
 				authCallback: (_tokenParams, callback) => {
-					require_InvalidParamError.__createApiClient_wrapped({}, client).getRealtimeAuthToken({ environmentId: core.environmentId }).then((response) => {
+					require_InvalidParamError.__createApiClient_wrapped({ headers }, client).getRealtimeAuthToken({ environmentId: core.environmentId }).then((response) => {
 						callback(null, response.token);
 					}).catch((err) => {
 						callback(err instanceof Error ? err.message : String(err), null);
@@ -1405,12 +1632,6 @@ Object.defineProperty(exports, '__createDeferredPromise_wrapped', {
     return __createDeferredPromise_wrapped;
   }
 });
-Object.defineProperty(exports, '__createIndexedDBKeychainService_wrapped', {
-  enumerable: true,
-  get: function () {
-    return __createIndexedDBKeychainService_wrapped;
-  }
-});
 Object.defineProperty(exports, '__createLocalStorageAdapter_wrapped', {
   enumerable: true,
   get: function () {
@@ -1459,6 +1680,12 @@ Object.defineProperty(exports, '__createVisit_wrapped', {
     return __createVisit_wrapped;
   }
 });
+Object.defineProperty(exports, '__fetchProjectSettings_wrapped', {
+  enumerable: true,
+  get: function () {
+    return __fetchProjectSettings_wrapped;
+  }
+});
 Object.defineProperty(exports, '__generateSessionKeys_wrapped', {
   enumerable: true,
   get: function () {
@@ -1483,6 +1710,12 @@ Object.defineProperty(exports, '__getNetworksData_wrapped', {
     return __getNetworksData_wrapped;
   }
 });
+Object.defineProperty(exports, '__logoutWithReason_wrapped', {
+  enumerable: true,
+  get: function () {
+    return __logoutWithReason_wrapped;
+  }
+});
 Object.defineProperty(exports, '__removeUnverifiedWalletAccount_wrapped', {
   enumerable: true,
   get: function () {
@@ -1525,6 +1758,12 @@ Object.defineProperty(exports, '__verifyMessageSignatureOwnership_wrapped', {
     return __verifyMessageSignatureOwnership_wrapped;
   }
 });
+Object.defineProperty(exports, 'createKeychainService', {
+  enumerable: true,
+  get: function () {
+    return createKeychainService;
+  }
+});
 Object.defineProperty(exports, 'formatSignInMessage', {
   enumerable: true,
   get: function () {
@@ -1567,4 +1806,16 @@ Object.defineProperty(exports, 'isServerSideRendering', {
     return isServerSideRendering;
   }
 });
-//# sourceMappingURL=getNetworkProviderFromNetworkId-COxYamJy.cjs.js.map
+Object.defineProperty(exports, 'isSignedIn', {
+  enumerable: true,
+  get: function () {
+    return isSignedIn;
+  }
+});
+Object.defineProperty(exports, 'retryOnFail', {
+  enumerable: true,
+  get: function () {
+    return retryOnFail;
+  }
+});
+//# sourceMappingURL=getNetworkProviderFromNetworkId-ClfETwqS.cjs.js.map