@seams/wallet 0.8.0 → 0.9.1

package/dist/public/sdk/workers/ecdsa-derivation-client.worker.js

@@ -1843,6 +1843,47 @@ var SERVER_ALLOCATED_WALLET_NOUNS = [
 var SERVER_ALLOCATED_WALLET_ADJECTIVE_SET = new Set(SERVER_ALLOCATED_WALLET_ADJECTIVES);
 var SERVER_ALLOCATED_WALLET_NOUN_SET = new Set(SERVER_ALLOCATED_WALLET_NOUNS);
 
+// ../shared-ts/src/utils/exactRecord.ts
+var SECRET_BEARING_FIELD_SUBSTRINGS = [
+  "prf",
+  "kek",
+  "seed",
+  "scalar",
+  "secretkey",
+  "privatekey",
+  "plaintext",
+  "recoverycode",
+  "clientroot",
+  "holdershare"
+];
+function rejectUnknownFields(record, allowed, label, knownOnOtherBranches = []) {
+  const allowedSet = new Set(allowed);
+  const knownSet = new Set(knownOnOtherBranches);
+  for (const field of Object.keys(record)) {
+    if (allowedSet.has(field))
+      continue;
+    if (knownSet.has(field)) {
+      throw new Error(`${label}.${field} is not part of ${label}`);
+    }
+    const normalized = field.toLowerCase().replace(/_/g, "");
+    const namesAPublicKey = normalized.includes("publickey");
+    if (!namesAPublicKey && SECRET_BEARING_FIELD_SUBSTRINGS.some((substring) => normalized.includes(substring))) {
+      throw new Error(`${label}.${field} must never carry plaintext custody material`);
+    }
+    throw new Error(`${label}.${field} is not part of ${label}`);
+  }
+}
+function exactRecord(raw, fields, label) {
+  const record = requireRecord(raw, label);
+  rejectUnknownFields(record, fields, label);
+  for (const field of fields) {
+    if (!Object.prototype.hasOwnProperty.call(record, field) || record[field] === undefined) {
+      throw new Error(`${label}.${field} is required`);
+    }
+  }
+  return record;
+}
+
 // ../shared-ts/src/passkey-custody/custodySecretBinding.ts
 var LANE_SCOPE_FIELDS = ["kind", "walletKeyId", "laneId", "laneShareEpoch"];
 var ALLOWED_FIELDS_BY_KIND = {
@@ -2162,6 +2203,47 @@ function parseAuthorizationId(value, fieldName) {
   return { ok: true, value: normalized };
 }
 
+// ../shared-ts/src/utils/wireSchema.ts
+function wireLiteral(...literals) {
+  const parse = (raw, label) => {
+    if (!literals.includes(raw))
+      throw new Error(`${label} is invalid`);
+    return raw;
+  };
+  return Object.assign(parse, { literals });
+}
+function wireObject(shape, refine) {
+  const keys = Object.keys(shape);
+  const order = [
+    ...keys.filter((key) => ("literals" in shape[key])),
+    ...keys.filter((key) => !("literals" in shape[key]))
+  ];
+  const parse = (raw, label) => {
+    const record = exactRecord(raw, keys, label);
+    const parsed = new Map;
+    for (const key of order)
+      parsed.set(key, shape[key](record[key], `${label}.${key}`));
+    const value = Object.fromEntries(keys.map((key) => [key, parsed.get(key)]));
+    refine?.(value, label);
+    return value;
+  };
+  return Object.assign(parse, { shape });
+}
+function wireUnion(tag, variants) {
+  const byTag = new Map;
+  for (const variant of variants) {
+    for (const literal of variant.shape[tag].literals)
+      byTag.set(literal, variant);
+  }
+  return (raw, label) => {
+    const record = requireRecord(raw, label);
+    const variant = byTag.get(record[tag]);
+    if (!variant)
+      throw new Error(`${label}.${tag} is invalid`);
+    return variant(record, label);
+  };
+}
+
 // ../shared-ts/src/authorization/delegatedAuthority.ts
 var FULL_OWNER_PERMISSIONS = Object.freeze([
   "export_keys",
@@ -2181,6 +2263,12 @@ var DELEGATED_WALLET_PERMISSION_VALUES = [
 var DELEGATED_WALLET_PERMISSION_VALUE_SET = new Set(DELEGATED_WALLET_PERMISSION_VALUES);
 var canonicalPermissionSetBrand = Symbol("canonicalPermissionSetBrand");
 
+// ../shared-ts/src/device-linking/activeWalletSession.ts
+var walletSessionHome = wireUnion("kind", [
+  wireObject({ kind: wireLiteral("direct") }),
+  wireObject({ kind: wireLiteral("regional"), region: wireLiteral("US", "WEUR", "APAC", "OC") })
+]);
+
 // ../shared-ts/src/utils/routerAbEcdsaDerivation.ts
 var ROUTER_AB_ECDSA_PRESIGN_CEREMONY_MAX_LIFETIME_MS = 5 * 60000;
 var ROUTER_AB_ECDSA_DERIVATION_NORMAL_SIGNING_STATE_KIND_V1 = "router_ab_ecdsa_derivation_normal_signing_v1";
@@ -3996,858 +4084,231 @@ function parseEcdsaRoleLocalWorkerHandle(value) {
   };
 }
 
-// ../shared-ts/src/utils/secureRandomId.ts
-var DEFAULT_SECURE_RANDOM_ID_BYTES = 32;
-function secureRandomBytes(length = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random bytes") {
-  const byteLength = Math.max(1, Math.floor(Number(length) || 0));
-  const cryptoApi = globalThis.crypto;
-  if (typeof cryptoApi?.getRandomValues !== "function") {
-    throw new Error(`WebCrypto getRandomValues is required for ${label}`);
-  }
-  return cryptoApi.getRandomValues(new Uint8Array(byteLength));
+// ../../node_modules/idb/build/index.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
 }
-function secureRandomBase64Url(byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random id") {
-  return base64UrlEncode(secureRandomBytes(byteLength, label));
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
 }
-function secureRandomId(prefix, byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = `${prefix} id`) {
-  const normalizedPrefix = String(prefix || "").trim() || "id";
-  return `${normalizedPrefix}-${secureRandomBase64Url(byteLength, label)}`;
+var transactionDoneMap = new WeakMap;
+var transformCache = new WeakMap;
+var reverseTransformCache = new WeakMap;
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
 }
-
-// src/core/signingEngine/interfaces/ecdsaChainTarget.ts
-function nonEmptyString(value) {
-  const normalized = String(value ?? "").trim();
-  return normalized ? normalized : null;
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
 }
-function normalizePositiveSafeInteger(value, field) {
-  const normalized = Number(value);
-  if (!Number.isSafeInteger(normalized) || normalized <= 0) {
-    throw new Error(`[threshold-ecdsa] ${field} must be a positive safe integer`);
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
   }
-  return normalized;
-}
-function defaultNetworkSlug(kind, chainId) {
-  return kind === "tempo" ? `tempo-${chainId}` : `evm-${chainId}`;
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
 }
-function toWalletId(value) {
-  const parsed = parseWalletId(value);
-  if (!parsed.ok) {
-    throw new Error(parsed.error.message);
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
   }
-  return parsed.value;
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
 }
-function thresholdEcdsaChainTargetFromChainFamily(args) {
-  const chainId = normalizePositiveSafeInteger(args.chainId, "chainId");
-  const networkSlug = nonEmptyString(args.networkSlug) || defaultNetworkSlug(args.chain, chainId);
-  if (args.chain === "tempo") {
-    return { kind: "tempo", chainId, networkSlug };
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
   }
-  return { kind: "evm", namespace: "eip155", chainId, networkSlug };
+  return newValue;
 }
-function thresholdEcdsaChainTargetFromRequest(args) {
-  const rawKind = String(args.kind ?? args.chain ?? "").trim().toLowerCase();
-  if (rawKind !== "evm" && rawKind !== "tempo") {
-    throw new Error("[threshold-ecdsa] ECDSA request target requires chain kind evm or tempo");
+var unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
   }
-  if (rawKind === "evm") {
-    const namespace = String(args.namespace ?? "eip155").trim().toLowerCase();
-    if (namespace !== "eip155") {
-      throw new Error("[threshold-ecdsa] EVM chain target namespace must be eip155");
-    }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(event.oldVersion, event.newVersion, event));
   }
-  return thresholdEcdsaChainTargetFromChainFamily({
-    chain: rawKind,
-    chainId: args.chainId,
-    networkSlug: args.networkSlug
-  });
-}
-
-// ../shared-ts/src/threshold/participants.ts
-function normalizeThresholdEd25519ParticipantId(id) {
-  const n = Number(id);
-  if (!Number.isSafeInteger(n) || n < 1 || n > 65535)
-    return null;
-  return n;
-}
-function normalizeThresholdEd25519ParticipantIds(input) {
-  if (!Array.isArray(input) || input.length === 0)
-    return null;
-  const out = [];
-  const seen = new Set;
-  for (const v of input) {
-    const id = normalizeThresholdEd25519ParticipantId(v);
-    if (!id)
-      return null;
-    if (!seen.has(id)) {
-      seen.add(id);
-      out.push(id);
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
     }
+  }).catch(() => {});
+  return openPromise;
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = new Map;
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
   }
-  out.sort((a, b) => a - b);
-  return out.length ? out : null;
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target = tx.store;
+    if (useIndex)
+      target = target.index(args.shift());
+    return (await Promise.all([
+      target[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
 }
-
-// ../shared-ts/src/utils/emailOtpDomain.ts
-var EMAIL_OTP_CHANNEL = "email_otp";
-
-// ../shared-ts/src/utils/signerDomain.ts
-var WALLET_AUTH_METHODS = {
-  passkey: "passkey",
-  emailOtp: EMAIL_OTP_CHANNEL
-};
-var WALLET_AUTH_METHOD_VALUES = Object.values(WALLET_AUTH_METHODS);
-
-// ../shared-ts/src/utils/thresholdEcdsaKeyHandle.ts
-function requiredString(value, field) {
-  const normalized = String(value ?? "").trim();
-  if (!normalized)
-    throw new Error(`[threshold-ecdsa-key-handle] ${field} is required`);
-  return normalized;
-}
-function normalizedSigningRootVersion(value) {
-  return String(value ?? "").trim() || "default";
-}
-async function deriveThresholdEcdsaKeyHandle(input) {
-  const canonical = alphabetizeStringify({
-    domain: "seams.threshold_ecdsa.key_handle.v1",
-    ecdsaThresholdKeyId: requiredString(input.ecdsaThresholdKeyId, "ecdsaThresholdKeyId"),
-    signingRootId: requiredString(input.signingRootId, "signingRootId"),
-    signingRootVersion: normalizedSigningRootVersion(input.signingRootVersion)
-  });
-  const digest = await sha256BytesUtf8(canonical);
-  return `ederivation-key-${base64UrlEncode(digest)}`;
-}
-// ../shared-ts/src/utils/digestEncoding.ts
-var TEXT_ENCODER = new TextEncoder;
-// src/core/signingEngine/session/identity/evmFamilyEcdsaIdentity.ts
-function requiredString2(value, field) {
-  const normalized = String(value ?? "").trim();
-  if (!normalized)
-    throw new Error(`[evm-family-ecdsa] ${field} is required`);
-  return normalized;
-}
-function normalizeThresholdOwnerAddress(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
-    throw new Error("[evm-family-ecdsa] thresholdOwnerAddress must be an EVM address");
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+var methodMap = {};
+var advanceResults = new WeakMap;
+var ittrProxiedCursorToOriginalProxy = new WeakMap;
+var cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop))
+      return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function(...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
   }
-  return normalized;
-}
-function toEvmFamilyEcdsaKeyHandle(value) {
-  return requiredString2(value, "keyHandle");
-}
-function toThresholdEcdsaPublicKeyB64u(value) {
-  const normalized = requiredString2(value, "thresholdEcdsaPublicKeyB64u");
-  let bytes;
-  try {
-    bytes = base64UrlDecode(normalized);
-  } catch {
-    throw new Error("[evm-family-ecdsa] thresholdEcdsaPublicKeyB64u must be base64url");
+};
+async function* iterate(...args) {
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
   }
-  if (bytes.length !== 33) {
-    throw new Error("[evm-family-ecdsa] thresholdEcdsaPublicKeyB64u must decode to 33 bytes");
+  if (!cursor)
+    return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
   }
-  return normalized;
 }
-function toParticipantId(value) {
-  const normalized = Math.floor(Number(value));
-  if (!Number.isSafeInteger(normalized) || normalized < 1 || normalized > 65535) {
-    throw new Error("[evm-family-ecdsa] participantId must be a positive safe integer");
-  }
-  return normalized;
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
 }
-function normalizeParticipantIds(value) {
-  const participantIds = normalizeThresholdEd25519ParticipantIds(value);
-  if (!participantIds?.length) {
-    throw new Error("[evm-family-ecdsa] participantIds are required");
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop))
+      return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
   }
-  return participantIds.map(toParticipantId);
-}
-function buildVerifiedEcdsaPublicFacts(input) {
-  return {
-    kind: "verified_ecdsa_public_facts",
-    keyHandle: input.keyHandle,
-    publicKeyB64u: toThresholdEcdsaPublicKeyB64u(input.publicKeyB64u),
-    participantIds: normalizeParticipantIds(input.participantIds),
-    thresholdOwnerAddress: normalizeThresholdOwnerAddress(input.thresholdOwnerAddress)
-  };
-}
-
-// src/core/signingEngine/session/identity/emailOtpEcdsaDerivationIdentity.ts
-function toEcdsaDerivationThresholdKeyId(value) {
-  return parseSdkEcdsaDerivationThresholdKeyId(value);
-}
-function toEcdsaDerivationSigningRootId(value) {
-  return parseSdkEcdsaDerivationSigningRootId(value);
-}
-function toEcdsaDerivationSigningRootVersion(value) {
-  return parseSdkEcdsaDerivationSigningRootVersion(value);
-}
-
-// src/core/signingEngine/session/persistence/ecdsaRoleLocalRecords.ts
-function requiredString3(value, field) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`[platform][ecdsa-role-local] ${field} is required`);
-  }
-  return value.trim();
-}
-function parseBase64UrlBytes(value, field, byteLength) {
-  const normalized = requiredString3(value, field);
-  const decoded = base64UrlDecode(normalized);
-  if (decoded.length !== byteLength) {
-    throw new Error(`[platform][ecdsa-role-local] ${field} must decode to ${byteLength} bytes`);
-  }
-  return normalized;
-}
-function parseCompressedSecp256k1PublicKey(value, field) {
-  const normalized = requiredString3(value, field);
-  const decoded = base64UrlDecode(normalized);
-  if (decoded.length !== 33) {
-    throw new Error(`[platform][ecdsa-role-local] ${field} must decode to 33 bytes`);
-  }
-  if (decoded[0] !== 2 && decoded[0] !== 3) {
-    throw new Error(`[platform][ecdsa-role-local] ${field} must be a compressed SEC1 key`);
-  }
-  return normalized;
-}
-function parseEcdsaDerivationClientSharePublicKey(value) {
-  return parseCompressedSecp256k1PublicKey(value, "derivationClientSharePublicKey33B64u");
-}
-function parseRelayerEcdsaDerivationPublicKey(value) {
-  return parseCompressedSecp256k1PublicKey(value, "relayerPublicKey33B64u");
-}
-function parseGroupPublicKey(value) {
-  return parseCompressedSecp256k1PublicKey(value, "groupPublicKey33B64u");
-}
-function parseEthereumAddress2(value) {
-  const normalized = requiredString3(value, "ethereumAddress").toLowerCase();
-  if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
-    throw new Error("[platform][ecdsa-role-local] ethereumAddress must be an EVM address");
-  }
-  return normalized;
-}
-function parseParticipantIds(value) {
-  if (!Array.isArray(value) || value.length !== 2 || value[0] !== 1 || value[1] !== 2) {
-    throw new Error("[platform][ecdsa-role-local] participantIds must be [1, 2]");
-  }
-  return [1, 2];
-}
-function parseChainTarget(input) {
-  if (input === null || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error("[platform][ecdsa-role-local] chainTarget must be an object");
-  }
-  const kind = requiredString3(Reflect.get(input, "kind"), "chainTarget.kind").toLowerCase();
-  switch (kind) {
-    case "evm": {
-      const fields = Object.keys(input).sort();
-      if (fields.join(",") !== "chainId,kind,namespace,networkSlug") {
-        throw new Error("[platform][ecdsa-role-local] EVM chainTarget fields are invalid");
-      }
-      return thresholdEcdsaChainTargetFromRequest({
-        kind: Reflect.get(input, "kind"),
-        namespace: Reflect.get(input, "namespace"),
-        chainId: Reflect.get(input, "chainId"),
-        networkSlug: Reflect.get(input, "networkSlug")
-      });
-    }
-    case "tempo": {
-      const fields = Object.keys(input).sort();
-      if (fields.join(",") !== "chainId,kind,networkSlug") {
-        throw new Error("[platform][ecdsa-role-local] Tempo chainTarget fields are invalid");
-      }
-      return thresholdEcdsaChainTargetFromRequest({
-        kind: Reflect.get(input, "kind"),
-        chainId: Reflect.get(input, "chainId"),
-        networkSlug: Reflect.get(input, "networkSlug")
-      });
-    }
-    default:
-      throw new Error("[platform][ecdsa-role-local] chainTarget kind is invalid");
-  }
-}
-function parsePublicFacts(input) {
-  if (input === null || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error("[platform][ecdsa-role-local] publicFacts must be an object");
-  }
-  const fields = Object.keys(input).sort();
-  if (fields.join(",") !== "applicationBindingDigestB64u,chainTarget,clientParticipantId,contextBinding32B64u,derivationClientSharePublicKey33B64u,ecdsaThresholdKeyId,ethereumAddress,groupPublicKey33B64u,keyHandle,participantIds,publicCapability,relayerParticipantId,relayerPublicKey33B64u,signingRootId,signingRootVersion,walletId") {
-    throw new Error("[platform][ecdsa-role-local] publicFacts fields are invalid");
-  }
-  if (Reflect.get(input, "clientParticipantId") !== 1) {
-    throw new Error("[platform][ecdsa-role-local] clientParticipantId must be 1");
-  }
-  if (Reflect.get(input, "relayerParticipantId") !== 2) {
-    throw new Error("[platform][ecdsa-role-local] relayerParticipantId must be 2");
-  }
-  const derivationClientSharePublicKey33B64u = parseEcdsaDerivationClientSharePublicKey(Reflect.get(input, "derivationClientSharePublicKey33B64u"));
-  const relayerPublicKey33B64u = parseRelayerEcdsaDerivationPublicKey(Reflect.get(input, "relayerPublicKey33B64u"));
-  if (String(derivationClientSharePublicKey33B64u) === String(relayerPublicKey33B64u)) {
-    throw new Error("[platform][ecdsa-role-local] relayerPublicKey33B64u must differ from derivationClientSharePublicKey33B64u");
-  }
-  return {
-    walletId: toWalletId(Reflect.get(input, "walletId")),
-    chainTarget: parseChainTarget(Reflect.get(input, "chainTarget")),
-    keyHandle: requiredString3(Reflect.get(input, "keyHandle"), "keyHandle"),
-    ecdsaThresholdKeyId: toEcdsaDerivationThresholdKeyId(Reflect.get(input, "ecdsaThresholdKeyId")),
-    signingRootId: toEcdsaDerivationSigningRootId(Reflect.get(input, "signingRootId")),
-    signingRootVersion: toEcdsaDerivationSigningRootVersion(Reflect.get(input, "signingRootVersion")),
-    applicationBindingDigestB64u: parseBase64UrlBytes(Reflect.get(input, "applicationBindingDigestB64u"), "applicationBindingDigestB64u", 32),
-    clientParticipantId: 1,
-    relayerParticipantId: 2,
-    participantIds: parseParticipantIds(Reflect.get(input, "participantIds")),
-    contextBinding32B64u: parseBase64UrlBytes(Reflect.get(input, "contextBinding32B64u"), "contextBinding32B64u", 32),
-    derivationClientSharePublicKey33B64u,
-    relayerPublicKey33B64u,
-    groupPublicKey33B64u: parseGroupPublicKey(Reflect.get(input, "groupPublicKey33B64u")),
-    ethereumAddress: parseEthereumAddress2(Reflect.get(input, "ethereumAddress")),
-    publicCapability: parseRouterAbEcdsaDerivationPublicCapabilityV1(Reflect.get(input, "publicCapability"))
-  };
-}
-function buildEcdsaRoleLocalPublicFacts(input) {
-  return parsePublicFacts(input);
-}
-
-// src/core/signingEngine/session/material/ecdsaCapabilityManifest.ts
-class EcdsaCapabilityManifestProof {
-  retainProof() {
-    return true;
-  }
-  constructor() {
-    this.retainProof();
-  }
-}
-
-class EcdsaCapabilityScopeProof extends EcdsaCapabilityManifestProof {
-  constructor(targetMemberships) {
-    super();
-    this.kind = "evm_family";
-    this.targetMemberships = targetMemberships;
-  }
-}
-
-class EcdsaManifestIdentityProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.manifestId = fields.manifestId;
-    this.manifestRevision = fields.manifestRevision;
-  }
-}
-
-class NoCurrentEcdsaManifestExpectationProof extends EcdsaCapabilityManifestProof {
-  constructor() {
-    super(...arguments);
-    this.kind = "no_current_manifest";
-  }
-}
-
-class ExactEcdsaManifestExpectationProof extends EcdsaCapabilityManifestProof {
-  constructor(identity) {
-    super();
-    this.kind = "exact_manifest";
-    this.manifestId = identity.manifestId;
-    this.manifestRevision = identity.manifestRevision;
-  }
-}
-
-class NoCurrentEcdsaServerGenerationExpectationProof extends EcdsaCapabilityManifestProof {
-  constructor() {
-    super(...arguments);
-    this.kind = "no_current_generation";
-  }
-}
-
-class ExactEcdsaServerGenerationExpectationProof extends EcdsaCapabilityManifestProof {
-  constructor(serverGeneration) {
-    super();
-    this.kind = "exact_generation";
-    this.serverGeneration = serverGeneration;
-  }
-}
-
-class EcdsaRoleLocalMaterialBindingProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "ecdsa_role_local_material_binding";
-    this.keyHandle = fields.keyHandle;
-    this.ecdsaThresholdKeyId = fields.ecdsaThresholdKeyId;
-    this.clientVerifyingPublicKey33B64u = fields.clientVerifyingPublicKey33B64u;
-    this.participantIds = fields.participantIds;
-    this.relayerKeyId = fields.relayerKeyId;
-  }
-}
-
-class PreparedEvmFamilySignerProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "prepared_evm_family_signer";
-    this.capability = fields.capability;
-    this.signerId = fields.signerId;
-    this.walletId = fields.authority.walletId;
-    this.authority = fields.authority;
-    this.scope = fields.scope;
-    this.materialOwner = fields.materialOwner;
-    this.signingRootId = fields.signingRootId;
-    this.signingRootVersion = fields.signingRootVersion;
-  }
-}
-
-class RegisteredEvmFamilySignerProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "registered_evm_family_signer";
-    this.capability = fields.preparedSigner.capability;
-    this.signerId = fields.preparedSigner.signerId;
-    this.walletId = fields.preparedSigner.walletId;
-    this.authority = fields.preparedSigner.authority;
-    this.scope = fields.preparedSigner.scope;
-    this.materialOwner = fields.preparedSigner.materialOwner;
-    this.signingRootId = fields.preparedSigner.signingRootId;
-    this.signingRootVersion = fields.preparedSigner.signingRootVersion;
-    this.registeredPublicFacts = fields.registeredPublicFacts;
-  }
-}
-
-class EncryptedEcdsaPendingCandidateProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "encrypted_ecdsa_pending_candidate";
-    this.sealingKeyId = fields.sealingKeyId;
-    this.iv12B64u = fields.iv12B64u;
-    this.ciphertextB64u = fields.ciphertextB64u;
-    this.ciphertextDigest = fields.ciphertextDigest;
-  }
-}
-
-class EcdsaActivationBindingProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "ecdsa_activation_binding";
-    this.targetManifest = fields.targetManifest;
-    this.signer = fields.signer;
-    this.roleLocalBinding = fields.roleLocalBinding;
-    this.bindingDigest = fields.bindingDigest;
-    this.durableMaterialRef = fields.durableMaterialRef;
-  }
-}
-
-class PreparedEcdsaActivationCandidateProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "prepared_ecdsa_activation_candidate";
-    this.activationBinding = fields.activationBinding;
-    this.encryptedPending = fields.encryptedPending;
-  }
-}
-
-class EcdsaServerActivationCommandProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "ecdsa_server_activation_command";
-    this.correlationId = fields.correlationId;
-    this.expectedGeneration = fields.expectedGeneration;
-    this.requestDigest = fields.requestDigest;
-    this.canonicalRequest = fields.canonicalRequest;
-  }
-}
-
-class EcdsaServerActivationReceiptProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "ecdsa_server_activation_receipt";
-    this.lifecycleId = fields.lifecycleId;
-    this.activationDigest = fields.activationDigest;
-    this.activatedAt = fields.activatedAt;
-    this.protocolReceipt = fields.protocolReceipt;
-  }
-}
-
-class EcdsaServerActivationCommitProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "ecdsa_server_activation_commit";
-    this.correlationId = fields.correlationId;
-    this.activationRequestDigest = fields.activationRequestDigest;
-    this.serverGeneration = fields.serverGeneration;
-    this.serverActivationReceipt = fields.serverActivationReceipt;
-  }
-}
-
-class PreparedEcdsaActivationJournalProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "activation_prepared";
-    this.journalId = fields.journalId;
-    this.expectedManifest = fields.expectedManifest;
-    this.activationCommand = fields.activationCommand;
-    this.candidate = fields.candidate;
-    this.createdAt = fields.createdAt;
-  }
-}
-
-class ServerCommittedEcdsaActivationJournalProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "server_activation_committed";
-    this.journalId = fields.journalId;
-    this.expectedManifest = fields.expectedManifest;
-    this.activationCommand = fields.activationCommand;
-    this.candidate = fields.candidate;
-    this.createdAt = fields.createdAt;
-    this.serverActivation = fields.serverActivation;
-  }
-}
-
-class DurableEcdsaMaterialBindingProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "durable_ecdsa_material";
-    this.materialActivation = fields.materialActivation;
-    this.routerAbEcdsaDerivationNormalSigning = fields.routerAbEcdsaDerivationNormalSigning;
-    this.roleLocalPublicFacts = fields.roleLocalPublicFacts;
-    this.roleLocalBinding = fields.roleLocalBinding;
-    this.durableMaterialRef = fields.durableMaterialRef;
-    this.bindingDigest = fields.bindingDigest;
-    this.lifecycleId = fields.lifecycleId;
-    this.ciphertextDigest = fields.ciphertextDigest;
-    this.activationDigest = fields.activationDigest;
-    this.activatedAt = fields.activatedAt;
-    this.runtimePolicyScope = fields.runtimePolicyScope;
-  }
-}
-
-class ValidatedEncryptedEcdsaReadyMaterialProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "encrypted_ecdsa_ready_material";
-    this.binding = fields.binding;
-    this.sealingKeyId = fields.sealingKeyId;
-    this.iv12B64u = fields.iv12B64u;
-    this.ciphertextB64u = fields.ciphertextB64u;
-  }
-}
-
-class ActiveEcdsaCapabilityManifestProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "active_ecdsa_capability_manifest";
-    this.identity = fields.identity;
-    this.signer = fields.signer;
-    this.activation = fields.activation;
-    this.durableMaterial = fields.durableMaterial;
-    this.committedAt = fields.committedAt;
-  }
-}
-
-class ReplacedEcdsaCapabilityManifestProof extends EcdsaCapabilityManifestProof {
-  constructor(fields) {
-    super();
-    this.kind = "replaced_ecdsa_capability_manifest";
-    this.identity = fields.identity;
-    this.signer = fields.signer;
-    this.retirement = fields.retirement;
-  }
-}
-function unwrapDomainId(result) {
-  if (!result.ok)
-    throw new Error(result.error.message);
-  return result.value;
-}
-function buildEcdsaCapabilityScope(input) {
-  assertUniqueEcdsaTargetMemberships(input.targetMemberships);
-  return new EcdsaCapabilityScopeProof([...input.targetMemberships]);
-}
-function buildEcdsaManifestIdentity(input) {
-  return new EcdsaManifestIdentityProof(input);
-}
-function buildNoCurrentEcdsaManifestExpectation() {
-  return new NoCurrentEcdsaManifestExpectationProof;
-}
-function buildExactEcdsaManifestExpectation(identity) {
-  return new ExactEcdsaManifestExpectationProof(identity);
-}
-function buildNoCurrentEcdsaServerGenerationExpectation() {
-  return new NoCurrentEcdsaServerGenerationExpectationProof;
-}
-function buildExactEcdsaServerGenerationExpectation(serverGeneration) {
-  return new ExactEcdsaServerGenerationExpectationProof(serverGeneration);
-}
-function buildEcdsaRoleLocalMaterialBinding(input) {
-  assertUniqueParticipantIds(input.participantIds);
-  return new EcdsaRoleLocalMaterialBindingProof({
-    keyHandle: input.keyHandle,
-    ecdsaThresholdKeyId: input.ecdsaThresholdKeyId,
-    clientVerifyingPublicKey33B64u: input.clientVerifyingPublicKey33B64u,
-    participantIds: [...input.participantIds],
-    relayerKeyId: input.relayerKeyId
-  });
-}
-function buildPreparedEvmFamilySigner(input) {
-  return new PreparedEvmFamilySignerProof(input);
-}
-function buildEncryptedEcdsaPendingCandidate(input) {
-  return new EncryptedEcdsaPendingCandidateProof(input);
-}
-function buildEcdsaActivationBinding(input) {
-  return new EcdsaActivationBindingProof(input);
-}
-function buildPreparedEcdsaActivationCandidate(input) {
-  return new PreparedEcdsaActivationCandidateProof(input);
-}
-function buildPreparedEcdsaActivationJournal(input) {
-  assertTargetManifestTransition(input.expectedManifest, input.candidate.activationBinding.targetManifest);
-  assertExpectedStatePair(input.expectedManifest, input.expectedGeneration);
-  const activationCommand = new EcdsaServerActivationCommandProof({
-    correlationId: input.journalId,
-    expectedGeneration: input.expectedGeneration,
-    requestDigest: input.requestDigest,
-    canonicalRequest: input.canonicalRequest
-  });
-  return new PreparedEcdsaActivationJournalProof({
-    journalId: input.journalId,
-    expectedManifest: input.expectedManifest,
-    activationCommand,
-    candidate: input.candidate,
-    createdAt: input.createdAt
-  });
-}
-function buildEcdsaServerActivationCommit(input) {
-  const protocolReceipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.serverCommit.protocolReceipt);
-  assertProtocolReceiptMatchesServerCommit(protocolReceipt, input.serverCommit);
-  assertProtocolReceiptMatchesActivationBinding(protocolReceipt, input.activationBinding);
-  const serverActivationReceipt = new EcdsaServerActivationReceiptProof({
-    lifecycleId: lifecycleIdFromProtocolReceipt(protocolReceipt),
-    activationDigest: activationDigestFromProtocolReceipt(protocolReceipt),
-    activatedAt: isoTimestampFromUnixMs(protocolReceipt.ecdsa_activation.activated_at_ms),
-    protocolReceipt
-  });
-  return new EcdsaServerActivationCommitProof({
-    correlationId: input.serverCommit.correlationId,
-    activationRequestDigest: input.serverCommit.activationRequestDigest,
-    serverGeneration: input.serverCommit.serverGeneration,
-    serverActivationReceipt
-  });
-}
-function buildServerCommittedEcdsaActivationJournal(input) {
-  assertServerCommitMatchesPreparedCommand(input.serverCommit, input.preparedJournal);
-  const serverActivation = buildEcdsaServerActivationCommit({
-    activationBinding: input.preparedJournal.candidate.activationBinding,
-    serverCommit: input.serverCommit
-  });
-  return new ServerCommittedEcdsaActivationJournalProof({
-    journalId: input.preparedJournal.journalId,
-    expectedManifest: input.preparedJournal.expectedManifest,
-    activationCommand: input.preparedJournal.activationCommand,
-    candidate: input.preparedJournal.candidate,
-    createdAt: input.preparedJournal.createdAt,
-    serverActivation
-  });
-}
-function buildDurableEcdsaMaterialBinding(input) {
-  assertServerActivationMatchesBinding(input.serverActivation, input.activationBinding);
-  const facts = input.roleLocalPublicFacts;
-  const binding = input.activationBinding;
-  const runtimePolicyScope = normalizeRuntimePolicyScope(input.runtimePolicyScope);
-  if (facts.walletId !== binding.signer.walletId || facts.keyHandle !== binding.roleLocalBinding.keyHandle || facts.ecdsaThresholdKeyId !== binding.roleLocalBinding.ecdsaThresholdKeyId || facts.signingRootId !== binding.signer.signingRootId || facts.signingRootVersion !== binding.signer.signingRootVersion || deriveSigningRootId(runtimePolicyScope) !== binding.signer.signingRootId || runtimePolicyScope.signingRootVersion !== binding.signer.signingRootVersion || facts.contextBinding32B64u !== binding.bindingDigest || !participantIdsMatch(facts.participantIds, binding.roleLocalBinding.participantIds) || !binding.signer.scope.targetMemberships.some((target) => ecdsaTargetMembershipKey(target) === ecdsaTargetMembershipKey(facts.chainTarget))) {
-    throw new Error("ECDSA role-local public facts do not match their activation");
-  }
-  const receipt = input.serverActivation.serverActivationReceipt;
-  assertNormalSigningMatchesActivation({
-    normalSigning: input.routerAbEcdsaDerivationNormalSigning,
-    activationBinding: binding,
-    roleLocalPublicFacts: facts,
-    receipt: receipt.protocolReceipt
-  });
-  return new DurableEcdsaMaterialBindingProof({
-    materialActivation: materialActivationFromCommit(receipt.protocolReceipt),
-    routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
-    roleLocalPublicFacts: input.roleLocalPublicFacts,
-    roleLocalBinding: input.activationBinding.roleLocalBinding,
-    durableMaterialRef: input.activationBinding.durableMaterialRef,
-    bindingDigest: input.activationBinding.bindingDigest,
-    lifecycleId: receipt.lifecycleId,
-    ciphertextDigest: input.ciphertextDigest,
-    activationDigest: receipt.activationDigest,
-    activatedAt: receipt.activatedAt,
-    runtimePolicyScope
-  });
-}
-function buildValidatedEncryptedEcdsaReadyMaterial(input) {
-  return new ValidatedEncryptedEcdsaReadyMaterialProof({
-    binding: input.binding,
-    sealingKeyId: input.sealingKeyId,
-    iv12B64u: input.iv12B64u,
-    ciphertextB64u: input.ciphertextB64u
-  });
-}
-function buildActiveEcdsaCapabilityManifest(input) {
-  assertRegisteredPublicFactsMatchBinding(input.registeredPublicFacts, input.activationBinding.roleLocalBinding, input.serverActivation);
-  assertDurableMaterialMatchesActivation(input.durableMaterial, input.activationBinding, input.serverActivation);
-  const signer = new RegisteredEvmFamilySignerProof({
-    preparedSigner: input.activationBinding.signer,
-    registeredPublicFacts: input.registeredPublicFacts
-  });
-  const activation = {
-    kind: "active_ecdsa_material_activation",
-    materialActivation: input.durableMaterial.materialActivation,
-    serverActivation: input.serverActivation,
-    retention: "retained"
-  };
-  return new ActiveEcdsaCapabilityManifestProof({
-    identity: input.activationBinding.targetManifest,
-    signer,
-    activation,
-    durableMaterial: input.durableMaterial,
-    committedAt: input.committedAt
-  });
-}
-function buildReplacedEcdsaCapabilityManifest(input) {
-  assertValidEcdsaReplacement(input.activeManifest, input.replacementManifest);
-  return new ReplacedEcdsaCapabilityManifestProof({
-    identity: input.activeManifest.identity,
-    signer: input.activeManifest.signer,
-    retirement: {
-      kind: "replaced",
-      replacementManifest: input.replacementManifest.identity,
-      replacementActivation: input.replacementManifest.activation.serverActivation
-    }
-  });
-}
-function assertUniqueEcdsaTargetMemberships(targetMemberships) {
-  const targetKeys = targetMemberships.map(ecdsaTargetMembershipKey);
-  if (new Set(targetKeys).size !== targetKeys.length) {
-    throw new Error("ECDSA capability target memberships must be unique");
-  }
-}
-function ecdsaTargetMembershipKey(target) {
-  switch (target.kind) {
-    case "evm":
-      return `evm:${target.namespace}:${target.chainId}:${target.networkSlug}`;
-    case "tempo":
-      return `tempo:${target.chainId}:${target.networkSlug}`;
-    default:
-      return assertNever(target);
-  }
-}
-function assertUniqueParticipantIds(participantIds) {
-  const normalizedIds = participantIds.map(Number);
-  if (normalizedIds.some((participantId) => !Number.isSafeInteger(participantId) || participantId < 1) || new Set(normalizedIds).size !== normalizedIds.length) {
-    throw new Error("ECDSA participant ids must be unique positive integers");
-  }
-}
-function assertTargetManifestTransition(expected, target) {
-  switch (expected.kind) {
-    case "no_current_manifest":
-      if (Number(target.manifestRevision) !== 1) {
-        throw new Error("Initial ECDSA manifest revision must be 1");
-      }
-      return;
-    case "exact_manifest":
-      if (target.manifestId === expected.manifestId || Number(target.manifestRevision) !== Number(expected.manifestRevision) + 1) {
-        throw new Error("Replacement ECDSA manifest must use a fresh id and next revision");
-      }
-      return;
-    default:
-      return assertNever(expected);
-  }
-}
-function assertExpectedStatePair(expectedManifest, expectedGeneration) {
-  switch (expectedManifest.kind) {
-    case "no_current_manifest":
-      if (expectedGeneration.kind !== "no_current_generation") {
-        throw new Error("Initial ECDSA activation cannot expect a server generation");
-      }
-      return;
-    case "exact_manifest":
-      if (expectedGeneration.kind !== "exact_generation") {
-        throw new Error("Replacement ECDSA activation requires an exact server generation");
-      }
-      return;
-    default:
-      return assertNever(expectedManifest);
-  }
-}
-function assertServerCommitMatchesPreparedCommand(serverCommit, journal) {
-  const canonicalRequest = JSON.parse(journal.activationCommand.canonicalRequest);
-  const requestDigestNamesOuterOperation = canonicalRequest.operation === "wallet_registration_activate_v2";
-  if (serverCommit.correlationId !== journal.activationCommand.correlationId || !requestDigestNamesOuterOperation && serverCommit.activationRequestDigest !== journal.activationCommand.requestDigest) {
-    throw new Error("ECDSA server activation commit does not match the prepared command");
-  }
-}
-function assertProtocolReceiptMatchesActivationBinding(receipt, activationBinding) {
-  const publicIdentity = receipt.ecdsa_activation.public_identity;
-  const materialActivation = receipt.ecdsa_activation.material_activation;
-  materialActivationFromCommit(receipt);
-  if (publicIdentity.context_binding_b64u !== String(activationBinding.bindingDigest) || publicIdentity.derivation_client_share_public_key33_b64u !== String(activationBinding.roleLocalBinding.clientVerifyingPublicKey33B64u) || materialActivation.material_owner !== String(activationBinding.signer.materialOwner) || materialActivation.key_binding !== String(activationBinding.bindingDigest) || materialActivation.lifecycle_binding !== receipt.lifecycle_id || materialActivation.signing_worker !== receipt.ecdsa_activation.signing_worker.server_id) {
-    throw new Error("ECDSA activation receipt does not match the prepared material binding");
-  }
-}
-function assertProtocolReceiptMatchesServerCommit(receipt, serverCommit) {
-  const receiptRequestDigest = base64UrlEncode(Uint8Array.from(receipt.activation_request_digest.bytes));
-  if (receipt.activation_correlation_id !== serverCommit.correlationId || receiptRequestDigest !== serverCommit.activationRequestDigest || receipt.server_generation !== serverCommit.serverGeneration) {
-    throw new Error("ECDSA activation receipt does not match the server activation commit");
-  }
-}
-function lifecycleIdFromProtocolReceipt(receipt) {
-  return parseEcdsaLifecycleId(receipt.lifecycle_id);
-}
-function activationDigestFromProtocolReceipt(receipt) {
-  return parseEcdsaActivationDigest(receipt.ecdsa_activation.activation_digest_b64u);
-}
-function materialActivationFromCommit(receipt) {
-  return routerAbMpcMaterialActivationRefFromWire(receipt.ecdsa_activation.material_activation);
-}
-function assertRegisteredPublicFactsMatchBinding(publicFacts, binding, serverActivation) {
-  const receiptPublicIdentity = serverActivation.serverActivationReceipt.protocolReceipt.ecdsa_activation.public_identity;
-  if (String(publicFacts.keyHandle) !== String(binding.keyHandle) || String(publicFacts.publicKeyB64u) !== receiptPublicIdentity.threshold_public_key33_b64u || String(binding.clientVerifyingPublicKey33B64u) !== receiptPublicIdentity.derivation_client_share_public_key33_b64u || !participantIdsMatch(publicFacts.participantIds, binding.participantIds)) {
-    throw new Error("Registered ECDSA public facts do not match role-local material");
-  }
-}
-function participantIdsMatch(left, right) {
-  if (left.length !== right.length)
-    return false;
-  return left.every((participantId, index) => Number(participantId) === Number(right[index]));
-}
-function assertServerActivationMatchesBinding(serverActivation, activationBinding) {
-  assertProtocolReceiptMatchesActivationBinding(serverActivation.serverActivationReceipt.protocolReceipt, activationBinding);
-}
-function assertDurableMaterialMatchesActivation(durableMaterial, activationBinding, serverActivation) {
-  const receipt = serverActivation.serverActivationReceipt;
-  const committedMaterialActivation = materialActivationFromCommit(receipt.protocolReceipt);
-  if (!mpcMaterialActivationRefsEqual(durableMaterial.materialActivation, committedMaterialActivation) || durableMaterial.roleLocalBinding !== activationBinding.roleLocalBinding || durableMaterial.durableMaterialRef !== activationBinding.durableMaterialRef || durableMaterial.bindingDigest !== activationBinding.bindingDigest || durableMaterial.lifecycleId !== receipt.lifecycleId || durableMaterial.activationDigest !== receipt.activationDigest || durableMaterial.activatedAt !== receipt.activatedAt) {
-    throw new Error("Durable ECDSA material does not match its activation");
-  }
-  assertNormalSigningMatchesActivation({
-    normalSigning: durableMaterial.routerAbEcdsaDerivationNormalSigning,
-    activationBinding,
-    roleLocalPublicFacts: durableMaterial.roleLocalPublicFacts,
-    receipt: receipt.protocolReceipt
-  });
-}
-function assertNormalSigningMatchesActivation(input) {
-  const scope = input.normalSigning.scope;
-  const facts = input.roleLocalPublicFacts;
-  const expectedMaterialActivation = materialActivationFromCommit(input.receipt);
-  const expectedMaterialActivationWire = routerAbMpcMaterialActivationRefToWire({
-    kind: expectedMaterialActivation.kind,
-    activationId: expectedMaterialActivation.activationId,
-    capability: expectedMaterialActivation.capability,
-    materialOwner: expectedMaterialActivation.materialOwner,
-    keyBinding: expectedMaterialActivation.keyBinding,
-    lifecycleBinding: expectedMaterialActivation.lifecycleBinding,
-    signingWorker: expectedMaterialActivation.signingWorker
-  });
-  if (scope.wallet_id !== String(input.activationBinding.signer.walletId) || scope.ecdsa_threshold_key_id !== String(input.activationBinding.roleLocalBinding.ecdsaThresholdKeyId) || scope.signing_root_id !== String(input.activationBinding.signer.signingRootId) || scope.signing_root_version !== String(input.activationBinding.signer.signingRootVersion) || scope.context.application_binding_digest_b64u !== input.receipt.ecdsa_activation.context.application_binding_digest_b64u || !sameRouterAbEcdsaDerivationPublicIdentityV1(scope.public_identity, input.receipt.ecdsa_activation.public_identity) || !sameRouterAbServerIdentityV1(scope.signing_worker, input.receipt.ecdsa_activation.signing_worker) || scope.activation_epoch !== input.receipt.ecdsa_activation.activation_epoch || scope.public_identity.context_binding_b64u !== facts.contextBinding32B64u || scope.public_identity.derivation_client_share_public_key33_b64u !== facts.derivationClientSharePublicKey33B64u || scope.public_identity.server_public_key33_b64u !== facts.relayerPublicKey33B64u || scope.public_identity.threshold_public_key33_b64u !== facts.groupPublicKey33B64u || !sameRouterAbMpcMaterialActivationRef(scope.material_activation, expectedMaterialActivationWire)) {
-    throw new Error("ECDSA normal-signing runtime does not match its activation");
-  }
-}
-function assertValidEcdsaReplacement(active, replacement) {
-  if (active.identity.manifestId === replacement.identity.manifestId || Number(replacement.identity.manifestRevision) !== Number(active.identity.manifestRevision) + 1 || active.signer.capability !== replacement.signer.capability || active.signer.signerId !== replacement.signer.signerId || active.signer.walletId !== replacement.signer.walletId || active.signer.authority.authorityDigest !== replacement.signer.authority.authorityDigest || active.signer.materialOwner !== replacement.signer.materialOwner || active.durableMaterial.durableMaterialRef === replacement.durableMaterial.durableMaterialRef || active.activation.serverActivation.serverGeneration === replacement.activation.serverActivation.serverGeneration) {
-    throw new Error("ECDSA replacement manifest does not exactly replace the active manifest");
-  }
-}
-function assertNever(value) {
-  throw new Error(`Unexpected ECDSA capability branch: ${String(value)}`);
-}
+}));
 
 // src/core/indexedDB/schemaNames.ts
 var SEAMS_WALLET_DB_NAME = "seams_wallet";
