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

package/dist/adapter/rpc.js

@@ -1,8 +1,9 @@
 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 { errAsync, fromPromise, okAsync } from 'neverthrow';
 import { toError } from '../helpers.js';
+import { AccountFullError, BadProofError, DataTooLargeError, EncodingTooLargeError, NoProofError, PriorityTooLowError, StorageFullError, } from './types.js';
 const POLLING_INTERVAL = 1500;
 function createKey(topics) {
     return topics.map(toHex).sort().join('');
@@ -62,7 +63,39 @@ export function createPapiStatementStoreAdapter(lazyClient) {
             };
         },
         submitStatement(statement) {
-            return fromPromise(sdk.submit(statement), toError);
+            return fromPromise(sdk.submit(statement), toError).andThen(result => {
+                switch (result.status) {
+                    case 'new':
+                    case 'known':
+                        return okAsync(undefined);
+                    case 'rejected':
+                        switch (result.reason) {
+                            case 'dataTooLarge':
+                                return errAsync(new DataTooLargeError(result.submitted_size, result.available_size));
+                            case 'channelPriorityTooLow':
+                                return errAsync(new PriorityTooLowError(result.submitted_priority, result.min_priority));
+                            case 'accountFull':
+                                return errAsync(new AccountFullError());
+                            case 'storeFull':
+                                return errAsync(new StorageFullError());
+                            default:
+                                return errAsync(new Error('Unknown rejection reason'));
+                        }
+                    case 'invalid':
+                        switch (result.reason) {
+                            case 'noProof':
+                                return errAsync(new NoProofError());
+                            case 'badProof':
+                                return errAsync(new BadProofError());
+                            case 'encodingTooLarge':
+                                return errAsync(new EncodingTooLargeError(result.submitted_size, result.max_size));
+                            default:
+                                return errAsync(new Error('Unknown rejection reason: invalid'));
+                        }
+                    default:
+                        return okAsync(undefined);
+                }
+            });
         },
     };
     return transportProvider;

package/dist/adapter/types.d.ts

@@ -3,5 +3,32 @@ 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>;
+    submitStatement(statement: SignedStatement): ResultAsync<void, DataTooLargeError | PriorityTooLowError | AccountFullError | StorageFullError | NoProofError | BadProofError | EncodingTooLargeError | Error>;
 };
+export declare class DataTooLargeError extends Error {
+    readonly submitted: number;
+    readonly available: number;
+    constructor(submitted: number, available: number);
+}
+export declare class PriorityTooLowError extends Error {
+    readonly submitted: number;
+    readonly min: number;
+    constructor(submitted: number, min: number);
+}
+export declare class AccountFullError extends Error {
+    constructor();
+}
+export declare class StorageFullError extends Error {
+    constructor();
+}
+export declare class NoProofError extends Error {
+    constructor();
+}
+export declare class BadProofError extends Error {
+    constructor();
+}
+export declare class EncodingTooLargeError extends Error {
+    readonly submitted: number;
+    readonly max: number;
+    constructor(submitted: number, max: number);
+}

package/dist/adapter/types.js

@@ -1 +1,47 @@
-export {};
+export class DataTooLargeError extends Error {
+    submitted;
+    available;
+    constructor(submitted, available) {
+        super(`Submit failed, data too large: ${submitted} > ${available}`);
+        this.submitted = submitted;
+        this.available = available;
+    }
+}
+export class PriorityTooLowError extends Error {
+    submitted;
+    min;
+    constructor(submitted, min) {
+        super(`Submit failed, priority too low: ${submitted} > ${min}`);
+        this.submitted = submitted;
+        this.min = min;
+    }
+}
+export class AccountFullError extends Error {
+    constructor() {
+        super(`Submit failed, account full`);
+    }
+}
+export class StorageFullError extends Error {
+    constructor() {
+        super(`Submit failed, storage is full`);
+    }
+}
+export class NoProofError extends Error {
+    constructor() {
+        super(`Submit failed, no proof provided`);
+    }
+}
+export class BadProofError extends Error {
+    constructor() {
+        super(`Submit failed, bad proof provided`);
+    }
+}
+export class EncodingTooLargeError extends Error {
+    submitted;
+    max;
+    constructor(submitted, max) {
+        super(`Submit failed, encoding too large`);
+        this.submitted = submitted;
+        this.max = max;
+    }
+}

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.5.0-17",
+  "version": "0.5.0-19",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {
@@ -24,13 +24,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@polkadot-api/sdk-statement": "^0.2.0",
+    "@polkadot-api/sdk-statement": "^0.3.0",
     "@polkadot-api/substrate-bindings": "^0.16.5",
     "@noble/hashes": "2.0.1",
     "@noble/ciphers": "2.1.1",
-    "polkadot-api": "^1.23.1",
+    "polkadot-api": "^1.23.2",
     "neverthrow": "^8.2.0",
-    "scale-ts": "^1.6.1"
+    "scale-ts": "1.6.1"
   },
   "publishConfig": {
     "access": "public"

package/dist/transport/impl.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

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

package/dist/transport/scale/opaque.js

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

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

@@ -1,24 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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;
-}