@novasamatech/host-papp 0.5.0-8 → 0.5.0

package/.papi/descriptors/dist/people_lite_metadata.d.ts

@@ -0,0 +1,2 @@
+declare const binMeta: string;
+export default binMeta;

package/.papi/descriptors/generated.json

@@ -0,0 +1 @@
+{"cliVersion":"0.18.0","whitelist":null,"chains":{"people_lite":"0x50b8c73c2a3438eeddf39175bda7d60b"}}

package/.papi/descriptors/package.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.1.0-autogenerated.16231069504393689218",
+  "name": "@polkadot-api/descriptors",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "module": "./dist/index.mjs",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "peerDependencies": {
+    "polkadot-api": ">=1.21.0"
+  }
+}

package/.papi/polkadot-api.json

@@ -0,0 +1,15 @@
+{
+  "version": 0,
+  "descriptorPath": ".papi/descriptors",
+  "options": {
+    "noDescriptorsPackage": true
+  },
+  "entries": {
+    "people_lite": {
+      "wsUrl": "wss://pop3-testnet.parity-lab.parity.io:443/7912",
+      "metadata": ".papi/metadata/people_lite.scale",
+      "genesis": "0x41412e46623c200d788ab7ef1c507c43490fda2ca7b48c19f86ea9a46cf9caa8",
+      "codeHash": "0xe6895843ad86452552f9ec62c9793f457e04ab0c23ca1be6e8837c8b4b6d6be9"
+    }
+  }
+}

package/dist/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const SS_DEV_ENDPOINTS: string[];
-export declare const SS_PROD_ENDPOINTS: string[];
+export declare const SS_UNSTABLE_STAGE_ENDPOINTS: string[];
+export declare const SS_STABLE_STAGE_ENDPOINTS: string[];

package/dist/constants.js

@@ -1,5 +1,5 @@
-export const SS_DEV_ENDPOINTS = ['wss://pop-testnet.parity-lab.parity.io:443/9910'];
-export const SS_PROD_ENDPOINTS = [
+export const SS_UNSTABLE_STAGE_ENDPOINTS = ['wss://pop-testnet.parity-lab.parity.io:443/9910'];
+export const SS_STABLE_STAGE_ENDPOINTS = [
     'wss://pop3-testnet.parity-lab.parity.io:443/7911',
     'wss://pop3-testnet.parity-lab.parity.io:443/7912',
 ];

package/dist/{modules/crypto.d.ts → crypto.d.ts}

@@ -1,27 +1,29 @@
 import type { Codec } from 'scale-ts';
-import type { Branded } from '../types.js';
+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 function mergeBytes(...bytes: Uint8Array[]): Uint8Array<ArrayBuffer>;
-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 createSsSecret(entropy: Uint8Array): SsSecret;
+export declare function createSsDerivation(secret: SsSecret, derivation: string): SsSecret;
 export declare function getSsPub(secret: SsSecret): SsPublicKey;
 export declare function signWithSsSecret(secret: SsSecret, message: Uint8Array): Uint8Array<ArrayBufferLike>;
-export declare const ENCR_SECRET_SEED_SIZE = 48;
-export declare function createEncrSecret(seed: Uint8Array): EncrSecret;
+export declare function verifyWithSsSecret(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
+export type DerivedSr25519Account = {
+    secret: SsSecret;
+    publicKey: SsPublicKey;
+    entropy: Uint8Array;
+    sign(message: Uint8Array): Uint8Array;
+    verify(message: Uint8Array, signature: Uint8Array): boolean;
+};
+export declare function deriveSr25519Account(mnemonic: string, derivation: string): DerivedSr25519Account;
+export declare function createEncrSecret(entropy: 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>;

package/dist/crypto.js

@@ -0,0 +1,87 @@
+import { p256 } from '@noble/curves/nist.js';
+import { entropyToMiniSecret, mnemonicToEntropy } from '@polkadot-labs/hdkd-helpers';
+import { HDKD as sr25519HDKD, getPublicKey as sr25519GetPublicKey, secretFromSeed as sr25519SecretFromSeed, sign as sr25519Sign, verify as sr25519Verify, } from '@scure/sr25519';
+import { Bytes, str } 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);
+}
+function parseDerivations(derivationsStr) {
+    const DERIVATION_RE = /(\/{1,2})([^/]+)/g;
+    const derivations = [];
+    for (const [, type, code] of derivationsStr.matchAll(DERIVATION_RE)) {
+        if (code) {
+            derivations.push([type === '//' ? 'hard' : 'soft', code]);
+        }
+    }
+    return derivations;
+}
+function createChainCode(derivation) {
+    const chainCode = new Uint8Array(32);
+    chainCode.set(str.enc(derivation));
+    return chainCode;
+}
+// statement store key pair
+export function createSsSecret(entropy) {
+    const miniSecret = entropyToMiniSecret(entropy);
+    return sr25519SecretFromSeed(miniSecret);
+}
+export function createSsDerivation(secret, derivation) {
+    const derivations = parseDerivations(derivation);
+    return derivations.reduce((secret, [type, derivation]) => {
+        const chainCode = createChainCode(derivation);
+        switch (type) {
+            case 'hard':
+                return sr25519HDKD.secretHard(secret, chainCode);
+            case 'soft':
+                return sr25519HDKD.secretSoft(secret, chainCode);
+        }
+    }, secret);
+}
+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);
+}
+export function deriveSr25519Account(mnemonic, derivation) {
+    const entropy = mnemonicToEntropy(mnemonic);
+    const secret = createSsDerivation(createSsSecret(entropy), derivation);
+    const publicKey = getSsPub(secret);
+    return {
+        secret,
+        publicKey,
+        entropy,
+        sign: message => signWithSsSecret(secret, message),
+        verify: (message, signature) => verifyWithSsSecret(message, signature, publicKey),
+    };
+}
+// encryption key pair
+export function createEncrSecret(entropy) {
+    const miniSecret = entropyToMiniSecret(entropy);
+    const seed = new Uint8Array(48);
+    seed.set(miniSecret);
+    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/abortError.d.ts

@@ -1,4 +1,3 @@
 export declare class AbortError extends Error {
     constructor(message?: string);
-    static isAbortError(err: unknown): err is AbortError;
 }

package/dist/helpers/abortError.js

@@ -2,7 +2,4 @@ export class AbortError extends Error {
     constructor(message) {
         super(message);
     }
-    static isAbortError(err) {
-        return err instanceof AbortError;
-    }
 }

package/dist/{modules → helpers}/state.d.ts

@@ -1,7 +1,7 @@
 type State<T> = ReturnType<typeof createState<T>>;
 export declare function createState<T>(initial: T): {
     read(): T;
-    write(value: T): T;
+    write(value: T | ((prev: T) => T)): T;
     reset(): void;
     subscribe(fn: (value: T) => void): () => void;
     onFirstSubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;

package/dist/{modules → helpers}/state.js

@@ -7,11 +7,12 @@ export function createState(initial) {
             return currentValue;
         },
         write(value) {
-            if (currentValue !== value) {
-                currentValue = value;
-                events.emit('value', value);
+            const actialValue = typeof value === 'function' ? value(currentValue) : value;
+            if (currentValue !== actialValue) {
+                currentValue = actialValue;
+                events.emit('value', actialValue);
             }
-            return value;
+            return actialValue;
         },
         reset() {
             if (currentValue !== initial) {

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,46 @@
+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(x => [accCodec.dec(x)])), 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];
+                    }
+                    const credibility = raw.credibility.type == 'Lite'
+                        ? {
+                            type: 'Lite',
+                        }
+                        : {
+                            type: 'Person',
+                            alias: raw.credibility.value.alias.asHex(),
+                            lastUpdate: raw.credibility.value.last_update.toString(),
+                        };
+                    return [
+                        accountId,
+                        {
+                            accountId: accountId,
+                            fullUsername: raw.full_username ? raw.full_username.asText() : null,
+                            liteUsername: raw.lite_username.asText(),
+                            credibility,
+                        },
+                    ];
+                })));
+            });
+        },
+    };
+}

