@novasamatech/host-papp 0.5.0-8 → 0.5.0

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

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

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

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

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

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

package/dist/{components/user → sso/sessionManager}/types.d.ts

@@ -1,4 +1,4 @@
-import type { EncrSecret, SharedSecret, SsSecret } from '../../modules/crypto.js';
+import type { EncrSecret, SharedSecret, SsSecret } from '../../crypto.js';
 export type UserSecrets = {
     sharedSecret: SharedSecret;
     encr: EncrSecret;

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

@@ -0,0 +1,22 @@
+import type { Encryption, StatementProver, StatementStoreAdapter } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import { ResultAsync } from 'neverthrow';
+import type { CodecType } from 'scale-ts';
+import type { Callback } from '../../types.js';
+import type { StoredUserSession } from '../userSessionRepository.js';
+import { RemoteMessageCodec } from './scale/remoteMessage.js';
+import type { SignPayloadRequest } from './scale/signPayloadRequest.js';
+import type { SignPayloadResponseData } from './scale/signPayloadResponse.js';
+export type UserSession = StoredUserSession & {
+    sendDisconnectMessage(): ResultAsync<void, Error>;
+    signPayload(payload: SignPayloadRequest): ResultAsync<SignPayloadResponseData, Error>;
+    subscribe(callback: Callback<CodecType<typeof RemoteMessageCodec>, ResultAsync<boolean, Error>>): VoidFunction;
+    dispose(): void;
+};
+export declare function createUserSession({ userSession, statementStore, encryption, storage, prover, }: {
+    userSession: StoredUserSession;
+    statementStore: StatementStoreAdapter;
+    encryption: Encryption;
+    storage: StorageAdapter;
+    prover: StatementProver;
+}): UserSession;

package/dist/sso/sessionManager/userSession.js

@@ -0,0 +1,116 @@
+import { createSession } from '@novasamatech/statement-store';
+import { fieldListView } from '@novasamatech/storage-adapter';
+import { AccountId } from '@polkadot-api/substrate-bindings';
+import { toHex } from '@polkadot-api/utils';
+import { nanoid } from 'nanoid';
+import { ResultAsync, err, errAsync, ok, okAsync } from 'neverthrow';
+import { RemoteMessageCodec } from './scale/remoteMessage.js';
+export function createUserSession({ userSession, statementStore, encryption, storage, prover, }) {
+    const session = createSession({
+        localAccount: userSession.localAccount,
+        remoteAccount: userSession.remoteAccount,
+        statementStore,
+        encryption,
+        prover,
+    });
+    const processedMessages = fieldListView({
+        storage,
+        key: `sso_processed_${userSession.id}`,
+        from: JSON.parse,
+        to: JSON.stringify,
+    });
+    return {
+        id: userSession.id,
+        localAccount: userSession.localAccount,
+        remoteAccount: userSession.remoteAccount,
+        signPayload(payload) {
+            const accountId = AccountId();
+            if (toHex(accountId.enc(payload.address)) !== toHex(userSession.remoteAccount.accountId)) {
+                return errAsync(new Error(`Invalid address, got ${payload.address}`));
+            }
+            const messageId = nanoid();
+            const request = session.request(RemoteMessageCodec, {
+                messageId,
+                data: {
+                    tag: 'v1',
+                    value: {
+                        tag: 'SignRequest',
+                        value: payload,
+                    },
+                },
+            });
+            const responseFilter = (message) => {
+                return (message.data.tag === 'v1' &&
+                    message.data.value.tag === 'SignResponse' &&
+                    message.data.value.value.respondingTo === messageId);
+            };
+            return request
+                .andThen(() => session.waitForRequestMessage(RemoteMessageCodec, responseFilter))
+                .andThen(message => {
+                const { data } = message.payload;
+                switch (data.tag) {
+                    case 'v1': {
+                        switch (data.value.tag) {
+                            case 'SignResponse':
+                                if (data.value.value.payload.success) {
+                                    return ok(data.value.value.payload.value);
+                                }
+                                else {
+                                    return err(new Error(data.value.value.payload.value));
+                                }
+                            default:
+                                return err(new Error(`Incorrect sign response: ${data.value.tag}`));
+                        }
+                    }
+                    default:
+                        return err(new Error(`Unsupported message version ${data.tag}`));
+                }
+            });
+        },
+        sendDisconnectMessage() {
+            return session
+                .submitRequestMessage(RemoteMessageCodec, {
+                messageId: nanoid(),
+                data: {
+                    tag: 'v1',
+                    value: {
+                        tag: 'Disconnected',
+                        value: undefined,
+                    },
+                },
+            })
+                .map(() => undefined);
+        },
+        subscribe(callback) {
+            return session.subscribe(RemoteMessageCodec, messages => {
+                processedMessages.read().andThen(processed => {
+                    const results = messages.map(message => {
+                        if (message.type === 'request') {
+                            const isMessageProcessed = processed.includes(message.payload.messageId);
+                            if (isMessageProcessed) {
+                                return okAsync({ processed: false });
+                            }
+                            return callback(message.payload)
+                                .orTee(error => {
+                                console.error('Error while processing sso messsage:', error);
+                            })
+                                .orElse(() => okAsync(false))
+                                .map(processed => (processed ? { processed, message: message.payload } : { processed }));
+                        }
+                        return okAsync({ processed: false });
+                    });
+                    return ResultAsync.combine(results).andThen(results => {
+                        const newMessages = results.filter(x => x.processed).map(x => x.message.messageId);
+                        if (newMessages.length > 0) {
+                            return processedMessages.mutate(x => x.concat(newMessages));
+                        }
+                        return okAsync();
+                    });
+                });
+            });
+        },
+        dispose() {
+            return session.dispose();
+        },
+    };
+}

package/dist/sso/ssoSessionProver.d.ts

@@ -0,0 +1,4 @@
+import type { StatementProver } from '@novasamatech/statement-store';
+import type { UserSecretRepository } from './userSecretRepository.js';
+import type { StoredUserSession } from './userSessionRepository.js';
+export declare function createSsoStatementProver(userSession: StoredUserSession, userSecretRepository: UserSecretRepository): StatementProver;

package/dist/sso/ssoSessionProver.js

@@ -0,0 +1,35 @@
+import { getStatementSigner, statementCodec } from '@polkadot-api/sdk-statement';
+import { err, errAsync, fromThrowable, ok, okAsync } from 'neverthrow';
+import { compact } from 'scale-ts';
+import { getSsPub, signWithSsSecret, verifyWithSsSecret } from '../crypto.js';
+import { toError } from '../helpers/utils.js';
+const verify = fromThrowable(verifyWithSsSecret, toError);
+export function createSsoStatementProver(userSession, userSecretRepository) {
+    const secret = userSecretRepository
+        .read(userSession.id)
+        .andThen(secrets => (secrets ? ok(secrets) : err(new Error(`Secrets for session ${userSession.id} not found.`))))
+        .map(x => x.ssSecret);
+    return {
+        generateMessageProof(statement) {
+            return secret.map(secret => {
+                const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
+                return signer.sign(statement);
+            });
+        },
+        verifyMessageProof(statement) {
+            const { proof, ...unsigned } = statement;
+            if (!proof) {
+                // TODO should we pass check when proof is not presented?
+                return okAsync(true);
+            }
+            const encoded = statementCodec.enc(unsigned);
+            const compactLen = compact.enc(compact.dec(encoded)).length;
+            switch (proof.type) {
+                case 'sr25519':
+                    return verify(encoded.slice(compactLen), proof.value.signature.asBytes(), proof.value.signer.asBytes()).asyncAndThen(x => okAsync(x));
+                default:
+                    return errAsync(new Error(`Proof type ${proof.type} is not supported.`));
+            }
+        },
+    };
+}

package/dist/sso/userSecretRepository.d.ts

@@ -0,0 +1,17 @@
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+import type { ResultAsync } from 'neverthrow';
+import type { CodecType } from 'scale-ts';
+import type { EncrSecret, SsSecret } from '../crypto.js';
+type StoredUserSecrets = CodecType<typeof StoredUserSecretsCodec>;
+declare const StoredUserSecretsCodec: import("scale-ts").Codec<{
+    ssSecret: SsSecret;
+    encrSecret: EncrSecret;
+    entropy: Uint8Array<ArrayBufferLike>;
+}>;
+export type UserSecretRepository = ReturnType<typeof createUserSecretRepository>;
+export declare function createUserSecretRepository(salt: string, storage: StorageAdapter): {
+    read(sessionId: string): ResultAsync<StoredUserSecrets | null, Error>;
+    write(sessionId: string, value: StoredUserSecrets): ResultAsync<void, Error>;
+    clear(sessionId: string): ResultAsync<void, Error>;
+};
+export {};

package/dist/sso/userSecretRepository.js

@@ -0,0 +1,45 @@
+import { gcm } from '@noble/ciphers/aes.js';
+import { blake2b } from '@noble/hashes/blake2.js';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { fromThrowable } from 'neverthrow';
+import { Bytes, Struct } from 'scale-ts';
+import { BrandedBytesCodec, stringToBytes } from '../crypto.js';
+import { toError } from '../helpers/utils.js';
+const StoredUserSecretsCodec = Struct({
+    ssSecret: BrandedBytesCodec(),
+    encrSecret: BrandedBytesCodec(),
+    entropy: Bytes(),
+});
+export function createUserSecretRepository(salt, storage) {
+    const baseKey = 'UserSecrets';
+    const encode = fromThrowable(StoredUserSecretsCodec.enc, toError);
+    const decode = fromThrowable((value) => (value ? StoredUserSecretsCodec.dec(value) : null), toError);
+    const encrypt = fromThrowable((value) => {
+        const aes = getAes(salt);
+        return toHex(aes.encrypt(value));
+    }, toError);
+    const decrypt = fromThrowable((value) => {
+        if (value === null) {
+            return null;
+        }
+        const aes = getAes(salt);
+        return aes.decrypt(fromHex(value));
+    }, toError);
+    return {
+        read(sessionId) {
+            return storage.read(createKey(baseKey, sessionId)).andThen(decrypt).andThen(decode);
+        },
+        write(sessionId, value) {
+            return encode(value)
+                .andThen(encrypt)
+                .asyncAndThen(value => storage.write(createKey(baseKey, sessionId), value));
+        },
+        clear(sessionId) {
+            return storage.clear(createKey(baseKey, sessionId));
+        },
+    };
+}
+const createKey = (key, context) => `${key}_${context}`;
+function getAes(salt) {
+    return gcm(blake2b(stringToBytes(salt), { dkLen: 16 }), blake2b(stringToBytes('nonce'), { dkLen: 32 }));
+}

package/dist/sso/userSessionRepository.d.ts

@@ -0,0 +1,18 @@
+import type { LocalSessionAccount, RemoteSessionAccount } from '@novasamatech/statement-store';
+import type { StorageAdapter } from '@novasamatech/storage-adapter';
+export type UserSessionRepository = ReturnType<typeof createUserSessionRepository>;
+export type StoredUserSession = {
+    id: string;
+    localAccount: LocalSessionAccount;
+    remoteAccount: RemoteSessionAccount;
+};
+export declare function createStoredUserSession(localAccount: LocalSessionAccount, remoteAccount: RemoteSessionAccount): StoredUserSession;
+export declare const createUserSessionRepository: (storage: StorageAdapter) => {
+    add(value: StoredUserSession): import("neverthrow").ResultAsync<StoredUserSession, Error>;
+    filter(fn: (value: StoredUserSession) => boolean): import("neverthrow").ResultAsync<StoredUserSession[], Error>;
+    mutate(fn: (value: StoredUserSession[]) => StoredUserSession[]): import("neverthrow").ResultAsync<StoredUserSession[], Error>;
+    read(): import("neverthrow").ResultAsync<StoredUserSession[], Error>;
+    write(value: StoredUserSession[]): import("neverthrow").ResultAsync<StoredUserSession[], Error> | import("neverthrow").ResultAsync<null, Error>;
+    clear(): import("neverthrow").ResultAsync<void, Error>;
+    subscribe(fn: (value: StoredUserSession[]) => void): VoidFunction;
+};

package/dist/sso/userSessionRepository.js

@@ -0,0 +1,26 @@
+import { LocalSessionAccountCodec, RemoteSessionAccountCodec } from '@novasamatech/statement-store';
+import { fieldListView } from '@novasamatech/storage-adapter';
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { nanoid } from 'nanoid';
+import { Struct, Vector, str } from 'scale-ts';
+const storedUserSessionCodec = Struct({
+    id: str,
+    localAccount: LocalSessionAccountCodec,
+    remoteAccount: RemoteSessionAccountCodec,
+});
+export function createStoredUserSession(localAccount, remoteAccount) {
+    return {
+        id: nanoid(12),
+        localAccount: localAccount,
+        remoteAccount: remoteAccount,
+    };
+}
+export const createUserSessionRepository = (storage) => {
+    const codec = Vector(storedUserSessionCodec);
+    return fieldListView({
+        storage,
+        key: 'SsoSessions',
+        from: x => codec.dec(fromHex(x)),
+        to: x => toHex(codec.enc(x)),
+    });
+};

package/package.json

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

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

@@ -1,6 +0,0 @@
-import { ResultAsync } from 'neverthrow';
-import type { LazyClientAdapter } from '../lazyClient/types.js';
-import type { StorageAdapter } from '../storage/types.js';
-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,101 +0,0 @@
-import { Result, ResultAsync, err, errAsync, fromPromise, ok, okAsync } from 'neverthrow';
-import { AccountId } from 'polkadot-api';
-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);
-            }
-            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 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,10 +0,0 @@
-import type { ResultAsync } from 'neverthrow';
-export type Identity = {
-    accountId: string;
-    fullUsername: string | null;
-    liteUsername: string;
-    credibility: string;
-};
-export type IdentityAdapter = {
-    readIdentities(accounts: string[]): ResultAsync<Record<string, Identity | null>, Error>;
-};

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

