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

package/dist/modules/userManager.js

@@ -0,0 +1,105 @@
+import { err, ok, seq } from '../helpers/result.js';
+import { createSecretStorage } from './secretStorage.js';
+export const createUserManager = (appId, storage) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createUserStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const manager = {
+        async readSelectedUser() {
+            const selectedUser = await selectedUserStorage.read();
+            return selectedUser.andThenPromise(async (selectedUser) => {
+                if (selectedUser === null) {
+                    return ok(null);
+                }
+                const user = await manager.readUser(selectedUser);
+                return user.andThenPromise(async (user) => {
+                    if (user === null) {
+                        await selectedUserStorage.clear();
+                    }
+                    return ok(user);
+                });
+            });
+        },
+        async readUser(accountId) {
+            const user = await secretStorage.readSessionTopic(accountId).then(existingSessionTopic => existingSessionTopic.map(sessionTopic => {
+                return sessionTopic ? { sessionTopic, accountId } : null;
+            }));
+            await user
+                .andThen(v => (v ? ok(undefined) : err('User not found')))
+                .orElsePromise(() => manager.removeUser(accountId));
+            return user;
+        },
+        async createUser(user) {
+            return (await usersStorage.add(user.accountId)).andThenPromise(async () => seq(await selectedUserStorage.write(user.accountId), await secretStorage.writeSessionTopic(user.accountId, user.sessionTopic)).map(() => user));
+        },
+        async removeUser(accountId) {
+            const op = seq(await selectedUserStorage.read(), await usersStorage.remove(accountId));
+            return op.andThenPromise(async ([selectedUser, users]) => {
+                if (selectedUser === accountId) {
+                    const nextSelectedUser = users.at(0);
+                    if (nextSelectedUser) {
+                        await selectedUserStorage.write(nextSelectedUser);
+                    }
+                    else {
+                        await selectedUserStorage.clear();
+                    }
+                }
+                return secretStorage.clearSessionTopic(accountId);
+            });
+        },
+        async readAccounts() {
+            return usersStorage.read();
+        },
+        async selectAccount(accountId) {
+            return selectedUserStorage.write(accountId);
+        },
+    };
+    return manager;
+};
+const createUserStorage = (storage) => {
+    const KEY = 'Users';
+    return {
+        async read() {
+            const users = await storage.read(KEY);
+            return users.map(users => {
+                return users === null ? [] : JSON.parse(users);
+            });
+        },
+        async add(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                const newUsers = users.concat(user);
+                return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+            });
+        },
+        async remove(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+                }
+                return ok([]);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    const KEY = 'SelectedUser';
+    return {
+        read() {
+            return storage.read(KEY);
+        },
+        write(accountId) {
+            return storage.write(KEY, accountId);
+        },
+        clear() {
+            return storage.clear(KEY);
+        },
+    };
+};

package/dist/modules/userStorage.d.ts

@@ -0,0 +1,19 @@
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Result } from '../helpers/result.js';
+import type { SessionTopic } from '../types.js';
+export type UserSession = {
+    accountId: string;
+    sessionTopic: SessionTopic;
+};
+export declare const createUserStorage: (appId: string, storage: StorageAdapter) => {
+    sessions: {
+        read(accountId: string): Promise<Result<UserSession | null>>;
+        readSelectedUser(): Promise<Result<UserSession | null>>;
+        create(user: UserSession): Promise<Result<UserSession>>;
+        remove(accountId: string): Promise<Result<void, Error>>;
+    };
+    accounts: {
+        read(): Promise<Result<string[], Error>>;
+        select(accountId: string): Promise<Result<string | null, Error> | Result<null, Error>>;
+    };
+};

package/dist/modules/userStorage.js

