@novasamatech/statement-store 0.8.7-3 → 0.8.7-5

package/dist/adapter/rpc.js

@@ -97,9 +97,9 @@ export function createPapiStatementStoreAdapter(lazyClient) {
                             case 'dataTooLarge':
                                 return errAsync(new DataTooLargeError(result.submitted_size, result.available_size));
                             case 'channelPriorityTooLow':
-                                return errAsync(new ExpiryTooLowError(result.submitted_expiry, result.min_expiry));
+                                return errAsync(new ExpiryTooLowError(BigInt(result.submitted_expiry), BigInt(result.min_expiry)));
                             case 'accountFull':
-                                return errAsync(new AccountFullError(result.submitted_expiry, result.min_expiry));
+                                return errAsync(new AccountFullError(BigInt(result.submitted_expiry), BigInt(result.min_expiry)));
                             case 'storeFull':
                                 return errAsync(new StorageFullError());
                             case 'noAllowance':

package/dist/session/session.js

@@ -99,12 +99,19 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
     // latest is live — a retry for an older one must not resurrect it).
     let lastResponseRequestId = null;
     // Encrypt, then submit on `channel`/`topicSessionId` at the allocator's next (strictly
-    // increasing) expiry. On a priority rejection submitStatementOnce resyncs the allocator to the
-    // chain-reported minimum before propagating, so the retry — and every later submit — clears it.
+    // increasing) expiry. A priority rejection does NOT resync the allocator here — each caller
+    // raises the floor to the chain-reported minimum (the submitWithRetry `onPriorityError` hooks
+    // below, and the one-shot clear in clearOutgoingStatement), so the retry — and every later
+    // submit — clears it.
     function submitStatementData(channel, topicSessionId, data) {
-        return encryption
-            .encrypt(data)
-            .asyncAndThen(encrypted => submitStatementOnce({ statementStore, prover, allocator, channel, topics: [topicSessionId], data: encrypted }));
+        return encryption.encrypt(data).asyncAndThen(encrypted => submitStatementOnce({
+            statementStore,
+            prover,
+            allocator,
+            channel,
+            topics: [topicSessionId],
+            data: encrypted,
+        }));
     }
     // Settle and remove the pending-delivery entries for the given tokens.
     function settleTokens(tokens, settle) {
@@ -118,8 +125,8 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
     }
     // Session retry policy (this and every submitWithRetry call below): priority errors
     // (ExpiryTooLow / AccountFull) are retried with `priorityAttempts: 'unbounded'` — they never
-    // consume the transient-failure budget, because submitStatementData has already resynced the
-    // allocator above the chain-reported minimum, so the next attempt submits higher. We keep at it
+    // consume the transient-failure budget, because the `onPriorityError` hook raises the allocator
+    // floor above the chain-reported minimum, so the next attempt submits higher. We keep at it
     // until the statement lands or the submission is superseded; once superseded, a priority
     // rejection is swallowed as success (it merely lost the channel race to a newer, higher-priority
     // statement). The upshot: priority errors never surface to session callers. Other errors keep
@@ -132,6 +139,8 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             attempts: MAX_SUBMIT_RETRIES,
             priorityAttempts: 'unbounded',
             delaysMs: RETRY_DELAY_MS,
+            // Adopt the chain-reported floor so the next attempt submits strictly above it.
+            onPriorityError: error => allocator.raiseFloor(error.min),
             // Only keep retrying while this is still the live submission (not superseded by a
             // newer retransmit, aborted via clearOutgoingStatement, or disposed).
             shouldRetry: () => !disposed && state.outgoingRequest?.requestIds.at(-1) === requestId,
@@ -454,6 +463,8 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
                 attempts: MAX_SUBMIT_RETRIES,
                 priorityAttempts: 'unbounded',
                 delaysMs: RETRY_DELAY_MS,
+                // Adopt the chain-reported floor so the next attempt submits strictly above it.
+                onPriorityError: error => allocator.raiseFloor(error.min),
                 // Stop retrying once a newer response supersedes this one (shared response channel) or disposed.
                 shouldRetry: () => !disposed && lastResponseRequestId === requestId,
             })
@@ -576,8 +587,14 @@ export function createSession({ localAccount, remoteAccount, statementStore, enc
             // would leave the original request live on-chain. One shot, no retry (clearing is a
             // supersede, not a request that must land); a priority rejection (ExpiryTooLow /
             // AccountFull) means the channel already advanced past us, so the clear already
-            // happened → absorb it as success.
-            return submitStatementData(requestChannel, outgoingSessionId, encoded.value).orElse(error => isPriorityTooLow(error) ? okAsync(undefined) : errAsync(error));
+            // happened → absorb it as success. No retry loop here means no onPriorityError hook, so
+            // resync the allocator inline: adopt the chain floor before absorbing, so later submits stay above it.
+            return submitStatementData(requestChannel, outgoingSessionId, encoded.value).orElse(error => {
+                if (!isPriorityTooLow(error))
+                    return errAsync(error);
+                allocator.raiseFloor(error.min);
+                return okAsync(undefined);
+            });
         },
         dispose() {
             disposed = true;

package/dist/submit/retry.d.ts

@@ -28,5 +28,13 @@ export type SubmitRetryOptions = {
         delayMs: number;
         error: Error;
     }) => void;
+    /**
+     * Invoked on every priority rejection (ExpiryTooLow / AccountFull), before the retry
+     * decision — so it fires even when the priority budget is exhausted or the submission is
+     * no longer live. This is where the caller adopts the chain-reported floor (`error.min`)
+     * into its allocator, so the NEXT attempt — here or via an outer retry/outbox — submits
+     * strictly above it and clears in one step rather than climbing.
+     */
+    onPriorityError?: (error: ExpiryTooLowError | AccountFullError) => void;
 };
 export declare function submitWithRetry(submit: () => ResultAsync<void, Error>, options: SubmitRetryOptions): ResultAsync<void, Error>;