@@ -1,3 +0,0 @@
-import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
-import type { LazyClientAdapter } from './types.js';
-export declare const createPapiLazyClient: (provider: JsonRpcProvider) => LazyClientAdapter;

package/dist/adapters/lazyClient/papi.js

@@ -1,17 +0,0 @@
-import { createClient } from 'polkadot-api';
-export const createPapiLazyClient = (provider) => {
-    let client = null;
-    return {
-        getClient() {
-            if (!client) {
-                client = createClient(provider);
-            }
-            return client;
-        },
-        disconnect() {
-            if (client) {
-                client.destroy();
-            }
-        },
-    };
-};

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

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

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

@@ -1,3 +0,0 @@
-import type { LazyClientAdapter } from '../lazyClient/types.js';
-import type { StatementAdapter } from './types.js';
-export declare function createPapiStatementAdapter(lazyClient: LazyClientAdapter): StatementAdapter;

package/dist/adapters/statement/rpc.js

@@ -1,93 +0,0 @@
-import { createStatementSdk } from '@polkadot-api/sdk-statement';
-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 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 = {
-        queryStatements(topics, destination) {
-            return fromPromise(sdk.getStatements({
-                topics: topics.map(t => Binary.fromBytes(t)),
-                dest: destination ? Binary.fromBytes(destination) : null,
-            }), toError);
-        },
-        subscribeStatements(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 fromPromise(sdk.submit(statement), toError);
-        },
-    };
-    return transportProvider;
-}
-function polling(interval, request, callback) {
-    let active = true;
-    let tm = null;
-    function createCycle() {
-        tm = setTimeout(() => {
-            if (!active) {
-                return;
-            }
-            request().match(data => {
-                callback(data);
-                createCycle();
-            }, () => {
-                createCycle();
-            });
-        }, interval);
-    }
-    createCycle();
-    return () => {
-        active = false;
-        if (tm !== null) {
-            clearTimeout(tm);
-        }
-    };
-}

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

@@ -1,9 +0,0 @@
-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 = {
-    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.d.ts

@@ -1,2 +0,0 @@
-import type { StorageAdapter } from './types.js';
-export declare function createLocalStorageAdapter(prefix: string): StorageAdapter;