@novasamatech/statement-store 0.8.10 → 0.8.12

package/dist/session/session.spec.js

@@ -263,7 +263,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 +274,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 +365,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 +400,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 +425,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 +523,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 +590,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 +649,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 +675,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 +687,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 +700,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 +730,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 +739,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 +773,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 +792,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 +808,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 +822,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 +847,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 +861,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 +876,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 +901,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 +1010,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 +1054,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 +1070,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 +1078,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 +1088,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 +1122,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 +1131,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 +1142,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 +1183,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 +1211,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 +1232,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.10",
+  "version": "0.8.12",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {
@@ -25,18 +25,18 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.8.10",
+    "@novasamatech/scale": "0.8.12",
     "@novasamatech/sdk-statement": "^0.6.0",
-    "@novasamatech/substrate-slot-sr25519-wasm": "0.8.10",
+    "@novasamatech/substrate-slot-sr25519-wasm": "0.8.12",
     "@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"
   },