diff --git a/.github/workflows/dashnote-e2e.yml b/.github/workflows/dashnote-e2e.yml
index 5f781ce8..e79ad364 100644
--- a/.github/workflows/dashnote-e2e.yml
+++ b/.github/workflows/dashnote-e2e.yml
@@ -5,11 +5,19 @@ on:
     branches: [main]
     paths:
       - 'example-apps/dashnote/**'
+      - 'example-apps/token-ops/src/dash/loginWithPrivateKey.ts'
+      - 'example-apps/token-ops/src/lib/detectSecretShape.ts'
+      - 'example-apps/token-ops/src/session/keyManagerFromKey.ts'
+      - 'scripts/check-shared-auth-parity.sh'
       - '.github/workflows/dashnote-e2e.yml'
   pull_request:
     branches: [main]
     paths:
       - 'example-apps/dashnote/**'
+      - 'example-apps/token-ops/src/dash/loginWithPrivateKey.ts'
+      - 'example-apps/token-ops/src/lib/detectSecretShape.ts'
+      - 'example-apps/token-ops/src/session/keyManagerFromKey.ts'
+      - 'scripts/check-shared-auth-parity.sh'
       - '.github/workflows/dashnote-e2e.yml'
   workflow_dispatch:
     inputs:
@@ -30,6 +38,17 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  auth-parity:
+    name: shared auth parity
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - name: Check shared authentication parity
+        run: bash scripts/check-shared-auth-parity.sh
+
   e2e-read-only:
     name: e2e (read-only — smoke + settings)
     runs-on: ubuntu-latest
diff --git a/.github/workflows/token-ops-ci.yml b/.github/workflows/token-ops-ci.yml
index 2bc87684..d9a805b0 100644
--- a/.github/workflows/token-ops-ci.yml
+++ b/.github/workflows/token-ops-ci.yml
@@ -5,11 +5,19 @@ on:
     branches: [main]
     paths:
       - 'example-apps/token-ops/**'
+      - 'example-apps/dashnote/src/dash/loginWithPrivateKey.ts'
+      - 'example-apps/dashnote/src/lib/detectSecretShape.ts'
+      - 'example-apps/dashnote/src/session/keyManagerFromKey.ts'
+      - 'scripts/check-shared-auth-parity.sh'
       - '.github/workflows/token-ops-ci.yml'
   pull_request:
     branches: [main]
     paths:
       - 'example-apps/token-ops/**'
+      - 'example-apps/dashnote/src/dash/loginWithPrivateKey.ts'
+      - 'example-apps/dashnote/src/lib/detectSecretShape.ts'
+      - 'example-apps/dashnote/src/session/keyManagerFromKey.ts'
+      - 'scripts/check-shared-auth-parity.sh'
       - '.github/workflows/token-ops-ci.yml'
   workflow_dispatch:
 
@@ -33,6 +41,9 @@ jobs:
         with:
           persist-credentials: false
 
+      - name: Check shared authentication parity
+        run: bash ../../scripts/check-shared-auth-parity.sh
+
       - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version-file: .nvmrc
diff --git a/README.md b/README.md
index 6943c31f..41ff3784 100644
--- a/README.md
+++ b/README.md
@@ -93,6 +93,13 @@ the normal lifecycle: info, mint, transfer, and burn.
 Some client configuration options are included as comments in
 [`setupDashClient.mjs`](./setupDashClient.mjs) if more advanced configuration is required.
 
+## Example Apps
+
+The [`example-apps`](./example-apps/README.md) directory contains independently runnable React +
+TypeScript npm projects that demonstrate Dash Platform concepts in complete browser workflows,
+including identities, documents, queries, tokens, and multi-signer groups. The apps have their own
+setup instructions and dependencies but share repository-level SDK client helpers.
+
 ## Testing
 
 Tests run each tutorial as a subprocess and validate its output. No test framework dependencies are
diff --git a/example-apps/README.md b/example-apps/README.md
index 5e90448e..04a2bfb9 100644
--- a/example-apps/README.md
+++ b/example-apps/README.md
@@ -1,12 +1,13 @@
-# Example Apps
+# 🚀 Example Apps
 
