@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/indexedDB/seamsWalletDB/ecdsaClientPresignatures.js

@@ -1,24 +1,10 @@
-import { mpcMaterialActivationRefsEqual } from "../../../shared-ts/src/utils/domainIds.js";
 import { requireRecord } from "../../../shared-ts/src/utils/validation.js";
-import { base64UrlDecode, base64UrlEncode } from "../../../shared-ts/src/utils/base64.js";
-import { sha256Bytes } from "../../../shared-ts/src/utils/digests.js";
-import { canonicalRouterAbMpcMaterialActivationRefBytes, routerAbMpcMaterialActivationRefToWire } from "../../../shared-ts/src/utils/routerAbNormalSigningIdentity.js";
-import { parseEcdsaClientVerifyingPublicKey33B64u, parseEcdsaRoleLocalPersistedMaterialRef } from "../../signingEngine/session/keyMaterialBrands.js";
+import "../../config/presignatures.js";
 import { parseEcdsaCiphertextB64u, parseEcdsaCiphertextDigest, parseEcdsaIv12B64u, parseEcdsaMaterialSealingKeyId } from "../../../shared-ts/src/utils/ecdsaCapabilityActivation.js";
-import { routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1 } from "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
-import { SEAMS_WALLET_INDEXES } from "../schemaNames.js";
+import "../../../shared-ts/src/utils/routerAbEcdsaDerivation.js";
+import { parseEcdsaClientVerifyingPublicKey33B64u, parseEcdsaRoleLocalPersistedMaterialRef } from "../../signingEngine/session/keyMaterialBrands.js";
 import { ecdsaClientPresignPoolKey, parseEcdsaClientPresignPoolIdentity } from "../../signingEngine/workerManager/ecdsaPresignPoolIdentity.js";
-import "../../signingEngine/workerManager/ecdsaPresignLifecycle.js";
-import { PRESIGNATURE_STORE, additionalData, requireExactKeys } from "./ecdsaCapabilityManifestRecords.js";
-//#region src/core/indexedDB/seamsWalletDB/ecdsaClientPresignatures.ts
-const CLIENT_PRESIGNATURE_AAD_DOMAIN = "seams/ecdsa-client-presignature/v1";
-const MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION = 32;
-const MAX_DURABLE_CLIENT_PRESIGNATURE_FUTURE_SKEW_MS = 5 * 6e4;
-function activeMaterialMatchesPresignature(material, poolIdentity, materialRef) {
-	const scope = material.binding.routerAbEcdsaDerivationNormalSigning.scope;
-	const materialActivation = routerAbMpcMaterialActivationRefToWire(material.binding.materialActivation);
-	return scope.wallet_id === poolIdentity.walletId && base64UrlEncode(routerAbEcdsaDerivationNormalSigningScopeCanonicalBytesV1(scope)) === poolIdentity.signingScopeB64u && base64UrlEncode(canonicalRouterAbMpcMaterialActivationRefBytes(materialActivation)) === poolIdentity.materialActivationB64u && scope.signing_worker.key_epoch === poolIdentity.keyEpoch && scope.activation_epoch === poolIdentity.activationEpoch && materialActivation.activation_id === poolIdentity.materialActivationId && materialActivation.capability === poolIdentity.capability && materialActivation.key_binding === poolIdentity.keyBinding && materialActivation.material_owner === poolIdentity.walletId && material.binding.durableMaterialRef === materialRef.durableMaterialRef && material.binding.bindingDigest === materialRef.bindingDigest && mpcMaterialActivationRefsEqual(material.binding.materialActivation, materialRef.materialActivation);
-}
+import { requireExactKeys } from "./ecdsaCapabilityManifestRecords.js";
 function materialRefMatchesPoolIdentity(materialRef, poolIdentity) {
 	return materialRef.materialActivation.activationId === poolIdentity.materialActivationId && materialRef.materialActivation.capability === poolIdentity.capability && materialRef.materialActivation.keyBinding === poolIdentity.keyBinding && materialRef.materialActivation.materialOwner === poolIdentity.walletId;
 }
@@ -30,54 +16,13 @@ function parsePresignatureTimestamp(value, label) {
 	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new Error(`${label} is invalid`);
 	return value;
 }
