@novasamatech/host-papp 0.5.0-8 → 0.5.0-9

package/dist/sso/auth/impl.js

@@ -0,0 +1,148 @@
+import { createAccountId, createEncryption, createLocalSessionAccount, createRemoteSessionAccount, khash, } from '@novasamatech/statement-store';
+import { mergeUint8, toHex } from '@polkadot-api/utils';
+import { Result, ResultAsync, err, fromPromise, fromThrowable, ok } from 'neverthrow';
+import { createEncrSecret, createSharedSecret, createSsHardDerivation, createSsSecret, getEncrPub, getSsPub, stringToBytes, } from '../../crypto.js';
+import { AbortError } from '../../helpers/abortError.js';
+import { createState, readonly } from '../../helpers/state.js';
+import { toError } from '../../helpers/utils.js';
+import { createStoredUserSession } from '../userSessionRepository.js';
+import { HandshakeData, HandshakeResponsePayload, HandshakeResponseSensitiveData } from './scale/handshake.js';
+export function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository }) {
+    const authStatus = createState({ step: 'none' });
+    let authResults = null;
+    let abort = null;
+    function handshake(signal) {
+        return getSecretKeys()
+            .andTee(() => {
+            authStatus.write({ step: 'initial' });
+        })
+            .asyncAndThen(({ encrSecret, encrPublicKey, ssSecret, ssPublicKey }) => {
+            const localAccount = createLocalSessionAccount(createAccountId(ssPublicKey));
+            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata }).andTee(payload => authStatus.write({ step: 'pairing', payload: createDeeplink(payload) }));
+            const pappResponse = handshakePayload
+                .andThen(() => createHandshakeTopic(localAccount, encrPublicKey))
+                .asyncAndThen(topic => waitForStatements(callback => statementStore.subscribeStatements([topic], callback), signal, (statements, resolve) => {
+                for (const statement of statements) {
+                    if (!statement.data)
+                        continue;
+                    const session = retrieveSession({
+                        localAccount,
+                        encrSecret,
+                        payload: statement.data.asBytes(),
+                    }).unwrapOr(null);
+                    if (session) {
+                        resolve(session);
+                        break;
+                    }
+                }
+            }));
+            const secretesSaved = pappResponse.andThen(({ id }) => userSecretRepository.write(id, { ssSecret, encrSecret }));
+            const userCreated = secretesSaved.andThen(() => pappResponse.andThen(ssoSessionRepository.add));
+            const result = ResultAsync.combine([userCreated, secretesSaved]).map(([session]) => session);
+            return result
+                .orElse(e => (AbortError.isAbortError(e) ? ok(null) : err(toError(e))))
+                .andTee(session => {
+                authStatus.write(session ? { step: 'finished', session } : { step: 'none' });
+            })
+                .orTee(e => {
+                authStatus.write({ step: 'error', message: e.message });
+            });
+        });
+    }
+    const authModule = {
+        status: readonly(authStatus),
+        authenticate() {
+            if (authResults) {
+                return authResults;
+            }
+            abort = new AbortController();
+            authResults = handshake(abort.signal);
+            return authResults;
+        },
+        abortAuthentication() {
+            if (abort) {
+                authResults = null;
+                authStatus.reset();
+                abort.abort(new AbortError('Aborted by user.'));
+            }
+        },
+    };
+    return authModule;
+}
+const createHandshakeTopic = fromThrowable((account, encrPublicKey) => khash(account.accountId, mergeUint8([encrPublicKey, stringToBytes('topic')])), toError);
+const createHandshakePayloadV1 = fromThrowable(({ encrPublicKey, ssPublicKey, metadata, }) => HandshakeData.enc({
+    tag: 'v1',
+    value: [ssPublicKey, encrPublicKey, metadata],
+}), toError);
+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 retrieveSession({ payload, encrSecret, localAccount, }) {
+    const { encrypted, tmpKey } = parseHandshakePayload(payload);
+    const symmetricKey = createSharedSecret(encrSecret, tmpKey);
+    return createEncryption(symmetricKey)
+        .decrypt(encrypted)
+        .map(decrypted => {
+        const [pappEncrPublicKey, pappAccountId] = HandshakeResponseSensitiveData.dec(decrypted);
+        const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
+        const peerAccount = createRemoteSessionAccount(createAccountId(pappAccountId), sharedSecret);
+        return createStoredUserSession(localAccount, peerAccount);
+    });
+}
+const getSsKeys = fromThrowable(() => {
+    const ssSecret = createSsHardDerivation(createSsSecret(), '//wallet//sso');
+    return {
+        ssSecret: ssSecret,
+        ssPublicKey: getSsPub(ssSecret),
+    };
+}, toError);
+const getEncrKeys = fromThrowable(() => {
+    const encrSecret = createEncrSecret();
+    return {
+        encrSecret,
+        encrPublicKey: getEncrPub(encrSecret),
+    };
+}, toError);
+function getSecretKeys() {
+    return Result.combine([getSsKeys(), getEncrKeys()]).map(([ss, encr]) => ({
+        ...ss,
+        ...encr,
+    }));
+}
+function createDeeplink(payload) {
+    return `polkadotapp://pair?handshake=${toHex(payload)}`;
+}
+function waitForStatements(subscribe, abortSignal, callback) {
+    return fromPromise(new Promise((resolve, reject) => {
+        const unsubscribe = subscribe(statements => {
+            if (abortSignal?.aborted) {
+                unsubscribe();
+                try {
+                    abortSignal.throwIfAborted();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }
+            try {
+                callback(statements, value => {
+                    unsubscribe();
+                    resolve(value);
+                });
+            }
+            catch (e) {
+                unsubscribe();
+                reject(e);
+            }
+        });
+    }), toError);
+}

package/dist/sso/auth/scale/handshake.d.ts

@@ -0,0 +1,9 @@
+export declare const HandshakeData: import("scale-ts").Codec<{
+    tag: "v1";
+    value: [import("../../../crypto.js").SsPublicKey, import("../../../crypto.js").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>]>;

package/dist/sso/auth/scale/handshake.js

@@ -0,0 +1,10 @@
+import { Bytes, Enum, Tuple, str } from 'scale-ts';
+import { EncrPubKey, SsPubKey } from '../../../crypto.js';
+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));

