@novasamatech/host-papp 0.5.0-6 → 0.5.0-7

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

@@ -1,4 +1,6 @@
+import { ResultAsync } from 'neverthrow';
 import type { LazyClientAdapter } from '../lazyClient/types.js';
 import type { StorageAdapter } from '../storage/types.js';
-import type { IdentityAdapter } from './types.js';
-export declare const createIdentityRpcAdapter: (lazyClient: LazyClientAdapter, storage: StorageAdapter) => IdentityAdapter;
+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: LazyClientAdapter, storage: StorageAdapter): IdentityAdapter;

package/dist/adapters/identity/rpc.js

@@ -1,31 +1,101 @@
+import { Result, ResultAsync, err, errAsync, fromPromise, ok, okAsync } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
-export const createIdentityRpcAdapter = (lazyClient, storage) => {
-    const getKey = (accountId) => `identity_${accountId}`;
-    const accCodec = AccountId();
-    return {
-        async getIdentity(accountId) {
-            const existingIdentity = await storage.read(getKey(accountId));
-            if (existingIdentity) {
-                try {
-                    return JSON.parse(existingIdentity);
-                }
-                catch (error) {
-                    console.error('Error while reading identity from cache', error);
+import { toError } from '../../helpers/utils.js';
+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;
+}
+export function createCachedIdentityRequester(storage, getKey, request) {
+    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) => {
+        return readCache(accounts).andThen(existing => {
+            const emptyIdentities = Object.entries(existing)
+                .filter(([, identity]) => identity === null)
+                .map(([accountId]) => accountId);
+            if (emptyIdentities.length === 0) {
+                return okAsync(existing);
             }
-            const client = lazyClient.getClient();
-            const unsafeApi = client.getUnsafeApi();
-            const result = await unsafeApi.query.Resources?.Consumers?.getValue(accCodec.dec(accountId));
-            if (result) {
-                const identity = {
-                    fullUsername: result.full_username ? result.full_username.asText() : null,
-                    liteUsername: result.lite_username ? result.lite_username.asText() : null,
-                    credibility: result.credibility.type,
-                };
-                await storage.write(getKey(accountId), JSON.stringify(identity));
-                return identity;
+            return request(accounts)
+                .map(response => Object.fromEntries(zipWith([accounts, response], x => x)))
+                .andThen(writeCache)
+                .map(fetched => ({
+                ...existing,
+                ...fetched,
+            }));
+        });
+    };
+}
+export function createIdentityRpcAdapter(lazyClient, storage) {
+    const requester = createCachedIdentityRequester(storage, (accountId) => `identity_${accountId}`, 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(accCodec.dec)]), toError);
+        return results.andThen(results => {
+            if (!results) {
+                return ok(accounts.map(() => null));
             }
-            return null;
-        },
+            return ok(zipWith([accounts, results], x => x).map(([accountId, raw]) => {
+                if (!raw) {
+                    return null;
+                }
+                return {
+                    accountId: accountId,
+                    fullUsername: raw.full_username ? raw.full_username.asText() : null,
+                    liteUsername: raw.lite_username ? raw.lite_username.asText() : null,
+                    credibility: raw.credibility.type,
+                };
+            }));
+        });
+    });
+    const accCodec = AccountId();
+    return {
+        readIdentities: requester,
     };
-};
+}

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

@@ -1,8 +1,10 @@
+import type { ResultAsync } from 'neverthrow';
 export type Identity = {
+    accountId: string;
     fullUsername: string | null;
     liteUsername: string;
     credibility: string;
 };
 export type IdentityAdapter = {
-    getIdentity(accountId: string): Promise<Identity | null>;
+    readIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
 };

package/dist/adapters/lazyClient/papi.js

@@ -8,5 +8,10 @@ export const createPapiLazyClient = (provider) => {
             }
             return client;
         },
+        disconnect() {
+            if (client) {
+                client.destroy();
+            }
+        },
     };
 };

package/dist/adapters/lazyClient/types.d.ts

@@ -1,4 +1,5 @@
 import type { PolkadotClient } from 'polkadot-api';
 export type LazyClientAdapter = {
     getClient(): PolkadotClient;
+    disconnect(): void;
 };

package/dist/adapters/statement/rpc.js

@@ -1,21 +1,68 @@
 import { createStatementSdk } from '@polkadot-api/sdk-statement';
