@novasamatech/host-papp 0.9.0 → 0.9.2

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,15 +215,15 @@ 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
 
-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`.
+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`.
 
 ```ts
 // [productId, suffix]. The suffix is the wire `Index(u32) | Raw([u8; 32])` selector
@@ -255,11 +248,9 @@ proof.match(
 
 ## 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 +261,14 @@ 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 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.
 
 ## 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 +286,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 +340,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 +403,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 +417,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,7 +9,9 @@ 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 { SignVrfErr, SignVrfRequest, SignVrfResponse } from './sso/sessionManager/scale/signVrf.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';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -11,6 +11,10 @@
   "keywords": [
     "polkadot"
   ],
+  "scripts": {
+    "papi:fix": "node ../../scripts/fix-papi-descriptors.mjs .papi/descriptors/dist",
+    "papi:update": "papi update && npm run papi:fix"
+  },
   "main": "dist/index.js",
   "exports": {
     "./package.json": "./package.json",
@@ -34,10 +38,10 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.9.0",
-    "@novasamatech/scale": "0.9.0",
-    "@novasamatech/statement-store": "0.9.0",
-    "@novasamatech/storage-adapter": "0.9.0",
+    "@novasamatech/host-api": "0.9.2",
+    "@novasamatech/scale": "0.9.2",
+    "@novasamatech/statement-store": "0.9.2",
+    "@novasamatech/storage-adapter": "0.9.2",
     "@polkadot-api/utils": "^0.4.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.31",
     "nanoevents": "10.0.0",