@tatchi-xyz/sdk 0.21.0 → 0.31.0

package/dist/cjs/server/core/ThresholdService/signingHandlers.js

@@ -0,0 +1,1179 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require_validation = require('../../sdk/src/utils/validation.js');
+const require_base64 = require('../../sdk/src/utils/base64.js');
+const require_participants = require('../../sdk/src/threshold/participants.js');
+const require_validation$1 = require('./validation.js');
+const require_ed25519 = require('../../node_modules/.pnpm/@noble_curves@2.0.1/node_modules/@noble/curves/ed25519.js');
+const require_coordinatorGrant = require('./coordinatorGrant.js');
+const require_cosigners = require('./cosigners.js');
+let src_wasm_signer_worker_pkg_wasm_signer_worker_js = require("../../../wasm_signer_worker/pkg/wasm_signer_worker.js");
+src_wasm_signer_worker_pkg_wasm_signer_worker_js = require_rolldown_runtime.__toESM(src_wasm_signer_worker_pkg_wasm_signer_worker_js);
+
+//#region src/server/core/ThresholdService/signingHandlers.ts
+function parseCommitments(input, label) {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return {
+		ok: false,
+		code: "invalid_body",
+		message: `${label}{hiding,binding} are required`
+	};
+	const rec = input;
+	const hiding = require_validation.toOptionalTrimmedString(rec.hiding);
+	const binding = require_validation.toOptionalTrimmedString(rec.binding);
+	if (!hiding || !binding) return {
+		ok: false,
+		code: "invalid_body",
+		message: `${label}{hiding,binding} are required`
+	};
+	return {
+		ok: true,
+		value: {
+			hiding,
+			binding
+		}
+	};
+}
+function parseThresholdEd25519SignInitRequest(request) {
+	const mpcSessionId = require_validation.toOptionalTrimmedString(request.mpcSessionId);
+	if (!mpcSessionId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "mpcSessionId is required"
+	};
+	const relayerKeyId = require_validation.toOptionalTrimmedString(request.relayerKeyId);
+	if (!relayerKeyId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "relayerKeyId is required"
+	};
+	const nearAccountId = require_validation.toOptionalTrimmedString(request.nearAccountId);
+	if (!nearAccountId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "nearAccountId is required"
+	};
+	const signingDigestB64u = require_validation.toOptionalTrimmedString(request.signingDigestB64u);
+	if (!signingDigestB64u) return {
+		ok: false,
+		code: "invalid_body",
+		message: "signingDigestB64u is required"
+	};
+	const commitments = parseCommitments(request.clientCommitments, "clientCommitments");
+	if (!commitments.ok) return commitments;
+	return {
+		ok: true,
+		value: {
+			mpcSessionId,
+			relayerKeyId,
+			nearAccountId,
+			signingDigestB64u,
+			clientCommitments: commitments.value
+		}
+	};
+}
+function parseThresholdEd25519FinalizeRequest(request) {
+	const signingSessionId = require_validation.toOptionalTrimmedString(request.signingSessionId);
+	if (!signingSessionId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "signingSessionId is required"
+	};
+	const clientSignatureShareB64u = require_validation.toOptionalTrimmedString(request.clientSignatureShareB64u);
+	if (!clientSignatureShareB64u) return {
+		ok: false,
+		code: "invalid_body",
+		message: "clientSignatureShareB64u is required"
+	};
+	return {
+		ok: true,
+		value: {
+			signingSessionId,
+			clientSignatureShareB64u
+		}
+	};
+}
+function parseThresholdEd25519CosignInitRequest(request) {
+	const signingSessionId = require_validation.toOptionalTrimmedString(request.signingSessionId);
+	if (!signingSessionId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "signingSessionId is required"
+	};
+	const cosignerShareB64u = require_validation.toOptionalTrimmedString(request.cosignerShareB64u);
+	if (!cosignerShareB64u) return {
+		ok: false,
+		code: "invalid_body",
+		message: "cosignerShareB64u is required"
+	};
+	try {
+		const decoded = require_base64.base64UrlDecode(cosignerShareB64u);
+		if (decoded.length !== 32) return {
+			ok: false,
+			code: "invalid_body",
+			message: `cosignerShareB64u must be 32 bytes, got ${decoded.length}`
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			code: "invalid_body",
+			message: `Invalid cosignerShareB64u: ${String(e || "decode failed")}`
+		};
+	}
+	const commitments = parseCommitments(request.clientCommitments, "clientCommitments");
+	if (!commitments.ok) return commitments;
+	return {
+		ok: true,
+		value: {
+			signingSessionId,
+			cosignerShareB64u,
+			clientCommitments: commitments.value
+		}
+	};
+}
+function parseThresholdEd25519CosignFinalizeRequest(request) {
+	const signingSessionId = require_validation.toOptionalTrimmedString(request.signingSessionId);
+	if (!signingSessionId) return {
+		ok: false,
+		code: "invalid_body",
+		message: "signingSessionId is required"
+	};
+	const groupPublicKey = require_validation.toOptionalTrimmedString(request.groupPublicKey);
+	if (!groupPublicKey) return {
+		ok: false,
+		code: "invalid_body",
+		message: "groupPublicKey is required"
+	};
+	const cosignerIds = require_cosigners.normalizeCosignerIds(request.cosignerIds);
+	if (!cosignerIds) return {
+		ok: false,
+		code: "invalid_body",
+		message: "cosignerIds must be a non-empty list of u16 ids"
+	};
+	const relayerCommitments = parseCommitments(request.relayerCommitments, "relayerCommitments");
+	if (!relayerCommitments.ok) return relayerCommitments;
+	return {
+		ok: true,
+		value: {
+			signingSessionId,
+			cosignerIds,
+			groupPublicKey,
+			relayerCommitments: relayerCommitments.value
+		}
+	};
+}
+function requireParticipantIdsIncludeSignerSet(raw, signerSet2p, label) {
+	const expected = require_participants.normalizeThresholdEd25519ParticipantIds(signerSet2p) || [...signerSet2p];
+	const participantIds = require_participants.normalizeThresholdEd25519ParticipantIds(raw) || [...expected];
+	for (const id of expected) if (!participantIds.includes(id)) return {
+		ok: false,
+		code: "unauthorized",
+		message: `${label} does not include the server signer set (expected participantIds to include [${expected.join(",")}])`
+	};
+	return {
+		ok: true,
+		value: participantIds
+	};
+}
+function expectThresholdEd25519Round1CommitWasmOutput(out) {
+	const parsed = out;
+	if (!parsed?.relayerNoncesB64u || !parsed?.relayerCommitments?.hiding || !parsed?.relayerCommitments?.binding) throw new Error("threshold-ed25519 /sign/init: invalid relayer commitments");
+	return parsed;
+}
+function expectThresholdEd25519Round2SignWasmOutput(out) {
+	const parsed = out;
+	if (!parsed?.relayerSignatureShareB64u) throw new Error("threshold-ed25519 /sign/finalize: missing relayerSignatureShareB64u");
+	return parsed;
+}
+function sumEd25519PointsB64u(pointsB64u, label) {
+	if (!pointsB64u.length) throw new Error(`${label}: empty point list`);
+	let acc = require_ed25519.ed25519.Point.ZERO;
+	for (const p of pointsB64u) {
+		const raw = require_validation.toOptionalTrimmedString(p);
+		if (!raw) throw new Error(`${label}: missing point`);
+		const bytes = require_base64.base64UrlDecode(raw);
+		if (bytes.length !== 32) throw new Error(`${label}: expected 32-byte point, got ${bytes.length}`);
+		const pt = require_ed25519.ed25519.Point.fromBytes(bytes);
+		acc = acc.add(pt);
+	}
+	return require_base64.base64UrlEncode(acc.toBytes());
+}
+function combineCommitmentsByAddition(commitments, label) {
+	if (!commitments.length) throw new Error(`${label}: empty commitments`);
+	const hiding = sumEd25519PointsB64u(commitments.map((c) => c.hiding), `${label}.hiding`);
+	const binding = sumEd25519PointsB64u(commitments.map((c) => c.binding), `${label}.binding`);
+	return {
+		hiding,
+		binding
+	};
+}
+var ThresholdEd25519SigningHandlers = class {
+	logger;
+	nodeRole;
+	relayerCosigners;
+	relayerCosignerThreshold;
+	relayerCosignerId;
+	coordinatorSharedSecretBytes;
+	coordinatorHmacKeyPromise = null;
+	clientParticipantId;
+	relayerParticipantId;
+	participantIds2p;
+	sessionStore;
+	ensureReady;
+	ensureSignerWasm;
+	viewAccessKeyList;
+	resolveRelayerKeyMaterial;
+	constructor(input) {
+		this.logger = input.logger;
+		this.nodeRole = input.nodeRole;
+		this.relayerCosigners = input.relayerCosigners;
+		this.relayerCosignerThreshold = input.relayerCosignerThreshold;
+		this.relayerCosignerId = input.relayerCosignerId;
+		this.coordinatorSharedSecretBytes = input.coordinatorSharedSecretBytes;
+		this.clientParticipantId = input.clientParticipantId;
+		this.relayerParticipantId = input.relayerParticipantId;
+		this.participantIds2p = input.participantIds2p;
+		this.sessionStore = input.sessionStore;
+		this.ensureReady = input.ensureReady;
+		this.ensureSignerWasm = input.ensureSignerWasm;
+		this.viewAccessKeyList = input.viewAccessKeyList;
+		this.resolveRelayerKeyMaterial = input.resolveRelayerKeyMaterial;
+	}
+	logResult(route, startedAtMs, result, extra) {
+		const elapsedMs = Math.max(0, Date.now() - startedAtMs);
+		const msg = typeof result.message === "string" ? result.message : void 0;
+		const message = msg && msg.length > 300 ? `${msg.slice(0, 297)}...` : msg;
+		const payload = {
+			route,
+			ok: result.ok,
+			...result.code ? { code: result.code } : {},
+			...!result.ok && message ? { message } : {},
+			elapsedMs,
+			...extra || {}
+		};
+		if (result.ok) {
+			this.logger.info("[threshold-ed25519] response", payload);
+			return;
+		}
+		if (result.code === "internal") {
+			this.logger.error("[threshold-ed25519] response", payload);
+			return;
+		}
+		this.logger.warn("[threshold-ed25519] response", payload);
+	}
+	createThresholdEd25519SigningSessionId() {
+		const id = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+		return `sign-${id}`;
+	}
+	async signCosignerGrant(payload) {
+		const out = await require_coordinatorGrant.signThresholdEd25519CosignerGrantV1({
+			secretBytes: this.coordinatorSharedSecretBytes,
+			keyPromise: this.coordinatorHmacKeyPromise,
+			payload
+		});
+		this.coordinatorHmacKeyPromise = out.keyPromise;
+		return out.token;
+	}
+	async verifyCosignerGrant(token) {
+		const verified = await require_coordinatorGrant.verifyThresholdEd25519CosignerGrantV1({
+			secretBytes: this.coordinatorSharedSecretBytes,
+			keyPromise: this.coordinatorHmacKeyPromise,
+			token
+		});
+		this.coordinatorHmacKeyPromise = verified.keyPromise;
+		if (!verified.ok) return verified;
+		return {
+			ok: true,
+			grant: verified.grant,
+			mpcSession: verified.mpcSession
+		};
+	}
+	async thresholdEd25519SignInit(request) {
+		const route = "/threshold-ed25519/sign/init";
+		const startedAtMs = Date.now();
+		let logExtra;
+		const result = await (async () => {
+			if (this.nodeRole !== "coordinator") return {
+				ok: false,
+				code: "not_found",
+				message: "threshold-ed25519 signing endpoints are not enabled on this server (set THRESHOLD_NODE_ROLE=coordinator)"
+			};
+			await this.ensureReady();
+			const parsedRequest = parseThresholdEd25519SignInitRequest(request);
+			if (!parsedRequest.ok) return parsedRequest;
+			const { mpcSessionId, relayerKeyId, nearAccountId, signingDigestB64u, clientCommitments } = parsedRequest.value;
+			this.logger.info("[threshold-ed25519] request", {
+				route,
+				mpcSessionId,
+				relayerKeyId,
+				nearAccountId,
+				signingDigestB64u_len: signingDigestB64u.length
+			});
+			const sess = await this.sessionStore.takeMpcSession(mpcSessionId);
+			if (!sess) return {
+				ok: false,
+				code: "unauthorized",
+				message: "mpcSessionId expired or invalid"
+			};
+			if (Date.now() > sess.expiresAtMs) return {
+				ok: false,
+				code: "unauthorized",
+				message: "mpcSessionId expired"
+			};
+			const groupParticipantIds = require_participants.normalizeThresholdEd25519ParticipantIds(sess.participantIds) || [...this.participantIds2p];
+			if (relayerKeyId !== sess.relayerKeyId) return {
+				ok: false,
+				code: "unauthorized",
+				message: "relayerKeyId does not match mpcSessionId scope"
+			};
+			if (nearAccountId !== sess.userId) return {
+				ok: false,
+				code: "unauthorized",
+				message: "nearAccountId does not match mpcSessionId scope"
+			};
+			if (signingDigestB64u !== sess.signingDigestB64u) return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingDigestB64u does not match mpcSessionId scope"
+			};
+			const hasRelayerCosignerConfig = this.relayerCosigners.length > 0 || this.relayerCosignerThreshold !== null;
+			if (hasRelayerCosignerConfig) {
+				logExtra = { mode: "cosigner" };
+				if (!this.relayerCosigners.length) return {
+					ok: false,
+					code: "missing_config",
+					message: "THRESHOLD_ED25519_RELAYER_COSIGNERS is required for relayer cosigning mode"
+				};
+				const t = this.relayerCosignerThreshold;
+				if (!t) return {
+					ok: false,
+					code: "missing_config",
+					message: "THRESHOLD_ED25519_RELAYER_COSIGNER_T is required for relayer cosigning mode"
+				};
+				const signerSetRes$1 = requireParticipantIdsIncludeSignerSet(groupParticipantIds, this.participantIds2p, "mpcSessionId");
+				if (!signerSetRes$1.ok) return signerSetRes$1;
+				const cosignerIdsAll = require_cosigners.normalizeCosignerIds(Array.from(new Set(this.relayerCosigners.map((p) => p.cosignerId)))) || [];
+				logExtra = {
+					...logExtra,
+					cosignerIdsAll,
+					t
+				};
+				if (cosignerIdsAll.length === 0) return {
+					ok: false,
+					code: "missing_config",
+					message: "THRESHOLD_ED25519_RELAYER_COSIGNERS must include at least one cosignerId"
+				};
+				if (t > cosignerIdsAll.length) return {
+					ok: false,
+					code: "missing_config",
+					message: `THRESHOLD_ED25519_RELAYER_COSIGNER_T must be <= number of cosigners (got t=${t}, n=${cosignerIdsAll.length})`
+				};
+				const key = await this.resolveRelayerKeyMaterial({
+					relayerKeyId: sess.relayerKeyId,
+					nearAccountId: sess.userId,
+					rpId: sess.rpId,
+					clientVerifyingShareB64u: sess.clientVerifyingShareB64u
+				});
+				if (!key.ok) return {
+					ok: false,
+					code: key.code,
+					message: key.message
+				};
+				const scope = await require_validation$1.ensureRelayerKeyIsActiveAccessKey({
+					nearAccountId: sess.userId,
+					relayerPublicKey: key.publicKey,
+					viewAccessKeyList: this.viewAccessKeyList
+				});
+				if (!scope.ok) return {
+					ok: false,
+					code: scope.code,
+					message: scope.message
+				};
+				const shares = require_cosigners.deriveRelayerCosignerSharesFromRelayerSigningShare({
+					relayerSigningShareB64u: key.relayerSigningShareB64u,
+					cosignerIds: cosignerIdsAll,
+					cosignerThreshold: t
+				});
+				if (!shares.ok) return {
+					ok: false,
+					code: shares.code,
+					message: shares.message
+				};
+				const now = Math.floor(Date.now() / 1e3);
+				const exp = now + 60;
+				const signingSessionId = this.createThresholdEd25519SigningSessionId();
+				const ttlMs = 6e4;
+				const expiresAtMs = Date.now() + ttlMs;
+				this.logger.info("[threshold-ed25519] cosign/init fanout", {
+					route,
+					signingSessionId,
+					cosignerIdsAll,
+					t
+				});
+				const initResults = await Promise.all(cosignerIdsAll.map(async (cosignerId) => {
+					const cosignerShareB64u = shares.sharesByCosignerId[String(cosignerId)];
+					if (!cosignerShareB64u) return {
+						ok: false,
+						cosignerId,
+						code: "internal",
+						message: "missing derived cosigner share"
+					};
+					const grant = await this.signCosignerGrant({
+						v: 1,
+						typ: "threshold_ed25519_cosigner_grant_v1",
+						iat: now,
+						exp,
+						mpcSessionId,
+						cosignerId,
+						mpcSession: sess
+					});
+					if (!grant) return {
+						ok: false,
+						cosignerId,
+						code: "missing_config",
+						message: "THRESHOLD_COORDINATOR_SHARED_SECRET_B64U is required for relayer cosigning"
+					};
+					const candidates = this.relayerCosigners.filter((p) => p.cosignerId === cosignerId);
+					if (!candidates.length) return {
+						ok: false,
+						cosignerId,
+						code: "missing_config",
+						message: `Missing relayer cosigner peer for cosignerId=${cosignerId}`
+					};
+					let lastErr = null;
+					for (const peer of candidates) {
+						const initUrl = `${peer.relayerUrl}/threshold-ed25519/internal/cosign/init`;
+						const peerInit = await this.postJsonWithTimeout(initUrl, {
+							coordinatorGrant: grant,
+							signingSessionId,
+							cosignerShareB64u,
+							clientCommitments
+						}, 1e4);
+						if (!peerInit.ok) {
+							lastErr = peerInit;
+							continue;
+						}
+						const initJson = peerInit.json;
+						if (!initJson?.ok) {
+							lastErr = {
+								code: initJson?.code || "internal",
+								message: initJson?.message || "cosign/init failed"
+							};
+							continue;
+						}
+						const commitments = initJson.relayerCommitments;
+						if (!commitments?.hiding || !commitments?.binding) {
+							lastErr = {
+								code: "internal",
+								message: "cosign/init produced incomplete commitments"
+							};
+							continue;
+						}
+						return {
+							ok: true,
+							cosignerId,
+							cosignerGrant: grant,
+							relayerUrl: peer.relayerUrl,
+							relayerCommitments: commitments
+						};
+					}
+					if (lastErr) this.logger.warn("[threshold-ed25519] cosign/init failed", {
+						route,
+						signingSessionId,
+						cosignerId,
+						candidateRelayerUrls: candidates.map((p) => p.relayerUrl),
+						code: lastErr.code,
+						message: lastErr.message
+					});
+					return {
+						ok: false,
+						cosignerId,
+						code: lastErr?.code || "unavailable",
+						message: lastErr?.message || "No cosigner available for cosign/init"
+					};
+				}));
+				const okInits = initResults.filter((r) => r.ok);
+				if (okInits.length < t) {
+					const errors = initResults.filter((r) => !r.ok);
+					const lastErr = errors.length ? errors[errors.length - 1] : null;
+					logExtra = {
+						...logExtra,
+						signingSessionId,
+						okCosigners: okInits.length
+					};
+					return {
+						ok: false,
+						code: lastErr?.code || "unavailable",
+						message: `Need at least ${t} relayer cosigners; got ${okInits.length}`
+					};
+				}
+				okInits.sort((a, b) => a.cosignerId - b.cosignerId);
+				const selected = okInits.slice(0, t);
+				const selectedCosignerIds = selected.map((r) => r.cosignerId);
+				const relayerCommitments = combineCommitmentsByAddition(selected.map((r) => r.relayerCommitments), "cosignerCommitments");
+				const commitmentsById = {
+					[String(this.clientParticipantId)]: clientCommitments,
+					[String(this.relayerParticipantId)]: relayerCommitments
+				};
+				const relayerVerifyingSharesById = { [String(this.relayerParticipantId)]: key.relayerVerifyingShareB64u };
+				const cosignerRelayerUrlsById = {};
+				const cosignerCoordinatorGrantsById = {};
+				for (const r of selected) {
+					cosignerRelayerUrlsById[String(r.cosignerId)] = r.relayerUrl;
+					cosignerCoordinatorGrantsById[String(r.cosignerId)] = r.cosignerGrant;
+				}
+				await this.sessionStore.putCoordinatorSigningSession(signingSessionId, {
+					mode: "cosigner",
+					expiresAtMs,
+					mpcSessionId,
+					relayerKeyId: sess.relayerKeyId,
+					signingDigestB64u: sess.signingDigestB64u,
+					userId: sess.userId,
+					rpId: sess.rpId,
+					clientVerifyingShareB64u: sess.clientVerifyingShareB64u,
+					commitmentsById,
+					participantIds: [...this.participantIds2p],
+					groupPublicKey: key.publicKey,
+					cosignerIds: selectedCosignerIds,
+					cosignerRelayerUrlsById,
+					cosignerCoordinatorGrantsById,
+					relayerVerifyingSharesById
+				}, ttlMs);
+				logExtra = {
+					...logExtra,
+					signingSessionId,
+					selectedCosignerIds
+				};
+				return {
+					ok: true,
+					signingSessionId,
+					commitmentsById,
+					relayerVerifyingSharesById,
+					participantIds: [...this.participantIds2p]
+				};
+			}
+			logExtra = { mode: "local" };
+			const signerSetRes = requireParticipantIdsIncludeSignerSet(groupParticipantIds, this.participantIds2p, "mpcSessionId");
+			if (!signerSetRes.ok) return signerSetRes;
+			const out = await this.peerSignInitFromMpcSessionRecord({
+				mpcSessionId,
+				mpcSession: sess,
+				clientCommitments
+			});
+			if (!out.ok) return out;
+			logExtra = {
+				...logExtra,
+				signingSessionId: out.signingSessionId
+			};
+			return {
+				ok: true,
+				signingSessionId: out.signingSessionId,
+				commitmentsById: {
+					[String(this.clientParticipantId)]: clientCommitments,
+					[String(this.relayerParticipantId)]: out.relayerCommitments
+				},
+				relayerVerifyingSharesById: { [String(this.relayerParticipantId)]: out.relayerVerifyingShareB64u },
+				participantIds: [...this.participantIds2p]
+			};
+		})().catch((e) => {
+			const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Internal error");
+			return {
+				ok: false,
+				code: "internal",
+				message: msg
+			};
+		});
+		this.logResult(route, startedAtMs, result, logExtra);
+		return result;
+	}
+	async thresholdEd25519CosignInit(request) {
+		const route = "/threshold-ed25519/internal/cosign/init";
+		const startedAtMs = Date.now();
+		const cosignerId = this.relayerCosignerId;
+		const logExtra = cosignerId ? { cosignerId } : void 0;
+		const result = await (async () => {
+			if (!cosignerId || this.nodeRole !== "cosigner" && this.nodeRole !== "coordinator") return {
+				ok: false,
+				code: "not_found",
+				message: "threshold-ed25519 cosigner endpoints are not enabled on this server (set THRESHOLD_NODE_ROLE=cosigner)"
+			};
+			await this.ensureReady();
+			const parsedRequest = parseThresholdEd25519CosignInitRequest(request);
+			if (!parsedRequest.ok) return parsedRequest;
+			const { signingSessionId, cosignerShareB64u, clientCommitments } = parsedRequest.value;
+			this.logger.info("[threshold-ed25519] request", {
+				route,
+				signingSessionId,
+				cosignerId,
+				cosignerShareB64u_len: cosignerShareB64u.length
+			});
+			const verified = await this.verifyCosignerGrant(request.coordinatorGrant);
+			if (!verified.ok) return {
+				ok: false,
+				code: verified.code,
+				message: verified.message
+			};
+			const { grant, mpcSession } = verified;
+			if (grant.cosignerId !== cosignerId) return {
+				ok: false,
+				code: "unauthorized",
+				message: "coordinatorGrant does not match this cosigner id"
+			};
+			const participantIdsRes = requireParticipantIdsIncludeSignerSet(mpcSession.participantIds, this.participantIds2p, "coordinatorGrant");
+			if (!participantIdsRes.ok) return participantIdsRes;
+			await this.ensureSignerWasm();
+			const commit = expectThresholdEd25519Round1CommitWasmOutput((0, src_wasm_signer_worker_pkg_wasm_signer_worker_js.threshold_ed25519_round1_commit)(cosignerShareB64u));
+			const ttlMs = 6e4;
+			const expiresAtMs = Date.now() + ttlMs;
+			const commitmentsById = { [String(this.clientParticipantId)]: clientCommitments };
+			await this.sessionStore.putSigningSession(signingSessionId, {
+				expiresAtMs,
+				mpcSessionId: grant.mpcSessionId,
+				relayerKeyId: mpcSession.relayerKeyId,
+				signingDigestB64u: mpcSession.signingDigestB64u,
+				userId: mpcSession.userId,
+				rpId: mpcSession.rpId,
+				clientVerifyingShareB64u: mpcSession.clientVerifyingShareB64u,
+				commitmentsById,
+				relayerSigningShareB64u: cosignerShareB64u,
+				relayerNoncesB64u: commit.relayerNoncesB64u,
+				participantIds: [...this.participantIds2p]
+			}, ttlMs);
+			return {
+				ok: true,
+				relayerCommitments: commit.relayerCommitments
+			};
+		})().catch((e) => {
+			const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Internal error");
+			return {
+				ok: false,
+				code: "internal",
+				message: msg
+			};
+		});
+		this.logResult(route, startedAtMs, result, logExtra);
+		return result;
+	}
+	async thresholdEd25519CosignFinalize(request) {
+		const route = "/threshold-ed25519/internal/cosign/finalize";
+		const startedAtMs = Date.now();
+		const cosignerId = this.relayerCosignerId;
+		const logExtra = cosignerId ? { cosignerId } : void 0;
+		const result = await (async () => {
+			if (!cosignerId || this.nodeRole !== "cosigner" && this.nodeRole !== "coordinator") return {
+				ok: false,
+				code: "not_found",
+				message: "threshold-ed25519 cosigner endpoints are not enabled on this server (set THRESHOLD_NODE_ROLE=cosigner)"
+			};
+			await this.ensureReady();
+			const parsedRequest = parseThresholdEd25519CosignFinalizeRequest(request);
+			if (!parsedRequest.ok) return parsedRequest;
+			const { signingSessionId, cosignerIds, groupPublicKey, relayerCommitments } = parsedRequest.value;
+			this.logger.info("[threshold-ed25519] request", {
+				route,
+				signingSessionId,
+				cosignerId,
+				cosignerIds
+			});
+			const verified = await this.verifyCosignerGrant(request.coordinatorGrant);
+			if (!verified.ok) return {
+				ok: false,
+				code: verified.code,
+				message: verified.message
+			};
+			const { grant, mpcSession } = verified;
+			if (grant.cosignerId !== cosignerId) return {
+				ok: false,
+				code: "unauthorized",
+				message: "coordinatorGrant does not match this cosigner id"
+			};
+			if (!cosignerIds.includes(cosignerId)) return {
+				ok: false,
+				code: "unauthorized",
+				message: "cosignerIds must include this cosigner id"
+			};
+			const sess = await this.sessionStore.takeSigningSession(signingSessionId);
+			if (!sess) return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId expired or invalid"
+			};
+			if (Date.now() > sess.expiresAtMs) return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId expired"
+			};
+			const restoreOnMismatch = async () => {
+				const ttlMs = Math.max(0, sess.expiresAtMs - Date.now());
+				if (!ttlMs) return;
+				await this.sessionStore.putSigningSession(signingSessionId, sess, ttlMs);
+			};
+			if (sess.mpcSessionId !== grant.mpcSessionId) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			if (sess.relayerKeyId !== mpcSession.relayerKeyId) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			if (sess.signingDigestB64u !== mpcSession.signingDigestB64u) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			if (sess.userId !== mpcSession.userId) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			if (sess.rpId !== mpcSession.rpId) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			if (sess.clientVerifyingShareB64u !== mpcSession.clientVerifyingShareB64u) {
+				await restoreOnMismatch();
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId does not match coordinatorGrant scope"
+				};
+			}
+			const storedShareB64u = require_validation.toOptionalTrimmedString(sess.relayerSigningShareB64u);
+			if (!storedShareB64u) return {
+				ok: false,
+				code: "internal",
+				message: "cosigner signing session missing share material"
+			};
+			const lambdaRes = require_cosigners.lagrangeCoefficientAtZeroForCosigner({
+				cosignerId,
+				cosignerIds
+			});
+			if (!lambdaRes.ok) return {
+				ok: false,
+				code: lambdaRes.code,
+				message: lambdaRes.message
+			};
+			const effShare = require_cosigners.multiplyEd25519ScalarB64uByScalarBytesLE32({
+				scalarB64u: storedShareB64u,
+				factorBytesLE32: lambdaRes.lambda
+			});
+			if (!effShare.ok) return {
+				ok: false,
+				code: effShare.code,
+				message: effShare.message
+			};
+			await this.ensureSignerWasm();
+			const clientCommitments = sess.commitmentsById?.[String(this.clientParticipantId)];
+			if (!clientCommitments) return {
+				ok: false,
+				code: "internal",
+				message: "signingSessionId missing client commitments"
+			};
+			const out = expectThresholdEd25519Round2SignWasmOutput((0, src_wasm_signer_worker_pkg_wasm_signer_worker_js.threshold_ed25519_round2_sign_cosigner)({
+				clientParticipantId: this.clientParticipantId,
+				relayerParticipantId: this.relayerParticipantId,
+				relayerSigningShareB64u: effShare.scalarB64u,
+				relayerNoncesB64u: sess.relayerNoncesB64u,
+				groupPublicKey,
+				signingDigestB64u: sess.signingDigestB64u,
+				clientCommitments,
+				relayerCommitments
+			}));
+			return {
+				ok: true,
+				relayerSignatureShareB64u: out.relayerSignatureShareB64u
+			};
+		})().catch((e) => {
+			const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Internal error");
+			return {
+				ok: false,
+				code: "internal",
+				message: msg
+			};
+		});
+		this.logResult(route, startedAtMs, result, logExtra);
+		return result;
+	}
+	async peerSignInitFromMpcSessionRecord(input) {
+		const mpcSessionId = input.mpcSessionId;
+		const sess = input.mpcSession;
+		if (Date.now() > sess.expiresAtMs) return {
+			ok: false,
+			code: "unauthorized",
+			message: "mpcSessionId expired"
+		};
+		const participantIdsRes = requireParticipantIdsIncludeSignerSet(sess.participantIds, this.participantIds2p, "mpcSessionId");
+		if (!participantIdsRes.ok) return participantIdsRes;
+		const participantIds = participantIdsRes.value;
+		const signingDigestB64u = sess.signingDigestB64u;
+		const key = await this.resolveRelayerKeyMaterial({
+			relayerKeyId: sess.relayerKeyId,
+			nearAccountId: sess.userId,
+			rpId: sess.rpId,
+			clientVerifyingShareB64u: sess.clientVerifyingShareB64u
+		});
+		if (!key.ok) return {
+			ok: false,
+			code: key.code,
+			message: key.message
+		};
+		const scope = await require_validation$1.ensureRelayerKeyIsActiveAccessKey({
+			nearAccountId: sess.userId,
+			relayerPublicKey: key.publicKey,
+			viewAccessKeyList: this.viewAccessKeyList
+		});
+		if (!scope.ok) return {
+			ok: false,
+			code: scope.code,
+			message: scope.message
+		};
+		await this.ensureSignerWasm();
+		const commit = expectThresholdEd25519Round1CommitWasmOutput((0, src_wasm_signer_worker_pkg_wasm_signer_worker_js.threshold_ed25519_round1_commit)(key.relayerSigningShareB64u));
+		const signingSessionId = this.createThresholdEd25519SigningSessionId();
+		const ttlMs = 6e4;
+		const expiresAtMs = Date.now() + ttlMs;
+		const commitmentsById = {
+			[String(this.clientParticipantId)]: input.clientCommitments,
+			[String(this.relayerParticipantId)]: commit.relayerCommitments
+		};
+		await this.sessionStore.putSigningSession(signingSessionId, {
+			expiresAtMs,
+			mpcSessionId,
+			relayerKeyId: sess.relayerKeyId,
+			signingDigestB64u,
+			userId: sess.userId,
+			rpId: sess.rpId,
+			clientVerifyingShareB64u: sess.clientVerifyingShareB64u,
+			commitmentsById,
+			relayerNoncesB64u: commit.relayerNoncesB64u,
+			participantIds
+		}, ttlMs);
+		return {
+			ok: true,
+			signingSessionId,
+			relayerCommitments: commit.relayerCommitments,
+			relayerVerifyingShareB64u: key.relayerVerifyingShareB64u
+		};
+	}
+	async peerSignFinalizeFromSigningSessionId(input) {
+		const signingSessionId = input.signingSessionId;
+		input.clientSignatureShareB64u;
+		const sess = await this.sessionStore.takeSigningSession(signingSessionId);
+		if (!sess) return {
+			ok: false,
+			code: "unauthorized",
+			message: "signingSessionId expired or invalid"
+		};
+		if (Date.now() > sess.expiresAtMs) return {
+			ok: false,
+			code: "unauthorized",
+			message: "signingSessionId expired"
+		};
+		const restoreOnMismatch = async () => {
+			const ttlMs = Math.max(0, sess.expiresAtMs - Date.now());
+			if (!ttlMs) return;
+			await this.sessionStore.putSigningSession(signingSessionId, sess, ttlMs);
+		};
+		if (input.expectedMpcSessionId && sess.mpcSessionId !== input.expectedMpcSessionId) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		if (input.expectedRelayerKeyId && sess.relayerKeyId !== input.expectedRelayerKeyId) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		if (input.expectedSigningDigestB64u && sess.signingDigestB64u !== input.expectedSigningDigestB64u) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		if (input.expectedUserId && sess.userId !== input.expectedUserId) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		if (input.expectedRpId && sess.rpId !== input.expectedRpId) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		if (input.expectedClientVerifyingShareB64u && sess.clientVerifyingShareB64u !== input.expectedClientVerifyingShareB64u) {
+			await restoreOnMismatch();
+			return {
+				ok: false,
+				code: "unauthorized",
+				message: "signingSessionId does not match coordinatorGrant scope"
+			};
+		}
+		const participantIdsRes = requireParticipantIdsIncludeSignerSet(sess.participantIds, this.participantIds2p, "signingSessionId");
+		if (!participantIdsRes.ok) return participantIdsRes;
+		const key = await this.resolveRelayerKeyMaterial({
+			relayerKeyId: sess.relayerKeyId,
+			nearAccountId: sess.userId,
+			rpId: sess.rpId,
+			clientVerifyingShareB64u: sess.clientVerifyingShareB64u
+		});
+		if (!key.ok) return {
+			ok: false,
+			code: key.code,
+			message: key.message
+		};
+		await this.ensureSignerWasm();
+		const clientCommitments = sess.commitmentsById?.[String(this.clientParticipantId)];
+		const relayerCommitments = sess.commitmentsById?.[String(this.relayerParticipantId)];
+		if (!clientCommitments || !relayerCommitments) return {
+			ok: false,
+			code: "internal",
+			message: "signingSessionId missing commitment transcript"
+		};
+		const out = expectThresholdEd25519Round2SignWasmOutput((0, src_wasm_signer_worker_pkg_wasm_signer_worker_js.threshold_ed25519_round2_sign)({
+			clientParticipantId: this.clientParticipantId,
+			relayerParticipantId: this.relayerParticipantId,
+			relayerSigningShareB64u: key.relayerSigningShareB64u,
+			relayerNoncesB64u: sess.relayerNoncesB64u,
+			groupPublicKey: key.publicKey,
+			signingDigestB64u: sess.signingDigestB64u,
+			clientCommitments,
+			relayerCommitments
+		}));
+		return {
+			ok: true,
+			relayerSignatureShareB64u: out.relayerSignatureShareB64u
+		};
+	}
+	async thresholdEd25519SignFinalize(request) {
+		const route = "/threshold-ed25519/sign/finalize";
+		const startedAtMs = Date.now();
+		let logExtra;
+		const result = await (async () => {
+			if (this.nodeRole !== "coordinator") return {
+				ok: false,
+				code: "not_found",
+				message: "threshold-ed25519 signing endpoints are not enabled on this server (set THRESHOLD_NODE_ROLE=coordinator)"
+			};
+			await this.ensureReady();
+			const parsedRequest = parseThresholdEd25519FinalizeRequest(request);
+			if (!parsedRequest.ok) return parsedRequest;
+			const { signingSessionId, clientSignatureShareB64u } = parsedRequest.value;
+			this.logger.info("[threshold-ed25519] request", {
+				route,
+				signingSessionId,
+				clientSignatureShareB64u_len: clientSignatureShareB64u.length
+			});
+			const coord = await this.sessionStore.takeCoordinatorSigningSession(signingSessionId);
+			if (!coord) {
+				logExtra = {
+					mode: "local",
+					signingSessionId
+				};
+				const out = await this.peerSignFinalizeFromSigningSessionId({
+					signingSessionId,
+					clientSignatureShareB64u
+				});
+				if (!out.ok) return out;
+				return {
+					ok: true,
+					relayerSignatureSharesById: { [String(this.relayerParticipantId)]: out.relayerSignatureShareB64u }
+				};
+			}
+			if (Date.now() > coord.expiresAtMs) {
+				logExtra = {
+					mode: coord.mode,
+					signingSessionId
+				};
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "signingSessionId expired"
+				};
+			}
+			if (coord.mode === "cosigner") {
+				const cosignerIds = require_cosigners.normalizeCosignerIds(coord.cosignerIds);
+				logExtra = {
+					mode: "cosigner",
+					signingSessionId,
+					cosignerIds
+				};
+				if (!cosignerIds || cosignerIds.length === 0) return {
+					ok: false,
+					code: "internal",
+					message: "coordinator signing session missing cosignerIds"
+				};
+				const relayerCommitments = coord.commitmentsById?.[String(this.relayerParticipantId)];
+				if (!relayerCommitments?.hiding || !relayerCommitments?.binding) return {
+					ok: false,
+					code: "internal",
+					message: "coordinator signing session missing relayer commitments"
+				};
+				this.logger.info("[threshold-ed25519] cosign/finalize fanout", {
+					route,
+					signingSessionId,
+					cosignerIds
+				});
+				const sharesByCosignerId = {};
+				let lastPeerErr = null;
+				for (const cosignerId of cosignerIds) {
+					const cosignerRelayerUrl = coord.cosignerRelayerUrlsById?.[String(cosignerId)];
+					const cosignerGrant = coord.cosignerCoordinatorGrantsById?.[String(cosignerId)];
+					if (!cosignerRelayerUrl || !cosignerGrant) return {
+						ok: false,
+						code: "internal",
+						message: "coordinator signing session missing cosigner mapping"
+					};
+					const candidates = [cosignerRelayerUrl, ...this.relayerCosigners.filter((p) => p.cosignerId === cosignerId).map((p) => p.relayerUrl)].filter((url, idx, arr) => arr.indexOf(url) === idx);
+					let cosignerShare = null;
+					for (const relayerUrl of candidates) {
+						const finalizeUrl = `${relayerUrl}/threshold-ed25519/internal/cosign/finalize`;
+						const peerFinalize = await this.postJsonWithTimeout(finalizeUrl, {
+							coordinatorGrant: cosignerGrant,
+							signingSessionId,
+							cosignerIds,
+							groupPublicKey: coord.groupPublicKey,
+							relayerCommitments
+						}, 1e4);
+						if (!peerFinalize.ok) {
+							lastPeerErr = peerFinalize;
+							continue;
+						}
+						const finalizeJson = peerFinalize.json;
+						if (!finalizeJson?.ok) {
+							lastPeerErr = {
+								code: finalizeJson?.code || "internal",
+								message: finalizeJson?.message || "cosign/finalize failed"
+							};
+							continue;
+						}
+						const share = require_validation.toOptionalTrimmedString(finalizeJson.relayerSignatureShareB64u);
+						if (!share) {
+							lastPeerErr = {
+								code: "internal",
+								message: "cosign/finalize produced empty signature share"
+							};
+							continue;
+						}
+						cosignerShare = share;
+						break;
+					}
+					if (!cosignerShare) {
+						if (lastPeerErr) this.logger.warn("[threshold-ed25519] cosign/finalize failed", {
+							route,
+							signingSessionId,
+							cosignerId,
+							candidateRelayerUrls: candidates,
+							code: lastPeerErr.code,
+							message: lastPeerErr.message
+						});
+						logExtra = {
+							...logExtra,
+							failedCosignerId: cosignerId
+						};
+						return {
+							ok: false,
+							code: lastPeerErr?.code || "unavailable",
+							message: lastPeerErr?.message || `No cosigner available for cosign/finalize (cosignerId=${cosignerId})`
+						};
+					}
+					sharesByCosignerId[String(cosignerId)] = cosignerShare;
+				}
+				const summed = require_cosigners.addEd25519ScalarsB64u({ scalarsB64u: Object.values(sharesByCosignerId) });
+				if (!summed.ok) return {
+					ok: false,
+					code: summed.code,
+					message: summed.message
+				};
+				return {
+					ok: true,
+					relayerSignatureSharesById: { [String(this.relayerParticipantId)]: summed.scalarB64u }
+				};
+			}
+			logExtra = {
+				mode: coord.mode,
+				signingSessionId
+			};
+			return {
+				ok: false,
+				code: "internal",
+				message: "coordinator signing session has invalid mode"
+			};
+		})().catch((e) => {
+			const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Internal error");
+			return {
+				ok: false,
+				code: "internal",
+				message: msg
+			};
+		});
+		this.logResult(route, startedAtMs, result, logExtra);
+		return result;
+	}
+	async postJsonWithTimeout(url, body, timeoutMs) {
+		const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+		const id = controller ? setTimeout(() => controller.abort(), Math.max(0, Number(timeoutMs) || 0)) : void 0;
+		try {
+			const res = await fetch(url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body ?? {}),
+				signal: controller?.signal
+			});
+			const text = await res.text();
+			let json = {};
+			try {
+				json = text ? JSON.parse(text) : {};
+			} catch {
+				json = {};
+			}
+			return {
+				ok: true,
+				status: res.status,
+				json
+			};
+		} catch (e) {
+			const msg = String(e && typeof e === "object" && "message" in e ? e.message : e || "Network error");
+			return {
+				ok: false,
+				code: "internal",
+				message: msg
+			};
+		} finally {
+			if (id !== void 0) clearTimeout(id);
+		}
+	}
+};
+
+//#endregion
+exports.ThresholdEd25519SigningHandlers = ThresholdEd25519SigningHandlers;
+//# sourceMappingURL=signingHandlers.js.map