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

package/dist/components/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 '../modules/crypto.js';
+import { createSecretStorage } from '../modules/secretStorage.js';
+import { createSession } from '../modules/statementStore.js';
+import { createSyncStorage } from '../modules/syncStorage.js';
+import { createUserStorage } from '../modules/userStorage.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 createUserComponent({ appId, metadata, statements, storage }) {
+    const userStorage = createUserStorage(appId, storage);
+    const secretStorage = createSecretStorage(appId, storage);
+    const authStatus = createSyncStorage({ step: 'none' });
+    let authPromise = 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.sessions.create))
+                .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 (authPromise) {
+                return authPromise;
+            }
+            abort = new AbortController();
+            authPromise = handshake(abort.signal);
+            return authPromise;
+        },
+        abortAuthentication() {
+            if (abort) {
+                authPromise = 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/constants.d.ts

@@ -1 +1,2 @@
-export declare const SS_ENDPOINTS: string[];
+export declare const SS_DEV_ENDPOINTS: string[];
+export declare const SS_PROD_ENDPOINTS: string[];

package/dist/constants.js

@@ -1 +1,5 @@
-export const SS_ENDPOINTS = ['wss://pop3-testnet.parity-lab.parity.io/7910'];
+export const SS_DEV_ENDPOINTS = ['wss://pop-testnet.parity-lab.parity.io:443/9910'];
+export const SS_PROD_ENDPOINTS = [
+    'wss://pop3-testnet.parity-lab.parity.io:443/7911',
+    'wss://pop3-testnet.parity-lab.parity.io:443/7912',
+];

package/dist/helpers/abortError.d.ts

@@ -0,0 +1,4 @@
+export declare class AbortError extends Error {
+    constructor(message?: string);
+    static isAbortError(err: unknown): err is AbortError;
+}

package/dist/helpers/abortError.js

@@ -0,0 +1,8 @@
+export class AbortError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static isAbortError(err) {
+        return err instanceof AbortError;
+    }
+}

package/dist/helpers/callbackRaceResolver.d.ts

@@ -0,0 +1 @@
+export declare function callbackRaceResolver<T, R>(callback: (value: R) => unknown, preprocess: (value: T) => PromiseLike<R>): (value: T) => unknown;

package/dist/helpers/callbackRaceResolver.js

@@ -0,0 +1,17 @@
+export function callbackRaceResolver(callback, preprocess) {
+    let abort = new AbortController();
+    return async (value) => {
+        abort.abort();
+        abort = new AbortController();
+        try {
+            const result = await preprocess(value);
+            if (abort.signal.aborted) {
+                return;
+            }
+            callback(result);
+        }
+        catch {
+            /* empty */
+        }
+    };
+}

package/dist/helpers/result.d.ts

@@ -0,0 +1,12 @@
+import type { Result, ResultAsync } from 'neverthrow';
+type InferOk<R> = R extends Result<infer Ok, unknown> ? Ok : never;
+type InferOkAsync<R> = R extends ResultAsync<infer Ok, unknown> ? Ok : never;
+type InferErr<R> = R extends Result<unknown, infer Err> ? Err : never;
+type InferErrAsync<R> = R extends ResultAsync<unknown, infer Err> ? Err : never;
+type InferOks<Results> = Results extends [infer Head, ...infer Tail] ? [InferOk<Head>, ...InferOks<Tail>] : Results extends Result<unknown, unknown>[] ? InferOk<Results[number]>[] : [];
+type InferOksAsync<Results> = Results extends [infer Head, ...infer Tail] ? [InferOkAsync<Head>, ...InferOksAsync<Tail>] : Results extends ResultAsync<unknown, unknown>[] ? InferOkAsync<Results[number]>[] : [];
+type SeqResults<Results extends Result<unknown, unknown>[]> = Result<InferOks<Results>, InferErr<Results[number]> | Error>;
+type SeqResultsAsync<Results extends ResultAsync<unknown, unknown>[]> = ResultAsync<InferOksAsync<Results>, InferErrAsync<Results[number]> | Error>;
+export declare function seq<const Results extends Result<unknown, unknown>[]>(...result: Results): SeqResults<Results>;
+export declare function seqAsync<const Results extends ResultAsync<unknown, unknown>[]>(...result: Results): SeqResultsAsync<Results>;
+export {};

package/dist/helpers/result.js

@@ -0,0 +1,15 @@
+import { err, errAsync } from 'neverthrow';
+export function seq(...result) {
+    const [head, ...tail] = result;
+    if (head === undefined) {
+        return err(new Error('Seq is empty'));
+    }
+    return tail.reduce((a, r) => a.andThen(av => r.map(rv => [...av, rv])), head.map(r => [r]));
+}
+export function seqAsync(...result) {
+    const [head, ...tail] = result;
+    if (head === undefined) {
+        return errAsync(new Error('Seq is empty'));
+    }
+    return tail.reduce((a, r) => a.andThen(av => r.map(rv => [...av, rv])), head.map(r => [r]));
+}

package/dist/helpers/result.spec.d.ts

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

package/dist/helpers/result.spec.js

@@ -0,0 +1,23 @@
+import { err, errAsync, ok, okAsync } from 'neverthrow';
+import { describe, expect, it } from 'vitest';
+import { seq, seqAsync } from './result.js';
+describe('Result', () => {
+    describe('seq', () => {
+        it('should concat ok values', () => {
+            expect(seq(ok(1), ok('2'))._unsafeUnwrap()).toEqual([1, '2']);
+        });
+        it('should fallback to err', () => {
+            expect(seq(ok(1), err('2')).orElse(ok)._unsafeUnwrap()).toEqual('2');
+            expect(seq(err(1), ok('2')).orElse(ok)._unsafeUnwrap()).toEqual(1);
+        });
+    });
+    describe('seqAsync', () => {
+        it('should concat ok values', async () => {
+            expect((await seqAsync(okAsync(1), okAsync('2')))._unsafeUnwrap()).toEqual([1, '2']);
+        });
+        it('should fallback to err', async () => {
+            await expect(seqAsync(okAsync(1), errAsync('2')).then(x => x._unsafeUnwrapErr())).resolves.toEqual('2');
+            await expect(seqAsync(errAsync(1), okAsync('2')).then(x => x._unsafeUnwrapErr())).resolves.toEqual(1);
+        });
+    });
+});

package/dist/helpers/utils.d.ts

@@ -1 +1,2 @@
-export declare function isAbortError(err: object): boolean;
+export declare function toError(err: unknown): Error;
+export declare function nonNullable<T>(value: T): value is Exclude<NonNullable<T>, void>;

package/dist/helpers/utils.js

@@ -1,3 +1,12 @@
-export function isAbortError(err) {
-    return err && 'name' in err && err.name === 'AbortError';
+export function toError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    if (err) {
+        return new Error(err.toString());
+    }
+    return new Error('Unknown error occurred.');
+}
+export function nonNullable(value) {
+    return value !== null && value !== undefined;
 }

package/dist/helpers.d.ts

@@ -0,0 +1 @@
+export declare function isAbortError(err: object): boolean;

package/dist/helpers.js

@@ -0,0 +1,3 @@
+export function isAbortError(err) {
+    return err && 'name' in err && err.name === 'AbortError';
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export type { PappAdapter } from './papp.js';
-export type { SignInStatus } from './modules/signIn.js';
+export type { AuthentificationStatus } from './components/auth/types.js';
+export type { UserSession } from './components/user/userSessionStorage.js';
 export type { Identity } from './adapters/identity/types.js';
 export declare function createPappHostAdapter(appId: string, metadata: string): import("./papp.js").PappAdapter;

package/dist/modules/accounts.d.ts

@@ -0,0 +1 @@
+export declare function getAccountsFlow(): void;

package/dist/modules/accounts.js

@@ -0,0 +1,2 @@
+// TODO implement
+export function getAccountsFlow() { }

package/dist/modules/crypto.d.ts

@@ -4,6 +4,7 @@ export type SsPublicKey = Branded<Uint8Array, 'SsPublicKey'>;
 export type SsSecret = Branded<Uint8Array, 'SsSecret'>;
 export type EncrPublicKey = Branded<Uint8Array, 'EncrPublicKey'>;
 export type EncrSecret = Branded<Uint8Array, 'EncrSecret'>;
+export type SharedSecret = Branded<Uint8Array, 'SharedSecret'>;
 export type SharedSession = Branded<Uint8Array, 'SharedSession'>;
 export declare const SsPubKey: Codec<SsPublicKey>;
 export declare const EncrPubKey: Codec<EncrPublicKey>;
@@ -12,13 +13,15 @@ export declare function bytesToString(bytes: Uint8Array): string;
 export declare function mergeBytes(...bytes: Uint8Array[]): Uint8Array<ArrayBuffer>;
 export declare const SS_SECRET_SEED_SIZE = 32;
 export declare function createSsSecret(seed: Uint8Array): SsSecret;
+export declare function createSsHardDerivation(secret: SsSecret, derivation: string | number): SsSecret;
 export declare function getSsPub(secret: SsSecret): SsPublicKey;
+export declare function signWithSsSecret(secret: SsSecret, message: Uint8Array): Uint8Array<ArrayBufferLike>;
 export declare const ENCR_SECRET_SEED_SIZE = 48;
 export declare function createEncrSecret(seed: Uint8Array): EncrSecret;
 export declare function getEncrPub(secret: EncrSecret): EncrPublicKey;
 export declare function createRandomSeed(suffix: string, size: number): Uint8Array<ArrayBufferLike>;
 export declare function createStableSeed(value: string, size: number): Uint8Array<ArrayBufferLike>;
 export declare function khash(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function createSymmetricKey(sharedSecret: Uint8Array): Uint8Array<ArrayBuffer>;
+export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;
+export declare function encrypt(secret: Uint8Array, cipherText: Uint8Array): Uint8Array<ArrayBufferLike>;
 export declare function decrypt(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;

package/dist/modules/crypto.js

@@ -4,8 +4,8 @@ import { blake2b } from '@noble/hashes/blake2.js';
 import { hkdf } from '@noble/hashes/hkdf.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { randomBytes } from '@noble/hashes/utils.js';
-import { getPublicKey as sr25519GetPublicKey, secretFromSeed as sr25519SecretFromSeed } from '@scure/sr25519';
-import { Bytes } from 'scale-ts';
+import { HDKD as sr25519HDKD, getPublicKey as sr25519GetPublicKey, secretFromSeed as sr25519SecretFromSeed, sign as sr25519Sign, } from '@scure/sr25519';
+import { Bytes, str, u32 } from 'scale-ts';
 // schemas
 function brandedBytesCodec(length) {
     return Bytes(length);
@@ -36,9 +36,17 @@ export const SS_SECRET_SEED_SIZE = 32;
 export function createSsSecret(seed) {
     return sr25519SecretFromSeed(seed);
 }
+export function createSsHardDerivation(secret, derivation) {
+    const chainCode = new Uint8Array(32);
+    chainCode.set(typeof derivation === 'string' ? str.enc(derivation) : u32.enc(derivation));
+    return sr25519HDKD.secretHard(secret, chainCode);
+}
 export function getSsPub(secret) {
     return sr25519GetPublicKey(secret);
 }
+export function signWithSsSecret(secret, message) {
+    return sr25519Sign(secret, message);
+}
 // encryption key pair
 export const ENCR_SECRET_SEED_SIZE = 48;
 export function createEncrSecret(seed) {
@@ -59,10 +67,13 @@ export function khash(secret, message) {
     return blake2b(message, { dkLen: 256 / 8, key: secret });
 }
 export function createSharedSecret(secret, publicKey) {
-    return p256.getSharedSecret(secret, publicKey);
+    return p256.getSharedSecret(secret, publicKey).slice(1, 33);
 }
-export function createSymmetricKey(sharedSecret) {
-    return sharedSecret.slice(1, 33);
+export function encrypt(secret, cipherText) {
+    const nonce = randomBytes(12);
+    const aesKey = hkdf(sha256, secret, new Uint8Array(), new Uint8Array(), 32);
+    const aes = gcm(aesKey, nonce);
+    return aes.encrypt(mergeBytes(nonce, cipherText));
 }
 export function decrypt(secret, message) {
     const nonce = message.slice(0, 12);

package/dist/modules/secretStorage.d.ts

@@ -1,14 +1,12 @@
+import type { ResultAsync } from 'neverthrow';
 import type { StorageAdapter } from '../adapters/storage/types.js';
-import type { SessionTopic } from '../types.js';
 import type { EncrSecret, SsSecret } from './crypto.js';
 export type SecretStorage = {
-    readSsSecret(): Promise<SsSecret | null>;
-    writeSsSecret(value: SsSecret): Promise<boolean>;
-    readEncrSecret(): Promise<EncrSecret | null>;
-    writeEncrSecret(value: EncrSecret): Promise<boolean>;
-    readSessionTopic(): Promise<SessionTopic | null>;
-    writeSessionTopic(value: SessionTopic): Promise<boolean>;
-    readPappAccountId(): Promise<string | null>;
-    writePappAccountId(value: string): Promise<boolean>;
+    readSsSecret(accountId: string): ResultAsync<SsSecret | null, Error>;
+    writeSsSecret(accountId: string, value: SsSecret): ResultAsync<void, Error>;
+    clearSsSecret(accountId: string): ResultAsync<void, Error>;
+    readEncrSecret(accountId: string): ResultAsync<EncrSecret | null, Error>;
+    writeEncrSecret(accountId: string, value: EncrSecret): ResultAsync<void, Error>;
+    clearEncrSecret(accountId: string): ResultAsync<void, Error>;
 };
 export declare function createSecretStorage(appId: string, storage: StorageAdapter): SecretStorage;

package/dist/modules/secretStorage.js

@@ -1,53 +1,40 @@
 import { gcm } from '@noble/ciphers/aes.js';
 import { blake2b } from '@noble/hashes/blake2.js';
 import { fromHex, toHex } from '@polkadot-api/utils';
-import { bytesToString, stringToBytes } from './crypto.js';
+import { stringToBytes } from './crypto.js';
 export function createSecretStorage(appId, storage) {
     const ssSecret = rwBytes('SsSecret', appId, storage);
     const encrSecret = rwBytes('EncrSecret', appId, storage);
-    const sessionTopic = rwBytes('SessionTopic', appId, storage);
-    const pappAccountId = rwString('PappAccountId', appId, storage);
     return {
         readSsSecret: ssSecret.read,
         writeSsSecret: ssSecret.write,
+        clearSsSecret: ssSecret.clear,
         readEncrSecret: encrSecret.read,
         writeEncrSecret: encrSecret.write,
-        readSessionTopic: sessionTopic.read,
-        writeSessionTopic: sessionTopic.write,
-        readPappAccountId: pappAccountId.read,
-        writePappAccountId: pappAccountId.write,
+        clearEncrSecret: encrSecret.clear,
     };
 }
-const withAppId = (appId, key) => `${appId}_${key}`;
-const rwBytes = (key, appId, storage) => ({
-    async read() {
-        const value = await storage.read(withAppId(appId, key));
-        if (value) {
-            const aes = getAes(appId);
-            return aes.decrypt(fromHex(value));
-        }
-        else {
-            return null;
-        }
+const createKey = (key, context) => `${key}_${context}`;
+const rwBytes = (baseKey, appId, storage) => ({
+    read(context) {
+        return storage.read(createKey(baseKey, context)).map(value => {
+            if (value) {
+                const aes = getAes(appId);
+                return aes.decrypt(fromHex(value));
+            }
+            else {
+                return null;
+            }
+        });
     },
-    write(value) {
+    write(context, value) {
         const aes = getAes(appId);
-        return storage.write(withAppId(appId, key), toHex(aes.encrypt(value)));
+        return storage.write(createKey(baseKey, context), toHex(aes.encrypt(value)));
+    },
+    clear(context) {
+        return storage.clear(createKey(baseKey, context));
     },
 });
-const rwString = (key, appId, storage) => {
-    const bytes = rwBytes(key, appId, storage);
-    return {
-        async read() {
-            const value = await bytes.read();
-            return value ? bytesToString(value) : null;
-        },
-        write(value) {
-            const b = stringToBytes(value);
-            return bytes.write(b);
-        },
-    };
-};
 function getAes(appId) {
     return gcm(blake2b(stringToBytes(appId), { dkLen: 16 }), blake2b(stringToBytes('nonce'), { dkLen: 32 }));
 }

package/dist/modules/session/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { Account } from './types.js';
+export declare function createSessionId(accountA: Account, accountB: Account): Uint8Array<ArrayBufferLike>;
+export declare function createRequestChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function createResponseChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function createAccount(accountId: Uint8Array, publicKey: Uint8Array, pin?: string): Account;

package/dist/modules/session/helpers.js

@@ -0,0 +1,29 @@
+import { mergeUint8 } from '@polkadot-api/utils';
+import { khash, stringToBytes } from '../crypto.js';
+export function createSessionId(accountA, accountB) {
+    const sessionPrefix = stringToBytes('session');
+    const pinSeparator = stringToBytes('/');
+    function makePin(pin) {
+        return pin ? mergeUint8([pinSeparator, stringToBytes(pin)]) : pinSeparator;
+    }
+    const accountSessionParams = mergeUint8([
+        accountA.accountId,
+        accountB.accountId,
+        makePin(accountA.pin),
+        makePin(accountB.pin),
+    ]);
+    return khash(accountA.publicKey, mergeUint8(sessionPrefix, accountSessionParams));
+}
+export function createRequestChannel(session) {
+    return khash(session, stringToBytes('request'));
+}
+export function createResponseChannel(session) {
+    return khash(session, stringToBytes('response'));
+}
+export function createAccount(accountId, publicKey, pin) {
+    return {
+        accountId,
+        publicKey,
+        pin,
+    };
+}

package/dist/modules/session/session.d.ts

@@ -0,0 +1,12 @@
+import type { Codec } from 'scale-ts';
+import type { StorageAdapter } from '../../adapters/storage/types.js';
+import type { Transport } from '../transport/transport.js';
+import type { Account, Session } from './types.js';
+export type SessionParams<T extends Codec<any>> = {
+    ownAccount: Account;
+    peerAccount: Account;
+    transport: Transport;
+    storage: StorageAdapter;
+    codec: T;
+};
+export declare function createSession<T extends Codec<any>>({ ownAccount, peerAccount, transport, storage, codec, }: SessionParams<T>): Session<T>;

package/dist/modules/session/session.js

@@ -0,0 +1,46 @@
+import { okAsync } from 'neverthrow';
+import { toHex } from 'polkadot-api/utils';
+import { storageListView } from '../storageView.js';
+import { createSessionId } from './helpers.js';
+export function createSession({ ownAccount, peerAccount, transport, storage, codec, }) {
+    // const ownSession = createSessionId(ownAccount, peerAccount);
+    const peerSession = createSessionId(peerAccount, ownAccount);
+    const processedStorage = storageListView({
+        key: `ProcessesMessages_${toHex(peerSession)}`,
+        storage,
+        initial: [],
+        from: JSON.parse,
+        to: JSON.stringify,
+    });
+    let subscriptions = [];
+    return {
+        subscribe(callback) {
+            const unsub = transport.handleRequest(ownAccount, peerAccount, codec, async (message) => {
+                processedStorage.read().andThen(processed => {
+                    if (processed.includes(message.requestId)) {
+                        return okAsync();
+                    }
+                    return callback(message.data).andThen(processed => {
+                        if (processed) {
+                            return processedStorage.mutate(p => p.concat(message.requestId));
+                        }
+                        else {
+                            return okAsync();
+                        }
+                    });
+                });
+            });
+            subscriptions.push(unsub);
+            return () => {
+                unsub();
+                subscriptions = subscriptions.filter(x => x !== unsub);
+            };
+        },
+        dispose() {
+            for (const unsub of subscriptions) {
+                unsub();
+            }
+            subscriptions = [];
+        },
+    };
+}

package/dist/modules/session/types.d.ts

@@ -0,0 +1,12 @@
+import type { ResultAsync } from 'neverthrow';
+import type { Codec, CodecType } from 'scale-ts';
+import type { Callback } from '../../types.js';
+export type Session<T extends Codec<any>> = {
+    subscribe(callback: Callback<CodecType<T>, ResultAsync<boolean, Error>>): VoidFunction;
+    dispose(): void;
+};
+export type Account = {
+    accountId: Uint8Array;
+    publicKey: Uint8Array;
+    pin: string | undefined;
+};

package/dist/modules/session/types.js

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