-function rawRecordId(value) {
-	if (!value || typeof value !== "object" || !("record_id" in value)) return null;
-	const recordId = value.record_id;
-	return typeof recordId === "string" ? recordId : null;
-}
-function supportsStrictIndexedDbDurability() {
-	return typeof IDBTransaction !== "undefined" && "durability" in IDBTransaction.prototype;
-}
-async function deleteCursorRows(cursor, limit = Number.POSITIVE_INFINITY) {
-	let deletedCount = 0;
-	while (cursor && deletedCount < limit) {
-		await cursor.delete();
-		deletedCount += 1;
-		cursor = await cursor.continue();
-	}
-	return deletedCount;
-}
-async function deleteExpiredClientPresignatureRows(context, walletId, nowMs) {
-	return await deleteCursorRows(await context.store(PRESIGNATURE_STORE).index(SEAMS_WALLET_INDEXES.walletExpiresAt).openCursor(IDBKeyRange.bound([walletId, 0], [walletId, nowMs])), MAX_EXPIRED_CLIENT_PRESIGNATURE_DELETIONS_PER_TRANSACTION);
-}
-async function readAvailableClientPresignatureRows(context, poolIdentity, nowMs) {
-	await deleteExpiredClientPresignatureRows(context, poolIdentity.walletId, nowMs);
-	const store = context.store(PRESIGNATURE_STORE);
-	const rows = await store.index(SEAMS_WALLET_INDEXES.poolIdentityKey).getAll(ecdsaClientPresignPoolKey(poolIdentity));
-	const available = [];
-	for (const raw of rows) try {
-		const row = parseSealedAvailableClientPresignatureRow(raw);
-		if (row.expires_at_ms <= nowMs) await store.delete(row.record_id);
-		else available.push(row);
-	} catch {
-		const malformedRecordId = rawRecordId(raw);
-		if (malformedRecordId) await store.delete(malformedRecordId);
-	}
-	return available;
-}
-function presignatureAadProjection(metadata) {
-	return {
-		domain: CLIENT_PRESIGNATURE_AAD_DOMAIN,
-		version: 1,
-		pool_identity: metadata.poolIdentity,
-		durable_material_ref: metadata.durableMaterialRef,
-		presignature_id: metadata.presignatureId,
-		group_public_key33_b64u: metadata.groupPublicKey33B64u,
-		big_r33_b64u: metadata.bigR33B64u,
-		created_at_ms: metadata.createdAtMs,
-		expires_at_ms: metadata.expiresAtMs,
-		sealing_key_id: metadata.sealingKeyId
-	};
+function initialGenerationPoolKey(identity) {
+	return [
+		identity.protocolId,
+		identity.relayerUrl,
+		identity.signingScopeB64u,
+		identity.materialActivationB64u
+	].join("|");
 }
 function parseSealedAvailableClientPresignatureRow(value) {
 	const record = requireRecord(value, "ECDSA durable presignature row");
@@ -98,7 +43,9 @@ function parseSealedAvailableClientPresignatureRow(value) {
 	]);
 	if (record.kind !== "sealed_available_client_presignature_v1") throw new Error("ECDSA durable presignature row kind is invalid");
 	const poolIdentityRecord = requireRecord(record.pool_identity, "ECDSA durable presignature pool identity");
+	const initialGenerationRecord = !Object.hasOwn(poolIdentityRecord, "ownershipGeneration");
 	requireExactKeys(poolIdentityRecord, "ECDSA durable presignature pool identity", [
+		...initialGenerationRecord ? [] : ["ownershipGeneration"],
 		"activationEpoch",
 		"capability",
 		"keyBinding",
@@ -111,10 +58,13 @@ function parseSealedAvailableClientPresignatureRow(value) {
 		"signingScopeB64u",
 		"walletId"
 	]);
-	const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityRecord);
+	const poolIdentity = parseEcdsaClientPresignPoolIdentity(initialGenerationRecord ? {
+		...poolIdentityRecord,
+		ownershipGeneration: 1
+	} : poolIdentityRecord);
 	const recordId = parseDurableClientPresignatureRecordId(record.record_id);
 	const poolIdentityKeyValue = String(record.pool_identity_key ?? "");
-	if (poolIdentityKeyValue !== ecdsaClientPresignPoolKey(poolIdentity)) throw new Error("ECDSA durable presignature pool identity index is inconsistent");
+	if (poolIdentityKeyValue !== ecdsaClientPresignPoolKey(poolIdentity) && !(initialGenerationRecord && poolIdentityKeyValue === initialGenerationPoolKey(poolIdentity))) throw new Error("ECDSA durable presignature pool identity index is inconsistent");
 	const walletId = String(record.wallet_id ?? "").trim();
 	const materialActivationId = String(record.material_activation_id ?? "").trim();
 	if (!walletId || walletId !== poolIdentity.walletId) throw new Error("ECDSA durable presignature wallet binding is inconsistent");
@@ -143,7 +93,7 @@ function parseSealedAvailableClientPresignatureRow(value) {
 		kind: "sealed_available_client_presignature_v1",
 		record_id: recordId,
 		pool_identity: poolIdentity,
-		pool_identity_key: poolIdentityKeyValue,
+		pool_identity_key: ecdsaClientPresignPoolKey(poolIdentity),
 		wallet_id: walletId,
 		material_activation_id: materialActivationId,
 		durable_material_ref: durableMaterialRef,
@@ -161,75 +111,7 @@ function parseSealedAvailableClientPresignatureRow(value) {
 		}
 	};
 }
