@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/rpcClients/evm/nonceBackend.js

@@ -1,6 +1,4 @@
-import { chainFamilyFromNetwork } from "../../config/chains.js";
 import { thresholdEcdsaChainTargetFromChainFamily, thresholdEcdsaChainTargetFromRequest, toWalletId } from "../../signingEngine/interfaces/ecdsaChainTarget.js";
-import { createEvmClient } from "./EvmClient.js";
 //#region src/core/rpcClients/evm/nonceBackend.ts
 function toManagedNonceReservationSnapshot(input) {
 	const subjectId = toWalletId(input.subjectId);
@@ -59,169 +57,6 @@ function reserveNonceInputFromBoundary(input) {
 	if (input.nonceKey != null) reservationInput.nonceKey = normalizeBigint(input.nonceKey, "nonceKey");
 	return reservationInput;
 }
-const DEFAULT_RPC_TIMEOUT_MS = 15e3;
-function createEvmNonceBackendWithFetcher(args) {
-	return {
-		async fetchChainNonce(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchChainNonce(normalized);
-		},
-		async fetchBroadcastTransactionStatus(input) {
-			const normalized = normalizeInput(input);
-			return await args.fetchBroadcastTransactionStatus({
-				...normalized,
-				txHash: normalizeTxHash(input.txHash)
-			});
-		}
-	};
-}
-function createEvmNonceBackend(args) {
-	const fetchImpl = args.fetchImpl || fetch.bind(globalThis);
-	return createEvmNonceBackendWithFetcher({
-		fetchChainNonce: async (input) => await fetchChainNonceFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		}),
-		fetchBroadcastTransactionStatus: async (input) => await fetchBroadcastTransactionStatusFromRpc({
-			chains: args.chains,
-			input,
-			fetchImpl
-		})
-	});
-}
-async function fetchBroadcastTransactionStatusFromRpc(args) {
-	const rpcUrl = resolveRpcUrlForInput(args.chains, args.input);
-	const receipt = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionReceipt",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	if (receipt && typeof receipt === "object") return { kind: "finalized" };
-	const transaction = await fetchEvmRpcResult({
-		rpcUrl,
-		method: "eth_getTransactionByHash",
-		params: [args.input.txHash],
-		fetchImpl: args.fetchImpl
-	});
-	return transaction && typeof transaction === "object" ? { kind: "pending" } : { kind: "missing" };
-}
-async function fetchEvmRpcResult(args) {
-	return await createEvmClient({
-		rpcUrl: args.rpcUrl,
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: args.method,
-		params: args.params
-	});
-}
-async function fetchChainNonceFromRpc(args) {
-	return parseRpcHexQuantity(await createEvmClient({
-		rpcUrl: resolveRpcUrlForInput(args.chains, args.input),
-		fetchImpl: args.fetchImpl,
-		requestTimeoutMs: DEFAULT_RPC_TIMEOUT_MS
-	}).request({
-		method: "eth_getTransactionCount",
-		params: [args.input.sender, "pending"]
-	}), "eth_getTransactionCount");
-}
-function resolveRpcUrlForInput(chains, input) {
-	const requestedChain = input.chain;
-	const targetChainId = input.chainId;
-	const networkKey = String(input.networkKey || "").trim().toLowerCase();
-	const byChainId = (source) => source.filter((chain) => {
-		const chainId = getOptionalConfigChainId(chain);
-		return typeof chainId === "number" && chainId === targetChainId;
-	});
-	const byNetworkKey = (source) => source.filter((chain) => String(chain.network || "").trim().toLowerCase() === networkKey);
-	const supportedChains = chains.filter((chain) => isSupportedNonceRoutingChain(chain));
-	if (!supportedChains.length) throw new Error("[evmNonceBackend] missing RPC config for nonce-enabled chains");
-	const networkMatches = byNetworkKey(supportedChains);
-	if (networkMatches.length === 1) {
-		const only = networkMatches[0];
-		assertChainSupportsRequestedRoute({
-			chain: only,
-			requestedChain,
-			networkKey: input.networkKey,
-			chainId: targetChainId
-		});
-		assertConfiguredChainIdMatchesInput({
-			chain: only,
-			chainId: targetChainId,
-			networkKey: input.networkKey
-		});
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (networkMatches.length > 1) {
-		const chainIdMatched = byChainId(networkMatches).filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-		if (chainIdMatched.length === 1) {
-			const only = chainIdMatched[0];
-			return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-		}
-		throw new Error(`[evmNonceBackend] ambiguous networkKey mapping for ${input.networkKey} (chainId=${String(targetChainId)})`);
-	}
-	const chainIdMatches = byChainId(supportedChains);
-	const compatibleMatches = chainIdMatches.filter((chain) => isChainCompatibleWithRequestChain(chain, requestedChain));
-	if (compatibleMatches.length === 1) {
-		const only = compatibleMatches[0];
-		return mustTrimmedRpcUrl(only.rpcUrl, only.network);
-	}
-	if (compatibleMatches.length > 1) {
-		const candidates = compatibleMatches.map((chain) => String(chain.network || "").trim()).join(", ");
-		throw new Error(`[evmNonceBackend] ambiguous chainId routing for ${requestedChain} chainId=${String(targetChainId)} across [${candidates}]`);
-	}
-	if (chainIdMatches.length > 0) {
-		const families = Array.from(new Set(chainIdMatches.map((chain) => chainFamilyFromNetwork(chain.network))));
-		throw new Error(`[evmNonceBackend] chainId=${String(targetChainId)} is configured for [${families.join(", ")}] but is incompatible with ${requestedChain} routing`);
-	}
-	throw new Error(`[evmNonceBackend] unable to resolve RPC URL for ${requestedChain} ${input.networkKey} (chainId=${String(targetChainId)})`);
-}
-function isSupportedNonceRoutingChain(chain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	return family === "evm" || family === "tempo";
-}
-function isChainCompatibleWithRequestChain(chain, requestedChain) {
-	const family = chainFamilyFromNetwork(chain.network);
-	if (requestedChain === "tempo") return family === "tempo";
-	return family === "evm" || family === "tempo";
-}
-function assertConfiguredChainIdMatchesInput(args) {
-	const configuredChainId = getOptionalConfigChainId(args.chain);
-	if (typeof configuredChainId !== "number") throw new Error(`[evmNonceBackend] configured network ${args.chain.network} is missing numeric chainId`);
-	if (configuredChainId !== args.chainId) throw new Error(`[evmNonceBackend] chainId mismatch for network ${args.networkKey}: expected ${configuredChainId}, received ${String(args.chainId)}`);
-}
-function assertChainSupportsRequestedRoute(args) {
-	if (isChainCompatibleWithRequestChain(args.chain, args.requestedChain)) return;
-	const resolvedFamily = chainFamilyFromNetwork(args.chain.network);
-	throw new Error(`[evmNonceBackend] network ${args.networkKey} (family=${resolvedFamily}) is incompatible with ${args.requestedChain} request (chainId=${String(args.chainId)})`);
-}
-function getOptionalConfigChainId(chain) {
-	return isChainWithChainId(chain) ? chain.chainId : void 0;
-}
-function isChainWithChainId(chain) {
-	return chainFamilyFromNetwork(chain.network) !== "near";
-}
-function mustTrimmedRpcUrl(rpcUrl, network) {
-	const trimmed = String(rpcUrl || "").trim();
-	if (!trimmed) throw new Error(`[evmNonceBackend] missing rpcUrl for ${network}`);
-	return trimmed;
-}
-function normalizeInput(input) {
-	const chain = input.chainTarget.kind;
-	if (chain !== "evm" && chain !== "tempo") throw new Error(`[evmNonceBackend] invalid chain '${String(chain)}'`);
-	const networkKey = String(input.chainTarget.networkSlug || "").trim().toLowerCase();
-	if (!networkKey) throw new Error("[evmNonceBackend] networkKey is required");
-	return {
-		chain,
-		networkKey,
-		chainId: input.chainTarget.chainId,
-		sender: normalizeAddress(input.sender, "sender"),
-		nonceKey: chain === "tempo" ? normalizeBigint(input.nonceKey, "nonceKey") : 0n,
-		walletId: String(toWalletId(input.subjectId))
-	};
-}
 function parseManagedNonceSnapshotChainTarget(snapshot) {
 	if (snapshot.chainTarget) return thresholdEcdsaChainTargetFromRequest(snapshot.chainTarget);
 	const chain = snapshot.chain;
@@ -244,11 +79,6 @@ function normalizeAddress(value, label) {
 function normalizeSender(value) {
 	return normalizeAddress(value, "sender");
 }
-function normalizeTxHash(value) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!/^0x[0-9a-f]{64}$/.test(normalized)) throw new Error("[evmNonceBackend] invalid txHash: expected 32-byte 0x-prefixed hex");
-	return normalized;
-}
 function normalizeBigint(value, label) {
 	try {
 		const parsed = BigInt(value);
@@ -268,12 +98,7 @@ function normalizeOptionalSafeInteger(value) {
 	const parsed = Math.floor(Number(value));
 	return Number.isSafeInteger(parsed) ? parsed : void 0;
 }
-function parseRpcHexQuantity(value, method) {
-	const raw = String(value || "").trim();
-	if (!/^0x[0-9a-fA-F]+$/.test(raw)) throw new Error(`[evmNonceBackend] invalid ${method} result: expected hex quantity`);
-	return BigInt(raw);
-}
 //#endregion
-export { createEvmNonceBackend, fromManagedNonceReservationSnapshot, reserveNonceInputFromBoundary, toManagedNonceReservationSnapshot };
+export { fromManagedNonceReservationSnapshot, reserveNonceInputFromBoundary, toManagedNonceReservationSnapshot };
 
 //# sourceMappingURL=nonceBackend.js.map

package/dist/esm/core/rpcClients/near/accountExists.js

@@ -0,0 +1,34 @@
+import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
+import { toAccountId } from "../../types/accountIds.js";
+//#region src/core/rpcClients/near/accountExists.ts
+function isMissingAccount(error) {
+	return /UNKNOWN_ACCOUNT|unknown\s+account|account\b[^\n]*\bdoes not exist/iu.test(errorMessage(error));
+}
+function isTransientLookupFailure(error) {
+	return /server error|internal|temporar|timeout|throttl|too many requests|429|empty response|rpc request failed|failed to fetch/iu.test(errorMessage(error));
+}
+function resolveRetryDelay(resolve) {
+	setTimeout(resolve, 150);
+}
+async function accountExists(nearClient, input) {
+	const accountId = toAccountId(input);
+	try {
+		await nearClient.viewAccount(accountId);
+		return true;
+	} catch (error) {
+		if (isMissingAccount(error)) return false;
+		if (!isTransientLookupFailure(error)) throw error;
+	}
+	await new Promise(resolveRetryDelay);
+	try {
+		await nearClient.viewAccount(accountId);
+		return true;
+	} catch (error) {
+		if (isMissingAccount(error)) return false;
+		throw error;
+	}
+}
+//#endregion
+export { accountExists };
+
+//# sourceMappingURL=accountExists.js.map

package/dist/esm/core/rpcClients/relayer/ecdsaPrepareSession.js

@@ -0,0 +1,42 @@
+import { requireRecord } from "../../../shared-ts/src/utils/validation.js";
+import { parseMpcWalletSigningQuotaId, parseWalletSessionId } from "../../../shared-ts/src/authorization/capabilityKinds.js";
+import { parseRouterAbEcdsaDerivationEvmDigestSigningPrepareResponseForRequestV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { parseExactWalletSessionStatusResponse } from "./walletSessionAuthorizationStatus.js";
+//#region src/core/rpcClients/relayer/ecdsaPrepareSession.ts
+async function parseEcdsaPrepareSessionResponse(request, value) {
+	const response = requireRecord(value, "ECDSA prepare response");
+	if (response.kind !== request.authorization.kind) throw new Error("ECDSA prepare authorization kind does not match the request");
+	const signing = await parseRouterAbEcdsaDerivationEvmDigestSigningPrepareResponseForRequestV1(request, response.signing);
+	if (request.authorization.kind === "operation_step_up") {
+		if (Object.keys(response).some(isUnexpectedStepUpField)) throw new Error("Invalid step-up prepare response");
+		return {
+			kind: "operation_step_up",
+			signing
+		};
+	}
+	if (Object.keys(response).some(isUnexpectedSessionField)) throw new Error("Invalid Wallet Session prepare response");
+	const snapshot = requireRecord(response.session_status, "ECDSA prepare session status");
+	const quotaId = parseMpcWalletSigningQuotaId(snapshot.quotaId);
+	const walletSessionId = parseWalletSessionId(request.authorization.wallet_session_id);
+	if (!quotaId.ok || !walletSessionId.ok) throw new Error("Invalid prepare session identity");
+	const status = parseExactWalletSessionStatusResponse(snapshot, {
+		walletSessionId: walletSessionId.value,
+		quotaId: quotaId.value
+	});
+	if (!status || status.status !== "active" || status.authorization.walletId !== request.scope.wallet_id) throw new Error("ECDSA prepare did not return the admitted Wallet Session");
+	return {
+		kind: "reusable_wallet_session",
+		signing,
+		sessionStatus: status
+	};
+}
+function isUnexpectedStepUpField(key) {
+	return key !== "kind" && key !== "signing";
+}
+function isUnexpectedSessionField(key) {
+	return isUnexpectedStepUpField(key) && key !== "session_status";
+}
+//#endregion
+export { parseEcdsaPrepareSessionResponse };
+
+//# sourceMappingURL=ecdsaPrepareSession.js.map

package/dist/esm/core/rpcClients/relayer/relayerHttp.js

@@ -1,4 +1,5 @@
 import { stripTrailingSlashes } from "../../../shared-ts/src/utils/normalize.js";
+import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
 //#region src/core/rpcClients/relayer/relayerHttp.ts
 function normalizeRelayerBaseUrl(value, options = { trim: true }) {
 	const raw = String(value ?? "");
@@ -20,7 +21,36 @@ function buildRelayerJsonPostRequestInit(args) {
 		body: args.bodyJson ?? JSON.stringify(args.body)
 	};
 }
+function buildWalletSessionAuthorizationHeaders(credential) {
+	return {
+		...buildBearerAuthorizationHeader({
+			token: credential.token,
+			missingMessage: "Wallet Session token is required"
+		}),
+		...buildWalletHomeRoutingHeaders(credential.home)
+	};
+}
+function buildWalletHomeRoutingHeaders(home) {
+	switch (home.kind) {
+		case "direct": return {};
+		case "regional": return { "X-Seams-Wallet-Region": home.region };
+	}
+}
+async function fetchWithWalletHomeDiscovery(request) {
+	const response = await fetch(request.clone());
+	if (response.status !== 409 || !request.headers.has("X-Seams-Wallet-Region")) return response;
+	let body;
+	try {
+		body = await response.clone().json();
+	} catch {
+		return response;
+	}
+	if (!isPlainObject(body) || body.code !== "wallet_home_discovery_required") return response;
+	const headers = new Headers(request.headers);
+	headers.delete("X-Seams-Wallet-Region");
+	return fetch(new Request(request, { headers }));
+}
 //#endregion
-export { buildBearerAuthorizationHeader, buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl };
+export { buildBearerAuthorizationHeader, buildRelayerJsonPostRequestInit, buildWalletSessionAuthorizationHeaders, fetchWithWalletHomeDiscovery, normalizeRelayerBaseUrl };
 
 //# sourceMappingURL=relayerHttp.js.map

package/dist/esm/core/rpcClients/relayer/routerAbNormalSigning.js

@@ -1,11 +1,14 @@
-import { coerceNonEmptyString } from "../../../shared-ts/src/utils/validation.js";
+import { coerceNonEmptyString, requireRecord } from "../../../shared-ts/src/utils/validation.js";
+import { parseMpcWalletSigningQuotaId, parseWalletSessionId } from "../../../shared-ts/src/authorization/capabilityKinds.js";
 import { base64Decode, base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
 import { alphabetizeStringify } from "../../../shared-ts/src/utils/digests.js";
-import { buildBearerAuthorizationHeader, buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl } from "./relayerHttp.js";
+import { buildRelayerJsonPostRequestInit, buildWalletSessionAuthorizationHeaders, fetchWithWalletHomeDiscovery, normalizeRelayerBaseUrl } from "./relayerHttp.js";
 import { parseRouterAbMpcMaterialActivationRef, parseRouterAbNormalSigningAuthorization } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseRouterAbEcdsaDerivationEvmDigestSigningPrepareResponseForRequestV1, parseRouterAbEcdsaDerivationEvmDigestSigningResponseForCoreRequestV1, parseRouterAbEcdsaOperationStepUpPreparationV1, routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestDigestV1, routerAbEcdsaDerivationEvmDigestSigningRequestDigestV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { parseRouterAbEcdsaDerivationEvmDigestSigningResponseForCoreRequestV1, parseRouterAbEcdsaOperationStepUpPreparationV1, routerAbEcdsaDerivationEvmDigestSigningFinalizeCoreRequestDigestV1, routerAbEcdsaDerivationEvmDigestSigningRequestDigestV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
 import { WalletSessionQuotaAdmissionError } from "../../signingEngine/session/operationState/authorizationAdmission.js";
+import { WalletSessionStatusReadScope, parseExactWalletSessionStatusResponse } from "./walletSessionAuthorizationStatus.js";
 import { walletSessionFailureErrorFromPayload } from "../../signingEngine/session/lifecycle/walletSessionFailure.js";
+import { parseEcdsaPrepareSessionResponse } from "./ecdsaPrepareSession.js";
 //#region src/core/rpcClients/relayer/routerAbNormalSigning.ts
 const INTENT_VERSION_V2 = "router-ab-protocol/ed25519-normal-signing/intent/v2";
 const PAYLOAD_VERSION_V2 = "router-ab-protocol/ed25519-normal-signing/payload/v2";
@@ -93,8 +96,8 @@ function routerAbEd25519Nep413CanonicalMessageB64uV2(args) {
 	const out = [];
 	pushU32Le(out, NEP413_PREFIX);
 	pushBorshString(out, message);
-	pushBorshString(out, recipient);
 	pushBytes(out, nonce);
+	pushBorshString(out, recipient);
 	if (callbackUrl) {
 		out.push(1);
 		pushBorshString(out, callbackUrl);
@@ -457,10 +460,10 @@ function parseNormalSigningResponse(value) {
 function buildRouterAbRequestInit(args) {
 	const bearer = args.credential.kind === "wallet_session_opaque" ? {
 		token: args.credential.walletSessionToken,
-		missingMessage: "walletSessionToken is required"
+		home: args.credential.home
 	} : null;
 	return buildRelayerJsonPostRequestInit({
-		...bearer ? { headers: buildBearerAuthorizationHeader(bearer) } : {},
+		...bearer ? { headers: buildWalletSessionAuthorizationHeaders(bearer) } : {},
 		body: args.body
 	});
 }
@@ -633,33 +636,66 @@ function routerAbSigningHttpError(args) {
 async function postRouterAbNormalSigningJson(args) {
 	if (typeof fetch !== "function") throw new Error("fetch is not available for Router A/B normal-signing request");
 	const base = normalizeRelayerBaseUrl(coerceNonEmptyString(args.relayServerUrl, "relayServerUrl"));
-	const response = await fetch(`${base}${args.path}`, {
+	const response = await fetchWithWalletHomeDiscovery(new Request(`${base}${args.path}`, {
 		...buildRouterAbRequestInit({
 			credential: args.credential,
 			body: args.body
 		}),
 		signal: args.signal
-	});
+	}));
 	try {
 		args.onServerTiming?.(response.headers.get("Server-Timing"));
 	} catch {}
 	if (!response.ok) {
 		const errorText = await response.text().catch(() => "");
-		throw routerAbSigningHttpError({
+		const error = routerAbSigningHttpError({
 			path: args.path,
 			status: response.status,
 			bodyText: errorText
 		});
+		if (args.credential.kind === "wallet_session_opaque" && error instanceof WalletSessionQuotaAdmissionError && error.failure.kind === "exhausted") WalletSessionStatusReadScope.forgetCredential(args.credential.walletSessionToken);
+		throw error;
 	}
 	return args.parse(await response.json());
 }
+function parseEd25519PrepareSessionResponse(request, value) {
+	const response = requireRecord(value, "Ed25519 prepare response");
+	if (response.kind !== request.scope.authorization.kind) throw new Error("Ed25519 prepare authorization kind does not match the request");
+	const signing = parsePrepareResponse(response.signing);
+	if (request.scope.authorization.kind === "operation_step_up") {
+		requireExactRecordFields(response, ["kind", "signing"], "Ed25519 step-up prepare response");
+		return {
+			kind: "operation_step_up",
+			signing
+		};
+	}
+	requireExactRecordFields(response, [
+		"kind",
+		"signing",
+		"session_status"
+	], "Ed25519 session prepare response");
+	const snapshot = requireRecord(response.session_status, "Ed25519 prepare session status");
+	const walletSessionId = parseWalletSessionId(request.scope.authorization.wallet_session_id);
+	const quotaId = parseMpcWalletSigningQuotaId(snapshot.quotaId);
+	if (!walletSessionId.ok || !quotaId.ok) throw new Error("Invalid Ed25519 prepare session identity");
+	const status = parseExactWalletSessionStatusResponse(snapshot, {
+		walletSessionId: walletSessionId.value,
+		quotaId: quotaId.value
+	});
+	if (!status || status.status !== "active") throw new Error("Ed25519 prepare did not return an active Wallet Session");
+	return {
+		kind: "reusable_wallet_session",
+		signing,
+		sessionStatus: status
+	};
+}
 async function prepareRouterAbNormalSigningV2(args) {
 	return postRouterAbNormalSigningJson({
 		relayServerUrl: args.relayServerUrl,
 		path: "/router-ab/ed25519/sign/prepare",
 		credential: args.credential,
 		body: args.request,
-		parse: parsePrepareResponse
+		parse: parseEd25519PrepareSessionResponse.bind(null, args.request)
 	});
 }
 async function prepareRouterAbEcdsaDerivationEvmDigestSigningV1(args) {
@@ -670,7 +706,7 @@ async function prepareRouterAbEcdsaDerivationEvmDigestSigningV1(args) {
 		onServerTiming: args.onServerTiming,
 		credential: args.credential,
 		body: args.request,
-		parse: (value) => parseRouterAbEcdsaDerivationEvmDigestSigningPrepareResponseForRequestV1(args.request, value)
+		parse: parseEcdsaPrepareSessionResponse.bind(null, args.request)
 	});
 }
 async function finalizeRouterAbNormalSigningV2(args) {

package/dist/esm/core/rpcClients/relayer/walletRecoveryFinalize.js

@@ -3,8 +3,8 @@ import { parseDeviceId } from "../../../shared-ts/src/authorization/capabilityKi
 import { buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl } from "./relayerHttp.js";
 import { parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
 import "../../../shared-ts/src/passkey-custody/index.js";
-import { parseWalletRecoveryEcdsaPossessionProofV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
 import { parseWalletRecoveryCommittedProjectionV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryCommittedProjection.js";
+import { parseWalletRecoveryEcdsaPossessionProofV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
 import { redactedPasskeyRegistrationCredential } from "../../signingEngine/webauthnAuth/credentials/helpers.js";
 //#region src/core/rpcClients/relayer/walletRecoveryFinalize.ts
 /**
@@ -88,52 +88,6 @@ async function finalizeWalletRecovery(args) {
 	if (response.status === 400 || response.status === 401) return { kind: "refused" };
 	return { kind: "transport_uncertain" };
 }
-/**
-* Replays a promotion whose server transaction already committed. The replay
-* body is credential-free and carries only the exact sealed replacement
-* envelope and immutable operation identity retained by the local journal.
-*/
-async function replayWalletRecovery(args) {
-	let replacementEnvelope;
-	try {
-		replacementEnvelope = parsePasskeyCustodyEnvelopeRecord(args.replacementEnvelope, "walletRecoveryReplay.replacementEnvelope");
-		if (String(replacementEnvelope.walletId) !== String(args.walletId) || String(replacementEnvelope.envelopeId) !== String(args.replacementId) || replacementEnvelope.factor.kind !== "passkey") throw new Error("recovery replay envelope identity is invalid");
-	} catch {
-		return { kind: "refused" };
-	}
-	let response;
-	try {
-		response = await (args.fetchImpl ?? fetch)(`${normalizeRelayerBaseUrl(args.relayUrl)}${WALLET_RECOVERY_FINALIZE_PATH}`, buildRelayerJsonPostRequestInit({ body: {
-			kind: "replay",
-			walletId: args.walletId,
-			reservationId: args.reservationId,
-			recoveryOperationId: args.recoveryOperationId,
-			targetDeviceId: args.targetDeviceId,
-			targetAuthorityId: args.targetAuthorityId,
-			targetWalletAuthMethodId: args.targetWalletAuthMethodId,
-			replacementId: args.replacementId,
-			replacementEnvelope
-		} }));
-	} catch {
-		return { kind: "transport_uncertain" };
-	}
-	const body = decodeWalletRecoveryFinalizeResponse(await response.json().catch(() => ({})));
-	if (response.status === 200 && body.kind === "success") try {
-		const projection = await parseWalletRecoveryCommittedProjectionV1(body.projection, buildPasskeyProjectionExpectation(args, replacementEnvelope));
-		if (projection.kind !== "passkey") throw new Error("recovery projection branch changed");
-		return {
-			kind: "promoted",
-			storeVersion: projection.storeVersion,
-			authority: projection.authority,
-			authMethod: projection.authMethod
-		};
-	} catch {
-		return { kind: "transport_uncertain" };
-	}
-	if (response.status === 409) return { kind: "retryable_conflict" };
-	if (response.status === 400 || response.status === 401) return { kind: "refused" };
-	return { kind: "transport_uncertain" };
-}
 function decodeWalletRecoveryFinalizeResponse(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return { kind: "invalid" };
 	const fields = new Map(Object.entries(value));
@@ -169,6 +123,6 @@ function requireParsed(result) {
 	return result.value;
 }
 //#endregion
-export { finalizeWalletRecovery, replayWalletRecovery };
+export { finalizeWalletRecovery };
 
 //# sourceMappingURL=walletRecoveryFinalize.js.map

package/dist/esm/core/rpcClients/relayer/walletRecoveryPrepare.js

@@ -1,23 +1,23 @@
+import { requireArray } from "../../../shared-ts/src/utils/validation.js";
 import { parseWalletAuthMethodId, parseWalletAuthorityId, parseWalletId, parseWalletRecoveryOperationId, parseWebAuthnCredentialIdB64u, parseWebAuthnRpId } from "../../../shared-ts/src/utils/domainIds.js";
 import { parseDeviceId } from "../../../shared-ts/src/authorization/capabilityKinds.js";
-import { requireArray } from "../../../shared-ts/src/utils/validation.js";
-import { wireLiteral, wireObject, wireResult } from "../../../shared-ts/src/utils/wireSchema.js";
 import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
 import { parseDigestField, parseEnvelopeCiphertextB64u, parseEnvelopeNonceB64u, parseUnixMs } from "../../../shared-ts/src/passkey-custody/primitives.js";
-import { buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl } from "./relayerHttp.js";
-import { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1 } from "../../../shared-ts/src/utils/signingSessionSeal.js";
+import { wireLiteral, wireObject, wireResult } from "../../../shared-ts/src/utils/wireSchema.js";
 import { normalizeRuntimePolicyScope } from "../../../shared-ts/src/threshold/signingRootScope.js";
-import { requireEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
-import "../../../shared-ts/src/signing-lanes/index.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
+import { PASSKEY_PRF_FIRST_SALT_V1, PASSKEY_PRF_SECOND_SALT_V1 } from "../../../shared-ts/src/utils/signingSessionSeal.js";
+import { buildRelayerJsonPostRequestInit, normalizeRelayerBaseUrl } from "./relayerHttp.js";
 import { parseRouterAbMpcMaterialActivationRef } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseRecoveryCodeReservationId } from "../../../shared-ts/src/wallet-recovery/recoveryCodeReservation.js";
+import { requireEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
 import { ecdsaClientRootPublicKey33B64uFromString, parseSdkEcdsaDerivationSigningRootId, parseSdkEcdsaDerivationSigningRootVersion, parseSdkEcdsaDerivationThresholdKeyId } from "../../../shared-ts/src/threshold/ecdsaDerivationRoleLocalBootstrap.js";
 import { parseEcdsaServerGeneration } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
 import { parseRouterAbEcdsaDerivationPublicCapabilityV1, parseRouterAbEcdsaRegistrationActivationReceiptV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { parseWalletRecoveryEcdsaPossessionChallengeV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
+import "../../../shared-ts/src/signing-lanes/index.js";
+import "../../../shared-ts/src/passkey-custody/index.js";
 import { thresholdEcdsaChainTargetKey } from "../../../shared-ts/src/utils/thresholdEcdsaChainTarget.js";
+import { parseRecoveryCodeReservationId } from "../../../shared-ts/src/wallet-recovery/recoveryCodeReservation.js";
 import { parseWalletRecoveryEnvelopeEntry } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEnvelopeSet.js";
+import { parseWalletRecoveryEcdsaPossessionChallengeV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryEcdsaPossession.js";
 import "../../../shared-ts/src/wallet-recovery/index.js";
 import { parseWalletRecoveryTargetV1 } from "../../../shared-ts/src/wallet-recovery/walletRecoveryTarget.js";
 //#region src/core/rpcClients/relayer/walletRecoveryPrepare.ts