@novasamatech/statement-store 0.6.4 → 0.6.5

package/dist/adapter/lazyClient.d.ts

@@ -1,7 +1,10 @@
+import type { RequestFn, SubscribeFn } from '@novasamatech/sdk-statement';
 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;
+    getRequestFn(): RequestFn;
+    getSubscribeFn(): SubscribeFn;
     disconnect(): void;
 };

package/dist/adapter/lazyClient.js

@@ -1,16 +1,47 @@
-import { createClient } from 'polkadot-api';
+import { createClient as createSubstrateClient } from '@polkadot-api/substrate-client';
+import { createClient as createPolkadotClient } from 'polkadot-api';
 export const createLazyClient = (provider) => {
-    let client = null;
+    let polkadotClient = null;
+    let substrateClient = null;
+    function getSubstrateClient() {
+        if (!substrateClient) {
+            substrateClient = createSubstrateClient(provider);
+        }
+        return substrateClient;
+    }
     return {
         getClient() {
-            if (!client) {
-                client = createClient(provider);
+            if (!polkadotClient) {
+                polkadotClient = createPolkadotClient(provider);
             }
-            return client;
+            return polkadotClient;
+        },
+        getRequestFn() {
+            const c = getSubstrateClient();
+            return (method, params) => new Promise((resolve, reject) => {
+                c._request(method, params, {
+                    onSuccess: result => resolve(result),
+                    onError: e => reject(e),
+                });
+            });
+        },
+        getSubscribeFn() {
+            const c = getSubstrateClient();
+            return (method, params, onMessage, onError) => {
+                return c._request(method, params, {
+                    onSuccess: (subscriptionId, followSubscription) => {
+                        followSubscription(subscriptionId, { next: onMessage, error: onError });
+                    },
+                    onError,
+                });
+            };
         },
         disconnect() {
-            if (client) {
-                client.destroy();
+            if (polkadotClient) {
+                polkadotClient.destroy();
+            }
+            if (substrateClient) {
+                substrateClient.destroy();
             }
         },
     };

package/dist/adapter/rpc.js

@@ -1,66 +1,84 @@
-import { createStatementSdk } from '@polkadot-api/sdk-statement';
-import { Binary } from '@polkadot-api/substrate-bindings';
+import { createStatementSdk } from '@novasamatech/sdk-statement';
 import { toHex } from '@polkadot-api/utils';
 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;
+import { AccountFullError, AlreadyExpiredError, BadProofError, DataTooLargeError, EncodingTooLargeError, ExpiryTooLowError, InternalStoreError, KnownExpiredError, NoAllowanceError, NoProofError, StorageFullError, } from './types.js';
 function createKey(topics) {
     return topics.map(toHex).sort().join('');
 }
+function toTopicFilter(topics) {
+    if (topics.length === 0)
+        return 'any';
+    return { matchAll: topics.map(t => toHex(t)) };
+}
 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);
+    const sdk = createStatementSdk(lazyClient.getRequestFn(), lazyClient.getSubscribeFn());
+    const activeSubscriptions = new Map();
+    const callbacks = new Map();
+    function addCallback(key, callback) {
+        let list = callbacks.get(key);
+        if (!list) {
+            list = [];
+            callbacks.set(key, list);
         }
-        subs.push(subscription);
-        return subs;
+        list.push(callback);
+        return list;
     }
-    function removeSubscription(key, subscription) {
-        let subs = subscriptions.get(key);
-        if (!subs) {
+    function removeCallback(key, callback) {
+        let list = callbacks.get(key);
+        if (!list)
             return [];
+        list = list.filter(x => x !== callback);
+        if (list.length === 0) {
+            callbacks.delete(key);
+        }
+        else {
+            callbacks.set(key, list);
         }
-        subs = subs.filter(x => x !== subscription);
-        return subs;
+        return list;
     }
-    const transportProvider = {
-        queryStatements(topics, destination) {
-            return fromPromise(sdk.getStatements({
-                // @ts-expect-error unmatched types of @polkadot-api/sdk-statement and @polkadot-api/substrate-bindings
-                topics: topics.map(t => Binary.fromBytes(t)),
-                // @ts-expect-error unmatched types of @polkadot-api/sdk-statement and @polkadot-api/substrate-bindings
-                dest: destination ? Binary.fromBytes(destination) : null,
-            }), toError);
+    const adapter = {
+        queryStatements(topics) {
+            const filter = toTopicFilter(topics);
+            return fromPromise(sdk.getStatements(filter), 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) {
+            const list = addCallback(key, callback);
+            if (list.length === 1) {
+                const filter = toTopicFilter(topics);
+                let batch = [];
+                let flushScheduled = false;
+                const flush = () => {
+                    flushScheduled = false;
+                    if (batch.length === 0)
+                        return;
+                    const statements = batch;
+                    batch = [];
+                    const currentCallbacks = callbacks.get(key);
+                    if (currentCallbacks) {
+                        for (const fn of currentCallbacks) {
                             fn(statements);
                         }
                     }
+                };
+                const unsub = sdk.subscribeStatements(filter, statement => {
+                    batch.push(statement);
+                    if (!flushScheduled) {
+                        flushScheduled = true;
+                        setTimeout(flush, 0);
+                    }
+                }, error => {
+                    console.error('Statement subscription error:', error);
                 });
-                pollings.set(key, unsub);
+                activeSubscriptions.set(key, unsub);
             }
             return () => {
-                const callbacks = removeSubscription(key, callback);
-                if (callbacks.length === 0) {
-                    const stopPolling = pollings.get(key);
-                    stopPolling?.();
-                    pollings.delete(key);
+                const remaining = removeCallback(key, callback);
+                if (remaining.length === 0) {
+                    const unsub = activeSubscriptions.get(key);
+                    unsub?.();
+                    activeSubscriptions.delete(key);
                 }
             };
         },
@@ -70,16 +88,22 @@ export function createPapiStatementStoreAdapter(lazyClient) {
                     case 'new':
                     case 'known':
                         return okAsync(undefined);
+                    case 'knownExpired':
+                        return errAsync(new KnownExpiredError());
+                    case 'internalError':
+                        return errAsync(new InternalStoreError(result.error));
                     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));
+                                return errAsync(new ExpiryTooLowError(result.submitted_expiry, result.min_expiry));
                             case 'accountFull':
-                                return errAsync(new AccountFullError());
+                                return errAsync(new AccountFullError(result.submitted_expiry, result.min_expiry));
                             case 'storeFull':
                                 return errAsync(new StorageFullError());
+                            case 'noAllowance':
+                                return errAsync(new NoAllowanceError());
                             default:
                                 return errAsync(new Error('Unknown rejection reason'));
                         }
@@ -91,6 +115,8 @@ export function createPapiStatementStoreAdapter(lazyClient) {
                                 return errAsync(new BadProofError());
                             case 'encodingTooLarge':
                                 return errAsync(new EncodingTooLargeError(result.submitted_size, result.max_size));
+                            case 'alreadyExpired':
+                                return errAsync(new AlreadyExpiredError());
                             default:
                                 return errAsync(new Error('Unknown rejection reason: invalid'));
                         }
@@ -100,29 +126,5 @@ export function createPapiStatementStoreAdapter(lazyClient) {
             });
         },
     };
-    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);
-        }
-    };
+    return adapter;
 }

