@novasamatech/host-papp 0.9.1 → 0.9.3

package/.papi/descriptors/generated.json

@@ -1 +1 @@
-{"cliVersion":"0.21.1","whitelist":null,"chains":{"people_lite":"0x5856bcc2600f139c76f7af463e725b08"},"contracts":{"ink":{},"sol":{}}}
+{"cliVersion":"0.21.9","whitelist":null,"chains":{"people_lite":"0xcca79c4482b2233e7cd4d24a23988e77"},"contracts":{"ink":{},"sol":{}}}

package/.papi/descriptors/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-autogenerated.11805297896621906130",
+  "version": "0.1.0-autogenerated.15132890757373389519",
   "name": "@polkadot-api/descriptors",
   "files": [
     "dist"

package/.papi/polkadot-api.json

@@ -6,10 +6,10 @@
   },
   "entries": {
     "people_lite": {
-      "wsUrl": "wss://paseo-people-next-rpc.polkadot.io",
+      "wsUrl": "wss://people-paseo.gatotech.network",
       "metadata": ".papi/metadata/people_lite.scale",
-      "genesis": "0xa22a2424d2cbf561eaecf7da8b1b548fa9d1939f60265e942b1049616a012f71",
-      "codeHash": "0x0e48da626edc33a96d18d81fdc5eebe5d6a9b624af4ca4b9dbcc1345a3b03bb6"
+      "genesis": "0xe6c30d6e148f250b887105237bcaa5cb9f16dd203bf7b5b9d4f1da7387cb86ec",
+      "codeHash": "0x82a343ddb8c1faf6d88721f6188dabb393b3d5b4fd54aae6d621bc3b0452ebbb"
     }
   }
 }

package/README.md

@@ -4,17 +4,16 @@ Polkadot app integration layer for host applications.
 
 ## Overview
 
-`@novasamatech/host-papp` is the integration SDK that lets a javascript-based host embed Polkadot
-Mobile capabilities. It encapsulates everything needed to:
+`@novasamatech/host-papp` is the integration SDK that lets a javascript-based host embed Polkadot Mobile capabilities.
+It encapsulates everything needed to:
 
 - pair the host with a Polkadot wallet/SSO provider via a deeplink handshake;
 - store and manage paired user sessions;
 - send signing requests and ring-VRF alias requests to the paired wallet;
 - look up on-chain identity information for accounts.
 
-The package is UI-framework agnostic — it exposes plain async APIs and observable state
-(`subscribe` / `read`), so it can be wired into React, Vue, Svelte, vanilla DOM, or a
-non-browser runtime.
+The package is UI-framework agnostic — it exposes plain async APIs and observable state (`subscribe` / `read`), so it
+can be wired into React, Vue, Svelte, vanilla DOM, or a non-browser runtime.
 
 ## Installation
 
@@ -24,8 +23,7 @@ npm install @novasamatech/host-papp --save -E
 
 ## Getting started
 