package/dist/sso/auth/types.d.ts

@@ -0,0 +1,15 @@
+import type { StoredUserSession } from '../userSessionRepository.js';
+export type AuthentificationStatus = {
+    step: 'none';
+} | {
+    step: 'initial';
+} | {
+    step: 'pairing';
+    payload: string;
+} | {
+    step: 'error';
+    message: string;
+} | {
+    step: 'finished';
+    session: StoredUserSession;
+};

package/dist/sso/auth/types.js

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

package/dist/sso/session/impl.d.ts

@@ -0,0 +1,23 @@
+import type { Transport } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { UserSession, ssoSessionStorage } from './ssoSessionStorage.js';
+export type SsoSessionManager = ReturnType<typeof createSsoSessionManager>;
+type Params = {
+    transport: Transport;
+    storage: StorageAdapter;
+    ssoSessionStorage: ssoSessionStorage;
+};
+export declare function createSsoSessionManager({ ssoSessionStorage, transport }: Params): {
+    sessions: {
+        add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+        filter(fn: (value: UserSession) => boolean): import("neverthrow").ResultAsync<UserSession[], Error>;
+        mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+        read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+        write(value: UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+        clear(): import("neverthrow").ResultAsync<void, Error>;
+        subscribe(fn: (value: UserSession[]) => void): VoidFunction;
+    };
+    disconnect: (session: UserSession) => import("neverthrow").ResultAsync<undefined, Error>;
+    destroy(): void;
+};
+export {};

package/dist/sso/session/impl.js

@@ -0,0 +1,57 @@
+import { okAsync } from 'neverthrow';
+import { createSSOSession } from './ssoSession.js';
+export function createSsoSessionManager({ ssoSessionStorage, transport }) {
+    let unsubStatements = null;
+    const disconnect = (session) => {
+        return ssoSessionStorage.mutate(sessions => sessions.filter(s => s.id !== session.id)).map(() => undefined);
+    };
+    const unsubSessions = ssoSessionStorage.subscribe(userSessions => {
+        if (unsubStatements) {
+            unsubStatements();
+            unsubStatements = null;
+        }
+        const ssoSessions = [];
+        for (const userSession of userSessions) {
+            const session = createSSOSession({
+                localAccount: userSession.local,
+                remoteAccount: userSession.remote,
+                transport,
+            });
+            session.subscribe(message => {
+                switch (message.data.tag) {
+                    case 'v1': {
+                        switch (message.data.value.tag) {
+                            case 'Disconnected':
+                                return disconnect(userSession).map(() => true);
+                        }
+                    }
+                }
+                return okAsync(false);
+            });
+            ssoSessions.push(session);
+        }
+        unsubStatements = () => {
+            for (const session of ssoSessions) {
+                session.dispose();
+            }
+        };
+    });
+    return {
+        sessions: ssoSessionStorage,
+        disconnect,
+        destroy() {
+            unsubSessions();
+        },
+    };
+}
+// function createDisconnectMessage(ssSecret: SsSecret, topic: Uint8Array) {
+//   const statement = createStatement(ssSecret, {
+//     priority: 0,
+//     channel: createRequestChannel(topic),
+//     topics: [topic],
+//     data: SSOMessage.enc({
+//       tag: 'Disconnected',
+//       value: undefined,
+//     }),
+//   });
+// }

package/dist/sso/session/scale/remoteMessage.d.ts

@@ -0,0 +1,10 @@
+export declare const HostRemoteMessageCodec: import("scale-ts").Codec<{
+    messageId: string;
+    data: {
+        tag: "v1";
+        value: {
+            tag: "Disconnected";
+            value: undefined;
+        };
+    };
+}>;

package/dist/sso/session/scale/remoteMessage.js

@@ -0,0 +1,13 @@
+import { Enum, Struct, _void, str } from 'scale-ts';
+export const HostRemoteMessageCodec = Struct({
+    messageId: str,
+    data: Enum({
+        v1: Enum({
+            Disconnected: _void,
+            // TODO implement
+            // SigningRequest: Bytes(),
+            // TODO implement
+            // SigningResponse: Bytes(),
+        }),
+    }),
+});

package/dist/sso/session/sessionManager.d.ts

@@ -0,0 +1,23 @@
+import type { StorageAdapter } from '../../adapters/storage/types.js';
+import type { Transport } from '../../modules/transport/transport.js';
+import type { UserSession, UserSessionStorage } from './userSessionStorage.js';
+export type SessionManager = ReturnType<typeof createSessionManager>;
+type Params = {
+    transport: Transport;
+    storage: StorageAdapter;
+    userSessionStorage: UserSessionStorage;
+};
+export declare function createSessionManager({ userSessionStorage, storage, transport }: Params): {
+    sessions: {
+        add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+        filter(fn: (value: UserSession) => boolean): import("neverthrow").ResultAsync<UserSession[], Error>;
+        mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+        read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+        write(value: UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+        clear(): import("neverthrow").ResultAsync<void, Error>;
+        subscribe(fn: (value: UserSession[]) => void): VoidFunction;
+    };
+    disconnect: (session: UserSession) => import("neverthrow").ResultAsync<undefined, Error>;
+    destroy(): void;
+};
+export {};

package/dist/sso/session/sessionManager.js

@@ -0,0 +1,58 @@
+import { okAsync } from 'neverthrow';
+import { createSSOSession } from './ssoSession.js';
+export function createSessionManager({ userSessionStorage, storage, transport }) {
+    let unsubStatements = null;
+    const disconnect = (session) => {
+        return userSessionStorage.mutate(sessions => sessions.filter(s => s.id !== session.id)).map(() => undefined);
+    };
+    const unsubSessions = userSessionStorage.subscribe(userSessions => {
+        if (unsubStatements) {
+            unsubStatements();
+            unsubStatements = null;
+        }
+        const ssoSessions = [];
+        for (const userSession of userSessions) {
+            const session = createSSOSession({
+                ownAccount: userSession.host,
+                peerAccount: userSession.peer,
+                storage,
+                transport,
+            });
+            session.subscribe(message => {
+                switch (message.data.tag) {
+                    case 'v1': {
+                        switch (message.data.value.tag) {
+                            case 'Disconnected':
+                                return disconnect(userSession).map(() => true);
+                        }
+                    }
+                }
+                return okAsync(false);
+            });
+            ssoSessions.push(session);
+        }
+        unsubStatements = () => {
+            for (const session of ssoSessions) {
+                session.dispose();
+            }
+        };
+    });
+    return {
+        sessions: userSessionStorage,
+        disconnect,
+        destroy() {
+            unsubSessions();
+        },
+    };
+}
+// function createDisconnectMessage(ssSecret: SsSecret, topic: Uint8Array) {
+//   const statement = createStatement(ssSecret, {
+//     priority: 0,
+//     channel: createRequestChannel(topic),
+//     topics: [topic],
+//     data: SSOMessage.enc({
+//       tag: 'Disconnected',
+//       value: undefined,
+//     }),
+//   });
+// }

package/dist/sso/session/ssoSession.d.ts

@@ -0,0 +1,8 @@
+import type { LocalSessionAccount, RemoteSessionAccount, Session, Transport } from '@novasamatech/statement-store';
+import { HostRemoteMessageCodec } from './scale/remoteMessage.js';
+export type SsoSession = Session<typeof HostRemoteMessageCodec>;
+export declare function createSSOSession({ localAccount, remoteAccount, transport, }: {
+    localAccount: LocalSessionAccount;
+    remoteAccount: RemoteSessionAccount;
+    transport: Transport;
+}): SsoSession;

package/dist/sso/session/ssoSession.js

@@ -0,0 +1,5 @@
+import { createSession } from '@novasamatech/statement-store';
+import { HostRemoteMessageCodec } from './scale/remoteMessage.js';
+export function createSSOSession({ localAccount, remoteAccount, transport, }) {
+    return createSession({ localAccount, remoteAccount, transport, codec: HostRemoteMessageCodec });
+}

package/dist/sso/session/ssoSessionStorage.d.ts

@@ -0,0 +1,21 @@
+import type { LocalSessionAccount, RemoteSessionAccount } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+export type ssoSessionStorage = ReturnType<typeof createSsoSessionStorage>;
+export type UserSession = {
+    id: string;
+    local: LocalSessionAccount;
+    remote: RemoteSessionAccount;
+};
+type Params = {
+    storage: StorageAdapter;
+};
+export declare const createSsoSessionStorage: ({ storage }: Params) => {
+    add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+    filter(fn: (value: UserSession) => boolean): import("neverthrow").ResultAsync<UserSession[], Error>;
+    mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+    read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+    write(value: UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+    clear(): import("neverthrow").ResultAsync<void, Error>;
+    subscribe(fn: (value: UserSession[]) => void): VoidFunction;
+};
+export {};

package/dist/sso/session/ssoSessionStorage.js

@@ -0,0 +1,20 @@
+import { LocalSessionAccountCodec, RemoteSessionAccountCodec } from '@novasamatech/statement-store';
+import { fieldListView } from '@novasamatech/storage-adapter';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Struct, Vector, str } from 'scale-ts';
+const userSessionCodec = Struct({
+    id: str,
+    local: LocalSessionAccountCodec,
+    remote: RemoteSessionAccountCodec,
+});
+const userSessionsCodec = Vector(userSessionCodec);
+export const createSsoSessionStorage = ({ storage }) => {
+    return fieldListView({
+        storage,
+        key: 'Sessions',
+        autosync: true,
+        initial: [],
+        from: x => userSessionsCodec.dec(fromHex(x)),
+        to: x => toHex(userSessionsCodec.enc(x)),
+    });
+};

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

@@ -0,0 +1,6 @@
+import type { EncrSecret, SharedSecret, SsSecret } from '../../modules/crypto.js';
+export type UserSecrets = {
+    sharedSecret: SharedSecret;
+    encr: EncrSecret;
+    ss: SsSecret;
+};

package/dist/sso/session/types.js

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

package/dist/sso/session/userSessionStorage.d.ts

@@ -0,0 +1,21 @@
+import type { LocalSessionAccount, RemoteSessionAccount } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+export type UserSessionStorage = ReturnType<typeof createUserSessionStorage>;
+export type UserSession = {
+    id: string;
+    local: LocalSessionAccount;
+    remote: RemoteSessionAccount;
+};
+type Params = {
+    storage: StorageAdapter;
+};
+export declare const createUserSessionStorage: ({ storage }: Params) => {
+    add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+    filter(fn: (value: UserSession) => boolean): import("neverthrow").ResultAsync<UserSession[], Error>;
+    mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+    read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+    write(value: UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+    clear(): import("neverthrow").ResultAsync<void, Error>;
+    subscribe(fn: (value: UserSession[]) => void): VoidFunction;
+};
+export {};

package/dist/sso/session/userSessionStorage.js

@@ -0,0 +1,20 @@
+import { LocalSessionAccountCodec, RemoteSessionAccountCodec } from '@novasamatech/statement-store';
+import { fieldListView } from '@novasamatech/storage-adapter';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Struct, Vector, str } from 'scale-ts';
+const userSessionCodec = Struct({
+    id: str,
+    local: LocalSessionAccountCodec,
+    remote: RemoteSessionAccountCodec,
+});
+const userSessionsCodec = Vector(userSessionCodec);
+export const createUserSessionStorage = ({ storage }) => {
+    return fieldListView({
+        storage,
+        key: 'Sessions',
+        autosync: true,
+        initial: [],
+        from: x => userSessionsCodec.dec(fromHex(x)),
+        to: x => toHex(userSessionsCodec.enc(x)),
+    });
+};

package/dist/sso/sessionManager/impl.d.ts

@@ -0,0 +1,22 @@
+import type { StatementStoreAdapter } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { Callback } from '../../types.js';
+import type { UserSecretRepository } from '../userSecretRepository.js';
+import type { StoredUserSession, UserSessionRepository } from '../userSessionRepository.js';
+import type { UserSession } from './userSession.js';
+export type SsoSessionManager = ReturnType<typeof createSsoSessionManager>;
+type Params = {
+    storage: StorageAdapter;
+    statementStore: StatementStoreAdapter;
+    ssoSessionRepository: UserSessionRepository;
+    userSecretRepository: UserSecretRepository;
+};
+export declare function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, statementStore, storage, }: Params): {
+    sessions: {
+        read: () => UserSession[];
+        subscribe: (callback: Callback<UserSession[]>) => () => void;
+    };
+    disconnect(userSession: StoredUserSession): import("neverthrow").ResultAsync<undefined, Error>;
+    dispose(): void;
+};
+export {};

