@seams/wallet-server 0.5.0

package/dist/esm/core/SessionService.js

@@ -0,0 +1,255 @@
+//#region src/core/SessionService.ts
+function normalizeParsedCorsOrigin(url) {
+	const host = url.hostname.toLowerCase();
+	const proto = url.protocol === "http:" || url.protocol === "https:" ? url.protocol : "https:";
+	const rawPort = String(url.port || "").trim();
+	return `${proto}//${host}${rawPort && !(proto === "https:" && rawPort === "443") && !(proto === "http:" && rawPort === "80") ? `:${rawPort}` : ""}`;
+}
+var SessionService = class {
+	constructor(cfg) {
+		this.cfg = cfg || {};
+	}
+	getCookieName() {
+		return this.cfg?.cookie?.name || "seams-jwt";
+	}
+	buildSetCookie(token) {
+		if (this.cfg?.cookie?.buildSetHeader) return this.cfg.cookie.buildSetHeader(token);
+		const cookieParts = [`${this.getCookieName()}=${token}`];
+		const path = "/";
+		const sameSite = "Lax";
+		const maxAge = 24 * 3600;
+		cookieParts.push(`Path=${path}`);
+		cookieParts.push("HttpOnly");
+		cookieParts.push("Secure");
+		cookieParts.push(`SameSite=${sameSite}`);
+		{
+			cookieParts.push(`Max-Age=${maxAge}`);
+			const expires = new Date(Date.now() + maxAge * 1e3).toUTCString();
+			cookieParts.push(`Expires=${expires}`);
+		}
+		return cookieParts.join("; ");
+	}
+	buildClearCookie() {
+		if (this.cfg?.cookie?.buildClearHeader) return this.cfg.cookie.buildClearHeader();
+		const parts = [
+			`${this.getCookieName()}=`,
+			`Path=/`,
+			"Max-Age=0",
+			"Expires=Thu, 01 Jan 1970 00:00:00 GMT"
+		];
+		parts.push("HttpOnly");
+		parts.push("Secure");
+		parts.push(`SameSite=Lax`);
+		return parts.join("; ");
+	}
+	/** Sign a JWT using the host-provided signing hook. */
+	async signJwt(sub, extraClaims) {
+		const jwt = this.cfg?.jwt || {};
+		const built = await Promise.resolve(jwt.buildClaims?.({
+			sub,
+			context: extraClaims
+		})) || {};
+		const payload = {
+			sub,
+			...extraClaims || {},
+			...built || {}
+		};
+		if (typeof jwt.signToken === "function") return await Promise.resolve(jwt.signToken({
+			header: { typ: "JWT" },
+			payload
+		}));
+		throw new Error("SessionService: No JWT signing hook or provider configured");
+	}
+	/** Verify signature and enforce standard time claims (`exp`/`nbf`) when present. */
+	async verifyJwt(token) {
+		const verify = this.cfg?.jwt?.verifyToken;
+		if (typeof verify !== "function") return {
+			valid: false,
+			reason: "signature_invalid"
+		};
+		const out = await Promise.resolve(verify(token));
+		if (!out?.valid) return {
+			valid: false,
+			reason: "signature_invalid"
+		};
+		const payload = out.payload;
+		if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {
+			valid: false,
+			reason: "claims_invalid"
+		};
+		const now = this.nowSeconds();
+		const expRaw = payload.exp;
+		if (expRaw !== void 0) {
+			const exp = Number(expRaw);
+			if (!Number.isFinite(exp)) return {
+				valid: false,
+				reason: "claims_invalid"
+			};
+			if (now >= exp) return {
+				valid: false,
+				reason: "expired"
+			};
+		}
+		const nbfRaw = payload.nbf;
+		if (nbfRaw !== void 0) {
+			const nbf = Number(nbfRaw);
+			if (!Number.isFinite(nbf)) return {
+				valid: false,
+				reason: "claims_invalid"
+			};
+			if (now < nbf) return {
+				valid: false,
+				reason: "not_active"
+			};
+		}
+		return {
+			valid: true,
+			payload
+		};
+	}
+	async parse(headers) {
+		const authHeader = headers["authorization"] || headers["Authorization"];
+		let token = null;
+		if (authHeader && /^Bearer\s+/.test(authHeader)) token = authHeader.replace(/^Bearer\s+/i, "").trim();
+		const cookieHeader = headers["cookie"] || headers["Cookie"];
+		if (!token && cookieHeader) {
+			const name = this.getCookieName();
+			for (const part of cookieHeader.split(";")) {
+				const [k, v] = part.split("=");
+				if (k && k.trim() === name) {
+					token = (v || "").trim();
+					break;
+				}
+			}
+		}
+		if (!token) return {
+			ok: false,
+			reason: "missing"
+		};
+		const verified = await this.verifyJwt(token);
+		if (!verified.valid) return {
+			ok: false,
+			reason: verified.reason
+		};
+		return {
+			ok: true,
+			claims: verified.payload
+		};
+	}
+	extractTokenFromHeaders(headers) {
+		if (this.cfg?.cookie?.extractToken) return this.cfg.cookie.extractToken(headers, this.getCookieName());
+		const authHeader = headers["authorization"] || headers["Authorization"];
+		if (authHeader && /^Bearer\s+/.test(authHeader)) return authHeader.replace(/^Bearer\s+/i, "").trim();
+		const cookieHeader = headers["cookie"] || headers["Cookie"];
+		if (cookieHeader) {
+			const name = this.getCookieName();
+			for (const part of cookieHeader.split(";")) {
+				const [k, v] = part.split("=");
+				if (k && k.trim() === name) return (v || "").trim();
+			}
+		}
+		return null;
+	}
+	async refresh(headers) {
+		try {
+			const token = this.extractTokenFromHeaders(headers);
+			if (!token) return {
+				ok: false,
+				code: "unauthorized",
+				message: "No session token"
+			};
+			const v = await this.verifyJwt(token);
+			if (!v.valid) {
+				if (v.reason === "expired") return {
+					ok: false,
+					code: "wallet_session_expired",
+					message: "Wallet Session expired"
+				};
+				return {
+					ok: false,
+					code: "unauthorized",
+					message: "Invalid token"
+				};
+			}
+			const payload = v.payload || {};
+			if (!this.isWithinRefreshWindow(payload)) return {
+				ok: false,
+				code: "not_eligible",
+				message: "Not within refresh window"
+			};
+			const sub = String(payload.sub || "");
+			if (!sub) return {
+				ok: false,
+				code: "invalid_claims",
+				message: "Missing sub claim"
+			};
+			const extra = {};
+			for (const [k, v] of Object.entries(payload || {})) {
+				if (k === "sub" || k === "exp" || k === "iat" || k === "nbf" || k === "jti" || k === "iss" || k === "aud") continue;
+				extra[k] = v;
+			}
+			return {
+				ok: true,
+				jwt: await this.signJwt(sub, extra)
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				code: "internal",
+				message: e?.message || "Refresh failed"
+			};
+		}
+	}
+	nowSeconds() {
+		return Math.floor(Date.now() / 1e3);
+	}
+	isWithinRefreshWindow(payload) {
+		try {
+			const now = this.nowSeconds();
+			const exp = Number(payload?.exp || 0);
+			if (!exp || now >= exp) return false;
+			const windowSec = Number(this.cfg?.jwt?.refreshWindowSec || 900);
+			return exp - now <= windowSec;
+		} catch {
+			return false;
+		}
+	}
+};
+function parseCsvList(input) {
+	const out = /* @__PURE__ */ new Set();
+	for (const raw of String(input || "").split(",")) {
+		const s = raw.trim();
+		if (!s) continue;
+		try {
+			const u = new URL(s);
+			out.add(normalizeParsedCorsOrigin(u));
+		} catch {
+			const stripped = s.replace(/\/$/, "");
+			if (stripped) out.add(stripped);
+		}
+	}
+	return Array.from(out);
+}
+/**
+* Normalize a single origin for CORS comparisons.
+* Returns null when the input is empty or not URL-like.
+*/
+function normalizeCorsOrigin(input) {
+	const raw = String(input || "").trim();
+	if (!raw) return null;
+	try {
+		return normalizeParsedCorsOrigin(new URL(raw));
+	} catch {
+		return null;
+	}
+}
+function buildCorsOrigins(...inputs) {
+	const merged = /* @__PURE__ */ new Set();
+	for (const input of inputs) for (const origin of parseCsvList(input)) merged.add(origin);
+	const list = Array.from(merged);
+	return list.length > 0 ? list : "*";
+}
+//#endregion
+export { SessionService, buildCorsOrigins, normalizeCorsOrigin, parseCsvList };
+
+//# sourceMappingURL=SessionService.js.map

