@novasamatech/statement-store 0.5.0-10

package/README.md

@@ -0,0 +1,11 @@
+# @novasamatech/statement-store
+
+Statement store integration layer.
+
+## Overview
+
+## Installation
+
+```shell
+npm install @novasamatech/statement-store --save -E
+```

package/dist/adapter/lazyClient.d.ts

@@ -0,0 +1,7 @@
+import type { JsonRpcProvider } from '@polkadot-api/json-rpc-provider';
+import type { PolkadotClient } from 'polkadot-api';
+export type LazyClient = ReturnType<typeof createLazyClient>;
+export declare const createLazyClient: (provider: JsonRpcProvider) => {
+    getClient(): PolkadotClient;
+    disconnect(): void;
+};

package/dist/adapter/lazyClient.js

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

package/dist/adapter/rpc.d.ts

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

package/dist/adapter/rpc.js

@@ -0,0 +1,93 @@
+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.js';
+const POLLING_INTERVAL = 1500;
+function createKey(topics) {
+    return topics.map(toHex).sort().join('');
+}
+export function createPapiStatementStoreAdapter(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/adapter/types.d.ts

@@ -0,0 +1,7 @@
+import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+import type { ResultAsync } from 'neverthrow';
+export type StatementStoreAdapter = {
+    queryStatements(topics: Uint8Array[], destination?: Uint8Array): ResultAsync<Statement[], Error>;
+    subscribeStatements(topics: Uint8Array[], callback: (statements: Statement[]) => unknown): VoidFunction;
+    submitStatement(statement: SignedStatement): ResultAsync<void, Error>;
+};

package/dist/adapter/types.js

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

package/dist/crypto.d.ts

@@ -0,0 +1,7 @@
+import type { Codec } from 'scale-ts';
+export declare function BrandedBytesCodec<T extends Uint8Array>(length?: number): Codec<T>;
+export declare function stringToBytes(str: string): Uint8Array<ArrayBuffer>;
+/**
+ * blake2b_256 with key
+ */
+export declare function khash(secret: Uint8Array, message: Uint8Array): Uint8Array<ArrayBufferLike>;

package/dist/crypto.js

@@ -0,0 +1,16 @@
+import { blake2b } from '@noble/hashes/blake2.js';
+import { Bytes } from 'scale-ts';
+export function BrandedBytesCodec(length) {
+    return Bytes(length);
+}
+// helpers
+const textEncoder = new TextEncoder();
+export function stringToBytes(str) {
+    return textEncoder.encode(str);
+}
+/**
+ * blake2b_256 with key
+ */
+export function khash(secret, message) {
+    return blake2b(message, { dkLen: 32, key: secret });
+}

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function toError(err: unknown): Error;
+export declare function nonNullable<T>(value: T): value is Exclude<NonNullable<T>, void>;

package/dist/helpers.js

@@ -0,0 +1,12 @@
+export function toError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    if (err) {
+        return new Error(err.toString());
+    }
+    return new Error('Unknown error occurred.');
+}
+export function nonNullable(value) {
+    return value !== null && value !== undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { Statement } from '@polkadot-api/sdk-statement';
+export type { SessionId } from './model/session.js';
+export { SessionIdCodec, createSessionId } from './model/session.js';
+export type { AccountId, LocalSessionAccount, RemoteSessionAccount, SessionAccount } from './model/sessionAccount.js';
+export { AccountIdCodec, LocalSessionAccountCodec, RemoteSessionAccountCodec, createAccountId, createLocalSessionAccount, createRemoteSessionAccount, } from './model/sessionAccount.js';
+export type { Session } from './session/types.js';
+export { createSession } from './session/session.js';
+export type { StatementProver } from './session/statementProver.js';
+export type { Encryption } from './session/encyption.js';
+export { createEncryption } from './session/encyption.js';
+export { DecodingError, DecryptionError, UnknownError } from './session/error.js';
+export type { LazyClient } from './adapter/lazyClient.js';
+export { createLazyClient } from './adapter/lazyClient.js';
+export type { StatementStoreAdapter } from './adapter/types.js';
+export { createPapiStatementStoreAdapter } from './adapter/rpc.js';
+export { khash } from './crypto.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { SessionIdCodec, createSessionId } from './model/session.js';
+export { AccountIdCodec, LocalSessionAccountCodec, RemoteSessionAccountCodec, createAccountId, createLocalSessionAccount, createRemoteSessionAccount, } from './model/sessionAccount.js';
+export { createSession } from './session/session.js';
+export { createEncryption } from './session/encyption.js';
+export { DecodingError, DecryptionError, UnknownError } from './session/error.js';
+export { createLazyClient } from './adapter/lazyClient.js';
+export { createPapiStatementStoreAdapter } from './adapter/rpc.js';
+export { khash } from './crypto.js';

package/dist/model/session.d.ts

@@ -0,0 +1,5 @@
+import type { Branded } from '../types.js';
+import type { SessionAccount } from './sessionAccount.js';
+export type SessionId = Branded<Uint8Array, 'SessionId'>;
+export declare const SessionIdCodec: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare function createSessionId(sharedSecret: Uint8Array, accountA: SessionAccount, accountB: SessionAccount): SessionId;

package/dist/model/session.js

@@ -0,0 +1,18 @@
+import { mergeUint8 } from '@polkadot-api/utils';
+import { Bytes } from 'scale-ts';
+import { khash, stringToBytes } from '../crypto.js';
+export const SessionIdCodec = Bytes(32);
+export function createSessionId(sharedSecret, accountA, accountB) {
+    const sessionPrefix = stringToBytes('session');
+    const pinSeparator = stringToBytes('/');
+    function makePin(pin) {
+        return pin ? mergeUint8([pinSeparator, stringToBytes(pin)]) : pinSeparator;
+    }
+    const accountSessionParams = mergeUint8([
+        accountA.accountId,
+        accountB.accountId,
+        makePin(accountA.pin),
+        makePin(accountB.pin),
+    ]);
+    return khash(sharedSecret, mergeUint8([sessionPrefix, accountSessionParams]));
+}

package/dist/model/sessionAccount.d.ts

@@ -0,0 +1,23 @@
+import type { Branded } from '../types.js';
+export type AccountId = Branded<Uint8Array, 'AccountId'>;
+export declare const AccountIdCodec: import("scale-ts").Codec<AccountId>;
+export declare function createAccountId(value: Uint8Array): AccountId;
+export type SessionAccount = {
+    accountId: AccountId;
+    pin: string | undefined;
+};
+export type LocalSessionAccount = SessionAccount;
+export declare const LocalSessionAccountCodec: import("scale-ts").Codec<{
+    accountId: AccountId;
+    pin: string | undefined;
+}>;
+export declare function createLocalSessionAccount(accountId: AccountId, pin?: string): LocalSessionAccount;
+export type RemoteSessionAccount = SessionAccount & {
+    publicKey: Uint8Array;
+};
+export declare const RemoteSessionAccountCodec: import("scale-ts").Codec<{
+    accountId: AccountId;
+    publicKey: Uint8Array<ArrayBufferLike>;
+    pin: string | undefined;
+}>;
+export declare function createRemoteSessionAccount(accountId: AccountId, publicKey: Uint8Array, pin?: string): RemoteSessionAccount;

package/dist/model/sessionAccount.js

@@ -0,0 +1,28 @@
+import { Bytes, Option, Struct, str } from 'scale-ts';
+import { BrandedBytesCodec } from '../crypto.js';
+export const AccountIdCodec = BrandedBytesCodec(32);
+export function createAccountId(value) {
+    return value.slice(0, 32);
+}
+export const LocalSessionAccountCodec = Struct({
+    accountId: AccountIdCodec,
+    pin: Option(str),
+});
+export function createLocalSessionAccount(accountId, pin) {
+    return {
+        accountId,
+        pin,
+    };
+}
+export const RemoteSessionAccountCodec = Struct({
+    accountId: AccountIdCodec,
+    publicKey: Bytes(32),
+    pin: Option(str),
+});
+export function createRemoteSessionAccount(accountId, publicKey, pin) {
+    return {
+        accountId,
+        publicKey,
+        pin,
+    };
+}

package/dist/session/encyption.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'neverthrow';
+export type Encryption = {
+    encrypt(cipherText: Uint8Array): Result<Uint8Array, Error>;
+    decrypt(encryptedMessage: Uint8Array): Result<Uint8Array, Error>;
+};
+export declare function createEncryption(sharedSecret: Uint8Array): Encryption;

package/dist/session/encyption.js

@@ -0,0 +1,24 @@
+import { gcm } from '@noble/ciphers/aes.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+import { mergeUint8 } from '@polkadot-api/utils';
+import { Result, fromThrowable } from 'neverthrow';
+export function createEncryption(sharedSecret) {
+    const salt = new Uint8Array(); // secure enough since P256 random keys provide enough entropy
+    const info = new Uint8Array(); // no need to introduce any context
+    const aesKey = hkdf(sha256, sharedSecret, salt, info, 32);
+    return {
+        encrypt: fromThrowable(cipherText => {
+            const nonce = randomBytes(12);
+            const aes = gcm(aesKey, nonce);
+            return mergeUint8([nonce, aes.encrypt(cipherText)]);
+        }),
+        decrypt: fromThrowable(encryptedMessage => {
+            const nonce = encryptedMessage.slice(0, 12);
+            const cipherText = encryptedMessage.slice(12);
+            const aes = gcm(aesKey, nonce);
+            return aes.decrypt(cipherText);
+        }),
+    };
+}

package/dist/session/error.d.ts

@@ -0,0 +1,9 @@
+export declare class DecryptionError extends Error {
+    constructor();
+}
+export declare class DecodingError extends Error {
+    constructor();
+}
+export declare class UnknownError extends Error {
+    constructor();
+}

package/dist/session/error.js

@@ -0,0 +1,15 @@
+export class DecryptionError extends Error {
+    constructor() {
+        super('Decryption error: failed to decrypt the request');
+    }
+}
+export class DecodingError extends Error {
+    constructor() {
+        super('Decoding error: failed to decode the request');
+    }
+}
+export class UnknownError extends Error {
+    constructor() {
+        super('Unknown error during request.');
+    }
+}

package/dist/session/messageMapper.d.ts

@@ -0,0 +1,4 @@
+import type { CodecType } from 'scale-ts';
+import type { StatementData } from './scale/statementData.js';
+import type { Message } from './types.js';
+export declare function toMessage<T>(statementData: CodecType<ReturnType<typeof StatementData<T>>>): Message<T>[];

package/dist/session/messageMapper.js

@@ -0,0 +1,20 @@
+export function toMessage(statementData) {
+    switch (statementData.tag) {
+        case 'request':
+            return statementData.value.data.map((payload, index) => ({
+                type: 'request',
+                localId: `${statementData.value.requestId}-${index.toString()}`,
+                requestId: statementData.value.requestId,
+                payload,
+            }));
+        case 'response':
+            return [
+                {
+                    type: 'response',
+                    localId: statementData.value.requestId,
+                    requestId: statementData.value.requestId,
+                    responseCode: statementData.value.responseCode,
+                },
+            ];
+    }
+}

package/dist/session/scale/statementData.d.ts

@@ -0,0 +1,24 @@
+import type { Codec } from 'scale-ts';
+export type ResponseCode = 'success' | 'decryptionFailed' | 'decodingFailed' | 'unknown';
+export declare const ResponseCodeCodec: Codec<ResponseCode>;
+export declare const Request: <T>(data: Codec<T>) => Codec<{
+    requestId: string;
+    data: T[];
+}>;
+export declare const Response: Codec<{
+    requestId: string;
+    responseCode: ResponseCode;
+}>;
+export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+    tag: "request";
+    value: {
+        requestId: string;
+        data: T[];
+    };
+} | {
+    tag: "response";
+    value: {
+        requestId: string;
+        responseCode: ResponseCode;
+    };
+}>;

