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

package/dist/sso/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)),
+    });
+};

package/dist/sso/userSecretRepository.d.ts

@@ -0,0 +1,17 @@
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { ResultAsync } from 'neverthrow';
+import type { CodecType } from 'scale-ts';
+import type { EncrSecret, SsSecret } from '../crypto.js';
+type StoredUserSecrets = CodecType<typeof StoredUserSecretsCodec>;
+declare const StoredUserSecretsCodec: import("scale-ts").Codec<{
+    ssSecret: SsSecret;
+    encrSecret: EncrSecret;
+    mnemonic: string;
+}>;
+export type UserSecretRepository = ReturnType<typeof createUserSecretRepository>;
+export declare function createUserSecretRepository(salt: string, storage: StorageAdapter): {
+    read(sessionId: string): ResultAsync<StoredUserSecrets | null, Error>;
+    write(sessionId: string, value: StoredUserSecrets): ResultAsync<void, Error>;
+    clear(sessionId: string): ResultAsync<void, Error>;
+};
+export {};

package/dist/sso/userSecretRepository.js

@@ -0,0 +1,45 @@
+import { gcm } from '@noble/ciphers/aes.js';
+import { blake2b } from '@noble/hashes/blake2.js';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { fromThrowable } from 'neverthrow';
+import { Struct, str } from 'scale-ts';
+import { BrandedBytesCodec, stringToBytes } from '../crypto.js';
+import { toError } from '../helpers/utils.js';
+const StoredUserSecretsCodec = Struct({
+    ssSecret: BrandedBytesCodec(),
+    encrSecret: BrandedBytesCodec(),
+    mnemonic: str,
+});
+export function createUserSecretRepository(salt, storage) {
+    const baseKey = 'UserSecrets';
+    const encode = fromThrowable(StoredUserSecretsCodec.enc, toError);
+    const decode = fromThrowable((value) => (value ? StoredUserSecretsCodec.dec(value) : null), toError);
+    const encrypt = fromThrowable((value) => {
+        const aes = getAes(salt);
+        return toHex(aes.encrypt(value));
+    }, toError);
+    const decrypt = fromThrowable((value) => {
+        if (value === null) {
+            return null;
+        }
+        const aes = getAes(salt);
+        return aes.decrypt(fromHex(value));
+    }, toError);
+    return {
+        read(sessionId) {
+            return storage.read(createKey(baseKey, sessionId)).andThen(decrypt).andThen(decode);
+        },
+        write(sessionId, value) {
+            return encode(value)
+                .andThen(encrypt)
+                .asyncAndThen(value => storage.write(createKey(baseKey, sessionId), value));
+        },
+        clear(sessionId) {
+            return storage.clear(createKey(baseKey, sessionId));
+        },
+    };
+}
+const createKey = (key, context) => `${key}_${context}`;
+function getAes(salt) {
+    return gcm(blake2b(stringToBytes(salt), { dkLen: 16 }), blake2b(stringToBytes('nonce'), { dkLen: 32 }));
+}

package/dist/sso/userSessionRepository.d.ts

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

package/dist/sso/userSessionRepository.js

@@ -0,0 +1,26 @@
+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 storedUserSessionCodec = Struct({
+    id: str,
+    localAccount: LocalSessionAccountCodec,
+    remoteAccount: RemoteSessionAccountCodec,
+});
+export function createStoredUserSession(localAccount, remoteAccount) {
+    return {
+        id: nanoid(12),
+        localAccount: localAccount,
+        remoteAccount: remoteAccount,
+    };
+}
+export const createUserSessionRepository = (storage) => {
+    const codec = Vector(storedUserSessionCodec);
+    return fieldListView({
+        storage,
+        key: 'SsoSessions',
+        from: x => codec.dec(fromHex(x)),
+        to: x => toHex(codec.enc(x)),
+    });
+};

package/dist/structs.d.ts

@@ -1,24 +1,24 @@
-type TransportError = 'decryptionFailed' | 'decodingFailed' | 'unknown';
-export declare const ResponseCode: import("scale-ts").Codec<TransportError>;
-export declare const RequestV1: import("scale-ts").Codec<{
+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: Uint8Array<ArrayBufferLike>;
+    data: T[];
 }>;
-export declare const ResponseV1: import("scale-ts").Codec<{
+export declare const Response: Codec<{
     requestId: string;
     responseCode: TransportError;
 }>;
-export declare const StatementData: import("scale-ts").Codec<{
-    tag: "requestV1";
+export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+    tag: "request";
     value: {
         requestId: string;
-        data: Uint8Array<ArrayBufferLike>;
+        data: T[];
     };
 } | {
-    tag: "responseV1";
+    tag: "response";
     value: {
         requestId: string;
         responseCode: TransportError;
     };
 }>;
-export {};

package/dist/structs.js

@@ -1,12 +1,12 @@
-import { Bytes, Enum, Struct, enhanceCodec, str, u8 } from 'scale-ts';
-export const ResponseCode = enhanceCodec(u8, error => {
+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 -1;
+            return 255;
     }
 }, code => {
     switch (code) {
@@ -18,15 +18,19 @@ export const ResponseCode = enhanceCodec(u8, error => {
             return 'unknown';
     }
 });
-export const RequestV1 = Struct({
+export const Request = (data) => {
+    return Struct({
+        requestId: str,
+        data: Vector(data),
+    });
+};
+export const Response = Struct({
     requestId: str,
-    data: Bytes(),
-});
-export const ResponseV1 = Struct({
-    requestId: str,
-    responseCode: ResponseCode,
-});
-export const StatementData = Enum({
-    requestV1: RequestV1,
-    responseV1: ResponseV1,
+    responseCode: TransportErrorCodec,
 });
+export const StatementData = (data) => {
+    return Enum({
+        request: Request(data),
+        response: Response,
+    });
+};

package/dist/types.d.ts

@@ -2,5 +2,5 @@ declare const __brand: unique symbol;
 export type Branded<T, K extends string> = T & {
     [__brand]: K;
 };
-export type SessionTopic = Branded<Uint8Array, 'SessionTopic'>;
+export type Callback<T, R = unknown> = (value: T) => R;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-papp",
   "type": "module",
-  "version": "0.5.0-0",
+  "version": "0.5.0-10",
   "description": "Polkadot app integration",
   "license": "Apache-2.0",
   "repository": {
@@ -21,18 +21,25 @@
   },
   "files": [
     "dist",
+    ".papi",
     "README.md"
   ],
   "dependencies": {
-    "@polkadot-api/utils": "0.2.0",
-    "@polkadot-api/sdk-statement": "0.2.0",
-    "@scure/sr25519": "0.3.0",
+    "@noble/ciphers": "2.1.1",
     "@noble/curves": "2.0.1",
     "@noble/hashes": "2.0.1",
-    "@noble/ciphers": "2.0.1",
-    "polkadot-api": "1.22.0",
+    "@novasamatech/host-api": "0.5.0-10",
+    "@novasamatech/statement-store": "0.5.0-10",
+    "@novasamatech/storage-adapter": "0.5.0-10",
+    "@polkadot-api/substrate-bindings": "^0.16.5",
+    "@polkadot-labs/hdkd-helpers": "^0.0.27",
+    "@scure/sr25519": "1.0.0",
     "nanoevents": "9.1.0",
-    "scale-ts": "1.6.1"
+    "nanoid": "5.1.6",
+    "neverthrow": "^8.2.0",
+    "polkadot-api": "^1.23.1",
+    "scale-ts": "1.6.1",
+    "verifiablejs": "1.1.0"
   },
   "publishConfig": {
     "access": "public"