@seams/wallet 0.6.2 → 0.7.1

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

@@ -1,7 +1,9 @@
 import "../../../shared-ts/src/utils/validation.js";
-import "../../../shared-ts/src/device-linking/sourceContribution.js";
+import "../../../shared-ts/src/utils/routerAbPublicKeyset.js";
+import "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
 import "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import "../../../shared-ts/src/signing-lanes/rotationParsers.js";
+import "../../../shared-ts/src/signing-lanes/rotationProtocolParsers.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",

package/dist/esm/react/core/signingEngine/workerManager/workerTransport.js

@@ -32,6 +32,18 @@ const SIGNER_WORKER_KINDS = [
 	"walletCustodyCeremony"
 ];
 const MULTICHAIN_WORKER_DEFAULT_TIMEOUT_MS = 2e4;
+/**
+* A timed-out operation resets its worker, and resetting a presign or
+* derivation worker discards the state other ceremonies hold in it. Name the
+* operation that caused the reset.
+*/
+function warnWorkerOperationTimedOut(kind, type, timeoutMs) {
+	console.warn("[WorkerTransport] operation timed out; resetting worker", {
+		kind,
+		type: String(type),
+		timeoutMs
+	});
+}
 function makeId(prefix) {
 	return secureRandomId(prefix, 32, "signer worker request IDs");
 }
@@ -136,11 +148,11 @@ var WorkerTransport = class {
 		return readiness.promise;
 	}
 	/**
-	* Refactor 94C. Initializes the ECDSA derivation and registration WASM
-	* inside the derivation worker during the authentication prompt, so the
-	* first ceremony call after auth does not pay module init (measured 654 ms
-	* cold vs 88 ms warm on `ecdsaRegistrationClientCreateMs`). Fire-and-forget
-	* safe: failure leaves the lazy init path exactly as it was.
+	* Initializes the ECDSA derivation and registration WASM inside the
+	* derivation worker during the authentication prompt, so the first ceremony
+	* call after auth does not pay module init (measured 654 ms cold vs 88 ms
+	* warm on `ecdsaRegistrationClientCreateMs`). Fire-and-forget safe: failure
+	* leaves the lazy init path exactly as it was.
 	*/
 	async prewarmEcdsaRegistrationCrypto() {
 		const existing = this.ecdsaRegistrationCryptoPrewarmPromise;
@@ -252,6 +264,7 @@ var WorkerTransport = class {
 					code: "TIMEOUT",
 					workerKind: "nearSigner"
 				}));
+				warnWorkerOperationTimedOut("nearSigner", type, timeoutMs);
 				this.resetWorker("nearSigner");
 				try {
 					const seconds = Math.round(timeoutMs / 1e3);
@@ -293,6 +306,7 @@ var WorkerTransport = class {
 					code: "TIMEOUT",
 					workerKind: "ecdsaDerivationClient"
 				}));
+				warnWorkerOperationTimedOut("ecdsaDerivationClient", type, timeoutMs);
 				this.resetWorker("ecdsaDerivationClient");
 			}, timeoutMs);
 			this.getPendingMap("ecdsaDerivationClient").set(requestId, {
@@ -327,6 +341,7 @@ var WorkerTransport = class {
 					code: "TIMEOUT",
 					workerKind: kind
 				}));