package/dist/esm/core/ThresholdService/config.js

@@ -0,0 +1,111 @@
+import { base64UrlDecode } from "../../shared-ts/src/utils/base64.js";
+import "../../shared-ts/src/utils/encoders.js";
+import { normalizeOptionalTrimmedString } from "../../shared-ts/src/utils/normalize.js";
+import "../../shared-ts/src/utils/validation.js";
+import { THRESHOLD_ED25519_2P_PARTICIPANT_IDS, normalizeThresholdEd25519ParticipantId, normalizeThresholdEd25519ParticipantIds } from "../../shared-ts/src/threshold/participants.js";
+//#region src/core/ThresholdService/config.ts
+function coerceThresholdNodeRole(input) {
+	const role = normalizeOptionalTrimmedString(input);
+	if (role === "cosigner") return "cosigner";
+	if (role === "coordinator") return "coordinator";
+	return "coordinator";
+}
+function parseThresholdRelayerCosigners(input) {
+	const asJson = (raw) => {
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	const raw = typeof input === "string" ? asJson(input) : input;
+	if (!Array.isArray(raw) || raw.length === 0) return null;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of raw) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+		const rec = item;
+		const cosignerId = normalizeThresholdEd25519ParticipantId(rec.cosignerId);
+		const relayerUrl = normalizeOptionalTrimmedString(rec.relayerUrl)?.replace(/\/+$/, "");
+		if (!cosignerId || !relayerUrl) return null;
+		const key = `${cosignerId}:${relayerUrl}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			cosignerId,
+			relayerUrl
+		});
+	}
+	out.sort((a, b) => a.cosignerId - b.cosignerId || a.relayerUrl.localeCompare(b.relayerUrl));
+	return out.length ? out : null;
+}
+function parseThresholdCoordinatorPeers(input) {
+	const asJson = (raw) => {
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	const raw = typeof input === "string" ? asJson(input) : input;
+	if (!Array.isArray(raw) || raw.length === 0) return null;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of raw) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+		const rec = item;
+		const instanceId = normalizeOptionalTrimmedString(rec.instanceId);
+		const relayerUrl = normalizeOptionalTrimmedString(rec.relayerUrl)?.replace(/\/+$/, "");
+		if (!instanceId || !relayerUrl) return null;
+		const key = `${instanceId}:${relayerUrl}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			instanceId,
+			relayerUrl
+		});
+	}
+	out.sort((a, b) => a.instanceId.localeCompare(b.instanceId) || a.relayerUrl.localeCompare(b.relayerUrl));
+	return out.length ? out : null;
+}
+function parseThresholdRelayerCosignerThreshold(input) {
+	const raw = normalizeOptionalTrimmedString(input);
+	if (!raw) return null;
+	const n = Number(raw);
+	if (!Number.isFinite(n)) return null;
+	const t = Math.floor(n);
+	if (t < 1) return null;
+	return t;
+}
+function parseThresholdCoordinatorSharedSecretBytes(input) {
+	const coordinatorSharedSecretB64u = normalizeOptionalTrimmedString(input);
+	if (!coordinatorSharedSecretB64u) return null;
+	let decoded;
+	try {
+		decoded = base64UrlDecode(coordinatorSharedSecretB64u);
+	} catch {
+		throw new Error("THRESHOLD_COORDINATOR_SHARED_SECRET_B64U must be valid base64url");
+	}
+	if (decoded.length !== 32) throw new Error(`THRESHOLD_COORDINATOR_SHARED_SECRET_B64U must decode to 32 bytes, got ${decoded.length}`);
+	return decoded;
+}
+function parseThresholdEd25519ParticipantIds2p(input) {
+	const clientIdRaw = input.THRESHOLD_ED25519_CLIENT_PARTICIPANT_ID;
+	const relayerIdRaw = input.THRESHOLD_ED25519_RELAYER_PARTICIPANT_ID;
+	const clientId = clientIdRaw === void 0 ? null : normalizeThresholdEd25519ParticipantId(clientIdRaw);
+	if (clientIdRaw !== void 0 && !clientId) throw new Error("THRESHOLD_ED25519_CLIENT_PARTICIPANT_ID must be an integer in [1,65535]");
+	const relayerId = relayerIdRaw === void 0 ? null : normalizeThresholdEd25519ParticipantId(relayerIdRaw);
+	if (relayerIdRaw !== void 0 && !relayerId) throw new Error("THRESHOLD_ED25519_RELAYER_PARTICIPANT_ID must be an integer in [1,65535]");
+	const clientParticipantId = clientId ?? 1;
+	const relayerParticipantId = relayerId ?? 2;
+	if (clientParticipantId === relayerParticipantId) throw new Error("THRESHOLD_ED25519_CLIENT_PARTICIPANT_ID must differ from THRESHOLD_ED25519_RELAYER_PARTICIPANT_ID");
+	return {
+		clientParticipantId,
+		relayerParticipantId,
+		participantIds2p: normalizeThresholdEd25519ParticipantIds([clientParticipantId, relayerParticipantId]) || [...THRESHOLD_ED25519_2P_PARTICIPANT_IDS]
+	};
+}
+//#endregion
+export { coerceThresholdNodeRole, parseThresholdCoordinatorPeers, parseThresholdCoordinatorSharedSecretBytes, parseThresholdEd25519ParticipantIds2p, parseThresholdRelayerCosignerThreshold, parseThresholdRelayerCosigners };
+
+//# sourceMappingURL=config.js.map