-function metadataFromPresignatureRow(row) {
-	return {
-		kind: "sealed_available_client_presignature_v1",
-		recordId: row.record_id,
-		poolIdentity: row.pool_identity,
-		durableMaterialRef: row.durable_material_ref,
-		presignatureId: row.presignature_id,
-		groupPublicKey33B64u: row.group_public_key33_b64u,
-		bigR33B64u: row.big_r33_b64u,
-		createdAtMs: row.created_at_ms,
-		expiresAtMs: row.expires_at_ms,
-		sealingKeyId: row.sealed.sealing_key_id
-	};
-}
-async function encryptPresignatureBytes(input) {
-	const iv12 = crypto.getRandomValues(new Uint8Array(12));
-	const aad = additionalData(presignatureAadProjection(input.metadata));
-	try {
-		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, input.plaintext97));
-		try {
-			const ciphertextB64u = base64UrlEncode(ciphertext);
-			return {
-				iv12B64u: parseEcdsaIv12B64u(base64UrlEncode(iv12)),
-				ciphertextB64u: parseEcdsaCiphertextB64u(ciphertextB64u),
-				ciphertextDigestB64u: parseEcdsaCiphertextDigest(base64UrlEncode(await sha256Bytes(ciphertext)))
-			};
-		} finally {
-			ciphertext.fill(0);
-		}
-	} finally {
-		iv12.fill(0);
-		aad.fill(0);
-		input.plaintext97.fill(0);
-	}
-}
-async function decryptPresignatureBytes(input) {
-	const iv12 = base64UrlDecode(input.sealed.iv12_b64u);
-	const ciphertext = base64UrlDecode(input.sealed.ciphertext_b64u);
-	const aad = additionalData(presignatureAadProjection(input.metadata));
-	let plaintext = null;
-	try {
-		if (base64UrlEncode(await sha256Bytes(ciphertext)) !== input.sealed.ciphertext_digest_b64u) throw new Error("ECDSA durable presignature ciphertext digest mismatch");
-		plaintext = new Uint8Array(await crypto.subtle.decrypt({
-			name: "AES-GCM",
-			iv: iv12,
-			additionalData: aad
-		}, input.key, ciphertext));
-		if (plaintext.length !== 97) throw new Error("ECDSA durable presignature plaintext length is invalid");
-		return plaintext.slice();
-	} finally {
-		iv12.fill(0);
-		ciphertext.fill(0);
-		aad.fill(0);
-		plaintext?.fill(0);
-	}
-}
-async function retireClientPresignaturesForActivationInTransaction(context, walletId, materialActivationId) {
-	const store = context.store(PRESIGNATURE_STORE);
-	const rows = await store.index(SEAMS_WALLET_INDEXES.walletMaterialActivationId).getAll([walletId, materialActivationId]);
-	for (const raw of rows) {
-		const recordId = rawRecordId(raw);
-		if (recordId) await store.delete(recordId);
-	}
-}
 //#endregion
-export { MAX_DURABLE_CLIENT_PRESIGNATURE_FUTURE_SKEW_MS, activeMaterialMatchesPresignature, decryptPresignatureBytes, deleteCursorRows, encryptPresignatureBytes, materialRefMatchesPoolIdentity, metadataFromPresignatureRow, parseDurableClientPresignatureRecordId, parsePresignatureTimestamp, parseSealedAvailableClientPresignatureRow, rawRecordId, readAvailableClientPresignatureRows, retireClientPresignaturesForActivationInTransaction, supportsStrictIndexedDbDurability };
+export { parseSealedAvailableClientPresignatureRow };
 
 //# sourceMappingURL=ecdsaClientPresignatures.js.map

