@novasamatech/host-papp 0.5.0-5 → 0.5.0-7

package/dist/modules/userStorage.js

@@ -0,0 +1,108 @@
+import { err, ok, seq } from '../helpers/result.js';
+import { createSecretStorage } from './secretStorage.js';
+import { reactiveStorage } from './syncStorage.js';
+export const createUserStorage = (appId, storage) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createSessionsStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const store = {
+        sessions: {
+            async read(accountId) {
+                const user = await secretStorage.readSessionTopic(accountId).then(existingSessionTopic => existingSessionTopic.map(sessionTopic => {
+                    return sessionTopic ? { sessionTopic, accountId } : null;
+                }));
+                await user
+                    .andThen(v => (v ? ok(undefined) : err('User not found')))
+                    .orElsePromise(() => store.sessions.remove(accountId));
+                return user;
+            },
+            async readSelectedUser() {
+                const selectedUser = await selectedUserStorage.read();
+                return selectedUser.andThenPromise(async (selectedUser) => {
+                    if (selectedUser === null) {
+                        return ok(null);
+                    }
+                    const user = await store.sessions.read(selectedUser);
+                    return user.andThenPromise(async (user) => {
+                        if (user === null) {
+                            await selectedUserStorage.clear();
+                        }
+                        return ok(user);
+                    });
+                });
+            },
+            async create(user) {
+                return (await usersStorage.add(user.accountId)).andThenPromise(async () => seq(await selectedUserStorage.write(user.accountId), await secretStorage.writeSessionTopic(user.accountId, user.sessionTopic)).map(() => user));
+            },
+            async remove(accountId) {
+                const op = seq(await selectedUserStorage.read(), await usersStorage.remove(accountId));
+                return op.andThenPromise(async ([selectedUser, users]) => {
+                    if (selectedUser === accountId) {
+                        const nextSelectedUser = users.at(0);
+                        if (nextSelectedUser) {
+                            await selectedUserStorage.write(nextSelectedUser);
+                        }
+                        else {
+                            await selectedUserStorage.clear();
+                        }
+                    }
+                    return secretStorage.clearSessionTopic(accountId);
+                });
+            },
+        },
+        accounts: {
+            async read() {
+                return usersStorage.read();
+            },
+            async select(accountId) {
+                return selectedUserStorage.write(accountId);
+            },
+        },
+    };
+    return store;
+};
+const createSessionsStorage = (storage) => {
+    const reactive = reactiveStorage({
+        storage,
+        key: 'Users',
+        autosync: true,
+        initial: [],
+        from: x => JSON.parse(x),
+        to: x => JSON.stringify(x),
+    });
+    return {
+        async read() {
+            return reactive.read();
+        },
+        async add(user) {
+            const users = await reactive.read();
+            return users.andThenPromise(async (users) => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                const newUsers = users.concat(user);
+                return reactive.write(newUsers).then(x => x.map(() => newUsers));
+            });
+        },
+        async remove(user) {
+            const users = await reactive.read();
+            return users.andThenPromise(async (users) => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return reactive.write(newUsers).then(x => x.map(() => newUsers));
+                }
+                return ok([]);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    return reactiveStorage({
+        storage,
+        key: 'SelectedUser',
+        autosync: true,
+        initial: null,
+        from: x => x,
+        to: x => x,
+    });
+};

package/dist/modules/userStore.d.ts

@@ -0,0 +1,15 @@
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Result } from '../helpers/result.js';
+import type { SessionTopic } from '../types.js';
+export type UserSession = {
+    accountId: string;
+    sessionTopic: SessionTopic;
+};
+export declare const createUserStore: (appId: string, storage: StorageAdapter) => {
+    readSelectedUserSession(): Promise<Result<UserSession | null>>;
+    readUserSession(accountId: string): Promise<Result<UserSession | null>>;
+    createUserSession(user: UserSession): Promise<Result<UserSession>>;
+    removeUserSession(accountId: string): Promise<Result<void, Error>>;
+    readAccounts(): Promise<Result<string[], Error>>;
+    selectAccount(accountId: string): Promise<Result<void, Error>>;
+};

package/dist/modules/userStore.js

