@novasamatech/host-papp 0.5.0-17 → 0.5.0-19

package/dist/modules/transport/transport.d.ts

@@ -1,42 +0,0 @@
-import type { Statement } from '@polkadot-api/sdk-statement';
-import type { ResultAsync } from 'neverthrow';
-import type { Codec } from 'scale-ts';
-import type { StatementAdapter } from '../../adapters/statement/types.js';
-import type { Callback } from '../../types.js';
-import type { SsSecret } from '../crypto.js';
-import type { Account } from '../session/types.js';
-import type { TransportError } from './codec.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): {
-    subscribeSession(sessionId: Uint8Array, callback: Callback<Statement[]>): VoidFunction;
-    subscribe<T>({ ownAccount, peerAccount, codec, }: {
-        ownAccount: Account;
-        peerAccount: Account;
-        codec: Codec<T>;
-    }, callback: Callback<Message<T>[]>): VoidFunction;
-    handleRequest<T>(params: {
-        ownAccount: Account;
-        peerAccount: Account;
-        codec: Codec<T>;
-    }, callback: Callback<RequestMessage<T>>): VoidFunction;
-    submitRequest({ ownAccount, peerAccount, secret }: {
-        ownAccount: Account;
-        peerAccount: Account;
-        secret: SsSecret;
-    }, message: Uint8Array): ResultAsync<void, Error>;
-};
-export {};

package/dist/modules/transport/transport.js

@@ -1,66 +0,0 @@
-import { Result, fromThrowable, ok } from 'neverthrow';
-import { nonNullable, toError } from '../../helpers/utils.js';
-import { decrypt } from '../crypto.js';
-import { createRequestChannel, createSessionId } from '../session/helpers.js';
-import { createStatement } from '../statementStore.js';
-import { StatementData } from './codec.js';
-const decryptResults = fromThrowable(decrypt, toError);
-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,
-                },
-            ];
-    }
-}
-export function createTransport({ adapter }) {
-    const transport = {
-        subscribeSession(sessionId, callback) {
-            return adapter.subscribeStatements([sessionId], callback);
-        },
-        subscribe({ ownAccount, peerAccount, codec, }, callback) {
-            const sessionId = createSessionId(peerAccount.publicKey, peerAccount, ownAccount);
-            const statementDataCodec = StatementData(codec);
-            return adapter.subscribeStatements([sessionId], statements => {
-                Result.combine(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);
-                    }
-                });
-            });
-        },
-        handleRequest(params, callback) {
-            return transport.subscribe(params, messages => {
-                messages.filter(m => m.type === 'request').forEach(callback);
-            });
-        },
-        submitRequest({ ownAccount, peerAccount, secret }, message) {
-            const sessionId = createSessionId(peerAccount.publicKey, ownAccount, peerAccount);
-            return createStatement(secret, {
-                channel: createRequestChannel(sessionId),
-                priority: 0,
-                topics: [sessionId],
-                data: message,
-            }).andThen(adapter.submitStatement);
-        },
-    };
-    return transport;
-}

package/dist/modules/user.d.ts

@@ -1,67 +0,0 @@
-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 './crypto.js';
-import type { UserSession } from './userStore.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 createUserModule({ appId, metadata, statements, storage }: Params): {
-    authStatus: {
-        read(): AuthentificationStatus;
-        write(value: AuthentificationStatus): void;
-        reset(): void;
-        subscribe(fn: (value: AuthentificationStatus) => void): import("nanoevents").Unsubscribe;
-    };
-    storage: {
-        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>>;
-    };
-    authenticate(): Promise<Result<UserSession | null>>;
-    abortAuthentication(): void;
-};
-export {};

package/dist/modules/user.js

