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

package/dist/modules/signIn.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 { createUserManager } from './userManager.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 createSignInFlow({ appId, metadata, statements, storage }) {
-    const userManager = createUserManager(appId, storage);
-    const secretStorage = createSecretStorage(appId, storage);
-    const signInStatus = createSyncStorage({ step: 'none' });
-    let signInPromise = null;
-    let abort = null;
-    async function handshake(signal) {
-        signInStatus.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 });
-            signInStatus.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(userManager.createUser))
-                .then(async (result) => result
-                .map(user => {
-                signInStatus.write({ step: 'finished', user });
-                return user;
-            })
-                .orElse(e => {
-                const error = toError(e);
-                if (isAbortError(error)) {
-                    signInStatus.write({ step: 'none' });
-                    return ok(null);
-                }
-                else {
-                    signInStatus.write({ step: 'error', message: error.message });
-                    return err(error);
-                }
-            }));
-        });
-    }
-    const signInFlow = {
-        signInStatus,
-        users: userManager,
-        async signIn() {
-            if (signInPromise) {
-                return signInPromise;
-            }
-            abort = new AbortController();
-            signInPromise = handshake(abort.signal);
-            return signInPromise;
-        },
-        abortSignIn() {
-            if (abort) {
-                signInPromise = null;
-                signInStatus.reset();
-                abort.abort();
-            }
-        },
-    };
-    return signInFlow;
-}
-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/state.d.ts

@@ -1,16 +0,0 @@
-type State<T> = ReturnType<typeof createState<T>>;
-export declare function createState<T>(initial: T): {
-    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;
-};
-export declare function readonly<T>(state: State<T>): {
-    read: () => T;
-    subscribe: (fn: (value: T) => void) => () => void;
-    onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
-    onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
-};
-export {};

package/dist/modules/state.js