package/dist/esm/core/ThresholdService/ecdsaClientRootProof.js

@@ -0,0 +1,27 @@
+import { base64UrlDecode, base64UrlEncode } from "../../shared-ts/src/utils/base64.js";
+import "../../shared-ts/src/utils/encoders.js";
+import { verifySecp256k1RecoverableSignatureAgainstPublicKey33 } from "./evmCryptoWasm.js";
+//#region src/core/ThresholdService/ecdsaClientRootProof.ts
+async function verifyEcdsaClientRootProof(proof) {
+	try {
+		if (base64UrlEncode(await verifySecp256k1RecoverableSignatureAgainstPublicKey33(base64UrlDecode(proof.digest32B64u), base64UrlDecode(proof.signature65B64u), base64UrlDecode(proof.clientRootPublicKey33B64u))) !== proof.clientRootPublicKey33B64u) return {
+			ok: false,
+			code: "unauthorized",
+			message: "Invalid client root proof"
+		};
+		return {
+			ok: true,
+			clientRootPublicKey33B64u: proof.clientRootPublicKey33B64u
+		};
+	} catch {
+		return {
+			ok: false,
+			code: "unauthorized",
+			message: "Invalid client root proof"
+		};
+	}
+}
+//#endregion
+export { verifyEcdsaClientRootProof };
+
+//# sourceMappingURL=ecdsaClientRootProof.js.map