@@ -1,188 +0,0 @@
-import { toHex } from '@polkadot-api/utils';
-import { Bytes, Enum, Tuple, str } from 'scale-ts';
-import { err, fromPromise, ok, seq } from '../helpers/result.js';
-import { isAbortError, toError } from '../helpers/utils.js';
-import { ENCR_SECRET_SEED_SIZE, EncrPubKey, SS_SECRET_SEED_SIZE, SsPubKey, createEncrSecret, createRandomSeed, createSharedSecret, createSsSecret, createSymmetricKey, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from './crypto.js';
-import { createSecretStorage } from './secretStorage.js';
-import { createSession } from './statementStore.js';
-import { createSyncStorage } from './syncStorage.js';
-import { createUserStore } from './userStore.js';
-// codecs
-export const HandshakeData = Enum({
-    V1: Tuple(SsPubKey, EncrPubKey, str),
-});
-export const HandshakeResponsePayload = Enum({
-    // [encrypted, tmp_key]
-    V1: Tuple(Bytes(), Bytes(65)),
-});
-export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));
-export function createUserModule({ appId, metadata, statements, storage }) {
-    const userStorage = createUserStore(appId, storage);
-    const secretStorage = createSecretStorage(appId, storage);
-    const authStatus = createSyncStorage({ step: 'none' });
-    let signInPromise = null;
-    let abort = null;
-    async function handshake(signal) {
-        authStatus.write({ step: 'initial' });
-        const secrets = await getSecretKeys(appId, secretStorage);
-        return secrets.andThenPromise(async ({ ssPublicKey, encrPublicKey, encrSecret }) => {
-            const handshakeTopic = createHandshakeTopic({ encrPublicKey, ssPublicKey });
-            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata });
-            authStatus.write({ step: 'pairing', payload: createDeeplink(handshakePayload) });
-            const statementStoreResponse = fromPromise(waitForStatements(statements, handshakeTopic, signal, (statements, resolve) => {
-                for (const statement of [...statements].reverse()) {
-                    if (!statement.data)
-                        continue;
-                    const { sessionTopic, accountId } = retrieveSessionTopic({
-                        payload: statement.data.asBytes(),
-                        encrSecret,
-                        ssPublicKey,
-                    });
-                    resolve({ sessionTopic, accountId: toHex(accountId) });
-                    break;
-                }
-            }), toError);
-            return statementStoreResponse
-                .then(x => x.andThenPromise(userStorage.createUserSession))
-                .then(async (result) => result
-                .map(user => {
-                authStatus.write({ step: 'finished', user });
-                return user;
-            })
-                .orElse(e => {
-                const error = toError(e);
-                if (isAbortError(error)) {
-                    authStatus.write({ step: 'none' });
-                    return ok(null);
-                }
-                else {
-                    authStatus.write({ step: 'error', message: error.message });
-                    return err(error);
-                }
-            }));
-        });
-    }
-    const userModule = {
-        authStatus,
-        storage: userStorage,
-        async authenticate() {
-            if (signInPromise) {
-                return signInPromise;
-            }
-            abort = new AbortController();
-            signInPromise = handshake(abort.signal);
-            return signInPromise;
-        },
-        abortAuthentication() {
-            if (abort) {
-                signInPromise = null;
-                authStatus.reset();
-                abort.abort();
-            }
-        },
-    };
-    return userModule;
-}
-function createHandshakeTopic({ encrPublicKey, ssPublicKey, }) {
-    return khash(ssPublicKey, mergeBytes(encrPublicKey, stringToBytes('topic')));
-}
-function createHandshakePayloadV1({ encrPublicKey, ssPublicKey, metadata, }) {
-    return HandshakeData.enc({
-        tag: 'V1',
-        value: [ssPublicKey, encrPublicKey, metadata],
-    });
-}
-function parseHandshakePayload(payload) {
-    const decoded = HandshakeResponsePayload.dec(payload);
-    switch (decoded.tag) {
-        case 'V1':
-            return {
-                encrypted: decoded.value[0],
-                tmpKey: decoded.value[1],
-            };
-        default:
-            throw new Error('Unsupported handshake payload version');
-    }
-}
-function retrieveSessionTopic({ payload, encrSecret, ssPublicKey, }) {
-    const { encrypted, tmpKey } = parseHandshakePayload(payload);
-    const symmetricKey = createSymmetricKey(createSharedSecret(encrSecret, tmpKey));
-    const decrypted = decrypt(symmetricKey, encrypted);
-    const [pappEncrPublicKey, userPublicKey] = HandshakeResponseSensitiveData.dec(decrypted);
-    const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
-    const session = createSession({
-        sharedSecret: sharedSecret,
-        accountA: ssPublicKey,
-        accountB: pappEncrPublicKey,
-    });
-    return {
-        accountId: userPublicKey,
-        sessionTopic: session.a,
-    };
-}
-async function getSsKeys(appId, secretStorage) {
-    return (await secretStorage.readSsSecret())
-        .andThenPromise(async (ssSecret) => {
-        if (ssSecret) {
-            return ok(ssSecret);
-        }
-        const seed = createRandomSeed(appId, SS_SECRET_SEED_SIZE);
-        const newSsSecret = createSsSecret(seed);
-        const write = await secretStorage.writeSsSecret(newSsSecret);
-        return write.map(() => newSsSecret);
-    })
-        .then(x => x.map(ssSecret => ({
-        ssSecret: ssSecret,
-        ssPublicKey: getSsPub(ssSecret),
-    })));
-}
-async function getEncrKeys(appId, secretStorage) {
-    return (await secretStorage.readEncrSecret())
-        .andThenPromise(async (encrSecret) => {
-        if (encrSecret) {
-            return ok(encrSecret);
-        }
-        const seed = createRandomSeed(appId, ENCR_SECRET_SEED_SIZE);
-        const newEncrSecret = createEncrSecret(seed);
-        const write = await secretStorage.writeEncrSecret(newEncrSecret);
-        return write.map(() => newEncrSecret);
-    })
-        .then(x => x.map(encrSecret => ({
-        encrSecret,
-        encrPublicKey: getEncrPub(encrSecret),
-    })));
-}
-async function getSecretKeys(appId, secretStorage) {
-    return seq(await getSsKeys(appId, secretStorage), await getEncrKeys(appId, secretStorage)).map(([ss, encr]) => ({
-        ...ss,
-        ...encr,
-    }));
-}
-function createDeeplink(payload) {
-    return `polkadotapp://pair?handshake=${toHex(payload)}`;
-}
-function waitForStatements(transport, topic, abortSignal, callback) {
-    return new Promise((resolve, reject) => {
-        const unsubscribe = transport.subscribeStatements([topic], statements => {
-            if (abortSignal?.aborted) {
-                unsubscribe();
-                try {
-                    abortSignal.throwIfAborted();
-                }
-                catch (e) {
-                    reject(e);
-                }
-            }
-            try {
-                callback(statements, value => {
-                    unsubscribe();
-                    resolve(value);
-                });
-            }
-            catch (e) {
-                unsubscribe();
-                reject(e);
-            }
-        });
-    });
-}

