@tatchi-xyz/sdk 0.19.0 → 0.21.0

package/dist/esm/sdk/wallet-iframe-host.js

@@ -6,7 +6,7 @@ import "./asset-base-K63RlTrt.js";
 import "./tx-tree-themes-BND0SU2h.js";
 import { CONFIRM_UI_ELEMENT_SELECTORS, W3A_TX_BUTTON_HOST_ID, W3A_TX_BUTTON_ID, defineTag } from "./tags-C2Wlhqjd.js";
 import { WalletIframeDomEvents, computeUiIntentDigestFromTxs, orderActionForDigest } from "./txDigest-CxjhSCgm.js";
-import { base64UrlDecode } from "./base64-DBPGuXh4.js";
+import { base64Decode, base64UrlDecode, init_base64 } from "./base64-DBPGuXh4.js";
 import { ActionType, init_actions, toActionArgsWasm, validateActionArgsWasm } from "./actions-O1FD5Bq8.js";
 import { ensureKnownW3aElement } from "./ensure-defined-CHInSx7l.js";
 import { base58Encode, errorMessage, esm_default, getNearShortErrorMessage, getUserFriendlyErrorMessage, init_base58, init_encoders, init_errors, init_esm, isTouchIdCancellationError, toError } from "./errors-D9ar28Dr.js";
