@seams/wallet 0.8.0 → 0.9.0

package/dist/esm/SeamsWeb/operations/devices/deviceLinkingHttpTransport.js

@@ -1,524 +0,0 @@
-import { parseLinkDeviceSessionId } from "../../../shared-ts/src/utils/domainIds.js";
-import { base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { sha256DigestB64u } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
-import { parseWalletSessionOperationCredentialV1 } from "../../../shared-ts/src/device-linking/activeWalletSession.js";
-import { secureRandomBase64Url } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { parseLinkedDeviceEd25519ExportRootPackageV1 } from "../../../shared-ts/src/device-linking/ed25519ExportRoot.js";
-import { parseCommittedAuthorityPackagesV1 } from "../../../shared-ts/src/device-linking/committedSignerPackages.js";
-import { parseLinkSessionProjectionV1, parseLinkSessionTransportEventV1, parseLinkedDeviceApprovalDeliveryV1, parseLinkedDeviceEmailOtpChallengeResendRequestV1, parseLinkedDeviceEmailOtpChallengeResultV1, parseLinkedDeviceEmailOtpChallengeStartRequestV1, parseLinkedDeviceEmailOtpChallengeVerifyRequestV1, parseLinkedDeviceEmailOtpVerificationResultV1, parseLinkedDeviceTargetCredentialRegistrationResultV1, parseLinkedDeviceTargetPreparationRequestV1, parseLinkedDeviceTargetPreparationV1 } from "../../../shared-ts/src/device-linking/parsers.js";
-import { parseActivateInstalledAuthorityResultV1, parseLocalAuthorityActivationFinalAckV1, parseLocalAuthorityInstallationReceiptV1 } from "../../../shared-ts/src/device-linking/authorityActivation.js";
-import { LINKED_DEVICE_REQUEST_PROOF_HEADER_V1, LINKED_DEVICE_REQUEST_PROOF_MAX_TTL_MS_V1, computeLinkedDevicePublicKeyDigestV1 } from "../../../shared-ts/src/device-linking/requestProof.js";
-import "../../../shared-ts/src/device-linking/index.js";
-import { hasExactKeys } from "../../../shared-ts/src/utils/exactKeys.js";
-//#region src/SeamsWeb/operations/devices/deviceLinkingHttpTransport.ts
-const LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1 = "/wallet/device-linking/v1/sessions";
-const LINKED_DEVICE_POLL_MAX_DELAY_MS = 4e3;
-const LINKED_DEVICE_COMMITTED_PACKAGES_WAIT_TIMEOUT_MS = 6e4;
-const SESSION_MUTATION_RESPONSE_FIELDS = [
-	"ok",
-	"outcome",
-	"session"
-];
-const TARGET_CREDENTIAL_RESPONSE_FIELDS = [
-	"ok",
-	"outcome",
-	"session",
-	"targetCredential"
-];
-const CODED_FAILURE_RESPONSE_FIELDS = [
-	"ok",
-	"code",
-	"message"
-];
-const OUTCOME_FAILURE_RESPONSE_FIELDS = [
-	"ok",
-	"outcome",
-	"code",
-	"message"
-];
-const SESSION_CONFLICT_FAILURE_FIELDS = [
-	"ok",
-	"outcome",
-	"expectedRevision",
-	"actualRevision",
-	"session"
-];
-const SESSION_EXPIRED_FAILURE_FIELDS = [
-	"ok",
-	"outcome",
-	"session"
-];
-const SESSION_INVALID_STATE_FAILURE_FIELDS = [
-	"ok",
-	"outcome",
-	"state",
-	"session"
-];
-const SESSION_INTEGRITY_FAILURE_FIELDS = [
-	"ok",
-	"outcome",
-	"reason",
-	"session"
-];
-/** Keep long-lived session polling responsive without creating a tight request loop. */
-function nextLinkedDevicePollingDelayMsV1(baseDelayMs, attempt) {
-	const boundedBaseDelayMs = Math.min(baseDelayMs, LINKED_DEVICE_POLL_MAX_DELAY_MS);
-	const boundedAttempt = Math.min(Math.max(attempt, 0), 5);
-	const exponentialDelayMs = Math.min(LINKED_DEVICE_POLL_MAX_DELAY_MS, boundedBaseDelayMs * 2 ** boundedAttempt);
-	const jitterWindowMs = Math.max(1, Math.min(boundedBaseDelayMs, exponentialDelayMs / 4));
-	const jitterMs = Math.floor(Math.random() * jitterWindowMs);
-	return Math.min(LINKED_DEVICE_POLL_MAX_DELAY_MS, exponentialDelayMs + jitterMs);
-}
-async function waitForCommittedAuthorityPackagesV1(input) {
-	const deadlineMs = input.options.nowMs() + LINKED_DEVICE_COMMITTED_PACKAGES_WAIT_TIMEOUT_MS;
-	let attempt = 0;
-	while (input.options.nowMs() < deadlineMs) {
-		const response = await requestDeviceV1({
-			options: input.options,
-			baseUrl: input.baseUrl,
-			method: "GET",
-			canonicalPath: sessionActionPath(input.linkSessionId, "approval"),
-			linkSessionId: input.linkSessionId
-		});
-		if (response.status !== 204) return parseCommittedAuthorityPackagesV1(response.body);
-		const delayMs = nextLinkedDevicePollingDelayMsV1(input.options.pollIntervalMs, attempt);
-		await new Promise((resolve) => setTimeout(resolve, delayMs));
-		attempt += 1;
-	}
-	throw new Error("committed authority packages were not ready before the activation deadline");
-}
-function createDeviceLinkingAuthenticatedSessionTransportV1(options) {
-	const baseUrl = normalizeBaseUrl(options.relayerUrl);
-	if (!Number.isSafeInteger(options.pollIntervalMs) || options.pollIntervalMs <= 0) throw new Error("linked-device session poll interval must be a positive integer");
-	return {
-		...createDeviceLinkingAuthorityActivationTransportV1(options),
-		...createDeviceLinkingWalletSessionAcknowledgementReplayPortV1(options),
-		createUnclaimedSessionV1: async (input) => {
-			await requestMutationV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1,
-				linkSessionId: input.payload.linkSessionId,
-				body: {
-					kind: "linked_device_session_create_request_v1",
-					payload: input.payload
-				}
-			});
-		},
-		getSessionV1: async ({ linkSessionId }) => await requestSessionV1({
-			options,
-			baseUrl,
-			linkSessionId
-		}),
-		getApprovalV1: async ({ linkSessionId }) => {
-			return parseLinkedDeviceApprovalDeliveryV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "GET",
-				canonicalPath: sessionActionPath(linkSessionId, "approval"),
-				linkSessionId
-			})).body).approval;
-		},
-		getTargetPreparationV1: async ({ linkSessionId, deliveryRecipientPublicKey65B64u }) => {
-			const request = parseLinkedDeviceTargetPreparationRequestV1({
-				kind: "linked_device_target_preparation_request_v1",
-				linkSessionId,
-				deliveryRecipientPublicKey65B64u
-			});
-			return parseLinkedDeviceTargetPreparationV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(linkSessionId, "target-preparation"),
-				linkSessionId,
-				body: request
-			})).body);
-		},
-		startTargetEmailOtpChallengeV1: async ({ request }) => {
-			const parsedRequest = parseLinkedDeviceEmailOtpChallengeStartRequestV1(request);
-			return parseLinkedDeviceEmailOtpChallengeResultV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(parsedRequest.linkSessionId, "email-otp/challenge"),
-				linkSessionId: parsedRequest.linkSessionId,
-				body: parsedRequest
-			})).body);
-		},
-		resendTargetEmailOtpChallengeV1: async ({ request }) => {
-			const parsedRequest = parseLinkedDeviceEmailOtpChallengeResendRequestV1(request);
-			return parseLinkedDeviceEmailOtpChallengeResultV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(parsedRequest.linkSessionId, "email-otp/challenge/resend"),
-				linkSessionId: parsedRequest.linkSessionId,
-				body: parsedRequest
-			})).body);
-		},
-		verifyTargetEmailOtpChallengeV1: async ({ request }) => {
-			const parsedRequest = parseLinkedDeviceEmailOtpChallengeVerifyRequestV1(request);
-			return parseLinkedDeviceEmailOtpVerificationResultV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(parsedRequest.linkSessionId, "email-otp/challenge/verify"),
-				linkSessionId: parsedRequest.linkSessionId,
-				body: parsedRequest
-			})).body);
-		},
-		registerTargetCredentialV1: async ({ registration }) => {
-			return parseTargetCredentialRegistrationResponseV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(registration.linkSessionId, "credential"),
-				linkSessionId: registration.linkSessionId,
-				body: registration
-			})).body);
-		},
-		registerEd25519ExportRootRecipientV1: async ({ recipient }) => {
-			const linkSessionId = requireLinkSessionId(recipient.linkSessionId);
-			await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(linkSessionId, "ed25519-export-root-recipient"),
-				linkSessionId,
-				body: recipient
-			});
-		},
-		getEd25519ExportRootPackageV1: async ({ linkSessionId }) => {
-			const response = await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "GET",
-				canonicalPath: sessionActionPath(linkSessionId, "ed25519-export-root"),
-				linkSessionId
-			});
-			if (response.status === 204) return null;
-			return parseLinkedDeviceEd25519ExportRootPackageV1(response.body);
-		},
-		retryCommittedDeliveryV1: async ({ request }) => {
-			await requestMutationV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(request.linkSessionId, "retry"),
-				linkSessionId: request.linkSessionId,
-				body: request
-			});
-		},
-		cancelSessionV1: async ({ request }) => {
-			await requestMutationV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(request.linkSessionId, "cancel"),
-				linkSessionId: request.linkSessionId,
-				body: request
-			});
-		},
-		subscribeSessionV1: async ({ linkSessionId, onEvent }) => await createPollingSubscriptionV1({
-			options,
-			baseUrl,
-			linkSessionId,
-			onEvent
-		})
-	};
-}
-function createDeviceLinkingWalletSessionAcknowledgementReplayPortV1(options) {
-	const baseUrl = normalizeBaseUrl(options.relayerUrl);
-	return { acknowledgeLocalAuthorityActivationWithWalletSessionV1: async ({ acknowledgement, operationCredential }) => {
-		const parsedAcknowledgement = parseLocalAuthorityActivationFinalAckV1(acknowledgement);
-		const parsedCredential = parseWalletSessionOperationCredentialV1(operationCredential);
-		if (parsedCredential.walletSessionId !== parsedAcknowledgement.walletSessionId) throw new Error("linked-device acknowledgement credential does not match Wallet Session");
-		await requestWalletSessionAcknowledgementV1({
-			options,
-			baseUrl,
-			linkSessionId: parsedAcknowledgement.linkSessionId,
-			token: parsedCredential.token,
-			body: parsedAcknowledgement
-		});
-	} };
-}
-function createDeviceLinkingAuthorityActivationTransportV1(options) {
-	const baseUrl = normalizeBaseUrl(options.relayerUrl);
-	return {
-		receiveCommittedAuthorityPackagesV1: async ({ linkSessionId }) => await waitForCommittedAuthorityPackagesV1({
-			options,
-			baseUrl,
-			linkSessionId
-		}),
-		activateInstalledAuthorityV1: async ({ linkSessionId, receipt }) => {
-			const parsedReceipt = parseLocalAuthorityInstallationReceiptV1(receipt);
-			return parseActivateInstalledAuthorityResultV1((await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(linkSessionId, "receipt"),
-				linkSessionId,
-				body: parsedReceipt
-			})).body);
-		},
-		acknowledgeLocalAuthorityActivationV1: async ({ acknowledgement }) => {
-			const parsedAcknowledgement = parseLocalAuthorityActivationFinalAckV1(acknowledgement);
-			await requestDeviceV1({
-				options,
-				baseUrl,
-				method: "POST",
-				canonicalPath: sessionActionPath(acknowledgement.linkSessionId, "receipt"),
-				linkSessionId: acknowledgement.linkSessionId,
-				body: parsedAcknowledgement
-			});
-		}
-	};
-}
-/** Compose one direct transport port; owner auth remains an injected boundary. */
-function createDeviceLinkingSessionTransportPortV1(options) {
-	return {
-		...options.owner,
-		createAuthenticatedSessionTransportV1: ({ keyMaterial, devicePublicKeyB64u }) => createDeviceLinkingAuthenticatedSessionTransportV1({
-			http: options.http,
-			relayerUrl: options.relayerUrl,
-			publishableKey: options.publishableKey,
-			projectEnvironmentId: options.projectEnvironmentId,
-			keyMaterial: options.keyMaterial,
-			keyMaterialHandle: keyMaterial,
-			devicePublicKeyB64u,
-			nowMs: options.nowMs,
-			pollIntervalMs: options.pollIntervalMs
-		})
-	};
-}
-/**
-* The recipient registration carries its link session as a plain string,
-* because it is also the body the server parses. Re-parsing it here keeps the
-* signed canonical path derived from a branded id.
-*/
-function requireLinkSessionId(raw) {
-	const parsed = parseLinkDeviceSessionId(raw);
-	if (!parsed.ok) throw new Error(parsed.error.message);
-	return parsed.value;
-}
-async function requestSessionV1(input) {
-	return parseSessionMutationEnvelopeV1((await requestDeviceV1({
-		options: input.options,
-		baseUrl: input.baseUrl,
-		method: "GET",
-		canonicalPath: sessionPath(input.linkSessionId),
-		linkSessionId: input.linkSessionId
-	})).body).session;
-}
-async function requestMutationV1(input) {
-	return parseSessionMutationEnvelopeV1((await requestDeviceV1(input)).body);
-}
-async function requestDeviceV1(input) {
-	const publishableKey = input.options.publishableKey.trim();
-	const projectEnvironmentId = input.options.projectEnvironmentId.trim();
-	if (!publishableKey || !projectEnvironmentId) throw new Error("linked-device Passkey ceremony requires registration API credentials");
-	const bodyDigestB64u = await sha256DigestB64u(encodeRequestBodyV1(input.body));
-	const issuedAtMs = input.options.nowMs();
-	if (!Number.isSafeInteger(issuedAtMs) || issuedAtMs <= 0) throw new Error("linked-device request clock is invalid");
-	const expiresAtMs = issuedAtMs + LINKED_DEVICE_REQUEST_PROOF_MAX_TTL_MS_V1;
-	const requestNonceB64u = secureRandomBase64Url(32, "linked-device request proof nonce");
-	const devicePublicKeyDigestB64u = await computeLinkedDevicePublicKeyDigestV1(input.options.devicePublicKeyB64u);
-	const signed = await input.options.keyMaterial.signDeviceSessionRequestV1({
-		handle: input.options.keyMaterialHandle,
-		linkSessionId: input.linkSessionId,
-		method: input.method,
-		canonicalPath: input.canonicalPath,
-		bodyDigestB64u,
-		devicePublicKeyDigestB64u,
-		challengeB64u: requestNonceB64u,
-		issuedAtMs,
-		expiresAtMs
-	});
-	const proof = {
-		kind: "linked_device_request_proof_v1",
-		linkSessionId: input.linkSessionId,
-		devicePublicKeyDigestB64u,
-		requestNonceB64u,
-		method: input.method,
-		canonicalPath: input.canonicalPath,
-		bodyDigestB64u,
-		issuedAtMs,
-		expiresAtMs,
-		signatureB64u: signed.signatureB64u
-	};
-	const proofHeader = base64UrlEncode(new TextEncoder().encode(JSON.stringify(proof)));
-	const response = await input.options.http.request({
-		method: input.method,
-		url: `${input.baseUrl}${input.canonicalPath}`,
-		headers: {
-			Accept: "application/json",
-			Authorization: `Bearer ${publishableKey}`,
-			"Content-Type": "application/json",
-			"X-Seams-Environment-Id": projectEnvironmentId,
-			[LINKED_DEVICE_REQUEST_PROOF_HEADER_V1]: proofHeader
-		},
-		...input.body === void 0 ? {} : { body: input.body }
-	});
-	if (!response.ok) throw new Error(`linked-device request failed: ${response.message}`);
-	if (response.value.status < 200 || response.value.status >= 300) throw new Error(parseHttpFailureMessageV1(response.value));
-	return response.value;
-}
-async function requestWalletSessionAcknowledgementV1(input) {
-	const token = input.token.trim();
-	const projectEnvironmentId = input.options.projectEnvironmentId.trim();
-	if (!token || !projectEnvironmentId) throw new Error("linked-device Wallet Session acknowledgement requires session credentials");
-	const response = await input.options.http.request({
-		method: "POST",
-		url: `${input.baseUrl}${sessionActionPath(input.linkSessionId, "receipt")}`,
-		headers: {
-			Accept: "application/json",
-			Authorization: `Bearer ${token}`,
-			"Content-Type": "application/json",
-			"X-Seams-Environment-Id": projectEnvironmentId
-		},
-		body: input.body
-	});
-	if (!response.ok) throw new Error(`linked-device request failed: ${response.message}`);
-	if (response.value.status < 200 || response.value.status >= 300) throw new Error(parseHttpFailureMessageV1(response.value));
-}
-async function createPollingSubscriptionV1(input) {
-	let closed = false;
-	let timer;
-	let lastRevision = null;
-	let firstPoll = true;
-	let retryAttempt = 0;
-	let inFlight = null;
-	const poll = async () => {
-		if (closed) return;
-		try {
-			const session = await requestSessionV1({ ...input });
-			if (lastRevision === null || session.revision !== lastRevision) {
-				lastRevision = session.revision;
-				retryAttempt = 0;
-				input.onEvent(parseLinkSessionTransportEventV1({
-					kind: "linked_device_session_event_v1",
-					linkSessionId: session.linkSessionId,
-					state: session.state,
-					emittedAtMs: session.updatedAtMs
-				}));
-			} else retryAttempt += 1;
-		} catch (error) {
-			if (firstPoll) {
-				closed = true;
-				throw error;
-			}
-			retryAttempt += 1;
-		} finally {
-			firstPoll = false;
-			if (!closed) timer = setTimeout(() => {
-				inFlight = poll();
-			}, nextLinkedDevicePollingDelayMsV1(input.options.pollIntervalMs, Math.max(0, retryAttempt - 1)));
-		}
-	};
-	await (inFlight = poll());
-	return { close: async () => {
-		closed = true;
-		if (timer !== void 0) clearTimeout(timer);
-		await inFlight?.catch(() => void 0);
-	} };
-}
-function parseSessionMutationEnvelopeV1(raw) {
-	const record = asPlainDeviceLinkingResponse(raw);
-	if (record === null) throw new Error("linked-device response must be an object");
-	if (!hasExactResponseKeys(record, SESSION_MUTATION_RESPONSE_FIELDS)) throw new Error("linked-device response contains invalid fields");
-	if (record.ok !== true) throw new Error("linked-device response outcome is invalid");
-	switch (record.outcome) {
-		case "applied": return {
-			ok: true,
-			outcome: "applied",
-			session: parseLinkSessionProjectionV1(record.session)
-		};
-		case "replayed": return {
-			ok: true,
-			outcome: "replayed",
-			session: parseLinkSessionProjectionV1(record.session)
-		};
-		default: throw new Error("linked-device response outcome is invalid");
-	}
-}
-function parseTargetCredentialRegistrationResponseV1(raw) {
-	const record = asPlainDeviceLinkingResponse(raw);
-	if (record === null) throw new Error("linked-device target credential response must be an object");
-	if (!hasExactResponseKeys(record, TARGET_CREDENTIAL_RESPONSE_FIELDS)) throw new Error("linked-device target credential response contains invalid fields");
-	if (record.ok !== true) throw new Error("linked-device target credential response outcome is invalid");
-	switch (record.outcome) {
-		case "applied": return parseTargetCredentialRegistrationResponseBranch(record, "applied");
-		case "replayed": return parseTargetCredentialRegistrationResponseBranch(record, "replayed");
-		default: throw new Error("linked-device target credential response outcome is invalid");
-	}
-}
-function parseTargetCredentialRegistrationResponseBranch(record, outcome) {
-	const session = parseLinkSessionProjectionV1(record.session);
-	const targetCredential = parseLinkedDeviceTargetCredentialRegistrationResultV1(record.targetCredential);
-	if (targetCredential.outcome !== outcome) throw new Error("linked-device target credential response outcome does not match its result");
-	if (targetCredential.linkSessionId !== session.linkSessionId) throw new Error("linked-device target credential response session identity differs");
-	return targetCredential;
-}
-function parseHttpFailureMessageV1(response) {
-	const record = asPlainDeviceLinkingResponse(response.body);
-	if (record === null || record.ok !== false) return `linked-device request failed with HTTP ${response.status}`;
-	if (hasExactResponseKeys(record, CODED_FAILURE_RESPONSE_FIELDS) && typeof record.code === "string" && typeof record.message === "string" && record.message.trim()) return `linked-device request failed: ${record.message}`;
-	if (hasExactResponseKeys(record, OUTCOME_FAILURE_RESPONSE_FIELDS) && typeof record.outcome === "string" && typeof record.code === "string" && typeof record.message === "string" && record.message.trim()) return `linked-device request failed: ${record.message}`;
-	switch (record.outcome) {
-		case "conflict":
-			if (hasExactResponseKeys(record, SESSION_CONFLICT_FAILURE_FIELDS)) return "linked-device request failed: conflict";
-			break;
-		case "expired":
-			if (hasExactResponseKeys(record, SESSION_EXPIRED_FAILURE_FIELDS)) return "linked-device request failed: expired";
-			break;
-		case "invalid_state":
-			if (hasExactResponseKeys(record, SESSION_INVALID_STATE_FAILURE_FIELDS)) return "linked-device request failed: invalid_state";
-			break;
-		case "integrity_error":
-			if (hasExactResponseKeys(record, SESSION_INTEGRITY_FAILURE_FIELDS)) return "linked-device request failed: integrity_error";
-			break;
-		default: break;
-	}
-	return `linked-device request failed with HTTP ${response.status}`;
-}
-function asPlainDeviceLinkingResponse(value) {
-	return isPlainDeviceLinkingResponse(value) ? value : null;
-}
-function isPlainDeviceLinkingResponse(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-	try {
-		const prototype = Object.getPrototypeOf(value);
-		return prototype === Object.prototype || prototype === null;
-	} catch {
-		return false;
-	}
-}
-function hasExactResponseKeys(record, expectedKeys) {
-	try {
-		return hasExactKeys(record, expectedKeys);
-	} catch {
-		return false;
-	}
-}
-function encodeRequestBodyV1(body) {
-	if (body === void 0) return new Uint8Array();
-	const encoded = JSON.stringify(body);
-	if (typeof encoded !== "string") throw new Error("linked-device request body is not JSON serializable");
-	return new TextEncoder().encode(encoded);
-}
-function normalizeBaseUrl(value) {
-	const normalized = value.trim().replace(/\/+$/, "");
-	if (!normalized) throw new Error("linked-device relayer URL is required");
-	return normalized;
-}
-function sessionPath(linkSessionId) {
-	return `${LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1}/${String(linkSessionId)}`;
-}
-function sessionActionPath(linkSessionId, action) {
-	return `${sessionPath(linkSessionId)}/${action}`;
-}
-//#endregion
-export { LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1, createDeviceLinkingSessionTransportPortV1, createDeviceLinkingWalletSessionAcknowledgementReplayPortV1, nextLinkedDevicePollingDelayMsV1 };
-
-//# sourceMappingURL=deviceLinkingHttpTransport.js.map