package/dist/identity/types.d.ts

@@ -0,0 +1,21 @@
+import type { ResultAsync } from 'neverthrow';
+export type Credibility = {
+    type: 'Lite';
+} | {
+    type: 'Person';
+    alias: `0x${string}`;
+    lastUpdate: string;
+};
+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>;
+};

package/dist/index.d.ts

@@ -1,5 +1,8 @@
+export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
 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 { AttestationStatus, PairingStatus } from './sso/auth/types.js';
+export type { UserSession } from './sso/sessionManager/userSession.js';
+export type { Identity } from './identity/types.js';
+export type { SignPayloadRequest } from './sso/sessionManager/scale/signPayloadRequest.js';
+export type { SignPayloadResponse } from './sso/sessionManager/scale/signPayloadResponse.js';

package/dist/index.js

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

package/dist/papp.d.ts

@@ -1,26 +1,37 @@
-import type { ResultAsync } from 'neverthrow';
-import type { Identity, IdentityAdapter } from './adapters/identity/types.js';
-import type { StatementAdapter } from './adapters/statement/types.js';
-import type { StorageAdapter } from './adapters/storage/types.js';
-import type { AuthComponent } from './components/auth/index.js';
-import type { UserSessionsComponent } from './components/user/index.js';
+import type { LazyClient, StatementStoreAdapter } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { IdentityAdapter, IdentityRepository } from './identity/types.js';
+import type { AuthComponent } from './sso/auth/impl.js';
+import type { SsoSessionManager } from './sso/sessionManager/impl.js';
 export type PappAdapter = {
     sso: AuthComponent;
-    sessions: UserSessionsComponent;
-    identity: {
-        getIdentity(accountId: string): ResultAsync<Identity | null, Error>;
-        getIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
-    };
+    sessions: SsoSessionManager;
+    identity: IdentityRepository;
 };
 type Adapters = {
-    statements: StatementAdapter;
+    statementStore: StatementStoreAdapter;
     identities: IdentityAdapter;
     storage: StorageAdapter;
+    lazyClient: LazyClient;
 };
 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;
