@seams/wallet 0.6.2 → 0.7.3

package/dist/{public/sdk/accountLifecycle-Ddavc_FC.js → esm/sdk/accountLifecycle-zthG08aC.js}

@@ -1,13 +1,15 @@
-import { c as normalizeTrimmedString } from "./normalize-BephcEIF.js";
-import { C as base58Encode, p as compactImplicitNearAccountId } from "./validation-BphUDXs7.js";
+import { B as normalizeTrimmedString } from "./domainIds-lcrFg6Sa.js";
+import { M as base58Encode, S as compactImplicitNearAccountId, t as asRecord } from "./validation-gat4LEKm.js";
 import { i as base64UrlEncode, r as base64UrlDecode } from "./base64-Clm8C-e9.js";
-import { N as sha256HexUtf8, m as nearEd25519SigningKeyIdFromString, t as NEAR_ED25519_YAO_KEY_VERSION_V1 } from "./registrationIntent-DwAIMQYh.js";
-import { c as toWalletId, o as thresholdEcdsaChainTargetKey } from "./ecdsaChainTarget-BOTPGIU_.js";
-import { i as SIGNER_SOURCES, n as SIGNER_AUTH_METHODS, r as SIGNER_KINDS } from "./signerDomain-DDLiwuYS.js";
-import { a as toIndexedDbChainTargetKey, t as normalizeIndexedDbAccountAddress } from "./normalization-oJyXl3Vn.js";
-import { t as toAccountId } from "./accountIds-Ck4GAQfm.js";
-import { t as parseSignerSlot } from "./signerSlot-DbNAs-kc.js";
-import { a as getNearChainCandidates, i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates, o as inferNearChainIdKey, r as resolveProfileAccountProjection, t as getLastSelectedProfileAccountByChain } from "./profileAccountProjection-C9rVhbeJ.js";
+import { h as sha256HexUtf8 } from "./chains-BMh3btVo.js";
+import { c as toWalletId, o as thresholdEcdsaChainTargetKey } from "./ecdsaChainTarget-Bl-JWyuw.js";
+import { i as SIGNER_SOURCES, n as SIGNER_AUTH_METHODS, r as SIGNER_KINDS } from "./signerDomain-IEAVrOrc.js";
+import { a as toIndexedDbChainTargetKey, t as normalizeIndexedDbAccountAddress } from "./normalization-CBt413-z.js";
+import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
+import { i as nearEd25519SigningKeyIdFromString } from "./registrationIds-DLSdEKSv.js";
+import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
+import { t as NEAR_ED25519_YAO_KEY_VERSION_V1 } from "./registrationSignerPlan-DhV8VAob.js";
+import { a as getNearChainCandidates, i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates, o as inferNearChainIdKey, r as resolveProfileAccountProjection, t as getLastSelectedProfileAccountByChain } from "./profileAccountProjection-uZVJuBvS.js";
 //#region src/core/accountData/near/profileId.ts
 const NEAR_PROFILE_PREFIX = "near-profile";
 function parseNearAccountProjectionProfileId(raw) {
@@ -30,10 +32,6 @@ function buildNearProfileId(accountId) {
 }
 //#endregion
 //#region src/core/indexedDB/keyMaterialEnvelope.ts
-function asRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	return value;
-}
 function sanitizePayload(value) {
 	const record = asRecord(value);
 	if (!record) return void 0;
@@ -264,6 +262,14 @@ function buildWalletCustodyEd25519MaterialRecordV1(input) {
 const WALLET_SUBJECT_CHAIN_ID_KEY = "wallet";
 const WALLET_SUBJECT_ACCOUNT_MODEL = "wallet";
 const THRESHOLD_ECDSA_ACCOUNT_MODEL = "threshold-ecdsa";
+const PASSKEY_REGISTRATION_SIGNER_SOURCE = {
+	signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
+	signerSource: SIGNER_SOURCES.passkeyRegistration
+};
+const EMAIL_OTP_REGISTRATION_SIGNER_SOURCE = {
+	signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
+	signerSource: SIGNER_SOURCES.emailOtpRegistration
+};
 function verifiedCredentialPublicKeyBytes(value, field) {
 	const credentialPublicKeyB64u = String(value || "").trim();
 	if (!credentialPublicKeyB64u) throw new Error(`SeamsWalletDB: ${field} is required`);
@@ -471,9 +477,8 @@ async function getWalletNearProvisioningState(deps, walletId) {
 	return (await deps.accountStore.getProfile(String(walletId)))?.nearProvisioning ?? null;
 }
 /**
-* Refactor 94 Phase 6. Writes the wallet root profile's NEAR provisioning
-* state. The durable record is authoritative, so this is the write every
-* publish is sequenced behind.
+* Writes the wallet root profile's NEAR provisioning state. The durable record
+* is authoritative, so this is the write every publish is sequenced behind.
 */
 async function setWalletNearProvisioningState(deps, write) {
 	const profileId = String(write.walletId || "").trim();
@@ -643,6 +648,97 @@ function walletEcdsaSignerActivationPolicy(args) {
 		};
 	}
 }
+function requireWalletEd25519SignerIdentity(args) {
+	const signerSlot = Number(args.signerSlot);
+	if (!Number.isSafeInteger(signerSlot) || signerSlot < 1) throw new Error("SeamsWalletDB: wallet signerSlot must be an integer >= 1");
+	const walletId = String(args.walletId || "").trim();
+	if (!walletId) throw new Error("SeamsWalletDB: walletId is required");
+	const nearAccountId = toAccountId(args.nearAccountId);
+	const nearEd25519SigningKeyId = String(args.nearEd25519SigningKeyId || "").trim();
+	if (!nearEd25519SigningKeyId) throw new Error("SeamsWalletDB: nearEd25519SigningKeyId is required");
+	return {
+		signerSlot,
+		walletId,
+		nearAccountId,
+		nearEd25519SigningKeyId
+	};
+}
+/** The metadata an Ed25519 signer records; `authFields` name the credential that owns it. */
+function walletEd25519SignerMetadata(identity, args, authFields) {
+	return {
+		walletId: identity.walletId,
+		nearAccountId: String(identity.nearAccountId),
+		nearEd25519SigningKeyId: identity.nearEd25519SigningKeyId,
+		operationalPublicKey: args.operationalPublicKey,
+		relayerKeyId: args.relayerKeyId,
+		keyVersion: args.keyVersion,
+		...authFields,
+		...args.participantIds ? { participantIds: args.participantIds } : {},
+		...args.clientParticipantId != null ? { clientParticipantId: args.clientParticipantId } : {},
+		...args.relayerParticipantId != null ? { relayerParticipantId: args.relayerParticipantId } : {}
+	};
+}
+/** One Ed25519 signer, activated on the wallet subject and on its NEAR account. */
+function walletEd25519SignerActivations(args) {
+	const signerId = requireStoreWalletString(args.operationalPublicKey, "Ed25519 signerId");
+	const { signerSlot, walletId, nearAccountId } = args.identity;
+	const activation = (account) => ({
+		input: {
+			account,
+			signer: {
+				signerId,
+				signerType: "threshold",
+				signerKind: SIGNER_KINDS.thresholdEd25519,
+				signerAuthMethod: args.source.signerAuthMethod,
+				signerSource: args.source.signerSource,
+				metadata: args.metadata
+			},
+			activationPolicy: args.activationPolicy,
+			preferredSlot: signerSlot,
+			mutation: { routeThroughOutbox: false }
+		},
+		signerSlot
+	});
+	return [activation({
+		profileId: walletId,
+		chainIdKey: WALLET_SUBJECT_CHAIN_ID_KEY,
+		accountAddress: walletId,
+		accountModel: WALLET_SUBJECT_ACCOUNT_MODEL
+	}), activation({
+		profileId: args.nearProfileId,
+		chainIdKey: inferNearChainIdKey(nearAccountId),
+		accountAddress: normalizeIndexedDbAccountAddress(nearAccountId),
+		accountModel: "near-native"
+	})];
+}
+/** Each activation's input and its key material, all stamped with one timestamp. */
+function signerActivationRecords(activations) {
+	const signerActivations = activations.map((activation) => activation.input);
+	const keyMaterialTimestamp = Date.now();
+	return {
+		signerActivations,
+		keyMaterials: activations.map((activation) => keyMaterialForSignerActivation({
+			activation: activation.input,
+			signerSlot: activation.signerSlot,
+			timestamp: keyMaterialTimestamp
+		}))
+	};
+}
+/** The ECDSA signers a registration's composition adds after its two Ed25519 activations. */
+function walletRegistrationEcdsaActivations(walletId, composition, source, mode) {
+	return composition.kind === "near_ed25519_and_evm_family_ecdsa" ? prepareWalletEcdsaSignerActivations({
+		walletId,
+		walletKeys: composition.walletKeys
+	}, source, mode).signerActivations : [];
+}
+function storedWalletEcdsaSigner(activation, stored) {
+	return {
+		chainTarget: activation.chainTarget,
+		targetKey: activation.targetKey,
+		signerSlot: stored.signerSlot,
+		signerId: activation.signerId
+	};
+}
 function prepareWalletEd25519RegistrationBatch(args, mode, composition) {
 	const credentialId = String(args.credential.rawId || "").trim();
 	if (!credentialId) throw new Error("SeamsWalletDB: registration credential rawId is required");
@@ -669,127 +765,42 @@ function prepareWalletEd25519RegistrationBatch(args, mode, composition) {
 }
 function prepareWalletEd25519RegistrationBatchFromFacts(args, mode, composition) {
 	const credentialId = args.credentialFacts.credentialId;
-	const signerSlot = Number(args.signerSlot);
-	if (!Number.isSafeInteger(signerSlot) || signerSlot < 1) throw new Error("SeamsWalletDB: wallet signerSlot must be an integer >= 1");
-	const walletId = String(args.walletId || "").trim();
-	if (!walletId) throw new Error("SeamsWalletDB: walletId is required");
-	const nearAccountId = toAccountId(args.nearAccountId);
-	const nearEd25519SigningKeyId = String(args.nearEd25519SigningKeyId || "").trim();
-	if (!nearEd25519SigningKeyId) throw new Error("SeamsWalletDB: nearEd25519SigningKeyId is required");
+	const identity = requireWalletEd25519SignerIdentity(args);
+	const { signerSlot, walletId, nearAccountId } = identity;
 	const passkeyCredential = {
 		id: args.credentialFacts.credentialDisplayId,
 		rawId: credentialId
 	};
 	const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-	const signerMetadata = {
-		walletId,
-		nearAccountId: String(nearAccountId),
-		nearEd25519SigningKeyId,
-		operationalPublicKey: args.operationalPublicKey,
-		relayerKeyId: args.relayerKeyId,
-		keyVersion: args.keyVersion,
-		passkeyCredentialId: args.credentialFacts.credentialDisplayId,
-		passkeyCredentialRawId: credentialId,
-		...args.participantIds ? { participantIds: args.participantIds } : {},
-		...args.clientParticipantId != null ? { clientParticipantId: args.clientParticipantId } : {},
-		...args.relayerParticipantId != null ? { relayerParticipantId: args.relayerParticipantId } : {}
-	};
 	const nearProfileId = buildNearProfileId(nearAccountId);
-	const chainIdKey = inferNearChainIdKey(nearAccountId);
-	const accountAddress = normalizeIndexedDbAccountAddress(nearAccountId);
-	const ed25519SignerId = requireStoreWalletString(args.operationalPublicKey, "Ed25519 signerId");
-	const activationPolicy = walletEd25519RegistrationActivationPolicy({
-		mode,
-		signerSlot
-	});
-	const walletActivation = {
-		account: {
-			profileId: walletId,
-			chainIdKey: WALLET_SUBJECT_CHAIN_ID_KEY,
-			accountAddress: walletId,
-			accountModel: WALLET_SUBJECT_ACCOUNT_MODEL
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-			signerSource: SIGNER_SOURCES.passkeyRegistration,
-			metadata: signerMetadata
-		},
-		activationPolicy,
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const nearActivation = {
-		account: {
-			profileId: nearProfileId,
-			chainIdKey,
-			accountAddress,
-			accountModel: "near-native"
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-			signerSource: SIGNER_SOURCES.passkeyRegistration,
-			metadata: signerMetadata
-		},
-		activationPolicy,
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const preparedEcdsa = composition.kind === "near_ed25519_and_evm_family_ecdsa" ? prepareWalletEcdsaSignerActivations({
-		walletId: args.walletId,
-		walletKeys: composition.walletKeys
-	}, void 0, { kind: mode.kind === "wallet_recovery_replacement" ? "wallet_recovery_replacement" : "fresh_registration" }) : null;
-	const signerActivations = [walletActivation, nearActivation];
-	if (preparedEcdsa) for (const activation of preparedEcdsa.signerActivations) signerActivations.push(activation.input);
-	const keyMaterialTimestamp = Date.now();
-	const keyMaterials = [];
-	keyMaterials.push(keyMaterialForSignerActivation({
-		activation: walletActivation,
-		signerSlot,
-		timestamp: keyMaterialTimestamp
-	}));
-	keyMaterials.push(keyMaterialForSignerActivation({
-		activation: nearActivation,
-		signerSlot,
-		timestamp: keyMaterialTimestamp
-	}));
-	if (preparedEcdsa) for (const activation of preparedEcdsa.signerActivations) keyMaterials.push(keyMaterialForSignerActivation({
-		activation: activation.input,
-		signerSlot: activation.signerSlot,
-		timestamp: keyMaterialTimestamp
-	}));
+	const { signerActivations, keyMaterials } = signerActivationRecords([...walletEd25519SignerActivations({
+		identity,
+		nearProfileId,
+		operationalPublicKey: args.operationalPublicKey,
+		source: PASSKEY_REGISTRATION_SIGNER_SOURCE,
+		metadata: walletEd25519SignerMetadata(identity, args, {
+			passkeyCredentialId: args.credentialFacts.credentialDisplayId,
+			passkeyCredentialRawId: credentialId
+		}),
+		activationPolicy: walletEd25519RegistrationActivationPolicy({
+			mode,
+			signerSlot
+		})
+	}), ...walletRegistrationEcdsaActivations(args.walletId, composition, PASSKEY_REGISTRATION_SIGNER_SOURCE, mode)]);
 	return {
-		profiles: [{
-			profileId: walletId,
-			defaultSignerSlot: signerSlot,
-			passkeyCredential
-		}, {
-			profileId: nearProfileId,
+		profiles: [walletId, nearProfileId].map((profileId) => ({
+			profileId,
 			defaultSignerSlot: signerSlot,
 			passkeyCredential
-		}],
+		})),
 		initialAuthMethod: passkeyAuthMethod({
 			walletId: args.walletId,
 			rpId: args.rpId,
 			credentialId,
 			credentialPublicKey: args.credentialFacts.credentialPublicKey
 		}),
-		authenticators: [{
-			profileId: walletId,
-			signerSlot,
-			credentialId,
-			credentialPublicKey: args.credentialFacts.credentialPublicKey,
-			transports: [...args.credentialFacts.transports],
-			name: `Passkey for ${extractUsername(nearAccountId)}`,
-			registered: nowIso,
-			syncedAt: nowIso
-		}, {
-			profileId: nearProfileId,
+		authenticators: [walletId, nearProfileId].map((profileId) => ({
+			profileId,
 			signerSlot,
 			credentialId,
 			credentialPublicKey: args.credentialFacts.credentialPublicKey,
@@ -797,7 +808,7 @@ function prepareWalletEd25519RegistrationBatchFromFacts(args, mode, composition)
 			name: `Passkey for ${extractUsername(nearAccountId)}`,
 			registered: nowIso,
 			syncedAt: nowIso
-		}],
+		})),
 		signerActivations,
 		keyMaterials,
 		lastProfileState: {
@@ -806,20 +817,15 @@ function prepareWalletEd25519RegistrationBatchFromFacts(args, mode, composition)
 		}
 	};
 }
-function storedRegistrationResult(result, preparedEcdsa) {
+function storedRegistrationResult(result, ecdsaActivations) {
 	const storedNearActivation = result.signerActivations[1];
 	if (!storedNearActivation) throw new Error("SeamsWalletDB: wallet Ed25519 registration batch did not complete");
 	const storedSigners = [];
-	if (preparedEcdsa) for (let index = 0; index < preparedEcdsa.signerActivations.length; index += 1) {
-		const activation = preparedEcdsa.signerActivations[index];
+	for (let index = 0; index < ecdsaActivations.length; index += 1) {
+		const activation = ecdsaActivations[index];
 		const stored = result.signerActivations[index + 2];
 		if (!activation || !stored) throw new Error("SeamsWalletDB: mixed wallet ECDSA registration batch did not complete");
-		storedSigners.push({
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: stored.signerSlot,
-			signerId: activation.signerId
-		});
+		storedSigners.push(storedWalletEcdsaSigner(activation, stored));
 	}
 	return {
 		signerSlot: storedNearActivation.signerSlot,
@@ -827,50 +833,34 @@ function storedRegistrationResult(result, preparedEcdsa) {
 	};
 }
 function prepareWalletEd25519RegistrationPublication(args) {
-	return buildWalletEd25519RegistrationPublication({
-		prepared: prepareWalletEd25519RegistrationBatch(args, { kind: "fresh_registration" }, { kind: "near_ed25519_only" }),
-		walletId: args.walletId,
-		nearAccountId: args.nearAccountId,
-		nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
-		signerSlot: args.signerSlot,
-		participantIds: args.participantIds,
-		custodyMaterials: [args.custodyMaterial]
-	});
+	return buildWalletEd25519RegistrationPublication(prepareWalletEd25519RegistrationBatch(args, { kind: "fresh_registration" }, { kind: "near_ed25519_only" }), args, args.participantIds, [args.custodyMaterial]);
 }
 function prepareWalletEd25519RegistrationProjectionPublication(args) {
 	const credentialId = String(args.credentialIdB64u || "").trim();
 	if (!credentialId) throw new Error("SeamsWalletDB: registration credential projection id is required");
-	return buildWalletEd25519RegistrationPublication({
-		prepared: prepareWalletEd25519RegistrationBatchFromFacts({
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
-			rpId: args.rpId,
-			signerSlot: args.signerSlot,
-			operationalPublicKey: args.operationalPublicKey,
-			relayerKeyId: args.relayerKeyId,
-			keyVersion: args.keyVersion,
-			participantIds: args.participantIds,
-			credentialFacts: {
-				credentialId,
-				credentialDisplayId: credentialId,
-				credentialPublicKey: verifiedCredentialPublicKeyBytes(args.credentialPublicKeyB64u, "credentialPublicKeyB64u"),
-				transports: [...args.transports]
-			}
-		}, { kind: "fresh_registration" }, { kind: "near_ed25519_only" }),
+	return buildWalletEd25519RegistrationPublication(prepareWalletEd25519RegistrationBatchFromFacts({
 		walletId: args.walletId,
 		nearAccountId: args.nearAccountId,
 		nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
+		rpId: args.rpId,
 		signerSlot: args.signerSlot,
+		operationalPublicKey: args.operationalPublicKey,
+		relayerKeyId: args.relayerKeyId,
+		keyVersion: args.keyVersion,
 		participantIds: args.participantIds,
-		custodyMaterials: [args.custodyMaterial]
-	});
+		credentialFacts: {
+			credentialId,
+			credentialDisplayId: credentialId,
+			credentialPublicKey: verifiedCredentialPublicKeyBytes(args.credentialPublicKeyB64u, "credentialPublicKeyB64u"),
+			transports: [...args.transports]
+		}
+	}, { kind: "fresh_registration" }, { kind: "near_ed25519_only" }), args, args.participantIds, [args.custodyMaterial]);
 }
-function buildWalletEd25519RegistrationPublication(args) {
-	const nearAccountId = toAccountId(args.nearAccountId);
-	const custodyMaterials = args.custodyMaterials.map((material) => {
+function buildWalletEd25519RegistrationPublication(prepared, identity, participantIds, materials) {
+	const nearAccountId = toAccountId(identity.nearAccountId);
+	const custodyMaterials = materials.map((material) => {
 		const binding = material.binding;
-		if (binding.walletId !== String(args.walletId) || binding.nearAccountId !== String(nearAccountId) || binding.nearEd25519SigningKeyId !== String(args.nearEd25519SigningKeyId) || binding.signerSlot !== Number(args.signerSlot) || binding.participantIds[0] !== args.participantIds[0] || binding.participantIds[1] !== args.participantIds[1]) throw new Error("Wallet custody Ed25519 material does not match registration identity");
+		if (binding.walletId !== String(identity.walletId) || binding.nearAccountId !== String(nearAccountId) || binding.nearEd25519SigningKeyId !== String(identity.nearEd25519SigningKeyId) || binding.signerSlot !== Number(identity.signerSlot) || binding.participantIds[0] !== participantIds[0] || binding.participantIds[1] !== participantIds[1]) throw new Error("Wallet custody Ed25519 material does not match registration identity");
 		return buildWalletCustodyEd25519MaterialRecordV1({
 			target: {
 				profileId: String(buildNearProfileId(nearAccountId)),
@@ -881,14 +871,14 @@ function buildWalletEd25519RegistrationPublication(args) {
 			sealed: material.sealed
 		});
 	});
-	const lastProfileState = args.prepared.lastProfileState;
+	const lastProfileState = prepared.lastProfileState;
 	if (!lastProfileState) throw new Error("Wallet Ed25519 registration publication requires last profile state");
 	return {
-		profiles: args.prepared.profiles,
-		initialAuthMethod: args.prepared.initialAuthMethod,
-		authenticators: args.prepared.authenticators,
-		signerActivations: args.prepared.signerActivations,
-		keyMaterials: [...args.prepared.keyMaterials, ...custodyMaterials],
+		profiles: prepared.profiles,
+		initialAuthMethod: prepared.initialAuthMethod,
+		authenticators: prepared.authenticators,
+		signerActivations: prepared.signerActivations,
+		keyMaterials: [...prepared.keyMaterials, ...custodyMaterials],
 		lastProfileState: {
 			profileId: lastProfileState.profileId,
 			activeSignerSlot: lastProfileState.activeSignerSlot,
@@ -903,14 +893,8 @@ function requireNonEmptyWalletEcdsaKeys(walletKeys) {
 }
 function walletEcdsaRegistrationSignerSource(kind) {
 	switch (kind) {
-		case "email_otp": return {
-			signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-			signerSource: SIGNER_SOURCES.emailOtpRegistration
-		};
-		case "passkey": return {
-			signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-			signerSource: SIGNER_SOURCES.passkeyRegistration
-		};
+		case "email_otp": return EMAIL_OTP_REGISTRATION_SIGNER_SOURCE;
+		case "passkey": return PASSKEY_REGISTRATION_SIGNER_SOURCE;
 		default: return assertNeverWalletEcdsaRegistrationKind(kind);
 	}
 }
@@ -918,17 +902,10 @@ function assertNeverWalletEcdsaRegistrationKind(value) {
 	throw new Error(`Unsupported wallet ECDSA registration kind: ${String(value)}`);
 }
 async function prepareWalletEcdsaRegistrationPublicationWithMode(args, mode) {
-	const preparedEcdsa = prepareWalletEcdsaSignerActivations({
+	const { signerActivations, keyMaterials } = signerActivationRecords(prepareWalletEcdsaSignerActivations({
 		walletId: args.walletId,
 		walletKeys: args.walletKeys
-	}, walletEcdsaRegistrationSignerSource(args.kind), mode);
-	const signerActivations = preparedEcdsa.signerActivations.map((activation) => activation.input);
-	const keyMaterialTimestamp = Date.now();
-	const keyMaterials = preparedEcdsa.signerActivations.map((activation) => keyMaterialForSignerActivation({
-		activation: activation.input,
-		signerSlot: activation.signerSlot,
-		timestamp: keyMaterialTimestamp
-	}));
+	}, walletEcdsaRegistrationSignerSource(args.kind), mode).signerActivations);
 	switch (args.kind) {
 		case "passkey": {
 			const credentialId = requireStoreWalletString(args.credentialIdB64u, "credentialIdB64u");
@@ -995,34 +972,26 @@ function prepareWalletEcdsaRegistrationPublication(args) {
 }
 async function prepareWalletRecoveryPasskeyPublication(args) {
 	const credentialId = requireStoreWalletString(args.credentialIdB64u, "credentialIdB64u");
-	if (args.kind === "near_ed25519") return buildWalletEd25519RegistrationPublication({
-		prepared: prepareWalletEd25519RegistrationBatchFromFacts({
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
-			rpId: args.rpId,
-			signerSlot: args.signerSlot,
-			operationalPublicKey: args.operationalPublicKey,
-			relayerKeyId: args.relayerKeyId,
-			keyVersion: NEAR_ED25519_YAO_KEY_VERSION_V1,
-			participantIds: normalizeEd25519ParticipantIds(args.participantIds),
-			credentialFacts: {
-				credentialId,
-				credentialDisplayId: credentialId,
-				credentialPublicKey: verifiedCredentialPublicKeyBytes(args.credentialPublicKeyB64u, "credentialPublicKeyB64u"),
-				transports: args.transports
-			}
-		}, { kind: "wallet_recovery_replacement" }, args.walletKeys.length > 0 ? {
-			kind: "near_ed25519_and_evm_family_ecdsa",
-			walletKeys: args.walletKeys
-		} : { kind: "near_ed25519_only" }),
+	if (args.kind === "near_ed25519") return buildWalletEd25519RegistrationPublication(prepareWalletEd25519RegistrationBatchFromFacts({
 		walletId: args.walletId,
 		nearAccountId: args.nearAccountId,
 		nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
+		rpId: args.rpId,
 		signerSlot: args.signerSlot,
+		operationalPublicKey: args.operationalPublicKey,
+		relayerKeyId: args.relayerKeyId,
+		keyVersion: NEAR_ED25519_YAO_KEY_VERSION_V1,
 		participantIds: normalizeEd25519ParticipantIds(args.participantIds),
-		custodyMaterials: args.custodyMaterials
-	});
+		credentialFacts: {
+			credentialId,
+			credentialDisplayId: credentialId,
+			credentialPublicKey: verifiedCredentialPublicKeyBytes(args.credentialPublicKeyB64u, "credentialPublicKeyB64u"),
+			transports: args.transports
+		}
+	}, { kind: "wallet_recovery_replacement" }, args.walletKeys.length > 0 ? {
+		kind: "near_ed25519_and_evm_family_ecdsa",
+		walletKeys: args.walletKeys
+	} : { kind: "near_ed25519_only" }), args, normalizeEd25519ParticipantIds(args.participantIds), args.custodyMaterials);
 	return await prepareWalletEcdsaRegistrationPublicationWithMode({
 		kind: "passkey",
 		walletId: args.walletId,
@@ -1034,30 +1003,22 @@ async function prepareWalletRecoveryPasskeyPublication(args) {
 	}, { kind: "wallet_recovery_replacement" });
 }
 async function prepareWalletRecoveryEmailOtpPublication(args) {
-	if (args.kind === "near_ed25519") return buildWalletEd25519RegistrationPublication({
-		prepared: await prepareWalletEmailOtpEd25519RegistrationBatch({
-			walletId: args.walletId,
-			nearAccountId: args.nearAccountId,
-			nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
-			email: args.email,
-			registrationAuthorityId: args.registrationAuthorityId,
-			authority: args.authority,
-			signerSlot: args.signerSlot,
-			operationalPublicKey: args.operationalPublicKey,
-			relayerKeyId: args.relayerKeyId,
-			keyVersion: NEAR_ED25519_YAO_KEY_VERSION_V1,
-			participantIds: normalizeEd25519ParticipantIds(args.participantIds)
-		}, args.walletKeys.length > 0 ? {
-			kind: "near_ed25519_and_evm_family_ecdsa",
-			walletKeys: args.walletKeys
-		} : { kind: "near_ed25519_only" }, { kind: "wallet_recovery_replacement" }),
+	if (args.kind === "near_ed25519") return buildWalletEd25519RegistrationPublication(await prepareWalletEmailOtpEd25519RegistrationBatch({
 		walletId: args.walletId,
 		nearAccountId: args.nearAccountId,
 		nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
+		email: args.email,
+		registrationAuthorityId: args.registrationAuthorityId,
+		authority: args.authority,
 		signerSlot: args.signerSlot,
-		participantIds: normalizeEd25519ParticipantIds(args.participantIds),
-		custodyMaterials: args.custodyMaterials
-	});
+		operationalPublicKey: args.operationalPublicKey,
+		relayerKeyId: args.relayerKeyId,
+		keyVersion: NEAR_ED25519_YAO_KEY_VERSION_V1,
+		participantIds: normalizeEd25519ParticipantIds(args.participantIds)
+	}, args.walletKeys.length > 0 ? {
+		kind: "near_ed25519_and_evm_family_ecdsa",
+		walletKeys: args.walletKeys
+	} : { kind: "near_ed25519_only" }, { kind: "wallet_recovery_replacement" }), args, normalizeEd25519ParticipantIds(args.participantIds), args.custodyMaterials);
 	return await prepareWalletEcdsaRegistrationPublicationWithMode({
 		kind: "email_otp",
 		walletId: args.walletId,
@@ -1069,10 +1030,7 @@ async function prepareWalletRecoveryEmailOtpPublication(args) {
 }
 async function storeWalletEd25519RegistrationDataWithMode(deps, args, mode, composition) {
 	const prepared = prepareWalletEd25519RegistrationBatch(args, mode, composition);
-	return storedRegistrationResult(await deps.accountStore.persistWalletRegistrationFinalize(prepared), composition.kind === "near_ed25519_and_evm_family_ecdsa" ? prepareWalletEcdsaSignerActivations({
-		walletId: args.walletId,
-		walletKeys: composition.walletKeys
-	}) : null);
+	return storedRegistrationResult(await deps.accountStore.persistWalletRegistrationFinalize(prepared), walletRegistrationEcdsaActivations(args.walletId, composition, PASSKEY_REGISTRATION_SIGNER_SOURCE));
 }
 async function storeWalletEd25519RegistrationData(deps, args) {
 	return { signerSlot: (await storeWalletEd25519RegistrationDataWithMode(deps, args, { kind: "fresh_registration" }, { kind: "near_ed25519_only" })).signerSlot };
@@ -1087,106 +1045,28 @@ async function storeWalletEd25519RecoveryRegistrationData(deps, args) {
 	return { signerSlot: (await storeWalletEd25519RegistrationDataWithMode(deps, args, { kind: "wallet_recovery_replacement" }, { kind: "near_ed25519_only" })).signerSlot };
 }
 async function prepareWalletEmailOtpEd25519RegistrationBatch(args, composition, mode = { kind: "fresh_registration" }) {
-	const signerSlot = Number(args.signerSlot);
-	if (!Number.isSafeInteger(signerSlot) || signerSlot < 1) throw new Error("SeamsWalletDB: wallet signerSlot must be an integer >= 1");
-	const walletId = String(args.walletId || "").trim();
-	if (!walletId) throw new Error("SeamsWalletDB: walletId is required");
-	const nearAccountId = toAccountId(args.nearAccountId);
-	const nearEd25519SigningKeyId = String(args.nearEd25519SigningKeyId || "").trim();
-	if (!nearEd25519SigningKeyId) throw new Error("SeamsWalletDB: nearEd25519SigningKeyId is required");
-	const signerMetadata = {
-		walletId,
-		nearAccountId: String(nearAccountId),
-		nearEd25519SigningKeyId,
-		operationalPublicKey: args.operationalPublicKey,
-		relayerKeyId: args.relayerKeyId,
-		keyVersion: args.keyVersion,
-		email: String(args.email || "").trim().toLowerCase(),
-		registrationAuthorityId: String(args.registrationAuthorityId || "").trim(),
-		...args.participantIds ? { participantIds: args.participantIds } : {},
-		...args.clientParticipantId != null ? { clientParticipantId: args.clientParticipantId } : {},
-		...args.relayerParticipantId != null ? { relayerParticipantId: args.relayerParticipantId } : {}
-	};
+	const identity = requireWalletEd25519SignerIdentity(args);
+	const { signerSlot, walletId, nearAccountId } = identity;
 	const nearProfileId = buildNearProfileId(nearAccountId);
-	const chainIdKey = inferNearChainIdKey(nearAccountId);
-	const accountAddress = normalizeIndexedDbAccountAddress(nearAccountId);
-	const ed25519SignerId = requireStoreWalletString(args.operationalPublicKey, "Ed25519 signerId");
-	const walletActivation = {
-		account: {
-			profileId: walletId,
-			chainIdKey: WALLET_SUBJECT_CHAIN_ID_KEY,
-			accountAddress: walletId,
-			accountModel: WALLET_SUBJECT_ACCOUNT_MODEL
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-			signerSource: SIGNER_SOURCES.emailOtpRegistration,
-			metadata: signerMetadata
-		},
-		activationPolicy: walletEd25519RegistrationActivationPolicy({
-			mode,
-			signerSlot
+	const { signerActivations, keyMaterials } = signerActivationRecords([...walletEd25519SignerActivations({
+		identity,
+		nearProfileId,
+		operationalPublicKey: args.operationalPublicKey,
+		source: EMAIL_OTP_REGISTRATION_SIGNER_SOURCE,
+		metadata: walletEd25519SignerMetadata(identity, args, {
+			email: String(args.email || "").trim().toLowerCase(),
+			registrationAuthorityId: String(args.registrationAuthorityId || "").trim()
 		}),
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const nearActivation = {
-		account: {
-			profileId: nearProfileId,
-			chainIdKey,
-			accountAddress,
-			accountModel: "near-native"
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-			signerSource: SIGNER_SOURCES.emailOtpRegistration,
-			metadata: signerMetadata
-		},
 		activationPolicy: walletEd25519RegistrationActivationPolicy({
 			mode,
 			signerSlot
-		}),
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const preparedEcdsa = composition.kind === "near_ed25519_and_evm_family_ecdsa" ? prepareWalletEcdsaSignerActivations({
-		walletId: args.walletId,
-		walletKeys: composition.walletKeys
-	}, {
-		signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-		signerSource: SIGNER_SOURCES.emailOtpRegistration
-	}, { kind: mode.kind === "wallet_recovery_replacement" ? "wallet_recovery_replacement" : "fresh_registration" }) : null;
-	const signerActivations = [walletActivation, nearActivation];
-	if (preparedEcdsa) for (const activation of preparedEcdsa.signerActivations) signerActivations.push(activation.input);
-	const keyMaterialTimestamp = Date.now();
-	const keyMaterials = [keyMaterialForSignerActivation({
-		activation: walletActivation,
-		signerSlot,
-		timestamp: keyMaterialTimestamp
-	}), keyMaterialForSignerActivation({
-		activation: nearActivation,
-		signerSlot,
-		timestamp: keyMaterialTimestamp
-	})];
-	if (preparedEcdsa) for (const activation of preparedEcdsa.signerActivations) keyMaterials.push(keyMaterialForSignerActivation({
-		activation: activation.input,
-		signerSlot: activation.signerSlot,
-		timestamp: keyMaterialTimestamp
-	}));
+		})
+	}), ...walletRegistrationEcdsaActivations(args.walletId, composition, EMAIL_OTP_REGISTRATION_SIGNER_SOURCE, mode)]);
 	return {
-		profiles: [{
-			profileId: walletId,
-			defaultSignerSlot: signerSlot
-		}, {
-			profileId: nearProfileId,
+		profiles: [walletId, nearProfileId].map((profileId) => ({
+			profileId,
 			defaultSignerSlot: signerSlot
-		}],
+		})),
 		initialAuthMethod: await emailOtpAuthMethod({
 			walletId: args.walletId,
 			email: args.email,
@@ -1205,26 +1085,15 @@ async function prepareWalletEmailOtpEd25519RegistrationBatch(args, composition,
 async function storeWalletEmailOtpEd25519RegistrationDataWithComposition(deps, args, composition) {
 	const prepared = await prepareWalletEmailOtpEd25519RegistrationBatch(args, composition);
 	const result = await deps.accountStore.persistWalletRegistrationFinalize(prepared);
-	const preparedEcdsa = composition.kind === "near_ed25519_and_evm_family_ecdsa" ? prepareWalletEcdsaSignerActivations({
-		walletId: args.walletId,
-		walletKeys: composition.walletKeys
-	}, {
-		signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-		signerSource: SIGNER_SOURCES.emailOtpRegistration
-	}) : null;
+	const ecdsaActivations = walletRegistrationEcdsaActivations(args.walletId, composition, EMAIL_OTP_REGISTRATION_SIGNER_SOURCE);
 	const storedNearActivation = result.signerActivations[1];
 	if (!storedNearActivation) throw new Error("SeamsWalletDB: wallet Email OTP Ed25519 registration batch did not complete");
 	const storedSigners = [];
-	if (preparedEcdsa) for (let index = 0; index < preparedEcdsa.signerActivations.length; index += 1) {
-		const activation = preparedEcdsa.signerActivations[index];
+	for (let index = 0; index < ecdsaActivations.length; index += 1) {
+		const activation = ecdsaActivations[index];
 		const stored = result.signerActivations[index + 2];
 		if (!activation || !stored) throw new Error("SeamsWalletDB: mixed wallet Email OTP ECDSA registration batch did not complete");
-		storedSigners.push({
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: stored.signerSlot,
-			signerId: activation.signerId
-		});
+		storedSigners.push(storedWalletEcdsaSigner(activation, stored));
 	}
 	return {
 		signerSlot: storedNearActivation.signerSlot,
@@ -1232,15 +1101,7 @@ async function storeWalletEmailOtpEd25519RegistrationDataWithComposition(deps, a
 	};
 }
 async function prepareWalletEmailOtpEd25519RegistrationPublication(args) {
-	return buildWalletEd25519RegistrationPublication({
-		prepared: await prepareWalletEmailOtpEd25519RegistrationBatch(args, { kind: "near_ed25519_only" }),
-		walletId: args.walletId,
-		nearAccountId: args.nearAccountId,
-		nearEd25519SigningKeyId: args.nearEd25519SigningKeyId,
-		signerSlot: args.signerSlot,
-		participantIds: args.participantIds,
-		custodyMaterials: [args.custodyMaterial]
-	});
+	return buildWalletEd25519RegistrationPublication(await prepareWalletEmailOtpEd25519RegistrationBatch(args, { kind: "near_ed25519_only" }), args, args.participantIds, [args.custodyMaterial]);
 }
 async function storeWalletEmailOtpEd25519RegistrationData(deps, args) {
 	return { signerSlot: (await storeWalletEmailOtpEd25519RegistrationDataWithComposition(deps, args, { kind: "near_ed25519_only" })).signerSlot };
@@ -1254,99 +1115,35 @@ async function storeWalletEmailOtpMixedRegistrationData(deps, args) {
 async function finalizeWalletEd25519SignerRegistration(deps, args) {
 	const credentialId = String(args.auth.credential.rawId || args.auth.credential.id || "").trim();
 	if (!credentialId) throw new Error("SeamsWalletDB: add-signer credential id is required");
-	const signerSlot = Number(args.signerSlot);
-	if (!Number.isSafeInteger(signerSlot) || signerSlot < 1) throw new Error("SeamsWalletDB: wallet signerSlot must be an integer >= 1");
-	const walletId = String(args.walletId || "").trim();
-	if (!walletId) throw new Error("SeamsWalletDB: walletId is required");
-	const nearAccountId = toAccountId(args.nearAccountId);
-	const nearEd25519SigningKeyId = String(args.nearEd25519SigningKeyId || "").trim();
-	if (!nearEd25519SigningKeyId) throw new Error("SeamsWalletDB: nearEd25519SigningKeyId is required");
+	const identity = requireWalletEd25519SignerIdentity(args);
+	const { signerSlot, walletId, nearAccountId } = identity;
 	const passkeyCredential = {
 		id: args.auth.credential.id,
 		rawId: credentialId
 	};
-	const signerMetadata = {
-		walletId,
-		nearAccountId: String(nearAccountId),
-		nearEd25519SigningKeyId,
-		operationalPublicKey: args.operationalPublicKey,
-		relayerKeyId: args.relayerKeyId,
-		keyVersion: args.keyVersion,
-		passkeyCredentialId: args.auth.credential.id,
-		passkeyCredentialRawId: credentialId,
-		...args.participantIds ? { participantIds: args.participantIds } : {},
-		...args.clientParticipantId != null ? { clientParticipantId: args.clientParticipantId } : {},
-		...args.relayerParticipantId != null ? { relayerParticipantId: args.relayerParticipantId } : {}
-	};
 	const nearProfileId = buildNearProfileId(nearAccountId);
-	const chainIdKey = inferNearChainIdKey(nearAccountId);
-	const accountAddress = normalizeIndexedDbAccountAddress(nearAccountId);
-	const ed25519SignerId = requireStoreWalletString(args.operationalPublicKey, "Ed25519 signerId");
-	const walletActivation = {
-		account: {
-			profileId: walletId,
-			chainIdKey: WALLET_SUBJECT_CHAIN_ID_KEY,
-			accountAddress: walletId,
-			accountModel: WALLET_SUBJECT_ACCOUNT_MODEL
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-			signerSource: SIGNER_SOURCES.passkeyRegistration,
-			metadata: signerMetadata
-		},
-		activationPolicy: {
-			mode: "fail_if_occupied",
-			signerSlot
-		},
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const nearActivation = {
-		account: {
-			profileId: nearProfileId,
-			chainIdKey,
-			accountAddress,
-			accountModel: "near-native"
-		},
-		signer: {
-			signerId: ed25519SignerId,
-			signerType: "threshold",
-			signerKind: SIGNER_KINDS.thresholdEd25519,
-			signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-			signerSource: SIGNER_SOURCES.passkeyRegistration,
-			metadata: signerMetadata
-		},
+	const { signerActivations, keyMaterials } = signerActivationRecords(walletEd25519SignerActivations({
+		identity,
+		nearProfileId,
+		operationalPublicKey: args.operationalPublicKey,
+		source: PASSKEY_REGISTRATION_SIGNER_SOURCE,
+		metadata: walletEd25519SignerMetadata(identity, args, {
+			passkeyCredentialId: args.auth.credential.id,
+			passkeyCredentialRawId: credentialId
+		}),
 		activationPolicy: {
 			mode: "fail_if_occupied",
 			signerSlot
-		},
-		preferredSlot: signerSlot,
-		mutation: { routeThroughOutbox: false }
-	};
-	const keyMaterialTimestamp = Date.now();
+		}
+	}));
 	const result = await deps.accountStore.persistWalletSignerFinalize({
-		profiles: [{
-			profileId: walletId,
-			defaultSignerSlot: signerSlot,
-			passkeyCredential
-		}, {
-			profileId: nearProfileId,
+		profiles: [walletId, nearProfileId].map((profileId) => ({
+			profileId,
 			defaultSignerSlot: signerSlot,
 			passkeyCredential
-		}],
-		signerActivations: [walletActivation, nearActivation],
-		keyMaterials: [keyMaterialForSignerActivation({
-			activation: walletActivation,
-			signerSlot,
-			timestamp: keyMaterialTimestamp
-		}), keyMaterialForSignerActivation({
-			activation: nearActivation,
-			signerSlot,
-			timestamp: keyMaterialTimestamp
-		})],
+		})),
+		signerActivations,
+		keyMaterials,
 		lastProfileState: {
 			profileId: walletId,
 			activeSignerSlot: signerSlot
@@ -1375,10 +1172,7 @@ function normalizeStoreWalletParticipantIds(value) {
 	if (!Array.isArray(value) || value.length !== 2 || value[0] !== 1 || value[1] !== 2) throw new Error("SeamsWalletDB: threshold ECDSA participantIds must be [1, 2]");
 	return [1, 2];
 }
-function prepareWalletEcdsaSignerActivations(args, source = {
-	signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-	signerSource: SIGNER_SOURCES.passkeyRegistration
-}, mode = { kind: "fresh_registration" }) {
+function prepareWalletEcdsaSignerActivations(args, source = PASSKEY_REGISTRATION_SIGNER_SOURCE, mode = { kind: "fresh_registration" }) {
 	const expectedWalletId = requireStoreWalletString(args.walletId, "walletId");
 	if (!Array.isArray(args.walletKeys) || args.walletKeys.length === 0) throw new Error("SeamsWalletDB: threshold ECDSA walletKeys are required");
 	const signerActivations = [];
@@ -1467,79 +1261,37 @@ function prepareWalletEcdsaSignerActivations(args, source = {
 		signerActivations
 	};
 }
-async function storeWalletEcdsaSignerRecords(deps, args) {
-	const { walletId, signerActivations } = prepareWalletEcdsaSignerActivations(args);
-	const keyMaterialTimestamp = Date.now();
-	const batch = await deps.accountStore.persistWalletSignerFinalize({
-		profiles: [{ profileId: walletId }],
-		signerActivations: signerActivations.map((activation) => activation.input),
-		keyMaterials: signerActivations.map((activation) => keyMaterialForSignerActivation({
-			activation: activation.input,
-			signerSlot: activation.signerSlot,
-			timestamp: keyMaterialTimestamp
-		}))
+function persistWalletEcdsaSigners(deps, prepared) {
+	return deps.accountStore.persistWalletSignerFinalize({
+		profiles: [{ profileId: prepared.walletId }],
+		...signerActivationRecords(prepared.signerActivations)
 	});
-	return { storedSigners: signerActivations.map((activation, index) => {
+}
+async function storeWalletEcdsaSignerRecords(deps, args) {
+	const prepared = prepareWalletEcdsaSignerActivations(args);
+	const batch = await persistWalletEcdsaSigners(deps, prepared);
+	return { storedSigners: prepared.signerActivations.map((activation, index) => {
 		const result = batch.signerActivations[index];
 		if (!result) throw new Error("SeamsWalletDB: wallet ECDSA signer batch did not complete");
-		return {
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: result.signerSlot,
-			signerId: activation.signerId
-		};
+		return storedWalletEcdsaSigner(activation, result);
 	}) };
 }
 async function storeWalletEcdsaRecoverySignerRecords(deps, args) {
-	const { walletId, signerActivations } = prepareWalletEcdsaSignerActivations(args, {
-		signerAuthMethod: SIGNER_AUTH_METHODS.passkey,
-		signerSource: SIGNER_SOURCES.passkeyRegistration
-	}, { kind: "wallet_recovery_replacement" });
-	const keyMaterialTimestamp = Date.now();
-	const batch = await deps.accountStore.persistWalletSignerFinalize({
-		profiles: [{ profileId: walletId }],
-		signerActivations: signerActivations.map((activation) => activation.input),
-		keyMaterials: signerActivations.map((activation) => keyMaterialForSignerActivation({
-			activation: activation.input,
-			signerSlot: activation.signerSlot,
-			timestamp: keyMaterialTimestamp
-		}))
-	});
-	return { storedSigners: signerActivations.map((activation, index) => {
+	const prepared = prepareWalletEcdsaSignerActivations(args, PASSKEY_REGISTRATION_SIGNER_SOURCE, { kind: "wallet_recovery_replacement" });
+	const batch = await persistWalletEcdsaSigners(deps, prepared);
+	return { storedSigners: prepared.signerActivations.map((activation, index) => {
 		const result = batch.signerActivations[index];
 		if (!result) throw new Error("SeamsWalletDB: wallet recovery ECDSA signer batch did not complete");
-		return {
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: result.signerSlot,
-			signerId: activation.signerId
-		};
+		return storedWalletEcdsaSigner(activation, result);
 	}) };
 }
 async function storeWalletEmailOtpEcdsaSignerRecords(deps, args) {
-	const { walletId, signerActivations } = prepareWalletEcdsaSignerActivations(args, {
-		signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-		signerSource: SIGNER_SOURCES.emailOtpRegistration
-	});
-	const keyMaterialTimestamp = Date.now();
-	const batch = await deps.accountStore.persistWalletSignerFinalize({
-		profiles: [{ profileId: walletId }],
-		signerActivations: signerActivations.map((activation) => activation.input),
-		keyMaterials: signerActivations.map((activation) => keyMaterialForSignerActivation({
-			activation: activation.input,
-			signerSlot: activation.signerSlot,
-			timestamp: keyMaterialTimestamp
-		}))
-	});
-	return { storedSigners: signerActivations.map((activation, index) => {
+	const prepared = prepareWalletEcdsaSignerActivations(args, EMAIL_OTP_REGISTRATION_SIGNER_SOURCE);
+	const batch = await persistWalletEcdsaSigners(deps, prepared);
+	return { storedSigners: prepared.signerActivations.map((activation, index) => {
 		const result = batch.signerActivations[index];
 		if (!result) throw new Error("SeamsWalletDB: wallet Email OTP ECDSA signer batch did not complete");
-		return {
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: result.signerSlot,
-			signerId: activation.signerId
-		};
+		return storedWalletEcdsaSigner(activation, result);
 	}) };
 }
 async function finalizeWalletEcdsaRegistration(deps, args) {
@@ -1562,22 +1314,14 @@ async function finalizeWalletEcdsaRegistration(deps, args) {
 	return { storedSigners: preparedEcdsa.signerActivations.map((activation, index) => {
 		const result = batch.signerActivations[index];
 		if (!result) throw new Error("SeamsWalletDB: wallet ECDSA registration batch did not complete");
-		return {
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: result.signerSlot,
-			signerId: activation.signerId
-		};
+		return storedWalletEcdsaSigner(activation, result);
 	}) };
 }
 async function storeWalletEmailOtpEcdsaRegistrationData(deps, args) {
 	const preparedEcdsa = prepareWalletEcdsaSignerActivations({
 		walletId: args.walletId,
 		walletKeys: args.walletKeys
-	}, {
-		signerAuthMethod: SIGNER_AUTH_METHODS.emailOtp,
-		signerSource: SIGNER_SOURCES.emailOtpRegistration
-	});
+	}, EMAIL_OTP_REGISTRATION_SIGNER_SOURCE);
 	const registration = await prepareWalletEcdsaRegistrationPublication({
 		kind: "email_otp",
 		walletId: args.walletId,
@@ -1590,12 +1334,7 @@ async function storeWalletEmailOtpEcdsaRegistrationData(deps, args) {
 	return { storedSigners: preparedEcdsa.signerActivations.map((activation, index) => {
 		const result = batch.signerActivations[index];
 		if (!result) throw new Error("SeamsWalletDB: wallet Email OTP ECDSA registration batch did not complete");
-		return {
-			chainTarget: activation.chainTarget,
-			targetKey: activation.targetKey,
-			signerSlot: result.signerSlot,
-			signerId: activation.signerId
-		};
+		return storedWalletEcdsaSigner(activation, result);
 	}) };
 }
 //#endregion