@@ -0,0 +1,105 @@
+import { err, ok, seq } from '../helpers/result.js';
+import { createSecretStorage } from './secretStorage.js';
+export const createUserStore = (appId, storage) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createUserStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const manager = {
+        async readSelectedUserSession() {
+            const selectedUser = await selectedUserStorage.read();
+            return selectedUser.andThenPromise(async (selectedUser) => {
+                if (selectedUser === null) {
+                    return ok(null);
+                }
+                const user = await manager.readUserSession(selectedUser);
+                return user.andThenPromise(async (user) => {
+                    if (user === null) {
+                        await selectedUserStorage.clear();
+                    }
+                    return ok(user);
+                });
+            });
+        },
+        async readUserSession(accountId) {
+            const user = await secretStorage.readSessionTopic(accountId).then(existingSessionTopic => existingSessionTopic.map(sessionTopic => {
+                return sessionTopic ? { sessionTopic, accountId } : null;
+            }));
+            await user
+                .andThen(v => (v ? ok(undefined) : err('User not found')))
+                .orElsePromise(() => manager.removeUserSession(accountId));
+            return user;
+        },
+        async createUserSession(user) {
+            return (await usersStorage.add(user.accountId)).andThenPromise(async () => seq(await selectedUserStorage.write(user.accountId), await secretStorage.writeSessionTopic(user.accountId, user.sessionTopic)).map(() => user));
+        },
+        async removeUserSession(accountId) {
+            const op = seq(await selectedUserStorage.read(), await usersStorage.remove(accountId));
+            return op.andThenPromise(async ([selectedUser, users]) => {
+                if (selectedUser === accountId) {
+                    const nextSelectedUser = users.at(0);
+                    if (nextSelectedUser) {
+                        await selectedUserStorage.write(nextSelectedUser);
+                    }
+                    else {
+                        await selectedUserStorage.clear();
+                    }
+                }
+                return secretStorage.clearSessionTopic(accountId);
+            });
+        },
+        async readAccounts() {
+            return usersStorage.read();
+        },
+        async selectAccount(accountId) {
+            return selectedUserStorage.write(accountId);
+        },
+    };
+    return manager;
+};
+const createUserStorage = (storage) => {
+    const KEY = 'Users';
+    return {
+        async read() {
+            const users = await storage.read(KEY);
+            return users.map(users => {
+                return users === null ? [] : JSON.parse(users);
+            });
+        },
+        async add(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                const newUsers = users.concat(user);
+                return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+            });
+        },
+        async remove(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+                }
+                return ok([]);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    const KEY = 'SelectedUser';
+    return {
+        read() {
+            return storage.read(KEY);
+        },
+        write(accountId) {
+            return storage.write(KEY, accountId);
+        },
+        clear() {
+            return storage.clear(KEY);
+        },
+    };
+};

package/dist/papp.d.ts

@@ -1,14 +1,15 @@
+import type { ResultAsync } from 'neverthrow';
 import type { Identity, IdentityAdapter } from './adapters/identity/types.js';
 import type { StatementAdapter } from './adapters/statement/types.js';
 import type { StorageAdapter } from './adapters/storage/types.js';