-Create a single adapter instance for the lifetime of your host app and share it across the
-features that need it.
+Create a single adapter instance for the lifetime of your host app and share it across the features that need it.
 
 ```ts
 import { createPappAdapter } from '@novasamatech/host-papp';
@@ -46,26 +44,25 @@ const papp = createPappAdapter({
 
 `createPappAdapter` returns five sub-modules:
 
-| Module           | Purpose                                                              |
-| ---------------- | ------------------------------------------------------------------- |
-| `papp.sso`       | Authentication / pairing flow with a remote wallet.                 |
-| `papp.sessions`  | List of paired user sessions and per-session messaging (sign, etc.).|
-| `papp.secrets`   | Local secret storage for the derived guest accounts.                |
-| `papp.identity`  | On-chain identity lookups for arbitrary account ids.                |
-| `papp.allowance` | Resource allowances (bulletin / statement-store signers) per product.|
+| Module           | Purpose                                                               |
+| ---------------- | --------------------------------------------------------------------- |
+| `papp.sso`       | Authentication / pairing flow with a remote wallet.                   |
+| `papp.sessions`  | List of paired user sessions and per-session messaging (sign, etc.).  |
+| `papp.secrets`   | Local secret storage for the derived guest accounts.                  |
+| `papp.identity`  | On-chain identity lookups for arbitrary account ids.                  |
+| `papp.allowance` | Resource allowances (bulletin / statement-store signers) per product. |
 
-Custom adapters (statement store, identity RPC, storage, lazy chain client) can be supplied
-via the `adapters` option for testing or non-browser environments.
+Custom adapters (statement store, identity RPC, storage, lazy chain client) can be supplied via the `adapters` option
+for testing or non-browser environments.
 
 ## Authentication and pairing (V1)
 
-The V1 SSO flow described in this section is the single-device pairing protocol used by
-`papp.sso.authenticate()`. For the multi-device V2 protocol see
-[V2 SSO handshake](#v2-sso-handshake) below.
+The V1 SSO flow described in this section is the single-device pairing protocol used by `papp.sso.authenticate()`. For
+the multi-device V2 protocol see [V2 SSO handshake](#v2-sso-handshake) below.
 
-`papp.sso.authenticate()` runs the full pairing + attestation flow and resolves with the
-stored user session, or `null` if the flow was aborted. The flow is idempotent — calling it
-again while a previous run is in flight returns the same in-progress promise.
+`papp.sso.authenticate()` runs the full pairing + attestation flow and resolves with the stored user session, or `null`
+if the flow was aborted. The flow is idempotent — calling it again while a previous run is in flight returns the same
+in-progress promise.
 
 ```ts
 const result = await papp.sso.authenticate();
@@ -92,8 +89,8 @@ papp.sso.abortAuthentication();
 
 ### Reacting to pairing status
 
-The pairing process is observable. UI code typically renders a QR code / deeplink while the
-status is `pairing`, then transitions to a "signing in" screen during attestation.
+The pairing process is observable. UI code typically renders a QR code / deeplink while the status is `pairing`, then
+transitions to a "signing in" screen during attestation.
 
 ```ts
 import type { PairingStatus } from '@novasamatech/host-papp';
@@ -121,15 +118,14 @@ render(papp.sso.pairingStatus.read());
 const unsubscribe = papp.sso.pairingStatus.subscribe(render);
 ```
 
-`papp.sso.attestationStatus` exposes the same `read` / `subscribe` shape and tracks
-attestation progress (`attestation` with a claimed `username`, `attestationError`, or
-`finished`). For convenience, treat the two streams as a single derived UI state — pairing
-steps before `attestation`, then attestation, then back to pairing's `finished`.
+`papp.sso.attestationStatus` exposes the same `read` / `subscribe` shape and tracks attestation progress (`attestation`
+with a claimed `username`, `attestationError`, or `finished`). For convenience, treat the two streams as a single
+derived UI state — pairing steps before `attestation`, then attestation, then back to pairing's `finished`.
 
 ## Managing user sessions
 
-`papp.sessions.sessions` is an observable list of currently paired sessions. Most host apps
-work with the first one (single-user model), but the SDK does not enforce that.
+`papp.sessions.sessions` is an observable list of currently paired sessions. Most host apps work with the first one
+(single-user model), but the SDK does not enforce that.
 
 ```ts
 import type { UserSession } from '@novasamatech/host-papp';
@@ -144,8 +140,7 @@ const unsubscribe = papp.sessions.sessions.subscribe(sessions => {
 currentSession = papp.sessions.sessions.read().at(0) ?? null;
 ```
 
