@novasamatech/statement-store 0.5.0-17 → 0.5.0-18

package/dist/model/channel.d.ts

@@ -0,0 +1,6 @@
+import type { Branded } from '../types.js';
+import type { SessionId } from './session.js';
+export type Channel = Branded<Uint8Array, 'Channel'>;
+export declare const ChannelCodec: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare function createRequestChannel(sessionId: SessionId): Channel;
+export declare function createResponseChannel(sessionId: SessionId): Channel;

package/dist/model/channel.js

@@ -0,0 +1,9 @@
+import { Bytes } from 'scale-ts';
+import { khash, stringToBytes } from '../crypto.js';
+export const ChannelCodec = Bytes(32);
+export function createRequestChannel(sessionId) {
+    return khash(sessionId, stringToBytes('request'));
+}
+export function createResponseChannel(sessionId) {
+    return khash(sessionId, stringToBytes('response'));
+}

package/dist/session/mappers.d.ts

@@ -0,0 +1,10 @@
+import type { Statement } from '@polkadot-api/sdk-statement';
+import type { CodecType } from 'scale-ts';
+import type { Channel } from '../model/channel.js';
+import type { SessionId } from '../model/session.js';
+import { DecodingError } from './error.js';
+import type { ResponseCode, StatementData } from './scale/statementData.js';
+import type { SessionEvent } from './types.js';
+export declare function toStatement(sessionId: SessionId, channel: Channel, priority: number, data: Uint8Array): Statement;
+export declare function toEvent(statement: Statement, data: CodecType<typeof StatementData>): SessionEvent;
+export declare function mapResponseCode(responseCode: ResponseCode): import("neverthrow").Ok<void, never> | import("neverthrow").Err<never, DecodingError>;

package/dist/session/mappers.js

@@ -0,0 +1,41 @@
+import { Binary } from '@polkadot-api/substrate-bindings';
+import { err, ok } from 'neverthrow';
+import { DecodingError, DecryptionError, UnknownError } from './error.js';
+export function toStatement(sessionId, channel, priority, data) {
+    return {
+        priority: priority,
+        channel: Binary.fromBytes(channel),
+        topics: [Binary.fromBytes(sessionId)],
+        data: Binary.fromBytes(data),
+    };
+}
+export function toEvent(statement, data) {
+    switch (data.tag) {
+        case 'request':
+            return {
+                type: 'request',
+                requestId: data.value.requestId,
+                priority: statement.priority ?? 0,
+                messages: data.value.data,
+            };
+        case 'response':
+            return {
+                type: 'response',
+                requestId: data.value.requestId,
+                priority: statement.priority ?? 0,
+                responseCode: data.value.responseCode,
+            };
+    }
+}
+export 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());
+    }
+}

package/dist/session/priority.d.ts

@@ -0,0 +1,2 @@
+export declare function getDefaultPriority(): number;
+export declare function getPriority(timestamp: number): number;

package/dist/session/priority.js

@@ -0,0 +1,13 @@
+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();
+}
+export function getDefaultPriority() {
+    return getPriority(now());
+}
+export function getPriority(timestamp) {
+    // (November 15, 2025) in seconds
+    const BASE_PRIORITY = 1763154000;
+    return Math.floor(timestamp / 1000) - BASE_PRIORITY;
+}

package/dist/session/requestId.d.ts

@@ -0,0 +1 @@
+export declare const createRequestId: () => string;

package/dist/session/requestId.js

@@ -0,0 +1,2 @@
+import { nanoid } from 'nanoid';
+export const createRequestId = () => nanoid(16);

package/dist/session/session.js

@@ -1,5 +1,4 @@
 import { Binary } from '@polkadot-api/substrate-bindings';
-import { toHex } from '@polkadot-api/utils';
 import { nanoid } from 'nanoid';
 import { ResultAsync, err, fromPromise, fromThrowable, ok, okAsync } from 'neverthrow';
 import { Bytes } from 'scale-ts';
