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

package/dist/sso/sessionManager/ssoSessionProver.js

@@ -1,35 +0,0 @@
-import { getStatementSigner, statementCodec } from '@polkadot-api/sdk-statement';
-import { err, errAsync, fromThrowable, ok, okAsync } from 'neverthrow';
-import { compact } from 'scale-ts';
-import { toError } from '../../helpers/utils.js';
-import { getSsPub, signWithSsSecret, verifyWithSsSecret } from '../../modules/crypto.js';
-const verify = fromThrowable(verifyWithSsSecret, toError);
-export function createSsoStatementProver(userSession, userSecretRepository) {
-    const secret = userSecretRepository
-        .read(userSession.id)
-        .andThen(secrets => (secrets ? ok(secrets) : err(new Error(`Secrets for session ${userSession.id} not found.`))))
-        .map(x => x.ssSecret);
-    return {
-        generateMessageProof(statement) {
-            return secret.map(secret => {
-                const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
-                return signer.sign(statement);
-            });
-        },
-        verifyMessageProof(statement) {
-            const { proof, ...unsigned } = statement;
-            if (!proof) {
-                // TODO should we pass check when proof is not presented?
-                return okAsync(true);
-            }
-            const encoded = statementCodec.enc(unsigned);
-            const compactLen = compact.enc(compact.dec(encoded)).length;
-            switch (proof.type) {
-                case 'sr25519':
-                    return verify(encoded.slice(compactLen), proof.value.signature.asBytes(), proof.value.signer.asBytes()).asyncAndThen(x => okAsync(x));
-                default:
-                    return errAsync(new Error(`Proof type ${proof.type} is not supported.`));
-            }
-        },
-    };
-}

package/dist/sso/ssoSessionRepository.d.ts

@@ -1,18 +0,0 @@
-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;
-export declare const createSsoSessionRepository: (storage: StorageAdapter) => {
-    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;
-};

package/dist/sso/ssoSessionRepository.js

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

package/dist/structs.d.ts

@@ -1,24 +0,0 @@
-import type { Codec } from 'scale-ts';
-export type TransportError = 'decryptionFailed' | 'decodingFailed' | 'unknown';
-export declare const TransportErrorCodec: Codec<TransportError>;
-export declare const Request: <T>(data: Codec<T>) => Codec<{
-    requestId: string;
-    data: T[];
-}>;
-export declare const Response: Codec<{
-    requestId: string;
-    responseCode: TransportError;
-}>;
-export declare const StatementData: <T>(data: Codec<T>) => Codec<{
-    tag: "request";
-    value: {
-        requestId: string;
-        data: T[];
-    };
-} | {
-    tag: "response";
-    value: {
-        requestId: string;
-        responseCode: TransportError;
-    };
-}>;

package/dist/structs.js

@@ -1,36 +0,0 @@
-import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
-export const TransportErrorCodec = enhanceCodec(u8, error => {
-    switch (error) {
-        case 'decryptionFailed':
-            return 1;
-        case 'decodingFailed':
-            return 2;
-        case 'unknown':
-            return 255;
-    }
-}, code => {
-    switch (code) {
-        case 1:
-            return 'decryptionFailed';
-        case 2:
-            return 'decodingFailed';
-        default:
-            return 'unknown';
-    }
-});
-export const Request = (data) => {
-    return Struct({
-        requestId: str,
-        data: Vector(data),
-    });
-};
-export const Response = Struct({
-    requestId: str,
-    responseCode: TransportErrorCodec,
-});
-export const StatementData = (data) => {
-    return Enum({
-        request: Request(data),
-        response: Response,
-    });
-};