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

package/dist/modules/session/session.js

@@ -0,0 +1,50 @@
+import { toHex } from '@polkadot-api/utils';
+import { okAsync } from 'neverthrow';
+import { storageListView } from '../storageView.js';
+import { createSessionId } from './helpers.js';
+export function createSession({ ownAccount, peerAccount, transport, storage, codec, }) {
+    // const ownSession = createSessionId(peerAccount.publicKey, ownAccount, peerAccount);
+    const peerSession = createSessionId(peerAccount.publicKey, peerAccount, ownAccount);
+    const processedStorage = storageListView({
+        key: `ProcessesMessages_${toHex(peerSession)}`,
+        storage,
+        initial: [],
+        from: JSON.parse,
+        to: JSON.stringify,
+    });
+    let subscriptions = [];
+    return {
+        subscribe(callback) {
+            const unsub = transport.subscribe({ ownAccount, peerAccount, codec }, async (messages) => {
+                processedStorage.read().map(processed => {
+                    for (const message of messages) {
+                        if (message.type === 'response')
+                            continue;
+                        if (processed.includes(message.requestId)) {
+                            return okAsync();
+                        }
+                        callback(message.data).andThen(processed => {
+                            if (processed) {
+                                return processedStorage.mutate(p => p.concat(message.requestId));
+                            }
+                            else {
+                                return okAsync();
+                            }
+                        });
+                    }
+                });
+            });
+            subscriptions.push(unsub);
+            return () => {
+                unsub();
+                subscriptions = subscriptions.filter(x => x !== unsub);
+            };
+        },
+        dispose() {
+            for (const unsub of subscriptions) {
+                unsub();
+            }
+            subscriptions = [];
+        },
+    };
+}

package/dist/modules/session/types.d.ts

@@ -0,0 +1,12 @@
+import type { ResultAsync } from 'neverthrow';
+import type { Codec, CodecType } from 'scale-ts';
+import type { Callback } from '../../types.js';
+export type Session<T extends Codec<any>> = {
+    subscribe(callback: Callback<CodecType<T>, ResultAsync<boolean, Error>>): VoidFunction;
+    dispose(): void;
+};
+export type Account = {
+    accountId: Uint8Array;
+    publicKey: Uint8Array;
+    pin: string | undefined;
+};

package/dist/modules/session/types.js

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

package/dist/modules/signIn.d.ts

@@ -1,7 +1,8 @@
 import type { StatementAdapter } from '../adapters/statement/types.js';
 import type { StorageAdapter } from '../adapters/storage/types.js';
-import type { SessionTopic } from '../types.js';
+import type { Result } from '../helpers/result.js';
 import type { EncrPublicKey, SsPublicKey } from './crypto.js';
+import type { User } from './userManager.js';
 export declare const HandshakeData: import("scale-ts").Codec<{
     tag: "V1";
     value: [SsPublicKey, EncrPublicKey, string];
@@ -23,24 +24,44 @@ export type SignInStatus = {
     message: string;
 } | {
     step: 'finished';
-    sessionTopic: SessionTopic;
-    pappAccountId: string;
-};
-export type SignInResult = {
-    sessionTopic: SessionTopic;
-    pappAccountId: string;
+    user: User;
 };
 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;
     statements: StatementAdapter;
     storage: StorageAdapter;
 };
 export declare function createSignInFlow({ appId, metadata, statements, storage }: Params): {
-    getSignedUser(): Promise<SignInResult | null>;
-    signIn(): Promise<SignInResult | null>;
+    signInStatus: {
+        read(): SignInStatus;
+        write(value: SignInStatus): void;
+        reset(): void;
+        subscribe(fn: (value: SignInStatus) => void): import("nanoevents").Unsubscribe;
+    };
+    users: {
+        readSelectedUser(): Promise<Result<User | null>>;
+        readUser(accountId: string): Promise<Result<User | null>>;
+        createUser(user: User): Promise<Result<User>>;
+        removeUser(accountId: string): Promise<Result<void, Error>>;
+        readAccounts(): Promise<Result<string[], Error>>;
+        selectAccount(accountId: string): Promise<Result<void, Error>>;
+    };
+    signIn(): Promise<Result<User | null>>;
     abortSignIn(): void;
-    getSignInStatus(): SignInStatus;
-    onStatusChange(callback: (status: SignInStatus) => void): import("nanoevents").Unsubscribe;
 };
 export {};