-import { FixedSizeBinary } from '@polkadot-api/substrate-bindings';
+import { Binary } from '@polkadot-api/substrate-bindings';
+import { toHex } from '@polkadot-api/utils';
+import { fromPromise } from 'neverthrow';
+import { toError } from '../../helpers/utils.js';
+const POLLING_INTERVAL = 1000;
+function createKey(topics) {
+    return topics.map(toHex).sort().join('');
+}
 export function createPapiStatementAdapter(lazyClient) {
-    const POLLING_INTERVAL = 1000;
     const sdk = createStatementSdk((method, params) => {
         const client = lazyClient.getClient();
         return client._request(method, params);
     });
+    const pollings = new Map();
+    const subscriptions = new Map();
+    function addSubscription(key, subscription) {
+        let subs = subscriptions.get(key);
+        if (!subs) {
+            subs = [];
+            subscriptions.set(key, subs);
+        }
+        subs.push(subscription);
+        return subs;
+    }
+    function removeSubscription(key, subscription) {
+        let subs = subscriptions.get(key);
+        if (!subs) {
+            return [];
+        }
+        subs = subs.filter(x => x !== subscription);
+        return subs;
+    }
     const transportProvider = {
-        getStatements(topics) {
-            // @ts-expect-error lib versions mismatch
-            return sdk.getStatements({ topics: topics.map(topic => new FixedSizeBinary(topic)) });
+        queryStatements(topics, destination) {
+            return fromPromise(sdk.getStatements({
+                topics: topics.map(t => Binary.fromBytes(t)),
+                dest: destination ? Binary.fromBytes(destination) : null,
+            }), toError);
         },
         subscribeStatements(topics, callback) {
-            return polling(POLLING_INTERVAL, () => transportProvider.getStatements(topics), callback);
+            const key = createKey(topics);
+            const callbacks = addSubscription(key, callback);
+            if (callbacks.length === 1) {
+                const unsub = polling(POLLING_INTERVAL, () => transportProvider.queryStatements(topics), statements => {
+                    const list = subscriptions.get(key);
+                    if (list) {
+                        for (const fn of list) {
+                            fn(statements);
+                        }
+                    }
+                });
+                pollings.set(key, unsub);
+            }
+            return () => {
+                const callbacks = removeSubscription(key, callback);
+                if (callbacks.length === 0) {
+                    const stopPolling = pollings.get(key);
+                    stopPolling?.();
+                    pollings.delete(key);
+                }
+            };
         },
         submitStatement(statement) {
-            return sdk.submit(statement);
+            return fromPromise(sdk.submit(statement), toError);
         },
     };
     return transportProvider;
@@ -28,9 +75,10 @@ function polling(interval, request, callback) {
             if (!active) {
                 return;
             }
-            request()
-                .then(callback)
-                .finally(() => {
+            request().match(data => {
+                callback(data);
+                createCycle();
+            }, () => {
                 createCycle();
             });
         }, interval);

package/dist/adapters/statement/types.d.ts

@@ -1,6 +1,9 @@
 import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+import type { ResultAsync } from 'neverthrow';
+import type { Callback } from '../../types.js';
+export type StatementsCallback = Callback<Statement[]>;
 export type StatementAdapter = {
-    getStatements(topics: Uint8Array[]): Promise<Statement[]>;
-    subscribeStatements(topics: Uint8Array[], callback: (response: Statement[]) => unknown): VoidFunction;
-    submitStatement(statement: SignedStatement): Promise<void>;
+    queryStatements(topics: Uint8Array[], destination?: Uint8Array): ResultAsync<Statement[], Error>;
+    subscribeStatements(topics: Uint8Array[], callback: StatementsCallback): VoidFunction;
+    submitStatement(statement: SignedStatement): ResultAsync<void, Error>;
 };

package/dist/adapters/storage/localStorage.js

@@ -1,12 +1,34 @@
+import { createNanoEvents } from 'nanoevents';
+import { fromAsyncThrowable } from 'neverthrow';
+import { toError } from '../../helpers/utils.js';
 export function createLocalStorageAdapter(prefix) {
+    const events = createNanoEvents();
     const withPrefix = (key) => `PAPP_${prefix}_${key}`;
     return {
-        async write(key, value) {
+        write: fromAsyncThrowable(async (key, value) => {
             localStorage.setItem(withPrefix(key), value);
-            return true;
-        },
-        async read(key) {
+            events.emit(key, value);
+        }, toError),
+        read: fromAsyncThrowable(async (key) => {
             return localStorage.getItem(withPrefix(key));
+        }, toError),
+        clear: fromAsyncThrowable(async (key) => {
+            localStorage.removeItem(withPrefix(key));
+            events.emit(key, null);
+        }, toError),
+        subscribe(key, callback) {
+            const prefixedKey = withPrefix(key);
+            const unsubscribeLocalListener = events.on(prefixedKey, callback);
+            const externalListener = (event) => {
+                if (event.storageArea === localStorage && event.key === prefixedKey) {
+                    callback(event.newValue);
+                }
+            };
+            window.addEventListener('storage', externalListener);
+            return () => {
+                unsubscribeLocalListener();
+                window.removeEventListener('storage', externalListener);
+            };
         },
     };
 }

package/dist/adapters/storage/memory.js

@@ -1,12 +1,22 @@
+import { createNanoEvents } from 'nanoevents';
+import { fromAsyncThrowable } from 'neverthrow';
 export function createMemoryAdapter(external) {
+    const events = createNanoEvents();
     const storage = external ? { ...external } : {};
     return {
-        async write(key, value) {
+        write: fromAsyncThrowable(async (key, value) => {
             storage[key] = value;
-            return true;
-        },
-        async read(key) {
+            events.emit(key, value);
+        }),
+        read: fromAsyncThrowable(async (key) => {
             return storage[key] ?? null;
+        }),
+        clear: fromAsyncThrowable(async (key) => {
+            delete storage[key];
+            events.emit(key, null);
+        }),
+        subscribe(key, callback) {
+            return events.on(key, callback);
         },
     };
 }

package/dist/adapters/storage/types.d.ts

@@ -1,4 +1,7 @@
+import { ResultAsync } from 'neverthrow';
 export type StorageAdapter = {
-    write(key: string, value: string): Promise<boolean>;
-    read(key: string): Promise<string | null>;
+    write(key: string, value: string): ResultAsync<void, Error>;
+    read(key: string): ResultAsync<string | null, Error>;
+    clear(key: string): ResultAsync<void, Error>;
+    subscribe(key: string, callback: (value: string | null) => unknown): VoidFunction;
 };

package/dist/adapters/storage/types.js

@@ -1 +1 @@
-export {};
+import { ResultAsync } from 'neverthrow';

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

@@ -0,0 +1,3 @@
+import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+import type { Transport } from './types.js';
+export declare function createRpcTransport(rpcProvider: JsonRpcProvider): Transport;

package/dist/adapters/transport/rpc.js

@@ -0,0 +1,51 @@
+import { createClient } from '@polkadot-api/raw-client';
+import { createStatementSdk } from '@polkadot-api/sdk-statement';
+import { FixedSizeBinary } from '@polkadot-api/substrate-bindings';
+export function createRpcTransport(rpcProvider) {
+    const POLLING_INTERVAL = 1000;
+    const client = createClient(rpcProvider);
+    const sdk = createStatementSdk((method, params) => {
+        return new Promise((resolve, reject) => {
+            client.request(method, params, {
+                onSuccess: resolve,
+                onError: reject,
+            });
+        });
+    });
+    const transportProvider = {
+        getStatements(topics) {
+            // @ts-expect-error lib versions mismatch
+            return sdk.getStatements({ topics: topics.map(topic => new FixedSizeBinary(topic)) });
+        },
+        subscribeStatements(topics, callback) {
+            return polling(POLLING_INTERVAL, () => transportProvider.getStatements(topics), callback);
+        },
+        submitStatement(statement) {
+            return sdk.submit(statement);
+        },
+    };
+    return transportProvider;
+}
+function polling(interval, request, callback) {
+    let active = true;
+    let tm = null;
+    function createCycle() {
+        tm = setTimeout(() => {
+            if (!active) {
+                return;
+            }
+            request()
+                .then(callback)
+                .finally(() => {
+                createCycle();
+            });
+        }, interval);
+    }
+    createCycle();
+    return () => {
+        active = false;
+        if (tm !== null) {
+            clearTimeout(tm);
+        }
+    };
+}

package/dist/adapters/transport/types.d.ts

@@ -0,0 +1,6 @@
+import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+export type Transport = {
+    getStatements(topics: Uint8Array[]): Promise<Statement[]>;
+    subscribeStatements(topics: Uint8Array[], callback: (response: Statement[]) => unknown): VoidFunction;
+    submitStatement(statement: SignedStatement): Promise<void>;
+};

package/dist/adapters/transport/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/auth/codec.d.ts

@@ -0,0 +1,9 @@
+export declare const HandshakeData: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [import("../../modules/crypto.js").SsPublicKey, import("../../modules/crypto.js").EncrPublicKey, string];
+}>;
+export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>];
+}>;
+export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>]>;

package/dist/components/auth/codec.js

@@ -0,0 +1,10 @@
+import { Bytes, Enum, Tuple, str } from 'scale-ts';
+import { EncrPubKey, SsPubKey } from '../../modules/crypto.js';
+export const HandshakeData = Enum({
+    V1: Tuple(SsPubKey, EncrPubKey, str),
+});
+export const HandshakeResponsePayload = Enum({
+    // [encrypted, tmp_key]
+    V1: Tuple(Bytes(), Bytes(65)),
+});
+export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));

