@novasamatech/host-papp 0.5.0-9 → 0.5.1

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/crypto.d.ts

@@ -11,13 +11,19 @@ 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 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 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 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 createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;

package/dist/crypto.js

@@ -1,7 +1,7 @@
 import { p256 } from '@noble/curves/nist.js';
-import { randomBytes } from '@noble/hashes/utils.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, u32 } from 'scale-ts';
+import { Bytes, str } from 'scale-ts';
 // schemas
 export function BrandedBytesCodec(length) {
     return Bytes(length);
@@ -17,15 +17,37 @@ export function stringToBytes(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);
+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;
 }
-export function createSsHardDerivation(secret, derivation) {
+function createChainCode(derivation) {
     const chainCode = new Uint8Array(32);
-    chainCode.set(typeof derivation === 'string' ? str.enc(derivation) : u32.enc(derivation));
-    return sr25519HDKD.secretHard(secret, chainCode);
+    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);
@@ -36,9 +58,23 @@ export function signWithSsSecret(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 const ENCR_SECRET_SEED_SIZE = 48;
-export function createEncrSecret(seed = randomBytes(ENCR_SECRET_SEED_SIZE)) {
+export function createEncrSecret(entropy) {
+    const miniSecret = entropyToMiniSecret(entropy);
+    const seed = new Uint8Array(48);
+    seed.set(miniSecret);
     const { secretKey } = p256.keygen(seed);
     return secretKey;
 }

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/identity/rpcAdapter.js

@@ -8,11 +8,11 @@ export function createIdentityRpcAdapter(lazyClient) {
         readIdentities(accounts) {
             const client = lazyClient.getClient();
             const unsafeApi = client.getUnsafeApi();
-            const method = unsafeApi.query.Resources?.Consumers;
+            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);
+            const results = fromPromise(method.getValues(accounts.map(x => [accCodec.dec(x)])), toError);
             return results.andThen(results => {
                 if (!results) {
                     return ok({});
@@ -21,14 +21,22 @@ export function createIdentityRpcAdapter(lazyClient) {
                     if (!raw) {
                         return [accountId, null];
                     }
-                    console.log(raw.credibility);
+                    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 ? raw.lite_username.asText() : null,
-                            credibility: raw.credibility.type,
+                            liteUsername: raw.lite_username.asText(),
+                            credibility,
                         },
                     ];
                 })));

package/dist/identity/types.d.ts

@@ -1,10 +1,10 @@
 import type { ResultAsync } from 'neverthrow';
-type Credibility = {
+export type Credibility = {
     type: 'Lite';
 } | {
     type: 'Person';
-    alias: number;
-    lastUpdate: bigint;
+    alias: `0x${string}`;
+    lastUpdate: string;
 };
 export type Identity = {
     accountId: string;
@@ -19,4 +19,3 @@ export type IdentityRepository = {
     getIdentity(accountId: string): ResultAsync<Identity | null, Error>;
     getIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
 };
-export {};

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 { createPappAdapter } from './papp.js';
-export type { AuthentificationStatus } from './sso/auth/types.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 +1,2 @@
+export { SS_STABLE_STAGE_ENDPOINTS, SS_UNSTABLE_STAGE_ENDPOINTS } from './constants.js';
 export { createPappAdapter } from './papp.js';

package/dist/papp.js

@@ -1,7 +1,7 @@
 import { createLazyClient, createPapiStatementStoreAdapter } from '@novasamatech/statement-store';
 import { createLocalStorageAdapter } from '@novasamatech/storage-adapter';
 import { getWsProvider } from '@polkadot-api/ws-provider';
-import { SS_PROD_ENDPOINTS } from './constants.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';
@@ -9,14 +9,14 @@ 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 }) {
-    const lazyClient = adapters?.lazyClient ?? createLazyClient(getWsProvider(SS_PROD_ENDPOINTS));
+    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 }),
+        sso: createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient }),
         sessions: createSsoSessionManager({ storage, statementStore, ssoSessionRepository, userSecretRepository }),
         identity: createIdentityRepository({ adapter: identities, storage }),
     };

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>;
+};

package/dist/sso/auth/attestationService.js

