@novasamatech/statement-store 0.8.11 → 0.9.0

package/dist/crypto.js

@@ -1,8 +1,9 @@
 import { blake2b } from '@noble/hashes/blake2.js';
+import { Bytes } from '@novasamatech/scale';
 import { deriveSlotAccountPublicKey as deriveSlotPublicKey, ensureSubstrateSlotSr25519Ready, signSlotAccountSecret as signSlotSecret, verifySlotAccountSignature as verifySlotSignature, } from '@novasamatech/substrate-slot-sr25519-wasm';
 import { entropyToMiniSecret } from '@polkadot-labs/hdkd-helpers';
 import { HDKD as sr25519HDKD, secretFromSeed as sr25519SecretFromSeed } from '@scure/sr25519';
-import { Bytes, str, u64 } from 'scale-ts';
+import { str, u64 } from 'scale-ts';
 import { substrateSr25519PublicKey, substrateSr25519Sign, substrateSr25519Verify } from './substrateSr25519.js';
 export { ensureSubstrateSlotSr25519Ready };
 export { ensureSubstrateSr25519Ready } from './substrateSr25519.js';

package/dist/model/session.d.ts

@@ -1,5 +1,5 @@
 import type { Branded } from '../types.js';
 import type { SessionAccount } from './sessionAccount.js';
 export type SessionId = Branded<Uint8Array, 'SessionId'>;
-export declare const SessionIdCodec: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const SessionIdCodec: import("@novasamatech/scale").BytesCodec<number>;
 export declare function createSessionId(sharedSecret: Uint8Array, accountA: SessionAccount, accountB: SessionAccount): SessionId;

package/dist/model/session.js

@@ -1,5 +1,5 @@
+import { Bytes } from '@novasamatech/scale';
 import { mergeUint8 } from 'polkadot-api/utils';