+				warnWorkerOperationTimedOut(kind, request.type, timeoutMs);
 				this.resetWorker(kind);
 			}, timeoutMs);
 			this.getPendingMap(kind).set(requestId, {

package/dist/esm/react/core/signingEngine/workerManager/workerTypes.js

@@ -79,11 +79,12 @@ const EcdsaPresignClientResponseType = {
 };
 const EcdsaOnlineClientRequestType = { ComputeSignatureShare: 72e3 };
 const EcdsaOnlineClientResponseType = { ComputeSignatureShareSuccess: 72100 };
+const DEFAULT_SIGNER_HOST_ERROR_CODE = "SIGNER_INTERNAL";
 var SignerWorkerOperationError = class extends Error {
 	constructor(args) {
 		super(args.message);
 		this.name = "SignerWorkerOperationError";
-		this.code = (args.code || "SIGNER_INTERNAL").trim();
+		this.code = (args.code || DEFAULT_SIGNER_HOST_ERROR_CODE).trim();
 		this.coreCode = args.coreCode?.trim() || void 0;
 		this.workerKind = args.workerKind;
 	}

package/dist/esm/react/core/types/linkDevice.js

@@ -16,9 +16,8 @@ let DeviceLinkingErrorCode = /* @__PURE__ */ function(DeviceLinkingErrorCode) {
 	DeviceLinkingErrorCode["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
 	DeviceLinkingErrorCode["REGISTRATION_FAILED"] = "REGISTRATION_FAILED";
 	/**
-	* R103 zero-prompt handoff: Device 1 is not unlocked with the custody
-	* capability linking needs. The QR flow never prompts; the user unlocks the
-	* wallet and scans again.
+	* Device 1 is not unlocked with the custody capability linking needs. The
+	* QR flow never prompts; the user unlocks the wallet and scans again.
 	*/
 	DeviceLinkingErrorCode["WALLET_UNLOCK_REQUIRED"] = "WALLET_UNLOCK_REQUIRED";
 	/**

package/dist/esm/react/core/types/sdkSentEvents.js

@@ -1,6 +1,8 @@
 import { parseLinkedDeviceEnrollmentId, parseWalletId } from "../../shared-ts/src/utils/domainIds.js";
 import { parseWalletSessionId } from "../../shared-ts/src/authorization/capabilityKinds.js";
 import { isWalletAuthMethod } from "../../shared-ts/src/utils/signerDomain.js";
+//#region src/core/types/sdkSentEvents.ts
+const SDK_LIFECYCLE_EVENT_VERSION = 1;
 const SIGNING_SESSION_EXPIRY_DETECTION_SOURCES = {
 	restore: "restore",
 	visibility: "visibility",
@@ -10,7 +12,7 @@ const SIGNING_SESSION_EXPIRY_DETECTION_SOURCES = {
 };
 function createNearProvisioningStateChangedEvent(input) {
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "registration.near_provisioning_changed",
 		walletId: input.walletId,
 		state: input.state
@@ -84,7 +86,7 @@ function createSigningSessionExpiredEvent(input) {
 	if (!isPositiveSafeInteger(input.detectedAtMs)) throw new Error("signing_session.expired detectedAtMs must be a positive safe integer");
 	if (input.expiresAtMs > input.detectedAtMs) throw new Error("signing_session.expired timeline is invalid");
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "signing_session.expired",
 		walletId: input.walletId,
 		walletSessionId: input.walletSessionId,
@@ -96,14 +98,14 @@ function createSigningSessionExpiredEvent(input) {
 }
 function parseSdkLifecycleEvent(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-	if (Reflect.get(value, "version") !== 1) return null;
+	if (Reflect.get(value, "version") !== SDK_LIFECYCLE_EVENT_VERSION) return null;
 	switch (Reflect.get(value, "event")) {
 		case "registration.near_provisioning_changed": {
 			const walletId = parseWalletId(Reflect.get(value, "walletId"));
 			const state = parseNearProvisioningState(Reflect.get(value, "state"));
 			if (!walletId.ok || !state) return null;
 			return {
-				version: 1,
+				version: SDK_LIFECYCLE_EVENT_VERSION,
 				event: "registration.near_provisioning_changed",
 				walletId: walletId.value,
 				state
@@ -126,7 +128,7 @@ function parseSdkLifecycleEvent(value) {
 	const source = parseSigningSessionExpiryDetectionSource(Reflect.get(value, "source"));
 	if (!source) return null;
 	return {
-		version: 1,
+		version: SDK_LIFECYCLE_EVENT_VERSION,
 		event: "signing_session.expired",
 		walletId: walletId.value,
 		walletSessionId: walletSessionId.value,

package/dist/esm/react/hooks/useQRCamera.js

@@ -71,7 +71,7 @@ const useQRCamera = (options) => {
 				setScanDurationMs(0);
 				onError?.(err);
 			},
-			onCameraReady: (stream) => {
+			onCameraReady: () => {
 				console.log("useQRCamera: Camera stream ready");
 			},
 			onScanProgress: (duration) => {

package/dist/esm/react/shared-ts/src/authorization/delegatedAuthority.js

@@ -116,6 +116,6 @@ function invalidAuthorityResult(message) {
 	};
 }
 //#endregion
-export { FULL_OWNER_PERMISSIONS, buildDelegatedWalletAuthorityV1, buildFullOwnerDelegatedWalletAuthorityV1, buildFullOwnerPermissionsV1, delegatedWalletPermissionNamesV1, hasDelegatedWalletPermissionV1, isDelegatedWalletPermissionV1, parseDelegatedWalletAuthorityV1, parseDelegatedWalletPermissionSetV1, sameDelegatedWalletAuthorityV1 };
+export { buildDelegatedWalletAuthorityV1, buildFullOwnerDelegatedWalletAuthorityV1, buildFullOwnerPermissionsV1, delegatedWalletPermissionNamesV1, hasDelegatedWalletPermissionV1, parseDelegatedWalletAuthorityV1, parseDelegatedWalletPermissionSetV1, sameDelegatedWalletAuthorityV1 };
 
 //# sourceMappingURL=delegatedAuthority.js.map

package/dist/esm/react/shared-ts/src/authorization/operationFingerprint.js

@@ -1,7 +1,6 @@
 import { base64UrlEncode } from "../utils/base64.js";
 import { alphabetizeStringify, sha256BytesUtf8 } from "../utils/digests.js";
 import { parseDigestB64u } from "../utils/canonicalPrimitives.js";
-import "./capabilityKinds.js";
 //#region ../shared-ts/src/authorization/operationFingerprint.ts
 const CAPABILITY_OPERATION_FINGERPRINT_DOMAIN_V1 = "seams:authorization:capability-operation-fingerprint:v1";
 var CapabilityOperationEnvelopeProof = class {

package/dist/esm/react/shared-ts/src/authorization/walletAuthority.js

@@ -1,20 +1,24 @@
-import { base64UrlDecode, base64UrlEncode } from "../utils/base64.js";
+import { base64UrlEncode } from "../utils/base64.js";
+import { requireRecord } from "../utils/validation.js";
 import { sha256Bytes } from "../utils/digests.js";
 import { parseLinkDeviceSessionId, parseLinkedDeviceEnrollmentId, parseMpcMaterialActivationRef, parseWalletAuthorityId, parseWalletId, parseWalletRecoveryOperationId } from "../utils/domainIds.js";
 import { parseDigestB64u } from "../utils/canonicalPrimitives.js";
 import { parseDeviceId } from "./capabilityKinds.js";
 import { parseDelegatedWalletPermissionSetV1 } from "./delegatedAuthority.js";
+import { concat, lp32, rawDigest, rawPublicKey, text, u32, u64 } from "../utils/digestEncoding.js";
 import { buildExactAdministeredSignerManifestV1, parseExactAdministeredSignerManifestV1 } from "../device-linking/delegatedActivationPlan.js";
 //#region ../shared-ts/src/authorization/walletAuthority.ts
 const SIGNER_ACTIVATION_SET_DOMAIN = "seams/wallet-signer-activation-set/v1";
 const WALLET_AUTHORITY_DOMAIN = "seams/wallet-authority/v1";
-const TEXT_ENCODER = new TextEncoder();
 function isCombinedWalletSignerActivationSetV1(value) {
 	return isBothFamilyActivationSet(value);
 }
 function isActiveEcdsaWalletAuthorityV1(value) {
 	return isEcdsaOnlyActivationSet(value.signerActivations);
 }
+function isActiveEd25519WalletAuthorityV1(value) {
+	return isEd25519OnlyActivationSet(value.signerActivations);
+}
 function isActiveRecoveredWalletAuthorityV1(value) {
 	return value.provenance.kind === "wallet_recovery";
 }
@@ -145,8 +149,8 @@ function encodeWalletSignerActivationSetV1(value) {
 async function computeWalletSignerActivationSetDigestB64u(value) {
 	return parseDigestB64u(base64UrlEncode(await sha256Bytes(encodeWalletSignerActivationSetV1(value))));
 }
-function buildPendingWalletAuthorityV1(input) {
-	validateWalletAuthorityV1(input);
+/** The fields every lifecycle state carries, copied in record order. */
+function walletAuthorityCommonFields(input) {
 	return {
 		kind: "wallet_authority_v1",
 		authorityId: input.authorityId,
@@ -159,7 +163,13 @@ function buildPendingWalletAuthorityV1(input) {
 		authorityDigestB64u: input.authorityDigestB64u,
 		revocationEpoch: input.revocationEpoch,
 		createdAtMs: input.createdAtMs,
-		updatedAtMs: input.updatedAtMs,
+		updatedAtMs: input.updatedAtMs
+	};
+}
+function buildPendingWalletAuthorityV1(input) {
+	validateWalletAuthorityV1(input);
+	return {
+		...walletAuthorityCommonFields(input),
 		state: "pending_local_install",
 		localInstallPackageSetDigestB64u: input.localInstallPackageSetDigestB64u
 	};
@@ -167,18 +177,7 @@ function buildPendingWalletAuthorityV1(input) {
 function buildActiveWalletAuthorityV1(input) {
 	validateWalletAuthorityV1(input);
 	return {
-		kind: "wallet_authority_v1",
-		authorityId: input.authorityId,
-		walletId: input.walletId,
-		principal: input.principal,
-		provenance: input.provenance,
-		permissions: input.permissions,
-		signerActivations: input.signerActivations,
-		signerActivationSetDigestB64u: input.signerActivationSetDigestB64u,
-		authorityDigestB64u: input.authorityDigestB64u,
-		revocationEpoch: input.revocationEpoch,
-		createdAtMs: input.createdAtMs,
-		updatedAtMs: input.updatedAtMs,
+		...walletAuthorityCommonFields(input),
 		state: "active",
 		activatedAtMs: input.activatedAtMs
 	};
@@ -218,37 +217,14 @@ async function replaceActiveWalletAuthorityEd25519MaterialActivationV1(input) {
 		activatedAtMs: input.authority.activatedAtMs
 	};
 	return buildActiveWalletAuthorityV1({
-		kind: draft.kind,
-		authorityId: draft.authorityId,
-		walletId: draft.walletId,
-		principal: draft.principal,
-		provenance: draft.provenance,
-		permissions: draft.permissions,
-		signerActivations: draft.signerActivations,
-		signerActivationSetDigestB64u: draft.signerActivationSetDigestB64u,
-		authorityDigestB64u: await computeWalletAuthorityDigestB64u(draft),
-		revocationEpoch: draft.revocationEpoch,
-		createdAtMs: draft.createdAtMs,
-		updatedAtMs: draft.updatedAtMs,
-		state: draft.state,
-		activatedAtMs: draft.activatedAtMs
+		...draft,
+		authorityDigestB64u: await computeWalletAuthorityDigestB64u(draft)
 	});
 }
 function buildActiveCombinedWalletAuthorityV1(input) {
 	validateWalletAuthorityV1(input);
 	return {
-		kind: "wallet_authority_v1",
-		authorityId: input.authorityId,
-		walletId: input.walletId,
-		principal: input.principal,
-		provenance: input.provenance,
-		permissions: input.permissions,
-		signerActivations: input.signerActivations,
-		signerActivationSetDigestB64u: input.signerActivationSetDigestB64u,
-		authorityDigestB64u: input.authorityDigestB64u,
-		revocationEpoch: input.revocationEpoch,
-		createdAtMs: input.createdAtMs,
-		updatedAtMs: input.updatedAtMs,
+		...walletAuthorityCommonFields(input),
 		state: "active",
 		activatedAtMs: input.activatedAtMs
 	};
@@ -256,115 +232,58 @@ function buildActiveCombinedWalletAuthorityV1(input) {
 function buildRevokedWalletAuthorityV1(input) {
 	validateWalletAuthorityV1(input);
 	return {
-		kind: "wallet_authority_v1",
-		authorityId: input.authorityId,
-		walletId: input.walletId,
-		principal: input.principal,
-		provenance: input.provenance,
-		permissions: input.permissions,
-		signerActivations: input.signerActivations,
-		signerActivationSetDigestB64u: input.signerActivationSetDigestB64u,
-		authorityDigestB64u: input.authorityDigestB64u,
-		revocationEpoch: input.revocationEpoch,
-		createdAtMs: input.createdAtMs,
-		updatedAtMs: input.updatedAtMs,
+		...walletAuthorityCommonFields(input),
 		state: "revoked",
 		activatedAtMs: input.activatedAtMs,
 		revokedAtMs: input.revokedAtMs
 	};
 }
+/** The record fields every lifecycle state has, in canonical order; each state adds its own. */
+const WALLET_AUTHORITY_FIELDS = [
+	"kind",
+	"authorityId",
+	"walletId",
+	"principal",
+	"provenance",
+	"permissions",
+	"signerActivations",
+	"signerActivationSetDigestB64u",
+	"authorityDigestB64u",
+	"revocationEpoch",
+	"createdAtMs",
+	"updatedAtMs",
+	"state"
+];
 function parseWalletAuthorityV1(raw) {
 	try {
 		const record = requireRecord(raw, "WalletAuthorityV1");
 		const common = parseWalletAuthorityCommon(record);
 		switch (record.state) {
 			case "pending_local_install":
-				exactFields(record, [
-					"kind",
-					"authorityId",
-					"walletId",
-					"principal",
-					"provenance",
-					"permissions",
-					"signerActivations",
-					"signerActivationSetDigestB64u",
-					"authorityDigestB64u",
-					"revocationEpoch",
-					"createdAtMs",
-					"updatedAtMs",
-					"state",
-					"localInstallPackageSetDigestB64u"
-				], "WalletAuthorityV1");
+				exactFields(record, [...WALLET_AUTHORITY_FIELDS, "localInstallPackageSetDigestB64u"], "WalletAuthorityV1");
 				return {
 					ok: true,
 					value: buildPendingWalletAuthorityV1({
 						kind: "wallet_authority_v1",
-						authorityId: common.authorityId,
-						walletId: common.walletId,
-						principal: common.principal,
-						provenance: common.provenance,
-						permissions: common.permissions,
-						signerActivations: common.signerActivations,
-						signerActivationSetDigestB64u: common.signerActivationSetDigestB64u,
-						authorityDigestB64u: common.authorityDigestB64u,
-						revocationEpoch: common.revocationEpoch,
-						createdAtMs: common.createdAtMs,
-						updatedAtMs: common.updatedAtMs,
+						...common,
 						state: "pending_local_install",
 						localInstallPackageSetDigestB64u: parseDigestField(record.localInstallPackageSetDigestB64u, "localInstallPackageSetDigestB64u")
 					})
 				};
 			case "active":
-				exactFields(record, [
-					"kind",
-					"authorityId",
-					"walletId",
-					"principal",
-					"provenance",
-					"permissions",
-					"signerActivations",
-					"signerActivationSetDigestB64u",
-					"authorityDigestB64u",
-					"revocationEpoch",
-					"createdAtMs",
-					"updatedAtMs",
-					"state",
-					"activatedAtMs"
-				], "WalletAuthorityV1");
+				exactFields(record, [...WALLET_AUTHORITY_FIELDS, "activatedAtMs"], "WalletAuthorityV1");
 				return {
 					ok: true,
 					value: buildActiveWalletAuthorityV1({
 						kind: "wallet_authority_v1",
-						authorityId: common.authorityId,
-						walletId: common.walletId,
-						principal: common.principal,
-						provenance: common.provenance,
-						permissions: common.permissions,
-						signerActivations: common.signerActivations,
-						signerActivationSetDigestB64u: common.signerActivationSetDigestB64u,
-						authorityDigestB64u: common.authorityDigestB64u,
-						revocationEpoch: common.revocationEpoch,
-						createdAtMs: common.createdAtMs,
-						updatedAtMs: common.updatedAtMs,
+						...common,
 						state: "active",
 						activatedAtMs: parseSafeInteger(record.activatedAtMs, "activatedAtMs")
 					})
 				};
 			case "revoked":
 				exactFields(record, [
-					"kind",
-					"authorityId",
-					"walletId",
-					"principal",
-					"provenance",
-					"permissions",
-					"signerActivations",
-					"signerActivationSetDigestB64u",
-					"authorityDigestB64u",
-					"revocationEpoch",
-					"createdAtMs",
-					"updatedAtMs",
-					"state",
+					...WALLET_AUTHORITY_FIELDS,
 					"activatedAtMs",
 					"revokedAtMs"
 				], "WalletAuthorityV1");
@@ -372,17 +291,7 @@ function parseWalletAuthorityV1(raw) {
 					ok: true,
 					value: buildRevokedWalletAuthorityV1({
 						kind: "wallet_authority_v1",
-						authorityId: common.authorityId,
-						walletId: common.walletId,
-						principal: common.principal,
-						provenance: common.provenance,
-						permissions: common.permissions,
-						signerActivations: common.signerActivations,
-						signerActivationSetDigestB64u: common.signerActivationSetDigestB64u,
-						authorityDigestB64u: common.authorityDigestB64u,
-						revocationEpoch: common.revocationEpoch,
-						createdAtMs: common.createdAtMs,
-						updatedAtMs: common.updatedAtMs,
+						...common,
 						state: "revoked",
 						activatedAtMs: parseSafeInteger(record.activatedAtMs, "activatedAtMs"),
 						revokedAtMs: parseSafeInteger(record.revokedAtMs, "revokedAtMs")
@@ -415,6 +324,14 @@ async function walletAuthorityDigestsMatchV1(value) {
 	if (await computeWalletSignerActivationSetDigestB64u(value.signerActivations) !== value.signerActivationSetDigestB64u) return false;
 	return await computeWalletAuthorityDigestB64u(value) === value.authorityDigestB64u;
 }
+/**
+* True when both authorities' stored digests verify and agree. The authority digest does not
+* cover the timestamps, so those must agree too.
+*/
+async function sameVerifiedActiveWalletAuthorityV1(left, right) {
+	const [leftVerified, rightVerified] = await Promise.all([walletAuthorityDigestsMatchV1(left), walletAuthorityDigestsMatchV1(right)]);
+	return leftVerified && rightVerified && left.authorityDigestB64u === right.authorityDigestB64u && left.signerActivationSetDigestB64u === right.signerActivationSetDigestB64u && left.createdAtMs === right.createdAtMs && left.updatedAtMs === right.updatedAtMs && left.activatedAtMs === right.activatedAtMs;
+}
 function parseWalletAuthorityCommon(record) {
 	if (record.kind !== "wallet_authority_v1") throw new Error("WalletAuthorityV1.kind is unsupported");
 	const authorityId = requireParsed(parseWalletAuthorityId(record.authorityId), "authorityId");
@@ -563,7 +480,7 @@ function parseEcdsaActivation(raw, label) {
 		materialActivation: requireParsed(parseMpcMaterialActivationRef(record.materialActivation), `${label}.materialActivation`)
 	});
 }
-function parseManifestForSigner(raw, family, label) {
+function parseManifestForSigner(raw, family, _label) {
 	return parseExactAdministeredSignerManifestV1({
 		kind: "exact_administered_signer_manifest_v1",
 		keyFamilies: [family],
@@ -639,10 +556,6 @@ function encodePermissions(value) {
 	for (const permission of value) parts.push(lp32(text(permission, "permissions.item"), "permissions.item"));
 	return concat(parts);
 }
-function requireRecord(value, label) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
 function exactRecord(value, fields, label) {
 	const record = requireRecord(value, label);
 	exactFields(record, fields, label);
@@ -717,59 +630,6 @@ function parseDigestField(raw, label) {
 		throw new Error(`${label} ${errorMessage(error, "is invalid")}`);
 	}
 }
-function rawDigest(value, label) {
-	try {
-		return base64UrlDecode(parseDigestB64u(value));
-	} catch (error) {
-		throw new Error(`${label} ${errorMessage(error, "is invalid")}`);
-	}
-}
-function rawPublicKey(value, label) {
-	try {
-		const decoded = base64UrlDecode(value);
-		if (decoded.length === 0 || base64UrlEncode(decoded) !== value) throw new Error("must be canonical base64url");
-		return decoded;
-	} catch (error) {
-		throw new Error(`${label} ${errorMessage(error, "is invalid")}`);
-	}
-}
-function concat(parts) {
-	let length = 0;
-	for (const part of parts) length += part.length;
-	const output = new Uint8Array(length);
-	let offset = 0;
-	for (const part of parts) {
-		output.set(part, offset);
-		offset += part.length;
-	}
-	return output;
-}
-function u32(value, label) {
-	if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) throw new Error(`${label} must be a non-negative u32`);
-	return Uint8Array.from([
-		value >>> 24 & 255,
-		value >>> 16 & 255,
-		value >>> 8 & 255,
-		value & 255
-	]);
-}
-function u64(value, label) {
-	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label} must be a non-negative safe integer`);
-	let remaining = BigInt(value);
-	const output = new Uint8Array(8);
-	for (let index = 7; index >= 0; index -= 1) {
-		output[index] = Number(remaining & 255n);
-		remaining >>= 8n;
-	}
-	return output;
-}
-function lp32(value, label) {
-	return concat([u32(value.length, `${label}.length`), value]);
-}
-function text(value, label) {
-	if (typeof value !== "string") throw new Error(`${label} must be a string`);
-	return lp32(TEXT_ENCODER.encode(value), label);
-}
 function parseSafeInteger(raw, label) {
 	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < 0) throw new Error(`${label} must be a non-negative safe integer`);
 	return raw;
@@ -796,6 +656,33 @@ function errorMessage(error, fallback) {
 function assertNever(value, label) {
 	throw new Error(`${label} branch is unsupported: ${String(value)}`);
 }
+/**
+* Re-seals an authority around its new combined signer activations. Both digests are
+* recomputed; identity, provenance, permissions and lifecycle stay as they were.
+*/
+async function withCombinedSignerActivations(authority, signerActivations, now) {
+	const signerActivationSetDigestB64u = await computeWalletSignerActivationSetDigestB64u(signerActivations);
+	const draft = {
+		kind: "wallet_authority_v1",
+		authorityId: authority.authorityId,
+		walletId: authority.walletId,
+		principal: authority.principal,
+		provenance: authority.provenance,
+		permissions: authority.permissions,
+		signerActivations,
+		signerActivationSetDigestB64u,
+		authorityDigestB64u: authority.authorityDigestB64u,
+		revocationEpoch: authority.revocationEpoch,
+		createdAtMs: authority.createdAtMs,
+		updatedAtMs: Math.max(authority.updatedAtMs, now),
+		state: "active",
+		activatedAtMs: authority.activatedAtMs
+	};
+	return buildActiveCombinedWalletAuthorityV1({
+		...draft,
+		authorityDigestB64u: await computeWalletAuthorityDigestB64u(draft)
+	});
+}
 async function extendEcdsaWalletAuthorityWithEd25519(input) {
 	if (input.ed25519.signer.walletId !== input.authority.walletId) throw new Error("NEAR signer belongs to a different wallet authority");
 	const existingEcdsa = input.authority.signerActivations.ecdsa;
@@ -809,46 +696,24 @@ async function extendEcdsaWalletAuthorityWithEd25519(input) {
 		}
 	});
 	if (!isCombinedWalletSignerActivationSetV1(signerActivationsCandidate)) throw new Error("Deferred Ed25519 activation did not produce a combined signer activation set");
-	const signerActivations = signerActivationsCandidate;
-	const signerActivationSetDigestB64u = await computeWalletSignerActivationSetDigestB64u(signerActivations);
-	const draft = {
-		kind: "wallet_authority_v1",
-		authorityId: input.authority.authorityId,
-		walletId: input.authority.walletId,
-		principal: input.authority.principal,
-		provenance: input.authority.provenance,
-		permissions: input.authority.permissions,
-		signerActivations,
-		signerActivationSetDigestB64u,
-		authorityDigestB64u: input.authority.authorityDigestB64u,
-		revocationEpoch: input.authority.revocationEpoch,
-		createdAtMs: input.authority.createdAtMs,
-		updatedAtMs: Math.max(input.authority.updatedAtMs, input.now),
-		state: "active",
-		activatedAtMs: input.authority.activatedAtMs
-	};
-	return buildActiveCombinedWalletAuthorityV1({
-		kind: draft.kind,
-		authorityId: draft.authorityId,
-		walletId: draft.walletId,
-		principal: draft.principal,
-		provenance: draft.provenance,
-		permissions: draft.permissions,
-		signerActivations: draft.signerActivations,
-		signerActivationSetDigestB64u: draft.signerActivationSetDigestB64u,
-		authorityDigestB64u: await computeWalletAuthorityDigestB64u(draft),
-		revocationEpoch: draft.revocationEpoch,
-		createdAtMs: draft.createdAtMs,
-		updatedAtMs: draft.updatedAtMs,
-		state: draft.state,
-		activatedAtMs: draft.activatedAtMs
-	});
+	return withCombinedSignerActivations(input.authority, signerActivationsCandidate, input.now);
+}
+/** `next` keeps everything of `previous` that an added signer must not change. */
+function keepsWalletAuthorityApartFromSigners(previous, next) {
+	return previous.authorityId === next.authorityId && previous.walletId === next.walletId && previous.revocationEpoch === next.revocationEpoch && previous.createdAtMs === next.createdAtMs && previous.activatedAtMs === next.activatedAtMs && base64UrlEncode(encodePrincipal(previous.principal)) === base64UrlEncode(encodePrincipal(next.principal)) && base64UrlEncode(encodeProvenance(previous.provenance)) === base64UrlEncode(encodeProvenance(next.provenance)) && base64UrlEncode(encodePermissions(previous.permissions)) === base64UrlEncode(encodePermissions(next.permissions));
+}
+/**
+* Whether `next` is `previous` with an added ECDSA signer and nothing else
+* changed. Both projections have already passed digest validation.
+*/
+function isEcdsaExtensionOfEd25519WalletAuthority(previous, next) {
+	return isActiveEd25519WalletAuthorityV1(previous) && isCombinedWalletSignerActivationSetV1(next.signerActivations) && keepsWalletAuthorityApartFromSigners(previous, next) && base64UrlEncode(encodeEd25519Activation(previous.signerActivations.ed25519)) === base64UrlEncode(encodeEd25519Activation(next.signerActivations.ed25519));
 }
 /** Both projections have already passed digest validation at their boundaries. */
 function isEd25519ExtensionOfEcdsaWalletAuthority(previous, next) {
-	return isActiveEcdsaWalletAuthorityV1(previous) && isCombinedWalletSignerActivationSetV1(next.signerActivations) && previous.provenance.kind === "wallet_registration" && previous.authorityId === next.authorityId && previous.walletId === next.walletId && previous.revocationEpoch === next.revocationEpoch && previous.createdAtMs === next.createdAtMs && previous.activatedAtMs === next.activatedAtMs && base64UrlEncode(encodePrincipal(previous.principal)) === base64UrlEncode(encodePrincipal(next.principal)) && base64UrlEncode(encodeProvenance(previous.provenance)) === base64UrlEncode(encodeProvenance(next.provenance)) && base64UrlEncode(encodePermissions(previous.permissions)) === base64UrlEncode(encodePermissions(next.permissions)) && base64UrlEncode(encodeEcdsaActivation(previous.signerActivations.ecdsa)) === base64UrlEncode(encodeEcdsaActivation(next.signerActivations.ecdsa));
+	return isActiveEcdsaWalletAuthorityV1(previous) && isCombinedWalletSignerActivationSetV1(next.signerActivations) && previous.provenance.kind === "wallet_registration" && keepsWalletAuthorityApartFromSigners(previous, next) && base64UrlEncode(encodeEcdsaActivation(previous.signerActivations.ecdsa)) === base64UrlEncode(encodeEcdsaActivation(next.signerActivations.ecdsa));
 }
 //#endregion
-export { buildActiveCombinedWalletAuthorityV1, buildActiveWalletAuthorityV1, buildPendingWalletAuthorityV1, buildRevokedWalletAuthorityV1, buildWalletEcdsaSignerActivationV1, buildWalletEd25519SignerActivationV1, buildWalletSignerActivationSetV1, computeWalletAuthorityDigestB64u, computeWalletSignerActivationSetDigestB64u, encodeWalletAuthorityV1, encodeWalletSignerActivationSetV1, extendEcdsaWalletAuthorityWithEd25519, isActiveEcdsaWalletAuthorityV1, isActiveRecoveredWalletAuthorityV1, isCombinedWalletSignerActivationSetV1, isEd25519ExtensionOfEcdsaWalletAuthority, parseWalletAuthorityV1, parseWalletSignerActivationSetV1, replaceActiveWalletAuthorityEd25519MaterialActivationV1, walletAuthorityDigestsMatchV1 };
+export { buildActiveCombinedWalletAuthorityV1, buildActiveWalletAuthorityV1, buildPendingWalletAuthorityV1, buildRevokedWalletAuthorityV1, buildWalletEcdsaSignerActivationV1, buildWalletSignerActivationSetV1, computeWalletAuthorityDigestB64u, computeWalletSignerActivationSetDigestB64u, encodeWalletSignerActivationSetV1, extendEcdsaWalletAuthorityWithEd25519, isActiveEcdsaWalletAuthorityV1, isActiveEd25519WalletAuthorityV1, isActiveRecoveredWalletAuthorityV1, isCombinedWalletSignerActivationSetV1, isEcdsaExtensionOfEd25519WalletAuthority, isEd25519ExtensionOfEcdsaWalletAuthority, parseWalletAuthorityV1, parseWalletSignerActivationSetV1, replaceActiveWalletAuthorityEd25519MaterialActivationV1, sameVerifiedActiveWalletAuthorityV1, walletAuthorityDigestsMatchV1 };
 
 //# sourceMappingURL=walletAuthority.js.map

package/dist/esm/react/shared-ts/src/authorization/walletCustodyOperation.js

@@ -1,16 +1,14 @@
-import { base64UrlEncode } from "../utils/base64.js";
-import { alphabetizeStringify, sha256BytesUtf8 } from "../utils/digests.js";
-import "../utils/encoders.js";
-import { parseDigestB64u } from "../utils/canonicalPrimitives.js";
+import { alphabetizeStringify } from "../utils/digests.js";
+import { sha256Utf8DigestB64u } from "../utils/canonicalPrimitives.js";
 //#region ../shared-ts/src/authorization/walletCustodyOperation.ts
 /** Public challenge digest for a single wallet-administration factor proof. */
 async function computeWalletCustodyAdminChallengeDigest(input) {
-	return parseDigestB64u(base64UrlEncode(await sha256BytesUtf8(`seams:wallet-custody:challenge:v1|${alphabetizeStringify({
+	return sha256Utf8DigestB64u(`seams:wallet-custody:challenge:v1|${alphabetizeStringify({
 		walletId: input.walletId,
 		operation: input.operation,
 		payload: input.payload,
 		requestOrigin: input.requestOrigin
-	})}`)));
+	})}`);
 }
 //#endregion
 export { computeWalletCustodyAdminChallengeDigest };