package/dist/sso/sessionManager/impl.js

@@ -0,0 +1,71 @@
+import { createEncryption } from '@novasamatech/statement-store';
+import { okAsync } from 'neverthrow';
+import { createState } from '../../helpers/state.js';
+import { createSsoStatementProver } from '../ssoSessionProver.js';
+import { createUserSession } from './userSession.js';
+export function createSsoSessionManager({ ssoSessionRepository, userSecretRepository, statementStore, storage, }) {
+    const localSessions = createState({});
+    const disconnect = (session) => {
+        return ssoSessionRepository.filter(s => s.id !== session.id).map(() => undefined);
+    };
+    ssoSessionRepository.subscribe(userSessions => {
+        const activeSessions = localSessions.read();
+        const toRemove = new Set(Object.keys(activeSessions));
+        const toAdd = new Set();
+        for (const userSession of userSessions) {
+            if (userSession.id in activeSessions)
+                continue;
+            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            toRemove.delete(userSession.id);
+            toAdd.add(session);
+            session.subscribe(message => {
+                switch (message.data.tag) {
+                    case 'v1': {
+                        switch (message.data.value.tag) {
+                            case 'Disconnected':
+                                return disconnect(userSession).map(() => true);
+                        }
+                    }
+                }
+                return okAsync(false);
+            });
+        }
+        if (toRemove.size > 0) {
+            localSessions.write(prev => {
+                return Object.fromEntries(Object.entries(prev).filter(([id]) => !toRemove.has(id)));
+            });
+        }
+        if (toAdd.size > 0) {
+            localSessions.write(prev => ({
+                ...prev,
+                ...Object.fromEntries(Array.from(toAdd).map(s => [s.id, s])),
+            }));
+        }
+    });
+    return {
+        sessions: {
+            read: () => Object.values(localSessions.read()),
+            subscribe: (callback) => localSessions.subscribe(sessions => callback(Object.values(sessions))),
+        },
+        disconnect(userSession) {
+            const session = createSession(userSession, statementStore, storage, userSecretRepository);
+            return session.sendDisconnectMessage().andThen(() => disconnect(userSession));
+        },
+        dispose() {
+            for (const session of Object.values(localSessions.read())) {
+                session.dispose();
+            }
+        },
+    };
+}
+function createSession(userSession, statementStore, storage, userSecretRepository) {
+    const encryption = createEncryption(userSession.remoteAccount.publicKey);
+    const prover = createSsoStatementProver(userSession, userSecretRepository);
+    return createUserSession({
+        userSession,
+        statementStore,
+        encryption,
+        storage,
+        prover,
+    });
+}