package/dist/session/scale/statementData.js

@@ -0,0 +1,40 @@
+import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
+export const ResponseCodeCodec = enhanceCodec(u8, error => {
+    switch (error) {
+        case 'success':
+            return 0;
+        case 'decryptionFailed':
+            return 1;
+        case 'decodingFailed':
+            return 2;
+        case 'unknown':
+            return 255;
+    }
+}, code => {
+    switch (code) {
+        case 0:
+            return 'success';
+        case 1:
+            return 'decryptionFailed';
+        case 2:
+            return 'decodingFailed';
+        default:
+            return 'unknown';
+    }
+});
+export const Request = (data) => {
+    return Struct({
+        requestId: str,
+        data: Vector(data),
+    });
+};
+export const Response = Struct({
+    requestId: str,
+    responseCode: ResponseCodeCodec,
+});
+export const StatementData = (data) => {
+    return Enum({
+        request: Request(data),
+        response: Response,
+    });
+};

package/dist/session/session.d.ts

@@ -0,0 +1,13 @@
+import type { StatementStoreAdapter } from '../adapter/types.js';
+import type { LocalSessionAccount, RemoteSessionAccount } from '../model/sessionAccount.js';
+import type { Encryption } from './encyption.js';
+import type { StatementProver } from './statementProver.js';
+import type { Session } from './types.js';
+export type SessionParams = {
+    localAccount: LocalSessionAccount;
+    remoteAccount: RemoteSessionAccount;
+    statementStore: StatementStoreAdapter;
+    encryption: Encryption;
+    prover: StatementProver;
+};
+export declare function createSession({ localAccount, remoteAccount, statementStore, encryption, prover, }: SessionParams): Session;