package/dist/modules/userManager.d.ts

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

package/dist/modules/userManager.js

@@ -1,105 +0,0 @@
-import { err, ok, seq } from '../helpers/result.js';
-import { createSecretStorage } from './secretStorage.js';
-export const createUserManager = (appId, storage) => {
-    const secretStorage = createSecretStorage(appId, storage);
-    const usersStorage = createUserStorage(storage);
-    const selectedUserStorage = createSelectedUserStorage(storage);
-    const manager = {
-        async readSelectedUser() {
-            const selectedUser = await selectedUserStorage.read();
-            return selectedUser.andThenPromise(async (selectedUser) => {
-                if (selectedUser === null) {
-                    return ok(null);
-                }
-                const user = await manager.readUser(selectedUser);
-                return user.andThenPromise(async (user) => {
-                    if (user === null) {
-                        await selectedUserStorage.clear();
-                    }
-                    return ok(user);
-                });
-            });
-        },
-        async readUser(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.removeUser(accountId));
-            return user;
-        },
-        async createUser(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 removeUser(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/modules/userStorage.d.ts

@@ -1,19 +0,0 @@
-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 createUserStorage: (appId: string, storage: StorageAdapter) => {
-    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>>;
-    };
-};

package/dist/modules/userStorage.js

@@ -1,108 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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>>;
-};