package/dist/modules/signIn.js

@@ -1,10 +1,12 @@
 import { toHex } from '@polkadot-api/utils';
-import { createNanoEvents } from 'nanoevents';
 import { Bytes, Enum, Tuple, str } from 'scale-ts';
-import { isAbortError } from '../helpers/utils.js';
-import { ENCR_SECRET_SEED_SIZE, EncrPubKey, SS_SECRET_SEED_SIZE, SsPubKey, createEncrSecret, createSharedSecret, createSsSecret, createStableSeed, createSymmetricKey, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from './crypto.js';
+import { err, fromPromise, ok, seq } from '../helpers/result.js';
+import { isAbortError, toError } from '../helpers/utils.js';
+import { ENCR_SECRET_SEED_SIZE, EncrPubKey, SS_SECRET_SEED_SIZE, SsPubKey, createEncrSecret, createRandomSeed, createSharedSecret, createSsSecret, createSymmetricKey, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from './crypto.js';
 import { createSecretStorage } from './secretStorage.js';
 import { createSession } from './statementStore.js';
+import { createSyncStorage } from './syncStorage.js';
+import { createUserManager } from './userManager.js';
 // codecs
 export const HandshakeData = Enum({
     V1: Tuple(SsPubKey, EncrPubKey, str),
@@ -15,101 +17,76 @@ export const HandshakeResponsePayload = Enum({
 });
 export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));
 export function createSignInFlow({ appId, metadata, statements, storage }) {
+    const userManager = createUserManager(appId, storage);
     const secretStorage = createSecretStorage(appId, storage);
-    const events = createNanoEvents();
-    let signInStatus = { step: 'none' };
-    events.on('status', status => {
-        signInStatus = status;
-    });
+    const signInStatus = createSyncStorage({ step: 'none' });
     let signInPromise = null;
     let abort = null;
-    const signInFlow = {
-        getSignedUser() {
-            return Promise.all([secretStorage.readSessionTopic(), secretStorage.readPappAccountId()]).then(([existingSessionTopic, existingPappAccountId]) => {
-                if (existingSessionTopic && existingPappAccountId) {
-                    events.emit('status', {
-                        step: 'finished',
-                        sessionTopic: existingSessionTopic,
-                        pappAccountId: existingPappAccountId,
+    async function handshake(signal) {
+        signInStatus.write({ step: 'initial' });
+        const secrets = await getSecretKeys(appId, secretStorage);
+        return secrets.andThenPromise(async ({ ssPublicKey, encrPublicKey, encrSecret }) => {
+            const handshakeTopic = createHandshakeTopic({ encrPublicKey, ssPublicKey });
+            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata });
+            signInStatus.write({ step: 'pairing', payload: createDeeplink(handshakePayload) });
+            const statementStoreResponse = fromPromise(waitForStatements(statements, handshakeTopic, signal, (statements, resolve) => {
+                for (const statement of [...statements].reverse()) {
+                    if (!statement.data)
+                        continue;
+                    const { sessionTopic, accountId } = retrieveSessionTopic({
+                        payload: statement.data.asBytes(),
+                        encrSecret,
+                        ssPublicKey,
                     });
-                    return {
-                        sessionTopic: existingSessionTopic,
-                        pappAccountId: existingPappAccountId,
-                    };
+                    resolve({ sessionTopic, accountId: toHex(accountId) });
+                    break;
                 }
-                return null;
-            });
-        },
+            }), toError);
+            return statementStoreResponse
+                .then(x => x.andThenPromise(userManager.createUser))
+                .then(async (result) => result
+                .map(user => {
+                signInStatus.write({ step: 'finished', user });
+                return user;
+            })
+                .orElse(e => {
+                const error = toError(e);
+                if (isAbortError(error)) {
+                    signInStatus.write({ step: 'none' });
+                    return ok(null);
+                }
+                else {
+                    signInStatus.write({ step: 'error', message: error.message });
+                    return err(error);
+                }
+            }));
+        });
+    }
+    const signInFlow = {
+        signInStatus,
+        users: userManager,
         async signIn() {
             if (signInPromise) {
                 return signInPromise;
             }
             abort = new AbortController();
-            events.emit('status', { step: 'initial' });
-            signInPromise = signInFlow
-                .getSignedUser()
-                .then(async (signedIn) => {
-                if (signedIn) {
-                    events.emit('status', {
-                        step: 'finished',
-                        sessionTopic: signedIn.sessionTopic,
-                        pappAccountId: signedIn.pappAccountId,
-                    });
-                    return signedIn;
-                }
-                const { ssPublicKey, encrPublicKey, encrSecret } = await getSecretKeys(appId, secretStorage);
-                const handshakeTopic = createHandshakeTopic({ encrPublicKey, ssPublicKey });
-                const handshakePayload = createHandshakePayload({ ssPublicKey, encrPublicKey, metadata });
-                events.emit('status', { step: 'pairing', payload: createDeeplink(handshakePayload) });
-                return waitForStatements(statements, handshakeTopic, abort?.signal ?? null, (statements, resolve) => {
-                    for (const statement of [...statements].reverse()) {
-                        if (!statement.data)
-                            continue;
-                        const { sessionTopic, pappAccountId } = retrieveSessionTopic({
-                            payload: statement.data.asBytes(),
-                            encrSecret,
-                            ssPublicKey,
-                        });
-                        resolve({ sessionTopic, pappAccountId: toHex(pappAccountId) });
-                        break;
-                    }
-                });
-            })
-                .then(async ({ sessionTopic, pappAccountId }) => {
-                await secretStorage.writeSessionTopic(sessionTopic);
-                await secretStorage.writePappAccountId(pappAccountId);
-                events.emit('status', { step: 'finished', sessionTopic, pappAccountId });
-                return { sessionTopic, pappAccountId };
-            })
-                .catch(e => {
-                if (isAbortError(e)) {
-                    events.emit('status', { step: 'none' });
-                    return null;
-                }
-                events.emit('status', { step: 'error', message: e.message });
-                throw e;
-            });
+            signInPromise = handshake(abort.signal);
             return signInPromise;
         },
         abortSignIn() {
             if (abort) {
-                events.emit('status', { step: 'none' });
+                signInPromise = null;
+                signInStatus.reset();
                 abort.abort();
             }
         },
-        getSignInStatus() {
-            return signInStatus;
-        },
-        onStatusChange(callback) {
-            return events.on('status', callback);
-        },
     };
     return signInFlow;
 }
 function createHandshakeTopic({ encrPublicKey, ssPublicKey, }) {
     return khash(ssPublicKey, mergeBytes(encrPublicKey, stringToBytes('topic')));
 }
-function createHandshakePayload({ encrPublicKey, ssPublicKey, metadata, }) {
+function createHandshakePayloadV1({ encrPublicKey, ssPublicKey, metadata, }) {
     return HandshakeData.enc({
         tag: 'V1',
         value: [ssPublicKey, encrPublicKey, metadata],
@@ -131,7 +108,6 @@ function retrieveSessionTopic({ payload, encrSecret, ssPublicKey, }) {
     const { encrypted, tmpKey } = parseHandshakePayload(payload);
     const symmetricKey = createSymmetricKey(createSharedSecret(encrSecret, tmpKey));
     const decrypted = decrypt(symmetricKey, encrypted);
-    console.log('decrypted', decrypted.length, 65 + 32); // true
     const [pappEncrPublicKey, userPublicKey] = HandshakeResponseSensitiveData.dec(decrypted);
     const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
     const session = createSession({
@@ -139,33 +115,48 @@ function retrieveSessionTopic({ payload, encrSecret, ssPublicKey, }) {
         accountA: ssPublicKey,
         accountB: pappEncrPublicKey,
     });
-    console.log('userPublicKey', userPublicKey.length, toHex(userPublicKey));
-    console.log('sessionTopic', session.a.length, toHex(session.a));
     return {
-        pappAccountId: userPublicKey,
+        accountId: userPublicKey,
         sessionTopic: session.a,
     };
 }
+async function getSsKeys(appId, secretStorage) {
+    return (await secretStorage.readSsSecret())
+        .andThenPromise(async (ssSecret) => {
+        if (ssSecret) {
+            return ok(ssSecret);
+        }
+        const seed = createRandomSeed(appId, SS_SECRET_SEED_SIZE);
+        const newSsSecret = createSsSecret(seed);
+        const write = await secretStorage.writeSsSecret(newSsSecret);
+        return write.map(() => newSsSecret);
+    })
+        .then(x => x.map(ssSecret => ({
+        ssSecret: ssSecret,
+        ssPublicKey: getSsPub(ssSecret),
+    })));
+}
+async function getEncrKeys(appId, secretStorage) {
+    return (await secretStorage.readEncrSecret())
+        .andThenPromise(async (encrSecret) => {
+        if (encrSecret) {
+            return ok(encrSecret);
+        }
+        const seed = createRandomSeed(appId, ENCR_SECRET_SEED_SIZE);
+        const newEncrSecret = createEncrSecret(seed);
+        const write = await secretStorage.writeEncrSecret(newEncrSecret);
+        return write.map(() => newEncrSecret);
+    })
+        .then(x => x.map(encrSecret => ({
+        encrSecret,
+        encrPublicKey: getEncrPub(encrSecret),
+    })));
+}
 async function getSecretKeys(appId, secretStorage) {
-    let ssSecret = await secretStorage.readSsSecret();
-    if (!ssSecret) {
-        // TODO randomize seed
-        // For testing purpose only
-        const seed = createStableSeed(appId, SS_SECRET_SEED_SIZE);
-        ssSecret = createSsSecret(seed);
-        await secretStorage.writeSsSecret(ssSecret);
-    }
-    let encrSecret = await secretStorage.readEncrSecret();
-    if (!encrSecret) {
-        // TODO randomize seed
-        // For testing purpose only
-        const seed = createStableSeed(appId, ENCR_SECRET_SEED_SIZE);
-        encrSecret = createEncrSecret(seed);
-        await secretStorage.writeEncrSecret(encrSecret);
-    }
-    const ssPublicKey = getSsPub(ssSecret);
-    const encrPublicKey = getEncrPub(encrSecret);
-    return { ssPublicKey, encrPublicKey, ssSecret, encrSecret };
+    return seq(await getSsKeys(appId, secretStorage), await getEncrKeys(appId, secretStorage)).map(([ss, encr]) => ({
+        ...ss,
+        ...encr,
+    }));
 }
 function createDeeplink(payload) {
     return `polkadotapp://pair?handshake=${toHex(payload)}`;
@@ -182,10 +173,16 @@ function waitForStatements(transport, topic, abortSignal, callback) {
                     reject(e);
                 }
             }
-            callback(statements, value => {
+            try {
+                callback(statements, value => {
+                    unsubscribe();
+                    resolve(value);
+                });
+            }
+            catch (e) {
                 unsubscribe();
-                resolve(value);
-            });
+                reject(e);
+            }
         });
     });
 }

package/dist/modules/state.d.ts

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

package/dist/modules/state.js

@@ -0,0 +1,50 @@
+import { createNanoEvents } from 'nanoevents';
+export function createState(initial) {
+    const events = createNanoEvents();
+    let currentValue = initial;
+    return {
+        read() {
+            return currentValue;
+        },
+        write(value) {
+            if (currentValue !== value) {
+                currentValue = value;
+                events.emit('value', value);
+            }
+            return value;
+        },
+        reset() {
+            if (currentValue !== initial) {
+                currentValue = initial;
+                events.emit('value', initial);
+            }
+        },
+        subscribe(fn) {
+            if (!events.events.value || events.events.value.length === 0) {
+                events.emit('first');
+            }
+            const unsubscribe = events.on('value', fn);
+            fn(currentValue);
+            return () => {
+                unsubscribe();
+                if (!events.events.value || events.events.value.length === 0) {
+                    events.emit('last');
+                }
+            };
+        },
+        onFirstSubscribe(callback) {
+            return events.on('first', callback);
+        },
+        onLastUnsubscribe(callback) {
+            return events.on('last', callback);
+        },
+    };
+}
+export function readonly(state) {
+    return {
+        read: state.read,
+        subscribe: state.subscribe,
+        onFirstSubscribe: state.onFirstSubscribe,
+        onLastUnsubscribe: state.onLastUnsubscribe,
+    };
+}

package/dist/modules/statementStore.d.ts

@@ -1,13 +1,12 @@
-import type { UnsignedStatement } from '@polkadot-api/sdk-statement';
+import type { UserSession } from '../sso/session/ssoSessionStorage.js';
 import type { SsSecret } from './crypto.js';
-export declare function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }: {
-    sharedSecret: Uint8Array;
-    accountA: Uint8Array;
-    accountB: Uint8Array;
-    pinA?: string;
-    pinB?: string;
-}): {
-    a: Uint8Array<ArrayBufferLike>;
-    b: Uint8Array<ArrayBufferLike>;
+import type { Account } from './session/types.js';
+export declare function createUserSession(hostAccount: Account, peerAccount: Account): UserSession;
+type StatementPayload = {
+    priority: number;
+    channel: Uint8Array;
+    topics: Uint8Array[];
+    data: Uint8Array;
 };
-export declare function createStatement(secret: SsSecret, payload: UnsignedStatement): Promise<import("@polkadot-api/sdk-statement").SignedStatement>;
+export declare function createStatement(secret: SsSecret, payload: StatementPayload): import("neverthrow").ResultAsync<import("@polkadot-api/sdk-statement").SignedStatement, Error>;
+export {};

package/dist/modules/statementStore.js

@@ -1,20 +1,22 @@
 import { getStatementSigner } from '@polkadot-api/sdk-statement';
-import * as sr25519 from '@scure/sr25519';
-import { getSsPub, khash, mergeBytes, stringToBytes } from './crypto.js';
-export function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }) {
-    const sessionPrefix = stringToBytes('session');
-    const pinSeparator = stringToBytes('/');
-    function makePin(pin) {
-        return pin ? mergeBytes(pinSeparator, stringToBytes(pin)) : pinSeparator;
-    }
-    const accountASessionParams = mergeBytes(sessionPrefix, accountA, accountB, makePin(pinA), makePin(pinB));
-    const accountBSessionParams = mergeBytes(sessionPrefix, accountB, accountA, makePin(pinB), makePin(pinA));
+import { Binary } from '@polkadot-api/substrate-bindings';
+import { nanoid } from 'nanoid';
+import { fromPromise } from 'neverthrow';
+import { toError } from '../helpers/utils.js';
+import { getSsPub, signWithSsSecret } from './crypto.js';
+export function createUserSession(hostAccount, peerAccount) {
     return {
-        a: khash(sharedSecret, accountASessionParams),
-        b: khash(sharedSecret, accountBSessionParams),
+        id: nanoid(12),
+        peer: peerAccount,
+        host: hostAccount,
     };
 }
 export function createStatement(secret, payload) {
-    const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => sr25519.sign(secret, data));
-    return signer.sign(payload);
+    const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
+    return fromPromise(signer.sign({
+        priority: payload.priority,
+        channel: Binary.fromBytes(payload.channel),
+        topics: payload.topics.map(Binary.fromBytes),
+        data: Binary.fromBytes(payload.data),
+    }), toError);
 }

package/dist/modules/statementTopic.d.ts

@@ -0,0 +1,34 @@
+import type { Statement } from '@polkadot-api/sdk-statement';
+import type { StatementAdapter } from '../adapters/statement/types.js';
+import type { StorageAdapter } from '../adapters/storage/types.js';
+import type { Callback } from '../types.js';
+import type { SsSecret } from './crypto.js';
+export declare function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }: {
+    sharedSecret: Uint8Array;
+    accountA: Uint8Array;
+    accountB: Uint8Array;
+    pinA?: string;
+    pinB?: string;
+}): {
+    a: Uint8Array<ArrayBufferLike>;
+    b: Uint8Array<ArrayBufferLike>;
+};
+export declare function createRequestChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function createResponseChannel(session: Uint8Array): Uint8Array<ArrayBufferLike>;
+type StatementPayload = {
+    priority: number;
+    channel: Uint8Array;
+    topics: Uint8Array[];
+    data: Uint8Array;
+};
+export declare function createStatement(secret: SsSecret, payload: StatementPayload): Promise<import("@polkadot-api/sdk-statement").SignedStatement>;
+type Params = {
+    topic: Uint8Array;
+    statement: StatementAdapter;
+    storage: StorageAdapter;
+};
+export declare function createStatementTopic({ topic, statement }: Params): {
+    subscribe(callback: Callback<Statement, boolean>): VoidFunction;
+    submit(): void;
+};
+export {};

