@oxy.so/core 7.28.0 → 7.30.0

package/dist/esm/api/identity.js

@@ -18,6 +18,7 @@
  * AEAD, signatures) load on first use, never with the client itself.
  */
 import { checkContract, IDENTITY_PROOF_ACTIONS, identityLinkCreateResponseCheck, identityLinkStateCheck, } from '@oxy.so/contracts/client';
+import { identityKeyHistoryCheck } from '@oxy.so/contracts/client';
 import { isAndroid, isWeb } from '../utils/platform.js';
 import { logger } from '../logger/index.js';
 /** Short-TTL read cache for public identity reads. */
@@ -158,7 +159,7 @@ export class IdentityApi {
         if (!userId) {
             throw new Error('No authenticated user — sign in before rotating your key.');
         }
-        const { KeyManager, RecoveryPhraseService, SignatureService, signMessage } = await import('../crypto/index.js');
+        const { KeyManager, RecoveryPhraseService, SignatureService, signMessage, retireIdentityKey } = await import('../crypto/index.js');
         // 1. The NEW identity (in memory only). The UI may pre-derive + pre-show
         //    it and pass it back here so the phrase shown === the phrase committed.
         const pending = options.pendingIdentity ?? (await RecoveryPhraseService.derivePendingIdentity());
@@ -166,6 +167,7 @@ export class IdentityApi {
         // 2. Resolve the OLD signing capability from the chosen proof mode.
         let oldPublicKey;
         let signWithOldKey;
+        let oldPrivateKeyForRing;
         if (options.proof === 'phrase') {
             const phrase = options.phrase?.trim();
             if (!phrase) {
@@ -174,6 +176,7 @@ export class IdentityApi {
             const oldPrivateKey = await RecoveryPhraseService.derivePrivateKeyFromPhrase(phrase);
             oldPublicKey = KeyManager.derivePublicKey(oldPrivateKey);
             signWithOldKey = (message) => signMessage(message, oldPrivateKey);
+            oldPrivateKeyForRing = oldPrivateKey;
         }
         else {
             const currentPublicKey = await KeyManager.getPublicKey();
@@ -182,6 +185,25 @@ export class IdentityApi {
             }
             oldPublicKey = currentPublicKey;
             signWithOldKey = (message) => SignatureService.sign(message);
+            oldPrivateKeyForRing = isWeb() ? null : await KeyManager.getPrivateKey();
+        }
+        // 2b. Keep the key being replaced in the retired ring BEFORE anything
+        //     changes (oxy ADR 0061 D7 as amended, Peable ADR 0002): coins keep
+        //     arriving under it after the swap, and the Peable wallet spends them
+        //     through the `publicKey` selector of `deriveScopedSeed` /
+        //     `signSocialReceive`. A device that cannot keep it does not rotate:
+        //     the phrase would become the only way to those coins. Native only —
+        //     on web no key is stored. Idempotent, so a retried rotation is fine.
+        if (!isWeb()) {
+            try {
+                if (!oldPrivateKeyForRing)
+                    throw new Error('no readable private key');
+                await retireIdentityKey({ privateKey: oldPrivateKeyForRing, publicKey: oldPublicKey });
+            }
+            catch (retainError) {
+                logger.warn('Could not keep the current key as a retired key; not rotating.', { component: 'oxy.identity', method: 'rotateKey' }, retainError);
+                throw new Error('Your current key could not be kept on this device, so it was not rotated. Nothing changed.');
+            }
         }
         // 3. Request a single-use rotate_key challenge (bearer).
         const { challenge } = await this.ctx.request('POST', '/auth/rotate/challenge', undefined, {
@@ -338,6 +360,23 @@ export class IdentityApi {
             keys.push(`GET:/u/${encodeURIComponent(userId)}/did.json`);
         this.ctx.http.invalidateCache({ keys, prefixes: ['GET:/users/me'] });
     }
+    /**
+     * The signed-in personal account's current root (`null` without one) and
+     * every root a rotation replaced, oldest first, all canonical (uncompressed,
+     * lowercase). Commons reads it to accept a previous recovery phrase only when
+     * it derives a key that WAS this account's root. A retired root is never any
+     * account's again. First-party only; a non-personal account is refused
+     * (`IDENTITY_NOT_PERSONAL_ACCOUNT`).
+     */
+    async keyHistory() {
+        const res = await this.ctx.request('GET', '/identity/key-history', undefined, {
+            cache: false,
+        });
+        const parsed = checkContract(identityKeyHistoryCheck, res);
+        if (!parsed)
+            throw new Error('identity/key-history returned an unexpected response shape');
+        return parsed;
+    }
 }
 /** `oxy.identity.links` — joining Commons' root to an account (ADR 0029 D3). */
 export class IdentityLinksApi {

package/dist/esm/crypto/index.js

@@ -17,6 +17,12 @@ export { KeyManager, IdentityAlreadyExistsError, IdentityPersistError, IdentityU
 export { readIdentityMarker, updateIdentityMarker } from './identityMarker.js';
 // Organization keys on the device (docs/adr/0061-organization-identity-key.md D6)
 export { generateOrganizationKey, organizationKeyFromPhrase, storeOrganizationKey, getOrganizationPublicKey, getOrganizationPrivateKey, getOrganizationRecoveryPhrase, listOrganizationKeys, deleteOrganizationKey, syncOrganizationKeys, isOrganizationAccountId, isHealthyOrganizationKeyPair, } from './organizationKeys.js';
+// iOS keychain access groups (docs/identity/ios-keychain-access-groups.md, ADR 0062)
+export { KEYCHAIN_ACCESS_GROUPS, KeychainAccessUnavailableError, keychainGroupFor, mayHoldKeychainItem, resolveKeychainAccess, keychainAccessGroupValue, keychainReadPlan, keychainDeletePlan, keychainWriteOption, ownKeychainItemPlan, readThroughPlan, deleteThroughPlan, groupedKeychainStore, } from '../utils/keychainAccessGroups.js';
+export { ensureKeychainGroupsMigrated } from './keychainGroupMigration.js';
+// Retired identity keys: kept for spending after a rotation or replacement
+// (docs/adr/0061-organization-identity-key.md D7 as amended 2026-11-06)
+export { retireIdentityKey, listRetiredIdentityKeys, forgetRetiredIdentityKey, forgetRetiredIdentityKeys, syncRetiredKeys, retiredKeyFromPhrase, } from './retiredKeys.js';
 export { SignatureService } from './signatureService.js';
 export { RecoveryPhraseService, BACKUP_KDF_ENCRYPTION_INFO } from './recoveryPhrase.js';
 // Low-level primitives (encrypted backup, device transfer)

package/dist/esm/crypto/keyManager.js

@@ -11,6 +11,10 @@ import { isDev, logger } from '../logger/index.js';
 import { deriveScopedSeedFromKey, signSocialReceiveDigest } from './identityDerivations.js';
 import { registerIdentitySignerStore } from './identitySigner.js';
 import { getOrganizationPrivateKey, isOrganizationAccountId } from './organizationKeys.js';
+import { forgetRetiredIdentityKeys, getRetiredPrivateKey, retiredKeyScope } from './retiredKeys.js';
+import { groupedKeychainStore, resolveKeychainAccess, } from '../utils/keychainAccessGroups.js';
+import { ensureKeychainGroupsMigrated } from './keychainGroupMigration.js';
+import { RECOVERY_MNEMONIC_KEYCHAIN_SERVICE, RECOVERY_MNEMONIC_STORAGE_KEY, STORAGE_KEYS, V2_BACKUP_KEYCHAIN_SERVICE, V2_PRIMARY_KEYCHAIN_SERVICE, V2_STORAGE_KEYS, } from './keychainItems.js';
 import { clearIdentityMarker, readIdentityMarker, updateIdentityMarker, writeIdentityMarker, } from './identityMarker.js';
 import { DEVICE_BACKUP_VERSION, parseDeviceBackup, serializeDeviceBackup, } from './deviceBackup.js';
 /**
@@ -68,16 +72,6 @@ export class IdentityUnavailableError extends Error {
         this.name = 'IdentityUnavailableError';
     }
 }
-const STORAGE_KEYS = {
-    PRIVATE_KEY: 'oxy_identity_private_key',
-    PUBLIC_KEY: 'oxy_identity_public_key',
-    BACKUP_PRIVATE_KEY: 'oxy_identity_backup_private_key',
-    BACKUP_PUBLIC_KEY: 'oxy_identity_backup_public_key',
-    BACKUP_TIMESTAMP: 'oxy_identity_backup_timestamp',
-    // The cross-app identity in the iOS keychain access group (iOS only).
-    SHARED_PRIVATE_KEY: 'oxy_shared_identity_private_key',
-    SHARED_PUBLIC_KEY: 'oxy_shared_identity_public_key',
-};
 /**
  * v2 identity slot layout — blast-radius isolation.
  *
@@ -93,15 +87,8 @@ const STORAGE_KEYS = {
  * Migration from the legacy layout is lazy + verify-before-delete — see
  * {@link KeyManager._runSlotMigration}.
  */
-const V2_PRIMARY_KEYCHAIN_SERVICE = 'oxy_identity';
-const V2_BACKUP_KEYCHAIN_SERVICE = 'oxy_identity_backup';
-const V2_STORAGE_KEYS = {
-    PRIVATE_KEY: 'oxy_identity_private_key_v2',
-    PUBLIC_KEY: 'oxy_identity_public_key_v2',
-    BACKUP_PRIVATE_KEY: 'oxy_identity_backup_private_key_v2',
-    BACKUP_PUBLIC_KEY: 'oxy_identity_backup_public_key_v2',
-    BACKUP_TIMESTAMP: 'oxy_identity_backup_timestamp_v2',
-};
+// The names (V2_PRIMARY_KEYCHAIN_SERVICE, V2_BACKUP_KEYCHAIN_SERVICE,
+// V2_STORAGE_KEYS) live in `./keychainItems`, beside every other identity item.
 /**
  * Dedicated keychain slot for the recovery mnemonic (the 12-word phrase).
  *
@@ -118,8 +105,7 @@ const V2_STORAGE_KEYS = {
  * lives ONLY in this slot: it is never mirrored into the identity marker,
  * {@link KeyManager.getIdentityStatus}, logs, or any exported bundle.
  */
-const RECOVERY_MNEMONIC_KEYCHAIN_SERVICE = 'oxy_identity_mnemonic';
-const RECOVERY_MNEMONIC_STORAGE_KEY = 'oxy_identity_mnemonic_v1';
+// RECOVERY_MNEMONIC_KEYCHAIN_SERVICE / RECOVERY_MNEMONIC_STORAGE_KEY: `./keychainItems`.
 /**
  * Advisory AsyncStorage fast-path flag: set once the v2 slots own the identity.
  * Re-derivable (its loss just re-runs the cheap slot check), so it lives in
@@ -154,12 +140,6 @@ const LEGACY_SLOT_LAYOUT = {
     backupPublicKeyName: STORAGE_KEYS.BACKUP_PUBLIC_KEY,
     backupTimestampName: STORAGE_KEYS.BACKUP_TIMESTAMP,
 };
-/**
- * iOS Keychain Access Group for sharing identities across Oxy apps
- * All Oxy apps must have this access group enabled in their entitlements
- * Format: [Team ID].so.oxy.shared or group.so.oxy.shared
- */
-const IOS_KEYCHAIN_GROUP = 'group.so.oxy.shared';
 /**
  * Initialize React Native specific modules
  *
@@ -169,7 +149,7 @@ const IOS_KEYCHAIN_GROUP = 'group.so.oxy.shared';
  * `expo-secure-store`; off RN it throws (and is never called because every
  * caller is gated by `isWebPlatform()` / native-only paths).
  */
-async function initSecureStore() {
+async function loadRawSecureStore() {
     try {
         return await loadSecureStore();
     }
@@ -178,6 +158,29 @@ async function initSecureStore() {
         throw new Error(`Failed to load expo-secure-store: ${errorMessage}. Make sure expo-secure-store is installed and properly configured.`);
     }
 }
+/**
+ * The secure store routed to the keychain group of `item`
+ * (`../utils/keychainAccessGroups`): on iOS reads walk the item's group then
+ * the pre-split shared group, writes carry the item's group and THROW in an app
+ * that may not hold it, and in Commons every access first awaits the
+ * access-group migration. Android and web are unchanged (`ungrouped`).
+ *
+ * Throws when the store cannot load or the keychain cannot say which groups
+ * this app holds; every caller already treats a throw here as "storage
+ * unavailable".
+ */
+async function keychainItemStore(item) {
+    const raw = await loadRawSecureStore();
+    const access = await resolveKeychainAccess();
+    if (access.mode === 'grouped' && access.role === 'holder') {
+        await ensureKeychainGroupsMigrated();
+    }
+    return groupedKeychainStore(raw, access, item);
+}
+/** The store for the identity slots (primary, backup, legacy, phrase): Commons only on iOS. */
+function initSecureStore() {
+    return keychainItemStore('identity-secret');
+}
 /**
  * Check if we're on web platform
  * Identity storage is only available on native platforms (iOS/Android)
@@ -568,12 +571,12 @@ export class KeyManager {
      * rung. Best-effort — the shared slot is a redundant convenience copy. The
      * Android signer store is cleared on every delete, in {@link deleteIdentity}.
      */
-    static async _clearSharedSlot(store) {
+    static async _clearSharedSlot(_identityStore) {
         try {
             if (isIOS()) {
-                const opts = { keychainAccessGroup: IOS_KEYCHAIN_GROUP };
-                await store.deleteItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, opts);
-                await store.deleteItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, opts);
+                // The shared slot lives in two groups of its own, not the identity slots'.
+                await (await keychainItemStore('spending-key')).deleteItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY);
+                await (await keychainItemStore('shared')).deleteItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY);
             }
             KeyManager.invalidateSharedCache();
         }
@@ -640,6 +643,20 @@ export class KeyManager {
         KeyManager.cachedSharedPublicKey = null;
         KeyManager.cachedHasSharedIdentity = null;
     }
+    /**
+     * iOS: write the personal key's cross-app slot — the private key to the
+     * wallet group (Commons and the Peable wallet), the public key to the shared
+     * group (every Oxy app). Throws in any app that may not hold the private key.
+     * @internal
+     */
+    static async _writeIosSharedSlot(privateKey, publicKey) {
+        const privateStore = await keychainItemStore('spending-key');
+        const privateOpts = {
+            keychainAccessible: privateStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+        };
+        await privateStore.setItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, privateKey, privateOpts);
+        await (await keychainItemStore('shared')).setItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, publicKey, {});
+    }
     /**
      * Lowercase and pad to canonical 64-hex-char form.
      *
@@ -675,8 +692,10 @@ export class KeyManager {
     // ==================== SHARED IDENTITY METHODS ====================
     // One Oxy identity across every Oxy app on a device.
     //
-    // iOS: the keychain access group `group.so.oxy.shared`. Every Oxy app reads
-    //   the same keychain item, and no app can wipe another's keychain.
+    // iOS: keychain access groups (docs/identity/ios-keychain-access-groups.md).
+    //   The private key is in `<TEAM>.so.oxy.wallet` (Commons and the Peable
+    //   wallet only), the public key in `<TEAM>.group.so.oxy.shared`, which every
+    //   Oxy app reads. Every other app signs in through Commons (ADR 0029).
     // Android: every app has its own UID, so nothing is shared through storage.
     //   Commons is the ONLY holder of the private key. It keeps the identity
     //   signer store (`setIdentitySignerStore`) for its identity host, and every
@@ -701,21 +720,11 @@ export class KeyManager {
         }
         const { privateKey, publicKey } = await KeyManager.generateKeyPair();
         if (isIOS()) {
-            const store = await initSecureStore();
-            // Note: keychainAccessGroup requires Keychain Sharing capability in Xcode
             try {
-                const privateOpts = {
-                    keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
-                    keychainAccessGroup: IOS_KEYCHAIN_GROUP, // Enables sharing across apps
-                };
-                await store.setItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, privateKey, privateOpts);
-                const publicOpts = {
-                    keychainAccessGroup: IOS_KEYCHAIN_GROUP,
-                };
-                await store.setItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, publicKey, publicOpts);
+                await KeyManager._writeIosSharedSlot(privateKey, publicKey);
             }
             catch (error) {
-                throw new Error(`Failed to create shared identity on iOS. Ensure your app has the Keychain Sharing capability enabled with access group "${IOS_KEYCHAIN_GROUP}". Error: ${error}`);
+                throw new Error(`Failed to create shared identity on iOS. Only Commons may write it, with the keychain access groups of docs/identity/ios-keychain-access-groups.md. Error: ${error}`);
             }
         }
         else if (isAndroid()) {
@@ -755,9 +764,8 @@ export class KeyManager {
         try {
             let publicKey = null;
             if (isIOS()) {
-                const store = await initSecureStore();
-                const opts = { keychainAccessGroup: IOS_KEYCHAIN_GROUP };
-                publicKey = await store.getItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, opts);
+                const store = await keychainItemStore('shared');
+                publicKey = await store.getItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, {});
             }
             else if (isAndroid()) {
                 const signer = KeyManager.identitySignerStore;
@@ -797,9 +805,10 @@ export class KeyManager {
             return null;
         }
         try {
-            const store = await initSecureStore();
-            const opts = { keychainAccessGroup: IOS_KEYCHAIN_GROUP };
-            return await store.getItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, opts);
+            // The wallet group: Commons and the Peable wallet. Every other app's plan
+            // is empty, so this is `null` there without touching the keychain.
+            const store = await keychainItemStore('spending-key');
+            return await store.getItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, {});
         }
         catch (error) {
             if (isDev()) {
@@ -893,16 +902,7 @@ export class KeyManager {
         const canonicalPrivate = KeyManager.canonicalPrivateKey(privateKey);
         const publicKey = deriveSecp256k1PublicKey(canonicalPrivate);
         if (isIOS()) {
-            const store = await initSecureStore();
-            const privateOpts = {
-                keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
-                keychainAccessGroup: IOS_KEYCHAIN_GROUP,
-            };
-            await store.setItemAsync(STORAGE_KEYS.SHARED_PRIVATE_KEY, canonicalPrivate, privateOpts);
-            const publicOpts = {
-                keychainAccessGroup: IOS_KEYCHAIN_GROUP,
-            };
-            await store.setItemAsync(STORAGE_KEYS.SHARED_PUBLIC_KEY, publicKey, publicOpts);
+            await KeyManager._writeIosSharedSlot(canonicalPrivate, publicKey);
         }
         else if (isAndroid()) {
             await KeyManager._writeIdentitySigner(canonicalPrivate, publicKey);
@@ -2050,6 +2050,13 @@ export class KeyManager {
         if (force) {
             await KeyManager._bestEffortDeleteBackupsAllGenerations(store);
             await KeyManager._clearSharedSlot(store);
+            // The person's retired keys go with the identity they belonged to.
+            try {
+                await forgetRetiredIdentityKeys();
+            }
+            catch (error) {
+                logger.warn('Failed to clear retired keys during delete', { component: 'KeyManager' }, error);
+            }
         }
         // The device backup goes on EVERY delete, forced or not: it is restored
         // silently, so leaving it would bring a deleted identity back on the next
@@ -2567,7 +2574,8 @@ export class KeyManager {
      * `HDKey.fromMasterSeed` and never touches the identity key.
      *
      * Key source (native only):
-     * - iOS: the shared identity in `group.so.oxy.shared`, then this device's
+     * - iOS: the shared slot's private key in the wallet keychain group (Commons
+     *   and the Peable wallet only; `null` in every other app), then this device's
      *   primary identity.
      * - Android: Commons (the one app with a signer store) uses its own primary
      *   identity; every other app asks Commons over IPC and never reads a local
@@ -2581,8 +2589,15 @@ export class KeyManager {
      * keychain group, or Commons' identity host. It never falls back to the
      * personal key.
      *
+     * With `opts.publicKey` the seed is derived from the key of that account
+     * (personal, or `accountId`'s) whose public key it names: the current key
+     * when it matches, else a RETIRED key Commons kept after a rotation or
+     * replacement (`./retiredKeys`, ADR 0061 D7 as amended). Spending only: a
+     * retired key never signs in. Never falls back to another key.
+     *
      * @param info Context/domain-binding label (distinct labels → independent seeds).
      * @param opts.accountId An organization's account id, for its key.
+     * @param opts.publicKey Selects one key of that account by its public key.
      * @returns 32 bytes of derived keying material, or `null` on web / when no
      *          identity key is available to this app.
      */
@@ -2590,6 +2605,18 @@ export class KeyManager {
         if (isWebPlatform()) {
             return null;
         }
+        if (opts?.publicKey !== undefined) {
+            if (isAndroid() && !KeyManager.identitySignerStore) {
+                const selected = KeyManager._selectorKey(opts.publicKey);
+                if (!selected)
+                    return null;
+                const bridge = await loadCommonsIdentityBridge();
+                const seed = (await bridge?.deriveRetiredScopedSeed?.(info, selected, opts.accountId)) ?? null;
+                return seed ? hexToBytes(seed) : null;
+            }
+            const selected = await KeyManager._selectedPrivateKey(opts.publicKey, opts.accountId);
+            return selected ? deriveScopedSeedFromKey(selected, info) : null;
+        }
         if (opts?.accountId !== undefined) {
             return KeyManager._deriveOrganizationScopedSeed(info, opts.accountId);
         }
@@ -2635,7 +2662,8 @@ export class KeyManager {
      * compressed public key for the scriptSig.
      *
      * Key source: as {@link deriveScopedSeed}, including `opts.accountId` for an
-     * organization's key (ADR 0061 D6). On Android outside Commons the signature
+     * organization's key (ADR 0061 D6) and `opts.publicKey` for one key of the
+     * account, current or retired. On Android outside Commons the signature
      * comes from Commons, which allows it for the wallet app only.
      *
      * @returns the signature, or `null` on web / when no identity key is
@@ -2645,6 +2673,18 @@ export class KeyManager {
         if (isWebPlatform()) {
             return null;
         }
+        if (opts?.publicKey !== undefined) {
+            if (isAndroid() && !KeyManager.identitySignerStore) {
+                const selected = KeyManager._selectorKey(opts.publicKey);
+                if (!selected)
+                    return null;
+                const bridge = await loadCommonsIdentityBridge();
+                return ((await bridge?.signRetiredSocialReceive?.(index, digest, selected, opts.accountId)) ??
+                    null);
+            }
+            const selected = await KeyManager._selectedPrivateKey(opts.publicKey, opts.accountId);
+            return selected ? signSocialReceiveDigest(selected, index, digest) : null;
+        }
         const accountId = opts?.accountId;
         if (accountId !== undefined) {
             // An organization key (ADR 0061 D6); never the personal one in its place.
@@ -2668,6 +2708,34 @@ export class KeyManager {
             : ((await KeyManager.getSharedPrivateKey()) ?? (await KeyManager.getPrivateKey()));
         return local ? signSocialReceiveDigest(local, index, digest) : null;
     }
+    /**
+     * The private key of the account (personal, or `accountId`'s organization)
+     * whose public key is `publicKey`, from this app's own storage: the current
+     * key when it matches, else the retired ring. iOS and Commons only; `null`
+     * for a key this device does not hold. Never another key in its place. @internal
+     */
+    /**
+     * The selector in the identity host's encoding (lowercase uncompressed), so a
+     * compressed `#key-1` from a DID or a gateway row selects the same key. @internal
+     */
+    static _selectorKey(publicKey) {
+        return KeyManager.isValidPublicKey(publicKey) ? KeyManager.canonicalPublicKey(publicKey) : null;
+    }
+    static async _selectedPrivateKey(publicKey, accountId) {
+        if (retiredKeyScope({ accountId }) === null || !KeyManager.isValidPublicKey(publicKey)) {
+            return null;
+        }
+        const wanted = KeyManager.canonicalPublicKey(publicKey);
+        const current = accountId !== undefined
+            ? await getOrganizationPrivateKey(accountId)
+            : isAndroid()
+                ? await KeyManager.getPrivateKey()
+                : ((await KeyManager.getSharedPrivateKey()) ?? (await KeyManager.getPrivateKey()));
+        if (current && KeyManager.canonicalPublicKey(KeyManager.derivePublicKey(current)) === wanted) {
+            return current;
+        }
+        return getRetiredPrivateKey(wanted, accountId !== undefined ? { accountId } : undefined);
+    }
     /**
      * Get a shortened version of the public key for display
      * Format: first 8 chars...last 8 chars