package/dist/esm/SeamsWeb/operations/devices/deviceLinkingOwnerTransport.js

@@ -1,135 +0,0 @@
-import { parseLinkDeviceSessionId } from "../../../shared-ts/src/utils/domainIds.js";
-import { parseLinkedDeviceEd25519ExportRootRecipientV1 } from "../../../shared-ts/src/device-linking/ed25519ExportRoot.js";
-import { parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationTupleV1 } from "../../../shared-ts/src/device-linking/sourceContribution.js";
-import { parseLinkSessionProjectionV1, parseLinkedDeviceApprovalResultV1, parseLinkedDeviceEmailOtpBaseFactorResolutionResultV1, parseLinkedDeviceSessionClaimV1 } from "../../../shared-ts/src/device-linking/parsers.js";
-import "../../../shared-ts/src/device-linking/index.js";
-import { LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1 } from "./deviceLinkingHttpTransport.js";
-//#region src/SeamsWeb/operations/devices/deviceLinkingOwnerTransport.ts
-function createDeviceLinkingOwnerTransportV1(options) {
-	return {
-		claimSessionV1: async (input) => {
-			return parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(input.request.payload.linkSessionId)}/claim`,
-				body: input.request,
-				authentication: input.authentication
-			}), parseLinkedDeviceSessionClaimV1);
-		},
-		resolveEmailOtpBaseFactorV1: async (input) => {
-			return parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(input.linkSessionId)}/email-otp-base-factor`,
-				body: input.request,
-				authentication: input.authentication
-			}), parseLinkedDeviceEmailOtpBaseFactorResolutionResultV1);
-		},
-		cancelClaimedSessionV1: async (input) => {
-			return parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(input.linkSessionId)}/owner-cancel`,
-				body: { expectedRevision: input.expectedRevision },
-				authentication: input.authentication
-			}), parseSessionProjectionResponseV1);
-		},
-		recordOwnerApprovalV1: async (input) => {
-			return parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(input.approval.linkSessionId)}/approval`,
-				body: input.approval,
-				authentication: input.authentication
-			}), parseLinkedDeviceApprovalResultV1);
-		},
-		getSourceContributionPreparationV1: async (input) => {
-			const response = await options.request.requestOwnerV1({
-				method: "GET",
-				canonicalPath: `${sessionPath(input.linkSessionId)}/source-contribution-preparation`,
-				authentication: input.authentication
-			});
-			if (response.status === 204) return null;
-			return parseOwnerResponseV1(response, parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationTupleV1);
-		},
-		recordSourceContributionV1: async (input) => {
-			return parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(input.approval.linkSessionId)}/source-contribution`,
-				body: input.approval,
-				authentication: input.authentication
-			}), parseSourceContributionSessionResponseV1);
-		},
-		getApprovalV1: options.approvalUpdates.getApprovalV1,
-		getEd25519ExportRootRecipientV1: async (input) => {
-			const response = await options.request.requestOwnerV1({
-				method: "GET",
-				canonicalPath: `${sessionPath(input.linkSessionId)}/ed25519-export-root-recipient`,
-				authentication: input.authentication
-			});
-			if (response.status === 204) return null;
-			return parseOwnerResponseV1(response, parseLinkedDeviceEd25519ExportRootRecipientV1);
-		},
-		submitEd25519ExportRootPackageV1: async (input) => {
-			parseOwnerResponseV1(await options.request.requestOwnerV1({
-				method: "POST",
-				canonicalPath: `${sessionPath(requireLinkSessionId(input.submission.linkSessionId))}/ed25519-export-root`,
-				body: input.submission,
-				authentication: input.authentication
-			}), (raw) => raw);
-		},
-		subscribeApprovalV1: options.approvalUpdates.subscribeApprovalV1
-	};
-}
-function parseOwnerResponseV1(response, parse) {
-	if (response.status < 200 || response.status >= 300) throw Object.assign(new Error(parseOwnerFailureMessageV1(response)), { status: response.status });
-	return parse(response.body);
-}
-function parseOwnerFailureMessageV1(response) {
-	const errorBody = decodeLinkedDeviceOwnerErrorBodyV1(response.body);
-	if (errorBody) return `linked-device owner request failed: ${errorBody.message}`;
-	return `linked-device owner request failed with HTTP ${response.status}`;
-}
-function parseSourceContributionSessionResponseV1(raw) {
-	const response = decodeLinkedDeviceSessionResponseV1(raw);
-	if (!response) throw new Error("linked-device source contribution response is invalid");
-	return parseLinkSessionProjectionV1(response.session);
-}
-function parseSessionProjectionResponseV1(raw) {
-	const response = decodeLinkedDeviceSessionResponseV1(raw);
-	if (!response) throw new Error("linked-device session response is invalid");
-	return parseLinkSessionProjectionV1(response.session);
-}
-function decodeLinkedDeviceSessionResponseV1(raw) {
-	if (raw === null || typeof raw !== "object" || Array.isArray(raw) || Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null) return null;
-	const fields = new Map(Object.entries(raw));
-	const names = [...fields.keys()];
-	const expected = new Set([
-		"ok",
-		"outcome",
-		"session"
-	]);
-	if (names.length !== expected.size || !names.every((name) => expected.has(name)) || fields.get("ok") !== true || fields.get("outcome") !== "applied" && fields.get("outcome") !== "replayed") return null;
-	return { session: fields.get("session") };
-}
-function decodeLinkedDeviceOwnerErrorBodyV1(raw) {
-	if (raw === null || typeof raw !== "object" || Array.isArray(raw) || Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null) return null;
-	const fields = new Map(Object.entries(raw));
-	const names = [...fields.keys()];
-	if (names.length === 0 || names.length > 2 || !names.every((name) => name === "code" || name === "message")) return null;
-	const message = fields.get("message");
-	return typeof message === "string" ? { message } : null;
-}
-function sessionPath(linkSessionId) {
-	return `${LINKED_DEVICE_SESSION_HTTP_BASE_PATH_V1}/${String(linkSessionId)}`;
-}
-/**
-* The submission carries its link session as a plain string because that is
-* also the body the server parses. Re-parsing keeps the request path derived
-* from a branded id.
-*/
-function requireLinkSessionId(raw) {
-	const parsed = parseLinkDeviceSessionId(raw);
-	if (!parsed.ok) throw new Error(parsed.error.message);
-	return parsed.value;
-}
-//#endregion
-export { createDeviceLinkingOwnerTransportV1 };
-
-//# sourceMappingURL=deviceLinkingOwnerTransport.js.map