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

package/dist/adapters/identity/rpc.d.ts

@@ -1,6 +1,6 @@
+import type { LazyClient } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
 import { ResultAsync } from 'neverthrow';
-import type { LazyClientAdapter } from '../lazyClient/types.js';
-import type { StorageAdapter } from '../storage/types.js';
 import type { Identity, IdentityAdapter } from './types.js';
 export declare function createCachedIdentityRequester(storage: StorageAdapter, getKey: (accountId: string) => string, request: (accounts: string[]) => ResultAsync<(Identity | null)[], Error>): (accounts: string[]) => ResultAsync<Record<string, Identity | null>, Error>;
-export declare function createIdentityRpcAdapter(lazyClient: LazyClientAdapter, storage: StorageAdapter): IdentityAdapter;
+export declare function createIdentityRpcAdapter(lazyClient: LazyClient, storage: StorageAdapter): IdentityAdapter;

package/dist/components/sso/index.d.ts

@@ -0,0 +1,36 @@
+import type { Transport } from '@novasamatech/statement-store';
+import type { ResultAsync } from 'neverthrow';
+import type { UserSession, UserSessionStorage } from '../user/userSessionStorage.js';
+import type { AuthentificationStatus } from './types.js';
+export type AuthComponent = ReturnType<typeof createAuthComponent>;
+type Params = {
+    /**
+     * Host app Id.
+     * CAUTION! This value should be stable.
+     */
+    appId: string;
+    /**
+     * URL for additional metadata that will be displayed during pairing process.
+     * Content of provided json shound be
+     * ```ts
+     * interface Metadata {
+     *   name: string;
+     *   icon: string; // url for icon. Icon should be a rasterized image with min size 256x256 px.
+     * }
+     * ```
+     */
+    metadata: string;
+    transport: Transport;
+    userSessionStorage: UserSessionStorage;
+};
+export declare function createAuthComponent({ appId, metadata, transport, userSessionStorage }: Params): {
+    status: {
+        read: () => AuthentificationStatus;
+        subscribe: (fn: (value: AuthentificationStatus) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
+    authenticate(): ResultAsync<UserSession | null, Error>;
+    abortAuthentication(): void;
+};
+export {};

package/dist/components/sso/index.js

@@ -0,0 +1,150 @@
+import { createAccountId, createLocalSessionAccount } from '@novasamatech/statement-store';
+import { toHex } from '@polkadot-api/utils';
+import { err, errAsync, fromPromise, fromThrowable, ok } from 'neverthrow';
+import { AbortError } from '../../helpers/abortError.js';
+import { toError } from '../../helpers/utils.js';
+import { ENCR_SECRET_SEED_SIZE, SS_SECRET_SEED_SIZE, createEncrSecret, createRandomSeed, createSharedSecret, createSsHardDerivation, createSsSecret, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from '../../modules/crypto.js';
+import { createState, readonly } from '../../modules/state.js';
+import { createUserSession } from '../../modules/statementStore.js';
+import { HandshakeData, HandshakeResponsePayload, HandshakeResponseSensitiveData } from './scale/handshake.js';
+export function createAuthComponent({ appId, metadata, transport, userSessionStorage }) {
+    const authStatus = createState({ step: 'none' });
+    let authResults = null;
+    let abort = null;
+    function handshake(signal) {
+        try {
+            authStatus.write({ step: 'initial' });
+            const { encrSecret, encrPublicKey, ssPublicKey } = getSecretKeys(appId);
+            const localAccount = createLocalSessionAccount(createAccountId(ssPublicKey));
+            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata }).andTee(payload => authStatus.write({ step: 'pairing', payload: createDeeplink(payload) }));
+            const handshakeTopic = createHandshakeTopic(localAccount, encrPublicKey);
+            const pappResponse = handshakePayload
+                .andThen(() => handshakeTopic)
+                .asyncAndThen(topic => waitForStatements(callback => transport.subscribeSession(topic, callback), signal, (statements, resolve) => {
+                for (const statement of [...statements].reverse()) {
+                    if (!statement.data)
+                        continue;
+                    const session = retrieveSession({
+                        hostAccount: localAccount,
+                        encrSecret,
+                        payload: statement.data.asBytes(),
+                    });
+                    resolve(session);
+                    break;
+                }
+            }));
+            const userCreated = pappResponse.andThen(userSessionStorage.add);
+            return userCreated
+                .orElse(e => (AbortError.isAbortError(e) ? ok(null) : err(toError(e))))
+                .andTee(session => {
+                if (session) {
+                    authStatus.write({ step: 'finished', session });
+                }
+                else {
+                    authStatus.write({ step: 'none' });
+                }
+            })
+                .orTee(e => authStatus.write({ step: 'error', message: e.message }));
+        }
+        catch (e) {
+            return errAsync(toError(e));
+        }
+    }
+    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, mergeBytes(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, hostAccount, }) {
+    const { encrypted, tmpKey } = parseHandshakePayload(payload);
+    const symmetricKey = createSharedSecret(encrSecret, tmpKey);
+    const decrypted = decrypt(symmetricKey, encrypted);
+    const [pappEncrPublicKey, pappAccountId] = HandshakeResponseSensitiveData.dec(decrypted);
+    const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
+    const peerAccount = createAccount(pappAccountId, sharedSecret);
+    return createUserSession(hostAccount, peerAccount);
+}
+function getSsKeys(appId) {
+    const seed = createRandomSeed(appId, SS_SECRET_SEED_SIZE);
+    const ssSecret = createSsHardDerivation(createSsSecret(seed), '//wallet');
+    return {
+        ssSecret: ssSecret,
+        ssPublicKey: getSsPub(ssSecret),
+    };
+}
+function getEncrKeys(appId) {
+    const seed = createRandomSeed(appId, ENCR_SECRET_SEED_SIZE);
+    const encrSecret = createEncrSecret(seed);
+    return {
+        encrSecret,
+        encrPublicKey: getEncrPub(encrSecret),
+    };
+}
+function getSecretKeys(appId) {
+    const ss = getSsKeys(appId);
+    const encr = getEncrKeys(appId);
+    return {
+        ...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/components/sso/scale/handshake.d.ts

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

@@ -0,0 +1,10 @@
+import { Bytes, Enum, Tuple, str } from 'scale-ts';
+import { EncrPubKey, SsPubKey } from '../../../modules/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/components/sso/types.d.ts

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

package/dist/components/sso/types.js

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

package/dist/components/user/index.d.ts

@@ -11,9 +11,9 @@ export declare function createUserSessionsComponent({ userSessionStorage, storag
     sessions: {
         add(value: UserSession): 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<null, Error> | import("neverthrow").ResultAsync<UserSession[], Error>;
-        clear(): import("neverthrow").ResultAsync<void, Error>;
+        read(): any;
+        write(value: UserSession[]): any;
+        clear(): any;
         subscribe(fn: (value: UserSession[]) => void): () => void;
     };
     disconnect: (session: UserSession) => import("neverthrow").ResultAsync<undefined, Error>;

package/dist/components/user/userSessionStorage.d.ts

@@ -12,9 +12,9 @@ type Params = {
 export declare const createUserSessionStorage: ({ storage }: Params) => {
     add(value: UserSession): 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<null, Error> | import("neverthrow").ResultAsync<UserSession[], Error>;
-    clear(): import("neverthrow").ResultAsync<void, Error>;
+    read(): any;
+    write(value: UserSession[]): any;
+    clear(): any;
     subscribe(fn: (value: UserSession[]) => void): () => void;
 };
 export {};

package/dist/components/user/userSessionStorage.js

@@ -1,4 +1,4 @@
-import { fromHex, toHex } from 'polkadot-api/utils';
+import { fromHex, toHex } from '@polkadot-api/utils';
 import { Bytes, Option, Struct, Vector, str } from 'scale-ts';
 import { storageListView } from '../../modules/storageView.js';
 const accountCodec = Struct({

package/dist/crypto.d.ts

@@ -0,0 +1,23 @@
+import type { Codec } from 'scale-ts';
+import type { Branded } from './types.js';
+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 const SS_SECRET_SEED_SIZE = 32;
+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 getEncrPub(secret: EncrSecret): EncrPublicKey;
+export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;

package/dist/crypto.js

@@ -0,0 +1,51 @@
+import { p256 } from '@noble/curves/nist.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+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
+export function BrandedBytesCodec(length) {
+    return Bytes(length);
+}
+export const SsPubKey = BrandedBytesCodec(32);
+export const EncrPubKey = BrandedBytesCodec(65);
+// helpers
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export function stringToBytes(str) {
+    return textEncoder.encode(str);
+}
+export function bytesToString(bytes) {
+    return textDecoder.decode(bytes);
+}
+// statement store key pair
+export const SS_SECRET_SEED_SIZE = 32;
+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 = randomBytes(ENCR_SECRET_SEED_SIZE)) {
+    const { secretKey } = p256.keygen(seed);
+    return secretKey;
+}
+export function getEncrPub(secret) {
+    return p256.getPublicKey(secret, false);
+}
+export function createSharedSecret(secret, publicKey) {
+    // slicing first byte: @noble/curves adds y offset at the start
+    return p256.getSharedSecret(secret, publicKey).slice(1, 33);
+}

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/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,38 @@
+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(accCodec.dec)]), 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];
+                    }
+                    console.log(raw.credibility);
+                    return [
+                        accountId,
+                        {
+                            accountId: accountId,
+                            fullUsername: raw.full_username ? raw.full_username.asText() : null,
+                            liteUsername: raw.lite_username ? raw.lite_username.asText() : null,
+                            credibility: raw.credibility.type,
+                        },
+                    ];
+                })));
+            });
+        },
+    };
+}

package/dist/identity/types.d.ts

@@ -0,0 +1,22 @@
+import type { ResultAsync } from 'neverthrow';
+type Credibility = {
+    type: 'Lite';
+} | {
+    type: 'Person';
+    alias: number;
+    lastUpdate: bigint;
+};
+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>;
+};
+export {};

package/dist/identity/types.js

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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { PappAdapter } from './papp.js';
-export type { AuthentificationStatus } from './components/auth/types.js';
-export type { UserSession } from './components/user/userSessionStorage.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';

package/dist/index.js

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

package/dist/modules/crypto.d.ts

@@ -6,22 +6,18 @@ 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): SharedSecret;
-export declare function encrypt(secret: Uint8Array, cipherText: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare function decrypt(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;