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

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

@@ -0,0 +1,53 @@
+import type { LazyClient, StatementStoreAdapter } from '@novasamatech/statement-store';
+import { ResultAsync } from 'neverthrow';
+import type { UserSecretRepository } from '../userSecretRepository.js';
+import type { StoredUserSession, UserSessionRepository } from '../userSessionRepository.js';
+export type AuthComponent = ReturnType<typeof createAuth>;
+type Params = {
+    metadata: string;
+    statementStore: StatementStoreAdapter;
+    ssoSessionRepository: UserSessionRepository;
+    userSecretRepository: UserSecretRepository;
+    lazyClient: LazyClient;
+};
+export declare function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }: Params): {
+    status: {
+        read: () => {
+            step: "none";
+        } | {
+            step: "initial";
+        } | {
+            step: "attestation";
+        } | {
+            step: "pairing";
+            payload: string;
+        } | {
+            step: "error";
+            message: string;
+        } | {
+            step: "finished";
+            session: StoredUserSession;
+        };
+        subscribe: (fn: (value: {
+            step: "none";
+        } | {
+            step: "initial";
+        } | {
+            step: "attestation";
+        } | {
+            step: "pairing";
+            payload: string;
+        } | {
+            step: "error";
+            message: string;
+        } | {
+            step: "finished";
+            session: StoredUserSession;
+        }) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
+    authenticate(): ResultAsync<StoredUserSession | null, Error>;
+    abortAuthentication(): void;
+};
+export {};

package/dist/sso/auth/impl.js

@@ -0,0 +1,161 @@
+import { createAccountId, createEncryption, createLocalSessionAccount, createRemoteSessionAccount, khash, } from '@novasamatech/statement-store';
+import { mergeUint8, toHex } from '@polkadot-api/utils';
+import { generateMnemonic } from '@polkadot-labs/hdkd-helpers';
+import { Result, ResultAsync, err, fromPromise, fromThrowable, ok } from 'neverthrow';
+import { createEncrSecret, createSharedSecret, deriveSr25519Account, getEncrPub, 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 { createAliceVerifier, createAttestationService } from './attestationService.js';
+import { HandshakeData, HandshakeResponsePayload, HandshakeResponseSensitiveData } from './scale/handshake.js';
+export function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }) {
+    const authStatus = createState({ step: 'none' });
+    let authResult = null;
+    let abort = null;
+    function attestateAccount(account, signal) {
+        const attestationService = createAttestationService(lazyClient);
+        authStatus.write({ step: 'attestation' });
+        const verifier = createAliceVerifier();
+        const username = attestationService.claimUsername();
+        return attestationService
+            .grantVerifierAllowance(verifier)
+            .andThrough(() => processSignal(signal))
+            .andThen(() => attestationService.registerLitePerson(username, account, verifier))
+            .andThrough(() => processSignal(signal));
+    }
+    function handshake(account, mnemonic, signal) {
+        const localAccount = createLocalSessionAccount(createAccountId(account.publicKey));
+        return createEncrKeys(mnemonic).asyncAndThen(({ encrSecret, encrPublicKey }) => {
+            const handshakePayload = createHandshakePayloadV1({
+                ssPublicKey: account.publicKey,
+                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: account.secret, encrSecret, mnemonic }));
+            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))));
+        });
+    }
+    const authModule = {
+        status: readonly(authStatus),
+        authenticate() {
+            if (authResult) {
+                return authResult;
+            }
+            abort = new AbortController();
+            const signal = abort.signal;
+            const mnemonic = generateMnemonic();
+            const account = deriveSr25519Account(mnemonic, '//wallet');
+            authStatus.write({ step: 'initial' });
+            authResult = attestateAccount(account, signal)
+                .andThen(() => handshake(account, mnemonic, signal))
+                .andTee(session => {
+                authStatus.write(session ? { step: 'finished', session } : { step: 'none' });
+            })
+                .orTee(e => {
+                authResult = null;
+                abort = null;
+                authStatus.write({ step: 'error', message: e.message });
+            });
+            return authResult;
+        },
+        abortAuthentication() {
+            if (abort) {
+                abort.abort(new AbortError('Aborted by user.'));
+                abort = null;
+            }
+            authResult = null;
+            authStatus.reset();
+        },
+    };
+    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');
+    }
+}
+const createEncrKeys = fromThrowable((mnemonic) => {
+    const encrSecret = createEncrSecret(mnemonic);
+    return {
+        encrSecret,
+        encrPublicKey: getEncrPub(encrSecret),
+    };
+}, toError);
+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);
+    });
+}
+function createDeeplink(payload) {
+    return `polkadotapp://pair?handshake=${toHex(payload)}`;
+}
+function waitForStatements(subscribe, signal, callback) {
+    return fromPromise(new Promise((resolve, reject) => {
+        const unsubscribe = subscribe(statements => {
+            const abortError = processSignal(signal).match(() => null, e => e);
+            if (abortError) {
+                unsubscribe();
+                reject(abortError);
+                return;
+            }
+            try {
+                callback(statements, value => {
+                    unsubscribe();
+                    resolve(value);
+                });
+            }
+            catch (e) {
+                unsubscribe();
+                reject(e);
+            }
+        });
+    }), toError);
+}
+function processSignal(signal) {
+    try {
+        signal.throwIfAborted();
+        return ok();
+    }
+    catch (e) {
+        return err(toError(e));
+    }
+}

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,17 @@
+import type { StoredUserSession } from '../userSessionRepository.js';
+export type AuthentificationStatus = {
+    step: 'none';
+} | {
+    step: 'initial';
+} | {
+    step: 'attestation';
+} | {
+    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/attestationService.d.ts

@@ -0,0 +1,5 @@
+import type { LazyClient } from '@novasamatech/statement-store';
+import type { IdentityRepository } from '../../identity/types.js';
+export declare const createAttestationService: (lazyClient: LazyClient, identity: IdentityRepository) => {
+    claimUsername(name: string): void;
+};

package/dist/sso/sessionManager/attestationService.js

@@ -0,0 +1,15 @@
+export const createAttestationService = (lazyClient, identity) => {
+    function generateSuffix(length) {
+        let suffix = '';
+        for (let i = 0; i < length; i++) {
+            suffix += (Math.random() * 9).toFixed();
+        }
+        return suffix;
+    }
+    return {
+        claimUsername(name) {
+            const client = lazyClient.getClient();
+            const api = client.getUnsafeApi();
+        },
+    };
+};

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 {};