@novasamatech/host-papp 0.5.0-1 → 0.5.0-10

package/dist/modules/storageView.js

@@ -0,0 +1,51 @@
+import { okAsync } from 'neverthrow';
+import { nonNullable } from '../helpers/utils.js';
+import { createState } from './state.js';
+export function storageView({ storage, initial, key, from, to, autosync = true }) {
+    const state = createState(to(initial));
+    const enhancedStorage = {
+        read() {
+            return storage
+                .read(key)
+                .map(state.write)
+                .map(x => (nonNullable(x) ? from(x) : initial));
+        },
+        write(value) {
+            const data = to(value);
+            if (data !== null) {
+                return storage
+                    .write(key, data)
+                    .map(() => state.write(data))
+                    .map(() => value);
+            }
+            return okAsync(null);
+        },
+        clear() {
+            return storage.clear(key).map(() => state.reset());
+        },
+        subscribe(fn) {
+            return state.subscribe(x => fn(nonNullable(x) ? from(x) : initial));
+        },
+    };
+    if (autosync) {
+        enhancedStorage.read();
+    }
+    state.onFirstSubscribe(() => enhancedStorage.read());
+    return enhancedStorage;
+}
+export function storageListView(params) {
+    const view = storageView(params);
+    const listView = {
+        ...view,
+        add(value) {
+            return listView.mutate(list => list.concat(value)).map(() => value);
+        },
+        mutate(fn) {
+            return listView.read().andThen(list => {
+                const result = fn(list);
+                return listView.write(result).map(() => result);
+            });
+        },
+    };
+    return listView;
+}

package/dist/modules/syncStorage.d.ts

@@ -0,0 +1,25 @@
+import type { StorageAdapter } from '../adapters/storage/types.js';
+export declare function createSyncStorage<T>(initial: T): {
+    touched(): boolean;
+    read(): T;
+    write(value: T): T;
+    reset(): void;
+    subscribe(fn: (value: T) => void): () => void;
+    onFirstSubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
+    onLastUnsubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
+};
+type ReactiveStorageParams<T> = {
+    storage: StorageAdapter;
+    key: string;
+    initial: T;
+    autosync: boolean;
+    from(value: string): T;
+    to(value: T): string | null;
+};
+export declare function reactiveStorage<T>({ storage, initial, key, autosync, from, to }: ReactiveStorageParams<T>): {
+    read(): Promise<import("../helpers/result.js").Result<T, Error>>;
+    write(value: T): Promise<import("../helpers/result.js").Result<null, Error> | import("../helpers/result.js").Result<T, Error>>;
+    clear(): Promise<import("../helpers/result.js").Result<void, Error>>;
+    subscribe(fn: (value: T | null) => void): () => void;
+};
+export {};

package/dist/modules/syncStorage.js

@@ -0,0 +1,76 @@
+import { createNanoEvents } from 'nanoevents';
+import { ok } from '../helpers/result.js';
+export function createSyncStorage(initial) {
+    const events = createNanoEvents();
+    let touched = false;
+    let currentValue = initial;
+    return {
+        touched() {
+            return touched;
+        },
+        read() {
+            return currentValue;
+        },
+        write(value) {
+            if (currentValue !== value) {
+                touched = true;
+                currentValue = value;
+                events.emit('value', value);
+            }
+            return value;
+        },
+        reset() {
+            if (currentValue !== initial) {
+                touched = true;
+                currentValue = initial;
+                events.emit('value', initial);
+            }
+        },
+        subscribe(fn) {
+            if (!events.events.value || events.events.value.length === 0) {
+                events.emit('first');
+            }
+            const unsubscribe = events.on('value', fn);
+            return () => {
+                unsubscribe();
+                if (!events.events.value || events.events.value.length === 0) {
+                    events.emit('last');
+                }
+            };
+        },
+        onFirstSubscribe(callback) {
+            return events.on('first', callback);
+        },
+        onLastUnsubscribe(callback) {
+            return events.on('last', callback);
+        },
+    };
+}
+export function reactiveStorage({ storage, initial, key, autosync, from, to }) {
+    const sync = createSyncStorage(initial);
+    const enhancedStorage = {
+        async read() {
+            const result = await storage.read(key);
+            return result.map(x => sync.write(x === null ? initial : from(x)));
+        },
+        async write(value) {
+            const data = to(value);
+            if (data !== null) {
+                const result = await storage.write(key, data);
+                return result.map(() => sync.write(value));
+            }
+            return ok(null);
+        },
+        async clear() {
+            const result = await storage.clear(key);
+            return result.map(() => sync.reset());
+        },
+        subscribe(fn) {
+            return sync.subscribe(fn);
+        },
+    };
+    if (autosync) {
+        sync.onFirstSubscribe(() => enhancedStorage.read());
+    }
+    return enhancedStorage;
+}

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

@@ -0,0 +1,24 @@
+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: T[];
+}>;
+export declare const Response: Codec<{
+    requestId: string;
+    responseCode: TransportError;
+}>;
+export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+    tag: "request";
+    value: {
+        requestId: string;
+        data: T[];
+    };
+} | {
+    tag: "response";
+    value: {
+        requestId: string;
+        responseCode: TransportError;
+    };
+}>;

package/dist/modules/transport/codec.js

@@ -0,0 +1,36 @@
+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 255;
+    }
+}, code => {
+    switch (code) {
+        case 1:
+            return 'decryptionFailed';
+        case 2:
+            return 'decodingFailed';
+        default:
+            return 'unknown';
+    }
+});
+export const Request = (data) => {
+    return Struct({
+        requestId: str,
+        data: Vector(data),
+    });
+};
+export const Response = Struct({
+    requestId: str,
+    responseCode: TransportErrorCodec,
+});
+export const StatementData = (data) => {
+    return Enum({
+        request: Request(data),
+        response: Response,
+    });
+};

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

@@ -0,0 +1,2 @@
+export declare function encrypt(secret: Uint8Array, cipherText: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function decrypt(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;

package/dist/modules/transport/crypto.js

@@ -0,0 +1,20 @@
+import { gcm } from '@noble/ciphers/aes.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+import { mergeBytes } from '../crypto.js';
+export function encrypt(secret, cipherText) {
+    const nonce = randomBytes(12);
+    const salt = new Uint8Array(); // secure enough since P256 random keys provide enough entropy
+    const info = new Uint8Array(); // no need to introduce any context
+    const aesKey = hkdf(sha256, secret, salt, info, 32);
+    const aes = gcm(aesKey, nonce);
+    return aes.encrypt(mergeBytes(nonce, cipherText));
+}
+export function decrypt(secret, message) {
+    const nonce = message.slice(0, 12);
+    const cipherText = message.slice(12);
+    const aesKey = hkdf(sha256, secret, new Uint8Array(), new Uint8Array(), 32);
+    const aes = gcm(aesKey, nonce);
+    return aes.decrypt(cipherText);
+}

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

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

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

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

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

@@ -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 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>>;
+};