@@ -5361,466 +4822,1191 @@ var SEAMS_WALLET_SCHEMA_MANIFEST = [
       }
     ]
   }
-];
+];
+
+// src/core/indexedDB/seamsWalletDB/schema.ts
+var SEAMS_WALLET_DB_CONFIG = {
+  dbName: SEAMS_WALLET_DB_NAME,
+  dbVersion: SEAMS_WALLET_DB_VERSION
+};
+function keyPathForIndexedDB(keyPath) {
+  return typeof keyPath === "string" ? keyPath : [...keyPath];
+}
+function createCanonicalStore(db, definition) {
+  const store = db.createObjectStore(definition.store, {
+    keyPath: keyPathForIndexedDB(definition.keyPath)
+  });
+  for (const index of definition.indexes) {
+    store.createIndex(index.name, keyPathForIndexedDB(index.keyPath), { unique: index.unique });
+  }
+}
+function upgradeSeamsWalletDBSchema(db) {
+  for (const definition of SEAMS_WALLET_SCHEMA_MANIFEST) {
+    if (db.objectStoreNames.contains(definition.store))
+      continue;
+    createCanonicalStore(db, definition);
+  }
+}
+
+// src/core/indexedDB/seamsWalletDB/manager.ts
+var INDEXED_DB_BLOCKED_OPEN_TIMEOUT_MS = 3000;
+var INDEXED_DB_OPEN_TIMEOUT_MS = 8000;
+var INDEXED_DB_TRANSACTION_TIMEOUT_MS = 8000;
+function seamsWalletDbOpenBlockedError(dbName) {
+  return new Error(`[SeamsWalletDBManager] IndexedDB open is blocked for ${dbName}. Close other tabs using this app and retry.`);
+}
+function indexedDbTimeoutError(message) {
+  return new Error(message);
+}
+async function withTimeout(promise, ms, error, onTimeout) {
+  let settled = false;
+  let timeout = null;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      if (settled)
+        return;
+      onTimeout?.();
+      reject(error);
+    }, ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    settled = true;
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function runIndexedDbTransactionTask(context, task) {
+  const result = await task(context);
+  await context.tx.done;
+  return result;
+}
+var 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;
+  }
+}
+
+class SeamsWalletDBManager {
+  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 = new Set;
+    this.config = config;
+  }
+  getDbName() {
+    return this.config.dbName;
+  }
+  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();
+      this.closeWalletAuthorityChannel();
+    } else {
+      this.connectWalletAuthorityChannel();
+    }
+  }
+  isDisabled() {
+    return this.disabled;
+  }
+  close() {
+    if (this.dbPromise) {
+      this.dbPromise.then((db) => db.close()).catch(() => {
+        return;
+      });
+      this.dbPromise = null;
+    }
+  }
+  async getDB() {
+    if (this.disabled) {
+      throw new Error("[SeamsWalletDBManager] IndexedDB is disabled in this environment.");
+    }
+    if (!this.dbPromise) {
+      const dbName = this.config.dbName;
+      const dbVersion = this.config.dbVersion;
+      let blockedTimer = null;
+      let rejectBlockedOpen = null;
+      const blockedOpen = new Promise((_resolve, reject) => {
+        rejectBlockedOpen = reject;
+      });
+      const openPromise = openDB(dbName, dbVersion, {
+        upgrade(db) {
+          upgradeSeamsWalletDBSchema(db);
+        },
+        blocked() {
+          console.warn("[SeamsWalletDBManager] IndexedDB open is blocked.", {
+            dbName,
+            dbVersion
+          });
+          blockedTimer = setTimeout(() => {
+            rejectBlockedOpen?.(seamsWalletDbOpenBlockedError(dbName));
+          }, INDEXED_DB_BLOCKED_OPEN_TIMEOUT_MS);
+        },
+        blocking: () => {
+          console.warn("[SeamsWalletDBManager] IndexedDB connection is blocking an upgrade.", {
+            dbName,
+            dbVersion
+          });
+          this.close();
+        },
+        terminated() {
+          console.warn("[SeamsWalletDBManager] IndexedDB connection has been terminated.", {
+            dbName,
+            dbVersion
+          });
+        }
+      });
+      const guardedOpen = withTimeout(Promise.race([openPromise, blockedOpen]).finally(() => {
+        if (blockedTimer)
+          clearTimeout(blockedTimer);
+      }), INDEXED_DB_OPEN_TIMEOUT_MS, indexedDbTimeoutError(`[SeamsWalletDBManager] IndexedDB open timed out for ${dbName}. Close other tabs using this app and retry.`));
+      this.dbPromise = guardedOpen.catch((error) => {
+        this.dbPromise = null;
+        openPromise.then((db) => db.close()).catch(() => {
+          return;
+        });
+        throw error;
+      });
+    }
+    return await this.dbPromise;
+  }
+  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: 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 {
+          tx.abort();
+        } catch {}
+      });
+    } catch (error) {
+      try {
+        tx.abort();
+      } catch {}
+      await tx.done.catch(() => {
+        return;
+      });
+      throw error;
+    }
+  }
+}
+
+// src/core/indexedDB/singletons.ts
+var seamsWalletDB = new SeamsWalletDBManager;
+
+// src/core/signingEngine/workerManager/ecdsaPresignPoolIdentity.ts
+var FIXED_ECDSA_PRESIGN_PROTOCOL_ID = "seams/router-ab-ecdsa-presign/fixed-2of2/v1";
+function requireIdentityString(value, label) {
+  if (typeof value !== "string" || !value)
+    throw new Error(`${label} is required`);
+  if (value.trim() !== value)
+    throw new Error(`${label} must be canonical`);
+  return value;
+}
+function parseEcdsaClientPresignPoolIdentity(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("poolIdentity is required");
+  }
+  const raw = value;
+  if (!Number.isSafeInteger(raw.ownershipGeneration) || Number(raw.ownershipGeneration) < 1) {
+    throw new Error("poolIdentity.ownershipGeneration must be a positive safe integer");
+  }
+  if (raw.pairRole !== "client")
+    throw new Error("poolIdentity.pairRole must be client");
+  if (raw.protocolId !== FIXED_ECDSA_PRESIGN_PROTOCOL_ID) {
+    throw new Error("poolIdentity.protocolId is unsupported");
+  }
+  const relayerUrl = requireIdentityString(raw.relayerUrl, "poolIdentity.relayerUrl");
+  if (relayerUrl.replace(/\/+$/g, "") !== relayerUrl) {
+    throw new Error("poolIdentity.relayerUrl must be canonical");
+  }
+  return {
+    ownershipGeneration: Number(raw.ownershipGeneration),
+    relayerUrl,
+    materialActivationB64u: requireIdentityString(raw.materialActivationB64u, "poolIdentity.materialActivationB64u"),
+    materialActivationId: requireIdentityString(raw.materialActivationId, "poolIdentity.materialActivationId"),
+    capability: requireIdentityString(raw.capability, "poolIdentity.capability"),
+    keyBinding: requireIdentityString(raw.keyBinding, "poolIdentity.keyBinding"),
+    walletId: requireIdentityString(raw.walletId, "poolIdentity.walletId"),
+    signingScopeB64u: requireIdentityString(raw.signingScopeB64u, "poolIdentity.signingScopeB64u"),
+    pairRole: "client",
+    keyEpoch: requireIdentityString(raw.keyEpoch, "poolIdentity.keyEpoch"),
+    activationEpoch: requirePoolRootShareEpoch(raw.activationEpoch),
+    protocolId: FIXED_ECDSA_PRESIGN_PROTOCOL_ID
+  };
+}
+function requirePoolRootShareEpoch(value) {
+  const parsed = parseRootShareEpoch(value);
+  if (!parsed.ok)
+    throw new Error("poolIdentity.activationEpoch is invalid");
+  return parsed.value;
+}
+function equalEcdsaClientPresignPoolIdentity(left, right) {
+  return left.ownershipGeneration === right.ownershipGeneration && left.relayerUrl === right.relayerUrl && left.materialActivationB64u === right.materialActivationB64u && left.materialActivationId === right.materialActivationId && left.capability === right.capability && left.keyBinding === right.keyBinding && left.walletId === right.walletId && left.signingScopeB64u === right.signingScopeB64u && left.pairRole === right.pairRole && left.keyEpoch === right.keyEpoch && left.activationEpoch === right.activationEpoch && left.protocolId === right.protocolId;
+}
+function ecdsaClientPresignPoolKey(identity) {
+  return [
+    identity.protocolId,
+    identity.relayerUrl,
+    identity.signingScopeB64u,
+    identity.materialActivationB64u,
+    identity.ownershipGeneration
+  ].join("|");
+}
 