package/dist/components/auth/codecs.d.ts

@@ -0,0 +1,9 @@
+export declare const HandshakeData: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [import("../../modules/crypto.js").SsPublicKey, import("../../modules/crypto.js").EncrPublicKey, string];
+}>;
+export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
+    tag: "V1";
+    value: [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>];
+}>;
+export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>]>;

package/dist/components/auth/codecs.js

@@ -0,0 +1,10 @@
+import { Bytes, Enum, Tuple, str } from 'scale-ts';
+import { EncrPubKey, SsPubKey } from '../../modules/crypto.js';
+export const HandshakeData = Enum({
+    V1: Tuple(SsPubKey, EncrPubKey, str),
+});
+export const HandshakeResponsePayload = Enum({
+    // [encrypted, tmp_key]
+    V1: Tuple(Bytes(), Bytes(65)),
+});
+export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));

package/dist/components/auth/index.d.ts

@@ -0,0 +1,36 @@
+import type { ResultAsync } from 'neverthrow';
+import type { Transport } from '../../modules/transport/transport.js';
+import type { UserSession, UserSessionStorage } from '../user/userSessionStorage.js';
+import type { AuthentificationStatus } from './types.js';
+export type AuthComponent = ReturnType<typeof createAuthComponent>;
+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;
+    transport: Transport;
+    userSessionStorage: UserSessionStorage;
+};
+export declare function createAuthComponent({ appId, metadata, transport, userSessionStorage }: Params): {
+    status: {
+        read: () => AuthentificationStatus;
+        subscribe: (fn: (value: AuthentificationStatus) => void) => () => void;
+        onFirstSubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+        onLastUnsubscribe: (callback: VoidFunction) => import("nanoevents").Unsubscribe;
+    };
+    authenticate(): ResultAsync<UserSession | null, Error>;
+    abortAuthentication(): void;
+};
+export {};