@@ -0,0 +1,108 @@
+import { err, ok, seq } from '../helpers/result.js';
+import { createSecretStorage } from './secretStorage.js';
+import { reactiveStorage } from './syncStorage.js';
+export const createUserStorage = (appId, storage) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createSessionsStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const store = {
+        sessions: {
+            async read(accountId) {
+                const user = await secretStorage.readSessionTopic(accountId).then(existingSessionTopic => existingSessionTopic.map(sessionTopic => {
+                    return sessionTopic ? { sessionTopic, accountId } : null;
+                }));
+                await user
+                    .andThen(v => (v ? ok(undefined) : err('User not found')))
+                    .orElsePromise(() => store.sessions.remove(accountId));
+                return user;
+            },
+            async readSelectedUser() {
+                const selectedUser = await selectedUserStorage.read();
+                return selectedUser.andThenPromise(async (selectedUser) => {
+                    if (selectedUser === null) {
+                        return ok(null);
+                    }
+                    const user = await store.sessions.read(selectedUser);
+                    return user.andThenPromise(async (user) => {
+                        if (user === null) {
+                            await selectedUserStorage.clear();
+                        }
+                        return ok(user);
+                    });
+                });
+            },
+            async create(user) {
+                return (await usersStorage.add(user.accountId)).andThenPromise(async () => seq(await selectedUserStorage.write(user.accountId), await secretStorage.writeSessionTopic(user.accountId, user.sessionTopic)).map(() => user));
+            },
+            async remove(accountId) {
+                const op = seq(await selectedUserStorage.read(), await usersStorage.remove(accountId));
+                return op.andThenPromise(async ([selectedUser, users]) => {
+                    if (selectedUser === accountId) {
+                        const nextSelectedUser = users.at(0);
+                        if (nextSelectedUser) {
+                            await selectedUserStorage.write(nextSelectedUser);
+                        }
+                        else {
+                            await selectedUserStorage.clear();
+                        }
+                    }
+                    return secretStorage.clearSessionTopic(accountId);
+                });
+            },
+        },
+        accounts: {
+            async read() {
+                return usersStorage.read();
+            },
+            async select(accountId) {
+                return selectedUserStorage.write(accountId);
+            },
+        },
+    };
+    return store;
+};
+const createSessionsStorage = (storage) => {
+    const reactive = reactiveStorage({
+        storage,
+        key: 'Users',
+        autosync: true,
+        initial: [],
+        from: x => JSON.parse(x),
+        to: x => JSON.stringify(x),
+    });
+    return {
+        async read() {
+            return reactive.read();
+        },
+        async add(user) {
+            const users = await reactive.read();
+            return users.andThenPromise(async (users) => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                const newUsers = users.concat(user);
+                return reactive.write(newUsers).then(x => x.map(() => newUsers));
+            });
+        },
+        async remove(user) {
+            const users = await reactive.read();
+            return users.andThenPromise(async (users) => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return reactive.write(newUsers).then(x => x.map(() => newUsers));
+                }
+                return ok([]);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    return reactiveStorage({
+        storage,
+        key: 'SelectedUser',
+        autosync: true,
+        initial: null,
+        from: x => x,
+        to: x => x,
+    });
+};

package/dist/modules/userStore.d.ts

@@ -0,0 +1,15 @@
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Result } from '../helpers/result.js';
+import type { SessionTopic } from '../types.js';
+export type UserSession = {
+    accountId: string;
+    sessionTopic: SessionTopic;
+};
+export declare const createUserStore: (appId: string, storage: StorageAdapter) => {
+    readSelectedUserSession(): Promise<Result<UserSession | null>>;
+    readUserSession(accountId: string): Promise<Result<UserSession | null>>;
+    createUserSession(user: UserSession): Promise<Result<UserSession>>;
+    removeUserSession(accountId: string): Promise<Result<void, Error>>;
+    readAccounts(): Promise<Result<string[], Error>>;
+    selectAccount(accountId: string): Promise<Result<void, Error>>;
+};

package/dist/modules/userStore.js