-Disconnecting notifies the wallet, removes local secrets, and triggers the subscription
-above.
+Disconnecting notifies the wallet, removes local secrets, and triggers the subscription above.
 
 ```ts
 const disconnect = async (session: UserSession) => {
@@ -159,8 +154,7 @@ const disconnect = async (session: UserSession) => {
 
 ## Signing
 
-A `UserSession` exposes `signPayload` and `signRaw` for forwarding signing requests to the
-paired wallet.
+A `UserSession` exposes `signPayload` and `signRaw` for forwarding signing requests to the paired wallet.
 
 ```ts
 const signed = await currentSession.signPayload({
@@ -197,10 +191,9 @@ await currentSession.signRaw({
 });
 ```
 
-`signVrf` asks the wallet for an sr25519 (schnorrkel) VRF signature from a product account
-(RFC-0023). The transcript travels as a recipe — a root domain-separation label plus an
-ordered list of `(label, value)` items — which the wallet replays verbatim into a Merlin
-transcript and signs. Callers that need a `signer` item must supply their own public key;
+`signVrf` asks the wallet for an sr25519 (schnorrkel) VRF signature from a product account (RFC-0023). The transcript
+travels as a recipe — a root domain-separation label plus an ordered list of `(label, value)` items — which the wallet
+replays verbatim into a Merlin transcript and signs. Callers that need a `signer` item must supply their own public key;
 the host never injects it.
 
 ```ts
@@ -222,44 +215,82 @@ vrf.match(
 );
 ```
 
-This is the non-`AutoSigning` path only: when `AutoSigning` covers the account the host
-signs locally and never round-trips to the wallet.
+This is the non-`AutoSigning` path only: when `AutoSigning` covers the account the host signs locally and never
+round-trips to the wallet.
 
-## Ring VRF proofs and aliases
+## Ring VRF keys, proofs and aliases
 
-A `UserSession` can ask the paired device for a privacy-preserving contextual alias, or a
-ring VRF proof, for a product-scoped `context` and a `ring` location. The device
-selects the member key for the ring; `callingProductId` names the product the host is acting
-for. Both take the same `(context, ring)` so the alias in the proof matches `getRingVrfAlias`.
+Ring VRF member keys are **explicit and product-owned** (RFC-0024): a product registers the keys it owns against the
+rings it intends them for, other products discover those registrations by an anonymized handle, and the handle is passed
+to every call that uses the key. The paired device is the authoritative registry — it needs the complete set to serve
+slot assignment and PGAS claims, and to show the user what their keys are used for.
 
 ```ts
-// [productId, suffix]. The suffix is the wire `Index(u32) | Raw([u8; 32])` selector
-// (RFC 0022): `Index` for a plain index, `Raw` for a raw 32-byte index. It
-// expands to the same 32-byte value as a product account's derivation index.
-const context = ['product.dot', { tag: 'Index', value: 0 }];
 const ring = {
   chainId: '0x…', // 32-byte chain genesis hash
   junctions: [{ tag: 'PalletInstance', value: 42 }],
 };
 
-const alias = await currentSession.getRingVrfAlias('caller.dot', context, ring);
+// Register a key owned by `peopl.dot` at index 0 for that ring. Consent-free and
+// idempotent — re-registering an index for another ring extends the entry.
+const publicKey = await currentSession.registerRingVrfKey('peopl.dot', { tag: 'Index', value: 0 }, ring);
+
+// Discover another product's keys. `'PublicKey'` disclosure additionally returns
+// the member public key, which is linkable across every ring it appears in and so
+// is permissioned cross-product.
+const entries = await currentSession.listRingVrfKeys('game.dot', 'peopl.dot', 'Anonymized');
+```
+
+A `UserSession` can then ask the paired device for a privacy-preserving contextual alias, or a ring VRF proof, for a
+given `keyHandle`, product-scoped `context` and `ring` location. `callingProductId` names the product the host is acting
+for — it is what the owner's allowlist is checked against when the handle is foreign. Both take the same
+`(keyHandle, context, ring)` so the alias in the proof matches `getRingVrfAlias`.
+
+```ts
+// The key handle names a slot in the owner's ring VRF domain. Select it from
+// `listRingVrfKeys` by declared ring and pass it through opaquely — never
+// hardcode another product's index.
+const keyHandle = ['peopl.dot', { tag: 'Index', value: 0 }];
+
+// [productId, suffix]. The suffix is the wire `Index(u32) | Raw([u8; 32])` selector
+// (RFC 0022): `Index` for a plain index, `Raw` for a raw 32-byte index. It
+// expands to the same 32-byte value as a product account's derivation index.
+const context = ['product.dot', { tag: 'Index', value: 0 }];
+
+const alias = await currentSession.getRingVrfAlias('caller.dot', keyHandle, context, ring);
 
-const proof = await currentSession.createRingVrfProof('caller.dot', context, ring, new Uint8Array([0x48, 0x69]));
+const proof = await currentSession.createRingVrfProof(
+  'caller.dot',
+  keyHandle,
+  context,
+  ring,
+  new Uint8Array([0x48, 0x69]),
+);
 proof.match(
   ({ proof, contextualAlias, ringIndex, ringRevision }) =>
     console.log('proof at ring', ringIndex, 'revision', ringRevision),
-  // failures decode to a structured `RingVrfError` (RingNotFound / NotMember / Rejected / Unknown)
+  // failures decode to a structured `CreateProofErr` — RingNotFound / NotMember /
+  // KeyNotRegistered / KeyNotInRing / NotAllowlisted / Rejected / Unknown
   error => console.error('proof failed:', error),
 );
+
+// `ringVrfSign` signs with the member key itself instead of proving membership
+// anonymously. No context and no ring — nothing for either to scope — and the
+// result is verified against the member public key, so it is linkable to every
+// other use of that key.
+const signature = await currentSession.ringVrfSign('caller.dot', keyHandle, new Uint8Array([0x48, 0x69]));
 ```
 
+Producing a proof or a signature with a **foreign** key handle is gated on the key's owning product having allowlisted
+the caller in its manifest, and there is deliberately no user-prompt fallback: `message` is opaque, so consenting to it
+is not meaningful consent, and only the owner is positioned to evaluate the risk. Reading an alias authorizes nothing
+and stays on the ordinary grant-or-prompt path.
+
 ## Product subtree public keys
 
-Product accounts live at `//product//{productId}/{index}` (RFC 0022). The
-product junction is **hard**, so the user's root public key alone no longer
-determines product account public keys — the host asks the paired device for the
-product-subtree public key once, then soft-derives account public keys locally
-from it.
+Product accounts live at `//product//{productId}/{index}` (RFC 0022). The product junction is **hard**, so the user's
+root public key alone no longer determines product account public keys — the host asks the paired device for the
+product-subtree public key once, then soft-derives account public keys locally from it.
 
 ```ts
 const subtreeKey = await currentSession.getProductSubtree('product.dot');
@@ -270,15 +301,21 @@ subtreeKey.match(
 );
 ```
 
-The request is consent-free — the response carries no secret material. Only
-`AutoSigning` does: its payload is now the product-subtree secret key alone
-(`productRootPrivateKey`, 64-byte expanded sr25519 secret), which exposes exactly
-that product's subtree. The former `productDerivationSecret` is gone.
+The request is consent-free — the response carries no secret material. Only `AutoSigning` does: its payload is the
+product-subtree secret key (`productRootPrivateKey`, 64-byte expanded sr25519 secret), which exposes exactly that
+product's subtree, plus `ringVrfDomainEntropy` (RFC-0024) — the entropy of the `//{productId}` node of the disjoint ring
+VRF tree, which lets the host derive the member secret of a **registered** key locally. The former
+`productDerivationSecret` is gone.
+
+Bundling the entropy widens the grant: "sign transactions without prompting me" and "produce personhood proofs offline"
+become one decision. And because derivation from the entropy is unconditional arithmetic, the registry is what
+distinguishes a meaningful index from a meaningless one — a host MUST NOT derive a member secret for a
+`(product, index)` pair absent from its registry.
 
 ## Identity lookups
 
-`papp.identity` resolves on-chain identity data (lite / full username, credibility, slots)
-for arbitrary account ids. Pass an `0x`-prefixed account id (32-byte hex).
+`papp.identity` resolves on-chain identity data (lite / full username, credibility, chat encryption key) for arbitrary
+account ids. Pass an `0x`-prefixed account id (32-byte hex).
 
 ```ts
 const lookup = async (accountId: string) => {
@@ -296,34 +333,51 @@ const lookup = async (accountId: string) => {
 await papp.identity.getIdentities([accountIdA, accountIdB]);
 ```
 
-A paired `UserSession` also exposes `getIdentity()` as a shortcut that looks up the identity
-of its own user identity account — no account id to pass:
+A paired `UserSession` also exposes `getIdentity()` as a shortcut that looks up the identity of its own user identity
+account — no account id to pass:
 
 ```ts
 const identity = await session.getIdentity(); // Result<Identity | null, Error>
 ```
 
+`Identity` is:
+
+```ts
+type Identity = {
+  accountId: string;
+  fullUsername: string | null;
+  liteUsername: string;
+  credibility: { type: 'Lite' } | { type: 'Person'; alias: `0x${string}`; lastUpdate: string | null };
+  /** 32-byte X25519 chat encryption key as hex, unwrapped from the 65-byte
+   *  RFC-0004 container; null for a keypair type this SDK does not implement. */
+  identifierKey: `0x${string}` | null;
+};
+```
+
+`lastUpdate` and `identifierKey` are both nullable — the chain record can carry neither a readable timestamp nor a key
+this SDK can use, and neither case is an error.
+
+This package owns the `Resources.Consumers` reader for the monorepo. `host-chat` reads through it rather than querying
+the chain itself; `createIdentityRpcAdapter` is exported for that, alongside the `Identity` and `Credibility` types.
+
 ## V2 SSO handshake
 
-V2 is a redesign of the SSO pairing flow that supports the same user identity across
-multiple devices. The host generates a stable device keypair locally, emits a
-`VersionedHandshakeProposal::V2` via QR/deeplink, and an authorising peer (e.g. the user's
-existing Polkadot App) responds over the Statement Store with the user identity keys signed
-to authorise this device. Subsequent devices belonging to the same user reuse the same
-identity, so contacts, chats, and roster events are shared between them.
+V2 is a redesign of the SSO pairing flow that supports the same user identity across multiple devices. The host
+generates a stable device keypair locally, emits a `VersionedHandshakeProposal::V2` via QR/deeplink, and an authorising
+peer (e.g. the user's existing Polkadot App) responds over the Statement Store with the user identity keys signed to
+authorise this device. Subsequent devices belonging to the same user reuse the same identity, so contacts, chats, and
+roster events are shared between them.
 
-V2 is **not interoperable with V1**: a V1-only peer can't decode a V2 proposal QR and vice
-versa. Hosts that want to support both should branch on which protocol the peer advertises.
+V2 is **not interoperable with V1**: a V1-only peer can't decode a V2 proposal QR and vice versa. Hosts that want to
+support both should branch on which protocol the peer advertises.
 
 ### The flow
 
 1. The host builds a pairing deeplink from its device keypair and shows it as a QR code.
-2. The authorising device scans it and posts its response to the Statement Store: first a
-   `Pending` acknowledgement, then either `Success` — carrying the user's identity keys,
-   signed to authorise this device — or `Failed`.
+2. The authorising device scans it and posts its response to the Statement Store: first a `Pending` acknowledgement,
+   then either `Success` — carrying the user's identity keys, signed to authorise this device — or `Failed`.
 3. The host polls the pairing topic, decrypts and verifies each response, and drives a
-   `Submitted → Pending → Success | Failed` state machine. On `Success` it persists the
-   user identity.
+   `Submitted → Pending → Success | Failed` state machine. On `Success` it persists the user identity.
 
 ### Building and rendering the QR
 
@@ -333,7 +387,7 @@ import { buildPairingDeeplink } from '@novasamatech/host-papp';
 const deeplink = buildPairingDeeplink(
   {
     statementAccountPublicKey: device.statementAccountPublicKey, // sr25519 device pubkey, 32 bytes
-    encryptionPublicKey: device.encryptionPublicKey,             // P-256 device pubkey, 65 bytes uncompressed
+    encryptionPublicKey: device.encryptionPublicKey, // P-256 device pubkey, 65 bytes uncompressed
   },
   {
     hostName: 'My Host App',
@@ -396,9 +450,9 @@ pairing.abort();
 
 ### Surviving reloads / proper logout
 
-The chain holds the most recent statement on the pairing topic indefinitely, so on cold
-start the service will see the previous Success and replay it. To distinguish a stale
-replay from a fresh re-pair, callers can pass byte-level dedupe state:
+The chain holds the most recent statement on the pairing topic indefinitely, so on cold start the service will see the
+previous Success and replay it. To distinguish a stale replay from a fresh re-pair, callers can pass byte-level dedupe
+state:
 
 ```ts
 const pairing = startPairingV2({
@@ -410,14 +464,13 @@ const pairing = startPairingV2({
 });
 ```
 
-The service skips any incoming statement whose bytes match `initialProcessedDataHex`. PApp
-re-encrypts every Success with a fresh ephemeral key + AES-GCM nonce, so a genuine re-pair
-always produces different bytes and passes the dedupe.
+The service skips any incoming statement whose bytes match `initialProcessedDataHex`. PApp re-encrypts every Success
+with a fresh ephemeral key + AES-GCM nonce, so a genuine re-pair always produces different bytes and passes the dedupe.
 
 ## Reading allowances
 
-Each `UserSession` can read its own persisted allowance slot-account key for a given
-product and resource. The session id is implicit — you only pass the product and resource:
+Each `UserSession` can read its own persisted allowance slot-account key for a given product and resource. The session
+id is implicit — you only pass the product and resource:
 
 ```ts
 const session = papp.sessions.sessions.read().at(0);

package/dist/identity/identifierKey.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `Resources.Consumers.identifier_key` — a peer's chat encryption key as the chain
+ * records it (CHAT-RFC-0004 §4).
+ *
+ * The 65-byte width predates X25519: it is what an uncompressed P-256 point occupied,
+ * and it stayed when the curve changed. Only the keypair type and the key width moved
+ * (0x04 + 64 → 0x00 + 32), so the field is still `SizedHex<65>` in runtime metadata.
+ *
+ * Padding is carried as a field because the RFC requires readers to ignore it rather
+ * than validate it. Decoding throws on a keypair type this SDK does not implement;
+ * `decodeRawIdentity` maps that to `null`.
+ */
+export declare const IdentifierKey: import("scale-ts").Codec<{
+    tag: "X25519";
+    value: {
+        key: Uint8Array<ArrayBufferLike>;
+        padding: Uint8Array<ArrayBufferLike>;
+    };
+}>;

package/dist/identity/identifierKey.js

@@ -0,0 +1,17 @@
+import { Bytes, Enum } from '@novasamatech/scale';
+import { Struct } from 'scale-ts';
+/**
+ * `Resources.Consumers.identifier_key` — a peer's chat encryption key as the chain
+ * records it (CHAT-RFC-0004 §4).
+ *
+ * The 65-byte width predates X25519: it is what an uncompressed P-256 point occupied,
+ * and it stayed when the curve changed. Only the keypair type and the key width moved
+ * (0x04 + 64 → 0x00 + 32), so the field is still `SizedHex<65>` in runtime metadata.
+ *
+ * Padding is carried as a field because the RFC requires readers to ignore it rather
+ * than validate it. Decoding throws on a keypair type this SDK does not implement;
+ * `decodeRawIdentity` maps that to `null`.
+ */
+export const IdentifierKey = Enum({
+    X25519: Struct({ key: Bytes(32), padding: Bytes(32) }),
+});

package/dist/identity/impl.js

@@ -1,15 +1,20 @@
-import { Result, ResultAsync, err, ok, okAsync } from 'neverthrow';
+import { ResultAsync, okAsync } from 'neverthrow';
 import { defer, distinctUntilChanged, filter, finalize, map, merge, shareReplay, takeUntil, tap, timer } from 'rxjs';
-import { toError } from '../helpers/utils.js';
 const WATCH_IDENTITY_INITIAL_TIMEOUT_MS = 15_000;
 function getCacheKey(accountId) {
     return `identity_${accountId}`;
 }
+/**
+ * An older-shape record reads as absent so the caller refetches — `getIdentity` only goes
+ * to chain on a `null` hit. Extend whenever `Identity` grows a field.
+ */
+const REQUIRED_FIELDS = ['accountId', 'fullUsername', 'liteUsername', 'credibility', 'identifierKey'];
 function parseIdentity(raw) {
     if (!raw)
         return null;
     try {
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        return REQUIRED_FIELDS.every(field => field in parsed) ? parsed : null;
     }
     catch {
         return null;
@@ -28,7 +33,7 @@ function readCachedIdentity(storage, accountId) {
     return defer(() => storage.read(getCacheKey(accountId)).match(parseIdentity, () => null));
 }
 export function createIdentityRepository({ adapter, storage, initialEmissionTimeoutMs = WATCH_IDENTITY_INITIAL_TIMEOUT_MS, }) {
-    const cachedRequester = createCachedIdentityRequester(storage, getCacheKey);
+    const cachedRequester = createCachedIdentityRequester(storage);
     // Per-account de-dup: concurrent watchIdentity(acc) calls share one chain
     // subscription via the shared stream built below. The entry clears itself —
     // see the `finalize` in `buildWatch` — so the map can't accumulate dead
@@ -81,25 +86,15 @@ export function createIdentityRepository({ adapter, storage, initialEmissionTime
         },
     };
 }
-function createCachedIdentityRequester(storage, getKey) {
+function createCachedIdentityRequester(storage) {
     function readSingleCacheRecord(accountId) {
-        return storage.read(getKey(accountId)).andThen(raw => {
-            if (!raw) {
-                return ok(null);
-            }
-            try {
-                return ok(JSON.parse(raw));
-            }
-            catch (e) {
-                return err(toError(e));
-            }
-        });
+        return storage.read(getCacheKey(accountId)).map(parseIdentity);
     }
     function writeSingleCacheRecord(accountId, identity) {
         if (identity === null) {
             return okAsync(undefined);
         }
-        return storage.write(getKey(accountId), JSON.stringify(identity));
+        return storage.write(getCacheKey(accountId), JSON.stringify(identity));
     }
     function readCache(accounts) {
         if (accounts.length === 0) {

package/dist/identity/index.d.ts

@@ -0,0 +1,2 @@
+export type { Credibility, Identity } from './types.js';
+export { createIdentityRpcAdapter } from './rpcAdapter.js';

package/dist/identity/index.js

@@ -0,0 +1 @@
+export { createIdentityRpcAdapter } from './rpcAdapter.js';

package/dist/identity/rpcAdapter.d.ts

@@ -1,3 +1,7 @@
 import type { LazyClient } from '@novasamatech/statement-store';
-import type { IdentityAdapter } from './types.js';
+import type { People_liteQueries } from '../../.papi/descriptors/dist/index.js';
+import type { Identity, IdentityAdapter } from './types.js';
+type RawConsumers = NonNullable<People_liteQueries['Resources']['Consumers']['Value']>;
+export declare function decodeRawIdentity(accountId: string, raw: RawConsumers | undefined, textDecoder: TextDecoder): Identity | null;
 export declare function createIdentityRpcAdapter(lazyClient: LazyClient): IdentityAdapter;
+export {};

package/dist/identity/rpcAdapter.js

@@ -1,9 +1,11 @@
-import { errAsync, fromPromise, ok } from 'neverthrow';
+import { toHex } from '@novasamatech/scale';
+import { Result, errAsync, fromPromise, ok } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
 import { defer, map, throwError } from 'rxjs';
 import { toError } from '../helpers/utils.js';
 import { zipWith } from '../helpers/zipWith.js';
-function decodeRawIdentity(accountId, raw, textDecoder) {
+import { IdentifierKey } from './identifierKey.js';
+export function decodeRawIdentity(accountId, raw, textDecoder) {
     if (!raw)
         return null;
     const credibility = raw.credibility.type === 'Lite'
@@ -11,13 +13,17 @@ function decodeRawIdentity(accountId, raw, textDecoder) {
         : {
             type: 'Person',
             alias: raw.credibility.value.alias,
-            lastUpdate: raw.credibility.value.last_update.toString(),
+            lastUpdate: raw.credibility.value.last_update?.toString() ?? null,
         };
     return {
         accountId,
         fullUsername: raw.full_username ? textDecoder.decode(raw.full_username) : null,
         liteUsername: textDecoder.decode(raw.lite_username),
         credibility,
+        // A keypair type we can't encrypt to is a normal condition, not a fault.
+        identifierKey: Result.fromThrowable(IdentifierKey.dec)(raw.identifier_key)
+            .map(({ value }) => toHex(value.key))
+            .unwrapOr(null),
     };
 }
 export function createIdentityRpcAdapter(lazyClient) {

package/dist/identity/types.d.ts

@@ -5,13 +5,21 @@ export type Credibility = {
 } | {
     type: 'Person';
     alias: `0x${string}`;
-    lastUpdate: string;
+    /** `null` when the chain record carries no readable timestamp. */
+    lastUpdate: string | null;
 };
 export type Identity = {
     accountId: string;
     fullUsername: string | null;
     liteUsername: string;
     credibility: Credibility;
+    /**
+     * The account's 32-byte X25519 chat encryption key, unwrapped from its RFC-0004
+     * container. `null` for a keypair type this SDK does not implement.
+     *
+     * Hex, not `Uint8Array`: `Identity` is JSON round-tripped through the storage cache.
+     */
+    identifierKey: `0x${string}` | null;
 };
 export type IdentityAdapter = {
     readIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;

package/dist/index.d.ts

@@ -9,9 +9,12 @@ export { AllowanceError } from './sso/allowance/index.js';
 export type { AllowanceResourceKind } from './sso/allowance/index.js';
 export type { UserSession } from './sso/sessionManager/userSession.js';
 export type { StoredUserSession } from './sso/userSessionRepository.js';
-export type { Identity } from './identity/types.js';
+export type { Credibility, Identity, IdentityAdapter, IdentityRepository } from './identity/types.js';
+export { createIdentityRepository } from './identity/impl.js';
+export { createIdentityRpcAdapter } from './identity/rpcAdapter.js';
 export type { SignRawLegacyRequest, SignRawLegacyResponse, SigningPayloadRequest, SigningPayloadResponse, SigningRawRequest, SigningRequest, } from './sso/sessionManager/scale/signing.js';
-export type { RingVrfAliasRequest, RingVrfAliasResponse, RingVrfProofRequest, RingVrfProofResponse, } from './sso/sessionManager/scale/ringVrf.js';
+export type { RingVrfAliasRequest, RingVrfAliasResponse, RingVrfProofRequest, RingVrfProofResponse, RingVrfSignRequest, RingVrfSignResponse, } from './sso/sessionManager/scale/ringVrf.js';
+export type { ListRingVrfKeysRequest, ListRingVrfKeysResponse, RegisterRingVrfKeyRequest, RegisterRingVrfKeyResponse, } from './sso/sessionManager/scale/ringVrfKeys.js';
 export type { SignVrfErr, SignVrfRequest, SignVrfResponse } from './sso/sessionManager/scale/signVrf.js';
 export type { CreateTransactionLegacyRequest, CreateTransactionRequest, CreateTransactionResponse, } from './sso/sessionManager/scale/createTransaction.js';
 export type { ProductSubtreeRequest, ProductSubtreeResponse } from './sso/sessionManager/scale/productSubtree.js';

package/dist/index.js

@@ -1,3 +1,5 @@
 export { SS_PASEO_STABLE_STAGE_ENDPOINTS, SS_PREVIEW_STAGE_ENDPOINTS, SS_STABLE_STAGE_ENDPOINTS } from './constants.js';
 export { createPappAdapter } from './papp.js';
 export { AllowanceError } from './sso/allowance/index.js';
+export { createIdentityRepository } from './identity/impl.js';
+export { createIdentityRpcAdapter } from './identity/rpcAdapter.js';