@seams/wallet 0.8.0 → 0.9.0

package/dist/esm/core/signingEngine/workerManager/deviceLinkingPorts.js

@@ -1,342 +0,0 @@
-import { parseWalletAuthMethodId, parseWalletAuthorityId, parseWalletKeyId } from "../../../shared-ts/src/utils/domainIds.js";
-import { requireCanonicalString } from "../../../shared-ts/src/utils/validation.js";
-import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { parseDigestB64u } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
-import { parsePasskeyCustodyEnvelopeRecord } from "../../../shared-ts/src/passkey-custody/custodyEnvelope.js";
-import "../../../shared-ts/src/passkey-custody/index.js";
-import { parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationV1 } from "../../../shared-ts/src/device-linking/sourceContribution.js";
-import { parseCommittedAuthorityPackagesV1 } from "../../../shared-ts/src/device-linking/committedSignerPackages.js";
-import { parseWalletAuthorityLinkedSignerMaterialRecordV1 } from "../../indexedDB/linkedAuthoritySignerMaterial.js";
-import { hasExactKeys } from "../../../shared-ts/src/utils/exactKeys.js";
-//#region src/core/signingEngine/workerManager/deviceLinkingPorts.ts
-function targetFactorBindingV1(targetFactor) {
-	const authMethod = parseWalletAuthMethodId(targetFactor.authMethod.walletAuthMethodId);
-	if (!authMethod.ok) throw new Error(authMethod.error.message);
-	const verificationDigestB64u = parseDigestB64u(targetFactor.verificationDigestB64u);
-	if (targetFactor.kind === "verified_passkey_target_v1") return {
-		kind: "passkey",
-		walletAuthMethodId: authMethod.value,
-		verificationDigestB64u,
-		rpId: targetFactor.authMethod.rpId,
-		credentialIdB64u: targetFactor.authMethod.credentialIdB64u
-	};
-	return {
-		kind: "email_otp",
-		walletAuthMethodId: authMethod.value,
-		verificationDigestB64u,
-		emailHashHex: targetFactor.authMethod.emailHashHex,
-		registrationAuthorityId: targetFactor.authMethod.registrationAuthorityId
-	};
-}
-function createDeviceLinkingOrdinaryMaterialWorkerPortV1(send) {
-	return {
-		async prepareOrdinarySignerMaterialV1(input) {
-			if (!(input.factorSecret instanceof ArrayBuffer) || input.factorSecret.byteLength !== 32) throw new Error("ordinary signer material factorSecret must be 32 bytes");
-			const preparations = parsePreparationTuple(input.preparations);
-			const recipientRequests = parseRecipientRequestTuple(input.recipientRequests);
-			const recipientInputs = parseRecipientInputTuple(input.recipientInputs);
-			assertRecipientInputsMatchRequests(recipientInputs, recipientRequests);
-			const transfer = [input.factorSecret, ...recipientInputTransferables(recipientInputs)];
-			return parsePreparationResult(await send({
-				kind: "device_linking_ordinary_signer_material_prepare_private_v1",
-				handleId: requireCanonicalString(input.keyMaterial.handleId, "keyMaterial.handleId", "is required"),
-				targetFactor: targetFactorBindingV1(input.targetFactor),
-				preparations,
-				recipientRequests,
-				recipientInputs,
-				factorSecret: input.factorSecret
-			}, transfer));
-		},
-		async createOrdinarySignerMaterialRecipientRequestsV1(input) {
-			return parseRecipientPreparationResult(await send({
-				kind: "device_linking_ordinary_signer_material_recipient_prepare_v1",
-				handleId: requireCanonicalString(input.keyMaterial.handleId, "keyMaterial.handleId", "is required"),
-				requirements: parseRecipientRequirementTuple(input.requirements)
-			}));
-		},
-		async sealCommittedAuthorityPackagesV1(input) {
-			const committed = parseCommittedAuthorityPackagesV1(input.committed);
-			return parseSealedLocalAuthorityMaterialSetV1(await send({
-				kind: "device_linking_ordinary_signer_material_seal_v1",
-				handleId: requireCanonicalString(input.keyMaterial.handleId, "keyMaterial.handleId", "is required"),
-				committed,
-				targetFactor: targetFactorBindingV1(input.targetFactor),
-				resealedExportRoot: parseOrdinaryResealedExportRootRecordV1(input.resealedExportRoot)
-			}));
-		}
-	};
-}
-function parseOrdinaryResealedExportRootRecordV1(value) {
-	if (value === null) return null;
-	if (!hasExactKeys(value, ["envelope"])) throw new Error("ordinary material resealed export root has unsupported fields");
-	return { envelope: parsePasskeyCustodyEnvelopeRecord(value.envelope) };
-}
-function parsePreparationResult(value) {
-	if (!hasExactKeys(value, [
-		"kind",
-		"targetFactor",
-		"preparations"
-	])) throw new Error("ordinary material preparation result has invalid fields");
-	if (value.kind !== "device_linking_ordinary_signer_material_preparation_v1") throw new Error("ordinary material preparation result kind is invalid");
-	return {
-		kind: "device_linking_ordinary_signer_material_preparation_v1",
-		targetFactor: parseTargetFactorBindingV1(value.targetFactor),
-		preparations: parsePreparationTuple(value.preparations)
-	};
-}
-function parsePreparationTuple(value) {
-	if (!Array.isArray(value) || value.length === 0 || value.length > 2) throw new Error("ordinary signer material preparations must contain one or two entries");
-	const preparations = value.map(parsePreparation);
-	const families = preparations.map((entry) => "kind" in entry ? "ed25519" : "ecdsa_secp256k1");
-	if (new Set(families).size !== preparations.length) throw new Error("ordinary signer material preparations repeat a key family");
-	const activations = preparations.map((entry) => "kind" in entry ? entry.targetMaterialActivation : entry.target.activation);
-	if (activations.length === 2 && activations[0].activationId === activations[1].activationId) throw new Error("ordinary signer material preparations repeat an activation reference");
-	const first = preparations[0];
-	if (!first) throw new Error("ordinary signer material preparations are empty");
-	return [first, ...preparations.slice(1)];
-}
-function parseRecipientRequirementTuple(value) {
-	if (!Array.isArray(value) || value.length === 0 || value.length > 2) throw new Error("ordinary signer material recipient requirements must contain one or two entries");
-	const requirements = value.map((entry, index) => {
-		if (!hasExactKeys(entry, [
-			"kind",
-			"keyFamily",
-			"walletKeyId"
-		])) throw new Error(`ordinary recipient requirement ${index} has invalid fields`);
-		if (entry.kind !== "ordinary_signer_material_recipient_requirement_v1") throw new Error("ordinary recipient requirement kind is invalid");
-		if (entry.keyFamily !== "ed25519" && entry.keyFamily !== "ecdsa_secp256k1") throw new Error("ordinary recipient requirement key family is invalid");
-		const walletKeyId = parseWalletKey(entry.walletKeyId);
-		return {
-			kind: entry.kind,
-			keyFamily: entry.keyFamily,
-			walletKeyId
-		};
-	});
-	assertUniqueRecipientFamilies(requirements);
-	const first = requirements[0];
-	if (!first) throw new Error("ordinary recipient requirements are empty");
-	return [first, ...requirements.slice(1)];
-}
-function parseRecipientRequestTuple(value) {
-	if (!Array.isArray(value) || value.length === 0 || value.length > 2) throw new Error("ordinary signer material recipient requests must contain one or two entries");
-	const requests = value.map((entry) => {
-		if (hasExactKeys(entry, [
-			"kind",
-			"keyFamily",
-			"walletKeyId",
-			"recipientPublicKeyB64u"
-		])) {
-			if (entry.kind !== "ordinary_ed25519_signer_material_recipient_request_v1" || entry.keyFamily !== "ed25519") throw new Error("ordinary Ed25519 recipient request kind is invalid");
-			return {
-				kind: "ordinary_ed25519_signer_material_recipient_request_v1",
-				keyFamily: "ed25519",
-				walletKeyId: parseWalletKey(entry.walletKeyId),
-				recipientPublicKeyB64u: parseB64u(entry.recipientPublicKeyB64u, "Ed25519 recipient public key")
-			};
-		}
-		if (hasExactKeys(entry, [
-			"kind",
-			"keyFamily",
-			"walletKeyId",
-			"clientEphemeralPublicKey"
-		])) {
-			if (entry.kind !== "ordinary_ecdsa_signer_material_recipient_request_v1" || entry.keyFamily !== "ecdsa_secp256k1") throw new Error("ordinary ECDSA recipient request kind is invalid");
-			return {
-				kind: "ordinary_ecdsa_signer_material_recipient_request_v1",
-				keyFamily: "ecdsa_secp256k1",
-				walletKeyId: parseWalletKey(entry.walletKeyId),
-				clientEphemeralPublicKey: requireCanonicalString(entry.clientEphemeralPublicKey, "ECDSA client ephemeral public key", "is required")
-			};
-		}
-		throw new Error("ordinary recipient request key family is invalid");
-	});
-	assertUniqueRecipientFamilies(requests);
-	const first = requests[0];
-	if (!first) throw new Error("ordinary recipient requests are empty");
-	return [first, ...requests.slice(1)];
-}
-function parseRecipientPreparationResult(value) {
-	if (!hasExactKeys(value, [
-		"kind",
-		"recipientRequests",
-		"recipientInputs"
-	])) throw new Error("ordinary recipient preparation result has invalid fields");
-	if (value.kind !== "device_linking_ordinary_signer_material_recipient_preparation_v1") throw new Error("ordinary recipient preparation result kind is invalid");
-	const recipientRequests = parseRecipientRequestTuple(value.recipientRequests);
-	const recipientInputs = parseRecipientInputTuple(value.recipientInputs);
-	assertRecipientInputsMatchRequests(recipientInputs, recipientRequests);
-	return {
-		recipientRequests,
-		recipientInputs
-	};
-}
-function parseRecipientInputTuple(value) {
-	if (!Array.isArray(value) || value.length === 0 || value.length > 2) throw new Error("ordinary signer material recipient inputs must contain one or two entries");
-	const inputs = value.map((entry) => {
-		if (hasExactKeys(entry, [
-			"kind",
-			"keyFamily",
-			"walletKeyId",
-			"recipientPrivateKey"
-		])) {
-			if (entry.kind !== "ordinary_ed25519_signer_material_recipient_input_v1" || entry.keyFamily !== "ed25519") throw new Error("ordinary Ed25519 recipient input kind is invalid");
-			return {
-				kind: "ordinary_ed25519_signer_material_recipient_input_v1",
-				keyFamily: "ed25519",
-				walletKeyId: parseWalletKey(entry.walletKeyId),
-				recipientPrivateKey: parsePrivateKeyBuffer(entry.recipientPrivateKey, "Ed25519 recipient private key")
-			};
-		}
-		if (hasExactKeys(entry, [
-			"kind",
-			"keyFamily",
-			"walletKeyId",
-			"clientEphemeralPrivateKey"
-		])) {
-			if (entry.kind !== "ordinary_ecdsa_signer_material_recipient_input_v1" || entry.keyFamily !== "ecdsa_secp256k1") throw new Error("ordinary ECDSA recipient input kind is invalid");
-			return {
-				kind: "ordinary_ecdsa_signer_material_recipient_input_v1",
-				keyFamily: "ecdsa_secp256k1",
-				walletKeyId: parseWalletKey(entry.walletKeyId),
-				clientEphemeralPrivateKey: parsePrivateKeyBuffer(entry.clientEphemeralPrivateKey, "ECDSA client ephemeral private key")
-			};
-		}
-		throw new Error("ordinary recipient input key family is invalid");
-	});
-	assertUniqueRecipientFamilies(inputs);
-	const first = inputs[0];
-	if (!first) throw new Error("ordinary recipient inputs are empty");
-	return [first, ...inputs.slice(1)];
-}
-function parsePrivateKeyBuffer(value, label) {
-	if (!(value instanceof ArrayBuffer) || value.byteLength !== 32) throw new Error(`${label} must be a 32-byte ArrayBuffer`);
-	return value;
-}
-function recipientInputTransferables(inputs) {
-	return inputs.map((input) => input.kind === "ordinary_ed25519_signer_material_recipient_input_v1" ? input.recipientPrivateKey : input.clientEphemeralPrivateKey);
-}
-function assertRecipientInputsMatchRequests(inputs, requests) {
-	if (inputs.length !== requests.length) throw new Error("ordinary recipient inputs and requests have different lengths");
-	for (const request of requests) if (inputs.filter((input) => input.walletKeyId === request.walletKeyId && input.keyFamily === request.keyFamily).length !== 1) throw new Error(`ordinary recipient input for ${String(request.walletKeyId)} is missing or duplicated`);
-}
-function assertUniqueRecipientFamilies(values) {
-	const families = /* @__PURE__ */ new Set();
-	const keys = /* @__PURE__ */ new Set();
-	for (const value of values) {
-		if (families.has(value.keyFamily)) throw new Error("ordinary recipient family repeats");
-		if (keys.has(String(value.walletKeyId))) throw new Error("ordinary recipient wallet key repeats");
-		families.add(value.keyFamily);
-		keys.add(String(value.walletKeyId));
-	}
-	const first = values[0];
-	if (values.length === 2 && first?.keyFamily !== "ed25519") throw new Error("ordinary recipient requests must be ordered Ed25519 then ECDSA");
-}
-function parseWalletKey(value) {
-	const parsed = parseWalletKeyId(value);
-	if (!parsed.ok) throw new Error(parsed.error.message);
-	return parsed.value;
-}
-function parsePreparation(value) {
-	return parseLinkedDeviceOrdinaryMaterialSourceContributionPreparationV1(value);
-}
-function parseTargetFactorBindingV1(value) {
-	if (hasExactKeys(value, [
-		"kind",
-		"walletAuthMethodId",
-		"verificationDigestB64u",
-		"rpId",
-		"credentialIdB64u"
-	])) {
-		if (value.kind !== "passkey") throw new Error("ordinary material target factor kind is unsupported");
-		const authMethod = parseWalletAuthMethodId(value.walletAuthMethodId);
-		if (!authMethod.ok) throw new Error(authMethod.error.message);
-		const verificationDigestB64u = parseDigestB64u(value.verificationDigestB64u);
-		return {
-			kind: "passkey",
-			walletAuthMethodId: authMethod.value,
-			verificationDigestB64u,
-			rpId: requireCanonicalString(value.rpId, "ordinary target factor rpId", "is required"),
-			credentialIdB64u: parseB64u(value.credentialIdB64u, "ordinary target factor credentialIdB64u")
-		};
-	}
-	if (hasExactKeys(value, [
-		"kind",
-		"walletAuthMethodId",
-		"verificationDigestB64u",
-		"emailHashHex",
-		"registrationAuthorityId"
-	])) {
-		if (value.kind !== "email_otp") throw new Error("ordinary material target factor kind is unsupported");
-		const authMethod = parseWalletAuthMethodId(value.walletAuthMethodId);
-		if (!authMethod.ok) throw new Error(authMethod.error.message);
-		const verificationDigestB64u = parseDigestB64u(value.verificationDigestB64u);
-		const emailHashHex = requireCanonicalString(value.emailHashHex, "ordinary target factor emailHashHex", "is required");
-		if (!/^[0-9a-f]{64}$/.test(emailHashHex)) throw new Error("ordinary target factor emailHashHex is invalid");
-		return {
-			kind: "email_otp",
-			walletAuthMethodId: authMethod.value,
-			verificationDigestB64u,
-			emailHashHex,
-			registrationAuthorityId: requireCanonicalString(value.registrationAuthorityId, "ordinary target factor registrationAuthorityId", "is required")
-		};
-	}
-	throw new Error("ordinary material target factor kind is unsupported");
-}
-function parseWalletAuthorityExportRootRecordV1(value) {
-	if (!hasExactKeys(value, [
-		"kind",
-		"authorityId",
-		"walletAuthMethodId",
-		"walletKeyId",
-		"envelope"
-	])) throw new Error("ordinary material export-root record has invalid fields");
-	if (value.kind !== "wallet_authority_export_root_v1") throw new Error("ordinary material export-root record kind is invalid");
-	const authorityId = parseWalletAuthorityId(value.authorityId);
-	if (!authorityId.ok) throw new Error(authorityId.error.message);
-	const walletAuthMethodId = parseWalletAuthMethodId(value.walletAuthMethodId);
-	if (!walletAuthMethodId.ok) throw new Error(walletAuthMethodId.error.message);
-	const walletKeyId = parseWalletKeyId(value.walletKeyId);
-	if (!walletKeyId.ok) throw new Error(walletKeyId.error.message);
-	return {
-		kind: "wallet_authority_export_root_v1",
-		authorityId: authorityId.value,
-		walletAuthMethodId: walletAuthMethodId.value,
-		walletKeyId: walletKeyId.value,
-		envelope: parsePasskeyCustodyEnvelopeRecord(value.envelope)
-	};
-}
-function parseSealedLocalAuthorityMaterialSetV1(value) {
-	if (!hasExactKeys(value, [
-		"signerMaterials",
-		"exportRoot",
-		"installedRecordSetDigestB64u"
-	])) throw new Error("ordinary material worker returned an invalid sealed record set");
-	if (!Array.isArray(value.signerMaterials) || value.signerMaterials.length === 0) throw new Error("ordinary material worker returned an invalid sealed record set");
-	const signerMaterials = value.signerMaterials.map((entry) => parseWalletAuthorityLinkedSignerMaterialRecordV1(entry));
-	const firstSignerMaterial = signerMaterials[0];
-	if (!firstSignerMaterial) throw new Error("ordinary material worker returned an invalid sealed record set");
-	return {
-		signerMaterials: [firstSignerMaterial, ...signerMaterials.slice(1)],
-		exportRoot: value.exportRoot === null ? null : parseWalletAuthorityExportRootRecordV1(value.exportRoot),
-		installedRecordSetDigestB64u: parseDigestB64u(value.installedRecordSetDigestB64u)
-	};
-}
-function parseB64u(value, label) {
-	const encoded = requireCanonicalString(value, label, "is required");
-	let decoded;
-	try {
-		decoded = base64UrlDecode(encoded);
-	} catch {
-		throw new Error(`${label} is invalid base64url`);
-	}
-	if (decoded.length === 0 || base64UrlEncode(decoded) !== encoded) {
-		decoded.fill(0);
-		throw new Error(`${label} must be canonical non-empty base64url`);
-	}
-	decoded.fill(0);
-	return encoded;
-}
-//#endregion
-export { createDeviceLinkingOrdinaryMaterialWorkerPortV1 };
-
-//# sourceMappingURL=deviceLinkingPorts.js.map