package/dist/session/session.js

@@ -0,0 +1,144 @@
+import { Binary } from '@polkadot-api/substrate-bindings';
+import { nanoid } from 'nanoid';
+import { ResultAsync, err, fromPromise, fromThrowable, ok, okAsync } from 'neverthrow';
+import { Bytes } from 'scale-ts';
+import { khash, stringToBytes } from '../crypto.js';
+import { nonNullable, toError } from '../helpers.js';
+import { createSessionId } from '../model/session.js';
+import { DecodingError, DecryptionError, UnknownError } from './error.js';
+import { toMessage } from './messageMapper.js';
+import { StatementData } from './scale/statementData.js';
+export function createSession({ localAccount, remoteAccount, statementStore, encryption, prover, }) {
+    let subscriptions = [];
+    function submit(sessionId, channel, data) {
+        return encryption
+            .encrypt(data)
+            .map(data => ({
+            priority: getPriority(now()),
+            channel: Binary.fromBytes(channel),
+            topics: [Binary.fromBytes(sessionId)],
+            data: Binary.fromBytes(data),
+        }))
+            .asyncAndThen(prover.generateMessageProof)
+            .andThen(statementStore.submitStatement);
+    }
+    const session = {
+        request(codec, data) {
+            return session.submitRequestMessage(codec, data).andThen(({ requestId }) => {
+                return session.waitForResponseMessage(requestId).andThen(({ responseCode }) => mapResponseCode(responseCode));
+            });
+        },
+        submitRequestMessage(codec, message) {
+            const requestId = nanoid();
+            const sessionId = createSessionId(remoteAccount.publicKey, localAccount, remoteAccount);
+            const statementDataCodec = StatementData(codec);
+            const encode = fromThrowable(statementDataCodec.enc, toError);
+            const rawData = encode({
+                tag: 'request',
+                value: { requestId, data: [message] },
+            });
+            return rawData
+                .asyncAndThen(data => submit(sessionId, createRequestChannel(sessionId), data))
+                .map(() => ({ requestId }));
+        },
+        submitResponseMessage(requestId, responseCode) {
+            const sessionId = createSessionId(remoteAccount.publicKey, localAccount, remoteAccount);
+            const statementDataCodec = StatementData(Bytes());
+            const encode = fromThrowable(statementDataCodec.enc, toError);
+            const rawData = encode({
+                tag: 'response',
+                value: { requestId, responseCode },
+            });
+            return rawData.asyncAndThen(data => submit(sessionId, createResponseChannel(sessionId), data));
+        },
+        waitForRequestMessage(codec, filter) {
+            const promise = new Promise(resolve => {
+                const unsubscribe = session.subscribe(codec, messages => {
+                    for (const message of messages) {
+                        if (message.type === 'request' && filter(message.payload)) {
+                            unsubscribe();
+                            resolve({
+                                type: 'request',
+                                localId: message.localId,
+                                requestId: message.requestId,
+                                payload: message.payload,
+                            });
+                            break;
+                        }
+                    }
+                });
+            });
+            return fromPromise(promise, toError);
+        },
+        waitForResponseMessage(requestId) {
+            const promise = new Promise(resolve => {
+                const unsub = session.subscribe(Bytes(), messages => {
+                    const response = messages.filter(m => m.type === 'response').find(m => m.requestId === requestId);
+                    if (response) {
+                        unsub();
+                        resolve(response);
+                    }
+                });
+            });
+            return fromPromise(promise, toError);
+        },
+        subscribe(codec, callback) {
+            const statementDataCodec = StatementData(codec);
+            const sessionId = createSessionId(remoteAccount.publicKey, remoteAccount, localAccount);
+            function processStatement(statement) {
+                if (!statement.data)
+                    return okAsync(null);
+                const data = statement.data.asBytes();
+                return prover
+                    .verifyMessageProof(statement)
+                    .andThen(verified => (verified ? ok() : err(new Error('Statement proof is not valid'))))
+                    .andThen(() => encryption.decrypt(data))
+                    .map(statementDataCodec.dec)
+                    .orElse(() => ok(null));
+            }
+            return statementStore.subscribeStatements([sessionId], statements => {
+                ResultAsync.combine(statements.map(processStatement))
+                    .map(messages => messages.filter(nonNullable).flatMap(toMessage))
+                    .andTee(messages => {
+                    if (messages.length > 0) {
+                        callback(messages);
+                    }
+                });
+            });
+        },
+        dispose() {
+            for (const unsub of subscriptions) {
+                unsub();
+            }
+            subscriptions = [];
+        },
+    };
+    return session;
+}
+function mapResponseCode(responseCode) {
+    switch (responseCode) {
+        case 'success':
+            return ok();
+        case 'decodingFailed':
+            return err(new DecodingError());
+        case 'decryptionFailed':
+            return err(new DecryptionError());
+        case 'unknown':
+            return err(new UnknownError());
+    }
+}
+function now() {
+    const d1 = new Date();
+    const d2 = new Date(d1.getUTCFullYear(), d1.getUTCMonth(), d1.getUTCDate(), d1.getUTCHours(), d1.getUTCMinutes(), d1.getUTCSeconds());
+    return d2.getTime();
+}
+function getPriority(timestamp) {
+    // time - (November 15, 2025)
+    return Math.floor((timestamp - 1763154000000) / 1000);
+}
+function createRequestChannel(sessionId) {
+    return khash(sessionId, stringToBytes('request'));
+}
+function createResponseChannel(sessionId) {
+    return khash(sessionId, stringToBytes('response'));
+}

