@tatchi-xyz/sdk 0.20.0 → 0.31.0

package/dist/esm/sdk/rpcCalls-BQrJMTdg.js

@@ -1,10 +0,0 @@
-import "./validation-DtLVzHDY.js";
-import "./base64-DBPGuXh4.js";
-import "./actions-O1FD5Bq8.js";
-import "./errors-D9ar28Dr.js";
-import "./sdkSentEvents-_jrJLIhw.js";
-import "./defaultConfigs-DpslkAQd.js";
-import { buildSetRecoveryEmailsActions, checkCanRegisterUserContractCall, executeDeviceLinkingContractCalls, getAuthenticatorsByUser, getCredentialIdsContractCall, getDeviceLinkingAccountContractCall, getEmailRecoveryVerificationResult, getRecoveryEmailHashesContractCall, init_rpcCalls, syncAuthenticatorsContractCall, verifyAuthenticationResponse } from "./rpcCalls-YVeUVMk2.js";
-
-init_rpcCalls();
-export { getEmailRecoveryVerificationResult, syncAuthenticatorsContractCall };

package/dist/esm/sdk/rpcCalls-YVeUVMk2.js

@@ -1,397 +0,0 @@
-import { __esm } from "./chunk-DIQ1yeMN.js";
-import { base64UrlDecode, base64UrlEncode } from "./base64-DBPGuXh4.js";
-import { ActionType, init_actions } from "./actions-O1FD5Bq8.js";
-import { errorMessage, init_encoders, init_errors } from "./errors-D9ar28Dr.js";
-import { ActionPhase, DEFAULT_WAIT_STATUS, DeviceLinkingPhase, DeviceLinkingStatus, init_rpc, init_sdkSentEvents } from "./sdkSentEvents-_jrJLIhw.js";
-import { DEFAULT_EMAIL_RECOVERY_CONTRACTS, init_defaultConfigs } from "./defaultConfigs-DpslkAQd.js";
-
-//#region src/core/rpcCalls.ts
-async function getEmailRecoveryVerificationResult(nearClient, dkimVerifierAccountId, verificationViewMethod, requestId) {
-	return await nearClient.view({
-		account: dkimVerifierAccountId,
-		method: verificationViewMethod,
-		args: { request_id: requestId }
-	});
-}
-/**
-* Query the contract to get the account linked to a device public key
-* Used in device linking flow to check if a device key has been added
-*
-* NEAR does not provide a way to lookup the AccountID an access key has access to.
-* So we store a temporary mapping in the contract to lookup pubkey -> account ID.
-*/
-async function getDeviceLinkingAccountContractCall(nearClient, contractId, devicePublicKey) {
-	try {
-		const result = await nearClient.callFunction(contractId, "get_device_linking_account", { device_public_key: devicePublicKey });
-		if (result && Array.isArray(result) && result.length >= 2) {
-			const [linkedAccountId, deviceNumberRaw] = result;
-			const deviceNumber = Number(deviceNumberRaw);
-			if (!Number.isSafeInteger(deviceNumber) || deviceNumber < 0) {
-				console.warn("Invalid deviceNumber returned from get_device_linking_account:", deviceNumberRaw);
-				return null;
-			}
-			return {
-				linkedAccountId,
-				deviceNumber
-			};
-		}
-		return null;
-	} catch (error) {
-		console.warn("Failed to get device linking account:", error.message);
-		return null;
-	}
-}
-/**
-* Execute device1's linking transactions (AddKey + Contract mapping)
-* This function signs and broadcasts both transactions required for device linking
-*/
-async function executeDeviceLinkingContractCalls({ context, device1AccountId, device2PublicKey, nextNonce, nextNextNonce, nextNextNextNonce, txBlockHash, vrfChallenge, onEvent, confirmationConfigOverride, confirmerText }) {
-	const signedTransactions = await context.webAuthnManager.signTransactionsWithActions({
-		rpcCall: {
-			contractId: context.webAuthnManager.tatchiPasskeyConfigs.contractId,
-			nearRpcUrl: context.webAuthnManager.tatchiPasskeyConfigs.nearRpcUrl,
-			nearAccountId: device1AccountId
-		},
-		confirmationConfigOverride,
-		title: confirmerText?.title,
-		body: confirmerText?.body,
-		transactions: [
-			{
-				receiverId: device1AccountId,
-				actions: [{
-					action_type: ActionType.AddKey,
-					public_key: device2PublicKey,
-					access_key: JSON.stringify({
-						nonce: 0,
-						permission: { FullAccess: {} }
-					})
-				}],
-				nonce: nextNonce
-			},
-			{
-				receiverId: context.webAuthnManager.tatchiPasskeyConfigs.contractId,
-				actions: [{
-					action_type: ActionType.FunctionCall,
-					method_name: "store_device_linking_mapping",
-					args: JSON.stringify({
-						device_public_key: device2PublicKey,
-						target_account_id: device1AccountId
-					}),
-					gas: "30000000000000",
-					deposit: "0"
-				}],
-				nonce: nextNextNonce
-			},
-			{
-				receiverId: device1AccountId,
-				actions: [{
-					action_type: ActionType.DeleteKey,
-					public_key: device2PublicKey
-				}],
-				nonce: nextNextNextNonce
-			}
-		],
-		onEvent: (progress) => {
-			try {
-				onEvent?.(progress);
-			} catch {}
-			if (progress.phase == ActionPhase.STEP_6_TRANSACTION_SIGNING_COMPLETE) onEvent?.({
-				step: 3,
-				phase: DeviceLinkingPhase.STEP_3_AUTHORIZATION,
-				status: DeviceLinkingStatus.PROGRESS,
-				message: progress.message || "Transaction signing in progress..."
-			});
-		}
-	});
-	if (!signedTransactions[0].signedTransaction) throw new Error("AddKey transaction signing failed");
-	if (!signedTransactions[1].signedTransaction) throw new Error("Contract mapping transaction signing failed");
-	if (!signedTransactions[2].signedTransaction) throw new Error("DeleteKey transaction signing failed");
-	let addKeyTxResult;
-	let storeDeviceLinkingTxResult;
-	try {
-		console.debug("LinkDeviceFlow: AddKey transaction details:", {
-			receiverId: signedTransactions[0].signedTransaction.transaction.receiverId,
-			actions: signedTransactions[0].signedTransaction.transaction.actions || [],
-			transactionKeys: Object.keys(signedTransactions[0].signedTransaction.transaction)
-		});
-		addKeyTxResult = await context.nearClient.sendTransaction(signedTransactions[0].signedTransaction, DEFAULT_WAIT_STATUS.linkDeviceAddKey);
-		console.log("LinkDeviceFlow: AddKey transaction result:", addKeyTxResult?.transaction?.hash);
-		onEvent?.({
-			step: 3,
-			phase: DeviceLinkingPhase.STEP_3_AUTHORIZATION,
-			status: DeviceLinkingStatus.SUCCESS,
-			message: `AddKey transaction completed successfully!`
-		});
-		const contractTx = signedTransactions[1].signedTransaction;
-		console.log("LinkDeviceFlow: Contract mapping transaction details:", {
-			receiverId: contractTx.transaction.receiverId,
-			actions: (contractTx.transaction.actions || []).length
-		});
-		storeDeviceLinkingTxResult = await context.nearClient.sendTransaction(contractTx, DEFAULT_WAIT_STATUS.linkDeviceAccountMapping);
-	} catch (txError) {
-		console.error("LinkDeviceFlow: Transaction broadcasting failed:", txError);
-		throw new Error(`Transaction broadcasting failed: ${txError.message}`);
-	}
-	onEvent?.({
-		step: 6,
-		phase: DeviceLinkingPhase.STEP_6_REGISTRATION,
-		status: DeviceLinkingStatus.SUCCESS,
-		message: `Device linking completed successfully!`
-	});
-	return {
-		addKeyTxResult,
-		storeDeviceLinkingTxResult,
-		signedDeleteKeyTransaction: signedTransactions[2].signedTransaction
-	};
-}
-/**
-* Get credential IDs associated with an account from the contract
-* Used in account recovery to discover available credentials
-*/
-async function getCredentialIdsContractCall(nearClient, contractId, accountId) {
-	try {
-		const credentialIds = await nearClient.callFunction(contractId, "get_credential_ids_by_account", { account_id: accountId });
-		return credentialIds || [];
-	} catch (error) {
-		console.warn("Failed to fetch credential IDs from contract:", error.message);
-		return [];
-	}
-}
-/**
-* Get all authenticators stored for a user from the contract
-* Used in account recovery to sync authenticator data
-*/
-async function getAuthenticatorsByUser(nearClient, contractId, accountId) {
-	try {
-		const authenticatorsResult = await nearClient.view({
-			account: contractId,
-			method: "get_authenticators_by_user",
-			args: { user_id: accountId }
-		});
-		if (authenticatorsResult && Array.isArray(authenticatorsResult)) return authenticatorsResult;
-		return [];
-	} catch (error) {
-		console.warn("Failed to fetch authenticators from contract:", error.message);
-		return [];
-	}
-}
-async function syncAuthenticatorsContractCall(nearClient, contractId, accountId) {
-	try {
-		const authenticatorsResult = await getAuthenticatorsByUser(nearClient, contractId, accountId);
-		if (authenticatorsResult && Array.isArray(authenticatorsResult)) return authenticatorsResult.map(([credentialId, contractAuthenticator]) => {
-			console.log(`Contract authenticator device_number for ${credentialId}:`, contractAuthenticator.device_number);
-			const transports = Array.isArray(contractAuthenticator.transports) ? contractAuthenticator.transports : [];
-			const registered = (() => {
-				const raw = String(contractAuthenticator.registered ?? "");
-				if (!raw) return /* @__PURE__ */ new Date(0);
-				if (/^\d+$/.test(raw)) {
-					const ts = Number(raw);
-					return Number.isFinite(ts) ? new Date(ts) : /* @__PURE__ */ new Date(0);
-				}
-				const d = new Date(raw);
-				return Number.isFinite(d.getTime()) ? d : /* @__PURE__ */ new Date(0);
-			})();
-			const vrfPublicKeys = (() => {
-				const raw = contractAuthenticator.vrf_public_keys;
-				if (!raw) return void 0;
-				if (Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "string") return raw;
-				if (Array.isArray(raw)) return raw.map((entry) => {
-					if (!entry) return null;
-					if (entry instanceof Uint8Array) return base64UrlEncode(entry);
-					if (Array.isArray(entry)) return base64UrlEncode(new Uint8Array(entry));
-					return null;
-				}).filter((x) => typeof x === "string" && x.length > 0);
-				return void 0;
-			})();
-			return {
-				credentialId,
-				authenticator: {
-					credentialId,
-					credentialPublicKey: new Uint8Array(contractAuthenticator.credential_public_key),
-					transports,
-					userId: accountId,
-					name: `Device ${contractAuthenticator.device_number} Authenticator`,
-					registered,
-					deviceNumber: contractAuthenticator.device_number,
-					vrfPublicKeys
-				}
-			};
-		});
-		return [];
-	} catch (error) {
-		console.warn("Failed to fetch authenticators from contract:", error.message);
-		return [];
-	}
-}
-/**
-* Fetch on-chain recovery email hashes from the per-account contract.
-* Returns [] when no contract is deployed or on failure.
-*/
-async function getRecoveryEmailHashesContractCall(nearClient, accountId) {
-	try {
-		const code = await nearClient.viewCode(accountId);
-		const hasContract = !!code && code.byteLength > 0;
-		if (!hasContract) return [];
-		const hashes = await nearClient.view({
-			account: accountId,
-			method: "get_recovery_emails",
-			args: {}
-		});
-		return Array.isArray(hashes) ? hashes : [];
-	} catch (error) {
-		console.error("[rpcCalls] Failed to fetch recovery email hashes", error);
-		return [];
-	}
-}
-/**
-* Build action args to update on-chain recovery emails for an account.
-* If the per-account contract is missing, deploy/attach the global recoverer via `init_email_recovery`.
-*/
-async function buildSetRecoveryEmailsActions(nearClient, accountId, recoveryEmailHashes, contracts = DEFAULT_EMAIL_RECOVERY_CONTRACTS) {
-	let hasContract = false;
-	try {
-		const code = await nearClient.viewCode(accountId);
-		hasContract = !!code && code.byteLength > 0;
-	} catch {
-		hasContract = false;
-	}
-	const { emailRecovererGlobalContract, zkEmailVerifierContract, emailDkimVerifierContract } = contracts;
-	return hasContract ? [{
-		type: ActionType.UseGlobalContract,
-		accountId: emailRecovererGlobalContract
-	}, {
-		type: ActionType.FunctionCall,
-		methodName: "set_recovery_emails",
-		args: { recovery_emails: recoveryEmailHashes },
-		gas: "80000000000000",
-		deposit: "0"
-	}] : [{
-		type: ActionType.UseGlobalContract,
-		accountId: emailRecovererGlobalContract
-	}, {
-		type: ActionType.FunctionCall,
-		methodName: "init_email_recovery",
-		args: {
-			zk_email_verifier: zkEmailVerifierContract,
-			email_dkim_verifier: emailDkimVerifierContract,
-			policy: null,
-			recovery_emails: recoveryEmailHashes
-		},
-		gas: "80000000000000",
-		deposit: "0"
-	}];
-}
-/**
-* View-only registration pre-check.
-*
-* Calls the contract's `check_can_register_user` view method with VRF data
-* derived from the provided VRF challenge and a serialized WebAuthn
-* registration credential (typically with PRF outputs embedded).
-*/
-async function checkCanRegisterUserContractCall({ nearClient, contractId, vrfChallenge, credential, authenticatorOptions }) {
-	try {
-		const vrfData = {
-			vrf_input_data: Array.from(base64UrlDecode(vrfChallenge.vrfInput)),
-			vrf_output: Array.from(base64UrlDecode(vrfChallenge.vrfOutput)),
-			vrf_proof: Array.from(base64UrlDecode(vrfChallenge.vrfProof)),
-			public_key: Array.from(base64UrlDecode(vrfChallenge.vrfPublicKey)),
-			user_id: vrfChallenge.userId,
-			rp_id: vrfChallenge.rpId,
-			block_height: Number(vrfChallenge.blockHeight),
-			block_hash: Array.from(base64UrlDecode(vrfChallenge.blockHash))
-		};
-		const args = {
-			vrf_data: vrfData,
-			webauthn_registration: credential,
-			authenticator_options: authenticatorOptions
-		};
-		const response = await nearClient.callFunction(contractId, "check_can_register_user", args);
-		const verified = !!response?.verified;
-		return {
-			success: true,
-			verified,
-			logs: [],
-			error: verified ? void 0 : "Contract registration check failed"
-		};
-	} catch (err) {
-		return {
-			success: false,
-			verified: false,
-			logs: [],
-			error: errorMessage(err) || "Failed to call check_can_register_user"
-		};
-	}
-}
-/**
-* Verify authentication response through relay server
-* Routes the request to relay server which calls the web3authn contract for verification
-* and issues a JWT or session credential
-*/
-async function verifyAuthenticationResponse(relayServerUrl, routePath, sessionKind, vrfChallenge, webauthnAuthentication) {
-	try {
-		const toBytes = (b64u) => {
-			if (!b64u) return [];
-			return Array.from(base64UrlDecode(b64u));
-		};
-		const vrf_data = {
-			vrf_input_data: toBytes(vrfChallenge.vrfInput),
-			vrf_output: toBytes(vrfChallenge.vrfOutput),
-			vrf_proof: toBytes(vrfChallenge.vrfProof),
-			public_key: toBytes(vrfChallenge.vrfPublicKey),
-			user_id: vrfChallenge.userId,
-			rp_id: vrfChallenge.rpId,
-			block_height: Number(vrfChallenge.blockHeight || 0),
-			block_hash: toBytes(vrfChallenge.blockHash)
-		};
-		const webauthn_authentication = {
-			...webauthnAuthentication,
-			authenticatorAttachment: webauthnAuthentication.authenticatorAttachment ?? null,
-			response: {
-				...webauthnAuthentication.response,
-				userHandle: webauthnAuthentication.response.userHandle ?? null
-			}
-		};
-		const url = `${relayServerUrl.replace(/\/$/, "")}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
-		const response = await fetch(url, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			credentials: sessionKind === "cookie" ? "include" : "omit",
-			body: JSON.stringify({
-				sessionKind,
-				vrf_data,
-				webauthn_authentication
-			})
-		});
-		if (!response.ok) {
-			const errorText = await response.text();
-			return {
-				success: false,
-				error: `HTTP ${response.status}: ${errorText}`
-			};
-		}
-		const result = await response.json();
-		return {
-			success: true,
-			verified: result.verified,
-			jwt: result.jwt,
-			sessionCredential: result.sessionCredential,
-			contractResponse: result.contractResponse
-		};
-	} catch (error) {
-		return {
-			success: false,
-			error: error.message || "Failed to verify authentication response"
-		};
-	}
-}
-var init_rpcCalls = __esm({ "src/core/rpcCalls.ts": (() => {
-	init_sdkSentEvents();
-	init_actions();
-	init_rpc();
-	init_encoders();
-	init_errors();
-	init_defaultConfigs();
-}) });
-
-//#endregion
-export { buildSetRecoveryEmailsActions, checkCanRegisterUserContractCall, executeDeviceLinkingContractCalls, getAuthenticatorsByUser, getCredentialIdsContractCall, getDeviceLinkingAccountContractCall, getEmailRecoveryVerificationResult, getRecoveryEmailHashesContractCall, init_rpcCalls, syncAuthenticatorsContractCall, verifyAuthenticationResponse };

package/dist/esm/sdk/sdkSentEvents-_jrJLIhw.js

@@ -1,128 +0,0 @@
-import { __esm } from "./chunk-DIQ1yeMN.js";
-
-//#region src/core/types/rpc.ts
-var DEFAULT_WAIT_STATUS;
-var init_rpc = __esm({ "src/core/types/rpc.ts": (() => {
-	DEFAULT_WAIT_STATUS = {
-		executeAction: "EXECUTED_OPTIMISTIC",
-		linkDeviceAddKey: "INCLUDED_FINAL",
-		linkDeviceSwapKey: "FINAL",
-		linkDeviceAccountMapping: "INCLUDED_FINAL",
-		linkDeviceDeleteKey: "INCLUDED_FINAL",
-		linkDeviceRegistration: "FINAL"
-	};
-}) });
-
-//#endregion
-//#region src/core/types/sdkSentEvents.ts
-var RegistrationPhase, RegistrationStatus, LoginPhase, LoginStatus, ActionPhase, ActionStatus, AccountRecoveryPhase, AccountRecoveryStatus, DeviceLinkingPhase, DeviceLinkingStatus, EmailRecoveryPhase, EmailRecoveryStatus;
-var init_sdkSentEvents = __esm({ "src/core/types/sdkSentEvents.ts": (() => {
-	RegistrationPhase = /* @__PURE__ */ function(RegistrationPhase$1) {
-		RegistrationPhase$1["STEP_1_WEBAUTHN_VERIFICATION"] = "webauthn-verification";
-		RegistrationPhase$1["STEP_2_KEY_GENERATION"] = "key-generation";
-		RegistrationPhase$1["STEP_3_CONTRACT_PRE_CHECK"] = "contract-pre-check";
-		RegistrationPhase$1["STEP_4_ACCESS_KEY_ADDITION"] = "access-key-addition";
-		RegistrationPhase$1["STEP_5_CONTRACT_REGISTRATION"] = "contract-registration";
-		RegistrationPhase$1["STEP_6_ACCOUNT_VERIFICATION"] = "account-verification";
-		RegistrationPhase$1["STEP_7_DATABASE_STORAGE"] = "database-storage";
-		RegistrationPhase$1["STEP_8_REGISTRATION_COMPLETE"] = "registration-complete";
-		RegistrationPhase$1["REGISTRATION_ERROR"] = "error";
-		return RegistrationPhase$1;
-	}({});
-	RegistrationStatus = /* @__PURE__ */ function(RegistrationStatus$1) {
-		RegistrationStatus$1["PROGRESS"] = "progress";
-		RegistrationStatus$1["SUCCESS"] = "success";
-		RegistrationStatus$1["ERROR"] = "error";
-		return RegistrationStatus$1;
-	}({});
-	LoginPhase = /* @__PURE__ */ function(LoginPhase$1) {
-		LoginPhase$1["STEP_1_PREPARATION"] = "preparation";
-		LoginPhase$1["STEP_2_WEBAUTHN_ASSERTION"] = "webauthn-assertion";
-		LoginPhase$1["STEP_3_VRF_UNLOCK"] = "vrf-unlock";
-		LoginPhase$1["STEP_4_LOGIN_COMPLETE"] = "login-complete";
-		LoginPhase$1["LOGIN_ERROR"] = "login-error";
-		return LoginPhase$1;
-	}({});
-	LoginStatus = /* @__PURE__ */ function(LoginStatus$1) {
-		LoginStatus$1["PROGRESS"] = "progress";
-		LoginStatus$1["SUCCESS"] = "success";
-		LoginStatus$1["ERROR"] = "error";
-		return LoginStatus$1;
-	}({});
-	ActionPhase = /* @__PURE__ */ function(ActionPhase$1) {
-		ActionPhase$1["STEP_1_PREPARATION"] = "preparation";
-		ActionPhase$1["STEP_2_USER_CONFIRMATION"] = "user-confirmation";
-		ActionPhase$1["STEP_3_WEBAUTHN_AUTHENTICATION"] = "webauthn-authentication";
-		ActionPhase$1["STEP_4_AUTHENTICATION_COMPLETE"] = "authentication-complete";
-		ActionPhase$1["STEP_5_TRANSACTION_SIGNING_PROGRESS"] = "transaction-signing-progress";
-		ActionPhase$1["STEP_6_TRANSACTION_SIGNING_COMPLETE"] = "transaction-signing-complete";
-		ActionPhase$1["WASM_ERROR"] = "wasm-error";
-		ActionPhase$1["STEP_7_BROADCASTING"] = "broadcasting";
-		ActionPhase$1["STEP_8_ACTION_COMPLETE"] = "action-complete";
-		ActionPhase$1["ACTION_ERROR"] = "action-error";
-		return ActionPhase$1;
-	}({});
-	ActionStatus = /* @__PURE__ */ function(ActionStatus$1) {
-		ActionStatus$1["PROGRESS"] = "progress";
-		ActionStatus$1["SUCCESS"] = "success";
-		ActionStatus$1["ERROR"] = "error";
-		return ActionStatus$1;
-	}({});
-	AccountRecoveryPhase = /* @__PURE__ */ function(AccountRecoveryPhase$1) {
-		AccountRecoveryPhase$1["STEP_1_PREPARATION"] = "preparation";
-		AccountRecoveryPhase$1["STEP_2_WEBAUTHN_AUTHENTICATION"] = "webauthn-authentication";
-		AccountRecoveryPhase$1["STEP_3_SYNC_AUTHENTICATORS_ONCHAIN"] = "sync-authenticators-onchain";
-		AccountRecoveryPhase$1["STEP_4_AUTHENTICATOR_SAVED"] = "authenticator-saved";
-		AccountRecoveryPhase$1["STEP_5_ACCOUNT_RECOVERY_COMPLETE"] = "account-recovery-complete";
-		AccountRecoveryPhase$1["ERROR"] = "error";
-		return AccountRecoveryPhase$1;
-	}({});
-	AccountRecoveryStatus = /* @__PURE__ */ function(AccountRecoveryStatus$1) {
-		AccountRecoveryStatus$1["PROGRESS"] = "progress";
-		AccountRecoveryStatus$1["SUCCESS"] = "success";
-		AccountRecoveryStatus$1["ERROR"] = "error";
-		return AccountRecoveryStatus$1;
-	}({});
-	DeviceLinkingPhase = /* @__PURE__ */ function(DeviceLinkingPhase$1) {
-		DeviceLinkingPhase$1["STEP_1_QR_CODE_GENERATED"] = "qr-code-generated";
-		DeviceLinkingPhase$1["STEP_2_SCANNING"] = "scanning";
-		DeviceLinkingPhase$1["STEP_3_AUTHORIZATION"] = "authorization";
-		DeviceLinkingPhase$1["STEP_4_POLLING"] = "polling";
-		DeviceLinkingPhase$1["STEP_5_ADDKEY_DETECTED"] = "addkey-detected";
-		DeviceLinkingPhase$1["STEP_6_REGISTRATION"] = "registration";
-		DeviceLinkingPhase$1["STEP_7_LINKING_COMPLETE"] = "linking-complete";
-		DeviceLinkingPhase$1["STEP_8_AUTO_LOGIN"] = "auto-login";
-		DeviceLinkingPhase$1["IDLE"] = "idle";
-		DeviceLinkingPhase$1["REGISTRATION_ERROR"] = "registration-error";
-		DeviceLinkingPhase$1["LOGIN_ERROR"] = "login-error";
-		DeviceLinkingPhase$1["DEVICE_LINKING_ERROR"] = "error";
-		return DeviceLinkingPhase$1;
-	}({});
-	DeviceLinkingStatus = /* @__PURE__ */ function(DeviceLinkingStatus$1) {
-		DeviceLinkingStatus$1["PROGRESS"] = "progress";
-		DeviceLinkingStatus$1["SUCCESS"] = "success";
-		DeviceLinkingStatus$1["ERROR"] = "error";
-		return DeviceLinkingStatus$1;
-	}({});
-	EmailRecoveryPhase = /* @__PURE__ */ function(EmailRecoveryPhase$1) {
-		EmailRecoveryPhase$1["STEP_1_PREPARATION"] = "email-recovery-preparation";
-		EmailRecoveryPhase$1["STEP_2_TOUCH_ID_REGISTRATION"] = "email-recovery-touch-id-registration";
-		EmailRecoveryPhase$1["STEP_3_AWAIT_EMAIL"] = "email-recovery-await-email";
-		EmailRecoveryPhase$1["STEP_4_POLLING_ADD_KEY"] = "email-recovery-polling-add-key";
-		EmailRecoveryPhase$1["STEP_4_POLLING_VERIFICATION_RESULT"] = "email-recovery-polling-add-key";
-		EmailRecoveryPhase$1["STEP_5_FINALIZING_REGISTRATION"] = "email-recovery-finalizing-registration";
-		EmailRecoveryPhase$1["STEP_6_COMPLETE"] = "email-recovery-complete";
-		EmailRecoveryPhase$1["ERROR"] = "email-recovery-error";
-		EmailRecoveryPhase$1["RESUMED_FROM_PENDING"] = "email-recovery-resumed-from-pending";
-		return EmailRecoveryPhase$1;
-	}({});
-	EmailRecoveryStatus = /* @__PURE__ */ function(EmailRecoveryStatus$1) {
-		EmailRecoveryStatus$1["PROGRESS"] = "progress";
-		EmailRecoveryStatus$1["SUCCESS"] = "success";
-		EmailRecoveryStatus$1["ERROR"] = "error";
-		return EmailRecoveryStatus$1;
-	}({});
-}) });
-
-//#endregion
-export { AccountRecoveryPhase, AccountRecoveryStatus, ActionPhase, ActionStatus, DEFAULT_WAIT_STATUS, DeviceLinkingPhase, DeviceLinkingStatus, EmailRecoveryPhase, EmailRecoveryStatus, LoginPhase, LoginStatus, RegistrationPhase, RegistrationStatus, init_rpc, init_sdkSentEvents };

package/dist/esm/sdk/tags-C2Wlhqjd.js

@@ -1,47 +0,0 @@
-//#region src/core/WebAuthnManager/LitComponents/tags.ts
-const W3A_BUTTON_WITH_TOOLTIP_ID = "w3a-button-with-tooltip";
-const W3A_TX_BUTTON_ID = "w3a-tx-button";
-const W3A_TX_BUTTON_HOST_ID = "w3a-tx-button-host";
-const TAG_DEFS = {
-	txButton: {
-		id: W3A_TX_BUTTON_ID,
-		aliases: []
-	},
-	txHost: {
-		id: W3A_TX_BUTTON_HOST_ID,
-		aliases: ["w3a-wallet-tx-host"]
-	}
-};
-/** Define a custom element for canonical and alias tags (no-throw). */
-function defineTag(key, ctor) {
-	const def = TAG_DEFS[key];
-	try {
-		if (!customElements.get(def.id)) customElements.define(def.id, ctor);
-	} catch {}
-	const aliases = def.aliases || [];
-	for (const alias of aliases) try {
-		if (!customElements.get(alias)) customElements.define(alias, ctor);
-	} catch {}
-}
-const IFRAME_TX_BUTTON_BOOTSTRAP_MODULE = "iframe-tx-button-bootstrap.js";
-const W3A_TX_CONFIRMER_ID = "w3a-tx-confirmer";
-const W3A_MODAL_TX_CONFIRMER_ID = "w3a-modal-tx-confirmer";
-const W3A_DRAWER_TX_CONFIRMER_ID = "w3a-drawer-tx-confirmer";
-const W3A_TX_CONFIRM_CONTENT_ID = "w3a-tx-confirm-content";
-const W3A_DRAWER_ID = "w3a-drawer";
-const W3A_TX_TREE_ID = "w3a-tx-tree";
-const W3A_HALO_BORDER_ID = "w3a-halo-border";
-const W3A_PASSKEY_HALO_LOADING_ID = "w3a-passkey-halo-loading";
-const CONFIRM_UI_ELEMENT_SELECTORS = [
-	W3A_TX_CONFIRMER_ID,
-	W3A_MODAL_TX_CONFIRMER_ID,
-	W3A_DRAWER_TX_CONFIRMER_ID
-];
-const W3A_CONFIRM_PORTAL_ID = "w3a-confirm-portal";
-const W3A_EXPORT_VIEWER_IFRAME_ID = "w3a-export-viewer-iframe";
-const W3A_EXPORT_KEY_VIEWER_ID = "w3a-export-key-viewer";
-const IFRAME_EXPORT_BOOTSTRAP_MODULE = "iframe-export-bootstrap.js";
-const EXPORT_VIEWER_BUNDLE = "export-private-key-viewer.js";
-
-//#endregion
-export { CONFIRM_UI_ELEMENT_SELECTORS, EXPORT_VIEWER_BUNDLE, IFRAME_EXPORT_BOOTSTRAP_MODULE, IFRAME_TX_BUTTON_BOOTSTRAP_MODULE, W3A_BUTTON_WITH_TOOLTIP_ID, W3A_CONFIRM_PORTAL_ID, W3A_DRAWER_ID, W3A_DRAWER_TX_CONFIRMER_ID, W3A_EXPORT_KEY_VIEWER_ID, W3A_EXPORT_VIEWER_IFRAME_ID, W3A_HALO_BORDER_ID, W3A_MODAL_TX_CONFIRMER_ID, W3A_PASSKEY_HALO_LOADING_ID, W3A_TX_BUTTON_HOST_ID, W3A_TX_BUTTON_ID, W3A_TX_CONFIRMER_ID, W3A_TX_CONFIRM_CONTENT_ID, W3A_TX_TREE_ID, defineTag };