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

package/dist/sso/session/userSessionStorage.js

@@ -1,20 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/repository/ssoSessionRepository.d.ts

@@ -1,22 +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;
-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

@@ -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/sso/sessionManager/scale/signRequest.d.ts

@@ -1,19 +0,0 @@
-import type { CodecType } from 'scale-ts';
-export type SignRequest = CodecType<typeof SignRequestCodec>;
-export declare const SignRequestCodec: import("scale-ts").Codec<{
-    address: string;
-    blockHash: `0x${string}`;
-    blockNumber: `0x${string}`;
-    era: `0x${string}`;
-    genesisHash: `0x${string}`;
-    method: string;
-    nonce: `0x${string}`;
-    specVersion: `0x${string}`;
-    tip: `0x${string}`;
-    transactionVersion: `0x${string}`;
-    signedExtensions: string[];
-    version: number;
-    assetId: `0x${string}` | undefined;
-    mode: number | undefined;
-    withSignedTransaction: boolean | undefined;
-}>;

package/dist/sso/sessionManager/scale/signRequest.js

@@ -1,19 +0,0 @@
-import { Option, Struct, Vector, bool, str, u32 } from 'scale-ts';
-import { hexCodec } from './hex.js';
-export const SignRequestCodec = Struct({
-    address: str,
-    blockHash: hexCodec,
-    blockNumber: hexCodec,
-    era: hexCodec,
-    genesisHash: hexCodec,
-    method: str,
-    nonce: hexCodec,
-    specVersion: hexCodec,
-    tip: hexCodec,
-    transactionVersion: hexCodec,
-    signedExtensions: Vector(str),
-    version: u32,
-    assetId: Option(hexCodec),
-    mode: Option(u32),
-    withSignedTransaction: Option(bool),
-});

package/dist/sso/sessionManager/scale/signResponse.d.ts

@@ -1,6 +0,0 @@
-import type { CodecType } from 'scale-ts';
-export type SignResponse = CodecType<typeof SignResponseCodec>;
-export declare const SignResponseCodec: import("scale-ts").Codec<{
-    signature: Uint8Array<ArrayBufferLike>;
-    SignedTransaction: Uint8Array<ArrayBufferLike>;
-}>;

package/dist/sso/sessionManager/scale/signResponse.js

@@ -1,5 +0,0 @@
-import { Bytes, Struct } from 'scale-ts';
-export const SignResponseCodec = Struct({
-    signature: Bytes(),
-    SignedTransaction: Bytes(),
-});

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

@@ -1,23 +0,0 @@
-import type { Encryption, StatementProver, StatementStoreAdapter } from '@novasamatech/statement-store';
-import type { StorageAdapter } from '@novasamatech/storage-adapter';
-import { ResultAsync } from 'neverthrow';
-import type { CodecType } from 'scale-ts';
-import type { Callback } from '../../types.js';
-import type { UserSession } from '../ssoSessionRepository.js';
-import { RemoteMessageCodec, RemoteMessageDataCodec } from './scale/remoteMessage.js';
-export type SsoSession = ReturnType<typeof createSsoSession>;
-export declare function createSsoSession({ userSession, statementStore, encryption, storage, prover, }: {
-    userSession: UserSession;
-    statementStore: StatementStoreAdapter;
-    encryption: Encryption;
-    storage: StorageAdapter;
-    prover: StatementProver;
-}): {
-    request(message: CodecType<typeof RemoteMessageDataCodec>): ResultAsync<{
-        requestId: string;
-    }, Error>;
-    sendDisconnectMessage(): ResultAsync<{
-        requestId: string;
-    }, Error>;
-    subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
-};

package/dist/sso/sessionManager/ssoSession.js

@@ -1,69 +0,0 @@
-import { createSession } from '@novasamatech/statement-store';
-import { fieldListView } from '@novasamatech/storage-adapter';
-import { nanoid } from 'nanoid';
-import { ResultAsync, okAsync } from 'neverthrow';
-import { RemoteMessageCodec, RemoteMessageDataCodec } from './scale/remoteMessage.js';
-export function createSsoSession({ userSession, statementStore, encryption, storage, prover, }) {
-    const session = createSession({
-        localAccount: userSession.local,
-        remoteAccount: userSession.remote,
-        statementStore,
-        encryption,
-        prover,
-    });
-    const processedMessages = fieldListView({
-        storage,
-        key: `sso_processed_${userSession.id}`,
-        from: JSON.parse,
-        to: JSON.stringify,
-        initial: [],
-    });
-    return {
-        request(message) {
-            return session.submitRequest(RemoteMessageCodec, {
-                messageId: nanoid(),
-                data: message,
-            });
-        },
-        sendDisconnectMessage() {
-            return session.submitRequest(RemoteMessageCodec, {
-                messageId: nanoid(),
-                data: {
-                    tag: 'v1',
-                    value: {
-                        tag: 'Disconnected',
-                        value: undefined,
-                    },
-                },
-            });
-        },
-        subscribe(callback) {
-            return session.subscribe(RemoteMessageCodec, messages => {
-                processedMessages.read().andThen(processed => {
-                    const results = messages.map(message => {
-                        if (message.type === 'request') {
-                            const isMessageProcessed = processed.includes(message.data.messageId);
-                            if (isMessageProcessed) {
-                                return okAsync({ processed: false });
-                            }
-                            return callback(message.data)
-                                .orTee(error => {
-                                console.error('Error while processing sso messsage:', error);
-                            })
-                                .orElse(() => okAsync(false))
-                                .map(processed => (processed ? { processed, message: message.data } : { processed }));
-                        }
-                        return okAsync({ processed: false });
-                    });
-                    return ResultAsync.combine(results).andThen(results => {
-                        const newMessages = results.filter(x => x.processed).map(x => x.message.messageId);
-                        if (newMessages.length > 0) {
-                            return processedMessages.mutate(x => x.concat(newMessages));
-                        }
-                        return okAsync();
-                    });
-                });
-            });
-        },
-    };
-}

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

@@ -1,4 +0,0 @@
-import type { StatementProver } from '@novasamatech/statement-store';
-import type { UserSession } from '../ssoSessionRepository.js';
-import type { UserSecretRepository } from '../userSecretRepository.js';
-export declare function createSsoStatementProver(userSession: UserSession, userSecretRepository: UserSecretRepository): StatementProver;

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,
-    });
-};