@@ -0,0 +1,105 @@
+import { err, ok, seq } from '../helpers/result.js';
+import { createSecretStorage } from './secretStorage.js';
+export const createUserStore = (appId, storage) => {
+    const secretStorage = createSecretStorage(appId, storage);
+    const usersStorage = createUserStorage(storage);
+    const selectedUserStorage = createSelectedUserStorage(storage);
+    const manager = {
+        async readSelectedUserSession() {
+            const selectedUser = await selectedUserStorage.read();
+            return selectedUser.andThenPromise(async (selectedUser) => {
+                if (selectedUser === null) {
+                    return ok(null);
+                }
+                const user = await manager.readUserSession(selectedUser);
+                return user.andThenPromise(async (user) => {
+                    if (user === null) {
+                        await selectedUserStorage.clear();
+                    }
+                    return ok(user);
+                });
+            });
+        },
+        async readUserSession(accountId) {
+            const user = await secretStorage.readSessionTopic(accountId).then(existingSessionTopic => existingSessionTopic.map(sessionTopic => {
+                return sessionTopic ? { sessionTopic, accountId } : null;
+            }));
+            await user
+                .andThen(v => (v ? ok(undefined) : err('User not found')))
+                .orElsePromise(() => manager.removeUserSession(accountId));
+            return user;
+        },
+        async createUserSession(user) {
+            return (await usersStorage.add(user.accountId)).andThenPromise(async () => seq(await selectedUserStorage.write(user.accountId), await secretStorage.writeSessionTopic(user.accountId, user.sessionTopic)).map(() => user));
+        },
+        async removeUserSession(accountId) {
+            const op = seq(await selectedUserStorage.read(), await usersStorage.remove(accountId));
+            return op.andThenPromise(async ([selectedUser, users]) => {
+                if (selectedUser === accountId) {
+                    const nextSelectedUser = users.at(0);
+                    if (nextSelectedUser) {
+                        await selectedUserStorage.write(nextSelectedUser);
+                    }
+                    else {
+                        await selectedUserStorage.clear();
+                    }
+                }
+                return secretStorage.clearSessionTopic(accountId);
+            });
+        },
+        async readAccounts() {
+            return usersStorage.read();
+        },
+        async selectAccount(accountId) {
+            return selectedUserStorage.write(accountId);
+        },
+    };
+    return manager;
+};
+const createUserStorage = (storage) => {
+    const KEY = 'Users';
+    return {
+        async read() {
+            const users = await storage.read(KEY);
+            return users.map(users => {
+                return users === null ? [] : JSON.parse(users);
+            });
+        },
+        async add(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                if (users.some(x => x === user)) {
+                    throw new Error(`User ${user} already exists.`);
+                }
+                const newUsers = users.concat(user);
+                return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+            });
+        },
+        async remove(user) {
+            const usersRaw = await storage.read(KEY);
+            const users = usersRaw.map(x => (x ? JSON.parse(x) : []));
+            return users.andThenPromise(async (users) => {
+                const newUsers = users.filter(x => x !== user);
+                if (newUsers.length !== users.length) {
+                    return storage.write(KEY, JSON.stringify(newUsers)).then(x => x.map(() => newUsers));
+                }
+                return ok([]);
+            });
+        },
+    };
+};
+const createSelectedUserStorage = (storage) => {
+    const KEY = 'SelectedUser';
+    return {
+        read() {
+            return storage.read(KEY);
+        },
+        write(accountId) {
+            return storage.write(KEY, accountId);
+        },
+        clear() {
+            return storage.clear(KEY);
+        },
+    };
+};

package/dist/papp.d.ts

@@ -1,25 +1,37 @@
-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 { SignInStatus } from './modules/signIn.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 = {
-    auth: {
-        signIn(): Promise<Identity | null>;
-        abortSignIn(): void;
-        getCurrentUser(): Promise<Identity | null>;
-        getSignInStatus(): SignInStatus;
-        onSignInStatusChange(callback: (status: SignInStatus) => void): VoidFunction;
-    };
+    sso: AuthComponent;
+    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,54 +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 { createMemoryAdapter } from './adapters/storage/memory.js';
-import { SS_ENDPOINTS } from './constants.js';
-import { createSignInFlow } from './modules/signIn.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_ENDPOINTS));
-        storage = createMemoryAdapter();
-        identities = createIdentityRpcAdapter(lazyPapiAdapter, storage);
-        statements = createPapiStatementAdapter(lazyPapiAdapter);
-    }
-    const signInFlow = createSignInFlow({ appId, metadata, statements, storage });
-    const papp = {
-        auth: {
-            signIn() {
-                return signInFlow.signIn().then(result => {
-                    if (result) {
-                        return identities.getIdentity(result.pappAccountId);
-                    }
-                    return null;
-                });
-            },
-            getCurrentUser() {
-                return signInFlow.getSignedUser().then(result => {
-                    if (result) {
-                        return identities.getIdentity(result.pappAccountId);
-                    }
-                    return null;
-                });
-            },
-            getSignInStatus() {
-                return signInFlow.getSignInStatus();
-            },
-            onSignInStatusChange(callback) {
-                return signInFlow.onStatusChange(callback);
-            },
-            abortSignIn() {
-                return signInFlow.abortSignIn();
-            },
-        },
+    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 }),
     };
-    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>;
+};

package/dist/sso/auth/attestationService.js

@@ -0,0 +1,171 @@
+import { createAccountId } from '@novasamatech/statement-store';
+import { AccountId, Binary } from '@polkadot-api/substrate-bindings';
+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 { 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);
+        },
+    };
+}