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

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/priority.d.ts

@@ -0,0 +1 @@
+export declare function nextExpiry(current: bigint): bigint;

package/dist/session/priority.js

@@ -0,0 +1,22 @@
+/**
+ * Statement expiry/priority, u64 = (expiration_epoch << 32) | priority (spec layout).
+ * We pin the high word to 0xFFFFFFFF (max → effectively non-expiring, matching iOS &
+ * Android) and use the low word as a wall-clock-floored monotonic priority, so channel
+ * supersession is driven by the priority regardless of how the store compares the field.
+ * Returns a value strictly greater than `current` (i.e. `max(current + 1, now-priority)`).
+ */
+const NEVER_EXPIRE_HIGH = 0xffffffffn;
+/**
+ * Priority epoch base: seconds at 2025-11-15T00:00:00Z. The low word is a u32 priority counted FROM
+ * this epoch (spec §1), not the raw Unix timestamp. iOS (StatementPriorityFactory.unixOffset) and
+ * Android subtract the same offset; omitting it makes the TS low word ~1.76e9 larger than every
+ * mobile client's, so any cross-client or shared-channel priority comparison would always rank a
+ * TS-written statement above a mobile-written one. Keeping the base aligned removes that landmine.
+ */
+const PRIORITY_EPOCH_OFFSET = 1763164800n;
+export function nextExpiry(current) {
+    const nowSecs = BigInt(Math.floor(Date.now() / 1000));
+    const priority = nowSecs > PRIORITY_EPOCH_OFFSET ? nowSecs - PRIORITY_EPOCH_OFFSET : 0n;
+    const timestampPriority = (NEVER_EXPIRE_HIGH << 32n) | priority;
+    return timestampPriority > current ? timestampPriority : current + 1n;
+}

package/dist/session/priority.spec.d.ts

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

package/dist/session/priority.spec.js

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from 'vitest';
+import { nextExpiry } from './priority.js';
+// Statement expiry/priority: u64 = (expiration_epoch << 32) | priority. The high word is pinned
+// to 0xFFFFFFFF (non-expiring) and the low word is a wall-clock-floored monotonic priority that
+// drives channel supersession. (Spec §1; matches iOS/Android.)
+describe('expiry priority', () => {
+    it('encodes a non-expiring statement (high word pinned to 0xFFFFFFFF)', () => {
+        expect(nextExpiry(0n) >> 32n).toBe(0xffffffffn);
+    });
+    it('carries a wall-clock priority in the low word', () => {
+        const result = nextExpiry(0n);
+        expect(result & 0xffffffffn).toBeGreaterThan(0n);
+    });
+    it('counts the low word from the 2025-11-15 priority epoch (matches iOS/Android)', () => {
+        // iOS StatementPriorityFactory: priority = unixSeconds - 1_763_164_800 (the 2025-11-15 base,
+        // spec §1). The TS SDK must use the SAME base; otherwise its low word is ~1.76e9 larger than
+        // every mobile client's, so any cross-client/shared-channel priority comparison would rank a
+        // TS-written statement above a mobile-written one regardless of real time.
+        const PRIORITY_EPOCH_OFFSET = 1763164800n;
+        vi.useFakeTimers();
+        try {
+            const fixedMs = 1_780_000_000_000;
+            vi.setSystemTime(fixedMs);
+            const expected = BigInt(Math.floor(fixedMs / 1000)) - PRIORITY_EPOCH_OFFSET;
+            expect(nextExpiry(0n) & 0xffffffffn).toBe(expected);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('increments by one when the current value already exceeds the wall-clock priority', () => {
+        const high = (0xffffffffn << 32n) | 0xffffffffn; // max u64
+        expect(nextExpiry(high)).toBe(high + 1n);
+    });
+    it('is strictly monotonic across repeated calls', () => {
+        let expiry = 0n;
+        for (let i = 0; i < 5; i++) {
+            const next = nextExpiry(expiry);
+            expect(next).toBeGreaterThan(expiry);
+            expiry = next;
+        }
+    });
+});

package/dist/session/session.d.ts

@@ -25,5 +25,11 @@ export type SessionParams = {
     sessionKey: Uint8Array;
     maxRequestSize?: number;
 };
-export declare function nextExpiry(current: bigint): bigint;
+/**
+ * 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 createSession({ localAccount, remoteAccount, statementStore, encryption, prover, sessionKey, maxRequestSize, }: SessionParams): Session;