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

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/state.d.ts

@@ -0,0 +1,16 @@
+type State<T> = ReturnType<typeof createState<T>>;
+export declare function createState<T>(initial: T): {
+    read(): T;
+    write(value: T | ((prev: T) => 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/helpers/state.js

@@ -0,0 +1,51 @@
+import { createNanoEvents } from 'nanoevents';
+export function createState(initial) {
+    const events = createNanoEvents();
+    let currentValue = initial;
+    return {
+        read() {
+            return currentValue;
+        },
+        write(value) {
+            const actialValue = typeof value === 'function' ? value(currentValue) : value;
+            if (currentValue !== actialValue) {
+                currentValue = actialValue;
+                events.emit('value', actialValue);
+            }
+            return actialValue;
+        },
+        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/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/zipWith.d.ts

@@ -0,0 +1,4 @@
+type InferArrayItem<T> = T extends Array<infer U> ? U : never;
+type InferArgs<Args extends unknown[][]> = Args extends [infer Head, ...infer Tail extends unknown[][]] ? [InferArrayItem<Head>, ...InferArgs<Tail>] : [];
+export declare function zipWith<const Args extends unknown[][], R>(arrays: Args, iteratee: (values: InferArgs<Args>) => R): R[];
+export {};

package/dist/helpers/zipWith.js

@@ -0,0 +1,11 @@
+export function zipWith(arrays, iteratee) {
+    if (arrays.length === 0)
+        return [];
+    const minLength = Math.min(...arrays.map(arr => arr.length));
+    const result = [];
+    for (let i = 0; i < minLength; i++) {
+        const values = arrays.map(arr => arr[i]);
+        result.push(iteratee(values));
+    }
+    return result;
+}

package/dist/identity/impl.d.ts

@@ -0,0 +1,6 @@
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { IdentityAdapter, IdentityRepository } from './types.js';
+export declare function createIdentityRepository({ adapter, storage, }: {
+    adapter: IdentityAdapter;
+    storage: StorageAdapter;
+}): IdentityRepository;

package/dist/identity/impl.js

@@ -0,0 +1,68 @@
+import { Result, ResultAsync, err, ok, okAsync } from 'neverthrow';
+import { toError } from '../helpers/utils.js';
+export function createIdentityRepository({ adapter, storage, }) {
+    const cachedRequester = createCachedIdentityRequester(storage, accountId => `identity_${accountId}`);
+    return {
+        getIdentity(accountId) {
+            return cachedRequester([accountId], adapter.readIdentities).map(map => map[accountId] ?? null);
+        },
+        getIdentities(accounts) {
+            return cachedRequester(accounts, adapter.readIdentities);
+        },
+    };
+}
+function createCachedIdentityRequester(storage, getKey) {
+    function readSingleCacheRecord(accountId) {
+        return storage.read(getKey(accountId)).andThen(raw => {
+            if (!raw) {
+                return ok(null);
+            }
+            try {
+                return ok(JSON.parse(raw));
+            }
+            catch (e) {
+                return err(toError(e));
+            }
+        });
+    }
+    function writeSingleCacheRecord(accountId, identity) {
+        if (identity === null) {
+            return okAsync(undefined);
+        }
+        return storage.write(getKey(accountId), JSON.stringify(identity));
+    }
+    function readCache(accounts) {
+        if (accounts.length === 0) {
+            return okAsync({});
+        }
+        const identities = ResultAsync.combine(accounts.map(readSingleCacheRecord));
+        return identities.map(identities => {
+            return Object.fromEntries(identities.map((x, i) => {
+                const accountId = accounts.at(i);
+                if (!accountId) {
+                    throw new Error(`Identity not found`);
+                }
+                return [accountId, x];
+            }));
+        });
+    }
+    function writeCache(identities) {
+        return ResultAsync.combine(Object.entries(identities).map(args => writeSingleCacheRecord(...args))).map(() => identities);
+    }
+    return (accounts, request) => {
+        return readCache(accounts).andThen(existing => {
+            const emptyIdentities = Object.entries(existing)
+                .filter(([, identity]) => identity === null)
+                .map(([accountId]) => accountId);
+            if (emptyIdentities.length === 0) {
+                return okAsync(existing);
+            }
+            return request(accounts)
+                .andThen(writeCache)
+                .map(fetched => ({
+                ...existing,
+                ...fetched,
+            }));
+        });
+    };
+}

package/dist/identity/rpcAdapter.d.ts

@@ -0,0 +1,3 @@
+import type { LazyClient } from '@novasamatech/statement-store';
+import type { IdentityAdapter } from './types.js';
+export declare function createIdentityRpcAdapter(lazyClient: LazyClient): IdentityAdapter;

package/dist/identity/rpcAdapter.js

@@ -0,0 +1,46 @@
+import { AccountId } from '@polkadot-api/substrate-bindings';
+import { errAsync, fromPromise, ok } from 'neverthrow';
+import { toError } from '../helpers/utils.js';
+import { zipWith } from '../helpers/zipWith.js';
+export function createIdentityRpcAdapter(lazyClient) {
+    const accCodec = AccountId();
+    return {
+        readIdentities(accounts) {
+            const client = lazyClient.getClient();
+            const unsafeApi = client.getUnsafeApi();
+            const method = unsafeApi.query.Resources.Consumers;
+            if (!method) {
+                return errAsync(new Error('Method Resources.Consumers not found'));
+            }
+            const results = fromPromise(method.getValues(accounts.map(x => [accCodec.dec(x)])), toError);
+            return results.andThen(results => {
+                if (!results) {
+                    return ok({});
+                }
+                return ok(Object.fromEntries(zipWith([accounts, results], x => x).map(([accountId, raw]) => {
+                    if (!raw) {
+                        return [accountId, null];
+                    }
+                    const credibility = raw.credibility.type == 'Lite'
+                        ? {
+                            type: 'Lite',
+                        }
+                        : {
+                            type: 'Person',
+                            alias: raw.credibility.value.alias.asHex(),
+                            lastUpdate: raw.credibility.value.last_update.toString(),
+                        };
+                    return [
+                        accountId,
+                        {
+                            accountId: accountId,
+                            fullUsername: raw.full_username ? raw.full_username.asText() : null,
+                            liteUsername: raw.lite_username.asText(),
+                            credibility,
+                        },
+                    ];
+                })));
+            });
+        },
+    };
+}

package/dist/identity/types.d.ts

@@ -0,0 +1,21 @@
+import type { ResultAsync } from 'neverthrow';
+export type Credibility = {
+    type: 'Lite';
+} | {
+    type: 'Person';
+    alias: `0x${string}`;
+    lastUpdate: string;
+};
+export type Identity = {
+    accountId: string;
+    fullUsername: string | null;
+    liteUsername: string;
+    credibility: Credibility;
+};
+export type IdentityAdapter = {
+    readIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
+};
+export type IdentityRepository = {
+    getIdentity(accountId: string): ResultAsync<Identity | null, Error>;
+    getIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
+};

package/dist/identity/types.js

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

package/dist/index.d.ts

@@ -1,4 +1,8 @@
+export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
 export type { PappAdapter } from './papp.js';
-export type { SignInStatus } from './modules/signIn.js';
-export type { Identity } from './adapters/identity/types.js';
-export declare function createPappHostAdapter(appId: string, metadata: string): import("./papp.js").PappAdapter;
+export { createPappAdapter } from './papp.js';
+export type { AuthentificationStatus } from './sso/auth/types.js';
+export type { UserSession } from './sso/sessionManager/userSession.js';
+export type { Identity } from './identity/types.js';
+export type { SignPayloadRequest } from './sso/sessionManager/scale/signPayloadRequest.js';
+export type { SignPayloadResponse } from './sso/sessionManager/scale/signPayloadResponse.js';

package/dist/index.js

@@ -1,7 +1,2 @@
-import { createPappAdapter } from './papp.js';
-export function createPappHostAdapter(appId, metadata) {
-    return createPappAdapter({
-        appId,
-        metadata,
-    });
-}
+export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
+export { createPappAdapter } from './papp.js';

package/dist/modules/crypto.d.ts

@@ -4,21 +4,20 @@ 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 function BrandedBytesCodec<T extends Uint8Array>(length?: number): Codec<T>;
 export declare const SsPubKey: Codec<SsPublicKey>;
 export declare const EncrPubKey: Codec<EncrPublicKey>;
 export declare function stringToBytes(str: string): Uint8Array<ArrayBuffer>;
 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 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 function verifyWithSsSecret(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
 export declare const ENCR_SECRET_SEED_SIZE = 48;
-export declare function createEncrSecret(seed: Uint8Array): EncrSecret;
+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 decrypt(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;

package/dist/modules/crypto.js

@@ -1,17 +1,13 @@
-import { gcm } from '@noble/ciphers/aes.js';
 import { p256 } from '@noble/curves/nist.js';
-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, verify as sr25519Verify, } from '@scure/sr25519';
+import { Bytes, str, u32 } from 'scale-ts';
 // schemas
-function brandedBytesCodec(length) {
+export function BrandedBytesCodec(length) {
     return Bytes(length);
 }
-export const SsPubKey = brandedBytesCodec(32);
-export const EncrPubKey = brandedBytesCodec(65);
+export const SsPubKey = BrandedBytesCodec(32);
+export const EncrPubKey = BrandedBytesCodec(65);
 // helpers
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -21,53 +17,35 @@ export function stringToBytes(str) {
 export function bytesToString(bytes) {
     return textDecoder.decode(bytes);
 }
-export function mergeBytes(...bytes) {
-    const len = bytes.reduce((l, b) => l + b.length, 0);
-    const merged = new Uint8Array(len);
-    let offset = 0;
-    for (const arr of bytes) {
-        merged.set(arr, offset);
-        offset += arr.length;
-    }
-    return merged;
-}
 // statement store key pair
 export const SS_SECRET_SEED_SIZE = 32;
-export function createSsSecret(seed) {
+export function createSsSecret(seed = randomBytes(SS_SECRET_SEED_SIZE)) {
     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);
+}
+export function verifyWithSsSecret(message, signature, publicKey) {
+    return sr25519Verify(message, signature, publicKey);
+}
 // encryption key pair
 export const ENCR_SECRET_SEED_SIZE = 48;
-export function createEncrSecret(seed) {
+export function createEncrSecret(seed = randomBytes(ENCR_SECRET_SEED_SIZE)) {
     const { secretKey } = p256.keygen(seed);
     return secretKey;
 }
 export function getEncrPub(secret) {
     return p256.getPublicKey(secret, false);
 }
-// helpers
-export function createRandomSeed(suffix, size) {
-    return blake2b(mergeBytes(randomBytes(128), stringToBytes(suffix)), { dkLen: size });
-}
-export function createStableSeed(value, size) {
-    return blake2b(stringToBytes(value), { dkLen: size });
-}
-export function khash(secret, message) {
-    return blake2b(message, { dkLen: 256 / 8, key: secret });
-}
 export function createSharedSecret(secret, publicKey) {
-    return p256.getSharedSecret(secret, publicKey);
-}
-export function createSymmetricKey(sharedSecret) {
-    return sharedSecret.slice(1, 33);
-}
-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);
+    // slicing first byte: @noble/curves adds y offset at the start
+    return p256.getSharedSecret(secret, publicKey).slice(1, 33);
 }

package/dist/modules/secretStorage.d.ts

@@ -1,14 +1,15 @@
-import type { StorageAdapter } from '../adapters/storage/types.js';
-import type { SessionTopic } from '../types.js';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { ResultAsync } from 'neverthrow';
+import type { CodecType } from 'scale-ts';
 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>;
+type UserSecrets = CodecType<typeof UserSecretsCodec>;
+declare const UserSecretsCodec: import("scale-ts").Codec<{
+    SsSecret: SsSecret;
+    EncrSecret: EncrSecret;
+}>;
+export declare function createSecretStorage(salt: string, storage: StorageAdapter): {
+    read(sessionId: string): ResultAsync<UserSecrets | null, Error>;
+    write(sessionId: string, value: UserSecrets): ResultAsync<void, Error>;
+    clear(sessionId: string): ResultAsync<void, Error>;
 };
-export declare function createSecretStorage(appId: string, storage: StorageAdapter): SecretStorage;
+export {};

package/dist/modules/secretStorage.js

@@ -1,53 +1,44 @@
 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';
-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,
-        readEncrSecret: encrSecret.read,
-        writeEncrSecret: encrSecret.write,
-        readSessionTopic: sessionTopic.read,
-        writeSessionTopic: sessionTopic.write,
-        readPappAccountId: pappAccountId.read,
-        writePappAccountId: pappAccountId.write,
-    };
-}
-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 {
+import { fromThrowable } from 'neverthrow';
+import { Struct } from 'scale-ts';
+import { toError } from '../helpers/utils.js';
+import { BrandedBytesCodec, stringToBytes } from './crypto.js';
+const UserSecretsCodec = Struct({
+    SsSecret: BrandedBytesCodec(),
+    EncrSecret: BrandedBytesCodec(),
+});
+export function createSecretStorage(salt, storage) {
+    const baseKey = 'UserSecrets';
+    const encode = fromThrowable(UserSecretsCodec.enc, toError);
+    const decode = fromThrowable((value) => (value ? UserSecretsCodec.dec(value) : null), toError);
+    const encrypt = fromThrowable((value) => {
+        const aes = getAes(salt);
+        return toHex(aes.encrypt(value));
+    }, toError);
+    const decrypt = fromThrowable((value) => {
+        if (value === null) {
             return null;
         }
-    },
-    write(value) {
-        const aes = getAes(appId);
-        return storage.write(withAppId(appId, key), toHex(aes.encrypt(value)));
-    },
-});
-const rwString = (key, appId, storage) => {
-    const bytes = rwBytes(key, appId, storage);
+        const aes = getAes(salt);
+        return aes.decrypt(fromHex(value));
+    }, toError);
     return {
-        async read() {
-            const value = await bytes.read();
-            return value ? bytesToString(value) : null;
+        read(sessionId) {
+            return storage.read(createKey(baseKey, sessionId)).andThen(decrypt).andThen(decode);
         },
-        write(value) {
-            const b = stringToBytes(value);
-            return bytes.write(b);
+        write(sessionId, value) {
+            return encode(value)
+                .andThen(encrypt)
+                .asyncAndThen(value => storage.write(createKey(baseKey, sessionId), value));
+        },
+        clear(sessionId) {
+            return storage.clear(createKey(baseKey, sessionId));
         },
     };
-};
-function getAes(appId) {
-    return gcm(blake2b(stringToBytes(appId), { dkLen: 16 }), blake2b(stringToBytes('nonce'), { dkLen: 32 }));
+}
+const createKey = (key, context) => `${key}_${context}`;
+function getAes(salt) {
+    return gcm(blake2b(stringToBytes(salt), { 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(sharedSecret: Uint8Array, 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(sharedSecret, 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(sharedSecret, 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>;