package/dist/adapter/types.d.ts

@@ -1,22 +1,24 @@
-import type { SignedStatement, Statement } from '@polkadot-api/sdk-statement';
+import type { SignedStatement, Statement } from '@novasamatech/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, DataTooLargeError | PriorityTooLowError | AccountFullError | StorageFullError | NoProofError | BadProofError | EncodingTooLargeError | Error>;
+    submitStatement(statement: SignedStatement): ResultAsync<void, DataTooLargeError | ExpiryTooLowError | AccountFullError | StorageFullError | NoProofError | BadProofError | EncodingTooLargeError | NoAllowanceError | AlreadyExpiredError | KnownExpiredError | InternalStoreError | 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 ExpiryTooLowError extends Error {
+    readonly submitted: bigint;
+    readonly min: bigint;
+    constructor(submitted: bigint, min: bigint);
 }
 export declare class AccountFullError extends Error {
-    constructor();
+    readonly submitted: bigint;
+    readonly min: bigint;
+    constructor(submitted: bigint, min: bigint);
 }
 export declare class StorageFullError extends Error {
     constructor();
@@ -32,3 +34,15 @@ export declare class EncodingTooLargeError extends Error {
     readonly max: number;
     constructor(submitted: number, max: number);
 }
+export declare class NoAllowanceError extends Error {
+    constructor();
+}
+export declare class AlreadyExpiredError extends Error {
+    constructor();
+}
+export declare class KnownExpiredError extends Error {
+    constructor();
+}
+export declare class InternalStoreError extends Error {
+    constructor(detail: string);
+}

package/dist/adapter/types.js

@@ -7,18 +7,22 @@ export class DataTooLargeError extends Error {
         this.available = available;
     }
 }
