@tatchi-xyz/sdk 0.20.0 → 0.31.0

package/dist/esm/sdk/createAdapters-1Hmc1vVC.js

@@ -0,0 +1,524 @@
+import { WalletIframeDomEvents } from "./events-D2g80q67.js";
+import { isActionArgsWasm, toActionArgsWasm } from "./actions-fHadejPs.js";
+import { computeUiIntentDigestFromNep413, computeUiIntentDigestFromTxs, orderActionForDigest, sha256Base64UrlUtf8 } from "./intentDigest-yivVENNK.js";
+import { CONFIRM_UI_ELEMENT_SELECTORS, W3A_CONFIRM_PORTAL_ID, W3A_TX_CONFIRMER_ID } from "./tags-ByzxP7Cc.js";
+import { TxConfirmerWrapperElement } from "./tx-confirmer-wrapper-DWKpXTUW.js";
+import { errorMessage, toError } from "./errors-DevlT39D.js";
+import { SecureConfirmationType, collectAuthenticationCredentialForVrfChallenge, getNearAccountId, getSignTransactionPayload, sendConfirmResponse } from "./collectAuthenticationCredentialForVrfChallenge-DqzPzwvU.js";
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/near.ts
+async function fetchNearContext(ctx, opts) {
+	try {
+		const transactionContext = await ctx.nonceManager.getNonceBlockHashAndHeight(ctx.nearClient);
+		const txCount = opts.txCount || 1;
+		let reservedNonces;
+		if (opts.reserveNonces) try {
+			reservedNonces = ctx.nonceManager.reserveNonces(txCount);
+			transactionContext.nextNonce = reservedNonces[0];
+		} catch (error) {}
+		return {
+			transactionContext,
+			reservedNonces
+		};
+	} catch (error) {
+		try {
+			const block = await ctx.nearClient.viewBlock({ finality: "final" });
+			const txBlockHeight = String(block?.header?.height ?? "");
+			const txBlockHash = String(block?.header?.hash ?? "");
+			const fallback = {
+				nearPublicKeyStr: "",
+				accessKeyInfo: {
+					nonce: 0,
+					permission: "FullAccess",
+					block_height: 0,
+					block_hash: ""
+				},
+				nextNonce: "0",
+				txBlockHeight,
+				txBlockHash
+			};
+			return { transactionContext: fallback };
+		} catch (e) {
+			return {
+				transactionContext: null,
+				error: "NEAR_RPC_FAILED",
+				details: errorMessage(e) || errorMessage(error)
+			};
+		}
+	}
+}
+function releaseReservedNonces(ctx, nonces) {
+	nonces?.forEach((n) => ctx.nonceManager.releaseNonce(n));
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/vrf.ts
+async function maybeRefreshVrfChallenge(ctx, request, nearAccountId) {
+	const vrfWorkerManager = ctx.vrfWorkerManager;
+	if (!vrfWorkerManager) throw new Error("VrfWorkerManager not available");
+	if (!ctx.nonceManager.nearAccountId || !ctx.nonceManager.nearPublicKeyStr || ctx.nonceManager.nearAccountId !== nearAccountId) throw new Error("NonceManager not initialized with user data");
+	const rpId = ctx.touchIdPrompt.getRpId();
+	let sessionPolicyDigest32;
+	let intentDigestB64u;
+	switch (request.type) {
+		case SecureConfirmationType.SIGN_TRANSACTION:
+			sessionPolicyDigest32 = request.payload.sessionPolicyDigest32;
+			intentDigestB64u = request.payload.intentDigest;
+			break;
+		case SecureConfirmationType.SIGN_NEP413_MESSAGE:
+			sessionPolicyDigest32 = request.payload.sessionPolicyDigest32;
+			intentDigestB64u = await computeUiIntentDigestFromNep413({
+				nearAccountId,
+				recipient: request.payload.recipient,
+				message: request.payload.message
+			});
+			break;
+		case SecureConfirmationType.REGISTER_ACCOUNT:
+		case SecureConfirmationType.LINK_DEVICE:
+			intentDigestB64u = request.intentDigest ? await sha256Base64UrlUtf8(request.intentDigest) : void 0;
+			break;
+		default: break;
+	}
+	const attempts = 3;
+	return await retryWithBackoff(async () => {
+		const latestCtx = await ctx.nonceManager.getNonceBlockHashAndHeight(ctx.nearClient, { force: true });
+		const vrfChallenge = request.type === SecureConfirmationType.REGISTER_ACCOUNT || request.type === SecureConfirmationType.LINK_DEVICE ? (await vrfWorkerManager.generateVrfKeypairBootstrap({
+			vrfInputData: {
+				userId: nearAccountId,
+				rpId,
+				blockHeight: latestCtx.txBlockHeight,
+				blockHash: latestCtx.txBlockHash,
+				...intentDigestB64u ? { intentDigest: intentDigestB64u } : {}
+			},
+			saveInMemory: true,
+			sessionId: request.requestId
+		})).vrfChallenge : await vrfWorkerManager.generateVrfChallengeForSession({
+			userId: nearAccountId,
+			rpId,
+			blockHeight: latestCtx.txBlockHeight,
+			blockHash: latestCtx.txBlockHash,
+			...intentDigestB64u ? { intentDigest: intentDigestB64u } : {},
+			...sessionPolicyDigest32 ? { sessionPolicyDigest32 } : {}
+		}, request.requestId);
+		return {
+			vrfChallenge,
+			transactionContext: latestCtx
+		};
+	}, {
+		attempts,
+		baseDelayMs: 150,
+		onError: (err, attempt) => {
+			const msg = errorMessage(err);
+			const isFinal = attempt >= attempts;
+			if (isFinal) console.warn(`[SecureConfirm] VRF refresh failed: ${msg}`);
+			else console.debug(`[SecureConfirm] VRF refresh attempt ${attempt} failed: ${msg}`);
+		},
+		errorFactory: () => /* @__PURE__ */ new Error("VRF refresh failed")
+	});
+}
+async function retryWithBackoff(fn, options) {
+	const { attempts, baseDelayMs, onError, errorFactory } = options;
+	let lastError;
+	for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) try {
+		return await fn(attempt);
+	} catch (err) {
+		lastError = err;
+		onError?.(err, attempt);
+		if (attempt < attempts) {
+			const delay = baseDelayMs * attempt;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	throw errorFactory ? errorFactory() : toError(lastError ?? /* @__PURE__ */ new Error("Retry exhausted"));
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/LitComponents/confirm-ui-types.ts
+function validateTheme(s) {
+	return s === "dark" || s === "light" ? s : void 0;
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/LitComponents/confirm-ui.ts
+try {
+	if (typeof customElements !== "undefined" && !customElements.get(W3A_TX_CONFIRMER_ID)) customElements.define(W3A_TX_CONFIRMER_ID, TxConfirmerWrapperElement);
+} catch {}
+function resolveTheme(ctx, requested) {
+	let resolved = validateTheme(requested);
+	if (!resolved) try {
+		resolved = validateTheme(ctx?.userPreferencesManager?.getUserTheme?.());
+	} catch {}
+	if (!resolved) {
+		const domAttr = (document?.documentElement?.getAttribute("data-w3a-theme") || "").toLowerCase();
+		resolved = validateTheme(domAttr);
+	}
+	return resolved || "dark";
+}
+async function mountConfirmUI({ ctx, summary, txSigningRequests, vrfChallenge, loading, theme, uiMode, nearAccountIdOverride }) {
+	const variant = uiModeToVariant(uiMode);
+	const { handle } = mountHostElement({
+		ctx,
+		summary,
+		txSigningRequests,
+		vrfChallenge,
+		loading,
+		theme,
+		variant,
+		nearAccountIdOverride
+	});
+	return handle;
+}
+async function awaitConfirmUIDecision({ ctx, summary, txSigningRequests, vrfChallenge, theme, uiMode, nearAccountIdOverride }) {
+	const variant = uiModeToVariant(uiMode);
+	const v = variant || "modal";
+	return new Promise((resolve) => {
+		const { el, handle } = mountHostElement({
+			ctx,
+			summary,
+			txSigningRequests,
+			vrfChallenge,
+			theme,
+			variant: v,
+			nearAccountIdOverride
+		});
+		const finalize = (result) => {
+			cleanup();
+			resolve({
+				...result,
+				handle
+			});
+		};
+		const onConfirm = async (event) => {
+			const detail = event?.detail;
+			let confirmed = detail?.confirmed !== false;
+			let error = typeof detail?.error === "string" ? detail.error : void 0;
+			if (confirmed) {
+				const guardErr = await checkIntentDigestGuard(summary, txSigningRequests);
+				if (guardErr) {
+					confirmed = false;
+					if (!error) error = guardErr;
+				}
+			}
+			if (!confirmed) {
+				if (error) handle.update({
+					errorMessage: error,
+					loading: false
+				});
+				else handle.update({
+					loading: false,
+					errorMessage: ""
+				});
+				finalize({
+					confirmed: false,
+					error
+				});
+				return;
+			}
+			finalize({ confirmed: true });
+		};
+		const onCancel = (event) => {
+			const detail = event?.detail;
+			const error = typeof detail?.error === "string" ? detail.error : void 0;
+			if (error) handle.update({
+				errorMessage: error,
+				loading: false
+			});
+			else handle.update({ loading: false });
+			finalize({
+				confirmed: false,
+				error
+			});
+		};
+		const cleanup = () => {
+			el.removeEventListener(WalletIframeDomEvents.TX_CONFIRMER_CONFIRM, onConfirm);
+			el.removeEventListener(WalletIframeDomEvents.TX_CONFIRMER_CANCEL, onCancel);
+		};
+		el.addEventListener(WalletIframeDomEvents.TX_CONFIRMER_CONFIRM, onConfirm);
+		el.addEventListener(WalletIframeDomEvents.TX_CONFIRMER_CANCEL, onCancel);
+	});
+}
+async function checkIntentDigestGuard(summary, txSigningRequests) {
+	const hasTxs = (txSigningRequests?.length || 0) > 0;
+	const expected = summary?.intentDigest;
+	if (!hasTxs || !expected) return void 0;
+	try {
+		const normalized = (txSigningRequests || []).map((tx) => ({
+			receiverId: tx.receiverId,
+			actions: (tx.actions || []).map((a) => isActionArgsWasm(a) ? a : toActionArgsWasm(a)).map((a) => orderActionForDigest(a))
+		}));
+		const uiDigest = await computeUiIntentDigestFromTxs(normalized);
+		if (uiDigest !== expected) return "INTENT_DIGEST_MISMATCH";
+		return void 0;
+	} catch {
+		return "UI_DIGEST_VALIDATION_FAILED";
+	}
+}
+function createHostConfirmHandle(el) {
+	return {
+		close: (_confirmed) => {
+			el.remove();
+		},
+		update: (props) => applyHostElementProps(el, props)
+	};
+}
+function setErrorAttribute(el, msg) {
+	if (msg) el.setAttribute("data-error-message", msg);
+	else el.removeAttribute("data-error-message");
+}
+function applyHostElementProps(el, props) {
+	if (!props) return;
+	if (props.nearAccountId != null) el.nearAccountId = props.nearAccountId;
+	if (props.txSigningRequests != null) el.txSigningRequests = props.txSigningRequests;
+	if (props.vrfChallenge != null) el.vrfChallenge = props.vrfChallenge;
+	if (props.theme != null) el.theme = props.theme;
+	if (props.loading != null) el.loading = !!props.loading;
+	if (props.body != null) el.body = props.body;
+	if (props.title != null) el.title = props.title;
+	if ("errorMessage" in props) {
+		const msg = props.errorMessage ?? "";
+		el.errorMessage = msg;
+		setErrorAttribute(el, msg);
+	}
+	if (props.nearExplorerUrl != null) el.nearExplorerUrl = props.nearExplorerUrl;
+	el.requestUpdate?.();
+}
+function cleanupExistingConfirmers() {
+	const portal = document.getElementById(W3A_CONFIRM_PORTAL_ID);
+	if (portal) {
+		const existing = Array.from(portal.querySelectorAll("*"));
+		for (const el of existing) el.dispatchEvent(new CustomEvent(WalletIframeDomEvents.TX_CONFIRMER_CANCEL, {
+			bubbles: true,
+			composed: true
+		}));
+		portal.replaceChildren();
+		return;
+	}
+	const selectors = CONFIRM_UI_ELEMENT_SELECTORS;
+	const els = selectors.flatMap((sel) => Array.from(document.querySelectorAll(sel)));
+	for (const el of els) {
+		el.dispatchEvent(new CustomEvent(WalletIframeDomEvents.TX_CONFIRMER_CANCEL, {
+			bubbles: true,
+			composed: true
+		}));
+		el.remove();
+	}
+}
+function ensureConfirmPortal() {
+	let portal = document.getElementById(W3A_CONFIRM_PORTAL_ID);
+	if (!portal) {
+		portal = document.createElement("div");
+		portal.id = W3A_CONFIRM_PORTAL_ID;
+		portal.classList.add("w3a-portal");
+		const root = document.body ?? document.documentElement;
+		if (root) root.appendChild(portal);
+	}
+	return portal;
+}
+function uiModeToVariant(uiMode) {
+	return uiMode === "drawer" ? "drawer" : "modal";
+}
+function mountHostElement({ ctx, summary, txSigningRequests, vrfChallenge, loading, theme, variant, nearAccountIdOverride }) {
+	const v = variant || "modal";
+	cleanupExistingConfirmers();
+	const el = document.createElement(W3A_TX_CONFIRMER_ID);
+	el.variant = v;
+	el.nearAccountId = nearAccountIdOverride || ctx.userPreferencesManager.getCurrentUserAccountId() || "";
+	el.txSigningRequests = txSigningRequests || [];
+	if (ctx.nearExplorerUrl) el.nearExplorerUrl = ctx.nearExplorerUrl;
+	if ((txSigningRequests?.length || 0) > 0) el.intentDigest = summary?.intentDigest;
+	if (vrfChallenge) el.vrfChallenge = vrfChallenge;
+	el.theme = resolveTheme(ctx, theme);
+	if (loading != null) el.loading = !!loading;
+	el.removeAttribute("data-error-message");
+	el.deferClose = true;
+	if (summary?.title != null) el.title = summary.title;
+	if (summary?.body != null) el.body = summary.body;
+	if (summary?.delegate && summary?.title == null) el.title = "Sign Delegate Action";
+	const portal = ensureConfirmPortal();
+	portal.classList.remove("w3a-portal--visible");
+	portal.replaceChildren(el);
+	requestAnimationFrame(() => {
+		portal.classList.add("w3a-portal--visible");
+	});
+	const handle = createHostConfirmHandle(el);
+	return {
+		el,
+		handle
+	};
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/ui.ts
+function closeModalSafely(confirmed, handle) {
+	handle?.close?.(confirmed);
+}
+async function renderConfirmUI({ ctx, request, confirmationConfig, transactionSummary, vrfChallenge }) {
+	const nearAccountIdForUi = getNearAccountId(request);
+	const uiMode = confirmationConfig.uiMode;
+	const txSigningRequests = request.type === SecureConfirmationType.SIGN_TRANSACTION ? getSignTransactionPayload(request).txSigningRequests : [];
+	const renderDrawerOrModal = async (mode) => {
+		if (confirmationConfig.behavior === "autoProceed") {
+			const handle$1 = await mountConfirmUI({
+				ctx,
+				summary: transactionSummary,
+				txSigningRequests,
+				vrfChallenge,
+				loading: true,
+				theme: confirmationConfig.theme,
+				uiMode: mode,
+				nearAccountIdOverride: nearAccountIdForUi
+			});
+			const delay = confirmationConfig.autoProceedDelay ?? 0;
+			await new Promise((r) => setTimeout(r, delay));
+			return {
+				confirmed: true,
+				confirmHandle: handle$1
+			};
+		}
+		const { confirmed, handle, error } = await awaitConfirmUIDecision({
+			ctx,
+			summary: transactionSummary,
+			txSigningRequests,
+			vrfChallenge,
+			theme: confirmationConfig.theme,
+			uiMode: mode,
+			nearAccountIdOverride: nearAccountIdForUi
+		});
+		return {
+			confirmed,
+			confirmHandle: handle,
+			error
+		};
+	};
+	switch (uiMode) {
+		case "skip": return {
+			confirmed: true,
+			confirmHandle: void 0
+		};
+		case "drawer": return await renderDrawerOrModal("drawer");
+		case "modal": return await renderDrawerOrModal("modal");
+		default: {
+			const handle = await mountConfirmUI({
+				ctx,
+				summary: transactionSummary,
+				txSigningRequests,
+				vrfChallenge,
+				loading: true,
+				theme: confirmationConfig.theme,
+				uiMode: "modal",
+				nearAccountIdOverride: nearAccountIdForUi
+			});
+			return {
+				confirmed: true,
+				confirmHandle: handle
+			};
+		}
+	}
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/webauthn.ts
+async function collectAuthenticationCredentialWithPRF({ ctx, nearAccountId, vrfChallenge, onBeforePrompt, includeSecondPrfOutput = false }) {
+	return collectAuthenticationCredentialForVrfChallenge({
+		indexedDB: ctx.indexedDB,
+		touchIdPrompt: ctx.touchIdPrompt,
+		nearAccountId,
+		vrfChallenge,
+		includeSecondPrfOutput,
+		onBeforePrompt
+	});
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/session.ts
+function createConfirmSession({ adapters, worker, request, confirmationConfig, transactionSummary }) {
+	let reservedNonces;
+	let confirmHandle;
+	const setReservedNonces = (nonces) => {
+		reservedNonces = nonces;
+	};
+	const updateUI = (props) => {
+		confirmHandle?.update?.(props);
+	};
+	const promptUser = async ({ vrfChallenge }) => {
+		const { confirmed, confirmHandle: handle, error } = await adapters.ui.renderConfirmUI({
+			request,
+			confirmationConfig,
+			transactionSummary,
+			vrfChallenge
+		});
+		confirmHandle = handle;
+		return {
+			confirmed,
+			error
+		};
+	};
+	const confirmAndCloseModal = (decision) => {
+		try {
+			sendConfirmResponse(worker, decision);
+		} finally {
+			if (!decision.confirmed) adapters.near.releaseReservedNonces(reservedNonces);
+			adapters.ui.closeModalSafely(!!decision.confirmed, confirmHandle);
+		}
+	};
+	const cleanupAndRethrow = (err) => {
+		try {
+			adapters.near.releaseReservedNonces(reservedNonces);
+			adapters.ui.closeModalSafely(false, confirmHandle);
+		} finally {
+			throw err;
+		}
+	};
+	return {
+		setReservedNonces,
+		updateUI,
+		promptUser,
+		confirmAndCloseModal,
+		cleanupAndRethrow
+	};
+}
+
+//#endregion
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/adapters/createAdapters.ts
+function getVrfWorkerManager(ctx) {
+	const vrfWorkerManager = ctx.vrfWorkerManager;
+	if (!vrfWorkerManager) throw new Error("VrfWorkerManager not available");
+	return vrfWorkerManager;
+}
+function createConfirmTxFlowAdapters(ctx) {
+	return {
+		near: {
+			fetchNearContext: (opts) => fetchNearContext(ctx, opts),
+			releaseReservedNonces: (nonces) => releaseReservedNonces(ctx, nonces)
+		},
+		vrf: {
+			getRpId: () => ctx.touchIdPrompt.getRpId(),
+			maybeRefreshVrfChallenge: (request, nearAccountId) => maybeRefreshVrfChallenge(ctx, request, nearAccountId),
+			generateVrfKeypairBootstrap: (args) => getVrfWorkerManager(ctx).generateVrfKeypairBootstrap(args),
+			generateVrfChallengeForSession: (inputData, sessionId) => getVrfWorkerManager(ctx).generateVrfChallengeForSession(inputData, sessionId),
+			mintSessionKeysAndSendToSigner: (args) => getVrfWorkerManager(ctx).mintSessionKeysAndSendToSigner(args),
+			dispenseSessionKey: (args) => getVrfWorkerManager(ctx).dispenseSessionKey(args),
+			prepareDecryptSession: (args) => getVrfWorkerManager(ctx).prepareDecryptSession(args),
+			requestRegistrationCredentialConfirmation: (args) => getVrfWorkerManager(ctx).requestRegistrationCredentialConfirmation(args),
+			confirmAndDeriveDevice2RegistrationSession: (args) => getVrfWorkerManager(ctx).confirmAndDeriveDevice2RegistrationSession(args),
+			checkVrfStatus: () => getVrfWorkerManager(ctx).checkVrfStatus()
+		},
+		webauthn: {
+			collectAuthenticationCredentialWithPRF: (args) => collectAuthenticationCredentialWithPRF({
+				ctx,
+				...args
+			}),
+			createRegistrationCredential: (args) => ctx.touchIdPrompt.generateRegistrationCredentialsInternal(args)
+		},
+		ui: {
+			renderConfirmUI: (args) => renderConfirmUI({
+				ctx,
+				...args
+			}),
+			closeModalSafely
+		}
+	};
+}
+
+//#endregion
+export { createConfirmSession, createConfirmTxFlowAdapters };