package/dist/esm/core/indexedDB/seamsWalletDB/manager.js

@@ -1,3 +1,4 @@
+import { SEAMS_WALLET_STORES } from "../schemaNames.js";
 import { SEAMS_WALLET_DB_CONFIG, upgradeSeamsWalletDBSchema } from "./schema.js";
 import { openDB } from "idb";
 //#region src/core/indexedDB/seamsWalletDB/manager.ts
@@ -32,10 +33,99 @@ async function runIndexedDbTransactionTask(context, task) {
 	await context.tx.done;
 	return result;
 }
+const WALLET_AUTHORITY_STORES = new Set([
+	SEAMS_WALLET_STORES.walletAuthorities,
+	SEAMS_WALLET_STORES.walletAuthoritySignerMaterials,
+	SEAMS_WALLET_STORES.walletAuthorityExportRoots,
+	SEAMS_WALLET_STORES.walletAuthMethods,
+	SEAMS_WALLET_STORES.walletSelections,
+	SEAMS_WALLET_STORES.walletSessionAuthorizations
+]);
+function recordWalletAuthorityWrite(writes, store, operation, ...args) {
+	const result = Reflect.apply(operation, store, args);
+	writes.changed = true;
+	return result;
+}
+function walletAuthorityStoreMember(writes, store, member) {
+	const value = Reflect.get(store, member);
+	if (typeof value !== "function") return value;
+	switch (member) {
+		case "add":
+		case "put":
+		case "delete":
+		case "clear": return recordWalletAuthorityWrite.bind(null, writes, store, value);
+		default: return value.bind(store);
+	}
+}
+function walletTransactionStore(tx, writes, name) {
+	const store = tx.objectStore(name);
+	if (tx.mode === "readonly" || !WALLET_AUTHORITY_STORES.has(name)) return store;
+	return new Proxy(store, { get: walletAuthorityStoreMember.bind(null, writes) });
+}
+function ignoreAbortedWalletTransaction() {}
+function openWalletAuthorityChannel(dbName) {
+	if (typeof BroadcastChannel === "undefined") return null;
+	try {
+		return new BroadcastChannel(`seams-wallet-authority:${dbName}`);
+	} catch (error) {
+		console.warn("[SeamsWalletDBManager] Authority notifications are unavailable:", error);
+		return null;
+	}
+}
 var SeamsWalletDBManager = class {
+	onWalletAuthorityChange(listener) {
+		this.walletAuthorityListeners.add(listener);
+		this.connectWalletAuthorityChannel();
+		return this.removeWalletAuthorityListener.bind(this, listener);
+	}
+	removeWalletAuthorityListener(listener) {
+		this.walletAuthorityListeners.delete(listener);
+		if (this.walletAuthorityListeners.size === 0) this.closeWalletAuthorityChannel();
+	}
+	getWalletAuthorityRevision() {
+		return this.walletAuthorityRevision;
+	}
+	publishWalletAuthorityCommit(writes, dbName) {
+		if (!writes.changed) return;
+		if (dbName === this.config.dbName) this.invalidateWalletAuthority();
+		const channel = dbName === this.config.dbName ? this.walletAuthorityChannel : null;
+		const publisher = channel ?? openWalletAuthorityChannel(dbName);
+		if (!publisher) return;
+		try {
+			publisher.postMessage("authority_committed");
+		} catch (error) {
+			console.warn("[SeamsWalletDBManager] Authority notification failed:", error);
+		} finally {
+			if (publisher !== channel) publisher.close();
+		}
+	}
+	connectWalletAuthorityChannel() {
+		if (this.disabled || this.walletAuthorityChannel || this.walletAuthorityListeners.size === 0) return;
+		const channel = openWalletAuthorityChannel(this.config.dbName);
+		if (!channel) return;
+		channel.onmessage = this.receiveWalletAuthorityCommit.bind(this, channel);
+		this.walletAuthorityChannel = channel;
+	}
+	closeWalletAuthorityChannel() {
+		this.walletAuthorityChannel?.close();
+		this.walletAuthorityChannel = null;
+	}
+	receiveWalletAuthorityCommit(channel, event) {
+		if (channel !== this.walletAuthorityChannel || event.data !== "authority_committed") return;
+		this.invalidateWalletAuthority();
+	}
+	invalidateWalletAuthority() {
+		this.walletAuthorityRevision += 1;
+		for (const listener of Array.from(this.walletAuthorityListeners)) try {
+			listener();
+		} catch {}
+	}
 	constructor(config = SEAMS_WALLET_DB_CONFIG) {
 		this.dbPromise = null;
 		this.disabled = false;
+		this.walletAuthorityRevision = 0;
+		this.walletAuthorityChannel = null;
+		this.walletAuthorityListeners = /* @__PURE__ */ new Set();
 		this.config = config;
 	}
 	getDbName() {
@@ -44,14 +134,20 @@ var SeamsWalletDBManager = class {
 	setDbName(dbName) {
 		if (this.config.dbName === dbName) return;
 		this.close();
+		this.closeWalletAuthorityChannel();
 		this.config = {
 			...this.config,
 			dbName
 		};
+		this.connectWalletAuthorityChannel();
+		this.invalidateWalletAuthority();
 	}
 	setDisabled(disabled) {
 		this.disabled = disabled;
-		if (disabled) this.close();
+		if (disabled) {
+			this.close();
+			this.closeWalletAuthorityChannel();
+		} else this.connectWalletAuthorityChannel();
 	}
 	isDisabled() {
 		return this.disabled;
@@ -112,13 +208,13 @@ var SeamsWalletDBManager = class {
 	async runTransaction(stores, mode, task, options) {
 		const db = await withTimeout(this.getDB(), INDEXED_DB_OPEN_TIMEOUT_MS, indexedDbTimeoutError(`[SeamsWalletDBManager] IndexedDB connection timed out for ${this.config.dbName}. Close other tabs using this app and retry.`));
 		const tx = db.transaction([...stores], mode, options);
+		const writes = { changed: false };
 		const context = {
 			db,
 			tx,
-			store(name) {
-				return tx.objectStore(name);
-			}
+			store: walletTransactionStore.bind(null, tx, writes)
 		};
+		tx.done.then(this.publishWalletAuthorityCommit.bind(this, writes, db.name)).catch(ignoreAbortedWalletTransaction);
 		try {
 			return await withTimeout(runIndexedDbTransactionTask(context, task), INDEXED_DB_TRANSACTION_TIMEOUT_MS, indexedDbTimeoutError(`[SeamsWalletDBManager] IndexedDB transaction timed out for ${this.config.dbName}. Close other tabs using this app and retry.`), () => {
 				try {

package/dist/esm/core/indexedDB/seamsWalletDB/nonceLeaseRows.js

@@ -0,0 +1,156 @@
+import { normalizeTrimmedString } from "../../../shared-ts/src/utils/normalize.js";
+import { thresholdEcdsaChainTargetFromRequest } from "../../signingEngine/interfaces/ecdsaChainTarget.js";
+import { parseStoredNonEmptyString } from "../normalization.js";
+//#region src/core/indexedDB/seamsWalletDB/nonceLeaseRows.ts
+function nonceLeaseWalletId(record) {
+	if (record.family === "near") return record.walletId;
+	return record.accountId;
+}
+function nonceLeaseNearAccountId(record) {
+	return record.family === "near" ? record.nearAccountId : "";
+}
+function nonceLeaseRow(record) {
+	const leaseId = normalizeTrimmedString(record.leaseId || "");
+	const laneKey = normalizeTrimmedString(record.laneKey || "");
+	const walletId = normalizeTrimmedString(nonceLeaseWalletId(record) || "");
+	const nearAccountId = normalizeTrimmedString(nonceLeaseNearAccountId(record) || "");
+	if (!leaseId || !laneKey || !walletId) throw new Error("[SeamsWalletDB] nonce lease requires leaseId, laneKey, and wallet identity");
+	return {
+		lease_id: leaseId,
+		lane_key: laneKey,
+		wallet_id: walletId,
+		...nearAccountId ? { near_account_id: nearAccountId } : {},
+		state: record.state,
+		expires_at_ms: Math.floor(Number(record.expiresAtMs)),
+		record
+	};
+}
+function parseNonceLaneLockRow(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const lockKey = parseStoredNonEmptyString(Reflect.get(value, "lock_key"));
+	const ownerId = parseStoredNonEmptyString(Reflect.get(value, "owner_id"));
+	const fencingToken = parseStoredNonEmptyString(Reflect.get(value, "fencing_token"));
+	const acquiredAtMs = Reflect.get(value, "acquired_at_ms");
+	const expiresAtMs = Reflect.get(value, "expires_at_ms");
+	const updatedAtMs = Reflect.get(value, "updated_at_ms");
+	if (!lockKey || !ownerId || !fencingToken || !Number.isSafeInteger(acquiredAtMs) || acquiredAtMs < 0 || !Number.isSafeInteger(expiresAtMs) || expiresAtMs < 0 || !Number.isSafeInteger(updatedAtMs) || updatedAtMs < 0) return null;
+	return {
+		lock_key: lockKey,
+		owner_id: ownerId,
+		fencing_token: fencingToken,
+		acquired_at_ms: acquiredAtMs,
+		expires_at_ms: expiresAtMs,
+		updated_at_ms: updatedAtMs
+	};
+}
+function parseStoredThresholdEcdsaChainTarget(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	try {
+		return thresholdEcdsaChainTargetFromRequest({
+			kind: Reflect.get(value, "kind"),
+			namespace: Reflect.get(value, "namespace"),
+			chainId: Reflect.get(value, "chainId"),
+			networkSlug: Reflect.get(value, "networkSlug")
+		});
+	} catch {
+		return null;
+	}
+}
+function parseNonceLeaseRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const version = Reflect.get(value, "v");
+	const leaseId = parseStoredNonEmptyString(Reflect.get(value, "leaseId"));
+	const laneKey = parseStoredNonEmptyString(Reflect.get(value, "laneKey"));
+	const networkKey = parseStoredNonEmptyString(Reflect.get(value, "networkKey"));
+	const nonce = parseStoredNonEmptyString(Reflect.get(value, "nonce"));
+	const operationId = parseStoredNonEmptyString(Reflect.get(value, "operationId"));
+	const operationFingerprint = parseStoredNonEmptyString(Reflect.get(value, "operationFingerprint"));
+	const reservedAtMs = Reflect.get(value, "reservedAtMs");
+	const expiresAtMs = Reflect.get(value, "expiresAtMs");
+	const updatedAtMs = Reflect.get(value, "updatedAtMs");
+	const state = Reflect.get(value, "state");
+	if (version !== 1 || !leaseId || !laneKey || !networkKey || !nonce || !operationId || !operationFingerprint || !Number.isSafeInteger(reservedAtMs) || !Number.isSafeInteger(expiresAtMs) || !Number.isSafeInteger(updatedAtMs) || state !== "reserved" && state !== "signed" && state !== "broadcast_accepted") return null;
+	const txHash = Reflect.get(value, "txHash");
+	if (state === "broadcast_accepted" && !parseStoredNonEmptyString(txHash)) return null;
+	if (state !== "broadcast_accepted" && txHash !== void 0) return null;
+	const runtimeId = Reflect.get(value, "runtimeId");
+	const fencingToken = Reflect.get(value, "fencingToken");
+	const batchId = Reflect.get(value, "batchId");
+	const txIndex = Reflect.get(value, "txIndex");
+	if (runtimeId !== void 0 && !parseStoredNonEmptyString(runtimeId) || fencingToken !== void 0 && !parseStoredNonEmptyString(fencingToken) || batchId !== void 0 && !parseStoredNonEmptyString(batchId) || txIndex !== void 0 && !Number.isSafeInteger(txIndex)) return null;
+	const family = Reflect.get(value, "family");
+	if (family === "near") {
+		const walletId = parseStoredNonEmptyString(Reflect.get(value, "walletId"));
+		const nearAccountId = parseStoredNonEmptyString(Reflect.get(value, "nearAccountId"));
+		const publicKey = parseStoredNonEmptyString(Reflect.get(value, "publicKey"));
+		if (!walletId || !nearAccountId || !publicKey) return null;
+		return {
+			v: 1,
+			leaseId,
+			laneKey,
+			networkKey,
+			nonce,
+			operationId,
+			operationFingerprint,
+			reservedAtMs,
+			expiresAtMs,
+			updatedAtMs,
+			family: "near",
+			walletId,
+			nearAccountId,
+			publicKey,
+			state,
+			...runtimeId === void 0 ? {} : { runtimeId },
+			...fencingToken === void 0 ? {} : { fencingToken },
+			...batchId === void 0 ? {} : { batchId },
+			...txIndex === void 0 ? {} : { txIndex },
+			...state === "broadcast_accepted" ? { txHash } : {}
+		};
+	}
+	if (family !== "evm") return null;
+	const chainTarget = parseStoredThresholdEcdsaChainTarget(Reflect.get(value, "chainTarget"));
+	const sender = parseStoredNonEmptyString(Reflect.get(value, "sender"));
+	const accountId = parseStoredNonEmptyString(Reflect.get(value, "accountId"));
+	if (!chainTarget || !sender || !accountId) return null;
+	const nonceKey = Reflect.get(value, "nonceKey");
+	if (nonceKey !== void 0 && !parseStoredNonEmptyString(nonceKey)) return null;
+	return {
+		v: 1,
+		leaseId,
+		laneKey,
+		networkKey,
+		nonce,
+		operationId,
+		operationFingerprint,
+		reservedAtMs,
+		expiresAtMs,
+		updatedAtMs,
+		family: "evm",
+		chainTarget,
+		sender,
+		accountId,
+		state,
+		...runtimeId === void 0 ? {} : { runtimeId },
+		...fencingToken === void 0 ? {} : { fencingToken },
+		...batchId === void 0 ? {} : { batchId },
+		...txIndex === void 0 ? {} : { txIndex },
+		...nonceKey === void 0 ? {} : { nonceKey },
+		...state === "broadcast_accepted" ? { txHash } : {}
+	};
+}
+function parseNonceLeaseRow(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = parseNonceLeaseRecord(Reflect.get(value, "record"));
+	if (!record) return null;
+	if (Reflect.get(value, "lease_id") !== record.leaseId) return null;
+	if (Reflect.get(value, "lane_key") !== record.laneKey) return null;
+	if (Reflect.get(value, "wallet_id") !== nonceLeaseWalletId(record)) return null;
+	if ((Reflect.get(value, "near_account_id") || "") !== nonceLeaseNearAccountId(record)) return null;
+	if (Reflect.get(value, "state") !== record.state) return null;
+	if (Reflect.get(value, "expires_at_ms") !== Math.floor(Number(record.expiresAtMs))) return null;
+	return record;
+}
+//#endregion
+export { nonceLeaseRow, parseNonceLaneLockRow, parseNonceLeaseRow };
+
+//# sourceMappingURL=nonceLeaseRows.js.map

package/dist/esm/core/indexedDB/seamsWalletDB/registrationSetup.js

@@ -1,9 +1,9 @@
-import { parseWalletId } from "../../../shared-ts/src/utils/domainIds.js";
 import { isPlainObject, requireCanonicalString } from "../../../shared-ts/src/utils/validation.js";
+import { parseWalletId } from "../../../shared-ts/src/utils/domainIds.js";
 import { alphabetizeStringify, sha256HexUtf8 } from "../../../shared-ts/src/utils/digests.js";
+import { createRegistrationSetupOperationId, parseRegistrationSetupOperationId } from "../../../shared-ts/src/utils/registrationSetupOperation.js";
 import { SEAMS_WALLET_STORES } from "../schemaNames.js";
 import { seamsWalletDB } from "../singletons.js";
-import { createRegistrationSetupOperationId, parseRegistrationSetupOperationId } from "../../../shared-ts/src/utils/registrationSetupOperation.js";
 //#region src/core/indexedDB/seamsWalletDB/registrationSetup.ts
 const PREFIX = "wallet_registration_setup:";
 function storageKey(scopeDigest, requestDigest) {
@@ -35,13 +35,6 @@ function parseAttempt(raw) {
 	}
 	throw new Error("Registration setup journal state is invalid");
 }
-async function registrationSetupScopeDigest(input) {
-	return sha256HexUtf8(alphabetizeStringify({
-		relayerUrl: input.relayerUrl.replace(/\/+$/u, ""),
-		publishableKey: input.publishableKey,
-		environmentId: input.environmentId
-	}));
-}
 function ignoreAbortedTransaction() {}
 var RegistrationSetupRepository = class {
 	constructor(manager) {
@@ -96,8 +89,8 @@ var RegistrationSetupRepository = class {
 		await transaction.done;
 	}
 };
-const registrationSetupRepository = new RegistrationSetupRepository(seamsWalletDB);
+new RegistrationSetupRepository(seamsWalletDB);
 //#endregion
-export { RegistrationSetupRepository, registrationSetupRepository, registrationSetupScopeDigest };
+export { RegistrationSetupRepository };
 
 //# sourceMappingURL=registrationSetup.js.map