@@ -14,8 +14,8 @@ import { init_credentialsHelpers, init_utils, init_validation as init_validation
 import { MinimalNearClient, SignedTransaction, isOffline, openOfflineExport } from "./overlay-ZGbucXIa.js";
 import { AccountRecoveryPhase, AccountRecoveryStatus, ActionPhase, ActionStatus, DEFAULT_WAIT_STATUS, DeviceLinkingPhase, DeviceLinkingStatus, EmailRecoveryPhase, EmailRecoveryStatus, LoginPhase, LoginStatus, RegistrationPhase, RegistrationStatus, init_rpc, init_sdkSentEvents } from "./sdkSentEvents-_jrJLIhw.js";
 import { SecureConfirmMessageType, SecureConfirmationType, TouchIdPrompt, authenticatorsToAllowCredentials, createRandomVRFChallenge, getIntentDigest, init_accountIds, init_touchIdPrompt, init_vrf_worker, parseTransactionSummary, sanitizeForPostMessage, sendConfirmResponse, toAccountId, validateVRFChallenge } from "./requestHelpers-Dh1hEYL9.js";
-import { PASSKEY_MANAGER_DEFAULT_CONFIGS, buildConfigsFromEnv, init_defaultConfigs } from "./defaultConfigs-DpslkAQd.js";
-import { buildSetRecoveryEmailsActions, checkCanRegisterUserContractCall, executeDeviceLinkingContractCalls, getCredentialIdsContractCall, getDeviceLinkingAccountContractCall, getRecoveryEmailHashesContractCall, init_rpcCalls, syncAuthenticatorsContractCall, verifyAuthenticationResponse } from "./rpcCalls-YVeUVMk2.js";
+import { PASSKEY_MANAGER_DEFAULT_CONFIGS, buildConfigsFromEnv, init_defaultConfigs } from "./defaultConfigs-CfQDV-ya.js";
+import { buildSetRecoveryEmailsActions, checkCanRegisterUserContractCall, executeDeviceLinkingContractCalls, getCredentialIdsContractCall, getDeviceLinkingAccountContractCall, getEmailRecoveryAttempt, getRecoveryEmailHashesContractCall, init_rpcCalls, syncAuthenticatorsContractCall, verifyAuthenticationResponse } from "./rpcCalls-DZZSa-sk.js";
 import { getLastLoggedInDeviceNumber, init_getDeviceNumber, parseDeviceNumber } from "./getDeviceNumber-zsOHT_Um.js";
 
 //#region src/core/sdkPaths/workers.ts
@@ -2226,6 +2226,7 @@ init_utils();
 init_encoders();
 init_base58();
 init_esm();
+init_base64();
 /**
 * Control messages exchanged between worker shims and the main thread.
 *
@@ -2666,10 +2667,480 @@ async function signTransactionsWithActions$1({ ctx, transactions, rpcCall, onEve
 	}
 }
 
+//#endregion
+//#region ../node_modules/.pnpm/@noble+ed25519@2.3.0/node_modules/@noble/ed25519/index.js
+var ed25519_CURVE, P, N, Gx, Gy, _a, _d, h, L, L2, err, isBig, isStr, isBytes, abytes, u8n, u8fr, padh, bytesToHex$1, C, _ch, hexToBytes, toU8, cr, subtle, concatBytes, randomBytes, big, arange, M, modN, invert, callHash, apoint, B256, Point, G, I, numTo32bLE, bytesToNumLE, pow2, pow_2_252_3, RM1, uvRatio, modL_LE, sha512a, sha512s, hash2extK, getExtendedPublicKeyAsync, getExtendedPublicKey, getPublicKeyAsync, etc, utils, W, scalarBits, pwindows, pwindowSize, precompute, Gpows, ctneg, wNAF;
+var init_ed25519 = __esm({ "../node_modules/.pnpm/@noble+ed25519@2.3.0/node_modules/@noble/ed25519/index.js": (() => {
+	ed25519_CURVE = {
+		p: 57896044618658097711785492504343953926634992332820282019728792003956564819949n,
+		n: 7237005577332262213973186563042994240857116359379907606001950938285454250989n,
+		h: 8n,
+		a: 57896044618658097711785492504343953926634992332820282019728792003956564819948n,
+		d: 37095705934669439343138083508754565189542113879843219016388785533085940283555n,
+		Gx: 15112221349535400772501151409588531511454012693041857206046113283949847762202n,
+		Gy: 46316835694926478169428394003475163141307993866256225615783033603165251855960n
+	};
+	({p: P, n: N, Gx, Gy, a: _a, d: _d} = ed25519_CURVE);
+	h = 8n;
+	L = 32;
+	L2 = 64;
+	err = (m = "") => {
+		throw new Error(m);
+	};
+	isBig = (n) => typeof n === "bigint";
+	isStr = (s) => typeof s === "string";
+	isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+	abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
+	u8n = (len) => new Uint8Array(len);
+	u8fr = (buf) => Uint8Array.from(buf);
+	padh = (n, pad) => n.toString(16).padStart(pad, "0");
+	bytesToHex$1 = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+	C = {
+		_0: 48,
+		_9: 57,
+		A: 65,
+		F: 70,
+		a: 97,
+		f: 102
+	};
+	_ch = (ch) => {
+		if (ch >= C._0 && ch <= C._9) return ch - C._0;
+		if (ch >= C.A && ch <= C.F) return ch - (C.A - 10);
+		if (ch >= C.a && ch <= C.f) return ch - (C.a - 10);
+	};
+	hexToBytes = (hex) => {
+		const e = "hex invalid";
+		if (!isStr(hex)) return err(e);
+		const hl = hex.length;
+		const al = hl / 2;
+		if (hl % 2) return err(e);
+		const array = u8n(al);
+		for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+			const n1 = _ch(hex.charCodeAt(hi));
+			const n2 = _ch(hex.charCodeAt(hi + 1));
+			if (n1 === void 0 || n2 === void 0) return err(e);
+			array[ai] = n1 * 16 + n2;
+		}
+		return array;
+	};
+	toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+	cr = () => globalThis?.crypto;
+	subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
+	concatBytes = (...arrs) => {
+		const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
+		let pad = 0;
+		arrs.forEach((a) => {
+			r.set(a, pad);
+			pad += a.length;
+		});
+		return r;
+	};
+	randomBytes = (len = L) => {
+		const c = cr();
+		return c.getRandomValues(u8n(len));
+	};
+	big = BigInt;
+	arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+	M = (a, b = P) => {
+		const r = a % b;
+		return r >= 0n ? r : b + r;
+	};
+	modN = (a) => M(a, N);
+	invert = (num, md) => {
+		if (num === 0n || md <= 0n) err("no inverse n=" + num + " mod=" + md);
+		let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
+		while (a !== 0n) {
+			const q = b / a, r = b % a;
+			const m = x - u * q, n = y - v * q;
+			b = a, a = r, x = u, y = v, u = m, v = n;
+		}
+		return b === 1n ? M(x, md) : err("no inverse");
+	};
+	callHash = (name) => {
+		const fn = etc[name];
+		if (typeof fn !== "function") err("hashes." + name + " not set");
+		return fn;
+	};
+	apoint = (p) => p instanceof Point ? p : err("Point expected");
+	B256 = 2n ** 256n;
+	Point = class Point {
+		static BASE;
+		static ZERO;
+		ex;
+		ey;
+		ez;
+		et;
+		constructor(ex, ey, ez, et) {
+			const max = B256;
+			this.ex = arange(ex, 0n, max);
+			this.ey = arange(ey, 0n, max);
+			this.ez = arange(ez, 1n, max);
+			this.et = arange(et, 0n, max);
+			Object.freeze(this);
+		}
+		static fromAffine(p) {
+			return new Point(p.x, p.y, 1n, M(p.x * p.y));
+		}
+		/** RFC8032 5.1.3: Uint8Array to Point. */
+		static fromBytes(hex, zip215 = false) {
+			const d = _d;
+			const normed = u8fr(abytes(hex, L));
+			const lastByte = hex[31];
+			normed[31] = lastByte & -129;
+			const y = bytesToNumLE(normed);
+			const max = zip215 ? B256 : P;
+			arange(y, 0n, max);
+			const y2 = M(y * y);
+			const u = M(y2 - 1n);
+			const v = M(d * y2 + 1n);
+			let { isValid, value: x } = uvRatio(u, v);
+			if (!isValid) err("bad point: y not sqrt");
+			const isXOdd = (x & 1n) === 1n;
+			const isLastByteOdd = (lastByte & 128) !== 0;
+			if (!zip215 && x === 0n && isLastByteOdd) err("bad point: x==0, isLastByteOdd");
+			if (isLastByteOdd !== isXOdd) x = M(-x);
+			return new Point(x, y, 1n, M(x * y));
+		}
+		/** Checks if the point is valid and on-curve. */
+		assertValidity() {
+			const a = _a;
+			const d = _d;
+			const p = this;
+			if (p.is0()) throw new Error("bad point: ZERO");
+			const { ex: X, ey: Y, ez: Z, et: T } = p;
+			const X2 = M(X * X);
+			const Y2 = M(Y * Y);
+			const Z2 = M(Z * Z);
+			const Z4 = M(Z2 * Z2);
+			const aX2 = M(X2 * a);
+			const left = M(Z2 * M(aX2 + Y2));
+			const right = M(Z4 + M(d * M(X2 * Y2)));
+			if (left !== right) throw new Error("bad point: equation left != right (1)");
+			const XY = M(X * Y);
+			const ZT = M(Z * T);
+			if (XY !== ZT) throw new Error("bad point: equation left != right (2)");
+			return this;
+		}
+		/** Equality check: compare points P&Q. */
+		equals(other) {
+			const { ex: X1, ey: Y1, ez: Z1 } = this;
+			const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
+			const X1Z2 = M(X1 * Z2);
+			const X2Z1 = M(X2 * Z1);
+			const Y1Z2 = M(Y1 * Z2);
+			const Y2Z1 = M(Y2 * Z1);
+			return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+		}
+		is0() {
+			return this.equals(I);
+		}
+		/** Flip point over y coordinate. */
+		negate() {
+			return new Point(M(-this.ex), this.ey, this.ez, M(-this.et));
+		}
+		/** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+		double() {
+			const { ex: X1, ey: Y1, ez: Z1 } = this;
+			const a = _a;
+			const A = M(X1 * X1);
+			const B = M(Y1 * Y1);
+			const C$1 = M(2n * M(Z1 * Z1));
+			const D = M(a * A);
+			const x1y1 = X1 + Y1;
+			const E = M(M(x1y1 * x1y1) - A - B);
+			const G$1 = D + B;
+			const F = G$1 - C$1;
+			const H = D - B;
+			const X3 = M(E * F);
+			const Y3 = M(G$1 * H);
+			const T3 = M(E * H);
+			const Z3 = M(F * G$1);
+			return new Point(X3, Y3, Z3, T3);
+		}
+		/** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+		add(other) {
+			const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+			const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
+			const a = _a;
+			const d = _d;
+			const A = M(X1 * X2);
+			const B = M(Y1 * Y2);
+			const C$1 = M(T1 * d * T2);
+			const D = M(Z1 * Z2);
+			const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+			const F = M(D - C$1);
+			const G$1 = M(D + C$1);
+			const H = M(B - a * A);
+			const X3 = M(E * F);
+			const Y3 = M(G$1 * H);
+			const T3 = M(E * H);
+			const Z3 = M(F * G$1);
+			return new Point(X3, Y3, Z3, T3);
+		}
+		/**
+		* Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+		* Uses {@link wNAF} for base point.
+		* Uses fake point to mitigate side-channel leakage.
+		* @param n scalar by which point is multiplied
+		* @param safe safe mode guards against timing attacks; unsafe mode is faster
+		*/
+		multiply(n, safe = true) {
+			if (!safe && (n === 0n || this.is0())) return I;
+			arange(n, 1n, N);
+			if (n === 1n) return this;
+			if (this.equals(G)) return wNAF(n).p;
+			let p = I;
+			let f = G;
+			for (let d = this; n > 0n; d = d.double(), n >>= 1n) if (n & 1n) p = p.add(d);
+			else if (safe) f = f.add(d);
+			return p;
+		}
+		/** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+		toAffine() {
+			const { ex: x, ey: y, ez: z } = this;
+			if (this.equals(I)) return {
+				x: 0n,
+				y: 1n
+			};
+			const iz = invert(z, P);
+			if (M(z * iz) !== 1n) err("invalid inverse");
+			return {
+				x: M(x * iz),
+				y: M(y * iz)
+			};
+		}
+		toBytes() {
+			const { x, y } = this.assertValidity().toAffine();
+			const b = numTo32bLE(y);
+			b[31] |= x & 1n ? 128 : 0;
+			return b;
+		}
+		toHex() {
+			return bytesToHex$1(this.toBytes());
+		}
+		clearCofactor() {
+			return this.multiply(big(h), false);
+		}
+		isSmallOrder() {
+			return this.clearCofactor().is0();
+		}
+		isTorsionFree() {
+			let p = this.multiply(N / 2n, false).double();
+			if (N % 2n) p = p.add(this);
+			return p.is0();
+		}
+		static fromHex(hex, zip215) {
+			return Point.fromBytes(toU8(hex), zip215);
+		}
+		get x() {
+			return this.toAffine().x;
+		}
+		get y() {
+			return this.toAffine().y;
+		}
+		toRawBytes() {
+			return this.toBytes();
+		}
+	};
+	G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+	I = new Point(0n, 1n, 1n, 0n);
+	Point.BASE = G;
+	Point.ZERO = I;
+	numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+	bytesToNumLE = (b) => big("0x" + bytesToHex$1(u8fr(abytes(b)).reverse()));
+	pow2 = (x, power) => {
+		let r = x;
+		while (power-- > 0n) {
+			r *= r;
+			r %= P;
+		}
+		return r;
+	};
+	pow_2_252_3 = (x) => {
+		const x2 = x * x % P;
+		const b2 = x2 * x % P;
+		const b4 = pow2(b2, 2n) * b2 % P;
+		const b5 = pow2(b4, 1n) * x % P;
+		const b10 = pow2(b5, 5n) * b5 % P;
+		const b20 = pow2(b10, 10n) * b10 % P;
+		const b40 = pow2(b20, 20n) * b20 % P;
+		const b80 = pow2(b40, 40n) * b40 % P;
+		const b160 = pow2(b80, 80n) * b80 % P;
+		const b240 = pow2(b160, 80n) * b80 % P;
+		const b250 = pow2(b240, 10n) * b10 % P;
+		const pow_p_5_8 = pow2(b250, 2n) * x % P;
+		return {
+			pow_p_5_8,
+			b2
+		};
+	};
+	RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;
+	uvRatio = (u, v) => {
+		const v3 = M(v * v * v);
+		const v7 = M(v3 * v3 * v);
+		const pow = pow_2_252_3(u * v7).pow_p_5_8;
+		let x = M(u * v3 * pow);
+		const vx2 = M(v * x * x);
+		const root1 = x;
+		const root2 = M(x * RM1);
+		const useRoot1 = vx2 === u;
+		const useRoot2 = vx2 === M(-u);
+		const noRoot = vx2 === M(-u * RM1);
+		if (useRoot1) x = root1;
+		if (useRoot2 || noRoot) x = root2;
+		if ((M(x) & 1n) === 1n) x = M(-x);
+		return {
+			isValid: useRoot1 || useRoot2,
+			value: x
+		};
+	};
+	modL_LE = (hash) => modN(bytesToNumLE(hash));
+	sha512a = (...m) => etc.sha512Async(...m);
+	sha512s = (...m) => callHash("sha512Sync")(...m);
+	hash2extK = (hashed) => {
+		const head = hashed.slice(0, L);
+		head[0] &= 248;
+		head[31] &= 127;
+		head[31] |= 64;
+		const prefix = hashed.slice(L, L2);
+		const scalar = modL_LE(head);
+		const point = G.multiply(scalar);
+		const pointBytes = point.toBytes();
+		return {
+			head,
+			prefix,
+			scalar,
+			point,
+			pointBytes
+		};
+	};
+	getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
+	getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
+	getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
+	etc = {
+		sha512Async: async (...messages) => {
+			const s = subtle();
+			const m = concatBytes(...messages);
+			return u8n(await s.digest("SHA-512", m.buffer));
+		},
+		sha512Sync: void 0,
+		bytesToHex: bytesToHex$1,
+		hexToBytes,
+		concatBytes,
+		mod: M,
+		invert,
+		randomBytes
+	};
+	utils = {
+		getExtendedPublicKeyAsync,
+		getExtendedPublicKey,
+		randomPrivateKey: () => randomBytes(L),
+		precompute: (w = 8, p = G) => {
+			p.multiply(3n);
+			return p;
+		}
+	};
+	W = 8;
+	scalarBits = 256;
+	pwindows = Math.ceil(scalarBits / W) + 1;
+	pwindowSize = 2 ** (W - 1);
+	precompute = () => {
+		const points = [];
+		let p = G;
+		let b = p;
+		for (let w = 0; w < pwindows; w++) {
+			b = p;
+			points.push(b);
+			for (let i = 1; i < pwindowSize; i++) {
+				b = b.add(p);
+				points.push(b);
+			}
+			p = b.double();
+		}
+		return points;
+	};
+	Gpows = void 0;
+	ctneg = (cnd, p) => {
+		const n = p.negate();
+		return cnd ? n : p;
+	};
+	wNAF = (n) => {
+		const comp = Gpows || (Gpows = precompute());
+		let p = I;
+		let f = G;
+		const pow_2_w = 2 ** W;
+		const maxNum = pow_2_w;
+		const mask = big(pow_2_w - 1);
+		const shiftBy = big(W);
+		for (let w = 0; w < pwindows; w++) {
+			let wbits = Number(n & mask);
+			n >>= shiftBy;
+			if (wbits > pwindowSize) {
+				wbits -= maxNum;
+				n += 1n;
+			}
+			const off = w * pwindowSize;
+			const offF = off;
+			const offP = off + Math.abs(wbits) - 1;
+			const isEven = w % 2 !== 0;
+			const isNeg = wbits < 0;
+			if (wbits === 0) f = f.add(ctneg(isEven, comp[offF]));
+			else p = p.add(ctneg(isNeg, comp[offP]));
+		}
+		return {
+			p,
+			f
+		};
+	};
+}) });
+
+//#endregion
+//#region src/core/nearCrypto.ts
+/**
+* Ensure a key string has the NEAR Ed25519 prefix (`ed25519:`).
+*
+* - Accepts either `ed25519:<base58>` or a bare `<base58>` string.
+* - Canonicalizes `ED25519:` → `ed25519:`.
+* - If a different prefix is present (e.g. `secp256k1:`), returns the input unchanged.
+*/
+function ensureEd25519Prefix(value) {
+	const raw = String(value || "").trim();
+	if (!raw) return "";
+	if (/^[a-z0-9_]+:/i.test(raw)) {
+		if (/^ed25519:/i.test(raw)) return `${NEAR_ED25519_KEY_PREFIX}${raw.replace(/^ed25519:/i, "")}`;
+		return raw;
+	}
+	return `${NEAR_ED25519_KEY_PREFIX}${raw}`;
+}
+/**
+* Creates a NEAR-compatible Ed25519 keypair formatted as strings:
+* - publicKey:  'ed25519:' + base58(pub)
+* - privateKey: 'ed25519:' + base58(seed(32) | pub(32))
+*/
+async function createNearKeypair() {
+	const seed = utils.randomPrivateKey();
+	const pub = await getPublicKeyAsync(seed);
+	const secret = new Uint8Array(64);
+	secret.set(seed, 0);
+	secret.set(pub, 32);
+	const publicKey = ensureEd25519Prefix(esm_default.encode(pub));
+	const privateKey = ensureEd25519Prefix(esm_default.encode(secret));
+	return {
+		publicKey,
+		privateKey
+	};
+}
+var NEAR_ED25519_KEY_PREFIX;
+var init_nearCrypto = __esm({ "src/core/nearCrypto.ts": (() => {
+	init_ed25519();
+	NEAR_ED25519_KEY_PREFIX = "ed25519:";
+}) });
+
 //#endregion
 //#region src/core/WebAuthnManager/SignerWorkerManager/handlers/validation.ts
 init_credentialsHelpers();
 init_validation();
+init_nearCrypto();
 function validateTransactionContextMaybe(input) {
 	if (input == null) return void 0;
 	if (!isObject(input)) throw new Error("Invalid transactionContext: expected object");
@@ -2730,9 +3201,6 @@ function parseAndValidateRegistrationCredentialConfirmationPayload(payload) {
 		error: normalizedError
 	};
 }
-const ensureEd25519Prefix = (value) => {
-	return value.startsWith("ed25519:") ? value : `ed25519:${value}`;
-};
 const toPublicKeyString = (pk) => {
 	if (typeof pk === "string") return pk;
 	return ensureEd25519Prefix(base58Encode(pk.keyData));
@@ -3299,14 +3767,14 @@ const HANDLERS = {
 		});
 	},
 	[SecureConfirmationType.SIGN_TRANSACTION]: async ({ ctx, request, worker, confirmationConfig, transactionSummary }) => {
-		const { handleTransactionSigningFlow } = await importFlow("transactions", () => import("./transactions-BalIhtJ9.js"));
+		const { handleTransactionSigningFlow } = await importFlow("transactions", () => import("./transactions-DfdwDQCn.js"));
 		await handleTransactionSigningFlow(ctx, request, worker, {
 			confirmationConfig,
 			transactionSummary
 		});
 	},
 	[SecureConfirmationType.SIGN_NEP413_MESSAGE]: async ({ ctx, request, worker, confirmationConfig, transactionSummary }) => {
-		const { handleTransactionSigningFlow } = await importFlow("transactions", () => import("./transactions-BalIhtJ9.js"));
+		const { handleTransactionSigningFlow } = await importFlow("transactions", () => import("./transactions-DfdwDQCn.js"));
 		await handleTransactionSigningFlow(ctx, request, worker, {
 			confirmationConfig,
 			transactionSummary
@@ -8408,504 +8876,6 @@ var ChainsigAddressManager = class {
 };
 const chainsigAddressManager = new ChainsigAddressManager();
 
-//#endregion
-//#region ../node_modules/.pnpm/@noble+ed25519@2.3.0/node_modules/@noble/ed25519/index.js
-/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-/**
-* 4KB JS implementation of ed25519 EdDSA signatures.
-* Compliant with RFC8032, FIPS 186-5 & ZIP215.
-* @module
-* @example
-* ```js
-import * as ed from '@noble/ed25519';
-(async () => {
-const privKey = ed.utils.randomPrivateKey();
-const message = Uint8Array.from([0xab, 0xbc, 0xcd, 0xde]);
-const pubKey = await ed.getPublicKeyAsync(privKey); // Sync methods are also present
-const signature = await ed.signAsync(message, privKey);
-const isValid = await ed.verifyAsync(signature, message, pubKey);
-})();
-```
-*/
-/**
-* Curve params. ed25519 is twisted edwards curve. Equation is −x² + y² = -a + dx²y².
-* * P = `2n**255n - 19n` // field over which calculations are done
-* * N = `2n**252n + 27742317777372353535851937790883648493n` // group order, amount of curve points
-* * h = 8 // cofactor
-* * a = `Fp.create(BigInt(-1))` // equation param
-* * d = -121665/121666 a.k.a. `Fp.neg(121665 * Fp.inv(121666))` // equation param
-* * Gx, Gy are coordinates of Generator / base point
-*/
-const ed25519_CURVE = {
-	p: 57896044618658097711785492504343953926634992332820282019728792003956564819949n,
-	n: 7237005577332262213973186563042994240857116359379907606001950938285454250989n,
-	h: 8n,
-	a: 57896044618658097711785492504343953926634992332820282019728792003956564819948n,
-	d: 37095705934669439343138083508754565189542113879843219016388785533085940283555n,
-	Gx: 15112221349535400772501151409588531511454012693041857206046113283949847762202n,
-	Gy: 46316835694926478169428394003475163141307993866256225615783033603165251855960n
-};
-const { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
-const h = 8n;
-const L = 32;
-const L2 = 64;
-const err = (m = "") => {
-	throw new Error(m);
-};
-const isBig = (n) => typeof n === "bigint";
-const isStr = (s) => typeof s === "string";
-const isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-/** assert is Uint8Array (of specific length) */
-const abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
-/** create Uint8Array */
-const u8n = (len) => new Uint8Array(len);
-const u8fr = (buf) => Uint8Array.from(buf);
-const padh = (n, pad) => n.toString(16).padStart(pad, "0");
-const bytesToHex$1 = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
-const C = {
-	_0: 48,
-	_9: 57,
-	A: 65,
-	F: 70,
-	a: 97,
-	f: 102
-};
-const _ch = (ch) => {
-	if (ch >= C._0 && ch <= C._9) return ch - C._0;
-	if (ch >= C.A && ch <= C.F) return ch - (C.A - 10);
-	if (ch >= C.a && ch <= C.f) return ch - (C.a - 10);
-};
-const hexToBytes = (hex) => {
-	const e = "hex invalid";
-	if (!isStr(hex)) return err(e);
-	const hl = hex.length;
-	const al = hl / 2;
-	if (hl % 2) return err(e);
-	const array = u8n(al);
-	for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-		const n1 = _ch(hex.charCodeAt(hi));
-		const n2 = _ch(hex.charCodeAt(hi + 1));
-		if (n1 === void 0 || n2 === void 0) return err(e);
-		array[ai] = n1 * 16 + n2;
-	}
-	return array;
-};
-/** normalize hex or ui8a to ui8a */
-const toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
-const cr = () => globalThis?.crypto;
-const subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
-const concatBytes = (...arrs) => {
-	const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
-	let pad = 0;
-	arrs.forEach((a) => {
-		r.set(a, pad);
-		pad += a.length;
-	});
-	return r;
-};
-/** WebCrypto OS-level CSPRNG (random number generator). Will throw when not available. */
-const randomBytes = (len = L) => {
-	const c = cr();
-	return c.getRandomValues(u8n(len));
-};
-const big = BigInt;
-const arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
-/** modular division */
-const M = (a, b = P) => {
-	const r = a % b;
-	return r >= 0n ? r : b + r;
-};
-const modN = (a) => M(a, N);
-/** Modular inversion using eucledian GCD (non-CT). No negative exponent for now. */
-const invert = (num, md) => {
-	if (num === 0n || md <= 0n) err("no inverse n=" + num + " mod=" + md);
-	let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
-	while (a !== 0n) {
-		const q = b / a, r = b % a;
-		const m = x - u * q, n = y - v * q;
-		b = a, a = r, x = u, y = v, u = m, v = n;
-	}
-	return b === 1n ? M(x, md) : err("no inverse");
-};
-const callHash = (name) => {
-	const fn = etc[name];
-	if (typeof fn !== "function") err("hashes." + name + " not set");
-	return fn;
-};
-const apoint = (p) => p instanceof Point ? p : err("Point expected");
-const B256 = 2n ** 256n;
-/** Point in XYZT extended coordinates. */
-var Point = class Point {
-	static BASE;
-	static ZERO;
-	ex;
-	ey;
-	ez;
-	et;
-	constructor(ex, ey, ez, et) {
-		const max = B256;
-		this.ex = arange(ex, 0n, max);
-		this.ey = arange(ey, 0n, max);
-		this.ez = arange(ez, 1n, max);
-		this.et = arange(et, 0n, max);
-		Object.freeze(this);
-	}
-	static fromAffine(p) {
-		return new Point(p.x, p.y, 1n, M(p.x * p.y));
-	}
-	/** RFC8032 5.1.3: Uint8Array to Point. */
-	static fromBytes(hex, zip215 = false) {
-		const d = _d;
-		const normed = u8fr(abytes(hex, L));
-		const lastByte = hex[31];
-		normed[31] = lastByte & -129;
-		const y = bytesToNumLE(normed);
-		const max = zip215 ? B256 : P;
-		arange(y, 0n, max);
-		const y2 = M(y * y);
-		const u = M(y2 - 1n);
-		const v = M(d * y2 + 1n);
-		let { isValid, value: x } = uvRatio(u, v);
-		if (!isValid) err("bad point: y not sqrt");
-		const isXOdd = (x & 1n) === 1n;
-		const isLastByteOdd = (lastByte & 128) !== 0;
-		if (!zip215 && x === 0n && isLastByteOdd) err("bad point: x==0, isLastByteOdd");
-		if (isLastByteOdd !== isXOdd) x = M(-x);
-		return new Point(x, y, 1n, M(x * y));
-	}
-	/** Checks if the point is valid and on-curve. */
-	assertValidity() {
-		const a = _a;
-		const d = _d;
-		const p = this;
-		if (p.is0()) throw new Error("bad point: ZERO");
-		const { ex: X, ey: Y, ez: Z, et: T } = p;
-		const X2 = M(X * X);
-		const Y2 = M(Y * Y);
-		const Z2 = M(Z * Z);
-		const Z4 = M(Z2 * Z2);
-		const aX2 = M(X2 * a);
-		const left = M(Z2 * M(aX2 + Y2));
-		const right = M(Z4 + M(d * M(X2 * Y2)));
-		if (left !== right) throw new Error("bad point: equation left != right (1)");
-		const XY = M(X * Y);
-		const ZT = M(Z * T);
-		if (XY !== ZT) throw new Error("bad point: equation left != right (2)");
-		return this;
-	}
-	/** Equality check: compare points P&Q. */
-	equals(other) {
-		const { ex: X1, ey: Y1, ez: Z1 } = this;
-		const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
-		const X1Z2 = M(X1 * Z2);
-		const X2Z1 = M(X2 * Z1);
-		const Y1Z2 = M(Y1 * Z2);
-		const Y2Z1 = M(Y2 * Z1);
-		return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
-	}
-	is0() {
-		return this.equals(I);
-	}
-	/** Flip point over y coordinate. */
-	negate() {
-		return new Point(M(-this.ex), this.ey, this.ez, M(-this.et));
-	}
-	/** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
-	double() {
-		const { ex: X1, ey: Y1, ez: Z1 } = this;
-		const a = _a;
-		const A = M(X1 * X1);
-		const B = M(Y1 * Y1);
-		const C$1 = M(2n * M(Z1 * Z1));
-		const D = M(a * A);
-		const x1y1 = X1 + Y1;
-		const E = M(M(x1y1 * x1y1) - A - B);
-		const G$1 = D + B;
-		const F = G$1 - C$1;
-		const H = D - B;
-		const X3 = M(E * F);
-		const Y3 = M(G$1 * H);
-		const T3 = M(E * H);
-		const Z3 = M(F * G$1);
-		return new Point(X3, Y3, Z3, T3);
-	}
-	/** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
-	add(other) {
-		const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
-		const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
-		const a = _a;
-		const d = _d;
-		const A = M(X1 * X2);
-		const B = M(Y1 * Y2);
-		const C$1 = M(T1 * d * T2);
-		const D = M(Z1 * Z2);
-		const E = M((X1 + Y1) * (X2 + Y2) - A - B);
-		const F = M(D - C$1);
-		const G$1 = M(D + C$1);
-		const H = M(B - a * A);
-		const X3 = M(E * F);
-		const Y3 = M(G$1 * H);
-		const T3 = M(E * H);
-		const Z3 = M(F * G$1);
-		return new Point(X3, Y3, Z3, T3);
-	}
-	/**
-	* Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
-	* Uses {@link wNAF} for base point.
-	* Uses fake point to mitigate side-channel leakage.
-	* @param n scalar by which point is multiplied
-	* @param safe safe mode guards against timing attacks; unsafe mode is faster
-	*/
-	multiply(n, safe = true) {
-		if (!safe && (n === 0n || this.is0())) return I;
-		arange(n, 1n, N);
-		if (n === 1n) return this;
-		if (this.equals(G)) return wNAF(n).p;
-		let p = I;
-		let f = G;
-		for (let d = this; n > 0n; d = d.double(), n >>= 1n) if (n & 1n) p = p.add(d);
-		else if (safe) f = f.add(d);
-		return p;
-	}
-	/** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
-	toAffine() {
-		const { ex: x, ey: y, ez: z } = this;
-		if (this.equals(I)) return {
-			x: 0n,
-			y: 1n
-		};
-		const iz = invert(z, P);
-		if (M(z * iz) !== 1n) err("invalid inverse");
-		return {
-			x: M(x * iz),
-			y: M(y * iz)
-		};
-	}
-	toBytes() {
-		const { x, y } = this.assertValidity().toAffine();
-		const b = numTo32bLE(y);
-		b[31] |= x & 1n ? 128 : 0;
-		return b;
-	}
-	toHex() {
-		return bytesToHex$1(this.toBytes());
-	}
-	clearCofactor() {
-		return this.multiply(big(h), false);
-	}
-	isSmallOrder() {
-		return this.clearCofactor().is0();
-	}
-	isTorsionFree() {
-		let p = this.multiply(N / 2n, false).double();
-		if (N % 2n) p = p.add(this);
-		return p.is0();
-	}
-	static fromHex(hex, zip215) {
-		return Point.fromBytes(toU8(hex), zip215);
-	}
-	get x() {
-		return this.toAffine().x;
-	}
-	get y() {
-		return this.toAffine().y;
-	}
-	toRawBytes() {
-		return this.toBytes();
-	}
-};
-/** Generator / base point */
-const G = new Point(Gx, Gy, 1n, M(Gx * Gy));
-/** Identity / zero point */
-const I = new Point(0n, 1n, 1n, 0n);
-Point.BASE = G;
-Point.ZERO = I;
-const numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
-const bytesToNumLE = (b) => big("0x" + bytesToHex$1(u8fr(abytes(b)).reverse()));
-const pow2 = (x, power) => {
-	let r = x;
-	while (power-- > 0n) {
-		r *= r;
-		r %= P;
-	}
-	return r;
-};
-const pow_2_252_3 = (x) => {
-	const x2 = x * x % P;
-	const b2 = x2 * x % P;
-	const b4 = pow2(b2, 2n) * b2 % P;
-	const b5 = pow2(b4, 1n) * x % P;
-	const b10 = pow2(b5, 5n) * b5 % P;
-	const b20 = pow2(b10, 10n) * b10 % P;
-	const b40 = pow2(b20, 20n) * b20 % P;
-	const b80 = pow2(b40, 40n) * b40 % P;
-	const b160 = pow2(b80, 80n) * b80 % P;
-	const b240 = pow2(b160, 80n) * b80 % P;
-	const b250 = pow2(b240, 10n) * b10 % P;
-	const pow_p_5_8 = pow2(b250, 2n) * x % P;
-	return {
-		pow_p_5_8,
-		b2
-	};
-};
-const RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;
-const uvRatio = (u, v) => {
-	const v3 = M(v * v * v);
-	const v7 = M(v3 * v3 * v);
-	const pow = pow_2_252_3(u * v7).pow_p_5_8;
-	let x = M(u * v3 * pow);
-	const vx2 = M(v * x * x);
-	const root1 = x;
-	const root2 = M(x * RM1);
-	const useRoot1 = vx2 === u;
-	const useRoot2 = vx2 === M(-u);
-	const noRoot = vx2 === M(-u * RM1);
-	if (useRoot1) x = root1;
-	if (useRoot2 || noRoot) x = root2;
-	if ((M(x) & 1n) === 1n) x = M(-x);
-	return {
-		isValid: useRoot1 || useRoot2,
-		value: x
-	};
-};
-const modL_LE = (hash) => modN(bytesToNumLE(hash));
-const sha512a = (...m) => etc.sha512Async(...m);
-const sha512s = (...m) => callHash("sha512Sync")(...m);
-const hash2extK = (hashed) => {
-	const head = hashed.slice(0, L);
-	head[0] &= 248;
-	head[31] &= 127;
-	head[31] |= 64;
-	const prefix = hashed.slice(L, L2);
-	const scalar = modL_LE(head);
-	const point = G.multiply(scalar);
-	const pointBytes = point.toBytes();
-	return {
-		head,
-		prefix,
-		scalar,
-		point,
-		pointBytes
-	};
-};
-const getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
-const getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
-/** Creates 32-byte ed25519 public key from 32-byte private key. Async. */
-const getPublicKeyAsync = (priv) => getExtendedPublicKeyAsync(priv).then((p) => p.pointBytes);
-/** Math, hex, byte helpers. Not in `utils` because utils share API with noble-curves. */
-const etc = {
-	sha512Async: async (...messages) => {
-		const s = subtle();
-		const m = concatBytes(...messages);
-		return u8n(await s.digest("SHA-512", m.buffer));
-	},
-	sha512Sync: void 0,
-	bytesToHex: bytesToHex$1,
-	hexToBytes,
-	concatBytes,
-	mod: M,
-	invert,
-	randomBytes
-};
-/** ed25519-specific key utilities. */
-const utils = {
-	getExtendedPublicKeyAsync,
-	getExtendedPublicKey,
-	randomPrivateKey: () => randomBytes(L),
-	precompute: (w = 8, p = G) => {
-		p.multiply(3n);
-		return p;
-	}
-};
-const W = 8;
-const scalarBits = 256;
-const pwindows = Math.ceil(scalarBits / W) + 1;
-const pwindowSize = 2 ** (W - 1);
-const precompute = () => {
-	const points = [];
-	let p = G;
-	let b = p;
-	for (let w = 0; w < pwindows; w++) {
-		b = p;
-		points.push(b);
-		for (let i = 1; i < pwindowSize; i++) {
-			b = b.add(p);
-			points.push(b);
-		}
-		p = b.double();
-	}
-	return points;
-};
-let Gpows = void 0;
-const ctneg = (cnd, p) => {
-	const n = p.negate();
-	return cnd ? n : p;
-};
-/**
-* Precomputes give 12x faster getPublicKey(), 10x sign(), 2x verify() by
-* caching multiples of G (base point). Cache is stored in 32MB of RAM.
-* Any time `G.multiply` is done, precomputes are used.
-* Not used for getSharedSecret, which instead multiplies random pubkey `P.multiply`.
-*
-* w-ary non-adjacent form (wNAF) precomputation method is 10% slower than windowed method,
-* but takes 2x less RAM. RAM reduction is possible by utilizing `.subtract`.
-*
-* !! Precomputes can be disabled by commenting-out call of the wNAF() inside Point#multiply().
-*/
-const wNAF = (n) => {
-	const comp = Gpows || (Gpows = precompute());
-	let p = I;
-	let f = G;
-	const pow_2_w = 2 ** W;
-	const maxNum = pow_2_w;
-	const mask = big(pow_2_w - 1);
-	const shiftBy = big(W);
-	for (let w = 0; w < pwindows; w++) {
-		let wbits = Number(n & mask);
-		n >>= shiftBy;
-		if (wbits > pwindowSize) {
-			wbits -= maxNum;
-			n += 1n;
-		}
-		const off = w * pwindowSize;
-		const offF = off;
-		const offP = off + Math.abs(wbits) - 1;
-		const isEven = w % 2 !== 0;
-		const isNeg = wbits < 0;
-		if (wbits === 0) f = f.add(ctneg(isEven, comp[offF]));
-		else p = p.add(ctneg(isNeg, comp[offP]));
-	}
-	return {
-		p,
-		f
-	};
-};
-
-//#endregion
-//#region src/core/nearCrypto.ts
-const NEAR_KEY_PREFIX = "ed25519:";
-function ensurePrefix(str) {
-	return str.startsWith(NEAR_KEY_PREFIX) ? str : `${NEAR_KEY_PREFIX}${str}`;
-}
-/**
-* Creates a NEAR-compatible Ed25519 keypair formatted as strings:
-* - publicKey:  'ed25519:' + base58(pub)
-* - privateKey: 'ed25519:' + base58(seed(32) | pub(32))
-*/
-async function createNearKeypair() {
-	const seed = utils.randomPrivateKey();
-	const pub = await getPublicKeyAsync(seed);
-	const secret = new Uint8Array(64);
-	secret.set(seed, 0);
-	secret.set(pub, 32);
-	const publicKey = ensurePrefix(esm_default.encode(pub));
-	const privateKey = ensurePrefix(esm_default.encode(secret));
-	return {
-		publicKey,
-		privateKey
-	};
-}
-
 //#endregion
 //#region src/core/types/linkDevice.ts
 var DeviceLinkingError = class extends Error {
@@ -8927,6 +8897,7 @@ let DeviceLinkingErrorCode = /* @__PURE__ */ function(DeviceLinkingErrorCode$1)
 
 //#endregion
 //#region src/core/TatchiPasskey/linkDevice.ts
+init_nearCrypto();
 init_IndexedDBManager();
 init_actions();
 init_rpcCalls();
@@ -9625,6 +9596,7 @@ init_validation$1();
 init_login();
 init_sdkSentEvents();
 init_rpcCalls();
+init_nearCrypto();
 /**
 * Device1 (original device): Link device using pre-scanned QR data
 */
@@ -9642,8 +9614,8 @@ async function linkDeviceWithScannedQRData(context, qrData, options) {
 		if (!device1LoginState.isLoggedIn || !device1LoginState.nearAccountId) throw new Error("Device1 must be logged in to authorize device linking");
 		const device1AccountId = device1LoginState.nearAccountId;
 		const fundingAmount = options.fundingAmount;
-		const device2PublicKey = qrData.device2PublicKey;
-		if (!device2PublicKey.startsWith("ed25519:")) throw new Error("Invalid device public key format");
+		const device2PublicKey = ensureEd25519Prefix(qrData.device2PublicKey);
+		if (!device2PublicKey || !/^ed25519:/i.test(device2PublicKey)) throw new Error("Invalid device public key format");
 		onEvent?.({
 			step: 3,
 			phase: DeviceLinkingPhase.STEP_3_AUTHORIZATION,
@@ -9684,7 +9656,7 @@ async function linkDeviceWithScannedQRData(context, qrData, options) {
 		});
 		const result = {
 			success: true,
-			device2PublicKey: qrData.device2PublicKey,
+			device2PublicKey,
 			transactionId: addKeyTxResult?.transaction?.hash || storeDeviceLinkingTxResult?.transaction?.hash || "unknown",
 			fundingAmount,
 			linkedToAccount: device1AccountId,
@@ -10037,6 +10009,28 @@ var init_emailRecoveryPendingStore = __esm({ "src/core/EmailRecovery/emailRecove
 
 //#endregion
 //#region src/core/EmailRecovery/index.ts
+function getTxSuccessValueBase64(outcome) {
+	const status = outcome.status;
+	if (!status || typeof status !== "object") return null;
+	if (!("SuccessValue" in status)) return null;
+	const value = status.SuccessValue;
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseLinkDeviceRegisterUserResponse(outcome) {
+	try {
+		const successValueB64 = getTxSuccessValueBase64(outcome);
+		if (!successValueB64) return null;
+		const bytes = base64Decode(successValueB64);
+		const text = new TextDecoder().decode(bytes);
+		if (!text.trim()) return null;
+		const parsed = JSON.parse(text);
+		if (!parsed || typeof parsed !== "object") return null;
+		const candidate = parsed;
+		return typeof candidate.verified === "boolean" ? candidate : null;
+	} catch {
+		return null;
+	}
+}
 async function hashRecoveryEmails(emails, accountId) {
 	const encoder = new TextEncoder();
 	const salt = (accountId || "").trim().toLowerCase();
@@ -10108,6 +10102,27 @@ var init_EmailRecovery = __esm({ "src/core/EmailRecovery/index.ts": (() => {
 	};
 }) });
 
+//#endregion
+//#region src/core/types/emailRecovery.ts
+var EmailRecoveryErrorCode, EmailRecoveryError;
+var init_emailRecovery$1 = __esm({ "src/core/types/emailRecovery.ts": (() => {
+	EmailRecoveryErrorCode = /* @__PURE__ */ function(EmailRecoveryErrorCode$1) {
+		EmailRecoveryErrorCode$1["REGISTRATION_NOT_VERIFIED"] = "EMAIL_RECOVERY_REGISTRATION_NOT_VERIFIED";
+		EmailRecoveryErrorCode$1["VRF_CHALLENGE_EXPIRED"] = "EMAIL_RECOVERY_VRF_CHALLENGE_EXPIRED";
+		return EmailRecoveryErrorCode$1;
+	}({});
+	EmailRecoveryError = class extends Error {
+		code;
+		context;
+		constructor(message, code, context) {
+			super(message);
+			this.name = "EmailRecoveryError";
+			this.code = code;
+			this.context = context;
+		}
+	};
+}) });
+
 //#endregion
 //#region src/core/TatchiPasskey/emailRecovery.ts
 var emailRecovery_exports = {};
@@ -10122,16 +10137,12 @@ function getEmailRecoveryConfig(configs) {
 	const maxPollingDurationMs = Number(relayerEmailCfg.maxPollingDurationMs);
 	const pendingTtlMs = Number(relayerEmailCfg.pendingTtlMs);
 	const mailtoAddress = String(relayerEmailCfg.mailtoAddress);
-	const dkimVerifierAccountId = String(relayerEmailCfg.dkimVerifierAccountId);
-	const verificationViewMethod = String(relayerEmailCfg.verificationViewMethod);
 	return {
 		minBalanceYocto,
 		pollingIntervalMs,
 		maxPollingDurationMs,
 		pendingTtlMs,
-		mailtoAddress,
-		dkimVerifierAccountId,
-		verificationViewMethod
+		mailtoAddress
 	};
 }
 function generateEmailRecoveryRequestId() {
@@ -10147,6 +10158,7 @@ var EmailRecoveryFlow;
 var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (() => {
 	init_IndexedDBManager();
 	init_validation$1();
+	init_errors();
 	init_accountIds();
 	init_sdkSentEvents();
 	init_vrf_worker();
@@ -10154,6 +10166,9 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 	init_getDeviceNumber();
 	init_login();
 	init_EmailRecovery();
+	init_emailRecovery$1();
+	init_rpcCalls();
+	init_nearCrypto();
 	EmailRecoveryFlow = class {
 		context;
 		options;
@@ -10181,8 +10196,9 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 		emit(event) {
 			this.options?.onEvent?.(event);
 		}
-		emitError(step, message) {
-			const err$1 = new Error(message);
+		emitError(step, messageOrError) {
+			const err$1 = typeof messageOrError === "string" ? new Error(messageOrError) : messageOrError;
+			const message = err$1.message || (typeof messageOrError === "string" ? messageOrError : "Unknown error");
 			this.phase = EmailRecoveryPhase.ERROR;
 			this.error = err$1;
 			this.emit({
@@ -10241,20 +10257,19 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 				const accountView = await this.context.nearClient.viewAccount(nearAccountId);
 				const available = this.computeAvailableBalance(accountView);
 				if (available < BigInt(minBalanceYocto)) await this.fail(1, `This account does not have enough NEAR to finalize recovery. Available: ${available.toString()} yocto; required: ${String(minBalanceYocto)}. Please top up and try again.`);
-			} catch (e) {
-				await this.fail(1, e?.message || "Failed to fetch account balance for recovery");
+			} catch (err$1) {
+				await this.fail(1, errorMessage(err$1) || "Failed to fetch account balance for recovery");
 			}
 		}
-		async getCanonicalRecoveryEmailOrFail(recoveryEmail) {
+		getCanonicalRecoveryEmail(recoveryEmail) {
 			const canonicalEmail = String(recoveryEmail || "").trim().toLowerCase();
-			if (!canonicalEmail) await this.fail(1, "Recovery email is required for email-based account recovery");
-			return canonicalEmail;
+			return canonicalEmail || void 0;
 		}
 		async getNextDeviceNumberFromContract(nearAccountId) {
 			try {
-				const { syncAuthenticatorsContractCall: syncAuthenticatorsContractCall$1 } = await import("./rpcCalls-BQrJMTdg.js");
+				const { syncAuthenticatorsContractCall: syncAuthenticatorsContractCall$1 } = await import("./rpcCalls-CYGJSCgm.js");
 				const authenticators = await syncAuthenticatorsContractCall$1(this.context.nearClient, this.context.configs.contractId, nearAccountId);
-				const numbers = authenticators.map((a) => a?.authenticator?.deviceNumber).filter((n) => typeof n === "number" && Number.isFinite(n));
+				const numbers = authenticators.map(({ authenticator }) => authenticator.deviceNumber).filter((n) => typeof n === "number" && Number.isFinite(n));
 				const max = numbers.length > 0 ? Math.max(...numbers) : 0;
 				return max + 1;
 			} catch {
@@ -10306,7 +10321,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 				message: "New device key created; please send the recovery email from your registered address.",
 				data: {
 					accountId: rec.accountId,
-					recoveryEmail: rec.recoveryEmail,
+					...rec.recoveryEmail ? { recoveryEmail: rec.recoveryEmail } : {},
 					nearPublicKey: rec.nearPublicKey,
 					requestId: rec.requestId,
 					mailtoUrl
@@ -10322,44 +10337,57 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 				data
 			});
 		}
-		async checkViaDkimViewMethod(rec) {
-			const { dkimVerifierAccountId, verificationViewMethod } = this.getConfig();
-			if (!dkimVerifierAccountId) return null;
+		async checkViaEmailRecovererAttempt(rec) {
 			try {
-				const { getEmailRecoveryVerificationResult } = await import("./rpcCalls-BQrJMTdg.js");
-				const result = await getEmailRecoveryVerificationResult(this.context.nearClient, dkimVerifierAccountId, verificationViewMethod, rec.requestId);
-				if (!result) return {
+				const attempt = await getEmailRecoveryAttempt(this.context.nearClient, rec.accountId, rec.requestId);
+				if (!attempt) return {
 					completed: false,
-					success: false
+					success: false,
+					missing: true
 				};
-				if (!result.verified) {
-					const errorMessage$1 = result.error_message || result.error_code || "Email verification failed on relayer/contract";
-					return {
+				if (attempt.request_id && attempt.request_id !== rec.requestId) return {
+					completed: true,
+					success: false,
+					errorMessage: "Email recovery attempt request_id does not match requested requestId."
+				};
+				if (attempt.new_public_key && attempt.new_public_key !== rec.nearPublicKey) {
+					const expected = ensureEd25519Prefix(rec.nearPublicKey);
+					const actual = ensureEd25519Prefix(attempt.new_public_key);
+					if (actual === expected) {} else return {
 						completed: true,
 						success: false,
-						errorMessage: errorMessage$1,
-						transactionHash: result.transaction_hash
+						errorMessage: `Email recovery new_public_key mismatch for request ${rec.requestId}. Expected ${expected}; got ${actual}. This usually means the recovery email you sent was generated for a different device/attempt.`
 					};
 				}
-				if (result.account_id && result.account_id !== rec.accountId) return {
+				const normalized = attempt.status.toLowerCase();
+				if (normalized === "complete" || normalized === "completed") return {
 					completed: true,
-					success: false,
-					errorMessage: "Email verification account_id does not match requested account.",
-					transactionHash: result.transaction_hash
+					success: true
 				};
-				if (result.new_public_key && result.new_public_key !== rec.nearPublicKey) return {
+				if (normalized.includes("failed")) return {
 					completed: true,
 					success: false,
-					errorMessage: "Email verification new_public_key does not match expected recovery key.",
-					transactionHash: result.transaction_hash
+					errorMessage: attempt.error || `Email recovery failed (${attempt.status || "unknown status"})`
 				};
 				return {
-					completed: true,
-					success: true,
-					transactionHash: result.transaction_hash
+					completed: false,
+					success: false
 				};
 			} catch (err$1) {
-				console.warn("[EmailRecoveryFlow] get_verification_result view failed; will retry", err$1);
+				console.warn("[EmailRecoveryFlow] get_recovery_attempt view failed; will retry", err$1);
+				return null;
+			}
+		}
+		async isRecoveryAccessKeyPresent(rec) {
+			try {
+				await this.context.nearClient.viewAccessKey(rec.accountId, rec.nearPublicKey);
+				return true;
+			} catch (err$1) {
+				const kind = typeof err$1?.kind === "string" ? String(err$1.kind) : "";
+				const short = typeof err$1?.short === "string" ? String(err$1.short) : "";
+				const msg = typeof err$1?.message === "string" ? String(err$1.message) : "";
+				if (/AccessKeyDoesNotExist/i.test(kind) || /AccessKeyDoesNotExist/i.test(short) || /access key does not exist/i.test(msg) || /access key .*does not exist/i.test(msg)) return false;
+				console.warn("[EmailRecoveryFlow] view_access_key failed while checking recovery key; will retry", err$1);
 				return null;
 			}
 		}
@@ -10468,7 +10496,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 			});
 			const nearAccountId = await this.assertValidAccountIdOrFail(1, accountId);
 			await this.assertSufficientBalance(nearAccountId);
-			const canonicalEmail = await this.getCanonicalRecoveryEmailOrFail(recoveryEmail);
+			const canonicalEmail = this.getCanonicalRecoveryEmail(recoveryEmail);
 			const deviceNumber = await this.getNextDeviceNumberFromContract(nearAccountId);
 			this.phase = EmailRecoveryPhase.STEP_2_TOUCH_ID_REGISTRATION;
 			this.emit({
@@ -10502,7 +10530,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 					nearPublicKey: rec.nearPublicKey
 				};
 			} catch (e) {
-				const err$1 = this.emitError(2, e?.message || "Email recovery TouchID/derivation failed");
+				const err$1 = this.emitError(2, errorMessage(e) || "Email recovery TouchID/derivation failed");
 				await this.options?.afterCall?.(false);
 				throw err$1;
 			}
@@ -10599,29 +10627,39 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 			await this.options?.afterCall?.(true, void 0);
 		}
 		async pollUntilAddKey(rec) {
-			const { pollingIntervalMs, maxPollingDurationMs, dkimVerifierAccountId } = this.getConfig();
-			if (!dkimVerifierAccountId) {
-				const err$2 = this.emitError(4, "Email recovery verification contract (dkimVerifierAccountId) is not configured");
-				await this.options?.afterCall?.(false);
-				throw err$2;
-			}
+			const { pollingIntervalMs, maxPollingDurationMs } = this.getConfig();
 			this.phase = EmailRecoveryPhase.STEP_4_POLLING_VERIFICATION_RESULT;
 			this.pollingStartedAt = Date.now();
+			let sawAttempt = false;
 			const pollResult = await this.pollUntil({
 				intervalMs: pollingIntervalMs,
 				timeoutMs: maxPollingDurationMs,
 				isCancelled: () => this.cancelled,
 				tick: async ({ elapsedMs, pollCount }) => {
-					const verification = await this.checkViaDkimViewMethod(rec);
-					const completed = verification?.completed === true;
-					const success = verification?.success === true;
+					const verification = await this.checkViaEmailRecovererAttempt(rec);
+					if (verification && !verification.missing) sawAttempt = true;
+					let completed = verification?.completed === true;
+					let success = verification?.success === true;
+					let errorMessage$1 = verification?.errorMessage;
+					let transactionHash;
+					if (verification?.missing) {
+						const hasKey = await this.isRecoveryAccessKeyPresent(rec);
+						if (hasKey === true) {
+							completed = true;
+							success = true;
+						} else if (hasKey === false && sawAttempt) {
+							completed = true;
+							success = false;
+							errorMessage$1 = "Email recovery attempt was cleared on-chain before completion. Please resend the recovery email or restart the flow.";
+						} else if (hasKey === null) return { done: false };
+					}
 					this.emit({
 						step: 4,
 						phase: EmailRecoveryPhase.STEP_4_POLLING_VERIFICATION_RESULT,
 						status: EmailRecoveryStatus.PROGRESS,
-						message: completed && success ? `Email verified for request ${rec.requestId}; finalizing registration` : `Waiting for email verification for request ${rec.requestId}`,
+						message: completed && success ? `Email recovery completed for request ${rec.requestId}; finalizing registration` : `Waiting for email recovery for request ${rec.requestId}`,
 						data: this.buildPollingEventData(rec, {
-							transactionHash: verification?.transactionHash,
+							transactionHash,
 							elapsedMs,
 							pollCount
 						})
@@ -10631,7 +10669,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 						done: true,
 						value: {
 							outcome: "failed",
-							errorMessage: verification?.errorMessage || "Email verification failed"
+							errorMessage: errorMessage$1 || "Email recovery failed"
 						}
 					};
 					return {
@@ -10672,7 +10710,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 				accountId
 			};
 		}
-		async signRegistrationTx(rec, accountId) {
+		async signNewDevice2RegistrationTx(rec, accountId) {
 			const vrfChallenge = rec.vrfChallenge;
 			if (!vrfChallenge) return this.fail(5, "Missing VRF challenge for email recovery registration");
 			const registrationResult = await this.context.webAuthnManager.signDevice2RegistrationWithStoredKey({
@@ -10686,28 +10724,56 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 			return registrationResult.signedTransaction;
 		}
 		async broadcastRegistrationTxAndWaitFinal(rec, signedTx) {
+			let txResult;
 			try {
-				const txResult = await this.context.nearClient.sendTransaction(signedTx, DEFAULT_WAIT_STATUS.linkDeviceRegistration);
-				try {
-					const txHash = txResult?.transaction?.hash || txResult?.transaction_hash;
-					if (txHash) this.emit({
-						step: 5,
-						phase: EmailRecoveryPhase.STEP_5_FINALIZING_REGISTRATION,
-						status: EmailRecoveryStatus.PROGRESS,
-						message: "Registration transaction confirmed",
-						data: {
-							accountId: rec.accountId,
-							nearPublicKey: rec.nearPublicKey,
-							transactionHash: txHash
-						}
-					});
-					return txHash;
-				} catch {}
-			} catch (e) {
-				const msg = String(e?.message || "");
-				await this.fail(5, msg || "Failed to broadcast email recovery registration transaction (insufficient funds or RPC error)");
+				txResult = await this.context.nearClient.sendTransaction(signedTx, DEFAULT_WAIT_STATUS.linkDeviceRegistration);
+			} catch (err$1) {
+				const msg = errorMessage(err$1) || "Failed to broadcast email recovery registration transaction (insufficient funds or RPC error)";
+				throw new Error(msg);
+			}
+			const txHash = this.getTxHash(txResult);
+			const linkDeviceResult = parseLinkDeviceRegisterUserResponse(txResult);
+			if (linkDeviceResult?.verified === false) {
+				const logs = this.extractNearExecutionLogs(txResult);
+				const isStaleChallenge = logs.some((log) => /StaleChallenge|freshness validation failed/i.test(log));
+				const txHint = txHash ? ` (tx: ${txHash})` : "";
+				const code = isStaleChallenge ? EmailRecoveryErrorCode.VRF_CHALLENGE_EXPIRED : EmailRecoveryErrorCode.REGISTRATION_NOT_VERIFIED;
+				const message = isStaleChallenge ? `Timed out finalizing registration (VRF challenge expired). Please restart email recovery and try again${txHint}.` : `Registration did not verify on-chain. Please try again${txHint}.`;
+				throw new EmailRecoveryError(message, code, {
+					accountId: rec.accountId,
+					nearPublicKey: rec.nearPublicKey,
+					transactionHash: txHash,
+					logs,
+					result: linkDeviceResult
+				});
+			}
+			if (txHash) this.emit({
+				step: 5,
+				phase: EmailRecoveryPhase.STEP_5_FINALIZING_REGISTRATION,
+				status: EmailRecoveryStatus.PROGRESS,
+				message: "Registration transaction confirmed",
+				data: {
+					accountId: rec.accountId,
+					nearPublicKey: rec.nearPublicKey,
+					transactionHash: txHash
+				}
+			});
+			return txHash;
+		}
+		getTxHash(outcome) {
+			const txUnknown = outcome.transaction;
+			if (txUnknown && typeof txUnknown === "object") {
+				const hash = txUnknown.hash;
+				if (typeof hash === "string" && hash.length > 0) return hash;
 			}
-			return void 0;
+			const fallback = outcome.transaction_hash;
+			return typeof fallback === "string" && fallback.length > 0 ? fallback : void 0;
+		}
+		extractNearExecutionLogs(outcome) {
+			const logs = [];
+			for (const entry of outcome.transaction_outcome.outcome.logs) logs.push(String(entry));
+			for (const receipt of outcome.receipts_outcome) for (const entry of receipt.outcome.logs) logs.push(String(entry));
+			return logs;
 		}
 		mapAuthenticatorsFromContract(authenticators) {
 			return authenticators.map(({ authenticator }) => ({
@@ -10722,7 +10788,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 		}
 		async syncAuthenticatorsBestEffort(accountId) {
 			try {
-				const { syncAuthenticatorsContractCall: syncAuthenticatorsContractCall$1 } = await import("./rpcCalls-BQrJMTdg.js");
+				const { syncAuthenticatorsContractCall: syncAuthenticatorsContractCall$1 } = await import("./rpcCalls-CYGJSCgm.js");
 				const authenticators = await syncAuthenticatorsContractCall$1(this.context.nearClient, this.context.configs.contractId, accountId);
 				const mappedAuthenticators = this.mapAuthenticatorsFromContract(authenticators);
 				await IndexedDBManager.clientDB.syncAuthenticatorsFromContract(accountId, mappedAuthenticators);
@@ -10743,7 +10809,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 		}
 		async updateNonceBestEffort(nonceManager, signedTx) {
 			try {
-				const txNonce = signedTx.transaction?.nonce;
+				const txNonce = signedTx.transaction.nonce;
 				if (txNonce != null) await nonceManager.updateNonceFromBlockchain(this.context.nearClient, String(txNonce));
 			} catch {}
 		}
@@ -10859,7 +10925,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 			} catch (err$1) {
 				return {
 					success: false,
-					reason: err$1?.message || String(err$1)
+					reason: errorMessage(err$1) || String(err$1)
 				};
 			}
 		}
@@ -10887,7 +10953,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 			});
 			try {
 				const { nonceManager, accountId } = this.initializeNonceManager(rec);
-				const signedTx = await this.signRegistrationTx(rec, accountId);
+				const signedTx = await this.signNewDevice2RegistrationTx(rec, accountId);
 				const txHash = await this.broadcastRegistrationTxAndWaitFinal(rec, signedTx);
 				if (!txHash) console.warn("[EmailRecoveryFlow] Registration transaction confirmed without hash; continuing local persistence");
 				await this.persistRecoveredUserData(rec, accountId);
@@ -10915,7 +10981,10 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 					}
 				});
 			} catch (e) {
-				const err$1 = this.emitError(5, e?.message || "Email recovery finalization failed");
+				rec.status = "error";
+				await this.savePending(rec).catch(() => {});
+				const original = e instanceof Error ? e : new Error(errorMessage(e) || "Email recovery finalization failed");
+				const err$1 = this.emitError(5, original);
 				await this.options?.afterCall?.(false);
 				throw err$1;
 			}
@@ -10937,7 +11006,7 @@ var init_emailRecovery = __esm({ "src/core/TatchiPasskey/emailRecovery.ts": (()
 				};
 				return this.handleAutoLoginFailure(touchIdResult.reason || "Auto-login failed");
 			} catch (err$1) {
-				return this.handleAutoLoginFailure(err$1?.message || String(err$1), err$1);
+				return this.handleAutoLoginFailure(errorMessage(err$1) || String(err$1), err$1);
 			}
 		}
 	};
@@ -11009,7 +11078,7 @@ var TatchiPasskey = class {
 		} catch {}
 		if (!this.iframeRouter) {
 			if (!this.walletIframeInitInFlight) this.walletIframeInitInFlight = (async () => {
-				const { WalletIframeRouter } = await import("./router-DuGYOd3G.js");
+				const { WalletIframeRouter } = await import("./router-BWtacLJg.js");
 				this.iframeRouter = new WalletIframeRouter({
 					walletOrigin,
 					servicePath: walletIframeConfig?.walletServicePath || "/wallet-service",
@@ -12047,6 +12116,7 @@ var TatchiPasskey = class {
 		const { accountId, recoveryEmail, options } = args;
 		if (this.shouldUseWalletIframe()) try {
 			const router = await this.requireWalletIframeRouter();
+			const normalizedRecoveryEmail = typeof recoveryEmail === "string" && recoveryEmail.trim().length > 0 ? recoveryEmail.trim() : void 0;
 			const confirmerText = options?.confirmerText;
 			const confirmationConfig = options?.confirmationConfig;
 			const safeOptions = {
@@ -12055,7 +12125,7 @@ var TatchiPasskey = class {
 			};
 			const res = await router.startEmailRecovery({
 				accountId,
-				recoveryEmail,
+				recoveryEmail: normalizedRecoveryEmail,
 				onEvent: options?.onEvent,
 				options: Object.keys(safeOptions).length > 0 ? safeOptions : void 0
 			});