package/dist/session/statementProver.d.ts

@@ -0,0 +1,6 @@
+import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+import type { ResultAsync } from 'neverthrow';
+export type StatementProver = {
+    generateMessageProof(statement: Statement): ResultAsync<SignedStatement, Error>;
+    verifyMessageProof(statement: Statement): ResultAsync<boolean, Error>;
+};

package/dist/session/statementProver.js

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

package/dist/session/types.d.ts

@@ -0,0 +1,30 @@
+import type { ResultAsync } from 'neverthrow';
+import type { Codec } from 'scale-ts';
+import type { Callback } from '../types.js';
+import type { DecodingError } from './error.js';
+import { DecryptionError, UnknownError } from './error.js';
+import type { ResponseCode } from './scale/statementData.js';
+export type RequestMessage<T> = {
+    type: 'request';
+    localId: string;
+    requestId: string;
+    payload: T;
+};
+export type ResponseMessage = {
+    type: 'response';
+    localId: string;
+    requestId: string;
+    responseCode: ResponseCode;
+};
+export type Message<T> = RequestMessage<T> | ResponseMessage;
+export type Session = {
+    request<T>(codec: Codec<T>, payload: T): ResultAsync<void, DecodingError | DecryptionError | UnknownError | Error>;
+    submitRequestMessage<T>(codec: Codec<T>, payload: T): ResultAsync<{
+        requestId: string;
+    }, Error>;
+    submitResponseMessage(requestId: string, responseCode: ResponseCode): ResultAsync<void, Error>;
+    waitForRequestMessage<T>(codec: Codec<T>, filter: (message: T) => boolean): ResultAsync<RequestMessage<T>, Error>;
+    waitForResponseMessage(requestId: string): ResultAsync<ResponseMessage, Error>;
+    subscribe<T>(codec: Codec<T>, callback: Callback<Message<T>[]>): VoidFunction;
+    dispose(): void;
+};