-import type { SignInStatus } from './modules/signIn.js';
+import type { AuthComponent } from './components/auth/index.js';
+import type { UserSessionsComponent } from './components/user/index.js';
 export type PappAdapter = {
-    auth: {
-        signIn(): Promise<Identity | null>;
-        abortSignIn(): void;
-        getCurrentUser(): Promise<Identity | null>;
-        getSignInStatus(): SignInStatus;
-        onSignInStatusChange(callback: (status: SignInStatus) => void): VoidFunction;
+    sso: AuthComponent;
+    sessions: UserSessionsComponent;
+    identity: {
+        getIdentity(accountId: string): ResultAsync<Identity | null, Error>;
+        getIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
     };
 };
 type Adapters = {

package/dist/papp.js

@@ -3,8 +3,11 @@ import { createIdentityRpcAdapter } from './adapters/identity/rpc.js';
 import { createPapiLazyClient } from './adapters/lazyClient/papi.js';
 import { createPapiStatementAdapter } from './adapters/statement/rpc.js';
 import { createLocalStorageAdapter } from './adapters/storage/localStorage.js';
-import { SS_ENDPOINTS } from './constants.js';
-import { createSignInFlow } from './modules/signIn.js';
+import { createAuthComponent } from './components/auth/index.js';
+import { createUserSessionsComponent } from './components/user/index.js';
+import { createUserSessionStorage } from './components/user/userSessionStorage.js';
+import { SS_PROD_ENDPOINTS } from './constants.js';
+import { createTransport } from './modules/transport/transport.js';
 export function createPappAdapter({ appId, metadata, adapters }) {
     let statements;
     let identities;
@@ -15,40 +18,25 @@ export function createPappAdapter({ appId, metadata, adapters }) {
         storage = adapters.storage;
     }
     else {
-        const lazyPapiAdapter = createPapiLazyClient(getWsProvider(SS_ENDPOINTS));
+        const lazyPapiAdapter = createPapiLazyClient(getWsProvider(SS_PROD_ENDPOINTS));
         storage = createLocalStorageAdapter(appId);
         identities = createIdentityRpcAdapter(lazyPapiAdapter, storage);
         statements = createPapiStatementAdapter(lazyPapiAdapter);
     }
-    const signInFlow = createSignInFlow({ appId, metadata, statements, storage });
-    const papp = {
-        auth: {
-            signIn() {
-                return signInFlow.signIn().then(result => {
-                    if (result) {
-                        return identities.getIdentity(result.pappAccountId);
-                    }
-                    return null;
-                });
-            },
-            getCurrentUser() {
-                return signInFlow.getSignedUser().then(result => {
-                    if (result) {
-                        return identities.getIdentity(result.pappAccountId);
-                    }
-                    return null;
-                });
-            },
-            getSignInStatus() {
-                return signInFlow.getSignInStatus();
-            },
-            onSignInStatusChange(callback) {
-                return signInFlow.onStatusChange(callback);
-            },
-            abortSignIn() {
-                return signInFlow.abortSignIn();
-            },
+    const transport = createTransport({ adapter: statements });
+    const userSessionStorage = createUserSessionStorage({ storage });
+    const identityComponent = {
+        getIdentity(accountId) {
+            return identities.readIdentities([accountId]).map(map => map[accountId] ?? null);
+        },
+        getIdentities(accounts) {
+            return identities.readIdentities(accounts);
         },
     };
+    const papp = {
+        sso: createAuthComponent({ appId, metadata, transport, userSessionStorage }),
+        sessions: createUserSessionsComponent({ transport, storage, userSessionStorage }),
+        identity: identityComponent,
+    };
     return papp;
 }

package/dist/structs.d.ts

@@ -1,24 +1,24 @@
-type TransportError = 'decryptionFailed' | 'decodingFailed' | 'unknown';
-export declare const ResponseCode: import("scale-ts").Codec<TransportError>;
-export declare const RequestV1: import("scale-ts").Codec<{
+import type { Codec } from 'scale-ts';
+export type TransportError = 'decryptionFailed' | 'decodingFailed' | 'unknown';
+export declare const TransportErrorCodec: Codec<TransportError>;
+export declare const Request: <T>(data: Codec<T>) => Codec<{
     requestId: string;
-    data: Uint8Array<ArrayBufferLike>;
+    data: T[];
 }>;
-export declare const ResponseV1: import("scale-ts").Codec<{
+export declare const Response: Codec<{
     requestId: string;
     responseCode: TransportError;
 }>;
-export declare const StatementData: import("scale-ts").Codec<{
-    tag: "requestV1";
+export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+    tag: "request";
     value: {
         requestId: string;
-        data: Uint8Array<ArrayBufferLike>;
+        data: T[];
     };
 } | {
-    tag: "responseV1";
+    tag: "response";
     value: {
         requestId: string;
         responseCode: TransportError;
     };
 }>;
-export {};

package/dist/structs.js

@@ -1,12 +1,12 @@
-import { Bytes, Enum, Struct, enhanceCodec, str, u8 } from 'scale-ts';
-export const ResponseCode = enhanceCodec(u8, error => {
+import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
+export const TransportErrorCodec = enhanceCodec(u8, error => {
     switch (error) {
         case 'decryptionFailed':
             return 1;
         case 'decodingFailed':
             return 2;
         case 'unknown':
-            return -1;
+            return 255;
     }
 }, code => {
     switch (code) {
@@ -18,15 +18,19 @@ export const ResponseCode = enhanceCodec(u8, error => {
             return 'unknown';
     }
 });
-export const RequestV1 = Struct({
+export const Request = (data) => {
+    return Struct({
+        requestId: str,
+        data: Vector(data),
+    });
+};
+export const Response = Struct({
     requestId: str,
-    data: Bytes(),
-});
-export const ResponseV1 = Struct({
-    requestId: str,
-    responseCode: ResponseCode,
-});
-export const StatementData = Enum({
-    requestV1: RequestV1,
-    responseV1: ResponseV1,
+    responseCode: TransportErrorCodec,
 });
+export const StatementData = (data) => {
+    return Enum({
+        request: Request(data),
+        response: Response,
+    });
+};

package/dist/types.d.ts

@@ -2,5 +2,5 @@ declare const __brand: unique symbol;
 export type Branded<T, K extends string> = T & {
     [__brand]: K;
 };
-export type SessionTopic = Branded<Uint8Array, 'SessionTopic'>;
+export type Callback<T, R = unknown> = (value: T) => R;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.5.0-5",
+  "version": "0.5.0-7",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -24,14 +24,16 @@
     "README.md"
   ],
   "dependencies": {
-    "@polkadot-api/utils": "0.2.0",
-    "@polkadot-api/sdk-statement": "0.2.0",
-    "@scure/sr25519": "0.3.0",
+    "@polkadot-api/sdk-statement": "^0.2.0",
+    "@polkadot-api/substrate-bindings": "^0.16.5",
+    "@scure/sr25519": "1.0.0",
     "@noble/curves": "2.0.1",
     "@noble/hashes": "2.0.1",
-    "@noble/ciphers": "2.0.1",
-    "polkadot-api": "1.22.0",
+    "@noble/ciphers": "2.1.1",
+    "polkadot-api": "^1.23.1",
     "nanoevents": "9.1.0",
+    "nanoid": "5.1.6",
+    "neverthrow": "8.2.0",
     "scale-ts": "1.6.1"
   },
   "publishConfig": {