package/dist/esm/core/ThresholdService/evmCryptoWasm.js

@@ -0,0 +1,167 @@
+import { __wbg_init, add_secp256k1_public_keys_33, compute_eip1559_tx_hash, encode_eip1559_signed_tx_from_signature65, init_evm_crypto, secp256k1_private_key_32_to_public_key_33, secp256k1_public_key_33_to_ethereum_address_20, sha256_bytes, sign_secp256k1_recoverable, validate_secp256k1_public_key_33, verify_secp256k1_bip340_signature_against_public_key_33, verify_secp256k1_recoverable_signature_against_public_key_33 } from "../../wasm/evm_crypto/pkg/evm_crypto.js";
+//#region src/core/ThresholdService/evmCryptoWasm.ts
+const importedEvmCryptoInitializer = __wbg_init;
+const initEvmCryptoWasm = typeof importedEvmCryptoInitializer === "function" ? importedEvmCryptoInitializer : void 0;
+const EVM_CRYPTO_WASM_PATH_CANDIDATES = [
+	"../../wasm/evm_crypto/pkg/evm_crypto_bg.wasm",
+	"../../wasm/evm_crypto/pkg/evm_crypto_bg.wasm",
+	"../../wasm/evm_crypto/pkg/evm_crypto_bg.wasm"
+];
+let evmCryptoWasmInitPromise = null;
+let evmCryptoWasmReady = false;
+function isNodeEnvironment() {
+	const processObj = globalThis.process;
+	const isNode = Boolean(processObj?.versions?.node);
+	const webSocketPair = globalThis.WebSocketPair;
+	const nav = globalThis.navigator;
+	const isCloudflareWorker = typeof webSocketPair !== "undefined" || typeof nav?.userAgent === "string" && nav.userAgent.includes("Cloudflare-Workers");
+	return isNode && !isCloudflareWorker;
+}
+function getEvmCryptoWasmUrls() {
+	const baseUrl = import.meta.url;
+	const resolved = [];
+	for (const path of EVM_CRYPTO_WASM_PATH_CANDIDATES) try {
+		if (!baseUrl) throw new Error("import.meta.url is undefined");
+		resolved.push(new URL(path, baseUrl));
+	} catch {}
+	return resolved;
+}
+async function loadBundledEvmCryptoWasmModule() {
+	try {
+		const imported = await import("../../wasm/evm_crypto/pkg/evm_crypto_bg.wasm");
+		return imported.default instanceof WebAssembly.Module ? imported.default : null;
+	} catch {
+		return null;
+	}
+}
+async function initEvmCryptoFromCompiledModule(module) {
+	if (initEvmCryptoWasm) await initEvmCryptoWasm({ module_or_path: module });
+	init_evm_crypto();
+	evmCryptoWasmReady = true;
+}
+async function ensureEvmCryptoWasm() {
+	if (evmCryptoWasmInitPromise) return evmCryptoWasmInitPromise;
+	evmCryptoWasmInitPromise = (async () => {
+		const urls = getEvmCryptoWasmUrls();
+		if (isNodeEnvironment()) {
+			const { fileURLToPath } = await import("node:url");
+			const { readFile } = await import("node:fs/promises");
+			for (const url of urls) try {
+				const bytes = await readFile(fileURLToPath(url));
+				const ab = new ArrayBuffer(bytes.byteLength);
+				new Uint8Array(ab).set(bytes);
+				await initEvmCryptoFromCompiledModule(await WebAssembly.compile(ab));
+				return;
+			} catch {}
+			throw new Error(`[threshold-ecdsa] Failed to initialize evm_crypto WASM from filesystem candidates: ${urls.map((u) => u.toString()).join(", ")}`);
+		}
+		let lastErr = null;
+		const bundledModule = await loadBundledEvmCryptoWasmModule();
+		if (bundledModule) try {
+			await initEvmCryptoFromCompiledModule(bundledModule);
+			return;
+		} catch (e) {
+			lastErr = e;
+		}
+		for (const url of urls) try {
+			if (!initEvmCryptoWasm) {
+				init_evm_crypto();
+				evmCryptoWasmReady = true;
+				return;
+			}
+			await initEvmCryptoWasm({ module_or_path: url });
+			init_evm_crypto();
+			evmCryptoWasmReady = true;
+			return;
+		} catch (e) {
+			lastErr = e;
+		}
+		throw lastErr instanceof Error ? lastErr : new Error(String(lastErr || "Failed to initialize evm_crypto WASM"));
+	})();
+	return evmCryptoWasmInitPromise;
+}
+function requireEvmCryptoReady() {
+	if (!evmCryptoWasmReady) throw new Error("[threshold-ecdsa] evm_crypto WASM is not initialized");
+}
+function checkedBytes(label, value, expectedLength) {
+	if (value.length !== expectedLength) throw new Error(`${label} must be ${expectedLength} bytes (got ${value.length})`);
+	return value;
+}
+function toDec(value) {
+	if (value < 0n) throw new Error("[threshold-ecdsa] negative bigint not supported");
+	return value.toString(10);
+}
+function toChainIdNumber(value) {
+	if (typeof value === "bigint") {
+		if (value < 0n) throw new Error("[threshold-ecdsa] chainId must be non-negative");
+		const numeric = Number(value);
+		if (!Number.isSafeInteger(numeric)) throw new Error("[threshold-ecdsa] chainId must be a safe integer");
+		return numeric;
+	}
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error("[threshold-ecdsa] chainId must be a safe integer");
+	return value;
+}
+function toWasmEip1559Tx(tx) {
+	return {
+		chainId: toChainIdNumber(tx.chainId),
+		nonce: toDec(tx.nonce),
+		maxPriorityFeePerGas: toDec(tx.maxPriorityFeePerGas),
+		maxFeePerGas: toDec(tx.maxFeePerGas),
+		gasLimit: toDec(tx.gasLimit),
+		to: tx.to ?? null,
+		value: toDec(tx.value),
+		data: tx.data ?? "0x",
+		accessList: (tx.accessList ?? []).map((entry) => ({
+			address: entry.address,
+			storageKeys: [...entry.storageKeys]
+		}))
+	};
+}
+function sha256BytesSync(input) {
+	requireEvmCryptoReady();
+	return checkedBytes("sha256_bytes output", sha256_bytes(input), 32);
+}
+async function computeEip1559TxHash(tx) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("compute_eip1559_tx_hash output", compute_eip1559_tx_hash(toWasmEip1559Tx(tx)), 32);
+}
+async function signSecp256k1Recoverable(digest32, privateKey32) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("sign_secp256k1_recoverable output", sign_secp256k1_recoverable(digest32, privateKey32), 65);
+}
+async function verifySecp256k1RecoverableSignatureAgainstPublicKey33(digest32, signature65, publicKey33) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("verify_secp256k1_recoverable_signature_against_public_key_33 output", verify_secp256k1_recoverable_signature_against_public_key_33(digest32, signature65, publicKey33), 33);
+}
+async function verifySecp256k1Bip340SignatureAgainstPublicKey33(digest32, signature64, publicKey33) {
+	const checkedDigest = checkedBytes("BIP340 digest", digest32, 32);
+	const checkedSignature = checkedBytes("BIP340 signature", signature64, 64);
+	const checkedPublicKey = checkedBytes("BIP340 public key", publicKey33, 33);
+	await ensureEvmCryptoWasm();
+	checkedBytes("verify_secp256k1_bip340_signature_against_public_key_33 output", verify_secp256k1_bip340_signature_against_public_key_33(checkedDigest, checkedSignature, checkedPublicKey), 0);
+}
+async function encodeEip1559SignedTxFromSignature65(input) {
+	await ensureEvmCryptoWasm();
+	return encode_eip1559_signed_tx_from_signature65(toWasmEip1559Tx(input.tx), input.signature65).slice();
+}
+async function validateSecp256k1PublicKey33(input) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("validate_secp256k1_public_key_33 output", validate_secp256k1_public_key_33(input), 33);
+}
+async function addSecp256k1PublicKeys33(input) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("add_secp256k1_public_keys_33 output", add_secp256k1_public_keys_33(input.left33, input.right33), 33);
+}
+async function secp256k1PrivateKey32ToPublicKey33(privateKey32) {
+	await ensureEvmCryptoWasm();
+	return checkedBytes("secp256k1_private_key_32_to_public_key_33 output", secp256k1_private_key_32_to_public_key_33(privateKey32), 33);
+}
+async function secp256k1PublicKey33ToEthereumAddress(publicKey33) {
+	await ensureEvmCryptoWasm();
+	const address20 = checkedBytes("secp256k1_public_key_33_to_ethereum_address_20 output", secp256k1_public_key_33_to_ethereum_address_20(publicKey33), 20);
+	return `0x${Array.from(address20).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+//#endregion
+export { addSecp256k1PublicKeys33, computeEip1559TxHash, encodeEip1559SignedTxFromSignature65, ensureEvmCryptoWasm, secp256k1PrivateKey32ToPublicKey33, secp256k1PublicKey33ToEthereumAddress, sha256BytesSync, signSecp256k1Recoverable, validateSecp256k1PublicKey33, verifySecp256k1Bip340SignatureAgainstPublicKey33, verifySecp256k1RecoverableSignatureAgainstPublicKey33 };
+
+//# sourceMappingURL=evmCryptoWasm.js.map

package/dist/esm/core/ThresholdService/index.js

@@ -0,0 +1,4 @@
+import { createEcdsaWalletSessionStore, createEd25519WalletSessionStore } from "./stores/WalletSessionStore.js";
+import { createThresholdEd25519KeyStore } from "./stores/KeyStore.js";
+import { createThresholdEd25519SessionStore } from "./stores/SessionStore.js";
+export { createEcdsaWalletSessionStore, createEd25519WalletSessionStore, createThresholdEd25519KeyStore, createThresholdEd25519SessionStore };