-import { Bytes } from 'scale-ts';
 import { khash, stringToBytes } from '../crypto.js';
 export const SessionIdCodec = Bytes(32);
 export function createSessionId(sharedSecret, accountA, accountB) {

package/dist/model/sessionAccount.js

@@ -1,4 +1,5 @@
-import { Bytes, Option, Struct, str } from 'scale-ts';
+import { Bytes } from '@novasamatech/scale';
+import { Option, Struct, str } from 'scale-ts';
 import { BrandedBytesCodec } from '../crypto.js';
 export const AccountIdCodec = BrandedBytesCodec(32);
 export function createAccountId(value) {

package/dist/session/encyption.js

@@ -1,24 +1,24 @@
-import { gcm } from '@noble/ciphers/aes.js';
+import { chacha20poly1305 } from '@noble/ciphers/chacha.js';
 import { hkdf } from '@noble/hashes/hkdf.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { randomBytes } from '@noble/hashes/utils.js';
 import { Result, fromThrowable } from 'neverthrow';
 import { mergeUint8 } from 'polkadot-api/utils';
 export function createEncryption(sharedSecret) {
-    const salt = new Uint8Array(); // secure enough since P256 random keys provide enough entropy
+    const salt = new Uint8Array(); // secure enough since the X25519 shared secret provides full entropy
     const info = new Uint8Array(); // no need to introduce any context
-    const aesKey = hkdf(sha256, sharedSecret, salt, info, 32);
+    const aeadKey = hkdf(sha256, sharedSecret, salt, info, 32);
     return {
         encrypt: fromThrowable(cipherText => {
             const nonce = randomBytes(12);
-            const aes = gcm(aesKey, nonce);
-            return mergeUint8([nonce, aes.encrypt(cipherText)]);
+            const aead = chacha20poly1305(aeadKey, nonce);
+            return mergeUint8([nonce, aead.encrypt(cipherText)]);
         }),
         decrypt: fromThrowable(encryptedMessage => {
             const nonce = encryptedMessage.slice(0, 12);
             const cipherText = encryptedMessage.slice(12);
-            const aes = gcm(aesKey, nonce);
-            return aes.decrypt(cipherText);
+            const aead = chacha20poly1305(aeadKey, nonce);
+            return aead.decrypt(cipherText);
         }),
     };
 }

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

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

package/dist/session/encyption.spec.js

@@ -0,0 +1,43 @@
+import { chacha20poly1305 } from '@noble/ciphers/chacha.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { randomBytes } from '@noble/hashes/utils.js';
+import { describe, expect, it } from 'vitest';
+import { createEncryption } from './encyption.js';
+const deriveAeadKey = (sharedSecret) => hkdf(sha256, sharedSecret, new Uint8Array(), new Uint8Array(), 32);
+describe('statement-store message encryption', () => {
+    it('round-trips a message', () => {
+        const sharedSecret = randomBytes(32);
+        const encryption = createEncryption(sharedSecret);
+        const plaintext = new TextEncoder().encode('hello statement');
+        const encrypted = encryption.encrypt(plaintext)._unsafeUnwrap();
+        const decrypted = encryption.decrypt(encrypted)._unsafeUnwrap();
+        expect(decrypted).toEqual(plaintext);
+    });
+    it('produces ChaCha20-Poly1305 ciphertext decryptable by an external ChaCha20-Poly1305 reader', () => {
+        const sharedSecret = randomBytes(32);
+        const plaintext = new TextEncoder().encode('cross-decrypt me');
+        const encrypted = createEncryption(sharedSecret).encrypt(plaintext)._unsafeUnwrap();
+        const nonce = encrypted.slice(0, 12);
+        const body = encrypted.slice(12);
+        const aeadKey = deriveAeadKey(sharedSecret);
+        const decrypted = chacha20poly1305(aeadKey, nonce).decrypt(body);
+        expect(decrypted).toEqual(plaintext);
+    });
+    it('decrypts a ChaCha20-Poly1305 ciphertext built externally (nonce || ct || tag framing)', () => {
+        const sharedSecret = randomBytes(32);
+        const plaintext = new TextEncoder().encode('external chacha');
+        const aeadKey = deriveAeadKey(sharedSecret);
+        const nonce = randomBytes(12);
+        const body = chacha20poly1305(aeadKey, nonce).encrypt(plaintext);
+        const wire = new Uint8Array([...nonce, ...body]);
+        const decrypted = createEncryption(sharedSecret).decrypt(wire)._unsafeUnwrap();
+        expect(decrypted).toEqual(plaintext);
+    });
+    it('fails to decrypt with a different shared secret', () => {
+        const plaintext = new TextEncoder().encode('secret');
+        const encrypted = createEncryption(randomBytes(32)).encrypt(plaintext)._unsafeUnwrap();
+        const result = createEncryption(randomBytes(32)).decrypt(encrypted);
+        expect(result.isErr()).toBe(true);
+    });
+});

package/dist/session/scale/statementData.js

@@ -1,4 +1,5 @@
-import { Bytes, Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
+import { Bytes } from '@novasamatech/scale';
+import { Enum, Struct, Vector, enhanceCodec, str, u8 } from 'scale-ts';
 export const ResponseCode = enhanceCodec(u8, error => {
     switch (error) {
         case 'success':

package/dist/session/session.spec.js

@@ -1,6 +1,7 @@
+import { Bytes } from '@novasamatech/scale';
 import { createExpiryFromDuration } from '@novasamatech/sdk-statement';
 import { ResultAsync, err, errAsync, ok, okAsync } from 'neverthrow';
-import { Bytes, Struct, str } from 'scale-ts';
+import { Struct, str } from 'scale-ts';
 import { describe, expect, it, vi } from 'vitest';
 import { createInMemoryStatementStore } from '../adapter/inMemory.js';
 import { AccountFullError, ExpiryTooLowError } from '../adapter/types.js';
@@ -263,7 +264,7 @@ describe('session', () => {
             const { session } = makeSession({ peer: [peerRequest] });
             await delay();
             const result = await session.submitResponseMessage(requestId, 'success');
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
         });
         it('treats an incoming request as already answered when our response is present (no resubmit)', async () => {
             const requestId = 'peer-request-id';
@@ -274,7 +275,7 @@ describe('session', () => {
             await delay();
             const submitsBefore = adapter.submitStatement.mock.calls.length;
             const result = await session.submitResponseMessage(requestId, 'success');
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
             expect(adapter.submitStatement.mock.calls.length).toBe(submitsBefore); // no new submit
         });
         it('does not re-deliver an incoming request we already answered', async () => {
@@ -365,8 +366,7 @@ describe('session', () => {
             });
             await delay();
             const result = await responsePromise;
-            expect(result.isOk()).toBe(true);
-            expect(result.unwrapOr({ responseCode: 'unknown' }).responseCode).toBe('success');
+            await expect(result).toBeOkWith(expect.objectContaining({ responseCode: 'success' }));
         });
         it('does not resend a message that is already in flight (dedup)', async () => {
             const store = createInMemoryStatementStore();
@@ -401,8 +401,8 @@ describe('session', () => {
                 isComplete: true,
             });
             await delay();
-            expect((await w1).isOk()).toBe(true);
-            expect((await w2).isOk()).toBe(true);
+            await expect(w1).toBeOk();
+            await expect(w2).toBeOk();
         });
         it('preserves FIFO order: a later fitting message does not overtake queued ones', async () => {
             const m1 = rawCodec.enc(new Uint8Array([1, 2, 3])); // first → in-flight batch
@@ -426,7 +426,7 @@ describe('session', () => {
             await delay();
             adapter.submitStatement.mockClear();
             const result = await session.submitRequestMessage(rawCodec, new Uint8Array([1, 2, 3, 4]));
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
             expect(adapter.submitStatement).not.toHaveBeenCalled();
         });
     });
@@ -524,7 +524,7 @@ describe('session', () => {
             const { session } = makeSession({ peer: [peerRequest] });
             await delay(); // init buffers the peer request
             const result = await session.waitForRequestMessage(rawCodec, () => 'matched');
-            expect(result._unsafeUnwrap()).toBe('matched');
+            await expect(result).toBeOkWith('matched');
         }, 2000);
         it('opens a single subscription on the incoming topic', () => {
             const store = createInMemoryStatementStore();
@@ -591,7 +591,7 @@ describe('session', () => {
             const { session } = makeSession();
             await delay();
             const result = await session.submitResponseMessage('wrong-id', 'success');
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
         });
         it('NACKs an undecodable incoming request with decodingFailed', async () => {
             // A request (enum tag 0) whose requestId decodes but whose data vector claims more
@@ -650,7 +650,7 @@ describe('session', () => {
             expect(adapter.submitStatement).not.toHaveBeenCalled(); // no premature NACK
             // The legitimate response still goes through.
             const res = await session.submitResponseMessage(reqId, 'success');
-            expect(res.isOk()).toBe(true);
+            await expect(res).toBeOk();
             const decoded = StatementData.dec(lastSubmitted(adapter).data);
             expect(decoded.tag === 'response' && decoded.value.responseCode).toBe('success');
         });
@@ -676,7 +676,7 @@ describe('session', () => {
             host.respondToRequests(RemoteMsg, () => 'success');
             await settle();
             const ack = await peer.request(RemoteMsg, requestMsg('p1'));
-            expect(ack.isOk()).toBe(true);
+            await expect(ack).toBeOk();
             host.dispose();
             peer.dispose();
         });
@@ -688,7 +688,7 @@ describe('session', () => {
             host.respondToRequests(RemoteMsg, () => okAsync('decodingFailed'));
             await settle();
             const ack = await peer.request(RemoteMsg, requestMsg('p1'));
-            expect(ack.isErr()).toBe(true);
+            await expect(ack).toBeErr();
             expect(ack._unsafeUnwrapErr()).toBeInstanceOf(DecodingError);
             host.dispose();
             peer.dispose();
@@ -701,7 +701,7 @@ describe('session', () => {
             host.respondToRequests(RemoteMsg, () => errAsync(new Error('handler boom')));
             await settle();
             const ack = await peer.request(RemoteMsg, requestMsg('p1'));
-            expect(ack.isErr()).toBe(true);
+            await expect(ack).toBeErr();
             expect(ack._unsafeUnwrapErr()).toBeInstanceOf(UnknownError);
             host.dispose();
             peer.dispose();
@@ -731,8 +731,8 @@ describe('session', () => {
             await delay();
             const resA = await session.submitResponseMessage('A', 'success');
             const resB = await session.submitResponseMessage('B', 'success');
-            expect(resA.isOk()).toBe(true);
-            expect(resB.isOk()).toBe(true);
+            await expect(resA).toBeOk();
+            await expect(resB).toBeOk();
         });
         it('remains answerable after response submission retries are exhausted', async () => {
             const peerRequest = makeStatement({ tag: 'request', value: { requestId: 'rid', data: [] } });
@@ -740,11 +740,11 @@ describe('session', () => {
             await delay();
             adapter.submitStatement.mockReturnValue(errAsync(new Error('store rejected')));
             const first = await session.submitResponseMessage('rid', 'success'); // all retries fail → err + rollback
-            expect(first.isErr()).toBe(true);
+            await expect(first).toBeErr();
             adapter.submitStatement.mockReturnValue(okAsync(undefined)); // store recovers
             const submitsBefore = adapter.submitStatement.mock.calls.length;
             const second = await session.submitResponseMessage('rid', 'success'); // retryable → submits and succeeds
-            expect(second.isOk()).toBe(true);
+            await expect(second).toBeOk();
             expect(adapter.submitStatement.mock.calls.length).toBeGreaterThan(submitsBefore);
         }, 3000);
         it.each([
@@ -774,13 +774,13 @@ describe('session', () => {
             pendings.find(p => p.requestId === 'A').settle(err(new PriorityError(0n, 0n))); // A lands late, rejected
             const resA = await resAPromise;
             const resB = await resBPromise;
-            expect(resB.isOk()).toBe(true);
-            expect(resA.isOk()).toBe(true); // superseded rejection absorbed, not surfaced as an error
+            await expect(resB).toBeOk();
+            await expect(resA).toBeOk(); // superseded rejection absorbed, not surfaced as an error
             // A stays answered: re-answering it must NOT submit again (which would clobber B's response).
             const submitsBefore = adapter.submitStatement.mock.calls.length;
             const reAnswer = await session.submitResponseMessage('A', 'success');
             await delay();
-            expect(reAnswer.isOk()).toBe(true);
+            await expect(reAnswer).toBeOk();
             expect(adapter.submitStatement.mock.calls.length).toBe(submitsBefore); // deduped → no resubmit
             session.dispose();
         }, 3000);
@@ -793,7 +793,7 @@ describe('session', () => {
             await delay();
             const before = adapter.submitStatement.mock.calls.length;
             const result = await session.clearOutgoingStatement();
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
             expect(adapter.submitStatement.mock.calls.length).toBe(before);
         });
         it('absorbs an ExpiryTooLow on the superseding empty batch as success', async () => {
@@ -809,7 +809,7 @@ describe('session', () => {
             void session.submitRequestMessage(rawCodec, new Uint8Array([1]));
             await delay();
             const cleared = await session.clearOutgoingStatement();
-            expect(cleared.isOk()).toBe(true); // ExpiryTooLow suppressed
+            await expect(cleared).toBeOk(); // ExpiryTooLow suppressed
             session.dispose();
         }, 3000);
         it('submits an empty batch on the same channel at a higher expiry and clears local state', async () => {
@@ -823,7 +823,7 @@ describe('session', () => {
             if (liveDecoded.tag === 'request')
                 expect(liveDecoded.value.data.length).toBe(1);
             const result = await session.clearOutgoingStatement();
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
             const clearCall = adapter.submitStatement.mock.calls.at(-1)?.[0];
             const clearDecoded = StatementData.dec(clearCall.data);
             expect(clearDecoded.tag).toBe('request');
@@ -848,7 +848,7 @@ describe('session', () => {
             void session.submitRequestMessage(rawCodec, new Uint8Array([1, 2, 3]));
             await settle();
             const result = await session.clearOutgoingStatement();
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
             await settle();
             const requests = store
                 .currentStatements()
@@ -862,12 +862,12 @@ describe('session', () => {
             const { session } = makeSession();
             await delay();
             const submit = await session.submitRequestMessage(rawCodec, new Uint8Array([9]));
-            expect(submit.isOk()).toBe(true);
+            await expect(submit).toBeOk();
             const requestId = submit._unsafeUnwrap().requestId;
             const waiter = session.waitForResponseMessage(requestId);
             await session.clearOutgoingStatement();
             const waited = await waiter;
-            expect(waited.isErr()).toBe(true);
+            await expect(waited).toBeErr();
         });
         it('clears local state and rejects waiters even when the supersede submission fails', async () => {
             const { session, adapter } = makeSession();
@@ -877,10 +877,10 @@ describe('session', () => {
             const waiter = session.waitForResponseMessage(requestId);
             adapter.submitStatement.mockReturnValueOnce(errAsync(new Error('store rejected')));
             const result = await session.clearOutgoingStatement();
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
             // The pending waiter is rejected despite the failed submission.
             const waited = await waiter;
-            expect(waited.isErr()).toBe(true);
+            await expect(waited).toBeErr();
             // State is cleared: the next message starts a brand-new batch (data length 1, not 2).
             adapter.submitStatement.mockReturnValue(okAsync(undefined));
             void session.submitRequestMessage(rawCodec, new Uint8Array([4]));
@@ -902,10 +902,10 @@ describe('session', () => {
             const waiter = session.waitForResponseMessage(requestId);
             const submitsBefore = adapter.submitStatement.mock.calls.length;
             const result = await session.clearOutgoingStatement();
-            expect(result.isOk()).toBe(true);
+            await expect(result).toBeOk();
             // The queued waiter is rejected rather than left to be submitted after init.
             const waited = await waiter;
-            expect(waited.isErr()).toBe(true);
+            await expect(waited).toBeErr();
             // No empty batch is submitted since there was no live on-chain request yet.
             expect(adapter.submitStatement.mock.calls.length).toBe(submitsBefore);
         });
@@ -1011,7 +1011,7 @@ describe('session', () => {
             const submit = await session.submitRequestMessage(rawCodec, new Uint8Array([1]));
             const requestId = submit._unsafeUnwrap().requestId;
             const waited = await session.waitForResponseMessage(requestId);
-            expect(waited.isErr()).toBe(true);
+            await expect(waited).toBeErr();
         }, 2000);
         it('absorbs a superseded older submission rejected as ExpiryTooLow without surfacing an error', async () => {
             // Two messages batch onto one outgoing request: the first submission (requestId A) is in
@@ -1055,7 +1055,7 @@ describe('session', () => {
             const waiter = session.waitForRequestMessage(rawCodec, () => 'x');
             session.dispose();
             const result = await waiter;
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
         }, 2000);
         it('cancels a pending init retry (no further queries)', async () => {
             const queryStatements = vi.fn(() => errAsync(new Error('store down'))); // init always fails → schedules retry
@@ -1071,7 +1071,7 @@ describe('session', () => {
             await delay();
             session.dispose();
             const result = await session.submitRequestMessage(rawCodec, new Uint8Array([1]));
-            expect(result.isErr()).toBe(true); // surfaced immediately, not a token left pending forever
+            await expect(result).toBeErr(); // surfaced immediately, not a token left pending forever
             expect(adapter.submitStatement).not.toHaveBeenCalled();
         });
         it('rejects submitResponseMessage after dispose', async () => {
@@ -1079,7 +1079,7 @@ describe('session', () => {
             await delay();
             session.dispose();
             const result = await session.submitResponseMessage('any-id', 'success');
-            expect(result.isErr()).toBe(true);
+            await expect(result).toBeErr();
         });
         it('does not re-activate when disposed while init is in flight', async () => {
             // dispose() lands during init's query await; init must bail before restoring state / flipping
@@ -1089,13 +1089,13 @@ describe('session', () => {
             const queryStatements = vi.fn(() => ResultAsync.fromSafePromise(gate));
             const { session, adapter } = makeSession({ queryStatements });
             const queued = await session.submitRequestMessage(rawCodec, new Uint8Array([1])); // queued during init
-            expect(queued.isOk()).toBe(true);
+            await expect(queued).toBeOk();
             session.dispose(); // dispose mid-init
             resolveQueries([]); // init resumes — must bail before draining the queue / activating
             await settle();
             expect(adapter.submitStatement).not.toHaveBeenCalled(); // no resurrection-driven submit
             const after = await session.submitRequestMessage(rawCodec, new Uint8Array([2]));
-            expect(after.isErr()).toBe(true); // session stays disposed
+            await expect(after).toBeErr(); // session stays disposed
         }, 3000);
     });
     // The in-memory adapter replicates the store's observable contract; `fidelity` pins the double's
@@ -1123,7 +1123,7 @@ describe('session', () => {
                 const store = createInMemoryStatementStore();
                 await store.submitStatement(makeSignedStatement(hex(0xaa), 10n, hex(0x01), new Uint8Array([1])));
                 const higher = await store.submitStatement(makeSignedStatement(hex(0xaa), 11n, hex(0x01), new Uint8Array([2])));
-                expect(higher.isOk()).toBe(true);
+                await expect(higher).toBeOk();
                 expect(store.currentStatements()).toHaveLength(1);
                 expect(store.currentStatements()[0]?.expiry).toBe(11n);
             });
@@ -1132,9 +1132,9 @@ describe('session', () => {
                 await store.submitStatement(makeSignedStatement(hex(0xaa), 10n, hex(0x01), new Uint8Array([1])));
                 const equal = await store.submitStatement(makeSignedStatement(hex(0xaa), 10n, hex(0x01), new Uint8Array([9])));
                 const lower = await store.submitStatement(makeSignedStatement(hex(0xaa), 5n, hex(0x01), new Uint8Array([9])));
-                expect(equal.isErr()).toBe(true);
+                await expect(equal).toBeErr();
                 expect(equal._unsafeUnwrapErr()).toBeInstanceOf(ExpiryTooLowError);
-                expect(lower.isErr()).toBe(true);
+                await expect(lower).toBeErr();
                 // The original statement is untouched.
                 expect(store.currentStatements()[0]?.data).toEqual(new Uint8Array([1]));
             });
@@ -1143,7 +1143,7 @@ describe('session', () => {
                 const stmt = makeSignedStatement(hex(0xaa), 10n, hex(0x01), new Uint8Array([1]));
                 await store.submitStatement(stmt);
                 const again = await store.submitStatement(stmt);
-                expect(again.isOk()).toBe(true);
+                await expect(again).toBeOk();
                 expect(store.currentStatements()).toHaveLength(1);
             });
             it('coexists statements on different channels sharing a topic', async () => {
@@ -1184,9 +1184,9 @@ describe('session', () => {
                 const mobileReplyAck = mobileGotRequest.andThen(req => mobile.request(RemoteMsg, { id: 'm1', kind: 'reply', respondingTo: req.id, body: 'signature' }));
                 const hostReply = host.waitForRequestMessage(RemoteMsg, msg => msg.kind === 'reply' && msg.respondingTo === 'h1' ? msg.body : undefined);
                 await settle();
-                expect((await hostAck).isOk()).toBe(true); // mobile ACKed the host request
-                expect((await mobileReplyAck).isOk()).toBe(true); // host ACKed the mobile reply
-                expect((await hostReply)._unsafeUnwrap()).toBe('signature'); // host received the reply
+                await expect(hostAck).toBeOk(); // mobile ACKed the host request
+                await expect(mobileReplyAck).toBeOk(); // host ACKed the mobile reply
+                await expect(hostReply).toBeOkWith('signature'); // host received the reply
                 host.dispose();
                 mobile.dispose();
             });
@@ -1212,7 +1212,7 @@ describe('session', () => {
                 mobile = makeMobile(store);
                 mobile.respondToRequests(RemoteMsg, () => 'success');
                 await settle();
-                expect((await hostAck).isOk()).toBe(true);
+                await expect(hostAck).toBeOk();
                 host.dispose();
                 mobile.dispose();
             });
@@ -1233,7 +1233,7 @@ describe('session', () => {
                 const hostAck = host.request(RemoteMsg, { id: 'h1', kind: 'request', respondingTo: '', body: 'sign this' });
                 await settle();
                 // The reply is delivered…
-                expect((await hostReply)._unsafeUnwrap()).toBe('signature');
+                await expect(hostReply).toBeOkWith('signature');
                 // …while the transport ACK is still outstanding (mobile never sent it).
                 const ackState = await Promise.race([
                     Promise.resolve(hostAck).then(() => 'resolved'),

package/dist/session/statementProver.spec.js

@@ -32,7 +32,7 @@ describe('statementProver', () => {
             const signed = (await prover.generateMessageProof(makeStatement(new Uint8Array([1, 2, 3]))))._unsafeUnwrap();
             expect(proofSigner(signed)).toBe(toHex(deriveSr25519PublicKey(secret)));
             const verified = await prover.verifyMessageProof(signed);
-            expect(verified._unsafeUnwrap()).toBe(true);
+            await expect(verified).toBeOkWith(true);
         });
     });
     describe('createSlotAccountProver (mobile slot secrets)', () => {
@@ -44,7 +44,7 @@ describe('statementProver', () => {
             const signed = (await prover.generateMessageProof(makeStatement(new Uint8Array([4, 5, 6]))))._unsafeUnwrap();
             expect(proofSigner(signed)).toBe(toHex(deriveSlotAccountPublicKey(slotSecret)));
             const verified = await prover.verifyMessageProof(signed);
-            expect(verified._unsafeUnwrap()).toBe(true);
+            await expect(verified).toBeOkWith(true);
         });
         it('signs under a different public key than the scure prover would for the same secret', () => {
             // Regression guard: a slot secret pushed through the scure scheme derives the WRONG
@@ -58,14 +58,14 @@ describe('statementProver', () => {
             const signed = (await prover.generateMessageProof(makeStatement(new Uint8Array([7, 8, 9]))))._unsafeUnwrap();
             const tampered = { ...signed, data: new Uint8Array([9, 9, 9]) };
             const verified = await prover.verifyMessageProof(tampered);
-            expect(verified._unsafeUnwrap()).toBe(false);
+            await expect(verified).toBeOkWith(false);
         });
     });
     describe('verifyMessageProof', () => {
         it('errors when the statement carries no proof', async () => {
             const prover = createSr25519Prover(createSr25519Secret(mnemonicToEntropy(DEV_MNEMONIC)));
             const verified = await prover.verifyMessageProof(makeStatement(new Uint8Array([1])));
-            expect(verified.isErr()).toBe(true);
+            await expect(verified).toBeErr();
         });
     });
 });

package/dist/submit/retry.spec.js

@@ -15,7 +15,7 @@ describe('submitWithRetry', () => {
         let calls = 0;
         const submit = vi.fn(() => ++calls <= 6 ? errAsync(new AccountFullError(0n, 1n)) : okAsync(undefined));
         const result = await submitWithRetry(submit, { ...FAST, attempts: 3, priorityAttempts: 'unbounded' });
-        expect(result.isOk()).toBe(true);
+        await expect(result).toBeOk();
         expect(calls).toBe(7);
     });
     it("priorityAttempts 'unbounded': a no-longer-live priority rejection settles as success", async () => {
@@ -26,13 +26,13 @@ describe('submitWithRetry', () => {
             priorityAttempts: 'unbounded',
             shouldRetry: () => false,
         });
-        expect(result.isOk()).toBe(true); // lost the channel race — benign
+        await expect(result).toBeOk(); // lost the channel race — benign
         expect(submit).toHaveBeenCalledTimes(1);
     });
     it('priorityAttempts budgeted: priority errors consume their budget then propagate', async () => {
         const submit = vi.fn(() => errAsync(new AccountFullError(0n, 1n)));
         const result = await submitWithRetry(submit, { ...FAST, attempts: 0, priorityAttempts: 3 });
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(result._unsafeUnwrapErr()).toBeInstanceOf(AccountFullError);
         expect(submit).toHaveBeenCalledTimes(4); // 1 initial + 3 retries
     });
@@ -46,7 +46,7 @@ describe('submitWithRetry', () => {
             priorityAttempts: 2,
             onPriorityError: error => seen.push(error.min),
         });
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(submit).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
         expect(seen).toEqual([1n, 2n, 3n]); // adopted the floor on all three, including the terminal rejection
     });
@@ -59,13 +59,13 @@ describe('submitWithRetry', () => {
     it('attempts 0: a non-priority error propagates immediately', async () => {
         const submit = vi.fn(() => errAsync(new Error('store rejected')));
         const result = await submitWithRetry(submit, { ...FAST, attempts: 0, priorityAttempts: 3 });
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(submit).toHaveBeenCalledTimes(1);
     });
     it('non-priority errors consume the attempts budget then propagate', async () => {
         const submit = vi.fn(() => errAsync(new Error('store rejected')));
         const result = await submitWithRetry(submit, { ...FAST, attempts: 2, priorityAttempts: 'unbounded' });
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(submit).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
     });
     it('per-attempt delay schedule is honored and reported via onRetry', async () => {
@@ -78,7 +78,7 @@ describe('submitWithRetry', () => {
             delaysMs: [1, 2, 3],
             onRetry: ({ attempt, delayMs }) => seen.push({ attempt, delayMs }),
         });
-        expect(result.isOk()).toBe(true);
+        await expect(result).toBeOk();
         expect(seen).toEqual([
             { attempt: 0, delayMs: 1 },
             { attempt: 1, delayMs: 2 },
@@ -87,7 +87,7 @@ describe('submitWithRetry', () => {
     it('a negative budget propagates immediately instead of looping', async () => {
         const submit = vi.fn(() => errAsync(new Error('store rejected')));
         const result = await submitWithRetry(submit, { ...FAST, attempts: -1, priorityAttempts: 3 });
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(submit).toHaveBeenCalledTimes(1);
     });
     it('a shouldRetry flip during the backoff settles a priority rejection as success', async () => {
@@ -104,7 +104,7 @@ describe('submitWithRetry', () => {
             priorityAttempts: 'unbounded',
             shouldRetry: () => live,
         });
-        expect(result.isOk()).toBe(true); // settled after the delay, no second attempt
+        await expect(result).toBeOk(); // settled after the delay, no second attempt
         expect(submit).toHaveBeenCalledTimes(1);
     });
     it('shouldRetry is re-checked before each retry and stops the loop', async () => {
@@ -119,7 +119,7 @@ describe('submitWithRetry', () => {
             priorityAttempts: 'unbounded',
             shouldRetry: () => live,
         });
-        expect(result.isErr()).toBe(true); // non-priority + not live → propagate, no settle
+        await expect(result).toBeErr(); // non-priority + not live → propagate, no settle
         expect(submit).toHaveBeenCalledTimes(1);
     });
 });

package/dist/submit/submitStatement.spec.js

@@ -41,7 +41,7 @@ describe('submitStatementOnce', () => {
     it('submits with the pinned-high expiry layout', async () => {
         const { adapter, submitted } = makeStore();
         const result = await submitStatementOnce(baseParams(adapter));
-        expect(result.isOk()).toBe(true);
+        await expect(result).toBeOk();
         expect(submitted).toHaveLength(1);
         expect((submitted[0].expiry ?? 0n) >> 32n).toBe(0xffffffffn);
     });
@@ -51,8 +51,8 @@ describe('submitStatementOnce', () => {
         const params = baseParams(adapter);
         const first = await submitStatementOnce(params);
         const second = await submitStatementOnce(params);
-        expect(first.isErr()).toBe(true);
-        expect(second.isOk()).toBe(true);
+        await expect(first).toBeErr();
+        await expect(second).toBeOk();
         expect(submitted[1].expiry ?? 0n).toBeGreaterThan(chainMin); // adopted min, not wall clock
     });
 });
@@ -73,7 +73,7 @@ describe('signAndSubmitStatement', () => {
         });
         await vi.advanceTimersByTimeAsync(600); // cover the 500ms first backoff
         const result = await promise;
-        expect(result.isOk()).toBe(true);
+        await expect(result).toBeOk();
         expect(submitted).toHaveLength(2);
         expect(submitted[1].expiry ?? 0n).toBeGreaterThan(chainMin);
     });
@@ -92,7 +92,7 @@ describe('signAndSubmitStatement', () => {
         });
         await vi.advanceTimersByTimeAsync(50);
         const result = await promise;
-        expect(result.isErr()).toBe(true);
+        await expect(result).toBeErr();
         expect(result._unsafeUnwrapErr()).toBeInstanceOf(AccountFullError);
         expect(submitted).toHaveLength(4); // 1 initial + 3 priority retries
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.8.11",
+  "version": "0.9.0",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {
@@ -25,18 +25,18 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.8.11",
+    "@novasamatech/scale": "0.9.0",
     "@novasamatech/sdk-statement": "^0.6.0",
-    "@novasamatech/substrate-slot-sr25519-wasm": "0.8.11",
+    "@novasamatech/substrate-slot-sr25519-wasm": "0.9.0",
     "@polkadot-api/substrate-bindings": "^0.20.3",
     "@polkadot-api/substrate-client": "^0.7.0",
-    "@polkadot-labs/hdkd-helpers": "^0.0.30",
+    "@polkadot-labs/hdkd-helpers": "^0.0.31",
     "@polkadot-labs/schnorrkel-wasm": "0.0.9",
     "@noble/hashes": "2.2.0",
     "@noble/ciphers": "2.2.0",
     "@scure/sr25519": "2.2.0",
     "polkadot-api": ">=2",
-    "nanoid": "5.1.11",
+    "nanoid": "6.0.0",
     "neverthrow": "^8.2.0",
     "scale-ts": "1.6.1"
   },