-Stand-alone applications built on top of the same `@dashevo/evo-sdk` used by the Node tutorials in the parent repo. Each example is an independent npm project — `cd` into its directory and run `npm install` there for the Vite app itself.
+Independently runnable applications built on the same `@dashevo/evo-sdk` used by the Node tutorials in the parent repo. Each example has its own npm project — `cd` into its directory and run `npm install` there for the Vite app itself — while sharing the repository-root `setupDashClient-core.mjs` helper for browser SDK setup and key management.
 
 Some app scripts still depend on the **repository-root** install. TokenOps `npm run bootstrap:identities` imports the root `setupDashClient.mjs` helper and the root `@dashevo/evo-sdk` copy (to keep a single module instance for SDK `instanceof` checks). For that path, run `npm install` at the repo root as well — see [token-ops/README.md](./token-ops/README.md#group-members).
 
-## Apps
+## 🧭 Apps
 
-- [dashmint-lab/](./dashmint-lab/) — React + TypeScript + Vite SPA for minting, viewing, transferring, and trading NFT-style collectible cards on Dash Platform testnet. Shares the browser-safe SDK core (`setupDashClient-core.mjs`) with the Node tutorials at the repo root.
-- [dashproof-lab/](./dashproof-lab/) — React + TypeScript + Vite proof-of-existence tutorial app that hashes files locally in the browser, anchors SHA-256 proofs on Dash Platform testnet, verifies files by hash, and reviews proof history by owner or chain ID. Also uses the shared browser-safe SDK core from the parent repo.
-- [dashnote/](./dashnote/) — React + TypeScript + Vite notes app for Dash Platform testnet. Create, edit, and delete notes against a small `note` data contract; supports a "Remember Me" read-only browse mode, optimistic localStorage cache, and ships a single-file zero-build read-only companion at `dashnote-lite.html`. Also uses the shared browser-safe SDK core from the parent repo.
-- [dashrate/](./dashrate/) — React + TypeScript + Vite app for rating Platform tutorial resources on Dash Platform testnet, built to showcase Platform 4.0's relational document queries: provable `count`, grouped `count` (`GROUP BY`) for the per-star distribution, range counts, and `where` filtering. One review per identity per resource (editable, with document history); read-only browsing works without signing in. Also uses the shared browser-safe SDK core from the parent repo.
+- 🃏 [dashmint-lab/](./dashmint-lab/) — React + TypeScript + Vite SPA for minting, viewing, transferring, and trading NFT-style collectible cards on Dash Platform testnet. Shares the browser-safe SDK core (`setupDashClient-core.mjs`) with the Node tutorials at the repo root.
+- 🔐 [dashproof-lab/](./dashproof-lab/) — React + TypeScript + Vite proof-of-existence tutorial app that hashes files locally in the browser, anchors SHA-256 proofs on Dash Platform testnet, verifies files by hash, and reviews proof history by owner or chain ID. Also uses the shared browser-safe SDK core from the parent repo.
+- 📝 [dashnote/](./dashnote/) — React + TypeScript + Vite notes app for Dash Platform testnet. Create, edit, and delete notes against a small `note` data contract; supports a "Remember Me" read-only browse mode, optimistic localStorage cache, and ships a single-file zero-build read-only companion at `dashnote-lite.html`. Also uses the shared browser-safe SDK core from the parent repo.
+- ⭐ [dashrate/](./dashrate/) — React + TypeScript + Vite app for rating Platform tutorial resources on Dash Platform testnet, built to showcase Platform 4.0's relational document queries: provable `count`, grouped `count` (`GROUP BY`) for the per-star distribution, range counts, and `where` filtering. One review per identity per resource (editable, with document history); read-only browsing works without signing in. Also uses the shared browser-safe SDK core from the parent repo.
+- 👥 [token-ops/](./token-ops/) — React + TypeScript + Vite app that demonstrates Dash Platform groups and multi-signer governance on testnet, using token operations as the example workflow. Create groups, propose and co-sign group-authorized actions, monitor signing progress, and inspect or reassign operator and admin authorities. Browse-only mode works without signing in.
diff --git a/example-apps/dashmint-lab/src/components/AppShell.tsx b/example-apps/dashmint-lab/src/components/AppShell.tsx
index bcbe8638..cca30098 100644
--- a/example-apps/dashmint-lab/src/components/AppShell.tsx
+++ b/example-apps/dashmint-lab/src/components/AppShell.tsx
@@ -175,7 +175,7 @@ export function AppShell({
         <div className="mx-auto max-w-[1310px]">{children}</div>
         <footer className="mx-auto mt-10 flex max-w-[1310px] justify-center border-t border-line pt-4 text-[12px] text-ink-3">
           <a
-            href="https://github.com/dashpay/platform-tutorials"
+            href="https://github.com/dashpay/platform-tutorials/tree/main/example-apps/dashmint-lab"
             target="_blank"
             rel="noreferrer"
             className="inline-flex items-center gap-1.5 text-ink-3 hover:text-accent"
diff --git a/example-apps/dashnote/CLAUDE.md b/example-apps/dashnote/CLAUDE.md
index ec48bd1d..507a5b17 100644
--- a/example-apps/dashnote/CLAUDE.md
+++ b/example-apps/dashnote/CLAUDE.md
@@ -21,9 +21,10 @@ React + TypeScript + Vite app for personal notes on Dash Platform testnet. Notes
 
 - **[src/dash/](src/dash/)** — one file per Platform SDK operation: [createNote.ts](src/dash/createNote.ts), [updateNote.ts](src/dash/updateNote.ts), [deleteNote.ts](src/dash/deleteNote.ts), [queries.ts](src/dash/queries.ts), [contract.ts](src/dash/contract.ts), [loginWithPrivateKey.ts](src/dash/loginWithPrivateKey.ts), [resolveDpnsName.ts](src/dash/resolveDpnsName.ts). Each exports an async function with a leading JSDoc block naming the SDK method it wraps. No hooks, no UI wrappers — the SDK call is the function. Files in this folder always reference `@dashevo/evo-sdk` (or shared core re-exports / SDK-shape types). App-shell utilities that don't touch the SDK live in [src/lib/](src/lib/) instead. Two deferred-import loaders live alongside the operations: [sdkModule.ts](src/dash/sdkModule.ts) caches a `import("@dashevo/evo-sdk")` so value imports (`Document`, `DataContract`, `Identifier`) stay out of the entry chunk, and [types.ts](src/dash/types.ts) holds the shared SDK type aliases used everywhere.
 - **Shared SDK core** — [src/dash/client.ts](src/dash/client.ts) and [src/dash/keyManager.ts](src/dash/keyManager.ts) re-export `createClient` and `IdentityKeyManager` from `../../../../setupDashClient-core.mjs` (the canonical browser-safe core at the host repo root). No vendoring. The `@dashevo/evo-sdk` bare specifier is aliased in [vite.config.ts](vite.config.ts) to this app's locally installed browser bundle so the shared core resolves the SDK from here.
-- **[src/session/](src/session/)** — `SessionContext.tsx` provides the context (`status`, `error`, `sdk`, `keyManager`, `identityId`, `contractId`, `rememberedIdentityId`, `dpnsName`, `setContractId`, `log`, `login`, `enterReadOnly`, `viewAsRemembered`, `forgetIdentity`, `logout`) and `useSession.ts` is the consumer hook. `login(secret, options)` auto-detects mnemonic vs WIF via [detectSecretShape](src/lib/detectSecretShape.ts): mnemonics use `IdentityKeyManager` (DIP-13 derivation with optional `identityIndex`); WIF dispatches to `loginWithPrivateKey` (dynamic-imported to keep its SDK dependency off the app shell), which produces a single-key manager via [keyManagerFromKey.ts](src/session/keyManagerFromKey.ts). Mnemonic + WIF live only in the keyManager closure — never in state, never in localStorage. `SessionContext` has its own small loader for the shared core (`createClient`, `IdentityKeyManager`); the `@dashevo/evo-sdk` value-import loader is the separate [sdkModule.ts](src/dash/sdkModule.ts) used by `createNote` / `updateNote` / `deleteNote` / `contract.ts`. Both are dynamically imported on first use so the ~8MB WASM bundle doesn't block initial paint. After a successful login the context also resolves the identity's DPNS name via [resolveDpnsName.ts](src/dash/resolveDpnsName.ts) and persists it alongside the remembered identity ID.
+- **[src/session/](src/session/)** — `SessionContext.tsx` provides the context (`status`, `error`, `sdk`, `keyManager`, `identityId`, `contractId`, `rememberedIdentityId`, `dpnsName`, `setContractId`, `log`, `login`, `enterReadOnly`, `viewAsRemembered`, `forgetIdentity`, `logout`) and `useSession.ts` is the consumer hook. `login(secret, options)` auto-detects mnemonic vs WIF via [detectSecretShape](src/lib/detectSecretShape.ts): mnemonics use `IdentityKeyManager` (DIP-13 derivation with optional `identityIndex`); WIF dispatches to `loginWithPrivateKey` (dynamic-imported to keep its SDK dependency off the app shell), which produces a single-key manager via [keyManagerFromKey.ts](src/session/keyManagerFromKey.ts). WIF resolution falls back to paginated `byNonUniquePublicKeyHash`; ambiguous keys require an exact `expectedIdentityId`, which is fetched directly and verified rather than resolved by result order. Mnemonic + WIF live only in the keyManager closure — never in state, never in localStorage. `SessionContext` has its own small loader for the shared core (`createClient`, `IdentityKeyManager`); the `@dashevo/evo-sdk` value-import loader is the separate [sdkModule.ts](src/dash/sdkModule.ts) used by `createNote` / `updateNote` / `deleteNote` / `contract.ts`. Both are dynamically imported on first use so the ~8MB WASM bundle doesn't block initial paint. After a successful login the context also resolves the identity's DPNS name via [resolveDpnsName.ts](src/dash/resolveDpnsName.ts) and persists it alongside the remembered identity ID only when the remember checkbox is enabled.
 - **[src/components/](src/components/)** — standard React. Modals/panels call `src/dash/` functions directly. Shell: [AppShell.tsx](src/components/AppShell.tsx), [Tabs.tsx](src/components/Tabs.tsx), [NavButton.tsx](src/components/NavButton.tsx), [HowItWorks.tsx](src/components/HowItWorks.tsx). Workspace: [NotesWorkspace.tsx](src/components/NotesWorkspace.tsx) (two-pane list + editor with optimistic cache + background revalidation), [NoteList.tsx](src/components/NoteList.tsx), [NoteEditor.tsx](src/components/NoteEditor.tsx) (fused title/body editor with byte-budget progress bar), [DeleteNoteModal.tsx](src/components/DeleteNoteModal.tsx) (confirmation modal for deletes). Auth + settings: [LoginModal.tsx](src/components/LoginModal.tsx) (mnemonic-or-WIF paste flow with remembered-identity panel), [SettingsPanel.tsx](src/components/SettingsPanel.tsx) (settings tab — contract paste / register, identity card, local-data controls), [IdentityCard.tsx](src/components/IdentityCard.tsx). Shared primitives: [Modal.tsx](src/components/Modal.tsx), [OperationResultNotice.tsx](src/components/OperationResultNotice.tsx).
 - **[src/hooks/](src/hooks/)** — app-specific hooks: [useTheme.ts](src/hooks/useTheme.ts) (dark mode toggle), [useMediaQuery.ts](src/hooks/useMediaQuery.ts) (`window.matchMedia` via `useSyncExternalStore`), [useContractRegistration.ts](src/hooks/useContractRegistration.ts) (Settings flow for paste-or-register), [useWifPreview.ts](src/hooks/useWifPreview.ts) (eager identity + key-fitness preview on WIF paste in the login modal).
+- **Shared auth parity:** `src/dash/loginWithPrivateKey.ts`, `src/lib/detectSecretShape.ts`, `src/session/keyManagerFromKey.ts`, and the core resolver suite `test/loginWithPrivateKey.test.ts` must remain byte-identical to their TokenOps counterparts. Keep app-specific preview, session, and modal behavior outside these files; CI enforces parity with `scripts/check-shared-auth-parity.sh`.
 - **[src/lib/](src/lib/)** — pure utilities, no SDK references: [logger.ts](src/lib/logger.ts) (`Logger` type + `errorMessage(err)`), [notesCache.ts](src/lib/notesCache.ts) (localStorage-backed note list keyed by identity + contract + network), [rememberedIdentity.ts](src/lib/rememberedIdentity.ts) (last-logged-in identity ID + DPNS name for read-only browse), [fieldLimits.ts](src/lib/fieldLimits.ts) (UTF-8 byte counters for title/message), [format.ts](src/lib/format.ts), [detectSecretShape.ts](src/lib/detectSecretShape.ts) (mnemonic-vs-WIF classifier used by `login` and the login modal preview).
 - **[src/dash/types.ts](src/dash/types.ts)** — shared SDK types (`DashSdk`, `DashKeyManager`, query result shapes) used across every dash helper.
 - **[public/dashnote-lite.html](public/dashnote-lite.html)** — single-file zero-build companion. Read-only Recent notes (with optional owner filter) + Get-by-ID only, loads `@dashevo/evo-sdk` from `esm.sh`, and ships alongside the React app at `<...>/dashnote/dashnote-lite.html` (Vite copies `public/*` into `dist/`). Intentionally self-contained as a learning reference — don't import app code into it.
diff --git a/example-apps/dashnote/README.md b/example-apps/dashnote/README.md
index 6f858c97..83a228a3 100644
--- a/example-apps/dashnote/README.md
+++ b/example-apps/dashnote/README.md
@@ -63,18 +63,18 @@ npm run preview       # Serve the production build
 
 Every SDK call lives in its own file under [`src/dash/`](./src/dash/). Open the file to see the full implementation with a JSDoc header naming the SDK method it wraps.
 
-| Operation              | File                                                                   | SDK method                                              |
-| ---------------------- | ---------------------------------------------------------------------- | ------------------------------------------------------- |
-| Connect to testnet     | [`src/dash/client.ts`](./src/dash/client.ts)                           | `EvoSDK.testnetTrusted()` + `sdk.connect()`             |
-| Derive identity keys   | [`src/dash/keyManager.ts`](./src/dash/keyManager.ts)                   | wallet/key derivation helpers (mnemonic path)           |
-| Login by private key   | [`src/dash/loginWithPrivateKey.ts`](./src/dash/loginWithPrivateKey.ts) | `PrivateKey.fromWIF` + `sdk.identities.byPublicKeyHash` |
-| Resolve DPNS name      | [`src/dash/resolveDpnsName.ts`](./src/dash/resolveDpnsName.ts)         | `sdk.dpns.username`                                     |
-| Register note contract | [`src/dash/contract.ts`](./src/dash/contract.ts)                       | `sdk.contracts.publish`                                 |
-| Create a note          | [`src/dash/createNote.ts`](./src/dash/createNote.ts)                   | `sdk.documents.create`                                  |
-| Update a note          | [`src/dash/updateNote.ts`](./src/dash/updateNote.ts)                   | `sdk.documents.get` + `sdk.documents.replace`           |
-| Delete a note          | [`src/dash/deleteNote.ts`](./src/dash/deleteNote.ts)                   | `sdk.documents.delete`                                  |
-| List my notes          | [`src/dash/queries.ts`](./src/dash/queries.ts)                         | `sdk.documents.query`                                   |
-| Get one note           | [`src/dash/queries.ts`](./src/dash/queries.ts)                         | `sdk.documents.get`                                     |
+| Operation              | File                                                                   | SDK method                                                                                     |
+| ---------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| Connect to testnet     | [`src/dash/client.ts`](./src/dash/client.ts)                           | `EvoSDK.testnetTrusted()` + `sdk.connect()`                                                    |
+| Derive identity keys   | [`src/dash/keyManager.ts`](./src/dash/keyManager.ts)                   | wallet/key derivation helpers (mnemonic path)                                                  |
+| Login by private key   | [`src/dash/loginWithPrivateKey.ts`](./src/dash/loginWithPrivateKey.ts) | `PrivateKey.fromWIF` + `sdk.identities.fetch` / `byPublicKeyHash` / `byNonUniquePublicKeyHash` |
+| Resolve DPNS name      | [`src/dash/resolveDpnsName.ts`](./src/dash/resolveDpnsName.ts)         | `sdk.dpns.username`                                                                            |
+| Register note contract | [`src/dash/contract.ts`](./src/dash/contract.ts)                       | `sdk.contracts.publish`                                                                        |
+| Create a note          | [`src/dash/createNote.ts`](./src/dash/createNote.ts)                   | `sdk.documents.create`                                                                         |
+| Update a note          | [`src/dash/updateNote.ts`](./src/dash/updateNote.ts)                   | `sdk.documents.get` + `sdk.documents.replace`                                                  |
+| Delete a note          | [`src/dash/deleteNote.ts`](./src/dash/deleteNote.ts)                   | `sdk.documents.delete`                                                                         |
+| List my notes          | [`src/dash/queries.ts`](./src/dash/queries.ts)                         | `sdk.documents.query`                                                                          |
+| Get one note           | [`src/dash/queries.ts`](./src/dash/queries.ts)                         | `sdk.documents.get`                                                                            |
 
 Update flow always fetches the document first to read its current revision, then submits a replace with `revision = BigInt(existing.revision ?? 0) + 1n`. Replays without bumping the revision are rejected by the state transition.
 
@@ -87,6 +87,8 @@ Supporting files:
 - **[`src/lib/rememberedIdentity.ts`](./src/lib/rememberedIdentity.ts)** — last-logged-in identity ID plus its DPNS name (when one was resolved) for read-only browse. Never stores the mnemonic or WIF.
 - **[`src/lib/detectSecretShape.ts`](./src/lib/detectSecretShape.ts)** — cheap "mnemonic vs WIF" classifier used by `SessionContext.login` and the login modal's eager WIF preview.
 
+WIF login treats the private key as a credential, not an identity identifier. The resolver accepts ECDSA key data encoded as either a full public key or ECDSA HASH160 value (hex or base64), while rejecting other HASH160 key types. If one key is associated with multiple identities, Dashnote does not list or guess among them: the login modal requires the full intended identity ID, fetches that identity directly, and verifies that the WIF is an enabled HIGH/CRITICAL authentication key for it. The identity ID and optional DPNS label are persisted only when **Remember this identity** is checked; private keys are never persisted.
+
 ## Reading the codebase
 
 Recommended order for understanding how the app works:
diff --git a/example-apps/dashnote/package-lock.json b/example-apps/dashnote/package-lock.json
index e0a441fd..7455050c 100644
--- a/example-apps/dashnote/package-lock.json
+++ b/example-apps/dashnote/package-lock.json
@@ -30,7 +30,7 @@
         "eslint-plugin-react-refresh": "^0.5.2",
         "globals": "^17.4.0",
         "jsdom": "^26.1.0",
-        "prettier": "^3.6.2",
+        "prettier": "3.8.4",
         "typescript": "~6.0.2",
         "typescript-eslint": "^8.58.0",
         "vite": "^8.0.4",
diff --git a/example-apps/dashnote/package.json b/example-apps/dashnote/package.json
index 052ac763..23fce26b 100644
--- a/example-apps/dashnote/package.json
+++ b/example-apps/dashnote/package.json
@@ -43,7 +43,7 @@
     "eslint-plugin-react-refresh": "^0.5.2",
     "globals": "^17.4.0",
     "jsdom": "^26.1.0",
-    "prettier": "^3.6.2",
+    "prettier": "3.8.4",
     "typescript": "~6.0.2",
     "typescript-eslint": "^8.58.0",
     "vite": "^8.0.4",
diff --git a/example-apps/dashnote/src/components/AppShell.tsx b/example-apps/dashnote/src/components/AppShell.tsx
index d438d547..36b9f3d1 100644
--- a/example-apps/dashnote/src/components/AppShell.tsx
+++ b/example-apps/dashnote/src/components/AppShell.tsx
@@ -267,7 +267,7 @@ export function AppShell({
           }`}
         >
           <a
-            href="https://github.com/dashpay/platform-tutorials"
+            href="https://github.com/dashpay/platform-tutorials/tree/main/example-apps/dashnote"
             target="_blank"
             rel="noreferrer"
             className="inline-flex items-center gap-1.5 text-ink-3 hover:text-accent"
diff --git a/example-apps/dashnote/src/components/LoginModal.tsx b/example-apps/dashnote/src/components/LoginModal.tsx
index 46c1ba33..c676b751 100644
--- a/example-apps/dashnote/src/components/LoginModal.tsx
+++ b/example-apps/dashnote/src/components/LoginModal.tsx
@@ -21,6 +21,8 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
   const [showAdvanced, setShowAdvanced] = useState(false);
   const [rememberMe, setRememberMe] = useState(true);
   const [useDifferentIdentity, setUseDifferentIdentity] = useState(false);
+  const [expectedIdentityId, setExpectedIdentityId] = useState("");
+  const [ambiguousWif, setAmbiguousWif] = useState<string | null>(null);
   const showRememberedPanel = Boolean(
     session.rememberedIdentityId && !useDifferentIdentity,
   );
@@ -31,10 +33,38 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
     [secret],
   );
   const isWifInput = secretShape === "wif";
-  const wifPreview = useWifPreview(session.sdk, secret, isWifInput);
+  const rememberedExpectedIdentityId = showRememberedPanel
+    ? (session.rememberedIdentityId ?? undefined)
+    : undefined;
+  const hasIdentityPrompt = isWifInput && expectedIdentityId.length > 0;
+  const effectiveExpectedIdentityId =
+    rememberedExpectedIdentityId ??
+    (hasIdentityPrompt ? expectedIdentityId.trim() || undefined : undefined);
+  const wifPreview = useWifPreview(
+    session.sdk,
+    secret,
+    isWifInput,
+    effectiveExpectedIdentityId,
+  );
+  const needsIdentityId =
+    hasIdentityPrompt ||
+    (isWifInput && ambiguousWif === secret.trim()) ||
+    wifPreview.status === "ambiguous";
   const previewBlocksLogin =
     wifPreview.status === "wrong-purpose" ||
-    wifPreview.status === "key-disabled";
+    wifPreview.status === "key-disabled" ||
+    wifPreview.status === "identity-mismatch" ||
+    wifPreview.status === "ambiguous" ||
+    (needsIdentityId && wifPreview.status !== "resolved");
+
+  useEffect(() => {
+    if (wifPreview.status === "ambiguous") {
+      // The preview is asynchronous state; retain its actionable result while
+      // a follow-up preview transitions through checking or idle.
+      // eslint-disable-next-line react-hooks/set-state-in-effect
+      setAmbiguousWif(secret.trim());
+    }
+  }, [secret, wifPreview.status]);
 
   useEffect(() => {
     if (open) {
@@ -42,6 +72,8 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
       setUseDifferentIdentity(false);
       setError(null);
       setSecret("");
+      setExpectedIdentityId("");
+      setAmbiguousWif(null);
     }
   }, [open]);
 
@@ -54,11 +86,17 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
       await session.login(secret, {
         identityIndex: Number.isNaN(index) ? 0 : index,
         rememberMe,
+        ...(isWifInput && effectiveExpectedIdentityId
+          ? { expectedIdentityId: effectiveExpectedIdentityId }
+          : {}),
       });
       setSecret("");
       onClose();
     } catch (err) {
       setError(errorMessage(err));
+      if (err instanceof Error && err.name === "AmbiguousIdentityError") {
+        setAmbiguousWif(secret.trim());
+      }
     } finally {
       setSubmitting(false);
     }
@@ -143,7 +181,11 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
             autoComplete="off"
             required
             value={secret}
-            onChange={(event) => setSecret(event.target.value)}
+            onChange={(event) => {
+              setSecret(event.target.value);
+              setExpectedIdentityId("");
+              setAmbiguousWif(null);
+            }}
             placeholder="Mnemonic phrase or WIF private key (high/critical)"
             className="rounded-md border border-line bg-bg px-3 py-2 text-[13px] text-ink outline-none transition focus:border-accent-dim"
           />
@@ -166,6 +208,18 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
                   </span>
                 </span>
               )}
+              {wifPreview.status === "ambiguous" && (
+                <span className="text-[color:var(--color-danger)]">
+                  This key is associated with multiple identities. Enter the
+                  full identity ID you intend to use.
+                </span>
+              )}
+              {wifPreview.status === "identity-mismatch" && (
+                <span className="text-[color:var(--color-danger)]">
+                  This key could not be verified as an eligible authentication
+                  key for that identity ID.
+                </span>
+              )}
               {wifPreview.status === "wrong-purpose" && (
                 <span className="text-[color:var(--color-danger)]">
                   Found identity{" "}
@@ -196,6 +250,27 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
           )}
         </label>
 
+        {needsIdentityId && !rememberedExpectedIdentityId && (
+          <label className="flex flex-col gap-1">
+            <span className="text-[10px] font-semibold uppercase tracking-[0.12em] text-ink-4">
+              Identity ID
+            </span>
+            <input
+              type="text"
+              value={expectedIdentityId}
+              onChange={(event) => setExpectedIdentityId(event.target.value)}
+              placeholder="Full Dash Platform identity ID"
+              autoComplete="off"
+              required
+              className="rounded-md border border-line bg-bg px-3 py-2 font-mono text-[12px] text-ink outline-none transition focus:border-accent-dim"
+            />
+            <span className="text-[11px] text-ink-4">
+              New notes will be owned by this exact identity. Dashnote does not
+              list identities associated with the key.
+            </span>
+          </label>
+        )}
+
         <div className="flex items-center gap-1.5 text-[11px] text-ink-4">
           <svg
             width="11"
@@ -218,7 +293,11 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
           >
             <button
               type="button"
-              onClick={() => setUseDifferentIdentity(true)}
+              onClick={() => {
+                setUseDifferentIdentity(true);
+                setExpectedIdentityId("");
+                setAmbiguousWif(null);
+              }}
               className="font-medium text-accent-dim underline-offset-2 hover:text-accent hover:underline"
             >
               Use a different identity
diff --git a/example-apps/dashnote/src/dash/loginWithPrivateKey.ts b/example-apps/dashnote/src/dash/loginWithPrivateKey.ts
index a9376efa..761ac13e 100644
--- a/example-apps/dashnote/src/dash/loginWithPrivateKey.ts
+++ b/example-apps/dashnote/src/dash/loginWithPrivateKey.ts
@@ -14,6 +14,15 @@ export class UnknownIdentityError extends Error {
   }
 }
 
+export class AmbiguousIdentityError extends Error {
+  constructor() {
+    super(
+      "This key is associated with multiple identities. Enter the full identity ID you want to use.",
+    );
+    this.name = "AmbiguousIdentityError";
+  }
+}
+
 export class WrongKeyPurposeError extends Error {
   identityId: string;
   purposeName: string;
@@ -25,7 +34,7 @@ export class WrongKeyPurposeError extends Error {
     securityLevelName: string,
   ) {
     super(
-      `Found identity ${identityId}, but this key can't sign document or contract operations. Paste a HIGH or CRITICAL authentication key instead.`,
+      `Found identity ${identityId}, but this key cannot sign state transitions. Paste a HIGH or CRITICAL authentication key instead.`,
     );
     this.name = "WrongKeyPurposeError";
     this.identityId = identityId;
@@ -46,7 +55,7 @@ export class KeyDisabledError extends Error {
 
 export class InvalidPrivateKeyError extends Error {
   constructor() {
-    super("This doesn't look like a valid private key (WIF).");
+    super("This does not look like a valid private key (WIF).");
     this.name = "InvalidPrivateKeyError";
   }
 }
@@ -55,6 +64,7 @@ interface IdentityJsonKey {
   id: number;
   purpose: number;
   securityLevel: number;
+  type?: number;
   data?: string;
   disabled?: boolean;
   disabledAt?: number | string | null;
@@ -85,7 +95,7 @@ function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
  * Decode a public-key data field from `identity.toJSON()`.
  *
  * Dash Platform's JSON encoding for bytes has historically been base64,
- * but some versions emit hex. We try base64 first (preferred), then hex,
+ * but some versions emit hex. We try hex first, then fall back to base64
  * before giving up. Returning null lets the caller skip a key it can't
  * compare rather than aborting.
  */
@@ -116,10 +126,10 @@ function tryDecodeKeyData(data: string): Uint8Array | null {
   }
 }
 
-// Document and contract state transitions require HIGH or CRITICAL auth.
+// State transitions require HIGH or CRITICAL authentication.
 // MASTER (key 0) can only sign identity-update transitions, so a user who
 // pastes their master WIF would log in successfully but fail at the first
-// note write — reject up front with a clear message instead.
+// write — reject up front with a clear message instead.
 const AUTH_SECURITY_LEVELS = new Set<number>([
   SecurityLevel.HIGH as unknown as number,
   SecurityLevel.CRITICAL as unknown as number,
@@ -153,6 +163,13 @@ interface ResolvedWifIdentity {
   identityKey: unknown;
 }
 
+interface MatchedIdentity {
+  identity: IdentityLike;
+  identityId: string;
+  matched: IdentityJsonKey;
+  error: Error | null;
+}
+
 /**
  * Resolve which identity a WIF private key belongs to and which key on that
  * identity it matches, without building a signer. Performs every check the
@@ -166,6 +183,7 @@ interface ResolvedWifIdentity {
 export async function resolveIdentityFromWif(
   sdk: DashSdk,
   wif: string,
+  expectedIdentityId?: string,
 ): Promise<ResolvedWifIdentity> {
   let privateKey: PrivateKey;
   try {
@@ -176,24 +194,6 @@ export async function resolveIdentityFromWif(
 
   const pubKeyHash = privateKey.getPublicKeyHash();
 
-  const identity = (await sdk.identities.byPublicKeyHash(
-    pubKeyHash as never,
-  )) as IdentityLike | undefined | null;
-  if (!identity) {
-    throw new UnknownIdentityError();
-  }
-
-  const identityId =
-    typeof identity.id === "string" ? identity.id : identity.id.toString();
-
-  const json = identity.toJSON?.();
-  const publicKeys = json?.publicKeys ?? [];
-  if (publicKeys.length === 0) {
-    // Shouldn't happen — byPublicKeyHash matched, so a key exists. Treat as
-    // an unexpected SDK response and fail closed.
-    throw new UnknownIdentityError();
-  }
-
   // Get the public key bytes our WIF derives, so we can identify which
   // entry in publicKeys[] is ours.
   const pkAny = privateKey as unknown as {
@@ -203,41 +203,108 @@ export async function resolveIdentityFromWif(
   const ourPubKey = pkAny.getPublicKey
     ? pkAny.getPublicKey()
     : pkAny.toPublicKey?.();
-  const ourPubKeyBytes: Uint8Array | null = ourPubKey
-    ? extractPubKeyBytes(ourPubKey)
-    : null;
+  const ourPubKeyBytes = ourPubKey ? extractPubKeyBytes(ourPubKey) : null;
+  const ourPubKeyHashBytes = normalizePublicKeyHash(pubKeyHash);
+  const expected = expectedIdentityId?.trim() || null;
+
+  if (expected) {
+    const expectedIdentity = (await sdk.identities.fetch(expected)) as
+      | IdentityLike
+      | undefined
+      | null;
+    if (!expectedIdentity) throw new UnknownIdentityError();
+    const selected = matchIdentityKey(
+      expectedIdentity,
+      ourPubKeyBytes,
+      ourPubKeyHashBytes,
+    );
+    if (!selected) throw new UnknownIdentityError();
+    if (selected.error) throw selected.error;
+    return resolvedIdentity(selected);
+  }
 
-  const matched = publicKeys.find((entry) => {
-    if (!entry.data || !ourPubKeyBytes) return false;
-    const entryBytes = tryDecodeKeyData(entry.data);
-    return entryBytes ? bytesEqual(entryBytes, ourPubKeyBytes) : false;
-  });
-  if (!matched) {
-    // Hash matched but we couldn't reconcile against any entry in the JSON
-    // (likely a data-encoding skew). Treat as unexpected and fail closed
-    // rather than silently picking the first key.
-    throw new UnknownIdentityError();
+  const identity = (await sdk.identities.byPublicKeyHash(
+    pubKeyHash as never,
+  )) as IdentityLike | undefined | null;
+
+  if (identity) {
+    const match = matchIdentityKey(
+      identity,
+      ourPubKeyBytes,
+      ourPubKeyHashBytes,
+    );
+    if (!match) throw new UnknownIdentityError();
+    if (match.error) throw match.error;
+    return resolvedIdentity(match);
   }
 
-  if (matched.disabled === true || matched.disabledAt) {
-    throw new KeyDisabledError(identityId);
+  const matches = await findNonUniqueMatches(
+    sdk,
+    pubKeyHash,
+    ourPubKeyBytes,
+    ourPubKeyHashBytes,
+  );
+  if (matches.length > 1) throw new AmbiguousIdentityError();
+  if (matches.length === 1) {
+    if (matches[0].error) throw matches[0].error;
+    return resolvedIdentity(matches[0]);
   }
+  throw new UnknownIdentityError();
+}
+
+async function findNonUniqueMatches(
+  sdk: DashSdk,
+  pubKeyHash: unknown,
+  ourPubKeyBytes: Uint8Array | null,
+  ourPubKeyHashBytes: Uint8Array | null,
+): Promise<MatchedIdentity[]> {
+  const lookup = sdk.identities.byNonUniquePublicKeyHash;
+  if (!lookup) return [];
+
+  const matches: MatchedIdentity[] = [];
+  let startAfter: string | undefined;
+  const seenCursors = new Set<string>();
+
+  while (true) {
+    const candidates = await lookup.call(
+      sdk.identities,
+      pubKeyHash as never,
+      startAfter,
+    );
+    if (candidates.length === 0) break;
 
-  const purposeValue = matched.purpose;
-  const securityLevelValue = matched.securityLevel;
-  const isAuthPurpose =
-    purposeValue === (Purpose.AUTHENTICATION as unknown as number);
-  const isAuthLevel = AUTH_SECURITY_LEVELS.has(securityLevelValue);
-  if (!isAuthPurpose || !isAuthLevel) {
-    throw new WrongKeyPurposeError(
-      identityId,
-      purposeName(purposeValue),
-      securityLevelName(securityLevelValue),
+    const cursor = identityIdOf(
+      candidates[candidates.length - 1] as IdentityLike,
     );
+    if (seenCursors.has(cursor)) {
+      throw new Error("Non-unique identity lookup pagination did not advance.");
+    }
+    seenCursors.add(cursor);
+
+    for (const candidate of candidates) {
+      const match = matchIdentityKey(
+        candidate as IdentityLike,
+        ourPubKeyBytes,
+        ourPubKeyHashBytes,
+      );
+      if (match) matches.push(match);
+      // We only need to establish ambiguity, not enumerate identities.
+      if (matches.length > 1) return matches;
+    }
+
+    startAfter = cursor;
   }
 
-  const identityKey = identity.getPublicKeyById?.(matched.id);
-  return { identity, identityId, matched, identityKey };
+  return matches;
+}
+
+function resolvedIdentity(match: MatchedIdentity): ResolvedWifIdentity {
+  return {
+    identity: match.identity,
+    identityId: match.identityId,
+    matched: match.matched,
+    identityKey: match.identity.getPublicKeyById?.(match.matched.id),
+  };
 }
 
 /**
@@ -249,8 +316,9 @@ export async function resolveIdentityFromWif(
 export async function loginWithPrivateKey(
   sdk: DashSdk,
   wif: string,
+  expectedIdentityId?: string,
 ): Promise<DashAuth & { identityId: string }> {
-  const resolved = await resolveIdentityFromWif(sdk, wif);
+  const resolved = await resolveIdentityFromWif(sdk, wif, expectedIdentityId);
   const signer = new IdentitySigner();
   signer.addKeyFromWif(wif);
 
@@ -262,6 +330,73 @@ export async function loginWithPrivateKey(
   };
 }
 
+function matchIdentityKey(
+  identity: IdentityLike,
+  ourPubKeyBytes: Uint8Array | null,
+  ourPubKeyHashBytes: Uint8Array | null,
+): MatchedIdentity | null {
+  const identityId =
+    typeof identity.id === "string" ? identity.id : identity.id.toString();
+  const publicKeys = identity.toJSON?.().publicKeys ?? [];
+  const matched = publicKeys.find((entry) => {
+    if (!entry.data) return false;
+    const entryBytes = tryDecodeKeyData(entry.data);
+    if (!entryBytes) return false;
+    // SDK JSON uses type 0 for a full secp256k1 key and type 2 for its
+    // HASH160 representation. Do not treat other 20-byte key types (such as
+    // BIP13 script hashes or EDDSA HASH160) as signable by this WIF. Older
+    // SDK/test shapes may omit `type`, where byte length remains unambiguous.
+    const isFullEcdsa = entry.type === undefined || entry.type === 0;
+    const isEcdsaHash160 = entry.type === undefined || entry.type === 2;
+    return (
+      (isFullEcdsa && ourPubKeyBytes
+        ? bytesEqual(entryBytes, ourPubKeyBytes)
+        : false) ||
+      (isEcdsaHash160 && ourPubKeyHashBytes
+        ? bytesEqual(entryBytes, ourPubKeyHashBytes)
+        : false)
+    );
+  });
+  if (!matched) return null;
+
+  let error: Error | null = null;
+  if (matched.disabled === true || matched.disabledAt) {
+    error = new KeyDisabledError(identityId);
+  } else {
+    const isAuthPurpose =
+      matched.purpose === (Purpose.AUTHENTICATION as unknown as number);
+    const isAuthLevel = AUTH_SECURITY_LEVELS.has(matched.securityLevel);
+    if (!isAuthPurpose || !isAuthLevel) {
+      error = new WrongKeyPurposeError(
+        identityId,
+        purposeName(matched.purpose),
+        securityLevelName(matched.securityLevel),
+      );
+    }
+  }
+  return { identity, identityId, matched, error };
+}
+
+function identityIdOf(identity: IdentityLike): string {
+  return typeof identity.id === "string" ? identity.id : identity.id.toString();
+}
+
+function normalizePublicKeyHash(hash: unknown): Uint8Array | null {
+  if (hash instanceof Uint8Array) return hash;
+  if (Array.isArray(hash)) return new Uint8Array(hash);
+  if (typeof hash === "string") return tryDecodeHex(hash);
+  return null;
+}
+
+function tryDecodeHex(hex: string): Uint8Array | null {
+  if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length % 2 !== 0) return null;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
 /**
  * Pull the raw compressed public key bytes from a `PrivateKey.toPublicKey()`
  * result. The SDK exposes a few encoders depending on version (toBytes(),
@@ -292,11 +427,7 @@ function extractPubKeyBytes(pubKey: unknown): Uint8Array | null {
     try {
       const hex = candidate.toString("hex");
       if (typeof hex === "string" && /^[0-9a-fA-F]+$/.test(hex)) {
-        const bytes = new Uint8Array(hex.length / 2);
-        for (let i = 0; i < bytes.length; i += 1) {
-          bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-        }
-        return bytes;
+        return tryDecodeHex(hex);
       }
     } catch {
       // fall through
diff --git a/example-apps/dashnote/src/dash/types.ts b/example-apps/dashnote/src/dash/types.ts
index bca572d5..42df3e1e 100644
--- a/example-apps/dashnote/src/dash/types.ts
+++ b/example-apps/dashnote/src/dash/types.ts
@@ -72,10 +72,15 @@ export interface DashSdk {
     }): Promise<unknown>;
   };
   identities: {
+    fetch(identityId: string): Promise<Identity | null | undefined>;
     nonce(identityId: string): Promise<bigint | null | undefined>;
     byPublicKeyHash(
       publicKeyHash: Uint8Array,
     ): Promise<Identity | null | undefined>;
+    byNonUniquePublicKeyHash?(
+      publicKeyHash: Uint8Array,
+      startAfter?: string,
+    ): Promise<Identity[]>;
   };
   dpns: {
     username(identityId: string): Promise<string | null | undefined>;
diff --git a/example-apps/dashnote/src/hooks/useWifPreview.ts b/example-apps/dashnote/src/hooks/useWifPreview.ts
index f70b4b7e..3a7d867d 100644
--- a/example-apps/dashnote/src/hooks/useWifPreview.ts
+++ b/example-apps/dashnote/src/hooks/useWifPreview.ts
@@ -25,6 +25,8 @@ function loadLoginModule(): Promise<LoginModule> {
 export type WifPreviewState =
   | { status: "idle" }
   | { status: "checking" }
+  | { status: "ambiguous" }
+  | { status: "identity-mismatch" }
   | { status: "resolved"; identityId: string; dpnsName: string | null }
   | {
       status: "wrong-purpose";
@@ -60,6 +62,7 @@ export function useWifPreview(
   sdk: DashSdk | null,
   secret: string,
   enabled: boolean,
+  expectedIdentityId?: string,
 ): WifPreviewState {
   const trimmed = secret.trim();
   const gateOk = enabled && Boolean(sdk) && looksLikeWif(trimmed);
@@ -84,7 +87,9 @@ export function useWifPreview(
       try {
         mod = await loadLoginModule();
         if (cancelled) return;
-        const result = await mod.resolveIdentityFromWif(sdk!, trimmed);
+        const result = expectedIdentityId
+          ? await mod.resolveIdentityFromWif(sdk!, trimmed, expectedIdentityId)
+          : await mod.resolveIdentityFromWif(sdk!, trimmed);
         let dpns: string | null = null;
         try {
           dpns = await resolveDpnsName(sdk!, result.identityId);
@@ -100,7 +105,15 @@ export function useWifPreview(
         // mod is null only if loadLoginModule itself rejected (chunk fetch
         // failure / offline). Treat that as an idle outcome — same silent
         // policy we apply to UnknownIdentity and network blips.
-        if (
+        if (err instanceof Error && err.name === "AmbiguousIdentityError") {
+          next = { status: "ambiguous" };
+        } else if (
+          expectedIdentityId &&
+          mod &&
+          err instanceof mod.UnknownIdentityError
+        ) {
+          next = { status: "identity-mismatch" };
+        } else if (
           mod &&
           (err instanceof mod.WrongKeyPurposeError ||
             err instanceof mod.KeyDisabledError)
@@ -129,8 +142,9 @@ export function useWifPreview(
             };
           }
         } else {
-          // UnknownIdentityError, network failure, import failure, or any
-          // other unexpected error — stay silent until the user submits.
+          // UnknownIdentityError without an explicit identity, network
+          // failure, import failure, or any other unexpected error — stay
+          // silent until the user submits.
           next = IDLE;
         }
       }
@@ -142,7 +156,7 @@ export function useWifPreview(
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, [sdk, trimmed, gateOk]);
+  }, [sdk, trimmed, gateOk, expectedIdentityId]);
 
   if (!gateOk) return IDLE;
   if (resolved && resolved.wif === trimmed) return resolved.state;
diff --git a/example-apps/dashnote/src/session/SessionContext.tsx b/example-apps/dashnote/src/session/SessionContext.tsx
index 4b40e79f..906db997 100644
--- a/example-apps/dashnote/src/session/SessionContext.tsx
+++ b/example-apps/dashnote/src/session/SessionContext.tsx
@@ -63,6 +63,7 @@ export type SessionStatus =
 export interface LoginOptions {
   identityIndex?: number;
   rememberMe?: boolean;
+  expectedIdentityId?: string;
 }
 
 export interface SessionValue {
@@ -179,7 +180,11 @@ export function SessionProvider({ children }: { children: ReactNode }) {
 
   const login = useCallback(
     async (secret: string, options: LoginOptions = {}) => {
-      const { identityIndex = 0, rememberMe = false } = options;
+      const {
+        identityIndex = 0,
+        rememberMe = false,
+        expectedIdentityId,
+      } = options;
       const trimmed = secret.trim();
       if (!trimmed) throw new Error("Secret is required.");
       // Snapshot session state so a failed login can restore the user's
@@ -215,7 +220,11 @@ export function SessionProvider({ children }: { children: ReactNode }) {
           // we fetch this module on first use here.
           const { loginWithPrivateKey } =
             await import("../dash/loginWithPrivateKey");
-          const auth = await loginWithPrivateKey(connected, trimmed);
+          const auth = await loginWithPrivateKey(
+            connected,
+            trimmed,
+            expectedIdentityId,
+          );
           resolvedKeyManager = keyManagerFromKey(auth.identityId, auth);
         }
 
diff --git a/example-apps/dashnote/test/LoginModal.test.tsx b/example-apps/dashnote/test/LoginModal.test.tsx
index 62417c4c..433c3737 100644
--- a/example-apps/dashnote/test/LoginModal.test.tsx
+++ b/example-apps/dashnote/test/LoginModal.test.tsx
@@ -635,6 +635,85 @@ describe("LoginModal", () => {
       );
     });
 
+    it("requires a full identity ID for an ambiguous WIF without listing candidates", () => {
+      renderWithSecret({ status: "ambiguous" });
+
+      expect(
+        screen.getByText(/associated with multiple identities/i),
+      ).toBeTruthy();
+      expect(
+        screen.getByPlaceholderText(/full dash platform identity id/i),
+      ).toBeTruthy();
+      expect(screen.queryByRole("option")).toBeNull();
+      expect(
+        (
+          screen.getByRole("button", {
+            name: /^sign in$/i,
+          }) as HTMLButtonElement
+        ).disabled,
+      ).toBe(true);
+    });
+
+    it("reveals the identity-ID field when submit reports ambiguity", async () => {
+      const error = new Error("ambiguous");
+      error.name = "AmbiguousIdentityError";
+      const login = vi.fn().mockRejectedValue(error);
+      mockUseSession.mockReturnValue(makeSession({ login }));
+      mockUseWifPreview.mockReturnValue({ status: "idle" });
+      render(<LoginModal open onClose={vi.fn()} />);
+      fireEvent.change(screen.getByPlaceholderText(/mnemonic phrase/i), {
+        target: { value: SAMPLE_WIF },
+      });
+
+      fireEvent.click(screen.getByRole("button", { name: /^sign in$/i }));
+
+      expect(
+        await screen.findByPlaceholderText(/full dash platform identity id/i),
+      ).toBeTruthy();
+      expect(screen.getByPlaceholderText(/mnemonic phrase/i)).toHaveProperty(
+        "value",
+        SAMPLE_WIF,
+      );
+    });
+
+    it("submits an ambiguous WIF with the manually entered identity ID", async () => {
+      const login = vi.fn().mockResolvedValue(undefined);
+      mockUseSession.mockReturnValue(makeSession({ login }));
+      mockUseWifPreview.mockImplementation(
+        (
+          _sdk: unknown,
+          _secret: string,
+          _enabled: boolean,
+          expectedIdentityId?: string,
+        ) =>
+          expectedIdentityId
+            ? {
+                status: "resolved",
+                identityId: expectedIdentityId,
+                dpnsName: null,
+              }
+            : { status: "ambiguous" },
+      );
+      render(<LoginModal open onClose={vi.fn()} />);
+      fireEvent.change(screen.getByPlaceholderText(/mnemonic phrase/i), {
+        target: { value: SAMPLE_WIF },
+      });
+      fireEvent.change(
+        screen.getByPlaceholderText(/full dash platform identity id/i),
+        { target: { value: "identity-intended" } },
+      );
+
+      fireEvent.click(screen.getByRole("button", { name: /^sign in$/i }));
+
+      await waitFor(() => {
+        expect(login).toHaveBeenCalledWith(SAMPLE_WIF, {
+          identityIndex: 0,
+          rememberMe: true,
+          expectedIdentityId: "identity-intended",
+        });
+      });
+    });
+
     it("prefers DPNS name over truncated ID on the resolved state", () => {
       renderWithSecret({
         status: "resolved",
diff --git a/example-apps/dashnote/test/SessionContext.test.tsx b/example-apps/dashnote/test/SessionContext.test.tsx
index 3f3db49b..faa503e7 100644
--- a/example-apps/dashnote/test/SessionContext.test.tsx
+++ b/example-apps/dashnote/test/SessionContext.test.tsx
@@ -516,6 +516,28 @@ describe("SessionProvider", () => {
     expect(ref.current.keyManager?.identityId).toBe("wif-identity-id");
   });
 
+  it("passes the expected identity ID to WIF login", async () => {
+    mockLoginWithPrivateKey.mockResolvedValue({
+      identityId: "expected-id",
+      identity: { id: "expected-id" },
+      identityKey: { mock: "key" },
+      signer: { mock: "signer" },
+    });
+    const ref = mountSession();
+
+    await act(async () => {
+      await ref.current.login("cVHcfvcWNc7DvqaPCwM6Z3", {
+        expectedIdentityId: "expected-id",
+      });
+    });
+
+    expect(mockLoginWithPrivateKey).toHaveBeenCalledWith(
+      expect.anything(),
+      "cVHcfvcWNc7DvqaPCwM6Z3",
+      "expected-id",
+    );
+  });
+
   it("failed WIF login from idle returns to idle without clobbering identity state", async () => {
     mockLoginWithPrivateKey.mockRejectedValue(
       new Error("Found identity X, but this is a transfer key."),
diff --git a/example-apps/dashnote/test/loginWithPrivateKey.test.ts b/example-apps/dashnote/test/loginWithPrivateKey.test.ts
index a4d2e236..c56612db 100644
--- a/example-apps/dashnote/test/loginWithPrivateKey.test.ts
+++ b/example-apps/dashnote/test/loginWithPrivateKey.test.ts
@@ -1,18 +1,14 @@
-// @vitest-environment jsdom
-
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-const { mockFromWIF, mockGetPublicKeyHash, mockSignerAddKeyFromWif } =
-  vi.hoisted(() => ({
-    mockFromWIF: vi.fn(),
-    mockGetPublicKeyHash: vi.fn(),
-    mockSignerAddKeyFromWif: vi.fn(),
-  }));
+const fromWIF = vi.hoisted(() => vi.fn());
+const addKeyFromWif = vi.hoisted(() => vi.fn());
 
 vi.mock("@dashevo/evo-sdk", () => ({
-  PrivateKey: { fromWIF: mockFromWIF },
-  IdentitySigner: function MockSigner() {
-    return { addKeyFromWif: mockSignerAddKeyFromWif };
+  IdentitySigner: class {
+    addKeyFromWif = addKeyFromWif;
+  },
+  PrivateKey: {
+    fromWIF,
   },
   Purpose: {
     AUTHENTICATION: 0,
@@ -28,17 +24,27 @@ vi.mock("@dashevo/evo-sdk", () => ({
 }));
 
 import {
-  KeyDisabledError,
+  AmbiguousIdentityError,
   InvalidPrivateKeyError,
-  loginWithPrivateKey,
-  resolveIdentityFromWif,
+  KeyDisabledError,
   UnknownIdentityError,
   WrongKeyPurposeError,
+  loginWithPrivateKey,
+  resolveIdentityFromWif,
 } from "../src/dash/loginWithPrivateKey";
 import type { DashSdk } from "../src/dash/types";
 
+const AUTHENTICATION = 0;
+const ENCRYPTION = 1;
+const TRANSFER = 2;
+const MASTER = 0;
+const CRITICAL = 1;
+const HIGH = 2;
+const MEDIUM = 3;
+
 const ourPubKeyHex =
   "02aabbccddeeff00112233445566778899aabbccddeeff00112233445566778899";
+const ourPubKeyHashHex = "11223344556677889900aabbccddeeff00112233";
 const ourPubKeyBytes = (() => {
   const bytes = new Uint8Array(ourPubKeyHex.length / 2);
   for (let i = 0; i < bytes.length; i += 1) {
@@ -46,111 +52,314 @@ const ourPubKeyBytes = (() => {
   }
   return bytes;
 })();
+const ourPubKeyHashBytes = (() => {
+  const bytes = new Uint8Array(ourPubKeyHashHex.length / 2);
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = parseInt(ourPubKeyHashHex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+})();
 const ourPubKeyBase64 = (() => {
   let binary = "";
-  ourPubKeyBytes.forEach((b) => {
-    binary += String.fromCharCode(b);
+  ourPubKeyBytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+})();
+const ourPubKeyHashBase64 = (() => {
+  let binary = "";
+  ourPubKeyHashBytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
   });
   return btoa(binary);
 })();
 
-function setupValidWifMocks() {
-  mockGetPublicKeyHash.mockReturnValue(new Uint8Array(20));
-  mockFromWIF.mockReturnValue({
-    getPublicKeyHash: mockGetPublicKeyHash,
+function privateKey(hash: string | Uint8Array = "hash") {
+  return {
+    getPublicKeyHash: () => hash,
     getPublicKey: () => ({
       toBytes: () => ourPubKeyBytes,
     }),
-  });
+  };
+}
+
+function identity({
+  id = "identity-1",
+  purpose = AUTHENTICATION,
+  securityLevel = CRITICAL,
+  type = undefined as number | undefined,
+  disabled = false,
+  disabledAt = null as number | string | null,
+  data = ourPubKeyBase64,
+} = {}) {
+  const identityKey = { id: 2 };
+  return {
+    id: { toString: () => id },
+    getPublicKeyById: vi.fn().mockReturnValue(identityKey),
+    toJSON: () => ({
+      publicKeys: [
+        {
+          id: 2,
+          purpose,
+          securityLevel,
+          type,
+          data,
+          disabled,
+          disabledAt,
+        },
+      ],
+    }),
+  };
 }
 
-function makeSdk(byPublicKeyHash: ReturnType<typeof vi.fn>): DashSdk {
+function sdkWithIdentity(value: unknown): DashSdk {
   return {
     identities: {
-      byPublicKeyHash,
-      nonce: vi.fn(),
+      fetch: vi.fn().mockResolvedValue(undefined),
+      byPublicKeyHash: vi.fn().mockResolvedValue(value),
+      byNonUniquePublicKeyHash: vi.fn().mockResolvedValue([]),
     },
   } as unknown as DashSdk;
 }
 
-afterEach(() => {
-  mockFromWIF.mockReset();
-  mockGetPublicKeyHash.mockReset();
-  mockSignerAddKeyFromWif.mockReset();
-});
+function sdkWithLookups(unique: unknown, nonUnique: unknown[]): DashSdk {
+  return {
+    identities: {
+      fetch: vi.fn().mockImplementation(async (identityId: string) =>
+        nonUnique.find((candidate) => {
+          const id = (candidate as { id?: string | { toString(): string } }).id;
+          return typeof id === "string"
+            ? id === identityId
+            : id?.toString() === identityId;
+        }),
+      ),
+      byPublicKeyHash: vi.fn().mockResolvedValue(unique),
+      byNonUniquePublicKeyHash: vi
+        .fn()
+        .mockImplementation(async (_hash, startAfter) =>
+          startAfter ? [] : nonUnique,
+        ),
+    },
+  } as unknown as DashSdk;
+}
 
 describe("loginWithPrivateKey", () => {
-  it("throws InvalidPrivateKeyError when the WIF can't be parsed", async () => {
-    mockFromWIF.mockImplementation(() => {
-      throw new Error("bad checksum");
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("rejects invalid WIF input", async () => {
+    fromWIF.mockImplementation(() => {
+      throw new Error("invalid");
+    });
+
+    await expect(
+      resolveIdentityFromWif(sdkWithIdentity(null), "not-a-wif"),
+    ).rejects.toBeInstanceOf(InvalidPrivateKeyError);
+  });
+
+  it("rejects invalid WIF input through the signer-building login path", async () => {
+    fromWIF.mockImplementation(() => {
+      throw new Error("invalid");
     });
-    const sdk = makeSdk(vi.fn());
 
-    await expect(loginWithPrivateKey(sdk, "not-a-key")).rejects.toBeInstanceOf(
-      InvalidPrivateKeyError,
+    await expect(
+      loginWithPrivateKey(sdkWithIdentity(null), "not-a-wif"),
+    ).rejects.toBeInstanceOf(InvalidPrivateKeyError);
+    expect(addKeyFromWif).not.toHaveBeenCalled();
+  });
+
+  it("rejects keys with no registered identity", async () => {
+    fromWIF.mockReturnValue(privateKey());
+
+    await expect(
+      resolveIdentityFromWif(sdkWithIdentity(null), "wif"),
+    ).rejects.toBeInstanceOf(UnknownIdentityError);
+  });
+
+  it("falls back to non-unique public-key-hash lookup", async () => {
+    const resolvedIdentity = identity({
+      id: "identity-non-unique",
+      data: ourPubKeyHashBase64,
+    });
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    const result = await loginWithPrivateKey(
+      sdkWithLookups(null, [resolvedIdentity]),
+      "wif",
+    );
+
+    expect(result.identity).toBe(resolvedIdentity);
+    expect(result.identityId).toBe("identity-non-unique");
+    expect(result.identityKey).toEqual({ id: 2 });
+    expect(addKeyFromWif).toHaveBeenCalledWith("wif");
+  });
+
+  it("matches base64-encoded public-key hash data", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    const result = await loginWithPrivateKey(
+      sdkWithIdentity(identity({ data: ourPubKeyHashBase64 })),
+      "wif",
+    );
+
+    expect(result.identityId).toBe("identity-1");
+  });
+
+  it("matches hex-encoded public-key hash data", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashBytes));
+
+    const result = await loginWithPrivateKey(
+      sdkWithIdentity(identity({ data: ourPubKeyHashHex })),
+      "wif",
     );
+
+    expect(result.identityId).toBe("identity-1");
   });
 
-  it("throws UnknownIdentityError when no identity matches the key", async () => {
-    setupValidWifMocks();
-    const byPublicKeyHash = vi.fn().mockResolvedValue(undefined);
-    const sdk = makeSdk(byPublicKeyHash);
+  it.each([3, 4])(
+    "rejects HASH160 bytes belonging to key type %s",
+    async (type) => {
+      fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+      await expect(
+        resolveIdentityFromWif(
+          sdkWithLookups(null, [identity({ data: ourPubKeyHashBase64, type })]),
+          "wif",
+        ),
+      ).rejects.toBeInstanceOf(UnknownIdentityError);
+    },
+  );
+
+  it("fetches and verifies an explicitly selected identity directly", async () => {
+    const identityA = identity({
+      id: "identity-a",
+      data: ourPubKeyHashBase64,
+      type: 2,
+    });
+    const identityB = identity({
+      id: "identity-b",
+      data: ourPubKeyHashBase64,
+      type: 2,
+    });
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+    const sdk = sdkWithLookups(null, [identityB, identityA]);
+
+    const result = await resolveIdentityFromWif(sdk, "wif", "identity-a");
+
+    expect(result.identityId).toBe("identity-a");
+    expect(sdk.identities.fetch).toHaveBeenCalledWith("identity-a");
+    expect(sdk.identities.byNonUniquePublicKeyHash).not.toHaveBeenCalled();
+  });
+
+  it("rejects an explicitly selected identity that does not match the WIF", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
 
     await expect(
-      loginWithPrivateKey(sdk, "valid-wif-stub"),
+      resolveIdentityFromWif(
+        sdkWithLookups(null, [
+          identity({ id: "identity-a", data: ourPubKeyHashBase64 }),
+        ]),
+        "wif",
+        "identity-other",
+      ),
     ).rejects.toBeInstanceOf(UnknownIdentityError);
   });
 
-  it("throws WrongKeyPurposeError carrying the identity ID for transfer keys", async () => {
-    setupValidWifMocks();
-    const identityId = "identity-1";
-    const identity = {
-      id: identityId,
-      toJSON: () => ({
-        publicKeys: [
-          {
-            id: 3,
-            purpose: 2, // TRANSFER
-            securityLevel: 1, // CRITICAL
-            data: ourPubKeyBase64,
-          },
-        ],
-      }),
-      getPublicKeyById: vi.fn(),
-    };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it("continues pagination until a second match establishes ambiguity", async () => {
+    const identityA = identity({ id: "identity-a" });
+    const identityB = identity({ id: "identity-b" });
+    fromWIF.mockReturnValue(privateKey());
+    const byNonUniquePublicKeyHash = vi
+      .fn()
+      .mockImplementation(async (_hash, startAfter) => {
+        if (!startAfter) return [identityA];
+        if (startAfter === "identity-a") return [identityB];
+        return [];
+      });
+    const sdk = {
+      identities: {
+        fetch: vi.fn(),
+        byPublicKeyHash: vi.fn().mockResolvedValue(undefined),
+        byNonUniquePublicKeyHash,
+      },
+    } as unknown as DashSdk;
+
+    await expect(resolveIdentityFromWif(sdk, "wif")).rejects.toBeInstanceOf(
+      AmbiguousIdentityError,
+    );
+    expect(byNonUniquePublicKeyHash).toHaveBeenNthCalledWith(
+      2,
+      expect.anything(),
+      "identity-a",
+    );
+  });
+
+  it("rejects ambiguous non-unique identity matches", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    await expect(
+      loginWithPrivateKey(
+        sdkWithLookups(null, [
+          identity({ id: "identity-a", data: ourPubKeyHashBase64 }),
+          identity({ id: "identity-b", data: ourPubKeyHashBase64 }),
+        ]),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(AmbiguousIdentityError);
+    expect(addKeyFromWif).not.toHaveBeenCalled();
+  });
+
+  it("rejects multiple matches when only one has a valid authentication key", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    await expect(
+      resolveIdentityFromWif(
+        sdkWithLookups(null, [
+          identity({ id: "identity-valid", data: ourPubKeyHashBase64 }),
+          identity({
+            id: "identity-wrong-purpose",
+            purpose: TRANSFER,
+            data: ourPubKeyHashBase64,
+          }),
+        ]),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(AmbiguousIdentityError);
+  });
+
+  it("rejects empty non-unique lookup results", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    await expect(
+      resolveIdentityFromWif(sdkWithLookups(null, []), "wif"),
+    ).rejects.toBeInstanceOf(UnknownIdentityError);
+  });
+
+  it("rejects non-authentication keys", async () => {
+    fromWIF.mockReturnValue(privateKey());
+
+    const promise = resolveIdentityFromWif(
+      sdkWithIdentity(identity({ purpose: TRANSFER })),
+      "wif",
+    );
 
-    const promise = loginWithPrivateKey(sdk, "valid-wif-stub");
     await expect(promise).rejects.toBeInstanceOf(WrongKeyPurposeError);
     await promise.catch((err: WrongKeyPurposeError) => {
-      expect(err.identityId).toBe(identityId);
+      expect(err.identityId).toBe("identity-1");
       expect(err.purposeName).toBe("TRANSFER");
       expect(err.securityLevelName).toBe("CRITICAL");
     });
   });
 
-  it("labels MASTER auth keys with securityLevelName=MASTER on the error", async () => {
-    // Eager preview UI uses securityLevelName to differentiate "AUTHENTICATION
-    // + MASTER" (MASTER auth key) from "TRANSFER" / "ENCRYPTION" purposes —
-    // both throw WrongKeyPurposeError but read very differently to the user.
-    setupValidWifMocks();
-    const identity = {
-      id: "identity-master",
-      toJSON: () => ({
-        publicKeys: [
-          {
-            id: 0,
-            purpose: 0, // AUTHENTICATION
-            securityLevel: 0, // MASTER
-            data: ourPubKeyBase64,
-          },
-        ],
-      }),
-      getPublicKeyById: vi.fn(),
-    };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it("labels MASTER auth keys on wrong-purpose errors", async () => {
+    fromWIF.mockReturnValue(privateKey());
+
+    const promise = resolveIdentityFromWif(
+      sdkWithIdentity(identity({ securityLevel: MASTER })),
+      "wif",
+    );
 
-    const promise = loginWithPrivateKey(sdk, "valid-wif-stub");
     await expect(promise).rejects.toBeInstanceOf(WrongKeyPurposeError);
     await promise.catch((err: WrongKeyPurposeError) => {
       expect(err.purposeName).toBe("AUTHENTICATION");
@@ -158,290 +367,162 @@ describe("loginWithPrivateKey", () => {
     });
   });
 
-  it("throws KeyDisabledError when the matching key has a disabledAt timestamp", async () => {
-    setupValidWifMocks();
-    const identityId = "identity-2";
-    const identity = {
-      id: identityId,
-      toJSON: () => ({
-        publicKeys: [
-          {
-            id: 1,
-            purpose: 0, // AUTHENTICATION
-            securityLevel: 2, // HIGH
-            data: ourPubKeyBase64,
-            disabledAt: 1700000000,
-          },
-        ],
-      }),
+  it("rejects keys whose public key data cannot be matched", async () => {
+    fromWIF.mockReturnValue(privateKey());
+    const otherIdentity = {
+      id: "identity-encoding-skew",
       getPublicKeyById: vi.fn(),
-    };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
-
-    const promise = loginWithPrivateKey(sdk, "valid-wif-stub");
-    await expect(promise).rejects.toBeInstanceOf(KeyDisabledError);
-    await promise.catch((err: KeyDisabledError) => {
-      expect(err.identityId).toBe(identityId);
-    });
-  });
-
-  it("throws KeyDisabledError when the matching key has disabled: true", async () => {
-    // Some SDK versions surface the disabled state as a boolean rather than
-    // a timestamp. The check must catch both shapes.
-    setupValidWifMocks();
-    const identityId = "identity-disabled-bool";
-    const identity = {
-      id: identityId,
       toJSON: () => ({
         publicKeys: [
           {
-            id: 1,
-            purpose: 0,
-            securityLevel: 2,
-            data: ourPubKeyBase64,
-            disabled: true,
+            id: 2,
+            purpose: AUTHENTICATION,
+            securityLevel: HIGH,
+            data: btoa("\xff".repeat(33)),
           },
         ],
       }),
-      getPublicKeyById: vi.fn(),
     };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
 
-    const promise = loginWithPrivateKey(sdk, "valid-wif-stub");
-    await expect(promise).rejects.toBeInstanceOf(KeyDisabledError);
-    await promise.catch((err: KeyDisabledError) => {
-      expect(err.identityId).toBe(identityId);
-    });
+    await expect(
+      resolveIdentityFromWif(sdkWithIdentity(otherIdentity), "wif"),
+    ).rejects.toBeInstanceOf(UnknownIdentityError);
   });
 
-  it("throws UnknownIdentityError when the identity has an empty publicKeys array", async () => {
-    // Defensive: byPublicKeyHash matched, so a key must exist on the
-    // identity. An empty publicKeys[] indicates an SDK shape we don't
-    // understand; fail closed rather than guessing.
-    setupValidWifMocks();
-    const identity = {
+  it("rejects identities whose serialized public-key list is empty", async () => {
+    fromWIF.mockReturnValue(privateKey());
+    const identityWithoutKeys = {
       id: "identity-no-keys",
-      toJSON: () => ({ publicKeys: [] }),
       getPublicKeyById: vi.fn(),
+      toJSON: () => ({ publicKeys: [] }),
     };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
 
     await expect(
-      loginWithPrivateKey(sdk, "valid-wif-stub"),
+      resolveIdentityFromWif(sdkWithIdentity(identityWithoutKeys), "wif"),
     ).rejects.toBeInstanceOf(UnknownIdentityError);
   });
 
-  it("throws UnknownIdentityError when no publicKeys[].data matches our pubkey bytes", async () => {
-    // Defensive: byPublicKeyHash returned an identity, but the JSON
-    // encoding of its keys' data field is something we can't reconcile
-    // (different encoding, different pubkey shape). Fail closed instead
-    // of silently picking the first key.
-    setupValidWifMocks();
-    // Use a base64 string that contains characters outside [0-9a-fA-F] so
-    // tryDecodeKeyData skips its hex branch and exercises the base64 path
-    // we actually want to verify here. 33 bytes of 0xff base64-encodes
-    // with '/' and '=' — definitively not hex.
-    const otherKeyBase64 = btoa("\xff".repeat(33));
-    expect(otherKeyBase64).toMatch(/[^0-9a-fA-F]/);
-    const identity = {
-      id: "identity-encoding-skew",
-      toJSON: () => ({
-        publicKeys: [
-          {
-            id: 1,
-            purpose: 0,
-            securityLevel: 2,
-            data: otherKeyBase64,
-          },
-        ],
-      }),
-      getPublicKeyById: vi.fn(),
-    };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it("rejects disabled keys", async () => {
+    fromWIF.mockReturnValue(privateKey());
 
     await expect(
-      loginWithPrivateKey(sdk, "valid-wif-stub"),
-    ).rejects.toBeInstanceOf(UnknownIdentityError);
+      resolveIdentityFromWif(
+        sdkWithIdentity(identity({ disabledAt: 123 })),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(KeyDisabledError);
   });
 
-  it("returns the matched key + signer wired with the original WIF", async () => {
-    setupValidWifMocks();
-    const identityId = "identity-3";
-    const identityKey = { mock: "identity-public-key" };
-    const getPublicKeyById = vi.fn().mockReturnValue(identityKey);
-    const identity = {
-      id: identityId,
-      toJSON: () => ({
-        publicKeys: [
-          {
-            id: 2,
-            purpose: 0, // AUTHENTICATION
-            securityLevel: 1, // CRITICAL
-            data: ourPubKeyBase64,
-          },
-        ],
-      }),
-      getPublicKeyById,
-    };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it("rejects disabled keys surfaced as a boolean", async () => {
+    fromWIF.mockReturnValue(privateKey());
 
-    const result = await loginWithPrivateKey(sdk, "valid-wif-stub");
+    await expect(
+      resolveIdentityFromWif(
+        sdkWithIdentity(identity({ disabled: true })),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(KeyDisabledError);
+  });
+
+  it("returns auth data and signer for a valid auth key", async () => {
+    const resolvedIdentity = identity();
+    fromWIF.mockReturnValue(privateKey());
 
-    expect(result.identityId).toBe(identityId);
-    expect(result.identity).toBe(identity);
-    expect(result.identityKey).toBe(identityKey);
-    expect(getPublicKeyById).toHaveBeenCalledWith(2);
-    expect(mockSignerAddKeyFromWif).toHaveBeenCalledWith("valid-wif-stub");
+    const result = await loginWithPrivateKey(
+      sdkWithIdentity(resolvedIdentity),
+      "wif",
+    );
+
+    expect(result.identity).toBe(resolvedIdentity);
+    expect(result.identityId).toBe("identity-1");
+    expect(result.identityKey).toEqual({ id: 2 });
+    expect(addKeyFromWif).toHaveBeenCalledWith("wif");
   });
 
-  it("matches keys whose JSON data is hex-encoded", async () => {
-    setupValidWifMocks();
-    const identity = {
+  it("matches keys whose public-key data is hex-encoded", async () => {
+    const resolvedIdentity = {
       id: "identity-hex",
+      getPublicKeyById: vi.fn().mockReturnValue({ id: 1 }),
       toJSON: () => ({
         publicKeys: [
           {
             id: 1,
-            purpose: 0,
-            securityLevel: 2, // HIGH
+            purpose: AUTHENTICATION,
+            securityLevel: HIGH,
             data: ourPubKeyHex,
           },
         ],
       }),
-      getPublicKeyById: vi.fn().mockReturnValue({}),
     };
-    const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+    fromWIF.mockReturnValue(privateKey());
+
+    const result = await loginWithPrivateKey(
+      sdkWithIdentity(resolvedIdentity),
+      "wif",
+    );
 
-    const result = await loginWithPrivateKey(sdk, "valid-wif-stub");
     expect(result.identityId).toBe("identity-hex");
+    expect(result.identityKey).toEqual({ id: 1 });
   });
 
-  describe("resolveIdentityFromWif", () => {
-    // The eager preview path uses resolveIdentityFromWif so it can validate
-    // the WIF + key purpose without touching the WASM signer. The contract:
-    // same checks, same errors, no signer side effects.
-    it("returns identity + matched key without invoking the signer", async () => {
-      setupValidWifMocks();
-      const identityKey = { mock: "identity-public-key" };
-      const getPublicKeyById = vi.fn().mockReturnValue(identityKey);
-      const identity = {
-        id: "identity-resolve",
-        toJSON: () => ({
-          publicKeys: [
-            {
-              id: 1,
-              purpose: 0, // AUTHENTICATION
-              securityLevel: 2, // HIGH
-              data: ourPubKeyBase64,
-            },
-          ],
-        }),
-        getPublicKeyById,
-      };
-      const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
-
-      const result = await resolveIdentityFromWif(sdk, "valid-wif-stub");
-
-      expect(result.identityId).toBe("identity-resolve");
-      expect(result.identity).toBe(identity);
-      expect(result.identityKey).toBe(identityKey);
-      expect(result.matched.id).toBe(1);
-      // No signer construction in the preview path.
-      expect(mockSignerAddKeyFromWif).not.toHaveBeenCalled();
-    });
+  it("resolves WIF identity details without constructing a signer", async () => {
+    const resolvedIdentity = identity({ securityLevel: HIGH });
+    fromWIF.mockReturnValue(privateKey());
 
-    it("throws the same WrongKeyPurposeError as loginWithPrivateKey", async () => {
-      setupValidWifMocks();
-      const identity = {
-        id: "identity-resolve-wrong",
-        toJSON: () => ({
-          publicKeys: [
-            {
-              id: 1,
-              purpose: 2, // TRANSFER
-              securityLevel: 1,
-              data: ourPubKeyBase64,
-            },
-          ],
-        }),
-        getPublicKeyById: vi.fn(),
-      };
-      const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+    const result = await resolveIdentityFromWif(
+      sdkWithIdentity(resolvedIdentity),
+      "wif",
+    );
 
-      await expect(
-        resolveIdentityFromWif(sdk, "valid-wif-stub"),
-      ).rejects.toBeInstanceOf(WrongKeyPurposeError);
-      expect(mockSignerAddKeyFromWif).not.toHaveBeenCalled();
-    });
+    expect(result.identity).toBe(resolvedIdentity);
+    expect(result.identityId).toBe("identity-1");
+    expect(result.matched.id).toBe(2);
+    expect(result.identityKey).toEqual({ id: 2 });
+    expect(addKeyFromWif).not.toHaveBeenCalled();
+  });
 
-    it("throws InvalidPrivateKeyError for unparseable WIFs", async () => {
-      mockFromWIF.mockImplementation(() => {
-        throw new Error("bad checksum");
-      });
-      const sdk = makeSdk(vi.fn());
+  it("applies the same purpose validation without constructing a signer", async () => {
+    fromWIF.mockReturnValue(privateKey());
 
-      await expect(
-        resolveIdentityFromWif(sdk, "not-a-key"),
-      ).rejects.toBeInstanceOf(InvalidPrivateKeyError);
-      expect(mockSignerAddKeyFromWif).not.toHaveBeenCalled();
-    });
+    await expect(
+      resolveIdentityFromWif(
+        sdkWithIdentity(identity({ purpose: TRANSFER })),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(WrongKeyPurposeError);
+    expect(addKeyFromWif).not.toHaveBeenCalled();
   });
 
-  describe("security level gate", () => {
-    function makeIdentityWithKey(opts: { purpose: number; level: number }) {
-      return {
-        id: `identity-p${opts.purpose}-l${opts.level}`,
-        toJSON: () => ({
-          publicKeys: [
-            {
-              id: 1,
-              purpose: opts.purpose,
-              securityLevel: opts.level,
-              data: ourPubKeyBase64,
-            },
-          ],
-        }),
-        getPublicKeyById: vi.fn().mockReturnValue({}),
-      };
-    }
-
-    // SecurityLevel: MASTER=0, CRITICAL=1, HIGH=2, MEDIUM=3
-    // Purpose: AUTHENTICATION=0, ENCRYPTION=1, TRANSFER=2
-    // Document/contract operations require AUTHENTICATION + (HIGH | CRITICAL).
-    // Anything else must be rejected up front so we don't reach a
-    // "level ... is not a valid level for these state transitions" failure
-    // mid-flow.
-    it.each([
-      { purpose: 0, level: 0, name: "AUTHENTICATION + MASTER" },
-      { purpose: 0, level: 3, name: "AUTHENTICATION + MEDIUM" },
-      { purpose: 1, level: 0, name: "ENCRYPTION + MASTER" },
-      { purpose: 1, level: 1, name: "ENCRYPTION + CRITICAL" },
-      { purpose: 1, level: 2, name: "ENCRYPTION + HIGH" },
-      { purpose: 1, level: 3, name: "ENCRYPTION + MEDIUM" },
-      { purpose: 2, level: 0, name: "TRANSFER + MASTER" },
-      { purpose: 2, level: 1, name: "TRANSFER + CRITICAL" },
-      { purpose: 2, level: 2, name: "TRANSFER + HIGH" },
-      { purpose: 2, level: 3, name: "TRANSFER + MEDIUM" },
-    ])("rejects $name", async ({ purpose, level }) => {
-      setupValidWifMocks();
-      const identity = makeIdentityWithKey({ purpose, level });
-      const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it.each([
+    { purpose: AUTHENTICATION, securityLevel: MASTER },
+    { purpose: AUTHENTICATION, securityLevel: MEDIUM },
+    { purpose: ENCRYPTION, securityLevel: MASTER },
+    { purpose: ENCRYPTION, securityLevel: CRITICAL },
+    { purpose: ENCRYPTION, securityLevel: HIGH },
+    { purpose: ENCRYPTION, securityLevel: MEDIUM },
+    { purpose: TRANSFER, securityLevel: MASTER },
+    { purpose: TRANSFER, securityLevel: CRITICAL },
+    { purpose: TRANSFER, securityLevel: HIGH },
+    { purpose: TRANSFER, securityLevel: MEDIUM },
+  ])("rejects unsupported key purpose/level %#", async (key) => {
+    fromWIF.mockReturnValue(privateKey());
 
-      await expect(
-        loginWithPrivateKey(sdk, "valid-wif-stub"),
-      ).rejects.toBeInstanceOf(WrongKeyPurposeError);
-    });
+    await expect(
+      loginWithPrivateKey(sdkWithIdentity(identity(key)), "wif"),
+    ).rejects.toBeInstanceOf(WrongKeyPurposeError);
+  });
 
-    it.each([
-      { level: 1, name: "CRITICAL" },
-      { level: 2, name: "HIGH" },
-    ])("accepts AUTHENTICATION + $name", async ({ level }) => {
-      setupValidWifMocks();
-      const identity = makeIdentityWithKey({ purpose: 0, level });
-      const sdk = makeSdk(vi.fn().mockResolvedValue(identity));
+  it.each([CRITICAL, HIGH])(
+    "accepts authentication key security level %i",
+    async (securityLevel) => {
+      fromWIF.mockReturnValue(privateKey());
 
-      const result = await loginWithPrivateKey(sdk, "valid-wif-stub");
-      expect(result.identityId).toBe(`identity-p0-l${level}`);
-    });
-  });
+      const result = await loginWithPrivateKey(
+        sdkWithIdentity(identity({ securityLevel })),
+        "wif",
+      );
+
+      expect(result.identityId).toBe("identity-1");
+    },
+  );
 });
diff --git a/example-apps/dashnote/test/useWifPreview.test.tsx b/example-apps/dashnote/test/useWifPreview.test.tsx
index 5e185de6..1f43386c 100644
--- a/example-apps/dashnote/test/useWifPreview.test.tsx
+++ b/example-apps/dashnote/test/useWifPreview.test.tsx
@@ -10,6 +10,7 @@ const {
   KeyDisabledError,
   UnknownIdentityError,
   InvalidPrivateKeyError,
+  AmbiguousIdentityError,
 } = vi.hoisted(() => {
   class WrongKeyPurposeError extends Error {
     identityId: string;
@@ -35,6 +36,12 @@ const {
   }
   class UnknownIdentityError extends Error {}
   class InvalidPrivateKeyError extends Error {}
+  class AmbiguousIdentityError extends Error {
+    constructor() {
+      super("ambiguous");
+      this.name = "AmbiguousIdentityError";
+    }
+  }
   return {
     mockResolveIdentityFromWif: vi.fn(),
     mockResolveDpnsName: vi.fn(),
@@ -42,6 +49,7 @@ const {
     KeyDisabledError,
     UnknownIdentityError,
     InvalidPrivateKeyError,
+    AmbiguousIdentityError,
   };
 });
 
@@ -51,6 +59,7 @@ vi.mock("../src/dash/loginWithPrivateKey", () => ({
   KeyDisabledError,
   UnknownIdentityError,
   InvalidPrivateKeyError,
+  AmbiguousIdentityError,
 }));
 
 vi.mock("../src/dash/resolveDpnsName", () => ({
@@ -74,16 +83,19 @@ function Harness({
   enabled = true,
   onState,
   sdkOverride,
+  expectedIdentityId,
 }: {
   secret: string;
   enabled?: boolean;
   onState: (state: WifPreviewState) => void;
   sdkOverride?: DashSdk | null;
+  expectedIdentityId?: string;
 }) {
   const state = useWifPreview(
     sdkOverride === undefined ? sdk : sdkOverride,
     secret,
     enabled,
+    expectedIdentityId,
   );
   onState(state);
   return null;
@@ -113,6 +125,38 @@ async function flushDebounce() {
 }
 
 describe("useWifPreview", () => {
+  it("surfaces ambiguity without exposing candidate identities", async () => {
+    mockResolveIdentityFromWif.mockRejectedValue(new AmbiguousIdentityError());
+    const states: WifPreviewState[] = [];
+
+    render(<Harness secret={VALID_WIF} onState={(s) => states.push(s)} />);
+    await flushDebounce();
+
+    expect(states.at(-1)).toEqual({ status: "ambiguous" });
+  });
+
+  it("passes an expected identity ID back to the resolver", async () => {
+    mockResolveIdentityFromWif.mockResolvedValue({
+      identityId: "identity-a",
+    });
+    const states: WifPreviewState[] = [];
+
+    render(
+      <Harness
+        secret={VALID_WIF}
+        expectedIdentityId="identity-a"
+        onState={(s) => states.push(s)}
+      />,
+    );
+    await flushDebounce();
+
+    expect(mockResolveIdentityFromWif).toHaveBeenCalledWith(
+      sdk,
+      VALID_WIF,
+      "identity-a",
+    );
+  });
+
   it("returns idle when disabled, even for a valid-shaped WIF", async () => {
     const states: WifPreviewState[] = [];
     render(
diff --git a/example-apps/dashproof-lab/src/components/AppShell.tsx b/example-apps/dashproof-lab/src/components/AppShell.tsx
index fb21c1a1..3827acc1 100644
--- a/example-apps/dashproof-lab/src/components/AppShell.tsx
+++ b/example-apps/dashproof-lab/src/components/AppShell.tsx
@@ -221,7 +221,7 @@ export function AppShell({
         <div className="mx-auto max-w-[1160px]">{children}</div>
         <footer className="mx-auto mt-10 flex max-w-[1160px] justify-center border-t border-line pt-4 text-[12px] text-ink-3">
           <a
-            href="https://github.com/dashpay/platform-tutorials"
+            href="https://github.com/dashpay/platform-tutorials/tree/main/example-apps/dashproof-lab"
             target="_blank"
             rel="noreferrer"
             className="inline-flex items-center gap-1.5 text-ink-3 hover:text-accent"
diff --git a/example-apps/dashrate/src/App.tsx b/example-apps/dashrate/src/App.tsx
index 8833ee9e..af3674f4 100644
--- a/example-apps/dashrate/src/App.tsx
+++ b/example-apps/dashrate/src/App.tsx
@@ -301,7 +301,7 @@ export default function App() {
 
       <footer className="app-footer">
         <a
-          href="https://github.com/dashpay/platform-tutorials"
+          href="https://github.com/dashpay/platform-tutorials/tree/main/example-apps/dashrate"
           target="_blank"
           rel="noreferrer"
         >
diff --git a/example-apps/token-ops/CLAUDE.md b/example-apps/token-ops/CLAUDE.md
index 63634e3d..2853ccec 100644
--- a/example-apps/token-ops/CLAUDE.md
+++ b/example-apps/token-ops/CLAUDE.md
@@ -33,6 +33,7 @@ React + TypeScript + Vite app demonstrating Dash Platform token operations gover
   - [types.ts](src/dash/types.ts) — the app's SDK-surface type aliases (`DashSdk`, `DashKeyManager`, `DashContractLike`, `DashTokenGroupActionResult`, …).
 - **[src/session/](src/session/)** — `SessionContext.tsx` provides `{ status, error, sdk, keyManager, identityId, contractId, setContractId, log, login, enterReadOnly, logout }`. It owns the cached `loadSdkCore()` dynamic import of the shared core (`createClient` + `IdentityKeyManager`) — a **distinct loader** from `dash/sdkModule.ts` (the evo-sdk value-import loader) on purpose (see [Performance](#performance--load-anchor-rules-dont-unwind-these) rule 2). `login(secret, { identityIndex? })` dispatches on secret shape (`detectSecretShape`): a **mnemonic** builds an `IdentityKeyManager` (from `loadSdkCore()`); a **WIF** dynamic-imports `loginWithPrivateKey` inside `login()` and then runs `keyManagerFromKey` (adapts the resolved `DashAuth` tuple into the minimal `DashKeyManager` shape — `{ identityId, getAuth: async () => auth }`; `identityIndex` is ignored for WIF, the identity is whichever holds the key). `enterReadOnly()` connects the SDK with no keys (`App.tsx` auto-enters it on `status === "idle"`). Network is hardcoded to **testnet**. The secret is never stored in state or localStorage — only `contractId` is persisted. Consumer hook: `useSession.ts`. `keyManagerFromKey.ts` is the WIF adapter; `../lib/detectSecretShape.ts` is the mnemonic-vs-WIF heuristic (mnemonics have whitespace, WIFs are a single token).
 - **[src/hooks/useDpnsNames.ts](src/hooks/useDpnsNames.ts)** — resolves a set of identity IDs to DPNS names, keyed/deduped by a normalized sorted `idsKey`, backed by a **module-level cache** so names survive remounts. Transient failures are left uncached for retry.
+- **Shared auth parity:** `src/dash/loginWithPrivateKey.ts`, `src/lib/detectSecretShape.ts`, `src/session/keyManagerFromKey.ts`, and the core resolver suite `test/loginWithPrivateKey.test.ts` must remain byte-identical to their Dashnote counterparts. Keep app-specific session and modal behavior outside these files; CI enforces parity with `scripts/check-shared-auth-parity.sh`.
 - **[src/components/](src/components/)** — four views rendered by tab in [App.tsx](src/App.tsx) (remounted via `key={refreshKey}` on op completion): `OverviewView` (the visible **Dashboard** tab: personalized proposal counts, membership, operator-authority cards with non-group authorities aggregated as pseudo-groups, compact token details, and a lazy collapsible identity balance/freeze-status inspector), `ActionsView` (owns one governance fetch shared by `ProposeActionPanel` and `PendingActionsView`; manual queue refresh updates the shared snapshot), `GovernanceView` (Access-control + Groups tabs), and `SettingsView` (signed-in status + balance _or_ read-only notice, contract/token-ID resolver, register-contract — **no longer holds the sign-in form**). `ProposeActionPanel` renders the conditional group-action/direct-transfer form, while `PendingActionsView` renders ACTIVE actions, signer progress, and co-sign controls. Sign-in lives in `LoginModal`, a top-bar modal opened by `TopNav`'s "Sign in" button (`App.tsx` owns the `loginOpen` state); `TopNav` also renders "Sign out" when authenticated. Supporting: `ConfirmActionPanel`, `CopyableId`, `IdentityLabel` (renders `@dpnsname`), `AppNotices`.
 - **[src/lib/](src/lib/)** — [capabilityIcon.tsx](src/lib/capabilityIcon.tsx) (per-capability SVG glyph), [explorer.ts](src/lib/explorer.ts) (testnet Platform Explorer URLs — base is hardcoded testnet), [format.ts](src/lib/format.ts) (`shortId`).
 - **[scripts/bootstrap-identities.mjs](scripts/bootstrap-identities.mjs)** — derives/registers four identities (indices 0–3) from one `PLATFORM_MNEMONIC`, tops each up to its role floor, and writes member IDs to `token-ops/.env`. See [Bootstrap](#bootstrap-script).
@@ -85,7 +86,7 @@ Remember a `ChangeControlRules` object has two authorities: `authorizedToMakeCha
 - **Config reassignment** supports only the six high-signal operator changes: `ManualMintingItem`, `ManualBurningItem`, `FreezeItem`, `UnfreezeItem`, `DestroyFrozenFundsItem`, `EmergencyActionItem` (built by `configurationChangeItemForRule`). Other rows in the Governance **Config authority** matrix (maxSupply, conventions, distribution destinations, trade mode, perpetual distribution) are `deferred: true` — displayed and documented but not reassignable in v1.
 - **Governance reads**: `sdk.contracts.fetch` for groups + token config; `sdk.group.info(contractId, position)` to backfill any group missing from the contract body; `sdk.contracts.update` to append a group. `governance.ts` normalizes both Map and plain-object shapes and both camelCase and snake_case rule keys because the SDK serialization varies.
 - **Pending actions**: `sdk.group.actions({ …, status: "ACTIVE", limit: 100 })` (single query per group; no cursor pagination) and `sdk.group.actionSigners({ …, status: "ACTIVE", actionId })`.
-- **WIF sign-in** ([loginWithPrivateKey.ts](src/dash/loginWithPrivateKey.ts)): `PrivateKey.fromWIF` → `privateKey.getPublicKeyHash()` → `sdk.identities.byPublicKeyHash(hash)` first, then `byNonUniquePublicKeyHash(hash)` if the unique lookup misses. The resolver matches the WIF against the identity's `publicKeys[]` by decoding `entry.data` as hex-or-base64 and comparing either full public-key bytes or the 20-byte public-key hash, since SDK serialization varies. It then gates on `purpose === AUTHENTICATION` + `securityLevel ∈ {HIGH, CRITICAL}` + not disabled, and throws `AmbiguousIdentityError` instead of guessing if non-unique lookup returns multiple valid auth matches. `IdentitySigner.addKeyFromWif` builds the signer. `DashSdk.identities` includes `byPublicKeyHash(...)` and `byNonUniquePublicKeyHash(...)` members in [types.ts](src/dash/types.ts) for this.
+- **WIF sign-in** ([loginWithPrivateKey.ts](src/dash/loginWithPrivateKey.ts)): `PrivateKey.fromWIF` → `privateKey.getPublicKeyHash()` → `sdk.identities.byPublicKeyHash(hash)` first, then paginated `byNonUniquePublicKeyHash(hash, startAfter)` if the unique lookup misses. Matching accepts full ECDSA and ECDSA HASH160 keys only, gates on AUTHENTICATION + HIGH/CRITICAL + enabled, and requires an exact identity ID when multiple identities match. Explicit IDs are fetched directly and verified; result order is never used for selection.
 - Direct purchase, distribution claims, and admin/control-group updates are displayed or documented but intentionally deferred from v1.
 
 ## Limitations
diff --git a/example-apps/token-ops/README.md b/example-apps/token-ops/README.md
index 72dea8b7..8bac8023 100644
--- a/example-apps/token-ops/README.md
+++ b/example-apps/token-ops/README.md
@@ -38,7 +38,7 @@ npm run format:check  # Prettier (check only)
 Click **Sign in** in the top bar to open the login modal. Paste either a BIP-39 **mnemonic** or a single **WIF private key** — the app picks the path automatically (mnemonics contain whitespace; a WIF is one token). "Sign out" also lives in the top bar. The secret is passed straight to the in-memory key manager and is never written to React state or localStorage.
 
 - **Mnemonic** — an "Advanced settings" disclosure exposes an identity index. Index `0` is the contract owner (the identity that can register a contract and reassign authorities); indices `1`–`3` are the group members that propose and co-sign token actions.
-- **WIF private key** — the app looks up the owning identity via its public-key hash (`sdk.identities.byPublicKeyHash`, then `byNonUniquePublicKeyHash` when needed) and verifies the matching key is an AUTHENTICATION key at HIGH or CRITICAL security level and not disabled. SDK key data may be encoded as either full public-key bytes or the 20-byte public-key hash; the login path accepts both. Wrong-purpose, disabled-key, unknown-identity, ambiguous-identity, and malformed-WIF cases each surface a specific error. No identity index applies — the identity is whichever one holds that key.
+- **WIF private key** — the app looks up the owning identity via its public-key hash (`sdk.identities.byPublicKeyHash`, then paginated `byNonUniquePublicKeyHash` when needed) and verifies the matching key is an AUTHENTICATION key at HIGH or CRITICAL security level and not disabled. SDK key data may be encoded as either full ECDSA public-key bytes or an ECDSA HASH160 value; other HASH160 key types are rejected. If the key belongs to multiple identities, the modal requires the exact intended identity ID, fetches it directly, and verifies the WIF against it instead of guessing or listing candidates. Wrong-purpose, disabled-key, unknown-identity, ambiguous-identity, and malformed-WIF cases each surface a specific error.
 
 The **Settings** tab shows signed-in status and token balance (or a read-only notice), plus the contract/token-ID resolver and the register-contract flow.
 
diff --git a/example-apps/token-ops/package-lock.json b/example-apps/token-ops/package-lock.json
index 299c002d..9f3eea6c 100644
--- a/example-apps/token-ops/package-lock.json
+++ b/example-apps/token-ops/package-lock.json
@@ -28,7 +28,7 @@
         "eslint-plugin-react-refresh": "^0.5.2",
         "globals": "^17.4.0",
         "jsdom": "^26.1.0",
-        "prettier": "^3.6.2",
+        "prettier": "3.8.4",
         "typescript": "~6.0.2",
         "typescript-eslint": "^8.58.0",
         "vite": "^8.0.4",
@@ -3441,9 +3441,9 @@
       }
     },
     "node_modules/prettier": {
-      "version": "3.9.4",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.4.tgz",
-      "integrity": "sha512-yWG/o/4oJfo036EKAfK6ACAoDOfHeRHx4tuxkfBZiauURiaSmYwlpOr5LQqKtIkRD2z1PLteme2WoxEnj4tHTg==",
+      "version": "3.8.4",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.4.tgz",
+      "integrity": "sha512-N2MylSdi48+5N/6S5j+maeHbUSIzzZ5uOcX5Hm4QpV8Dkb1HFjfAKTKX6yNPJQD9AhcT3ifHNB66tWTTJDi11Q==",
       "dev": true,
       "license": "MIT",
       "bin": {
diff --git a/example-apps/token-ops/package.json b/example-apps/token-ops/package.json
index f4d3b312..78bf140e 100644
--- a/example-apps/token-ops/package.json
+++ b/example-apps/token-ops/package.json
@@ -42,7 +42,7 @@
     "eslint-plugin-react-refresh": "^0.5.2",
     "globals": "^17.4.0",
     "jsdom": "^26.1.0",
-    "prettier": "^3.6.2",
+    "prettier": "3.8.4",
     "typescript": "~6.0.2",
     "typescript-eslint": "^8.58.0",
     "vite": "^8.0.4",
diff --git a/example-apps/token-ops/src/components/LoginModal.tsx b/example-apps/token-ops/src/components/LoginModal.tsx
index 8d5242f5..2fc7d434 100644
--- a/example-apps/token-ops/src/components/LoginModal.tsx
+++ b/example-apps/token-ops/src/components/LoginModal.tsx
@@ -22,12 +22,15 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
   const [error, setError] = useState<string | null>(null);
   const [submitting, setSubmitting] = useState(false);
   const [showAdvanced, setShowAdvanced] = useState(false);
+  const [expectedIdentityId, setExpectedIdentityId] = useState("");
+  const [ambiguousWif, setAmbiguousWif] = useState<string | null>(null);
 
   const secretShape = useMemo(
     () => (secret.trim() ? detectSecretShape(secret) : null),
     [secret],
   );
   const isWifInput = secretShape === "wif";
+  const needsIdentityId = isWifInput && ambiguousWif === secret.trim();
 
   const resetForm = useCallback(() => {
     setSecret("");
@@ -35,6 +38,8 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
     setError(null);
     setSubmitting(false);
     setShowAdvanced(false);
+    setExpectedIdentityId("");
+    setAmbiguousWif(null);
   }, []);
 
   const handleClose = useCallback(() => {
@@ -66,10 +71,16 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
       const index = Number.parseInt(identityIndex, 10);
       await session.login(secret, {
         identityIndex: Number.isNaN(index) ? 0 : index,
+        ...(isWifInput && expectedIdentityId.trim()
+          ? { expectedIdentityId: expectedIdentityId.trim() }
+          : {}),
       });
       handleClose();
     } catch (err) {
       setError(errorMessage(err));
+      if (err instanceof Error && err.name === "AmbiguousIdentityError") {
+        setAmbiguousWif(secret.trim());
+      }
     } finally {
       setSubmitting(false);
     }
@@ -124,7 +135,11 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
               autoComplete="off"
               spellCheck={false}
               value={secret}
-              onChange={(event) => setSecret(event.target.value)}
+              onChange={(event) => {
+                setSecret(event.target.value);
+                setExpectedIdentityId("");
+                setAmbiguousWif(null);
+              }}
               placeholder="Mnemonic phrase or WIF private key"
             />
             <p className="muted login-modal-hint">
@@ -133,6 +148,29 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
             </p>
           </div>
 
+          {needsIdentityId && (
+            <div className="field login-advanced-field">
+              <label htmlFor="login-identity-id">Identity ID</label>
+              <input
+                id="login-identity-id"
+                type="text"
+                autoComplete="off"
+                spellCheck={false}
+                value={expectedIdentityId}
+                onChange={(event) => {
+                  setExpectedIdentityId(event.target.value);
+                  setError(null);
+                }}
+                placeholder="Full Dash Platform identity ID"
+              />
+              <p className="muted login-modal-hint">
+                This key is associated with multiple identities. Token
+                operations will be performed as this exact identity; TokenOps
+                does not list identities associated with the key.
+              </p>
+            </div>
+          )}
+
           {!isWifInput && (
             <>
               <button
@@ -173,7 +211,14 @@ export function LoginModal({ open, onClose }: LoginModalProps) {
           </p>
 
           <div className="modal-actions">
-            <button type="submit" disabled={submitting || !secret.trim()}>
+            <button
+              type="submit"
+              disabled={
+                submitting ||
+                !secret.trim() ||
+                (needsIdentityId && !expectedIdentityId.trim())
+              }
+            >
               {submitting ? "Connecting..." : "Sign in"}
             </button>
             <button
diff --git a/example-apps/token-ops/src/dash/loginWithPrivateKey.ts b/example-apps/token-ops/src/dash/loginWithPrivateKey.ts
index 2b75a591..761ac13e 100644
--- a/example-apps/token-ops/src/dash/loginWithPrivateKey.ts
+++ b/example-apps/token-ops/src/dash/loginWithPrivateKey.ts
@@ -17,7 +17,7 @@ export class UnknownIdentityError extends Error {
 export class AmbiguousIdentityError extends Error {
   constructor() {
     super(
-      "This key matches multiple identities on testnet. Use a different authentication key.",
+      "This key is associated with multiple identities. Enter the full identity ID you want to use.",
     );
     this.name = "AmbiguousIdentityError";
   }
@@ -34,7 +34,7 @@ export class WrongKeyPurposeError extends Error {
     securityLevelName: string,
   ) {
     super(
-      `Found identity ${identityId}, but this key cannot sign token operations. Paste a HIGH or CRITICAL authentication key instead.`,
+      `Found identity ${identityId}, but this key cannot sign state transitions. Paste a HIGH or CRITICAL authentication key instead.`,
     );
     this.name = "WrongKeyPurposeError";
     this.identityId = identityId;
@@ -64,6 +64,7 @@ interface IdentityJsonKey {
   id: number;
   purpose: number;
   securityLevel: number;
+  type?: number;
   data?: string;
   disabled?: boolean;
   disabledAt?: number | string | null;
@@ -79,6 +80,9 @@ interface IdentityLike {
   getPublicKeyById?: (keyId: number) => unknown;
 }
 
+/**
+ * Compare two byte arrays for equality.
+ */
 function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i += 1) {
@@ -87,6 +91,14 @@ function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
   return true;
 }
 
+/**
+ * Decode a public-key data field from `identity.toJSON()`.
+ *
+ * Dash Platform's JSON encoding for bytes has historically been base64,
+ * but some versions emit hex. We try hex first, then fall back to base64
+ * before giving up. Returning null lets the caller skip a key it can't
+ * compare rather than aborting.
+ */
 function tryDecodeKeyData(data: string): Uint8Array | null {
   if (typeof data !== "string" || data.length === 0) return null;
 
@@ -98,7 +110,7 @@ function tryDecodeKeyData(data: string): Uint8Array | null {
       }
       return bytes;
     } catch {
-      // Try base64 next.
+      // fall through to base64
     }
   }
 
@@ -114,6 +126,10 @@ function tryDecodeKeyData(data: string): Uint8Array | null {
   }
 }
 
+// State transitions require HIGH or CRITICAL authentication.
+// MASTER (key 0) can only sign identity-update transitions, so a user who
+// pastes their master WIF would log in successfully but fail at the first
+// write — reject up front with a clear message instead.
 const AUTH_SECURITY_LEVELS = new Set<number>([
   SecurityLevel.HIGH as unknown as number,
   SecurityLevel.CRITICAL as unknown as number,
@@ -154,9 +170,20 @@ interface MatchedIdentity {
   error: Error | null;
 }
 
+/**
+ * Resolve which identity a WIF private key belongs to and which key on that
+ * identity it matches, without building a signer. Performs every check the
+ * full login does (WIF parse, identity lookup, key-purpose / disabled / level
+ * validation) and throws the same error types — this is the shared core for
+ * both eager preview and the actual login.
+ *
+ * The signer construction is split out so the preview path can avoid touching
+ * the WASM signer until the user commits to logging in.
+ */
 export async function resolveIdentityFromWif(
   sdk: DashSdk,
   wif: string,
+  expectedIdentityId?: string,
 ): Promise<ResolvedWifIdentity> {
   let privateKey: PrivateKey;
   try {
@@ -166,10 +193,9 @@ export async function resolveIdentityFromWif(
   }
 
   const pubKeyHash = privateKey.getPublicKeyHash();
-  const identity = (await sdk.identities.byPublicKeyHash(
-    pubKeyHash as never,
-  )) as IdentityLike | undefined | null;
 
+  // Get the public key bytes our WIF derives, so we can identify which
+  // entry in publicKeys[] is ours.
   const pkAny = privateKey as unknown as {
     getPublicKey?: () => unknown;
     toPublicKey?: () => unknown;
@@ -179,6 +205,27 @@ export async function resolveIdentityFromWif(
     : pkAny.toPublicKey?.();
   const ourPubKeyBytes = ourPubKey ? extractPubKeyBytes(ourPubKey) : null;
   const ourPubKeyHashBytes = normalizePublicKeyHash(pubKeyHash);
+  const expected = expectedIdentityId?.trim() || null;
+
+  if (expected) {
+    const expectedIdentity = (await sdk.identities.fetch(expected)) as
+      | IdentityLike
+      | undefined
+      | null;
+    if (!expectedIdentity) throw new UnknownIdentityError();
+    const selected = matchIdentityKey(
+      expectedIdentity,
+      ourPubKeyBytes,
+      ourPubKeyHashBytes,
+    );
+    if (!selected) throw new UnknownIdentityError();
+    if (selected.error) throw selected.error;
+    return resolvedIdentity(selected);
+  }
+
+  const identity = (await sdk.identities.byPublicKeyHash(
+    pubKeyHash as never,
+  )) as IdentityLike | undefined | null;
 
   if (identity) {
     const match = matchIdentityKey(
@@ -191,30 +238,64 @@ export async function resolveIdentityFromWif(
     return resolvedIdentity(match);
   }
 
-  const candidates =
-    (await sdk.identities.byNonUniquePublicKeyHash?.(pubKeyHash as never)) ??
-    [];
-  const matches = candidates
-    .map((candidate) =>
-      matchIdentityKey(
+  const matches = await findNonUniqueMatches(
+    sdk,
+    pubKeyHash,
+    ourPubKeyBytes,
+    ourPubKeyHashBytes,
+  );
+  if (matches.length > 1) throw new AmbiguousIdentityError();
+  if (matches.length === 1) {
+    if (matches[0].error) throw matches[0].error;
+    return resolvedIdentity(matches[0]);
+  }
+  throw new UnknownIdentityError();
+}
+
+async function findNonUniqueMatches(
+  sdk: DashSdk,
+  pubKeyHash: unknown,
+  ourPubKeyBytes: Uint8Array | null,
+  ourPubKeyHashBytes: Uint8Array | null,
+): Promise<MatchedIdentity[]> {
+  const lookup = sdk.identities.byNonUniquePublicKeyHash;
+  if (!lookup) return [];
+
+  const matches: MatchedIdentity[] = [];
+  let startAfter: string | undefined;
+  const seenCursors = new Set<string>();
+
+  while (true) {
+    const candidates = await lookup.call(
+      sdk.identities,
+      pubKeyHash as never,
+      startAfter,
+    );
+    if (candidates.length === 0) break;
+
+    const cursor = identityIdOf(
+      candidates[candidates.length - 1] as IdentityLike,
+    );
+    if (seenCursors.has(cursor)) {
+      throw new Error("Non-unique identity lookup pagination did not advance.");
+    }
+    seenCursors.add(cursor);
+
+    for (const candidate of candidates) {
+      const match = matchIdentityKey(
         candidate as IdentityLike,
         ourPubKeyBytes,
         ourPubKeyHashBytes,
-      ),
-    )
-    .filter((match): match is MatchedIdentity => match != null);
+      );
+      if (match) matches.push(match);
+      // We only need to establish ambiguity, not enumerate identities.
+      if (matches.length > 1) return matches;
+    }
 
-  if (matches.length > 1) {
-    throw new AmbiguousIdentityError();
-  }
-  const validMatches = matches.filter((match) => !match.error);
-  if (validMatches.length === 1) {
-    return resolvedIdentity(validMatches[0]);
+    startAfter = cursor;
   }
-  if (matches.length === 1) {
-    throw matches[0].error ?? new UnknownIdentityError();
-  }
-  throw new UnknownIdentityError();
+
+  return matches;
 }
 
 function resolvedIdentity(match: MatchedIdentity): ResolvedWifIdentity {
@@ -226,11 +307,18 @@ function resolvedIdentity(match: MatchedIdentity): ResolvedWifIdentity {
   };
 }
 
+/**
+ * Look up an identity from a WIF private key and prepare a one-key signer
+ * for auth-purpose operations.
+ *
+ * Thin wrapper around `resolveIdentityFromWif` that adds signer construction.
+ */
 export async function loginWithPrivateKey(
   sdk: DashSdk,
   wif: string,
+  expectedIdentityId?: string,
 ): Promise<DashAuth & { identityId: string }> {
-  const resolved = await resolveIdentityFromWif(sdk, wif);
+  const resolved = await resolveIdentityFromWif(sdk, wif, expectedIdentityId);
   const signer = new IdentitySigner();
   signer.addKeyFromWif(wif);
 
@@ -250,15 +338,23 @@ function matchIdentityKey(
   const identityId =
     typeof identity.id === "string" ? identity.id : identity.id.toString();
   const publicKeys = identity.toJSON?.().publicKeys ?? [];
-  if (publicKeys.length === 0) return null;
-
   const matched = publicKeys.find((entry) => {
     if (!entry.data) return false;
     const entryBytes = tryDecodeKeyData(entry.data);
     if (!entryBytes) return false;
+    // SDK JSON uses type 0 for a full secp256k1 key and type 2 for its
+    // HASH160 representation. Do not treat other 20-byte key types (such as
+    // BIP13 script hashes or EDDSA HASH160) as signable by this WIF. Older
+    // SDK/test shapes may omit `type`, where byte length remains unambiguous.
+    const isFullEcdsa = entry.type === undefined || entry.type === 0;
+    const isEcdsaHash160 = entry.type === undefined || entry.type === 2;
     return (
-      (ourPubKeyBytes ? bytesEqual(entryBytes, ourPubKeyBytes) : false) ||
-      (ourPubKeyHashBytes ? bytesEqual(entryBytes, ourPubKeyHashBytes) : false)
+      (isFullEcdsa && ourPubKeyBytes
+        ? bytesEqual(entryBytes, ourPubKeyBytes)
+        : false) ||
+      (isEcdsaHash160 && ourPubKeyHashBytes
+        ? bytesEqual(entryBytes, ourPubKeyHashBytes)
+        : false)
     );
   });
   if (!matched) return null;
@@ -267,26 +363,22 @@ function matchIdentityKey(
   if (matched.disabled === true || matched.disabledAt) {
     error = new KeyDisabledError(identityId);
   } else {
-    const purposeValue = matched.purpose;
-    const securityLevelValue = matched.securityLevel;
     const isAuthPurpose =
-      purposeValue === (Purpose.AUTHENTICATION as unknown as number);
-    const isAuthLevel = AUTH_SECURITY_LEVELS.has(securityLevelValue);
+      matched.purpose === (Purpose.AUTHENTICATION as unknown as number);
+    const isAuthLevel = AUTH_SECURITY_LEVELS.has(matched.securityLevel);
     if (!isAuthPurpose || !isAuthLevel) {
       error = new WrongKeyPurposeError(
         identityId,
-        purposeName(purposeValue),
-        securityLevelName(securityLevelValue),
+        purposeName(matched.purpose),
+        securityLevelName(matched.securityLevel),
       );
     }
   }
+  return { identity, identityId, matched, error };
+}
 
-  return {
-    identity,
-    identityId,
-    matched,
-    error,
-  };
+function identityIdOf(identity: IdentityLike): string {
+  return typeof identity.id === "string" ? identity.id : identity.id.toString();
 }
 
 function normalizePublicKeyHash(hash: unknown): Uint8Array | null {
@@ -305,6 +397,11 @@ function tryDecodeHex(hex: string): Uint8Array | null {
   return bytes;
 }
 
+/**
+ * Pull the raw compressed public key bytes from a `PrivateKey.toPublicKey()`
+ * result. The SDK exposes a few encoders depending on version (toBytes(),
+ * toBuffer(), toString('hex'), etc.) — we try each in order.
+ */
 function extractPubKeyBytes(pubKey: unknown): Uint8Array | null {
   const candidate = pubKey as {
     toBytes?: () => Uint8Array | ArrayLike<number>;
@@ -316,14 +413,14 @@ function extractPubKeyBytes(pubKey: unknown): Uint8Array | null {
     try {
       return new Uint8Array(candidate.toBytes() as ArrayLike<number>);
     } catch {
-      // Try the next encoder.
+      // fall through
     }
   }
   if (typeof candidate.toBuffer === "function") {
     try {
       return new Uint8Array(candidate.toBuffer() as ArrayLike<number>);
     } catch {
-      // Try the next encoder.
+      // fall through
     }
   }
   if (typeof candidate.toString === "function") {
@@ -333,7 +430,7 @@ function extractPubKeyBytes(pubKey: unknown): Uint8Array | null {
         return tryDecodeHex(hex);
       }
     } catch {
-      // Fall through.
+      // fall through
     }
   }
   return null;
diff --git a/example-apps/token-ops/src/dash/types.ts b/example-apps/token-ops/src/dash/types.ts
index 2c772c17..a57551e2 100644
--- a/example-apps/token-ops/src/dash/types.ts
+++ b/example-apps/token-ops/src/dash/types.ts
@@ -82,12 +82,15 @@ export interface DashSdk {
   };
   documents?: Record<string, unknown>;
   identities: {
-    byPublicKeyHash(publicKeyHash: unknown): Promise<Identity | undefined>;
+    fetch(identityId: string): Promise<Identity | null | undefined>;
+    nonce(identityId: string): Promise<bigint | null | undefined>;
+    byPublicKeyHash(
+      publicKeyHash: Uint8Array,
+    ): Promise<Identity | null | undefined>;
     byNonUniquePublicKeyHash?(
-      publicKeyHash: unknown,
-      startAfter?: unknown,
+      publicKeyHash: Uint8Array,
+      startAfter?: string,
     ): Promise<Identity[]>;
-    nonce(identityId: string): Promise<bigint | null | undefined>;
     balance(identityId: string): Promise<bigint>;
   };
   tokens: {
diff --git a/example-apps/token-ops/src/lib/detectSecretShape.ts b/example-apps/token-ops/src/lib/detectSecretShape.ts
index e1007c82..9dd6bebe 100644
--- a/example-apps/token-ops/src/lib/detectSecretShape.ts
+++ b/example-apps/token-ops/src/lib/detectSecretShape.ts
@@ -1,9 +1,31 @@
-export type SecretShape = "mnemonic" | "wif";
-
 /**
- * BIP39 mnemonics are whitespace-separated word lists; WIF keys are base58
- * strings without whitespace. Real validation happens in the selected parser.
+ * Decide whether a pasted secret is a BIP39 mnemonic or a WIF private key.
+ *
+ * BIP39 mnemonics are space-separated word lists; WIF keys are base58-encoded
+ * with no whitespace. The two formats don't overlap, so a whitespace check is
+ * a sufficient discriminator. The downstream parser does the real validation.
  */
+export type SecretShape = "mnemonic" | "wif";
+
 export function detectSecretShape(input: string): SecretShape {
   return /\s/.test(input.trim()) ? "mnemonic" : "wif";
 }
+
+// Bitcoin/Dash base58 alphabet (no 0, O, I, l).
+const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]+$/;
+
+/**
+ * Cheap, local "looks like a WIF" check used to gate eager identity lookup.
+ *
+ * Catches obviously-incomplete input (still typing, wrong charset, wrong
+ * length) without invoking the WASM PrivateKey parser. Returning true does
+ * NOT mean the WIF is valid — only that it's worth handing to the parser.
+ * Authoritative validation (checksum, version byte) is done downstream by
+ * `PrivateKey.fromWIF`.
+ */
+export function looksLikeWif(input: string): boolean {
+  const trimmed = input.trim();
+  // Compressed WIF is 52 chars, uncompressed is 51. Anything else is partial.
+  if (trimmed.length !== 51 && trimmed.length !== 52) return false;
+  return BASE58_RE.test(trimmed);
+}
diff --git a/example-apps/token-ops/src/session/SessionContext.tsx b/example-apps/token-ops/src/session/SessionContext.tsx
index ddb4326c..072c2bd5 100644
--- a/example-apps/token-ops/src/session/SessionContext.tsx
+++ b/example-apps/token-ops/src/session/SessionContext.tsx
@@ -42,6 +42,7 @@ export type SessionStatus =
 
 export interface LoginOptions {
   identityIndex?: number;
+  expectedIdentityId?: string;
 }
 
 export interface SessionValue {
@@ -103,7 +104,7 @@ export function SessionProvider({ children }: { children: ReactNode }) {
 
   const login = useCallback(
     async (secret: string, options: LoginOptions = {}) => {
-      const { identityIndex = 0 } = options;
+      const { identityIndex = 0, expectedIdentityId } = options;
       const trimmed = secret.trim();
       if (!trimmed) throw new Error("Mnemonic or private key is required.");
       setError(null);
@@ -130,6 +131,7 @@ export function SessionProvider({ children }: { children: ReactNode }) {
           const auth = await loginWithPrivateKey(
             connected as unknown as DashSdk,
             trimmed,
+            expectedIdentityId,
           );
           manager = keyManagerFromKey(auth.identityId, auth);
         }
diff --git a/example-apps/token-ops/src/session/keyManagerFromKey.ts b/example-apps/token-ops/src/session/keyManagerFromKey.ts
index 01797ebd..c91042d1 100644
--- a/example-apps/token-ops/src/session/keyManagerFromKey.ts
+++ b/example-apps/token-ops/src/session/keyManagerFromKey.ts
@@ -1,5 +1,13 @@
 import type { DashAuth, DashKeyManager } from "../dash/types";
 
+/**
+ * Build a DashKeyManager-shaped object from a pre-resolved auth triple.
+ *
+ * Used by the WIF login flow: `loginWithPrivateKey` already located the
+ * identity and built a one-key signer, so getAuth() just hands the cached
+ * triple back. This lets `src/dash/*` helpers consume WIF-based sessions
+ * without a separate code path.
+ */
 export function keyManagerFromKey(
   identityId: string,
   auth: DashAuth,
diff --git a/example-apps/token-ops/test/LoginModal.test.tsx b/example-apps/token-ops/test/LoginModal.test.tsx
index f9dae607..4e1eb102 100644
--- a/example-apps/token-ops/test/LoginModal.test.tsx
+++ b/example-apps/token-ops/test/LoginModal.test.tsx
@@ -276,4 +276,54 @@ describe("LoginModal", () => {
     expect(await screen.findByText("bad key")).toBeTruthy();
     expect(onClose).not.toHaveBeenCalled();
   });
+
+  it("prompts for an exact identity ID after an ambiguous WIF login", async () => {
+    const ambiguity = new Error("ambiguous key");
+    ambiguity.name = "AmbiguousIdentityError";
+    const login = mockSession(
+      vi.fn().mockRejectedValueOnce(ambiguity).mockResolvedValueOnce(undefined),
+    );
+    const onClose = vi.fn();
+    render(<LoginModal open onClose={onClose} />);
+    fireEvent.change(screen.getByLabelText("Mnemonic or private key"), {
+      target: { value: "private-key" },
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "Sign in" }));
+    const identityInput = await screen.findByLabelText("Identity ID");
+    expect(screen.getByLabelText("Mnemonic or private key")).toHaveProperty(
+      "value",
+      "private-key",
+    );
+    expect(
+      (screen.getByRole("button", { name: "Sign in" }) as HTMLButtonElement)
+        .disabled,
+    ).toBe(true);
+
+    fireEvent.change(identityInput, { target: { value: "identity-intended" } });
+    fireEvent.click(screen.getByRole("button", { name: "Sign in" }));
+
+    await waitFor(() =>
+      expect(login).toHaveBeenLastCalledWith("private-key", {
+        identityIndex: 0,
+        expectedIdentityId: "identity-intended",
+      }),
+    );
+    expect(onClose).toHaveBeenCalledOnce();
+  });
+
+  it("clears the ambiguity prompt when the secret changes", async () => {
+    const ambiguity = new Error("ambiguous key");
+    ambiguity.name = "AmbiguousIdentityError";
+    mockSession(vi.fn().mockRejectedValue(ambiguity));
+    render(<LoginModal open onClose={vi.fn()} />);
+    const secretInput = screen.getByLabelText("Mnemonic or private key");
+    fireEvent.change(secretInput, { target: { value: "private-key" } });
+    fireEvent.click(screen.getByRole("button", { name: "Sign in" }));
+    await screen.findByLabelText("Identity ID");
+
+    fireEvent.change(secretInput, { target: { value: "different-key" } });
+
+    expect(screen.queryByLabelText("Identity ID")).toBeNull();
+  });
 });
diff --git a/example-apps/token-ops/test/SessionContext.test.tsx b/example-apps/token-ops/test/SessionContext.test.tsx
index 5dc120f0..ccfef011 100644
--- a/example-apps/token-ops/test/SessionContext.test.tsx
+++ b/example-apps/token-ops/test/SessionContext.test.tsx
@@ -97,12 +97,34 @@ describe("SessionProvider", () => {
     expect(loginWithPrivateKey).toHaveBeenCalledWith(
       expect.anything(),
       "private-key",
+      undefined,
     );
     expect(result.current.keyManager?.identityId).toBe("wif-identity");
     expect(result.current.identityId).toBe("wif-identity");
     expect(result.current.status).toBe("authenticated");
   });
 
+  it("forwards an expected identity ID only to private-key login", async () => {
+    vi.mocked(loginWithPrivateKey).mockResolvedValue({
+      identityId: "expected-identity",
+      identityKey: {},
+      signer: {},
+    } as never);
+    const { result } = renderHook(() => useSession(), { wrapper });
+
+    await act(() =>
+      result.current.login("private-key", {
+        expectedIdentityId: "expected-identity",
+      }),
+    );
+
+    expect(loginWithPrivateKey).toHaveBeenCalledWith(
+      expect.anything(),
+      "private-key",
+      "expected-identity",
+    );
+  });
+
   it("rejects an empty secret before connecting", async () => {
     const { result } = renderHook(() => useSession(), { wrapper });
 
diff --git a/example-apps/token-ops/test/loginWithPrivateKey.test.ts b/example-apps/token-ops/test/loginWithPrivateKey.test.ts
index e5cbc269..c56612db 100644
--- a/example-apps/token-ops/test/loginWithPrivateKey.test.ts
+++ b/example-apps/token-ops/test/loginWithPrivateKey.test.ts
@@ -87,6 +87,7 @@ function identity({
   id = "identity-1",
   purpose = AUTHENTICATION,
   securityLevel = CRITICAL,
+  type = undefined as number | undefined,
   disabled = false,
   disabledAt = null as number | string | null,
   data = ourPubKeyBase64,
@@ -101,6 +102,7 @@ function identity({
           id: 2,
           purpose,
           securityLevel,
+          type,
           data,
           disabled,
           disabledAt,
@@ -113,6 +115,7 @@ function identity({
 function sdkWithIdentity(value: unknown): DashSdk {
   return {
     identities: {
+      fetch: vi.fn().mockResolvedValue(undefined),
       byPublicKeyHash: vi.fn().mockResolvedValue(value),
       byNonUniquePublicKeyHash: vi.fn().mockResolvedValue([]),
     },
@@ -122,8 +125,20 @@ function sdkWithIdentity(value: unknown): DashSdk {
 function sdkWithLookups(unique: unknown, nonUnique: unknown[]): DashSdk {
   return {
     identities: {
+      fetch: vi.fn().mockImplementation(async (identityId: string) =>
+        nonUnique.find((candidate) => {
+          const id = (candidate as { id?: string | { toString(): string } }).id;
+          return typeof id === "string"
+            ? id === identityId
+            : id?.toString() === identityId;
+        }),
+      ),
       byPublicKeyHash: vi.fn().mockResolvedValue(unique),
-      byNonUniquePublicKeyHash: vi.fn().mockResolvedValue(nonUnique),
+      byNonUniquePublicKeyHash: vi
+        .fn()
+        .mockImplementation(async (_hash, startAfter) =>
+          startAfter ? [] : nonUnique,
+        ),
     },
   } as unknown as DashSdk;
 }
@@ -143,6 +158,17 @@ describe("loginWithPrivateKey", () => {
     ).rejects.toBeInstanceOf(InvalidPrivateKeyError);
   });
 
+  it("rejects invalid WIF input through the signer-building login path", async () => {
+    fromWIF.mockImplementation(() => {
+      throw new Error("invalid");
+    });
+
+    await expect(
+      loginWithPrivateKey(sdkWithIdentity(null), "not-a-wif"),
+    ).rejects.toBeInstanceOf(InvalidPrivateKeyError);
+    expect(addKeyFromWif).not.toHaveBeenCalled();
+  });
+
   it("rejects keys with no registered identity", async () => {
     fromWIF.mockReturnValue(privateKey());
 
@@ -191,6 +217,84 @@ describe("loginWithPrivateKey", () => {
     expect(result.identityId).toBe("identity-1");
   });
 
+  it.each([3, 4])(
+    "rejects HASH160 bytes belonging to key type %s",
+    async (type) => {
+      fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+      await expect(
+        resolveIdentityFromWif(
+          sdkWithLookups(null, [identity({ data: ourPubKeyHashBase64, type })]),
+          "wif",
+        ),
+      ).rejects.toBeInstanceOf(UnknownIdentityError);
+    },
+  );
+
+  it("fetches and verifies an explicitly selected identity directly", async () => {
+    const identityA = identity({
+      id: "identity-a",
+      data: ourPubKeyHashBase64,
+      type: 2,
+    });
+    const identityB = identity({
+      id: "identity-b",
+      data: ourPubKeyHashBase64,
+      type: 2,
+    });
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+    const sdk = sdkWithLookups(null, [identityB, identityA]);
+
+    const result = await resolveIdentityFromWif(sdk, "wif", "identity-a");
+
+    expect(result.identityId).toBe("identity-a");
+    expect(sdk.identities.fetch).toHaveBeenCalledWith("identity-a");
+    expect(sdk.identities.byNonUniquePublicKeyHash).not.toHaveBeenCalled();
+  });
+
+  it("rejects an explicitly selected identity that does not match the WIF", async () => {
+    fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
+
+    await expect(
+      resolveIdentityFromWif(
+        sdkWithLookups(null, [
+          identity({ id: "identity-a", data: ourPubKeyHashBase64 }),
+        ]),
+        "wif",
+        "identity-other",
+      ),
+    ).rejects.toBeInstanceOf(UnknownIdentityError);
+  });
+
+  it("continues pagination until a second match establishes ambiguity", async () => {
+    const identityA = identity({ id: "identity-a" });
+    const identityB = identity({ id: "identity-b" });
+    fromWIF.mockReturnValue(privateKey());
+    const byNonUniquePublicKeyHash = vi
+      .fn()
+      .mockImplementation(async (_hash, startAfter) => {
+        if (!startAfter) return [identityA];
+        if (startAfter === "identity-a") return [identityB];
+        return [];
+      });
+    const sdk = {
+      identities: {
+        fetch: vi.fn(),
+        byPublicKeyHash: vi.fn().mockResolvedValue(undefined),
+        byNonUniquePublicKeyHash,
+      },
+    } as unknown as DashSdk;
+
+    await expect(resolveIdentityFromWif(sdk, "wif")).rejects.toBeInstanceOf(
+      AmbiguousIdentityError,
+    );
+    expect(byNonUniquePublicKeyHash).toHaveBeenNthCalledWith(
+      2,
+      expect.anything(),
+      "identity-a",
+    );
+  });
+
   it("rejects ambiguous non-unique identity matches", async () => {
     fromWIF.mockReturnValue(privateKey(ourPubKeyHashHex));
 
@@ -285,6 +389,19 @@ describe("loginWithPrivateKey", () => {
     ).rejects.toBeInstanceOf(UnknownIdentityError);
   });
 
+  it("rejects identities whose serialized public-key list is empty", async () => {
+    fromWIF.mockReturnValue(privateKey());
+    const identityWithoutKeys = {
+      id: "identity-no-keys",
+      getPublicKeyById: vi.fn(),
+      toJSON: () => ({ publicKeys: [] }),
+    };
+
+    await expect(
+      resolveIdentityFromWif(sdkWithIdentity(identityWithoutKeys), "wif"),
+    ).rejects.toBeInstanceOf(UnknownIdentityError);
+  });
+
   it("rejects disabled keys", async () => {
     fromWIF.mockReturnValue(privateKey());
 
@@ -364,6 +481,18 @@ describe("loginWithPrivateKey", () => {
     expect(addKeyFromWif).not.toHaveBeenCalled();
   });
 
+  it("applies the same purpose validation without constructing a signer", async () => {
+    fromWIF.mockReturnValue(privateKey());
+
+    await expect(
+      resolveIdentityFromWif(
+        sdkWithIdentity(identity({ purpose: TRANSFER })),
+        "wif",
+      ),
+    ).rejects.toBeInstanceOf(WrongKeyPurposeError);
+    expect(addKeyFromWif).not.toHaveBeenCalled();
+  });
+
   it.each([
     { purpose: AUTHENTICATION, securityLevel: MASTER },
     { purpose: AUTHENTICATION, securityLevel: MEDIUM },
diff --git a/scripts/check-shared-auth-parity.sh b/scripts/check-shared-auth-parity.sh
new file mode 100755
index 00000000..40cc3fd7
--- /dev/null
+++ b/scripts/check-shared-auth-parity.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+dashnote="$repo_root/example-apps/dashnote/src"
+token_ops="$repo_root/example-apps/token-ops/src"
+dashnote_tests="$repo_root/example-apps/dashnote/test"
+token_ops_tests="$repo_root/example-apps/token-ops/test"
+
+cmp "$dashnote/dash/loginWithPrivateKey.ts" "$token_ops/dash/loginWithPrivateKey.ts"
+cmp "$dashnote/lib/detectSecretShape.ts" "$token_ops/lib/detectSecretShape.ts"
+cmp "$dashnote/session/keyManagerFromKey.ts" "$token_ops/session/keyManagerFromKey.ts"
+cmp "$dashnote_tests/loginWithPrivateKey.test.ts" "$token_ops_tests/loginWithPrivateKey.test.ts"
+
+echo "Shared Dashnote/TokenOps authentication files and resolver tests are byte-identical."