@novasamatech/host-papp 0.5.0-6 → 0.5.0-8

package/dist/components/auth/types.d.ts

@@ -0,0 +1,15 @@
+import type { UserSession } from '../user/userSessionStorage.js';
+export type AuthentificationStatus = {
+    step: 'none';
+} | {
+    step: 'initial';
+} | {
+    step: 'pairing';
+    payload: string;
+} | {
+    step: 'error';
+    message: string;
+} | {
+    step: 'finished';
+    session: UserSession;
+};

package/dist/components/auth/types.js

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

package/dist/components/session.d.ts

@@ -0,0 +1,34 @@
+import type { CodecType } from 'scale-ts';
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Account } from '../modules/statementStore.js';
+import type { Transport } from '../modules/transport/transport.js';
+import type { Callback } from '../types.js';
+export type Session<T> = {
+    subscribe(callback: Callback<T>): VoidFunction;
+    dispose(): void;
+};
+export declare const HostRemoteMessageCodec: import("scale-ts").Codec<{
+    messageId: string;
+    data: {
+        tag: "v1";
+        value: {
+            tag: "Disconnected";
+            value: undefined;
+        } | {
+            tag: "SigningRequest";
+            value: Uint8Array<ArrayBufferLike>;
+        } | {
+            tag: "SigningResponse";
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    };
+}>;
+export type SSOSession = Session<CodecType<typeof HostRemoteMessageCodec>>;
+type SsoSessionParams = {
+    ownAccount: Account;
+    peerAccount: Account;
+    transport: Transport;
+    storage: StorageAdapter;
+};
+export declare function createSSOSession({ ownAccount, peerAccount, transport, storage }: SsoSessionParams): SSOSession;
+export {};

package/dist/components/session.js

@@ -0,0 +1,54 @@
+import { fromThrowable, okAsync } from 'neverthrow';
+import { toHex } from 'polkadot-api/utils';
+import { Bytes, Enum, Struct, _void, str } from 'scale-ts';
+import { toError } from '../helpers/utils.js';
+import { createSessionId } from '../modules/statementStore.js';
+import { storageListView } from '../modules/storageView.js';
+// SSO
+export const HostRemoteMessageCodec = Struct({
+    messageId: str,
+    data: Enum({
+        v1: Enum({
+            Disconnected: _void,
+            // TODO implement
+            SigningRequest: Bytes(),
+            // TODO implement
+            SigningResponse: Bytes(),
+        }),
+    }),
+});
+export function createSSOSession({ ownAccount, peerAccount, transport, storage }) {
+    const peerSession = createSessionId(peerAccount, ownAccount);
+    const processedStorage = storageListView({
+        key: `Session_Processed_${toHex(peerSession)}`,
+        storage,
+        initial: [],
+        from: JSON.parse,
+        to: JSON.stringify,
+    });
+    let subscriptions = [];
+    return {
+        subscribe(callback) {
+            const fn = fromThrowable(callback, toError);
+            const unsub = transport.handleRequest(ownAccount, peerAccount, HostRemoteMessageCodec, async (message) => {
+                processedStorage.read().andThen(processed => {
+                    if (processed.includes(message.requestId)) {
+                        return okAsync();
+                    }
+                    return fn(message.data).asyncAndThen(() => processedStorage.mutate(p => p.concat(message.requestId)));
+                });
+            });
+            subscriptions.push(unsub);
+            return () => {
+                unsub();
+                subscriptions = subscriptions.filter(x => x !== unsub);
+            };
+        },
+        dispose() {
+            for (const unsub of subscriptions) {
+                unsub();
+            }
+            subscriptions = [];
+        },
+    };
+}

package/dist/components/transport.d.ts

@@ -0,0 +1,27 @@
+import type { Statement } from '@polkadot-api/sdk-statement';
+import type { Codec } from 'scale-ts';
+import type { StatementAdapter } from '../adapters/statement/types.js';
+import type { Account } from '../modules/statementStore.js';
+import type { TransportError } from '../structs.js';
+import type { Callback } from '../types.js';
+export type Transport = ReturnType<typeof createTransport>;
+type RequestMessage<T> = {
+    type: 'request';
+    requestId: string;
+    data: T;
+};
+type ResponseMessage = {
+    type: 'response';
+    requestId: string;
+    code: TransportError;
+};
+type Message<T> = RequestMessage<T> | ResponseMessage;
+type Params = {
+    adapter: StatementAdapter;
+};
+export declare function createTransport({ adapter }: Params): {
+    subscribe<T>(ownAccount: Account, peerAccount: Account, codec: Codec<T>, callback: Callback<Message<T>[]>): VoidFunction;
+    subscribeSession(sessionId: Uint8Array, callback: Callback<Statement[]>): VoidFunction;
+    handleRequest<T>(ownAccount: Account, peerAccount: Account, codec: Codec<T>, callback: Callback<RequestMessage<T>>): VoidFunction;
+};
+export {};

package/dist/components/transport.js

@@ -0,0 +1,57 @@
+import { fromThrowable, ok } from 'neverthrow';
+import { seq } from '../helpers/result.js';
+import { nonNullable, toError } from '../helpers/utils.js';
+import { decrypt } from '../modules/crypto.js';
+import { createSessionId } from '../modules/statementStore.js';
+import { StatementData } from '../structs.js';
+const decryptResults = fromThrowable(decrypt, toError);
+export function createTransport({ adapter }) {
+    function mapMessage(statementData) {
+        switch (statementData.tag) {
+            case 'request':
+                return statementData.value.data.map((data, index) => ({
+                    type: 'request',
+                    requestId: `${statementData.value.requestId}-${index.toString()}`,
+                    data,
+                }));
+            case 'response':
+                return [
+                    {
+                        type: 'response',
+                        requestId: statementData.value.requestId,
+                        code: statementData.value.responseCode,
+                    },
+                ];
+        }
+    }
+    const transport = {
+        subscribe(ownAccount, peerAccount, codec, callback) {
+            const sessionId = createSessionId(peerAccount, ownAccount);
+            const statementDataCodec = StatementData(codec);
+            return adapter.subscribeStatements([sessionId], statements => {
+                seq(...statements.map(statement => {
+                    if (!statement.data)
+                        return ok(null);
+                    return decryptResults(peerAccount.publicKey, statement.data.asBytes())
+                        .map(statementDataCodec.dec)
+                        .orElse(() => ok(null));
+                }))
+                    .map(messages => messages.filter(nonNullable).flatMap(mapMessage))
+                    .andTee(messages => {
+                    if (messages.length > 0) {
+                        callback(messages);
+                    }
+                });
+            });
+        },
+        subscribeSession(sessionId, callback) {
+            return adapter.subscribeStatements([sessionId], callback);
+        },
+        handleRequest(ownAccount, peerAccount, codec, callback) {
+            return transport.subscribe(ownAccount, peerAccount, codec, messages => {
+                messages.filter(m => m.type === 'request').forEach(callback);
+            });
+        },
+    };
+    return transport;
+}

package/dist/components/user/codec.d.ts

@@ -0,0 +1,16 @@
+export declare const HostRemoteMessageCodec: import("scale-ts").Codec<{
+    messageId: string;
+    data: {
+        tag: "v1";
+        value: {
+            tag: "Disconnected";
+            value: undefined;
+        } | {
+            tag: "SigningRequest";
+            value: Uint8Array<ArrayBufferLike>;
+        } | {
+            tag: "SigningResponse";
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    };
+}>;

package/dist/components/user/codec.js

@@ -0,0 +1,13 @@
+import { Bytes, Enum, Struct, _void, str } from 'scale-ts';
+export const HostRemoteMessageCodec = Struct({
+    messageId: str,
+    data: Enum({
+        v1: Enum({
+            Disconnected: _void,
+            // TODO implement
+            SigningRequest: Bytes(),
+            // TODO implement
+            SigningResponse: Bytes(),
+        }),
+    }),
+});

package/dist/components/user/index.d.ts

@@ -0,0 +1,22 @@
+import type { StorageAdapter } from '../../adapters/storage/types.js';
+import type { Transport } from '../../modules/transport/transport.js';
+import type { UserSession, UserSessionStorage } from './userSessionStorage.js';
+export type UserSessionsComponent = ReturnType<typeof createUserSessionsComponent>;
+type Params = {
+    transport: Transport;
+    storage: StorageAdapter;
+    userSessionStorage: UserSessionStorage;
+};
+export declare function createUserSessionsComponent({ userSessionStorage, storage, transport }: Params): {
+    sessions: {
+        add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+        mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+        read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+        write(value: UserSession[]): import("neverthrow").ResultAsync<null, Error> | import("neverthrow").ResultAsync<UserSession[], Error>;
+        clear(): import("neverthrow").ResultAsync<void, Error>;
+        subscribe(fn: (value: UserSession[]) => void): () => void;
+    };
+    disconnect: (session: UserSession) => import("neverthrow").ResultAsync<undefined, Error>;
+    destroy(): void;
+};
+export {};

package/dist/components/user/index.js

@@ -0,0 +1,58 @@
+import { okAsync } from 'neverthrow';
+import { createSSOSession } from './ssoSession.js';
+export function createUserSessionsComponent({ userSessionStorage, storage, transport }) {
+    let unsubStatements = null;
+    const disconnect = (session) => {
+        return userSessionStorage.mutate(sessions => sessions.filter(s => s.id !== session.id)).map(() => undefined);
+    };
+    const unsubSessions = userSessionStorage.subscribe(userSessions => {
+        if (unsubStatements) {
+            unsubStatements();
+            unsubStatements = null;
+        }
+        const ssoSessions = [];
+        for (const userSession of userSessions) {
+            const session = createSSOSession({
+                ownAccount: userSession.host,
+                peerAccount: userSession.peer,
+                storage,
+                transport,
+            });
+            session.subscribe(message => {
+                switch (message.data.tag) {
+                    case 'v1': {
+                        switch (message.data.value.tag) {
+                            case 'Disconnected':
+                                return disconnect(userSession).map(() => true);
+                        }
+                    }
+                }
+                return okAsync(false);
+            });
+            ssoSessions.push(session);
+        }
+        unsubStatements = () => {
+            for (const session of ssoSessions) {
+                session.dispose();
+            }
+        };
+    });
+    return {
+        sessions: userSessionStorage,
+        disconnect,
+        destroy() {
+            unsubSessions();
+        },
+    };
+}
+// function createDisconnectMessage(ssSecret: SsSecret, topic: Uint8Array) {
+//   const statement = createStatement(ssSecret, {
+//     priority: 0,
+//     channel: createRequestChannel(topic),
+//     topics: [topic],
+//     data: SSOMessage.enc({
+//       tag: 'Disconnected',
+//       value: undefined,
+//     }),
+//   });
+// }

package/dist/components/user/ssoMessageStream.d.ts

@@ -0,0 +1,10 @@
+export declare const SSOMessage: import("scale-ts").Codec<{
+    tag: "Disconnected";
+    value: undefined;
+} | {
+    tag: "SigningRequest";
+    value: Uint8Array<ArrayBufferLike>;
+} | {
+    tag: "SigningResponse";
+    value: Uint8Array<ArrayBufferLike>;
+}>;

package/dist/components/user/ssoMessageStream.js

@@ -0,0 +1,8 @@
+import { Bytes, Enum, _void } from 'scale-ts';
+export const SSOMessage = Enum({
+    Disconnected: _void,
+    // TODO implement
+    SigningRequest: Bytes(),
+    // TODO implement
+    SigningResponse: Bytes(),
+});

package/dist/components/user/ssoSession.d.ts

@@ -0,0 +1,5 @@
+import type { SessionParams } from '../../modules/session/session.js';
+import type { Session } from '../../modules/session/types.js';
+import { HostRemoteMessageCodec } from './codec.js';
+export type SsoSession = Session<typeof HostRemoteMessageCodec>;
+export declare function createSSOSession({ ownAccount, peerAccount, transport, storage, }: Omit<SessionParams<any>, 'codec'>): SsoSession;

package/dist/components/user/ssoSession.js

@@ -0,0 +1,5 @@
+import { createSession } from '../../modules/session/session.js';
+import { HostRemoteMessageCodec } from './codec.js';
+export function createSSOSession({ ownAccount, peerAccount, transport, storage, }) {
+    return createSession({ ownAccount, peerAccount, transport, storage, codec: HostRemoteMessageCodec });
+}

package/dist/components/user/storage.d.ts

@@ -0,0 +1,27 @@
+import type { ResultAsync } from 'neverthrow';
+import type { StorageAdapter } from '../../adapters/storage/types.js';
+import type { Callback } from '../../types.js';
+import type { UserSecrets, UserSession } from './types.js';
+export type UserStorage = ReturnType<typeof createUserStorage>;
+type Params = {
+    appId: string;
+    storage: StorageAdapter;
+};
+export declare const createUserStorage: ({ appId, storage }: Params) => {
+    sessions: {
+        read(accountId: string): ResultAsync<UserSession | null, Error>;
+        readSelectedUser(): ResultAsync<UserSession | null, Error>;
+        subscribeSessions(callback: Callback<UserSession[]>): () => void;
+        create(user: UserSession, secrets: UserSecrets): ResultAsync<UserSession, Error>;
+        remove(accountId: string): ResultAsync<void, Error>;
+        readSecrets(accountId: string): ResultAsync<UserSecrets | null, Error>;
+    };
+    accounts: {
+        read(): ResultAsync<string[], Error>;
+        subscribe(callback: (accounts: string[]) => void): () => void;
+        readSelectedUser(): ResultAsync<string | null, Error>;
+        subscribeSelectedAccount(callback: (accountId: string | null) => void): VoidFunction;
+        select(accountId: string): ResultAsync<undefined, Error>;
+    };
+};
+export {};

package/dist/components/user/storage.js

@@ -0,0 +1,143 @@
+import { okAsync } from 'neverthrow';
+import { callbackRaceResolver } from '../../helpers/callbackRaceResolver.js';
+import { seq, seqAsync } from '../../helpers/result.js';
+import { nonNullable } from '../../helpers/utils.js';
+import { createSecretStorage } from '../../modules/secretStorage.js';
+import { storageListView, storageView } from '../../modules/storageView.js';
+export const createUserStorage = ({ appId, storage }) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createSessionsStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const store = {
+        sessions: {
+            read(accountId) {
+                const sessions = seqAsync(secretStorage.readSessionId(accountId, 'A'), secretStorage.readSessionId(accountId, 'B'));
+                return sessions.map(([sessionIdA, sessionIdB]) => {
+                    if (nonNullable(sessionIdA) && nonNullable(sessionIdB)) {
+                        return { accountId, sessionIdA, sessionIdB };
+                    }
+                    return null;
+                });
+            },
+            readSelectedUser() {
+                return store.accounts.readSelectedUser().andThen(selectedUser => {
+                    if (selectedUser === null) {
+                        return okAsync(null);
+                    }
+                    return store.sessions.read(selectedUser).andThen(user => {
+                        if (user === null) {
+                            return selectedUserStorage.clear().map(() => user);
+                        }
+                        return okAsync(user);
+                    });
+                });
+            },
+            subscribeSessions(callback) {
+                const resolver = callbackRaceResolver(callback, async (accounts) => {
+                    if (accounts.length === 0) {
+                        return [];
+                    }
+                    return seq(...(await Promise.all(accounts.map(store.sessions.read))))
+                        .map(sessions => sessions.filter(nonNullable))
+                        .unwrapOr([]);
+                });
+                return store.accounts.subscribe(resolver);
+            },
+            create(user, secrets) {
+                return usersStorage
+                    .add(user.accountId)
+                    .andThen(() => seqAsync(secretStorage.writeSsSecret(user.accountId, secrets.ss), secretStorage.writeEncrSecret(user.accountId, secrets.encr), secretStorage.writeSharedSecret(user.accountId, secrets.sharedSecret), secretStorage.writeSessionId(user.accountId, 'A', user.sessionIdA), secretStorage.writeSessionId(user.accountId, 'B', user.sessionIdB), selectedUserStorage.write(user.accountId)).map(() => user));
+            },
+            remove(accountId) {
+                const op = seqAsync(secretStorage.clearSsSecret(accountId), secretStorage.clearEncrSecret(accountId), secretStorage.clearSharedSecret(accountId), secretStorage.clearSessionId(accountId, 'A'), secretStorage.clearSessionId(accountId, 'B'), usersStorage.remove(accountId), selectedUserStorage.read());
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                return op.andThen(([_1, _2, _3, _4, _5, users, selectedUser]) => {
+                    if (selectedUser === accountId) {
+                        const nextSelectedUser = users.at(0);
+                        if (nextSelectedUser) {
+                            return selectedUserStorage.write(nextSelectedUser).map(() => undefined);
+                        }
+                        else {
+                            return selectedUserStorage.clear();
+                        }
+                    }
+                    return okAsync(undefined);
+                });
+            },
+            readSecrets(accountId) {
+                const op = seqAsync(secretStorage.readSsSecret(accountId), secretStorage.readEncrSecret(accountId), secretStorage.readSharedSecret(accountId));
+                return op.map(([ss, encr, sharedSecret]) => {
+                    if (nonNullable(ss) && nonNullable(encr) && nonNullable(sharedSecret)) {
+                        return { ss, encr, sharedSecret };
+                    }
+                    return null;
+                });
+            },
+        },
+        accounts: {
+            read() {
+                return usersStorage.read();
+            },
+            subscribe(callback) {
+                return usersStorage.subscribe(callback);
+            },
+            readSelectedUser() {
+                return selectedUserStorage.read();
+            },
+            subscribeSelectedAccount(callback) {
+                return selectedUserStorage.subscribe(callback);
+            },
+            select(accountId) {
+                return selectedUserStorage.write(accountId).map(() => undefined);
+            },
+        },
+    };
+    return store;
+};
+const createSessionsStorage = (storage) => {
+    const view = storageListView({
+        storage,
+        key: 'Users',
+        autosync: true,
+        initial: [],
+        from: x => JSON.parse(x),
+        to: x => JSON.stringify(x),
+    });
+    return {
+        read() {
+            return view.read();
+        },
+        add(user) {
+            return view.mutate(users => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                return users.concat(user);
+            });
+        },
+        remove(user) {
+            return view.mutate(users => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return newUsers;
+                }
+                return users;
+            });
+        },
+        subscribe(callback) {
+            return view.subscribe(v => {
+                callback(v ?? []);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    return storageView({
+        storage,
+        key: 'SelectedUser',
+        autosync: true,
+        initial: null,
+        from: x => x,
+        to: x => x,
+    });
+};

package/dist/components/user/types.d.ts

@@ -0,0 +1,6 @@
+import type { EncrSecret, SharedSecret, SsSecret } from '../../modules/crypto.js';
+export type UserSecrets = {
+    sharedSecret: SharedSecret;
+    encr: EncrSecret;
+    ss: SsSecret;
+};

package/dist/components/user/types.js

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

package/dist/components/user/userSessionStorage.d.ts

@@ -0,0 +1,20 @@
+import type { StorageAdapter } from '../../adapters/storage/types.js';
+import type { Account } from '../../modules/session/types.js';
+export type UserSessionStorage = ReturnType<typeof createUserSessionStorage>;
+export type UserSession = {
+    id: string;
+    host: Account;
+    peer: Account;
+};
+type Params = {
+    storage: StorageAdapter;
+};
+export declare const createUserSessionStorage: ({ storage }: Params) => {
+    add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+    mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+    read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+    write(value: UserSession[]): import("neverthrow").ResultAsync<null, Error> | import("neverthrow").ResultAsync<UserSession[], Error>;
+    clear(): import("neverthrow").ResultAsync<void, Error>;
+    subscribe(fn: (value: UserSession[]) => void): () => void;
+};
+export {};

package/dist/components/user/userSessionStorage.js

@@ -0,0 +1,24 @@
+import { fromHex, toHex } from 'polkadot-api/utils';
+import { Bytes, Option, Struct, Vector, str } from 'scale-ts';
+import { storageListView } from '../../modules/storageView.js';
+const accountCodec = Struct({
+    accountId: Bytes(),
+    publicKey: Bytes(),
+    pin: Option(str),
+});
+const userSessionCodec = Struct({
+    id: str,
+    host: accountCodec,
+    peer: accountCodec,
+});
+const userSessionsCodec = Vector(userSessionCodec);
+export const createUserSessionStorage = ({ storage }) => {
+    return storageListView({
+        storage,
+        key: 'Sessions',
+        autosync: true,
+        initial: [],
+        from: x => userSessionsCodec.dec(fromHex(x)),
+        to: x => toHex(userSessionsCodec.enc(x)),
+    });
+};

package/dist/components/user.d.ts

@@ -0,0 +1,74 @@
+import type { StatementAdapter } from '../adapters/statement/types.js';
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Result } from '../helpers/result.js';
+import type { EncrPublicKey, SsPublicKey } from '../modules/crypto.js';
+import type { UserSession } from '../modules/userStorage.js';
+export declare const HandshakeData: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [SsPublicKey, EncrPublicKey, string];
+}>;
+export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>];
+}>;
+export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>]>;
+export type AuthentificationStatus = {
+    step: 'none';
+} | {
+    step: 'initial';
+} | {
+    step: 'pairing';
+    payload: string;
+} | {
+    step: 'error';
+    message: string;
+} | {
+    step: 'finished';
+    user: UserSession;
+};
+type Params = {
+    /**
+     * Host app Id.
+     * CAUTION! This value should be stable.
+     */
+    appId: string;
+    /**
+     * URL for additional metadata that will be displayed during pairing process.
+     * Content of provided json shound be
+     * ```ts
+     * interface Metadata {
+     *   name: string;
+     *   icon: string; // url for icon. Icon should be a rasterized image with min size 256x256 px.
+     * }
+     * ```
+     */
+    metadata: string;
+    statements: StatementAdapter;
+    storage: StorageAdapter;
+};
+export declare function createUserComponent({ appId, metadata, statements, storage }: Params): {
+    authStatus: {
+        touched(): boolean;
+        read(): AuthentificationStatus;
+        write(value: AuthentificationStatus): AuthentificationStatus;
+        reset(): void;
+        subscribe(fn: (value: AuthentificationStatus) => void): () => void;
+        onFirstSubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
+        onLastUnsubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
+    };
+    storage: {
+        sessions: {
+            read(accountId: string): Promise<Result<UserSession | null>>;
+            readSelectedUser(): Promise<Result<UserSession | null>>;
+            create(user: UserSession): Promise<Result<UserSession>>;
+            remove(accountId: string): Promise<Result<void, Error>>;
+        };
+        accounts: {
+            read(): Promise<Result<string[], Error>>;
+            select(accountId: string): Promise<Result<string | null, Error> | Result<null, Error>>;
+        };
+    };
+    authenticate(): Promise<Result<UserSession | null>>;
+    abortAuthentication(): void;
+};
+export {};