@novasamatech/host-papp 0.7.2 → 0.7.3

package/README.md

@@ -4,8 +4,215 @@ 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:
+
+- 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.
+
 ## Installation
 
 ```shell
 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.
+
+```ts
+import { createPappAdapter } from '@novasamatech/host-papp';
+
+const papp = createPappAdapter({
+  // Stable identifier for your host app — must not change between releases,
+  // otherwise existing pairings will be lost.
+  appId: 'my-host-app',
+
+  // URL to a JSON document describing the host: { name: string, icon: string }.
+  // The icon should be a rasterized image at least 256x256 px.
+  metadata: 'https://my-host-app.example/papp-metadata.json',
+
+  // Optional environment metadata shown on the wallet's confirmation screen.
+  hostMetadata: {
+    hostVersion: '1.4.0',
+    osType: 'macOS',
+    osVersion: '15.4',
+  },
+});
+```
+
+`createPappAdapter` returns four 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.                   |
+
+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
+
+`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();
+
+result.match(
+  session => {
+    if (session) {
+      console.log('Paired with', session.remoteAccount.accountId);
+    } else {
+      console.log('Pairing aborted');
+    }
+  },
+  error => {
+    console.error('Pairing failed:', error);
+  },
+);
+```
+
+To cancel a running flow:
+
+```ts
+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.
+
+```ts
+import type { PairingStatus } from '@novasamatech/host-papp';
+
+const render = (status: PairingStatus) => {
+  switch (status.step) {
+    case 'none':
+    case 'initial':
+      return; // not started yet
+    case 'pairing':
+      // status.payload is a `polkadotapp://pair?handshake=…` deeplink —
+      // render it as a QR code or open it on mobile.
+      showDeeplink(status.payload);
+      return;
+    case 'pairingError':
+      showError(status.message);
+      return;
+    case 'finished':
+      showPairedAccount(status.session);
+      return;
+  }
+};
+
+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`.
+
+## 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.
+
+```ts
+import type { UserSession } from '@novasamatech/host-papp';
+
+let currentSession: UserSession | null = null;
+
+const unsubscribe = papp.sessions.sessions.subscribe(sessions => {
+  currentSession = sessions.at(0) ?? null;
+});
+
+// Initial value, in case a session was restored from storage on boot.
+currentSession = papp.sessions.sessions.read().at(0) ?? null;
+```
+
+Disconnecting notifies the wallet, removes local secrets, and triggers the subscription
+above.
+
+```ts
+const disconnect = async (session: UserSession) => {
+  const result = await papp.sessions.disconnect(session);
+  result.match(
+    () => console.log('Disconnected'),
+    error => console.error('Disconnect failed:', error),
+  );
+};
+```
+
+## Signing
+
+A `UserSession` exposes `signPayload` and `signRaw` for forwarding signing requests to the
+paired wallet.
+
+```ts
+const signed = await currentSession.signPayload({
+  address: '5G…', // SS58 address or 0x-prefixed account id
+  blockHash: '0x…',
+  blockNumber: '0x…',
+  era: '0x…',
+  genesisHash: '0x…',
+  method: '0x…',
+  nonce: '0x…',
+  specVersion: '0x…',
+  tip: '0x…',
+  transactionVersion: '0x…',
+  signedExtensions: ['CheckNonZeroSender', 'CheckSpecVersion' /* … */],
+  version: 4,
+  assetId: undefined,
+  metadataHash: undefined,
+  mode: undefined,
+  withSignedTransaction: undefined,
+});
+
+signed.match(
+  response => submitSignedExtrinsic(response),
+  error => console.error('Signing rejected:', error),
+);
+```
+
+`signRaw` follows the same pattern but takes either raw `Bytes` or a `Payload` string:
+
+```ts
+await currentSession.signRaw({
+  address: '5G…',
+  data: { tag: 'Payload', value: 'Login challenge: abc123' },
+});
+```
+
+## 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).
+
+```ts
+const lookup = async (accountId: string) => {
+  const result = await papp.identity.getIdentity(accountId);
+  result.match(
+    identity => {
+      if (!identity) return;
+      console.log(identity.liteUsername, identity.credibility);
+    },
+    error => console.error('Identity lookup failed:', error),
+  );
+};
+
+// Batch lookup
+await papp.identity.getIdentities([accountIdA, accountIdB]);
+```

package/dist/helpers/createAsyncTaskPool.d.ts

@@ -0,0 +1,28 @@
+import type { ResultAsync } from 'neverthrow';
+export declare const DEFAULT_POOL = "default";
+type Params = {
+    poolSize: number;
+    retryCount: number;
+    retryDelay: ((attempt: number) => number) | number;
+};
+type TaskParams = {
+    pool?: string;
+    signal?: AbortSignal;
+};
+/**
+ * Task manager with queues, retries and named pools.
+ */
+declare class AsyncTaskPool {
+    private config;
+    private events;
+    private queue;
+    private activeTasks;
+    constructor(config: Params);
+    call<T>(fn: () => ResultAsync<T, Error>, params?: TaskParams): ResultAsync<T, Error>;
+    settle(pool: string): Promise<void>;
+    private processPool;
+    private tryToSettlePool;
+    private retryDelay;
+}
+export declare const createAsyncTaskPool: (params: Params) => AsyncTaskPool;
+export {};

package/dist/helpers/createAsyncTaskPool.js

@@ -0,0 +1,115 @@
+import { createNanoEvents } from 'nanoevents';
+import { fromPromise } from 'neverthrow';
+import { promiseWithResolvers } from './promiseWithResolvers.js';
+import { nullable, toError } from './utils.js';
+export const DEFAULT_POOL = 'default';
+/**
+ * Task manager with queues, retries and named pools.
+ */
+class AsyncTaskPool {
+    config;
+    events = createNanoEvents();
+    queue = [];
+    activeTasks = [];
+    constructor(config) {
+        this.config = config;
+    }
+    call(fn, params) {
+        const { resolve, reject, promise } = promiseWithResolvers();
+        const task = {
+            fn,
+            pool: params?.pool ?? DEFAULT_POOL,
+            retry: 0,
+            resolve,
+            reject,
+            signal: params?.signal,
+        };
+        this.queue.push(task);
+        this.processPool(task.pool);
+        return fromPromise(promise, toError);
+    }
+    settle(pool) {
+        if (this.queue.length === 0 && this.activeTasks.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise(resolve => {
+            const handler = (done) => {
+                if (done === pool) {
+                    unsubscribe();
+                    resolve();
+                }
+            };
+            const unsubscribe = this.events.on('settled', handler);
+        });
+    }
+    processPool(pool) {
+        let task = null;
+        const activeTasks = this.activeTasks.filter(x => x.pool === pool);
+        // skip this iteration since task pool at full capacity
+        if (activeTasks.length >= this.config.poolSize) {
+            return;
+        }
+        // finding the next task
+        for (const [index, potentialTask] of this.queue.entries()) {
+            if (potentialTask.pool !== pool) {
+                continue;
+            }
+            task = potentialTask;
+            this.queue.splice(index, 1);
+            break;
+        }
+        if (nullable(task)) {
+            return;
+        }
+        this.activeTasks.push(task);
+        const handleError = (task, error) => {
+            if (task.retry >= this.config.retryCount) {
+                task.reject(error);
+            }
+            else {
+                if (task.signal?.aborted) {
+                    task.reject(error);
+                    return;
+                }
+                const retryDelay = this.retryDelay(task);
+                task.retry++;
+                setTimeout(() => {
+                    this.queue.push(task);
+                    this.processPool(pool);
+                }, retryDelay);
+            }
+        };
+        const finish = (task) => {
+            this.activeTasks = this.activeTasks.filter(x => x !== task);
+            this.tryToSettlePool(pool);
+            this.processPool(pool);
+        };
+        try {
+            task
+                .fn()
+                .andTee(result => {
+                task.resolve(result);
+                finish(task);
+            })
+                .orTee(error => {
+                handleError(task, error);
+                finish(task);
+            });
+        }
+        catch (error) {
+            handleError(task, toError(error));
+            finish(task);
+        }
+    }
+    tryToSettlePool(pool) {
+        const activePoolTasks = this.activeTasks.find(x => x.pool === pool);
+        const queuedPoolTasks = this.queue.find(x => x.pool === pool);
+        if (nullable(activePoolTasks) && nullable(queuedPoolTasks)) {
+            this.events.emit('settled', pool);
+        }
+    }
+    retryDelay(task) {
+        return typeof this.config.retryDelay === 'function' ? this.config.retryDelay(task.retry) : this.config.retryDelay;
+    }
+}
+export const createAsyncTaskPool = (params) => new AsyncTaskPool(params);

package/dist/helpers/createAsyncTaskPool.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/createAsyncTaskPool.spec.js

@@ -0,0 +1,138 @@
+import { setTimeout } from 'node:timers/promises';
+import { err, fromPromise, ok, okAsync } from 'neverthrow';
+import { describe, expect, it, vi } from 'vitest';
+import { createAsyncTaskPool } from './createAsyncTaskPool.js';
+import { toError } from './utils.js';
+const delay = (ttl = 0) => setTimeout(ttl);
+describe('asyncTaskPool', () => {
+    it('should exec async task', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
+        const result = await pool.call(() => fromPromise(delay().then(() => 'test'), toError));
+        expect(result).toEqual(ok('test'));
+    });
+    it('should handle sync errors', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
+        const error = new Error('test');
+        const result = await pool.call(() => {
+            throw error;
+        });
+        expect(result).toEqual(err(error));
+    });
+    it('should handle async errors', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: () => 0 });
+        const error = new Error('test');
+        const result = await pool.call(() => fromPromise(Promise.reject(error), toError));
+        return expect(result).toEqual(err(error));
+    });
+    it('should handle queue', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 2, retryCount: 0, retryDelay: () => 0 });
+        const spy = vi.fn();
+        await Promise.all([pool.call(spy), pool.call(spy), pool.call(spy), pool.call(spy)]);
+        expect(spy).toBeCalledTimes(4);
+    });
+    it('should update pool in correct order', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 2, retryCount: 0, retryDelay: () => 0 });
+        const result = [];
+        const res = Promise.all([
+            pool.call(() => fromPromise(delay(800).then(() => result.push(1)), toError)),
+            pool.call(() => fromPromise(delay(100).then(() => result.push(2)), toError)),
+            pool.call(() => fromPromise(delay(500).then(() => result.push(3)), toError)),
+            pool.call(() => fromPromise(delay(100).then(() => result.push(4)), toError)),
+        ]);
+        await res;
+        expect(result).toEqual([2, 3, 4, 1]);
+    });
+    it('should retry', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 1, retryDelay: () => 0 });
+        let tries = 0;
+        const result = await pool.call(() => {
+            if (tries === 1) {
+                return okAsync('test');
+            }
+            tries++;
+            throw new Error();
+        });
+        expect(result).toEqual(ok('test'));
+    });
+    it('should throw on retry limit exceeding', async () => {
+        const spy = vi.fn(() => 0);
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 1, retryDelay: spy });
+        let tries = 0;
+        const result = await pool.call(() => {
+            if (tries === 2) {
+                return okAsync('test');
+            }
+            tries++;
+            throw new Error();
+        });
+        expect(spy).toBeCalledTimes(1);
+        expect(result).toEqual(err(new Error()));
+    });
+    it('should correctly calculate retry delay', async () => {
+        const spy = vi.fn((retry) => retry * 10);
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 2, retryDelay: spy });
+        let tries = 0;
+        await pool.call(() => {
+            if (tries === 2) {
+                return okAsync('test');
+            }
+            tries++;
+            throw new Error();
+        });
+        expect(spy).toHaveBeenCalledTimes(2);
+        expect(spy.mock.calls).toEqual([[0], [1]]);
+    });
+    it('should create multiple pools', async () => {
+        const spy = vi.fn();
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
+        const tasks = [
+            { delay: 600, value: 1, pool: '1' },
+            { delay: 400, value: 2, pool: '2' },
+            { delay: 100, value: 3, pool: '1' },
+            { delay: 0, value: 4, pool: '2' },
+        ];
+        const result = [];
+        for (const task of tasks) {
+            const call = pool.call(() => fromPromise(delay(task.delay).then(() => spy(task.value)), toError), { pool: task.pool });
+            result.push(call);
+        }
+        await Promise.all(result);
+        expect(spy).toHaveBeenCalledTimes(4);
+        expect(spy.mock.calls).toEqual([[2], [4], [1], [3]]);
+    }, 10000);
+    it('should settle all tasks', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
+        const tasks = [
+            { delay: 0, value: 1 },
+            { delay: 0, value: 2 },
+            { delay: 0, value: 3 },
+            { delay: 0, value: 4 },
+        ];
+        const result = [];
+        for (const task of tasks) {
+            pool.call(() => fromPromise(delay(task.delay), toError).andTee(() => result.push(task.value)), { pool: 'test' });
+        }
+        await pool.settle('test');
+        expect(result).toEqual([1, 2, 3, 4]);
+    });
+    it('should settle tasks that was created by chain reaction', async () => {
+        const pool = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
+        const tasks = [
+            { delay: 10, value: 1 },
+            { delay: 10, value: 2 },
+            { delay: 10, value: 3 },
+            { delay: 10, value: 4 },
+        ];
+        const result = [];
+        for (const task of tasks) {
+            pool
+                .call(() => fromPromise(delay(task.delay), toError), { pool: 'test' })
+                .then(() => {
+                result.push(task.value);
+                pool.call(() => fromPromise(delay(task.delay).then(() => result.push(task.value + 10)), toError), { pool: 'test' });
+            });
+        }
+        await pool.settle('test');
+        expect(result).toEqual([1, 2, 3, 4, 11, 12, 13, 14]);
+    });
+});

package/dist/helpers/promiseWithResolvers.d.ts

@@ -0,0 +1,6 @@
+export type PromiseWithResolvers<T> = {
+    promise: PromiseLike<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export declare const promiseWithResolvers: <T>() => PromiseWithResolvers<T>;

package/dist/helpers/promiseWithResolvers.js

@@ -0,0 +1,10 @@
+export const promiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    // @ts-expect-error before assign
+    return { promise, resolve, reject };
+};

package/dist/helpers/utils.d.ts

@@ -1 +1,9 @@
 export declare function toError(err: unknown): Error;
+/**
+ * Type guard that checks is value nullable
+ *
+ * @param value Value to be checked
+ *
+ * @returns {Boolean}
+ */
+export declare function nullable(value: unknown): value is null | undefined;

package/dist/helpers/utils.js

@@ -7,3 +7,13 @@ export function toError(err) {
     }
     return new Error('Unknown error occurred.');
 }
+/**
+ * Type guard that checks is value nullable
+ *
+ * @param value Value to be checked
+ *
+ * @returns {Boolean}
+ */
+export function nullable(value) {
+    return value === null || value === undefined;
+}

package/dist/sso/sessionManager/userSession.js

@@ -3,11 +3,13 @@ import { enumValue, toHex } from '@novasamatech/scale';
 import { createSession } from '@novasamatech/statement-store';
 import { fieldListView } from '@novasamatech/storage-adapter';
 import { nanoid } from 'nanoid';
-import { ResultAsync, err, errAsync, ok, okAsync } from 'neverthrow';
+import { ResultAsync, err, ok, okAsync } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
+import { createAsyncTaskPool } from '../../helpers/createAsyncTaskPool.js';
 import { RemoteMessageCodec } from './scale/remoteMessage.js';
 export function createUserSession({ userSession, statementStore, encryption, storage, prover, }) {
     const accountId = AccountId();
+    const requestQueue = createAsyncTaskPool({ poolSize: 1, retryCount: 0, retryDelay: 0 });
     const session = createSession({
         localAccount: userSession.localAccount,
         remoteAccount: userSession.remoteAccount,
@@ -22,7 +24,7 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         to: JSON.stringify,
     });
     function toAccountId(address) {
-        // already account id
+        // already an account id
         if (address.startsWith('0x') && address.length === 64 + 2) {
             return address;
         }
@@ -36,74 +38,92 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         localAccount: userSession.localAccount,
         remoteAccount: userSession.remoteAccount,
         signPayload(payload) {
-            const accountId = toAccountId(payload.address);
-            if (accountId !== toHex(userSession.remoteAccount.accountId)) {
-                return errAsync(new Error(`Invalid address, got ${payload.address}`));
-            }
-            const messageId = nanoid();
-            const request = session.request(RemoteMessageCodec, {
-                messageId,
-                data: enumValue('v1', enumValue('SignRequest', enumValue('Payload', {
-                    ...payload,
-                    address: toAddress(accountId),
-                }))),
-            });
-            const responseFilter = (message) => {
-                if (message.data.tag === 'v1' &&
-                    message.data.value.tag === 'SignResponse' &&
-                    message.data.value.value.respondingTo === messageId) {
-                    return message.data.value.value.payload;
-                }
-            };
-            return request
-                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                .andThen(message => {
-                if (message.success) {
-                    return ok(message.value);
-                }
-                else {
-                    return err(new Error(message.value));
-                }
+            return requestQueue.call(() => {
+                const messageId = nanoid();
+                const request = session.request(RemoteMessageCodec, {
+                    messageId,
+                    data: enumValue('v1', enumValue('SignRequest', enumValue('Payload', {
+                        ...payload,
+                        address: toAddress(toAccountId(payload.address)),
+                    }))),
+                });
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'SignResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.payload;
+                    }
+                };
+                return request
+                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                    .andThen(message => {
+                    if (message.success) {
+                        return ok(message.value);
+                    }
+                    else {
+                        return err(new Error(message.value));
+                    }
+                });
             });
         },
         signRaw(payload) {
-            const accountId = toAccountId(payload.address);
-            if (accountId !== toHex(userSession.remoteAccount.accountId)) {
-                return errAsync(new Error(`Invalid address, got ${payload.address}`));
-            }
-            const messageId = nanoid();
-            const request = session.request(RemoteMessageCodec, {
-                messageId,
-                data: enumValue('v1', enumValue('SignRequest', enumValue('Raw', {
-                    ...payload,
-                    address: toAddress(accountId),
-                }))),
-            });
-            const responseFilter = (message) => {
-                if (message.data.tag === 'v1' &&
-                    message.data.value.tag === 'SignResponse' &&
-                    message.data.value.value.respondingTo === messageId) {
-                    return message.data.value.value.payload;
-                }
-            };
-            return request
-                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                .andThen(message => {
-                if (message.success) {
-                    return ok(message.value);
-                }
-                else {
-                    return err(new Error(message.value));
-                }
+            return requestQueue.call(() => {
+                const messageId = nanoid();
+                const request = session.request(RemoteMessageCodec, {
+                    messageId,
+                    data: enumValue('v1', enumValue('SignRequest', enumValue('Raw', {
+                        ...payload,
+                        address: toAddress(toAccountId(payload.address)),
+                    }))),
+                });
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'SignResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.payload;
+                    }
+                };
+                return request
+                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                    .andThen(message => {
+                    if (message.success) {
+                        return ok(message.value);
+                    }
+                    else {
+                        return err(new Error(message.value));
+                    }
+                });
             });
         },
         sendDisconnectMessage() {
-            return session
+            return requestQueue.call(() => session
                 .submitRequestMessage(RemoteMessageCodec, {
                 messageId: nanoid(),
                 data: enumValue('v1', enumValue('Disconnected', undefined)),
             })
-                .map(() => undefined);
+                .map(() => undefined));
+        },
+        getRingVrfAlias(productAccountId, productId) {
+            return requestQueue.call(() => {
+                const messageId = nanoid();
+                const request = session.request(RemoteMessageCodec, {
+                    messageId,
+                    data: enumValue('v1', enumValue('RingVrfAliasRequest', {
+                        productAccountId,
+                        productId,
+                    })),
+                });
+                const responseFilter = (message) => {
+                    if (message.data.tag === 'v1' &&
+                        message.data.value.tag === 'RingVrfAliasResponse' &&
+                        message.data.value.value.respondingTo === messageId) {
+                        return message.data.value.value.payload;
+                    }
+                };
+                return request
+                    .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                    .andThen(result => (result.success ? ok(result.value) : err(new Error(result.value))));
+            });
         },
         subscribe(callback) {
             return session.subscribe(RemoteMessageCodec, messages => {
@@ -134,26 +154,6 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                 });
             });
         },
-        getRingVrfAlias(productAccountId, productId) {
-            const messageId = nanoid();
-            const request = session.request(RemoteMessageCodec, {
-                messageId,
-                data: enumValue('v1', enumValue('RingVrfAliasRequest', {
-                    productAccountId,
-                    productId,
-                })),
-            });
-            const responseFilter = (message) => {
-                if (message.data.tag === 'v1' &&
-                    message.data.value.tag === 'RingVrfAliasResponse' &&
-                    message.data.value.value.respondingTo === messageId) {
-                    return message.data.value.value.payload;
-                }
-            };
-            return request
-                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
-                .andThen(result => (result.success ? ok(result.value) : err(new Error(result.value))));
-        },
         dispose() {
             return session.dispose();
         },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -29,11 +29,11 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
-    "@novasamatech/host-api": "0.7.2",
-    "@novasamatech/scale": "0.7.2",
-    "@novasamatech/statement-store": "0.7.2",
-    "@novasamatech/storage-adapter": "0.7.2",
-    "@polkadot-labs/hdkd-helpers": "^0.0.29",
+    "@novasamatech/host-api": "0.7.3",
+    "@novasamatech/scale": "0.7.3",
+    "@novasamatech/statement-store": "0.7.3",
+    "@novasamatech/storage-adapter": "0.7.3",
+    "@polkadot-labs/hdkd-helpers": "^0.0.30",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0",