@tatchi-xyz/sdk 0.21.0 → 0.31.1

package/dist/esm/react/sdk/src/core/IndexedDBManager/passkeyClientDB.js

@@ -1,678 +0,0 @@
-import { __esm } from "../../../../_virtual/rolldown_runtime.js";
-import { init_validation, validateNearAccountId } from "../../utils/validation.js";
-import { init_accountIds, toAccountId } from "../types/accountIds.js";
-import { DEFAULT_CONFIRMATION_CONFIG, init_signer_worker } from "../types/signer-worker.js";
-import { openDB } from "idb";
-
-//#region src/core/IndexedDBManager/passkeyClientDB.ts
-var DB_CONFIG, PasskeyClientDBManager;
-var init_passkeyClientDB = __esm({ "src/core/IndexedDBManager/passkeyClientDB.ts": (() => {
-	init_validation();
-	init_accountIds();
-	init_signer_worker();
-	DB_CONFIG = {
-		dbName: "PasskeyClientDB",
-		dbVersion: 15,
-		userStore: "users",
-		appStateStore: "appState",
-		authenticatorStore: "authenticators",
-		derivedAddressStore: "derivedAddresses",
-		recoveryEmailStore: "recoveryEmails"
-	};
-	PasskeyClientDBManager = class {
-		config;
-		db = null;
-		disabled = false;
-		eventListeners = /* @__PURE__ */ new Set();
-		constructor(config = DB_CONFIG) {
-			this.config = config;
-		}
-		getDbName() {
-			return this.config.dbName;
-		}
-		setDbName(dbName) {
-			const next = String(dbName || "").trim();
-			if (!next || next === this.config.dbName) return;
-			try {
-				this.db?.close?.();
-			} catch {}
-			this.db = null;
-			this.config = {
-				...this.config,
-				dbName: next
-			};
-		}
-		isDisabled() {
-			return this.disabled;
-		}
-		setDisabled(disabled) {
-			const next = !!disabled;
-			if (next === this.disabled) return;
-			this.disabled = next;
-			if (next) {
-				try {
-					this.db?.close?.();
-				} catch {}
-				this.db = null;
-			}
-		}
-		onChange(listener) {
-			this.eventListeners.add(listener);
-			return () => {
-				this.eventListeners.delete(listener);
-			};
-		}
-		emitEvent(event) {
-			this.eventListeners.forEach((listener) => {
-				try {
-					listener(event);
-				} catch (error) {
-					console.warn("[IndexedDBManager]: Error in event listener:", error);
-				}
-			});
-		}
-		async getDB() {
-			if (this.disabled) throw new Error("[PasskeyClientDBManager] IndexedDB is disabled in this environment.");
-			if (this.db) return this.db;
-			try {
-				this.db = await openDB(this.config.dbName, this.config.dbVersion, {
-					upgrade: (db, oldVersion, _newVersion, _transaction) => {
-						if (!db.objectStoreNames.contains(DB_CONFIG.userStore)) {
-							const userStore = db.createObjectStore(DB_CONFIG.userStore, { keyPath: ["nearAccountId", "deviceNumber"] });
-							userStore.createIndex("nearAccountId", "nearAccountId", { unique: false });
-						}
-						if (!db.objectStoreNames.contains(DB_CONFIG.appStateStore)) db.createObjectStore(DB_CONFIG.appStateStore, { keyPath: "key" });
-						if (!db.objectStoreNames.contains(DB_CONFIG.authenticatorStore)) {
-							const authStore = db.createObjectStore(DB_CONFIG.authenticatorStore, { keyPath: [
-								"nearAccountId",
-								"deviceNumber",
-								"credentialId"
-							] });
-							authStore.createIndex("nearAccountId", "nearAccountId", { unique: false });
-						}
-						if (!db.objectStoreNames.contains(DB_CONFIG.derivedAddressStore)) {
-							const dStore = db.createObjectStore(DB_CONFIG.derivedAddressStore, { keyPath: [
-								"nearAccountId",
-								"contractId",
-								"path"
-							] });
-							try {
-								dStore.createIndex("nearAccountId", "nearAccountId", { unique: false });
-							} catch {}
-						}
-						if (!db.objectStoreNames.contains(DB_CONFIG.recoveryEmailStore)) {
-							const rStore = db.createObjectStore(DB_CONFIG.recoveryEmailStore, { keyPath: ["nearAccountId", "hashHex"] });
-							try {
-								rStore.createIndex("nearAccountId", "nearAccountId", { unique: false });
-							} catch {}
-						}
-					},
-					blocked() {
-						console.warn("PasskeyClientDB connection is blocked.");
-					},
-					blocking() {
-						console.warn("PasskeyClientDB connection is blocking another connection.");
-					},
-					terminated: () => {
-						console.warn("PasskeyClientDB connection has been terminated.");
-						this.db = null;
-					}
-				});
-				try {
-					await this.runMigrationsIfNeeded(this.db);
-				} catch {}
-			} catch (err) {
-				const msg = String(err?.message || "");
-				if (err?.name === "VersionError" || /less than the existing version/i.test(msg)) try {
-					console.warn("PasskeyClientDB: opening existing DB without version due to VersionError");
-					this.db = await openDB(this.config.dbName);
-				} catch (e) {
-					throw err;
-				}
-				else throw err;
-			}
-			return this.db;
-		}
-		async runMigrationsIfNeeded(_db) {}
-		async getAppState(key) {
-			const db = await this.getDB();
-			const result = await db.get(DB_CONFIG.appStateStore, key);
-			return result?.value;
-		}
-		async setAppState(key, value) {
-			const db = await this.getDB();
-			const entry = {
-				key,
-				value
-			};
-			await db.put(DB_CONFIG.appStateStore, entry);
-		}
-		/**
-		* Validate that a NEAR account ID is in the expected format
-		* Supports both <username>.<relayerAccountId> and <username>.testnet formats
-		*/
-		validateNearAccountId(nearAccountId) {
-			return validateNearAccountId(nearAccountId);
-		}
-		/**
-		* Extract username from NEAR account ID
-		*/
-		extractUsername(nearAccountId) {
-			const validation = validateNearAccountId(nearAccountId);
-			if (!validation.valid) throw new Error(`Invalid NEAR account ID: ${validation.error}`);
-			return nearAccountId.split(".")[0];
-		}
-		/**
-		* Generate a NEAR account ID from a username and domain
-		* @param username - The username to use for the account ID
-		* @param domain - The domain to use for the account ID
-		* @returns The generated NEAR account ID
-		*/
-		generateNearAccountId(username, domain) {
-			const sanitizedName = username.toLowerCase().replace(/[^a-z0-9_\\-]/g, "").substring(0, 32);
-			return `${sanitizedName}.${domain}`;
-		}
-		async getUser(nearAccountId, deviceNumber) {
-			if (!nearAccountId) return null;
-			const validation = this.validateNearAccountId(nearAccountId);
-			if (!validation.valid) {
-				console.warn(`Invalid account ID format: ${nearAccountId}`);
-				return null;
-			}
-			const db = await this.getDB();
-			const accountId = toAccountId(nearAccountId);
-			if (typeof deviceNumber === "number") {
-				const rec = await db.get(DB_CONFIG.userStore, [accountId, deviceNumber]);
-				if (!rec) return null;
-				return await this.normalizeUserDeviceNumber(rec, deviceNumber);
-			}
-			const index = db.transaction(DB_CONFIG.userStore).store.index("nearAccountId");
-			const results = await index.getAll(accountId);
-			if (results.length === 0) return null;
-			if (results.length > 1) {
-				console.warn(`Multiple passkeys found for account ${accountId}, deviceNumber not provided; defaulting to last logged-in user.`);
-				console.log("defaulting to last used user deviceNumber");
-				const lastUserState = await this.getAppState("lastUserAccountId").catch(() => null);
-				if (lastUserState && toAccountId(lastUserState.accountId) === accountId) {
-					const keyed = await db.get(DB_CONFIG.userStore, [accountId, lastUserState.deviceNumber]);
-					if (keyed) return await this.normalizeUserDeviceNumber(keyed, lastUserState.deviceNumber);
-				}
-			}
-			const first = results[0];
-			if (!first) return null;
-			return await this.normalizeUserDeviceNumber(first, 1);
-		}
-		/**
-		* Get the current/last user
-		* This is maintained via app state and updated whenever a user is stored or updated
-		*/
-		async getLastUser() {
-			const lastUserState = await this.getAppState("lastUserAccountId");
-			if (!lastUserState) return null;
-			const db = await this.getDB();
-			const accountId = toAccountId(lastUserState.accountId);
-			const record = await db.get(DB_CONFIG.userStore, [accountId, lastUserState.deviceNumber]);
-			if (record) return record;
-			return this.getUser(accountId);
-		}
-		/** Get user record by composite key (nearAccountId, deviceNumber) */
-		async getUserByDevice(nearAccountId, deviceNumber) {
-			const db = await this.getDB();
-			const accountId = toAccountId(nearAccountId);
-			const rec = await db.get(DB_CONFIG.userStore, [accountId, deviceNumber]);
-			return rec || null;
-		}
-		/**
-		* Get the most recently updated user record for a given account.
-		* Useful when deviceNumber is unknown but we need the freshest key for the account.
-		*/
-		/**
-		* Get the most recently updated user record for a given account.
-		* Useful when deviceNumber is unknown but we need the freshest key for the account.
-		*/
-		async getLastDBUpdatedUser(nearAccountId) {
-			const db = await this.getDB();
-			try {
-				const idx = db.transaction(DB_CONFIG.userStore).store.index("nearAccountId");
-				const all = await idx.getAll(toAccountId(nearAccountId));
-				if (Array.isArray(all) && all.length > 0) {
-					const latest = all.reduce((a, b) => (a.lastUpdated ?? 0) >= (b.lastUpdated ?? 0) ? a : b);
-					return latest;
-				}
-			} catch {}
-			return null;
-		}
-		async hasPasskeyCredential(nearAccountId) {
-			const authenticators = await this.getAuthenticatorsByUser(nearAccountId);
-			return !!authenticators[0]?.credentialId;
-		}
-		/**
-		* Ensure the current passkey selection is aligned with the last logged-in device.
-		*
-		* - When multiple authenticators exist for an account and no deviceNumber is specified,
-		*   this helper prefers authenticators whose deviceNumber matches the last logged-in user.
-		* - Optionally validates that a selected credential (by rawId) also matches the last-user device.
-		*
-		* @param nearAccountId - Account ID for which the operation is being performed
-		* @param authenticators - All authenticators stored for the account
-		* @param selectedCredentialRawId - Optional rawId of the credential chosen by WebAuthn
-		* @returns filtered authenticators for allowCredentials, plus optional wrongPasskeyError
-		*/
-		async ensureCurrentPasskey(nearAccountId, authenticators, selectedCredentialRawId) {
-			if (authenticators.length <= 1) return { authenticatorsForPrompt: authenticators };
-			const accountIdNormalized = toAccountId(nearAccountId);
-			const lastUser = await this.getLastUser().catch(() => null);
-			if (!lastUser || lastUser.nearAccountId !== accountIdNormalized) return { authenticatorsForPrompt: authenticators };
-			const expectedDeviceNumber = lastUser.deviceNumber;
-			const byDeviceNumber = authenticators.filter((a) => a.deviceNumber === expectedDeviceNumber);
-			let expectedCredentialId = lastUser.passkeyCredential.rawId;
-			if (byDeviceNumber.length > 0 && !byDeviceNumber.some((a) => a.credentialId === expectedCredentialId)) expectedCredentialId = byDeviceNumber[0].credentialId;
-			const byCredentialId = authenticators.filter((a) => a.credentialId === expectedCredentialId);
-			const authenticatorsForPrompt = byCredentialId.length > 0 ? byCredentialId : byDeviceNumber.length > 0 ? byDeviceNumber : authenticators;
-			const wrongPasskeyError = selectedCredentialRawId && selectedCredentialRawId !== expectedCredentialId ? `You have multiple passkeys (deviceNumbers) for account ${accountIdNormalized}, but used a different passkey than the most recently logged-in one. Please use the passkey for the most recently logged-in device.` : void 0;
-			return {
-				authenticatorsForPrompt,
-				wrongPasskeyError
-			};
-		}
-		/**
-		* Register a new user with the given NEAR account ID
-		* @param nearAccountId - Full NEAR account ID (e.g., "username.testnet" or "username.relayer.testnet")
-		* @param additionalData - Additional user data to store
-		*/
-		async registerUser(storeUserData) {
-			const validation = this.validateNearAccountId(storeUserData.nearAccountId);
-			if (!validation.valid) throw new Error(`Cannot register user with invalid account ID: ${validation.error}`);
-			const now = Date.now();
-			const userData = {
-				nearAccountId: toAccountId(storeUserData.nearAccountId),
-				deviceNumber: storeUserData.deviceNumber || 1,
-				version: storeUserData.version || 2,
-				registeredAt: now,
-				lastLogin: now,
-				lastUpdated: now,
-				clientNearPublicKey: storeUserData.clientNearPublicKey,
-				passkeyCredential: storeUserData.passkeyCredential,
-				preferences: {
-					useRelayer: false,
-					useNetwork: "testnet",
-					confirmationConfig: DEFAULT_CONFIRMATION_CONFIG
-				},
-				encryptedVrfKeypair: storeUserData.encryptedVrfKeypair,
-				serverEncryptedVrfKeypair: storeUserData.serverEncryptedVrfKeypair
-			};
-			await this.storeUser(userData);
-			return userData;
-		}
-		async updateUser(nearAccountId, updates) {
-			const user = await this.getUser(nearAccountId);
-			if (user) {
-				const updatedUser = {
-					...user,
-					...updates,
-					lastUpdated: Date.now()
-				};
-				await this.storeUser(updatedUser);
-				this.emitEvent({
-					type: "user-updated",
-					accountId: nearAccountId,
-					data: {
-						updates,
-						updatedUser
-					}
-				});
-			}
-		}
-		async updateLastLogin(nearAccountId) {
-			await this.updateUser(nearAccountId, { lastLogin: Date.now() });
-		}
-		/**
-		* Set the last logged-in user
-		* @param nearAccountId - The account ID of the user
-		* @param deviceNumber - The device number (defaults to 1)
-		*/
-		async setLastUser(nearAccountId, deviceNumber = 1) {
-			const lastUserState = {
-				accountId: nearAccountId,
-				deviceNumber
-			};
-			await this.setAppState("lastUserAccountId", lastUserState);
-		}
-		async updatePreferences(nearAccountId, preferences) {
-			const user = await this.getUser(nearAccountId);
-			if (user) {
-				const updatedPreferences = {
-					...user.preferences,
-					...preferences
-				};
-				await this.updateUser(nearAccountId, { preferences: updatedPreferences });
-				this.emitEvent({
-					type: "preferences-updated",
-					accountId: nearAccountId,
-					data: { preferences: updatedPreferences }
-				});
-			}
-		}
-		async normalizeUserDeviceNumber(user, defaultDeviceNumber) {
-			const hasValidDevice = typeof user.deviceNumber === "number" && Number.isFinite(user.deviceNumber);
-			if (hasValidDevice) return user;
-			const deviceNumber = defaultDeviceNumber;
-			const fixed = {
-				...user,
-				deviceNumber
-			};
-			await this.storeUser(fixed);
-			return fixed;
-		}
-		async storeUser(userData) {
-			const validation = this.validateNearAccountId(userData.nearAccountId);
-			if (!validation.valid) throw new Error(`Cannot store user with invalid account ID: ${validation.error}`);
-			const db = await this.getDB();
-			await db.put(DB_CONFIG.userStore, userData);
-			const lastUserState = {
-				accountId: userData.nearAccountId,
-				deviceNumber: userData.deviceNumber
-			};
-			await this.setAppState("lastUserAccountId", lastUserState);
-		}
-		/**
-		* Store WebAuthn user data (compatibility with WebAuthnManager)
-		* @param userData - User data with nearAccountId as primary identifier
-		*/
-		async storeWebAuthnUserData(userData) {
-			const validation = this.validateNearAccountId(userData.nearAccountId);
-			if (!validation.valid) throw new Error(`Cannot store WebAuthn data for invalid account ID: ${validation.error}`);
-			const accountId = toAccountId(userData.nearAccountId);
-			const deviceNumber = userData.deviceNumber;
-			let user = await this.getUser(accountId, deviceNumber);
-			if (!user) user = await this.registerUser({
-				nearAccountId: accountId,
-				deviceNumber,
-				clientNearPublicKey: userData.clientNearPublicKey,
-				passkeyCredential: userData.passkeyCredential,
-				encryptedVrfKeypair: userData.encryptedVrfKeypair,
-				version: userData.version || 2,
-				serverEncryptedVrfKeypair: userData.serverEncryptedVrfKeypair
-			});
-			const updatedUser = {
-				...user,
-				clientNearPublicKey: userData.clientNearPublicKey,
-				passkeyCredential: userData.passkeyCredential,
-				encryptedVrfKeypair: userData.encryptedVrfKeypair,
-				serverEncryptedVrfKeypair: userData.serverEncryptedVrfKeypair ?? user.serverEncryptedVrfKeypair,
-				version: userData.version ?? user.version,
-				lastUpdated: userData.lastUpdated ?? Date.now()
-			};
-			await this.storeUser(updatedUser);
-			this.emitEvent({
-				type: "user-updated",
-				accountId,
-				data: { updatedUser }
-			});
-		}
-		async getAllUsers() {
-			const db = await this.getDB();
-			return db.getAll(DB_CONFIG.userStore);
-		}
-		async deleteUser(nearAccountId) {
-			const db = await this.getDB();
-			await db.delete(DB_CONFIG.userStore, nearAccountId);
-			await this.clearAuthenticatorsForUser(nearAccountId);
-		}
-		async clearAllUsers() {
-			const db = await this.getDB();
-			await db.clear(DB_CONFIG.userStore);
-		}
-		async clearAllAppState() {
-			const db = await this.getDB();
-			await db.clear(DB_CONFIG.appStateStore);
-		}
-		/**
-		* Store authenticator data for a user
-		*/
-		async storeAuthenticator(authenticatorData) {
-			const db = await this.getDB();
-			await db.put(DB_CONFIG.authenticatorStore, authenticatorData);
-		}
-		/**
-		* Get all authenticators for a user (optionally for a specific device)
-		*/
-		async getAuthenticatorsByUser(nearAccountId) {
-			const db = await this.getDB();
-			const tx = db.transaction(DB_CONFIG.authenticatorStore, "readonly");
-			const store = tx.objectStore(DB_CONFIG.authenticatorStore);
-			const accountId = toAccountId(nearAccountId);
-			const index = store.index("nearAccountId");
-			return await index.getAll(accountId);
-		}
-		/**
-		* Get a specific authenticator by credential ID
-		*/
-		async getAuthenticatorByCredentialId(nearAccountId, credentialId) {
-			const db = await this.getDB();
-			const tx = db.transaction(DB_CONFIG.authenticatorStore, "readonly");
-			const store = tx.objectStore(DB_CONFIG.authenticatorStore);
-			const accountId = toAccountId(nearAccountId);
-			const index = store.index("nearAccountId");
-			const all = await index.getAll(accountId);
-			const match = all.find((auth) => auth.credentialId === credentialId) || null;
-			return match;
-		}
-		/**
-		* Clear all authenticators for a user
-		*/
-		async clearAuthenticatorsForUser(nearAccountId) {
-			const authenticators = await this.getAuthenticatorsByUser(nearAccountId);
-			const db = await this.getDB();
-			const tx = db.transaction(DB_CONFIG.authenticatorStore, "readwrite");
-			const store = tx.objectStore(DB_CONFIG.authenticatorStore);
-			for (const auth of authenticators) await store.delete([
-				nearAccountId,
-				auth.deviceNumber,
-				auth.credentialId
-			]);
-		}
-		/**
-		* Sync authenticators from contract data
-		*/
-		async syncAuthenticatorsFromContract(nearAccountId, contractAuthenticators) {
-			await this.clearAuthenticatorsForUser(nearAccountId);
-			const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
-			for (const auth of contractAuthenticators) {
-				const rawTransports = auth.transports || [];
-				const validTransports = rawTransports.filter((transport) => transport !== void 0 && transport !== null && typeof transport === "string");
-				const transports = validTransports.length > 0 ? validTransports : ["internal"];
-				const clientAuth = {
-					credentialId: auth.credentialId,
-					credentialPublicKey: auth.credentialPublicKey,
-					transports,
-					name: auth.name,
-					nearAccountId: toAccountId(nearAccountId),
-					deviceNumber: auth.deviceNumber || 1,
-					registered: auth.registered,
-					syncedAt,
-					vrfPublicKey: auth.vrfPublicKey
-				};
-				await this.storeAuthenticator(clientAuth);
-			}
-		}
-		/**
-		* Delete all authenticators for a user
-		*/
-		async deleteAllAuthenticatorsForUser(nearAccountId) {
-			const authenticators = await this.getAuthenticatorsByUser(nearAccountId);
-			if (authenticators.length === 0) {
-				console.warn(`No authenticators found for user ${nearAccountId}`);
-				return;
-			}
-			const db = await this.getDB();
-			const tx = db.transaction(DB_CONFIG.authenticatorStore, "readwrite");
-			const store = tx.objectStore(DB_CONFIG.authenticatorStore);
-			for (const auth of authenticators) await store.delete([
-				nearAccountId,
-				auth.deviceNumber,
-				auth.credentialId
-			]);
-			console.debug(`Deleted ${authenticators.length} authenticators for user ${nearAccountId}`);
-		}
-		/**
-		* Get user's confirmation config from IndexedDB
-		* @param nearAccountId - The user's account ID
-		* @returns ConfirmationConfig or undefined
-		*/
-		async getConfirmationConfig(nearAccountId) {
-			const user = await this.getUser(nearAccountId);
-			return user?.preferences?.confirmationConfig || DEFAULT_CONFIRMATION_CONFIG;
-		}
-		/**
-		* Get user's theme preference from IndexedDB
-		* @param nearAccountId - The user's account ID
-		* @returns 'dark' | 'light' | null
-		*/
-		async getTheme(nearAccountId) {
-			const user = await this.getUser(nearAccountId);
-			return user?.preferences?.confirmationConfig.theme || null;
-		}
-		/**
-		* Set user's theme preference in IndexedDB
-		* @param nearAccountId - The user's account ID
-		* @param theme - The theme to set ('dark' | 'light')
-		*/
-		async setTheme(nearAccountId, theme) {
-			const existingConfig = await this.getConfirmationConfig(nearAccountId);
-			const confirmationConfig = {
-				...existingConfig,
-				theme
-			};
-			await this.updatePreferences(nearAccountId, { confirmationConfig });
-		}
-		/**
-		* Get user's theme with fallback to 'dark'
-		* @param nearAccountId - The user's account ID
-		* @returns 'dark' | 'light'
-		*/
-		async getThemeOrDefault(nearAccountId) {
-			const theme = await this.getTheme(nearAccountId);
-			return theme || "dark";
-		}
-		/**
-		* Toggle between dark and light theme for a user
-		* @param nearAccountId - The user's account ID
-		* @returns The new theme that was set
-		*/
-		async toggleTheme(nearAccountId) {
-			const currentTheme = await this.getThemeOrDefault(nearAccountId);
-			const newTheme = currentTheme === "dark" ? "light" : "dark";
-			await this.setTheme(nearAccountId, newTheme);
-			return newTheme;
-		}
-		/**
-		* Store a derived address for a given NEAR account + contract + path
-		*/
-		async setDerivedAddress(nearAccountId, args) {
-			if (!nearAccountId || !args?.contractId || !args?.path || !args?.address) return;
-			const validation = this.validateNearAccountId(nearAccountId);
-			if (!validation.valid) return;
-			const rec = {
-				nearAccountId: toAccountId(nearAccountId),
-				contractId: String(args.contractId),
-				path: String(args.path),
-				address: String(args.address),
-				updatedAt: Date.now()
-			};
-			const db = await this.getDB();
-			await db.put(DB_CONFIG.derivedAddressStore, rec);
-		}
-		/**
-		* Fetch a derived address record; returns null if not found
-		*/
-		async getDerivedAddressRecord(nearAccountId, args) {
-			if (!nearAccountId || !args?.contractId || !args?.path) return null;
-			const db = await this.getDB();
-			const rec = await db.get(DB_CONFIG.derivedAddressStore, [
-				toAccountId(nearAccountId),
-				String(args.contractId),
-				String(args.path)
-			]);
-			return rec || null;
-		}
-		/**
-		* Get only the derived address string; returns null if not set
-		*/
-		async getDerivedAddress(nearAccountId, args) {
-			const rec = await this.getDerivedAddressRecord(nearAccountId, args);
-			return rec?.address || null;
-		}
-		/**
-		* Upsert recovery email records for an account.
-		* Merges by hashHex, preferring the most recent email.
-		*/
-		async upsertRecoveryEmails(nearAccountId, entries) {
-			if (!nearAccountId || !entries?.length) return;
-			const validation = this.validateNearAccountId(nearAccountId);
-			if (!validation.valid) return;
-			const db = await this.getDB();
-			const accountId = toAccountId(nearAccountId);
-			const now = Date.now();
-			for (const entry of entries) {
-				const hashHex = String(entry?.hashHex || "").trim();
-				const email = String(entry?.email || "").trim();
-				if (!hashHex || !email) continue;
-				const rec = {
-					nearAccountId: accountId,
-					hashHex,
-					email,
-					addedAt: now
-				};
-				await db.put(DB_CONFIG.recoveryEmailStore, rec);
-			}
-		}
-		/**
-		* Fetch all recovery email records for an account.
-		*/
-		async getRecoveryEmails(nearAccountId) {
-			if (!nearAccountId) return [];
-			const db = await this.getDB();
-			const accountId = toAccountId(nearAccountId);
-			const tx = db.transaction(DB_CONFIG.recoveryEmailStore, "readonly");
-			const store = tx.objectStore(DB_CONFIG.recoveryEmailStore);
-			const index = store.index("nearAccountId");
-			const result = await index.getAll(accountId);
-			return result || [];
-		}
-		/**
-		* Atomic operation wrapper for multiple IndexedDB operations
-		* Either all operations succeed or all are rolled back
-		*/
-		async atomicOperation(operation) {
-			const db = await this.getDB();
-			try {
-				const result = await operation(db);
-				return result;
-			} catch (error) {
-				console.error("Atomic operation failed:", error);
-				throw error;
-			}
-		}
-		/**
-		* Complete rollback of user registration data
-		* Deletes user, authenticators, and WebAuthn data atomically
-		*/
-		async rollbackUserRegistration(nearAccountId) {
-			console.debug(`Rolling back registration data for ${nearAccountId}`);
-			await this.atomicOperation(async (db) => {
-				await this.deleteAllAuthenticatorsForUser(nearAccountId);
-				await db.delete(DB_CONFIG.userStore, nearAccountId);
-				const lastUserAccount = await this.getAppState("lastUserAccountId");
-				if (lastUserAccount === nearAccountId) await this.setAppState("lastUserAccountId", null);
-				console.debug(`Rolled back all registration data for ${nearAccountId}`);
-				return true;
-			});
-		}
-	};
-}) });
-
-//#endregion
-init_passkeyClientDB();
-export { PasskeyClientDBManager, init_passkeyClientDB };
-//# sourceMappingURL=passkeyClientDB.js.map