@novasamatech/statement-store 0.5.0-11 → 0.5.0-13

package/dist/session/messageMapper.d.ts

@@ -1,4 +1,4 @@
-import type { CodecType } from 'scale-ts';
+import type { Codec, 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>[];
+export declare function toMessage<T>(statementData: CodecType<typeof StatementData>, codec: Codec<T>): Message<T>[];

package/dist/session/messageMapper.js

@@ -1,11 +1,11 @@
-export function toMessage(statementData) {
+export function toMessage(statementData, codec) {
     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,
+                payload: codec.dec(payload),
             }));
         case 'response':
             return [

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

@@ -1,19 +1,18 @@
-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<{
+export declare const ResponseCodeCodec: import("scale-ts").Codec<ResponseCode>;
+export declare const Request: import("scale-ts").Codec<{
     requestId: string;
-    data: T[];
+    data: Uint8Array<ArrayBufferLike>[];
 }>;
-export declare const Response: Codec<{
+export declare const Response: import("scale-ts").Codec<{
     requestId: string;
     responseCode: ResponseCode;
 }>;
-export declare const StatementData: <T>(data: Codec<T>) => Codec<{
+export declare const StatementData: import("scale-ts").Codec<{
     tag: "request";
     value: {
         requestId: string;
-        data: T[];
+        data: Uint8Array<ArrayBufferLike>[];
     };
 } | {
     tag: "response";

package/dist/session/scale/statementData.js

@@ -1,4 +1,4 @@
-import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
+import { Bytes, Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
 export const ResponseCodeCodec = enhanceCodec(u8, error => {
     switch (error) {
         case 'success':
@@ -22,19 +22,15 @@ export const ResponseCodeCodec = enhanceCodec(u8, error => {
             return 'unknown';
     }
 });
-export const Request = (data) => {
-    return Struct({
-        requestId: str,
-        data: Vector(data),
-    });
-};
+export const Request = Struct({
+    requestId: str,
+    data: Vector(Bytes()),
+});
 export const Response = Struct({
     requestId: str,
     responseCode: ResponseCodeCodec,
 });
-export const StatementData = (data) => {
-    return Enum({
-        request: Request(data),
-        response: Response,
-    });
-};
+export const StatementData = Enum({
+    request: Request,
+    response: Response,
+});

package/dist/session/session.js

@@ -1,4 +1,5 @@
 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';
@@ -11,6 +12,7 @@ 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 => ({
@@ -31,11 +33,11 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         submitRequestMessage(codec, message) {
             const requestId = nanoid();
             const sessionId = createSessionId(remoteAccount.publicKey, localAccount, remoteAccount);
-            const statementDataCodec = StatementData(codec);
-            const encode = fromThrowable(statementDataCodec.enc, toError);
+            const encode = fromThrowable(StatementData.enc, toError);
+            const encoded = codec.enc(message);
             const rawData = encode({
                 tag: 'request',
-                value: { requestId, data: [message] },
+                value: { requestId, data: [encoded] },
             });
             return rawData
                 .asyncAndThen(data => submit(sessionId, createRequestChannel(sessionId), data))
@@ -43,8 +45,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         },
         submitResponseMessage(requestId, responseCode) {
             const sessionId = createSessionId(remoteAccount.publicKey, localAccount, remoteAccount);
-            const statementDataCodec = StatementData(Bytes());
-            const encode = fromThrowable(statementDataCodec.enc, toError);
+            const encode = fromThrowable(StatementData.enc, toError);
             const rawData = encode({
                 tag: 'response',
                 value: { requestId, responseCode },
@@ -83,7 +84,6 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             return fromPromise(promise, toError);
         },
         subscribe(codec, callback) {
-            const statementDataCodec = StatementData(codec);
             const sessionId = createSessionId(remoteAccount.publicKey, remoteAccount, localAccount);
             function processStatement(statement) {
                 if (!statement.data)
@@ -93,12 +93,12 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
                     .verifyMessageProof(statement)
                     .andThen(verified => (verified ? ok() : err(new Error('Statement proof is not valid'))))
                     .andThen(() => encryption.decrypt(data))
-                    .map(statementDataCodec.dec)
+                    .map(StatementData.dec)
                     .orElse(() => ok(null));
             }
             return statementStore.subscribeStatements([sessionId], statements => {
                 ResultAsync.combine(statements.map(processStatement))
-                    .map(messages => messages.filter(nonNullable).flatMap(toMessage))
+                    .map(messages => messages.filter(nonNullable).flatMap(x => toMessage(x, codec)))
                     .andTee(messages => {
                     if (messages.length > 0) {
                         callback(messages);

package/package.json

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