package/dist/session/types.js

@@ -0,0 +1 @@
+import { DecryptionError, UnknownError } from './error.js';

package/dist/transport/impl.d.ts

@@ -0,0 +1,32 @@
+import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+import type { ResultAsync } from 'neverthrow';
+import type { Codec } from 'scale-ts';
+import type { StatementAdapter } from '../adapter/types.js';
+import type { SessionId } from '../model/session.js';
+import type { Callback } from '../types.js';
+import type { TransportError } from './scale/statementData.js';
+export type Transport = ReturnType<typeof createTransport>;
+type RequestMessage<T> = {
+    type: 'request';
+    requestId: string;
+    data: T;
+};
+type ResponseMessage = {
+    type: 'response';
+    requestId: string;
+    code: TransportError;
+};
+type Message<T> = RequestMessage<T> | ResponseMessage;
+type Params = {
+    adapter: StatementAdapter;
+};
+export declare function createTransport({ adapter }: Params): {
+    subscribeStatements(topic: Uint8Array, callback: Callback<Statement[]>): VoidFunction;
+    subscribe<T>({ sessionId, sharedSecret, codec, }: {
+        sessionId: SessionId;
+        sharedSecret: Uint8Array;
+        codec: Codec<T>;
+    }, callback: Callback<Message<T>[]>): VoidFunction;
+    submitRequest(statement: SignedStatement): ResultAsync<void, Error>;
+};
+export {};