@@ -12,7 +11,6 @@ import { StatementData } from './scale/statementData.js';
 export function createSession({ localAccount, remoteAccount, statementStore, encryption, prover, }) {
     let subscriptions = [];
     function submit(sessionId, channel, data) {
-        console.log('data', toHex(data));
         return encryption
             .encrypt(data)
             .map(data => ({

package/dist/session/tracker.d.ts

@@ -0,0 +1,6 @@
+import type { SessionEvent } from './types.js';
+export type Tracker = {
+    track(payload: SessionEvent): void;
+    isTracked(payload: SessionEvent): boolean;
+};
+export declare const createTracker: () => Tracker;

package/dist/session/tracker.js

@@ -0,0 +1,26 @@
+import { toHex } from '@polkadot-api/utils';
+export const createTracker = () => {
+    const tracked = new Set();
+    function toHash(payload) {
+        switch (payload.type) {
+            case 'request': {
+                let hash = `${payload.requestId}_${payload.priority}_`;
+                for (const message of payload.messages) {
+                    hash += toHex(message);
+                }
+                return hash;
+            }
+            case 'response': {
+                return `${payload.requestId}_${payload.priority}_${payload.responseCode}`;
+            }
+        }
+    }
+    return {
+        track(payload) {
+            tracked.add(toHash(payload));
+        },
+        isTracked(payload) {
+            return tracked.has(toHash(payload));
+        },
+    };
+};

package/dist/session/transport.d.ts

@@ -0,0 +1,20 @@
+import { ResultAsync } from 'neverthrow';
+import type { StatementStoreAdapter } from '../adapter/types.js';
+import type { SessionId } from '../model/session.js';
+import type { Callback } from '../types.js';
+import type { Encryption } from './encyption.js';
+import type { StatementProver } from './statementProver.js';
+import type { SessionEvent, SessionRequestEvent, SessionResponseEvent, Subscriber } from './types.js';
+export type Transport = {
+    submitRequest(sessionId: SessionId, request: SessionRequestEvent): ResultAsync<void, Error>;
+    submitResponse(sessionId: SessionId, response: SessionResponseEvent): ResultAsync<void, Error>;
+    query(sessionId: SessionId): ResultAsync<SessionEvent[], Error>;
+    subscribe(sessionId: SessionId, callback: Callback<SessionEvent>): Subscriber;
+};
+type Params = {
+    statementStore: StatementStoreAdapter;
+    encryption: Encryption;
+    prover: StatementProver;
+};
+export declare function createTransport({ encryption, prover, statementStore }: Params): Transport;
+export {};

package/dist/session/transport.js

@@ -0,0 +1,76 @@
+import { statementCodec } from '@polkadot-api/sdk-statement';
+import { ResultAsync, err, errAsync, fromThrowable, ok } from 'neverthrow';
+import { toError } from '../helpers.js';
+import { createRequestChannel, createResponseChannel } from '../model/channel.js';
+import { DecodingError, DecryptionError, MessageTooLarge } from './error.js';
+import { toEvent, toStatement } from './mappers.js';
+import { StatementData } from './scale/statementData.js';
+import { createTracker } from './tracker.js';
+export function createTransport({ encryption, prover, statementStore }) {
+    const tracker = createTracker();
+    const encode = fromThrowable(StatementData.enc, toError);
+    const decode = fromThrowable(StatementData.dec, () => new DecodingError());
+    function validateStatementSize(statement) {
+        const MAX_REQUEST_SIZE = 1024;
+        const size = statementCodec.enc(statement).length;
+        return statementCodec.enc(statement).length > MAX_REQUEST_SIZE
+            ? err(new MessageTooLarge(size, MAX_REQUEST_SIZE))
+            : ok();
+    }
+    function processStatement(statement) {
+        if (!statement.data)
+            return errAsync(new Error('Statement.data is not presented'));
+        const data = statement.data.asBytes();
+        return prover
+            .verifyMessageProof(statement)
+            .andThen(() => encryption.decrypt(data))
+            .andThen(decode)
+            .map(statementData => toEvent(statement, statementData));
+    }
+    function submit(sessionId, channel, priority, data) {
+        return encryption
+            .encrypt(data)
+            .map(data => toStatement(sessionId, channel, priority, data))
+            .asyncAndThen(prover.generateMessageProof)
+            .andThrough(validateStatementSize)
+            .andThen(statementStore.submitStatement);
+    }
+    return {
+        submitRequest(sessionId, request) {
+            const rawData = encode({
+                tag: 'request',
+                value: { requestId: request.requestId, data: request.messages },
+            });
+            return rawData.asyncAndThen(data => submit(sessionId, createRequestChannel(sessionId), request.priority, data));
+        },
+        submitResponse(sessionId, response) {
+            const rawData = encode({
+                tag: 'response',
+                value: { requestId: response.requestId, responseCode: response.responseCode },
+            });
+            return rawData.asyncAndThen(data => submit(sessionId, createResponseChannel(sessionId), response.priority, data));
+        },
+        query(sessionId) {
+            return statementStore
+                .queryStatements([sessionId])
+                .andThen(statements => ResultAsync.combine(statements.map(processStatement)));
+        },
+        subscribe(sessionId, callback) {
+            const unsubscribe = statementStore.subscribeStatements([sessionId], statements => {
+                statements.map(processStatement).forEach(result => {
+                    result.match(event => {
+                        if (tracker.isTracked(event))
+                            return;
+                        tracker.track(event);
+                        callback(event);
+                    }, e => {
+                        if (DecryptionError.isDecryptionError(e) || DecodingError.isDecodingError(e)) {
+                            console.error(e);
+                        }
+                    });
+                });
+            });
+            return { unsubscribe };
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.5.0-17",
+  "version": "0.5.0-18",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {