@oxy.so/core 1.2.0 → 1.3.0

package/src/crypto/keyManager.ts

@@ -991,6 +991,49 @@ export class KeyManager {
     }
   }
 
+  /**
+   * Which identity key this device is actually acting as, per slot.
+   *
+   * There are two slots and they can disagree. The shared slot is what every
+   * cross-app reader takes first — `deriveScopedSeed` (so: the FairCoin wallet
+   * Peable derives) and `getSharedPrivateKey` — while the primary slot is what
+   * signing and the server-facing identity use. A disagreement is invisible to
+   * both sides on its own, and it is money: a wallet derived from a stale
+   * shared key watches addresses that the key published in the DID will never
+   * produce, so payments land where the recipient cannot see them.
+   *
+   * `activePublicKey` is the one money derives from — the same `shared ?? primary`
+   * order `deriveScopedSeed` uses, so a caller can compare it against the key
+   * published for the account and refuse to receive rather than watch the wrong
+   * addresses.
+   *
+   * Public keys are canonicalized, so two encodings of the same key compare
+   * equal. On web both slots are null and `inSync` is true: nothing is stored,
+   * so nothing can disagree.
+   */
+  static async getIdentityKeyState(): Promise<{
+    primaryPublicKey: string | null;
+    sharedPublicKey: string | null;
+    activePublicKey: string | null;
+    inSync: boolean;
+  }> {
+    const [primaryRaw, sharedRaw] = await Promise.all([
+      KeyManager.getPublicKey(),
+      KeyManager.getSharedPublicKey(),
+    ]);
+    const primaryPublicKey = primaryRaw ? KeyManager.canonicalPublicKey(primaryRaw) : null;
+    const sharedPublicKey = sharedRaw ? KeyManager.canonicalPublicKey(sharedRaw) : null;
+    return {
+      primaryPublicKey,
+      sharedPublicKey,
+      activePublicKey: sharedPublicKey ?? primaryPublicKey,
+      // Only a real disagreement is out of sync. A device with just one slot
+      // populated has nothing to contradict.
+      inSync:
+        primaryPublicKey === null || sharedPublicKey === null || primaryPublicKey === sharedPublicKey,
+    };
+  }
+
   /**
    * Check if a shared identity exists (accessible across all Oxy apps)
    *
@@ -1201,54 +1244,61 @@ export class KeyManager {
   }
 
   /**
-   * Migrate local identity to shared identity
+   * Make the shared slot hold THIS device's identity key.
    *
-   * Call this when upgrading existing apps to use shared identities.
-   * Copies the device-specific identity to shared storage so it can
-   * be accessed by other Oxy apps.
+   * The shared slot is the one every Oxy app on the device reads, so it has to
+   * agree with the primary slot. This creates it when it is empty (the original
+   * migration, for apps that predate the shared identity) and repairs it when it
+   * holds a different key.
    *
-   * @returns True if migration was successful, false if no local identity exists
+   * @returns True when the shared slot ends up holding the device's key, false
+   *          when there is no identity to share.
    */
-  static async migrateToSharedIdentity(): Promise<boolean> {
+  static async syncSharedIdentity(): Promise<boolean> {
     if (isWebPlatform()) {
       return false;
     }
 
     try {
-      // Check if we already have a shared identity
-      const hasShared = await KeyManager.hasSharedIdentity();
-      if (hasShared) {
-        if (isDev()) {
-          logger.debug('Shared identity already exists, skipping migration', { component: 'KeyManager' });
-        }
+      const state = await KeyManager.getIdentityKeyState();
+      if (state.sharedPublicKey !== null && (state.inSync || state.primaryPublicKey === null)) {
         return true;
       }
 
-      // Get local identity
       const privateKey = await KeyManager.getPrivateKey();
       if (!privateKey) {
-        if (isDev()) {
-          logger.debug('No local identity to migrate', { component: 'KeyManager' });
-        }
-        return false;
+        // Nothing of this device's own to share. A shared slot that is already
+        // populated stays as it is: it is the only identity here.
+        return state.sharedPublicKey !== null;
       }
 
-      // Import to shared storage
       await KeyManager.importSharedIdentity(privateKey);
 
-      if (isDev()) {
-        logger.debug('Successfully migrated local identity to shared identity', { component: 'KeyManager' });
+      // A slot that held a DIFFERENT key is the dangerous case, so it is said
+      // out loud rather than debug-logged: until this write, cross-app readers
+      // (`deriveScopedSeed`, so Peable's wallet) were deriving from one key
+      // while signing and the server used another.
+      if (state.sharedPublicKey !== null) {
+        logger.warn(
+          'Shared identity held a different key than this device: repaired it from the primary slot.',
+          { component: 'KeyManager', method: 'syncSharedIdentity' },
+        );
       }
 
       return true;
     } catch (error) {
       if (isDev()) {
-        logger.error('Failed to migrate to shared identity', error, { component: 'KeyManager' });
+        logger.error('Failed to sync the shared identity', error, { component: 'KeyManager' });
       }
       return false;
     }
   }
 
+  /** @deprecated Renamed to {@link KeyManager.syncSharedIdentity}. */
+  static async migrateToSharedIdentity(): Promise<boolean> {
+    return KeyManager.syncSharedIdentity();
+  }
+
   // ==================== END SHARED IDENTITY METHODS ====================
 
   /**

package/src/crypto/webIdentityCarrier.ts

@@ -0,0 +1,326 @@
+/**
+ * Web identity carrier — the crypto of "one identity, two carriers".
+ *
+ * An Oxy identity is a BIP-39 mnemonic; its seed's first 32 bytes are the
+ * secp256k1 key (`recoveryPhrase.ts`). Commons keeps that key in the device
+ * keychain. This module lets a browser carry the SAME identity without Oxy ever
+ * being able to use it:
+ *
+ *   entropy ──AEAD(DEK)──▶ sealedEntropy
+ *   DEK     ──AEAD(KEK_i)─▶ wraps[i]            KEK_i = HKDF(PRF output of passkey i)
+ *
+ * The PRF output is produced inside the user's authenticator, behind user
+ * verification, and never leaves the page that asked for it. The envelope is
+ * therefore safe to store anywhere — the identity origin's IndexedDB and the
+ * server copy alike — and opens only with a registered passkey or the phrase.
+ *
+ * PURE: no storage, no network, no WebAuthn call, no platform globals beyond the
+ * CSPRNG the AEAD polyfill guarantees. The caller runs the ceremony and hands the
+ * PRF output in; everything here is deterministic given its inputs, so it is
+ * identical on web, Node and React Native, and fully unit-testable.
+ *
+ * Contract: `WebIdentityEnvelope` in `@oxy.so/contracts`.
+ */
+
+import './polyfill';
+import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+import { signMessage } from '@oxy.so/protocol';
+import { deriveSecp256k1PublicKey } from '@oxy.so/protocol/secp256k1';
+import {
+  WEB_IDENTITY_ENVELOPE_VERSION,
+  type WebIdentityEnvelope,
+  type WebIdentityWrap,
+} from '@oxy.so/contracts';
+import { AEAD_KEY_LENGTH, decryptAead, encryptAead } from './aead';
+import { hkdfSha256 } from './kdf';
+
+/**
+ * The PRF input every identity-carrier ceremony evaluates (`prf.eval.first`).
+ *
+ * Fixed rather than per-wrap: discoverable sign-in has no credential list to key
+ * `evalByCredential` by, and each passkey's output is already distinct. A future
+ * scheme change bumps the label — and with it every KEK — instead of mutating it.
+ */
+export const WEB_IDENTITY_PRF_INPUT: Uint8Array = sha256(utf8ToBytes('oxy-web-identity-carrier/prf/v1'));
+
+/** HKDF salt of the key-encryption-key schedule. Versioned with the envelope. */
+const KEK_SALT = utf8ToBytes('oxy-web-identity-carrier/kek/v1');
+
+/** A WebAuthn PRF output is 32 bytes (HMAC-SHA-256). */
+const PRF_OUTPUT_LENGTH = 32;
+
+/** Why an envelope did not open. Every value is a normal outcome a UI can explain. */
+export type WebIdentityUnlockFailure =
+  /** The passkey used is not one of the envelope's wraps. */
+  | 'unknown-credential'
+  /**
+   * The passkey IS listed but its PRF output does not open its wrap — a synced
+   * copy returning a different PRF value, or a provider that silently changed it.
+   * Recoverable with another passkey or the phrase.
+   */
+  | 'prf-mismatch'
+  /** The envelope itself is malformed or tampered with. */
+  | 'corrupt';
+
+export class WebIdentityUnlockError extends Error {
+  constructor(readonly failure: WebIdentityUnlockFailure, message: string) {
+    super(message);
+    this.name = 'WebIdentityUnlockError';
+  }
+}
+
+/** The identity in usable form. Hold it for one operation, then {@link wipeBytes}. */
+export interface OpenedWebIdentity {
+  mnemonic: string;
+  /** 32-byte secp256k1 private key, lowercase hex. */
+  privateKey: string;
+  /** Uncompressed SEC1 public key, lowercase hex (Oxy's canonical form). */
+  publicKey: string;
+}
+
+function aadFor(parts: Record<string, string | number>): Uint8Array {
+  return utf8ToBytes(JSON.stringify(parts));
+}
+
+function entropyAad(publicKey: string): Uint8Array {
+  return aadFor({ v: WEB_IDENTITY_ENVELOPE_VERSION, purpose: 'entropy', publicKey });
+}
+
+function wrapAad(publicKey: string, credentialId: string): Uint8Array {
+  return aadFor({ v: WEB_IDENTITY_ENVELOPE_VERSION, purpose: 'wrap', publicKey, credentialId });
+}
+
+/** Overwrite a buffer holding secret material. Best effort — JS gives no stronger guarantee. */
+export function wipeBytes(bytes: Uint8Array): void {
+  bytes.fill(0);
+}
+
+/**
+ * Derive the identity from a mnemonic exactly as Commons does
+ * (`RecoveryPhraseService`): seed → first 32 bytes → secp256k1.
+ */
+export function deriveIdentityFromMnemonic(mnemonic: string): OpenedWebIdentity {
+  const normalized = mnemonic.trim().toLowerCase().split(/\s+/).join(' ');
+  if (!validateMnemonic(normalized, wordlist)) {
+    throw new Error('Invalid recovery phrase');
+  }
+  const seed = mnemonicToSeedSync(normalized);
+  const privateKeyBytes = seed.slice(0, 32);
+  wipeBytes(seed);
+  const privateKey = bytesToHex(privateKeyBytes);
+  wipeBytes(privateKeyBytes);
+  return { mnemonic: normalized, privateKey, publicKey: deriveSecp256k1PublicKey(privateKey) };
+}
+
+/** A brand-new 12-word identity. Nothing is persisted. */
+export function generateWebIdentity(): OpenedWebIdentity {
+  return deriveIdentityFromMnemonic(generateMnemonic(wordlist, 128));
+}
+
+/** A fresh random data key for a new envelope. */
+export function generateDataKey(): Uint8Array {
+  const key = new Uint8Array(AEAD_KEY_LENGTH);
+  globalThis.crypto.getRandomValues(key);
+  return key;
+}
+
+/** The key-encryption key a passkey's PRF output yields for its own wrap. */
+export function deriveKeyEncryptionKey(prfOutput: Uint8Array, credentialId: string): Uint8Array {
+  if (prfOutput.length !== PRF_OUTPUT_LENGTH) {
+    throw new Error(`PRF output must be ${PRF_OUTPUT_LENGTH} bytes, got ${prfOutput.length}`);
+  }
+  return hkdfSha256(prfOutput, KEK_SALT, utf8ToBytes(credentialId), AEAD_KEY_LENGTH);
+}
+
+/** Wrap `dataKey` for one passkey. */
+export function wrapDataKey(
+  dataKey: Uint8Array,
+  prfOutput: Uint8Array,
+  credentialId: string,
+  publicKey: string,
+  now: Date = new Date(),
+): WebIdentityWrap {
+  const kek = deriveKeyEncryptionKey(prfOutput, credentialId);
+  try {
+    const { nonce, ciphertext } = encryptAead(kek, dataKey, wrapAad(publicKey, credentialId));
+    return {
+      credentialId,
+      nonce: bytesToHex(nonce),
+      wrappedKey: bytesToHex(ciphertext),
+      createdAt: now.toISOString(),
+    };
+  } finally {
+    wipeBytes(kek);
+  }
+}
+
+/**
+ * Seal an identity into a new envelope that opens with the given passkey.
+ *
+ * Returns the data key too, so the caller can add further wraps in the same
+ * session; wipe it when done.
+ */
+export function sealWebIdentity(
+  identity: Pick<OpenedWebIdentity, 'mnemonic' | 'publicKey'>,
+  firstWrap: { prfOutput: Uint8Array; credentialId: string },
+  now: Date = new Date(),
+): { envelope: WebIdentityEnvelope; dataKey: Uint8Array } {
+  const derived = deriveIdentityFromMnemonic(identity.mnemonic);
+  if (derived.publicKey !== identity.publicKey.toLowerCase()) {
+    throw new Error('The recovery phrase does not belong to this identity');
+  }
+  const dataKey = generateDataKey();
+  const entropy = mnemonicToEntropy(derived.mnemonic, wordlist);
+  try {
+    const { nonce, ciphertext } = encryptAead(dataKey, entropy, entropyAad(derived.publicKey));
+    const envelope: WebIdentityEnvelope = {
+      version: WEB_IDENTITY_ENVELOPE_VERSION,
+      algorithm: 'xchacha20poly1305',
+      publicKey: derived.publicKey,
+      entropyNonce: bytesToHex(nonce),
+      sealedEntropy: bytesToHex(ciphertext),
+      wraps: [wrapDataKey(dataKey, firstWrap.prfOutput, firstWrap.credentialId, derived.publicKey, now)],
+    };
+    return { envelope, dataKey };
+  } finally {
+    wipeBytes(entropy);
+  }
+}
+
+/** Recover the data key with one passkey's PRF output. */
+export function unwrapDataKey(
+  envelope: WebIdentityEnvelope,
+  prfOutput: Uint8Array,
+  credentialId: string,
+): Uint8Array {
+  const wrap = envelope.wraps.find((entry) => entry.credentialId === credentialId);
+  if (!wrap) {
+    throw new WebIdentityUnlockError('unknown-credential', 'This passkey cannot open this identity');
+  }
+  const kek = deriveKeyEncryptionKey(prfOutput, credentialId);
+  try {
+    return decryptAead(kek, hexToBytes(wrap.nonce), hexToBytes(wrap.wrappedKey), wrapAad(envelope.publicKey, credentialId));
+  } catch {
+    throw new WebIdentityUnlockError('prf-mismatch', 'This passkey returned a different secret than when it was registered');
+  } finally {
+    wipeBytes(kek);
+  }
+}
+
+/**
+ * Open an envelope with its data key.
+ *
+ * The derived public key is checked against the envelope's own: a sealed entropy
+ * that decrypts into a different identity is treated as corruption, never used.
+ */
+export function openWebIdentity(envelope: WebIdentityEnvelope, dataKey: Uint8Array): OpenedWebIdentity {
+  let entropy: Uint8Array;
+  try {
+    entropy = decryptAead(
+      dataKey,
+      hexToBytes(envelope.entropyNonce),
+      hexToBytes(envelope.sealedEntropy),
+      entropyAad(envelope.publicKey),
+    );
+  } catch {
+    throw new WebIdentityUnlockError('corrupt', 'The sealed identity could not be opened');
+  }
+  try {
+    const identity = deriveIdentityFromMnemonic(entropyToMnemonic(entropy, wordlist));
+    if (identity.publicKey !== envelope.publicKey.toLowerCase()) {
+      throw new WebIdentityUnlockError('corrupt', 'The sealed identity does not match its public key');
+    }
+    return identity;
+  } finally {
+    wipeBytes(entropy);
+  }
+}
+
+/** Unwrap and open in one step. */
+export function unlockWebIdentity(
+  envelope: WebIdentityEnvelope,
+  prfOutput: Uint8Array,
+  credentialId: string,
+): OpenedWebIdentity {
+  const dataKey = unwrapDataKey(envelope, prfOutput, credentialId);
+  try {
+    return openWebIdentity(envelope, dataKey);
+  } finally {
+    wipeBytes(dataKey);
+  }
+}
+
+/** Add (or replace) one passkey's wrap. Requires the data key of an unlocked envelope. */
+export function addWrap(
+  envelope: WebIdentityEnvelope,
+  dataKey: Uint8Array,
+  prfOutput: Uint8Array,
+  credentialId: string,
+  now: Date = new Date(),
+): WebIdentityEnvelope {
+  // Proves `dataKey` belongs to THIS envelope before anything new can open it.
+  openWebIdentity(envelope, dataKey);
+  const others = envelope.wraps.filter((entry) => entry.credentialId !== credentialId);
+  return {
+    ...envelope,
+    wraps: [...others, wrapDataKey(dataKey, prfOutput, credentialId, envelope.publicKey, now)],
+  };
+}
+
+/** Remove one passkey's wrap. The last wrap can never be removed — an envelope nobody can open is a loss. */
+export function removeWrap(envelope: WebIdentityEnvelope, credentialId: string): WebIdentityEnvelope {
+  const remaining = envelope.wraps.filter((entry) => entry.credentialId !== credentialId);
+  if (remaining.length === 0) {
+    throw new Error('An identity envelope must keep at least one passkey');
+  }
+  return { ...envelope, wraps: remaining };
+}
+
+/**
+ * The message an identity key signs to authorize an account action
+ * (`link_identity`, `web_envelope_delete`, …): `JSON.stringify({ action, userId,
+ * timestamp })`, byte-identical to what the API reconstructs.
+ */
+export function buildIdentityActionMessage(action: string, userId: string, timestamp: number): string {
+  return JSON.stringify({ action, userId, timestamp });
+}
+
+/** Sign an identity-action message with an opened identity's key. */
+export async function signIdentityAction(
+  identity: Pick<OpenedWebIdentity, 'privateKey'>,
+  action: string,
+  userId: string,
+  timestamp: number = Date.now(),
+): Promise<{ signature: string; timestamp: number }> {
+  const signature = await signMessage(buildIdentityActionMessage(action, userId, timestamp), identity.privateKey);
+  return { signature, timestamp };
+}
+
+/**
+ * The 6-digit short authentication string both sides of an identity transfer show.
+ *
+ * Bound to the pairing and to BOTH ephemeral public keys in their roles, so a relay
+ * that substitutes either key produces a different code on each screen. The user
+ * comparing the two codes is what makes the transfer safe against the relay itself.
+ */
+export function deriveTransferSas(input: {
+  pairingId: string;
+  initiatorEphemeralPublicKey: string;
+  responderEphemeralPublicKey: string;
+}): string {
+  const digest = sha256(
+    utf8ToBytes(
+      JSON.stringify({
+        v: 'oxy-identity-transfer-sas-v1',
+        pairingId: input.pairingId.toLowerCase(),
+        initiator: input.initiatorEphemeralPublicKey.toLowerCase(),
+        responder: input.responderEphemeralPublicKey.toLowerCase(),
+      }),
+    ),
+  );
+  const value = ((digest[0] << 24) | (digest[1] << 16) | (digest[2] << 8) | digest[3]) >>> 0;
+  return String(value % 1_000_000).padStart(6, '0');
+}

package/src/i18n/locales/ar-SA.json

@@ -52,19 +52,9 @@
   "signup": {
     "title": "أنشئ حسابك",
     "subtitle": "هوية واحدة لكل النظام البيئي.",
-    "commonsHeadline": "أنشئ هويتك في Commons",
-    "commonsExplainer": "‏Commons هي هوية Oxy الخاصة بك بحفظ ذاتي كامل — تطبيق واحد يعمل في كل مكان.",
     "createInCommons": "أنشئ هويتك في Commons",
-    "passkeyAlternative": "لا تملك Commons؟ أنشئ مفتاح مرور على هذا الجهاز بدلاً من ذلك",
     "createAccount": "إنشاء حساب",
-    "creating": "جارٍ الإنشاء…",
-    "usernamePlaceholder": "اختر اسم مستخدم",
-    "usernameChecking": "جارٍ التحقق…",
-    "usernameAvailable": "متاح",
-    "usernameTaken": "اسم المستخدم هذا مستخدم بالفعل",
     "backToSignInLink": "لديك حساب بالفعل؟ سجّل الدخول",
-    "hubExplainer": "أنشئ هوية Oxy الخاصة بك في نافذة آمنة، ثم عد إلى هنا مباشرة.",
-    "continueInWindow": "المتابعة في نافذة جديدة",
     "welcome": {
       "title": "مرحبًا بك في Oxy!",
       "subtitle": "أنشئ حسابك في خطوات قليلة",
@@ -119,7 +109,6 @@
     "qrHeadline": "سجّل الدخول بهوية Oxy الخاصة بك",
     "signInWithOxy": "تسجيل الدخول باستخدام Oxy",
     "useIdentityOnDevice": "لا تملك Commons؟ استخدم مفتاح مرور على هذا الجهاز بدلاً من ذلك",
-    "passkeySigningIn": "جارٍ تسجيل الدخول…",
     "getCommons": "احصل على Commons",
     "commonsNotInstalled": "لا تملك Commons؟ احصل على التطبيق لتسجيل الدخول بمعرّف Oxy الخاص بك.",
     "showQrAnyway": "لدي Commons على جهاز آخر",
@@ -136,7 +125,20 @@
       "openedInCommons": "تم الفتح في Commons",
       "confirming": "جارٍ تأكيد الهوية",
       "confirmed": "تم تأكيد الهوية"
-    }
+    },
+    "signInFailures": {
+      "denied": "تم رفض تسجيل الدخول في Commons.",
+      "expired": "انتهت صلاحية طلب تسجيل الدخول. يُرجى المحاولة مرة أخرى.",
+      "network": "تعذّر الاتصال بـ Oxy. تحقّق من اتصالك وحاول مرة أخرى.",
+      "notConfigured": "هذا التطبيق غير مُعدّ لتسجيل الدخول بعد.",
+      "unsupportedFlow": "لا يمكن إكمال تسجيل الدخول هنا.",
+      "claimFailed": "تمت الموافقة على تسجيل الدخول، لكن تعذّر إكماله. يُرجى المحاولة مرة أخرى.",
+      "generic": "تعذّر تسجيل الدخول. يُرجى المحاولة مرة أخرى."
+    },
+    "linkOpenFailed": "تعذّر فتح الرابط. يُرجى المحاولة مرة أخرى.",
+    "continueWithPasskey": "متابعة",
+    "passkeyHint": "استخدم بصمتك أو وجهك أو رمز PIN للجهاز.",
+    "otherDeviceCommons": "حسابك على جهاز آخر؟ امسح الرمز باستخدام Commons"
   },
   "common": {
     "actions": {
@@ -277,6 +279,7 @@
     "help": "المساعدة والملاحظات",
     "signOut": "تسجيل الخروج",
     "privacy": "سياسة الخصوصية",
-    "terms": "شروط الخدمة"
+    "terms": "شروط الخدمة",
+    "identity": "هويتك"
   }
 }

package/src/i18n/locales/ca-ES.json

@@ -52,19 +52,9 @@
   "signup": {
     "title": "Crea el teu compte",
     "subtitle": "Una identitat per a tot l'ecosistema.",
-    "commonsHeadline": "Crea la teva identitat a Commons",
-    "commonsExplainer": "Commons és la teva identitat d'Oxy amb autocustòdia completa: una app que funciona a tot arreu.",
     "createInCommons": "Crea la teva identitat a Commons",
-    "passkeyAlternative": "No tens Commons? Crea una clau d'accés en aquest dispositiu",
     "createAccount": "Crear compte",
-    "creating": "Creant…",
-    "usernamePlaceholder": "Tria un nom d'usuari",
-    "usernameChecking": "Comprovant…",
-    "usernameAvailable": "Disponible",
-    "usernameTaken": "Aquest nom d'usuari ja està en ús",
     "backToSignInLink": "Ja tens compte? Inicia sessió",
-    "hubExplainer": "Crea la teva Oxy ID en una finestra segura i torna de seguida.",
-    "continueInWindow": "Continua en una finestra nova",
     "welcome": {
       "title": "Benvingut a Oxy!",
       "subtitle": "Crea el teu compte en pocs passos",
@@ -119,7 +109,6 @@
     "qrHeadline": "Inicia sessió amb la teva identitat d'Oxy",
     "signInWithOxy": "Inicia sessió amb Oxy",
     "useIdentityOnDevice": "No tens Commons? Fes servir una clau d'accés en aquest dispositiu",
-    "passkeySigningIn": "Iniciant sessió…",
     "getCommons": "Descarrega Commons",
     "commonsNotInstalled": "No tens Commons? Descarrega l'app per iniciar sessió amb el teu Oxy ID.",
     "showQrAnyway": "Tinc Commons en un altre dispositiu",
@@ -136,7 +125,20 @@
       "openedInCommons": "Obert a Commons",
       "confirming": "Confirmant la identitat",
       "confirmed": "Identitat confirmada"
-    }
+    },
+    "signInFailures": {
+      "denied": "S'ha rebutjat l'inici de sessió a Commons.",
+      "expired": "La sol·licitud d'inici de sessió ha caducat. Torna-ho a provar.",
+      "network": "No s'ha pogut connectar amb Oxy. Comprova la connexió i torna-ho a provar.",
+      "notConfigured": "Aquesta app encara no està preparada per iniciar sessió.",
+      "unsupportedFlow": "Aquest inici de sessió no es pot completar aquí.",
+      "claimFailed": "S'ha aprovat l'inici de sessió, però no l'hem pogut completar. Torna-ho a provar.",
+      "generic": "No s'ha pogut iniciar la sessió. Torna-ho a provar."
+    },
+    "linkOpenFailed": "No s'ha pogut obrir l'enllaç. Torna-ho a provar.",
+    "continueWithPasskey": "Continua",
+    "passkeyHint": "Fes servir l'empremta, la cara o el PIN del dispositiu.",
+    "otherDeviceCommons": "El teu compte és en un altre dispositiu? Escaneja amb Commons"
   },
   "common": {
     "actions": {
@@ -277,6 +279,7 @@
     "help": "Ajuda i comentaris",
     "signOut": "Tancar sessió",
     "privacy": "Política de privacitat",
-    "terms": "Condicions del servei"
+    "terms": "Condicions del servei",
+    "identity": "La teva identitat"
   }
 }

package/src/i18n/locales/de-DE.json

@@ -52,19 +52,9 @@
   "signup": {
     "title": "Erstellen Sie Ihr Konto",
     "subtitle": "Eine Identität für das gesamte Ökosystem.",
-    "commonsHeadline": "Erstellen Sie Ihre Identität in Commons",
-    "commonsExplainer": "Commons ist Ihre vollständig selbstverwaltete Oxy-Identität – eine App, überall einsetzbar.",
     "createInCommons": "Erstellen Sie Ihre Identität in Commons",
-    "passkeyAlternative": "Kein Commons? Erstellen Sie stattdessen einen Passkey auf diesem Gerät",
     "createAccount": "Konto erstellen",
-    "creating": "Wird erstellt…",
-    "usernamePlaceholder": "Benutzernamen wählen",
-    "usernameChecking": "Wird geprüft…",
-    "usernameAvailable": "Verfügbar",
-    "usernameTaken": "Dieser Benutzername ist bereits vergeben",
     "backToSignInLink": "Sie haben bereits ein Konto? Anmelden",
-    "hubExplainer": "Erstellen Sie Ihre Oxy-ID in einem sicheren Fenster und kehren Sie dann direkt zurück.",
-    "continueInWindow": "In einem neuen Fenster fortfahren",
     "welcome": {
       "title": "Willkommen bei Oxy!",
       "subtitle": "Erstellen Sie Ihr Konto in nur wenigen Schritten",
@@ -119,7 +109,6 @@
     "qrHeadline": "Melden Sie sich mit Ihrer Oxy-Identität an",
     "signInWithOxy": "Mit Oxy anmelden",
     "useIdentityOnDevice": "Kein Commons? Verwenden Sie stattdessen einen Passkey auf diesem Gerät",
-    "passkeySigningIn": "Anmeldung läuft…",
     "getCommons": "Commons herunterladen",
     "commonsNotInstalled": "Kein Commons? Holen Sie sich die App, um sich mit Ihrer Oxy-ID anzumelden.",
     "showQrAnyway": "Ich habe Commons auf einem anderen Gerät",
@@ -136,7 +125,20 @@
       "openedInCommons": "In Commons geöffnet",
       "confirming": "Identität wird bestätigt",
       "confirmed": "Identität bestätigt"
-    }
+    },
+    "signInFailures": {
+      "denied": "Die Anmeldung wurde in Commons abgelehnt.",
+      "expired": "Die Anmeldeanfrage ist abgelaufen. Bitte versuchen Sie es erneut.",
+      "network": "Oxy ist nicht erreichbar. Prüfen Sie Ihre Verbindung und versuchen Sie es erneut.",
+      "notConfigured": "Diese App ist noch nicht für die Anmeldung eingerichtet.",
+      "unsupportedFlow": "Diese Anmeldung kann hier nicht abgeschlossen werden.",
+      "claimFailed": "Die Anmeldung wurde genehmigt, konnte aber nicht abgeschlossen werden. Bitte versuchen Sie es erneut.",
+      "generic": "Die Anmeldung ist fehlgeschlagen. Bitte versuchen Sie es erneut."
+    },
+    "linkOpenFailed": "Der Link konnte nicht geöffnet werden. Bitte versuchen Sie es erneut.",
+    "continueWithPasskey": "Weiter",
+    "passkeyHint": "Nutzen Sie Fingerabdruck, Gesicht oder die Geräte-PIN.",
+    "otherDeviceCommons": "Konto auf einem anderen Gerät? Mit Commons scannen"
   },
   "common": {
     "actions": {
@@ -277,6 +279,7 @@
     "help": "Hilfe & Feedback",
     "signOut": "Abmelden",
     "privacy": "Datenschutzerklärung",
-    "terms": "Nutzungsbedingungen"
+    "terms": "Nutzungsbedingungen",
+    "identity": "Ihre Identität"
   }
 }