@@ -1,50 +0,0 @@
-import { createNanoEvents } from 'nanoevents';
-export function createState(initial) {
-    const events = createNanoEvents();
-    let currentValue = initial;
-    return {
-        read() {
-            return currentValue;
-        },
-        write(value) {
-            if (currentValue !== value) {
-                currentValue = value;
-                events.emit('value', value);
-            }
-            return value;
-        },
-        reset() {
-            if (currentValue !== initial) {
-                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);
-            fn(currentValue);
-            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 readonly(state) {
-    return {
-        read: state.read,
-        subscribe: state.subscribe,
-        onFirstSubscribe: state.onFirstSubscribe,
-        onLastUnsubscribe: state.onLastUnsubscribe,
-    };
-}

package/dist/modules/statementStore.d.ts

@@ -1,12 +0,0 @@
-import type { UserSession } from '../sso/session/ssoSessionStorage.js';
-import type { SsSecret } from './crypto.js';
-import type { Account } from './session/types.js';
-export declare function createUserSession(hostAccount: Account, peerAccount: Account): UserSession;
-type StatementPayload = {
-    priority: number;
-    channel: Uint8Array;
-    topics: Uint8Array[];
-    data: Uint8Array;
-};
-export declare function createStatement(secret: SsSecret, payload: StatementPayload): import("neverthrow").ResultAsync<import("@polkadot-api/sdk-statement").SignedStatement, Error>;
-export {};

package/dist/modules/statementStore.js

@@ -1,22 +0,0 @@
-import { getStatementSigner } from '@polkadot-api/sdk-statement';
-import { Binary } from '@polkadot-api/substrate-bindings';
-import { nanoid } from 'nanoid';
-import { fromPromise } from 'neverthrow';
-import { toError } from '../helpers/utils.js';
-import { getSsPub, signWithSsSecret } from './crypto.js';
-export function createUserSession(hostAccount, peerAccount) {
-    return {
-        id: nanoid(12),
-        peer: peerAccount,
-        host: hostAccount,
-    };
-}
-export function createStatement(secret, payload) {
-    const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
-    return fromPromise(signer.sign({
-        priority: payload.priority,
-        channel: Binary.fromBytes(payload.channel),
-        topics: payload.topics.map(Binary.fromBytes),
-        data: Binary.fromBytes(payload.data),
-    }), toError);
-}

package/dist/modules/statementTopic.d.ts

@@ -1,34 +0,0 @@
-import type { Statement } from '@polkadot-api/sdk-statement';
-import type { StatementAdapter } from '../adapters/statement/types.js';
-import type { StorageAdapter } from '../adapters/storage/types.js';
-import type { Callback } from '../types.js';
-import type { SsSecret } from './crypto.js';
-export declare function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }: {
-    sharedSecret: Uint8Array;
-    accountA: Uint8Array;
-    accountB: Uint8Array;
-    pinA?: string;
-    pinB?: string;
-}): {
-    a: Uint8Array<ArrayBufferLike>;
-    b: Uint8Array<ArrayBufferLike>;
-};
-export declare function createRequestChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function createResponseChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
-type StatementPayload = {
-    priority: number;
-    channel: Uint8Array;
-    topics: Uint8Array[];
-    data: Uint8Array;
-};
-export declare function createStatement(secret: SsSecret, payload: StatementPayload): Promise<import("@polkadot-api/sdk-statement").SignedStatement>;
-type Params = {
-    topic: Uint8Array;
-    statement: StatementAdapter;
-    storage: StorageAdapter;
-};
-export declare function createStatementTopic({ topic, statement }: Params): {
-    subscribe(callback: Callback<Statement, boolean>): VoidFunction;
-    submit(): void;
-};
-export {};

package/dist/modules/statementTopic.js

@@ -1,46 +0,0 @@
-import { getStatementSigner } from '@polkadot-api/sdk-statement';
-import { Binary } from '@polkadot-api/substrate-bindings';
-import { getSsPub, khash, mergeBytes, signWithSsSecret, stringToBytes } from './crypto.js';
-export function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }) {
-    const sessionPrefix = stringToBytes('session');
-    const pinSeparator = stringToBytes('/');
-    function makePin(pin) {
-        return pin ? mergeBytes(pinSeparator, stringToBytes(pin)) : pinSeparator;
-    }
-    const accountASessionParams = mergeBytes(sessionPrefix, accountA, accountB, makePin(pinA), makePin(pinB));
-    const accountBSessionParams = mergeBytes(sessionPrefix, accountB, accountA, makePin(pinB), makePin(pinA));
-    return {
-        a: khash(sharedSecret, accountASessionParams),
-        b: khash(sharedSecret, accountBSessionParams),
-    };
-}
-export function createRequestChannel(session) {
-    return khash(session, stringToBytes('request'));
-}
-export function createResponseChannel(session) {
-    return khash(session, stringToBytes('response'));
-}
-export function createStatement(secret, payload) {
-    const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
-    return signer.sign({
-        priority: payload.priority,
-        channel: Binary.fromBytes(payload.channel),
-        topics: payload.topics.map(Binary.fromBytes),
-        data: Binary.fromBytes(payload.data),
-    });
-}
-export function createStatementTopic({ topic, statement }) {
-    return {
-        subscribe(callback) {
-            return statement.subscribeStatements([topic], statements => {
-                for (const statement of statements) {
-                    const processed = callback(statement);
-                    if (processed) {
-                        // TODO save anywhere
-                    }
-                }
-            });
-        },
-        submit() { },
-    };
-}

package/dist/modules/storageView.d.ts

@@ -1,25 +0,0 @@
-import type { ResultAsync } from 'neverthrow';
-import type { StorageAdapter } from '../adapters/storage/types.js';
-type Params<T> = {
-    storage: StorageAdapter;
-    key: string;
-    initial: T;
-    autosync?: boolean;
-    from(value: string): T;
-    to(value: T): string | null;
-};
-export declare function storageView<T>({ storage, initial, key, from, to, autosync }: Params<T>): {
-    read(): any;
-    write(value: T): any;
-    clear(): any;
-    subscribe(fn: (value: T) => void): () => void;
-};
-export declare function storageListView<T>(params: Params<T[]>): {
-    add(value: T): ResultAsync<T, Error>;
-    mutate(fn: (value: T[]) => T[]): ResultAsync<T[], Error>;
-    read(): any;
-    write(value: T[]): any;
-    clear(): any;
-    subscribe(fn: (value: T[]) => void): () => void;
-};
-export {};

package/dist/modules/storageView.js

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

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

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

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

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

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

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