@@ -0,0 +1,171 @@
+import { createAccountId } from '@novasamatech/statement-store';
+import { mergeUint8 } from '@polkadot-api/utils';
+import { blake2b256 } from '@polkadot-labs/hdkd-helpers';
+import { customAlphabet } from 'nanoid';
+import { errAsync, fromAsyncThrowable, fromPromise, okAsync } from 'neverthrow';
+import { AccountId, Binary } from 'polkadot-api';
+import { getPolkadotSigner } from 'polkadot-api/signer';
+import { Bytes, Option, Tuple, str } from 'scale-ts';
+import { member_from_entropy, sign } from 'verifiablejs/bundler';
+import { deriveSr25519Account, getEncrPub, stringToBytes } from '../../crypto.js';
+import { toError } from '../../helpers/utils.js';
+const accountId = AccountId();
+export function createAliceVerifier() {
+    return deriveSr25519Account('bottom drive obey lake curtain smoke basket hold race lonely fit walk', '//Alice');
+}
+export const createAttestationService = (lazyClient) => {
+    const service = {
+        claimUsername() {
+            const nameSuffixFactory = customAlphabet('abcdefghijklmnopqrstuvwxyz', 4);
+            return `guest${nameSuffixFactory()}.${createNumericSuffix(4)}`;
+        },
+        grantVerifierAllowance(verifier) {
+            const client = lazyClient.getClient();
+            const api = client.getUnsafeApi();
+            const verifierAddress = accountId.dec(verifier.publicKey);
+            if (!api.query.PeopleLite || !api.query.PeopleLite.AttestationAllowance) {
+                return errAsync(new Error('Query PeopleLite.AttestationAllowance not found.'));
+            }
+            const verifierAllowance = fromPromise(api.query.PeopleLite.AttestationAllowance.getValue(verifierAddress), toError);
+            const getAllowance = fromAsyncThrowable(async () => {
+                const increaseAllowanceCall = api.tx.PeopleLite.increase_attestation_allowance({
+                    account: verifierAddress,
+                    count: 10,
+                });
+                const sudoCall = api.tx.Sudo.sudo({
+                    call: increaseAllowanceCall.decodedCall,
+                });
+                return sudoCall.signAndSubmit(createPeopleSigner(verifier)).then(() => undefined);
+            }, toError);
+            return verifierAllowance.andThen(verifierAllowance => (verifierAllowance > 0 ? okAsync() : getAllowance()));
+        },
+        getRingRfKey(candidate) {
+            const verifiableEntropy = blake2b256(candidate.entropy);
+            return member_from_entropy(verifiableEntropy);
+        },
+        getProofMessage(candidate, ringVrfKey) {
+            return mergeUint8([stringToBytes('pop:people-lite:register using'), candidate.publicKey, ringVrfKey]);
+        },
+        deriveAttestationParams(username, candidate, verifier) {
+            const verifiableEntropy = blake2b256(candidate.entropy);
+            const ringVrfKey = service.getRingRfKey(candidate);
+            const identifierKey = getEncrPub(blake2b256(candidate.secret));
+            const message = service.getProofMessage(candidate, ringVrfKey);
+            // Extract username without the `.` separator and any following digits
+            // For lite person usernames like "ceainnhgidpj.39642086", we only use "ceainnhgidpj"
+            const usernameWithoutDigits = username.split('.')[0] ?? username;
+            const candidateSignature = candidate.sign(message);
+            const proofOfOwnership = sign(verifiableEntropy, message);
+            const ResourceSignatureCodec = Tuple(
+            // candidate PublicKey (32 bytes)
+            Bytes(32), 
+            // verifier AccountId (32 bytes)
+            Bytes(32), 
+            // identifierKey
+            Bytes(65), 
+            // username without digits
+            str, 
+            // reserved_username
+            Option(Bytes()));
+            const resourcesSignatureData = ResourceSignatureCodec.enc([
+                candidate.publicKey,
+                createAccountId(verifier.publicKey),
+                identifierKey,
+                usernameWithoutDigits,
+                undefined,
+            ]);
+            const consumerRegistrationSignature = candidate.sign(resourcesSignatureData);
+            return okAsync({
+                candidateSignature: candidateSignature,
+                ringVrfKey,
+                proofOfOwnership,
+                identifierKey,
+                consumerRegistrationSignature,
+            });
+        },
+        registerLitePerson(username, candidate, verifier) {
+            const client = lazyClient.getClient();
+            const api = client.getUnsafeApi();
+            return service
+                .deriveAttestationParams(username, candidate, verifier)
+                .andThen(params => {
+                const attestCall = api.tx.PeopleLite.attest({
+                    candidate: accountId.dec(candidate.publicKey),
+                    candidate_signature: {
+                        type: 'Sr25519',
+                        value: Binary.fromBytes(params.candidateSignature),
+                    },
+                    ring_vrf_key: Binary.fromBytes(params.ringVrfKey),
+                    proof_of_ownership: Binary.fromBytes(params.proofOfOwnership),
+                    consumer_registration: {
+                        signature: {
+                            type: 'Sr25519',
+                            value: Binary.fromBytes(params.consumerRegistrationSignature),
+                        },
+                        account: accountId.dec(candidate.publicKey),
+                        identifier_key: Binary.fromBytes(params.identifierKey),
+                        username: Binary.fromText(username),
+                        reserved_username: undefined,
+                    },
+                });
+                return fromPromise(new Promise((resolve, reject) => {
+                    const subscription = attestCall.signSubmitAndWatch(createPeopleSigner(verifier)).subscribe({
+                        next(event) {
+                            if (event.type === 'finalized') {
+                                // Check if transaction was successful
+                                if (event.ok) {
+                                    subscription.unsubscribe();
+                                    resolve();
+                                }
+                                else {
+                                    // Extract error details
+                                    let errorMessage = 'Transaction failed';
+                                    if (event.dispatchError?.type === 'Module') {
+                                        const moduleError = event.dispatchError.value;
+                                        errorMessage = `${moduleError.type}.${moduleError.value?.type || 'Unknown'}`;
+                                    }
+                                    subscription.unsubscribe();
+                                    reject(errorMessage);
+                                }
+                            }
+                        },
+                        error: reject,
+                    });
+                }), toError).map(() => undefined);
+            })
+                .andTee(() => console.log(`Attestation for ${accountId.dec(candidate.publicKey)} successfully passed.`));
+        },
+    };
+    return service;
+};
+function createNumericSuffix(length) {
+    let suffix = '';
+    for (let i = 0; i < length; i++) {
+        suffix += (Math.random() * 9).toFixed();
+    }
+    return suffix;
+}
+function createPeopleSigner(verifier) {
+    const baseSigner = getPolkadotSigner(verifier.publicKey, 'Sr25519', verifier.sign);
+    return {
+        publicKey: baseSigner.publicKey,
+        signBytes: baseSigner.signBytes,
+        signTx: async (callData, signedExtensions, metadata, atBlockNumber, hasher) => {
+            // Add People chain custom signed extensions
+            const extensionsWithCustom = {
+                ...signedExtensions,
+                VerifyMultiSignature: {
+                    identifier: 'VerifyMultiSignature',
+                    value: new Uint8Array([1]), // 1u8 = Option::Some with empty data
+                    additionalSigned: new Uint8Array([]), // Empty additional data
+                },
+                AsPerson: {
+                    identifier: 'AsPerson',
+                    value: new Uint8Array([0]), // 0u8 = Option::None
+                    additionalSigned: new Uint8Array([]), // Empty additional data
+                },
+            };
+            return baseSigner.signTx(callData, extensionsWithCustom, metadata, atBlockNumber, hasher);
+        },
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { StatementStoreAdapter } from '@novasamatech/statement-store';
+import type { LazyClient, StatementStoreAdapter } from '@novasamatech/statement-store';
 import { ResultAsync } from 'neverthrow';
 import type { UserSecretRepository } from '../userSecretRepository.js';
 import type { StoredUserSession, UserSessionRepository } from '../userSessionRepository.js';
@@ -8,18 +8,21 @@ type Params = {
     statementStore: StatementStoreAdapter;
     ssoSessionRepository: UserSessionRepository;
     userSecretRepository: UserSecretRepository;
+    lazyClient: LazyClient;
 };
-export declare function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository }: Params): {
-    status: {
+export declare function createAuth({ metadata, statementStore, ssoSessionRepository, userSecretRepository, lazyClient, }: Params): {
+    pairingStatus: {
         read: () => {
             step: "none";
         } | {
             step: "initial";
+        } | {
+            step: "attestation";
         } | {
             step: "pairing";
             payload: string;
         } | {
-            step: "error";
+            step: "pairingError";
             message: string;
         } | {
             step: "finished";
@@ -29,11 +32,13 @@ export declare function createAuth({ metadata, statementStore, ssoSessionReposit
             step: "none";
         } | {
             step: "initial";
+        } | {
+            step: "attestation";
         } | {
             step: "pairing";
             payload: string;
         } | {
-            step: "error";
+            step: "pairingError";
             message: string;
         } | {
             step: "finished";
@@ -42,6 +47,32 @@ export declare function createAuth({ metadata, statementStore, ssoSessionReposit
         onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
         onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
     };
+    attestationStatus: {
+        read: () => {
+            step: "none";
+        } | {
+            step: "attestation";
+            username: string;
+        } | {
+            step: "attestationError";
+            message: string;
+        } | {
+            step: "finished";
+        };
+        subscribe: (fn: (value: {
+            step: "none";
+        } | {
+            step: "attestation";
+            username: string;
+        } | {
+            step: "attestationError";
+            message: string;
+        } | {
+            step: "finished";
+        }) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
     authenticate(): ResultAsync<StoredUserSession | null, Error>;
     abortAuthentication(): void;
 };