package/dist/esm/core/signingEngine/workerManager/deviceLinkingSourceContribution.js

@@ -1,158 +0,0 @@
-import { mpcMaterialActivationRefsEqual, parseWalletKeyId } from "../../../shared-ts/src/utils/domainIds.js";
-import { base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { parseDigestB64u } from "../../../shared-ts/src/utils/canonicalPrimitives.js";
-import { deriveEvmFamilySigningKeySlotId } from "../../../shared-ts/src/signing-lanes/evmFamilySigningKeySlotId.js";
-import "../../../shared-ts/src/signing-lanes/index.js";
-import { deriveRouterAbEd25519YaoApplicationBindingDigestV1 } from "../../../shared-ts/src/utils/routerAbEd25519YaoDigests.js";
-import { parseEcdsaThresholdKeyId } from "../session/keyMaterialBrands.js";
-import { prepareLinkedDeviceEcdsaSourceContributionWasm } from "../threshold/crypto/ecdsaDerivationClientWasm.js";
-import { parseLinkedDeviceEd25519SourcePreservingReservationV1 } from "../../../shared-ts/src/device-linking/sourceContribution.js";
-import { openEd25519YaoLaneWorkerSourceFromUnlockedCapabilityV1 } from "../threshold/crypto/ed25519YaoLaneWasm.js";
-//#region src/core/signingEngine/workerManager/deviceLinkingSourceContribution.ts
-function createDeviceLinkingEcdsaSourceContributionMetadataReaderV1(context) {
-	return async ({ preparation }) => {
-		const sourceActivation = preparation.source.activation;
-		const linked = context.readLinkedEcdsaHolderV1({ materialActivation: sourceActivation });
-		if (linked) return linkedEcdsaSourceMetadataV1(linked, sourceActivation);
-		const manifest = await context.readActiveEcdsaCapabilityManifestV1({ materialActivation: sourceActivation });
-		assertExactEcdsaSourceMetadataContextV1({
-			sourceActivation,
-			manifest
-		});
-		return {
-			walletKeyId: walletKeyIdForActiveManifestV1(manifest),
-			sourceDerivation: {
-				applicationBindingDigestB64u: parseDigestB64u(manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning.scope.context.application_binding_digest_b64u),
-				clientShareRetryCounter: manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning.scope.public_identity.client_share_retry_counter,
-				ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(manifest.durableMaterial.roleLocalBinding.ecdsaThresholdKeyId),
-				sourceNormalSigning: manifest.durableMaterial.routerAbEcdsaDerivationNormalSigning
-			}
-		};
-	};
-}
-function linkedEcdsaSourceMetadataV1(holder, sourceActivation) {
-	if (!mpcMaterialActivationRefsEqual(holder.materialActivation, sourceActivation)) throw new Error("linked ECDSA holder activation does not match preparation");
-	const normalSigning = holder.activationReceipt.normalSigning;
-	const scope = normalSigning.scope;
-	const signingKeySlotId = deriveEvmFamilySigningKeySlotId({
-		walletId: holder.walletId,
-		signingRootId: scope.signing_root_id,
-		signingRootVersion: scope.signing_root_version
-	});
-	const walletKeyId = parseWalletKeyId(`wallet-key:ecdsa:${holder.walletId}:${signingKeySlotId}`);
-	if (!walletKeyId.ok) throw new Error(`linked ECDSA source wallet key identity: ${walletKeyId.error.message}`);
-	return {
-		walletKeyId: walletKeyId.value,
-		sourceDerivation: {
-			applicationBindingDigestB64u: parseDigestB64u(scope.context.application_binding_digest_b64u),
-			clientShareRetryCounter: scope.public_identity.client_share_retry_counter,
-			ecdsaThresholdKeyId: parseEcdsaThresholdKeyId(holder.ecdsaThresholdKeyId),
-			sourceNormalSigning: normalSigning
-		},
-		linkedHolderHandleId: holder.holderHandleId
-	};
-}
-function assertExactEcdsaSourceMetadataContextV1(input) {
-	if (!mpcMaterialActivationRefsEqual(input.manifest.activation.materialActivation, input.sourceActivation)) throw new Error("ECDSA capability manifest activation does not match preparation");
-}
-function walletKeyIdForActiveManifestV1(manifest) {
-	const signingKeySlotId = deriveEvmFamilySigningKeySlotId({
-		walletId: manifest.signer.walletId,
-		signingRootId: manifest.signer.signingRootId,
-		signingRootVersion: manifest.signer.signingRootVersion
-	});
-	const parsed = parseWalletKeyId(`wallet-key:ecdsa:${manifest.signer.walletId}:${signingKeySlotId}`);
-	if (!parsed.ok) throw new Error(`ECDSA source wallet key identity: ${parsed.error.message}`);
-	return parsed.value;
-}
-function createDeviceLinkingEd25519SourceContributionPortV1(input) {
-	return { produceSourceContributionV1: async ({ preparation, capability, authentication }) => {
-		const source = await openEd25519YaoLaneWorkerSourceFromUnlockedCapabilityV1({
-			workerCtx: input.workerContext,
-			capability,
-			applicationBindingDigestB64u: await applicationBindingDigestB64uV1(preparation.applicationBinding),
-			walletKeyId: String(preparation.walletKeyId),
-			enrollmentId: String(preparation.enrollmentId),
-			revocationEpoch: preparation.sourceRevocationEpoch,
-			registeredPublicKeyB64u: preparation.sourceRegisteredPublicKeyB64u
-		});
-		try {
-			const prepared = await source.prepareSourcePreservingRegistration({
-				targetAdmission: preparation.targetAdmission,
-				applicationBinding: preparation.applicationBinding,
-				participantIds: preparation.participantIds,
-				expectedRegisteredPublicKeyB64u: preparation.sourceRegisteredPublicKeyB64u,
-				targetClientRecipientPublicKeyB64u: preparation.targetClientRecipientPublicKeyB64u
-			});
-			const reservation = parseLinkedDeviceEd25519SourcePreservingReservationV1(await input.executeSourcePreservingV1({
-				linkSessionId: preparation.linkSessionId,
-				sourceBinding: preparation.sourceBinding,
-				targetRequestJson: prepared.requestJson,
-				participantIds: preparation.participantIds,
-				authentication
-			}));
-			return {
-				kind: "linked_device_ed25519_source_contribution_v1",
-				keyFamily: "ed25519",
-				linkSessionId: preparation.linkSessionId,
-				enrollmentId: preparation.enrollmentId,
-				sourceAuthorityId: preparation.sourceAuthorityId,
-				walletKeyId: preparation.walletKeyId,
-				targetDeviceId: preparation.targetDeviceId,
-				targetFactorVerificationDigestB64u: preparation.targetFactorVerificationDigestB64u,
-				targetMaterialActivation: preparation.targetMaterialActivation,
-				targetClientRecipientPublicKeyB64u: preparation.targetClientRecipientPublicKeyB64u,
-				targetSigningWorkerRecipientPublicKeyB64u: preparation.targetSigningWorkerRecipientPublicKeyB64u,
-				sourceRegisteredPublicKeyB64u: preparation.sourceRegisteredPublicKeyB64u,
-				sourceBinding: preparation.sourceBinding,
-				reservationId: reservation.reservationId,
-				targetBinding: preparation.targetAdmission.binding,
-				activationReceipt: reservation.activationReceipt,
-				participantIds: reservation.participantIds,
-				deriver_a_client_package: reservation.deriver_a_client_package,
-				deriver_b_client_package: reservation.deriver_b_client_package
-			};
-		} finally {
-			await source.discard();
-		}
-	} };
-}
-function createDeviceLinkingSourceContributionPortV1(input) {
-	return {
-		ed25519: input.ed25519,
-		ecdsa: { produceSourceContributionV1: async ({ preparation }) => await produceEcdsaSourceContributionV1({
-			workerContext: input.workerContext,
-			readMetadataV1: input.readEcdsaMetadataV1,
-			preparation
-		}) }
-	};
-}
-async function produceEcdsaSourceContributionV1(input) {
-	const metadata = await input.readMetadataV1({ preparation: input.preparation });
-	const prepared = await prepareLinkedDeviceEcdsaSourceContributionWasm({
-		preparation: input.preparation,
-		workerCtx: input.workerContext,
-		...metadata.linkedHolderHandleId === void 0 ? {} : { linkedHolderHandleId: metadata.linkedHolderHandleId }
-	});
-	return {
-		kind: "linked_device_ecdsa_source_contribution_v1",
-		keyFamily: "ecdsa_secp256k1",
-		linkSessionId: input.preparation.linkSessionId,
-		enrollmentId: input.preparation.enrollmentId,
-		sourceAuthorityId: input.preparation.sourceAuthorityId,
-		walletKeyId: metadata.walletKeyId,
-		targetDeviceId: input.preparation.target.targetDeviceId,
-		targetFactorVerificationDigestB64u: input.preparation.target.targetFactorVerificationDigestB64u,
-		sourceSigner: input.preparation.source,
-		sourceDerivation: metadata.sourceDerivation,
-		target: input.preparation.target,
-		package: prepared.package
-	};
-}
-async function applicationBindingDigestB64uV1(applicationBinding) {
-	return base64UrlEncode(Uint8Array.from(await deriveRouterAbEd25519YaoApplicationBindingDigestV1(applicationBinding)));
-}
-//#endregion
-export { createDeviceLinkingEcdsaSourceContributionMetadataReaderV1, createDeviceLinkingEd25519SourceContributionPortV1, createDeviceLinkingSourceContributionPortV1 };
-
-//# sourceMappingURL=deviceLinkingSourceContribution.js.map

package/dist/esm/core/signingEngine/workerManager/ecdsaClientWorkerChannels.js

@@ -1,13 +0,0 @@
-import "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import "../../../shared-ts/src/device-linking/sourceContribution.js";
-//#region src/core/signingEngine/workerManager/ecdsaClientWorkerChannels.ts
-const EcdsaClientWorkerControlKind = {
-	AttachDerivationToPresign: "attach_ecdsa_derivation_to_presign_v1",
-	AttachLinkedHolderToPresign: "attach_linked_holder_to_ecdsa_presign_v1",
-	AttachPresignToOnline: "attach_ecdsa_presign_to_online_v1"
-};
-"A".repeat(43);
-//#endregion
-export { EcdsaClientWorkerControlKind };
-
-//# sourceMappingURL=ecdsaClientWorkerChannels.js.map

package/dist/esm/core/signingEngine/workerManager/ecdsaPresignLifecycle.js

@@ -1,6 +0,0 @@
-//#region src/core/signingEngine/workerManager/ecdsaPresignLifecycle.ts
-const MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS = 2160 * 60 * 6e4;
-//#endregion
-export { MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS };
-
-//# sourceMappingURL=ecdsaPresignLifecycle.js.map