package/dist/modules/statementTopic.js

@@ -0,0 +1,46 @@
+import { getStatementSigner } from '@polkadot-api/sdk-statement';
+import { Binary } from '@polkadot-api/substrate-bindings';
+import { getSsPub, khash, mergeBytes, signWithSsSecret, stringToBytes } from './crypto.js';
+export function createSession({ sharedSecret, accountA, accountB, pinA, pinB, }) {
+    const sessionPrefix = stringToBytes('session');
+    const pinSeparator = stringToBytes('/');
+    function makePin(pin) {
+        return pin ? mergeBytes(pinSeparator, stringToBytes(pin)) : pinSeparator;
+    }
+    const accountASessionParams = mergeBytes(sessionPrefix, accountA, accountB, makePin(pinA), makePin(pinB));
+    const accountBSessionParams = mergeBytes(sessionPrefix, accountB, accountA, makePin(pinB), makePin(pinA));
+    return {
+        a: khash(sharedSecret, accountASessionParams),
+        b: khash(sharedSecret, accountBSessionParams),
+    };
+}
+export function createRequestChannel(session) {
+    return khash(session, stringToBytes('request'));
+}
+export function createResponseChannel(session) {
+    return khash(session, stringToBytes('response'));
+}
+export function createStatement(secret, payload) {
+    const signer = getStatementSigner(getSsPub(secret), 'sr25519', data => signWithSsSecret(secret, data));
+    return signer.sign({
+        priority: payload.priority,
+        channel: Binary.fromBytes(payload.channel),
+        topics: payload.topics.map(Binary.fromBytes),
+        data: Binary.fromBytes(payload.data),
+    });
+}
+export function createStatementTopic({ topic, statement }) {
+    return {
+        subscribe(callback) {
+            return statement.subscribeStatements([topic], statements => {
+                for (const statement of statements) {
+                    const processed = callback(statement);
+                    if (processed) {
+                        // TODO save anywhere
+                    }
+                }
+            });
+        },
+        submit() { },
+    };
+}

package/dist/modules/storageView.d.ts

@@ -0,0 +1,25 @@
+import type { ResultAsync } from 'neverthrow';
+import type { StorageAdapter } from '../adapters/storage/types.js';
+type Params<T> = {
+    storage: StorageAdapter;
+    key: string;
+    initial: T;
+    autosync?: boolean;
+    from(value: string): T;
+    to(value: T): string | null;
+};
+export declare function storageView<T>({ storage, initial, key, from, to, autosync }: Params<T>): {
+    read(): any;
+    write(value: T): any;
+    clear(): any;
+    subscribe(fn: (value: T) => void): () => void;
+};
+export declare function storageListView<T>(params: Params<T[]>): {
+    add(value: T): ResultAsync<T, Error>;
+    mutate(fn: (value: T[]) => T[]): ResultAsync<T[], Error>;
+    read(): any;
+    write(value: T[]): any;
+    clear(): any;
+    subscribe(fn: (value: T[]) => void): () => void;
+};
+export {};