package/dist/transport/impl.js

@@ -0,0 +1,59 @@
+import { Result, fromThrowable, ok } from 'neverthrow';
+import { decrypt } from '../crypto.js';
+import { nonNullable, toError } from '../helpers.js';
+import { StatementData } from './scale/statementData.js';
+const decryptResults = fromThrowable(decrypt, toError);
+function mapMessage(statementData) {
+    switch (statementData.tag) {
+        case 'request':
+            return statementData.value.data.map((data, index) => ({
+                type: 'request',
+                requestId: `${statementData.value.requestId}-${index.toString()}`,
+                data,
+            }));
+        case 'response':
+            return [
+                {
+                    type: 'response',
+                    requestId: statementData.value.requestId,
+                    code: statementData.value.responseCode,
+                },
+            ];
+    }
+}
+// function createRequestChannel(session: Uint8Array) {
+//   return khash(session, stringToBytes('request'));
+// }
+//
+// export function createResponseChannel(session: Uint8Array) {
+//   return khash(session, stringToBytes('response'));
+// }
+export function createTransport({ adapter }) {
+    const transport = {
+        subscribeStatements(topic, callback) {
+            return adapter.subscribeStatements([topic], callback);
+        },
+        subscribe({ sessionId, sharedSecret, codec, }, callback) {
+            const statementDataCodec = StatementData(codec);
+            return adapter.subscribeStatements([sessionId], statements => {
+                Result.combine(statements.map(statement => {
+                    if (!statement.data)
+                        return ok(null);
+                    return decryptResults(sharedSecret, statement.data.asBytes())
+                        .map(statementDataCodec.dec)
+                        .orElse(() => ok(null));
+                }))
+                    .map(messages => messages.filter(nonNullable).flatMap(mapMessage))
+                    .andTee(messages => {
+                    if (messages.length > 0) {
+                        callback(messages);
+                    }
+                });
+            });
+        },
+        submitRequest(statement) {
+            return adapter.submitStatement(statement);
+        },
+    };
+    return transport;
+}

package/dist/transport/scale/opaque.d.ts

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

package/dist/transport/scale/opaque.js

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

package/dist/transport/scale/statementData.d.ts

@@ -0,0 +1,24 @@
+import type { Codec } from 'scale-ts';
+export type TransportError = 'decryptionFailed' | 'decodingFailed' | 'unknown';
+export declare const TransportErrorCodec: Codec<TransportError>;
+export declare const Request: <T>(data: Codec<T>) => Codec<{
+    requestId: string;
+    data: T[];
+}>;
+export declare const Response: Codec<{
+    requestId: string;
+    responseCode: TransportError;
+}>;
+export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+    tag: "request";
+    value: {
+        requestId: string;
+        data: T[];
+    };
+} | {
+    tag: "response";
+    value: {
+        requestId: string;
+        responseCode: TransportError;
+    };
+}>;

package/dist/transport/scale/statementData.js

@@ -0,0 +1,36 @@
+import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
+export const TransportErrorCodec = enhanceCodec(u8, error => {
+    switch (error) {
+        case 'decryptionFailed':
+            return 1;
+        case 'decodingFailed':
+            return 2;
+        case 'unknown':
+            return 255;
+    }
+}, code => {
+    switch (code) {
+        case 1:
+            return 'decryptionFailed';
+        case 2:
+            return 'decodingFailed';
+        default:
+            return 'unknown';
+    }
+});
+export const Request = (data) => {
+    return Struct({
+        requestId: str,
+        data: Vector(data),
+    });
+};
+export const Response = Struct({
+    requestId: str,
+    responseCode: TransportErrorCodec,
+});
+export const StatementData = (data) => {
+    return Enum({
+        request: Request(data),
+        response: Response,
+    });
+};