package/dist/components/auth/index.js

@@ -0,0 +1,150 @@
+import { toHex } from '@polkadot-api/utils';
+import { err, errAsync, fromPromise, fromThrowable, ok } from 'neverthrow';
+import { AbortError } from '../../helpers/abortError.js';
+import { toError } from '../../helpers/utils.js';
+import { ENCR_SECRET_SEED_SIZE, SS_SECRET_SEED_SIZE, createEncrSecret, createRandomSeed, createSharedSecret, createSsHardDerivation, createSsSecret, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from '../../modules/crypto.js';
+import { createAccount } from '../../modules/session/helpers.js';
+import { createState, readonly } from '../../modules/state.js';
+import { createUserSession } from '../../modules/statementStore.js';
+import { HandshakeData, HandshakeResponsePayload, HandshakeResponseSensitiveData } from './codec.js';
+export function createAuthComponent({ appId, metadata, transport, userSessionStorage }) {
+    const authStatus = createState({ step: 'none' });
+    let authResults = null;
+    let abort = null;
+    function handshake(signal) {
+        try {
+            authStatus.write({ step: 'initial' });
+            const { encrSecret, encrPublicKey, ssPublicKey } = getSecretKeys(appId);
+            const hostAccount = createAccount(ssPublicKey, encrPublicKey);
+            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata }).andTee(payload => authStatus.write({ step: 'pairing', payload: createDeeplink(payload) }));
+            const handshakeTopic = createHandshakeTopic(hostAccount);
+            const pappResponse = handshakePayload
+                .andThen(() => handshakeTopic)
+                .asyncAndThen(topic => waitForStatements(callback => transport.subscribeSession(topic, callback), signal, (statements, resolve) => {
+                for (const statement of [...statements].reverse()) {
+                    if (!statement.data)
+                        continue;
+                    const session = retrieveSession({
+                        hostAccount,
+                        encrSecret,
+                        payload: statement.data.asBytes(),
+                    });
+                    resolve(session);
+                    break;
+                }
+            }));
+            const userCreated = pappResponse.andThen(userSessionStorage.add);
+            return userCreated
+                .orElse(e => (AbortError.isAbortError(e) ? ok(null) : err(toError(e))))
+                .andTee(session => {
+                if (session) {
+                    authStatus.write({ step: 'finished', session });
+                }
+                else {
+                    authStatus.write({ step: 'none' });
+                }
+            })
+                .orTee(e => authStatus.write({ step: 'error', message: e.message }));
+        }
+        catch (e) {
+            return errAsync(toError(e));
+        }
+    }
+    const authModule = {
+        status: readonly(authStatus),
+        authenticate() {
+            if (authResults) {
+                return authResults;
+            }
+            abort = new AbortController();
+            authResults = handshake(abort.signal);
+            return authResults;
+        },
+        abortAuthentication() {
+            if (abort) {
+                authResults = null;
+                authStatus.reset();
+                abort.abort(new AbortError('Aborted by user.'));
+            }
+        },
+    };
+    return authModule;
+}
+const createHandshakeTopic = fromThrowable((account) => khash(account.accountId, mergeBytes(account.publicKey, stringToBytes('topic'))), toError);
+const createHandshakePayloadV1 = fromThrowable(({ encrPublicKey, ssPublicKey, metadata, }) => HandshakeData.enc({
+    tag: 'V1',
+    value: [ssPublicKey, encrPublicKey, metadata],
+}), toError);
+function parseHandshakePayload(payload) {
+    const decoded = HandshakeResponsePayload.dec(payload);
+    switch (decoded.tag) {
+        case 'V1':
+            return {
+                encrypted: decoded.value[0],
+                tmpKey: decoded.value[1],
+            };
+        default:
+            throw new Error('Unsupported handshake payload version');
+    }
+}
+function retrieveSession({ payload, encrSecret, hostAccount, }) {
+    const { encrypted, tmpKey } = parseHandshakePayload(payload);
+    const symmetricKey = createSharedSecret(encrSecret, tmpKey);
+    const decrypted = decrypt(symmetricKey, encrypted);
+    const [pappEncrPublicKey, pappAccountId] = HandshakeResponseSensitiveData.dec(decrypted);
+    const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
+    const peerAccount = createAccount(pappAccountId, sharedSecret);
+    return createUserSession(hostAccount, peerAccount);
+}
+function getSsKeys(appId) {
+    const seed = createRandomSeed(appId, SS_SECRET_SEED_SIZE);
+    const ssSecret = createSsHardDerivation(createSsSecret(seed), '//wallet');
+    return {
+        ssSecret: ssSecret,
+        ssPublicKey: getSsPub(ssSecret),
+    };
+}
+function getEncrKeys(appId) {
+    const seed = createRandomSeed(appId, ENCR_SECRET_SEED_SIZE);
+    const encrSecret = createEncrSecret(seed);
+    return {
+        encrSecret,
+        encrPublicKey: getEncrPub(encrSecret),
+    };
+}
+function getSecretKeys(appId) {
+    const ss = getSsKeys(appId);
+    const encr = getEncrKeys(appId);
+    return {
+        ...ss,
+        ...encr,
+    };
+}
+function createDeeplink(payload) {
+    return `polkadotapp://pair?handshake=${toHex(payload)}`;
+}
+function waitForStatements(subscribe, abortSignal, callback) {
+    return fromPromise(new Promise((resolve, reject) => {
+        const unsubscribe = subscribe(statements => {
+            if (abortSignal?.aborted) {
+                unsubscribe();
+                try {
+                    abortSignal.throwIfAborted();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }
+            try {
+                callback(statements, value => {
+                    unsubscribe();
+                    resolve(value);
+                });
+            }
+            catch (e) {
+                unsubscribe();
+                reject(e);
+            }
+        });
+    }), toError);
+}