@novasamatech/statement-store 0.8.7-0 → 0.8.7-1

package/dist/adapter/inMemory.d.ts

@@ -0,0 +1,32 @@
+import type { Statement } from '@novasamatech/sdk-statement';
+import type { StatementStoreAdapter } from './types.js';
+/**
+ * An in-memory {@link StatementStoreAdapter} that replicates the real statement
+ * store's observable contract, for tests and local development.
+ *
+ * Fidelity rules (mirroring the on-chain store):
+ *   - One statement per channel. A same-channel write is accepted only with a
+ *     STRICTLY HIGHER expiry; an equal-or-lower expiry is rejected with
+ *     {@link ExpiryTooLowError} (the store's `channelPriorityTooLow`). A
+ *     byte-identical resubmission is "known" → ok, with no duplicate.
+ *   - `queryStatements` returns the current per-channel statements matching the
+ *     topic filter (superseded statements are evicted).
+ *   - `subscribeStatements` streams statements submitted AFTER subscription that
+ *     match the filter — the initial snapshot is obtained via `queryStatements`,
+ *     exactly as a consumer does. Delivery is synchronous on submit.
+ *
+ * Two mirrored sessions can share ONE store to exercise full bidirectional
+ * host ↔ peer flows: a submit by one is observed by the other.
+ *
+ * It IS a {@link StatementStoreAdapter} (pass it straight to `createSession`)
+ * with extra inspection helpers attached.
+ */
+export type InMemoryStatementStore = StatementStoreAdapter & {
+    /** Statements currently retained — one per channel (highest expiry wins). */
+    currentStatements(): Statement[];
+    /** Every accepted submission, in order (excludes rejected writes and known no-ops). */
+    acceptedStatements(): Statement[];
+    /** Number of live subscriptions (increases on subscribe, decreases on unsubscribe). */
+    activeSubscriptions(): number;
+};
+export declare function createInMemoryStatementStore(): InMemoryStatementStore;

package/dist/adapter/inMemory.js

@@ -0,0 +1,56 @@
+import { errAsync, okAsync } from 'neverthrow';
+import { toHex } from 'polkadot-api/utils';
+import { ExpiryTooLowError } from './types.js';
+export function createInMemoryStatementStore() {
+    const channels = new Map();
+    const accepted = [];
+    const subscribers = new Set();
+    const topicsOf = (s) => s.topics ?? [];
+    const matches = (filter, s) => {
+        const topics = topicsOf(s);
+        return 'matchAll' in filter
+            ? filter.matchAll.every(t => topics.includes(toHex(t)))
+            : filter.matchAny.some(t => topics.includes(toHex(t)));
+    };
+    // Statement identity for the "known" (dedup) check.
+    const keyOf = (s) => `${s.channel ?? ''}|${(s.expiry ?? 0n).toString()}|${topicsOf(s).join(',')}|${s.data ? toHex(s.data) : ''}`;
+    const adapter = {
+        queryStatements(filter) {
+            return okAsync([...channels.values()].filter(s => matches(filter, s)));
+        },
+        subscribeStatements(filter, callback) {
+            const sub = { filter, callback };
+            subscribers.add(sub);
+            return () => {
+                subscribers.delete(sub);
+            };
+        },
+        submitStatement(statement) {
+            const channel = statement.channel ?? '';
+            const existing = channels.get(channel);
+            const submittedExpiry = statement.expiry ?? 0n;
+            if (existing) {
+                if (keyOf(existing) === keyOf(statement))
+                    return okAsync(undefined); // known
+                const existingExpiry = existing.expiry ?? 0n;
+                if (submittedExpiry <= existingExpiry) {
+                    return errAsync(new ExpiryTooLowError(submittedExpiry, existingExpiry));
+                }
+            }
+            channels.set(channel, statement);
+            accepted.push(statement);
+            for (const sub of subscribers) {
+                if (matches(sub.filter, statement)) {
+                    sub.callback({ statements: [statement], isComplete: true });
+                }
+            }
+            return okAsync(undefined);
+        },
+    };
+    return {
+        ...adapter,
+        currentStatements: () => [...channels.values()],
+        acceptedStatements: () => [...accepted],
+        activeSubscriptions: () => subscribers.size,
+    };
+}

package/dist/index.d.ts

@@ -5,14 +5,17 @@ export type { AccountId, LocalSessionAccount, RemoteSessionAccount, SessionAccou
 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 { ResponseStatus } from './session/scale/statementData.js';
 export { Request, Response, ResponseCode, StatementData } from './session/scale/statementData.js';
 export type { StatementProver } from './session/statementProver.js';
-export { createSr25519Prover } from './session/statementProver.js';
+export { createSlotAccountProver, createSr25519Prover } 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 { InMemoryStatementStore } from './adapter/inMemory.js';
+export { createInMemoryStatementStore } from './adapter/inMemory.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';

package/dist/index.js

@@ -2,10 +2,11 @@ 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 { Request, Response, ResponseCode, StatementData } from './session/scale/statementData.js';
-export { createSr25519Prover } from './session/statementProver.js';
+export { createSlotAccountProver, 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 { createInMemoryStatementStore } from './adapter/inMemory.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, deriveSlotAccountPublicKey, deriveSr25519PublicKey, ensureSubstrateSlotSr25519Ready, ensureSubstrateSr25519Ready, khash, signSlotAccountSecret, signWithSr25519Secret, verifySlotAccountSignature, verifySr25519Signature, } from './crypto.js';

package/dist/session/session.d.ts

@@ -25,5 +25,12 @@ export type SessionParams = {
     sessionKey: Uint8Array;
     maxRequestSize?: number;
 };
+/**
+ * Fixed per-statement wire overhead reserved before sizing the request payload:
+ * topic (32) + channel (32) + expiry (8) + proof signature (64) + signer (32).
+ * Mirrors the Android/iOS sessions, which size message batches against
+ * `maxStatementSize - overhead` rather than the raw statement limit.
+ */
+export declare const STATEMENT_OVERHEAD: number;
 export declare function nextExpiry(current: bigint): bigint;
 export declare function createSession({ localAccount, remoteAccount, statementStore, encryption, prover, sessionKey, maxRequestSize, }: SessionParams): Session;