package/dist/transport/transport.d.ts

@@ -0,0 +1,31 @@
+import type { SignedStatement } from '@polkadot-api/sdk-statement';
+import type { ResultAsync } from 'neverthrow';
+import type { Codec } from 'scale-ts';
+import type { StatementAdapter } from '../adapter/types.js';
+import type { SessionId } from '../model/session.js';
+import type { Callback } from '../types.js';
+import type { TransportError } from './scale/statementData.js';
+export type Transport = ReturnType<typeof createTransport>;
+type RequestMessage<T> = {
+    type: 'request';
+    requestId: string;
+    data: T;
+};
+type ResponseMessage = {
+    type: 'response';
+    requestId: string;
+    code: TransportError;
+};
+type Message<T> = RequestMessage<T> | ResponseMessage;
+type Params = {
+    adapter: StatementAdapter;
+};
+export declare function createTransport({ adapter }: Params): {
+    subscribe<T>({ sessionId, sharedSecret, codec, }: {
+        sessionId: SessionId;
+        sharedSecret: Uint8Array;
+        codec: Codec<T>;
+    }, callback: Callback<Message<T>[]>): VoidFunction;
+    submitRequest(statement: SignedStatement): ResultAsync<void, Error>;
+};
+export {};

package/dist/transport/transport.js

@@ -0,0 +1,56 @@
+import { Result, fromThrowable, ok } from 'neverthrow';
+import { decrypt } from '../crypto.js';
+import { nonNullable, toError } from '../helpers.js';
+import { StatementData } from './scale/statementData.js';
+const decryptResults = fromThrowable(decrypt, toError);
+function mapMessage(statementData) {
+    switch (statementData.tag) {
+        case 'request':
+            return statementData.value.data.map((data, index) => ({
+                type: 'request',
+                requestId: `${statementData.value.requestId}-${index.toString()}`,
+                data,
+            }));
+        case 'response':
+            return [
+                {
+                    type: 'response',
+                    requestId: statementData.value.requestId,
+                    code: statementData.value.responseCode,
+                },
+            ];
+    }
+}
+// function createRequestChannel(session: Uint8Array) {
+//   return khash(session, stringToBytes('request'));
+// }
+//
+// export function createResponseChannel(session: Uint8Array) {
+//   return khash(session, stringToBytes('response'));
+// }
+export function createTransport({ adapter }) {
+    const transport = {
+        subscribe({ sessionId, sharedSecret, codec, }, callback) {
+            const statementDataCodec = StatementData(codec);
+            return adapter.subscribeStatements([sessionId], statements => {
+                Result.combine(statements.map(statement => {
+                    if (!statement.data)
+                        return ok(null);
+                    return decryptResults(sharedSecret, statement.data.asBytes())
+                        .map(statementDataCodec.dec)
+                        .orElse(() => ok(null));
+                }))
+                    .map(messages => messages.filter(nonNullable).flatMap(mapMessage))
+                    .andTee(messages => {
+                    if (messages.length > 0) {
+                        callback(messages);
+                    }
+                });
+            });
+        },
+        submitRequest(statement) {
+            return adapter.submitStatement(statement);
+        },
+    };
+    return transport;
+}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+declare const __brand: unique symbol;
+export type Branded<T, K extends string> = T & {
+    [__brand]: K;
+};
+export type Callback<T, R = unknown> = (value: T) => R;
+export {};

package/dist/types.js

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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@novasamatech/statement-store",
+  "type": "module",
+  "version": "0.5.0-10",
+  "description": "Statement store integration",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+  },
+  "keywords": [
+    "polkadot"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polkadot-api/sdk-statement": "^0.2.0",
+    "@polkadot-api/substrate-bindings": "^0.16.5",
+    "@noble/hashes": "2.0.1",
+    "@noble/ciphers": "2.1.1",
+    "polkadot-api": "^1.23.1",
+    "neverthrow": "^8.2.0",
+    "scale-ts": "^1.6.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}