-export class PriorityTooLowError extends Error {
+export class ExpiryTooLowError extends Error {
     submitted;
     min;
     constructor(submitted, min) {
-        super(`Submit failed, priority too low: ${submitted} > ${min}`);
+        super(`Submit failed, expiry too low: ${submitted} < ${min}`);
         this.submitted = submitted;
         this.min = min;
     }
 }
 export class AccountFullError extends Error {
-    constructor() {
-        super(`Submit failed, account full`);
+    submitted;
+    min;
+    constructor(submitted, min) {
+        super(`Submit failed, account full: submitted expiry ${submitted} < min ${min}`);
+        this.submitted = submitted;
+        this.min = min;
     }
 }
 export class StorageFullError extends Error {
@@ -45,3 +49,23 @@ export class EncodingTooLargeError extends Error {
         this.max = max;
     }
 }
+export class NoAllowanceError extends Error {
+    constructor() {
+        super(`Submit failed, no allowance set for account`);
+    }
+}
+export class AlreadyExpiredError extends Error {
+    constructor() {
+        super(`Submit failed, statement already expired`);
+    }
+}
+export class KnownExpiredError extends Error {
+    constructor() {
+        super(`Submit failed, statement was known but has expired`);
+    }
+}
+export class InternalStoreError extends Error {
+    constructor(detail) {
+        super(`Submit failed, internal store error: ${detail}`);
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { Statement } from '@polkadot-api/sdk-statement';
+export type { Statement } from '@novasamatech/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';
@@ -14,5 +14,6 @@ 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 { AccountFullError, AlreadyExpiredError, BadProofError, DataTooLargeError, EncodingTooLargeError, ExpiryTooLowError, InternalStoreError, KnownExpiredError, NoAllowanceError, NoProofError, StorageFullError, } from './adapter/types.js';
 export { createPapiStatementStoreAdapter } from './adapter/rpc.js';
 export { createSr25519Derivation, createSr25519Secret, deriveSr25519PublicKey, khash, signWithSr25519Secret, verifySr25519Signature, } from './crypto.js';

package/dist/index.js

@@ -6,5 +6,6 @@ export { createSr25519Prover } from './session/statementProver.js';
 export { createEncryption } from './session/encyption.js';
 export { DecodingError, DecryptionError, UnknownError } from './session/error.js';
 export { createLazyClient } from './adapter/lazyClient.js';
+export { AccountFullError, AlreadyExpiredError, BadProofError, DataTooLargeError, EncodingTooLargeError, ExpiryTooLowError, InternalStoreError, KnownExpiredError, NoAllowanceError, NoProofError, StorageFullError, } from './adapter/types.js';
 export { createPapiStatementStoreAdapter } from './adapter/rpc.js';
 export { createSr25519Derivation, createSr25519Secret, deriveSr25519PublicKey, khash, signWithSr25519Secret, verifySr25519Signature, } from './crypto.js';

package/dist/session/session.js

@@ -1,4 +1,5 @@
-import { Binary } from '@polkadot-api/substrate-bindings';
+import { createExpiryFromDuration } from '@novasamatech/sdk-statement';
+import { toHex } from '@polkadot-api/utils';
 import { nanoid } from 'nanoid';
 import { ResultAsync, err, fromPromise, fromThrowable, ok, okAsync } from 'neverthrow';
 import { Bytes } from 'scale-ts';
@@ -14,13 +15,10 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
         return encryption
             .encrypt(data)
             .map(data => ({
-            priority: getPriority(now()),
-            // @ts-expect-error unmatched types of @polkadot-api/sdk-statement and @polkadot-api/substrate-bindings
-            channel: Binary.fromBytes(channel),
-            // @ts-expect-error unmatched types of @polkadot-api/sdk-statement and @polkadot-api/substrate-bindings
-            topics: [Binary.fromBytes(sessionId)],
-            // @ts-expect-error unmatched types of @polkadot-api/sdk-statement and @polkadot-api/substrate-bindings
-            data: Binary.fromBytes(data),
+            expiry: getExpiry(),
+            channel: toHex(channel),
+            topics: [toHex(sessionId)],
+            data,
         }))
             .asyncAndThen(prover.generateMessageProof)
             .andThen(statementStore.submitStatement);
@@ -90,7 +88,7 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             function processStatement(statement) {
                 if (!statement.data)
                     return okAsync(null);
-                const data = statement.data.asBytes();
+                const data = statement.data;
                 return prover
                     .verifyMessageProof(statement)
                     .andThen(verified => (verified ? ok() : err(new Error('Statement proof is not valid'))))
@@ -135,14 +133,9 @@ function mapResponseCode(responseCode) {
             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);
+const DEFAULT_EXPIRY_DURATION_SECS = 7 * 24 * 60 * 60; // 7 days
+function getExpiry() {
+    return createExpiryFromDuration(DEFAULT_EXPIRY_DURATION_SECS);
 }
 function createRequestChannel(sessionId) {
     return khash(sessionId, stringToBytes('request'));

package/dist/session/statementProver.d.ts

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

package/dist/session/statementProver.js

@@ -1,6 +1,7 @@
-import { getStatementSigner, statementCodec } from '@polkadot-api/sdk-statement';
+import { getStatementSigner, statementCodec } from '@novasamatech/sdk-statement';
+import { compact } from '@polkadot-api/substrate-bindings';
+import { fromHex } from '@polkadot-api/utils';
 import { errAsync, fromPromise, fromThrowable, okAsync } from 'neverthrow';
-import { compact } from 'scale-ts';
 import { deriveSr25519PublicKey, signWithSr25519Secret, verifySr25519Signature } from '../crypto.js';
 import { toError } from '../helpers.js';
 export function createSr25519Prover(secret) {
@@ -20,7 +21,7 @@ export function createSr25519Prover(secret) {
             const compactLen = compact.enc(compact.dec(encoded)).length;
             switch (proof.type) {
                 case 'sr25519':
-                    return verify(encoded.slice(compactLen), proof.value.signature.asBytes(), proof.value.signer.asBytes()).asyncAndThen(x => okAsync(x));
+                    return verify(encoded.slice(compactLen), fromHex(proof.value.signature), fromHex(proof.value.signer)).asyncAndThen(x => okAsync(x));
                 default:
                     return errAsync(new Error(`Proof type ${proof.type} is not supported.`));
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {
@@ -24,8 +24,9 @@
     "README.md"
   ],
   "dependencies": {
-    "@polkadot-api/sdk-statement": "^0.3.0",
+    "@novasamatech/sdk-statement": "^0.5.0",
     "@polkadot-api/substrate-bindings": "^0.17.0",
+    "@polkadot-api/substrate-client": "^0.5.0",
     "@polkadot-api/utils": "0.2.0",
     "@polkadot-labs/hdkd-helpers": "0.0.27",
     "@noble/hashes": "2.0.1",