package/dist/sso/sessionManager/repository/ssoSessionRepository.d.ts

@@ -0,0 +1,22 @@
+import type { LocalSessionAccount, RemoteSessionAccount } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+export type SsoSessionRepository = ReturnType<typeof createSsoSessionRepository>;
+export type UserSession = {
+    id: string;
+    local: LocalSessionAccount;
+    remote: RemoteSessionAccount;
+};
+export declare function createUserSession(localAccount: LocalSessionAccount, remoteAccount: RemoteSessionAccount): UserSession;
+type Params = {
+    storage: StorageAdapter;
+};
+export declare const createSsoSessionRepository: ({ storage }: Params) => {
+    add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
+    filter(fn: (value: UserSession) => boolean): import("neverthrow").ResultAsync<UserSession[], Error>;
+    mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
+    read(): import("neverthrow").ResultAsync<UserSession[], Error>;
+    write(value: UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+    clear(): import("neverthrow").ResultAsync<void, Error>;
+    subscribe(fn: (value: UserSession[]) => void): VoidFunction;
+};
+export {};

package/dist/sso/sessionManager/repository/ssoSessionRepository.js

@@ -0,0 +1,27 @@
+import { LocalSessionAccountCodec, RemoteSessionAccountCodec } from '@novasamatech/statement-store';
+import { fieldListView } from '@novasamatech/storage-adapter';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { nanoid } from 'nanoid';
+import { Struct, Vector, str } from 'scale-ts';
+const userSessionCodec = Struct({
+    id: str,
+    local: LocalSessionAccountCodec,
+    remote: RemoteSessionAccountCodec,
+});
+export function createUserSession(localAccount, remoteAccount) {
+    return {
+        id: nanoid(12),
+        local: localAccount,
+        remote: remoteAccount,
+    };
+}
+const userSessionsCodec = Vector(userSessionCodec);
+export const createSsoSessionRepository = ({ storage }) => {
+    return fieldListView({
+        storage,
+        key: 'SsoSessions',
+        initial: [],
+        from: x => userSessionsCodec.dec(fromHex(x)),
+        to: x => toHex(userSessionsCodec.enc(x)),
+    });
+};