@cef-ai/wallet-identity 1.0.0

package/dist/index.cjs

@@ -0,0 +1,690 @@
+'use strict';
+
+var crypto = require('crypto');
+var bs58 = require('bs58');
+var blake2b = require('@noble/hashes/blake2b');
+var sha3 = require('@noble/hashes/sha3');
+var utils = require('@noble/hashes/utils');
+var ed25519 = require('@noble/curves/ed25519');
+var secp256k1 = require('@noble/curves/secp256k1');
+var hkdf = require('@noble/hashes/hkdf');
+var sha256 = require('@noble/hashes/sha256');
+var mobx = require('mobx');
+var walletApiClient = require('@cef-ai/wallet-api-client');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var PRF_INPUT_LABEL = "cere-wallet-prf-v1";
+var PRF_INPUT_SEED = new Uint8Array(crypto.createHash("sha256").update(PRF_INPUT_LABEL).digest());
+var EVM_HKDF_INFO = "cere-wallet-evm-secp256k1-v1";
+
+// src/browser.ts
+function detectPrfSupport() {
+  return __async(this, null, function* () {
+    const PKC = globalThis.PublicKeyCredential;
+    const webAuthn = typeof PKC !== "undefined";
+    if (!webAuthn) {
+      return { webAuthn: false, platformAuthenticator: false, prfPotentiallySupported: false };
+    }
+    let platformAuthenticator = false;
+    try {
+      platformAuthenticator = typeof PKC.isUserVerifyingPlatformAuthenticatorAvailable === "function" && (yield PKC.isUserVerifyingPlatformAuthenticatorAvailable());
+    } catch (e) {
+      platformAuthenticator = false;
+    }
+    let prfPotentiallySupported = true;
+    try {
+      if (typeof PKC.getClientCapabilities === "function") {
+        const caps = yield PKC.getClientCapabilities();
+        if (caps && caps["extensions:prf"] === false) {
+          prfPotentiallySupported = false;
+        }
+      }
+    } catch (e) {
+    }
+    return { webAuthn, platformAuthenticator, prfPotentiallySupported };
+  });
+}
+function isPrfSupportedResult(extensions) {
+  var _a;
+  const prf = extensions == null ? void 0 : extensions.prf;
+  if (!prf) return false;
+  if (prf.enabled === true) return true;
+  if (((_a = prf.results) == null ? void 0 : _a.first) instanceof Uint8Array) return true;
+  return false;
+}
+var CERE_SS58_PREFIX = 54;
+var SS58PRE = new TextEncoder().encode("SS58PRE");
+function deriveCereAddress(edPubkey) {
+  if (edPubkey.length !== 32) {
+    throw new Error(`expected 32-byte Ed25519 pubkey, got ${edPubkey.length}`);
+  }
+  const prefix = new Uint8Array([CERE_SS58_PREFIX]);
+  const body = utils.concatBytes(prefix, edPubkey);
+  const checksum = blake2b.blake2b(utils.concatBytes(SS58PRE, body), { dkLen: 64 }).slice(0, 2);
+  const payload = utils.concatBytes(body, checksum);
+  return bs58__default.default.encode(payload);
+}
+function deriveSolanaAddress(edPubkey) {
+  if (edPubkey.length !== 32) {
+    throw new Error(`expected 32-byte Ed25519 pubkey, got ${edPubkey.length}`);
+  }
+  return bs58__default.default.encode(edPubkey);
+}
+function decodeEd25519Pubkey(solanaAddress) {
+  const pubkey = bs58__default.default.decode(solanaAddress);
+  if (pubkey.length !== 32) {
+    throw new Error(`expected a 32-byte Ed25519 pubkey from the Solana address, got ${pubkey.length}`);
+  }
+  return pubkey;
+}
+function deriveEvmAddress(secpPubkey) {
+  let xy;
+  if (secpPubkey.length === 65 && secpPubkey[0] === 4) {
+    xy = secpPubkey.slice(1);
+  } else if (secpPubkey.length === 64) {
+    xy = secpPubkey;
+  } else {
+    throw new Error(`expected 64-byte (X||Y) or 65-byte (0x04||X||Y) secp256k1 pubkey, got ${secpPubkey.length}`);
+  }
+  const hash = sha3.keccak_256(xy);
+  const last20 = hash.slice(12);
+  return "0x" + Buffer.from(last20).toString("hex");
+}
+function derivedKeys(prfOutput) {
+  if (prfOutput.length !== 32) {
+    throw new Error(`expected 32-byte PRF output, got ${prfOutput.length}`);
+  }
+  const edSeed = new Uint8Array(prfOutput);
+  const secpKey = hkdf.hkdf(sha256.sha256, prfOutput, new Uint8Array(0), EVM_HKDF_INFO, 32);
+  const edPubkey = ed25519.ed25519.getPublicKey(edSeed);
+  const secpPubkeyUncompressed = secp256k1.secp256k1.getPublicKey(secpKey, false);
+  return { edSeed, secpKey, edPubkey, secpPubkeyUncompressed };
+}
+
+// src/base64url.ts
+function bytesToB64u(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  const b64 = btoa(bin);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64uToBytes(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+  const bin = atob(padded);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+// src/ceremony.ts
+var PRF_CAPABLE_HINTS = ["client-device", "hybrid", "security-key"];
+var WebAuthnCeremonyAdapter = class {
+  constructor(opts = {}) {
+    var _a, _b;
+    this.credentials = (_b = opts.credentials) != null ? _b : (_a = globalThis.navigator) == null ? void 0 : _a.credentials;
+  }
+  register(opts) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      if (!this.credentials) {
+        throw new Error("WebAuthnCeremonyAdapter: navigator.credentials is unavailable");
+      }
+      const cred = yield this.credentials.create({
+        publicKey: {
+          challenge: opts.challenge,
+          rp: { id: opts.rpId, name: opts.rpId },
+          user: {
+            id: opts.userHandle,
+            name: (_a = opts.label) != null ? _a : "scp-wallet",
+            displayName: (_b = opts.label) != null ? _b : "SCP Wallet"
+          },
+          pubKeyCredParams: [
+            { alg: -8, type: "public-key" },
+            // EdDSA (Ed25519 security keys) — preferred
+            { alg: -7, type: "public-key" }
+            // ES256 (Apple/Windows/Android platform authenticators)
+          ],
+          authenticatorSelection: {
+            // No `authenticatorAttachment`: allow platform authenticators
+            // (Touch ID / Windows Hello), roaming security keys, and phone
+            // passkeys via hybrid — PRF works across all of them, and the
+            // pubKeyCredParams above explicitly prefer Ed25519 security keys.
+            // The post-ceremony PRF result is the real capability gate.
+            userVerification: "required",
+            residentKey: "preferred"
+          },
+          // Bias the picker toward PRF-capable authenticators so the user
+          // doesn't default onto a password-manager passkey. See PRF_CAPABLE_HINTS.
+          hints: [...PRF_CAPABLE_HINTS],
+          timeout: 6e4,
+          extensions: { prf: { eval: { first: opts.prfInput } } }
+        }
+      });
+      if (!cred) {
+        throw new Error("WebAuthnCeremonyAdapter.register: credentials.create returned null");
+      }
+      const response = cred.response;
+      const transports = typeof response.getTransports === "function" ? response.getTransports() : [];
+      const ext = cred.getClientExtensionResults();
+      const prfFirst = (_d = (_c = ext == null ? void 0 : ext.prf) == null ? void 0 : _c.results) == null ? void 0 : _d.first;
+      return {
+        credentialId: cred.id,
+        clientDataJSON: bytesToB64u(response.clientDataJSON),
+        attestationObject: bytesToB64u(response.attestationObject),
+        transports,
+        prfOutput: prfFirst ? new Uint8Array(prfFirst) : void 0
+      };
+    });
+  }
+  login(opts) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (!this.credentials) {
+        throw new Error("WebAuthnCeremonyAdapter: navigator.credentials is unavailable");
+      }
+      const cred = yield this.credentials.get({
+        publicKey: {
+          challenge: opts.challenge,
+          rpId: opts.rpId,
+          allowCredentials: opts.credentialId ? [{ id: b64uToBytes(opts.credentialId), type: "public-key" }] : void 0,
+          userVerification: "required",
+          // Bias first-login-on-device (no allowCredentials) toward PRF-capable
+          // authenticators, mirroring register. See PRF_CAPABLE_HINTS.
+          hints: [...PRF_CAPABLE_HINTS],
+          timeout: 6e4,
+          extensions: { prf: { eval: { first: opts.prfInput } } }
+        }
+      });
+      if (!cred) {
+        throw new Error("WebAuthnCeremonyAdapter.login: credentials.get returned null");
+      }
+      const response = cred.response;
+      const ext = cred.getClientExtensionResults();
+      const prfFirst = (_b = (_a = ext == null ? void 0 : ext.prf) == null ? void 0 : _a.results) == null ? void 0 : _b.first;
+      return {
+        credentialId: cred.id,
+        clientDataJSON: bytesToB64u(response.clientDataJSON),
+        authenticatorData: bytesToB64u(response.authenticatorData),
+        signature: bytesToB64u(response.signature),
+        prfOutput: prfFirst ? new Uint8Array(prfFirst) : void 0
+      };
+    });
+  }
+};
+function b64u(bytes) {
+  return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var SoftAuthenticator = class {
+  constructor(opts = {}) {
+    this.creds = /* @__PURE__ */ new Map();
+    /** Monotonic counter mixed into the seed-derived material so successive
+     *  register() calls on a seeded instance produce distinct credentials. */
+    this.regCounter = 0;
+    this.seedBytes = opts.seed != null ? new TextEncoder().encode(opts.seed) : null;
+    this.fallbackToLastRegistered = opts.fallbackToLastRegistered === true;
+  }
+  register(opts) {
+    return __async(this, null, function* () {
+      let edSeed;
+      let prfSecret;
+      let credentialIdBytes;
+      if (this.seedBytes) {
+        const salt = new TextEncoder().encode(`reg-${this.regCounter++}`);
+        edSeed = hkdf.hkdf(sha256.sha256, this.seedBytes, salt, "ed-seed", 32);
+        prfSecret = hkdf.hkdf(sha256.sha256, this.seedBytes, salt, "prf-secret", 32);
+        credentialIdBytes = hkdf.hkdf(sha256.sha256, this.seedBytes, salt, "credential-id", 16);
+      } else {
+        edSeed = ed25519.ed25519.utils.randomPrivateKey();
+        prfSecret = ed25519.ed25519.utils.randomPrivateKey();
+        credentialIdBytes = ed25519.ed25519.utils.randomPrivateKey().slice(0, 16);
+      }
+      const credentialId = b64u(credentialIdBytes);
+      this.creds.set(credentialId, { credentialId, edSeed, prfSecret });
+      const clientData = {
+        type: "webauthn.create",
+        challenge: b64u(opts.challenge),
+        origin: `https://${opts.rpId}`,
+        crossOrigin: false
+      };
+      const clientDataJSON = new TextEncoder().encode(JSON.stringify(clientData));
+      const attestationObject = new Uint8Array([170]);
+      const prfOutput = this.computePrf(prfSecret, opts.prfInput);
+      return {
+        credentialId,
+        clientDataJSON: b64u(clientDataJSON),
+        attestationObject: b64u(attestationObject),
+        transports: ["internal"],
+        prfOutput
+      };
+    });
+  }
+  login(opts) {
+    return __async(this, null, function* () {
+      let stored;
+      if (opts.credentialId) {
+        stored = this.creds.get(opts.credentialId);
+        if (!stored) {
+          throw new Error(`SoftAuthenticator.login: unknown credential ${opts.credentialId}`);
+        }
+      } else {
+        if (!this.fallbackToLastRegistered) {
+          throw new Error(
+            "SoftAuthenticator.login: credentialId is required (set `fallbackToLastRegistered: true` in the constructor to opt into the e2e convenience of picking the most-recently-registered credential)"
+          );
+        }
+        const all = Array.from(this.creds.values());
+        stored = all[all.length - 1];
+        if (!stored) {
+          throw new Error("SoftAuthenticator.login: no credentials registered");
+        }
+      }
+      const clientData = {
+        type: "webauthn.get",
+        challenge: b64u(opts.challenge),
+        origin: `https://${opts.rpId}`,
+        crossOrigin: false
+      };
+      const clientDataJSON = new TextEncoder().encode(JSON.stringify(clientData));
+      const authenticatorData = new Uint8Array(37);
+      authenticatorData[32] = 5;
+      const clientDataHash = sha256.sha256(clientDataJSON);
+      const toSign = utils.concatBytes(authenticatorData, clientDataHash);
+      const signature = ed25519.ed25519.sign(toSign, stored.edSeed);
+      const prfOutput = this.computePrf(stored.prfSecret, opts.prfInput);
+      return {
+        credentialId: stored.credentialId,
+        clientDataJSON: b64u(clientDataJSON),
+        authenticatorData: b64u(authenticatorData),
+        signature: b64u(signature),
+        prfOutput
+      };
+    });
+  }
+  /** Public-key bytes for a credential. Used by integration tests for cross-checks. */
+  getEd25519PublicKey(credentialId) {
+    const stored = this.creds.get(credentialId);
+    if (!stored) throw new Error(`unknown credential ${credentialId}`);
+    return ed25519.ed25519.getPublicKey(stored.edSeed);
+  }
+  computePrf(prfSecret, prfInput) {
+    return hkdf.hkdf(sha256.sha256, prfSecret, new Uint8Array(0), prfInput, 32);
+  }
+};
+function createSessionVault() {
+  let state = null;
+  return {
+    isOpen() {
+      return state !== null;
+    },
+    snapshot() {
+      if (!state) return null;
+      return { addresses: state.addresses, credentialId: state.credentialId };
+    },
+    set({ keys, addresses, credentialId }) {
+      state = {
+        edSeed: new Uint8Array(keys.edSeed),
+        secpKey: new Uint8Array(keys.secpKey),
+        addresses,
+        credentialId
+      };
+    },
+    clear() {
+      if (state) {
+        state.edSeed.fill(0);
+        state.secpKey.fill(0);
+      }
+      state = null;
+    },
+    sign(chain, payload) {
+      return __async(this, null, function* () {
+        if (!state) {
+          throw new Error("SessionVault: closed \u2014 no session keys available");
+        }
+        if (chain === "cere" || chain === "solana") {
+          return ed25519.ed25519.sign(payload, state.edSeed);
+        }
+        if (chain === "evm") {
+          const sig = secp256k1.secp256k1.sign(payload, state.secpKey);
+          const compact = sig.toCompactRawBytes();
+          const v = sig.recovery;
+          const out = new Uint8Array(65);
+          out.set(compact, 0);
+          out[64] = v;
+          return out;
+        }
+        throw new Error(`SessionVault.sign: unknown chain "${String(chain)}"`);
+      });
+    }
+  };
+}
+function signRegistrationProof(keys, challenge) {
+  const identitySig = ed25519.ed25519.sign(challenge, keys.edSeed);
+  const evmSig = secp256k1.secp256k1.sign(challenge, keys.secpKey).toCompactRawBytes();
+  return { identitySig, evmPubkey: keys.secpPubkeyUncompressed, evmSig };
+}
+
+// src/CrossTabSync.ts
+var CHANNEL_NAME = "scp-wallet-v2";
+var CrossTabSync = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    if (typeof BroadcastChannel === "undefined") {
+      this.channel = null;
+      return;
+    }
+    this.channel = new BroadcastChannel(CHANNEL_NAME);
+    this.channel.onmessage = (ev) => {
+      const msg = ev.data;
+      if (!msg || typeof msg !== "object" || typeof msg.type !== "string") {
+        return;
+      }
+      for (const fn of this.listeners) {
+        try {
+          fn(msg);
+        } catch (e) {
+        }
+      }
+    };
+  }
+  /** Broadcast a message to all other tabs (and not to this tab — that's the
+   * BroadcastChannel spec). The originating tab is expected to have already
+   * applied the state change locally before broadcasting. */
+  broadcast(msg) {
+    var _a;
+    (_a = this.channel) == null ? void 0 : _a.postMessage(msg);
+  }
+  /** Subscribe to messages from other tabs. Returns an unsubscribe function. */
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  /**
+   * Close the underlying channel and drop all listeners. Idempotent.
+   *
+   * Sets `this.channel = null` so subsequent `broadcast()` calls become a
+   * no-op (the `?.postMessage` short-circuits) and we don't accidentally
+   * postMessage on a closed BroadcastChannel (which throws InvalidStateError
+   * in some implementations).
+   */
+  close() {
+    var _a;
+    (_a = this.channel) == null ? void 0 : _a.close();
+    this.channel = null;
+    this.listeners.clear();
+  }
+};
+
+// src/IdentityImpl.ts
+var JWT_REFRESH_SLACK_MS = 6e4;
+function decodeJwtExpMs(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) {
+    throw new walletApiClient.WalletError("validation", "JWT does not have 3 parts");
+  }
+  const payloadB64 = parts[1];
+  const payload = JSON.parse(Buffer.from(payloadB64.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8"));
+  if (typeof payload.exp !== "number") {
+    throw new walletApiClient.WalletError("validation", "JWT missing exp");
+  }
+  return payload.exp * 1e3;
+}
+function b64uDecode(s) {
+  return Uint8Array.from(Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
+}
+var IdentityImpl = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.vault = createSessionVault();
+    this.cachedJwt = null;
+    /** Server-returned credential ID (used as the public identity.credentialId). */
+    this.serverCredentialId = null;
+    // Public observable state — derived from vault snapshot + serverCredentialId.
+    // Kept in sync via syncPublicState() so React `observer()` wrappers around
+    // components reading isAuthenticated/addresses/credentialId actually re-render
+    // on register/login/logout. The vault itself stays non-observable (security:
+    // the closure-encapsulated keys must not be tracked by MobX).
+    this._isAuthenticated = mobx.observable.box(false);
+    // `deep: false` keeps the stored value a plain object instead of wrapping it
+    // in a MobX proxy. addresses is a wholesale-replaced snapshot (never mutated
+    // field-by-field), so deep observability buys nothing — and a proxy is not
+    // structured-cloneable, which breaks `postMessage` when the embed popup
+    // bridge sends addresses to the host page (wallet:login:ok).
+    this._addresses = mobx.observable.box(null, { deep: false });
+    this._credentialId = mobx.observable.box(null);
+    /** Cross-tab logout coordination via BroadcastChannel('scp-wallet-v2'). */
+    this.crossTabSync = new CrossTabSync();
+    /** Idempotency flag for dispose(). */
+    this.disposed = false;
+    this.syncPublicState();
+    this.crossTabSyncUnsubscribe = this.crossTabSync.subscribe((msg) => {
+      if (msg.type === "logout" && this.vault.isOpen()) {
+        this.vault.clear();
+        this.cachedJwt = null;
+        this.serverCredentialId = null;
+        this.syncPublicState();
+      }
+    });
+  }
+  get isAuthenticated() {
+    return this._isAuthenticated.get();
+  }
+  get addresses() {
+    return this._addresses.get();
+  }
+  /**
+   * Returns the server-returned credentialId from the last register/login ceremony.
+   * The vault internally tracks the authenticator-generated credential ID for login use.
+   */
+  get credentialId() {
+    return this._credentialId.get();
+  }
+  /**
+   * Read the (non-observable) vault snapshot + cached server credential ID and
+   * push the values into the three public observable boxes. Call after any
+   * mutation that could change the public derived state: register, login,
+   * logout, or constructor (hydration).
+   */
+  syncPublicState() {
+    const snap = this.vault.snapshot();
+    mobx.runInAction(() => {
+      var _a;
+      this._isAuthenticated.set(this.vault.isOpen());
+      this._addresses.set((_a = snap == null ? void 0 : snap.addresses) != null ? _a : null);
+      this._credentialId.set(this.serverCredentialId);
+    });
+  }
+  register() {
+    return __async(this, arguments, function* (opts = {}) {
+      const start = yield this.opts.apiClient.passkey.registerStart({
+        addresses: { cere: "5GplaceholderClientCannotKnowYet" },
+        label: opts.label
+      });
+      const cer = yield this.opts.ceremony.register({
+        rpId: start.rpId,
+        challenge: b64uDecode(start.challenge),
+        userHandle: b64uDecode(start.userHandle),
+        prfInput: PRF_INPUT_SEED,
+        label: opts.label
+      });
+      if (!cer.prfOutput) {
+        throw new walletApiClient.WalletError("prf-unsupported", "authenticator did not return a PRF output");
+      }
+      const keys = derivedKeys(cer.prfOutput);
+      const clientAddresses = {
+        cere: deriveCereAddress(keys.edPubkey),
+        solana: deriveSolanaAddress(keys.edPubkey),
+        evm: deriveEvmAddress(keys.secpPubkeyUncompressed)
+      };
+      const proof = signRegistrationProof(keys, b64uDecode(start.challenge));
+      const finish = yield this.opts.apiClient.passkey.registerFinish({
+        challengeId: start.challengeId,
+        clientDataJSON: cer.clientDataJSON,
+        attestationObject: cer.attestationObject,
+        addresses: clientAddresses,
+        transports: cer.transports,
+        identitySig: bytesToB64u(proof.identitySig),
+        evmPubkey: bytesToB64u(proof.evmPubkey),
+        evmSig: bytesToB64u(proof.evmSig)
+      });
+      this.crossCheckAddresses(clientAddresses, finish.addresses);
+      this.vault.set({
+        keys,
+        addresses: clientAddresses,
+        credentialId: cer.credentialId
+      });
+      this.serverCredentialId = finish.credentialId;
+      this.cachedJwt = { token: finish.token, expMs: decodeJwtExpMs(finish.token) };
+      this.syncPublicState();
+    });
+  }
+  login() {
+    return __async(this, null, function* () {
+      var _a;
+      const start = yield this.opts.apiClient.passkey.loginStart();
+      const cer = yield this.opts.ceremony.login({
+        rpId: start.rpId,
+        challenge: b64uDecode(start.challenge),
+        credentialId: (_a = this.vault.snapshot()) == null ? void 0 : _a.credentialId,
+        prfInput: PRF_INPUT_SEED
+      });
+      if (!cer.prfOutput) {
+        throw new walletApiClient.WalletError("prf-unsupported", "authenticator did not return a PRF output");
+      }
+      const keys = derivedKeys(cer.prfOutput);
+      const clientAddresses = {
+        cere: deriveCereAddress(keys.edPubkey),
+        solana: deriveSolanaAddress(keys.edPubkey),
+        evm: deriveEvmAddress(keys.secpPubkeyUncompressed)
+      };
+      const finish = yield this.opts.apiClient.passkey.loginFinish({
+        challengeId: start.challengeId,
+        credentialId: cer.credentialId,
+        clientDataJSON: cer.clientDataJSON,
+        authenticatorData: cer.authenticatorData,
+        signature: cer.signature
+      });
+      this.crossCheckAddresses(clientAddresses, finish.addresses);
+      this.vault.set({
+        keys,
+        addresses: clientAddresses,
+        credentialId: cer.credentialId
+      });
+      this.serverCredentialId = finish.credentialId;
+      this.cachedJwt = { token: finish.token, expMs: decodeJwtExpMs(finish.token) };
+      this.syncPublicState();
+    });
+  }
+  logout() {
+    this.vault.clear();
+    this.cachedJwt = null;
+    this.serverCredentialId = null;
+    this.syncPublicState();
+    this.crossTabSync.broadcast({ type: "logout" });
+  }
+  getJwt() {
+    return __async(this, null, function* () {
+      if (this.cachedJwt && Date.now() < this.cachedJwt.expMs - JWT_REFRESH_SLACK_MS) {
+        return this.cachedJwt.token;
+      }
+      if (!this.vault.isOpen()) {
+        throw new walletApiClient.WalletError("unauthorized", "session is closed; call register() or login() first");
+      }
+      yield this.login();
+      return this.cachedJwt.token;
+    });
+  }
+  /** Helper used by callers (e.g. ApiClient.getAuthToken). */
+  getCachedJwtForApiClient() {
+    var _a, _b;
+    return (_b = (_a = this.cachedJwt) == null ? void 0 : _a.token) != null ? _b : null;
+  }
+  /**
+   * Returns the session vault. Used by popup-side `wallet:sign` handlers
+   * which need direct access to `vault.sign(chain, payload)`. NOT for host-
+   * side use — keys never reach the host. Spec §3.6 invariant 1.
+   */
+  getVault() {
+    return this.vault;
+  }
+  /**
+   * Release the BroadcastChannel + cross-tab subscriber. Idempotent.
+   *
+   * Called by:
+   *   - WalletProvider's useEffect cleanup (SPA unmount / apiBaseUrl change)
+   *   - test afterEach hooks (prevent listener leakage across tests)
+   *
+   * After dispose(), the identity is unusable: register/login/logout/getJwt
+   * still execute their normal logic, but cross-tab broadcasts no longer
+   * propagate (channel is closed) and the local subscriber is detached.
+   * The vault remains cleared (logout() runs locally). Spec §9.4 lifecycle.
+   */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.crossTabSyncUnsubscribe();
+    this.crossTabSync.close();
+  }
+  // ---- private --------------------------------------------------------------
+  crossCheckAddresses(client, server) {
+    if (!server) {
+      throw new walletApiClient.WalletError("derivation-mismatch", "API did not return addresses");
+    }
+    if (server.cere != null && client.cere !== server.cere) {
+      throw new walletApiClient.WalletError("derivation-mismatch", `Cere mismatch: client=${client.cere} api=${server.cere}`);
+    }
+    if (server.solana != null && client.solana !== server.solana) {
+      throw new walletApiClient.WalletError("derivation-mismatch", `Solana mismatch: client=${client.solana} api=${server.solana}`);
+    }
+    if (server.evm != null && client.evm.toLowerCase() !== server.evm.toLowerCase()) {
+      throw new walletApiClient.WalletError("derivation-mismatch", `EVM mismatch: client=${client.evm} api=${server.evm}`);
+    }
+  }
+};
+
+exports.CERE_SS58_PREFIX = CERE_SS58_PREFIX;
+exports.CrossTabSync = CrossTabSync;
+exports.EVM_HKDF_INFO = EVM_HKDF_INFO;
+exports.IdentityImpl = IdentityImpl;
+exports.PRF_INPUT_LABEL = PRF_INPUT_LABEL;
+exports.PRF_INPUT_SEED = PRF_INPUT_SEED;
+exports.SoftAuthenticator = SoftAuthenticator;
+exports.WebAuthnCeremonyAdapter = WebAuthnCeremonyAdapter;
+exports.b64uToBytes = b64uToBytes;
+exports.bytesToB64u = bytesToB64u;
+exports.createSessionVault = createSessionVault;
+exports.decodeEd25519Pubkey = decodeEd25519Pubkey;
+exports.deriveCereAddress = deriveCereAddress;
+exports.deriveEvmAddress = deriveEvmAddress;
+exports.deriveSolanaAddress = deriveSolanaAddress;
+exports.derivedKeys = derivedKeys;
+exports.detectPrfSupport = detectPrfSupport;
+exports.isPrfSupportedResult = isPrfSupportedResult;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map