@novasamatech/host-papp 0.5.0-9 → 0.5.1

package/dist/sso/auth/impl.js

@@ -1,33 +1,57 @@
 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, createSsHardDerivation, createSsSecret, getEncrPub, getSsPub, stringToBytes, } from '../../crypto.js';
+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 }) {
-    const authStatus = createState({ step: 'none' });
-    let authResults = null;
+export function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }) {
+    const attestationStatus = createState({ step: 'none' });
+    const pairingStatus = createState({ step: 'none' });
+    let authResult = null;
     let abort = null;
-    function handshake(signal) {
-        return getSecretKeys()
+    function attestAccount(account, signal) {
+        const attestationService = createAttestationService(lazyClient);
+        const verifier = createAliceVerifier();
+        const username = attestationService.claimUsername();
+        attestationStatus.write({ step: 'attestation', username });
+        return attestationService
+            .grantVerifierAllowance(verifier)
+            .andThrough(() => processSignal(signal))
+            .andThen(() => attestationService.registerLitePerson(username, account, verifier))
+            .andThrough(() => processSignal(signal))
             .andTee(() => {
-            authStatus.write({ step: 'initial' });
+            attestationStatus.write({ step: 'finished' });
         })
-            .asyncAndThen(({ encrSecret, encrPublicKey, ssSecret, ssPublicKey }) => {
-            const localAccount = createLocalSessionAccount(createAccountId(ssPublicKey));
-            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, 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) => {
+            .orTee(e => {
+            if (!(e instanceof AbortError)) {
+                attestationStatus.write({ step: 'attestationError', message: e.message });
+            }
+        });
+    }
+    function handshake(account, signal) {
+        const localAccount = createLocalSessionAccount(createAccountId(account.publicKey));
+        pairingStatus.write({ step: 'initial' });
+        const encrKeys = createEncrKeys(account.entropy);
+        const handshakePayload = encrKeys.andThen(({ publicKey }) => createHandshakePayloadV1({
+            ssPublicKey: account.publicKey,
+            encrPublicKey: publicKey,
+            metadata,
+        }));
+        const handshakeTopic = encrKeys.andThen(({ publicKey }) => createHandshakeTopic(localAccount, publicKey));
+        const dataPrepared = Result.combine([handshakePayload, handshakeTopic, encrKeys]).andTee(([payload]) => pairingStatus.write({ step: 'pairing', payload: createDeeplink(payload) }));
+        return dataPrepared.asyncAndThen(([, handshakeTopic, encrKeys]) => {
+            const pappResponse = waitForStatements(callback => statementStore.subscribeStatements([handshakeTopic], callback), signal, (statements, resolve) => {
                 for (const statement of statements) {
                     if (!statement.data)
                         continue;
                     const session = retrieveSession({
                         localAccount,
-                        encrSecret,
+                        encrSecret: encrKeys.secret,
                         payload: statement.data.asBytes(),
                     }).unwrapOr(null);
                     if (session) {
@@ -35,36 +59,57 @@ export function createAuth({ metadata, statementStore, ssoSessionRepository, use
                         break;
                     }
                 }
-            }));
-            const secretesSaved = pappResponse.andThen(({ id }) => userSecretRepository.write(id, { ssSecret, encrSecret }));
+            });
+            const secretesSaved = pappResponse.andThen(({ id }) => {
+                return userSecretRepository.write(id, {
+                    ssSecret: account.secret,
+                    encrSecret: encrKeys.secret,
+                    entropy: account.entropy,
+                });
+            });
+            // secrets and sso session should be chained, or it can produce an incorrect state
             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 sessionReceived = ResultAsync.combine([userCreated, secretesSaved]).map(([session]) => session);
+            return sessionReceived
                 .andTee(session => {
-                authStatus.write(session ? { step: 'finished', session } : { step: 'none' });
+                pairingStatus.write(session ? { step: 'finished', session } : { step: 'none' });
             })
                 .orTee(e => {
-                authStatus.write({ step: 'error', message: e.message });
+                if (!(e instanceof AbortError)) {
+                    pairingStatus.write({ step: 'pairingError', message: e.message });
+                }
             });
         });
     }
     const authModule = {
-        status: readonly(authStatus),
+        pairingStatus: readonly(pairingStatus),
+        attestationStatus: readonly(attestationStatus),
         authenticate() {
-            if (authResults) {
-                return authResults;
+            if (authResult) {
+                return authResult;
             }
             abort = new AbortController();
-            authResults = handshake(abort.signal);
-            return authResults;
+            const account = deriveSr25519Account(generateMnemonic(), '//wallet//sso');
+            authResult = ResultAsync.combine([handshake(account, abort.signal), attestAccount(account, abort.signal)])
+                .map(([session]) => session)
+                .orElse(e => (e instanceof AbortError ? ok(null) : err(e)))
+                .andTee(() => {
+                abort = null;
+            })
+                .orTee(() => {
+                authResult = null;
+                abort = null;
+            });
+            return authResult;
         },
         abortAuthentication() {
             if (abort) {
-                authResults = null;
-                authStatus.reset();
                 abort.abort(new AbortError('Aborted by user.'));
+                abort = null;
             }
+            authResult = null;
+            pairingStatus.reset();
+            attestationStatus.reset();
         },
     };
     return authModule;
@@ -86,6 +131,13 @@ function parseHandshakePayload(payload) {
             throw new Error('Unsupported handshake payload version');
     }
 }
+const createEncrKeys = fromThrowable((entropy) => {
+    const secret = createEncrSecret(entropy);
+    return {
+        secret,
+        publicKey: getEncrPub(secret),
+    };
+}, toError);
 function retrieveSession({ payload, encrSecret, localAccount, }) {
     const { encrypted, tmpKey } = parseHandshakePayload(payload);
     const symmetricKey = createSharedSecret(encrSecret, tmpKey);
@@ -98,40 +150,17 @@ function retrieveSession({ payload, encrSecret, localAccount, }) {
         return createStoredUserSession(localAccount, peerAccount);
     });
 }
-const getSsKeys = fromThrowable(() => {
-    const ssSecret = createSsHardDerivation(createSsSecret(), '//wallet//sso');
-    return {
-        ssSecret: ssSecret,
-        ssPublicKey: getSsPub(ssSecret),
-    };
-}, toError);
-const getEncrKeys = fromThrowable(() => {
-    const encrSecret = createEncrSecret();
-    return {
-        encrSecret,
-        encrPublicKey: getEncrPub(encrSecret),
-    };
-}, toError);
-function getSecretKeys() {
-    return Result.combine([getSsKeys(), getEncrKeys()]).map(([ss, encr]) => ({
-        ...ss,
-        ...encr,
-    }));
-}
 function createDeeplink(payload) {
     return `polkadotapp://pair?handshake=${toHex(payload)}`;
 }
-function waitForStatements(subscribe, abortSignal, callback) {
+function waitForStatements(subscribe, signal, callback) {
     return fromPromise(new Promise((resolve, reject) => {
         const unsubscribe = subscribe(statements => {
-            if (abortSignal?.aborted) {
+            const abortError = processSignal(signal).match(() => null, e => e);
+            if (abortError) {
                 unsubscribe();
-                try {
-                    abortSignal.throwIfAborted();
-                }
-                catch (e) {
-                    reject(e);
-                }
+                reject(abortError);
+                return;
             }
             try {
                 callback(statements, value => {
@@ -146,3 +175,12 @@ function waitForStatements(subscribe, abortSignal, callback) {
         });
     }), toError);
 }
+function processSignal(signal) {
+    try {
+        signal.throwIfAborted();
+        return ok();
+    }
+    catch (e) {
+        return err(toError(e));
+    }
+}

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

@@ -1,15 +1,28 @@
 import type { StoredUserSession } from '../userSessionRepository.js';
-export type AuthentificationStatus = {
+export type PairingStatus = {
     step: 'none';
 } | {
     step: 'initial';
+} | {
+    step: 'attestation';
 } | {
     step: 'pairing';
     payload: string;
 } | {
-    step: 'error';
+    step: 'pairingError';
     message: string;
 } | {
     step: 'finished';
     session: StoredUserSession;
 };
+export type AttestationStatus = {
+    step: 'none';
+} | {
+    step: 'attestation';
+    username: string;
+} | {
+    step: 'attestationError';
+    message: string;
+} | {
+    step: 'finished';
+};

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

@@ -0,0 +1 @@
+export declare const hexCodec: import("scale-ts").Codec<`0x${string}`>;

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

@@ -0,0 +1,3 @@
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Bytes, enhanceCodec } from 'scale-ts';
+export const hexCodec = enhanceCodec(Bytes(), fromHex, v => toHex(v));

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

@@ -1,13 +1,5 @@
-export declare const RemoteMessageDataCodec: import("scale-ts").Codec<{
-    tag: "v1";
-    value: {
-        tag: "Disconnected";
-        value: undefined;
-    } | {
-        tag: "SigningRequest";
-        value: Uint8Array<ArrayBufferLike>;
-    };
-}>;
+import type { CodecType } from 'scale-ts';
+export type RemoteMessage = CodecType<typeof RemoteMessageCodec>;
 export declare const RemoteMessageCodec: import("scale-ts").Codec<{
     messageId: string;
     data: {
@@ -16,8 +8,34 @@ export declare const RemoteMessageCodec: import("scale-ts").Codec<{
             tag: "Disconnected";
             value: undefined;
         } | {
-            tag: "SigningRequest";
-            value: Uint8Array<ArrayBufferLike>;
+            tag: "SignRequest";
+            value: {
+                address: string;
+                blockHash: `0x${string}`;
+                blockNumber: `0x${string}`;
+                era: `0x${string}`;
+                genesisHash: `0x${string}`;
+                method: `0x${string}`;
+                nonce: `0x${string}`;
+                specVersion: `0x${string}`;
+                tip: `0x${string}`;
+                transactionVersion: `0x${string}`;
+                signedExtensions: string[];
+                version: number;
+                assetId: `0x${string}` | undefined;
+                metadataHash: `0x${string}` | undefined;
+                mode: number | undefined;
+                withSignedTransaction: boolean | undefined;
+            };
+        } | {
+            tag: "SignResponse";
+            value: {
+                respondingTo: string;
+                payload: import("scale-ts").ResultPayload<{
+                    signature: Uint8Array<ArrayBufferLike>;
+                    signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+                }, string>;
+            };
         };
     };
 }>;

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

@@ -1,14 +1,13 @@
-import { Bytes, Enum, Struct, _void, str } from 'scale-ts';
-export const RemoteMessageDataCodec = Enum({
-    v1: Enum({
-        Disconnected: _void,
-        // TODO implement
-        SigningRequest: Bytes(),
-        // TODO implement
-        // SigningResponse: Bytes(),
-    }),
-});
+import { Enum, Struct, _void, str } from 'scale-ts';
+import { SignPayloadRequestCodec } from './signPayloadRequest.js';
+import { SignPayloadResponseCodec } from './signPayloadResponse.js';
 export const RemoteMessageCodec = Struct({
     messageId: str,
-    data: RemoteMessageDataCodec,
+    data: Enum({
+        v1: Enum({
+            Disconnected: _void,
+            SignRequest: SignPayloadRequestCodec,
+            SignResponse: SignPayloadResponseCodec,
+        }),
+    }),
 });

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

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

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

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

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

@@ -0,0 +1,14 @@
+import type { CodecType } from 'scale-ts';
+export type SignPayloadResponseData = CodecType<typeof SignPayloadResponseDataCodec>;
+export declare const SignPayloadResponseDataCodec: import("scale-ts").Codec<{
+    signature: Uint8Array<ArrayBufferLike>;
+    signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+}>;
+export type SignPayloadResponse = CodecType<typeof SignPayloadResponseCodec>;
+export declare const SignPayloadResponseCodec: import("scale-ts").Codec<{
+    respondingTo: string;
+    payload: import("scale-ts").ResultPayload<{
+        signature: Uint8Array<ArrayBufferLike>;
+        signedTransaction: Uint8Array<ArrayBufferLike> | undefined;
+    }, string>;
+}>;

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

@@ -0,0 +1,10 @@
+import { Bytes, Option, Result, Struct, str } from 'scale-ts';
+export const SignPayloadResponseDataCodec = Struct({
+    signature: Bytes(),
+    signedTransaction: Option(Bytes()),
+});
+export const SignPayloadResponseCodec = Struct({
+    // referencing to RemoteMessage.messageId
+    respondingTo: str,
+    payload: Result(SignPayloadResponseDataCodec, str),
+});

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

@@ -4,14 +4,12 @@ import { ResultAsync } from 'neverthrow';
 import type { CodecType } from 'scale-ts';
 import type { Callback } from '../../types.js';
 import type { StoredUserSession } from '../userSessionRepository.js';
-import { RemoteMessageCodec, RemoteMessageDataCodec } from './scale/remoteMessage.js';
+import { RemoteMessageCodec } from './scale/remoteMessage.js';
+import type { SignPayloadRequest } from './scale/signPayloadRequest.js';
+import type { SignPayloadResponseData } from './scale/signPayloadResponse.js';
 export type UserSession = StoredUserSession & {
-    request(message: CodecType<typeof RemoteMessageDataCodec>): ResultAsync<{
-        requestId: string;
-    }, Error>;
-    sendDisconnectMessage(): ResultAsync<{
-        requestId: string;
-    }, Error>;
+    sendDisconnectMessage(): ResultAsync<void, Error>;
+    signPayload(payload: SignPayloadRequest): ResultAsync<SignPayloadResponseData, Error>;
     subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
     dispose(): void;
 };

package/dist/sso/sessionManager/userSession.js

@@ -1,8 +1,10 @@
 import { createSession } from '@novasamatech/statement-store';
 import { fieldListView } from '@novasamatech/storage-adapter';
+import { AccountId } from '@polkadot-api/substrate-bindings';
+import { toHex } from '@polkadot-api/utils';
 import { nanoid } from 'nanoid';
-import { ResultAsync, okAsync } from 'neverthrow';
-import { RemoteMessageCodec, RemoteMessageDataCodec } from './scale/remoteMessage.js';
+import { ResultAsync, err, errAsync, ok, okAsync } from 'neverthrow';
+import { RemoteMessageCodec } from './scale/remoteMessage.js';
 export function createUserSession({ userSession, statementStore, encryption, storage, prover, }) {
     const session = createSession({
         localAccount: userSession.localAccount,
@@ -16,20 +18,58 @@ export function createUserSession({ userSession, statementStore, encryption, sto
         key: `sso_processed_${userSession.id}`,
         from: JSON.parse,
         to: JSON.stringify,
-        initial: [],
     });
     return {
         id: userSession.id,
         localAccount: userSession.localAccount,
         remoteAccount: userSession.remoteAccount,
-        request(message) {
-            return session.submitRequest(RemoteMessageCodec, {
-                messageId: nanoid(),
-                data: message,
+        signPayload(payload) {
+            const accountId = AccountId();
+            if (toHex(accountId.enc(payload.address)) !== toHex(userSession.remoteAccount.accountId)) {
+                return errAsync(new Error(`Invalid address, got ${payload.address}`));
+            }
+            const messageId = nanoid();
+            const request = session.request(RemoteMessageCodec, {
+                messageId,
+                data: {
+                    tag: 'v1',
+                    value: {
+                        tag: 'SignRequest',
+                        value: payload,
+                    },
+                },
+            });
+            const responseFilter = (message) => {
+                return (message.data.tag === 'v1' &&
+                    message.data.value.tag === 'SignResponse' &&
+                    message.data.value.value.respondingTo === messageId);
+            };
+            return request
+                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                .andThen(message => {
+                const { data } = message.payload;
+                switch (data.tag) {
+                    case 'v1': {
+                        switch (data.value.tag) {
+                            case 'SignResponse':
+                                if (data.value.value.payload.success) {
+                                    return ok(data.value.value.payload.value);
+                                }
+                                else {
+                                    return err(new Error(data.value.value.payload.value));
+                                }
+                            default:
+                                return err(new Error(`Incorrect sign response: ${data.value.tag}`));
+                        }
+                    }
+                    default:
+                        return err(new Error(`Unsupported message version ${data.tag}`));
+                }
             });
         },
         sendDisconnectMessage() {
-            return session.submitRequest(RemoteMessageCodec, {
+            return session
+                .submitRequestMessage(RemoteMessageCodec, {
                 messageId: nanoid(),
                 data: {
                     tag: 'v1',
@@ -38,23 +78,24 @@ export function createUserSession({ userSession, statementStore, encryption, sto
                         value: undefined,
                     },
                 },
-            });
+            })
+                .map(() => 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);
+                            const isMessageProcessed = processed.includes(message.payload.messageId);
                             if (isMessageProcessed) {
                                 return okAsync({ processed: false });
                             }
-                            return callback(message.data)
+                            return callback(message.payload)
                                 .orTee(error => {
                                 console.error('Error while processing sso messsage:', error);
                             })
                                 .orElse(() => okAsync(false))
-                                .map(processed => (processed ? { processed, message: message.data } : { processed }));
+                                .map(processed => (processed ? { processed, message: message.payload } : { processed }));
                         }
                         return okAsync({ processed: false });
                     });

package/dist/sso/userSecretRepository.d.ts

@@ -6,6 +6,7 @@ type StoredUserSecrets = CodecType<typeof StoredUserSecretsCodec>;
 declare const StoredUserSecretsCodec: import("scale-ts").Codec<{
     ssSecret: SsSecret;
     encrSecret: EncrSecret;
+    entropy: Uint8Array<ArrayBufferLike>;
 }>;
 export type UserSecretRepository = ReturnType<typeof createUserSecretRepository>;
 export declare function createUserSecretRepository(salt: string, storage: StorageAdapter): {

package/dist/sso/userSecretRepository.js

@@ -2,12 +2,13 @@ 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 } from 'scale-ts';
+import { Bytes, Struct } from 'scale-ts';
 import { BrandedBytesCodec, stringToBytes } from '../crypto.js';
 import { toError } from '../helpers/utils.js';
 const StoredUserSecretsCodec = Struct({
     ssSecret: BrandedBytesCodec(),
     encrSecret: BrandedBytesCodec(),
+    entropy: Bytes(),
 });
 export function createUserSecretRepository(salt, storage) {
     const baseKey = 'UserSecrets';

package/dist/sso/userSessionRepository.js

@@ -20,7 +20,6 @@ export const createUserSessionRepository = (storage) => {
     return fieldListView({
         storage,
         key: 'SsoSessions',
-        initial: [],
         from: x => codec.dec(fromHex(x)),
         to: x => toHex(codec.enc(x)),
     });

package/package.json

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

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

@@ -1,6 +0,0 @@
-import type { LazyClient } from '@novasamatech/statement-store';
-import type { StorageAdapter } from '@novasamatech/storage-adapter';
-import { ResultAsync } from 'neverthrow';
-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: LazyClient, storage: StorageAdapter): IdentityAdapter;