-    adapters?: Adapters;
+    adapters?: Partial<Adapters>;
 };
 export declare function createPappAdapter({ appId, metadata, adapters }: Params): PappAdapter;
 export {};

package/dist/papp.js

@@ -1,42 +1,23 @@
+import { createLazyClient, createPapiStatementStoreAdapter } from '@novasamatech/statement-store';
+import { createLocalStorageAdapter } from '@novasamatech/storage-adapter';
 import { getWsProvider } from '@polkadot-api/ws-provider';
-import { createIdentityRpcAdapter } from './adapters/identity/rpc.js';
-import { createPapiLazyClient } from './adapters/lazyClient/papi.js';
-import { createPapiStatementAdapter } from './adapters/statement/rpc.js';
-import { createLocalStorageAdapter } from './adapters/storage/localStorage.js';
-import { createAuthComponent } from './components/auth/index.js';
-import { createUserSessionsComponent } from './components/user/index.js';
-import { createUserSessionStorage } from './components/user/userSessionStorage.js';
-import { SS_PROD_ENDPOINTS } from './constants.js';
-import { createTransport } from './modules/transport/transport.js';
+import { SS_STABLE_STAGE_ENDPOINTS } from './constants.js';
+import { createIdentityRepository } from './identity/impl.js';
+import { createIdentityRpcAdapter } from './identity/rpcAdapter.js';
+import { createAuth } from './sso/auth/impl.js';
+import { createSsoSessionManager } from './sso/sessionManager/impl.js';
+import { createUserSecretRepository } from './sso/userSecretRepository.js';
+import { createUserSessionRepository } from './sso/userSessionRepository.js';
 export function createPappAdapter({ appId, metadata, adapters }) {
-    let statements;
-    let identities;
-    let storage;
-    if (adapters) {
-        statements = adapters.statements;
-        identities = adapters.identities;
-        storage = adapters.storage;
-    }
-    else {
-        const lazyPapiAdapter = createPapiLazyClient(getWsProvider(SS_PROD_ENDPOINTS));
-        storage = createLocalStorageAdapter(appId);
-        identities = createIdentityRpcAdapter(lazyPapiAdapter, storage);
-        statements = createPapiStatementAdapter(lazyPapiAdapter);
-    }
-    const transport = createTransport({ adapter: statements });
-    const userSessionStorage = createUserSessionStorage({ storage });
-    const identityComponent = {
-        getIdentity(accountId) {
-            return identities.readIdentities([accountId]).map(map => map[accountId] ?? null);
-        },
-        getIdentities(accounts) {
-            return identities.readIdentities(accounts);
-        },
+    const lazyClient = adapters?.lazyClient ?? createLazyClient(getWsProvider(SS_STABLE_STAGE_ENDPOINTS));
+    const statementStore = adapters?.statementStore ?? createPapiStatementStoreAdapter(lazyClient);
+    const identities = adapters?.identities ?? createIdentityRpcAdapter(lazyClient);
+    const storage = adapters?.storage ?? createLocalStorageAdapter(appId);
+    const ssoSessionRepository = createUserSessionRepository(storage);
+    const userSecretRepository = createUserSecretRepository(appId, storage);
+    return {
+        sso: createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient }),
+        sessions: createSsoSessionManager({ storage, statementStore, ssoSessionRepository, userSecretRepository }),
+        identity: createIdentityRepository({ adapter: identities, storage }),
     };
-    const papp = {
-        sso: createAuthComponent({ appId, metadata, transport, userSessionStorage }),
-        sessions: createUserSessionsComponent({ transport, storage, userSessionStorage }),
-        identity: identityComponent,
-    };
-    return papp;
 }

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

@@ -0,0 +1,18 @@
+import type { LazyClient } from '@novasamatech/statement-store';
+import type { ResultAsync } from 'neverthrow';
+import type { DerivedSr25519Account } from '../../crypto.js';
+export declare function createAliceVerifier(): DerivedSr25519Account;
+export declare const createAttestationService: (lazyClient: LazyClient) => {
+    claimUsername(): string;
+    grantVerifierAllowance(verifier: DerivedSr25519Account): ResultAsync<void, Error>;
+    getRingRfKey(candidate: DerivedSr25519Account): Uint8Array<ArrayBufferLike>;
+    getProofMessage(candidate: DerivedSr25519Account, ringVrfKey: Uint8Array): Uint8Array<ArrayBufferLike>;
+    deriveAttestationParams(username: string, candidate: DerivedSr25519Account, verifier: DerivedSr25519Account): ResultAsync<{
+        candidateSignature: Uint8Array<ArrayBufferLike>;
+        ringVrfKey: Uint8Array<ArrayBufferLike>;
+        proofOfOwnership: Uint8Array<ArrayBufferLike>;
+        identifierKey: import("../../crypto.js").EncrPublicKey;
+        consumerRegistrationSignature: Uint8Array<ArrayBufferLike>;
+    }, never>;
+    registerLitePerson(username: string, candidate: DerivedSr25519Account, verifier: DerivedSr25519Account): ResultAsync<void, Error>;
+};