package/dist/submit/retry.js

@@ -15,7 +15,7 @@ function delayFor(delaysMs, attempt) {
     return delaysMs[Math.min(attempt, delaysMs.length - 1)] ?? 0;
 }
 export function submitWithRetry(submit, options) {
-    const { attempts, priorityAttempts, delaysMs, shouldRetry = () => true, onRetry } = options;
+    const { attempts, priorityAttempts, delaysMs, shouldRetry = () => true, onRetry, onPriorityError } = options;
     // How to settle once we stop retrying: under the 'unbounded' policy a
     // no-longer-live submission rejected with a priority error simply lost the
     // channel race to a newer, higher-priority statement — benign, so report success.
@@ -30,13 +30,17 @@ export function submitWithRetry(submit, options) {
             if (result.isOk())
                 return result;
             const error = result.error;
-            const priority = isPriorityTooLow(error);
-            const budgetLeft = priority ? priorityLeft : attemptsLeft;
+            const priorityError = isPriorityTooLow(error) ? error : null;
+            // Adopt the chain-reported floor before deciding whether to retry, so an exhausted or
+            // no-longer-live priority rejection still raises it for any outer retry/outbox.
+            if (priorityError)
+                onPriorityError?.(priorityError);
+            const budgetLeft = priorityError ? priorityLeft : attemptsLeft;
             if (!shouldRetry() || (typeof budgetLeft === 'number' && budgetLeft <= 0))
                 return settle(error);
             const delayMs = delayFor(delaysMs, attempt);
             onRetry?.({ attempt, delayMs, error });
-            if (priority) {
+            if (priorityError) {
                 if (priorityLeft !== 'unbounded')
                     priorityLeft -= 1;
             }

package/dist/submit/retry.spec.js

@@ -36,6 +36,26 @@ describe('submitWithRetry', () => {
         expect(result._unsafeUnwrapErr()).toBeInstanceOf(AccountFullError);
         expect(submit).toHaveBeenCalledTimes(4); // 1 initial + 3 retries
     });
+    it('onPriorityError fires for every priority rejection, including the terminal one once the budget is exhausted', async () => {
+        const seen = [];
+        let calls = 0;
+        const submit = vi.fn(() => errAsync(new AccountFullError(0n, BigInt(++calls))));
+        const result = await submitWithRetry(submit, {
+            ...FAST,
+            attempts: 0,
+            priorityAttempts: 2,
+            onPriorityError: error => seen.push(error.min),
+        });
+        expect(result.isErr()).toBe(true);
+        expect(submit).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
+        expect(seen).toEqual([1n, 2n, 3n]); // adopted the floor on all three, including the terminal rejection
+    });
+    it('onPriorityError is not called for non-priority errors', async () => {
+        const onPriorityError = vi.fn();
+        const submit = vi.fn(() => errAsync(new Error('store rejected')));
+        await submitWithRetry(submit, { ...FAST, attempts: 2, priorityAttempts: 'unbounded', onPriorityError });
+        expect(onPriorityError).not.toHaveBeenCalled();
+    });
     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 });

package/dist/submit/submitStatement.js

@@ -24,5 +24,9 @@ export function submitStatementOnce(params) {
     });
 }
 export function signAndSubmitStatement(params) {
-    return submitWithRetry(() => submitStatementOnce(params), params.retry);
+    return submitWithRetry(() => submitStatementOnce(params), {
+        ...params.retry,
+        // Adopt the chain-reported floor so the next retry submits strictly above it and clears.
+        onPriorityError: error => params.allocator.raiseFloor(error.min),
+    });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/statement-store",
   "type": "module",
-  "version": "0.8.7-3",
+  "version": "0.8.7-5",
   "description": "Statement store integration",
   "license": "Apache-2.0",
   "repository": {
@@ -25,9 +25,9 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.8.7-3",
+    "@novasamatech/scale": "0.8.7-5",
     "@novasamatech/sdk-statement": "^0.6.0",
-    "@novasamatech/substrate-slot-sr25519-wasm": "0.8.7-3",
+    "@novasamatech/substrate-slot-sr25519-wasm": "0.8.7-5",
     "@polkadot-api/substrate-bindings": "^0.20.3",
     "@polkadot-api/substrate-client": "^0.7.0",
     "@polkadot-labs/hdkd-helpers": "^0.0.30",