-// ../../node_modules/idb/build/index.js
-var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-var idbProxyableTypes;
-var cursorAdvanceMethods;
-function getIdbProxyableTypes() {
-  return idbProxyableTypes || (idbProxyableTypes = [
-    IDBDatabase,
-    IDBObjectStore,
-    IDBIndex,
-    IDBCursor,
-    IDBTransaction
-  ]);
+// src/core/config/presignatures.ts
+var ECDSA_CLIENT_PRESIGNATURE_CAPACITY = 5;
+var MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS = 90 * 24 * 60 * 60000;
+
+// src/core/signingEngine/interfaces/ecdsaChainTarget.ts
+function nonEmptyString(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized ? normalized : null;
+}
+function normalizePositiveSafeInteger(value, field) {
+  const normalized = Number(value);
+  if (!Number.isSafeInteger(normalized) || normalized <= 0) {
+    throw new Error(`[threshold-ecdsa] ${field} must be a positive safe integer`);
+  }
+  return normalized;
+}
+function defaultNetworkSlug(kind, chainId) {
+  return kind === "tempo" ? `tempo-${chainId}` : `evm-${chainId}`;
+}
+function toWalletId(value) {
+  const parsed = parseWalletId(value);
+  if (!parsed.ok) {
+    throw new Error(parsed.error.message);
+  }
+  return parsed.value;
+}
+function thresholdEcdsaChainTargetFromChainFamily(args) {
+  const chainId = normalizePositiveSafeInteger(args.chainId, "chainId");
+  const networkSlug = nonEmptyString(args.networkSlug) || defaultNetworkSlug(args.chain, chainId);
+  if (args.chain === "tempo") {
+    return { kind: "tempo", chainId, networkSlug };
+  }
+  return { kind: "evm", namespace: "eip155", chainId, networkSlug };
+}
+function thresholdEcdsaChainTargetFromRequest(args) {
+  const rawKind = String(args.kind ?? args.chain ?? "").trim().toLowerCase();
+  if (rawKind !== "evm" && rawKind !== "tempo") {
+    throw new Error("[threshold-ecdsa] ECDSA request target requires chain kind evm or tempo");
+  }
+  if (rawKind === "evm") {
+    const namespace = String(args.namespace ?? "eip155").trim().toLowerCase();
+    if (namespace !== "eip155") {
+      throw new Error("[threshold-ecdsa] EVM chain target namespace must be eip155");
+    }
+  }
+  return thresholdEcdsaChainTargetFromChainFamily({
+    chain: rawKind,
+    chainId: args.chainId,
+    networkSlug: args.networkSlug
+  });
+}
+
+// ../shared-ts/src/threshold/participants.ts
+function normalizeThresholdEd25519ParticipantId(id) {
+  const n = Number(id);
+  if (!Number.isSafeInteger(n) || n < 1 || n > 65535)
+    return null;
+  return n;
+}
+function normalizeThresholdEd25519ParticipantIds(input) {
+  if (!Array.isArray(input) || input.length === 0)
+    return null;
+  const out = [];
+  const seen = new Set;
+  for (const v of input) {
+    const id = normalizeThresholdEd25519ParticipantId(v);
+    if (!id)
+      return null;
+    if (!seen.has(id)) {
+      seen.add(id);
+      out.push(id);
+    }
+  }
+  out.sort((a, b) => a - b);
+  return out.length ? out : null;
+}
+
+// ../shared-ts/src/utils/emailOtpDomain.ts
+var EMAIL_OTP_CHANNEL = "email_otp";
+
+// ../shared-ts/src/utils/signerDomain.ts
+var WALLET_AUTH_METHODS = {
+  passkey: "passkey",
+  emailOtp: EMAIL_OTP_CHANNEL
+};
+var WALLET_AUTH_METHOD_VALUES = Object.values(WALLET_AUTH_METHODS);
+
+// ../shared-ts/src/utils/thresholdEcdsaKeyHandle.ts
+function requiredString(value, field) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized)
+    throw new Error(`[threshold-ecdsa-key-handle] ${field} is required`);
+  return normalized;
+}
+function normalizedSigningRootVersion(value) {
+  return String(value ?? "").trim() || "default";
+}
+async function deriveThresholdEcdsaKeyHandle(input) {
+  const canonical = alphabetizeStringify({
+    domain: "seams.threshold_ecdsa.key_handle.v1",
+    ecdsaThresholdKeyId: requiredString(input.ecdsaThresholdKeyId, "ecdsaThresholdKeyId"),
+    signingRootId: requiredString(input.signingRootId, "signingRootId"),
+    signingRootVersion: normalizedSigningRootVersion(input.signingRootVersion)
+  });
+  const digest = await sha256BytesUtf8(canonical);
+  return `ederivation-key-${base64UrlEncode(digest)}`;
+}
+// ../shared-ts/src/utils/digestEncoding.ts
+var TEXT_ENCODER = new TextEncoder;
+// src/core/signingEngine/session/identity/evmFamilyEcdsaIdentity.ts
+function requiredString2(value, field) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized)
+    throw new Error(`[evm-family-ecdsa] ${field} is required`);
+  return normalized;
+}
+function normalizeThresholdOwnerAddress(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
+    throw new Error("[evm-family-ecdsa] thresholdOwnerAddress must be an EVM address");
+  }
+  return normalized;
+}
+function toEvmFamilyEcdsaKeyHandle(value) {
+  return requiredString2(value, "keyHandle");
+}
+function toThresholdEcdsaPublicKeyB64u(value) {
+  const normalized = requiredString2(value, "thresholdEcdsaPublicKeyB64u");
+  let bytes;
+  try {
+    bytes = base64UrlDecode(normalized);
+  } catch {
+    throw new Error("[evm-family-ecdsa] thresholdEcdsaPublicKeyB64u must be base64url");
+  }
+  if (bytes.length !== 33) {
+    throw new Error("[evm-family-ecdsa] thresholdEcdsaPublicKeyB64u must decode to 33 bytes");
+  }
+  return normalized;
+}
+function toParticipantId(value) {
+  const normalized = Math.floor(Number(value));
+  if (!Number.isSafeInteger(normalized) || normalized < 1 || normalized > 65535) {
+    throw new Error("[evm-family-ecdsa] participantId must be a positive safe integer");
+  }
+  return normalized;
+}
+function normalizeParticipantIds(value) {
+  const participantIds = normalizeThresholdEd25519ParticipantIds(value);
+  if (!participantIds?.length) {
+    throw new Error("[evm-family-ecdsa] participantIds are required");
+  }
+  return participantIds.map(toParticipantId);
+}
+function buildVerifiedEcdsaPublicFacts(input) {
+  return {
+    kind: "verified_ecdsa_public_facts",
+    keyHandle: input.keyHandle,
+    publicKeyB64u: toThresholdEcdsaPublicKeyB64u(input.publicKeyB64u),
+    participantIds: normalizeParticipantIds(input.participantIds),
+    thresholdOwnerAddress: normalizeThresholdOwnerAddress(input.thresholdOwnerAddress)
+  };
+}
+
+// src/core/signingEngine/session/identity/emailOtpEcdsaDerivationIdentity.ts
+function toEcdsaDerivationThresholdKeyId(value) {
+  return parseSdkEcdsaDerivationThresholdKeyId(value);
+}
+function toEcdsaDerivationSigningRootId(value) {
+  return parseSdkEcdsaDerivationSigningRootId(value);
+}
+function toEcdsaDerivationSigningRootVersion(value) {
+  return parseSdkEcdsaDerivationSigningRootVersion(value);
+}
+
+// src/core/signingEngine/session/persistence/ecdsaRoleLocalRecords.ts
+function requiredString3(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[platform][ecdsa-role-local] ${field} is required`);
+  }
+  return value.trim();
+}
+function parseBase64UrlBytes(value, field, byteLength) {
+  const normalized = requiredString3(value, field);
+  const decoded = base64UrlDecode(normalized);
+  if (decoded.length !== byteLength) {
+    throw new Error(`[platform][ecdsa-role-local] ${field} must decode to ${byteLength} bytes`);
+  }
+  return normalized;
+}
+function parseCompressedSecp256k1PublicKey(value, field) {
+  const normalized = requiredString3(value, field);
+  const decoded = base64UrlDecode(normalized);
+  if (decoded.length !== 33) {
+    throw new Error(`[platform][ecdsa-role-local] ${field} must decode to 33 bytes`);
+  }
+  if (decoded[0] !== 2 && decoded[0] !== 3) {
+    throw new Error(`[platform][ecdsa-role-local] ${field} must be a compressed SEC1 key`);
+  }
+  return normalized;
 }
-function getCursorAdvanceMethods() {
-  return cursorAdvanceMethods || (cursorAdvanceMethods = [
-    IDBCursor.prototype.advance,
-    IDBCursor.prototype.continue,
-    IDBCursor.prototype.continuePrimaryKey
-  ]);
+function parseEcdsaDerivationClientSharePublicKey(value) {
+  return parseCompressedSecp256k1PublicKey(value, "derivationClientSharePublicKey33B64u");
 }
-var transactionDoneMap = new WeakMap;
-var transformCache = new WeakMap;
-var reverseTransformCache = new WeakMap;
-function promisifyRequest(request) {
-  const promise = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      request.removeEventListener("success", success);
-      request.removeEventListener("error", error);
-    };
-    const success = () => {
-      resolve(wrap(request.result));
-      unlisten();
-    };
-    const error = () => {
-      reject(request.error);
-      unlisten();
-    };
-    request.addEventListener("success", success);
-    request.addEventListener("error", error);
-  });
-  reverseTransformCache.set(promise, request);
-  return promise;
+function parseRelayerEcdsaDerivationPublicKey(value) {
+  return parseCompressedSecp256k1PublicKey(value, "relayerPublicKey33B64u");
 }
-function cacheDonePromiseForTransaction(tx) {
-  if (transactionDoneMap.has(tx))
-    return;
-  const done = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      tx.removeEventListener("complete", complete);
-      tx.removeEventListener("error", error);
-      tx.removeEventListener("abort", error);
-    };
-    const complete = () => {
-      resolve();
-      unlisten();
-    };
-    const error = () => {
-      reject(tx.error || new DOMException("AbortError", "AbortError"));
-      unlisten();
-    };
-    tx.addEventListener("complete", complete);
-    tx.addEventListener("error", error);
-    tx.addEventListener("abort", error);
-  });
-  transactionDoneMap.set(tx, done);
+function parseGroupPublicKey(value) {
+  return parseCompressedSecp256k1PublicKey(value, "groupPublicKey33B64u");
 }
-var idbProxyTraps = {
-  get(target, prop, receiver) {
-    if (target instanceof IDBTransaction) {
-      if (prop === "done")
-        return transactionDoneMap.get(target);
-      if (prop === "store") {
-        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+function parseEthereumAddress2(value) {
+  const normalized = requiredString3(value, "ethereumAddress").toLowerCase();
+  if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
+    throw new Error("[platform][ecdsa-role-local] ethereumAddress must be an EVM address");
+  }
+  return normalized;
+}
+function parseParticipantIds(value) {
+  if (!Array.isArray(value) || value.length !== 2 || value[0] !== 1 || value[1] !== 2) {
+    throw new Error("[platform][ecdsa-role-local] participantIds must be [1, 2]");
+  }
+  return [1, 2];
+}
+function parseChainTarget(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("[platform][ecdsa-role-local] chainTarget must be an object");
+  }
+  const kind = requiredString3(Reflect.get(input, "kind"), "chainTarget.kind").toLowerCase();
+  switch (kind) {
+    case "evm": {
+      const fields = Object.keys(input).sort();
+      if (fields.join(",") !== "chainId,kind,namespace,networkSlug") {
+        throw new Error("[platform][ecdsa-role-local] EVM chainTarget fields are invalid");
       }
+      return thresholdEcdsaChainTargetFromRequest({
+        kind: Reflect.get(input, "kind"),
+        namespace: Reflect.get(input, "namespace"),
+        chainId: Reflect.get(input, "chainId"),
+        networkSlug: Reflect.get(input, "networkSlug")
+      });
     }
-    return wrap(target[prop]);
-  },
-  set(target, prop, value) {
-    target[prop] = value;
-    return true;
-  },
-  has(target, prop) {
-    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
-      return true;
+    case "tempo": {
+      const fields = Object.keys(input).sort();
+      if (fields.join(",") !== "chainId,kind,networkSlug") {
+        throw new Error("[platform][ecdsa-role-local] Tempo chainTarget fields are invalid");
+      }
+      return thresholdEcdsaChainTargetFromRequest({
+        kind: Reflect.get(input, "kind"),
+        chainId: Reflect.get(input, "chainId"),
+        networkSlug: Reflect.get(input, "networkSlug")
+      });
     }
-    return prop in target;
+    default:
+      throw new Error("[platform][ecdsa-role-local] chainTarget kind is invalid");
+  }
+}
+function parsePublicFacts(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("[platform][ecdsa-role-local] publicFacts must be an object");
+  }
+  const fields = Object.keys(input).sort();
+  if (fields.join(",") !== "applicationBindingDigestB64u,chainTarget,clientParticipantId,contextBinding32B64u,derivationClientSharePublicKey33B64u,ecdsaThresholdKeyId,ethereumAddress,groupPublicKey33B64u,keyHandle,participantIds,publicCapability,relayerParticipantId,relayerPublicKey33B64u,signingRootId,signingRootVersion,walletId") {
+    throw new Error("[platform][ecdsa-role-local] publicFacts fields are invalid");
+  }
+  if (Reflect.get(input, "clientParticipantId") !== 1) {
+    throw new Error("[platform][ecdsa-role-local] clientParticipantId must be 1");
+  }
+  if (Reflect.get(input, "relayerParticipantId") !== 2) {
+    throw new Error("[platform][ecdsa-role-local] relayerParticipantId must be 2");
+  }
+  const derivationClientSharePublicKey33B64u = parseEcdsaDerivationClientSharePublicKey(Reflect.get(input, "derivationClientSharePublicKey33B64u"));
+  const relayerPublicKey33B64u = parseRelayerEcdsaDerivationPublicKey(Reflect.get(input, "relayerPublicKey33B64u"));
+  if (String(derivationClientSharePublicKey33B64u) === String(relayerPublicKey33B64u)) {
+    throw new Error("[platform][ecdsa-role-local] relayerPublicKey33B64u must differ from derivationClientSharePublicKey33B64u");
+  }
+  return {
+    walletId: toWalletId(Reflect.get(input, "walletId")),
+    chainTarget: parseChainTarget(Reflect.get(input, "chainTarget")),
+    keyHandle: requiredString3(Reflect.get(input, "keyHandle"), "keyHandle"),
+    ecdsaThresholdKeyId: toEcdsaDerivationThresholdKeyId(Reflect.get(input, "ecdsaThresholdKeyId")),
+    signingRootId: toEcdsaDerivationSigningRootId(Reflect.get(input, "signingRootId")),
+    signingRootVersion: toEcdsaDerivationSigningRootVersion(Reflect.get(input, "signingRootVersion")),
+    applicationBindingDigestB64u: parseBase64UrlBytes(Reflect.get(input, "applicationBindingDigestB64u"), "applicationBindingDigestB64u", 32),
+    clientParticipantId: 1,
+    relayerParticipantId: 2,
+    participantIds: parseParticipantIds(Reflect.get(input, "participantIds")),
+    contextBinding32B64u: parseBase64UrlBytes(Reflect.get(input, "contextBinding32B64u"), "contextBinding32B64u", 32),
+    derivationClientSharePublicKey33B64u,
+    relayerPublicKey33B64u,
+    groupPublicKey33B64u: parseGroupPublicKey(Reflect.get(input, "groupPublicKey33B64u")),
+    ethereumAddress: parseEthereumAddress2(Reflect.get(input, "ethereumAddress")),
+    publicCapability: parseRouterAbEcdsaDerivationPublicCapabilityV1(Reflect.get(input, "publicCapability"))
+  };
+}
+function buildEcdsaRoleLocalPublicFacts(input) {
+  return parsePublicFacts(input);
+}
+
+// src/core/signingEngine/session/material/ecdsaCapabilityManifest.ts
+class EcdsaCapabilityManifestProof {
+  retainProof() {
+    return true;
+  }
+  constructor() {
+    this.retainProof();
+  }
+}
+
+class EcdsaCapabilityScopeProof extends EcdsaCapabilityManifestProof {
+  constructor(targetMemberships) {
+    super();
+    this.kind = "evm_family";
+    this.targetMemberships = targetMemberships;
+  }
+}
+
+class EcdsaManifestIdentityProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.manifestId = fields.manifestId;
+    this.manifestRevision = fields.manifestRevision;
+  }
+}
+
+class NoCurrentEcdsaManifestExpectationProof extends EcdsaCapabilityManifestProof {
+  constructor() {
+    super(...arguments);
+    this.kind = "no_current_manifest";
+  }
+}
+
+class ExactEcdsaManifestExpectationProof extends EcdsaCapabilityManifestProof {
+  constructor(identity) {
+    super();
+    this.kind = "exact_manifest";
+    this.manifestId = identity.manifestId;
+    this.manifestRevision = identity.manifestRevision;
+  }
+}
+
+class NoCurrentEcdsaServerGenerationExpectationProof extends EcdsaCapabilityManifestProof {
+  constructor() {
+    super(...arguments);
+    this.kind = "no_current_generation";
+  }
+}
+
+class ExactEcdsaServerGenerationExpectationProof extends EcdsaCapabilityManifestProof {
+  constructor(serverGeneration) {
+    super();
+    this.kind = "exact_generation";
+    this.serverGeneration = serverGeneration;
+  }
+}
+
+class EcdsaRoleLocalMaterialBindingProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "ecdsa_role_local_material_binding";
+    this.keyHandle = fields.keyHandle;
+    this.ecdsaThresholdKeyId = fields.ecdsaThresholdKeyId;
+    this.clientVerifyingPublicKey33B64u = fields.clientVerifyingPublicKey33B64u;
+    this.participantIds = fields.participantIds;
+    this.relayerKeyId = fields.relayerKeyId;
+  }
+}
+
+class PreparedEvmFamilySignerProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "prepared_evm_family_signer";
+    this.capability = fields.capability;
+    this.signerId = fields.signerId;
+    this.walletId = fields.authority.walletId;
+    this.authority = fields.authority;
+    this.scope = fields.scope;
+    this.materialOwner = fields.materialOwner;
+    this.signingRootId = fields.signingRootId;
+    this.signingRootVersion = fields.signingRootVersion;
+  }
+}
+
+class RegisteredEvmFamilySignerProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "registered_evm_family_signer";
+    this.capability = fields.preparedSigner.capability;
+    this.signerId = fields.preparedSigner.signerId;
+    this.walletId = fields.preparedSigner.walletId;
+    this.authority = fields.preparedSigner.authority;
+    this.scope = fields.preparedSigner.scope;
+    this.materialOwner = fields.preparedSigner.materialOwner;
+    this.signingRootId = fields.preparedSigner.signingRootId;
+    this.signingRootVersion = fields.preparedSigner.signingRootVersion;
+    this.registeredPublicFacts = fields.registeredPublicFacts;
   }
-};
-function replaceTraps(callback) {
-  idbProxyTraps = callback(idbProxyTraps);
 }
-function wrapFunction(func) {
-  if (getCursorAdvanceMethods().includes(func)) {
-    return function(...args) {
-      func.apply(unwrap(this), args);
-      return wrap(this.request);
-    };
+
+class EncryptedEcdsaPendingCandidateProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "encrypted_ecdsa_pending_candidate";
+    this.sealingKeyId = fields.sealingKeyId;
+    this.iv12B64u = fields.iv12B64u;
+    this.ciphertextB64u = fields.ciphertextB64u;
+    this.ciphertextDigest = fields.ciphertextDigest;
   }
-  return function(...args) {
-    return wrap(func.apply(unwrap(this), args));
-  };
 }
-function transformCachableValue(value) {
-  if (typeof value === "function")
-    return wrapFunction(value);
-  if (value instanceof IDBTransaction)
-    cacheDonePromiseForTransaction(value);
-  if (instanceOfAny(value, getIdbProxyableTypes()))
-    return new Proxy(value, idbProxyTraps);
-  return value;
+
+class EcdsaActivationBindingProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "ecdsa_activation_binding";
+    this.targetManifest = fields.targetManifest;
+    this.signer = fields.signer;
+    this.roleLocalBinding = fields.roleLocalBinding;
+    this.bindingDigest = fields.bindingDigest;
+    this.durableMaterialRef = fields.durableMaterialRef;
+  }
 }
-function wrap(value) {
-  if (value instanceof IDBRequest)
-    return promisifyRequest(value);
-  if (transformCache.has(value))
-    return transformCache.get(value);
-  const newValue = transformCachableValue(value);
-  if (newValue !== value) {
-    transformCache.set(value, newValue);
-    reverseTransformCache.set(newValue, value);
+
+class PreparedEcdsaActivationCandidateProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "prepared_ecdsa_activation_candidate";
+    this.activationBinding = fields.activationBinding;
+    this.encryptedPending = fields.encryptedPending;
   }
-  return newValue;
 }
-var unwrap = (value) => reverseTransformCache.get(value);
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-  const request = indexedDB.open(name, version);
-  const openPromise = wrap(request);
-  if (upgrade) {
-    request.addEventListener("upgradeneeded", (event) => {
-      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-    });
+
+class EcdsaServerActivationCommandProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "ecdsa_server_activation_command";
+    this.correlationId = fields.correlationId;
+    this.expectedGeneration = fields.expectedGeneration;
+    this.requestDigest = fields.requestDigest;
+    this.canonicalRequest = fields.canonicalRequest;
   }
-  if (blocked) {
-    request.addEventListener("blocked", (event) => blocked(event.oldVersion, event.newVersion, event));
+}
+
+class EcdsaServerActivationReceiptProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "ecdsa_server_activation_receipt";
+    this.lifecycleId = fields.lifecycleId;
+    this.activationDigest = fields.activationDigest;
+    this.activatedAt = fields.activatedAt;
+    this.protocolReceipt = fields.protocolReceipt;
   }
-  openPromise.then((db) => {
-    if (terminated)
-      db.addEventListener("close", () => terminated());
-    if (blocking) {
-      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
-    }
-  }).catch(() => {});
-  return openPromise;
 }
-var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
-var writeMethods = ["put", "add", "delete", "clear"];
-var cachedMethods = new Map;
-function getMethod(target, prop) {
-  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
-    return;
+
+class EcdsaServerActivationCommitProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "ecdsa_server_activation_commit";
+    this.correlationId = fields.correlationId;
+    this.activationRequestDigest = fields.activationRequestDigest;
+    this.serverGeneration = fields.serverGeneration;
+    this.serverActivationReceipt = fields.serverActivationReceipt;
   }
-  if (cachedMethods.get(prop))
-    return cachedMethods.get(prop);
-  const targetFuncName = prop.replace(/FromIndex$/, "");
-  const useIndex = prop !== targetFuncName;
-  const isWrite = writeMethods.includes(targetFuncName);
-  if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
-    return;
+}
+
+class PreparedEcdsaActivationJournalProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "activation_prepared";
+    this.journalId = fields.journalId;
+    this.expectedManifest = fields.expectedManifest;
+    this.activationCommand = fields.activationCommand;
+    this.candidate = fields.candidate;
+    this.createdAt = fields.createdAt;
   }
-  const method = async function(storeName, ...args) {
-    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
-    let target = tx.store;
-    if (useIndex)
-      target = target.index(args.shift());
-    return (await Promise.all([
-      target[targetFuncName](...args),
-      isWrite && tx.done
-    ]))[0];
-  };
-  cachedMethods.set(prop, method);
-  return method;
 }
-replaceTraps((oldTraps) => ({
-  ...oldTraps,
-  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
-}));
-var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
-var methodMap = {};
-var advanceResults = new WeakMap;
-var ittrProxiedCursorToOriginalProxy = new WeakMap;
-var cursorIteratorTraps = {
-  get(target, prop) {
-    if (!advanceMethodProps.includes(prop))
-      return target[prop];
-    let cachedFunc = methodMap[prop];
-    if (!cachedFunc) {
-      cachedFunc = methodMap[prop] = function(...args) {
-        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-      };
-    }
-    return cachedFunc;
+
+class ServerCommittedEcdsaActivationJournalProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "server_activation_committed";
+    this.journalId = fields.journalId;
+    this.expectedManifest = fields.expectedManifest;
+    this.activationCommand = fields.activationCommand;
+    this.candidate = fields.candidate;
+    this.createdAt = fields.createdAt;
+    this.serverActivation = fields.serverActivation;
   }
-};
-async function* iterate(...args) {
-  let cursor = this;
-  if (!(cursor instanceof IDBCursor)) {
-    cursor = await cursor.openCursor(...args);
+}
+
+class DurableEcdsaMaterialBindingProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "durable_ecdsa_material";
+    this.materialActivation = fields.materialActivation;
+    this.routerAbEcdsaDerivationNormalSigning = fields.routerAbEcdsaDerivationNormalSigning;
+    this.roleLocalPublicFacts = fields.roleLocalPublicFacts;
+    this.roleLocalBinding = fields.roleLocalBinding;
+    this.durableMaterialRef = fields.durableMaterialRef;
+    this.bindingDigest = fields.bindingDigest;
+    this.lifecycleId = fields.lifecycleId;
+    this.ciphertextDigest = fields.ciphertextDigest;
+    this.activationDigest = fields.activationDigest;
+    this.activatedAt = fields.activatedAt;
+    this.runtimePolicyScope = fields.runtimePolicyScope;
   }
-  if (!cursor)
-    return;
-  cursor = cursor;
-  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-  while (cursor) {
-    yield proxiedCursor;
-    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-    advanceResults.delete(proxiedCursor);
+}
+
+class ValidatedEncryptedEcdsaReadyMaterialProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "encrypted_ecdsa_ready_material";
+    this.binding = fields.binding;
+    this.sealingKeyId = fields.sealingKeyId;
+    this.iv12B64u = fields.iv12B64u;
+    this.ciphertextB64u = fields.ciphertextB64u;
   }
 }
-function isIteratorProp(target, prop) {
-  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+
+class ActiveEcdsaCapabilityManifestProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "active_ecdsa_capability_manifest";
+    this.identity = fields.identity;
+    this.signer = fields.signer;
+    this.activation = fields.activation;
+    this.durableMaterial = fields.durableMaterial;
+    this.committedAt = fields.committedAt;
+  }
+}
+
+class ReplacedEcdsaCapabilityManifestProof extends EcdsaCapabilityManifestProof {
+  constructor(fields) {
+    super();
+    this.kind = "replaced_ecdsa_capability_manifest";
+    this.identity = fields.identity;
+    this.signer = fields.signer;
+    this.retirement = fields.retirement;
+  }
+}
+function unwrapDomainId(result) {
+  if (!result.ok)
+    throw new Error(result.error.message);
+  return result.value;
+}
+function buildEcdsaCapabilityScope(input) {
+  assertUniqueEcdsaTargetMemberships(input.targetMemberships);
+  return new EcdsaCapabilityScopeProof([...input.targetMemberships]);
+}
+function buildEcdsaManifestIdentity(input) {
+  return new EcdsaManifestIdentityProof(input);
+}
+function buildNoCurrentEcdsaManifestExpectation() {
+  return new NoCurrentEcdsaManifestExpectationProof;
+}
+function buildExactEcdsaManifestExpectation(identity) {
+  return new ExactEcdsaManifestExpectationProof(identity);
+}
+function buildNoCurrentEcdsaServerGenerationExpectation() {
+  return new NoCurrentEcdsaServerGenerationExpectationProof;
 }
-replaceTraps((oldTraps) => ({
-  ...oldTraps,
-  get(target, prop, receiver) {
-    if (isIteratorProp(target, prop))
-      return iterate;
-    return oldTraps.get(target, prop, receiver);
-  },
-  has(target, prop) {
-    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-  }
-}));
-
-// src/core/indexedDB/seamsWalletDB/schema.ts
-var SEAMS_WALLET_DB_CONFIG = {
-  dbName: SEAMS_WALLET_DB_NAME,
-  dbVersion: SEAMS_WALLET_DB_VERSION
-};
-function keyPathForIndexedDB(keyPath) {
-  return typeof keyPath === "string" ? keyPath : [...keyPath];
+function buildExactEcdsaServerGenerationExpectation(serverGeneration) {
+  return new ExactEcdsaServerGenerationExpectationProof(serverGeneration);
 }
-function createCanonicalStore(db, definition) {
-  const store = db.createObjectStore(definition.store, {
-    keyPath: keyPathForIndexedDB(definition.keyPath)
+function buildEcdsaRoleLocalMaterialBinding(input) {
+  assertUniqueParticipantIds(input.participantIds);
+  return new EcdsaRoleLocalMaterialBindingProof({
+    keyHandle: input.keyHandle,
+    ecdsaThresholdKeyId: input.ecdsaThresholdKeyId,
+    clientVerifyingPublicKey33B64u: input.clientVerifyingPublicKey33B64u,
+    participantIds: [...input.participantIds],
+    relayerKeyId: input.relayerKeyId
   });
-  for (const index of definition.indexes) {
-    store.createIndex(index.name, keyPathForIndexedDB(index.keyPath), { unique: index.unique });
-  }
 }
-function upgradeSeamsWalletDBSchema(db) {
-  for (const definition of SEAMS_WALLET_SCHEMA_MANIFEST) {
-    if (db.objectStoreNames.contains(definition.store))
-      continue;
-    createCanonicalStore(db, definition);
-  }
+function buildPreparedEvmFamilySigner(input) {
+  return new PreparedEvmFamilySignerProof(input);
 }
-
-// src/core/indexedDB/seamsWalletDB/manager.ts
-var INDEXED_DB_BLOCKED_OPEN_TIMEOUT_MS = 3000;
-var INDEXED_DB_OPEN_TIMEOUT_MS = 8000;
-var INDEXED_DB_TRANSACTION_TIMEOUT_MS = 8000;
-function seamsWalletDbOpenBlockedError(dbName) {
-  return new Error(`[SeamsWalletDBManager] IndexedDB open is blocked for ${dbName}. Close other tabs using this app and retry.`);
+function buildEncryptedEcdsaPendingCandidate(input) {
+  return new EncryptedEcdsaPendingCandidateProof(input);
 }
-function indexedDbTimeoutError(message) {
-  return new Error(message);
+function buildEcdsaActivationBinding(input) {
+  return new EcdsaActivationBindingProof(input);
 }
-async function withTimeout(promise, ms, error, onTimeout) {
-  let settled = false;
-  let timeout = null;
-  const timeoutPromise = new Promise((_resolve, reject) => {
-    timeout = setTimeout(() => {
-      if (settled)
-        return;
-      onTimeout?.();
-      reject(error);
-    }, ms);
+function buildPreparedEcdsaActivationCandidate(input) {
+  return new PreparedEcdsaActivationCandidateProof(input);
+}
+function buildPreparedEcdsaActivationJournal(input) {
+  assertTargetManifestTransition(input.expectedManifest, input.candidate.activationBinding.targetManifest);
+  assertExpectedStatePair(input.expectedManifest, input.expectedGeneration);
+  const activationCommand = new EcdsaServerActivationCommandProof({
+    correlationId: input.journalId,
+    expectedGeneration: input.expectedGeneration,
+    requestDigest: input.requestDigest,
+    canonicalRequest: input.canonicalRequest
+  });
+  return new PreparedEcdsaActivationJournalProof({
+    journalId: input.journalId,
+    expectedManifest: input.expectedManifest,
+    activationCommand,
+    candidate: input.candidate,
+    createdAt: input.createdAt
   });
-  try {
-    return await Promise.race([promise, timeoutPromise]);
-  } finally {
-    settled = true;
-    if (timeout)
-      clearTimeout(timeout);
-  }
 }
-async function runIndexedDbTransactionTask(context, task) {
-  const result = await task(context);
-  await context.tx.done;
-  return result;
+function buildEcdsaServerActivationCommit(input) {
+  const protocolReceipt = parseRouterAbEcdsaRegistrationActivationReceiptV1(input.serverCommit.protocolReceipt);
+  assertProtocolReceiptMatchesServerCommit(protocolReceipt, input.serverCommit);
+  assertProtocolReceiptMatchesActivationBinding(protocolReceipt, input.activationBinding);
+  const serverActivationReceipt = new EcdsaServerActivationReceiptProof({
+    lifecycleId: lifecycleIdFromProtocolReceipt(protocolReceipt),
+    activationDigest: activationDigestFromProtocolReceipt(protocolReceipt),
+    activatedAt: isoTimestampFromUnixMs(protocolReceipt.ecdsa_activation.activated_at_ms),
+    protocolReceipt
+  });
+  return new EcdsaServerActivationCommitProof({
+    correlationId: input.serverCommit.correlationId,
+    activationRequestDigest: input.serverCommit.activationRequestDigest,
+    serverGeneration: input.serverCommit.serverGeneration,
+    serverActivationReceipt
+  });
 }
-
-class SeamsWalletDBManager {
-  constructor(config = SEAMS_WALLET_DB_CONFIG) {
-    this.dbPromise = null;
-    this.disabled = false;
-    this.config = config;
-  }
-  getDbName() {
-    return this.config.dbName;
-  }
-  setDbName(dbName) {
-    if (this.config.dbName === dbName)
-      return;
-    this.close();
-    this.config = { ...this.config, dbName };
-  }
-  setDisabled(disabled) {
-    this.disabled = disabled;
-    if (disabled)
-      this.close();
-  }
-  isDisabled() {
-    return this.disabled;
-  }
-  close() {
-    if (this.dbPromise) {
-      this.dbPromise.then((db) => db.close()).catch(() => {
-        return;
-      });
-      this.dbPromise = null;
-    }
+function buildServerCommittedEcdsaActivationJournal(input) {
+  assertServerCommitMatchesPreparedCommand(input.serverCommit, input.preparedJournal);
+  const serverActivation = buildEcdsaServerActivationCommit({
+    activationBinding: input.preparedJournal.candidate.activationBinding,
+    serverCommit: input.serverCommit
+  });
+  return new ServerCommittedEcdsaActivationJournalProof({
+    journalId: input.preparedJournal.journalId,
+    expectedManifest: input.preparedJournal.expectedManifest,
+    activationCommand: input.preparedJournal.activationCommand,
+    candidate: input.preparedJournal.candidate,
+    createdAt: input.preparedJournal.createdAt,
+    serverActivation
+  });
+}
+function buildDurableEcdsaMaterialBinding(input) {
+  assertServerActivationMatchesBinding(input.serverActivation, input.activationBinding);
+  const facts = input.roleLocalPublicFacts;
+  const binding = input.activationBinding;
+  const runtimePolicyScope = normalizeRuntimePolicyScope(input.runtimePolicyScope);
+  if (facts.walletId !== binding.signer.walletId || facts.keyHandle !== binding.roleLocalBinding.keyHandle || facts.ecdsaThresholdKeyId !== binding.roleLocalBinding.ecdsaThresholdKeyId || facts.signingRootId !== binding.signer.signingRootId || facts.signingRootVersion !== binding.signer.signingRootVersion || deriveSigningRootId(runtimePolicyScope) !== binding.signer.signingRootId || runtimePolicyScope.signingRootVersion !== binding.signer.signingRootVersion || facts.contextBinding32B64u !== binding.bindingDigest || !participantIdsMatch(facts.participantIds, binding.roleLocalBinding.participantIds) || !binding.signer.scope.targetMemberships.some((target) => ecdsaTargetMembershipKey(target) === ecdsaTargetMembershipKey(facts.chainTarget))) {
+    throw new Error("ECDSA role-local public facts do not match their activation");
   }
-  async getDB() {
-    if (this.disabled) {
-      throw new Error("[SeamsWalletDBManager] IndexedDB is disabled in this environment.");
-    }
-    if (!this.dbPromise) {
-      const dbName = this.config.dbName;
-      const dbVersion = this.config.dbVersion;
-      let blockedTimer = null;
-      let rejectBlockedOpen = null;
-      const blockedOpen = new Promise((_resolve, reject) => {
-        rejectBlockedOpen = reject;
-      });
-      const openPromise = openDB(dbName, dbVersion, {
-        upgrade(db) {
-          upgradeSeamsWalletDBSchema(db);
-        },
-        blocked() {
-          console.warn("[SeamsWalletDBManager] IndexedDB open is blocked.", {
-            dbName,
-            dbVersion
-          });
-          blockedTimer = setTimeout(() => {
-            rejectBlockedOpen?.(seamsWalletDbOpenBlockedError(dbName));
-          }, INDEXED_DB_BLOCKED_OPEN_TIMEOUT_MS);
-        },
-        blocking: () => {
-          console.warn("[SeamsWalletDBManager] IndexedDB connection is blocking an upgrade.", {
-            dbName,
-            dbVersion
-          });
-          this.close();
-        },
-        terminated() {
-          console.warn("[SeamsWalletDBManager] IndexedDB connection has been terminated.", {
-            dbName,
-            dbVersion
-          });
-        }
-      });
-      const guardedOpen = withTimeout(Promise.race([openPromise, blockedOpen]).finally(() => {
-        if (blockedTimer)
-          clearTimeout(blockedTimer);
-      }), INDEXED_DB_OPEN_TIMEOUT_MS, indexedDbTimeoutError(`[SeamsWalletDBManager] IndexedDB open timed out for ${dbName}. Close other tabs using this app and retry.`));
-      this.dbPromise = guardedOpen.catch((error) => {
-        this.dbPromise = null;
-        openPromise.then((db) => db.close()).catch(() => {
-          return;
-        });
-        throw error;
-      });
+  const receipt = input.serverActivation.serverActivationReceipt;
+  assertNormalSigningMatchesActivation({
+    normalSigning: input.routerAbEcdsaDerivationNormalSigning,
+    activationBinding: binding,
+    roleLocalPublicFacts: facts,
+    receipt: receipt.protocolReceipt
+  });
+  return new DurableEcdsaMaterialBindingProof({
+    materialActivation: materialActivationFromCommit(receipt.protocolReceipt),
+    routerAbEcdsaDerivationNormalSigning: input.routerAbEcdsaDerivationNormalSigning,
+    roleLocalPublicFacts: input.roleLocalPublicFacts,
+    roleLocalBinding: input.activationBinding.roleLocalBinding,
+    durableMaterialRef: input.activationBinding.durableMaterialRef,
+    bindingDigest: input.activationBinding.bindingDigest,
+    lifecycleId: receipt.lifecycleId,
+    ciphertextDigest: input.ciphertextDigest,
+    activationDigest: receipt.activationDigest,
+    activatedAt: receipt.activatedAt,
+    runtimePolicyScope
+  });
+}
+function buildValidatedEncryptedEcdsaReadyMaterial(input) {
+  return new ValidatedEncryptedEcdsaReadyMaterialProof({
+    binding: input.binding,
+    sealingKeyId: input.sealingKeyId,
+    iv12B64u: input.iv12B64u,
+    ciphertextB64u: input.ciphertextB64u
+  });
+}
+function buildActiveEcdsaCapabilityManifest(input) {
+  assertRegisteredPublicFactsMatchBinding(input.registeredPublicFacts, input.activationBinding.roleLocalBinding, input.serverActivation);
+  assertDurableMaterialMatchesActivation(input.durableMaterial, input.activationBinding, input.serverActivation);
+  const signer = new RegisteredEvmFamilySignerProof({
+    preparedSigner: input.activationBinding.signer,
+    registeredPublicFacts: input.registeredPublicFacts
+  });
+  const activation = {
+    kind: "active_ecdsa_material_activation",
+    materialActivation: input.durableMaterial.materialActivation,
+    serverActivation: input.serverActivation,
+    retention: "retained"
+  };
+  return new ActiveEcdsaCapabilityManifestProof({
+    identity: input.activationBinding.targetManifest,
+    signer,
+    activation,
+    durableMaterial: input.durableMaterial,
+    committedAt: input.committedAt
+  });
+}
+function buildReplacedEcdsaCapabilityManifest(input) {
+  assertValidEcdsaReplacement(input.activeManifest, input.replacementManifest);
+  return new ReplacedEcdsaCapabilityManifestProof({
+    identity: input.activeManifest.identity,
+    signer: input.activeManifest.signer,
+    retirement: {
+      kind: "replaced",
+      replacementManifest: input.replacementManifest.identity,
+      replacementActivation: input.replacementManifest.activation.serverActivation
     }
-    return await this.dbPromise;
+  });
+}
+function assertUniqueEcdsaTargetMemberships(targetMemberships) {
+  const targetKeys = targetMemberships.map(ecdsaTargetMembershipKey);
+  if (new Set(targetKeys).size !== targetKeys.length) {
+    throw new Error("ECDSA capability target memberships must be unique");
   }
-  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 context = {
-      db,
-      tx,
-      store(name) {
-        return tx.objectStore(name);
+}
+function ecdsaTargetMembershipKey(target) {
+  switch (target.kind) {
+    case "evm":
+      return `evm:${target.namespace}:${target.chainId}:${target.networkSlug}`;
+    case "tempo":
+      return `tempo:${target.chainId}:${target.networkSlug}`;
+    default:
+      return assertNever(target);
+  }
+}
+function assertUniqueParticipantIds(participantIds) {
+  const normalizedIds = participantIds.map(Number);
+  if (normalizedIds.some((participantId) => !Number.isSafeInteger(participantId) || participantId < 1) || new Set(normalizedIds).size !== normalizedIds.length) {
+    throw new Error("ECDSA participant ids must be unique positive integers");
+  }
+}
+function assertTargetManifestTransition(expected, target) {
+  switch (expected.kind) {
+    case "no_current_manifest":
+      if (Number(target.manifestRevision) !== 1) {
+        throw new Error("Initial ECDSA manifest revision must be 1");
       }
-    };
-    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 {
-          tx.abort();
-        } catch {}
-      });
-    } catch (error) {
-      try {
-        tx.abort();
-      } catch {}
-      await tx.done.catch(() => {
-        return;
-      });
-      throw error;
-    }
+      return;
+    case "exact_manifest":
+      if (target.manifestId === expected.manifestId || Number(target.manifestRevision) !== Number(expected.manifestRevision) + 1) {
+        throw new Error("Replacement ECDSA manifest must use a fresh id and next revision");
+      }
+      return;
+    default:
+      return assertNever(expected);
   }
 }
-
-// src/core/indexedDB/singletons.ts
-var seamsWalletDB = new SeamsWalletDBManager;
-
-// src/core/signingEngine/workerManager/ecdsaPresignPoolIdentity.ts
-var FIXED_ECDSA_PRESIGN_PROTOCOL_ID = "seams/router-ab-ecdsa-presign/fixed-2of2/v1";
-function requireIdentityString(value, label) {
-  if (typeof value !== "string" || !value)
-    throw new Error(`${label} is required`);
-  if (value.trim() !== value)
-    throw new Error(`${label} must be canonical`);
-  return value;
+function assertExpectedStatePair(expectedManifest, expectedGeneration) {
+  switch (expectedManifest.kind) {
+    case "no_current_manifest":
+      if (expectedGeneration.kind !== "no_current_generation") {
+        throw new Error("Initial ECDSA activation cannot expect a server generation");
+      }
+      return;
+    case "exact_manifest":
+      if (expectedGeneration.kind !== "exact_generation") {
+        throw new Error("Replacement ECDSA activation requires an exact server generation");
+      }
+      return;
+    default:
+      return assertNever(expectedManifest);
+  }
 }
-function parseEcdsaClientPresignPoolIdentity(value) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error("poolIdentity is required");
+function assertServerCommitMatchesPreparedCommand(serverCommit, journal) {
+  const canonicalRequest = JSON.parse(journal.activationCommand.canonicalRequest);
+  const requestDigestNamesOuterOperation = canonicalRequest.operation === "wallet_registration_activate_v2";
+  if (serverCommit.correlationId !== journal.activationCommand.correlationId || !requestDigestNamesOuterOperation && serverCommit.activationRequestDigest !== journal.activationCommand.requestDigest) {
+    throw new Error("ECDSA server activation commit does not match the prepared command");
   }
-  const raw = value;
-  if (raw.pairRole !== "client")
-    throw new Error("poolIdentity.pairRole must be client");
-  if (raw.protocolId !== FIXED_ECDSA_PRESIGN_PROTOCOL_ID) {
-    throw new Error("poolIdentity.protocolId is unsupported");
+}
+function assertProtocolReceiptMatchesActivationBinding(receipt, activationBinding) {
+  const publicIdentity = receipt.ecdsa_activation.public_identity;
+  const materialActivation = receipt.ecdsa_activation.material_activation;
+  materialActivationFromCommit(receipt);
+  if (publicIdentity.context_binding_b64u !== String(activationBinding.bindingDigest) || publicIdentity.derivation_client_share_public_key33_b64u !== String(activationBinding.roleLocalBinding.clientVerifyingPublicKey33B64u) || materialActivation.material_owner !== String(activationBinding.signer.materialOwner) || materialActivation.key_binding !== String(activationBinding.bindingDigest) || materialActivation.lifecycle_binding !== receipt.lifecycle_id || materialActivation.signing_worker !== receipt.ecdsa_activation.signing_worker.server_id) {
+    throw new Error("ECDSA activation receipt does not match the prepared material binding");
   }
-  const relayerUrl = requireIdentityString(raw.relayerUrl, "poolIdentity.relayerUrl");
-  if (relayerUrl.replace(/\/+$/g, "") !== relayerUrl) {
-    throw new Error("poolIdentity.relayerUrl must be canonical");
+}
+function assertProtocolReceiptMatchesServerCommit(receipt, serverCommit) {
+  const receiptRequestDigest = base64UrlEncode(Uint8Array.from(receipt.activation_request_digest.bytes));
+  if (receipt.activation_correlation_id !== serverCommit.correlationId || receiptRequestDigest !== serverCommit.activationRequestDigest || receipt.server_generation !== serverCommit.serverGeneration) {
+    throw new Error("ECDSA activation receipt does not match the server activation commit");
   }
-  return {
-    relayerUrl,
-    materialActivationB64u: requireIdentityString(raw.materialActivationB64u, "poolIdentity.materialActivationB64u"),
-    materialActivationId: requireIdentityString(raw.materialActivationId, "poolIdentity.materialActivationId"),
-    capability: requireIdentityString(raw.capability, "poolIdentity.capability"),
-    keyBinding: requireIdentityString(raw.keyBinding, "poolIdentity.keyBinding"),
-    walletId: requireIdentityString(raw.walletId, "poolIdentity.walletId"),
-    signingScopeB64u: requireIdentityString(raw.signingScopeB64u, "poolIdentity.signingScopeB64u"),
-    pairRole: "client",
-    keyEpoch: requireIdentityString(raw.keyEpoch, "poolIdentity.keyEpoch"),
-    activationEpoch: requirePoolRootShareEpoch(raw.activationEpoch),
-    protocolId: FIXED_ECDSA_PRESIGN_PROTOCOL_ID
-  };
 }
-function requirePoolRootShareEpoch(value) {
-  const parsed = parseRootShareEpoch(value);
-  if (!parsed.ok)
-    throw new Error("poolIdentity.activationEpoch is invalid");
-  return parsed.value;
+function lifecycleIdFromProtocolReceipt(receipt) {
+  return parseEcdsaLifecycleId(receipt.lifecycle_id);
 }
-function equalEcdsaClientPresignPoolIdentity(left, right) {
-  return left.relayerUrl === right.relayerUrl && left.materialActivationB64u === right.materialActivationB64u && left.materialActivationId === right.materialActivationId && left.capability === right.capability && left.keyBinding === right.keyBinding && left.walletId === right.walletId && left.signingScopeB64u === right.signingScopeB64u && left.pairRole === right.pairRole && left.keyEpoch === right.keyEpoch && left.activationEpoch === right.activationEpoch && left.protocolId === right.protocolId;
+function activationDigestFromProtocolReceipt(receipt) {
+  return parseEcdsaActivationDigest(receipt.ecdsa_activation.activation_digest_b64u);
 }
-function ecdsaClientPresignPoolKey(identity) {
-  return [
-    identity.protocolId,
-    identity.relayerUrl,
-    identity.signingScopeB64u,
-    identity.materialActivationB64u
-  ].join("|");
+function materialActivationFromCommit(receipt) {
+  return routerAbMpcMaterialActivationRefFromWire(receipt.ecdsa_activation.material_activation);
+}
+function assertRegisteredPublicFactsMatchBinding(publicFacts, binding, serverActivation) {
+  const receiptPublicIdentity = serverActivation.serverActivationReceipt.protocolReceipt.ecdsa_activation.public_identity;
+  if (String(publicFacts.keyHandle) !== String(binding.keyHandle) || String(publicFacts.publicKeyB64u) !== receiptPublicIdentity.threshold_public_key33_b64u || String(binding.clientVerifyingPublicKey33B64u) !== receiptPublicIdentity.derivation_client_share_public_key33_b64u || !participantIdsMatch(publicFacts.participantIds, binding.participantIds)) {
+    throw new Error("Registered ECDSA public facts do not match role-local material");
+  }
+}
+function participantIdsMatch(left, right) {
+  if (left.length !== right.length)
+    return false;
+  return left.every((participantId, index) => Number(participantId) === Number(right[index]));
+}
+function assertServerActivationMatchesBinding(serverActivation, activationBinding) {
+  assertProtocolReceiptMatchesActivationBinding(serverActivation.serverActivationReceipt.protocolReceipt, activationBinding);
+}
+function assertDurableMaterialMatchesActivation(durableMaterial, activationBinding, serverActivation) {
+  const receipt = serverActivation.serverActivationReceipt;
+  const committedMaterialActivation = materialActivationFromCommit(receipt.protocolReceipt);
+  if (!mpcMaterialActivationRefsEqual(durableMaterial.materialActivation, committedMaterialActivation) || durableMaterial.roleLocalBinding !== activationBinding.roleLocalBinding || durableMaterial.durableMaterialRef !== activationBinding.durableMaterialRef || durableMaterial.bindingDigest !== activationBinding.bindingDigest || durableMaterial.lifecycleId !== receipt.lifecycleId || durableMaterial.activationDigest !== receipt.activationDigest || durableMaterial.activatedAt !== receipt.activatedAt) {
+    throw new Error("Durable ECDSA material does not match its activation");
+  }
+  assertNormalSigningMatchesActivation({
+    normalSigning: durableMaterial.routerAbEcdsaDerivationNormalSigning,
+    activationBinding,
+    roleLocalPublicFacts: durableMaterial.roleLocalPublicFacts,
+    receipt: receipt.protocolReceipt
+  });
+}
+function assertNormalSigningMatchesActivation(input) {
+  const scope = input.normalSigning.scope;
+  const facts = input.roleLocalPublicFacts;
+  const expectedMaterialActivation = materialActivationFromCommit(input.receipt);
+  const expectedMaterialActivationWire = routerAbMpcMaterialActivationRefToWire({
+    kind: expectedMaterialActivation.kind,
+    activationId: expectedMaterialActivation.activationId,
+    capability: expectedMaterialActivation.capability,
+    materialOwner: expectedMaterialActivation.materialOwner,
+    keyBinding: expectedMaterialActivation.keyBinding,
+    lifecycleBinding: expectedMaterialActivation.lifecycleBinding,
+    signingWorker: expectedMaterialActivation.signingWorker
+  });
+  if (scope.wallet_id !== String(input.activationBinding.signer.walletId) || scope.ecdsa_threshold_key_id !== String(input.activationBinding.roleLocalBinding.ecdsaThresholdKeyId) || scope.signing_root_id !== String(input.activationBinding.signer.signingRootId) || scope.signing_root_version !== String(input.activationBinding.signer.signingRootVersion) || scope.context.application_binding_digest_b64u !== input.receipt.ecdsa_activation.context.application_binding_digest_b64u || !sameRouterAbEcdsaDerivationPublicIdentityV1(scope.public_identity, input.receipt.ecdsa_activation.public_identity) || !sameRouterAbServerIdentityV1(scope.signing_worker, input.receipt.ecdsa_activation.signing_worker) || scope.activation_epoch !== input.receipt.ecdsa_activation.activation_epoch || scope.public_identity.context_binding_b64u !== facts.contextBinding32B64u || scope.public_identity.derivation_client_share_public_key33_b64u !== facts.derivationClientSharePublicKey33B64u || scope.public_identity.server_public_key33_b64u !== facts.relayerPublicKey33B64u || scope.public_identity.threshold_public_key33_b64u !== facts.groupPublicKey33B64u || !sameRouterAbMpcMaterialActivationRef(scope.material_activation, expectedMaterialActivationWire)) {
+    throw new Error("ECDSA normal-signing runtime does not match its activation");
+  }
+}
+function assertValidEcdsaReplacement(active, replacement) {
+  if (active.identity.manifestId === replacement.identity.manifestId || Number(replacement.identity.manifestRevision) !== Number(active.identity.manifestRevision) + 1 || active.signer.capability !== replacement.signer.capability || active.signer.signerId !== replacement.signer.signerId || active.signer.walletId !== replacement.signer.walletId || active.signer.authority.authorityDigest !== replacement.signer.authority.authorityDigest || active.signer.materialOwner !== replacement.signer.materialOwner || active.durableMaterial.durableMaterialRef === replacement.durableMaterial.durableMaterialRef || active.activation.serverActivation.serverGeneration === replacement.activation.serverActivation.serverGeneration) {
+    throw new Error("ECDSA replacement manifest does not exactly replace the active manifest");
+  }
+}
+function assertNever(value) {
+  throw new Error(`Unexpected ECDSA capability branch: ${String(value)}`);
 }
-
-// src/core/signingEngine/workerManager/ecdsaPresignLifecycle.ts
-var ECDSA_CLIENT_PRESIGNATURE_CAPACITY = 5;
-var MAX_DURABLE_CLIENT_PRESIGNATURE_LIFETIME_MS = 90 * 24 * 60 * 60000;
 
 // src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestRecords.ts
 var MANIFEST_RECORD_VERSION = "ecdsa_capability_manifest_v3";
@@ -6787,6 +6973,9 @@ 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));
+  if (poolIdentity.ownershipGeneration === 1) {
+    rows.push(...await store.index(SEAMS_WALLET_INDEXES.poolIdentityKey).getAll(initialGenerationPoolKey(poolIdentity)));
+  }
   const available = [];
   for (const raw of rows) {
     try {
@@ -6794,6 +6983,8 @@ async function readAvailableClientPresignatureRows(context, poolIdentity, nowMs)
       if (row.expires_at_ms <= nowMs) {
         await store.delete(row.record_id);
       } else {
+        if (raw.pool_identity_key !== row.pool_identity_key)
+          await store.put(row);
         available.push(row);
       }
     } catch {
@@ -6805,10 +6996,11 @@ async function readAvailableClientPresignatureRows(context, poolIdentity, nowMs)
   return available;
 }
 function presignatureAadProjection(metadata) {
+  const { ownershipGeneration, ...initialIdentity } = metadata.poolIdentity;
   return {
     domain: CLIENT_PRESIGNATURE_AAD_DOMAIN,
     version: 1,
-    pool_identity: metadata.poolIdentity,
+    pool_identity: ownershipGeneration === 1 ? initialIdentity : metadata.poolIdentity,
     durable_material_ref: metadata.durableMaterialRef,
     presignature_id: metadata.presignatureId,
     group_public_key33_b64u: metadata.groupPublicKey33B64u,
@@ -6818,6 +7010,14 @@ function presignatureAadProjection(metadata) {
     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");
   requireExactKeys3(record, "ECDSA durable presignature row", [
@@ -6839,7 +7039,9 @@ function parseSealedAvailableClientPresignatureRow(value) {
     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");
   requireExactKeys3(poolIdentityRecord, "ECDSA durable presignature pool identity", [
+    ...initialGenerationRecord ? [] : ["ownershipGeneration"],
     "activationEpoch",
     "capability",
     "keyBinding",
@@ -6852,10 +7054,10 @@ 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)) {
+  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();
@@ -6901,7 +7103,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,
@@ -6986,6 +7188,42 @@ async function retireClientPresignaturesForActivationInTransaction(context, wall
   }
 }
 
+// src/core/indexedDB/seamsWalletDB/walletOwnershipGeneration.ts
+async function readOwnershipGeneration(context, walletId) {
+  const raw = await context.store(SEAMS_WALLET_STORES.appState).get(`wallet_ownership_generation:${walletId}`);
+  if (raw === undefined)
+    return 1;
+  const record = requireRecord(raw, "Wallet ownership generation");
+  const generation = record.value;
+  if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 1) {
+    throw new Error("Stored wallet ownership generation is invalid");
+  }
+  return generation;
+}
+async function assertWalletOwnershipGeneration(context, walletId, generation) {
+  if (await readOwnershipGeneration(context, walletId) !== generation) {
+    throw new Error("Wallet ownership generation requires fresh authentication");
+  }
+}
+
+// ../shared-ts/src/utils/secureRandomId.ts
+var DEFAULT_SECURE_RANDOM_ID_BYTES = 32;
+function secureRandomBytes(length = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random bytes") {
+  const byteLength = Math.max(1, Math.floor(Number(length) || 0));
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.getRandomValues !== "function") {
+    throw new Error(`WebCrypto getRandomValues is required for ${label}`);
+  }
+  return cryptoApi.getRandomValues(new Uint8Array(byteLength));
+}
+function secureRandomBase64Url(byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = "secure random id") {
+  return base64UrlEncode(secureRandomBytes(byteLength, label));
+}
+function secureRandomId(prefix, byteLength = DEFAULT_SECURE_RANDOM_ID_BYTES, label = `${prefix} id`) {
+  const normalizedPrefix = String(prefix || "").trim() || "id";
+  return `${normalizedPrefix}-${secureRandomBase64Url(byteLength, label)}`;
+}
+
 // src/core/indexedDB/seamsWalletDB/ecdsaCapabilityManifestLookups.ts
 async function persistenceDigest(category, selector, detail) {
   const canonical = alphabetizeStringify({ category, ...selectorColumns(selector), detail });
@@ -7591,7 +7829,8 @@ class IndexedDbEcdsaCapabilityManifestStore {
       }
     };
     try {
-      const result = await this.manager.runTransaction([PRESIGNATURE_STORE, MATERIAL_STORE], "readwrite", async (context) => {
+      const result = await this.manager.runTransaction([PRESIGNATURE_STORE, MATERIAL_STORE, SEAMS_WALLET_STORES.appState], "readwrite", async (context) => {
+        await assertWalletOwnershipGeneration(context, poolIdentity.walletId, poolIdentity.ownershipGeneration);
         const nowMs = Date.now();
         const available = await readAvailableClientPresignatureRows(context, poolIdentity, nowMs);
         if (available.length >= ECDSA_CLIENT_PRESIGNATURE_CAPACITY) {
@@ -7623,7 +7862,8 @@ class IndexedDbEcdsaCapabilityManifestStore {
     const poolIdentity = parseEcdsaClientPresignPoolIdentity(poolIdentityInput);
     const nowMs = Date.now();
     try {
-      return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+      return await this.manager.runTransaction([PRESIGNATURE_STORE, SEAMS_WALLET_STORES.appState], "readwrite", async (context) => {
+        await assertWalletOwnershipGeneration(context, poolIdentity.walletId, poolIdentity.ownershipGeneration);
         const rows = await readAvailableClientPresignatureRows(context, poolIdentity, nowMs);
         return rows.map(metadataFromPresignatureRow).sort((left, right) => left.createdAtMs - right.createdAtMs);
       });
@@ -7638,8 +7878,9 @@ class IndexedDbEcdsaCapabilityManifestStore {
     const poolIdentity = parseEcdsaClientPresignPoolIdentity(input.poolIdentity);
     let row;
     try {
-      const claimed = await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
+      const claimed = await this.manager.runTransaction([PRESIGNATURE_STORE, SEAMS_WALLET_STORES.appState], "readwrite", async (context) => {
         const store = context.store(PRESIGNATURE_STORE);
+        await assertWalletOwnershipGeneration(context, poolIdentity.walletId, poolIdentity.ownershipGeneration);
         const raw = await store.get(recordId);
         if (raw === undefined)
           return { kind: "claimed_elsewhere" };
@@ -7715,25 +7956,6 @@ class IndexedDbEcdsaCapabilityManifestStore {
       }
     });
   }
-  async deleteClientPresignatures(target) {
-    return await this.manager.runTransaction([PRESIGNATURE_STORE], "readwrite", async (context) => {
-      const store = context.store(PRESIGNATURE_STORE);
-      let deletedCount = 0;
-      switch (target.kind) {
-        case "wallet": {
-          const walletId = String(target.walletId).trim();
-          if (!walletId)
-            throw new Error("ECDSA durable presignature wallet id is required");
-          deletedCount = await deleteCursorRows(await store.index(SEAMS_WALLET_INDEXES.walletId).openCursor(walletId));
-          break;
-        }
-        case "all":
-          deletedCount = await deleteCursorRows(await store.openCursor());
-          break;
-      }
-      return deletedCount;
-    });
-  }
   async listActiveWalletCapabilitySubjects(walletIdInput) {
     const parsedWalletId = parseWalletId(walletIdInput);
     if (!parsedWalletId.ok)