Merge branch 'master' into nd/index-active-sub-conns

agent: index connections with active subscriptions instead of folding all subscriptions per batch
(cherry picked from commit bae057286d9675bae9a8cf1999f319b25517eda5)
2026-10-12 11:39:56 +00:00 · 2026-09-30 15:45:18 +00:00 · 2026-09-26 11:23:43 +00:00
104 changed files with 1837 additions and 5927 deletions
@@ -66,19 +66,8 @@ jobs:
  build:
    name: "ubuntu-${{ matrix.os }}-${{ matrix.arch }}, GHC: ${{ matrix.ghc }}"
    needs: maybe-release
-    permissions:
-      contents: write
-      packages: write
    env:
      apps: "smp-server xftp-server ntf-server xftp"
-      opt: ${{ github.event_name == 'pull_request' && 'O0' || 'O2' }}
-      ghc_options: ${{ github.event_name == 'pull_request' && '--ghc-options=-O0' || '' }}
-      release: ${{ startsWith(github.ref, 'refs/tags/v') }}
-      postgres_dist: ${{ startsWith(github.ref, 'refs/tags/v') && 'dist-newstyle' || 'dist-postgres' }}
-      branch: ${{ github.base_ref || github.ref_name }}
-      cache_o0: ${{ github.event_name == 'push' && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/stable') }}
-      image_cache: ghcr.io/simplex-chat/simplexmq-build-cache:${{ matrix.os }}-${{ matrix.arch }}-ghc${{ matrix.ghc }}
-      source_hashes: dist-newstyle/sources.sha256
    runs-on: ${{ matrix.runner }}
    services:
      postgres:
@@ -157,18 +146,6 @@ jobs:
          sudo apt update
          sudo apt -y install postgresql-client-15

-      - name: Log in to GitHub Container Registry
-        if: matrix.should_run == true && env.release != 'true'
-        shell: bash
-        env:
-          GHCR_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: echo "$GHCR_TOKEN" | docker login ghcr.io -u "${{ github.actor }}" --password-stdin
-
-      - name: Compute image cache week
-        id: week
-        if: matrix.should_run == true && env.release != 'true'
-        run: echo "week=$(date -u +%G-W%V)" >> "$GITHUB_OUTPUT"
-
      - name: Build and cache Docker image
        if: matrix.should_run == true
        uses: simplex-chat/docker-build-push-action@v6
@@ -180,14 +157,20 @@ jobs:
          build-args: |
            TAG=${{ matrix.os }}
            GHC=${{ matrix.ghc }}
-          cache-from: ${{ env.release != 'true' && format('type=registry,ref={0}-{1}', env.image_cache, steps.week.outputs.week) || '' }}
-          cache-to: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && format('type=registry,ref={0}-{1},mode=max,ignore-error=true', env.image_cache, steps.week.outputs.week) || '' }}
+
+      - name: Cache dependencies
+        if: matrix.should_run == true
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cabal/store
+            dist-newstyle
+          key: ubuntu-${{ matrix.os }}-${{ matrix.arch }}-ghc${{ matrix.ghc }}-${{ hashFiles('cabal.project', 'simplexmq.cabal') }}

      - name: Start container
        if: matrix.should_run == true
        shell: bash
        run: |
-          mkdir -p ~/.cabal
          docker run -t -d \
            --device /dev/fuse \
            --cap-add SYS_ADMIN \
@@ -198,66 +181,21 @@ jobs:
            -v ${{ github.workspace }}:/project \
            build/${{ matrix.os }}:latest

-      - name: Compute cache key prefixes
-        id: keys
-        if: matrix.should_run == true && env.release != 'true'
-        run: |
-          toolchain=$(docker exec builder dpkg-query -W -f '${db:Status-Status} ${binary:Package} ${Version}\n' 'binutils*' 'cpp*' 'gcc*' '*-dev' | grep '^installed ' | sha256sum | cut -c1-16)
-          target=${{ matrix.os }}-${{ matrix.arch }}-ghc${{ matrix.ghc }}-$toolchain
-          echo "deps=deps-$target" >> "$GITHUB_OUTPUT"
-          echo "dist=dist-$target" >> "$GITHUB_OUTPUT"
-
-      - name: Restore dependencies from cache
-        id: restore-deps
-        if: matrix.should_run == true && env.release != 'true'
-        uses: actions/cache/restore@v4
-        with:
-          path: ~/.cabal/store
-          key: ${{ steps.keys.outputs.deps }}-${{ env.branch }}-${{ github.sha }}
-          restore-keys: |
-            ${{ steps.keys.outputs.deps }}-${{ env.branch }}-
-            ${{ steps.keys.outputs.deps }}-
-
-      - name: Warn if dependencies not in cache
-        if: matrix.should_run == true && env.release != 'true' && steps.restore-deps.outputs.cache-matched-key == ''
-        run: echo "::warning title=Cache miss::${{ steps.keys.outputs.deps }}-${{ env.branch }}"
-
-      - name: Restore build directories from cache
-        id: restore-build
-        if: matrix.should_run == true && env.release != 'true'
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            dist-newstyle
-            dist-postgres
-          key: ${{ steps.keys.outputs.dist }}-${{ env.opt }}-${{ env.branch }}-${{ github.sha }}
-          restore-keys: |
-            ${{ steps.keys.outputs.dist }}-${{ env.opt }}-${{ env.branch }}-
-            ${{ steps.keys.outputs.dist }}-${{ env.opt }}-
-
-      - name: Warn if build directories not in cache
-        if: matrix.should_run == true && env.release != 'true' && steps.restore-build.outputs.cache-matched-key == ''
-        run: echo "::warning title=Cache miss::${{ steps.keys.outputs.dist }}-${{ env.opt }}-${{ env.branch }}"
-
-      - name: Set old timestamps on unchanged sources (GHC 8.10.7)
-        if: matrix.ghc == '8.10.7' && steps.restore-build.outputs.cache-matched-key != '' && hashFiles(env.source_hashes) != ''
-        run: scripts/ci/source-timestamps.sh restore ${{ env.source_hashes }}
-
      - name: Build smp-server, xftp-server (postgresql) and tests
        if: matrix.should_run == true
        shell: docker exec -t builder sh -eu {0}
        run: |
-          chmod -fR 777 ~/.cabal ./dist-newstyle ./dist-postgres || :; git config --global --add safe.directory '*'
-          scripts/ci/prune-old-builds.sh dist-newstyle dist-postgres
+          chmod -fR 777 ~/.cabal ./dist-newstyle || :; git config --global --add safe.directory '*'
+          cabal clean
          cabal update
-          cabal build --builddir=${{ env.postgres_dist }} --jobs=$(nproc) --enable-tests -fserver_postgres ${{ env.ghc_options }}
+          cabal build --jobs=$(nproc) --enable-tests -fserver_postgres
          mkdir -p /out
-          for i in smp-server xftp-server ntf-server simplexmq-test; do
-            bin=$(find /project/${{ env.postgres_dist }} -name "$i" -type f -executable)
+          for i in smp-server xftp-server simplexmq-test; do
+            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
            chmod +x "$bin"
-            cp "$bin" /out/
+            mv "$bin" /out/
          done
-          strip /out/smp-server /out/xftp-server /out/ntf-server
+          strip /out/smp-server /out/xftp-server

      - name: Copy simplexmq-test from container
        if: matrix.should_run == true
@@ -290,17 +228,16 @@ jobs:
          cat hashes.output >> "$GITHUB_OUTPUT"

      - name: Build everything else (standard)
-        id: build-standard
        if: matrix.should_run == true
        shell: docker exec -t builder sh -eu {0}
        run: |
-          cabal build --jobs=$(nproc) ${{ env.ghc_options }}
+          cabal build --jobs=$(nproc)
          mkdir -p /out
-          for i in smp-server xftp-server xftp; do
+          for i in ${{ env.apps }}; do
            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
            strip "$bin"
            chmod +x "$bin"
-            cp "$bin" /out/
+            mv "$bin" /out/
          done

      - name: Copy binaries from container and prepare them
@@ -345,33 +282,6 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

-      - name: Record source hashes (GHC 8.10.7)
-        if: matrix.should_run == true && matrix.ghc == '8.10.7'
-        shell: docker exec -t builder sh -eu {0}
-        run: scripts/ci/source-timestamps.sh record ${{ env.source_hashes }}
-
-      - name: Compute dependency cache key
-        id: hash-deps
-        if: matrix.should_run == true && env.release != 'true'
-        shell: bash
-        run: echo "hash=$(ls ~/.cabal/store/ghc-*/ | sha256sum | cut -c1-16)" >> "$GITHUB_OUTPUT"
-
-      - name: Save dependencies to cache
-        if: matrix.should_run == true && env.release != 'true' && steps.restore-deps.outputs.cache-matched-key != format('{0}-{1}-{2}', steps.keys.outputs.deps, env.branch, steps.hash-deps.outputs.hash)
-        uses: actions/cache/save@v4
-        with:
-          path: ~/.cabal/store
-          key: ${{ steps.keys.outputs.deps }}-${{ env.branch }}-${{ steps.hash-deps.outputs.hash }}
-
-      - name: Save build directories to cache
-        if: matrix.should_run == true && env.release != 'true' && steps.restore-build.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            dist-newstyle
-            dist-postgres
-          key: ${{ steps.keys.outputs.dist }}-${{ env.opt }}-${{ env.branch }}-${{ github.sha }}
-
      - name: Test
        if: matrix.should_run == true && matrix.arch == 'x86-64'
        timeout-minutes: 120
@@ -396,52 +306,6 @@ jobs:
            exit 1
          fi

-      - name: Remove -O2 build directories
-        id: remove-o2
-        if: env.cache_o0 == 'true' && !cancelled() && steps.build-standard.outcome == 'success'
-        shell: docker exec -t builder sh -eu {0}
-        run: rm -rf dist-newstyle dist-postgres
-
-      - name: Restore -O0 build directories from cache
-        id: restore-build-o0
-        if: ${{ !cancelled() && steps.remove-o2.outcome == 'success' }}
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            dist-newstyle
-            dist-postgres
-          key: ${{ steps.keys.outputs.dist }}-O0-${{ env.branch }}-${{ github.sha }}
-          restore-keys: |
-            ${{ steps.keys.outputs.dist }}-O0-${{ env.branch }}-
-            ${{ steps.keys.outputs.dist }}-O0-
-
-      - name: Set old timestamps on unchanged sources for -O0 build (GHC 8.10.7)
-        if: ${{ !cancelled() && matrix.ghc == '8.10.7' && steps.restore-build-o0.outputs.cache-matched-key != '' && hashFiles(env.source_hashes) != '' }}
-        run: scripts/ci/source-timestamps.sh restore ${{ env.source_hashes }}
-
-      - name: Build at -O0 for pull request caches
-        id: build-o0
-        if: ${{ !cancelled() && steps.remove-o2.outcome == 'success' }}
-        shell: docker exec -t builder sh -eu {0}
-        run: |
-          scripts/ci/prune-old-builds.sh dist-newstyle dist-postgres
-          cabal build --builddir=dist-postgres --jobs=$(nproc) --enable-tests -fserver_postgres --ghc-options=-O0
-          cabal build --jobs=$(nproc) --ghc-options=-O0
-
-      - name: Record source hashes for -O0 build (GHC 8.10.7)
-        if: ${{ !cancelled() && matrix.ghc == '8.10.7' && steps.build-o0.outcome == 'success' }}
-        shell: docker exec -t builder sh -eu {0}
-        run: scripts/ci/source-timestamps.sh record ${{ env.source_hashes }}
-
-      - name: Save -O0 build directories to cache
-        if: ${{ !cancelled() && steps.build-o0.outcome == 'success' && steps.restore-build-o0.outputs.cache-hit != 'true' }}
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            dist-newstyle
-            dist-postgres
-          key: ${{ steps.keys.outputs.dist }}-O0-${{ env.branch }}-${{ github.sha }}
-
 # =============================
 #      Resolver test job
 # =============================
@@ -456,14 +320,15 @@ jobs:
      - name: Clone project
        uses: actions/checkout@v3

-      - name: Set up uv
-        # uv takes Python from .python-version, the version of the Dockerfile's runtime stage.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      - name: Set up Python
+        # Matches the runtime stage of scripts/resolver/service/Dockerfile.
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"

-      - name: Lint
-        working-directory: scripts/resolver/service
-        run: uv run --frozen ruff check .
+      - name: Install resolver dependencies
+        # Must match scripts/resolver/service/pyproject.toml.
+        run: python -m pip install "eth-hash[pycryptodome]>=0.7"

      - name: Test
-        working-directory: scripts/resolver/service
-        run: uv run --frozen pytest -v
+        run: python -m unittest discover -s scripts/resolver/service -v
@@ -1,8 +1,4 @@
 *.lock
-# the resolver's Docker image and CI install exactly these
-!/scripts/resolver/service/uv.lock
-# local overrides of scripts/resolver/.env.example
-/scripts/resolver/.env
 *.db
 *.db.bak
 *.session.sql
@@ -31,7 +31,7 @@ source-repository-package
 source-repository-package
    type: git
    location: https://github.com/simplex-chat/direct-sqlcipher.git
-    tag: 2330df3dc8c4b660674d3c02d76bb86f66c2abee
+    tag: f814ee68b16a9447fbb467ccc8f29bdd3546bfd9

 source-repository-package
    type: git
@@ -719,32 +719,23 @@ Small_random (small * out, void *random_ctx, sntrup761_random_func * random)

 /* ----- Streamlined NTRU Prime Core */

-/* x^p-x-1 has a degree-19 factor mod 3, so a random g is not invertible in R3
-   with probability about 3^-19; KeyGen_attempts failures in a row mean a broken RNG */
-#define KeyGen_attempts 10
-
 /* h,(f,ginv) = KeyGen() */
-/* returns 0 if KeyGen succeeded; else -1 */
-static int
+static void
 KeyGen (Fq * h, small * f, small * ginv, void *random_ctx,
        sntrup761_random_func * random)
 {
  small g[p];
  Fq finv[p];
-  int i;

-  for (i = 0; i < KeyGen_attempts; ++i)
+  for (;;)
    {
      Small_random (g, random_ctx, random);
      if (R3_recip (ginv, g) == 0)
        break;
    }
-  if (i == KeyGen_attempts)
-    return -1;
  Short_random (f, random_ctx, random);
  Rq_recip3 (finv, f);          /* always works */
  Rq_mult_small (h, finv, g);
-  return 0;
 }

 /* c = Encrypt(r,h) */
@@ -893,21 +884,18 @@ typedef small Inputs[p];        /* passed by reference */
 #define PublicKeys_bytes Rq_bytes

 /* pk,sk = ZKeyGen() */
-/* returns 0 if KeyGen succeeded; else -1 */
-static int
+static void
 ZKeyGen (unsigned char *pk, unsigned char *sk, void *random_ctx,
         sntrup761_random_func * random)
 {
  Fq h[p];
  small f[p], v[p];

-  if (KeyGen (h, f, v, random_ctx, random) != 0)
-    return -1;
+  KeyGen (h, f, v, random_ctx, random);
  Rq_encode (pk, h);
  Small_encode (sk, f);
  sk += Small_bytes;
  Small_encode (sk, v);
-  return 0;
 }

 /* C = ZEncrypt(r,pk) */
@@ -972,21 +960,19 @@ HashSession (unsigned char *k, int b, const unsigned char *y,
 /* ----- Streamlined NTRU Prime */

 /* pk,sk = KEM_KeyGen() */
-int
+void
 sntrup761_keypair (unsigned char *pk, unsigned char *sk, void *random_ctx,
                   sntrup761_random_func * random)
 {
  int i;

-  if (ZKeyGen (pk, sk, random_ctx, random) != 0)
-    return -1;
+  ZKeyGen (pk, sk, random_ctx, random);
  sk += SecretKeys_bytes;
  for (i = 0; i < PublicKeys_bytes; ++i)
    *sk++ = pk[i];
  random (random_ctx, Inputs_bytes, sk);
  sk += Inputs_bytes;
  Hash_prefix (sk, 4, pk, PublicKeys_bytes);
-  return 0;
 }

 /* c,r_enc = Hide(r,pk,cache); cache is Hash4(pk) */
@@ -19,8 +19,7 @@

 typedef void sntrup761_random_func (void *ctx, size_t length, uint8_t *dst);

-/* returns 0 on success, -1 if the RNG never produced an invertible polynomial */
-int
+void
 sntrup761_keypair (uint8_t *pk, uint8_t *sk,
                   void *random_ctx, sntrup761_random_func *random);

@@ -7,7 +7,6 @@ This file provides guidance on coding style and approaches and on building the c
 When designing code and planning implementations:
 - Apply adversarial thinking, and consider what may happen if one of the communicating parties is malicious.
 - Formulate an explicit threat model for each change - who can do which undesirable things and under which circumstances.
- Use the default cryptographic primitive for each purpose from the [primitive registry](../protocol/crypto-registry.md); any exception requires review, and the registry must be updated with every new primitive use or domain-separation string.

 ## Code Quality Standards

@@ -0,0 +1,65 @@
+## Root cause: every subscription batch rebuilds the set of subscribed connections
+
+Resubscribing a session allocates and discards a fresh `Set ConnId` covering *all* of that
+session's active subscriptions, once per batch. On clients with many queues per session this
+dominates both the CPU and the allocation of a reconnection, and it happens again on every
+network change.
+
+`subscribeSessQueues_` (`Agent/Client.hs`) needs to know which connections were already
+subscribed, so that only newly subscribed ones are reported `UP`. It obtained that by folding
+the session's whole subscription map:
+
+```haskell
+Just . S.fromList . map qConnId . M.elems <$> atomically (SS.getActiveSubs tSess $ currentSubs c)
+```
+
+`activeSubs` is keyed by `RecipientId` and holds every subscribed queue of the session, so this
+walks all of them and builds a set of the same size — to answer a membership question about at
+most `subsBatchSize` connections.
+
+### Cost
+
+`subscribeQueues` chunks the queues into batches of `subsBatchSize` (1350 by default) and calls
+`subscribeSessQueues_` per batch. `activeSubs` grows as the resubscription proceeds, so batch *k*
+folds roughly *k* × 1350 entries: resubscribing *N* queues in one session costs on the order of
+*N²* / 2700 entry traversals, and allocates a `Set` of up to *N* elements per batch.
+
+For a session holding 50k queues that is ~0.9M traversals per resubscription and ~37 sets of up
+to 50k elements — tens of MB of short-lived allocation, repeated for each session. Under the
+non-moving collector this allocation is also promotion pressure, which is what makes a
+reconnection storm visible as resident memory rather than only as CPU.
+
+Sessions are keyed `(userId, server, Nothing)` in `TSMSession` mode, so a client with many
+connections concentrates its queues into few sessions and hits the worst case rather than
+avoiding it.
+
+## Fix
+
+Maintain the connection index incrementally instead of deriving it per batch.
+
+`SessSubs` gains `activeConns :: TMap ConnId Int` alongside `activeSubs`, and `getActiveConns`
+reads it directly. `subscribeSessQueues_` then tests membership against that map.
+
+A connection can hold more than one subscribed queue, so the index counts them rather than
+storing a set: `incActiveConn` on a queue becoming active, `decActiveConn` when it stops, and the
+entry is removed when its count reaches zero. That keeps "connection has at least one active
+subscription" exact under partial subscription and partial failure.
+
+It is maintained at every site that mutates `activeSubs`, and nowhere else:
+
+| site | change |
+|---|---|
+| `addActiveSub'` | increments, but only when the queue was not already active |
+| `batchAddActiveSubs` | increments for the queues actually added (`M.difference` against the previous map) |
+| `deleteSub` | decrements for the queue if it was active |
+| `batchDeleteSubs` | decrements for the removed queues that were active (`M.restrictKeys`) |
+| `setSubsPending_` | clears the index with `activeSubs`, since all subscriptions become pending |
+
+The guards matter: re-adding an already-active queue, or deleting one that was only pending,
+must not move the count, otherwise the index drifts from `activeSubs` and connections are
+reported `UP` twice or not at all.
+
+## Behaviour
+
+Unchanged. The same connections are reported `UP`, and the session-closing condition that
+previously tested `S.null cs` now tests `M.null cs` over the same information.
@@ -1,80 +0,0 @@
-# Parallel test execution
-
-Every test gets its own ports, directory and Postgres schemas, so hspec runs
-the tree concurrently in one process with `parallel` and `--jobs`.
-
-## Decisions
-
- `Util` defines the test environment:
-
-  ```haskell
-  data TestEnv = TestEnv
-    { testNo :: Int,
-      portBase :: Int
-    }
-
-  type HasTestEnv = (?testEnv :: TestEnv)
-  ```
-
- `Util.it`, `fit` and `xit` take `HasTestEnv => a`. The test wrapper
-  creates the environment for each attempt, so a CI retry gets fresh ports,
-  directory and schemas.
- Environment creation:
-  - `testNo` from a counter, never reused in a run.
-  - `portBase` from a pool `[10000, 10010 .. 19990]`, returned after the test.
-  - directory `tests/tmp/<testNo>` with `xftp-sender-files` and
-    `xftp-recipient-files`, removed after the test.
- Fixture constants become `HasTestEnv =>` values:
-  - ports: offsets from `portBase`
-
-    | offset | fixture         |
-    |--------|-----------------|
-    | 1      | `testPort`      |
-    | 2      | `testPort2`     |
-    | 3      | `ntfTestPort`   |
-    | 4      | `ntfTestPort2`  |
-    | 5      | `apnsTestPort`  |
-    | 6      | `xftpTestPort`  |
-    | 7      | `xftpTestPort2` |
-
-  - server addresses: built from the ports.
-  - files: in the test directory.
-  - Postgres schemas: `test<testNo>_<name>`.
- Functions that use fixtures gain `HasTestEnv` in their signatures.
- `withXFTPServerCfg` creates the server files directory.
- Removed hooks:
-  - `tests/tmp` creation and removal per test.
-  - per-test database recreation and schema drops.
-  - XFTP `testBracket` and server files directory hooks.
-  - `around (withMsgStore cfg)`: each test opens its store.
- `tests/tmp` is cleared before the run and removed after it.
- Postgres databases are created before the run and dropped after it.
- Schema dumps and the Ntf CLI test keep the production schema names and
-  recreate the database per test.
- Sequential, after all parallel tests:
-  - SMP proxy tests that change the number of capabilities.
-  - XFTP CLI tests: `withArgs` and stdout capture are process-wide.
-  - server CLI tests: the same, and fixed ports.
-  - tests with wall-clock assertions:
-    - retry intervals
-    - AUTH error timing
-    - agent user network info
-    - agent SMP queue info
-    - agent client notices
-  - schema dumps.
- The SQLite agent schema dump resets `tests/tmp` after each item.
- `createRandomFile_` in the XFTP agent tests writes random bytes directly.
- Test suite `-with-rtsopts=-N1` becomes `-with-rtsopts=-N`.
- `it "..." . f $ x` becomes `it "..." $ f $ x` where `f` or `x` uses the
-  environment.
-
-## Mechanics
-
- `tests/Util.hs`: environment, wrapper, `it`, `fit`, `xit`,
-  `eventuallyRemove`, sender and recipient directories.
- `tests/Test.hs`: `parallel` tree, sequential tail, `tests/tmp` and database
-  brackets around `hspec`.
- `tests/SMPClient.hs`, `tests/SMPAgentClient.hs`, `tests/NtfClient.hs`,
-  `tests/XFTPClient.hs`, `tests/Fixtures.hs`: fixtures from the environment.
- Test modules: signatures, literal paths and ports, removed hooks.
- `simplexmq.cabal`: `-N`.
@@ -1,62 +0,0 @@
-# Fast rotation: draining the old receive queue
-
-Recipient only. The sender is unchanged.
-
-## Decisions
-
- New `RcvSwitchStatus` value:
-
-  | constructor      | encoding        |
-  |------------------|-----------------|
-  | `RSReceivedQEND` | `received_qend` |
-
-  - Stored in `rcv_queues.switch_status`.
-  - `canAbortRcvSwitch` returns `False` for it.
- `qEndMsg`, by the queue that delivered `QEND`:
-  - the queue named in `QEND`: the named queue is marked deleted, `ICDeleteRcvQueue` is enqueued.
-  - the new queue: the named queue is set to `RSReceivedQEND` and stays subscribed.
-  - `NSCCreate` and `SWITCH QDRcv SPCompleted`: sent when the named queue had no `RSReceivedQEND`.
- Deletion of an `RSReceivedQEND` queue:
-  - trigger: `OK` response to an `ACK` on that queue, without a `GET` lock on it.
-  - action: the queue is marked deleted, `ICDeleteRcvQueue` is enqueued.
- Bound, a `cleanupManager` step, for each connection with an `RSReceivedQEND` queue:
-  - condition: another receive queue of the connection has an active subscription.
-  - `delete_errors + 1 < deleteErrorCount`: `delete_errors` is incremented.
-  - otherwise: the queue is deleted as above; the first `DEL` error of `ICDeleteRcvQueue` removes it locally.
- `ackSMPMessage` result, `type QueueDrained = Bool`:
-  - `OK`: `True`.
-  - `MSG`: `False`; the message is written to `msgQ`.
- Apps: `received_qend` is added to `RcvSwitchStatus`.
- Migration `20261008_rcv_switch_status`, SQLite and Postgres:
-  - up: index `idx_rcv_queues_switch_status` on `rcv_queues(switch_status)`.
-  - down: `received_qend` is set to `NULL`, the index is dropped.
-
-## Mechanics
-
- `Agent/Protocol.hs`: `RSReceivedQEND`.
- `Agent/Store.hs`: `canAbortRcvSwitch`.
- `Client.hs`: `QueueDrained`; `ackSMPMessage` returns it.
- `Agent/Client.hs`: `sendAck` returns `QueueDrained`.
- `Agent/Store/AgentStore.hs`: `getEndedRcvQueueConnIds`:
-
-  ```sql
-  SELECT conn_id FROM rcv_queues WHERE switch_status = ? AND deleted = 0
-  ```
-
- `Agent.hs`:
-  - `deleteRcvQueueAsync`: `setRcvQueueDeleted`, then `ICDeleteRcvQueue`.
-  - `qEndMsg`.
-  - `ackQueueMessage`.
-  - `cleanupManager`: `expireEndedRcvQueues`.
- Apps:
-  - `apps/ios/SimpleXChat/APITypes.swift`
-  - `apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt`
-
-## Tests
-
- `QEND` on the new queue while a message waits on the old queue:
-  - the message is delivered;
-  - the old queue is deleted after the `ACK` that returns `OK`.
- The same with a recipient restart before the `ACK`.
- Old server stopped: the old queue is deleted by the bound.
- Downgrade: `received_qend` is cleared, other switch statuses are kept.
@@ -1,52 +0,0 @@
-# Delayed AUTH error responses
-
-## Decisions
-
- Responses that include `ERR AUTH` are sent at the next multiple of the delay after the start time.
- Delayed response sets:
-
-  | Source | Responses sent together | Start time |
-  |---|---|---|
-  | `receive`, failed verification | verification and parsing errors of one received block | block receipt |
-  | `client`, command processing | responses and messages of one batch | batch read from `rcvQ` |
-  | `RFWD`, forwarded command | the `RRES` of that command | start of forwarded command processing |
-
- A thread created by `forkClient` writes the responses to the send queue.
- Delay 0: the responses are written to the send queue directly.
- `authDelayExceeded`: incremented when processing took longer than the delay.
-  - Prometheus counter `simplex_smp_auth_delay_exceeded`.
-  - Not saved in the stats backup.
-  - Not in the daily stats log.
- Configuration:
-
-  | Item | Value |
-  |---|---|
-  | INI section | `TRANSPORT` |
-  | INI key | `auth_error_delay_ms` |
-  | default | 50 |
-  | `ServerConfig` field | `authErrorDelay`, microseconds |
-  | test servers | 20 ms |
-
- AUTH timing test: elapsed time of 5 requests, test servers' delay.
- Out of scope: NTF and XFTP servers.
-
-## Mechanics
-
- `Server.hs`:
-  - `isAuthError`: response is `ERR AUTH`.
-  - `sendResponses`: responses with `ERR AUTH` to `sendAfterDelay`, others to the send queue.
-  - `sendAfterDelay`: writes responses to the send queue at the next multiple of the delay.
-  - `receive`: block receipt time from the `rcvActiveAt` reading.
-  - `client`: batch time.
-  - `processForwardedCommand`: start time.
- `Server/Env/STM.hs`: `authErrorDelay` field, `defaultAuthErrorDelayMs`.
- `Server/Stats.hs`: `authDelayExceeded` in `ServerStats` and `ServerStatsData`.
- `Server/Prometheus.hs`: `simplex_smp_auth_delay_exceeded`.
- `Server/Main.hs`: INI value.
- `Server/Main/Init.hs`: INI template line.
- `simplexmq.cabal`: `timeit` removed from the test suite.
- `tests/SMPClient.hs`: `authErrorDelay = 20000`.
- `tests/ServerTests.hs`:
-  - delayed AUTH for wrong key, absent queue, absent link and suspended queue; immediate `SOK`.
-  - AUTH timing test measures elapsed time.
- `tests/SMPProxyTests.hs`: delayed AUTH to forwarded `SEND` and `LGET`.
@@ -85,7 +85,7 @@ SMP agent protocol has 2 main parts:

 ![Duplex connection procedure](./diagrams/duplex-messaging/duplex-creating.svg)

-The procedure of establishing a duplex connection is explained on the example of Alice (the initiating party) and Bob (the joining party) creating a bi-directional connection consisting of two unidirectional (simplex) queues, using SMP agents (A and B) to facilitate it, and two different SMP routers (which could be the same router). It is shown on the diagram above and has these steps:
+The procedure of establishing a duplex connection is explained on the example of Alice and Bob creating a bi-directional connection consisting of two unidirectional (simplex) queues, using SMP agents (A and B) to facilitate it, and two different SMP routers (which could be the same router). It is shown on the diagram above and has these steps:

 1. Alice requests the new connection from the SMP agent A using agent `createConnection` api function.
 2. Agent A creates an SMP queue on the router (using [SMP protocol](./simplex-messaging.md) `NEW` command) and responds to Alice with the invitation that contains queue information and the encryption keys Bob's agent B should use. The invitation format is described in [Connection link](connection-link-1-time-invitation-and-contact-address).
@@ -208,7 +208,7 @@ This syntax of decrypted SMP client message body is defined by `decryptedAgentMe
 Decrypted SMP message client body can be one of 4 types:
 - `agentConnInfo` - used by the initiating party when confirming reply queue - sent in `agentConfirmation` envelope.
 - `agentConnInfoReply` - used by accepting party, includes reply queue(s) in the initial confirmation - sent in `agentConfirmation` envelope.
- `agentRatchetInfo` - used to pass additional information when renegotiating double ratchet encryption - sent in `agentRatchetKey` envelope. A key sent in reply to another key includes the hash of that key; agents do not reply to such keys.
+- `agentRatchetInfo` - used to pass additional information when renegotiating double ratchet encryption - sent in `agentRatchetKey` envelope.
 - `agentMessage` - all other agent messages.

 `agentMessage` contains these parts:
@@ -233,8 +233,7 @@ connInfo = *OCTET
 agentConnInfoReply = %s"D" smpQueues connInfo
 smpQueues = length 1*newQueueInfo ; NonEmpty list of reply queues
 agentRatchetInfo = %s"R" ratchetInfo
-ratchetInfo = [answeredKeyHash *OCTET] ; bytes after answeredKeyHash are ignored
-answeredKeyHash = %s"0" / (%s"1" shortString) ; "0" in a key that starts renegotiation, otherwise SHA-256 of the two raw public keys of the answered key
+ratchetInfo = *OCTET

 agentMessage = %s"M" agentMsgHeader aMessage
 agentMsgHeader = agentMsgId prevMsgHash
@@ -1,189 +0,0 @@
-Revision 1, 2026-10-01
-
-# SimpleX Network: cryptographic primitive registry
-
-The cryptographic primitives, constructions and domain-separation strings used by this repository, and which of them new code may use. For the threat model see [Security](./security.md).
-
-Module aliases follow the codebase: `C` = [Simplex.Messaging.Crypto](../src/Simplex/Messaging/Crypto.hs), `LC` = [Crypto.Lazy](../src/Simplex/Messaging/Crypto/Lazy.hs), `CR` = [Crypto.Ratchet](../src/Simplex/Messaging/Crypto/Ratchet.hs), `SL` = [Crypto.ShortLink](../src/Simplex/Messaging/Crypto/ShortLink.hs), `KEM` = [Crypto.SNTRUP761](../src/Simplex/Messaging/Crypto/SNTRUP761.hs) and [its bindings](../src/Simplex/Messaging/Crypto/SNTRUP761/Bindings.hs), `BBS` = [Crypto.BBS](../src/Simplex/Messaging/Crypto/BBS.hs). Lengths are in bytes.
-
-## Table of contents
-
- [Policy](#policy)
- [Defaults for new code](#defaults-for-new-code)
- [Primitives](#primitives)
- [SimpleX box constructions](#simplex-box-constructions)
- [Domain separation and KDF inputs](#domain-separation-and-kdf-inputs)
- [Nonces and IVs](#nonces-and-ivs)
- [Implementation sources](#implementation-sources)
- [xftp-web (TypeScript)](#xftp-web-typescript)
- [Tests](#tests)
-
-## Policy
-
- New code uses the default primitive for its purpose from [Defaults for new code](#defaults-for-new-code).
- Using any other primitive, or a primitive marked *restricted* outside its listed purpose, requires a written justification in the pull request and review by a maintainer responsible for cryptography.
- *Legacy-only* primitives stay only for the existing wire formats and stored data listed below. Do not add call sites.
- Every new HKDF info string or hash prefix must be unique, start with `SimpleX`, and be added to [Domain separation and KDF inputs](#domain-separation-and-kdf-inputs).
- Changing a primitive, key length, KDF input, info string or nonce construction changes the wire format. It requires a protocol version and an update of this registry and of the affected `protocol/` specification.
-
-Status values used below:
-
-| Status | Meaning |
-|---|---|
-| Default | Approved and preferred for new code for this purpose |
-| Approved | Approved for new code for this purpose when the default does not fit |
-| Restricted | Approved only for the listed purpose (external interoperability or a single protocol) |
-| Legacy-only | Kept for existing wire formats or stored data; no new call sites |
-
-## Defaults for new code
-
-| Purpose | Default | Functions |
-|---|---|---|
-| Signature | Ed25519 | `C.sign'`, `C.verify'` with `C.SEd25519` |
-| Key agreement | X25519 | `C.generateKeyPair`, `C.dh'` |
-| Post-quantum KEM | sntrup761 | `KEM.sntrup761Keypair`, `sntrup761Enc`, `sntrup761Dec` |
-| Hybrid DH + KEM secret | HKDF-SHA512 over `dh \|\| kemSecret` with a new info string, as in `CR.rootKdf` | `C.hkdf` |
-| Authenticated encryption | XSalsa20-Poly1305 [SimpleX secretbox](#simplex-box-constructions) | `C.sbEncrypt`/`C.sbDecrypt`, `LC.sbEncryptTailTag` for streams |
-| Authenticated encryption with a DH secret | XSalsa20-Poly1305 [SimpleX crypto_box](#simplex-box-constructions) | `C.cbEncrypt`/`C.cbDecrypt` |
-| Forward-secret symmetric session | HKDF-SHA512 key chain | `C.sbcInit`, `C.sbcHkdf` |
-| KDF | HKDF-SHA512 | `C.hkdf` |
-| Hash commitment, derived identifier | SHA3-256 | `C.sha3_256` |
-| Certificate fingerprint | SHA-256 X.509 fingerprint | `C.signedFingerprint`, `C.certificateFingerprint` |
-| Randomness | ChaChaDRG seeded from system entropy | `C.newRandom`, `C.randomBytes` and the `random*` helpers |
-
-## Primitives
-
-| Primitive | Status | Purpose and protocol | Implementation | Lengths |
-|---|---|---|---|---|
-| Ed25519 | Default | SMP/NTF/XFTP queue and file keys (agent default `rcvAuthAlg`, `sndAuthAlg` in [Agent/Env/SQLite.hs](../src/Simplex/Messaging/Agent/Env/SQLite.hs)), short-link signatures and owner auth (`SL.encodeSign`, `SL.newOwnerAuth`), XRCP identity and session keys ([RemoteControl/Invitation.hs](../src/Simplex/RemoteControl/Invitation.hs)), agent service request signatures, client/service TLS certificates ([Transport/Credentials.hs](../src/Simplex/Messaging/Transport/Credentials.hs)) | crypton `Crypto.PubKey.Ed25519` via `C.sign'`/`C.verify'` | pub 32, priv 32, sig 64; X.509 SPKI 44 |
-| Ed448 | Approved | Server CA and online certificates (default `signAlgorithm = ED448` in [Server/CLI.hs](../src/Simplex/Messaging/Server/CLI.hs)); accepted for SMP command signatures and TLS | crypton `Crypto.PubKey.Ed448`; server key generation by the `openssl genpkey` CLI | pub 57, priv 57, sig 114; SPKI 69 |
-| X25519 | Default | Per-queue e2e and server-to-recipient `crypto_box` keys, SMP session DH, command authenticator (SMP v7+), proxy (PRXY/PFWD), notification tokens, XFTP chunk transport, XRCP hello and announcements | crypton `Crypto.PubKey.Curve25519` via `C.dh'` | pub 32, priv 32, secret 32; SPKI 44 |
-| X448 | Restricted | E2E double ratchet only: X3DH and DH ratchet (`CR.RatchetX448`, E2E v3) | crypton `Crypto.PubKey.Curve448` | pub 56, priv 56, secret 56 |
-| sntrup761 | Default | PQ KEM in double ratchet (E2E v3, agent v5+) and XRCP v1 hello | Vendored C [cbits/sntrup761.c](../cbits/sntrup761.c) via FFI; randomness from ChaChaDRG through `haskell_rng_func` ([Bindings/RNG.hs](../src/Simplex/Messaging/Crypto/SNTRUP761/Bindings/RNG.hs)) | pk 1158, sk 1763, ct 1039, shared 32 |
-| XSalsa20-Poly1305, SimpleX crypto_box | Default | SMP message bodies (server to recipient), per-queue e2e envelope, confirmations, proxy forwarding, notifications, XRCP hello, XFTP chunk transport | crypton `Crypto.Cipher.XSalsa`, `Crypto.MAC.Poly1305`; `C.cryptoBox`, `LC.cbInit` | key 32 (DH secret), nonce 24, tag 16 |
-| XSalsa20-Poly1305, SimpleX secretbox | Default | SMP transport block encryption (SMP v11+), short-link data (SMP v15+), XFTP file encryption, local file encryption ([Crypto/File.hs](../src/Simplex/Messaging/Crypto/File.hs)), XRCP session | same; `C.sbEncrypt`, `LC.sbEncryptTailTag`, `LC.sbInit` | key 32, nonce 24, tag 16 |
-| crypto_box authenticator | Approved | Deniable sender command authorization with X25519 queue keys (SMP v7+); agent currently creates Ed25519 keys | `C.cbAuthenticate`, `C.cbVerify`: `crypto_box(sha512(msg))` | 80 = 64 + 16 |
-| AES-256-GCM, 16-byte IV | Legacy-only | Double ratchet header and body (E2E v3, [pqdr.md](./pqdr.md)) | crypton `Crypto.Cipher.AES`, `Crypto.Cipher.Types`; `C.encryptAEAD`, `C.decryptAEAD`, `C.initAEAD`; J0 = GHASH(IV) as NIST SP 800-38D defines for non-96-bit IVs | key 32, IV 16, tag 16; padded header 88 (PQ off) or 2310 (PQ on), `CR.paddedHeaderLen` |
-| AES-256-GCM, 12-byte IV | Restricted | WebRTC frame encryption in simplex-chat (`Simplex.Chat.Mobile.WebRTC`), for WebCrypto interoperability | `C.encryptAESNoPad`, `C.decryptAESNoPad`, `C.initAEADGCM`, `C.GCMIV` | key 32, IV 12, tag 16 |
-| HKDF-SHA512 | Default | All KDFs listed in [Domain separation](#domain-separation-and-kdf-inputs) | crypton `Crypto.KDF.HKDF` with `SHA512`; `C.hkdf` (extract + expand) | output per use, at most 255 * 64 |
-| SHA-256 | Default for X.509 fingerprints, otherwise Restricted | X.509 fingerprints (`C.KeyHash`, server identity, XRCP CA, service certificate hash, SMP v16+), XFTP chunk digests, agent message hashes, `requestCode`, ratchet key dedup hash, security code `codeAD = sha256(rcAD)` | crypton; `C.sha256Hash`, `LC.sha256Hash`, `getFingerprint ... HashSHA256` | 32 |
-| SHA-512 | Restricted | XFTP file digests and file description hash, input of the crypto_box authenticator | crypton; `C.sha512Hash`, `LC.sha512Hash` | 64 |
-| SHA-512 (inside sntrup761) | Restricted | sntrup761 internal hash | [cbits/sha512.c](../cbits/sha512.c) calls OpenSSL `SHA512()` from the system `libcrypto` (`extra-libraries: crypto`) | 64 |
-| SHA3-256 | Default | Short-link key `sha3_256(fixedData)` (SMP v15+), XRCP hybrid secret, service request binding (agent v8) | crypton; `C.sha3_256`, `KEM.kemHybridSecret` | 32 |
-| SHA3-384 | Restricted | Client-supplied sender ID: first 24 bytes of `sha3_384(corrId)`, computed by the agent (`prepareConnectionLink'`, `newRcvConnSrv`) and the server (`createQueue`) | crypton; `C.sha3_384` | 48, truncated to 24 |
-| Keccak-256 | Restricted | Label hash for SMP name queries (`NameQuery NQHash`), must match the on-chain registry | crypton `Keccak_256`; `labelHash` in [SimplexName.hs](../src/Simplex/Messaging/SimplexName.hs) | 32 |
-| MD5 | Legacy-only, non-security | XOR-aggregated queue ID hash `IdsHash` for service subscription reconciliation (SUBS, NSUBS, SOKS, ENDS) | crypton (`C.md5Hash`, `Protocol.queueIdHash`); SQLite UDF `simplex_xor_md5_combine` ([Agent/Store/SQLite.hs](../src/Simplex/Messaging/Agent/Store/SQLite.hs)); PostgreSQL pgcrypto `digest(..., 'md5')` in server and NTF schemas | 16 |
-| ChaChaDRG | Default | Keys, nonces, correlation IDs, random IDs, sntrup761 randomness | crypton `Crypto.Random`; `C.newRandom` seeds with `drgNew` from system entropy | n/a |
-| BBS+ over BLS12-381, SHA-256 suite | Restricted | Badge entitlement credentials and proofs ([Crypto/Entitlement.hs](../src/Simplex/Messaging/Crypto/Entitlement.hs)), XFTP storage-time extension | Vendored submodules libbbs and blst (C and assembly) via FFI; randomness from libbbs `getentropy`, `SecRandomCopyBytes` with the `commoncrypto` flag, `BCryptGenRandom` on Windows ([cbits/getentropy_win.c](../cbits/getentropy_win.c)) | sk 32, pk 96, sig 80, proof 272 + 32 per undisclosed message |
-| ECDSA with SHA-256 (ES256) | Restricted | APNS provider JWT ([Push/APNS.hs](../src/Simplex/Messaging/Notifications/Server/Push/APNS.hs)) | crypton `Crypto.PubKey.ECC.ECDSA.sign`; key read by cryptostore `Crypto.Store.PKCS8`; curve taken from the key file | signature DER `SEQUENCE {r, s}`, base64url |
-| TLS 1.3 / 1.2 | Restricted | SMP, XFTP, NTF, XRCP transport: `TLS_CHACHA20_POLY1305_SHA256` (1.3), `ECDHE_ECDSA_CHACHA20POLY1305_SHA256` (1.2), groups X448 and X25519, Ed448 and Ed25519 signatures (`defaultSupportedParams`) | `tls` 1.9 | n/a |
-| TLS for browsers | Restricted | XFTP server with HTTPS credentials (`defaultSupportedParamsHTTPS`: `ciphersuite_strong`, FFDHE, P-521, ECDSA and RSA signatures); SMP server HTTPS requires RSA-4096 (`checkHTTPSCredentials`) | `tls`, `warp-tls` | n/a |
-| X.509 | Restricted | Certificate chains, fingerprints, signed session keys (`C.signX509`, `C.verifyX509`) | `crypton-x509`, `crypton-x509-validation`, `cryptostore` | n/a |
-| SQLCipher | Restricted | Agent SQLite database at rest (`PRAGMA key`); cipher parameters are SQLCipher defaults, not set in this repository | `direct-sqlcipher` (git dependency, [cabal.project](../cabal.project)) | n/a |
-
-## SimpleX box constructions
-
-`C.cryptoBox` and `LC.sbInit_` compute, for a 32-byte key `k` and 24-byte nonce `n`:
-
-```
-k1 = HSalsa20(k, 0^16)
-subkey = HSalsa20(k1, n[0..16])
-stream = Salsa20(subkey, n[16..24])
-polyKey = stream[0..32]
-ct = msg XOR stream[32..]
-tag = Poly1305(polyKey, ct)
-```
-
-| Construction | Key `k` | Equivalent libsodium call | Layout |
-|---|---|---|---|
-| SimpleX crypto_box (`C.cbEncrypt`, `LC.cbInit`) | X25519 shared secret | `crypto_box_easy` (`crypto_box_beforenm` is `HSalsa20(dh, 0^16)`) | strict: `tag \|\| ct`; lazy tail-tag: `ct \|\| tag` |
-| SimpleX secretbox (`C.sbEncrypt`, `LC.sbInit`, `KEM.kcb*`) | 32-byte symmetric key | `crypto_secretbox_easy` with key `crypto_core_hsalsa20(0^16, k)`, not with `k` | same |
-
-Padding before encryption: `C.pad` prefixes a 2-byte big-endian length and fills with `#` (message at most 65533 bytes); `LC.pad` prefixes an 8-byte length. `*NoPad` variants skip padding.
-
-## Domain separation and KDF inputs
-
-HKDF is `C.hkdf salt ikm info len` (HKDF-SHA512).
-
-| Info string | Salt | IKM | Output (split) | Function | Use |
-|---|---|---|---|---|---|
-| `"SimpleXX3DH"` | 64 zero bytes | `dh1 \|\| dh2 \|\| dh3 [\|\| kemShared]` | 96: `hk`, `nhk`, root key (32 each) | `CR.pqX3dh` | Ratchet initialization, added in E2E v2; KEM secret from E2E v3 (current minimum) |
-| `"SimpleXVerifyCode"` | 64 zero bytes | same as `SimpleXX3DH` | 32: `rcVCPQ` | `CR.pqX3dh` | Verification code covering all handshake keys, new ratchets |
-| `"SimpleXRootRatchet"` | root key | `dh [\|\| kemShared]` | 96: root key, chain key, next header key | `CR.rootKdf` | DH/PQ ratchet step |
-| `"SimpleXChainRatchet"` | empty | chain key | 96: chain key, message key (32 each), message IV (16), header IV (16) | `CR.chainKdf` | Per-message keys |
-| `"SimpleXSbChainInit"` | SMP session ID | X25519 session secret | 64: two 32-byte chain keys | `C.sbcInit` from `Transport.blockEncryption` | SMP transport block encryption, SMP v11+ |
-| `"SimpleXSbChainInit"` | empty | XRCP hybrid secret (below) | 64: two 32-byte chain keys | `C.sbcInit` in [RemoteControl/Client.hs](../src/Simplex/RemoteControl/Client.hs) | XRCP v1 session |
-| `"SimpleXSbChain"` | empty | chain key | 88: chain key (32), secretbox key (32), nonce (24) | `C.sbcHkdf` | Each SMP block and XRCP message |
-| `"SimpleXContactLink"` | empty | link key (32) | 56: link ID (24), secretbox key (32) | `SL.contactShortLinkKdf` | Contact short links, SMP v15+ |
-| `"SimpleXInvLink"` | empty | link key (32) | 32: secretbox key | `SL.invShortLinkKdf` | Invitation short links, SMP v15+ |
-
-Other derivations:
-
-| Value | Construction | Function | Use |
-|---|---|---|---|
-| Service request binding | `sha3_256("SimpleXService" \|\| rcAD)` | `serviceReqBinding` in [Agent.hs](../src/Simplex/Messaging/Agent.hs) | Agent RPC, agent v8 |
-| BBS header | `"SimpleX badges v1"` | `entitlementBBSHeader` | Badge credentials |
-| XRCP hybrid secret | `sha3_256(x25519Dh \|\| kemShared)` | `KEM.kemHybridSecret` | XRCP v1 |
-| Short-link key | `sha3_256(smpEncode FixedLinkData)` | `SL.encodeSignFixedData`, checked in `SL.decryptLinkData` | SMP v15+ |
-| Sender ID | `take 24 (sha3_384 corrId)` | `prepareConnectionLink'`, `newRcvConnSrv` in Agent.hs; `createQueue` in [Server.hs](../src/Simplex/Messaging/Server.hs) | Client-supplied sender ID with link data, SMP v15+; the server rejects a mismatch to prevent an ID oracle |
-| Ratchet associated data | `pubKeyBytes sk1 \|\| pubKeyBytes rk1` (raw X448, 112) | `CR.pqX3dh` | AD of every ratchet AEAD |
-| Security code | `sha256(rcAD)` | `ratchetVerifyCodes` in [AgentStore.hs](../src/Simplex/Messaging/Agent/Store/AgentStore.hs) | Connection verification |
-| Contact request code | `sha256(smpEncode (k1, k2, kem, sndId))` | `requestCode` in Agent.hs | Contact request binding |
-| Command authenticator | `crypto_box(sha512(authorized))` | `C.cbAuthenticate` | SMP v7+ |
-| Queue IDs hash | `xor` of `md5(queueId)` | `Protocol.queueIdsHash` | Service subscriptions |
-
-`"SimpleXSbChainInit"` and `"SimpleXSbChain"` are shared by SMP block encryption and XRCP. Their outputs are separated only by the IKM (and the salt for `sbcInit`).
-
-## Nonces and IVs
-
-| Use | Construction |
-|---|---|
-| SMP command authenticator, proxied command | `C.cbNonce corrId`, where `corrId` is a random 24-byte nonce (`C.randomCbNonce`) |
-| SMP proxied responses | `C.reverseNonce` of the request nonce |
-| Server-to-recipient message body | `C.cbNonce msgId`; `msgIdBytes = 24` in [Server/Main.hs](../src/Simplex/Messaging/Server/Main.hs) |
-| Per-queue e2e envelope, short-link data, notifications, XRCP hello, XFTP chunk download | Random 24-byte nonce, sent with the ciphertext |
-| XFTP file, local encrypted file | Random key and nonce per file (`C.randomSbKey`, `C.randomCbNonce`) |
-| SMP block, XRCP session messages | Key and nonce from `C.sbcHkdf`, one per block |
-| Ratchet header, body | 16-byte IVs from `CR.chainKdf`; header IV is sent, body IV is not |
-| WebRTC frames | 12-byte `C.GCMIV` supplied by the caller in simplex-chat |
-
-## Implementation sources
-
-| Source | Version or pin | Provides |
-|---|---|---|
-| crypton | 0.34 | Ed25519, Ed448, X25519, X448, XSalsa20, Poly1305, AES-GCM, HKDF, SHA-2, SHA-3, Keccak, MD5, ChaChaDRG, ECDSA |
-| tls, crypton-x509, crypton-x509-validation, cryptostore | 1.9.0, 1.7.6, 1.6.12, 0.3.0.1 | TLS, X.509, PKCS#8 |
-| [cbits/sntrup761.c](../cbits/sntrup761.c) | Copy of draft-josefsson-ntruprime-streamlined-00 ([cbits/README.md](../cbits/README.md)) | sntrup761 |
-| [cbits/sha512.c](../cbits/sha512.c) and system OpenSSL `libcrypto` | system | SHA-512 for sntrup761 |
-| `cbits/libbbs` submodule ([simplex-chat/libbbs](https://github.com/simplex-chat/libbbs)) | `59a0f4bf` | BBS+ (`bbs_sha256_ciphersuite`), SHA-256, SHAKE256 |
-| `cbits/blst` submodule ([supranational/blst](https://github.com/supranational/blst)) | `db3defd0` | BLS12-381 (C and `build/assembly.S`, `-D__BLST_PORTABLE__`) |
-| direct-sqlcipher | git `f814ee68` | SQLCipher |
-| `openssl` CLI | system | Server CA and certificate key generation (`createServerX509_`) |
-
-## xftp-web (TypeScript)
-
-[xftp-web](../xftp-web/) reimplements a subset for the browser XFTP client. It has no AES-GCM, HKDF, SHA-3, MD5, X448 or sntrup761 code.
-
-| Primitive | Implementation | Haskell counterpart |
-|---|---|---|
-| Ed25519 sign, verify, keys | libsodium-wrappers-sumo (`crypto_sign_*`), [src/crypto/keys.ts](../xftp-web/src/crypto/keys.ts) | `C.sign'`, `C.verify'` |
-| Ed448 verify | `@noble/curves/ed448`, keys.ts `verifyEd448` | `C.verify'` |
-| X25519 | libsodium `crypto_scalarmult`, `crypto_box_keypair` | `C.dh'` |
-| SimpleX crypto_box, secretbox, tail-tag streaming | Salsa20 block function written in TypeScript, libsodium `crypto_core_hsalsa20` and `crypto_onetimeauth_*`, [src/crypto/secretbox.ts](../xftp-web/src/crypto/secretbox.ts) | `C.cryptoBox`, `LC.sbInit_` |
-| crypto_box authenticator | [src/protocol/client.ts](../xftp-web/src/protocol/client.ts) `cbAuthenticate`, `cbVerify` | `C.cbAuthenticate`, `C.cbVerify` |
-| SHA-256, SHA-512 | libsodium `crypto_hash_sha256`, `crypto_hash_sha512*`, [src/crypto/digest.ts](../xftp-web/src/crypto/digest.ts) | `C.sha256Hash`, `C.sha512Hash` |
-| Random | WebCrypto `crypto.getRandomValues`; libsodium for key generation | `C.randomBytes` |
-
-## Tests
-
-None of the tests below compares against published reference vectors (NIST, RFC 8032, RFC 7748, RFC 5869, NaCl, the sntrup761 draft or the BBS draft). Interoperability is tested between this repository's own implementations.
-
-| Area | Test module (hspec group) | Kind |
-|---|---|---|
-| Ed25519, Ed448, X25519 crypto_box, secretbox, lazy and tail-tag secretbox, AES-GCM 12-byte IV, X.509 key encoding, X.509 chains, sntrup761, BBS+, entitlements, padding | [tests/CoreTests/CryptoTests.hs](../tests/CoreTests/CryptoTests.hs) | Round-trip; fixed lengths for BBS+; fixed bytes for padding |
-| Double ratchet (X25519 and X448), PQ KEM agreement, AES-GCM 16-byte IV | [tests/AgentTests/DoubleRatchetTests.hs](../tests/AgentTests/DoubleRatchetTests.hs) | Round-trip; decoding of a stored v2 ratchet JSON |
-| Short links (HKDF info strings, SHA3-256 link key) | [tests/AgentTests/ShortLinkTests.hs](../tests/AgentTests/ShortLinkTests.hs) | Round-trip, tamper rejection |
-| File encryption | [tests/CoreTests/CryptoFileTests.hs](../tests/CoreTests/CryptoFileTests.hs) | Round-trip |
-| XRCP session (SHA3-256 hybrid, sb chain) | [tests/RemoteControl.hs](../tests/RemoteControl.hs) | End-to-end |
-| SMP authenticators, block encryption, `IdsHash` (MD5) | [tests/ServerTests.hs](../tests/ServerTests.hs) | End-to-end; with the PostgreSQL queue store this checks Haskell MD5 against pgcrypto |
-| Haskell and xftp-web: SHA-256/512, Ed25519, Ed448 identity proof, X25519, DER keys, crypto_box, secretbox, tail-tag, authenticator, file encryption | [tests/XFTPWebTests.hs](../tests/XFTPWebTests.hs) (`XFTP Web Client`) | Byte-identical cross-language output |
@@ -62,16 +62,14 @@ It is possible to reduce size overhead by using only one KEM agreement and makin

 ## Double ratchet with encrypted headers augmented with double PQ KEM

-Algorithm below assumes that in addition to shared secret from the initial key agreement, there will be an encapsulation key available from the initiating party, that sent its keys in the connection invitation to the joining party (see [agent protocol](./agent-protocol.md)). Following the double ratchet specification, the pseudo-code below names the joining party Alice and the initiating party Bob.
-
-Unlike X3DH prekey bundles, these keys are not reusable keys published for any party to use. The initiating party generates two X448 key pairs and, optionally, a sntrup761 KEM key pair for each connection, sends the public keys in the invitation, and deletes the stored private keys once the ratchet is initialized; only the second X448 private key and the agreed KEM key pair remain in the ratchet state as its initial ratchet keys. The joining party generates its keys when joining and keeps only its KEM key pair, in the ratchet state. The exception is a contact address that publishes ratchet keys in its link data: all requesters use these keys until the address owner rotates them, and the owner keeps the private keys of a few recent generations.
+Algorithm below assumes that in addition to shared secret from the initial key agreement, there will be an encapsulation key available from the party that published its keys (Bob).

 ### Initialization

 The double ratchet initialization is defined in pseudo-code. This pseudo-code is identical to Signal algorithm specification except for that parts that add post-quantum key agreement.

 ```
-// Alice (joining party) received Bob's keys in the invitation and initializes ratchet first
+// Alice obtained Bob's keys and initializes ratchet first
 def RatchetInitAlicePQ2HE(state, SK, bob_dh_public_key, shared_hka, shared_nhkb, bob_pq_kem_encapsulation_key):
    state.DHRs = GENERATE_DH()
    state.DHRr = bob_dh_public_key
@@ -91,7 +89,7 @@ def RatchetInitAlicePQ2HE(state, SK, bob_dh_public_key, shared_hka, shared_nhkb,
    state.HKr = None
    state.NHKr = shared_nhkb

-// Bob (initiating party) initializes ratchet second, having received Alice's first message
+// Bob initializes ratchet second, having received Alice's connection request
 def RatchetInitBobPQ2HE(state, SK, bob_dh_key_pair, shared_hka, shared_nhkb, bob_pq_kem_key_pair):
    state.DHRs = bob_dh_key_pair
    state.DHRr = None
@@ -212,8 +210,6 @@ The outer envelope contains the encrypted header (used as associated data for bo

 The message body is encrypted with AES-256-GCM using the message key derived from the sending chain key (`KDF_CK`). The associated data for body encryption is the concatenation of the ratchet associated data and the encoded encrypted header.

-`KDF_CK(CK)` is HKDF-SHA512 with empty salt, `CK` as input key material and info `"SimpleXChainRatchet"`, producing 96 bytes split into the next chain key (32 bytes), the message key (32 bytes), the message body IV (16 bytes, not transmitted) and `headerIV` (16 bytes). Both IVs are used as 16-byte AES-256-GCM IVs, not the 12-byte IVs recommended by NIST SP 800-38D, so the initial counter block is J0 = GHASH(IV || 0^64 || [128]_64) as defined there for non-96-bit IVs. WebCrypto and other conforming implementations compute it when given the full 16-byte IV; truncating the IV to 12 bytes produces different ciphertext.
-
 ```abnf
 encRatchetMessage = versionedLength encMessageHeader msgAuthTag encMsgBody
 ; encMessageHeader is used as associated data for body decryption: AD = rcAD || encMessageHeader
@@ -278,7 +274,7 @@ As SimpleX Messaging Protocol pads messages to a fixed size, using 16kb transpor

 Sharing the initial keys in case of SimpleX Chat it is equivalent to sharing the invitation link. As encapsulation key is large, it may be inconvenient to share it in the link in some contexts, e.g. when QR codes are used.

-It is possible to postpone sharing the encapsulation key until the first message from the joining party (confirmation message in SMP protocol). The upside here is that the invitation link size would not increase. The downside is that the user profile shared in this confirmation will not be encrypted with PQ-resistant algorithm.
+It is possible to postpone sharing the encapsulation key until the first message from Alice (confirmation message in SMP protocol), the party sending connection request. The upside here is that the invitation link size would not increase. The downside is that the user profile shared in this confirmation will not be encrypted with PQ-resistant algorithm.

 Another consideration is pairwise ratchets in groups. Key generation in sntrup761 is quite slow - on slow devices it can be as slow as 10-20 keys per second, so using this primitive in groups larger than 10-20 members would result in slow performance.

@@ -15,7 +15,7 @@ This document describes the cryptographic primitives and threat model for the Si
  - [SimpleX Messaging Protocol router that proxies the messages to another SMP router](#simplex-messaging-protocol-router-that-proxies-the-messages-to-another-smp-router)
  - [An attacker who obtained Alice's (decrypted) chat database](#an-attacker-who-obtained-alices-decrypted-chat-database)
  - [A user's contact](#a-users-contact)
-  - [An attacker who observes the initiating party showing an introduction message to the joining party](#an-attacker-who-observes-the-initiating-party-showing-an-introduction-message-to-the-joining-party)
+  - [An attacker who observes Alice showing an introduction message to Bob](#an-attacker-who-observes-alice-showing-an-introduction-message-to-bob)
  - [An attacker with Internet access](#an-attacker-with-internet-access)


@@ -37,8 +37,6 @@ This document describes the cryptographic primitives and threat model for the Si
  - AES-GCM AEAD cipher,
  - SHA512-based HKDF for key derivation.

-All primitives in use, their lengths, domain-separation strings and the policy for new code are listed in the [cryptographic primitive registry](./crypto-registry.md).
-

 ## Threat Model

@@ -192,15 +190,15 @@ All primitives in use, their lengths, domain-separation strings and the policy f

 - cannot collaborate with another of the user's contacts to confirm they are communicating with the same user.

-### An attacker who observes the initiating party showing an introduction message to the joining party
+### An attacker who observes Alice showing an introduction message to Bob

 *can:*

- Impersonate the joining party to the initiating party.
+- Impersonate Bob to Alice.

 *cannot:*

- Impersonate the initiating party to the joining party.
+- Impersonate Alice to Bob.

 ### An attacker with Internet access

@@ -86,7 +86,7 @@ It's designed with the focus on communication security and integrity, under the

 It is designed as a low level protocol for other application protocols to solve the problem of secure and private message transmission, making [MITM attack][1] very difficult at any part of the message transmission system.

-This document describes SMP protocol version 23. Versions 1-5 are discontinued. The version history:
+This document describes SMP protocol version 22. Versions 1-5 are discontinued. The version history:

 - v1: binary protocol encoding
 - v2: message flags (used to control notifications)
@@ -109,7 +109,6 @@ This document describes SMP protocol version 23. Versions 1-5 are discontinued.
 - v20: public namespaces resolver (RSLV command, RNAME response) — direct or forwarded via PFWD
 - v21: server public information in handshake
 - v22: `RNAME` says whether a name can be registered, not only what it resolves to
- v23: version in nonces of forwarded commands, random nonces for forwarded responses

 ## Introduction

@@ -1129,7 +1128,7 @@ The proxy router may respond with error response in case the destination router

 Sender can send `SKEY` and `SEND` commands via proxy after obtaining the session ID with `PRXY` command (see [Request proxied session](#request-proxied-session)).

-Transmission sent to proxy router should use session ID as entity ID and use a random correlation ID of 24 bytes as a nonce for crypto_box encryption of transmission to the destination router. When `smpVersion` in `PFWD` is 23 or higher, the first 2 bytes of this nonce are XOR-ed with `smpVersion`. The random ephemeral X25519 key to encrypt transmission should be unique per command, and it should be combined with the key sent by the router in the handshake header to proxy and to the client in `PKEY` command.
+Transmission sent to proxy router should use session ID as entity ID and use a random correlation ID of 24 bytes as a nonce for crypto_box encryption of transmission to the destination router. The random ephemeral X25519 key to encrypt transmission should be unique per command, and it should be combined with the key sent by the router in the handshake header to proxy and to the client in `PKEY` command.

 Encrypted transmission should use the received session ID from the connection between proxy router and destination router in the authorized body.

@@ -1141,11 +1140,10 @@ commandKey = length x509encoded

 The proxy router will forward the encrypted transmission in `RFWD` command (see below).

-Having received the `RRES` response from the destination router, proxy router will forward `PRES` response to the client. `PRES` response should use the same correlation ID as `PFWD` command. The destination router will use this correlation ID increased by 1 as a nonce for encryption of the response. When `smpVersion` in `PFWD` is 23 or higher, the destination router uses a random nonce instead, and sends it before the encrypted response.
+Having received the `RRES` response from the destination router, proxy router will forward `PRES` response to the client. `PRES` response should use the same correlation ID as `PFWD` command. The destination router will use this correlation ID increased by 1 as a nonce for encryption of the response.

 ```abnf
-proxyResponse = %s"PRES" SP [responseNonce] <encrypted padded(forwardedResponse, 16226)>
-responseNonce = %s"0" / (%s"1" 24*24 OCTET) ; from v23
+proxyResponse = %s"PRES" SP <encrypted padded(forwardedResponse, 16226)>
 forwardedResponse = *OCTET ; client-encrypted SMP response, decrypted by client using per-command DH secret
 ```

@@ -1172,7 +1170,7 @@ The shared secret for encrypting transmission bodies between proxy router and de


 ```abnf
-relayResponse = %s"RRES" SP [responseNonce] <encrypted(responseTransmission)>
+relayResponse = %s"RRES" SP <encrypted(responseTransmission)>
 responseTransmission = fwdCorrId forwardedResponse
  ; fwdCorrId and forwardedResponse defined above in RFWD section
 ```
@@ -71,7 +71,7 @@ The session invitation contains this data:

 Host application decrypts (except the first session) and validates the invitation:
 - Session signature is valid.
- Timestamp of a multicast announcement is not earlier than 3660 seconds before and not later than 3600 seconds after the current time of the host. The host ignores announcements outside of this interval and continues listening.
+- Timestamp is within some window from the current time.
 - Long-term key signature is valid.
 - Long-term CA and signature key are the same as in the first session.
 - Some version in the offered range is supported.
@@ -1,9 +0,0 @@
-#!/bin/sh
-set -eu
-
-version=$(awk '/^version:/ {print $2}' simplexmq.cabal)
-for dir in "$@"; do
-  if [ -d "$dir/build" ]; then
-    find "$dir/build" -mindepth 3 -maxdepth 3 -type d -name 'simplexmq-*' ! -name "simplexmq-$version" -exec rm -rf {} +
-  fi
-done
@@ -1,27 +0,0 @@
-#!/bin/sh
-set -eu
-
-command=$1
-hashes=$2
-
-sources() {
-  git ls-files -z '*.hs' '*.hsc'
-}
-
-case "$command" in
-  record)
-    sources | xargs -0 sha256sum > "$hashes"
-    ;;
-  restore)
-    sources | xargs -0 touch
-    while read -r hash file; do
-      if [ -f "$file" ] && [ "$(sha256sum "$file" | cut -d' ' -f1)" = "$hash" ]; then
-        touch -d 2000-01-01 "$file"
-      fi
-    done < "$hashes"
-    ;;
-  *)
-    echo "usage: $0 record|restore <hashes file>" >&2
-    exit 1
-    ;;
-esac
@@ -1,8 +1,5 @@
-# Copy to .env (next to docker-compose.yml) only to change a setting; without it
-# docker-compose.yml uses the values shown here.
-
 # ============================================================================
-# Chain settings.
+# Required settings — the stack will not start without these.
 # ============================================================================

 # Ethereum network: mainnet (the SNRC `.testing` contracts live on mainnet)
@@ -17,16 +14,9 @@ NETWORK=mainnet
 TRUSTED_NODE_URL=https://mainnet-checkpoint-sync.attestant.io

 # ============================================================================
-# Optional overrides — leave commented unless you need to change them.
+# Optional overrides — sensible defaults are baked into docker-compose.yml,
+# so leave these commented unless you need to change them.
 # ============================================================================

 # Nimbus NAT (default: any). For a stable public node set an explicit IP:
 #   NAT=extip:1.2.3.4        # your public IPv4: curl -s ifconfig.me
-
-# Resolver (defaults in the README's "Load and scaling" and "Logs" sections)
-#   SNRC_WORKERS=4                          # worker processes; default CPU count, at most 4
-#   SNRC_RPC_TIMEOUT=5                      # seconds per request to reth
-#   SNRC_LOG_FORMAT=json                    # default text (key=value)
-#   SNRC_LOG_COLOR=always                   # coloured `docker compose logs`
-#   SNRC_LOG_LEVEL=debug                    # also log health checks and idle connections
-#   SNRC_TRUSTED_PROXIES=172.16.0.0/12      # behind a reverse proxy on the host; see README
@@ -19,15 +19,15 @@ against **Ethereum mainnet** (where the `.testing` contracts live):

 ## 1. Configure

-The defaults in `docker-compose.yml` work as-is:
+Edit `.env` — the defaults work as-is; override only if needed:

 ```sh
 NETWORK=mainnet                                               # default
 TRUSTED_NODE_URL=https://mainnet-checkpoint-sync.attestant.io # default
 ```

-To override these or NAT, copy `.env.example` to `.env` and edit it; `.env` is
-not committed.
+Everything else (NAT) has a working default baked into `docker-compose.yml`;
+uncomment the hints in `.env` only to override.

 ## 2. Run

@@ -121,15 +121,6 @@ standalone for local dev (no Docker), via [`uv`](https://docs.astral.sh/uv/):
 uv run scripts/resolver/service/snrc-resolve.py  # defaults to local reth + mainnet .testing
 ```

-Tests and lint run from `scripts/resolver/service`:
-
-```sh
-uv run pytest
-uv run ruff check .
-```
-
-Dependencies are locked in `uv.lock`; the Docker image installs exactly those.
-
 Three routes, versioned separately from the protocol so each only changes when
 its own shape does:

@@ -252,7 +243,7 @@ wrong, `error` and `status` hold the same value, so one field is enough to read.

 `upstreamError` says only which exception type the RPC call raised. The text
 goes to the resolver's log instead, because `SNRC_RPC` can carry a provider key
-and the exception can carry the URL it failed on. It is also the answer
+and urlopen puts the URL it failed on into the message. It is also the answer
 when a registrar, controller or oracle address has no contract behind it: the
 empty reply is refused rather than read as zero, which would make every name
 look free.
@@ -383,87 +374,3 @@ here.
 To override any of them, set `SNRC_REGISTRY_<TLD>`, `SNRC_REGISTRAR_<TLD>` or
 `SNRC_CONTROLLER_<TLD>` on the `resolver` service in `docker-compose.yml`, or
 as env vars when you run the script directly.
-
-### Load and scaling
-
-A lookup reads the chain in at most three rounds: the name's status and
-registry entries, then its record from its resolver, then prices for a name
-that is free. The node runs the calls of a JSON-RPC batch one after another,
-so the contract reads of a round go to the chain as one `eth_call` to
-[Multicall3](https://github.com/mds1/multicall). A node that is slow for a
-moment therefore delays a lookup a few times, not once per read. Connections to
-the node are kept open and reused.
-
-The resolver answers HTTP/1.1, so each smp-server keeps its connections to it
-open instead of connecting for every lookup. An idle connection is closed after
-60 s; the smp-server drops its own idle ones after 30 s, so it closes them first.
-
-Each access log line ends with how long the request took, so slow requests
-show up in `docker compose logs resolver`.
-
-| Variable | Default | Meaning |
-|---|---|---|
-| `SNRC_WORKERS` | CPU count, at most 4 | processes sharing the port. If one exits, the others stop, so the container restarts |
-| `SNRC_RPC_TIMEOUT` | `5` | seconds to wait for each request to the node; the smp-server gives up after 3 |
-| `SNRC_MULTICALL` | `0xcA11bde05977b3631167028862bE2a173976CA11` | Multicall3 address. If it does not answer, each round is sent as a plain batch and the log says so once |
-
-### Logs
-
-Each event is one line: UTC time, level, event name, then `key=value` fields.
-
-```
-2026-09-26T08:06:19.992Z INFO  request  client=203.0.113.7 worker=12 method=GET path=/v2/resolve/[4fdd…].testing status=200 bytes=701 ms=35
-2026-09-26T08:06:20.051Z WARN  upstream_error  name=foobar.testing error=ConnectionRefusedError message="[Errno 111] Connection refused"
-```
-
-| Event | Level | Meaning |
-|---|---|---|
-| `listening` | info | started: address, workers, RPC endpoint, registries, trusted proxies |
-| `request` | info | one answered request; `/health` only at debug |
-| `upstream_error` | warn | a read from the node failed; the caller got 502 |
-| `multicall_unavailable` | warn | Multicall3 did not answer; rounds are sent as plain batches |
-| `client_gone` | warn | the caller hung up before the answer, usually an smp-server past its timeout |
-| `http_error` | warn | a malformed request; idle keep-alive timeouts only at debug |
-| `request_failed` | error | a request failed unexpectedly, with its traceback |
-| `worker_exited`, `worker_failed` | error | a worker stopped; the others stop too, so the container restarts |
-| `stopping` | info | stopped by a signal |
-
-| Variable | Default | Meaning |
-|---|---|---|
-| `SNRC_LOG_FORMAT` | `text` | `text` (`key=value`) or `json`, one object per line |
-| `SNRC_LOG_COLOR` | `auto` | `auto` colours only a terminal, `always`, `never`. Docker output is no terminal, so set `always` for coloured `docker compose logs` |
-| `SNRC_LOG_LEVEL` | `info` | `debug` also logs health checks and idle connections closing |
-| `SNRC_TRUSTED_PROXIES` | none | addresses or CIDRs of reverse proxies whose `X-Forwarded-For` names the client |
-
-With docker compose, set these, and those in "Load and scaling", in `.env`
-(`.env.example` lists them).
-
-Behind a reverse proxy such as Caddy on the host, the resolver sees the Docker
-network's gateway rather than the client. Trust that gateway, and the logged
-client is the last `X-Forwarded-For` address no trusted proxy added, so a caller
-through the proxy cannot claim another address. Everything else on the host that
-connects to `127.0.0.1:8000`, the smp-servers included, arrives through the same
-gateway and could set the logged address too; run the proxy in the compose network
-and trust only its address to avoid that.
-
-The gateway is
-`docker network inspect resolver_default --format '{{(index .IPAM.Config 0).Gateway}}'`,
-with the network named after the compose project. It changes when the network is
-recreated, as `docker compose down` does, so trust one of, in `.env`:
-
- `SNRC_TRUSTED_PROXIES=172.16.0.0/12`: Docker's default pools for compose
-  networks, whatever subnet it picks. This also trusts every other container on the
-  host. Add the gateway too if Docker ever gives the network a `192.168.x.x` one.
- a pinned subnet, so the gateway stays fixed, and only that gateway:
-
-  ```yaml
-  networks:
-    default:
-      ipam:
-        config:
-          - subnet: 172.30.0.0/24
-            gateway: 172.30.0.1
-  ```
-
-  in `docker-compose.yml`, with `SNRC_TRUSTED_PROXIES=172.30.0.1`, on a subnet no
-  other network on the host uses.
@@ -38,14 +38,14 @@ services:
      - sh
      - -c
      - |
-        if [ -d /home/user/nimbus-eth2/build/data/${NETWORK:-mainnet}/db ]; then
+        if [ -d /home/user/nimbus-eth2/build/data/${NETWORK}/db ]; then
          echo "Nimbus data dir already initialised — skipping checkpoint sync";
          exit 0;
        fi;
        /home/user/nimbus-eth2/build/nimbus_beacon_node trustedNodeSync \
-          --network=${NETWORK:-mainnet} \
-          --data-dir=/home/user/nimbus-eth2/build/data/${NETWORK:-mainnet} \
-          --trusted-node-url=${TRUSTED_NODE_URL:-https://mainnet-checkpoint-sync.attestant.io} \
+          --network=${NETWORK} \
+          --data-dir=/home/user/nimbus-eth2/build/data/${NETWORK} \
+          --trusted-node-url=${TRUSTED_NODE_URL} \
          --backfill=false
    restart: "no"

@@ -69,8 +69,8 @@ services:
          echo "Reth data already initialised — skipping snapshot download";
          exit 0;
        fi;
-        echo "Downloading Reth ${NETWORK:-mainnet} --minimal snapshot...";
-        reth download --datadir /data --chain ${NETWORK:-mainnet} --minimal && \
+        echo "Downloading Reth ${NETWORK} --minimal snapshot...";
+        reth download --datadir /data --chain ${NETWORK} --minimal && \
        touch /data/.snapshot-done && \
        echo "Snapshot download complete"
    restart: "no"
@@ -92,7 +92,7 @@ services:
    command: >
      node
      --datadir /data
-      --chain ${NETWORK:-mainnet}
+      --chain ${NETWORK}
      --minimal
      --authrpc.jwtsecret /jwt/jwt.hex
      --authrpc.addr 0.0.0.0 --authrpc.port 8551
@@ -117,8 +117,8 @@ services:
      - "9000:9000/udp"
      - "127.0.0.1:5052:5052"
    command: >
-      --network=${NETWORK:-mainnet}
-      --data-dir=/home/user/nimbus-eth2/build/data/${NETWORK:-mainnet}
+      --network=${NETWORK}
+      --data-dir=/home/user/nimbus-eth2/build/data/${NETWORK}
      --el=http://reth:8551
      --jwt-secret=/jwt/jwt.hex
      --non-interactive
@@ -131,7 +131,6 @@ services:
  # smp-server points its [NAMES] resolver_endpoint at this URL.
  # To change the host port, edit the LEFT side of the port mapping below.
  resolver:
-    image: snrc-resolve:local
    build:
      context: ./service
      dockerfile: Dockerfile
@@ -157,18 +156,8 @@ services:
      # SNRC_REGISTRAR_SIMPLEX: 0x...
      # SNRC_CONTROLLER_TESTING: 0x...
      # SNRC_CONTROLLER_SIMPLEX: 0x...
-      # Set in .env (see .env.example); unset or empty means the resolver's default.
-      SNRC_WORKERS: ${SNRC_WORKERS:-}
-      SNRC_RPC_TIMEOUT: ${SNRC_RPC_TIMEOUT:-}
-      SNRC_LOG_FORMAT: ${SNRC_LOG_FORMAT:-}
-      SNRC_LOG_COLOR: ${SNRC_LOG_COLOR:-}
-      SNRC_LOG_LEVEL: ${SNRC_LOG_LEVEL:-}
-      SNRC_TRUSTED_PROXIES: ${SNRC_TRUSTED_PROXIES:-}
    ports:
      - "127.0.0.1:8000:8000"
-    # a line per lookup; the local driver keeps 5 rotated files of 20 MB
-    logging:
-      driver: local
    restart: unless-stopped

 volumes:
@@ -1,5 +0,0 @@
-.venv
-**/__pycache__
-.pytest_cache
-.ruff_cache
-test_snrc_resolve.py
@@ -1 +0,0 @@
-3.13
@@ -1,10 +1,9 @@
 # syntax=docker/dockerfile:1.7
 # ---------- builder ----------
-# The official uv image (Astral) on top of a slim Python base installs the
-# locked dependencies into a portable .venv for the runtime stage.
-# Pinned to the uv that wrote uv.lock (its bookworm images stopped at 0.9.30), on the
-# runtime's Debian release, so the .venv's Python path exists there.
-FROM ghcr.io/astral-sh/uv:0.12.16-python3.13-trixie-slim AS builder
+# Use the official uv image (Astral) on top of a slim Python base.
+# uv resolves and installs the lockfile-free pyproject.toml in seconds and
+# produces a portable .venv we can copy into the runtime stage.
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim AS builder

 ENV UV_LINK_MODE=copy \
    UV_COMPILE_BYTECODE=1 \
@@ -13,17 +12,17 @@ ENV UV_LINK_MODE=copy \

 WORKDIR /app

-# Dependencies first (separate layer), exactly as locked: script edits don't bust this cache.
-COPY pyproject.toml uv.lock .python-version ./
+# Install deps first (separate layer) — script edits won't bust this cache.
+COPY pyproject.toml ./
 RUN --mount=type=cache,target=/root/.cache/uv \
-    uv sync --frozen --no-dev --no-install-project
+    uv sync --no-dev --no-install-project

 # Script is added after the dep layer for cache friendliness.
 COPY snrc-resolve.py ./

 # ---------- runtime ----------
 # Slim runtime — only the venv + script. No uv, no apt.
-FROM python:3.13-slim-trixie AS runtime
+FROM python:3.13-slim AS runtime

 ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
@@ -34,15 +33,15 @@ RUN groupadd --system --gid 10001 snrc && \
    useradd  --system --uid 10001 --gid snrc --no-create-home --shell /usr/sbin/nologin snrc

 WORKDIR /app
-# owned by root, so the service cannot rewrite its own code
-COPY --from=builder /app /app
+COPY --from=builder --chown=snrc:snrc /app /app

 USER snrc:snrc

 EXPOSE 8000

-# Liveness check hits the script's own /health route. Three failures mark the
-# container unhealthy; compose does not restart it for that, but `docker ps` shows it.
+# Liveness check hits the script's own /health route. ThreadingHTTPServer is
+# fast enough that 3s is generous for a localhost probe; restart if it stops
+# responding entirely.
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
    CMD ["python", "-c", "import urllib.request, sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=3).status == 200 else 1)"]

@@ -9,14 +9,5 @@ dependencies = [
  "eth-hash[pycryptodome]>=0.7",
 ]

-[dependency-groups]
-dev = [
-  "pytest>=8",
-  "ruff>=0.6",
-]
-
 [tool.uv]
 package = false
-
-[tool.ruff.lint]
-select = ["E9", "F", "B"]
@@ -46,15 +46,6 @@ Environment:
                         (default: mainnet for .testing, empty for .simplex)
  SNRC_PORT              Listen port (default: 8000)
  SNRC_BIND              Bind address (default: 0.0.0.0)
-  SNRC_WORKERS           Worker processes sharing the port (default: CPU count, at most 4)
-  SNRC_RPC_TIMEOUT       Seconds to wait for each RPC request (default: 5)
-  SNRC_MULTICALL         Multicall3 contract that runs a round of reads as one call
-                         (default: 0xcA11bde05977b3631167028862bE2a173976CA11)
-  SNRC_LOG_FORMAT        text (key=value) or json (default: text)
-  SNRC_LOG_COLOR         auto (on a terminal), always or never (default: auto)
-  SNRC_LOG_LEVEL         debug, info, warning or error (default: info)
-  SNRC_TRUSTED_PROXIES   Comma-separated addresses or CIDRs of reverse proxies whose
-                         X-Forwarded-For names the client (default: none)

 Each TLD is a separate SNRC deployment with its own ENSRegistry; the
 resolver dispatches by the queried name's rightmost label.
@@ -73,45 +64,19 @@ Unrecognised payloads fall back to `0x`-prefixed raw hex.
 """

 import hashlib
-import ipaddress
 import json
-import logging
 import os
-import queue
-import signal
-import socket
 import sys
-import threading
 import time
-from contextlib import contextmanager
-from datetime import datetime, timezone
-from functools import lru_cache
-from http.client import BadStatusLine, HTTPConnection, HTTPSConnection
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from urllib.error import HTTPError
 from urllib.parse import unquote, urlparse
+from urllib.request import Request, urlopen

 from eth_hash.auto import keccak

 RPC = os.environ.get("SNRC_RPC", "http://127.0.0.1:8545")
 BIND = os.environ.get("SNRC_BIND", "0.0.0.0")
 PORT = int(os.environ.get("SNRC_PORT", "8000"))
-# The smp-server gives up after 3 s, so a slower call only holds a thread.
-RPC_TIMEOUT_S = float(os.environ.get("SNRC_RPC_TIMEOUT", "") or 5)
-# The node and the beacon client usually share the host, so not every core.
-MAX_DEFAULT_WORKERS = 4
-WORKERS = int(os.environ.get("SNRC_WORKERS", "") or min(MAX_DEFAULT_WORKERS, os.cpu_count() or 1))
-# Multicall3, at this address on mainnet and most chains. A node runs a JSON-RPC
-# batch one call after another, so a round of reads is sent as one eth_call.
-MULTICALL = os.environ.get("SNRC_MULTICALL", "") or "0xcA11bde05977b3631167028862bE2a173976CA11"
-LOG_FORMAT = os.environ.get("SNRC_LOG_FORMAT", "") or "text"
-LOG_COLOR = os.environ.get("SNRC_LOG_COLOR", "") or "auto"
-LOG_LEVEL = os.environ.get("SNRC_LOG_LEVEL", "") or "info"
-# Peers whose X-Forwarded-For is believed, such as the Docker gateway a reverse proxy on the host
-# connects through. Anyone else could put any address there.
-TRUSTED_PROXIES = tuple(
-    ipaddress.ip_network(p.strip(), strict=False) for p in os.environ.get("SNRC_TRUSTED_PROXIES", "").split(",") if p.strip()
-)

 # Each TLD is its own SNRC deployment with its own ENSRegistry. Dispatch
 # happens on the rightmost label of the queried name. Empty / unset means
@@ -156,291 +121,34 @@ COIN_ETH = 60
 COIN_BTC = 0
 COIN_XMR = 128
 COIN_DOT = 354
-RECORD_COINS = (COIN_ETH, COIN_BTC, COIN_XMR, COIN_DOT)

 ZERO_ADDR = "0x0000000000000000000000000000000000000000"

 # The registry prices in attoUSD (1e-18 USD); the protocol carries US cents.


-# ---------- Logging ----------
-
-LOGGER = logging.getLogger("snrc_resolve")
-LEVEL_NAMES = {logging.DEBUG: "DEBUG", logging.INFO: "INFO", logging.WARNING: "WARN", logging.ERROR: "ERROR"}
-# ANSI SGR codes
-DIM, BOLD, GREEN, YELLOW, RED = "2", "1", "32", "33", "31"
-LEVEL_COLORS = {"DEBUG": DIM, "INFO": GREEN, "WARN": YELLOW, "ERROR": RED}
-STATUS_COLORS = {2: GREEN, 3: GREEN, 4: YELLOW, 5: RED}
-
-
-def log_event(level: int, name: str, /, exc_info=None, **fields):
-    LOGGER.log(level, name, exc_info=exc_info, extra={"fields": fields})
-
-
-def _log_time(record: logging.LogRecord) -> str:
-    return datetime.fromtimestamp(record.created, timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
-
-
-def _log_value(value) -> str:
-    """A logfmt value: bare when it cannot be misread, JSON-quoted otherwise."""
-    if value is None:
-        return "-"
-    s = str(value)
-    if not s or any(c in s for c in ' ="\\') or not s.isprintable():
-        return json.dumps(s)
-    return s
-
-
-class TextFormatter(logging.Formatter):
-    def __init__(self, color: bool):
-        super().__init__()
-        self.color = color
-
-    def _paint(self, code: str, text: str) -> str:
-        return f"\033[{code}m{text}\033[0m" if self.color and code else text
-
-    def format(self, record: logging.LogRecord) -> str:
-        level = LEVEL_NAMES.get(record.levelno, record.levelname)
-        fields = " ".join(
-            self._paint(DIM, f"{k}=") + self._paint(STATUS_COLORS.get(v // 100, "") if k == "status" and isinstance(v, int) else "", _log_value(v))
-            for k, v in getattr(record, "fields", {}).items()
-        )
-        line = f"{self._paint(DIM, _log_time(record))} {self._paint(LEVEL_COLORS.get(level, ''), f'{level:<5}')} {self._paint(BOLD, record.getMessage())}"
-        if fields:
-            line += "  " + fields
-        if record.exc_info:
-            line += "\n" + self.formatException(record.exc_info)
-        return line
-
-
-class JsonFormatter(logging.Formatter):
-    def format(self, record: logging.LogRecord) -> str:
-        out = {
-            "time": _log_time(record),
-            "level": LEVEL_NAMES.get(record.levelno, record.levelname).lower(),
-            "event": record.getMessage(),
-            **getattr(record, "fields", {}),
-        }
-        if record.exc_info:
-            out["exception"] = self.formatException(record.exc_info)
-        return json.dumps(out, default=str)
-
-
-def setup_logging(stream=None):
-    """Sends the resolver's events to stderr in the configured format."""
-    stream = stream or sys.stderr
-    if LOG_FORMAT not in ("text", "json"):
-        raise ValueError(f"SNRC_LOG_FORMAT must be text or json, not {LOG_FORMAT!r}")
-    if LOG_COLOR not in ("auto", "always", "never"):
-        raise ValueError(f"SNRC_LOG_COLOR must be auto, always or never, not {LOG_COLOR!r}")
-    level = logging.getLevelName(LOG_LEVEL.upper())
-    if not isinstance(level, int):
-        raise ValueError(f"SNRC_LOG_LEVEL must be debug, info, warning or error, not {LOG_LEVEL!r}")
-    color = LOG_COLOR == "always" or (LOG_COLOR == "auto" and stream.isatty())
-    handler = logging.StreamHandler(stream)
-    handler.setFormatter(JsonFormatter() if LOG_FORMAT == "json" else TextFormatter(color))
-    LOGGER.handlers[:] = [handler]
-    LOGGER.setLevel(level)
-    LOGGER.propagate = False
-
-
 # ---------- RPC + ABI helpers (mirrors ens-lookup.py shape) ----------

-RPC_URL = urlparse(RPC)
-# Set a non-default User-Agent; Cloudflare-fronted public RPCs (drpc,
-# publicnode, etc.) reject `Python-urllib/3.x` with 403.
-RPC_HEADERS = {"Content-Type": "application/json", "User-Agent": "snrc-resolve/1.0"}
-
-# Idle keep-alive connections to SNRC_RPC. A connection per call costs most of
-# a lookup's CPU and leaves a TIME_WAIT socket per call, which exhausts local
-# ports at a few dozen lookups per second.
-# Idle connections kept per worker; more are closed after use. 4 workers stay well
-# under reth's default limit of 500 connections.
-RPC_POOL_SIZE = 32
-_rpc_pool = queue.LifoQueue(maxsize=RPC_POOL_SIZE)
-
-
-def _new_rpc_connection():
-    conn_class = HTTPSConnection if RPC_URL.scheme == "https" else HTTPConnection
-    return conn_class(RPC_URL.hostname, RPC_URL.port, timeout=RPC_TIMEOUT_S)
-
-
-def _post_rpc(conn, body: bytes) -> bytes:
-    path = (RPC_URL.path or "/") + (f"?{RPC_URL.query}" if RPC_URL.query else "")
-    conn.request("POST", path, body, RPC_HEADERS)
-    res = conn.getresponse()
-    data = res.read()
-    # HTTPError, as urlopen raised: RuntimeError means the call itself failed
-    if not 200 <= res.status < 300:
-        raise HTTPError(RPC, res.status, res.reason, res.headers, None)
-    return data
-
-
-def _post_pooled(conn, body: bytes) -> bytes:
-    try:
-        data = _post_rpc(conn, body)
-    except BaseException:
-        conn.close()
-        raise
-    try:
-        _rpc_pool.put_nowait(conn)
-    except queue.Full:
-        conn.close()
-    return data
-
-
-def _send_rpc(payload) -> object:
-    body = json.dumps(payload).encode()
-    try:
-        idle = _rpc_pool.get_nowait()
-    except queue.Empty:
-        return json.loads(_post_pooled(_new_rpc_connection(), body))
-    try:
-        return json.loads(_post_pooled(idle, body))
-    except (ConnectionError, BadStatusLine):
-        # the node closed the idle connection; every call is a read, so resending is safe
-        return json.loads(_post_pooled(_new_rpc_connection(), body))
-
-
-# Reads prefetched for the request being answered, keyed by _read_key. Only set
-# inside request_reads(), so code called outside a request reads one call at a time.
-_request = threading.local()
-_UNREAD = object()
-
-
-def _read_key(method, params) -> str:
-    return method + json.dumps(params, sort_keys=True)
-
-
-@contextmanager
-def request_reads():
-    _request.reads = {}
-    try:
-        yield
-    finally:
-        del _request.reads
-
-
 def rpc(method, params):
-    reads = getattr(_request, "reads", None)
-    if reads is not None:
-        read = reads.get(_read_key(method, params), _UNREAD)
-        if isinstance(read, RuntimeError):
-            raise read
-        if read is not _UNREAD:
-            return read
-    res = _send_rpc({"jsonrpc": "2.0", "method": method, "params": params, "id": 1})
+    body = json.dumps(
+        {"jsonrpc": "2.0", "method": method, "params": params, "id": 1}
+    ).encode()
+    # Set a non-default User-Agent; Cloudflare-fronted public RPCs (drpc,
+    # publicnode, etc.) reject `Python-urllib/3.x` with 403.
+    req = Request(
+        RPC,
+        data=body,
+        headers={
+            "Content-Type": "application/json",
+            "User-Agent": "snrc-resolve/1.0",
+        },
+    )
+    res = json.loads(urlopen(req, timeout=15).read())
    if "error" in res:
        raise RuntimeError(res["error"])
    return res["result"]


-def _send_batch(requests):
-    """Answers of a JSON-RPC batch in request order, None for a request left
-    unanswered; all None when the node does not batch."""
-    res = _send_rpc([{"jsonrpc": "2.0", "id": i, "method": m, "params": p} for i, (m, p) in enumerate(requests)])
-    # a node that does not batch answers with a single error object
-    by_id = {r.get("id"): r for r in res if isinstance(r, dict)} if isinstance(res, list) else {}
-    return [by_id.get(i) for i in range(len(requests))]
-
-
-def _is_latest_call(method, params) -> bool:
-    return method == "eth_call" and params[1] == "latest"
-
-
-_multicall_failed_logged = False
-
-
-def _remember(reads, requests, answers):
-    for (m, p), r in zip(requests, answers, strict=True):
-        if r is not None and ("result" in r or "error" in r):
-            reads[_read_key(m, p)] = RuntimeError(r["error"]) if "error" in r else r["result"]
-
-
-def prefetch(requests):
-    """Sends reads the request will make in one round trip, with its contract
-    reads as one multicall. A read left unanswered is made on its own when the
-    code gets to it."""
-    global _multicall_failed_logged
-    reads = getattr(_request, "reads", None)
-    if reads is None:
-        return
-    todo = [(m, p) for m, p in requests if _read_key(m, p) not in reads]
-    if len(todo) < 2:
-        return
-    calls = [(m, p) for m, p in todo if _is_latest_call(m, p)]
-    if len(calls) < 2:
-        _remember(reads, todo, _send_batch(todo))
-        return
-    others = [(m, p) for m, p in todo if not _is_latest_call(m, p)]
-    multicall = eth_call_read(MULTICALL, encode_aggregate3([(p[0]["to"], p[0]["data"]) for _, p in calls]))
-    answers = _send_batch(others + [multicall])
-    if all(r is None for r in answers):
-        return
-    _remember(reads, others, answers[:-1])
-    try:
-        result = (answers[-1] or {}).get("result")
-        if not isinstance(result, str):
-            raise ValueError(f"multicall answered {answers[-1]!r}")
-        results = decode_aggregate3(result)
-        if len(results) != len(calls):
-            raise ValueError("multicall answered a different number of calls")
-    except (KeyError, TypeError, ValueError) as e:
-        if not _multicall_failed_logged:
-            _multicall_failed_logged = True
-            log_event(logging.WARNING, "multicall_unavailable", multicall=MULTICALL, error=repr(e), fallback="batch")
-        _remember(reads, calls, _send_batch(calls))
-        return
-    for (m, p), (success, data) in zip(calls, results, strict=True):
-        reads[_read_key(m, p)] = "0x" + data.hex() if success else RuntimeError("execution reverted")
-
-
-AGGREGATE3 = "0x82ad56cb"  # aggregate3((address,bool,bytes)[])
-
-
-def encode_aggregate3(calls) -> str:
-    """Calldata for Multicall3.aggregate3 with every call allowed to fail."""
-    tuples = []
-    for to, data in calls:
-        b = bytes.fromhex(data[2:])
-        tuples.append(
-            int(to, 16).to_bytes(32, "big")
-            + (1).to_bytes(32, "big")
-            + (0x60).to_bytes(32, "big")
-            + len(b).to_bytes(32, "big")
-            + b
-            + b"\x00" * ((-len(b)) % 32)
-        )
-    offsets, at = [], 32 * len(tuples)
-    for t in tuples:
-        offsets.append(at.to_bytes(32, "big"))
-        at += len(t)
-    body = (0x20).to_bytes(32, "big") + len(tuples).to_bytes(32, "big") + b"".join(offsets) + b"".join(tuples)
-    return AGGREGATE3 + body.hex()
-
-
-def decode_aggregate3(hex_data: str):
-    """Multicall3.aggregate3's (bool success, bytes returnData)[]."""
-    raw = bytes.fromhex(hex_data[2:] if hex_data.startswith("0x") else hex_data)
-
-    def word(at: int) -> int:
-        if at + 32 > len(raw):
-            raise ValueError("multicall answer is truncated")
-        return int.from_bytes(raw[at:at + 32], "big")
-
-    array = word(0)
-    base = array + 32
-    out = []
-    for i in range(word(array)):
-        item = base + word(base + 32 * i)
-        data = item + word(item + 32)
-        length = word(data)
-        if data + 32 + length > len(raw):
-            raise ValueError("multicall answer is truncated")
-        out.append((word(item) != 0, raw[data + 32:data + 32 + length]))
-    return out
-
-
 def namehash(name: str) -> bytes:
    node = b"\x00" * 32
    if name:
@@ -476,14 +184,11 @@ def node_of(name: str) -> bytes:
 # ---------- Registration status ----------


-BLOCK_READ = ("eth_getBlockByNumber", ["latest", False])
-
-
 def head_block():
    """How far behind the node is. Unlike expiry, this is the one thing that has
    to be measured against the host clock: a node that stops still has a block."""
    try:
-        block = rpc(*BLOCK_READ)
+        block = rpc("eth_getBlockByNumber", ["latest", False])
        return {
            "blockNumber": decode_uint(block["number"]),
            "chainLagSeconds": int(time.time()) - decode_uint(block["timestamp"]),
@@ -494,13 +199,13 @@ def head_block():

 def chain_now() -> int:
    """Expiry is compared against the block timestamp, never the host clock."""
-    block = rpc(*BLOCK_READ)
+    block = rpc("eth_getBlockByNumber", ["latest", False])
    return decode_uint(block["timestamp"])


 def grace_period(registrar: str) -> int:
    """A deployment can configure a different window, so it is read on chain."""
-    return decode_uint(eth_call(*grace_call(registrar)))
+    return decode_uint(eth_call(registrar, selector("GRACE_PERIOD()")))


 def expiry_status(expires: int, grace: int, now: int) -> str:
@@ -520,7 +225,8 @@ def reservation_reason(tld: str, token: int) -> int:
    controller = CONTROLLERS.get(tld)
    if not controller:
        return 0
-    return decode_uint(eth_call(*reserved_call(controller, token)))
+    raw = eth_call(controller, selector("reservedNames(bytes32)") + encode_uint(token))
+    return decode_uint(raw)


 def pricing_params(tld: str):
@@ -529,8 +235,7 @@ def pricing_params(tld: str):
    controller = CONTROLLERS.get(tld)
    if not controller:
        return None
-    prefetch([eth_call_read(*prices_call(controller)), eth_call_read(*min_length_call(controller))])
-    oracle = decode_address(eth_call(*prices_call(controller)))
+    oracle = decode_address(eth_call(controller, selector("prices()")))
    if oracle == ZERO_ADDR:
        return None
    try:
@@ -542,8 +247,6 @@ def pricing_params(tld: str):


 SECONDS_PER_YEAR = 31536000
-# an ENS-shaped oracle prices names by length up to six letters
-LETTER_TIERS = range(1, 7)
 ATTO_PER_CENT = 10**16


@@ -552,15 +255,13 @@ def read_oracle_prices(controller: str, oracle: str):
    protocol carries. An ENS-shaped oracle prices in attoUSD per second and
    charges a premium on lapsed names that it does not expose, so a quote from
    it is only safe for a name that was never registered."""
-    # either oracle shape is answered in the same round trip
-    prefetch([eth_call_read(*prices_call(oracle))] + [eth_call_read(*letter_price_call(oracle, n)) for n in LETTER_TIERS])
    try:
-        base, tiers = decode_prices(eth_call(*prices_call(oracle)))
+        base, tiers = decode_prices(eth_call(oracle, selector("prices()")))
        premium_unknown = False
    except RuntimeError:
        base, tiers = decode_letter_prices(oracle)
        premium_unknown = True
-    min_len = decode_uint(eth_call(*min_length_call(controller)))
+    min_len = decode_uint(eth_call(controller, selector("minCharLength()")))
    return {
        # lengths the registry refuses are left out rather than priced at zero
        "registrationPrices": {n: c for n, c in tiers.items() if n >= min_len},
@@ -576,9 +277,9 @@ def decode_letter_prices(oracle: str):
    the six-letter tier stops at five, and charges its highest tier for anything
    longer, which is what basePrice means here."""
    tiers = {}
-    for n in LETTER_TIERS:
+    for n in range(1, 7):
        try:
-            rate = decode_uint(eth_call(*letter_price_call(oracle, n)))
+            rate = decode_uint(eth_call(oracle, selector(f"price{n}Letter()")))
        except RuntimeError:
            if n <= 5:
                raise
@@ -600,9 +301,6 @@ def decode_prices(hex_data: str):
    base = int.from_bytes(raw[:32], "big")
    at = int.from_bytes(raw[32:64], "big")
    count = int.from_bytes(raw[at:at + 32], "big")
-    # the count comes from the answer, so it is checked against the answer's length
-    if at + 32 + count * 64 > len(raw):
-        raise RuntimeError("prices(): short response")
    tiers = {}
    for i in range(count):
        item = at + 32 + i * 64
@@ -630,7 +328,9 @@ def name_status(name: str):
    # The 2LD's label is that key at any depth. node_of decodes a bracket only
    # in a two-label name, so a bracket subname gets a status but no record.
    token = label_token(labels[-2])
-    expires = decode_uint(eth_call(*expires_call(registrar, token)))
+    expires = decode_uint(
+        eth_call(registrar, selector("nameExpires(uint256)") + encode_uint(token))
+    )
    grace = grace_period(registrar) if expires else 0
    now = chain_now()
    status = expiry_status(expires, grace, now)
@@ -658,17 +358,12 @@ def name_status(name: str):
    return out


-@lru_cache(maxsize=None)
 def selector(signature: str) -> str:
    return "0x" + keccak(signature.encode())[:4].hex()


-def eth_call_read(to: str, data: str):
-    return "eth_call", [{"to": to, "data": data}, "latest"]
-
-
 def eth_call(to: str, data: str) -> str:
-    result = rpc(*eth_call_read(to, data))
+    result = rpc("eth_call", [{"to": to, "data": data}, "latest"])
    if result == "0x":
        raise RuntimeError(f"empty return from {to}: no contract at that address?")
    return result
@@ -690,7 +385,7 @@ def registered_label(registrar: str, token: int):
    """The plaintext label the registrar recorded at registration, keyed by the
    hash of that label. None when the name was registered without
    registerWithLabel, so the registrar cannot name it."""
-    raw = decode_bytes(eth_call(*label_call(registrar, token)))
+    raw = decode_bytes(eth_call(registrar, selector("labelOf(uint256)") + encode_uint(token)))
    return raw.decode("utf-8", errors="replace") if raw else None


@@ -732,7 +427,7 @@ def encode_text_call(node: bytes, key: str) -> str:


 def text(resolver: str, node: bytes, key: str) -> str:
-    raw = decode_bytes(eth_call(*text_call(resolver, node, key)))
+    raw = decode_bytes(eth_call(resolver, encode_text_call(node, key)))
    return raw.decode("utf-8", errors="replace") if raw else ""


@@ -751,7 +446,7 @@ def addr_multicoin(resolver: str, node: bytes, coin_type: int):
    payload doesn't match any recognised on-chain shape. Returns None when
    the record is unset."""
    try:
-        raw = decode_bytes(eth_call(*addr_call(resolver, node, coin_type)))
+        raw = decode_bytes(eth_call(resolver, encode_addr_multicoin_call(node, coin_type)))
    except RuntimeError:
        return None
    if not raw:
@@ -770,81 +465,6 @@ def addr_multicoin(resolver: str, node: bytes, coin_type: int):
        return "0x" + raw.hex()


-# ---------- Contract calls, as (to, data) ----------
-# Shared by the reads and prefetch, so a prefetched read is found by the code that makes it.
-
-
-def expires_call(registrar: str, token: int):
-    return registrar, selector("nameExpires(uint256)") + encode_uint(token)
-
-
-def grace_call(registrar: str):
-    return registrar, selector("GRACE_PERIOD()")
-
-
-def label_call(registrar: str, token: int):
-    return registrar, selector("labelOf(uint256)") + encode_uint(token)
-
-
-def reserved_call(controller: str, token: int):
-    return controller, selector("reservedNames(bytes32)") + encode_uint(token)
-
-
-def prices_call(contract: str):
-    return contract, selector("prices()")
-
-
-def letter_price_call(oracle: str, letters: int):
-    return oracle, selector(f"price{letters}Letter()")
-
-
-def min_length_call(controller: str):
-    return controller, selector("minCharLength()")
-
-
-def resolver_call(registry: str, node: bytes):
-    return registry, selector("resolver(bytes32)") + node.hex()
-
-
-def owner_call(registry: str, node: bytes):
-    return registry, selector("owner(bytes32)") + node.hex()
-
-
-def text_call(resolver: str, node: bytes, key: str):
-    return resolver, encode_text_call(node, key)
-
-
-def addr_call(resolver: str, node: bytes, coin_type: int):
-    return resolver, encode_addr_multicoin_call(node, coin_type)
-
-
-def lookup_reads(name: str):
-    """The reads a lookup makes before it knows the name's resolver."""
-    labels = name.split(".")
-    tld = labels[-1]
-    reads = []
-    registrar = REGISTRARS.get(tld)
-    if registrar and len(labels) >= 2:
-        token = label_token(labels[-2])
-        reads += [BLOCK_READ, eth_call_read(*expires_call(registrar, token)), eth_call_read(*grace_call(registrar))]
-        if len(labels) == 2 and is_encoded_labelhash(labels[0]):
-            reads.append(eth_call_read(*label_call(registrar, token)))
-        if CONTROLLERS.get(tld):
-            reads.append(eth_call_read(*reserved_call(CONTROLLERS[tld], token)))
-    registry = REGISTRIES.get(tld)
-    if registry:
-        node = node_of(name)
-        reads += [eth_call_read(*resolver_call(registry, node)), eth_call_read(*owner_call(registry, node))]
-    return reads
-
-
-def record_reads(resolver: str, node: bytes):
-    """The reads of a name's record from its resolver."""
-    return [eth_call_read(*text_call(resolver, node, k)) for k in TEXT_KEYS] + [
-        eth_call_read(*addr_call(resolver, node, coin)) for coin in RECORD_COINS
-    ]
-
-
 # ---------- Coin-specific address encoders ----------
 # Each takes raw bytes as stored under ENSIP-9 and returns the canonical
 # user-facing string for that chain (EIP-55 for ETH, bech32/base58check
@@ -1045,9 +665,9 @@ def split_links(value: str) -> list:


 def upstream_error(subject: dict, e: Exception) -> dict:
-    """The exception can carry the failing URL and SNRC_RPC can carry a provider
-    key, so the text goes to the log and only the type to the caller."""
-    log_event(logging.WARNING, "upstream_error", **subject, error=type(e).__name__, message=str(e))
+    """urlopen puts the failing URL into its message and SNRC_RPC can carry a
+    provider key, so the text goes to the log and only the type to the caller."""
+    print(f"upstream error: {type(e).__name__}: {e}", file=sys.stderr)
    return {
        **subject,
        "error": "upstreamError",
@@ -1060,8 +680,9 @@ def name_record(name: str):
    has one, with every field unset."""
    registry = REGISTRIES[name.rsplit(".", 1)[-1]]
    node = node_of(name)
-    resolver_addr = decode_address(eth_call(*resolver_call(registry, node)))
-    owner = decode_address(eth_call(*owner_call(registry, node)))
+    node_hex = node.hex()
+    resolver_addr = decode_address(eth_call(registry, selector("resolver(bytes32)") + node_hex))
+    owner = decode_address(eth_call(registry, selector("owner(bytes32)") + node_hex))
    rec = {
        "name": canonical_name(name),
        "nickname": "",
@@ -1078,7 +699,6 @@ def name_record(name: str):
    }
    if resolver_addr == ZERO_ADDR:
        return rec
-    prefetch(record_reads(resolver_addr, node))
    texts = {}
    for k in TEXT_KEYS:
        try:
@@ -1114,7 +734,6 @@ def registration(name: str):
    tld = name.rsplit(".", 1)[-1]
    if not REGISTRIES.get(tld):
        return 400, {"name": name, "error": "tldNotConfigured"}
-    prefetch(lookup_reads(name))
    reg = name_status(name)
    status = reg["status"]
    if status in ("registered", "grace"):
@@ -1169,7 +788,7 @@ def resolve(name: str):
        }

    node = node_of(name)
-    prefetch(lookup_reads(name))
+    node_hex = node.hex()

    # Before the resolver lookup, so a lapsed name is not reported as noResolver.
    reg = name_status(name)
@@ -1187,12 +806,13 @@ def resolve(name: str):
        }
        return (404 if reg["status"] == "unregistered" else 410), body

-    resolver_addr = decode_address(eth_call(*resolver_call(registry, node)))
+    resolver_raw = eth_call(registry, selector("resolver(bytes32)") + node_hex)
+    resolver_addr = decode_address(resolver_raw)
    if resolver_addr == ZERO_ADDR:
        # A registered name always resolves: with no resolver set the record is
        # still returned with every field unset, so "taken until <date>" stays
        # answerable. For a subname, no owner means nobody created it.
-        owner = decode_address(eth_call(*owner_call(registry, node)))
+        owner = decode_address(eth_call(registry, selector("owner(bytes32)") + node_hex))
        if len(name.split(".")) > 2 and owner == ZERO_ADDR:
            return 404, {
                "name": name,
@@ -1217,9 +837,9 @@ def resolve(name: str):
            **reg,
        }

-    owner = decode_address(eth_call(*owner_call(registry, node)))
+    owner_raw = eth_call(registry, selector("owner(bytes32)") + node_hex)
+    owner = decode_address(owner_raw)

-    prefetch(record_reads(resolver_addr, node))
    texts = {}
    for k in TEXT_KEYS:
        try:
@@ -1258,34 +878,12 @@ def resolve(name: str):
 # ---------- HTTP layer ----------

 class Handler(BaseHTTPRequestHandler):
-    # the smp-server reuses a connection only after an HTTP/1.1 response
-    protocol_version = "HTTP/1.1"
-    # idle seconds before a kept-alive connection is closed; the smp-server closes
-    # its idle ones after 30-35 s, so it is the one to close them
-    timeout = 60
-
-    def setup(self):
-        super().setup()
-        # headers and body go out in separate writes, which Nagle holds for the client's delayed ACK
-        self.request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-
-    def handle_one_request(self):
-        # on a kept-alive connection these still hold the previous request's values
-        self._started = self._sent = self.path = self.headers = None
-        super().handle_one_request()
-
    def do_GET(self):  # noqa: N802 - http.server contract
-        self._started = time.monotonic()
-        if self._has_body():
-            # an unread body would be taken for the next request on this connection, which a
-            # reverse proxy reusing it would pass to another client (request smuggling)
-            self._respond(400, {"error": "unexpectedBody"}, close=True)
-            return
        path = urlparse(self.path).path
        parts = [unquote(p) for p in path.split("/") if p]

        if parts == ["health"]:
-            self._respond(200, {"ok": True, "rpc": public_endpoint(RPC), "registries": REGISTRIES, **head_block()})
+            self._respond(200, {"ok": True, "rpc": RPC, "registries": REGISTRIES, **head_block()})
            return

        if len(parts) == 3 and parts[0] == "v2" and parts[1] == "resolve":
@@ -1294,8 +892,7 @@ class Handler(BaseHTTPRequestHandler):
                self._respond(400, {"name": name, "error": "notFullyQualified"})
                return
            try:
-                with request_reads():
-                    status, body = registration(name)
+                status, body = registration(name)
            except Exception as e:  # surface upstream errors as 502
                status, body = 502, upstream_error({"name": name}, e)
            self._respond(status, body)
@@ -1318,8 +915,7 @@ class Handler(BaseHTTPRequestHandler):
                )
                return
            try:
-                with request_reads():
-                    status, body = resolve(name)
+                status, body = resolve(name)
            except Exception as e:  # surface upstream errors as 502
                status, body = 502, upstream_error({"name": name}, e)
            self._respond(status, body)
@@ -1334,176 +930,34 @@ class Handler(BaseHTTPRequestHandler):
            },
        )

-    def _has_body(self) -> bool:
-        # a malformed header line ends parsing, leaving the rest, Content-Length included, as payload
-        if self.headers.defects or self.headers.get_payload():
-            return True
-        if self.headers.get_all("Transfer-Encoding"):
-            return True
-        return any(length.strip() != "0" for length in self.headers.get_all("Content-Length") or [])
-
-    def _respond(self, status: int, body: dict, close: bool = False):
+    def _respond(self, status: int, body: dict):
        data = json.dumps(body, indent=2).encode()
-        # send_response logs the request, so the size is known before it
-        self._sent = len(data)
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
-        if close:
-            # also sets close_connection, so the server closes it after this response
-            self.send_header("Connection", "close")
        self.end_headers()
        self.wfile.write(data)

-    def address_string(self) -> str:
-        forwarded = self.headers.get_all("X-Forwarded-For") if self.headers else None
-        return client_address(self.client_address[0], ",".join(forwarded) if forwarded else None)
-
-    def log_request(self, code="-", size="-"):
-        started = self._started
-        path = urlparse(self.path).path if self.path else None
-        log_event(
-            # the container's health check runs every 30 s
-            logging.DEBUG if path == "/health" else logging.INFO,
-            "request",
-            client=self.address_string(),
-            worker=os.getpid(),
-            method=getattr(self, "command", None),
-            path=unquote(self.path) if self.path else None,
-            status=getattr(code, "value", code),
-            bytes=self._sent,
-            ms=round((time.monotonic() - started) * 1000) if started else None,
-        )
-
-    def log_error(self, fmt, *args):
-        message = fmt % args
-        # a kept-alive connection left idle is closed on purpose
-        level = logging.DEBUG if message.startswith("Request timed out") else logging.WARNING
-        log_event(level, "http_error", client=self.address_string(), worker=os.getpid(), message=message)
-
    def log_message(self, fmt, *args):
-        log_event(logging.INFO, "http", client=self.address_string(), message=fmt % args)
-
-
-class ResolverServer(ThreadingHTTPServer):
-    # socketserver's default of 5 drops simultaneous connections, each retried by
-    # TCP after 1 s, and the smp-server gives up after 3 s. The kernel caps it at somaxconn.
-    request_queue_size = 128
-
-    def handle_error(self, request, client_address):
-        error = sys.exc_info()[1]
-        if isinstance(error, ConnectionError):
-            # the smp-server hung up, usually after its own timeout
-            log_event(logging.WARNING, "client_gone", client=client_address[0], worker=os.getpid(), error=type(error).__name__)
-        else:
-            log_event(logging.ERROR, "request_failed", client=client_address[0], worker=os.getpid(), exc_info=True)
-
-
-def public_endpoint(url: str) -> str:
-    """The RPC endpoint without credentials, path or query, where a provider key would be."""
-    parsed = urlparse(url)
-    return f"{parsed.scheme}://{parsed.netloc.rpartition('@')[2]}"
-
-
-def client_address(peer: str, forwarded_for: str | None) -> str:
-    """The peer, or behind trusted proxies the last X-Forwarded-For address none of them added."""
-    if not forwarded_for or not _trusted(peer):
-        return peer
-    hops = [hop.strip() for hop in forwarded_for.split(",")]
-    for hop in reversed(hops):
-        # an address it cannot read, and anything claimed before it, is not believed
-        if _address(hop) is None:
-            return peer
-        if not _trusted(hop):
-            return hop
-    return hops[0]
-
-
-def _address(text: str):
-    try:
-        ip = ipaddress.ip_address(text)
-    except ValueError:
-        return None
-    return ip.ipv4_mapped or ip if ip.version == 6 else ip
-
-
-def _trusted(text: str) -> bool:
-    ip = _address(text)
-    return ip is not None and any(ip in net for net in TRUSTED_PROXIES)
-
-
-def serve(reuse_port: bool):
-    server = ResolverServer((BIND, PORT), Handler, bind_and_activate=False)
-    server.allow_reuse_port = reuse_port
-    try:
-        server.server_bind()
-        server.server_activate()
-        server.serve_forever()
-    finally:
-        server.server_close()
-
-
-def stop_on(signum, _frame):
-    log_event(logging.INFO, "stopping", signal=signal.Signals(signum).name)
-    sys.exit(0)
-
-
-def supervise(workers: int):
-    """Runs the workers, each with its own socket on the shared port. One worker
-    exiting stops the others, so the container restarts instead of running short."""
-    children = []
-
-    def stop(*_):
-        for pid in children:
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except ProcessLookupError:
-                pass
-
-    def stop_and_exit(signum, frame):
-        stop()
-        stop_on(signum, frame)
-
-    # before forking, so a signal during startup cannot orphan the workers
-    signal.signal(signal.SIGTERM, stop_and_exit)
-    signal.signal(signal.SIGINT, stop_and_exit)
-    for _ in range(workers):
-        pid = os.fork()
-        if pid == 0:
-            signal.signal(signal.SIGTERM, signal.SIG_DFL)
-            signal.signal(signal.SIGINT, signal.SIG_DFL)
-            code = 0
-            try:
-                serve(reuse_port=True)
-            except BaseException:
-                log_event(logging.ERROR, "worker_failed", worker=os.getpid(), exc_info=True)
-                code = 1
-            os._exit(code)
-        children.append(pid)
-    pid, status = os.wait()
-    log_event(logging.ERROR, "worker_exited", worker=pid, status=status, action="stopping")
-    stop()
-    sys.exit(1)
+        # Quiet the default per-request access log; route to stderr in one line.
+        sys.stderr.write(f"{self.address_string()} - {fmt % args}\n")


 def main():
-    setup_logging()
-    log_event(
-        logging.INFO,
-        "listening",
-        bind=BIND,
-        port=PORT,
-        workers=WORKERS,
-        rpc=public_endpoint(RPC),
-        registries=",".join(f"{tld}={addr or '-'}" for tld, addr in REGISTRIES.items()),
-        trusted_proxies=",".join(map(str, TRUSTED_PROXIES)) or None,
+    server = ThreadingHTTPServer((BIND, PORT), Handler)
+    sys.stderr.write(
+        f"snrc-resolve listening on {BIND}:{PORT}\n"
+        f"  RPC = {RPC}\n"
+        f"  Registries:\n"
    )
-    if WORKERS > 1:
-        supervise(WORKERS)
-    else:
-        signal.signal(signal.SIGTERM, stop_on)
-        signal.signal(signal.SIGINT, stop_on)
-        serve(reuse_port=False)
+    for tld, addr in REGISTRIES.items():
+        sys.stderr.write(f"    .{tld:<8s} = {addr or '(not configured)'}\n")
+    sys.stderr.write("  GET /v2/resolve/<name>   GET /v1/resolve/<name>   GET /health\n")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        sys.stderr.write("\nshutting down\n")
+        server.server_close()


 if __name__ == "__main__":
@@ -1,30 +1,15 @@
 #!/usr/bin/env python3
 """Unit tests for snrc-resolve helpers.

-Run with `uv run pytest` from scripts/resolver/service.
+Run with `python3 -m unittest scripts/resolver/service/test_snrc_resolve.py`.
 """

 import contextlib
-import http.client
 import importlib.util
 import io
-import ipaddress
-import json
-import logging
 import os
-import queue
-import re
-import signal
-import socket
-import subprocess
-import sys
-import threading
 import time
 import unittest
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from urllib.error import HTTPError
-from urllib.parse import urlparse
-from urllib.request import Request, urlopen

 # snrc-resolve.py has a hyphen, so import it via importlib instead of `import`.
 _HERE = os.path.dirname(os.path.abspath(__file__))
@@ -651,25 +636,6 @@ class PricingTests(unittest.TestCase):
        self.assertEqual(body["basePrice"], self.BASE)


-class DecodePricesTests(unittest.TestCase):
-    def test_a_count_longer_than_the_answer_is_refused(self):
-        """The count comes from the oracle; decoding it unchecked could loop for ever."""
-        huge = "0x" + snrc.encode_uint(200) + snrc.encode_uint(0x40) + snrc.encode_uint(2**64)
-        outcome = []
-
-        def decode():
-            try:
-                snrc.decode_prices(huge)
-            except RuntimeError as e:
-                outcome.append(e)
-
-        worker = threading.Thread(target=decode, daemon=True)
-        worker.start()
-        worker.join(5)
-        self.assertFalse(worker.is_alive(), "decoding did not stop")
-        self.assertRegex(str(outcome[0]), "short response")
-
-
 class EnsOracleTests(unittest.TestCase):
    """.testing runs an ENS-shaped oracle: it prices in attoUSD per second and
    charges a premium on lapsed names that it does not expose."""
@@ -811,17 +777,13 @@ class ErrorCodeTests(unittest.TestCase):
                self.assertNotEqual(body["error"], body["message"])

    def test_an_upstream_failure_does_not_echo_the_exception(self):
-        with self.assertLogs("snrc_resolve", "WARNING") as logs:
+        with contextlib.redirect_stderr(io.StringIO()) as log:
            body = snrc.upstream_error(
                {"name": "alice.testing"},
                RuntimeError("http://user:[email protected]/kEy8 refused"),
            )
        # the operator still sees the detail in the log
-        [record] = logs.records
-        self.assertEqual(record.getMessage(), "upstream_error")
-        self.assertEqual(record.fields["name"], "alice.testing")
-        self.assertEqual(record.fields["error"], "RuntimeError")
-        self.assertIn("secret", record.fields["message"])
+        self.assertIn("secret", log.getvalue())
        self.assertEqual(body["error"], "upstreamError")
        self.assertIn("RuntimeError", body["message"])
        self.assertNotIn("secret", body["message"])
@@ -1073,797 +1035,5 @@ class RegistrationV2Tests(unittest.TestCase):
        self.assertEqual(res["lastBlockTs"], self.now)
        self.assertEqual(res["registration"]["type"], "available")

-
-@unittest.skipUnless(sys.platform.startswith("linux"), "Linux drops SYNs on a full accept queue")
-class ListenBacklogTests(unittest.TestCase):
-    """The smp-server opens a connection per lookup and gives up after 3 s, so a
-    burst the accept queue cannot hold fails: TCP retries a dropped SYN after 1 s."""
-
-    BURST = 50
-
-    def test_a_burst_of_connections_is_queued_while_the_server_is_busy(self):
-        # never accepts, so every connection must wait in the queue
-        server = snrc.ResolverServer(("127.0.0.1", 0), snrc.Handler)
-        clients = []
-        try:
-            for i in range(self.BURST):
-                c = socket.socket()
-                clients.append(c)
-                c.settimeout(0.5)
-                try:
-                    c.connect(server.server_address)
-                except TimeoutError:
-                    self.fail(f"connection {i + 1} of {self.BURST} was not queued")
-        finally:
-            for c in clients:
-                c.close()
-            server.server_close()
-
-
-def _word(value: int) -> bytes:
-    return value.to_bytes(32, "big")
-
-
-def _decode_aggregate3_calls(data: str):
-    """Multicall3.aggregate3 calldata back to (to, data) pairs, written apart
-    from the resolver's encoder so the two check each other."""
-    raw = bytes.fromhex(data[len(snrc.AGGREGATE3):])
-
-    def word(at):
-        return int.from_bytes(raw[at:at + 32], "big")
-
-    array = word(0)
-    base = array + 32
-    calls = []
-    for i in range(word(array)):
-        item = base + word(base + 32 * i)
-        call = item + word(item + 64)
-        calls.append(("0x" + raw[item + 12:item + 32].hex(), "0x" + raw[call + 32:call + 32 + word(call)].hex()))
-    return calls
-
-
-def _encode_aggregate3_results(results) -> str:
-    tuples = [
-        _word(int(ok)) + _word(0x40) + _word(len(data)) + data + b"\x00" * ((-len(data)) % 32)
-        for ok, data in results
-    ]
-    offsets, at = b"", 32 * len(tuples)
-    for t in tuples:
-        offsets += _word(at)
-        at += len(t)
-    return "0x" + (_word(0x20) + _word(len(tuples)) + offsets + b"".join(tuples)).hex()
-
-
-class FakeChain:
-    """Contract state for one registered name and one free name. Any other
-    call reverts, as a view function asked for something unset does."""
-
-    REGISTRY = "0x58fc46996d975c57883564648bda5206d1a0102b"
-    REGISTRAR = "0xef47eb4384b46c89e4482a677c2cbcbd2a6fd85a"
-    CONTROLLER = "0x281ca41311c2aa808c917c4674639d7567b75714"
-    ORACLE = "0x1e0c9a2b9d1a4c8f7b3e5d6a9c2f4b8e1d7a3c50"
-    OWNER = "0xd83bd7e0e6b8a4c1f2593a7b0c4e8d1a6f9b2c37"
-    RESOLVER = "0x80fa2b1c3d4e5f60718293a4b5c6d7e8f9012345"
-    GRACE = 90 * 86400
-    TEXTS = {"nickname": "Acme", "url": "https://acme.example", "simplex.channel": "https://a.example/c#1;https://b.example/c#2"}
-
-    def __init__(self):
-        self.now = int(time.time())
-        acme, free = snrc.label_token("acme"), snrc.label_token("free")
-        node = snrc.node_of("acme.testing")
-        abi_bytes = RegistrationV2Tests._abi_bytes
-        prices = RegistrationV2Tests._prices_return(RegistrationV2Tests())
-        self.answers = {
-            snrc.expires_call(self.REGISTRAR, acme): "0x" + snrc.encode_uint(self.now + 3600),
-            snrc.expires_call(self.REGISTRAR, free): "0x" + snrc.encode_uint(0),
-            snrc.grace_call(self.REGISTRAR): "0x" + snrc.encode_uint(self.GRACE),
-            snrc.label_call(self.REGISTRAR, acme): abi_bytes(b"acme"),
-            snrc.reserved_call(self.CONTROLLER, acme): "0x" + snrc.encode_uint(0),
-            snrc.reserved_call(self.CONTROLLER, free): "0x" + snrc.encode_uint(0),
-            snrc.resolver_call(self.REGISTRY, node): "0x" + snrc.encode_uint(int(self.RESOLVER, 16)),
-            snrc.owner_call(self.REGISTRY, node): "0x" + snrc.encode_uint(int(self.OWNER, 16)),
-            snrc.addr_call(self.RESOLVER, node, snrc.COIN_ETH): abi_bytes(bytes.fromhex(self.OWNER[2:])),
-            snrc.prices_call(self.CONTROLLER): "0x" + snrc.encode_uint(int(self.ORACLE, 16)),
-            snrc.prices_call(self.ORACLE): prices,
-            snrc.min_length_call(self.CONTROLLER): "0x" + snrc.encode_uint(3),
-        }
-        for key, value in self.TEXTS.items():
-            self.answers[snrc.text_call(self.RESOLVER, node, key)] = abi_bytes(value.encode())
-
-    def call(self, to, data):
-        answer = self.answers.get((to.lower(), data))
-        if answer is None:
-            raise RuntimeError("execution reverted")
-        return answer
-
-
-class FakeNode(ThreadingHTTPServer):
-    """A JSON-RPC node over HTTP/1.1 keep-alive, serving FakeChain, with
-    batches and Multicall3, each of which a test can take away."""
-
-    daemon_threads = True
-
-    def __init__(self):
-        super().__init__(("127.0.0.1", 0), _FakeNodeHandler)
-        self.chain = FakeChain()
-        self.block = 100
-        self.requests = 0
-        self.connections = 0
-        self.batch = True
-        self.multicall = True
-        self.multicall_null = False
-        self.status = 200
-        self.hang_up = False
-        self.drop_after_reply = False
-        threading.Thread(target=self.serve_forever, args=(0.05,), daemon=True).start()
-
-    @property
-    def url(self):
-        return f"http://127.0.0.1:{self.server_address[1]}/"
-
-    def stop(self):
-        self.shutdown()
-        self.server_close()
-
-    def answer(self, req):
-        out = {"jsonrpc": "2.0", "id": req.get("id")}
-        method, params = req["method"], req["params"]
-        if method == "eth_blockNumber":
-            out["result"] = hex(self.block)
-        elif method == "eth_getBlockByNumber":
-            out["result"] = {"number": hex(self.block), "timestamp": hex(self.chain.now)}
-        elif method == "eth_call" and params[0]["to"].lower() == snrc.MULTICALL.lower():
-            if not self.multicall:
-                out["error"] = {"code": -32000, "message": "no contract code"}
-            elif self.multicall_null:
-                out["result"] = None
-            else:
-                results = []
-                for to, data in _decode_aggregate3_calls(params[0]["data"]):
-                    try:
-                        results.append((True, bytes.fromhex(self.chain.call(to, data)[2:])))
-                    except RuntimeError:
-                        results.append((False, b""))
-                out["result"] = _encode_aggregate3_results(results)
-        elif method == "eth_call":
-            try:
-                out["result"] = self.chain.call(params[0]["to"], params[0]["data"])
-            except RuntimeError:
-                out["error"] = {"code": 3, "message": "execution reverted"}
-        else:
-            out["error"] = {"code": -32601, "message": "method not found"}
-        return out
-
-
-class _FakeNodeHandler(BaseHTTPRequestHandler):
-    protocol_version = "HTTP/1.1"
-
-    def setup(self):
-        super().setup()
-        # headers and body go out in separate writes, which Nagle holds for the client's delayed ACK
-        self.request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        self.server.connections += 1
-
-    def do_POST(self):  # noqa: N802 - http.server contract
-        request = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
-        node = self.server
-        node.requests += 1
-        if node.hang_up:
-            self.close_connection = True
-            return
-        if node.status != 200:
-            reply = {"error": "unavailable"}
-        elif isinstance(request, list):
-            reply = [node.answer(r) for r in request] if node.batch else {"jsonrpc": "2.0", "id": None, "error": {"code": -32600, "message": "batch not supported"}}
-        else:
-            reply = node.answer(request)
-        data = json.dumps(reply).encode()
-        self.send_response(node.status)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Content-Length", str(len(data)))
-        self.end_headers()
-        self.wfile.write(data)
-        # closes without `Connection: close`, as a node dropping an idle connection does
-        self.close_connection = node.drop_after_reply
-
-    def log_message(self, fmt, *args):
-        pass
-
-
-class FakeNodeTestCase(unittest.TestCase):
-    """Points the resolver at a FakeNode and at FakeChain's contracts."""
-
-    def setUp(self):
-        self.node = FakeNode()
-        self._saved = (snrc.RPC, snrc.RPC_URL, snrc.REGISTRIES, snrc.REGISTRARS, snrc.CONTROLLERS)
-        snrc.RPC = self.node.url
-        snrc.RPC_URL = urlparse(snrc.RPC)
-        snrc.REGISTRIES = {"testing": FakeChain.REGISTRY, "simplex": ""}
-        snrc.REGISTRARS = {"testing": FakeChain.REGISTRAR}
-        snrc.CONTROLLERS = {"testing": FakeChain.CONTROLLER}
-        snrc._multicall_failed_logged = False
-        self._drain_pool()
-
-    def tearDown(self):
-        self._drain_pool()
-        snrc.RPC, snrc.RPC_URL, snrc.REGISTRIES, snrc.REGISTRARS, snrc.CONTROLLERS = self._saved
-        self.node.stop()
-
-    def _drain_pool(self):
-        while not snrc._rpc_pool.empty():
-            snrc._rpc_pool.get_nowait().close()
-
-    def requests_made(self, action):
-        before = self.node.requests
-        result = action()
-        return result, self.node.requests - before
-
-
-class RpcTransportTests(FakeNodeTestCase):
-    """A lookup makes several reads, and a new connection per read costs CPU
-    and leaves a TIME_WAIT socket each, which exhausts local ports under load."""
-
-    def test_reads_share_one_connection(self):
-        for _ in range(18):
-            self.assertEqual(snrc.rpc("eth_blockNumber", []), hex(self.node.block))
-        self.assertEqual(self.node.connections, 1)
-
-    def test_a_connection_the_node_closed_is_replaced(self):
-        self.node.drop_after_reply = True
-        for _ in range(3):
-            self.assertEqual(snrc.rpc("eth_blockNumber", []), hex(self.node.block))
-        self.assertEqual(self.node.connections, 3)
-
-    def test_a_fresh_connection_that_fails_is_not_retried(self):
-        """Only a pooled connection can be stale; a new one failing means the
-        node is down, and resending would only double the wait."""
-        self.node.hang_up = True
-        with self.assertRaises(ConnectionError):
-            snrc.rpc("eth_blockNumber", [])
-        self.assertEqual(self.node.requests, 1)
-
-    def test_a_node_failure_is_not_a_reverted_call(self):
-        """Callers read RuntimeError as the call reverting and fall back to an
-        empty value, so a node failure must not look like one."""
-        self.node.status = 502
-        with self.assertRaises(HTTPError) as cm:
-            snrc.rpc("eth_blockNumber", [])
-        self.assertNotIsInstance(cm.exception, RuntimeError)
-        self.assertEqual(cm.exception.code, 502)
-
-    def test_a_reverted_call_is_a_runtime_error_and_keeps_the_connection(self):
-        with self.assertRaises(RuntimeError):
-            snrc.eth_call("0x" + "11" * 20, "0xdeadbeef")
-        snrc.rpc("eth_blockNumber", [])
-        self.assertEqual(self.node.connections, 1)
-
-
-class RpcPoolTests(FakeNodeTestCase):
-    def test_connections_beyond_the_pool_are_closed_after_use(self):
-        """Every worker would otherwise keep its peak concurrency open to the node."""
-        saved, snrc._rpc_pool = snrc._rpc_pool, queue.LifoQueue(maxsize=1)
-        try:
-            body = json.dumps({"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}).encode()
-            kept, extra = snrc._new_rpc_connection(), snrc._new_rpc_connection()
-            snrc._post_pooled(kept, body)
-            # returning a connection to a full pool must not wait for a free slot
-            done = threading.Thread(target=snrc._post_pooled, args=(extra, body), daemon=True)
-            done.start()
-            done.join(5)
-            self.assertFalse(done.is_alive(), "returning a connection to a full pool blocked")
-            self.assertEqual(snrc._rpc_pool.qsize(), 1)
-            self.assertIsNotNone(kept.sock)
-            self.assertIsNone(extra.sock)
-        finally:
-            while not snrc._rpc_pool.empty():
-                snrc._rpc_pool.get_nowait().close()
-            snrc._rpc_pool = saved
-
-
-class BatchedReadsTests(FakeNodeTestCase):
-    """Inside a request a round of reads is one round trip, and its contract
-    reads one multicall, because a node runs the calls of a JSON-RPC batch one
-    after another. Answers must be exactly those of reading one call at a time."""
-
-    def batched(self, answer, name):
-        def action():
-            with snrc.request_reads():
-                return answer(name)
-        return self.requests_made(action)
-
-    def assert_same_answer(self, answer, name, round_trips):
-        one_by_one, one_by_one_trips = self.requests_made(lambda: answer(name))
-        batched, batched_trips = self.batched(answer, name)
-        self.assertEqual(batched, one_by_one)
-        self.assertEqual(batched_trips, round_trips)
-        self.assertGreater(one_by_one_trips, round_trips)
-        return batched
-
-    def test_a_registered_name_takes_two_round_trips(self):
-        status, body = self.assert_same_answer(snrc.registration, "acme.testing", 2)
-        record = body["registration"]["nameRecord"]
-        self.assertEqual(record["nickname"], "Acme")
-        self.assertEqual(record["simplexChannel"], ["https://a.example/c#1", "https://b.example/c#2"])
-        self.assertIsNone(record["btc"])
-
-    def test_a_hashed_query_is_named_from_the_same_round_trip(self):
-        hashed = "[" + snrc.keccak(b"acme").hex() + "].testing"
-        status, body = self.assert_same_answer(snrc.registration, hashed, 2)
-        self.assertEqual(body["registration"]["nameRecord"]["name"], "acme.testing")
-
-    def test_an_available_name_is_priced_in_three_round_trips(self):
-        status, body = self.assert_same_answer(snrc.registration, "free.testing", 3)
-        self.assertEqual(body["registration"]["type"], "available")
-
-    def test_v1_answers_the_same(self):
-        self.assert_same_answer(snrc.resolve, "acme.testing", 2)
-
-    def test_without_multicall_a_round_is_still_one_batch(self):
-        self.node.multicall = False
-        with self.assertLogs("snrc_resolve", "WARNING") as logs:
-            self.assert_same_answer(snrc.registration, "acme.testing", 4)
-        [record] = logs.records
-        self.assertEqual((record.getMessage(), record.fields["fallback"]), ("multicall_unavailable", "batch"))
-
-    def test_a_multicall_without_a_result_falls_back_to_a_batch(self):
-        self.node.multicall_null = True
-        with self.assertLogs("snrc_resolve", "WARNING") as logs:
-            self.assert_same_answer(snrc.registration, "acme.testing", 4)
-        self.assertEqual([r.getMessage() for r in logs.records], ["multicall_unavailable"])
-
-    def test_an_answer_with_neither_result_nor_error_is_not_taken_as_one(self):
-        reads = {}
-        snrc._remember(reads, [("eth_blockNumber", [])], [{"jsonrpc": "2.0", "id": 0}])
-        self.assertEqual(reads, {})
-
-    def test_a_node_that_does_not_batch_is_read_one_call_at_a_time(self):
-        self.node.batch = False
-        one_by_one, one_by_one_trips = self.requests_made(lambda: snrc.registration("acme.testing"))
-        with self.assertNoLogs("snrc_resolve"):
-            batched, batched_trips = self.batched(snrc.registration, "acme.testing")
-        self.assertEqual(batched, one_by_one)
-        # one refused batch per round, then the reads the batch would have made
-        self.assertEqual(batched_trips, one_by_one_trips + 2)
-
-    def test_a_read_reverted_in_the_multicall_is_a_reverted_call(self):
-        with snrc.request_reads():
-            snrc.prefetch([snrc.eth_call_read(*snrc.grace_call(FakeChain.REGISTRAR)), snrc.eth_call_read(FakeChain.REGISTRY, "0xdeadbeef")])
-            _, trips = self.requests_made(lambda: self.assertRaises(RuntimeError, snrc.eth_call, FakeChain.REGISTRY, "0xdeadbeef"))
-        self.assertEqual(trips, 0)
-
-    def test_outside_a_request_nothing_is_prefetched(self):
-        _, trips = self.requests_made(lambda: snrc.prefetch(snrc.lookup_reads("acme.testing")))
-        self.assertEqual(trips, 0)
-
-
-class Aggregate3Tests(unittest.TestCase):
-    def test_calls_are_encoded_as_multicall3_reads_them(self):
-        calls = [(FakeChain.REGISTRY, "0x0178b8bf" + "11" * 32), (FakeChain.RESOLVER, "0x59d1d43c" + "22" * 100)]
-        data = snrc.encode_aggregate3(calls)
-        self.assertTrue(data.startswith(snrc.AGGREGATE3))
-        self.assertEqual(_decode_aggregate3_calls(data), calls)
-
-    def test_results_are_decoded_with_their_success_flags(self):
-        results = [(True, b"\x01" * 40), (False, b""), (True, b"")]
-        self.assertEqual(snrc.decode_aggregate3(_encode_aggregate3_results(results)), results)
-
-    def test_a_truncated_answer_is_refused(self):
-        whole = _encode_aggregate3_results([(True, b"\x01" * 40)])
-        with self.assertRaises(ValueError):
-            snrc.decode_aggregate3(whole[:-64])
-        with self.assertRaises(ValueError):
-            snrc.decode_aggregate3("0x")
-
-
-class RequestLogTests(unittest.TestCase):
-    """Each request is one event with the client it came from, behind a reverse
-    proxy the client the proxy names rather than the proxy itself."""
-
-    def setUp(self):
-        self.server = snrc.ResolverServer(("127.0.0.1", 0), snrc.Handler)
-        threading.Thread(target=self.server.serve_forever, args=(0.05,), daemon=True).start()
-        self._saved = snrc.TRUSTED_PROXIES
-
-    def tearDown(self):
-        snrc.TRUSTED_PROXIES = self._saved
-        self.server.shutdown()
-        self.server.server_close()
-
-    def request(self, path, headers=None, level="INFO"):
-        url = f"http://127.0.0.1:{self.server.server_address[1]}{path}"
-        with self.assertLogs("snrc_resolve", level) as logs:
-            try:
-                urlopen(Request(url, headers=headers or {}), timeout=5).read()
-            except HTTPError:
-                pass
-            deadline = time.monotonic() + 2
-            while not any(r.getMessage() == "request" for r in logs.records) and time.monotonic() < deadline:
-                time.sleep(0.01)
-        [record] = [r for r in logs.records if r.getMessage() == "request"]
-        return record
-
-    def test_a_request_is_logged_with_its_outcome(self):
-        record = self.request("/v2/resolve/x.simplex")
-        fields = record.fields
-        self.assertEqual(record.levelname, "INFO")
-        self.assertEqual(
-            (fields["client"], fields["method"], fields["path"], fields["status"], fields["worker"]),
-            ("127.0.0.1", "GET", "/v2/resolve/x.simplex", 400, os.getpid()),
-        )
-        self.assertGreater(fields["bytes"], 0)
-        self.assertGreaterEqual(fields["ms"], 0)
-
-    def test_a_trusted_proxy_names_the_client(self):
-        snrc.TRUSTED_PROXIES = (ipaddress.ip_network("127.0.0.1/32"),)
-        record = self.request("/v2/resolve/x.simplex", {"X-Forwarded-For": "203.0.113.7"})
-        self.assertEqual(record.fields["client"], "203.0.113.7")
-
-    def test_any_other_peer_cannot_name_itself(self):
-        record = self.request("/v2/resolve/x.simplex", {"X-Forwarded-For": "203.0.113.7"})
-        self.assertEqual(record.fields["client"], "127.0.0.1")
-
-    def test_a_bad_request_is_not_logged_with_the_previous_ones_fields(self):
-        """On a kept-alive connection the handler still held the last request's path and size."""
-        with self.assertLogs("snrc_resolve", "INFO") as logs:
-            with socket.create_connection(self.server.server_address, timeout=5) as sock:
-                sock.sendall(b"GET /v2/resolve/x.simplex HTTP/1.1\r\nHost: x\r\n\r\n")
-                sock.recv(65536)
-                sock.sendall(b"BOGUS\r\n\r\n")
-                while sock.recv(65536):
-                    pass
-        first, second = [r for r in logs.records if r.getMessage() == "request"]
-        self.assertEqual(first.fields["path"], "/v2/resolve/x.simplex")
-        self.assertEqual((second.fields["status"], second.fields["path"], second.fields["bytes"], second.fields["ms"]), (400, None, None, None))
-
-    def test_health_checks_are_logged_only_at_debug(self):
-        """The container checks /health every 30 s."""
-        record = self.request("/health", level="DEBUG")
-        self.assertEqual(record.levelname, "DEBUG")
-
-
-class RequestBodyTests(unittest.TestCase):
-    """Behind a reverse proxy that reuses connections, a body left unread would be
-    answered as another request, and that answer given to the proxy's next client."""
-
-    def setUp(self):
-        self.server = snrc.ResolverServer(("127.0.0.1", 0), snrc.Handler)
-        threading.Thread(target=self.server.serve_forever, args=(0.05,), daemon=True).start()
-        self._log = contextlib.redirect_stderr(io.StringIO())
-        self._log.__enter__()
-
-    def tearDown(self):
-        self._log.__exit__(None, None, None)
-        self.server.shutdown()
-        self.server.server_close()
-
-    def exchange(self, head: bytes, body: bytes = b"") -> bytes:
-        with socket.create_connection(self.server.server_address, timeout=5) as sock:
-            sock.sendall(head + body)
-            data = b""
-            while chunk := sock.recv(65536):
-                data += chunk
-                if data.count(b"HTTP/1.1 ") > 1:
-                    break
-            return data
-
-    SMUGGLED = b"GET /v2/resolve/y.simplex HTTP/1.1\r\nHost: x\r\n\r\n"
-
-    def test_a_body_is_refused_and_the_connection_closed(self):
-        data = self.exchange(b"GET /v2/resolve/x.simplex HTTP/1.1\r\nHost: x\r\nContent-Length: %d\r\n\r\n" % len(self.SMUGGLED), self.SMUGGLED)
-        self.assertEqual(data.count(b"HTTP/1.1 "), 1)
-        self.assertIn(b"HTTP/1.1 400 ", data)
-        self.assertIn(b"Connection: close", data)
-        self.assertNotIn(b"y.simplex", data)
-
-    def test_a_length_after_a_malformed_header_line_is_still_seen(self):
-        """Python stops parsing headers at a malformed line and keeps the rest as payload."""
-        data = self.exchange(b"GET /v2/resolve/x.simplex HTTP/1.1\r\nX-Junk : 1\r\nContent-Length: %d\r\n\r\n" % len(self.SMUGGLED), self.SMUGGLED)
-        self.assertEqual(data.count(b"HTTP/1.1 "), 1)
-        self.assertIn(b"unexpectedBody", data)
-        self.assertNotIn(b"y.simplex", data)
-
-    def test_a_chunked_body_is_refused_and_the_connection_closed(self):
-        chunked = b"%x\r\n" % len(self.SMUGGLED) + self.SMUGGLED + b"\r\n0\r\n\r\n"
-        data = self.exchange(b"GET /v2/resolve/x.simplex HTTP/1.1\r\nHost: x\r\nTransfer-Encoding: chunked\r\n\r\n", chunked)
-        self.assertEqual(data.count(b"HTTP/1.1 "), 1)
-        self.assertNotIn(b"y.simplex", data)
-
-    def test_an_empty_body_keeps_the_connection(self):
-        conn = http.client.HTTPConnection(*self.server.server_address, timeout=5)
-        answers = []
-        for _ in range(2):
-            conn.request("GET", "/v2/resolve/x.simplex", headers={"Content-Length": "0"})
-            res = conn.getresponse()
-            answers.append((res.status, json.loads(res.read())["error"], conn.sock))
-        conn.close()
-        self.assertEqual([a[:2] for a in answers], [(400, "tldNotConfigured")] * 2)
-        self.assertIs(answers[0][2], answers[1][2])
-
-
-class PublicEndpointTests(unittest.TestCase):
-    def test_credentials_path_and_query_are_not_shown(self):
-        self.assertEqual(snrc.public_endpoint("https://user:[email protected]:8443/v2/KEY?apikey=K"), "https://rpc.example:8443")
-
-    def test_a_plain_endpoint_is_unchanged(self):
-        self.assertEqual(snrc.public_endpoint("http://reth:8545"), "http://reth:8545")
-
-    def test_an_ipv6_host_keeps_its_brackets(self):
-        self.assertEqual(snrc.public_endpoint("http://u:p@[::1]:8545/key"), "http://[::1]:8545")
-
-    def test_a_malformed_port_does_not_break_health(self):
-        self.assertEqual(snrc.public_endpoint("http://reth:port"), "http://reth:port")
-
-
-class ClientAddressTests(unittest.TestCase):
-    PROXY = "172.18.0.1"
-
-    def setUp(self):
-        self._saved = snrc.TRUSTED_PROXIES
-        snrc.TRUSTED_PROXIES = (ipaddress.ip_network("172.16.0.0/12"),)
-
-    def tearDown(self):
-        snrc.TRUSTED_PROXIES = self._saved
-
-    def test_a_peer_that_is_no_proxy_is_the_client(self):
-        self.assertEqual(snrc.client_address("198.51.100.9", "203.0.113.7"), "198.51.100.9")
-
-    def test_without_the_header_the_proxy_is_the_client(self):
-        self.assertEqual(snrc.client_address(self.PROXY, None), self.PROXY)
-
-    def test_the_address_the_proxy_added_is_the_client(self):
-        self.assertEqual(snrc.client_address(self.PROXY, "203.0.113.7"), "203.0.113.7")
-
-    def test_addresses_a_client_sent_itself_are_not_believed(self):
-        """A proxy appends the address it saw, so only the last untrusted one is known."""
-        self.assertEqual(snrc.client_address(self.PROXY, "6.6.6.6, 203.0.113.7"), "203.0.113.7")
-
-    def test_trusted_proxies_in_a_chain_are_skipped(self):
-        self.assertEqual(snrc.client_address(self.PROXY, "203.0.113.7, 172.18.0.5"), "203.0.113.7")
-
-    def test_an_address_that_does_not_parse_is_not_believed(self):
-        self.assertEqual(snrc.client_address(self.PROXY, "203.0.113.7, not-an-ip"), self.PROXY)
-
-    def test_an_ipv4_mapped_peer_is_matched_as_ipv4(self):
-        self.assertEqual(snrc.client_address("::ffff:172.18.0.1", "203.0.113.7"), "203.0.113.7")
-
-    def test_an_ipv6_client_is_kept(self):
-        self.assertEqual(snrc.client_address(self.PROXY, "2001:db8::7"), "2001:db8::7")
-
-
-class RequestErrorTests(unittest.TestCase):
-    def setUp(self):
-        self.server = snrc.ResolverServer(("127.0.0.1", 0), snrc.Handler)
-
-    def tearDown(self):
-        self.server.server_close()
-
-    def test_a_client_that_hung_up_is_a_warning_without_a_traceback(self):
-        """What an smp-server that gave up after its timeout leaves behind."""
-        with self.assertLogs("snrc_resolve", "WARNING") as logs:
-            try:
-                raise BrokenPipeError
-            except BrokenPipeError:
-                self.server.handle_error(None, ("198.51.100.9", 4000))
-        [record] = logs.records
-        self.assertEqual((record.levelname, record.getMessage(), record.fields["error"]), ("WARNING", "client_gone", "BrokenPipeError"))
-        self.assertIsNone(record.exc_info)
-
-    def test_a_failure_is_an_error_with_its_traceback(self):
-        with self.assertLogs("snrc_resolve", "ERROR") as logs:
-            try:
-                raise KeyError("boom")
-            except KeyError:
-                self.server.handle_error(None, ("198.51.100.9", 4000))
-        [record] = logs.records
-        self.assertEqual((record.getMessage(), record.fields["client"]), ("request_failed", "198.51.100.9"))
-        self.assertIsNotNone(record.exc_info)
-
-
-class KeepAliveTests(unittest.TestCase):
-    """The smp-server keeps a resolver connection only after an HTTP/1.1
-    response, and otherwise connects for every lookup."""
-
-    def setUp(self):
-        self.server = snrc.ResolverServer(("127.0.0.1", 0), snrc.Handler)
-        threading.Thread(target=self.server.serve_forever, args=(0.05,), daemon=True).start()
-        self._saved_timeout = snrc.Handler.timeout
-        self._log = contextlib.redirect_stderr(io.StringIO())
-        self._log.__enter__()
-
-    def tearDown(self):
-        self._log.__exit__(None, None, None)
-        snrc.Handler.timeout = self._saved_timeout
-        self.server.shutdown()
-        self.server.server_close()
-
-    def test_requests_share_one_connection_without_delay(self):
-        conn = http.client.HTTPConnection(*self.server.server_address, timeout=5)
-        start = time.monotonic()
-        for i in range(20):
-            conn.request("GET", "/v2/resolve/x.simplex")
-            res = conn.getresponse()
-            res.read()
-            self.assertEqual((res.version, res.status), (11, 400))
-            if i == 0:
-                sock = conn.sock
-            self.assertIs(conn.sock, sock)
-        conn.close()
-        # a response held by Nagle for the delayed ACK takes ~40 ms, 20 of them over 0.8 s
-        self.assertLess(time.monotonic() - start, 0.5)
-
-    def test_idle_connections_outlast_the_smp_servers(self):
-        """http-client drops a connection idle for 30 s, checked every 5 s. A
-        resolver that closed sooner would race the client reusing it, and one
-        that never closed would keep a thread per dead connection."""
-        self.assertIsNotNone(self._saved_timeout)
-        self.assertGreater(self._saved_timeout, 35)
-
-    def test_an_idle_connection_is_closed(self):
-        snrc.Handler.timeout = 0.2
-        with socket.create_connection(self.server.server_address, timeout=5) as sock:
-            time.sleep(0.5)
-            self.assertEqual(sock.recv(1), b"")
-
-
-@unittest.skipUnless(sys.platform.startswith("linux"), "reads worker processes from /proc")
-class WorkerProcessesTests(unittest.TestCase):
-    """Workers share the port, and the service stops as a whole, so the
-    container restarts rather than serving on fewer workers."""
-
-    def setUp(self):
-        self.node = FakeNode()
-        with socket.socket() as s:
-            s.bind(("127.0.0.1", 0))
-            self.port = s.getsockname()[1]
-        env = dict(os.environ, SNRC_RPC=self.node.url, SNRC_BIND="127.0.0.1", SNRC_PORT=str(self.port), SNRC_WORKERS="2",
-                   SNRC_REGISTRY_TESTING=FakeChain.REGISTRY, SNRC_REGISTRAR_TESTING=FakeChain.REGISTRAR, SNRC_CONTROLLER_TESTING=FakeChain.CONTROLLER)
-        self.service = subprocess.Popen([sys.executable, os.path.join(_HERE, "snrc-resolve.py")], env=env, stderr=subprocess.PIPE, text=True)
-        self.workers = self._wait_for_workers(2)
-
-    def tearDown(self):
-        if self.service.poll() is None:
-            self.service.kill()
-            self.service.wait()
-        self.service.stderr.close()
-        for pid in self.workers:
-            with contextlib.suppress(ProcessLookupError):
-                os.kill(pid, signal.SIGKILL)
-        self.node.stop()
-
-    def _wait_for_workers(self, count):
-        deadline = time.monotonic() + 10
-        while time.monotonic() < deadline:
-            workers = [int(p) for p in os.listdir("/proc") if p.isdigit() and self._parent(p) == self.service.pid]
-            if len(workers) == count and self._serving():
-                return workers
-            time.sleep(0.05)
-        self.fail("workers did not start")
-
-    @staticmethod
-    def _parent(pid):
-        try:
-            with open(f"/proc/{pid}/stat") as f:
-                return int(f.read().rsplit(")", 1)[1].split()[1])
-        except (FileNotFoundError, ProcessLookupError):
-            return None
-
-    def _serving(self):
-        try:
-            with socket.create_connection(("127.0.0.1", self.port), timeout=1):
-                return True
-        except OSError:
-            return False
-
-    def _gone(self, pid):
-        deadline = time.monotonic() + 5
-        while time.monotonic() < deadline:
-            if self._parent(pid) != self.service.pid:
-                return True
-            time.sleep(0.05)
-        return False
-
-    def test_workers_answer_on_the_shared_port(self):
-        for _ in range(20):
-            with urlopen(f"http://127.0.0.1:{self.port}/v2/resolve/acme.testing", timeout=5) as res:
-                self.assertEqual(json.loads(res.read())["registration"]["type"], "registered")
-
-    def test_stopping_the_service_stops_every_worker(self):
-        self.service.send_signal(signal.SIGTERM)
-        self.assertEqual(self.service.wait(timeout=5), 0)
-        self.assertTrue(all(self._gone(pid) for pid in self.workers))
-        self.assertRegex(self.service.stderr.read(), r"INFO  stopping  signal=SIGTERM")
-
-    def test_a_worker_exiting_stops_the_service(self):
-        os.kill(self.workers[0], signal.SIGKILL)
-        self.assertEqual(self.service.wait(timeout=5), 1)
-        self.assertTrue(self._gone(self.workers[1]))
-
-
-TIME = r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z"
-
-
-class LogTestCase(unittest.TestCase):
-    def setUp(self):
-        self._saved = (snrc.LOG_FORMAT, snrc.LOG_COLOR, snrc.LOG_LEVEL)
-        snrc.LOG_FORMAT, snrc.LOG_COLOR, snrc.LOG_LEVEL = "text", "never", "info"
-        self.out = io.StringIO()
-
-    def tearDown(self):
-        snrc.LOG_FORMAT, snrc.LOG_COLOR, snrc.LOG_LEVEL = self._saved
-        snrc.LOGGER.handlers[:] = []
-        snrc.LOGGER.setLevel(logging.NOTSET)
-        snrc.LOGGER.propagate = True
-
-    def emit(self, level=logging.INFO, name="request", **fields):
-        snrc.setup_logging(self.out)
-        snrc.log_event(level, name, **fields)
-        return self.out.getvalue()
-
-
-class TextFormatTests(LogTestCase):
-    def test_a_line_is_utc_time_level_event_and_fields(self):
-        line = self.emit(client="203.0.113.7", path="/v2/resolve/[4fdd].testing", status=200, ms=7)
-        self.assertRegex(line, rf"^{TIME} INFO  request  client=203\.0\.113\.7 path=/v2/resolve/\[4fdd\]\.testing status=200 ms=7\n$")
-
-    def test_values_that_would_be_misread_are_quoted(self):
-        line = self.emit(message='says "hi" here', empty="", missing=None, eq="a=b")
-        self.assertIn('message="says \\"hi\\" here" empty="" missing=- eq="a=b"', line)
-
-    def test_levels_are_named_in_five_columns(self):
-        self.assertRegex(self.emit(logging.WARNING, "upstream_error"), rf"^{TIME} WARN  upstream_error\n$")
-
-    def test_below_the_configured_level_nothing_is_written(self):
-        self.assertEqual(self.emit(logging.DEBUG), "")
-
-    def test_an_exception_follows_its_line(self):
-        snrc.setup_logging(self.out)
-        try:
-            raise KeyError("boom")
-        except KeyError:
-            snrc.log_event(logging.ERROR, "request_failed", exc_info=True)
-        self.assertRegex(self.out.getvalue(), rf"(?s)^{TIME} ERROR request_failed\nTraceback .*KeyError: 'boom'\n$")
-
-
-class ColorTests(LogTestCase):
-    def test_colours_mark_the_level_and_the_status_class(self):
-        snrc.LOG_COLOR = "always"
-        line = self.emit(status=503)
-        self.assertIn("\033[32mINFO ", line)
-        self.assertIn("\033[31m503\033[0m", line)
-
-    def test_auto_leaves_output_that_is_no_terminal_plain(self):
-        snrc.LOG_COLOR = "auto"
-        self.assertNotIn("\033[", self.emit(status=200))
-
-    def test_never_is_plain(self):
-        self.assertNotIn("\033[", self.emit(status=200))
-
-
-class JsonFormatTests(LogTestCase):
-    def test_a_line_is_one_json_object(self):
-        snrc.LOG_FORMAT = "json"
-        record = json.loads(self.emit(client="203.0.113.7", status=200, missing=None))
-        self.assertRegex(record.pop("time"), rf"^{TIME}$")
-        self.assertEqual(record, {"level": "info", "event": "request", "client": "203.0.113.7", "status": 200, "missing": None})
-
-    def test_an_exception_is_a_field(self):
-        snrc.LOG_FORMAT = "json"
-        snrc.setup_logging(self.out)
-        try:
-            raise KeyError("boom")
-        except KeyError:
-            snrc.log_event(logging.ERROR, "request_failed", exc_info=True)
-        self.assertIn("KeyError: 'boom'", json.loads(self.out.getvalue())["exception"])
-
-
-class SetupTests(LogTestCase):
-    def test_unknown_settings_are_refused_at_start(self):
-        for setting, value in (("LOG_FORMAT", "yaml"), ("LOG_COLOR", "sometimes"), ("LOG_LEVEL", "loud")):
-            with self.subTest(setting=setting):
-                saved = getattr(snrc, setting)
-                setattr(snrc, setting, value)
-                try:
-                    with self.assertRaisesRegex(ValueError, re.escape(f"SNRC_{setting}")):
-                        snrc.setup_logging(self.out)
-                finally:
-                    setattr(snrc, setting, saved)
+if __name__ == "__main__":
+    unittest.main()
@@ -1,156 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.11"
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
-]
-
-[[package]]
-name = "eth-hash"
-version = "0.8.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3c/f5/c67fc24f2f676aa9b7ab29679d44f113f314c817207cd4319353356f62da/eth_hash-0.8.0.tar.gz", hash = "sha256:b009752b620da2e9c7668014849d1f5fadbe4f138603f1871cc5d4ca706896b1", size = 12225, upload-time = "2026-03-25T16:36:55.099Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/87/b36792150ca0b28e4df683a34be15a61461ca0e349e5b5cf3ec8f694edb9/eth_hash-0.8.0-py3-none-any.whl", hash = "sha256:523718a51b369ab89866b929a5c93c52978cd866ea309192ad980dd8271f9fac", size = 7965, upload-time = "2026-03-25T16:36:54.205Z" },
-]
-
-[package.optional-dependencies]
-pycryptodome = [
-    { name = "pycryptodome" },
-]
-
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
-]
-
-[[package]]
-name = "packaging"
-version = "26.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
-]
-
-[[package]]
-name = "pluggy"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
-]
-
-[[package]]
-name = "pycryptodome"
-version = "3.23.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8e/a6/8452177684d5e906854776276ddd34eca30d1b1e15aa1ee9cefc289a33f5/pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef", size = 4921276, upload-time = "2025-05-17T17:21:45.242Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/5d/bdb09489b63cd34a976cc9e2a8d938114f7a53a74d3dd4f125ffa49dce82/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4", size = 2495152, upload-time = "2025-05-17T17:20:20.833Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/ce/7840250ed4cc0039c433cd41715536f926d6e86ce84e904068eb3244b6a6/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae", size = 1639348, upload-time = "2025-05-17T17:20:23.171Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/f0/991da24c55c1f688d6a3b5a11940567353f74590734ee4a64294834ae472/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477", size = 2184033, upload-time = "2025-05-17T17:20:25.424Z" },
-    { url = "https://files.pythonhosted.org/packages/54/16/0e11882deddf00f68b68dd4e8e442ddc30641f31afeb2bc25588124ac8de/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7", size = 2270142, upload-time = "2025-05-17T17:20:27.808Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/fc/4347fea23a3f95ffb931f383ff28b3f7b1fe868739182cb76718c0da86a1/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446", size = 2309384, upload-time = "2025-05-17T17:20:30.765Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/d9/c5261780b69ce66d8cfab25d2797bd6e82ba0241804694cd48be41add5eb/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265", size = 2183237, upload-time = "2025-05-17T17:20:33.736Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/6f/3af2ffedd5cfa08c631f89452c6648c4d779e7772dfc388c77c920ca6bbf/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b", size = 2343898, upload-time = "2025-05-17T17:20:36.086Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/dc/9060d807039ee5de6e2f260f72f3d70ac213993a804f5e67e0a73a56dd2f/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d", size = 2269197, upload-time = "2025-05-17T17:20:38.414Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/34/e6c8ca177cb29dcc4967fef73f5de445912f93bd0343c9c33c8e5bf8cde8/pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a", size = 1768600, upload-time = "2025-05-17T17:20:40.688Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/1d/89756b8d7ff623ad0160f4539da571d1f594d21ee6d68be130a6eccb39a4/pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625", size = 1799740, upload-time = "2025-05-17T17:20:42.413Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/61/35a64f0feaea9fd07f0d91209e7be91726eb48c0f1bfc6720647194071e4/pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39", size = 1703685, upload-time = "2025-05-17T17:20:44.388Z" },
-    { url = "https://files.pythonhosted.org/packages/db/6c/a1f71542c969912bb0e106f64f60a56cc1f0fabecf9396f45accbe63fa68/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27", size = 2495627, upload-time = "2025-05-17T17:20:47.139Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/4e/a066527e079fc5002390c8acdd3aca431e6ea0a50ffd7201551175b47323/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843", size = 1640362, upload-time = "2025-05-17T17:20:50.392Z" },
-    { url = "https://files.pythonhosted.org/packages/50/52/adaf4c8c100a8c49d2bd058e5b551f73dfd8cb89eb4911e25a0c469b6b4e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490", size = 2182625, upload-time = "2025-05-17T17:20:52.866Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/e9/a09476d436d0ff1402ac3867d933c61805ec2326c6ea557aeeac3825604e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575", size = 2268954, upload-time = "2025-05-17T17:20:55.027Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/c5/ffe6474e0c551d54cab931918127c46d70cab8f114e0c2b5a3c071c2f484/pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b", size = 2308534, upload-time = "2025-05-17T17:20:57.279Z" },
-    { url = "https://files.pythonhosted.org/packages/18/28/e199677fc15ecf43010f2463fde4c1a53015d1fe95fb03bca2890836603a/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a", size = 2181853, upload-time = "2025-05-17T17:20:59.322Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/ea/4fdb09f2165ce1365c9eaefef36625583371ee514db58dc9b65d3a255c4c/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f", size = 2342465, upload-time = "2025-05-17T17:21:03.83Z" },
-    { url = "https://files.pythonhosted.org/packages/22/82/6edc3fc42fe9284aead511394bac167693fb2b0e0395b28b8bedaa07ef04/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa", size = 2267414, upload-time = "2025-05-17T17:21:06.72Z" },
-    { url = "https://files.pythonhosted.org/packages/59/fe/aae679b64363eb78326c7fdc9d06ec3de18bac68be4b612fc1fe8902693c/pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886", size = 1768484, upload-time = "2025-05-17T17:21:08.535Z" },
-    { url = "https://files.pythonhosted.org/packages/54/2f/e97a1b8294db0daaa87012c24a7bb714147c7ade7656973fd6c736b484ff/pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2", size = 1799636, upload-time = "2025-05-17T17:21:10.393Z" },
-    { url = "https://files.pythonhosted.org/packages/18/3d/f9441a0d798bf2b1e645adc3265e55706aead1255ccdad3856dbdcffec14/pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c", size = 1703675, upload-time = "2025-05-17T17:21:13.146Z" },
-]
-
-[[package]]
-name = "pygments"
-version = "2.21.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
-]
-
-[[package]]
-name = "pytest"
-version = "9.1.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "pygments" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
-]
-
-[[package]]
-name = "ruff"
-version = "0.16.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/bf/c935ca98e73fe8ce65b87ef08a280c0c1e85295d569228c15e87d8fdfaf1/ruff-0.16.9.tar.gz", hash = "sha256:12b625c6cfba78d285d9f48eda5f053374f1e53cb10ef17342a383750db99161", size = 4948764, upload-time = "2026-09-24T20:37:49.416Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/26/df51322b52ee1ada7eff2d071ea09d11d5c2d1dcc9f02594f5785c4d1635/ruff-0.16.9-py3-none-linux_armv6l.whl", hash = "sha256:95e6f022090368ab3b824c36276839c53b2adf1a3f4c09fefc33dfc400f6da96", size = 10082922, upload-time = "2026-09-24T20:37:13.045Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/27/7bf51f5a7aa375e9f339280a303aab44ca75dc1525f1cdc5991761685b0f/ruff-0.16.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a5f27be168556594a86d2f415db0cf43f5291917849318f873c7e2791f7a8c67", size = 10236360, upload-time = "2026-09-24T20:37:16.049Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/63/09659283f92f02dff45809da194a70da2f688d87c55d8875c4fae3536072/ruff-0.16.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1632eb1d6197f33bd00b1acbc5b71009e89a8895c158e2d2b03a834fac964ab6", size = 9892940, upload-time = "2026-09-24T20:37:17.957Z" },
-    { url = "https://files.pythonhosted.org/packages/24/58/98de1b72ec172f5f8f1731236fe21585b3998bf7dfe9fcc44ae9ba626012/ruff-0.16.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3f951b14d865d5952c89d40a5ca07e87abe24fa5453299878411e127748fb1c", size = 10032114, upload-time = "2026-09-24T20:37:19.942Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/7d/f1e17c54ab59d4bad1dce8ee3e22a7a1d0ef4745240decacdcf3832b5bb2/ruff-0.16.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:447fc07e1573afff7cb02803462b12b6c8ece7cf10e2cd78565fa6d7a1c0bf8d", size = 9910227, upload-time = "2026-09-24T20:37:21.872Z" },
-    { url = "https://files.pythonhosted.org/packages/34/19/436f647a65075bbd3bab2668b3bdaa5120559b294694018cdcefabbbf30b/ruff-0.16.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a3e039a6a40ed976c491722b60e0ae4a4aa1a86057f540ee7a37a5d19ae9120", size = 10547484, upload-time = "2026-09-24T20:37:24.229Z" },
-    { url = "https://files.pythonhosted.org/packages/03/59/38430a6bc2f6d8095447ac39625cf8b6e9344a47e6c26225c8ba1bff3ffb/ruff-0.16.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4684dded7db60aa57cb118fa158630f5feade4af5782903b6053484bdf9bd129", size = 11412367, upload-time = "2026-09-24T20:37:26.307Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/bd/bbb6d7fc7f208c8b8c50dd5dc8206e4cfdb1e7a8fb852606a3adf370c880/ruff-0.16.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d29c934357e45642fda2f34c0b1f4025b4a6c01e15e4bf0016879d60078a142c", size = 10869787, upload-time = "2026-09-24T20:37:28.35Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/b8/9c543074918061abbefc3bd139bee22de35abedb00dde0f2d27288838962/ruff-0.16.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a21713e629d3e5bdb2f5c2def1cc7f04f47fa8e1a7eb0571b4a28e1da64bc728", size = 10406494, upload-time = "2026-09-24T20:37:30.624Z" },
-    { url = "https://files.pythonhosted.org/packages/35/7a/5a8851bd146e7ccf8fd4b003f6c75c11f8fbdb0e60673b45097986b6bf41/ruff-0.16.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7baa24ef5fc8e77aa93879e1d3f43754a01ae488e869f1ae30cf431afd4d2452", size = 10590083, upload-time = "2026-09-24T20:37:32.439Z" },
-    { url = "https://files.pythonhosted.org/packages/87/f0/4c3467188f23f806960b46fa76575a7cd0514c9ba90562650b71efc96980/ruff-0.16.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a41aac6230aadfaa133bdfa1614488531ffa3e0837567ae04c0da2058a9c0f9e", size = 10119151, upload-time = "2026-09-24T20:37:34.581Z" },
-    { url = "https://files.pythonhosted.org/packages/15/34/5a4def5adea572ce6aea0bb64f21f928ee317b80e0db747d7979b01d7261/ruff-0.16.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:c2529fb5896d49115b0e9aa8f887490b34bbe76baf879ec2264ac59406869ce7", size = 9911544, upload-time = "2026-09-24T20:37:36.796Z" },
-    { url = "https://files.pythonhosted.org/packages/62/5d/d15ebea7499eef9373318c0ee6ca127832927c6529731f6d48e18dce7ca9/ruff-0.16.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:41e3870277694177429b56406d65dfbdb2c2802c52b715edaf6a0b829c69d4ee", size = 10269884, upload-time = "2026-09-24T20:37:38.857Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/56/c5d3cd119ded7a3c7aba0e961b69cb3df701c91662c98ad694467d060ce1/ruff-0.16.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:8adbe4e58af167f767d7b2ba5e83c42e878350796cf78c2f5e14ab9903a92588", size = 10749366, upload-time = "2026-09-24T20:37:41.042Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/fe/734ec7527029ac757ecf821f143c9f3fcf69149c21f53a044a899b430f5a/ruff-0.16.9-py3-none-win32.whl", hash = "sha256:0e1dbc2073624dee6618d41d0098690a7244654af746704b64759e12b6b6b385", size = 10152355, upload-time = "2026-09-24T20:37:43.025Z" },
-    { url = "https://files.pythonhosted.org/packages/14/21/26e4643629b3ebb44f0a06f9c9a53058d63d989415f63a9a3c28e2ee7f22/ruff-0.16.9-py3-none-win_amd64.whl", hash = "sha256:6bd40fec8cd4c8a3d4dd589bd8ad4e6320c13c29234159bfd959a40d529d597b", size = 10592965, upload-time = "2026-09-24T20:37:44.944Z" },
-    { url = "https://files.pythonhosted.org/packages/51/60/5fb1a39dbb5ae314d5f59bc7348a63c1d5c20f3cd83914c4b5cb0be31d2d/ruff-0.16.9-py3-none-win_arm64.whl", hash = "sha256:ed1a252039200f57a59eebc063b54beabea67bfbaaca0eeaa7f54b5fbcda2284", size = 10458649, upload-time = "2026-09-24T20:37:46.882Z" },
-]
-
-[[package]]
-name = "snrc-resolve"
-version = "0.1.0"
-source = { virtual = "." }
-dependencies = [
-    { name = "eth-hash", extra = ["pycryptodome"] },
-]
-
-[package.dev-dependencies]
-dev = [
-    { name = "pytest" },
-    { name = "ruff" },
-]
-
-[package.metadata]
-requires-dist = [{ name = "eth-hash", extras = ["pycryptodome"], specifier = ">=0.7" }]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "pytest", specifier = ">=8" },
-    { name = "ruff", specifier = ">=0.6" },
-]
@@ -195,8 +195,6 @@ library
          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260712_address_dr_rpc
          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260823_snd_files_entitlement
          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260919_ratchet_verify_codes
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260929_ratchet_indexes
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20261008_rcv_switch_status
  else
      exposed-modules:
          Simplex.Messaging.Agent.Store.SQLite
@@ -252,9 +250,6 @@ library
          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260712_address_dr_rpc
          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260823_snd_files_entitlement
          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260919_ratchet_verify_codes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260929_ratchet_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261005_commands_autoincrement
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261008_rcv_switch_status
          Simplex.Messaging.Agent.Store.SQLite.Util
  if flag(client_postgres) || flag(server_postgres)
      exposed-modules:
@@ -602,7 +597,7 @@ test-suite simplexmq-test
  default-extensions:
      StrictData
  -- add -fhpc to ghc-options to run tests with coverage
-  ghc-options: -Weverything -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-missing-kind-signatures -Wno-missing-deriving-strategies -Wno-monomorphism-restriction -Wno-prepositive-qualified-module -Wno-implicit-prelude -Wno-missing-safe-haskell-mode -Wno-missing-export-lists -Wno-partial-fields -Wcompat -Werror=incomplete-record-updates -Werror=incomplete-patterns -Werror=incomplete-uni-patterns -Werror=missing-methods -Werror=tabs -Wredundant-constraints -Wincomplete-record-updates -Wunused-type-patterns -O2 -threaded -rtsopts "-with-rtsopts=-A64M -N"
+  ghc-options: -Weverything -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-missing-kind-signatures -Wno-missing-deriving-strategies -Wno-monomorphism-restriction -Wno-prepositive-qualified-module -Wno-implicit-prelude -Wno-missing-safe-haskell-mode -Wno-missing-export-lists -Wno-partial-fields -Wcompat -Werror=incomplete-record-updates -Werror=incomplete-patterns -Werror=incomplete-uni-patterns -Werror=missing-methods -Werror=tabs -Wredundant-constraints -Wincomplete-record-updates -Wunused-type-patterns -O2 -threaded -rtsopts -with-rtsopts=-A64M -with-rtsopts=-N1
  build-depends:
      base
    , aeson
@@ -640,6 +635,7 @@ test-suite simplexmq-test
    , stm
    , text
    , time
+    , timeit ==2.0.*
    , tls >=1.9.0 && <1.10
    , transformers
    , unliftio
@@ -279,7 +279,6 @@ retryOnError name loop done e = do

 rcvWorkerInternalError :: AgentClient -> DBRcvFileId -> RcvFileId -> Maybe RcvFileId -> Maybe FilePath -> AgentErrorType -> AM ()
 rcvWorkerInternalError c rcvFileId rcvFileEntityId redirectEntityId_ tmpPath err = do
-  liftIO $ throwWhenInactive c
  lift $ forM_ tmpPath (removePath <=< toFSFilePath)
  withStore' c $ \db -> updateRcvFileError db rcvFileId (show err)
  notify c (fromMaybe rcvFileEntityId redirectEntityId_) (RFERR err)
@@ -319,6 +318,9 @@ runXFTPRcvLocalWorker c Worker {doWork} = do
          withStore' c (`updateRcvFileComplete` rcvFileId)
        Just RcvFileRedirect {redirectFileInfo, redirectDbId} -> do
          let RedirectFileInfo {size = redirectSize, digest = redirectDigest} = redirectFileInfo
+          lift $ forM_ tmpPath (removePath <=< toFSFilePath)
+          liftIO $ waitUntilForeground c
+          withStore' c (`updateRcvFileComplete` rcvFileId)
          -- proceed with redirect
          yaml <- liftError (FILE . FILE_IO . show) (CF.readFile $ CryptoFile fsSavePath cfArgs) `allFinally` (lift $ toFSFilePath fsSavePath >>= removePath)
          next@FileDescription {chunks = nextChunks} <- case strDecode (LB.toStrict yaml) of
@@ -328,12 +330,9 @@ runXFTPRcvLocalWorker c Worker {doWork} = do
              | dstSize /= redirectSize -> throwE . FILE $ REDIRECT "size mismatch"
              | dstDigest /= redirectDigest -> throwE . FILE $ REDIRECT "digest mismatch"
              | otherwise -> pure fd
-          liftIO $ waitUntilForeground c
          -- register and download chunks from the actual file
-          withStore c $ \db -> updateRcvFileComplete db rcvFileId >> updateRcvFileRedirect db redirectDbId next
+          withStore c $ \db -> updateRcvFileRedirect db redirectDbId next
          forM_ nextChunks (downloadChunk c)
-          flip catchAllErrors (\e -> logError $ "XFTP rcv worker error: " <> tshow e) $
-            lift $ forM_ tmpPath (removePath <=< toFSFilePath)
      where
        getChunkPaths :: [RcvFileChunk] -> AM [FilePath]
        getChunkPaths [] = pure []
@@ -513,7 +512,6 @@ runXFTPSndPrepareWorker c Worker {doWork} = do

 sndWorkerInternalError :: AgentClient -> DBSndFileId -> SndFileId -> Maybe FilePath -> AgentErrorType -> AM ()
 sndWorkerInternalError c sndFileId sndFileEntityId prefixPath err = do
-  liftIO $ throwWhenInactive c
  lift . forM_ prefixPath $ removePath <=< toFSFilePath
  withStore' c $ \db -> updateSndFileError db sndFileId (show err)
  notify c sndFileEntityId $ SFERR err
@@ -570,10 +568,9 @@ runXFTPSndWorker c srv Worker {doWork} = do
      notify c sndFileEntityId $ SFPROG uploaded total
      when complete $ do
        (sndDescr, rcvDescrs) <- sndFileToDescrs sf
-        flip catchAllErrors (\e -> logError $ "XFTP snd worker error: " <> tshow e) $ do
-          lift . forM_ prefixPath $ removePath <=< toFSFilePath
-          withStore' c $ \db -> updateSndFileComplete db sndFileId
        notify c sndFileEntityId $ SFDONE sndDescr rcvDescrs (sndFileExpiresAt chunks)
+        lift . forM_ prefixPath $ removePath <=< toFSFilePath
+        withStore' c $ \db -> updateSndFileComplete db sndFileId
      where
        addRecipients :: SndFileChunk -> SndFileChunkReplica -> AM SndFileChunkReplica
        addRecipients ch@SndFileChunk {numRecipients} cr@SndFileChunkReplica {sndChunkReplicaId, rcvIdsKeys}
@@ -735,7 +732,6 @@ runXFTPDelWorker c srv Worker {doWork} = do

 delWorkerInternalError :: AgentClient -> Int64 -> AgentErrorType -> AM ()
 delWorkerInternalError c deletedSndChunkReplicaId e = do
-  liftIO $ throwWhenInactive c
  withStore' c $ \db -> deleteDeletedSndChunkReplica db deletedSndChunkReplicaId
  notify c "" $ SFERR e

@@ -80,7 +80,7 @@ import Simplex.Messaging.Protocol
    tParse,
  )
 import Simplex.Messaging.Transport (THandleParams (..), TransportError (..), TransportPeer (..))
-import Simplex.Messaging.Util (eitherToMaybe, (<$?>))
+import Simplex.Messaging.Util ((<$?>))

 xftpBlockSize :: Int
 xftpBlockSize = 16384
@@ -383,7 +383,7 @@ checkParty' c = case testEquality (sFileParty @p) (sFileParty @p') of
 xftpEncodeAuthTransmission :: ProtocolEncoding XFTPVersion XFTPErrorType c => THandleParams XFTPVersion 'TClient -> C.APrivateAuthKey -> Transmission c -> Either TransportError ByteString
 xftpEncodeAuthTransmission thParams@THandleParams {thAuth} pKey t@(corrId, _, _) = do
  let TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth thParams t
-  xftpEncodeBatch1 . (,tToSend) =<< authTransmission thAuth False (Just pKey) (eitherToMaybe $ C.cbNonce $ bs corrId) tForAuth
+  xftpEncodeBatch1 . (,tToSend) =<< authTransmission thAuth False (Just pKey) (C.cbNonce $ bs corrId) tForAuth

 xftpEncodeTransmission :: ProtocolEncoding XFTPVersion XFTPErrorType c => THandleParams XFTPVersion p -> Transmission c -> Either TransportError ByteString
 xftpEncodeTransmission thParams t = xftpEncodeBatch1 (Nothing, encodeTransmission thParams t)
@@ -312,7 +312,7 @@ import Simplex.Messaging.Session
 import Simplex.Messaging.SystemTime
 import Simplex.Messaging.TMap (TMap)
 import qualified Simplex.Messaging.TMap as TM
-import Simplex.Messaging.Transport (HandshakeError (..), SMPServiceRole (..), SMPVersion, ServiceCredentials (..), SessionId, THClientService' (..), THandleAuth (..), THandleParams (sessionId, thAuth, thVersion, serverInfo), TransportError (..), newNtfCredsSMPVersion)
+import Simplex.Messaging.Transport (HandshakeError (..), SMPServiceRole (..), SMPVersion, ServiceCredentials (..), SessionId, THClientService' (..), THandleAuth (..), THandleParams (sessionId, thAuth, thVersion, serverInfo), TransportError (..), TransportPeer (..), shortLinksSMPVersion, newNtfCredsSMPVersion)
 import Simplex.Messaging.Transport.Client (TransportHost (..))
 import Simplex.Messaging.Transport.Credentials
 import Simplex.Messaging.Util
@@ -1261,12 +1261,9 @@ sendOrProxySMPCommand c nm userId destSrv@ProtocolServer {host = destHosts} conn
          Left e -> throwE e

 ipAddressProtected :: NetworkConfig -> ProtocolServer p -> Bool
-ipAddressProtected NetworkConfig {socksProxy, socksMode, hostMode} (ProtocolServer _ hosts _ _)
-  | isJust socksProxy = socksMode == SMAlways || if hostMode == HMPublic then allOnion else anyOnion
-  | otherwise = hostMode == HMOnion && anyOnion
+ipAddressProtected NetworkConfig {socksProxy, hostMode} (ProtocolServer _ hosts _ _) = do
+  isJust socksProxy || (hostMode == HMOnion && any isOnionHost hosts)
  where
-    anyOnion = any isOnionHost hosts
-    allOnion = all isOnionHost hosts
    isOnionHost = \case THOnionHost _ -> True; _ -> False

 withNtfClient :: AgentClient -> NetworkRequestMode -> NtfServer -> EntityId -> ByteString -> (NtfClient -> ExceptT NtfClientError IO a) -> AM a
@@ -1499,7 +1496,7 @@ newRcvQueue_ c nm userId connId (ProtoServerWithAuth srv auth) vRange cqrd enabl
  let sessServiceId = (\THClientService {serviceId = sId} -> sId) <$> (clientService =<< thAuth thParams')
  when (isJust serviceId && serviceId /= sessServiceId) $ logError "incorrect service ID in NEW response"
  liftIO . logServer "<--" c srv NoEntity $ B.unwords ["IDS", logSecret rcvId, logSecret sndId]
-  shortLink <- mkShortLinkCreds qik
+  shortLink <- mkShortLinkCreds thParams' qik
  let rq =
        RcvQueue
          { userId,
@@ -1540,8 +1537,8 @@ newRcvQueue_ c nm userId connId (ProtoServerWithAuth srv auth) vRange cqrd enabl
      (Just ((ntfPublicKey, ntfPrivateKey), dhpk), Just (ServerNtfCreds notifierId dhk')) ->
        Just ClientNtfCreds {ntfPublicKey, ntfPrivateKey, notifierId, rcvNtfDhSecret = C.dh' dhk' dhpk}
      _ -> Nothing
-    mkShortLinkCreds :: QueueIdsKeys -> AM (Maybe ShortLinkCreds)
-    mkShortLinkCreds QIK {sndId, queueMode, linkId} = case (cqrd, queueMode) of
+    mkShortLinkCreds :: THandleParams SMPVersion 'TClient -> QueueIdsKeys -> AM (Maybe ShortLinkCreds)
+    mkShortLinkCreds thParams' QIK {sndId, queueMode, linkId} = case (cqrd, queueMode) of
      (CQRMessaging ld, Just QMMessaging) ->
        withLinkData ld $ \lnkId CQRData {linkKey, privSigKey, srvReq = (sndId', d)} ->
          if sndId == sndId'
@@ -1555,9 +1552,11 @@ newRcvQueue_ c nm userId connId (ProtoServerWithAuth srv auth) vRange cqrd enabl
      (_, Nothing) -> newErr "unexpected link ID"
      _ -> newErr "unexpected queue mode"
      where
+        v = thVersion thParams'
        withLinkData :: Maybe d -> (SMP.LinkId -> d -> AM (Maybe ShortLinkCreds)) -> AM (Maybe ShortLinkCreds)
        withLinkData ld_ mkLink = case (ld_, linkId) of
          (Just ld, Just lnkId) -> mkLink lnkId ld
+          (Just _, Nothing) | v < shortLinksSMPVersion -> pure Nothing
          (Nothing, Nothing) -> pure Nothing
          _ -> newErr "unexpected or absent link ID"
        newErr :: String -> AM (Maybe ShortLinkCreds)
@@ -1717,7 +1716,7 @@ subscribeSessQueues_ c withEvents qs = sendClientBatch_ "SUB" False subscribe_ c
      rs <- sendBatch (\smp' _ -> subscribeSMPQueues smp') smp NRMBackground qs'
      cs_ <-
        if withEvents
-          then Just . S.fromList . map qConnId . M.elems <$> atomically (SS.getActiveSubs tSess $ currentSubs c)
+          then Just <$> atomically (SS.getActiveConns tSess $ currentSubs c)
          else pure Nothing
      active <- E.uninterruptibleMask_ $ do
        (active, (serviceQs, notices)) <- atomically $ do
@@ -1735,13 +1734,13 @@ subscribeSessQueues_ c withEvents qs = sendClientBatch_ "SUB" False subscribe_ c
        pure active
      forM_ cs_ $ \cs -> do
        let (errs, okConns) = partitionEithers $ map (\(RcvQueueSub {connId}, r) -> bimap (connId,) (const connId) r) $ L.toList rs
-            conns = filter (`S.notMember` cs) okConns
+            conns = filter (`M.notMember` cs) okConns
        unless (null conns) $ notifySub c $ UP srv conns
        forM_ (L.nonEmpty errs) $ \errs' -> do
          let noFinalErrs = all (temporaryClientError . snd) errs'
              addr = B.unpack $ strEncode srv
          notifySub c $ ERRS $ L.map (second $ protocolClientError SMP addr) errs'
-          when (null okConns && S.null cs && noFinalErrs && active) $ liftIO $ do
+          when (null okConns && M.null cs && noFinalErrs && active) $ liftIO $ do
            -- We only close the client session that was used to subscribe.
            v_ <- atomically $ ifM (activeClientSession c tSess sessId) (TM.lookupDelete tSess $ smpClients c) (pure Nothing)
            mapM_ (closeClient_ c) v_
@@ -1982,7 +1981,7 @@ decryptSMPMessage :: RcvQueue -> SMP.RcvMessage -> AM SMP.ClientRcvMsgBody
 decryptSMPMessage rq SMP.RcvMessage {msgId, msgBody = SMP.EncRcvMsgBody body} =
  liftEither $ parse SMP.clientRcvMsgBodyP (AGENT $ A_MESSAGE "decrypt message") =<< decrypt body
  where
-    decrypt = agentCbDecrypt (rcvDhSecret rq) msgId
+    decrypt = agentCbDecrypt (rcvDhSecret rq) (C.cbNonce msgId)

 secureQueue :: AgentClient -> NetworkRequestMode -> RcvQueue -> SndPublicAuthKey -> AM ()
 secureQueue c nm rq@RcvQueue {rcvId, rcvPrivateKey} senderKey =
@@ -2080,9 +2079,9 @@ disableQueuesNtfs c = sendTSessionBatches "NDEL" (mkSMPTSession . snd) disableQu
    queueCreds :: DisableQueueNtfReq -> (SMP.RecipientId, SMP.RcvPrivateAuthKey)
    queueCreds (_, RcvQueue {rcvPrivateKey, rcvId}) = (rcvId, rcvPrivateKey)

-sendAck :: AgentClient -> RcvQueue -> MsgId -> AM QueueDrained
+sendAck :: AgentClient -> RcvQueue -> MsgId -> AM ()
 sendAck c rq@RcvQueue {rcvId, rcvPrivateKey} msgId =
-  withSMPClient c NRMBackground rq ("ACK:" <> logSecret' (SMP.unMsgId msgId)) $ \smp ->
+  withSMPClient c NRMBackground rq ("ACK:" <> logSecret' msgId) $ \smp ->
    ackSMPMessage smp rcvPrivateKey rcvId msgId

 hasGetLock :: SomeRcvQueue q => AgentClient -> q -> IO Bool
@@ -2277,7 +2276,7 @@ agentCbEncryptOnce clientVersion dhRcvPubKey msg = do

 -- | NaCl crypto-box decrypt - both for messages received from the server
 -- and per-queue E2E encrypted messages from the sender that were inside.
-agentCbDecrypt :: C.CbNonceI n => C.DhSecretX25519 -> n -> ByteString -> Either AgentErrorType ByteString
+agentCbDecrypt :: C.DhSecretX25519 -> C.CbNonce -> ByteString -> Either AgentErrorType ByteString
 agentCbDecrypt dhSecret nonce msg =
  first cryptoError $
    C.cbDecrypt dhSecret nonce msg
@@ -79,7 +79,6 @@ module Simplex.Messaging.Agent.Protocol
    SMPConfirmation (..),
    AgentMsgEnvelope (..),
    AgentMessage (..),
-    RatchetInfo (..),
    RequestSignature (..),
    AgentMessageType (..),
    APrivHeader (..),
@@ -246,6 +245,7 @@ import Simplex.Messaging.Crypto.Ratchet
    RcvE2ERatchetParams,
    RcvE2ERatchetParamsUri,
    SndE2ERatchetParams,
+    RcvE2EPrivRatchetParams,
    pattern PQSupportOff,
    pattern PQSupportOn,
  )
@@ -611,7 +611,6 @@ data RcvSwitchStatus
  | RSSendingQADD
  | RSSendingQUSE
  | RSReceivedMessage
-  | RSReceivedQEND
  deriving (Eq, Show)

 instance StrEncoding RcvSwitchStatus where
@@ -620,14 +619,12 @@ instance StrEncoding RcvSwitchStatus where
    RSSendingQADD -> "sending_qadd"
    RSSendingQUSE -> "sending_quse"
    RSReceivedMessage -> "received_message"
-    RSReceivedQEND -> "received_qend"
  strP =
    A.takeTill (== ' ') >>= \case
      "switch_started" -> pure RSSwitchStarted
      "sending_qadd" -> pure RSSendingQADD
      "sending_quse" -> pure RSSendingQUSE
      "received_message" -> pure RSReceivedMessage
-      "received_qend" -> pure RSReceivedQEND
      _ -> fail "bad RcvSwitchStatus"

 instance ToField RcvSwitchStatus where toField = toField . decodeLatin1 . strEncode
@@ -931,7 +928,7 @@ data AgentMessage
  | -- AgentConnInfoReply is used by accepting party in duplexHandshake mode (v2), allowing to include reply queue(s) in the initial confirmation.
    -- It made removed REPLY message unnecessary.
    AgentConnInfoReply (NonEmpty SMPQueueInfo) ConnInfo
-  | AgentRatchetInfo RatchetInfo
+  | AgentRatchetInfo ByteString
  | AgentMessage APrivHeader AMessage
  | AgentServiceRequest (NonEmpty SMPQueueInfo) (Maybe RequestSignature) MsgBody
  | AgentServiceResponse MsgBody
@@ -942,7 +939,7 @@ instance Encoding AgentMessage where
  smpEncode = \case
    AgentConnInfo cInfo -> smpEncode ('I', Tail cInfo)
    AgentConnInfoReply smpQueues cInfo -> smpEncode ('D', smpQueues, Tail cInfo) -- 'D' stands for "duplex"
-    AgentRatchetInfo info -> smpEncode ('R', info)
+    AgentRatchetInfo info -> smpEncode ('R', Tail info)
    AgentMessage hdr aMsg -> smpEncode ('M', hdr, aMsg)
    AgentServiceRequest qs sig_ body -> smpEncode ('A', qs, sig_, Tail body)
    AgentServiceResponse body -> smpEncode ('P', Tail body)
@@ -951,23 +948,13 @@ instance Encoding AgentMessage where
    smpP >>= \case
      'I' -> AgentConnInfo . unTail <$> smpP
      'D' -> AgentConnInfoReply <$> smpP <*> (unTail <$> smpP)
-      'R' -> AgentRatchetInfo <$> smpP
+      'R' -> AgentRatchetInfo . unTail <$> smpP
      'M' -> AgentMessage <$> smpP <*> smpP
      'A' -> AgentServiceRequest <$> smpP <*> smpP <*> (unTail <$> smpP)
      'P' -> AgentServiceResponse . unTail <$> smpP
      'J' -> AgentRejection . unTail <$> smpP
      _ -> fail "bad AgentMessage"

-data RatchetInfo = RatchetInfo {answeredKeyHash :: Maybe ByteString}
-  deriving (Eq, Show)
-
-instance Encoding RatchetInfo where
-  smpEncode RatchetInfo {answeredKeyHash} = smpEncode answeredKeyHash
-  smpP = do
-    answeredKeyHash <- smpP <|> pure Nothing
-    _ <- A.takeByteString
-    pure RatchetInfo {answeredKeyHash}
-
 -- internal type for storing message type in the database
 data AgentMessageType
  = AM_CONN_INFO
@@ -1626,7 +1613,7 @@ newtype LinkKey = LinkKey ByteString -- sha3-256(fixed_data)
 instance ToField LinkKey where toField (LinkKey s) = toField $ Binary s

 -- | Parameters for creating a connection with a prepared link.
-data PreparedLinkParams k = PreparedLinkParams
+data PreparedLinkParams = PreparedLinkParams
  { -- | Correlation ID / determines sender ID
    plpNonce :: C.CbNonce,
    -- | Queue E2EE DH key pair
@@ -1641,8 +1628,8 @@ data PreparedLinkParams k = PreparedLinkParams
    plpSrvWithAuth :: SMPServerWithAuth,
    -- | Initial PQ keys
    plpInitKeys :: InitialKeys,
-    -- | Contact address double ratchet keys or invitation X3DH keys
-    plpRatchetKeys :: k
+    -- | Contact address double ratchet keys
+    plpAddressKeys :: Maybe (RatchetKeyId, RcvE2EPrivRatchetParams 'C.X448)
  }

 instance ConnectionModeI c => ToField (ConnectionLink c) where toField = toField . Binary . strEncode
@@ -219,7 +219,6 @@ canAbortRcvSwitch ConnData {connAgentVersion} = maybe False canAbort . rcvSwchSt
      -- if switch is in RSReceivedMessage status, aborting switch (deleting new queue)
      -- will break the connection because the sender would have original queue deleted
      RSReceivedMessage -> False
-      RSReceivedQEND -> False

 data ClientNtfCreds = ClientNtfCreds
  { -- | key pair to be used by the notification server to authorize transmissions
@@ -76,7 +76,6 @@ module Simplex.Messaging.Agent.Store.AgentStore
    getExpiredServiceConns,
    deleteExpiredServiceRequests,
    getDeletedWaitingDeliveryConnIds,
-    getConnRatchetSync,
    setConnRatchetSync,
    addProcessedRatchetKeyHash,
    checkRatchetKeyHashExists,
@@ -100,7 +99,6 @@ module Simplex.Messaging.Agent.Store.AgentStore
    setSndQueuePrimary,
    deleteConnRcvQueue,
    incRcvDeleteErrors,
-    getEndedRcvQueueConnIds,
    deleteConnSndQueue,
    getPrimaryRcvQueue,
    getRcvQueue,
@@ -764,10 +762,6 @@ incRcvDeleteErrors :: DB.Connection -> RcvQueue -> IO ()
 incRcvDeleteErrors db RcvQueue {connId, dbQueueId} =
  DB.execute db "UPDATE rcv_queues SET delete_errors = delete_errors + 1 WHERE conn_id = ? AND rcv_queue_id = ?" (connId, dbQueueId)

-getEndedRcvQueueConnIds :: DB.Connection -> IO [ConnId]
-getEndedRcvQueueConnIds db =
-  map fromOnly <$> DB.query db "SELECT conn_id FROM rcv_queues WHERE switch_status = ? AND deleted = 0" (Only RSReceivedQEND)
-
 deleteConnRcvQueue :: DB.Connection -> RcvQueue -> IO ()
 deleteConnRcvQueue db RcvQueue {connId, dbQueueId} =
  DB.execute db "DELETE FROM rcv_queues WHERE conn_id = ? AND rcv_queue_id = ?" (connId, dbQueueId)
@@ -1260,7 +1254,7 @@ getLastMsg db connId msgId =
        LEFT JOIN snd_messages s ON s.conn_id = r.conn_id AND s.rcpt_internal_id = r.internal_id
        WHERE r.conn_id = ? AND r.broker_id = ?
      |]
-      (connId, msgId)
+      (connId, Binary msgId)

 toRcvMsg :: (Int64, InternalTs, BrokerId, BrokerTs) :. (AgentMsgId, MsgIntegrity, MsgHash, AgentMessageType, MsgBody, PQEncryption, Maybe AgentMsgId, Maybe MsgReceiptStatus, BoolInt) -> RcvMsg
 toRcvMsg ((agentMsgId, internalTs, brokerId, brokerTs) :. (sndMsgId, integrity, internalHash, msgType, msgBody, pqEncryption, rcptInternalId_, rcptStatus_, BI userAck)) =
@@ -1292,7 +1286,7 @@ checkRcvMsgHashExists db connId hash =
 getRcvMsgBrokerTs :: DB.Connection -> ConnId -> SMP.MsgId -> IO (Either StoreError BrokerTs)
 getRcvMsgBrokerTs db connId msgId =
  firstRow fromOnly (SEMsgNotFound "getRcvMsgBrokerTs") $
-    DB.query db "SELECT broker_ts FROM rcv_messages WHERE conn_id = ? AND broker_id = ?" (connId, msgId)
+    DB.query db "SELECT broker_ts FROM rcv_messages WHERE conn_id = ? AND broker_id = ?" (connId, Binary msgId)

 deleteMsg :: DB.Connection -> ConnId -> InternalId -> IO ()
 deleteMsg db connId msgId =
@@ -1600,16 +1594,12 @@ getRatchet_ q db connId =
  where
    ratchet = maybe (Left SERatchetNotFound) Right . fromOnly

-getSkippedMsgKeys :: DB.Connection -> ConnId -> Int -> IO SkippedMsgKeys
-getSkippedMsgKeys db connId maxKeys = do
-  (keys, oldKeys) <- splitAt maxKeys <$> DB.query db "SELECT skipped_message_id, header_key, msg_n, msg_key FROM skipped_messages WHERE conn_id = ? ORDER BY skipped_message_id DESC LIMIT ?" (connId, maxKeys + 1)
-  case oldKeys of
-    (skippedMsgId :: Int64, _, _, _) : _ -> DB.execute db "DELETE FROM skipped_messages WHERE conn_id = ? AND skipped_message_id <= ?" (connId, skippedMsgId)
-    [] -> pure ()
-  pure $ skipped keys
+getSkippedMsgKeys :: DB.Connection -> ConnId -> IO SkippedMsgKeys
+getSkippedMsgKeys db connId =
+  skipped <$> DB.query db "SELECT header_key, msg_n, msg_key FROM skipped_messages WHERE conn_id = ?" (Only connId)
  where
    skipped = foldl' addSkippedKey M.empty
-    addSkippedKey smks (_, hk, msgN, mk) = M.alter (Just . addMsgKey) hk smks
+    addSkippedKey smks (hk, msgN, mk) = M.alter (Just . addMsgKey) hk smks
      where
        addMsgKey = maybe (M.singleton msgN mk) (M.insert msgN mk)

@@ -2803,11 +2793,6 @@ getDeletedWaitingDeliveryConnIds :: DB.Connection -> IO [ConnId]
 getDeletedWaitingDeliveryConnIds db =
  map fromOnly <$> DB.query_ db "SELECT conn_id FROM connections WHERE deleted_at_wait_delivery IS NOT NULL"

-getConnRatchetSync :: DB.Connection -> ConnId -> IO (Either StoreError RatchetSyncState)
-getConnRatchetSync db connId =
-  firstRow fromOnly SEConnNotFound $
-    DB.query db "SELECT ratchet_sync_state FROM connections WHERE conn_id = ?" (Only connId)
-
 setConnRatchetSync :: DB.Connection -> ConnId -> RatchetSyncState -> IO ()
 setConnRatchetSync db connId ratchetSyncState =
  DB.execute db "UPDATE connections SET ratchet_sync_state = ? WHERE conn_id = ?" (ratchetSyncState, connId)
@@ -2829,35 +2814,21 @@ checkRatchetKeyHashExists db connId hash =
      (connId, Binary hash)

 deleteRatchetKeyHashesExpired :: DB.Connection -> NominalDiffTime -> Int -> IO ()
-deleteRatchetKeyHashesExpired db ttl maxConnHashes = do
+deleteRatchetKeyHashesExpired db ttl limit = do
  cutoffTs <- addUTCTime (-ttl) <$> getCurrentTime
-#if defined(dbPostgres)
  DB.execute
    db
-    ("DELETE FROM processed_ratchet_key_hashes h USING (" <> maxExcessIdsQuery <> ") e WHERE h.conn_id = e.conn_id AND h.processed_ratchet_key_hash_id <= e.max_excess_id AND h.created_at < ?")
-    (maxConnHashes, maxConnHashes, cutoffTs)
-#else
-  maxExcessIds <- DB.query db maxExcessIdsQuery (maxConnHashes, maxConnHashes)
-  DB.executeMany
-    db
-    "DELETE FROM processed_ratchet_key_hashes WHERE conn_id = ? AND processed_ratchet_key_hash_id <= ? AND created_at < ?"
-    (map (\(connId :: ConnId, maxExcessId :: Int64) -> (connId, maxExcessId, cutoffTs)) maxExcessIds)
-#endif
-  where
-    maxExcessIdsQuery :: Query
-    maxExcessIdsQuery =
-      [sql|
-        SELECT conn_id, (
-          SELECT processed_ratchet_key_hash_id
-          FROM processed_ratchet_key_hashes
-          WHERE conn_id = c.conn_id
-          ORDER BY processed_ratchet_key_hash_id DESC
-          LIMIT 1 OFFSET ?
-        ) AS max_excess_id
-        FROM processed_ratchet_key_hashes c
-        GROUP BY conn_id
-        HAVING COUNT(*) > ?
-      |]
+    [sql|
+      DELETE FROM processed_ratchet_key_hashes
+      WHERE processed_ratchet_key_hash_id IN (
+        SELECT processed_ratchet_key_hash_id
+        FROM processed_ratchet_key_hashes
+        WHERE created_at < ?
+        ORDER BY created_at ASC
+        LIMIT ?
+      )
+    |]
+    (cutoffTs, limit)

 -- | returns all connection queues, the first queue is the primary one
 getRcvQueuesByConnId_ :: DB.Connection -> ConnId -> IO (Maybe (NonEmpty RcvQueue))
@@ -3040,7 +3011,7 @@ insertRcvMsgDetails_ db connId RcvQueue {dbQueueId} RcvMsgData {msgMeta, interna
      VALUES
        (?,?,?,?,?,?,?,?,?,?)
    |]
-    (connId, dbQueueId, internalRcvId, fst recipient, sndMsgId, fst broker, snd broker, Binary internalHash, Binary externalPrevSndHash, integrity)
+    (connId, dbQueueId, internalRcvId, fst recipient, sndMsgId, Binary (fst broker), snd broker, Binary internalHash, Binary externalPrevSndHash, integrity)
  DB.execute db "INSERT INTO encrypted_rcv_message_hashes (conn_id, hash) VALUES (?,?)" (connId, Binary encryptedMsgHash)

 updateRcvMsgHash :: DB.Connection -> ConnId -> AgentMsgId -> InternalRcvId -> MsgHash -> IO ()
@@ -3188,8 +3159,7 @@ createRcvFile db gVar userId fd@FileDescription {chunks} prefixPath tmpPath file
 createRcvFileRedirect :: DB.Connection -> TVar ChaChaDRG -> UserId -> FileDescription 'FRecipient -> FilePath -> FilePath -> CryptoFile -> FilePath -> CryptoFile -> Bool -> IO (Either StoreError RcvFileId)
 createRcvFileRedirect _ _ _ FileDescription {redirect = Nothing} _ _ _ _ _ _ = pure $ Left $ SEInternal "createRcvFileRedirect called without redirect"
 createRcvFileRedirect db gVar userId redirectFd@FileDescription {chunks = redirectChunks, redirect = Just RedirectFileInfo {size, digest}} prefixPath redirectPath redirectFile dstPath dstFile approvedRelays = runExceptT $ do
-  nonce <- atomically $ C.randomCbNonce gVar
-  (dstEntityId, dstId) <- ExceptT $ insertRcvFile db gVar userId (dummyDst nonce) prefixPath dstPath dstFile Nothing Nothing approvedRelays
+  (dstEntityId, dstId) <- ExceptT $ insertRcvFile db gVar userId dummyDst prefixPath dstPath dstFile Nothing Nothing approvedRelays
  (_, redirectId) <- ExceptT $ insertRcvFile db gVar userId redirectFd prefixPath redirectPath redirectFile (Just dstId) (Just dstEntityId) approvedRelays
  liftIO $
    forM_ redirectChunks $ \fc@FileChunk {replicas} -> do
@@ -3197,7 +3167,7 @@ createRcvFileRedirect db gVar userId redirectFd@FileDescription {chunks = redire
      forM_ (zip [1 ..] replicas) $ \(rno, replica) -> insertRcvFileChunkReplica db rno replica chunkId
  pure dstEntityId
  where
-    dummyDst nonce =
+    dummyDst =
      FileDescription
        { party = SFRecipient,
          size,
@@ -3205,7 +3175,7 @@ createRcvFileRedirect db gVar userId redirectFd@FileDescription {chunks = redire
          redirect = Nothing,
          -- updated later with updateRcvFileRedirect
          key = C.unsafeSbKey $ B.replicate 32 '#',
-          nonce,
+          nonce = C.cbNonce "",
          chunkSize = FileSize 0,
          chunks = []
        }
@@ -16,8 +16,6 @@ import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260411_service_certs
 import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260712_address_dr_rpc
 import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260823_snd_files_entitlement
 import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260919_ratchet_verify_codes
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260929_ratchet_indexes
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20261008_rcv_switch_status
 import Simplex.Messaging.Agent.Store.Shared (Migration (..))

 schemaMigrations :: [(String, Text, Maybe Text)]
@@ -33,9 +31,7 @@ schemaMigrations =
    ("20260411_service_certs", m20260411_service_certs, Just down_m20260411_service_certs),
    ("20260712_address_dr_rpc", m20260712_address_dr_rpc, Just down_m20260712_address_dr_rpc),
    ("20260823_snd_files_entitlement", m20260823_snd_files_entitlement, Just down_m20260823_snd_files_entitlement),
-    ("20260919_ratchet_verify_codes", m20260919_ratchet_verify_codes, Just down_m20260919_ratchet_verify_codes),
-    ("20260929_ratchet_indexes", m20260929_ratchet_indexes, Just down_m20260929_ratchet_indexes),
-    ("20261008_rcv_switch_status", m20261008_rcv_switch_status, Just down_m20261008_rcv_switch_status)
+    ("20260919_ratchet_verify_codes", m20260919_ratchet_verify_codes, Just down_m20260919_ratchet_verify_codes)
  ]

 -- | The list of migrations in ascending order by date
@@ -1,34 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20260929_ratchet_indexes where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20260929_ratchet_indexes :: Text
-m20260929_ratchet_indexes =
-  [r|
-DROP INDEX idx_skipped_messages_conn_id;
-CREATE INDEX idx_skipped_messages_conn_id ON skipped_messages(conn_id, skipped_message_id);
-
-DELETE FROM processed_ratchet_key_hashes AS h
-WHERE EXISTS (
-  SELECT 1 FROM processed_ratchet_key_hashes d
-  WHERE d.conn_id = h.conn_id AND d.hash = h.hash AND d.processed_ratchet_key_hash_id < h.processed_ratchet_key_hash_id
-);
-
-DROP INDEX idx_processed_ratchet_key_hashes_hash;
-CREATE UNIQUE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(conn_id, hash);
-CREATE INDEX idx_processed_ratchet_key_hashes_conn_id ON processed_ratchet_key_hashes(conn_id, processed_ratchet_key_hash_id);
-|]
-
-down_m20260929_ratchet_indexes :: Text
-down_m20260929_ratchet_indexes =
-  [r|
-DROP INDEX idx_processed_ratchet_key_hashes_conn_id;
-DROP INDEX idx_processed_ratchet_key_hashes_hash;
-CREATE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(conn_id, hash);
-DROP INDEX idx_skipped_messages_conn_id;
-CREATE INDEX idx_skipped_messages_conn_id ON skipped_messages(conn_id);
-|]
@@ -1,20 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20261008_rcv_switch_status where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20261008_rcv_switch_status :: Text
-m20261008_rcv_switch_status =
-  [r|
-CREATE INDEX idx_rcv_queues_switch_status ON rcv_queues(switch_status);
-|]
-
-down_m20261008_rcv_switch_status :: Text
-down_m20261008_rcv_switch_status =
-  [r|
-UPDATE rcv_queues SET switch_status = NULL WHERE switch_status = 'received_qend';
-DROP INDEX idx_rcv_queues_switch_status;
-|]
@@ -1169,15 +1169,11 @@ CREATE INDEX idx_ntf_tokens_ntf_host_ntf_port ON smp_agent_test_protocol_schema.



-CREATE INDEX idx_processed_ratchet_key_hashes_conn_id ON smp_agent_test_protocol_schema.processed_ratchet_key_hashes USING btree (conn_id, processed_ratchet_key_hash_id);
-
-
-
 CREATE INDEX idx_processed_ratchet_key_hashes_created_at ON smp_agent_test_protocol_schema.processed_ratchet_key_hashes USING btree (created_at);



-CREATE UNIQUE INDEX idx_processed_ratchet_key_hashes_hash ON smp_agent_test_protocol_schema.processed_ratchet_key_hashes USING btree (conn_id, hash);
+CREATE INDEX idx_processed_ratchet_key_hashes_hash ON smp_agent_test_protocol_schema.processed_ratchet_key_hashes USING btree (conn_id, hash);



@@ -1233,10 +1229,6 @@ CREATE UNIQUE INDEX idx_rcv_queues_ntf ON smp_agent_test_protocol_schema.rcv_que



-CREATE INDEX idx_rcv_queues_switch_status ON smp_agent_test_protocol_schema.rcv_queues USING btree (switch_status);
-
-
-
 CREATE INDEX idx_rcv_queues_to_subscribe ON smp_agent_test_protocol_schema.rcv_queues USING btree (to_subscribe);


@@ -1249,7 +1241,7 @@ CREATE UNIQUE INDEX idx_server_certs_user_id_host_port ON smp_agent_test_protoco



-CREATE INDEX idx_skipped_messages_conn_id ON smp_agent_test_protocol_schema.skipped_messages USING btree (conn_id, skipped_message_id);
+CREATE INDEX idx_skipped_messages_conn_id ON smp_agent_test_protocol_schema.skipped_messages USING btree (conn_id);



@@ -100,8 +100,7 @@ withTransaction st = withTransactionPriority st False
 {-# INLINE withTransaction #-}

 withTransactionPriority :: DBStore -> Bool -> (DB.Connection -> IO a) -> IO a
-withTransactionPriority st@DBStore {dbClosed} priority action = withConnectionPriority st priority $ \db ->
-  ifM (readTVarIO dbClosed) (fail "withTransaction: database closed") (dbBusyLoop $ transaction db)
+withTransactionPriority st priority action = withConnectionPriority st priority $ dbBusyLoop . transaction
  where
    transaction db@DB.Connection {conn} = SQL.withImmediateTransaction conn $ action db

@@ -52,9 +52,6 @@ import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260411_service_certs
 import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260712_address_dr_rpc
 import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260823_snd_files_entitlement
 import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260919_ratchet_verify_codes
-import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260929_ratchet_indexes
-import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261005_commands_autoincrement
-import Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261008_rcv_switch_status
 import Simplex.Messaging.Agent.Store.Shared (Migration (..))

 schemaMigrations :: [(String, Query, Maybe Query)]
@@ -106,10 +103,7 @@ schemaMigrations =
    ("m20260411_service_certs", m20260411_service_certs, Just down_m20260411_service_certs),
    ("m20260712_address_dr_rpc", m20260712_address_dr_rpc, Just down_m20260712_address_dr_rpc),
    ("m20260823_snd_files_entitlement", m20260823_snd_files_entitlement, Just down_m20260823_snd_files_entitlement),
-    ("m20260919_ratchet_verify_codes", m20260919_ratchet_verify_codes, Just down_m20260919_ratchet_verify_codes),
-    ("m20260929_ratchet_indexes", m20260929_ratchet_indexes, Just down_m20260929_ratchet_indexes),
-    ("m20261005_commands_autoincrement", m20261005_commands_autoincrement, Just down_m20261005_commands_autoincrement),
-    ("m20261008_rcv_switch_status", m20261008_rcv_switch_status, Just down_m20261008_rcv_switch_status)
+    ("m20260919_ratchet_verify_codes", m20260919_ratchet_verify_codes, Just down_m20260919_ratchet_verify_codes)
  ]

 -- | The list of migrations in ascending order by date
@@ -1,29 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.SQLite.Migrations.M20260929_ratchet_indexes where
-
-import Database.SQLite.Simple (Query)
-import Database.SQLite.Simple.QQ (sql)
-
-- idx_skipped_messages_conn_id is not changed: SQLite index entries include rowid (skipped_message_id)
-m20260929_ratchet_indexes :: Query
-m20260929_ratchet_indexes =
-  [sql|
-DELETE FROM processed_ratchet_key_hashes AS h
-WHERE EXISTS (
-  SELECT 1 FROM processed_ratchet_key_hashes d
-  WHERE d.conn_id = h.conn_id AND d.hash = h.hash AND d.processed_ratchet_key_hash_id < h.processed_ratchet_key_hash_id
-);
-
-DROP INDEX idx_processed_ratchet_key_hashes_hash;
-CREATE UNIQUE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(conn_id, hash);
-CREATE INDEX idx_processed_ratchet_key_hashes_conn_id ON processed_ratchet_key_hashes(conn_id, processed_ratchet_key_hash_id);
-  |]
-
-down_m20260929_ratchet_indexes :: Query
-down_m20260929_ratchet_indexes =
-  [sql|
-DROP INDEX idx_processed_ratchet_key_hashes_conn_id;
-DROP INDEX idx_processed_ratchet_key_hashes_hash;
-CREATE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(conn_id, hash);
-  |]
@@ -1,33 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261005_commands_autoincrement where
-
-import Database.SQLite.Simple (Query)
-import Database.SQLite.Simple.QQ (sql)
-
-m20261005_commands_autoincrement :: Query
-m20261005_commands_autoincrement =
-  [sql|
-INSERT INTO sqlite_sequence (name, seq)
-SELECT 'commands', MAX(ROWID) FROM commands;
-
-PRAGMA writable_schema=1;
-
-UPDATE sqlite_master SET sql = replace(sql, 'command_id INTEGER PRIMARY KEY,', 'command_id INTEGER PRIMARY KEY AUTOINCREMENT,')
-WHERE name = 'commands' AND type = 'table';
-
-PRAGMA writable_schema=RESET;
-  |]
-
-down_m20261005_commands_autoincrement :: Query
-down_m20261005_commands_autoincrement =
-  [sql|
-DELETE FROM sqlite_sequence WHERE name = 'commands';
-
-PRAGMA writable_schema=1;
-
-UPDATE sqlite_master SET sql = replace(sql, 'command_id INTEGER PRIMARY KEY AUTOINCREMENT,', 'command_id INTEGER PRIMARY KEY,')
-WHERE name = 'commands' AND type = 'table';
-
-PRAGMA writable_schema=RESET;
-  |]
@@ -1,19 +0,0 @@
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.SQLite.Migrations.M20261008_rcv_switch_status where
-
-import Database.SQLite.Simple (Query)
-import Database.SQLite.Simple.QQ (sql)
-
-m20261008_rcv_switch_status :: Query
-m20261008_rcv_switch_status =
-  [sql|
-CREATE INDEX idx_rcv_queues_switch_status ON rcv_queues(switch_status);
-|]
-
-down_m20261008_rcv_switch_status :: Query
-down_m20261008_rcv_switch_status =
-  [sql|
-UPDATE rcv_queues SET switch_status = NULL WHERE switch_status = 'received_qend';
-DROP INDEX idx_rcv_queues_switch_status;
-|]
@@ -247,7 +247,7 @@ CREATE TABLE ntf_subscriptions(
  ON DELETE RESTRICT ON UPDATE CASCADE
 ) WITHOUT ROWID, STRICT;
 CREATE TABLE commands(
-  command_id INTEGER PRIMARY KEY AUTOINCREMENT,
+  command_id INTEGER PRIMARY KEY,
  conn_id BLOB NOT NULL REFERENCES connections ON DELETE CASCADE,
  host TEXT,
  port TEXT,
@@ -261,7 +261,6 @@ CREATE TABLE commands(
  FOREIGN KEY(host, port) REFERENCES servers
  ON DELETE RESTRICT ON UPDATE CASCADE
 ) STRICT;
-CREATE TABLE sqlite_sequence(name,seq);
 CREATE TABLE snd_message_deliveries(
  snd_message_delivery_id INTEGER PRIMARY KEY AUTOINCREMENT,
  conn_id BLOB NOT NULL REFERENCES connections ON DELETE CASCADE,
@@ -270,6 +269,7 @@ CREATE TABLE snd_message_deliveries(
  failed INTEGER DEFAULT 0,
  FOREIGN KEY(conn_id, internal_id) REFERENCES messages ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED
 ) STRICT;
+CREATE TABLE sqlite_sequence(name,seq);
 CREATE TABLE users(
  user_id INTEGER PRIMARY KEY AUTOINCREMENT
  ,
@@ -573,6 +573,10 @@ CREATE INDEX idx_encrypted_rcv_message_hashes_hash ON encrypted_rcv_message_hash
  conn_id,
  hash
 );
+CREATE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(
+  conn_id,
+  hash
+);
 CREATE INDEX idx_snd_messages_rcpt_internal_id ON snd_messages(
  conn_id,
  rcpt_internal_id
@@ -637,15 +641,6 @@ CREATE INDEX idx_connections_deleted ON connections(deleted);
 CREATE INDEX idx_connections_service_request_expires_at ON connections(
  service_request_expires_at
 );
-CREATE UNIQUE INDEX idx_processed_ratchet_key_hashes_hash ON processed_ratchet_key_hashes(
-  conn_id,
-  hash
-);
-CREATE INDEX idx_processed_ratchet_key_hashes_conn_id ON processed_ratchet_key_hashes(
-  conn_id,
-  processed_ratchet_key_hash_id
-);
-CREATE INDEX idx_rcv_queues_switch_status ON rcv_queues(switch_status);
 CREATE TRIGGER tr_rcv_queue_insert
 AFTER INSERT ON rcv_queues
 FOR EACH ROW
@@ -28,6 +28,7 @@ module Simplex.Messaging.Agent.TSessionSubs
    getPendingSubs,
    getPendingQueueSubs,
    getActiveSubs,
+    getActiveConns,
    setSubsPending,
    updateClientNotices,
    foldSessionSubs,
@@ -43,7 +44,7 @@ import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
 import Data.Maybe (fromMaybe, isJust)
 import qualified Data.Set as S
-import Simplex.Messaging.Agent.Protocol (SMPQueue (..))
+import Simplex.Messaging.Agent.Protocol (ConnId, SMPQueue (..))
 import Simplex.Messaging.Agent.Store (RcvQueue, RcvQueueSub (..), ServiceAssoc, SomeRcvQueue, StoredRcvQueue (rcvServiceAssoc), rcvQueueSub)
 import Simplex.Messaging.Client (SMPTransportSession, TransportSessionMode (..))
 import Simplex.Messaging.Protocol (IdsHash, RecipientId, ServiceSub (..), queueIdHash)
@@ -59,6 +60,10 @@ data TSessionSubs = TSessionSubs
 data SessSubs = SessSubs
  { subsSessId :: TVar (Maybe SessionId),
    activeSubs :: TMap RecipientId RcvQueueSub,
+    -- Connections with active subscriptions, with the number of their active subscriptions.
+    -- Kept in sync with activeSubs, so that "is this connection already subscribed" does not
+    -- require folding activeSubs, which holds every subscribed queue of the session.
+    activeConns :: TMap ConnId Int,
    pendingSubs :: TMap RecipientId RcvQueueSub,
    activeServiceSub :: TVar (Maybe ServiceSub),
    pendingServiceSub :: TVar (Maybe ServiceSub)
@@ -80,10 +85,21 @@ getSessSubs :: SMPTransportSession -> TSessionSubs -> STM SessSubs
 getSessSubs tSess ss = lookupSubs tSess ss >>= maybe new pure
  where
    new = do
-      s <- SessSubs <$> newTVar Nothing <*> newTVar M.empty <*> newTVar M.empty <*> newTVar Nothing <*> newTVar Nothing
+      s <- SessSubs <$> newTVar Nothing <*> newTVar M.empty <*> newTVar M.empty <*> newTVar M.empty <*> newTVar Nothing <*> newTVar Nothing
      TM.insert tSess s $ sessionSubs ss
      pure s

+incActiveConn :: SessSubs -> ConnId -> STM ()
+incActiveConn s cId = TM.alter inc cId $ activeConns s
+  where
+    inc = Just . maybe 1 (+ 1)
+
+decActiveConn :: SessSubs -> ConnId -> STM ()
+decActiveConn s cId = TM.alter dec cId $ activeConns s
+  where
+    dec (Just n) | n > 1 = Just (n - 1)
+    dec _ = Nothing
+
 hasActiveSub :: SMPTransportSession -> RecipientId -> TSessionSubs -> STM Bool
 hasActiveSub = hasQueue_ activeSubs
 {-# INLINE hasActiveSub #-}
@@ -135,7 +151,10 @@ addActiveSub' tSess sessId serviceId_ rq serviceAssoc ss = do
      TM.delete rId $ pendingSubs s
      case serviceId_ of
        Just serviceId | serviceAssoc -> updateActiveService s serviceId 1 (queueIdHash rId)
-        _ -> TM.insert rId rq $ activeSubs s
+        _ -> do
+          prev <- TM.lookup rId $ activeSubs s
+          TM.insert rId rq $ activeSubs s
+          unless (isJust prev) $ incActiveConn s (connId rq)
    else TM.insert rId rq $ pendingSubs s

 batchAddActiveSubs :: SMPTransportSession -> SessionId -> Maybe ServiceId -> ([RcvQueueSub], [RcvQueueSub]) -> TSessionSubs -> STM ()
@@ -146,7 +165,9 @@ batchAddActiveSubs tSess sessId serviceId_ (rqs, serviceRQs) ss = do
      serviceQs = queuesMap serviceRQs
  if Just sessId == sessId'
    then do
+      prev <- readTVar $ activeSubs s
      TM.union qs $ activeSubs s
+      mapM_ (incActiveConn s . connId) $ M.elems $ qs `M.difference` prev
      modifyTVar' (pendingSubs s) (`M.difference` qs)
      unless (null serviceRQs) $ forM_ serviceId_ $ \serviceId -> do
        modifyTVar' (pendingSubs s) (`M.difference` serviceQs)
@@ -178,13 +199,24 @@ batchDeletePendingSubs tSess rIds = lookupSubs tSess >=> mapM_ (delete . pending
    delete = (`modifyTVar'` (`M.withoutKeys` rIds))

 deleteSub :: SMPTransportSession -> RecipientId -> TSessionSubs -> STM ()
-deleteSub tSess rId = lookupSubs tSess >=> mapM_ (\s -> TM.delete rId (activeSubs s) >> TM.delete rId (pendingSubs s))
+deleteSub tSess rId = lookupSubs tSess >=> mapM_ delete_
+  where
+    delete_ s = do
+      prev <- TM.lookup rId $ activeSubs s
+      TM.delete rId (activeSubs s)
+      TM.delete rId (pendingSubs s)
+      mapM_ (decActiveConn s . connId) prev

 batchDeleteSubs :: SomeRcvQueue q => SMPTransportSession -> [q] -> TSessionSubs -> STM ()
-batchDeleteSubs tSess rqs = lookupSubs tSess >=> mapM_ (\s -> delete (activeSubs s) >> delete (pendingSubs s))
+batchDeleteSubs tSess rqs = lookupSubs tSess >=> mapM_ delete_
  where
    rIds = S.fromList $ map queueId rqs
    delete = (`modifyTVar'` (`M.withoutKeys` rIds))
+    delete_ s = do
+      prev <- readTVar $ activeSubs s
+      delete (activeSubs s)
+      delete (pendingSubs s)
+      mapM_ (decActiveConn s . connId) $ M.elems $ M.restrictKeys prev rIds

 deleteServiceSub :: SMPTransportSession -> TSessionSubs -> STM ()
 deleteServiceSub tSess = lookupSubs tSess >=> mapM_ (\s -> writeTVar (activeServiceSub s) Nothing >> writeTVar (pendingServiceSub s) Nothing)
@@ -204,6 +236,9 @@ getPendingQueueSubs :: SMPTransportSession -> TSessionSubs -> STM (Map Recipient
 getPendingQueueSubs = getSubs_ pendingSubs
 {-# INLINE getPendingQueueSubs #-}

+getActiveConns :: SMPTransportSession -> TSessionSubs -> STM (Map ConnId Int)
+getActiveConns tSess = lookupSubs tSess >=> maybe (pure M.empty) (readTVar . activeConns)
+
 getActiveSubs :: SMPTransportSession -> TSessionSubs -> STM (Map RecipientId RcvQueueSub)
 getActiveSubs = getSubs_ activeSubs
 {-# INLINE getActiveSubs #-}
@@ -238,6 +273,7 @@ setSubsPending_ s sessId_ = do
  subs <- readTVar as
  unless (null subs) $ do
    writeTVar as M.empty
+    TM.clear $ activeConns s
    modifyTVar' (pendingSubs s) $ M.union subs
  (subs,) <$> setServiceSubPending_ s

@@ -67,7 +67,6 @@ module Simplex.Messaging.Client
    enableSMPQueuesNtfs,
    disableSMPQueuesNtfs,
    sendSMPMessage,
-    QueueDrained,
    ackSMPMessage,
    suspendSMPQueue,
    deleteSMPQueue,
@@ -196,7 +195,6 @@ data PClient v err msg = PClient
    transportHost :: TransportHost,
    tcpConnectTimeout :: NetworkTimeout,
    tcpTimeout :: NetworkTimeout,
-    proxiedRelayVRange :: VersionRange v,
    sendPings :: TVar Bool,
    lastReceived :: TVar UTCTime,
    timeoutErrorCount :: TVar Int,
@@ -242,7 +240,6 @@ smpClientStub g sessionId thVersion thAuth = do
              transportHost = "localhost",
              tcpConnectTimeout,
              tcpTimeout,
-              proxiedRelayVRange = supportedClientSMPRelayVRange,
              sendPings,
              lastReceived,
              timeoutErrorCount,
@@ -480,7 +477,6 @@ data ProtocolClientConfig v = ProtocolClientConfig
    serviceCredentials :: Maybe ServiceCredentials,
    -- | client-server protocol version range
    serverVRange :: VersionRange v,
-    proxiedRelayVRange :: VersionRange v,
    -- | agree shared session secret (used in SMP proxy for additional encryption layer)
    agreeSecret :: Bool,
    -- | Whether connecting client is a proxy server. See comment in ClientHandshake
@@ -499,7 +495,6 @@ defaultClientConfig clientALPN useSNI serverVRange =
      clientALPN,
      serviceCredentials = Nothing,
      serverVRange,
-      proxiedRelayVRange = serverVRange,
      agreeSecret = False,
      proxyServer = False,
      useSNI
@@ -510,7 +505,6 @@ defaultSMPClientConfig :: ProtocolClientConfig SMPVersion
 defaultSMPClientConfig =
  (defaultClientConfig (Just alpnSupportedSMPHandshakes) False supportedClientSMPRelayVRange)
    { defaultTransport = (show defaultSMPPort, transport @TLS),
-      proxiedRelayVRange = supportedClientSMPRelayVRange,
      agreeSecret = True
    }
 {-# INLINE defaultSMPClientConfig #-}
@@ -574,7 +568,7 @@ type SMPTransportSession = TransportSession BrokerMsg
 -- A single queue can be used for multiple 'SMPClient' instances,
 -- as 'SMPServerTransmission' includes server information.
 getProtocolClient :: forall v err msg. Protocol v err msg => TVar ChaChaDRG -> NetworkRequestMode -> TransportSession msg -> ProtocolClientConfig v -> [HostName] -> Maybe (TBQueue (ServerTransmissionBatch v err msg)) -> UTCTime -> (ProtocolClient v err msg -> IO ()) -> IO (Either (ProtocolClientError err) (ProtocolClient v err msg))
-getProtocolClient g nm transportSession@(_, srv, _) cfg@ProtocolClientConfig {qSize, networkConfig, clientALPN, serviceCredentials, serverVRange, proxiedRelayVRange, agreeSecret, proxyServer, useSNI} presetDomains msgQ proxySessTs disconnected = do
+getProtocolClient g nm transportSession@(_, srv, _) cfg@ProtocolClientConfig {qSize, networkConfig, clientALPN, serviceCredentials, serverVRange, agreeSecret, proxyServer, useSNI} presetDomains msgQ proxySessTs disconnected = do
  case chooseTransportHost networkConfig (host srv) of
    Right useHost ->
      (getCurrentTime >>= mkProtocolClient useHost >>= runClient useTransport useHost)
@@ -599,7 +593,6 @@ getProtocolClient g nm transportSession@(_, srv, _) cfg@ProtocolClientConfig {qS
            transportHost,
            tcpConnectTimeout,
            tcpTimeout,
-            proxiedRelayVRange,
            sendPings,
            lastReceived,
            timeoutErrorCount,
@@ -1088,17 +1081,15 @@ resolvedNameOrNotFound d NameResponse {registration} = case registration of
  NRRegistered {nameRecord} -> T.toLower (nrName nameRecord) == fullDomainName d
  _ -> True

-type QueueDrained = Bool
-
 -- | Acknowledge message delivery (server deletes the message).
 --
 -- https://github.com/simplex-chat/simplexmq/blob/master/protocol/simplex-messaging.md#acknowledge-message-delivery
 -- This command is always sent in background request mode
-ackSMPMessage :: SMPClient -> RcvPrivateAuthKey -> QueueId -> MsgId -> ExceptT SMPClientError IO QueueDrained
+ackSMPMessage :: SMPClient -> RcvPrivateAuthKey -> QueueId -> MsgId -> ExceptT SMPClientError IO ()
 ackSMPMessage c rpKey rId msgId =
  sendSMPCommand c NRMBackground (Just rpKey) rId (ACK msgId) >>= \case
-    OK -> pure True
-    cmd@MSG {} -> liftIO (writeSMPMessage c rId cmd) $> False
+    OK -> return ()
+    cmd@MSG {} -> liftIO $ writeSMPMessage c rId cmd
    r -> throwE $ unexpectedResponse r

 -- | Irreversibly suspend SMP queue.
@@ -1124,10 +1115,10 @@ deleteSMPQueues = okSMPCommands DEL
 -- send PRXY :: SMPServer -> Maybe BasicAuth -> Command Sender
 -- receives PKEY :: SessionId -> X.CertificateChain -> X.SignedExact X.PubKey -> BrokerMsg
 connectSMPProxiedRelay :: SMPClient -> NetworkRequestMode -> SMPServer -> Maybe BasicAuth -> ExceptT SMPClientError IO ProxiedRelay
-connectSMPProxiedRelay c@ProtocolClient {client_ = PClient {tcpConnectTimeout, tcpTimeout, proxiedRelayVRange}} nm relayServ@ProtocolServer {port = relayPort, keyHash = C.KeyHash kh} proxyAuth =
+connectSMPProxiedRelay c@ProtocolClient {client_ = PClient {tcpConnectTimeout, tcpTimeout}} nm relayServ@ProtocolServer {port = relayPort, keyHash = C.KeyHash kh} proxyAuth =
  sendProtocolCommand_ c nm Nothing tOut Nothing NoEntity (Cmd SProxiedClient (PRXY relayServ proxyAuth)) >>= \case
    PKEY sId vr (CertChainPubKey chain key) ->
-      case proxiedRelayVRange `compatibleVersion` vr of
+      case supportedClientSMPRelayVRange `compatibleVersion` vr of
        Nothing -> throwE $ transportErr TEVersion
        Just (Compatible v) -> do
          relayKey <- liftEitherWith (const $ transportErr $ TEHandshake IDENTITY) =<< liftIO (runExceptT $ validateRelay chain key)
@@ -1178,7 +1169,7 @@ instance StrEncoding ProxyClientError where
 -- consider how to process slow responses - is it handled somehow locally or delegated to the caller
 -- this method is used in the client
 -- sends PFWD :: C.PublicKeyX25519 -> EncTransmission -> Command Sender
-- receives PRES :: Maybe C.CbNonce -> EncResponse -> BrokerMsg -- proxy to client
+-- receives PRES :: EncResponse -> BrokerMsg -- proxy to client

 -- When client sends message via proxy, there may be one successful scenario and 9 error scenarios
 -- as shown below (WTF stands for unexpected response, ??? for response that failed to parse).
@@ -1231,20 +1222,20 @@ proxySMPCommand c@ProtocolClient {thParams = proxyThParams, client_ = PClient {c
  -- encode
  let TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth serverThParams (CorrId corrId, sId, Cmd (sParty @p) command)
  -- serviceAuth is False here – proxied commands are not used with service certificates
-  auth <- liftEitherWith PCETransportError $ authTransmission serverThAuth False spKey (Just nonce) tForAuth
+  auth <- liftEitherWith PCETransportError $ authTransmission serverThAuth False spKey nonce tForAuth
  b <- case batchTransmissions serverThParams [Right (auth, tToSend)] of
    [] -> throwE $ PCETransportError TELargeMsg
    TBError e _ : _ -> throwE $ PCETransportError e
    TBTransmission s _ : _ -> pure s
    TBTransmissions s _ _ : _ -> pure s
-  et <- liftEitherWith PCECryptoError $ EncTransmission <$> C.cbEncrypt cmdSecret (encTransmissionNonce v nonce) b paddedProxiedTLength
+  et <- liftEitherWith PCECryptoError $ EncTransmission <$> C.cbEncrypt cmdSecret nonce b paddedProxiedTLength
  -- proxy interaction errors are wrapped
  let tOut = Just $ 2 * netTimeoutInt tcpTimeout nm
  tryE (sendProtocolCommand_ c nm (Just nonce) tOut Nothing (EntityId sessionId) (Cmd SProxiedClient (PFWD v cmdPubKey et))) >>= \case
    Right r -> case r of
-      PRES nonce_ (EncResponse er) -> do
+      PRES (EncResponse er) -> do
        -- server interaction errors are thrown directly
-        t' <- liftEitherWith PCECryptoError $ C.cbDecrypt cmdSecret (fromMaybe (C.reverseNonce nonce) nonce_) er
+        t' <- liftEitherWith PCECryptoError $ C.cbDecrypt cmdSecret (C.reverseNonce nonce) er
        case tParse serverThParams t' of
          t'' :| [] -> case tDecodeClient serverThParams t'' of
            (_, _, cmd) -> case cmd of
@@ -1262,10 +1253,10 @@ proxySMPCommand c@ProtocolClient {thParams = proxyThParams, client_ = PClient {c

 -- this method is used in the proxy
 -- sends RFWD :: EncFwdTransmission -> Command Sender
-- receives RRES :: Maybe C.CbNonce -> EncFwdResponse -> BrokerMsg
+-- receives RRES :: EncFwdResponse -> BrokerMsg
 -- proxy should send PRES to the client with EncResponse
 -- Always uses background timeout mode
-forwardSMPTransmission :: SMPClient -> C.CorrCbNonce -> VersionSMP -> C.PublicKeyX25519 -> EncTransmission -> ExceptT SMPClientError IO (Maybe C.CbNonce, EncResponse)
+forwardSMPTransmission :: SMPClient -> CorrId -> VersionSMP -> C.PublicKeyX25519 -> EncTransmission -> ExceptT SMPClientError IO EncResponse
 forwardSMPTransmission c@ProtocolClient {thParams, client_ = PClient {clientCorrId = g}} fwdCorrId fwdVersion fwdKey fwdTransmission = do
  -- prepare params
  sessSecret <- case thAuth thParams of
@@ -1277,11 +1268,11 @@ forwardSMPTransmission c@ProtocolClient {thParams, client_ = PClient {clientCorr
      eft = EncFwdTransmission $ C.cbEncryptNoPad sessSecret nonce (smpEncode fwdT)
  -- send
  sendProtocolCommand_ c NRMBackground (Just nonce) Nothing Nothing NoEntity (Cmd SProxyService (RFWD eft)) >>= \case
-    RRES nonce_ (EncFwdResponse efr) -> do
+    RRES (EncFwdResponse efr) -> do
      -- unwrap
      r' <- liftEitherWith PCECryptoError $ C.cbDecryptNoPad sessSecret (C.reverseNonce nonce) efr
      FwdResponse {fwdCorrId = _, fwdResponse} <- liftEitherWith (const $ PCEResponseError BLOCK) $ smpDecode r'
-      pure (nonce_, fwdResponse)
+      pure fwdResponse
    r -> throwE $ unexpectedResponse r

 -- get queue information - always sent interactively
@@ -1403,7 +1394,7 @@ mkTransmission_ :: forall v err msg. Protocol v err msg => ProtocolClient v err
 mkTransmission_ ProtocolClient {thParams, client_ = PClient {clientCorrId, sentCommands}} nonce_ (entityId, pKey_, command) = do
  nonce@(C.CbNonce corrId) <- maybe (atomically $ C.randomCbNonce clientCorrId) pure nonce_
  let TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth thParams (CorrId corrId, entityId, command)
-      auth = authTransmission (thAuth thParams) (useServiceAuth command) pKey_ (Just nonce) tForAuth
+      auth = authTransmission (thAuth thParams) (useServiceAuth command) pKey_ nonce tForAuth
  r <- mkRequest (CorrId corrId)
  pure ((,tToSend) <$> auth, r)
  where
@@ -1422,14 +1413,14 @@ mkTransmission_ ProtocolClient {thParams, client_ = PClient {clientCorrId, sentC
      atomically $ TM.insert corrId r sentCommands
      pure r

-authTransmission :: Maybe (THandleAuth 'TClient) -> Bool -> Maybe C.APrivateAuthKey -> Maybe C.CbNonce -> ByteString -> Either TransportError (Maybe TAuthorizations)
-authTransmission thAuth serviceAuth pKey_ nonce_ t = traverse authenticate pKey_
+authTransmission :: Maybe (THandleAuth 'TClient) -> Bool -> Maybe C.APrivateAuthKey -> C.CbNonce -> ByteString -> Either TransportError (Maybe TAuthorizations)
+authTransmission thAuth serviceAuth pKey_ nonce t = traverse authenticate pKey_
  where
    authenticate :: C.APrivateAuthKey -> Either TransportError TAuthorizations
    authenticate (C.APrivateAuthKey a pk) = (,serviceSig) <$> case a of
-      C.SX25519 -> case (thAuth, nonce_) of
-        (Just THAuthClient {peerServerPubKey = k}, Just nonce) -> Right $ TAAuthenticator $ C.cbAuthenticate k pk nonce t'
-        _ -> Left TENoServerAuth
+      C.SX25519 -> case thAuth of
+        Just THAuthClient {peerServerPubKey = k} -> Right $ TAAuthenticator $ C.cbAuthenticate k pk nonce t'
+        Nothing -> Left TENoServerAuth
      C.SEd25519 -> sign pk
      C.SEd448 -> sign pk
    -- When command is signed by both entity key and service key,
@@ -140,10 +140,8 @@ module Simplex.Messaging.Crypto
    gcmIV,

    -- * NaCl crypto_box
-    CbNonceI (..),
-    CbNonce,
+    CbNonce (unCbNonce),
    pattern CbNonce,
-    CorrCbNonce,
    cbEncrypt,
    cbEncryptNoPad,
    cbEncryptMaxLenBS,
@@ -154,12 +152,8 @@ module Simplex.Messaging.Crypto
    sbEncryptNoPad,
    sbDecryptNoPad,
    cbNonce,
-    unsafeCbNonce,
-    corrCbNonce,
    randomCbNonce,
    reverseNonce,
-    xorNonce,
-    toCbNonce,

    -- * NaCl crypto_secretbox
    SbKey (unSbKey),
@@ -238,7 +232,6 @@ import Data.ASN1.Types
 import Data.Aeson (FromJSON (..), ToJSON (..))
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Bifunctor (bimap, first)
-import Data.Bits (xor)
 import Data.ByteArray (ByteArrayAccess)
 import qualified Data.ByteArray as BA
 import Data.ByteString.Base64 (decode)
@@ -261,7 +254,7 @@ import Simplex.Messaging.Agent.Store.DB (Binary (..), FromField (..), ToField (.
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (parseAll, parseString)
-import Simplex.Messaging.Util (packZipWith, (<$?>))
+import Simplex.Messaging.Util ((<$?>))

 -- | Cryptographic algorithms.
 data Algorithm = Ed25519 | Ed448 | X25519 | X448
@@ -938,8 +931,6 @@ data CryptoError
    CERatchetEarlierMessage Word32
  | -- | duplicate message number
    CERatchetDuplicateMessage
-  | -- | KEM key generation failed, indicating a broken RNG
-    CryptoKEMKeyGenError
  deriving (Eq, Show, Exception)

 aesKeySize :: Int
@@ -1054,7 +1045,9 @@ md5Hash = BA.convert . (hash :: ByteString -> Digest MD5)

 -- | AEAD-GCM encryption with associated data.
 --
-- Used as part of double ratchet encryption, with a 16-byte IV (see @initAEAD@).
+-- Used as part of double ratchet encryption.
+-- This function requires 16 bytes IV, it transforms IV in cryptonite_aes_gcm_init here:
+-- https://github.com/haskell-crypto/cryptonite/blob/master/cbits/cryptonite_aes.c
 encryptAEAD :: Key -> IV -> Int -> ByteString -> ByteString -> ExceptT CryptoError IO (AuthTag, ByteString)
 encryptAEAD aesKey ivBytes paddedLen ad msg = do
  aead <- initAEAD @AES256 aesKey ivBytes
@@ -1074,7 +1067,10 @@ encryptAEADNoPad aesKey ivBytes ad msg = do

 -- | AEAD-GCM decryption with associated data.
 --
-- Used as part of double ratchet encryption, with a 16-byte IV (see @initAEAD@).
+-- Used as part of double ratchet encryption.
+-- This function requires 16 bytes IV, it transforms IV in cryptonite_aes_gcm_init here:
+-- https://github.com/haskell-crypto/cryptonite/blob/master/cbits/cryptonite_aes.c
+-- To make it compatible with WebCrypto we will need to start using initAEADGCM.
 decryptAEAD :: Key -> IV -> ByteString -> ByteString -> AuthTag -> ExceptT CryptoError IO ByteString
 decryptAEAD aesKey ivBytes ad msg (AuthTag authTag) = do
  aead <- initAEAD @AES256 aesKey ivBytes
@@ -1152,9 +1148,9 @@ maxLength :: forall i. KnownNat i => Int
 maxLength = fromIntegral (natVal $ Proxy @i)
 {-# INLINE maxLength #-}

-- The 16-byte double ratchet IV is intentionally not the 96-bit IV recommended by NIST SP 800-38D, so GCM derives J0 = GHASH(IV || 0^64 || [128]_64),
-- as in crypton_aes_gcm_init: https://hackage.haskell.org/package/crypton-0.34/src/cbits/crypton_aes.c
-- WebCrypto and other SP 800-38D implementations interoperate only when given all 16 IV bytes.
+-- this function requires 16 bytes IV, it transforms IV in cryptonite_aes_gcm_init here:
+-- https://github.com/haskell-crypto/cryptonite/blob/master/cbits/cryptonite_aes.c
+-- This is used for double ratchet encryption, so to make it compatible with WebCrypto we will need to deprecate it and start using initAEADGCM
 initAEAD :: forall c. AES.BlockCipher c => Key -> IV -> ExceptT CryptoError IO (AES.AEAD c)
 initAEAD (Key aesKey) (IV ivBytes) = do
  iv <- makeIV @c ivBytes
@@ -1331,8 +1327,8 @@ sbEncryptNoPad (SbKey key) (CbNonce nonce) = cryptoBox key nonce
 {-# INLINE sbEncryptNoPad #-}

 -- | NaCl @crypto_box@ encrypt with a shared DH secret and 192-bit nonce.
-cbEncryptMaxLenBS :: (KnownNat i, CbNonceI n) => DhSecret X25519 -> n -> MaxLenBS i -> ByteString
-cbEncryptMaxLenBS (DhSecretX25519 secret) nonce = cryptoBox secret (unCbNonce nonce) . unMaxLenBS . padMaxLenBS
+cbEncryptMaxLenBS :: KnownNat i => DhSecret X25519 -> CbNonce -> MaxLenBS i -> ByteString
+cbEncryptMaxLenBS (DhSecretX25519 secret) (CbNonce nonce) = cryptoBox secret nonce . unMaxLenBS . padMaxLenBS
 {-# INLINE cbEncryptMaxLenBS #-}

 cryptoBox :: ByteArrayAccess key => key -> ByteString -> ByteString -> ByteString
@@ -1342,8 +1338,8 @@ cryptoBox secret nonce s = BA.convert tag <> c
    tag = Poly1305.auth rs c

 -- | NaCl @crypto_box@ decrypt with a shared DH secret and 192-bit nonce.
-cbDecrypt :: CbNonceI n => DhSecret X25519 -> n -> ByteString -> Either CryptoError ByteString
-cbDecrypt (DhSecretX25519 secret) = sbDecrypt_ secret . toCbNonce
+cbDecrypt :: DhSecret X25519 -> CbNonce -> ByteString -> Either CryptoError ByteString
+cbDecrypt (DhSecretX25519 secret) = sbDecrypt_ secret
 {-# INLINE cbDecrypt #-}

 -- | NaCl @crypto_box@ decrypt with a shared DH secret and 192-bit nonce (without unpadding).
@@ -1390,16 +1386,9 @@ cbAuthenticate k pk nonce msg = CbAuthenticator $ cbEncryptNoPad (dh' k pk) nonc
 cbVerify :: PublicKeyX25519 -> PrivateKeyX25519 -> CbNonce -> CbAuthenticator -> ByteString -> Bool
 cbVerify k pk nonce (CbAuthenticator s) authorized = cbDecryptNoPad (dh' k pk) nonce s == Right (sha512Hash authorized)

-class CbNonceI n where
-  unCbNonce :: n -> ByteString
-
-newtype CbNonce = CryptoBoxNonce ByteString
+newtype CbNonce = CryptoBoxNonce {unCbNonce :: ByteString}
  deriving (Eq, Show)
-
-instance CbNonceI CbNonce where
-  unCbNonce (CryptoBoxNonce s) = s
-
-instance FromField CbNonce where fromField = blobFieldDecoder cbNonce
+  deriving newtype (FromField)

 instance ToField CbNonce where toField (CryptoBoxNonce s) = toField $ Binary s

@@ -1410,7 +1399,7 @@ pattern CbNonce s <- CryptoBoxNonce s

 instance StrEncoding CbNonce where
  strEncode (CbNonce s) = strEncode s
-  strP = cbNonce <$?> strP
+  strP = cbNonce <$> strP

 instance ToJSON CbNonce where
  toJSON = strToJSON
@@ -1419,16 +1408,13 @@ instance ToJSON CbNonce where
 instance FromJSON CbNonce where
  parseJSON = strParseJSON "CbNonce"

-cbNonce :: ByteString -> Either String CbNonce
+cbNonce :: ByteString -> CbNonce
 cbNonce s
-  | B.length s == 24 = Right $ CryptoBoxNonce s
-  | otherwise = Left "CbNonce: invalid length"
-
-unsafeCbNonce :: ByteString -> CbNonce
-unsafeCbNonce s = either error id $ cbNonce s
-
-corrCbNonce :: ByteString -> Either String CorrCbNonce
-corrCbNonce s = CorrCbNonce . unCbNonce <$> cbNonce s
+  | len == 24 = CryptoBoxNonce s
+  | len > 24 = CryptoBoxNonce . fst $ B.splitAt 24 s
+  | otherwise = CryptoBoxNonce $ s <> B.replicate (24 - len) (toEnum 0)
+  where
+    len = B.length s

 randomCbNonce :: TVar ChaChaDRG -> STM CbNonce
 randomCbNonce = fmap CryptoBoxNonce . randomBytes 24
@@ -1436,30 +1422,13 @@ randomCbNonce = fmap CryptoBoxNonce . randomBytes 24
 randomBytes :: Int -> TVar ChaChaDRG -> STM ByteString
 randomBytes n gVar = stateTVar gVar $ randomBytesGenerate n

-reverseNonce :: CbNonceI n => n -> CbNonce
-reverseNonce = CryptoBoxNonce . B.reverse . unCbNonce
-
-xorNonce :: CbNonceI n => ByteString -> n -> CbNonce
-xorNonce s nonce = CryptoBoxNonce $ packZipWith xor s n <> B.drop (B.length s) n
-  where
-    n = unCbNonce nonce
-
-toCbNonce :: CbNonceI n => n -> CbNonce
-toCbNonce = CryptoBoxNonce . unCbNonce
+reverseNonce :: CbNonce -> CbNonce
+reverseNonce (CryptoBoxNonce s) = CryptoBoxNonce (B.reverse s)

 instance Encoding CbNonce where
  smpEncode = unCbNonce
  smpP = CryptoBoxNonce <$> A.take 24

-newtype CorrCbNonce = CorrCbNonce ByteString
-
-instance CbNonceI CorrCbNonce where
-  unCbNonce (CorrCbNonce s) = s
-
-instance Encoding CorrCbNonce where
-  smpEncode = smpEncode . unCbNonce
-  smpP = corrCbNonce <$?> smpP
-
 newtype SbKey = SecretBoxKey {unSbKey :: ByteString}
  deriving (Eq, Show)
  deriving newtype (FromField)
@@ -72,7 +72,6 @@ module Simplex.Messaging.Crypto.Ratchet
    rcEncryptHeader,
    rcEncryptMsg,
    rcDecrypt,
-    maxSkippedMsgKeys,
    -- used in tests
    MsgHeader (..),
    RatchetInitParams (..),
@@ -120,7 +119,7 @@ import Simplex.Messaging.Crypto.SNTRUP761.Bindings
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (defaultJSON, parseE, parseE')
-import Simplex.Messaging.Util ((<$?>))
+import Simplex.Messaging.Util (($>>=), (<$?>))
 import Simplex.Messaging.Version
 import Simplex.Messaging.Version.Internal
 import UnliftIO.STM
@@ -328,13 +327,9 @@ instance StrEncoding AnyE2ERatchetParamsUri where
            Nothing -> pure $ AnyE2ERatchetParamsUri SRKSProposed a $ E2ERatchetParamsUri vr k1 k2 Nothing
      _ -> fail "bad e2e params"
    where
-      kemP query = do
-        k_ <- queryParam_ "kem_key" query
-        ct_ <- queryParam_ "kem_ct" query
-        case (k_, ct_) of
-          (Just k, _) -> pure $ Just $ kemParams k ct_
-          (Nothing, Nothing) -> pure Nothing
-          (Nothing, Just _) -> fail "bad e2e params: kem_ct without kem_key"
+      kemP query =
+        queryParam_ "kem_key" query
+          $>>= \k -> Just . kemParams k <$> queryParam_ "kem_ct" query
      kemParams k = \case
        Nothing -> ARKP SRKSProposed $ RKParamsProposed k
        Just ct -> ARKP SRKSAccepted $ RKParamsAccepted ct k
@@ -963,9 +958,6 @@ type DecryptResult a = (Either CryptoError ByteString, Ratchet a, SkippedMsgDiff
 maxSkip :: Word32
 maxSkip = 512

-maxSkippedMsgKeys :: Int
-maxSkippedMsgKeys = 2000
-
 rcDecrypt ::
  forall a.
  (AlgorithmI a, DhAlgorithm a) =>
@@ -16,8 +16,6 @@ module Simplex.Messaging.Crypto.SNTRUP761.Bindings
  ) where

 import Control.Concurrent.STM
-import Control.Exception (throwIO)
-import Control.Monad (when)
 import Crypto.Random (ChaChaDRG)
 import Data.Aeson (FromJSON (..), ToJSON (..))
 import Data.Bifunctor (bimap)
@@ -25,7 +23,6 @@ import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteArray as BA
 import Data.ByteString (ByteString)
 import Simplex.Messaging.Agent.Store.DB (FromField (..), ToField (..))
-import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings.Defines
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings.FFI
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings.RNG (rngFuncPtr, withDRG)
@@ -58,13 +55,14 @@ pattern KEMSharedKey s <- KEMSharedKey_ s
 type KEMKeyPair = (KEMPublicKey, KEMSecretKey)

 sntrup761Keypair :: TVar ChaChaDRG -> IO KEMKeyPair
-sntrup761Keypair drg = do
-  ((r, pk), sk) <-
-    BA.allocRet c_SNTRUP761_SECRETKEY_SIZE $ \skPtr ->
-      BA.allocRet c_SNTRUP761_PUBLICKEY_SIZE $ \pkPtr ->
-        withDRG drg $ \cxtPtr -> c_sntrup761_keypair pkPtr skPtr cxtPtr rngFuncPtr
-  when (r /= 0) $ throwIO C.CryptoKEMKeyGenError
-  pure (KEMPublicKey_ pk, KEMSecretKey sk)
+sntrup761Keypair drg =
+  bimap KEMPublicKey_ KEMSecretKey
+    <$> BA.allocRet
+      c_SNTRUP761_SECRETKEY_SIZE
+      ( \skPtr ->
+          BA.alloc c_SNTRUP761_PUBLICKEY_SIZE $ \pkPtr ->
+            withDRG drg $ \cxtPtr -> c_sntrup761_keypair pkPtr skPtr cxtPtr rngFuncPtr
+      )

 sntrup761Enc :: TVar ChaChaDRG -> KEMPublicKey -> IO (KEMCiphertext, KEMSharedKey)
 sntrup761Enc drg (KEMPublicKey pk) =
@@ -10,9 +10,9 @@ import Foreign
 import Foreign.C
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings.RNG (RNGContext, RNGFunc)

-- int sntrup761_keypair (uint8_t *pk, uint8_t *sk, void *random_ctx, sntrup761_random_func *random);
+-- void sntrup761_keypair (uint8_t *pk, uint8_t *sk, void *random_ctx, sntrup761_random_func *random);
 foreign import ccall "sntrup761_keypair"
-  c_sntrup761_keypair :: Ptr Word8 -> Ptr Word8 -> Ptr RNGContext -> FunPtr RNGFunc -> IO CInt
+  c_sntrup761_keypair :: Ptr Word8 -> Ptr Word8 -> Ptr RNGContext -> FunPtr RNGFunc -> IO ()

 -- void sntrup761_enc (uint8_t *c, uint8_t *k, const uint8_t *pk, void *random_ctx, sntrup761_random_func *random);
 foreign import ccall "sntrup761_enc"
@@ -17,7 +17,6 @@ module Simplex.Messaging.Crypto.ShortLink
    encodeSignUserData,
    newOwnerAuth,
    encryptLinkData,
-    encryptFixedData,
    encryptUserData,
    decryptLinkData,
  )
@@ -85,10 +84,9 @@ newOwnerAuth g ownerId signingKey = do
  pure (ownerPrivKey, OwnerAuth {ownerId, ownerKey, authOwnerSig})

 encryptLinkData :: TVar ChaChaDRG -> C.SbKey -> (ByteString, ByteString) -> ExceptT AgentErrorType IO QueueLinkData
-encryptLinkData g k = bimapM (encryptFixedData g k) (encryptUserData g k)
-
-encryptFixedData :: TVar ChaChaDRG -> C.SbKey -> ByteString -> ExceptT AgentErrorType IO EncDataBytes
-encryptFixedData g k s = encryptData g k fixedDataPaddedLength s
+encryptLinkData g k = bimapM (encrypt fixedDataPaddedLength) (encrypt userDataPaddedLength)
+  where
+    encrypt len = encryptData g k len

 encryptUserData :: TVar ChaChaDRG -> C.SbKey -> ByteString -> ExceptT AgentErrorType IO EncDataBytes
 encryptUserData g k s = encryptData g k userDataPaddedLength s
@@ -1,11 +1,3 @@
--
-- PostgreSQL database dump
--
-
-\restrict 2VhRh9TjEf48DUpOJ9yf0mHxQuP7DAwleNuR1ACyiZ7rn51S2x3TX2fGKTdJ0MO
-
-- Dumped from database version 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1)
-- Dumped by pg_dump version 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1)


 SET statement_timeout = 0;
@@ -19,16 +11,10 @@ SET xmloption = content;
 SET client_min_messages = warning;
 SET row_security = off;

--
-- Name: ntf_server; Type: SCHEMA; Schema: -; Owner: -
--

 CREATE SCHEMA ntf_server;


--
-- Name: on_subscription_delete(); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.on_subscription_delete() RETURNS trigger
    LANGUAGE plpgsql
@@ -42,9 +28,6 @@ END;
 $$;


--
-- Name: on_subscription_insert(); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.on_subscription_insert() RETURNS trigger
    LANGUAGE plpgsql
@@ -58,9 +41,6 @@ END;
 $$;


--
-- Name: on_subscription_update(); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.on_subscription_update() RETURNS trigger
    LANGUAGE plpgsql
@@ -78,9 +58,6 @@ END;
 $$;


--
-- Name: should_subscribe_status(text); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.should_subscribe_status(p_status text) RETURNS boolean
    LANGUAGE plpgsql IMMUTABLE STRICT
@@ -91,9 +68,6 @@ END;
 $$;


--
-- Name: update_aggregates(bigint, bigint, bytea); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.update_aggregates(p_server_id bigint, p_change bigint, p_notifier_id bytea) RETURNS void
    LANGUAGE plpgsql
@@ -107,9 +81,6 @@ END;
 $$;


--
-- Name: update_all_aggregates(); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.update_all_aggregates() RETURNS void
    LANGUAGE plpgsql
@@ -133,9 +104,6 @@ END;
 $$;


--
-- Name: xor_combine(bytea, bytea); Type: FUNCTION; Schema: ntf_server; Owner: -
--

 CREATE FUNCTION ntf_server.xor_combine(state bytea, value bytea) RETURNS bytea
    LANGUAGE plpgsql IMMUTABLE STRICT
@@ -156,9 +124,6 @@ END;
 $$;


--
-- Name: xor_aggregate(bytea); Type: AGGREGATE; Schema: ntf_server; Owner: -
--

 CREATE AGGREGATE ntf_server.xor_aggregate(bytea) (
    SFUNC = ntf_server.xor_combine,
@@ -169,9 +134,6 @@ CREATE AGGREGATE ntf_server.xor_aggregate(bytea) (

 SET default_table_access_method = heap;

--
-- Name: last_notifications; Type: TABLE; Schema: ntf_server; Owner: -
--

 CREATE TABLE ntf_server.last_notifications (
    token_ntf_id bigint NOT NULL,
@@ -183,9 +145,6 @@ CREATE TABLE ntf_server.last_notifications (
 );


--
-- Name: last_notifications_token_ntf_id_seq; Type: SEQUENCE; Schema: ntf_server; Owner: -
--

 ALTER TABLE ntf_server.last_notifications ALTER COLUMN token_ntf_id ADD GENERATED ALWAYS AS IDENTITY (
    SEQUENCE NAME ntf_server.last_notifications_token_ntf_id_seq
@@ -197,9 +156,6 @@ ALTER TABLE ntf_server.last_notifications ALTER COLUMN token_ntf_id ADD GENERATE
 );


--
-- Name: migrations; Type: TABLE; Schema: ntf_server; Owner: -
--

 CREATE TABLE ntf_server.migrations (
    name text NOT NULL,
@@ -208,9 +164,6 @@ CREATE TABLE ntf_server.migrations (
 );


--
-- Name: smp_servers; Type: TABLE; Schema: ntf_server; Owner: -
--

 CREATE TABLE ntf_server.smp_servers (
    smp_server_id bigint NOT NULL,
@@ -226,9 +179,6 @@ CREATE TABLE ntf_server.smp_servers (
 );


--
-- Name: smp_servers_smp_server_id_seq; Type: SEQUENCE; Schema: ntf_server; Owner: -
--

 ALTER TABLE ntf_server.smp_servers ALTER COLUMN smp_server_id ADD GENERATED ALWAYS AS IDENTITY (
    SEQUENCE NAME ntf_server.smp_servers_smp_server_id_seq
@@ -240,9 +190,6 @@ ALTER TABLE ntf_server.smp_servers ALTER COLUMN smp_server_id ADD GENERATED ALWA
 );


--
-- Name: subscriptions; Type: TABLE; Schema: ntf_server; Owner: -
--

 CREATE TABLE ntf_server.subscriptions (
    subscription_id bytea NOT NULL,
@@ -255,9 +202,6 @@ CREATE TABLE ntf_server.subscriptions (
 );


--
-- Name: tokens; Type: TABLE; Schema: ntf_server; Owner: -
--

 CREATE TABLE ntf_server.tokens (
    token_id bytea NOT NULL,
@@ -274,166 +218,97 @@ CREATE TABLE ntf_server.tokens (
 );


--
-- Name: last_notifications last_notifications_pkey; Type: CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.last_notifications
    ADD CONSTRAINT last_notifications_pkey PRIMARY KEY (token_ntf_id);


--
-- Name: migrations migrations_pkey; Type: CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.migrations
    ADD CONSTRAINT migrations_pkey PRIMARY KEY (name);


--
-- Name: smp_servers smp_servers_pkey; Type: CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.smp_servers
    ADD CONSTRAINT smp_servers_pkey PRIMARY KEY (smp_server_id);


--
-- Name: subscriptions subscriptions_pkey; Type: CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.subscriptions
    ADD CONSTRAINT subscriptions_pkey PRIMARY KEY (subscription_id);


--
-- Name: tokens tokens_pkey; Type: CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.tokens
    ADD CONSTRAINT tokens_pkey PRIMARY KEY (token_id);


--
-- Name: idx_last_notifications_subscription_id; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE INDEX idx_last_notifications_subscription_id ON ntf_server.last_notifications USING btree (subscription_id);


--
-- Name: idx_last_notifications_token_id_sent_at; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE INDEX idx_last_notifications_token_id_sent_at ON ntf_server.last_notifications USING btree (token_id, sent_at);


--
-- Name: idx_last_notifications_token_subscription; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE UNIQUE INDEX idx_last_notifications_token_subscription ON ntf_server.last_notifications USING btree (token_id, subscription_id);


--
-- Name: idx_smp_servers; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE UNIQUE INDEX idx_smp_servers ON ntf_server.smp_servers USING btree (smp_host, smp_port, smp_keyhash);


--
-- Name: idx_subscriptions_smp_server_id_notifier_id; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE UNIQUE INDEX idx_subscriptions_smp_server_id_notifier_id ON ntf_server.subscriptions USING btree (smp_server_id, smp_notifier_id);


--
-- Name: idx_subscriptions_smp_server_id_ntf_service_status; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE INDEX idx_subscriptions_smp_server_id_ntf_service_status ON ntf_server.subscriptions USING btree (smp_server_id, ntf_service_assoc, status);


--
-- Name: idx_subscriptions_token_id; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE INDEX idx_subscriptions_token_id ON ntf_server.subscriptions USING btree (token_id);


--
-- Name: idx_tokens_push_provider_token; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE UNIQUE INDEX idx_tokens_push_provider_token ON ntf_server.tokens USING btree (push_provider, push_provider_token, verify_key);


--
-- Name: idx_tokens_status_cron_interval_sent_at; Type: INDEX; Schema: ntf_server; Owner: -
--

 CREATE INDEX idx_tokens_status_cron_interval_sent_at ON ntf_server.tokens USING btree (status, cron_interval, ((cron_sent_at + (cron_interval * 60))));


--
-- Name: subscriptions tr_subscriptions_delete; Type: TRIGGER; Schema: ntf_server; Owner: -
--

 CREATE TRIGGER tr_subscriptions_delete AFTER DELETE ON ntf_server.subscriptions FOR EACH ROW EXECUTE FUNCTION ntf_server.on_subscription_delete();


--
-- Name: subscriptions tr_subscriptions_insert; Type: TRIGGER; Schema: ntf_server; Owner: -
--

 CREATE TRIGGER tr_subscriptions_insert AFTER INSERT ON ntf_server.subscriptions FOR EACH ROW EXECUTE FUNCTION ntf_server.on_subscription_insert();


--
-- Name: subscriptions tr_subscriptions_update; Type: TRIGGER; Schema: ntf_server; Owner: -
--

 CREATE TRIGGER tr_subscriptions_update AFTER UPDATE ON ntf_server.subscriptions FOR EACH ROW EXECUTE FUNCTION ntf_server.on_subscription_update();


--
-- Name: last_notifications last_notifications_subscription_id_fkey; Type: FK CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.last_notifications
    ADD CONSTRAINT last_notifications_subscription_id_fkey FOREIGN KEY (subscription_id) REFERENCES ntf_server.subscriptions(subscription_id) ON UPDATE RESTRICT ON DELETE CASCADE;


--
-- Name: last_notifications last_notifications_token_id_fkey; Type: FK CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.last_notifications
    ADD CONSTRAINT last_notifications_token_id_fkey FOREIGN KEY (token_id) REFERENCES ntf_server.tokens(token_id) ON UPDATE RESTRICT ON DELETE CASCADE;


--
-- Name: subscriptions subscriptions_smp_server_id_fkey; Type: FK CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.subscriptions
    ADD CONSTRAINT subscriptions_smp_server_id_fkey FOREIGN KEY (smp_server_id) REFERENCES ntf_server.smp_servers(smp_server_id) ON UPDATE RESTRICT ON DELETE RESTRICT;


--
-- Name: subscriptions subscriptions_token_id_fkey; Type: FK CONSTRAINT; Schema: ntf_server; Owner: -
--

 ALTER TABLE ONLY ntf_server.subscriptions
    ADD CONSTRAINT subscriptions_token_id_fkey FOREIGN KEY (token_id) REFERENCES ntf_server.tokens(token_id) ON UPDATE RESTRICT ON DELETE CASCADE;


--
-- PostgreSQL database dump complete
--
-
-\unrestrict 2VhRh9TjEf48DUpOJ9yf0mHxQuP7DAwleNuR1ACyiZ7rn51S2x3TX2fGKTdJ0MO
-

@@ -145,10 +145,7 @@ module Simplex.Messaging.Protocol
    RcvNtfDhSecret,
    Message (..),
    RcvMessage (..),
-    MsgId (unMsgId),
-    mkMsgId,
-    unsafeMsgId,
-    randomMsgId,
+    MsgId,
    MsgBody,
    IdsHash (..),
    ServiceSub (..),
@@ -171,7 +168,6 @@ module Simplex.Messaging.Protocol
    EncFwdTransmission (..),
    EncResponse (..),
    EncTransmission (..),
-    encTransmissionNonce,
    FwdResponse (..),
    FwdTransmission (..),
    NameRecord (..),
@@ -236,10 +232,8 @@ module Simplex.Messaging.Protocol
 where

 import Control.Applicative (optional, (<|>))
-import Control.Concurrent.STM (STM, TVar)
 import Control.Exception (Exception, SomeException, displayException, fromException)
 import Control.Monad.Except
-import Crypto.Random (ChaChaDRG)
 import Data.Aeson (FromJSON (..), ToJSON (..))
 import qualified Data.Aeson as J
 import qualified Data.Aeson.TH as J
@@ -274,7 +268,7 @@ import qualified GHC.TypeLits as TE
 import qualified GHC.TypeLits as Type
 import Network.Socket (ServiceName)
 import qualified Network.TLS as TLS
-import Simplex.Messaging.Agent.Store.DB (Binary (..), FromField (..), ToField (..), blobFieldDecoder)
+import Simplex.Messaging.Agent.Store.DB (Binary (..), FromField (..), ToField (..))
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
@@ -708,24 +702,19 @@ instance Encoding NewNtfCreds where
 newtype EncTransmission = EncTransmission ByteString
  deriving (Show)

-encTransmissionNonce :: C.CbNonceI n => VersionSMP -> n -> C.CbNonce
-encTransmissionNonce v nonce
-  | v >= fwdNoncesSMPVersion = C.xorNonce (smpEncode v) nonce
-  | otherwise = C.toCbNonce nonce
-
 data FwdTransmission = FwdTransmission
-  { fwdCorrId :: C.CorrCbNonce,
+  { fwdCorrId :: CorrId,
    fwdVersion :: VersionSMP,
    fwdKey :: C.PublicKeyX25519,
    fwdTransmission :: EncTransmission
  }

 instance Encoding FwdTransmission where
-  smpEncode FwdTransmission {fwdCorrId, fwdVersion, fwdKey, fwdTransmission = EncTransmission t} =
-    smpEncode (fwdCorrId, fwdVersion, fwdKey, Tail t)
+  smpEncode FwdTransmission {fwdCorrId = CorrId corrId, fwdVersion, fwdKey, fwdTransmission = EncTransmission t} =
+    smpEncode (corrId, fwdVersion, fwdKey, Tail t)
  smpP = do
-    (fwdCorrId, fwdVersion, fwdKey, Tail t) <- smpP
-    pure FwdTransmission {fwdCorrId, fwdVersion, fwdKey, fwdTransmission = EncTransmission t}
+    (corrId, fwdVersion, fwdKey, Tail t) <- smpP
+    pure FwdTransmission {fwdCorrId = CorrId corrId, fwdVersion, fwdKey, fwdTransmission = EncTransmission t}

 newtype EncFwdTransmission = EncFwdTransmission ByteString
  deriving (Show)
@@ -748,8 +737,8 @@ data BrokerMsg where
  NMSG :: C.CbNonce -> EncNMsgMeta -> BrokerMsg
  -- Should include certificate chain
  PKEY :: SessionId -> VersionRangeSMP -> CertChainPubKey -> BrokerMsg -- TLS-signed server key for proxy shared secret and initial sender key
-  RRES :: Maybe C.CbNonce -> EncFwdResponse -> BrokerMsg -- relay to proxy
-  PRES :: Maybe C.CbNonce -> EncResponse -> BrokerMsg -- proxy to client
+  RRES :: EncFwdResponse -> BrokerMsg -- relay to proxy
+  PRES :: EncResponse -> BrokerMsg -- proxy to client
  END :: BrokerMsg
  ENDS :: Int64 -> IdsHash -> BrokerMsg
  DELD :: BrokerMsg
@@ -771,16 +760,16 @@ newtype EncFwdResponse = EncFwdResponse ByteString
  deriving (Eq, Show)

 data FwdResponse = FwdResponse
-  { fwdCorrId :: C.CorrCbNonce,
+  { fwdCorrId :: CorrId,
    fwdResponse :: EncResponse
  }

 instance Encoding FwdResponse where
-  smpEncode FwdResponse {fwdCorrId, fwdResponse = EncResponse t} =
-    smpEncode (fwdCorrId, Tail t)
+  smpEncode FwdResponse {fwdCorrId = CorrId corrId, fwdResponse = EncResponse t} =
+    smpEncode (corrId, Tail t)
  smpP = do
-    (fwdCorrId, Tail t) <- smpP
-    pure FwdResponse {fwdCorrId, fwdResponse = EncResponse t}
+    (corrId, Tail t) <- smpP
+    pure FwdResponse {fwdCorrId = CorrId corrId, fwdResponse = EncResponse t}

 newtype EncResponse = EncResponse ByteString
  deriving (Eq, Show)
@@ -803,7 +792,7 @@ toMsgInfo = \case
  Message {msgId, msgTs} -> msgInfo msgId msgTs MTMessage
  MessageQuota {msgId, msgTs} -> msgInfo msgId msgTs MTQuota
  where
-    msgInfo msgId msgTs msgType = MsgInfo {msgId = decodeLatin1 $ B64.encode $ unMsgId msgId, msgTs = systemToUTCTime msgTs, msgType}
+    msgInfo msgId msgTs msgType = MsgInfo {msgId = decodeLatin1 $ B64.encode msgId, msgTs = systemToUTCTime msgTs, msgType}

 messageId :: Message -> MsgId
 messageId = \case
@@ -1504,34 +1493,7 @@ type RcvNtfPublicDhKey = C.PublicKeyX25519
 type RcvNtfDhSecret = C.DhSecretX25519

 -- | SMP message server ID.
-newtype MsgId = MsgId {unMsgId :: ByteString}
-  deriving (Eq, Show)
-
-instance C.CbNonceI MsgId where
-  unCbNonce (MsgId s) = B.take 24 s
-
-instance Encoding MsgId where
-  smpEncode (MsgId s) = smpEncode s
-  smpP = mkMsgId <$?> smpP
-
-instance StrEncoding MsgId where
-  strEncode (MsgId s) = strEncode s
-  strP = mkMsgId <$?> strP
-
-instance FromField MsgId where fromField = blobFieldDecoder mkMsgId
-
-instance ToField MsgId where toField (MsgId s) = toField $ Binary s
-
-mkMsgId :: ByteString -> Either String MsgId
-mkMsgId s
-  | B.length s >= 24 = Right $ MsgId s
-  | otherwise = Left "MsgId: invalid length"
-
-unsafeMsgId :: ByteString -> MsgId
-unsafeMsgId s = either error id $ mkMsgId s
-
-randomMsgId :: Int -> TVar ChaChaDRG -> STM MsgId
-randomMsgId n = fmap MsgId . C.randomBytes (max 24 n)
+type MsgId = ByteString

 -- | SMP message body.
 type MsgBody = ByteString
@@ -1856,7 +1818,8 @@ instance PartyI p => ProtocolEncoding SMPVersion ErrorType (Command p) where
  encodeProtocol v = \case
    NEW NewQueueReq {rcvAuthKey = rKey, rcvDhKey = dhKey, auth_, subMode, queueReqData, ntfCreds}
      | v >= newNtfCredsSMPVersion -> new <> e (subMode, queueReqData, ntfCreds)
-      | otherwise -> new <> e (subMode, queueReqData)
+      | v >= shortLinksSMPVersion -> new <> e (subMode, queueReqData)
+      | otherwise -> new <> e (subMode, senderCanSecure (queueReqMode <$> queueReqData))
      where
        new = e (NEW_, ' ', rKey, dhKey, auth_)
    SUB -> e SUB_
@@ -1943,18 +1906,20 @@ instance ProtocolEncoding SMPVersion ErrorType Cmd where
    CT SCreator NEW_ -> Cmd SCreator <$> newCmd
      where
        newCmd
-          | v >= newNtfCredsSMPVersion = new smpP
-          | otherwise = new nothing
+          | v >= newNtfCredsSMPVersion = new smpP smpP
+          | v >= shortLinksSMPVersion = new smpP nothing
+          | otherwise = new (qReq <$> smpP) nothing
          where
            nothing = pure Nothing
-            new p3 = NEW <$> do
+            new p2 p3 = NEW <$> do
              rcvAuthKey <- _smpP
              rcvDhKey <- smpP
              auth_ <- smpP
              subMode <- smpP
-              queueReqData <- smpP
+              queueReqData <- p2
              ntfCreds <- p3
              pure NewQueueReq {rcvAuthKey, rcvDhKey, auth_, subMode, queueReqData, ntfCreds}
+            qReq sndSecure = Just $ if sndSecure then QRMessaging Nothing else QRContact Nothing
    CT SRecipient tag ->
      Cmd SRecipient <$> case tag of
        SUB_ -> pure SUB
@@ -2005,7 +1970,8 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
    IDS QIK {rcvId, sndId, rcvPublicDhKey = srvDh, queueMode, linkId, serviceId, serverNtfCreds}
      | v >= newNtfCredsSMPVersion -> ids <> e (queueMode, linkId, serviceId, serverNtfCreds)
      | v >= serviceCertsSMPVersion -> ids <> e (queueMode, linkId, serviceId)
-      | otherwise -> ids <> e (queueMode, linkId)
+      | v >= shortLinksSMPVersion -> ids <> e (queueMode, linkId)
+      | otherwise -> ids <> e (senderCanSecure queueMode)
      where
        ids = e (IDS_, ' ', rcvId, sndId, srvDh)
    LNK sId d -> e (LNK_, ' ', sId, d)
@@ -2019,8 +1985,8 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
    NID nId srvNtfDh -> e (NID_, ' ', nId, srvNtfDh)
    NMSG nmsgNonce encNMsgMeta -> e (NMSG_, ' ', nmsgNonce, encNMsgMeta)
    PKEY sid vr certKey -> e (PKEY_, ' ', sid, vr, certKey)
-    RRES nonce_ (EncFwdResponse encBlock) -> fwdResp RRES_ nonce_ encBlock
-    PRES nonce_ (EncResponse encBlock) -> fwdResp PRES_ nonce_ encBlock
+    RRES (EncFwdResponse encBlock) -> e (RRES_, ' ', Tail encBlock)
+    PRES (EncResponse encBlock) -> e (PRES_, ' ', Tail encBlock)
    END -> e END_
    ENDS n idsHash -> serviceResp ENDS_ n idsHash
    DELD -> e DELD_
@@ -2044,9 +2010,6 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
      serviceResp tag n idsHash
        | v >= rcvServiceSMPVersion = e (tag, ' ', n, idsHash)
        | otherwise = e (tag, ' ', n)
-      fwdResp tag nonce_ encBlock
-        | v >= fwdNoncesSMPVersion = e (tag, ' ', nonce_, Tail encBlock)
-        | otherwise = e (tag, ' ', Tail encBlock)

  protocolP v = \case
    MSG_ -> do
@@ -2056,17 +2019,19 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
        bodyP = EncRcvMsgBody . unTail <$> smpP
    ALLS_ -> pure ALLS
    IDS_
-      | v >= newNtfCredsSMPVersion -> ids smpP smpP
-      | v >= serviceCertsSMPVersion -> ids smpP nothing
-      | otherwise -> ids nothing nothing
+      | v >= newNtfCredsSMPVersion -> ids smpP smpP smpP smpP
+      | v >= serviceCertsSMPVersion -> ids smpP smpP smpP nothing
+      | v >= shortLinksSMPVersion -> ids smpP smpP nothing nothing
+      | otherwise -> ids (qm <$> smpP) nothing nothing nothing
      where
+        qm sndSecure = Just $ if sndSecure then QMMessaging else QMContact
        nothing = pure Nothing
-        ids p3 p4 = do
+        ids p1 p2 p3 p4 = do
          rcvId <- _smpP
          sndId <- smpP
          rcvPublicDhKey <- smpP
-          queueMode <- smpP
-          linkId <- smpP
+          queueMode <- p1
+          linkId <- p2
          serviceId <- p3
          serverNtfCreds <- p4
          pure $ IDS QIK {rcvId, sndId, rcvPublicDhKey, queueMode, linkId, serviceId, serverNtfCreds}
@@ -2076,8 +2041,8 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
    NID_ -> NID <$> _smpP <*> smpP
    NMSG_ -> NMSG <$> _smpP <*> smpP
    PKEY_ -> PKEY <$> _smpP <*> smpP <*> smpP
-    RRES_ -> fwdRespP RRES EncFwdResponse
-    PRES_ -> fwdRespP PRES EncResponse
+    RRES_ -> RRES <$> (EncFwdResponse . unTail <$> _smpP)
+    PRES_ -> PRES <$> (EncResponse . unTail <$> _smpP)
    END_ -> pure END
    ENDS_ -> serviceRespP ENDS
    DELD_ -> pure DELD
@@ -2094,9 +2059,6 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
      serviceRespP resp
        | v >= rcvServiceSMPVersion = resp <$> _smpP <*> smpP
        | otherwise = resp <$> _smpP <*> pure mempty
-      fwdRespP :: (Maybe C.CbNonce -> a -> BrokerMsg) -> (ByteString -> a) -> Parser BrokerMsg
-      fwdRespP resp enc = resp <$> (A.space *> nonceP) <*> (enc <$> A.takeByteString)
-      nonceP = if v >= fwdNoncesSMPVersion then smpP else pure Nothing

  fromProtocolError = \case
    PECmdSyntax -> CMD SYNTAX
@@ -2113,7 +2075,7 @@ instance ProtocolEncoding SMPVersion ErrorType BrokerMsg where
    -- PONG response must not have queue ID
    PONG -> noEntityMsg
    PKEY {} -> noEntityMsg
-    RRES {} -> noEntityMsg
+    RRES _ -> noEntityMsg
    ALLS -> noEntityMsg
    RNAME {} -> noEntityMsg
    -- other broker responses must have queue ID
@@ -2449,9 +2411,7 @@ tDecodeServer THandleParams {sessionId, thVersion = v, implySessId} = \case
          where
            cmdOrErr = parseProtocol @v @err @cmd v command >>= checkCredentials tAuth entityId
            t :: a -> (CorrId, EntityId, a)
-            -- IDs are slices of the ~16 KB received block and are kept as subscription keys,
-            -- so without a copy one live key retains the whole block
-            t = (CorrId $ B.copy $ bs corrId,EntityId $ B.copy $ unEntityId entityId,)
+            t = (corrId,entityId,)
        Left _ -> tError corrId PEBlock
    | otherwise -> tError corrId PESession
  Left _ -> tError "" PEBlock
@@ -1145,16 +1145,14 @@ cancelSub s = case subThread s of
 type VerifiedTransmissionOrError s = Either (Transmission BrokerMsg) (VerifiedTransmission s)

 receive :: forall c s. (Transport c, MsgStoreClass s) => THandleSMP c 'TServer -> s -> Client s -> M s ()
-receive h@THandle {params = THandleParams {thAuth, sessionId}} ms c@Client {rcvQ, rcvActiveAt} = do
+receive h@THandle {params = THandleParams {thAuth, sessionId}} ms Client {rcvQ, sndQ, rcvActiveAt} = do
  labelMyThread . B.unpack $ "client $" <> encode sessionId <> " receive"
  sa <- asks serverActive
  stats <- asks serverStats
-  authDelay <- asks $ authErrorDelay . config
  liftIO $ forever $ do
    ts <- tGetServer h
    unlessM (readTVarIO sa) $ throwIO $ userError "server stopped"
-    receivedAt <- getSystemTime
-    atomically $ writeTVar rcvActiveAt $! receivedAt
+    atomically . (writeTVar rcvActiveAt $!) =<< getSystemTime
    let (es, ts') = partitionEithers $ L.toList ts
        errs = map (second ERR) es
    errs' <- case ts' of
@@ -1170,7 +1168,7 @@ receive h@THandle {params = THandleParams {thAuth, sessionId}} ms c@Client {rcvQ
        mapM_ (atomically . writeTBQueue rcvQ) $ L.nonEmpty cmds
        pure $ errs ++ errs'
      [] -> pure errs
-    mapM_ (sendResponses c stats authDelay receivedAt . (,[])) $ L.nonEmpty errs'
+    mapM_ (atomically . writeTBQueue sndQ . (,[])) $ L.nonEmpty errs'
  where
    sameParty :: SParty p -> SignedTransmission Cmd -> Bool
    sameParty p (_, _, (_, _, Cmd p' _)) = isJust $ testEquality p p'
@@ -1193,27 +1191,6 @@ receive h@THandle {params = THandleParams {thAuth, sessionId}} ms c@Client {rcvQ
            GET -> incStat $ msgGetAuth stats
            _ -> pure ()

-isAuthError :: Transmission BrokerMsg -> Bool
-isAuthError (_, _, r) = case r of
-  ERR AUTH -> True
-  _ -> False
-
-sendResponses :: Client s -> ServerStats -> Int64 -> SystemTime -> (NonEmpty (Transmission BrokerMsg), [Transmission BrokerMsg]) -> IO ()
-sendResponses c@Client {sndQ} stats authDelay since rs@(ts, _)
-  | any isAuthError ts = sendAfterDelay c stats authDelay since rs
-  | otherwise = atomically $ writeTBQueue sndQ rs
-
-sendAfterDelay :: Client s -> ServerStats -> Int64 -> SystemTime -> (NonEmpty (Transmission BrokerMsg), [Transmission BrokerMsg]) -> IO ()
-sendAfterDelay c@Client {sndQ, clientTHParams = THandleParams {sessionId}} stats delay since rs
-  | delay > 0 = do
-      elapsed <- subtract (microseconds since) . microseconds <$> getSystemTime
-      when (elapsed >= delay) $ incStat $ authDelayExceeded stats
-      forkClient c (B.unpack $ "client $" <> encode sessionId <> " auth") $ threadDelay' (delay - elapsed `mod` delay) >> write
-  | otherwise = write
-  where
-    write = atomically $ writeTBQueue sndQ rs
-    microseconds (MkSystemTime s ns) = s * 1000000 + fromIntegral (ns `div` 1000)
-
 send :: Transport c => MVar (THandleSMP c 'TServer) -> Client s -> IO ()
 send th c@Client {sndQ, msgQ, clientTHParams = THandleParams {sessionId}} = do
  labelMyThread . B.unpack $ "client $" <> encode sessionId <> " send"
@@ -1342,6 +1319,11 @@ isContactQueue QueueRec {queueMode, senderKey} = case queueMode of
  Just QMContact -> True
  Nothing -> isNothing senderKey -- for backward compatibility with pre-SKEY contact addresses

+isSecuredMsgQueue :: QueueRec -> Bool
+isSecuredMsgQueue QueueRec {queueMode, senderKey} = case queueMode of
+  Just QMContact -> False
+  _ -> isJust senderKey
+
 -- Random correlation ID is used as a nonce in case crypto_box authenticator is used to authorize transmission
 verifyCmdAuthorization :: Maybe (THandleAuth 'TServer) -> Maybe TAuthorizations -> ByteString -> CorrId -> C.APublicAuthKey -> Bool
 verifyCmdAuthorization thAuth tAuth authorized corrId key = maybe False (verify key) tAuth
@@ -1357,7 +1339,7 @@ verifyCmdAuthorization thAuth tAuth authorized corrId key = maybe False (verify

 verifyCmdAuth :: Maybe (THandleAuth 'TServer) -> C.PublicKeyX25519 -> C.CbAuthenticator -> ByteString -> CorrId -> Bool
 verifyCmdAuth thAuth k authenticator authorized (CorrId corrId) = case thAuth of
-  Just THAuthServer {serverPrivKey = pk} -> either (const False) (\nonce -> C.cbVerify k pk nonce authenticator authorized) $ C.cbNonce corrId
+  Just THAuthServer {serverPrivKey = pk} -> C.cbVerify k pk (C.cbNonce corrId) authenticator authorized
  Nothing -> False

 dummyVerifyCmd :: Maybe (THandleAuth 'TServer) -> Maybe TAuthorizations -> ByteString -> CorrId -> Bool
@@ -1397,18 +1379,15 @@ client
  ms
  clnt@Client {clientId, rcvQ, sndQ, msgQ, clientTHParams = thParams'@THandleParams {sessionId}, procThreads} = do
    labelMyThread . B.unpack $ "client $" <> encode sessionId <> " commands"
-    stats <- asks serverStats
-    authDelay <- asks $ authErrorDelay . config
    let clntServiceId = (\THClientService {serviceId} -> serviceId) <$> (peerClientService =<< thAuth thParams')
        process batchSubs t acc@(rs, msgs) =
          (maybe acc (\(!r, !msg_) -> (r : rs, maybe msgs (: msgs) msg_)))
            <$> processCommand clntServiceId batchSubs t
    forever $ do
      batch <- atomically (readTBQueue rcvQ)
-      processedAt <- liftIO getSystemTime
      batchSubs <- prepareBatchSubs clntServiceId batch
      foldrM (process batchSubs) ([], []) batch
-        >>= \(rs_, msgs) -> mapM_ (liftIO . sendResponses clnt stats authDelay processedAt . (,msgs)) (L.nonEmpty rs_)
+        >>= \(rs_, msgs) -> mapM_ (atomically . writeTBQueue sndQ . (,msgs)) (L.nonEmpty rs_)
  where
    prepareBatchSubs ::
      Maybe ServiceId ->
@@ -1479,15 +1458,14 @@ client
        ServerStats {pMsgFwds, pMsgFwdsOwn} <- asks serverStats
        let inc = mkIncProxyStats pMsgFwds pMsgFwdsOwn
        liftIO (lookupSMPServerClient a sessId) >>= \case
-          Just (own, smp) | Right fwdCorrId <- C.corrCbNonce (bs corrId) -> do
+          Just (own, smp) -> do
            inc own pRequests
            forkProxiedCmd $ do
-              liftIO (runExceptT (forwardSMPTransmission smp fwdCorrId fwdV pubKey encBlock) `E.catches` clientHandlers)  >>= \case
-                Right (nonce_, r) -> PRES nonce_ r <$ inc own pSuccesses
+              liftIO (runExceptT (forwardSMPTransmission smp corrId fwdV pubKey encBlock) `E.catches` clientHandlers)  >>= \case
+                Right r -> PRES r <$ inc own pSuccesses
                Left e -> ERR (smpProxyError e) <$ case e of
                  PCEProtocolError {} -> inc own pSuccesses
                  _ -> inc own pErrorsOther
-          Just _ -> pure $ Just $ ERR $ CMD SYNTAX
          Nothing -> inc False pRequests >> inc False pErrorsConnect $> Just (ERR $ PROXY NO_SESSION)
      where
        forkProxiedCmd :: M s BrokerMsg -> M s (Maybe BrokerMsg)
@@ -1977,7 +1955,7 @@ client
            getDelivered :: Sub -> STM (Maybe (ServerSub, SystemSeconds))
            getDelivered Sub {delivered, subThread} = do
              readTVar delivered $>>= \(msgId', ts) ->
-                if msgId == msgId'
+                if msgId == msgId' || B.null msgId
                  then writeTVar delivered Nothing $> Just (subThread, ts)
                  else pure Nothing
            updateStats :: ServerStats -> Bool -> SystemSeconds -> Message -> IO ()
@@ -2023,7 +2001,7 @@ client
                      when (isJust (queueData qr) && isSecuredMsgQueue qr) $ void $ liftIO $
                        deleteQueueLinkData (queueStore ms) q
                      ServerConfig {messageExpiration, expireMessagesOnSend, msgIdBytes} <- asks config
-                      msgId <- atomically . randomMsgId msgIdBytes =<< asks random
+                      msgId <- randomId' msgIdBytes
                      msg_ <- liftIO $ runExceptT $ do
                        when expireMessagesOnSend $ mapM_ (expireMessages stats) messageExpiration
                        msg <- liftIO $ mkMessage msgId body
@@ -2136,7 +2114,7 @@ client
              liftIO $ storeNtf ns nId ntf
              incStat . ntfCount =<< asks serverStats

-            mkMessageNotification :: MsgId -> SystemTime -> RcvNtfDhSecret -> M s MsgNtf
+            mkMessageNotification :: ByteString -> SystemTime -> RcvNtfDhSecret -> M s MsgNtf
            mkMessageNotification msgId msgTs rcvNtfDhSecret = do
              ntfNonce <- atomically . C.randomCbNonce =<< asks random
              let msgMeta = NMsgMeta {msgId, msgTs}
@@ -2145,16 +2123,15 @@ client

        processForwardedCommand :: EncFwdTransmission -> M s (Maybe BrokerMsg)
        processForwardedCommand (EncFwdTransmission s) = fmap (either (Just . ERR) id) . runExceptT $ do
-          startedAt <- liftIO getSystemTime
          THAuthServer {serverPrivKey, sessSecret'} <- maybe (throwE $ transportErr TENoServerAuth) pure (thAuth thParams')
          sessSecret <- maybe (throwE $ transportErr TENoServerAuth) pure sessSecret'
-          proxyNonce <- liftEitherWith (const CRYPTO) $ C.cbNonce $ bs corrId
+          let proxyNonce = C.cbNonce $ bs corrId
          s' <- liftEitherWith (const CRYPTO) $ C.cbDecryptNoPad sessSecret proxyNonce s
          FwdTransmission {fwdCorrId, fwdVersion, fwdKey, fwdTransmission = EncTransmission et} <- liftEitherWith (const $ CMD SYNTAX) $ smpDecode s'
          unless (fwdVersion `isCompatible` thServerVRange thParams') $ throwE $ transportErr TEVersion
          let clientSecret = C.dh' fwdKey serverPrivKey
-              clientNonce = fwdCorrId
-          b <- liftEitherWith (const CRYPTO) $ C.cbDecrypt clientSecret (encTransmissionNonce fwdVersion clientNonce) et
+              clientNonce = C.cbNonce $ bs fwdCorrId
+          b <- liftEitherWith (const CRYPTO) $ C.cbDecrypt clientSecret clientNonce et
          let clntTHParams = smpTHParamsSetVersion fwdVersion thParams'
          -- only allowing single forwarded transactions
          t' <- case tParse clntTHParams b of
@@ -2167,13 +2144,9 @@ client
                  TBError _ _ : _ -> throwE BLOCK
                  TBTransmission b' _ : _ -> pure b'
                  TBTransmissions b' _ _ : _ -> pure b'
-                nonce_ <-
-                  if fwdVersion >= fwdNoncesSMPVersion
-                    then Just <$> (atomically . C.randomCbNonce =<< asks random)
-                    else pure Nothing
-                r2 <- liftEitherWith (const BLOCK) $ EncResponse <$> C.cbEncrypt clientSecret (fromMaybe (C.reverseNonce clientNonce) nonce_) r' paddedProxiedTLength
+                r2 <- liftEitherWith (const BLOCK) $ EncResponse <$> C.cbEncrypt clientSecret (C.reverseNonce clientNonce) r' paddedProxiedTLength
                let fr = FwdResponse {fwdCorrId, fwdResponse = r2}
-                pure $ RRES nonce_ $ EncFwdResponse $ C.cbEncryptNoPad sessSecret (C.reverseNonce proxyNonce) (smpEncode fr)
+                pure $ RRES $ EncFwdResponse $ C.cbEncryptNoPad sessSecret (C.reverseNonce proxyNonce) (smpEncode fr)
          -- the inner response, or Nothing if forked (RSLV).
          r_ <- lift (rejectOrVerify clntThAuth t') >>= \case
            -- rejectOrVerify filters allowed commands, no need to repeat it here.
@@ -2189,11 +2162,7 @@ client
              _ -> Just . maybe (corrId', entId', ERR INTERNAL) fst <$> lift (processCommand Nothing (Right (M.empty, M.empty, M.empty)) t'')
          stats <- asks serverStats
          incStat $ pMsgFwdsRecv stats
-          traverse encodeResp r_ >>= \case
-            Just rres | any isAuthError r_ -> do
-              authDelay <- asks $ authErrorDelay . config
-              Nothing <$ liftIO (sendAfterDelay clnt stats authDelay startedAt ([(corrId, NoEntity, rres)], []))
-            rres_ -> pure rres_
+          traverse encodeResp r_
          where
            rejectOrVerify :: Maybe (THandleAuth 'TServer) -> SignedTransmissionOrError ErrorType Cmd -> M s (VerifiedTransmissionOrError s)
            rejectOrVerify clntThAuth = \case
@@ -2219,7 +2188,7 @@ client
          MessageQuota {} -> RcvMsgQuota msgTs'
          where
            encrypt :: KnownNat i => C.MaxLenBS i -> RcvMessage
-            encrypt body = RcvMessage msgId' . EncRcvMsgBody $ C.cbEncryptMaxLenBS (rcvDhSecret qr) msgId' body
+            encrypt body = RcvMessage msgId' . EncRcvMsgBody $ C.cbEncryptMaxLenBS (rcvDhSecret qr) (C.cbNonce msgId') body
            msgId' = messageId msg
            msgTs' = messageTs msg

@@ -2268,7 +2237,7 @@ client
                    SubPending -> QSubPending
                    SubThread _ -> QSubThread
                ProhibitSub -> pure QProhibitSub
-              qDelivered <- decodeLatin1 . encode . unMsgId . fst <$$> readTVarIO delivered
+              qDelivered <- decodeLatin1 . encode . fst <$$> readTVarIO delivered
              pure QSub {qSubThread, qDelivered}

        ok :: Transmission BrokerMsg
@@ -68,7 +68,6 @@ module Simplex.Messaging.Server.Env.STM
    defaultInactiveClientExpiration,
    defaultProxyClientConcurrency,
    defaultNameResolverConcurrency,
-    defaultAuthErrorDelayMs,
    defaultMaxJournalMsgCount,
    defaultMaxJournalStateLines,
    defaultIdleQueueInterval,
@@ -188,7 +187,6 @@ data ServerConfig s = ServerConfig
    ntfDeliveryInterval :: Int,
    -- | interval between sending pending END events to unsubscribed clients, seconds
    pendingENDInterval :: Int,
-    authErrorDelay :: Int64,
    smpCredentials :: ServerCredentials,
    httpCredentials :: Maybe ServerCredentials,
    -- | SMP client-server protocol version range
@@ -257,9 +255,6 @@ defaultProxyClientConcurrency = 32
 defaultNameResolverConcurrency :: Int
 defaultNameResolverConcurrency = 1000

-defaultAuthErrorDelayMs :: Int64
-defaultAuthErrorDelayMs = 50
-
 journalMsgStoreDepth :: Int
 journalMsgStoreDepth = 5

@@ -576,10 +571,7 @@ newProhibitedSub = do
  return Sub {subThread = ProhibitSub, delivered}

 newEnv :: ServerConfig s -> IO (Env s)
-newEnv config@ServerConfig {smpCredentials, httpCredentials, serverStoreCfg, smpAgentCfg, information, messageExpiration, idleQueueInterval, msgQueueQuota, maxJournalMsgCount, maxJournalStateLines, namesConfig, msgIdBytes} = do
-  when (msgIdBytes < 24) $ do
-    logError "Error: msgIdBytes must be at least 24"
-    exitFailure
+newEnv config@ServerConfig {smpCredentials, httpCredentials, serverStoreCfg, smpAgentCfg, information, messageExpiration, idleQueueInterval, msgQueueQuota, maxJournalMsgCount, maxJournalStateLines, namesConfig} = do
  serverActive <- newTVarIO True
  server <- newServer
  msgStore_ <- case serverStoreCfg of
@@ -580,7 +580,6 @@ smpServerCLI_ generateSite serveStaticFiles attachStaticFiles cfgPath logPath =
              prometheusMetricsFile = combine logPath "smp-server-metrics.txt",
              pendingENDInterval = 15000000, -- 15 seconds
              ntfDeliveryInterval = 1500000, -- 1.5 second
-              authErrorDelay = 1000 * readIniDefault defaultAuthErrorDelayMs "TRANSPORT" "auth_error_delay_ms" ini,
              smpServerVRange = supportedServerSMPRelayVRange,
              transportConfig =
                mkTransportServerConfig
@@ -130,9 +130,7 @@ iniFileContent cfgPath logPath opts host basicAuth controlPortPwds =
    <> ("host = " <> T.pack host <> "\n")
    <> ("port = " <> defaultServerPorts <> "\n")
    <> "log_tls_errors = off\n\n\
-        \# Minimum time to respond with AUTH error, milliseconds.\n"
-    <> ("# auth_error_delay_ms = " <> tshow defaultAuthErrorDelayMs <> "\n\n")
-    <> "# Use `websockets = 443` to run websockets server in addition to plain TLS.\n\
+        \# Use `websockets = 443` to run websockets server in addition to plain TLS.\n\
        \# This option is deprecated and should be used for testing only.\n\
        \# , port 443 should be specified in port above\n\
        \websockets = off\n"
@@ -114,9 +114,7 @@ instance MsgStoreClass PostgresMsgStore where
    where
      st = dbStore $ queueStore_ ms
      oldMsg = now - ttl
-      -- expired messages read per page in expire_old_messages, and the page is one
-      -- transaction: queues in it stay row-locked against SEND and ACK until it commits.
-      batchSize = 100 :: Int
+      batchSize = 10000 :: Int
      toMessageStats (expiredMsgsCount, storedMsgsCount, storedQueues) =
        MessageStats {expiredMsgsCount, storedMsgsCount, storedQueues}

@@ -202,7 +200,7 @@ instance MsgStoreClass PostgresMsgStore where
          DB.query
            db
            "SELECT quota_written, was_empty FROM write_message(?,?,?,?,?,?,?)"
-            (recipientId' q, messageId msg, systemSeconds (messageTs msg), msgQuota, ntf, Binary body, quota)
+            (recipientId' q, Binary (messageId msg), systemSeconds (messageTs msg), msgQuota, ntf, Binary body, quota)
    where
      toResult = \case
        ((msgQuota, wasEmpty) : _) -> if msgQuota then Nothing else Just (msg, wasEmpty)
@@ -271,14 +269,14 @@ instance MsgStoreClass PostgresMsgStore where
    uninterruptibleMask_ $
      withDB' "tryDelMsg" (queueStore_ ms) $ \db ->
        maybeFirstRow toMessage $
-          DB.query db "SELECT r_msg_id, r_msg_ts, r_msg_quota, r_msg_ntf_flag, r_msg_body FROM try_del_msg(?, ?)" (recipientId' q, msgId)
+          DB.query db "SELECT r_msg_id, r_msg_ts, r_msg_quota, r_msg_ntf_flag, r_msg_body FROM try_del_msg(?, ?)" (recipientId' q, Binary msgId)

  tryDelPeekMsg :: PostgresMsgStore -> PostgresQueue -> MsgId -> ExceptT ErrorType IO (Maybe Message, Maybe Message)
  tryDelPeekMsg ms q msgId =
    uninterruptibleMask_ $
      withDB' "tryDelPeekMsg" (queueStore_ ms) $ \db ->
        toResult . map toMessage
-          <$> DB.query db "SELECT r_msg_id, r_msg_ts, r_msg_quota, r_msg_ntf_flag, r_msg_body FROM try_del_peek_msg(?, ?)" (recipientId' q, msgId)
+          <$> DB.query db "SELECT r_msg_id, r_msg_ts, r_msg_quota, r_msg_ntf_flag, r_msg_body FROM try_del_peek_msg(?, ?)" (recipientId' q, Binary msgId)
    where
      toResult = \case
        [] -> (Nothing, Nothing)
@@ -297,13 +295,13 @@ uninterruptibleMask_ :: ExceptT ErrorType IO a -> ExceptT ErrorType IO a
 uninterruptibleMask_ = ExceptT . E.uninterruptibleMask_ . runExceptT
 {-# INLINE uninterruptibleMask_ #-}

-toMaybeMessage :: (Maybe MsgId, Maybe Int64, Maybe Bool, Maybe Bool, Maybe (Binary MsgBody)) -> Maybe Message
+toMaybeMessage :: (Maybe (Binary MsgId), Maybe Int64, Maybe Bool, Maybe Bool, Maybe (Binary MsgBody)) -> Maybe Message
 toMaybeMessage = \case
  (Just msgId, Just ts, Just msgQuota, Just ntf, Just body) -> Just $ toMessage (msgId, ts, msgQuota, ntf, body)
  _ -> Nothing

-toMessage :: (MsgId, Int64, Bool, Bool, Binary MsgBody) -> Message
-toMessage (msgId, ts, msgQuota, ntf, Binary body)
+toMessage :: (Binary MsgId, Int64, Bool, Bool, Binary MsgBody) -> Message
+toMessage (Binary msgId, ts, msgQuota, ntf, Binary body)
  | msgQuota = MessageQuota {msgId, msgTs}
  | otherwise = Message {msgId, msgTs, msgFlags = MsgFlags ntf, msgBody = C.unsafeMaxLenBS body} -- TODO [messages] unsafeMaxLenBS?
  where
@@ -365,8 +363,8 @@ deleteAllMessages ms =
      db
      [sql|
        UPDATE msg_queues
-        SET msg_queue_size = 0, msg_can_write = TRUE
-        WHERE msg_queue_size != 0 OR msg_can_write = FALSE
+        SET msg_queue_size = 0, msg_can_write = TRUE, msg_queue_expire = FALSE
+        WHERE msg_queue_size != 0 OR msg_can_write = FALSE OR msg_queue_expire = TRUE
      |]

 updateQueueCounts :: PostgresMsgStore -> IO ()
@@ -386,15 +384,16 @@ updateQueueCounts ms =
      db
      [sql|
        UPDATE msg_queues
-        SET msg_queue_size = 0, msg_can_write = TRUE
-        WHERE msg_queue_size != 0 OR msg_can_write = FALSE
+        SET msg_queue_size = 0, msg_can_write = TRUE, msg_queue_expire = FALSE
+        WHERE msg_queue_size != 0 OR msg_can_write = FALSE OR msg_queue_expire = TRUE
      |]
    void $ DB.execute_
      db
      [sql|
        UPDATE msg_queues q
        SET msg_queue_size = s.size,
-            msg_can_write = s.quota_count = 0
+            msg_can_write = s.quota_count = 0,
+            msg_queue_expire = s.size > s.quota_count
        FROM queue_stats s
        WHERE q.recipient_id = s.recipient_id
      |]
@@ -429,7 +428,7 @@ messageRecToText rId msg =
    tabFields = BB.char7 ',' `intersperse` fields
    fields =
      [ renderField (toField rId),
-        renderField (toField $ messageId msg),
+        renderField (toField $ Binary (messageId msg)),
        renderField (toField $ systemSeconds (messageTs msg)),
        renderField (toField msgQuota),
        renderField (toField ntf),
@@ -126,7 +126,6 @@ prometheusMetrics sm rtm ts =
        _ntfServices,
        _rcvServicesSubMsg,
        _rcvServicesSubDuplicate,
-        _authDelayExceeded,
        _qCount,
        _msgCount,
        _ntfCount,
@@ -193,10 +192,6 @@ prometheusMetrics sm rtm ts =
      \# HELP simplex_smp_queues_notify_monthly Monthly active queues with notifications.\n\
      \# TYPE simplex_smp_queues_notify_monthly gauge\n\
      \simplex_smp_queues_notify_monthly " <> mstr (monthCount psNtf) <> "\n# monthCountNtf\n\
-      \\n\
-      \# HELP simplex_smp_auth_delay_exceeded Responses with AUTH errors sent without delay, as processing took longer than the delay.\n\
-      \# TYPE simplex_smp_auth_delay_exceeded counter\n\
-      \simplex_smp_auth_delay_exceeded " <> mshow _authDelayExceeded <> "\n# authDelayExceeded\n\
      \\n"
    subscriptions =
      "# Subscriptions\n\
@@ -13,14 +13,12 @@ module Simplex.Messaging.Server.QueueStore
    ServiceRec (..),
    CertFingerprint,
    ServerEntityStatus (..),
-    isSecuredMsgQueue,
  ) where

 import Control.Applicative (optional, (<|>))
 import qualified Data.ByteString.Char8 as B
 import Data.Functor (($>))
 import Data.List.NonEmpty (NonEmpty)
-import Data.Maybe (isJust)
 import qualified Data.X509 as X
 import qualified Data.X509.Validation as XV
 import Simplex.Messaging.Encoding
@@ -50,11 +48,6 @@ data QueueRec = QueueRec
  }
  deriving (Show)

-isSecuredMsgQueue :: QueueRec -> Bool
-isSecuredMsgQueue QueueRec {queueMode, senderKey} = case queueMode of
-  Just QMContact -> False
-  _ -> isJust senderKey
-
 data NtfCreds = NtfCreds
  { notifierId :: NotifierId,
    notifierKey :: NtfPublicAuthKey,
@@ -314,9 +314,9 @@ instance StoreQueueClass q => QueueStoreClass q (PostgresQueueStore q) where
  addQueueLinkData st sq lnkId d =
    withQueueRec sq "addQueueLinkData" $ \q -> case queueData q of
      Nothing ->
-        addLink q $ \db -> DB.execute db qry (d :. (lnkId, rId, QMContact))
+        addLink q $ \db -> DB.execute db qry (d :. (lnkId, rId))
      Just (lnkId', _) | lnkId' == lnkId ->
-        addLink q $ \db -> DB.execute db (qry <> " AND (fixed_data IS NULL OR fixed_data = ?)") (d :. (lnkId, rId, QMContact, fst d))
+        addLink q $ \db -> DB.execute db (qry <> " AND (fixed_data IS NULL OR fixed_data = ?)") (d :. (lnkId, rId, fst d))
      _ -> throwE AUTH
    where
      rId = recipientId sq
@@ -324,8 +324,7 @@ instance StoreQueueClass q => QueueStoreClass q (PostgresQueueStore q) where
        assertUpdated $ withDB' "addQueueLinkData" st update
        atomically $ writeTVar (queueRec sq) $ Just q {queueData = Just (lnkId, d)}
        withLog "addQueueLinkData" st $ \s -> logCreateLink s rId lnkId d
-      -- the sender key condition is checked in SQL because without cache each command reads its own copy of the queue record
-      qry = "UPDATE msg_queues SET fixed_data = ?, user_data = ?, link_id = ? WHERE recipient_id = ? AND deleted_at IS NULL AND (sender_key IS NULL OR queue_mode = ?)"
+      qry = "UPDATE msg_queues SET fixed_data = ?, user_data = ?, link_id = ? WHERE recipient_id = ? AND deleted_at IS NULL"

  deleteQueueLinkData :: PostgresQueueStore q -> q -> IO (Either ErrorType ())
  deleteQueueLinkData st sq =
@@ -825,10 +824,6 @@ instance ToField EncDataBytes where toField (EncDataBytes s) = toField (Binary s

 deriving newtype instance FromField EncDataBytes

-instance ToField MsgId where toField = toField . Binary . unMsgId
-
-instance FromField MsgId where fromField = blobFieldDecoder mkMsgId
-
 deriving newtype instance ToField (RoundedSystemTime t)

 deriving newtype instance FromField (RoundedSystemTime t)
@@ -22,8 +22,7 @@ serverSchemaMigrations =
    ("20250903_store_messages", m20250903_store_messages, Just down_m20250903_store_messages),
    ("20250915_queue_ids_hash", m20250915_queue_ids_hash, Just down_m20250915_queue_ids_hash),
    ("20260916_prometheus_indexes", m20260916_prometheus_indexes, Just down_m20260916_prometheus_indexes),
-    ("20260917_msg_queues_hot", m20260917_msg_queues_hot, Just down_m20260917_msg_queues_hot),
-    ("20260918_expire_messages", m20260918_expire_messages, Just down_m20260918_expire_messages)
+    ("20260917_msg_queues_hot", m20260917_msg_queues_hot, Just down_m20260917_msg_queues_hot)
  ]

 -- | The list of migrations in ascending order by date
@@ -735,504 +734,3 @@ ALTER TABLE msg_queues RESET (fillfactor, autovacuum_vacuum_scale_factor, autova
 ALTER TABLE messages RESET (autovacuum_vacuum_scale_factor, autovacuum_analyze_scale_factor, toast.autovacuum_vacuum_scale_factor);
 ALTER TABLE services RESET (fillfactor, autovacuum_vacuum_threshold, autovacuum_vacuum_scale_factor);
    |]
-
-m20260918_expire_messages :: Text
-m20260918_expire_messages =
-  [r|
-CREATE INDEX idx_messages_expire ON messages (msg_ts, recipient_id) WHERE NOT msg_quota;
-
-DROP INDEX idx_messages_recipient_id_msg_ts;
-
-DROP INDEX idx_msg_queues_expire;
-
-DROP PROCEDURE expire_old_messages(bigint, integer);
-
-CREATE PROCEDURE expire_old_messages(IN p_old_ts bigint, IN batch_size integer, OUT r_expired_msgs_count bigint, OUT r_stored_msgs_count bigint, OUT r_stored_queues bigint)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  rids BYTEA[];
-  rid BYTEA;
-  last_ts BIGINT := -1;
-  last_rid BYTEA := '\x';
-  next_ts BIGINT;
-  next_rid BYTEA;
-  del_count BIGINT;
-  total_deleted BIGINT := 0;
-BEGIN
-  LOOP
-    -- The page is scanned in (msg_ts, recipient_id) order, so its last row is the next
-    -- keyset cursor. Advancing it past every row read, including queues left unexpired
-    -- because delete_expired_msgs skipped a locked row or raised, is what terminates the
-    -- loop; re-reading from the start instead would repeat those queues forever.
-    SELECT array_agg(DISTINCT recipient_id),
-           (array_agg(msg_ts ORDER BY msg_ts DESC, recipient_id DESC))[1],
-           (array_agg(recipient_id ORDER BY msg_ts DESC, recipient_id DESC))[1]
-    INTO rids, next_ts, next_rid
-    FROM (
-      SELECT msg_ts, recipient_id
-      FROM messages
-      WHERE NOT msg_quota
-        AND msg_ts < p_old_ts
-        AND (msg_ts, recipient_id) > (last_ts, last_rid)
-      ORDER BY msg_ts ASC, recipient_id ASC
-      LIMIT batch_size
-    ) m;
-
-    EXIT WHEN rids IS NULL;
-
-    FOREACH rid IN ARRAY rids
-    LOOP
-      BEGIN
-        del_count := delete_expired_msgs(rid, p_old_ts);
-        total_deleted := total_deleted + del_count;
-      EXCEPTION WHEN OTHERS THEN
-        RAISE WARNING 'STORE, expire_old_messages, error expiring queue %: %', encode(rid, 'base64'), SQLERRM;
-        CONTINUE;
-      END;
-    END LOOP;
-    COMMIT;
-
-    last_ts := next_ts;
-    last_rid := next_rid;
-  END LOOP;
-
-  r_expired_msgs_count := total_deleted;
-  r_stored_msgs_count := (SELECT COUNT(1) FROM messages);
-  r_stored_queues := (SELECT COUNT(1) FROM msg_queues WHERE deleted_at IS NULL);
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION delete_expired_msgs(p_recipient_id bytea, p_old_ts bigint) RETURNS bigint
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  keep_min_id BIGINT;
-  del_count BIGINT;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE SKIP LOCKED;
-
-  IF NOT FOUND OR q_size = 0 THEN
-    RETURN 0;
-  END IF;
-
-  SELECT MIN(message_id) INTO keep_min_id
-  FROM messages WHERE recipient_id = p_recipient_id AND msg_ts >= p_old_ts AND msg_quota = FALSE;
-
-  IF keep_min_id IS NULL THEN
-    DELETE FROM messages WHERE recipient_id = p_recipient_id AND msg_quota = FALSE;
-  ELSE
-    DELETE FROM messages WHERE recipient_id = p_recipient_id AND message_id < keep_min_id AND msg_quota = FALSE;
-  END IF;
-
-  GET DIAGNOSTICS del_count = ROW_COUNT;
-  IF del_count > 0 THEN
-    UPDATE msg_queues
-    SET msg_can_write = msg_can_write OR msg_queue_size <= del_count,
-        msg_queue_size = GREATEST(msg_queue_size - del_count, 0)
-    WHERE recipient_id = p_recipient_id;
-  END IF;
-  RETURN del_count;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION write_message(p_recipient_id bytea, p_msg_id bytea, p_msg_ts bigint, p_msg_quota boolean, p_msg_ntf_flag boolean, p_msg_body bytea, p_quota integer) RETURNS TABLE(quota_written boolean, was_empty boolean)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_can_write BOOLEAN;
-  q_size BIGINT;
-BEGIN
-  SELECT msg_can_write, msg_queue_size INTO q_can_write, q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF q_can_write OR q_size = 0 THEN
-    quota_written := p_msg_quota OR q_size >= p_quota;
-    was_empty := q_size = 0;
-
-    INSERT INTO messages(recipient_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body)
-    VALUES (p_recipient_id, p_msg_id, p_msg_ts, quota_written, p_msg_ntf_flag AND NOT quota_written, CASE WHEN quota_written THEN '' :: BYTEA ELSE p_msg_body END);
-
-    UPDATE msg_queues
-    SET msg_can_write = NOT quota_written,
-        msg_queue_size = msg_queue_size + 1
-    WHERE recipient_id = p_recipient_id;
-
-    RETURN QUERY VALUES (quota_written, was_empty);
-  END IF;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION try_del_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  msg RECORD;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF NOT FOUND THEN
-    RETURN;
-  END IF;
-
-  SELECT message_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-  INTO msg
-  FROM messages
-  WHERE recipient_id = p_recipient_id
-  ORDER BY message_id ASC LIMIT 1;
-
-  IF NOT FOUND THEN
-    IF q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-    RETURN;
-  END IF;
-
-  IF msg.msg_id = p_msg_id THEN
-    DELETE FROM messages WHERE message_id = msg.message_id;
-    IF FOUND THEN
-      UPDATE msg_queues
-      SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
-          msg_queue_size = GREATEST(msg_queue_size - 1, 0)
-      WHERE recipient_id = p_recipient_id;
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-    END IF;
-  END IF;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION try_del_peek_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  msg RECORD;
-  msg_deleted BOOLEAN;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF NOT FOUND THEN
-    RETURN;
-  END IF;
-
-  SELECT message_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-  INTO msg
-  FROM messages
-  WHERE recipient_id = p_recipient_id
-  ORDER BY message_id ASC LIMIT 1;
-
-  IF NOT FOUND THEN
-    IF q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-    RETURN;
-  END IF;
-
-  IF msg.msg_id = p_msg_id THEN
-    DELETE FROM messages WHERE message_id = msg.message_id;
-
-    msg_deleted := FOUND;
-    IF msg_deleted THEN
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-    END IF;
-
-    SELECT msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-    INTO msg
-    FROM messages
-    WHERE recipient_id = p_recipient_id
-    ORDER BY message_id ASC LIMIT 1;
-
-    IF FOUND THEN
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-      IF msg_deleted THEN
-        UPDATE msg_queues
-        SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
-            msg_queue_size = GREATEST(msg_queue_size - 1, 0)
-        WHERE recipient_id = p_recipient_id;
-      END IF;
-    ELSIF msg_deleted OR q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-  ELSE
-    RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-  END IF;
-END;
-$$;
-
-ALTER TABLE msg_queues DROP COLUMN msg_queue_expire;
-    |]
-
-down_m20260918_expire_messages :: Text
-down_m20260918_expire_messages =
-  [r|
-ALTER TABLE msg_queues ADD COLUMN msg_queue_expire boolean NOT NULL DEFAULT FALSE;
-
-- ADD COLUMN already defaulted every row to FALSE, so the backfill only needs the rows
-- that become TRUE, which avoids rewriting the whole table. The flag is only read to pick
-- queues for delete_expired_msgs, and that returns 0 without deleting when msg_queue_size
-- is 0, so excluding empty queues here cannot change what expires.
-UPDATE msg_queues q
-SET msg_queue_expire = TRUE
-WHERE msg_queue_size > 0
-  AND EXISTS (SELECT 1 FROM messages m WHERE m.recipient_id = q.recipient_id AND NOT m.msg_quota);
-
-CREATE INDEX idx_msg_queues_expire ON msg_queues (recipient_id) WHERE deleted_at IS NULL AND msg_queue_expire;
-
-CREATE INDEX idx_messages_recipient_id_msg_ts ON messages (recipient_id, msg_ts);
-
-DROP INDEX idx_messages_expire;
-
-CREATE OR REPLACE FUNCTION delete_expired_msgs(p_recipient_id bytea, p_old_ts bigint) RETURNS bigint
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  keep_min_id BIGINT;
-  del_count BIGINT;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE SKIP LOCKED;
-
-  IF NOT FOUND OR q_size = 0 THEN
-    RETURN 0;
-  END IF;
-
-  SELECT MIN(message_id) INTO keep_min_id
-  FROM messages WHERE recipient_id = p_recipient_id AND msg_ts >= p_old_ts AND msg_quota = FALSE;
-
-  IF keep_min_id IS NULL THEN
-    DELETE FROM messages WHERE recipient_id = p_recipient_id AND msg_quota = FALSE;
-  ELSE
-    DELETE FROM messages WHERE recipient_id = p_recipient_id AND message_id < keep_min_id AND msg_quota = FALSE;
-  END IF;
-
-  GET DIAGNOSTICS del_count = ROW_COUNT;
-  IF del_count > 0 THEN
-    UPDATE msg_queues
-    SET msg_can_write = msg_can_write OR msg_queue_size <= del_count,
-        msg_queue_expire = msg_queue_size > del_count AND keep_min_id IS NOT NULL,
-        msg_queue_size = GREATEST(msg_queue_size - del_count, 0)
-    WHERE recipient_id = p_recipient_id;
-  END IF;
-  RETURN del_count;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION write_message(p_recipient_id bytea, p_msg_id bytea, p_msg_ts bigint, p_msg_quota boolean, p_msg_ntf_flag boolean, p_msg_body bytea, p_quota integer) RETURNS TABLE(quota_written boolean, was_empty boolean)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_can_write BOOLEAN;
-  q_size BIGINT;
-BEGIN
-  SELECT msg_can_write, msg_queue_size INTO q_can_write, q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF q_can_write OR q_size = 0 THEN
-    quota_written := p_msg_quota OR q_size >= p_quota;
-    was_empty := q_size = 0;
-
-    INSERT INTO messages(recipient_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body)
-    VALUES (p_recipient_id, p_msg_id, p_msg_ts, quota_written, p_msg_ntf_flag AND NOT quota_written, CASE WHEN quota_written THEN '' :: BYTEA ELSE p_msg_body END);
-
-    UPDATE msg_queues
-    SET msg_can_write = NOT quota_written,
-        msg_queue_expire = TRUE,
-        msg_queue_size = msg_queue_size + 1
-    WHERE recipient_id = p_recipient_id;
-
-    RETURN QUERY VALUES (quota_written, was_empty);
-  END IF;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION try_del_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  msg RECORD;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF NOT FOUND THEN
-    RETURN;
-  END IF;
-
-  SELECT message_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-  INTO msg
-  FROM messages
-  WHERE recipient_id = p_recipient_id
-  ORDER BY message_id ASC LIMIT 1;
-
-  IF NOT FOUND THEN
-    IF q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_expire = FALSE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-    RETURN;
-  END IF;
-
-  IF msg.msg_id = p_msg_id THEN
-    DELETE FROM messages WHERE message_id = msg.message_id;
-    IF FOUND THEN
-      UPDATE msg_queues
-      SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
-          msg_queue_expire = msg_queue_size > 1,
-          msg_queue_size = GREATEST(msg_queue_size - 1, 0)
-      WHERE recipient_id = p_recipient_id;
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-    END IF;
-  END IF;
-END;
-$$;
-
-CREATE OR REPLACE FUNCTION try_del_peek_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  q_size BIGINT;
-  msg RECORD;
-  msg_deleted BOOLEAN;
-BEGIN
-  SELECT msg_queue_size INTO q_size
-  FROM msg_queues
-  WHERE recipient_id = p_recipient_id AND deleted_at IS NULL
-  FOR UPDATE;
-
-  IF NOT FOUND THEN
-    RETURN;
-  END IF;
-
-  SELECT message_id, msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-  INTO msg
-  FROM messages
-  WHERE recipient_id = p_recipient_id
-  ORDER BY message_id ASC LIMIT 1;
-
-  IF NOT FOUND THEN
-    IF q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_expire = FALSE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-    RETURN;
-  END IF;
-
-  IF msg.msg_id = p_msg_id THEN
-    DELETE FROM messages WHERE message_id = msg.message_id;
-
-    msg_deleted := FOUND;
-    IF msg_deleted THEN
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-    END IF;
-
-    SELECT msg_id, msg_ts, msg_quota, msg_ntf_flag, msg_body
-    INTO msg
-    FROM messages
-    WHERE recipient_id = p_recipient_id
-    ORDER BY message_id ASC LIMIT 1;
-
-    IF FOUND THEN
-      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-      IF msg_deleted THEN
-        UPDATE msg_queues
-        SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
-            msg_queue_expire = msg_queue_size > 1,
-            msg_queue_size = GREATEST(msg_queue_size - 1, 0)
-        WHERE recipient_id = p_recipient_id;
-      END IF;
-    ELSIF msg_deleted OR q_size != 0 THEN
-      UPDATE msg_queues
-      SET msg_can_write = TRUE,
-          msg_queue_expire = FALSE,
-          msg_queue_size = 0
-      WHERE recipient_id = p_recipient_id;
-    END IF;
-  ELSE
-    RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
-  END IF;
-END;
-$$;
-
-DROP PROCEDURE expire_old_messages(bigint, integer);
-
-CREATE PROCEDURE expire_old_messages(IN p_old_ts bigint, IN batch_size integer, OUT r_expired_msgs_count bigint, OUT r_stored_msgs_count bigint, OUT r_stored_queues bigint)
-    LANGUAGE plpgsql
-    AS $$
-DECLARE
-  rids BYTEA[];
-  rid BYTEA;
-  last_rid BYTEA := '\x';
-  del_count BIGINT;
-  total_deleted BIGINT := 0;
-BEGIN
-  LOOP
-    SELECT array_agg(recipient_id)
-    INTO rids
-    FROM (
-      SELECT recipient_id
-      FROM msg_queues
-      WHERE deleted_at IS NULL
-        AND msg_queue_expire = TRUE
-        AND recipient_id > last_rid
-      ORDER BY recipient_id ASC
-      LIMIT batch_size
-    ) qs;
-
-    EXIT WHEN rids IS NULL OR cardinality(rids) = 0;
-
-    FOREACH rid IN ARRAY rids
-    LOOP
-      BEGIN
-        del_count := delete_expired_msgs(rid, p_old_ts);
-        total_deleted := total_deleted + del_count;
-      EXCEPTION WHEN OTHERS THEN
-        RAISE WARNING 'STORE, expire_old_messages, error expiring queue %: %', encode(rid, 'base64'), SQLERRM;
-        CONTINUE;
-      END;
-      COMMIT;
-    END LOOP;
-    last_rid := rids[cardinality(rids)];
-  END LOOP;
-
-  r_expired_msgs_count := total_deleted;
-  r_stored_msgs_count := (SELECT COUNT(1) FROM messages);
-  r_stored_queues := (SELECT COUNT(1) FROM msg_queues WHERE deleted_at IS NULL);
-END;
-$$;
-    |]
@@ -1,11 +1,5 @@
--
-- PostgreSQL database dump
--

-\restrict Syi742MOIhG1l4r03KD7ril66oifkCCIReFiBCdmZcoTgCvB2NGXpJdwNatyQue

-- Dumped from database version 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1)
-- Dumped by pg_dump version 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1)

 SET statement_timeout = 0;
 SET lock_timeout = 0;
@@ -18,16 +12,10 @@ SET xmloption = content;
 SET client_min_messages = warning;
 SET row_security = off;

--
-- Name: smp_server; Type: SCHEMA; Schema: -; Owner: -
--

 CREATE SCHEMA smp_server;


--
-- Name: delete_expired_msgs(bytea, bigint); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.delete_expired_msgs(p_recipient_id bytea, p_old_ts bigint) RETURNS bigint
    LANGUAGE plpgsql
@@ -59,6 +47,7 @@ BEGIN
  IF del_count > 0 THEN
    UPDATE msg_queues
    SET msg_can_write = msg_can_write OR msg_queue_size <= del_count,
+        msg_queue_expire = msg_queue_size > del_count AND keep_min_id IS NOT NULL,
        msg_queue_size = GREATEST(msg_queue_size - del_count, 0)
    WHERE recipient_id = p_recipient_id;
  END IF;
@@ -67,9 +56,6 @@ END;
 $$;


--
-- Name: expire_old_messages(bigint, integer); Type: PROCEDURE; Schema: smp_server; Owner: -
--

 CREATE PROCEDURE smp_server.expire_old_messages(IN p_old_ts bigint, IN batch_size integer, OUT r_expired_msgs_count bigint, OUT r_stored_msgs_count bigint, OUT r_stored_queues bigint)
    LANGUAGE plpgsql
@@ -77,33 +63,24 @@ CREATE PROCEDURE smp_server.expire_old_messages(IN p_old_ts bigint, IN batch_siz
 DECLARE
  rids BYTEA[];
  rid BYTEA;
-  last_ts BIGINT := -1;
  last_rid BYTEA := '\x';
-  next_ts BIGINT;
-  next_rid BYTEA;
  del_count BIGINT;
  total_deleted BIGINT := 0;
 BEGIN
  LOOP
-    -- The page is scanned in (msg_ts, recipient_id) order, so its last row is the next
-    -- keyset cursor. Advancing it past every row read, including queues left unexpired
-    -- because delete_expired_msgs skipped a locked row or raised, is what terminates the
-    -- loop; re-reading from the start instead would repeat those queues forever.
-    SELECT array_agg(DISTINCT recipient_id),
-           (array_agg(msg_ts ORDER BY msg_ts DESC, recipient_id DESC))[1],
-           (array_agg(recipient_id ORDER BY msg_ts DESC, recipient_id DESC))[1]
-    INTO rids, next_ts, next_rid
+    SELECT array_agg(recipient_id)
+    INTO rids
    FROM (
-      SELECT msg_ts, recipient_id
-      FROM messages
-      WHERE NOT msg_quota
-        AND msg_ts < p_old_ts
-        AND (msg_ts, recipient_id) > (last_ts, last_rid)
-      ORDER BY msg_ts ASC, recipient_id ASC
+      SELECT recipient_id
+      FROM msg_queues
+      WHERE deleted_at IS NULL
+        AND msg_queue_expire = TRUE
+        AND recipient_id > last_rid
+      ORDER BY recipient_id ASC
      LIMIT batch_size
-    ) m;
+    ) qs;

-    EXIT WHEN rids IS NULL;
+    EXIT WHEN rids IS NULL OR cardinality(rids) = 0;

    FOREACH rid IN ARRAY rids
    LOOP
@@ -114,11 +91,9 @@ BEGIN
        RAISE WARNING 'STORE, expire_old_messages, error expiring queue %: %', encode(rid, 'base64'), SQLERRM;
        CONTINUE;
      END;
+      COMMIT;
    END LOOP;
-    COMMIT;
-
-    last_ts := next_ts;
-    last_rid := next_rid;
+    last_rid := rids[cardinality(rids)];
  END LOOP;

  r_expired_msgs_count := total_deleted;
@@ -128,9 +103,6 @@ END;
 $$;


--
-- Name: on_queue_delete(); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.on_queue_delete() RETURNS trigger
    LANGUAGE plpgsql
@@ -149,9 +121,6 @@ END;
 $$;


--
-- Name: on_queue_insert(); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.on_queue_insert() RETURNS trigger
    LANGUAGE plpgsql
@@ -168,9 +137,6 @@ END;
 $$;


--
-- Name: on_queue_update(); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.on_queue_update() RETURNS trigger
    LANGUAGE plpgsql
@@ -202,9 +168,6 @@ END;
 $$;


--
-- Name: try_del_msg(bytea, bytea); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.try_del_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
    LANGUAGE plpgsql
@@ -232,6 +195,7 @@ BEGIN
    IF q_size != 0 THEN
      UPDATE msg_queues
      SET msg_can_write = TRUE,
+          msg_queue_expire = FALSE,
          msg_queue_size = 0
      WHERE recipient_id = p_recipient_id;
    END IF;
@@ -243,6 +207,7 @@ BEGIN
    IF FOUND THEN
      UPDATE msg_queues
      SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
+          msg_queue_expire = msg_queue_size > 1,
          msg_queue_size = GREATEST(msg_queue_size - 1, 0)
      WHERE recipient_id = p_recipient_id;
      RETURN QUERY VALUES (msg.msg_id, msg.msg_ts, msg.msg_quota, msg.msg_ntf_flag, msg.msg_body);
@@ -252,9 +217,6 @@ END;
 $$;


--
-- Name: try_del_peek_msg(bytea, bytea); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.try_del_peek_msg(p_recipient_id bytea, p_msg_id bytea) RETURNS TABLE(r_msg_id bytea, r_msg_ts bigint, r_msg_quota boolean, r_msg_ntf_flag boolean, r_msg_body bytea)
    LANGUAGE plpgsql
@@ -283,6 +245,7 @@ BEGIN
    IF q_size != 0 THEN
      UPDATE msg_queues
      SET msg_can_write = TRUE,
+          msg_queue_expire = FALSE,
          msg_queue_size = 0
      WHERE recipient_id = p_recipient_id;
    END IF;
@@ -308,12 +271,14 @@ BEGIN
      IF msg_deleted THEN
        UPDATE msg_queues
        SET msg_can_write = msg_can_write OR msg_queue_size <= 1,
+            msg_queue_expire = msg_queue_size > 1,
            msg_queue_size = GREATEST(msg_queue_size - 1, 0)
        WHERE recipient_id = p_recipient_id;
      END IF;
    ELSIF msg_deleted OR q_size != 0 THEN
      UPDATE msg_queues
      SET msg_can_write = TRUE,
+          msg_queue_expire = FALSE,
          msg_queue_size = 0
      WHERE recipient_id = p_recipient_id;
    END IF;
@@ -324,9 +289,6 @@ END;
 $$;


--
-- Name: update_aggregates(bytea, text, bytea, bigint); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.update_aggregates(p_service_id bytea, p_role text, p_queue_id bytea, p_change bigint) RETURNS void
    LANGUAGE plpgsql
@@ -340,9 +302,6 @@ END;
 $$;


--
-- Name: update_all_aggregates(); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.update_all_aggregates() RETURNS void
    LANGUAGE plpgsql
@@ -367,9 +326,6 @@ END;
 $$;


--
-- Name: write_message(bytea, bytea, bigint, boolean, boolean, bytea, integer); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.write_message(p_recipient_id bytea, p_msg_id bytea, p_msg_ts bigint, p_msg_quota boolean, p_msg_ntf_flag boolean, p_msg_body bytea, p_quota integer) RETURNS TABLE(quota_written boolean, was_empty boolean)
    LANGUAGE plpgsql
@@ -392,6 +348,7 @@ BEGIN

    UPDATE msg_queues
    SET msg_can_write = NOT quota_written,
+        msg_queue_expire = TRUE,
        msg_queue_size = msg_queue_size + 1
    WHERE recipient_id = p_recipient_id;

@@ -401,9 +358,6 @@ END;
 $$;


--
-- Name: xor_combine(bytea, bytea); Type: FUNCTION; Schema: smp_server; Owner: -
--

 CREATE FUNCTION smp_server.xor_combine(state bytea, value bytea) RETURNS bytea
    LANGUAGE plpgsql IMMUTABLE STRICT
@@ -424,9 +378,6 @@ END;
 $$;


--
-- Name: xor_aggregate(bytea); Type: AGGREGATE; Schema: smp_server; Owner: -
--

 CREATE AGGREGATE smp_server.xor_aggregate(bytea) (
    SFUNC = smp_server.xor_combine,
@@ -437,9 +388,6 @@ CREATE AGGREGATE smp_server.xor_aggregate(bytea) (

 SET default_table_access_method = heap;

--
-- Name: messages; Type: TABLE; Schema: smp_server; Owner: -
--

 CREATE TABLE smp_server.messages (
    message_id bigint NOT NULL,
@@ -453,9 +401,6 @@ CREATE TABLE smp_server.messages (
 WITH (autovacuum_vacuum_scale_factor='0.02', autovacuum_analyze_scale_factor='0.01', toast.autovacuum_vacuum_scale_factor='0.02');


--
-- Name: messages_message_id_seq; Type: SEQUENCE; Schema: smp_server; Owner: -
--

 ALTER TABLE smp_server.messages ALTER COLUMN message_id ADD GENERATED ALWAYS AS IDENTITY (
    SEQUENCE NAME smp_server.messages_message_id_seq
@@ -467,9 +412,6 @@ ALTER TABLE smp_server.messages ALTER COLUMN message_id ADD GENERATED ALWAYS AS
 );


--
-- Name: migrations; Type: TABLE; Schema: smp_server; Owner: -
--

 CREATE TABLE smp_server.migrations (
    name text NOT NULL,
@@ -478,9 +420,6 @@ CREATE TABLE smp_server.migrations (
 );


--
-- Name: msg_queues; Type: TABLE; Schema: smp_server; Owner: -
--

 CREATE TABLE smp_server.msg_queues (
    recipient_id bytea NOT NULL,
@@ -501,14 +440,12 @@ CREATE TABLE smp_server.msg_queues (
    rcv_service_id bytea,
    ntf_service_id bytea,
    msg_can_write boolean DEFAULT true NOT NULL,
+    msg_queue_expire boolean DEFAULT false NOT NULL,
    msg_queue_size bigint DEFAULT 0 NOT NULL
 )
 WITH (fillfactor='80', autovacuum_vacuum_scale_factor='0.02', autovacuum_analyze_scale_factor='0.01', autovacuum_vacuum_cost_limit='1000');


--
-- Name: services; Type: TABLE; Schema: smp_server; Owner: -
--

 CREATE TABLE smp_server.services (
    service_id bytea NOT NULL,
@@ -522,164 +459,101 @@ CREATE TABLE smp_server.services (
 WITH (fillfactor='70', autovacuum_vacuum_threshold='1000', autovacuum_vacuum_scale_factor='0');


--
-- Name: messages messages_pkey; Type: CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.messages
    ADD CONSTRAINT messages_pkey PRIMARY KEY (message_id);


--
-- Name: migrations migrations_pkey; Type: CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.migrations
    ADD CONSTRAINT migrations_pkey PRIMARY KEY (name);


--
-- Name: msg_queues msg_queues_pkey; Type: CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.msg_queues
    ADD CONSTRAINT msg_queues_pkey PRIMARY KEY (recipient_id);


--
-- Name: services services_pkey; Type: CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.services
    ADD CONSTRAINT services_pkey PRIMARY KEY (service_id);


--
-- Name: services services_service_cert_hash_key; Type: CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.services
    ADD CONSTRAINT services_service_cert_hash_key UNIQUE (service_cert_hash);


--
-- Name: idx_messages_expire; Type: INDEX; Schema: smp_server; Owner: -
--
-
-CREATE INDEX idx_messages_expire ON smp_server.messages USING btree (msg_ts, recipient_id) WHERE (NOT msg_quota);
-
-
--
-- Name: idx_messages_recipient_id_message_id; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_messages_recipient_id_message_id ON smp_server.messages USING btree (recipient_id, message_id);


--
-- Name: idx_messages_recipient_id_msg_quota; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_messages_recipient_id_msg_quota ON smp_server.messages USING btree (recipient_id, msg_quota);


--
-- Name: idx_msg_queues_link_id; Type: INDEX; Schema: smp_server; Owner: -
--
+
+CREATE INDEX idx_messages_recipient_id_msg_ts ON smp_server.messages USING btree (recipient_id, msg_ts);
+
+
+
+CREATE INDEX idx_msg_queues_expire ON smp_server.msg_queues USING btree (recipient_id) WHERE ((deleted_at IS NULL) AND msg_queue_expire);
+
+

 CREATE UNIQUE INDEX idx_msg_queues_link_id ON smp_server.msg_queues USING btree (link_id);


--
-- Name: idx_msg_queues_notifier_active; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_msg_queues_notifier_active ON smp_server.msg_queues USING btree (notifier_id) WHERE ((deleted_at IS NULL) AND (notifier_id IS NOT NULL));


--
-- Name: idx_msg_queues_notifier_id; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE UNIQUE INDEX idx_msg_queues_notifier_id ON smp_server.msg_queues USING btree (notifier_id);


--
-- Name: idx_msg_queues_ntf_service_id; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_msg_queues_ntf_service_id ON smp_server.msg_queues USING btree (ntf_service_id, deleted_at);


--
-- Name: idx_msg_queues_rcv_service_id; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_msg_queues_rcv_service_id ON smp_server.msg_queues USING btree (rcv_service_id, deleted_at);


--
-- Name: idx_msg_queues_sender_id; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE UNIQUE INDEX idx_msg_queues_sender_id ON smp_server.msg_queues USING btree (sender_id);


--
-- Name: idx_services_service_role; Type: INDEX; Schema: smp_server; Owner: -
--

 CREATE INDEX idx_services_service_role ON smp_server.services USING btree (service_role);


--
-- Name: msg_queues tr_queue_delete; Type: TRIGGER; Schema: smp_server; Owner: -
--

 CREATE TRIGGER tr_queue_delete AFTER DELETE ON smp_server.msg_queues FOR EACH ROW EXECUTE FUNCTION smp_server.on_queue_delete();


--
-- Name: msg_queues tr_queue_insert; Type: TRIGGER; Schema: smp_server; Owner: -
--

 CREATE TRIGGER tr_queue_insert AFTER INSERT ON smp_server.msg_queues FOR EACH ROW EXECUTE FUNCTION smp_server.on_queue_insert();


--
-- Name: msg_queues tr_queue_update; Type: TRIGGER; Schema: smp_server; Owner: -
--

 CREATE TRIGGER tr_queue_update AFTER UPDATE ON smp_server.msg_queues FOR EACH ROW EXECUTE FUNCTION smp_server.on_queue_update();


--
-- Name: messages messages_recipient_id_fkey; Type: FK CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.messages
    ADD CONSTRAINT messages_recipient_id_fkey FOREIGN KEY (recipient_id) REFERENCES smp_server.msg_queues(recipient_id) ON UPDATE RESTRICT ON DELETE CASCADE;


--
-- Name: msg_queues msg_queues_ntf_service_id_fkey; Type: FK CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.msg_queues
    ADD CONSTRAINT msg_queues_ntf_service_id_fkey FOREIGN KEY (ntf_service_id) REFERENCES smp_server.services(service_id) ON UPDATE RESTRICT ON DELETE SET NULL;


--
-- Name: msg_queues msg_queues_rcv_service_id_fkey; Type: FK CONSTRAINT; Schema: smp_server; Owner: -
--

 ALTER TABLE ONLY smp_server.msg_queues
    ADD CONSTRAINT msg_queues_rcv_service_id_fkey FOREIGN KEY (rcv_service_id) REFERENCES smp_server.services(service_id) ON UPDATE RESTRICT ON DELETE SET NULL;


--
-- PostgreSQL database dump complete
--

-\unrestrict Syi742MOIhG1l4r03KD7ril66oifkCCIReFiBCdmZcoTgCvB2NGXpJdwNatyQue

@@ -173,7 +173,6 @@ instance StoreQueueClass q => QueueStoreClass q (STMQueueStore q) where
      rId = recipientId sq
      qr = queueRec sq
      add q = case queueData q of
-        _ | isSecuredMsgQueue q -> pure $ Left AUTH
        Nothing -> addLink
        Just (lnkId', d') | lnkId' == lnkId && fst d' == fst d -> addLink
        _ -> pure $ Left AUTH
@@ -128,7 +128,6 @@ data ServerStats = ServerStats
    ntfServices :: ServiceStats,
    rcvServicesSubMsg :: IORef Int,
    rcvServicesSubDuplicate :: IORef Int,
-    authDelayExceeded :: IORef Int,
    qCount :: IORef Int,
    msgCount :: IORef Int,
    ntfCount :: IORef Int,
@@ -191,7 +190,6 @@ data ServerStatsData = ServerStatsData
    _rcvServices :: ServiceStatsData,
    _rcvServicesSubMsg :: Int,
    _rcvServicesSubDuplicate :: Int,
-    _authDelayExceeded :: Int,
    _qCount :: Int,
    _msgCount :: Int,
    _ntfCount :: Int,
@@ -256,7 +254,6 @@ newServerStats ts = do
  ntfServices <- newServiceStats
  rcvServicesSubMsg <- newIORef 0
  rcvServicesSubDuplicate <- newIORef 0
-  authDelayExceeded <- newIORef 0
  qCount <- newIORef 0
  msgCount <- newIORef 0
  ntfCount <- newIORef 0
@@ -318,7 +315,6 @@ newServerStats ts = do
        ntfServices,
        rcvServicesSubMsg,
        rcvServicesSubDuplicate,
-        authDelayExceeded,
        qCount,
        msgCount,
        ntfCount,
@@ -382,7 +378,6 @@ getServerStatsData s = do
  _ntfServices <- getServiceStatsData $ ntfServices s
  _rcvServicesSubMsg <- readIORef $ rcvServicesSubMsg s
  _rcvServicesSubDuplicate <- readIORef $ rcvServicesSubDuplicate s
-  _authDelayExceeded <- readIORef $ authDelayExceeded s
  _qCount <- readIORef $ qCount s
  _msgCount <- readIORef $ msgCount s
  _ntfCount <- readIORef $ ntfCount s
@@ -444,7 +439,6 @@ getServerStatsData s = do
        _ntfServices,
        _rcvServicesSubMsg,
        _rcvServicesSubDuplicate,
-        _authDelayExceeded,
        _qCount,
        _msgCount,
        _ntfCount,
@@ -509,7 +503,6 @@ setServerStats s d = do
  setServiceStats (ntfServices s) $! _ntfServices d
  writeIORef (rcvServicesSubMsg s) $! _rcvServicesSubMsg d
  writeIORef (rcvServicesSubDuplicate s) $! _rcvServicesSubDuplicate d
-  writeIORef (authDelayExceeded s) $! _authDelayExceeded d
  writeIORef (qCount s) $! _qCount d
  writeIORef (msgCount s) $! _msgCount d
  writeIORef (ntfCount s) $! _ntfCount d
@@ -712,7 +705,6 @@ instance StrEncoding ServerStatsData where
          _ntfServices,
          _rcvServicesSubMsg = 0,
          _rcvServicesSubDuplicate = 0,
-          _authDelayExceeded = 0,
          _qCount,
          _msgCount = 0,
          _ntfCount = 0,
@@ -46,6 +46,7 @@ module Simplex.Messaging.Transport
    minServerSMPRelayVersion,
    currentClientSMPRelayVersion,
    currentServerSMPRelayVersion,
+    shortLinksSMPVersion,
    serviceCertsSMPVersion,
    newNtfCredsSMPVersion,
    clientNoticesSMPVersion,
@@ -53,7 +54,6 @@ module Simplex.Messaging.Transport
    namesSMPVersion,
    serverInfoSMPVersion,
    nameAvailSMPVersion,
-    fwdNoncesSMPVersion,
    simplexMQVersion,
    smpBlockSize,
    TransportConfig (..),
@@ -177,7 +177,6 @@ smpBlockSize = 16384
 -- 20 - public namespaces resolver, RSLV command (6/20/2026)
 -- 21 - server public information in handshake (7/5/2026)
 -- 22 - RNAME answers name availability as well as the record (7/25/2026)
-- 23 - version in forwarded command nonce, random nonce in forwarded responses (10/2/2026)

 data SMPVersion

@@ -190,8 +189,11 @@ type VersionRangeSMP = VersionRange SMPVersion
 pattern VersionSMP :: Word16 -> VersionSMP
 pattern VersionSMP v = Version v

-_shortLinksSMPVersion :: VersionSMP
-_shortLinksSMPVersion = VersionSMP 15
+_proxyServerHandshakeSMPVersion :: VersionSMP
+_proxyServerHandshakeSMPVersion = VersionSMP 14
+
+shortLinksSMPVersion :: VersionSMP
+shortLinksSMPVersion = VersionSMP 15

 serviceCertsSMPVersion :: VersionSMP
 serviceCertsSMPVersion = VersionSMP 16
@@ -216,32 +218,29 @@ serverInfoSMPVersion = VersionSMP 21
 nameAvailSMPVersion :: VersionSMP
 nameAvailSMPVersion = VersionSMP 22

-fwdNoncesSMPVersion :: VersionSMP
-fwdNoncesSMPVersion = VersionSMP 23
-
 minClientSMPRelayVersion :: VersionSMP
-minClientSMPRelayVersion = VersionSMP 15
+minClientSMPRelayVersion = VersionSMP 14

 minServerSMPRelayVersion :: VersionSMP
-minServerSMPRelayVersion = VersionSMP 15
+minServerSMPRelayVersion = VersionSMP 14

 currentClientSMPRelayVersion :: VersionSMP
-currentClientSMPRelayVersion = VersionSMP 23
+currentClientSMPRelayVersion = VersionSMP 22

 currentServerSMPRelayVersion :: VersionSMP
-currentServerSMPRelayVersion = VersionSMP 23
+currentServerSMPRelayVersion = VersionSMP 22

 -- Max SMP protocol version to be used in e2e encrypted connection between
 -- client and server, as defined by SMP proxy. Normally set below the current
 -- version to prevent client version fingerprinting by the destination relays
-- when clients upgrade at different times. Pinned to the current version (23)
-- for this release because forwarded commands use the nonces from
-- fwdNoncesSMPVersion (23), so the one-version anti-fingerprinting buffer does
-- not apply yet; it reappears once the current version advances past 23.
+-- when clients upgrade at different times. Pinned to the current version (22)
+-- for this release because a proxied RSLV only carries availability from
+-- nameAvailSMPVersion (22), so the one-version anti-fingerprinting buffer does
+-- not apply yet; it reappears once the current version advances past 22.
 proxiedSMPRelayVersion :: VersionSMP
-proxiedSMPRelayVersion = VersionSMP 23
+proxiedSMPRelayVersion = VersionSMP 22

-- minimal supported protocol version is 15
+-- minimal supported protocol version is 14
 supportedClientSMPRelayVRange :: VersionRangeSMP
 supportedClientSMPRelayVRange = mkVersionRange minClientSMPRelayVersion currentClientSMPRelayVersion

@@ -26,7 +26,6 @@ module Simplex.RemoteControl.Client
    -- for tests only
    sendRCPacket,
    receiveRCPacket,
-    findRCCtrlPairing,
  ) where

 import Control.Applicative ((<|>))
@@ -47,7 +46,7 @@ import Data.List.NonEmpty (NonEmpty (..))
 import qualified Data.List.NonEmpty as L
 import Data.Maybe (isNothing)
 import qualified Data.Text as T
-import Data.Time.Clock.System (SystemTime (..), getSystemTime)
+import Data.Time.Clock.System (getSystemTime)
 import Data.Tuple (swap)
 import Data.Word (Word16)
 import qualified Data.X509 as X
@@ -396,10 +395,8 @@ findRCCtrlPairing :: NonEmpty RCCtrlPairing -> RCEncInvitation -> ExceptT RCErro
 findRCCtrlPairing pairings RCEncInvitation {dhPubKey, nonce, encInvitation} = do
  (pairing, signedInvStr) <- liftEither $ decrypt (L.toList pairings)
  signedInv <- liftEitherWith RCESyntax $ strDecode signedInvStr
-  inv@(RCVerifiedInvitation RCInvitation {dh = invDh, ts}) <- maybe (throwE RCEInvitation) pure $ verifySignedInvitation signedInv
+  inv@(RCVerifiedInvitation RCInvitation {dh = invDh}) <- maybe (throwE RCEInvitation) pure $ verifySignedInvitation signedInv
  unless (invDh == dhPubKey) $ throwE RCEInvitation
-  now <- systemSeconds <$> liftIO getSystemTime
-  unless (now - 3660 <= systemSeconds ts && systemSeconds ts <= now + 3600) $ throwE RCEInvitation
  pure (pairing, inv)
  where
    decrypt :: [RCCtrlPairing] -> Either RCErrorType (RCCtrlPairing, ByteString)
@@ -122,22 +122,18 @@ closeListener subscribers sock =
 joinMulticast :: TMVar Int -> N.Socket -> N.HostAddress -> IO ()
 joinMulticast subscribers sock group = do
  now <- atomically $ takeTMVar subscribers
-  if now == 0
-    then
-      setMembership sock group True >>= \case
-        Left e -> atomically (putTMVar subscribers now) >> logError ("setMembership failed " <> tshow e)
-        Right () -> atomically $ putTMVar subscribers (now + 1)
-    else atomically $ putTMVar subscribers (now + 1)
+  when (now == 0) $ do
+    setMembership sock group True >>= \case
+      Left e -> atomically (putTMVar subscribers now) >> logError ("setMembership failed " <> tshow e)
+      Right () -> atomically $ putTMVar subscribers (now + 1)

 partMulticast :: TMVar Int -> N.Socket -> N.HostAddress -> IO ()
 partMulticast subscribers sock group = do
  now <- atomically $ takeTMVar subscribers
-  if now == 1
-    then
-      setMembership sock group False >>= \case
-        Left e -> atomically (putTMVar subscribers (now - 1)) >> logError ("setMembership failed " <> tshow e)
-        Right () -> atomically $ putTMVar subscribers (now - 1)
-    else atomically $ putTMVar subscribers (max 0 (now - 1))
+  when (now == 1) $
+    setMembership sock group False >>= \case
+      Left e -> atomically (putTMVar subscribers now) >> logError ("setMembership failed " <> tshow e)
+      Right () -> atomically $ putTMVar subscribers (now - 1)

 listenerHostAddr4 :: UDP.ListenSocket -> N.HostAddress
 listenerHostAddr4 sock = case UDP.mySockAddr sock of
@@ -19,12 +19,17 @@ import Simplex.Messaging.Server.Env.STM (AStoreType (..))
 import Simplex.Messaging.Transport (ASrvTransport)
 import Test.Hspec hiding (fit, it)

-#if !defined(dbPostgres)
+#if defined(dbPostgres)
+import Fixtures
+import Simplex.Messaging.Agent.Store.Postgres.Util (dropAllSchemasExceptSystem)
+#else
 import AgentTests.SQLiteTests (storeTests)
 #endif

 #if defined(dbServerPostgres)
 import AgentTests.NotificationTests (notificationTests)
+import SMPClient (postgressBracket)
+import NtfClient (ntfTestServerDBConnectInfo)
 #endif

 agentCoreTests :: Spec
@@ -37,10 +42,16 @@ agentCoreTests = do

 agentTests :: (ASrvTransport, AStoreType) -> Spec
 agentTests ps = do
-  describe "Functional API" $ functionalAPITests ps
-  describe "Chosen servers" serverChoiceTests
+#if defined(dbPostgres)
+  after_ (dropAllSchemasExceptSystem testDBConnectInfo) $ do
+#else
+  do
+#endif
+    describe "Functional API" $ functionalAPITests ps
+    describe "Chosen servers" serverChoiceTests
 #if defined(dbServerPostgres)
-  describe "Notification tests" $ notificationTests ps
+    around_ (postgressBracket ntfTestServerDBConnectInfo) $
+      describe "Notification tests" $ notificationTests ps
 #endif
 #if !defined(dbPostgres)
  describe "SQLite store" storeTests
@@ -20,8 +20,6 @@ module AgentTests.ConnectionRequestTests

 import AgentTests.EqInstances ()
 import Data.ByteString (ByteString)
-import qualified Data.ByteString.Char8 as B
-import Data.Either (isLeft)
 import Network.HTTP.Types (urlEncode)
 import Simplex.Messaging.Agent.Protocol
 import qualified Simplex.Messaging.Crypto as C
@@ -287,9 +285,6 @@ connectionRequestTests =
      contactAddressV6 #== ("https://simplex.chat/contact#/?v=1-2&smp=" <> url queueStr) -- adjusted to v6
      contactAddressV6 #== ("https://simplex.chat/contact#/?v=2-2&smp=" <> url queueStr)
      contactAddressClientData #==# ("simplex:/contact#/?v=6-8&smp=" <> url queueStr <> "&data=" <> url "{\"type\":\"group_link\", \"group_link_id\":\"abc\"}")
-    it "should reject KEM ciphertext without KEM key in e2e params" $
-      strDecode @(RcvE2ERatchetParamsUri 'C.X448) (strEncode testE2ERatchetParams <> "&kem_ct=" <> strEncode (B.replicate 1039 '\0'))
-        `shouldSatisfy` isLeft
    it "should serialize / parse queue address, connection invitations and contact addresses as binary" $ do
      smpEncodingTest queue
      smpEncodingTest queueNoQM -- this passes, no queue mode patch in SMPQueueUri encoding
@@ -362,10 +357,6 @@ connectionRequestTests =
      smpEncodingTest $ AgentServiceRequest [qInfo] Nothing "service request payload"
      smpEncodingTest $ AgentServiceResponse "service response payload"
      smpEncodingTest $ AgentRejection "rejected: not allowed"
-    it "should serialize and parse ratchet key info" $ do
-      smpDecode "R" `shouldBe` Right (AgentRatchetInfo RatchetInfo {answeredKeyHash = Nothing})
-      smpDecode "R1\3abcdef" `shouldBe` Right (AgentRatchetInfo RatchetInfo {answeredKeyHash = Just "abc"})
-      smpEncodingTest $ AgentRatchetInfo RatchetInfo {answeredKeyHash = Just "0123456789abcdef0123456789abcdef"}
  where
    smpEncodingTest :: (Encoding a, Eq a, Show a, HasCallStack) => a -> Expectation
    smpEncodingTest a = smpDecode (smpEncode a) `shouldBe` Right a
@@ -8,7 +8,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}
 {-# LANGUAGE TypeApplications #-}
@@ -139,8 +138,7 @@ notificationTests ps@(t, _) = do
        testNtfTokenReRegisterInvalidOnCheck t apns
  describe "notification server tests" $ do
    it "should pass" $ testRunNTFServerTests t testNtfServer `shouldReturn` Right Nothing
-    let srv1 :: HasTestEnv => NtfServer
-        srv1 = testNtfServer {keyHash = "1234"}
+    let srv1 = testNtfServer {keyHash = "1234"}
    it "should fail with incorrect fingerprint" $ do
      testRunNTFServerTests t srv1 `shouldReturn` Left (ProtocolTestFailure TSConnect $ BROKER (B.unpack $ strEncode srv1) $ NETWORK NEUnknownCAError)
  describe "Managing notification subscriptions" $ do
@@ -188,7 +186,7 @@ notificationTests ps@(t, _) = do
          testNotificationsNewToken apns ntf
  it "should migrate to service subscriptions" $ testMigrateToServiceSubscriptions ps

-testNtfMatrix :: HasCallStack => (ASrvTransport, AStoreType) -> (HasTestEnv => APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()) -> Spec
+testNtfMatrix :: HasCallStack => (ASrvTransport, AStoreType) -> (APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()) -> Spec
 testNtfMatrix ps@(_, msType) runTest = do
  describe "next and current" $ do
    it "curr servers; curr clients" $ runNtfTestCfg ps 1 cfg' ntfServerCfg agentCfg agentCfg runTest
@@ -202,7 +200,6 @@ testNtfMatrix ps@(_, msType) runTest = do
    it "servers: curr SMP, curr NTF; clients: curr/prev" $ runNtfTestCfg ps 1 cfg' ntfServerCfg agentCfg agentCfgVPrevPQ runTest
    it "servers: curr SMP, curr NTF; clients: prev/curr" $ runNtfTestCfg ps 1 cfg' ntfServerCfg agentCfgVPrevPQ agentCfg runTest
  where
-    cfg', cfgVPrev' :: HasTestEnv => AServerConfig
    cfg' = cfgMS msType
    cfgVPrev' = cfgVPrev msType

@@ -215,7 +212,7 @@ checkNtfToken c = A.checkNtfToken c NRMInteractive
 verifyNtfToken :: AgentClient -> DeviceToken -> C.CbNonce -> ByteString -> AE ()
 verifyNtfToken c = A.verifyNtfToken c NRMInteractive

-runNtfTestCfg :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> AgentMsgId -> AServerConfig -> NtfServerConfig -> AgentConfig -> AgentConfig -> (APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()) -> IO ()
+runNtfTestCfg :: HasCallStack => (ASrvTransport, AStoreType) -> AgentMsgId -> AServerConfig -> NtfServerConfig -> AgentConfig -> AgentConfig -> (APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()) -> IO ()
 runNtfTestCfg (t, msType) baseId smpCfg ntfCfg aCfg bCfg runTest = do
  ASSCfg qt mt serverStoreCfg <- pure $ testServerStoreConfig msType
  let smpCfg' = withServerCfg smpCfg $ \cfg_ -> ASrvCfg qt mt cfg_ {serverStoreCfg}
@@ -225,7 +222,7 @@ runNtfTestCfg (t, msType) baseId smpCfg ntfCfg aCfg bCfg runTest = do
        withAgentClientsCfg2 aCfg bCfg $ runTest apns baseId
  threadDelay 100000

-testNotificationToken :: HasTestEnv => APNSMockServer -> IO ()
+testNotificationToken :: APNSMockServer -> IO ()
 testNotificationToken apns = do
  withAgent 1 agentCfg initAgentServers testDB $ \a -> runRight_ $ do
    let tkn = DeviceToken PPApnsTest "abcd"
@@ -233,7 +230,7 @@ testNotificationToken apns = do
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
      getMockNotification apns tkn
    verification <- ntfData .-> "verification"
-    nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+    nonce <- C.cbNonce <$> ntfData .-> "nonce"
    verifyNtfToken a tkn nonce verification
    NTActive <- checkNtfToken a tkn
    deleteNtfToken a tkn
@@ -249,7 +246,7 @@ v .-> key = do
 -- logCfg :: LogConfig
 -- logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}

-testNtfTokenRepeatRegistration :: HasTestEnv => APNSMockServer -> IO ()
+testNtfTokenRepeatRegistration :: APNSMockServer -> IO ()
 testNtfTokenRepeatRegistration apns = do
  withAgent 1 agentCfg initAgentServers testDB $ \a -> runRight_ $ do
    let tkn = DeviceToken PPApnsTest "abcd"
@@ -257,7 +254,7 @@ testNtfTokenRepeatRegistration apns = do
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
      getMockNotification apns tkn
    verification <- ntfData .-> "verification"
-    nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+    nonce <- C.cbNonce <$> ntfData .-> "nonce"
    NTRegistered <- registerNtfToken a tkn NMPeriodic
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData'}} <-
      getMockNotification apns tkn
@@ -268,7 +265,7 @@ testNtfTokenRepeatRegistration apns = do
    NTActive <- checkNtfToken a tkn
    pure ()

-testNtfTokenSecondRegistration :: HasTestEnv => APNSMockServer -> IO ()
+testNtfTokenSecondRegistration :: APNSMockServer -> IO ()
 testNtfTokenSecondRegistration apns =
  withAgentClients2 $ \a a' -> runRight_ $ do
    let tkn = DeviceToken PPApnsTest "abcd"
@@ -276,14 +273,14 @@ testNtfTokenSecondRegistration apns =
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
      getMockNotification apns tkn
    verification <- ntfData .-> "verification"
-    nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+    nonce <- C.cbNonce <$> ntfData .-> "nonce"
    verifyNtfToken a tkn nonce verification

    NTRegistered <- registerNtfToken a' tkn NMPeriodic
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData'}} <-
      getMockNotification apns tkn
    verification' <- ntfData' .-> "verification"
-    nonce' <- C.unsafeCbNonce <$> ntfData' .-> "nonce"
+    nonce' <- C.cbNonce <$> ntfData' .-> "nonce"

    -- at this point the first token is still active
    NTActive <- checkNtfToken a tkn
@@ -298,7 +295,7 @@ testNtfTokenSecondRegistration apns =
    NTActive <- checkNtfToken a' tkn
    pure ()

-testNtfTokenServerRestart :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenServerRestart :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenServerRestart t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  ntfData <- withAgent 1 agentCfg initAgentServers testDB $ \a ->
@@ -314,12 +311,12 @@ testNtfTokenServerRestart t apns = do
    -- so that repeat verification happens without restarting the clients, when notification arrives
    withNtfServer t $ runRight_ $ do
      verification <- ntfData .-> "verification"
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
      verifyNtfToken a' tkn nonce verification
      NTActive <- checkNtfToken a' tkn
      pure ()

-testNtfTokenServerRestartReverify :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenServerRestartReverify :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenServerRestartReverify t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  withAgent 1 agentCfg initAgentServers testDB $ \a -> do
@@ -330,10 +327,8 @@ testNtfTokenServerRestartReverify t apns = do
      pure ntfData
    runRight_ $ do
      verification <- ntfData .-> "verification"
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
-      r <- tryE $ verifyNtfToken a tkn nonce verification
-      liftIO $ putStrLn $ "DEBUG reverify result: " <> show r
-      Left (BROKER _ (NETWORK _)) <- pure r
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
+      Left (BROKER _ (NETWORK _)) <- tryE $ verifyNtfToken a tkn nonce verification
      pure ()
  threadDelay 1500000
  withAgent 2 agentCfg initAgentServers testDB $ \a' ->
@@ -344,7 +339,7 @@ testNtfTokenServerRestartReverify t apns = do
      NTActive <- checkNtfToken a' tkn
      pure ()

-testNtfTokenServerRestartReverifyTimeout :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenServerRestartReverifyTimeout :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenServerRestartReverifyTimeout t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  withAgent 1 agentCfg initAgentServers testDB $ \a@AgentClient {agentEnv = Env {store}} -> do
@@ -353,7 +348,7 @@ testNtfTokenServerRestartReverifyTimeout t apns = do
      APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
        getMockNotification apns tkn
      verification <- ntfData .-> "verification"
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
      verifyNtfToken a tkn nonce verification
      pure (nonce, verification)
    -- this emulates the situation when server verified token but the client did not receive the response
@@ -379,7 +374,7 @@ testNtfTokenServerRestartReverifyTimeout t apns = do
      NTActive <- checkNtfToken a' tkn
      pure ()

-testNtfTokenServerRestartReregister :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenServerRestartReregister :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenServerRestartReregister t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  withAgent 1 agentCfg initAgentServers testDB $ \a ->
@@ -398,12 +393,12 @@ testNtfTokenServerRestartReregister t apns = do
      APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
        getMockNotification apns tkn
      verification <- ntfData .-> "verification"
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
      verifyNtfToken a' tkn nonce verification
      NTActive <- checkNtfToken a' tkn
      pure ()

-testNtfTokenServerRestartReregisterTimeout :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenServerRestartReregisterTimeout :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenServerRestartReregisterTimeout t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  withAgent 1 agentCfg initAgentServers testDB $ \a@AgentClient {agentEnv = Env {store}} -> do
@@ -433,7 +428,7 @@ testNtfTokenServerRestartReregisterTimeout t apns = do
      APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
        getMockNotification apns tkn
      verification <- ntfData .-> "verification"
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
      verifyNtfToken a' tkn nonce verification
      NTActive <- checkNtfToken a' tkn
      pure ()
@@ -444,7 +439,7 @@ getTestNtfTokenPort a =
    Just NtfToken {ntfServer = ProtocolServer {port}} -> pure port
    Nothing -> error "no active NtfToken"

-testNtfTokenMultipleServers :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenMultipleServers :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenMultipleServers t apns = do
  let tkn = DeviceToken PPApnsTest "abcd"
  withAgent 1 agentCfg initAgentServers2 testDB $ \a ->
@@ -455,7 +450,7 @@ testNtfTokenMultipleServers t apns = do
        APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
          getMockNotification apns tkn
        verification <- ntfData .-> "verification"
-        nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+        nonce <- C.cbNonce <$> ntfData .-> "nonce"
        verifyNtfToken a tkn nonce verification
        NTActive <- checkNtfToken a tkn
        -- shut down the "other" server
@@ -468,7 +463,7 @@ testNtfTokenMultipleServers t apns = do
        Left _ <- tryError (checkNtfToken a tkn)
        pure ()

-testNtfTokenChangeServers :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenChangeServers :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenChangeServers t apns =
  withNtfServerThreadOn t ntfTestPort ntfTestDBCfg $ \ntf -> do
    tkn1 <- withAgent 1 agentCfg initAgentServers testDB $ \a -> runRight $ do
@@ -498,7 +493,7 @@ testNtfTokenChangeServers t apns =
        tkn <- registerTestToken a "qwer" NMInstant apns
        checkNtfToken a tkn >>= \r -> liftIO $ r `shouldBe` NTActive

-testNtfTokenReRegisterInvalid :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenReRegisterInvalid :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenReRegisterInvalid t apns = do
  tkn <- withNtfServer t $ do
    withAgent 1 agentCfg initAgentServers testDB $ \a -> runRight $ do
@@ -523,7 +518,7 @@ testNtfTokenReRegisterInvalid t apns = do
      NTActive <- checkNtfToken a tkn1
      pure ()

-testNtfTokenReRegisterInvalidOnCheck :: HasTestEnv => ASrvTransport -> APNSMockServer -> IO ()
+testNtfTokenReRegisterInvalidOnCheck :: ASrvTransport -> APNSMockServer -> IO ()
 testNtfTokenReRegisterInvalidOnCheck t apns = do
  tkn <- withNtfServer t $ do
    withAgent 1 agentCfg initAgentServers testDB $ \a -> runRight $ do
@@ -548,13 +543,13 @@ testNtfTokenReRegisterInvalidOnCheck t apns = do
      NTActive <- checkNtfToken a tkn1
      pure ()

-testRunNTFServerTests :: HasTestEnv => ASrvTransport -> NtfServer -> IO (Either ProtocolTestFailure (Maybe (Either String ServerPublicInfo)))
+testRunNTFServerTests :: ASrvTransport -> NtfServer -> IO (Either ProtocolTestFailure (Maybe (Either String ServerPublicInfo)))
 testRunNTFServerTests t srv =
  withNtfServer t $
    withAgent 1 agentCfg initAgentServers testDB $ \a ->
      testProtocolServer a NRMInteractive 1 (ProtoServerWithAuth srv Nothing)

-testNotificationSubscriptionExistingConnection :: HasTestEnv => APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()
+testNotificationSubscriptionExistingConnection :: APNSMockServer -> AgentMsgId -> AgentClient -> AgentClient -> IO ()
 testNotificationSubscriptionExistingConnection apns baseId alice@AgentClient {agentEnv = Env {config = aliceCfg, store}} bob = do
  (bobId, aliceId, nonce, message) <- runRight $ do
    -- establish connection
@@ -571,7 +566,7 @@ testNotificationSubscriptionExistingConnection apns baseId alice@AgentClient {ag
    APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData}} <-
      getMockNotification apns tkn
    verification <- ntfData .-> "verification"
-    vNonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+    vNonce <- C.cbNonce <$> ntfData .-> "nonce"
    verifyNtfToken alice tkn vNonce verification
    NTActive <- checkNtfToken alice tkn
    -- send message
@@ -662,12 +657,12 @@ registerTestToken a token mode apns = do
  Just APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData'}} <-
    timeout 1000000 $ getMockNotification apns tkn
  verification' <- ntfData' .-> "verification"
-  nonce' <- C.unsafeCbNonce <$> ntfData' .-> "nonce"
+  nonce' <- C.cbNonce <$> ntfData' .-> "nonce"
  verifyNtfToken a tkn nonce' verification'
  NTActive <- checkNtfToken a tkn
  pure tkn

-testChangeNotificationsMode :: (HasCallStack, HasTestEnv) => APNSMockServer -> IO ()
+testChangeNotificationsMode :: HasCallStack => APNSMockServer -> IO ()
 testChangeNotificationsMode apns =
  withAgentClients2 $ \alice bob -> runRight_ $ do
    -- establish connection
@@ -730,7 +725,7 @@ testChangeNotificationsMode apns =
    baseId = 1
    msgId = subtract baseId

-testChangeToken :: HasTestEnv => APNSMockServer -> IO ()
+testChangeToken :: APNSMockServer -> IO ()
 testChangeToken apns = withAgent 1 agentCfg initAgentServers testDB2 $ \bob -> do
  (aliceId, bobId) <- withAgent 2 agentCfg initAgentServers testDB $ \alice -> runRight $ do
    -- establish connection
@@ -770,7 +765,7 @@ testChangeToken apns = withAgent 1 agentCfg initAgentServers testDB2 $ \bob -> d
    baseId = 1
    msgId = subtract baseId

-testNotificationsStoreLog :: HasTestEnv => (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
+testNotificationsStoreLog :: (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
 testNotificationsStoreLog ps@(t, _) apns = withAgentClients2 $ \alice bob -> do
  withSmpServerStoreMsgLogOn ps testPort $ \_ -> do
    (aliceId, bobId) <- withNtfServer t $ runRight $ do
@@ -805,7 +800,7 @@ testNotificationsStoreLog ps@(t, _) apns = withAgentClients2 $ \alice bob -> do
    withNtfServer t $ runRight_ $ do
      void $ messageNotificationData alice apns

-testNotificationsSMPRestart :: HasTestEnv => (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
+testNotificationsSMPRestart :: (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
 testNotificationsSMPRestart ps apns = withAgentClients2 $ \alice bob -> do
  (aliceId, bobId) <- withSmpServerStoreLogOn ps testPort $ \threadId -> runRight $ do
    (aliceId, bobId) <- makeConnection alice bob
@@ -833,7 +828,7 @@ testNotificationsSMPRestart ps apns = withAgentClients2 $ \alice bob -> do
    get alice =##> \case ("", c, Msg "hello again") -> c == bobId; _ -> False
    liftIO $ killThread threadId

-testNotificationsSMPRestartBatch :: HasTestEnv => Int -> (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
+testNotificationsSMPRestartBatch :: Int -> (ASrvTransport, AStoreType) -> APNSMockServer -> IO ()
 testNotificationsSMPRestartBatch n ps@(t, ASType qsType _) apns =
  withAgentClientsCfgServers2 agentCfg agentCfg initAgentServers2 $ \a b -> do
    threadDelay 1000000
@@ -879,7 +874,7 @@ testNotificationsSMPRestartBatch n ps@(t, ASType qsType _) apns =
        killThread t1
        pure res

-testSwitchNotifications :: HasTestEnv => AgentConfig -> (AgentClient -> ByteString -> AgentClient -> ByteString -> ExceptT AgentErrorType IO ()) -> InitialAgentServers -> APNSMockServer -> IO ()
+testSwitchNotifications :: AgentConfig -> (AgentClient -> ByteString -> AgentClient -> ByteString -> ExceptT AgentErrorType IO ()) -> InitialAgentServers -> APNSMockServer -> IO ()
 testSwitchNotifications cfg completeSwitch servers apns =
  withAgentClientsCfgServers2 cfg cfg servers $ \a b -> runRight_ $ do
    (aId, bId) <- makeConnection a b
@@ -898,7 +893,7 @@ testSwitchNotifications cfg completeSwitch servers apns =
    liftIO $ threadDelay 500000
    testMessage "hello again"

-testNotificationsOldToken :: HasTestEnv => APNSMockServer -> IO ()
+testNotificationsOldToken :: APNSMockServer -> IO ()
 testNotificationsOldToken apns =
  withAgentClients3 $ \a b c -> runRight_ $ do
    (abId, baId) <- makeConnection a b
@@ -917,7 +912,7 @@ testNotificationsOldToken apns =
    let testMessageAC = testMessage_ apns a acId c caId
    testMessageAC "greetings"

-testNotificationsNewToken :: HasTestEnv => APNSMockServer -> ThreadId -> IO ()
+testNotificationsNewToken :: APNSMockServer -> ThreadId -> IO ()
 testNotificationsNewToken apns oldNtf =
  withAgentClients3 $ \a b c -> runRight_ $ do
    (abId, baId) <- makeConnection a b
@@ -939,7 +934,7 @@ testNotificationsNewToken apns oldNtf =
    let testMessageAC = testMessage_ apns a acId c caId
    testMessageAC "greetings"

-testMigrateToServiceSubscriptions :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> IO ()
+testMigrateToServiceSubscriptions :: HasCallStack => (ASrvTransport, AStoreType) -> IO ()
 testMigrateToServiceSubscriptions ps@(t, msType) = withAgentClients2 $ \a b -> do
  (c1, c2, c3) <- withSmpServerConfigOn t cfgNoService testPort $ \_ -> do
    (c1, c2) <- withAPNSMockServer $ \apns -> do
@@ -1040,7 +1035,7 @@ messageNotification apns tkn = do
  500000 `timeout` getMockNotification apns tkn >>= \case
    Nothing -> error "no notification"
    Just APNSMockRequest {notification = APNSNotification {aps = APNSMutableContent {}, notificationData = Just ntfData}} -> do
-      nonce <- C.unsafeCbNonce <$> ntfData .-> "nonce"
+      nonce <- C.cbNonce <$> ntfData .-> "nonce"
      message <- ntfData .-> "message"
      pure (nonce, message)
    _ -> error "bad notification"
@@ -32,7 +32,7 @@ import qualified Simplex.Messaging.Protocol as SMP
 import Simplex.Messaging.SimplexName (SimplexDomain (..), SimplexTLD (..))
 import Simplex.Messaging.Transport
 import Test.Hspec hiding (fit, it)
-import Util (HasTestEnv, it)
+import Util (it)

 nameSrvCfg :: SMPServer -> ServerCfg 'SMP.PSMP
 nameSrvCfg = presetServerCfg True ServerRoles {storage = True, proxy = False, names = True} (Just 1) . SMP.noAuthSrv
@@ -40,16 +40,16 @@ nameSrvCfg = presetServerCfg True ServerRoles {storage = True, proxy = False, na
 proxySrvCfg :: SMPServer -> ServerCfg 'SMP.PSMP
 proxySrvCfg = presetServerCfg True ServerRoles {storage = True, proxy = True, names = False} (Just 1) . SMP.noAuthSrv

-oneSrv :: HasTestEnv => ServerCfg 'SMP.PSMP -> InitialAgentServers
+oneSrv :: ServerCfg 'SMP.PSMP -> InitialAgentServers
 oneSrv cfg_ = (initAgentServersProxy_ SPMNever SPFProhibit) {smp = [(1, [cfg_])]}

-withDirectResolver :: HasTestEnv => (Status, LB.ByteString) -> (AgentClient -> IO a) -> IO a
+withDirectResolver :: (Status, LB.ByteString) -> (AgentClient -> IO a) -> IO a
 withDirectResolver (st, body) k =
  NRS.withResolverServer (NRS.resolveResp st body) $ \port _ ->
    withSmpServerConfigOn (transport @TLS) (withNames port memCfg) testPort $ \_ ->
      withAgent 1 agentCfg (oneSrv (nameSrvCfg testSMPServer)) testDB k

-withProxyAndResolver :: HasTestEnv => (Status, LB.ByteString) -> (AgentClient -> IO a) -> IO a
+withProxyAndResolver :: (Status, LB.ByteString) -> (AgentClient -> IO a) -> IO a
 withProxyAndResolver (st, body) k =
  NRS.withResolverServer (NRS.resolveResp st body) $ \port _ ->
    withSmpServerConfigOn (transport @TLS) memProxyCfg testPort $ \_ ->
@@ -59,12 +59,12 @@ withProxyAndResolver (st, body) k =
    -- only testSMPServer2 (the resolver) has the names role; testSMPServer is the proxy
    proxyServers = (initAgentServersProxy_ SPMAlways SPFProhibit) {smp = [(1, [proxySrvCfg testSMPServer, nameSrvCfg testSMPServer2])]}

-withNoResolver :: HasTestEnv => (AgentClient -> IO a) -> IO a
+withNoResolver :: (AgentClient -> IO a) -> IO a
 withNoResolver k =
  withSmpServerConfigOn (transport @TLS) memCfg testPort $ \_ ->
    withAgent 1 agentCfg (oneSrv (nameSrvCfg testSMPServer)) testDB k

-withNoNameServers :: HasTestEnv => (AgentClient -> IO a) -> IO a
+withNoNameServers :: (AgentClient -> IO a) -> IO a
 withNoNameServers k = withAgent 1 agentCfg (oneSrv (proxySrvCfg testSMPServer)) testDB k

 resolveNameTests :: Spec
@@ -88,7 +88,7 @@ resolveNameTests = do
  describe "name availability" $
    it "an unregistered name answers as available" testAvailSuccess

-testAvailSuccess :: (HasCallStack, HasTestEnv) => IO ()
+testAvailSuccess :: HasCallStack => IO ()
 testAvailSuccess =
  withDirectResolver (status200, availableBody) $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -98,7 +98,7 @@ testAvailSuccess =

 -- | 404 is a resolver that predates /v2/resolve: no status from that endpoint
 -- means "not registered", since an unregistered name answers NRAvailable.
-testDirectResolverErr :: (HasCallStack, HasTestEnv) => IO ()
+testDirectResolverErr :: HasCallStack => IO ()
 testDirectResolverErr =
  withDirectResolver (status404, "{}") $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -106,7 +106,7 @@ testDirectResolverErr =
      Left (SMP _ (SMP.NAME (SMP.RESOLVER _))) -> pure ()
      _ -> expectationFailure $ "expected Left (SMP _ (NAME (RESOLVER _))), got: " <> show r

-testProxyResolverErr :: (HasCallStack, HasTestEnv) => IO ()
+testProxyResolverErr :: HasCallStack => IO ()
 testProxyResolverErr =
  withProxyAndResolver (status404, "{}") $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -114,7 +114,7 @@ testProxyResolverErr =
      Left (SMP host (SMP.NAME (SMP.RESOLVER _))) | testPort `isInfixOf` host -> pure ()
      _ -> expectationFailure $ "expected Left (SMP <proxyHost:" <> testPort <> "> (NAME (RESOLVER _))), got: " <> show r

-testTestingTldResolverErr :: (HasCallStack, HasTestEnv) => IO ()
+testTestingTldResolverErr :: HasCallStack => IO ()
 testTestingTldResolverErr =
  withDirectResolver (status404, "{}") $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDTesting "bob" [])
@@ -122,7 +122,7 @@ testTestingTldResolverErr =
      Left (SMP _ (SMP.NAME (SMP.RESOLVER _))) -> pure ()
      _ -> expectationFailure $ "expected Left (SMP _ (NAME (RESOLVER _))), got: " <> show r

-testWebTldResolverErr :: (HasCallStack, HasTestEnv) => IO ()
+testWebTldResolverErr :: HasCallStack => IO ()
 testWebTldResolverErr =
  withDirectResolver (status404, "{}") $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDWeb "example.com" [])
@@ -130,7 +130,7 @@ testWebTldResolverErr =
      Left (SMP _ (SMP.NAME (SMP.RESOLVER _))) -> pure ()
      _ -> expectationFailure $ "expected Left (SMP _ (NAME (RESOLVER _))), got: " <> show r

-testNoResolver :: (HasCallStack, HasTestEnv) => IO ()
+testNoResolver :: HasCallStack => IO ()
 testNoResolver =
  withNoResolver $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -138,7 +138,7 @@ testNoResolver =
      Left (SMP _ (SMP.NAME SMP.NO_RESOLVER)) -> pure ()
      _ -> expectationFailure $ "expected Left (SMP _ (NAME NO_RESOLVER)), got: " <> show r

-testNoNameServers :: (HasCallStack, HasTestEnv) => IO ()
+testNoNameServers :: HasCallStack => IO ()
 testNoNameServers =
  withNoNameServers $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -146,7 +146,7 @@ testNoNameServers =
      Left NO_NAME_SERVERS -> pure ()
      _ -> expectationFailure $ "expected Left NO_NAME_SERVERS, got: " <> show r

-testBackendError :: (HasCallStack, HasTestEnv) => IO ()
+testBackendError :: HasCallStack => IO ()
 testBackendError =
  withDirectResolver (status502, "{}") $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -154,7 +154,7 @@ testBackendError =
      Left (SMP _ (SMP.NAME (SMP.RESOLVER _))) -> pure ()
      _ -> expectationFailure $ "expected Left (SMP _ (NAME (RESOLVER ..))), got: " <> show r

-testDirectSuccess :: (HasCallStack, HasTestEnv) => IO ()
+testDirectSuccess :: HasCallStack => IO ()
 testDirectSuccess =
  withDirectResolver (status200, registeredBody testNameRecord) $ \c -> do
    r <- runExceptT $ resolveSimplexName c NRMInteractive 1 (SimplexDomain TLDSimplex "alice" [])
@@ -20,13 +20,12 @@ import Control.Concurrent.Async (concurrently_)
 import Control.Concurrent.MVar
 import Control.Concurrent.STM
 import Control.Exception (SomeException)
-import Control.Monad (forM_, replicateM_)
+import Control.Monad (replicateM_)
 import Control.Monad.Trans.Except
 import Crypto.Random (ChaChaDRG)
 import Data.ByteArray (ScrubbedBytes)
 import Data.ByteString.Char8 (ByteString)
 import Data.List (isInfixOf)
-import qualified Data.Map.Strict as M
 import qualified Data.Text as T
 import Data.Text.Encoding (encodeUtf8)
 import Data.Time
@@ -52,7 +51,6 @@ import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.File (CryptoFile (..))
 import Simplex.Messaging.Crypto.Ratchet (pattern IKPQOn)
 import qualified Simplex.Messaging.Crypto.Ratchet as CR
-import Simplex.Messaging.Encoding (Encoding (..))
 import Simplex.Messaging.Encoding.String (StrEncoding (..))
 import Simplex.Messaging.Protocol (EntityId (..), QueueMode (..), SubscriptionMode (..), pattern VersionSMPC)
 import qualified Simplex.Messaging.Protocol as SMP
@@ -137,8 +135,6 @@ storeTests = do
          testCreateRcvMsg
          testCreateSndMsg
          testCreateRcvAndSndMsgs
-      describe "deleteRatchetKeyHashesExpired" testDeleteRatchetKeyHashesExpired
-      it "should keep only the newest skipped message keys" testGetSkippedMsgKeys
      describe "Work items" $ do
        it "should getPendingQueueMsg" testGetPendingQueueMsg
        it "should getPendingServerCommand" testGetPendingServerCommand
@@ -513,7 +509,7 @@ hw = encodeUtf8 "Hello world!"
 ts :: UTCTime
 ts = UTCTime (fromGregorian 2021 02 24) (secondsToDiffTime 0)

-mkRcvMsgData :: InternalId -> InternalRcvId -> ExternalSndId -> ByteString -> MsgHash -> RcvMsgData
+mkRcvMsgData :: InternalId -> InternalRcvId -> ExternalSndId -> BrokerId -> MsgHash -> RcvMsgData
 mkRcvMsgData internalId internalRcvId externalSndId brokerId internalHash =
  RcvMsgData
    { internalRcvId,
@@ -522,7 +518,7 @@ mkRcvMsgData internalId internalRcvId externalSndId brokerId internalHash =
          { integrity = MsgOk,
            recipient = (unId internalId, ts),
            sndMsgId = externalSndId,
-            broker = (SMP.unsafeMsgId $ mconcat (replicate 24 brokerId), ts),
+            broker = (brokerId, ts),
            pqEncryption = CR.PQEncOn
          },
      msgType = AM_A_MSG_,
@@ -603,42 +599,6 @@ testCreateRcvAndSndMsgs =
      testCreateSndMsg_ db "snd_hash_1" connId sq $ mkSndMsgData (InternalId 5) (InternalSndId 2) "snd_hash_2"
      testCreateSndMsg_ db "snd_hash_2" connId sq $ mkSndMsgData (InternalId 6) (InternalSndId 3) "snd_hash_3"

-testDeleteRatchetKeyHashesExpired :: SpecWith DBStore
-testDeleteRatchetKeyHashesExpired =
-  it "should delete expired ratchet key hashes except the newest in each connection" . withStoreTransaction $ \db -> do
-    g <- C.newRandom
-    Right connId <- createNewConn db g cData1 {connId = ""} SCMInvitation
-    Right connId' <- createNewConn db g cData1 {connId = ""} SCMContact
-    let hashes = ["h1", "h2", "h3", "h4", "h5", "h6"]
-    forM_ hashes $ addProcessedRatchetKeyHash db connId
-    forM_ (take 4 hashes) $ addProcessedRatchetKeyHash db connId'
-    deleteRatchetKeyHashesExpired db 86400 4
-    mapM (checkRatchetKeyHashExists db connId) hashes `shouldReturn` replicate 6 True
-    deleteRatchetKeyHashesExpired db 0 4
-    mapM (checkRatchetKeyHashExists db connId) hashes `shouldReturn` [False, False, True, True, True, True]
-    mapM (checkRatchetKeyHashExists db connId') (take 4 hashes) `shouldReturn` replicate 4 True
-
-testGetSkippedMsgKeys :: DBStore -> Expectation
-testGetSkippedMsgKeys st = do
-  g <- C.newRandom
-  withTransaction st $ \db -> do
-    Right connId <- createNewConn db g cData1 {connId = ""} SCMInvitation
-    Right connId' <- createNewConn db g cData1 {connId = ""} SCMInvitation
-    createSkippedKeys db connId'
-    createSkippedKeys db connId
-    M.map M.keys <$> getSkippedMsgKeys db connId 4
-      `shouldReturn` M.singleton (C.Key "header_key") [1, 2, 3, 4]
-    getMsgNs db connId `shouldReturn` [1 .. 4]
-    getMsgNs db connId' `shouldReturn` [1 .. 10]
-  where
-    createSkippedKeys :: DB.Connection -> ConnId -> IO ()
-    createSkippedKeys db connId = do
-      DB.execute db "INSERT INTO ratchets (conn_id) VALUES (?)" (Only connId)
-      forM_ ([10, 9 .. 1] :: [Int]) $ \msgN ->
-        DB.execute db "INSERT INTO skipped_messages (conn_id, header_key, msg_n, msg_key) VALUES (?, ?, ?, ?)" (connId, "header_key" :: ByteString, msgN, smpEncode ("key" :: ByteString, "iv" :: ByteString))
-    getMsgNs :: DB.Connection -> ConnId -> IO [Int]
-    getMsgNs db connId = map fromOnly <$> DB.query db "SELECT msg_n FROM skipped_messages WHERE conn_id = ? ORDER BY msg_n" (Only connId)
-
 testCloseReopenStore :: IO ()
 testCloseReopenStore = do
  st <- createStore'
@@ -688,7 +648,7 @@ hasMigrations :: DBStore -> Expectation
 hasMigrations st = getMigrations st `shouldReturn` True

 errorGettingMigrations :: DBStore -> Expectation
-errorGettingMigrations st = getMigrations st `shouldThrow` \(e :: SomeException) -> "withTransaction: database closed" `isInfixOf` show e
+errorGettingMigrations st = getMigrations st `shouldThrow` \(e :: SomeException) -> "ErrorMisuse" `isInfixOf` show e

 testGetPendingQueueMsg :: DBStore -> Expectation
 testGetPendingQueueMsg st = do
@@ -48,8 +48,6 @@ schemaDumpTest = do
  it "verify strict tables" testVerifyStrict
  it "should NOT create user record for new database" testUsersMigrationNew
  it "should create user record for old database" testUsersMigrationOld
-  it "should remove duplicate ratchet key hashes before adding unique index" testRatchetKeyHashesUniqueMigration
-  it "should clear received_qend switch status on downgrade" testRcvSwitchStatusDowngrade

 testVerifySchemaDump :: IO ()
 testVerifySchemaDump = do
@@ -116,45 +114,12 @@ testUsersMigrationOld = do
    `shouldReturn` ([Only (1 :: Int)])
  closeDBStore st'

-testRatchetKeyHashesUniqueMigration :: IO ()
-testRatchetKeyHashesUniqueMigration = do
-  let beforeUnique = takeWhile (("m20260929_ratchet_indexes" /=) . name) appMigrations
-  Right st <- createDBStore (DBOpts testDB [] "" False True TQOff) beforeUnique (MigrationConfig MCError Nothing)
-  withTransaction' st $ \db -> do
-    SQL.execute_ db "INSERT INTO users (user_id) VALUES (1)"
-    SQL.execute_ db "INSERT INTO connections (conn_id, conn_mode, user_id) VALUES (x'01', 'INV', 1), (x'02', 'INV', 1)"
-    SQL.execute_ db "INSERT INTO processed_ratchet_key_hashes (conn_id, hash) VALUES (x'01', x'aa'), (x'01', x'aa'), (x'01', x'bb'), (x'02', x'aa'), (x'01', x'aa')"
-  closeDBStore st
-  Right st' <- createDBStore (DBOpts testDB [] "" False True TQOff) appMigrations (MigrationConfig MCYesUp Nothing)
-  withTransaction' st' (`SQL.query_` "SELECT processed_ratchet_key_hash_id FROM processed_ratchet_key_hashes ORDER BY processed_ratchet_key_hash_id")
-    `shouldReturn` [Only (1 :: Int), Only 3, Only 4]
-  closeDBStore st'
-
-testRcvSwitchStatusDowngrade :: IO ()
-testRcvSwitchStatusDowngrade = do
-  Right st <- createDBStore (DBOpts testDB [] "" False True TQOff) appMigrations (MigrationConfig MCError Nothing)
-  withTransaction' st $ \db -> do
-    SQL.execute_ db "INSERT INTO users (user_id) VALUES (1)"
-    SQL.execute_ db "INSERT INTO connections (conn_id, conn_mode, user_id) VALUES (x'01', 'INV', 1)"
-    SQL.execute_ db "INSERT INTO servers (host, port, key_hash) VALUES ('localhost', '5001', x'00')"
-    SQL.execute_ db "INSERT INTO rcv_queues (host, port, rcv_id, conn_id, rcv_private_key, rcv_dh_secret, e2e_priv_key, snd_id, status, rcv_queue_id, rcv_primary, switch_status) VALUES ('localhost', '5001', x'01', x'01', x'00', x'00', x'00', x'01', 'active', 1, 0, 'received_qend'), ('localhost', '5001', x'02', x'01', x'00', x'00', x'00', x'02', 'active', 2, 1, 'sending_qadd')"
-  closeDBStore st
-  let beforeRcvSwitchStatus = takeWhile (("m20261008_rcv_switch_status" /=) . name) appMigrations
-  Right st' <- createDBStore (DBOpts testDB [] "" False True TQOff) beforeRcvSwitchStatus (MigrationConfig MCYesUpDown Nothing)
-  withTransaction' st' (`SQL.query_` "SELECT switch_status FROM rcv_queues ORDER BY rcv_queue_id")
-    `shouldReturn` [Only (Nothing :: Maybe Text), Only (Just "sending_qadd")]
-  closeDBStore st'
-
 skipComparisonForDownMigrations :: [String]
 skipComparisonForDownMigrations =
  [ -- on down migration idx_messages_internal_snd_id_ts index moves down to the end of the file
    "m20230814_indexes",
    -- snd_secure and last_broker_ts columns swap order on down migration
-    "m20250322_short_links",
-    -- on down migration idx_processed_ratchet_key_hashes_hash index moves down to the end of the file
-    "m20260929_ratchet_indexes",
-    -- sqlite_sequence moves after commands table after VACUUM
-    "m20261005_commands_autoincrement"
+    "m20250322_short_links"
  ]

 getSchema :: FilePath -> FilePath -> IO String
@@ -57,7 +57,7 @@ storageOnly = ServerRoles {storage = True, proxy = False, names = False}
 proxyOnly :: ServerRoles
 proxyOnly = ServerRoles {storage = False, proxy = True, names = False}

-initServers :: HasTestEnv => InitialAgentServers
+initServers :: InitialAgentServers
 initServers =
  InitialAgentServers
    { smp = M.fromList [(1, testSMPServers)],
@@ -70,7 +70,7 @@ initServers =
      presetServers = []
    }

-testChooseDifferentOperator :: HasTestEnv => IO ()
+testChooseDifferentOperator :: IO ()
 testChooseDifferentOperator = withAgent 1 agentCfg initServers testDB $ \c -> runRight_ $ do
    -- chooses the only operator with storage role
    srv1 <- withAgentEnv c $ getNextServer c 1 storageSrvs []
@@ -49,32 +49,32 @@ import Util
 import qualified Data.ByteString.Char8 as B
 import qualified Database.PostgreSQL.Simple as PSQL
 import Database.PostgreSQL.Simple.Types (Query (..))
-import NtfClient (ntfTestServerDBConnectInfo, ntfTestServerDBConnstr, ntfTestServerDBOpts)
+import NtfClient (ntfTestServerDBConnectInfo, ntfTestServerDBConnstr, ntfTestStoreDBOpts)
 import SMPClient (postgressBracket)
 import Simplex.Messaging.Agent.Store.Postgres.Options (DBOpts (..))
 import Simplex.Messaging.Notifications.Server.Main
 #endif

-cfgPath :: HasTestEnv => FilePath
-cfgPath = testPath "cli/etc/opt/simplex"
+cfgPath :: FilePath
+cfgPath = "tests/tmp/cli/etc/opt/simplex"

-logPath :: HasTestEnv => FilePath
-logPath = testPath "cli/etc/var/simplex"
+logPath :: FilePath
+logPath = "tests/tmp/cli/etc/var/simplex"

-webPath :: HasTestEnv => FilePath
-webPath = testPath "cli/var/www"
+webPath :: FilePath
+webPath = "tests/tmp/cli/var/www"

-ntfCfgPath :: HasTestEnv => FilePath
-ntfCfgPath = testPath "cli/etc/opt/simplex-notifications"
+ntfCfgPath :: FilePath
+ntfCfgPath = "tests/tmp/cli/etc/opt/simplex-notifications"

-ntfLogPath :: HasTestEnv => FilePath
-ntfLogPath = testPath "cli/etc/var/simplex-notifications"
+ntfLogPath :: FilePath
+ntfLogPath = "tests/tmp/cli/etc/var/simplex-notifications"

-fileCfgPath :: HasTestEnv => FilePath
-fileCfgPath = testPath "cli/etc/opt/simplex-files"
+fileCfgPath :: FilePath
+fileCfgPath = "tests/tmp/cli/etc/opt/simplex-files"

-fileLogPath :: HasTestEnv => FilePath
-fileLogPath = testPath "cli/etc/var/simplex-files"
+fileLogPath :: FilePath
+fileLogPath = "tests/tmp/cli/etc/var/simplex-files"

 cliTests :: Spec
 cliTests = do
@@ -87,7 +87,7 @@ cliTests = do
      it "static files" smpServerTestStatic
      it "cloud scripts disable embedded web without certificates" smpCloudScriptsDisableWeb
 #if defined(dbServerPostgres)
-  around_ (postgressBracket ntfTestServerDBConnectInfo) $ before_ (createNtfSchema ntfTestServerDBConnectInfo ntfTestServerDBOpts) $
+  around_ (postgressBracket ntfTestServerDBConnectInfo) $ before_ (createNtfSchema ntfTestServerDBConnectInfo ntfTestStoreDBOpts) $
    describe "Ntf server CLI" $ do
      it "should initialize, start and delete the server (no store log)" $ ntfServerTest False
      it "should initialize, start and delete the server (with store log)" $ ntfServerTest True
@@ -96,7 +96,7 @@ cliTests = do
    it "should initialize, start and delete the server (no store log)" $ xftpServerTest False
    it "should initialize, start and delete the server (with store log)" $ xftpServerTest True

-smpServerTest :: HasTestEnv => Bool -> Bool -> IO ()
+smpServerTest :: Bool -> Bool -> IO ()
 smpServerTest storeLog basicAuth = do
  -- init
  capture_ (withArgs (["init", "-y"] <> ["--disable-store-log" | not storeLog] <> ["--no-password" | not basicAuth]) $ smpServerCLI cfgPath logPath)
@@ -137,7 +137,7 @@ smpServerTest storeLog basicAuth = do
    >>= (`shouldSatisfy` ("WARNING: deleting the server will make all queues inaccessible" `isPrefixOf`))
  doesFileExist (cfgPath <> "/ca.key") `shouldReturn` False

-smpServerTestStatic :: (HasCallStack, HasTestEnv) => IO ()
+smpServerTestStatic :: HasCallStack => IO ()
 smpServerTestStatic = do
  let iniFile = cfgPath <> "/smp-server.ini"
  capture_ (withArgs ["init", "-y", "--no-password", "--web-path", webPath] $ smpServerCLI cfgPath logPath)
@@ -225,7 +225,7 @@ createNtfSchema connInfo DBOpts {schema} = do
  void $ PSQL.execute_ db $ Query $ "CREATE SCHEMA " <> schema
  PSQL.close db

-ntfServerTest :: HasTestEnv => Bool -> IO ()
+ntfServerTest :: Bool -> IO ()
 ntfServerTest storeLog = do
  capture_ (withArgs (["init", "--database=" <> B.unpack ntfTestServerDBConnstr] <> ["--disable-store-log" | not storeLog]) $ ntfServerCLI ntfCfgPath ntfLogPath)
    >>= (`shouldSatisfy` (("Server initialized, you can modify configuration in " <> ntfCfgPath <> "/ntf-server.ini") `isPrefixOf`))
@@ -244,9 +244,9 @@ ntfServerTest storeLog = do
  doesFileExist (cfgPath <> "/ca.key") `shouldReturn` False
 #endif

-xftpServerTest :: HasTestEnv => Bool -> IO ()
+xftpServerTest :: Bool -> IO ()
 xftpServerTest storeLog = do
-  capture_ (withArgs (["init", "-p", testDir, "-q", "10gb"] <> ["--disable-store-log" | not storeLog]) $ xftpServerCLI fileCfgPath fileLogPath)
+  capture_ (withArgs (["init", "-p", "tests/tmp", "-q", "10gb"] <> ["--disable-store-log" | not storeLog]) $ xftpServerCLI fileCfgPath fileLogPath)
    >>= (`shouldSatisfy` (("Server initialized, you can modify configuration in " <> fileCfgPath <> "/file-server.ini") `isPrefixOf`))
  Right ini <- readIniFile $ fileCfgPath <> "/file-server.ini"
  lookupValue "STORE_LOG" "enable" ini `shouldBe` Right (if storeLog then "on" else "off")
@@ -14,13 +14,11 @@ import Control.Monad
 import Crypto.Random (ChaChaDRG)
 import qualified Data.ByteString as B
 import Data.ByteString.Char8 (ByteString)
-import Data.ByteString.Unsafe (unsafeUseAsCString)
 import qualified Data.List.NonEmpty as L
 import Data.Time.Clock.System (SystemTime, getSystemTime)
 import qualified Data.X509 as X
 import qualified Data.X509.CertificateStore as XS
 import qualified Data.X509.File as XF
-import Foreign.Ptr (plusPtr)
 import Simplex.Messaging.Client
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding
@@ -42,8 +40,6 @@ batchingTests = do
    it "should batch subscription responses with message" testBatchSubResponses
    it "should break on message that does not fit" testClientBatchWithMessage
    it "should break on large message" testClientBatchWithLargeMessage
-  describe "tDecodeServer" $
-    it "should copy IDs out of received block" testDecodeServerCopiesIds

 testBatchSubscriptions :: IO ()
 testBatchSubscriptions = do
@@ -170,26 +166,6 @@ testClientBatchWithLargeMessage = do
  (length rs1', length rs2') `shouldBe` (75, 135)
  all lenOk [s1', s2'] `shouldBe` True

-testDecodeServerCopiesIds :: IO ()
-testDecodeServerCopiesIds = do
-  sessId <- atomically . C.randomBytes 32 =<< C.newRandom
-  subs <- replicateM 2 $ randomSUB sessId
-  let thParams = testTHandleParams sessId
-  [TBTransmissions s 2 _] <- pure $ batchTransmissions thParams $ L.fromList subs
-  forM_ (tParse thParams s) $ \t -> do
-    let (corrId, entId, _) = tDecodeClient @SMPVersion @ErrorType @Cmd thParams t
-    Right (_, _, (corrId', entId', _)) <- pure $ tDecodeServer @SMPVersion @ErrorType @Cmd (testTHandleParams sessId) t
-    (corrId', entId') `shouldBe` (corrId, entId)
-    sharesBuffer s (bs corrId) `shouldReturn` True
-    sharesBuffer s (unEntityId entId) `shouldReturn` True
-    sharesBuffer s (bs corrId') `shouldReturn` False
-    sharesBuffer s (unEntityId entId') `shouldReturn` False
-
-sharesBuffer :: ByteString -> ByteString -> IO Bool
-sharesBuffer block s =
-  unsafeUseAsCString block $ \blockPtr -> unsafeUseAsCString s $ \ptr ->
-    pure $ ptr >= blockPtr && ptr < blockPtr `plusPtr` B.length block
-
 testClientStub :: IO (ProtocolClient SMPVersion ErrorType BrokerMsg)
 testClientStub = do
  g <- C.newRandom
@@ -207,7 +183,7 @@ randomSUB sessId = do
  thAuth_ <- testTHandleAuth g rKey
  let thParams = testTHandleParams sessId
      TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth thParams (CorrId corrId, EntityId rId, Cmd SRecipient SUB)
-  pure $ (,tToSend) <$> authTransmission thAuth_ True (Just rpKey) (Just nonce) tForAuth
+  pure $ (,tToSend) <$> authTransmission thAuth_ True (Just rpKey) nonce tForAuth

 randomSUBCmd :: ProtocolClient SMPVersion ErrorType BrokerMsg -> IO (PCTransmission ErrorType BrokerMsg)
 randomSUBCmd c = do
@@ -226,7 +202,7 @@ randomNMSGCmd :: SystemTime -> IO (Transmission BrokerMsg)
 randomNMSGCmd ts = do
  g <- C.newRandom
  nId <- atomically $ C.randomBytes 24 g
-  msgId <- atomically $ randomMsgId 24 g
+  msgId <- atomically $ C.randomBytes 24 g
  (k, pk) <- atomically $ C.generateKeyPair g
  nonce <- atomically $ C.randomCbNonce g
  let msgMeta = NMsgMeta {msgId, msgTs = ts}
@@ -245,7 +221,7 @@ randomMSG = do
  g <- C.newRandom
  corrId <- atomically $ C.randomBytes 24 g
  rId <- atomically $ C.randomBytes 24 g
-  msgId <- atomically $ randomMsgId 24 g
+  msgId <- atomically $ C.randomBytes 24 g
  msg <- atomically $ C.randomBytes maxMessageLength g
  pure (CorrId corrId, EntityId rId, MSG RcvMessage {msgId, msgBody = EncRcvMsgBody msg})

@@ -259,9 +235,9 @@ randomSEND sessId len = do
  msg <- atomically $ C.randomBytes len g
  let thParams = testTHandleParams sessId
      TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth thParams (CorrId corrId, EntityId sId, Cmd SSender $ SEND noMsgFlags msg)
-  pure $ (,tToSend) <$> authTransmission thAuth_ False (Just spKey) (Just nonce) tForAuth
+  pure $ (,tToSend) <$> authTransmission thAuth_ False (Just spKey) nonce tForAuth

-testTHandleParams :: ByteString -> THandleParams SMPVersion p
+testTHandleParams :: ByteString -> THandleParams SMPVersion 'TClient
 testTHandleParams sessionId =
  THandleParams
    { sessionId,
@@ -24,10 +24,10 @@ cryptoFileTests = do
  it "should put/read file" testPutReadFile
  it "should fail reading empty or small file" testSmallFile

-testFilePath :: HasTestEnv => FilePath
-testFilePath = testPath "testcryptofile"
+testFilePath :: FilePath
+testFilePath = "tests/tmp/testcryptofile"

-testWriteReadFile :: HasTestEnv => IO ()
+testWriteReadFile :: IO ()
 testWriteReadFile = do
  g <- C.newRandom
  s <- atomically $ LB.fromStrict <$> C.randomBytes 100000 g
@@ -39,7 +39,7 @@ testWriteReadFile = do
    s' <- CF.readFile file
    liftIO $ s `shouldBe` s'

-testPutGetFile :: HasTestEnv => IO ()
+testPutGetFile :: IO ()
 testPutGetFile = do
  g <- C.newRandom
  s <- atomically $ LB.fromStrict <$> C.randomBytes 50000 g
@@ -59,7 +59,7 @@ testPutGetFile = do
      CF.hGetTag h
      liftIO $ (s <> s') `shouldBe` LB.fromStrict (s1 <> s2 <> s3)

-testWriteGetFile :: HasTestEnv => IO ()
+testWriteGetFile :: IO ()
 testWriteGetFile = do
  g <- C.newRandom
  s <- atomically $ LB.fromStrict <$> C.randomBytes 100000 g
@@ -73,7 +73,7 @@ testWriteGetFile = do
      liftIO $ runExceptT (CF.hGetTag h) `shouldReturn` Left FTCEInvalidAuthTag
      liftIO $ s `shouldBe` LB.fromStrict (s' <> s'')

-testPutReadFile :: HasTestEnv => IO ()
+testPutReadFile :: IO ()
 testPutReadFile = do
  g <- C.newRandom
  s <- atomically $ LB.fromStrict <$> C.randomBytes 50000 g
@@ -92,7 +92,7 @@ testPutReadFile = do
    s'' <- CF.readFile file
    liftIO $ (s <> s') `shouldBe` s''

-testSmallFile :: HasTestEnv => IO ()
+testSmallFile :: IO ()
 testSmallFile = do
  g <- C.newRandom
  file <- atomically $ mkCryptoFile g
@@ -101,5 +101,5 @@ testSmallFile = do
  LB.writeFile testFilePath "123"
  runExceptT (CF.readFile file) `shouldReturn` Left FTCEInvalidFileSize

-mkCryptoFile :: HasTestEnv => TVar ChaChaDRG -> STM CryptoFile
+mkCryptoFile :: TVar ChaChaDRG -> STM CryptoFile
 mkCryptoFile g = CryptoFile testFilePath . Just <$> CF.randomArgs g
@@ -6,9 +6,8 @@

 module CoreTests.CryptoTests (cryptoTests) where

-import Control.Concurrent (forkIO, newEmptyMVar, putMVar, takeMVar)
 import Control.Concurrent.STM
-import Control.Exception (bracket, evaluate)
+import Control.Exception (evaluate)
 import Control.Monad.Except
 import qualified Data.Aeson as J
 import qualified Data.ByteString.Char8 as B
@@ -23,12 +22,9 @@ import Data.Time.Clock (UTCTime (..))
 import qualified Data.Text.Lazy as LT
 import qualified Data.Text.Lazy.Encoding as LE
 import Data.Type.Equality
-import Data.Word (Word8)
 import qualified Data.X509 as X
 import qualified Data.X509.CertificateStore as XS
 import qualified Data.X509.Validation as XV
-import Foreign (FunPtr, allocaBytes, fillBytes, freeHaskellFunPtr, nullPtr)
-import Foreign.C.Types (CInt, CSize (..))
 import qualified SMPClient
 import qualified Simplex.Messaging.Crypto as C
 import qualified Simplex.Messaging.Crypto.Lazy as LC
@@ -36,12 +32,9 @@ import Simplex.Messaging.Crypto.BBS
 import Simplex.Messaging.Crypto.Entitlement
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings
 import Simplex.Messaging.Crypto.SNTRUP761.Bindings.Defines
-import Simplex.Messaging.Crypto.SNTRUP761.Bindings.FFI (c_sntrup761_keypair)
-import Simplex.Messaging.Crypto.SNTRUP761.Bindings.RNG (RNGFunc)
 import Simplex.Messaging.Encoding (Large (..), smpDecode, smpEncode)
 import Simplex.Messaging.Encoding.String (strDecode, strEncode)
 import Simplex.Messaging.Transport.Client
-import System.Timeout (timeout)
 import Test.Hspec hiding (fit, it)
 import Test.Hspec.QuickCheck (modifyMaxSuccess)
 import Test.QuickCheck hiding (Large)
@@ -120,7 +113,6 @@ cryptoTests = do
  describe "sntrup761" $ do
    it "should enc/dec key" testSNTRUP761
    it "should reject malformed KEM encodings" testSNTRUP761RejectsMalformedEncodings
-    it "should fail key generation with degenerate RNG" testSNTRUP761KeypairDegenerateRNG
  describe "BBS+" $ do
    it "should sign and verify" testBBSSignVerify
    it "should derive public key from secret key" testBBSPublicKeyDerivation
@@ -146,9 +138,9 @@ instance Eq C.APrivateKey where
    Just Refl -> k == k'
    Nothing -> False

-testPadUnpadFile :: HasTestEnv => IO ()
+testPadUnpadFile :: IO ()
 testPadUnpadFile = do
-  let f = testPath "testpad"
+  let f = "tests/tmp/testpad"
      paddedLen = 1024 * 1024
      len = 1000000
      s = LB.replicate len 'a'
@@ -208,7 +200,7 @@ testLazySecretBoxFile = it "should lazily encrypt / decrypt file with a random s
  g <- C.newRandom
  k <- atomically $ C.randomSbKey g
  nonce <- atomically $ C.randomCbNonce g
-  let f = testPath "testsecretbox"
+  let f = "tests/tmp/testsecretbox"
      paddedLen = 4 * 1024 * 1024
      len = 4 * 1000 * 1000 :: Int64
      s = LC.fastReplicate len 'a'
@@ -236,7 +228,7 @@ testLazySecretBoxFileTailTag = it "should lazily encrypt / decrypt file with a r
  g <- C.newRandom
  k <- atomically $ C.randomSbKey g
  nonce <- atomically $ C.randomCbNonce g
-  let f = testPath "testsecretbox"
+  let f = "tests/tmp/testsecretbox"
      paddedLen = 4 * 1024 * 1024
      len = 4 * 1000 * 1000 :: Int64
      s = LC.fastReplicate len 'a'
@@ -306,26 +298,6 @@ testSNTRUP761 = do
  KEMSharedKey k' <- sntrup761Dec c sk
  k' `shouldBe` k

-foreign import ccall "wrapper"
-  mkRNGFunc :: RNGFunc -> IO (FunPtr RNGFunc)
-
-testSNTRUP761KeypairDegenerateRNG :: IO ()
-testSNTRUP761KeypairDegenerateRNG = do
-  -- constant byte 0 draws invertible g = -(1 + x + ... + x^760), byte 0x20 draws g = 0
-  keypairWithConstantRNG 0 `shouldReturn` Just 0
-  keypairWithConstantRNG 0x20 `shouldReturn` Just (-1)
-  where
-    keypairWithConstantRNG :: Word8 -> IO (Maybe CInt)
-    keypairWithConstantRNG b = do
-      result <- newEmptyMVar
-      -- timeout cannot interrupt a foreign call, so the call runs in another thread
-      _ <- forkIO $
-        bracket (mkRNGFunc $ \_ sz buf -> fillBytes buf b (fromIntegral sz)) freeHaskellFunPtr $ \rng ->
-          allocaBytes c_SNTRUP761_PUBLICKEY_SIZE $ \pkPtr ->
-            allocaBytes c_SNTRUP761_SECRETKEY_SIZE $ \skPtr ->
-              c_sntrup761_keypair pkPtr skPtr nullPtr rng >>= putMVar result
-      timeout 10000000 $ takeMVar result
-
 testSNTRUP761RejectsMalformedEncodings :: IO ()
 testSNTRUP761RejectsMalformedEncodings = do
  smpDecode @KEMPublicKey (smpEncode $ Large shortPublicKey) `shouldSatisfy` isLeft
@@ -34,7 +34,7 @@ import Data.Time.Clock.System (SystemTime (..), getSystemTime)
 import SMPClient (testStoreLogFile, testStoreMsgsDir, testStoreMsgsDir2, testStoreMsgsFile, testStoreMsgsFile2)
 import Simplex.Messaging.Crypto (pattern MaxLenBS)
 import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Protocol (EncDataBytes (..), EntityId (..), ErrorType (..), LinkId, Message (..), QueueLinkData, RecipientId, SParty (..), noMsgFlags, randomMsgId)
+import Simplex.Messaging.Protocol (EntityId (..), ErrorType, LinkId, Message (..), QueueLinkData, RecipientId, SParty (..), noMsgFlags)
 import Simplex.Messaging.Server (exportMessages, importMessages, printMessageStats)
 import Simplex.Messaging.Server.Env.STM (MsgStore (..), journalMsgStoreDepth, readWriteQueueStore)
 import Simplex.Messaging.Server.Expiration (ExpirationConfig (..), expireBeforeEpoch)
@@ -43,7 +43,6 @@ import Simplex.Messaging.Server.MsgStore.STM
 import Simplex.Messaging.Server.MsgStore.Types
 import Simplex.Messaging.Server.QueueStore
 import Simplex.Messaging.Server.QueueStore.QueueInfo
-import Simplex.Messaging.Server.QueueStore.Types
 import Simplex.Messaging.Server.StoreLog (closeStoreLog, logCreateQueue)
 import System.Directory (copyFile, createDirectoryIfMissing, listDirectory, removeFile, renameFile)
 import System.FilePath ((</>))
@@ -58,47 +57,49 @@ import Simplex.Messaging.Agent.Store.Postgres.Common
 import Simplex.Messaging.Agent.Store.Shared (MigrationConfirmation (..))
 import Simplex.Messaging.Server.MsgStore.Postgres
 import Simplex.Messaging.Server.QueueStore.Postgres
-import SMPClient (testStoreDBOpts)
+import Simplex.Messaging.Server.QueueStore.Types
+import SMPClient (postgressBracket, testServerDBConnectInfo, testStoreDBOpts)
 #endif

 msgStoreTests :: Spec
 msgStoreTests = do
-  describe "STM message store" $ someMsgStoreTests testSMTStoreConfig
-  describe "Journal message store" $ do
-    someMsgStoreTests $ testJournalStoreCfg MQStoreCfg
-    journalMsgStoreTests $ testJournalStoreCfg MQStoreCfg
-    it "should export and import journal store" $ withMsgStore (testJournalStoreCfg MQStoreCfg) testExportImportStore
+  around (withMsgStore testSMTStoreConfig) $ describe "STM message store" someMsgStoreTests
+  around (withMsgStore $ testJournalStoreCfg MQStoreCfg) $ describe "Journal message store" $ do
+    someMsgStoreTests
+    journalMsgStoreTests
+    it "should export and import journal store" testExportImportStore
 #if defined(dbServerPostgres)
-  describe "Postgres+journal message store" $ do
-    someMsgStoreTests $ testJournalStoreCfg $ PQStoreCfg testPostgresStoreCfg
-    journalMsgStoreTests $ testJournalStoreCfg $ PQStoreCfg testPostgresStoreCfg
-  describe "Postgres-only message store" $ do
-    someMsgStoreTests testPostgresStoreConfig
-    it "should correctly update message counts and canWrite flag" $ withMsgStore testPostgresStoreConfig testUpdateMessageCounts
-    it "tryDelPeekMsg (ACK not from NSE) should reset message counts when queue is empty" $ withMsgStore testPostgresStoreConfig testResetMessageCounts
-    it "should expire messages across commit batches" $ withMsgStore testPostgresStoreConfig testExpireMessagesInBatches
+  around_ (postgressBracket testServerDBConnectInfo) $ do
+    around (withMsgStore $ testJournalStoreCfg $ PQStoreCfg testPostgresStoreCfg) $
+      describe "Postgres+journal message store" $ do
+        someMsgStoreTests
+        journalMsgStoreTests
+    around (withMsgStore testPostgresStoreConfig) $
+      describe "Postgres-only message store" $ do
+        someMsgStoreTests
+        it "should correctly update message counts and canWrite flag" testUpdateMessageCounts
+        it "tryDelPeekMsg (ACK not from NSE) should reset message counts when queue is empty" testResetMessageCounts
 #endif
  describe "Journal message store: queue state backup expiration" $ do
    it "should remove old queue state backups" testRemoveQueueStateBackups
    it "should expire messages in idle queues" testExpireIdleQueues
  where
-    journalMsgStoreTests :: (HasTestEnv => JournalStoreConfig s) -> Spec
-    journalMsgStoreTests cfg = do
+    journalMsgStoreTests :: SpecWith (JournalMsgStore s)
+    journalMsgStoreTests = do
      describe "queue state" $ do
-        it "should restore queue state from the last line" $ withMsgStore cfg testQueueState
-        it "should recover when message is written and state is not" $ withMsgStore cfg testMessageState
-        it "should remove journal files when queue is empty" $ withMsgStore cfg testRemoveJournals
+        it "should restore queue state from the last line" testQueueState
+        it "should recover when message is written and state is not" testMessageState
+        it "should remove journal files when queue is empty" testRemoveJournals
      describe "missing files" $ do
-        it "should create read file when missing" $ withMsgStore cfg testReadFileMissing
-        it "should switch to write file when read file missing" $ withMsgStore cfg testReadFileMissingSwitch
-        it "should create write file when missing" $ withMsgStore cfg testWriteFileMissing
-        it "should create read file when read and write files are missing" $ withMsgStore cfg testReadAndWriteFilesMissing
-    someMsgStoreTests :: MsgStoreClass s => (HasTestEnv => MsgStoreConfig s) -> Spec
-    someMsgStoreTests cfg = do
-      it "should get queue and store/read messages" $ withMsgStore cfg testGetQueue
-      it "should write/ack messages" $ withMsgStore cfg testWriteAckMessages
-      it "should not fail on EOF when changing read journal" $ withMsgStore cfg testChangeReadJournal
-      it "should not add link data to secured messaging queue" $ withMsgStore cfg testLinkDataSecuredQueue
+        it "should create read file when missing" testReadFileMissing
+        it "should switch to write file when read file missing" testReadFileMissingSwitch
+        it "should create write file when missing" testWriteFileMissing
+        it "should create read file when read and write files are missing" testReadAndWriteFilesMissing
+    someMsgStoreTests :: MsgStoreClass s => SpecWith s
+    someMsgStoreTests = do
+      it "should get queue and store/read messages" testGetQueue
+      it "should write/ack messages" testWriteAckMessages
+      it "should not fail on EOF when changing read journal" testChangeReadJournal

 -- TODO constrain to STM stores?
 withMsgStore :: MsgStoreClass s => MsgStoreConfig s -> (s -> IO ()) -> IO ()
@@ -107,7 +108,7 @@ withMsgStore cfg = bracket (newMsgStore cfg) closeMsgStore
 testSMTStoreConfig :: STMStoreConfig
 testSMTStoreConfig = STMStoreConfig {storePath = Nothing, quota = 3}

-testJournalStoreCfg :: HasTestEnv => QStoreCfg s -> JournalStoreConfig s
+testJournalStoreCfg :: QStoreCfg s -> JournalStoreConfig s
 testJournalStoreCfg queueStoreCfg =
  JournalStoreConfig
    { storePath = testStoreMsgsDir,
@@ -123,14 +124,14 @@ testJournalStoreCfg queueStoreCfg =
    }

 #if defined(dbServerPostgres)
-testPostgresStoreConfig :: HasTestEnv => PostgresMsgStoreCfg
+testPostgresStoreConfig :: PostgresMsgStoreCfg
 testPostgresStoreConfig =
  PostgresMsgStoreCfg
    { queueStoreCfg = testPostgresStoreCfg,
      quota = 3
    }

-testPostgresStoreCfg :: HasTestEnv => PostgresStoreCfg
+testPostgresStoreCfg :: PostgresStoreCfg
 testPostgresStoreCfg =
  PostgresStoreCfg
    { dbOpts = testStoreDBOpts,
@@ -144,7 +145,7 @@ mkMessage :: MonadIO m => ByteString -> m Message
 mkMessage body = liftIO $ do
  g <- C.newRandom
  msgTs <- getSystemTime
-  msgId <- atomically $ randomMsgId 24 g
+  msgId <- atomically $ C.randomBytes 24 g
  pure Message {msgId, msgTs, msgFlags = noMsgFlags, msgBody = C.unsafeMaxLenBS body}

 pattern Msg :: ByteString -> Maybe Message
@@ -265,34 +266,7 @@ testChangeReadJournal ms = do
    (Msg "message 5", Nothing) <- tryDelPeekMsg ms q mId5
    void $ ExceptT $ deleteQueue ms q

-testLinkDataSecuredQueue :: MsgStoreClass s => s -> IO ()
-testLinkDataSecuredQueue ms = do
-  g <- C.newRandom
-  (sKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-  let st = queueStore ms
-      ld = (EncDataBytes "fixed data", EncDataBytes "user data")
-      rndId = atomically $ EntityId <$> C.randomBytes 24 g
-  (rId, qr) <- testNewQueueRec g QMMessaging
-  (cId, cqr) <- testNewQueueRec g QMContact
-  lnkId <- rndId
-  cLnkId <- rndId
-  runRight_ $ do
-    q <- ExceptT $ addQueue ms rId qr
-    -- the handle is read before SKEY, as in a command that raced with it
-    staleQ <- ExceptT $ getQueue ms SRecipient rId
-    ExceptT $ secureQueue st q sKey
-    liftIO $ addQueueLinkData st staleQ lnkId ld `shouldReturn` Left AUTH
-    freshQ <- ExceptT $ getQueue ms SRecipient rId
-    liftIO $ getQueueLinkData st freshQ lnkId `shouldReturn` Left AUTH
-    cq <- ExceptT $ addQueue ms cId cqr
-    ExceptT $ secureQueue st cq sKey
-    ExceptT $ addQueueLinkData st cq cLnkId ld
-    ld' <- ExceptT $ getQueueLinkData st cq cLnkId
-    liftIO $ ld' `shouldBe` ld
-    void $ ExceptT $ deleteQueue ms q
-    void $ ExceptT $ deleteQueue ms cq
-
-testExportImportStore :: HasTestEnv => JournalMsgStore 'QSMemory -> IO ()
+testExportImportStore :: JournalMsgStore 'QSMemory -> IO ()
 testExportImportStore ms = do
  g <- C.newRandom
  (rId1, qr1) <- testNewQueueRec g QMMessaging
@@ -353,34 +327,35 @@ testUpdateMessageCounts ms = do
    q <- ExceptT $ addQueue ms rId qr
    let write s = writeMsg ms q True =<< mkMessage s
        hasSize = checkQueueSize ms
-    q `hasSize` (0, True)
+    q `hasSize` (0, True, False)
    Just (Message {msgId = mId1}, True) <- write "message 1"
-    q `hasSize` (1, True)
+    q `hasSize` (1, True, True)
    Just (Message {msgId = mId2}, False) <- write "message 2"
-    q `hasSize` (2, True)
+    q `hasSize` (2, True, True)
    Just (Message {msgId = mId3}, False) <- write "message 3"
-    q `hasSize` (3, True)
+    q `hasSize` (3, True, True)
    Nothing <- write "message 4"
-    q `hasSize` (4, False)
+    q `hasSize` (4, False, True)
    Msg "message 1" <- tryPeekMsg ms q
-    q `hasSize` (4, False)
+    q `hasSize` (4, False, True)
    Msg "message 1" <- tryDelMsg ms q mId1
-    q `hasSize` (3, False)
+    q `hasSize` (3, False, True)
    Msg "message 2" <- tryPeekMsg ms q
    (Msg "message 2", Msg "message 3") <- tryDelPeekMsg ms q mId2
-    q `hasSize` (2, False)
+    q `hasSize` (2, False, True)
    (Msg "message 3", Just MessageQuota {msgId = mId4}) <- tryDelPeekMsg ms q mId3
-    q `hasSize` (1, False)
+    q `hasSize` (1, False, True)
    (Just MessageQuota {}, Nothing) <- tryDelPeekMsg ms q mId4
-    q `hasSize` (0, True)
+    q `hasSize` (0, True, False)

-checkQueueSize :: PostgresMsgStore -> PostgresQueue -> (Int64, Bool) -> ExceptT ErrorType IO ()
-checkQueueSize ms q (size, canWrt) = liftIO $ do
-  [(size', canWrt')] <-
+checkQueueSize :: PostgresMsgStore -> PostgresQueue -> (Int64, Bool, Bool) -> ExceptT ErrorType IO ()
+checkQueueSize ms q (size, canWrt, expire) = liftIO $ do
+  [(size', canWrt', expire')] <-
    withTransaction (dbStore $ queueStore ms) $ \db ->
-      DB.query db "SELECT msg_queue_size, msg_can_write FROM msg_queues WHERE recipient_id = ?" (Only (recipientId q))
+      DB.query db "SELECT msg_queue_size, msg_can_write, msg_queue_expire FROM msg_queues WHERE recipient_id = ?" (Only (recipientId q))
  size' `shouldBe` size
  canWrt' `shouldBe` canWrt
+  expire' `shouldBe` expire

 testResetMessageCounts :: PostgresMsgStore -> IO ()
 testResetMessageCounts ms = do
@@ -394,63 +369,25 @@ testResetMessageCounts ms = do
    Just (Message {msgId = mId2}, False) <- write "message 2"
    Just (Message {msgId = mId3}, False) <- write "message 3"
    Nothing <- write "message 4"
-    q `hasSize` (4, False)
+    q `hasSize` (4, False, True)
    liftIO $ setIncorrectSize q (10, True)
    Nothing <- write "message 5"
-    q `hasSize` (11, False)
+    q `hasSize` (11, False, True)
    (Msg "message 1", Msg "message 2") <- tryDelPeekMsg ms q mId1
-    q `hasSize` (10, False)
+    q `hasSize` (10, False, True)
    (Msg "message 2", Msg "message 3") <- tryDelPeekMsg ms q mId2
-    q `hasSize` (9, False)
+    q `hasSize` (9, False, True)
    (Msg "message 3", Just MessageQuota {msgId = mId4}) <- tryDelPeekMsg ms q mId3
-    q `hasSize` (8, False)
+    q `hasSize` (8, False, True)
    (Just MessageQuota {}, Just MessageQuota {msgId = mId5}) <- tryDelPeekMsg ms q mId4
-    q `hasSize` (7, False)
+    q `hasSize` (7, False, True)
    (Just MessageQuota {}, Nothing) <- tryDelPeekMsg ms q mId5
-    q `hasSize` (0, True) -- reset
+    q `hasSize` (0, True, False) -- reset
  where
    setIncorrectSize :: PostgresQueue -> (Int64, Bool) -> IO ()
    setIncorrectSize q (size, canWrt) =
      void $ withTransaction (dbStore $ queueStore ms) $ \db ->
        DB.execute db "UPDATE msg_queues SET msg_queue_size = ?, msg_can_write = ? WHERE recipient_id = ?" (size, canWrt, recipientId q)
-
-testExpireMessagesInBatches :: PostgresMsgStore -> IO ()
-testExpireMessagesInBatches ms = do
-  g <- C.newRandom
-  emptiedQs <- replicateM emptiedCount $ newQueue g
-  partialQs <- replicateM partialCount $ newQueue g
-  overQuotaQs <- replicateM overQuotaCount $ newQueue g
-  quotaMsgs <- runRight $ do
-    forM_ (emptiedQs <> partialQs) $ \q -> void $ write q "old 1"
-    forM_ emptiedQs $ \q -> void $ write q "old 2"
-    mapM fillPastQuota overQuotaQs
-  -- msg_ts has second granularity, so the recent messages need a new second to be kept
-  threadDelay 1100000
-  boundary <- systemSeconds <$> getSystemTime
-  runRight_ $ forM_ partialQs $ \q -> void $ write q "recent"
-
-  MessageStats {expiredMsgsCount, storedMsgsCount, storedQueues} <- expireOldMessages False ms boundary 0
-  expiredMsgsCount `shouldBe` (emptiedCount * 2 + partialCount + sum quotaMsgs)
-  storedMsgsCount `shouldBe` (partialCount + overQuotaCount) -- recent messages and quota markers
-  storedQueues `shouldBe` (emptiedCount + partialCount + overQuotaCount)
-  runRight_ $ do
-    forM_ emptiedQs $ \q -> checkQueueSize ms q (0, True)
-    forM_ partialQs $ \q -> checkQueueSize ms q (1, True)
-    -- the quota marker is never expired, and the queue stays blocked until it is acked
-    forM_ overQuotaQs $ \q -> checkQueueSize ms q (1, False)
-  where
-    -- expire_old_messages pages through expired messages and commits per page, so these
-    -- counts put a page boundary inside each group of queues.
-    emptiedCount = 120 :: Int
-    partialCount = 40 :: Int
-    overQuotaCount = 10 :: Int
-    newQueue g = do
-      (rId, qr) <- testNewQueueRec g QMMessaging
-      runRight $ ExceptT $ addQueue ms rId qr
-    write q s = writeMsg ms q True =<< mkMessage s
-    fillPastQuota q = go 0
-      where
-        go n = write q "fill" >>= maybe (pure n) (const $ go (n + 1))
 #endif

 testQueueState :: JournalMsgStore s -> IO ()
@@ -605,7 +542,7 @@ testRemoveJournals ms = do
    journalFilesCount dir = length . filter ("messages." `isPrefixOf`) <$> listDirectory dir
    stateBackupCount dir = length . filter (".bak" `isSuffixOf`) <$> listDirectory dir

-testRemoveQueueStateBackups :: HasTestEnv => IO ()
+testRemoveQueueStateBackups :: IO ()
 testRemoveQueueStateBackups = do
  g <- C.newRandom
  (rId, qr) <- testNewQueueRec g QMMessaging
@@ -641,7 +578,7 @@ testRemoveQueueStateBackups = do
  where
    stateBackupCount dir = length . filter (".bak" `isSuffixOf`) <$> listDirectory dir

-testExpireIdleQueues :: HasTestEnv => IO ()
+testExpireIdleQueues :: IO ()
 testExpireIdleQueues = do
  g <- C.newRandom
  (rId, qr) <- testNewQueueRec g QMMessaging
@@ -2,18 +2,15 @@
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedLists #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE TypeApplications #-}
 {-# OPTIONS_GHC -fno-warn-ambiguous-fields #-}

 module CoreTests.SOCKSSettings where

 import Network.Socket (SockAddr (..), tupleToHostAddress)
-import Simplex.Messaging.Agent.Client (ipAddressProtected)
 import Simplex.Messaging.Client
-import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String
-import Simplex.Messaging.Protocol (ErrorType, pattern SMPServer)
+import Simplex.Messaging.Protocol (ErrorType)
 import Simplex.Messaging.Transport.Client
 import Test.Hspec hiding (fit, it)
 import Util
@@ -22,7 +19,6 @@ socksSettingsTests :: Spec
 socksSettingsTests = do
  describe "hostMode and requiredHostMode settings" testHostMode
  describe "socksMode setting, independent of hostMode setting" testSocksMode
-  describe "ipAddressProtected, consistent with chosen host and socksMode" testIPAddressProtected
  describe "socks proxy address encoding" testSocksProxyEncoding

 testPublicHost :: TransportHost
@@ -98,19 +94,6 @@ testSocksMode = do
      let TransportClientConfig {socksProxy} = transportClientConfig cfg NRMInteractive host False Nothing
       in socksProxy

-testIPAddressProtected :: Spec
-testIPAddressProtected = do
-  it "should be protected if SOCKS proxy is used for the chosen host" $ do
-    protected SMAlways HMOnionViaSocks [testPublicHost] `shouldBe` True
-    protected SMOnion HMOnionViaSocks [testPublicHost, testOnionHost] `shouldBe` True
-    protected SMOnion HMPublic [testOnionHost] `shouldBe` True
-  it "should not be protected if SOCKS proxy is not used for the chosen host" $ do
-    protected SMOnion HMOnionViaSocks [testPublicHost] `shouldBe` False
-    protected SMOnion HMPublic [testPublicHost, testOnionHost] `shouldBe` False
-  where
-    protected socksMode hostMode hosts =
-      ipAddressProtected defaultNetworkConfig {socksProxy = Just defaultSocksProxyWithAuth, socksMode, hostMode} (SMPServer hosts "" (C.KeyHash ""))
-
 testSocksProxyEncoding :: Spec
 testSocksProxyEncoding = do
  it "should decode SOCKS proxy with isolate-by-auth mode" $ do
@@ -177,10 +177,10 @@ testSMPStoreLog testSuite tests =
    closeStoreLog l
    replicateM_ 3 $ testReadWrite t
 #if defined(dbServerPostgres)
-    (sCnt, qCnt) <- importStoreLogToDatabase testDir testStoreLogFile testStoreDBOpts
+    (sCnt, qCnt) <- importStoreLogToDatabase "tests/tmp/" testStoreLogFile testStoreDBOpts
    fromIntegral (sCnt + qCnt) `shouldBe` length (compacted t)
    imported <- B.readFile $ testStoreLogFile <> ".bak"
-    (sCnt', qCnt') <- exportDatabaseToStoreLog testDir testStoreDBOpts testStoreLogFile
+    (sCnt', qCnt') <- exportDatabaseToStoreLog "tests/tmp/" testStoreDBOpts testStoreLogFile
    sCnt' `shouldBe` fromIntegral sCnt
    qCnt' `shouldBe` fromIntegral qCnt
    exported <- B.readFile testStoreLogFile
@@ -207,8 +207,8 @@ deriving instance Eq FileRecipient

 deriving instance Eq FileStoreLogRecord

-testFileStoreLogFile :: HasTestEnv => FilePath
-testFileStoreLogFile = testPath "xftp-server-store.log"
+testFileStoreLogFile :: FilePath
+testFileStoreLogFile = "tests/tmp/xftp-server-store.log"

 fileExpirationTests :: Spec
 fileExpirationTests =
@@ -47,7 +47,7 @@ xftpMigrationTests = describe "XFTP migration round-trip" $ do

 -- Test helpers

-withPgStore :: HasTestEnv => (PostgresFileStore -> IO ()) -> IO ()
+withPgStore :: (PostgresFileStore -> IO ()) -> IO ()
 withPgStore test = do
  st <- newFileStore testXFTPPostgresCfg :: IO PostgresFileStore
  test st
@@ -75,7 +75,7 @@ testExpiresAt = RoundedSystemTime 2000000

 -- Tests

-testAddGetFileSender :: HasTestEnv => Expectation
+testAddGetFileSender :: Expectation
 testAddGetFileSender = withPgStore $ \st -> do
  g <- C.newRandom
  (sk, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -91,7 +91,7 @@ testAddGetFileSender = withPgStore $ \st -> do
      key `shouldBe` sk
    Left e -> expectationFailure $ "getFile failed: " <> show e

-testAddGetFileRecipient :: HasTestEnv => Expectation
+testAddGetFileRecipient :: Expectation
 testAddGetFileRecipient = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -106,7 +106,7 @@ testAddGetFileRecipient = withPgStore $ \st -> do
      key `shouldBe` rcpKey
    Left e -> expectationFailure $ "getFile failed: " <> show e

-testDuplicateFile :: HasTestEnv => Expectation
+testDuplicateFile :: Expectation
 testDuplicateFile = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -114,12 +114,12 @@ testDuplicateFile = withPgStore $ \st -> do
  addFile st testSenderId fileInfo testCreatedAt Nothing EntityActive `shouldReturn` Right ()
  addFile st testSenderId fileInfo testCreatedAt Nothing EntityActive `shouldReturn` Left DUPLICATE_

-testGetNonexistent :: HasTestEnv => Expectation
+testGetNonexistent :: Expectation
 testGetNonexistent = withPgStore $ \st -> do
  getFile st SFSender testSenderId >>= (`shouldBe` Left AUTH) . fmap (const ())
  getFile st SFRecipient testRecipientId >>= (`shouldBe` Left AUTH) . fmap (const ())

-testSetFilePath :: HasTestEnv => Expectation
+testSetFilePath :: Expectation
 testSetFilePath = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -134,7 +134,7 @@ testSetFilePath = withPgStore $ \st -> do
    Right (FileRec {filePath}, _) -> readTVarIO filePath `shouldReturn` Just "/tmp/test_file"
    Left e -> expectationFailure $ "getFile failed: " <> show e

-testDuplicateRecipient :: HasTestEnv => Expectation
+testDuplicateRecipient :: Expectation
 testDuplicateRecipient = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -144,7 +144,7 @@ testDuplicateRecipient = withPgStore $ \st -> do
  addRecipient st testSenderId (FileRecipient testRecipientId rcpKey) `shouldReturn` Right ()
  addRecipient st testSenderId (FileRecipient testRecipientId rcpKey) `shouldReturn` Left DUPLICATE_

-testDeleteFileCascade :: HasTestEnv => Expectation
+testDeleteFileCascade :: Expectation
 testDeleteFileCascade = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -157,7 +157,7 @@ testDeleteFileCascade = withPgStore $ \st -> do
  getFile st SFSender testSenderId >>= (`shouldBe` Left AUTH) . fmap (const ())
  getFile st SFRecipient testRecipientId >>= (`shouldBe` Left AUTH) . fmap (const ())

-testBlockFile :: HasTestEnv => Expectation
+testBlockFile :: Expectation
 testBlockFile = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -170,7 +170,7 @@ testBlockFile = withPgStore $ \st -> do
    Right (FileRec {fileStatus}, _) -> readTVarIO fileStatus `shouldReturn` EntityBlocked blockInfo
    Left e -> expectationFailure $ "getFile failed: " <> show e

-testAckFile :: HasTestEnv => Expectation
+testAckFile :: Expectation
 testAckFile = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -186,7 +186,7 @@ testAckFile = withPgStore $ \st -> do
    Right _ -> pure ()
    Left e -> expectationFailure $ "getFile failed: " <> show e

-testExpiredFiles :: HasTestEnv => Expectation
+testExpiredFiles :: Expectation
 testExpiredFiles = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -207,7 +207,7 @@ testExpiredFiles = withPgStore $ \st -> do
      sz `shouldBe` 128000
    _ -> expectationFailure "expected 1 expired file"

-testExpiredFilesStoredExpiration :: HasTestEnv => Expectation
+testExpiredFilesStoredExpiration :: Expectation
 testExpiredFilesStoredExpiration = withPgStore $ \st -> do
  g <- C.newRandom
  (sndKey, _) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -219,7 +219,7 @@ testExpiredFilesStoredExpiration = withPgStore $ \st -> do
  expired <- expiredFiles st (RoundedSystemTime 500000) 0 100
  map (\(sId, _, _) -> sId) expired `shouldBe` [EntityId "expired_file____"]

-testStorageAndCount :: HasTestEnv => Expectation
+testStorageAndCount :: Expectation
 testStorageAndCount = withPgStore $ \st -> do
  testStorageAndCountForStore st

@@ -250,10 +250,10 @@ testStorageAndCountForStore st = do

 -- Migration round-trip test

-testMigrationRoundTrip :: HasTestEnv => Expectation
+testMigrationRoundTrip :: Expectation
 testMigrationRoundTrip = do
-  let storeLogPath = testPath "xftp-migration-test.log"
-      storeLogPath2 = testPath "xftp-migration-test2.log"
+  let storeLogPath = "tests/tmp/xftp-migration-test.log"
+      storeLogPath2 = "tests/tmp/xftp-migration-test2.log"
  -- 1. Create STM store with test data
  stmStore <- newFileStore () :: IO STMFileStore
  g <- C.newRandom
@@ -33,8 +33,8 @@ fileDescriptionTests = do
 fileDescPath :: FilePath
 fileDescPath = "tests/fixtures/file_description.yaml"

-tmpFileDescPath :: HasTestEnv => FilePath
-tmpFileDescPath = testPath "file_description.yaml"
+tmpFileDescPath :: FilePath
+tmpFileDescPath = "tests/tmp/file_description.yaml"

 testSbKey :: C.SbKey
 testSbKey = either error id $ strDecode "00n8p1tJq5E-SGnHcYTOrS4A9I07gTA_WFD6MTFFFOY="
@@ -144,7 +144,7 @@ testParseYAMLFileDescription = do
  yfd <- Y.decodeFileThrow fileDescPath
  yfd `shouldBe` yamlFileDesc

-testSerializeYAMLFileDescription :: HasTestEnv => IO ()
+testSerializeYAMLFileDescription :: IO ()
 testSerializeYAMLFileDescription = withRemoveTmpFile $ do
  Y.encodeFile tmpFileDescPath yamlFileDesc
  fdSer <- B.readFile tmpFileDescPath
@@ -158,7 +158,7 @@ testParseFileDescription = do
    Left e -> expectationFailure $ show e
    Right fd -> fd `shouldBe` fileDesc

-testSerializeFileDescription :: HasTestEnv => IO ()
+testSerializeFileDescription :: IO ()
 testSerializeFileDescription = withRemoveTmpFile $ do
  B.writeFile tmpFileDescPath $ strEncode fileDesc
  fdSer <- B.readFile tmpFileDescPath
@@ -177,7 +177,7 @@ testFileDescriptionURIExtras = do
  let descr = FileDescriptionURI SSSimplex vfd $ Just "{\"something\":\"extra\",\"more\":true}"
  strDecode (strEncode descr) `shouldBe` Right descr

-withRemoveTmpFile :: HasTestEnv => IO () -> IO ()
+withRemoveTmpFile :: IO () -> IO ()
 withRemoveTmpFile =
  bracket_
    (pure ())
@@ -30,7 +30,6 @@ import SMPClient (AServerConfig (..), cfgMS, proxyCfgMS, testStoreLogFile2, test
 import Simplex.Messaging.Server.Env.STM (AStoreType (..), ServerConfig (..), ServerStoreCfg (..), StorePaths (..))
 import Simplex.Messaging.Server.MsgStore.Types (SMSType (..), SQSType (..))
 import Simplex.Messaging.Server.Names (NamesConfig (..))
-import Util (HasTestEnv)

 -- | Run an action with a local HTTP resolver on a free port.
 withResolverServer :: ([Text] -> (Status, LB.ByteString)) -> (Int -> IORef [[Text]] -> IO a) -> IO a
@@ -65,13 +64,13 @@ testNamesConfig port =
      resolverMaxResponseBytes = 65536
    }

-memCfg :: HasTestEnv => AServerConfig
+memCfg :: AServerConfig
 memCfg = cfgMS (ASType SQSMemory SMSMemory)

-memProxyCfg :: HasTestEnv => AServerConfig
+memProxyCfg :: AServerConfig
 memProxyCfg = proxyCfgMS (ASType SQSMemory SMSMemory)

-memCfg2 :: HasTestEnv => AServerConfig
+memCfg2 :: AServerConfig
 memCfg2 = case memCfg of
  ASrvCfg qt mt c -> ASrvCfg qt mt c {serverStoreCfg = newStoreCfg (serverStoreCfg c)}
  where
@@ -60,31 +60,30 @@ import UnliftIO.Async
 import UnliftIO.Concurrent
 import qualified UnliftIO.Exception as E
 import UnliftIO.STM
-import Util

 testHost :: NonEmpty TransportHost
 testHost = "localhost"

-apnsTestPort :: HasTestEnv => ServiceName
-apnsTestPort = testServerPort 5
+apnsTestPort :: ServiceName
+apnsTestPort = "6010"

 testKeyHash :: C.KeyHash
 testKeyHash = "LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI="

-ntfTestStoreLogFile :: HasTestEnv => FilePath
-ntfTestStoreLogFile = testPath "ntf-server-store.log"
+ntfTestStoreLogFile :: FilePath
+ntfTestStoreLogFile = "tests/tmp/ntf-server-store.log"

-ntfTestStoreLogFile2 :: HasTestEnv => FilePath
-ntfTestStoreLogFile2 = testPath "ntf-server-store.log.2"
+ntfTestStoreLogFile2 :: FilePath
+ntfTestStoreLogFile2 = "tests/tmp/ntf-server-store.log.2"

-ntfTestStoreLastNtfsFile :: HasTestEnv => FilePath
-ntfTestStoreLastNtfsFile = testPath "ntf-server-last-notifications.log"
+ntfTestStoreLastNtfsFile :: FilePath
+ntfTestStoreLastNtfsFile = "tests/tmp/ntf-server-last-notifications.log"

-ntfTestPrometheusMetricsFile :: HasTestEnv => FilePath
-ntfTestPrometheusMetricsFile = testPath "ntf-server-metrics.txt"
+ntfTestPrometheusMetricsFile :: FilePath
+ntfTestPrometheusMetricsFile = "tests/tmp/ntf-server-metrics.txt"

-ntfTestServerDBOpts :: DBOpts
-ntfTestServerDBOpts =
+ntfTestStoreDBOpts :: DBOpts
+ntfTestStoreDBOpts =
  DBOpts
    { connstr = ntfTestServerDBConnstr,
      schema = "ntf_server",
@@ -92,11 +91,8 @@ ntfTestServerDBOpts =
      createSchema = True
    }

-ntfTestStoreDBOpts :: HasTestEnv => DBOpts
-ntfTestStoreDBOpts = ntfTestServerDBOpts {schema = testSchemaName "ntf_server"}
-
-ntfTestStoreDBOpts2 :: HasTestEnv => DBOpts
-ntfTestStoreDBOpts2 = ntfTestStoreDBOpts {schema = testSchemaName "smp_server2"}
+ntfTestStoreDBOpts2 :: DBOpts
+ntfTestStoreDBOpts2 = ntfTestStoreDBOpts {schema = "smp_server2"}

 ntfTestServerDBConnstr :: ByteString
 ntfTestServerDBConnstr = "postgresql://ntf_test_server_user@/ntf_test_server_db"
@@ -108,7 +104,7 @@ ntfTestServerDBConnectInfo =
      connectDatabase = "ntf_test_server_db"
    }

-ntfTestDBCfg :: HasTestEnv => PostgresStoreCfg
+ntfTestDBCfg :: PostgresStoreCfg
 ntfTestDBCfg =
  PostgresStoreCfg
    { dbOpts = ntfTestStoreDBOpts,
@@ -117,10 +113,10 @@ ntfTestDBCfg =
      deletedTTL = 86400
    }

-ntfTestDBCfg2 :: HasTestEnv => PostgresStoreCfg
+ntfTestDBCfg2 :: PostgresStoreCfg
 ntfTestDBCfg2 = ntfTestDBCfg {dbOpts = ntfTestStoreDBOpts2, dbStoreLogPath = Just ntfTestStoreLogFile2}

-testNtfClient :: (HasTestEnv, Transport c) => (THandleNTF c 'TClient -> IO a) -> IO a
+testNtfClient :: Transport c => (THandleNTF c 'TClient -> IO a) -> IO a
 testNtfClient client = do
  Right host <- pure $ chooseTransportHost defaultNetworkConfig testHost
  runTransportClient defaultTransportClientConfig Nothing host ntfTestPort (Just testKeyHash) $ \h ->
@@ -128,7 +124,7 @@ testNtfClient client = do
      Right th -> client th
      Left e -> error $ show e

-ntfServerCfg :: HasTestEnv => NtfServerConfig
+ntfServerCfg :: NtfServerConfig
 ntfServerCfg =
  NtfServerConfig
    { transports = [],
@@ -155,7 +151,7 @@ ntfServerCfg =
      -- stats config
      logStatsInterval = Nothing,
      logStatsStartTime = 0,
-      serverStatsLogFile = testPath "ntf-server-stats.daily.log",
+      serverStatsLogFile = "tests/ntf-server-stats.daily.log",
      serverStatsBackupFile = Nothing,
      prometheusInterval = Nothing,
      prometheusMetricsFile = ntfTestPrometheusMetricsFile,
@@ -175,7 +171,7 @@ ntfServerCfg =
 --     smpCfg' = smpCfg smpAgentCfg'
 --     serverVRange' = serverVRange smpCfg'

-withNtfServerThreadOn :: (HasCallStack, HasTestEnv) => ASrvTransport -> ServiceName -> PostgresStoreCfg -> (HasCallStack => ThreadId -> IO a) -> IO a
+withNtfServerThreadOn :: HasCallStack => ASrvTransport -> ServiceName -> PostgresStoreCfg -> (HasCallStack => ThreadId -> IO a) -> IO a
 withNtfServerThreadOn t port' dbStoreConfig =
  withNtfServerCfg ntfServerCfg {transports = [(port', t, False)], dbStoreConfig}

@@ -188,18 +184,18 @@ withNtfServerCfg cfg@NtfServerConfig {transports} =
        (\started -> runNtfServerBlocking started cfg)
        (pure ())

-withNtfServerOn :: (HasCallStack, HasTestEnv) => ASrvTransport -> ServiceName -> PostgresStoreCfg -> (HasCallStack => IO a) -> IO a
+withNtfServerOn :: HasCallStack => ASrvTransport -> ServiceName -> PostgresStoreCfg -> (HasCallStack => IO a) -> IO a
 withNtfServerOn t port' dbStoreConfig = withNtfServerThreadOn t port' dbStoreConfig . const

-withNtfServer :: (HasCallStack, HasTestEnv) => ASrvTransport -> (HasCallStack => IO a) -> IO a
+withNtfServer :: HasCallStack => ASrvTransport -> (HasCallStack => IO a) -> IO a
 withNtfServer t = withNtfServerOn t ntfTestPort ntfTestDBCfg

-runNtfTest :: forall c a. (HasTestEnv, Transport c) => (THandleNTF c 'TClient -> IO a) -> IO a
+runNtfTest :: forall c a. Transport c => (THandleNTF c 'TClient -> IO a) -> IO a
 runNtfTest test = withNtfServer (transport @c) $ testNtfClient test

 ntfServerTest ::
  forall c smp.
-  (HasTestEnv, Transport c, Encoding smp) =>
+  (Transport c, Encoding smp) =>
  TProxy c 'TServer ->
  (Maybe TAuthorizations, ByteString, ByteString, smp) ->
  IO (Maybe TAuthorizations, ByteString, ByteString, NtfResponse)
@@ -214,7 +210,7 @@ ntfServerTest _ t = runNtfTest $ \h -> tPut' h t >> tGet' h
      [(CorrId corrId, EntityId qId, Right cmd)] <- tGetClient h
      pure (Nothing, corrId, qId, cmd)

-ntfTest :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleNTF c 'TClient -> IO ()) -> Expectation
+ntfTest :: Transport c => TProxy c 'TServer -> (THandleNTF c 'TClient -> IO ()) -> Expectation
 ntfTest _ test' = runNtfTest test' `shouldReturn` ()

 data APNSMockRequest = APNSMockRequest
@@ -229,7 +225,7 @@ data APNSMockServer = APNSMockServer
    http2Server :: HTTP2Server
  }

-apnsMockServerConfig :: HasTestEnv => HTTP2ServerConfig
+apnsMockServerConfig :: HTTP2ServerConfig
 apnsMockServerConfig =
  HTTP2ServerConfig
    { qSize = 2,
@@ -246,7 +242,7 @@ apnsMockServerConfig =
      transportConfig = mkTransportServerConfig True Nothing False
    }

-withAPNSMockServer :: HasTestEnv => (APNSMockServer -> IO a) -> IO a
+withAPNSMockServer :: (APNSMockServer -> IO a) -> IO a
 withAPNSMockServer = E.bracket (getAPNSMockServer apnsMockServerConfig) closeAPNSMockServer

 deriving instance Generic APNSAlertBody
@@ -69,13 +69,13 @@ ntfSyntaxTests (ATransport t) = do
    it "token ID" $ (sampleSig, "abcd", "12345678", (TNEW_, ' ', ('T', 'A', 'T', "abcd" :: ByteString), samplePubKey, sampleDhPubKey)) >#> ("", "abcd", "12345678", NRErr $ CMD HAS_AUTH)
  where
    (>#>) ::
-      (HasTestEnv, Encoding smp) =>
+      Encoding smp =>
      (Maybe TAuthorizations, ByteString, ByteString, smp) ->
      (Maybe TAuthorizations, ByteString, ByteString, NtfResponse) ->
      Expectation
    command >#> response = withAPNSMockServer $ \_ -> ntfServerTest t command `shouldReturn` response

-testApnsTestProviderRejected :: HasTestEnv => ASrvTransport -> Expectation
+testApnsTestProviderRejected :: ASrvTransport -> Expectation
 testApnsTestProviderRejected (ATransport (t :: TProxy c 'TServer)) = do
  g <- C.newRandom
  (tknPub, tknKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -136,7 +136,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          let dhSecret = C.dh' ntfDh dhPriv
              decryptCode nd =
                let Right verification = nd .-> "verification"
-                    Right nonce = C.cbNonce =<< nd .-> "nonce"
+                    Right nonce = C.cbNonce <$> nd .-> "nonce"
                    Right pt = C.cbDecrypt dhSecret nonce verification
                 in NtfRegCode pt
          let code = decryptCode ntfData
@@ -160,7 +160,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          -- receive notification
          APNSMockRequest {notification} <- getMockNotification apns tkn
          let APNSNotification {aps = APNSMutableContent {}, notificationData = Just ntfData'} = notification
-              Right nonce' = C.cbNonce =<< ntfData' .-> "nonce"
+              Right nonce' = C.cbNonce <$> ntfData' .-> "nonce"
              Right message = ntfData' .-> "message"
              Right ntfDataDecrypted = C.cbDecrypt dhSecret nonce' message
              Right pnMsgs1 = parse pnMessagesP (AP.INTERNAL "error parsing PNMessageData") ntfDataDecrypted
@@ -171,7 +171,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          notifierId `shouldBe` nId
          -- receive message
          Resp "" _ (MSG RcvMessage {msgId = mId1, msgBody = EncRcvMsgBody body}) <- tGet1 rh
-          Right ClientRcvMsgBody {msgTs = mTs, msgBody} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret mId1 body)
+          Right ClientRcvMsgBody {msgTs = mTs, msgBody} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret (C.cbNonce mId1) body)
          mId1 `shouldBe` msgId
          mTs `shouldBe` msgTs
          (msgBody, "hello") #== "delivered from queue"
@@ -183,7 +183,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          APNSMockRequest {notification = APNSNotification {aps = APNSBackground _, notificationData = Just ntfData2}} <-
            getMockNotification apns tkn'
          let Right verification2 = ntfData2 .-> "verification"
-              Right nonce2 = C.cbNonce =<< ntfData2 .-> "nonce"
+              Right nonce2 = C.cbNonce <$> ntfData2 .-> "nonce"
              Right code2 = NtfRegCode <$> C.cbDecrypt dhSecret nonce2 verification2
          RespNtf "8" _ NROk <- signSendRecvNtf nh tknKey ("8", tId, TVFY code2)
          RespNtf "8a" _ (NRTkn NTActive) <- signSendRecvNtf nh tknKey ("8a", tId, TCHK)
@@ -191,7 +191,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          Resp "9" _ OK <- signSendRecv sh sKey ("9", sId, _SEND' "hello 2")
          APNSMockRequest {notification = notification3} <- getMockNotification apns tkn'
          let APNSNotification {aps = APNSMutableContent {}, notificationData = Just ntfData3} = notification3
-              Right nonce3 = C.cbNonce =<< ntfData3 .-> "nonce"
+              Right nonce3 = C.cbNonce <$> ntfData3 .-> "nonce"
              Right message3 = ntfData3 .-> "message"
              Right ntfDataDecrypted3 = C.cbDecrypt dhSecret nonce3 message3
              Right pnMsgs2 = parse pnMessagesP (AP.INTERNAL "error parsing PNMessageData") ntfDataDecrypted3
@@ -199,7 +199,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          smpServer3 `shouldBe` srv
          notifierId3 `shouldBe` nId
          Resp "" _ (MSG RcvMessage {msgId = mId2, msgBody = EncRcvMsgBody body2}) <- tGet1 rh
-          Right ClientRcvMsgBody {msgBody = "hello 2"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret mId2 body2)
+          Right ClientRcvMsgBody {msgBody = "hello 2"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret (C.cbNonce mId2) body2)
          Resp "10" _ OK <- signSendRecv rh rKey ("10", rId, ACK mId2)

          q2 <- createQueue rh sPub nPub
@@ -218,7 +218,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          Resp "14" _ OK <- signSendRecv sh sKey ("14", sId, _SEND' "hello 3")
          APNSMockRequest {notification = notification4} <- getMockNotification apns tkn'
          let APNSNotification {aps = APNSMutableContent {}, notificationData = Just ntfData4} = notification4
-              Right nonce4 = C.cbNonce =<< ntfData4 .-> "nonce"
+              Right nonce4 = C.cbNonce <$> ntfData4 .-> "nonce"
              Right message4 = ntfData4 .-> "message"
              Right ntfDataDecrypted4 = C.cbDecrypt dhSecret nonce4 message4
              Right pnMsgs4 = parse pnMessagesP (AP.INTERNAL "error parsing PNMessageData") ntfDataDecrypted4
@@ -226,14 +226,14 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          smpServer4 `shouldBe` srv
          notifierId4 `shouldBe` nId
          Resp "" _ (MSG RcvMessage {msgId = mId3, msgBody = EncRcvMsgBody body3}) <- tGet1 rh
-          Right ClientRcvMsgBody {msgBody = "hello 3"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret mId3 body3)
+          Right ClientRcvMsgBody {msgBody = "hello 3"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret (C.cbNonce mId3) body3)
          Resp "15" _ OK <- signSendRecv rh rKey ("15", rId, ACK mId3)

          -- deliver to queue with ntf sub created while SMP was offline
          Resp "16" _ OK <- signSendRecv sh sKey ("16", sId', _SEND' "hello 4")
          APNSMockRequest {notification = notification5} <- getMockNotification apns tkn'
          let APNSNotification {aps = APNSMutableContent {}, notificationData = Just ntfData5} = notification5
-              Right nonce5 = C.cbNonce =<< ntfData5 .-> "nonce"
+              Right nonce5 = C.cbNonce <$> ntfData5 .-> "nonce"
              Right message5 = ntfData5 .-> "message"
              Right ntfDataDecrypted5 = C.cbDecrypt dhSecret nonce5 message5
              Right pnMsgs5 = parse pnMessagesP (AP.INTERNAL "error parsing PNMessageData") ntfDataDecrypted5
@@ -241,7 +241,7 @@ testNotificationSubscription (ATransport t, msType) createQueue =
          smpServer5 `shouldBe` srv
          notifierId5 `shouldBe` nId'
          Resp "" _ (MSG RcvMessage {msgId = mId4, msgBody = EncRcvMsgBody body4}) <- tGet1 rh
-          Right ClientRcvMsgBody {msgBody = "hello 4"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret' mId4 body4)
+          Right ClientRcvMsgBody {msgBody = "hello 4"} <- pure $ parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt rcvDhSecret' (C.cbNonce mId4) body4)
          Resp "17" _ OK <- signSendRecv rh rKey' ("17", rId', ACK mId4)
          pure ()

@@ -307,7 +307,7 @@ registerToken nh apns token = do
  let dhSecret = C.dh' ntfDh dhPriv
      decryptCode nd =
        let Right verification = nd .-> "verification"
-            Right nonce = C.cbNonce =<< nd .-> "nonce"
+            Right nonce = C.cbNonce <$> nd .-> "nonce"
            Right pt = C.cbDecrypt dhSecret nonce verification
         in NtfRegCode pt
  let code = decryptCode ntfData
@@ -15,7 +15,6 @@ import qualified Simplex.Messaging.Agent.Store.Postgres.Migrations as Migrations
 import Simplex.Messaging.Agent.Store.Shared (Migration (..), MigrationConfig (..), MigrationConfirmation (..), MigrationsToRun (..), toDownMigration)
 import Simplex.Messaging.Util (ifM, whenM)
 import System.Directory (doesFileExist, removeFile)
-import System.Info (os)
 import System.Process (readCreateProcess, shell)
 import Test.Hspec hiding (fit, it)
 import Util
@@ -58,13 +57,14 @@ postgresSchemaDumpTest migrations skipComparisonForDownMigrations testDBOpts@DBO

    getSchema :: FilePath -> IO String
    getSchema schemaPath = do
+      ci <- envCI
      let cmd =
            ("pg_dump " <> B.unpack connstr <> " --schema " <> B.unpack testDBSchema)
              <> " --schema-only --no-owner --no-privileges --no-acl --no-subscriptions --no-tablespaces > "
              <> schemaPath
      void $ readCreateProcess (shell cmd) ""
      threadDelay 20000
-      let sed = (if os == "linux" then "sed -i" else "sed -i ''")
+      let sed = (if ci then "sed -i" else "sed -i ''")
      void $ readCreateProcess (shell $ sed <> " '/^--/d; /^\\\\restrict/d; /^\\\\unrestrict/d' " <> schemaPath) ""
      sch <- readFile schemaPath
      sch `deepseq` pure sch
@@ -51,22 +51,22 @@ import Simplex.Messaging.SimplexName (SimplexDomain)
 import Simplex.Messaging.Transport
 import Simplex.Messaging.Version (mkVersionRange)
 import Test.Hspec hiding (fit, it)
-import Util (HasTestEnv, it)
+import Util (it)

 domain :: Text -> SimplexDomain
 domain = either error id . strDecode . encodeUtf8

-withResolverServer :: HasTestEnv => (Status, LB.ByteString) -> IO a -> IO a
+withResolverServer :: (Status, LB.ByteString) -> IO a -> IO a
 withResolverServer (st, body) runTest =
  NRS.withResolverServer (NRS.resolveResp st body) $ \port _ ->
    withSmpServerConfigOn (transport @TLS) (withNames port memCfg) testPort (const runTest)

-withResolverServerReqs :: HasTestEnv => (Status, LB.ByteString) -> (IORef [[Text]] -> IO a) -> IO a
+withResolverServerReqs :: (Status, LB.ByteString) -> (IORef [[Text]] -> IO a) -> IO a
 withResolverServerReqs (st, body) runTest =
  NRS.withResolverServer (NRS.resolveResp st body) $ \port reqs ->
    withSmpServerConfigOn (transport @TLS) (withNames port memCfg) testPort (const (runTest reqs))

-withProxyAndResolver :: HasTestEnv => (Status, LB.ByteString) -> IO a -> IO a
+withProxyAndResolver :: (Status, LB.ByteString) -> IO a -> IO a
 withProxyAndResolver (st, body) runTest =
  NRS.withResolverServer (NRS.resolveResp st body) $ \port _ ->
    withSmpServerConfigOn (transport @TLS) memProxyCfg testPort $ \_ ->
@@ -105,7 +105,7 @@ rslvTests = do

 -- | /v2/resolve answers 200, 400 or 502, so a 404 is a resolver that predates
 -- the route, not a name that does not exist.
-testRslvBackendNotFound :: HasTestEnv => IO ()
+testRslvBackendNotFound :: IO ()
 testRslvBackendNotFound =
  withResolverServer (status404, "{}") $
    testSMPClient @TLS $ \h -> do
@@ -113,21 +113,21 @@ testRslvBackendNotFound =
      corrId `shouldBe` CorrId "rs01"
      resp `shouldBe` Right (ERR (NAME (RESOLVER "HTTP 404")))

-testRslvBackendHttpErr :: HasTestEnv => IO ()
+testRslvBackendHttpErr :: IO ()
 testRslvBackendHttpErr =
  withResolverServer (status502, "{}") $
    testSMPClient @TLS $ \h -> do
      (_, _, resp) <- sendRslv h "rs05" (domain "alice.simplex")
      resp `shouldBe` Right (ERR (NAME (RESOLVER "HTTP 502")))

-testRslvDisabled :: HasTestEnv => IO ()
+testRslvDisabled :: IO ()
 testRslvDisabled =
  withSmpServerConfigOn (transport @TLS) memCfg testPort $ const $
    testSMPClient @TLS $ \h -> do
      (_, _, resp) <- sendRslv h "rs06" (domain "alice.simplex")
      resp `shouldBe` Right (ERR (NAME NO_RESOLVER))

-testRslvVersion :: HasTestEnv => IO ()
+testRslvVersion :: IO ()
 testRslvVersion =
  withResolverServer (status200, registeredBody testNameRecord) $ do
    g <- C.newRandom
@@ -141,7 +141,7 @@ testRslvVersion =
      Left (PCETransportError TEVersion) -> pure ()
      _ -> expectationFailure $ "expected Left (PCETransportError TEVersion), got: " <> show r

-forwardedResolveAlice :: HasTestEnv => IO (Either SMPClientError (Either ProxyClientError SMP.NameResponse))
+forwardedResolveAlice :: IO (Either SMPClientError (Either ProxyClientError SMP.NameResponse))
 forwardedResolveAlice = do
  g <- C.newRandom
  ts <- getCurrentTime
@@ -153,21 +153,21 @@ forwardedResolveAlice = do
  sess <- runExceptT' (connectSMPProxiedRelay pc NRMInteractive relayServ Nothing)
  runExceptT (proxyResolveName pc NRMInteractive sess (domain "alice.simplex"))

-testRslvForwarded :: HasTestEnv => IO ()
+testRslvForwarded :: IO ()
 testRslvForwarded =
  withProxyAndResolver (status404, "{}") $
    forwardedResolveAlice >>= \r -> case r of
      Left (PCEProtocolError (SMP.NAME (SMP.RESOLVER _))) -> pure ()
      _ -> expectationFailure $ "expected Left (PCEProtocolError (NAME (RESOLVER _))), got: " <> show r

-testRslvForwardedSuccess :: HasTestEnv => IO ()
+testRslvForwardedSuccess :: IO ()
 testRslvForwardedSuccess =
  withProxyAndResolver (status200, registeredBody testNameRecord) $
    forwardedResolveAlice >>= \r -> case r of
      Right (Right NameResponse {registration = NRRegistered {nameRecord}}) -> nameRecord `shouldBe` testNameRecord
      _ -> expectationFailure $ "expected Right (Right NRRegistered), got: " <> show r

-testRslvSuccess :: HasTestEnv => IO ()
+testRslvSuccess :: IO ()
 testRslvSuccess =
  withResolverServer (status200, registeredBody testNameRecord) $
    testSMPClient @TLS $ \h -> do
@@ -177,7 +177,7 @@ testRslvSuccess =
        Right (RNAME NameResponse {registration = NRRegistered {nameRecord}}) -> nameRecord `shouldBe` testNameRecord
        _ -> expectationFailure $ "expected Right (RNAME NRRegistered), got: " <> show resp

-testRslvAvailable :: HasTestEnv => IO ()
+testRslvAvailable :: IO ()
 testRslvAvailable =
  withResolverServer (status200, availableBody) $
    testSMPClient @TLS $ \h -> do
@@ -185,7 +185,7 @@ testRslvAvailable =
      corrId `shouldBe` CorrId "na01"
      resp `shouldBe` Right (RNAME (resolved (NRAvailable testPricing)))

-testRslvReserved :: HasTestEnv => IO ()
+testRslvReserved :: IO ()
 testRslvReserved =
  withResolverServer (status200, reservedBody) $
    testSMPClient @TLS $ \h -> do
@@ -194,7 +194,7 @@ testRslvReserved =

 -- | A client that predates v22 must see exactly what it saw before: the record
 -- for a name that resolves, and NOT_FOUND for one that does not.
-oldClient :: HasTestEnv => IO SMPClient
+oldClient :: IO SMPClient
 oldClient = do
  g <- C.newRandom
  ts <- getCurrentTime
@@ -205,14 +205,14 @@ oldClient = do
  pcE <- getProtocolClient g NRMInteractive (1, srv, Nothing) oldCfg [] Nothing ts (\_ -> pure ())
  either (fail . show) pure pcE

-testRslvOldClientRecord :: HasTestEnv => IO ()
+testRslvOldClientRecord :: IO ()
 testRslvOldClientRecord =
  withResolverServer (status200, registeredBody testNameRecord) $ do
    pc <- oldClient
    r <- runExceptT' (directResolveName pc NRMInteractive (domain "alice.simplex"))
    r `shouldBe` NameResponse Nothing (NRRegistered Nothing Nothing Nothing testNameRecord)

-testRslvOldClientNotFound :: HasTestEnv => IO ()
+testRslvOldClientNotFound :: IO ()
 testRslvOldClientNotFound =
  withResolverServer (status200, availableBody) $ do
    pc <- oldClient
@@ -221,7 +221,7 @@ testRslvOldClientNotFound =
      Left (PCEProtocolError (SMP.NAME SMP.NOT_FOUND)) -> pure ()
      _ -> expectationFailure $ "expected Left (PCEProtocolError (NAME NOT_FOUND)), got: " <> show r

-testRslvForwardedAvailable :: HasTestEnv => IO ()
+testRslvForwardedAvailable :: IO ()
 testRslvForwardedAvailable =
  withProxyAndResolver (status200, availableBody) $
    forwardedResolveAlice >>= \r -> case r of
@@ -238,7 +238,7 @@ resolvePaths reqs = filter isResolve <$> readIORef reqs
  where
    isResolve = \case ("v2" : "resolve" : _) -> True; _ -> False

-currentClient :: HasTestEnv => IO SMPClient
+currentClient :: IO SMPClient
 currentClient = do
  g <- C.newRandom
  ts <- getCurrentTime
@@ -246,7 +246,7 @@ currentClient = do
  pcE <- getProtocolClient g NRMInteractive (1, srv, Nothing) defaultSMPClientConfig [] Nothing ts (\_ -> pure ())
  either (fail . show) pure pcE

-testRslvSendsTheHash :: HasTestEnv => IO ()
+testRslvSendsTheHash :: IO ()
 testRslvSendsTheHash =
  withResolverServerReqs (status200, registeredBody testNameRecord) $ \reqs -> do
    pc <- currentClient
@@ -257,7 +257,7 @@ testRslvSendsTheHash =
      NameResponse {registration = NRRegistered {nameRecord}} -> SMP.nrName nameRecord `shouldBe` "alice.simplex"
      _ -> expectationFailure $ "expected NRRegistered, got: " <> show r

-testSubnameKeepsItsLabels :: HasTestEnv => IO ()
+testSubnameKeepsItsLabels :: IO ()
 testSubnameKeepsItsLabels =
  withResolverServerReqs (status200, availableBody) $ \reqs -> do
    pc <- currentClient
@@ -266,7 +266,7 @@ testSubnameKeepsItsLabels =

 -- a hashed query does not tell the router the name, so the record's own name is
 -- checked against the one that was asked for
-testRslvWrongName :: HasTestEnv => IO ()
+testRslvWrongName :: IO ()
 testRslvWrongName =
  withResolverServer (status200, registeredBody testNameRecord {SMP.nrName = "mallory.simplex"}) $ do
    pc <- currentClient
@@ -9,15 +9,13 @@ module RemoteControl where

 import AgentTests.FunctionalAPITests (runRight)
 import Control.Logger.Simple
-import Control.Monad (void)
-import Control.Monad.Trans.Except (runExceptT)
 import Crypto.Random (ChaChaDRG)
 import qualified Data.Aeson as J
 import qualified Data.ByteString.Char8 as B
 import qualified Data.ByteString.Lazy.Char8 as LB
 import Data.List (stripPrefix)
 import Data.List.NonEmpty (NonEmpty (..))
-import Data.Time.Clock.System (SystemTime (..), getSystemTime)
+import Data.Time.Clock.System (SystemTime (..))
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String (StrEncoding (..))
 import Simplex.Messaging.Transport (TSbChainKeys (..))
@@ -26,10 +24,8 @@ import qualified Simplex.RemoteControl.Client as HC (RCHostClient (action))
 import qualified Simplex.RemoteControl.Client as RC
 import Simplex.RemoteControl.Discovery (mkLastLocalHost, preferAddress)
 import Simplex.RemoteControl.Invitation
-  ( RCEncInvitation (..),
-    RCInvitation (..),
+  ( RCInvitation (..),
    RCSignedInvitation,
-    signInvitation,
    verifySignedInvitation,
  )
 import Simplex.RemoteControl.Types
@@ -49,7 +45,6 @@ remoteControlTests = do
    it "should connect to existing pairing" testExistingPairing
  describe "Multicast discovery" $ do
    it "should find paired host and connect" testMulticast
-    it "should accept announcement only within timestamp window" testAnnouncementTimestamp

 testPreferAddress :: Spec
 testPreferAddress = do
@@ -249,26 +244,6 @@ testMulticast = do
        Nothing -> fail "timeout"
        Just _ -> pure ()

-testAnnouncementTimestamp :: IO ()
-testAnnouncementTimestamp = do
-  drg <- C.newRandom
-  RCHostPairing {caKey, caCert, idPrivKey} <- RC.newRCHostPairing drg
-  (hostDhPubKey, dhPrivKey) <- atomically $ C.generateKeyPair @'C.X25519 drg
-  (skey, sessPrivKey) <- atomically $ C.generateKeyPair @'C.Ed25519 drg
-  (dh, ctrlDhPrivKey) <- atomically $ C.generateKeyPair @'C.X25519 drg
-  nonce <- atomically $ C.randomCbNonce drg
-  now <- systemSeconds <$> getSystemTime
-  let pairing = RCCtrlPairing {caKey, caCert, ctrlFingerprint = C.KeyHash "test-ca", idPubKey = C.publicKey idPrivKey, dhPrivKey, prevDhPrivKey = Nothing}
-      announce offset = do
-        let inv = RCInvitation {ca = C.KeyHash "test-ca", host = "127.0.0.1", port = 5223, v = supportedRCPVRange, app = J.String "app", ts = MkSystemTime (now + offset) 0, skey, idkey = C.publicKey idPrivKey, dh}
-        encInvitation <- either (fail . show) pure $ C.cbEncrypt (C.dh' hostDhPubKey ctrlDhPrivKey) nonce (strEncode $ signInvitation sessPrivKey idPrivKey inv) 900
-        runExceptT . void $ RC.findRCCtrlPairing (pairing :| []) RCEncInvitation {dhPubKey = dh, nonce, encInvitation}
-  announce 0 `shouldReturn` Right ()
-  announce (-3600) `shouldReturn` Right ()
-  announce 3500 `shouldReturn` Right ()
-  announce (-3700) `shouldReturn` Left RCEInvitation
-  announce 3700 `shouldReturn` Left RCEInvitation
-
 runCtrl :: TVar ChaChaDRG -> Bool -> RCHostPairing -> MVar RCSignedInvitation -> IO (Async RCHostPairing)
 runCtrl drg multicast hp invVar = async . runRight $ do
  (_found, inv, hc, r) <- RC.connectRCHost drg hp (J.String "app") multicast Nothing Nothing
@@ -6,7 +6,6 @@
 {-# LANGUAGE NumericUnderscores #-}
 {-# LANGUAGE OverloadedLists #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeApplications #-}

@@ -16,51 +15,50 @@ import Data.List.NonEmpty (NonEmpty)
 import qualified Data.List.NonEmpty as L
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
-import SMPClient (ntfTestPort, ntfTestPort2, testHost, testHost2, testKeyHash, testPort, testPort2)
+import SMPClient (ntfTestPort, testPort)
 import Simplex.Messaging.Agent.Env.SQLite
 import Simplex.Messaging.Agent.Protocol
 import Simplex.Messaging.Agent.RetryInterval
 import Simplex.Messaging.Client (NetworkTimeout (..), ProtocolClientConfig (..), SMPProxyFallback (..), SMPProxyMode (..), defaultNetworkConfig, defaultSMPClientConfig)
 import Simplex.Messaging.Notifications.Client (defaultNTFClientConfig)
-import Simplex.Messaging.Protocol (NtfServer, ProtoServerWithAuth (..), ProtocolServer, pattern NtfServer)
+import Simplex.Messaging.Protocol (NtfServer, ProtoServerWithAuth (..), ProtocolServer)
 import Simplex.Messaging.Transport
-import Util
 import XFTPClient (testXFTPServer)

 -- name fixtures are reused, but they are used as schema name instead of database file path
 #if defined(dbPostgres)
-testDB :: HasTestEnv => String
-testDB = testSchemaName "smp_agent_test_protocol_schema"
+testDB :: String
+testDB = "smp_agent_test_protocol_schema"

-testDB2 :: HasTestEnv => String
-testDB2 = testSchemaName "smp_agent2_test_protocol_schema"
+testDB2 :: String
+testDB2 = "smp_agent2_test_protocol_schema"

-testDB3 :: HasTestEnv => String
-testDB3 = testSchemaName "smp_agent3_test_protocol_schema"
+testDB3 :: String
+testDB3 = "smp_agent3_test_protocol_schema"
 #else
-testDB :: HasTestEnv => FilePath
-testDB = testPath "smp-agent.test.protocol.db"
+testDB :: FilePath
+testDB = "tests/tmp/smp-agent.test.protocol.db"

-testDB2 :: HasTestEnv => FilePath
-testDB2 = testPath "smp-agent2.test.protocol.db"
+testDB2 :: FilePath
+testDB2 = "tests/tmp/smp-agent2.test.protocol.db"

-testDB3 :: HasTestEnv => FilePath
-testDB3 = testPath "smp-agent3.test.protocol.db"
+testDB3 :: FilePath
+testDB3 = "tests/tmp/smp-agent3.test.protocol.db"
 #endif

-testSMPServer :: HasTestEnv => SMPServer
-testSMPServer = SMPServer testHost testPort testKeyHash
+testSMPServer :: SMPServer
+testSMPServer = "smp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:5001"

-testSMPServer2 :: HasTestEnv => SMPServer
-testSMPServer2 = SMPServer testHost2 testPort2 testKeyHash
+testSMPServer2 :: SMPServer
+testSMPServer2 = "smp://[email protected]:5002"

-testNtfServer :: HasTestEnv => NtfServer
-testNtfServer = NtfServer testHost ntfTestPort testKeyHash
+testNtfServer :: NtfServer
+testNtfServer = "ntf://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:6001"

-testNtfServer2 :: HasTestEnv => NtfServer
-testNtfServer2 = NtfServer testHost ntfTestPort2 testKeyHash
+testNtfServer2 :: NtfServer
+testNtfServer2 = "ntf://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:6002"

-initAgentServers :: HasTestEnv => InitialAgentServers
+initAgentServers :: InitialAgentServers
 initAgentServers =
  InitialAgentServers
    { smp = userServers [testSMPServer],
@@ -73,23 +71,23 @@ initAgentServers =
      presetServers = []
    }

-initAgentServers2 :: HasTestEnv => InitialAgentServers
+initAgentServers2 :: InitialAgentServers
 initAgentServers2 = initAgentServers {smp = userServers [testSMPServer, testSMPServer2]}

-initAgentServersProxy :: HasTestEnv => InitialAgentServers
+initAgentServersProxy :: InitialAgentServers
 initAgentServersProxy = initAgentServersProxy_ SPMAlways SPFProhibit

-initAgentServersProxy_ :: HasTestEnv => SMPProxyMode -> SMPProxyFallback -> InitialAgentServers
+initAgentServersProxy_ :: SMPProxyMode -> SMPProxyFallback -> InitialAgentServers
 initAgentServersProxy_ smpProxyMode smpProxyFallback =
  initAgentServers {netCfg = (netCfg initAgentServers) {smpProxyMode, smpProxyFallback}}

-initAgentServersProxy2 :: HasTestEnv => InitialAgentServers
+initAgentServersProxy2 :: InitialAgentServers
 initAgentServersProxy2 = initAgentServersProxy {smp = userServers [testSMPServer2]}

-initAgentServersClientService :: HasTestEnv => InitialAgentServers
+initAgentServersClientService :: InitialAgentServers
 initAgentServersClientService = initAgentServers {useServices = M.fromList [(1, True)]}

-agentCfg :: HasTestEnv => AgentConfig
+agentCfg :: AgentConfig
 agentCfg =
  defaultAgentConfig
    { tcpPort = Nothing,
@@ -45,7 +45,7 @@ import System.Info (os)
 import Test.Hspec hiding (fit, it)
 import UnliftIO.Concurrent
 import qualified UnliftIO.Exception as E
-import UnliftIO.STM (TMVar, atomically, newEmptyTMVarIO, putTMVar, readTMVar, takeTMVar)
+import UnliftIO.STM (TMVar, atomically, newEmptyTMVarIO, putTMVar, takeTMVar)
 import UnliftIO.Timeout (timeout)
 import Util

@@ -72,29 +72,29 @@ testHost = "localhost"
 testHost2 :: NonEmpty TransportHost
 testHost2 = "127.0.0.1"

-testPort :: HasTestEnv => ServiceName
-testPort = testServerPort 1
+testPort :: ServiceName
+testPort = "5001"

-testPort2 :: HasTestEnv => ServiceName
-testPort2 = testServerPort 2
+testPort2 :: ServiceName
+testPort2 = "5002"

-ntfTestPort :: HasTestEnv => ServiceName
-ntfTestPort = testServerPort 3
+ntfTestPort :: ServiceName
+ntfTestPort = "6001"

-ntfTestPort2 :: HasTestEnv => ServiceName
-ntfTestPort2 = testServerPort 4
+ntfTestPort2 :: ServiceName
+ntfTestPort2 = "6002"

 testKeyHash :: C.KeyHash
 testKeyHash = "LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI="

-testStoreLogFile :: HasTestEnv => FilePath
-testStoreLogFile = testPath "smp-server-store.log"
+testStoreLogFile :: FilePath
+testStoreLogFile = "tests/tmp/smp-server-store.log"

-testStoreLogFile2 :: HasTestEnv => FilePath
-testStoreLogFile2 = testPath "smp-server-store.log.2"
+testStoreLogFile2 :: FilePath
+testStoreLogFile2 = "tests/tmp/smp-server-store.log.2"

-testServerDBOpts :: DBOpts
-testServerDBOpts =
+testStoreDBOpts :: DBOpts
+testStoreDBOpts =
  DBOpts
    { connstr = testServerDBConnstr,
      schema = "smp_server",
@@ -102,11 +102,8 @@ testServerDBOpts =
      createSchema = True
    }

-testStoreDBOpts :: HasTestEnv => DBOpts
-testStoreDBOpts = testServerDBOpts {schema = testSchemaName "smp_server"}
-
-testStoreDBOpts2 :: HasTestEnv => DBOpts
-testStoreDBOpts2 = testStoreDBOpts {schema = testSchemaName "smp_server2"}
+testStoreDBOpts2 :: DBOpts
+testStoreDBOpts2 = testStoreDBOpts {schema = "smp_server2"}

 testServerDBConnstr :: ByteString
 testServerDBConnstr = "postgresql://test_server_user@/test_server_db"
@@ -120,48 +117,48 @@ testServerDBConnectInfo =
  }
 #endif

-testStoreMsgsFile :: HasTestEnv => FilePath
-testStoreMsgsFile = testPath "smp-server-messages.log"
+testStoreMsgsFile :: FilePath
+testStoreMsgsFile = "tests/tmp/smp-server-messages.log"

-testStoreMsgsFile2 :: HasTestEnv => FilePath
-testStoreMsgsFile2 = testPath "smp-server-messages.log.2"
+testStoreMsgsFile2 :: FilePath
+testStoreMsgsFile2 = "tests/tmp/smp-server-messages.log.2"

-testStoreMsgsDir :: HasTestEnv => FilePath
-testStoreMsgsDir = testPath "messages"
+testStoreMsgsDir :: FilePath
+testStoreMsgsDir = "tests/tmp/messages"

-testStoreMsgsDir2 :: HasTestEnv => FilePath
-testStoreMsgsDir2 = testPath "messages.2"
+testStoreMsgsDir2 :: FilePath
+testStoreMsgsDir2 = "tests/tmp/messages.2"

-testStoreNtfsFile :: HasTestEnv => FilePath
-testStoreNtfsFile = testPath "smp-server-ntfs.log"
+testStoreNtfsFile :: FilePath
+testStoreNtfsFile = "tests/tmp/smp-server-ntfs.log"

-testStoreNtfsFile2 :: HasTestEnv => FilePath
-testStoreNtfsFile2 = testPath "smp-server-ntfs.log.2"
+testStoreNtfsFile2 :: FilePath
+testStoreNtfsFile2 = "tests/tmp/smp-server-ntfs.log.2"

-testPrometheusMetricsFile :: HasTestEnv => FilePath
-testPrometheusMetricsFile = testPath "smp-server-metrics.txt"
+testPrometheusMetricsFile :: FilePath
+testPrometheusMetricsFile = "tests/tmp/smp-server-metrics.txt"

-testServerStatsBackupFile :: HasTestEnv => FilePath
-testServerStatsBackupFile = testPath "smp-server-stats.log"
+testServerStatsBackupFile :: FilePath
+testServerStatsBackupFile = "tests/tmp/smp-server-stats.log"

-xit' :: (HasCallStack, Example a) => String -> (HasTestEnv => a) -> SpecWith (Arg a)
-xit' d t = if os == "linux" then skip "skipped on Linux" $ it d t else it d t
+xit' :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
+xit' d = if os == "linux" then skip "skipped on Linux" . it d else it d

-xit'' :: (HasCallStack, Example a) => String -> (HasTestEnv => a) -> SpecWith (Arg a)
-xit'' d t = skipOnCI $ it d t
+xit'' :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
+xit'' d = skipOnCI . it d

 skipOnCI :: SpecWith a -> SpecWith a
 skipOnCI t = ifM (runIO envCI) (skip "skipped on CI" t) t

-testSMPClient :: (HasTestEnv, Transport c) => (THandleSMP c 'TClient -> IO a) -> IO a
+testSMPClient :: Transport c => (THandleSMP c 'TClient -> IO a) -> IO a
 testSMPClient = testSMPClientVR supportedClientSMPRelayVRange

-testSMPClientVR :: (HasTestEnv, Transport c) => VersionRangeSMP -> (THandleSMP c 'TClient -> IO a) -> IO a
+testSMPClientVR :: Transport c => VersionRangeSMP -> (THandleSMP c 'TClient -> IO a) -> IO a
 testSMPClientVR vr client = do
  Right useHost <- pure $ chooseTransportHost defaultNetworkConfig testHost
  testSMPClient_ useHost testPort vr Nothing client

-testSMPServiceClient :: (HasTestEnv, Transport c) => (TLS.Credential, C.KeyPairEd25519) -> (THandleSMP c 'TClient -> IO a) -> IO a
+testSMPServiceClient :: Transport c => (TLS.Credential, C.KeyPairEd25519) -> (THandleSMP c 'TClient -> IO a) -> IO a
 testSMPServiceClient serviceCreds client = do
  Right useHost <- pure $ chooseTransportHost defaultNetworkConfig testHost
  testSMPClient_ useHost testPort supportedClientSMPRelayVRange (Just serviceCreds) client
@@ -184,13 +181,13 @@ testSMPClient_ host port vr serviceCreds_ client = do
  where
    clientALPN = Just alpnSupportedSMPHandshakes

-runSMPClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO a) -> IO a
+runSMPClient :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO a) -> IO a
 runSMPClient _ test' = testSMPClient test'

-runSMPServiceClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (TLS.Credential, C.KeyPairEd25519) -> (THandleSMP c 'TClient -> IO a) -> IO a
+runSMPServiceClient :: Transport c => TProxy c 'TServer -> (TLS.Credential, C.KeyPairEd25519) -> (THandleSMP c 'TClient -> IO a) -> IO a
 runSMPServiceClient _ serviceCreds test' = testSMPServiceClient serviceCreds test'

-testNtfServiceClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> C.KeyPairEd25519 -> (THandleSMP c 'TClient -> IO a) -> IO a
+testNtfServiceClient :: Transport c => TProxy c 'TServer -> C.KeyPairEd25519 -> (THandleSMP c 'TClient -> IO a) -> IO a
 testNtfServiceClient _ keys client = do
  tlsNtfServerCreds <- loadServerCredential ntfTestServerCredentials
  serviceCertHash <- loadFingerprint ntfTestServerCredentials
@@ -214,13 +211,13 @@ ntfTestServerCredentials =
      certificateFile = "tests/fixtures/server.crt"
    }

-cfg :: HasTestEnv => AServerConfig
+cfg :: AServerConfig
 cfg = cfgMS (ASType SQSMemory SMSJournal)

-cfgJ2 :: HasTestEnv => AServerConfig
+cfgJ2 :: AServerConfig
 cfgJ2 = journalCfg cfg testStoreLogFile2 testStoreMsgsDir2

-cfgJ2QS :: HasTestEnv => SQSType s -> AServerConfig
+cfgJ2QS :: SQSType s -> AServerConfig
 cfgJ2QS = \case
  SQSMemory -> journalCfg (cfgMS $ ASType SQSMemory SMSJournal) testStoreLogFile2 testStoreMsgsDir2
  SQSPostgres -> journalCfgDB (cfgMS $ ASType SQSPostgres SMSJournal) testStoreDBOpts2 testStoreMsgsDir2
@@ -234,7 +231,7 @@ journalCfgDB (ASrvCfg _ _ cfg') dbOpts storeMsgsPath' =
  let storeCfg = PostgresStoreCfg {dbOpts, dbStoreLogPath = Nothing, confirmMigrations = MCYesUp, deletedTTL = 86400}
   in ASrvCfg SQSPostgres SMSJournal cfg' {serverStoreCfg = SSCDatabaseJournal {storeCfg, storeMsgsPath'}}

-cfgMS :: HasTestEnv => AStoreType -> AServerConfig
+cfgMS :: AStoreType -> AServerConfig
 cfgMS msType = withStoreCfg (testServerStoreConfig msType) $ \serverStoreCfg ->
  ServerConfig
    { transports = [],
@@ -260,13 +257,12 @@ cfgMS msType = withStoreCfg (testServerStoreConfig msType) $ \serverStoreCfg ->
      inactiveClientExpiration = Just defaultInactiveClientExpiration,
      logStatsInterval = Nothing,
      logStatsStartTime = 0,
-      serverStatsLogFile = testPath "smp-server-stats.daily.log",
+      serverStatsLogFile = "tests/tmp/smp-server-stats.daily.log",
      serverStatsBackupFile = Nothing,
      prometheusInterval = Nothing,
      prometheusMetricsFile = testPrometheusMetricsFile,
      pendingENDInterval = 500000,
      ntfDeliveryInterval = 200000,
-      authErrorDelay = 20000,
      smpCredentials =
        ServerCredentials
          { caCertificateFile = Just "tests/fixtures/ca.crt",
@@ -292,10 +288,10 @@ withStoreCfg (ASSCfg qt mt storeCfg) f = ASrvCfg qt mt (f storeCfg)
 defaultStartOptions :: StartOptions
 defaultStartOptions = StartOptions {maintenance = False, compactLog = False, logLevel = testLogLevel, skipWarnings = False, confirmMigrations = MCYesUp}

-testServerStoreConfig :: HasTestEnv => AStoreType -> AServerStoreCfg
+testServerStoreConfig :: AStoreType -> AServerStoreCfg
 testServerStoreConfig = serverStoreConfig_ False

-serverStoreConfig_ :: HasTestEnv => Bool -> AStoreType -> AServerStoreCfg
+serverStoreConfig_ :: Bool -> AStoreType -> AServerStoreCfg
 serverStoreConfig_ useDbStoreLog = \case
  ASType SQSMemory SMSMemory ->
    ASSCfg SQSMemory SMSMemory $ SSCMemory $ Just StorePaths {storeLogFile = testStoreLogFile, storeMsgsFile = Just testStoreMsgsFile}
@@ -311,7 +307,7 @@ serverStoreConfig_ useDbStoreLog = \case
    dbStoreLogPath = if useDbStoreLog then Just testStoreLogFile else Nothing
    storeCfg = PostgresStoreCfg {dbOpts = testStoreDBOpts, dbStoreLogPath, confirmMigrations = MCYesUp, deletedTTL = 86400}

-cfgVPrev :: HasTestEnv => AStoreType -> AServerConfig
+cfgVPrev :: AStoreType -> AServerConfig
 cfgVPrev msType = updateCfg (cfgMS msType) $ \cfg' -> cfg' {smpServerVRange = prevRange $ smpServerVRange cfg'}

 prevRange :: VersionRange v -> VersionRange v
@@ -323,10 +319,10 @@ prevVersion (Version v) = Version (v - 1)
 nextVersion :: Version v -> Version v
 nextVersion (Version v) = Version (v + 1)

-proxyCfg :: HasTestEnv => AServerConfig
+proxyCfg :: AServerConfig
 proxyCfg = proxyCfgMS (ASType SQSMemory SMSJournal)

-proxyCfgMS :: HasTestEnv => AStoreType -> AServerConfig
+proxyCfgMS :: AStoreType -> AServerConfig
 proxyCfgMS msType =
  updateCfg (cfgMS msType) $ \cfg' ->
    let smpAgentCfg' = smpAgentCfg cfg'
@@ -335,17 +331,17 @@ proxyCfgMS msType =
            smpAgentCfg = smpAgentCfg' {smpCfg = (smpCfg smpAgentCfg') {agreeSecret = True, proxyServer = True, serverVRange = supportedProxyClientSMPRelayVRange}}
          }

-proxyCfgJ2 :: HasTestEnv => AServerConfig
+proxyCfgJ2 :: AServerConfig
 proxyCfgJ2 = journalCfg proxyCfg testStoreLogFile2 testStoreMsgsDir2

-proxyCfgJ2QS :: HasTestEnv => SQSType qs -> AServerConfig
+proxyCfgJ2QS :: SQSType qs -> AServerConfig
 proxyCfgJ2QS = \case
  SQSMemory -> journalCfg (proxyCfgMS $ ASType SQSMemory SMSJournal) testStoreLogFile2 testStoreMsgsDir2
  SQSPostgres -> journalCfgDB (proxyCfgMS $ ASType SQSPostgres SMSJournal) testStoreDBOpts2 testStoreMsgsDir2

 -- Proxy config with a short relay-connection timeout, to bound how long a failing
 -- proxy->relay connection attempt blocks in the relay reconnection tests.
-proxyCfgShortTimeout :: HasTestEnv => AServerConfig
+proxyCfgShortTimeout :: AServerConfig
 proxyCfgShortTimeout =
  updateCfg proxyCfg $ \cfg' ->
    let aCfg = smpAgentCfg cfg'
@@ -353,21 +349,11 @@ proxyCfgShortTimeout =
        nt = NetworkTimeout {backgroundTimeout = 4_000000, interactiveTimeout = 4_000000}
     in cfg' {smpAgentCfg = aCfg {smpCfg = cCfg {networkConfig = (networkConfig cCfg) {tcpConnectTimeout = nt}}}}

-proxyCfgVPrev :: HasTestEnv => AStoreType -> AServerConfig
-proxyCfgVPrev msType =
-  updateCfg (proxyCfgMS msType) $ \cfg' ->
-    let aCfg = smpAgentCfg cfg'
-        cCfg = smpCfg aCfg
-     in cfg'
-          { smpServerVRange = prevRange $ smpServerVRange cfg',
-            smpAgentCfg = aCfg {smpCfg = cCfg {serverVRange = prevRange $ serverVRange cCfg}}
-          }
-
-withSmpServerStoreMsgLogOn :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
+withSmpServerStoreMsgLogOn :: HasCallStack => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
 withSmpServerStoreMsgLogOn (t, msType) =
  withSmpServerConfigOn t $ updateCfg (cfgMS msType) $ \cfg' -> cfg' {storeNtfsFile = Just testStoreNtfsFile, serverStatsBackupFile = Just testServerStatsBackupFile}

-withSmpServerStoreLogOn :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
+withSmpServerStoreLogOn :: HasCallStack => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
 withSmpServerStoreLogOn (t, msType) =
  withSmpServerConfigOn t $ updateCfg (cfgMS msType) $ \cfg' -> cfg' {serverStatsBackupFile = Just testServerStatsBackupFile}

@@ -383,31 +369,26 @@ withSmpServerConfigOn t (ASrvCfg _ _ cfg') port' =
    (\started -> runSMPServerBlocking started cfg' {transports = [(port', t, False)]} Nothing)
    (threadDelay 10000)

-withSmpServerThreadOn :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
+withSmpServerThreadOn :: HasCallStack => (ASrvTransport, AStoreType) -> ServiceName -> (HasCallStack => ThreadId -> IO a) -> IO a
 withSmpServerThreadOn (t, msType) = withSmpServerConfigOn t (cfgMS msType)

 serverBracket :: HasCallStack => (TMVar Bool -> IO ()) -> IO () -> (HasCallStack => ThreadId -> IO a) -> IO a
 serverBracket process afterProcess f = do
  started <- newEmptyTMVarIO
-  startError <- newEmptyTMVarIO
  E.bracket
-    (forkIOWithUnmask (\unmask -> unmask (process started) `E.catchAny` handleStartError started startError))
-    (\t -> killThread t >> afterProcess >> void (waitFor started "stop"))
-    (\t -> checkStarted started startError >> f t >>= \r -> r <$ threadDelay 100000)
+    (forkIOWithUnmask (\unmask -> unmask (process started) `E.catchAny` handleStartError started))
+    (\t -> killThread t >> afterProcess >> waitFor started "stop")
+    (\t -> waitFor started "start" >> f t >>= \r -> r <$ threadDelay 100000)
  where
    -- it putTMVar is called twise to unlock both parts of the bracket in case of start failure
-    handleStartError started startError e = do
-      atomically $ putTMVar startError e
+    handleStartError started e = do
      atomically $ putTMVar started False
      atomically $ putTMVar started False
      E.throwIO e
-    checkStarted started startError =
-      waitFor started "start" >>= \ok ->
-        unless ok $ atomically (readTMVar startError) >>= \e -> error $ "server did not start: " <> show e
    waitFor started s =
      5_000_000 `timeout` atomically (takeTMVar started) >>= \case
        Nothing -> error $ "server did not " <> s
-        Just ok -> pure ok
+        _ -> pure ()

 -- A TCP server that accepts connections but never performs a TLS handshake, so a client
 -- connecting to it stays blocked in the TLS handshake until its connection timeout.
@@ -418,28 +399,28 @@ withStallingServerOn port action =
    (pure ())
    (const action)

-withSmpServerOn :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> ServiceName -> IO a -> IO a
+withSmpServerOn :: HasCallStack => (ASrvTransport, AStoreType) -> ServiceName -> IO a -> IO a
 withSmpServerOn ps port' = withSmpServerThreadOn ps port' . const

-withSmpServer :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> IO a -> IO a
+withSmpServer :: HasCallStack => (ASrvTransport, AStoreType) -> IO a -> IO a
 withSmpServer ps = withSmpServerOn ps testPort

-withSmpServerProxy :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> IO a -> IO a
+withSmpServerProxy :: HasCallStack => (ASrvTransport, AStoreType) -> IO a -> IO a
 withSmpServerProxy (t, msType) = withSmpServerConfigOn t (proxyCfgMS msType) testPort . const

-withSmpServers2 :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> IO a -> IO a
+withSmpServers2 :: HasCallStack => (ASrvTransport, AStoreType) -> IO a -> IO a
 withSmpServers2 ps@(t, ASType qs _ms) = withSmpServer ps . withSmpServerConfigOn t (cfgJ2QS qs) testPort2 . const

-withSmpServersProxy2 :: (HasCallStack, HasTestEnv) => (ASrvTransport, AStoreType) -> IO a -> IO a
+withSmpServersProxy2 :: HasCallStack => (ASrvTransport, AStoreType) -> IO a -> IO a
 withSmpServersProxy2 ps@(t, ASType qs _ms) = withSmpServerProxy ps . withSmpServerConfigOn t (proxyCfgJ2QS qs) testPort2 . const

-runSmpTest :: forall c a. (HasCallStack, HasTestEnv, Transport c) => AStoreType -> (HasCallStack => THandleSMP c 'TClient -> IO a) -> IO a
+runSmpTest :: forall c a. (HasCallStack, Transport c) => AStoreType -> (HasCallStack => THandleSMP c 'TClient -> IO a) -> IO a
 runSmpTest msType test = withSmpServerConfigOn (transport @c) (cfgMS msType) testPort $ \_ -> testSMPClient test

-runSmpTestN :: forall c a. (HasCallStack, HasTestEnv, Transport c) => AStoreType -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO a) -> IO a
+runSmpTestN :: forall c a. (HasCallStack, Transport c) => AStoreType -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO a) -> IO a
 runSmpTestN msType = runSmpTestNCfg (cfgMS msType) supportedClientSMPRelayVRange

-runSmpTestNCfg :: forall c a. (HasCallStack, HasTestEnv, Transport c) => AServerConfig -> VersionRangeSMP -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO a) -> IO a
+runSmpTestNCfg :: forall c a. (HasCallStack, Transport c) => AServerConfig -> VersionRangeSMP -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO a) -> IO a
 runSmpTestNCfg srvCfg clntVR nClients test = withSmpServerConfigOn (transport @c) srvCfg testPort $ \_ -> run nClients []
  where
    run :: Int -> [THandleSMP c 'TClient] -> IO a
@@ -448,7 +429,7 @@ runSmpTestNCfg srvCfg clntVR nClients test = withSmpServerConfigOn (transport @c

 smpServerTest ::
  forall c smp.
-  (HasTestEnv, Transport c, Encoding smp) =>
+  (Transport c, Encoding smp) =>
  TProxy c 'TServer ->
  (Maybe TAuthorizations, ByteString, ByteString, smp) ->
  IO (Maybe TAuthorizations, ByteString, ByteString, BrokerMsg)
@@ -463,30 +444,30 @@ smpServerTest _ t = runSmpTest (ASType SQSMemory SMSJournal) $ \h -> tPut' h t >
      [(CorrId corrId, EntityId qId, Right cmd)] <- tGetClient h
      pure (Nothing, corrId, qId, cmd)

-smpTest :: (HasCallStack, HasTestEnv, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> IO ()) -> Expectation
+smpTest :: (HasCallStack, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> IO ()) -> Expectation
 smpTest _ msType test' = runSmpTest msType test' `shouldReturn` ()

-smpTestN :: (HasCallStack, HasTestEnv, Transport c) => AStoreType -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO ()) -> Expectation
+smpTestN :: (HasCallStack, Transport c) => AStoreType -> Int -> (HasCallStack => [THandleSMP c 'TClient] -> IO ()) -> Expectation
 smpTestN msType n test' = runSmpTestN msType n test' `shouldReturn` ()

-smpTest2 :: forall c. (HasCallStack, HasTestEnv, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
+smpTest2 :: forall c. (HasCallStack, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
 smpTest2 t msType = smpTest2Cfg (cfgMS msType) supportedClientSMPRelayVRange t

-smpTest2Cfg :: forall c. (HasCallStack, HasTestEnv, Transport c) => AServerConfig -> VersionRangeSMP -> TProxy c 'TServer -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
+smpTest2Cfg :: forall c. (HasCallStack, Transport c) => AServerConfig -> VersionRangeSMP -> TProxy c 'TServer -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
 smpTest2Cfg srvCfg clntVR _ test' = runSmpTestNCfg srvCfg clntVR 2 _test `shouldReturn` ()
  where
    _test :: HasCallStack => [THandleSMP c 'TClient] -> IO ()
    _test [h1, h2] = test' h1 h2
    _test _ = error "expected 2 handles"

-smpTest3 :: forall c. (HasCallStack, HasTestEnv, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
+smpTest3 :: forall c. (HasCallStack, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
 smpTest3 _ msType test' = smpTestN msType 3 _test
  where
    _test :: HasCallStack => [THandleSMP c 'TClient] -> IO ()
    _test [h1, h2, h3] = test' h1 h2 h3
    _test _ = error "expected 3 handles"

-smpTest4 :: forall c. (HasCallStack, HasTestEnv, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
+smpTest4 :: forall c. (HasCallStack, Transport c) => TProxy c 'TServer -> AStoreType -> (HasCallStack => THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO ()) -> Expectation
 smpTest4 _ msType test' = smpTestN msType 4 _test
  where
    _test :: HasCallStack => [THandleSMP c 'TClient] -> IO ()
@@ -26,7 +26,7 @@ import qualified Data.List.NonEmpty as L
 import Data.Time.Clock (getCurrentTime)
 import SMPAgentClient
 import SMPClient
-import ServerTests (decryptMsgV3, responseTime, sendRecv)
+import ServerTests (decryptMsgV3, sendRecv)
 import Simplex.Messaging.Agent hiding (createConnection, joinConnection, sendMessage)
 import qualified Simplex.Messaging.Agent as A
 import Simplex.Messaging.Agent.Env.SQLite (AgentConfig (..), InitialAgentServers (..))
@@ -45,9 +45,13 @@ import Simplex.Messaging.Util (bshow, tshow)
 import Simplex.Messaging.Version (mkVersionRange)
 import System.FilePath (splitExtensions)
 import System.Random (randomRIO)
-import Test.Hspec hiding (fit, it, xit)
+import Test.Hspec hiding (fit, it)
 import UnliftIO
 import Util
+#if defined(dbPostgres)
+import Fixtures
+import Simplex.Messaging.Agent.Store.Postgres.Util (dropAllSchemasExceptSystem)
+#endif

 smpProxyTests :: SpecWith AStoreType
 smpProxyTests = do
@@ -69,78 +73,69 @@ smpProxyTests = do
      xit "no SMP service at host/port" todo
      xit "bad SMP fingerprint" todo
    xit "batching proxy requests" todo
-    it "relay rejects forwarded command with changed version" $ \_ ->
-      testChangedFwdVersion
-    it "proxy rejects forwarded correlation ID that is not 24 bytes" $ \_ ->
-      testFwdCorrIdSize
-    it "relay delays AUTH errors to forwarded commands" $ \_ ->
-      testForwardedAuthErrorDelay
  describe "deliver message via SMP proxy" $ do
-    let srv1, srv2 :: HasTestEnv => SMPServer
-        srv1 = SMPServer testHost testPort testKeyHash
+    let srv1 = SMPServer testHost testPort testKeyHash
        srv2 = SMPServer testHost2 testPort2 testKeyHash
    describe "client API" $ do
      let maxLen = maxMessageLength
      describe "one server" $ do
-        it "deliver via proxy" $ oneServer $ do
+        it "deliver via proxy" . oneServer $ do
          deliverMessageViaProxy srv1 srv1 C.SEd448 "hello 1" "hello 2"
      describe "two servers" $ do
-        let proxyServ, relayServ :: HasTestEnv => SMPServer
-            proxyServ = srv1
+        let proxyServ = srv1
            relayServ = srv2
        (msg1, msg2) <- runIO $ do
          g <- C.newRandom
          atomically $ (,) <$> C.randomBytes maxLen g <*> C.randomBytes maxLen g
-        it "deliver via proxy" $ twoServersFirstProxy $
+        it "deliver via proxy" . twoServersFirstProxy $
          deliverMessageViaProxy proxyServ relayServ C.SEd448 "hello 1" "hello 2"
-        it "max message size, Ed448 keys" $ twoServersFirstProxy $
+        it "max message size, Ed448 keys" . twoServersFirstProxy $
          deliverMessageViaProxy proxyServ relayServ C.SEd448 msg1 msg2
-        it "max message size, Ed25519 keys" $ twoServersFirstProxy $
+        it "max message size, Ed25519 keys" . twoServersFirstProxy $
          deliverMessageViaProxy proxyServ relayServ C.SEd25519 msg1 msg2
-        it "max message size, X25519 keys" $ twoServersFirstProxy $
+        it "max message size, X25519 keys" . twoServersFirstProxy $
          deliverMessageViaProxy proxyServ relayServ C.SX25519 msg1 msg2
-      describe "version compatibility" $ do
-        let deliver clientVR = deliverMessagesViaProxyVR clientVR srv1 srv2 C.SEd448 ["hello 1"] ["hello 2"]
-        it "prev client" $ twoServersFirstProxy $ deliver (prevRange supportedClientSMPRelayVRange)
-        it "prev proxy" $ twoServersPrevProxy $ deliver supportedClientSMPRelayVRange
-        it "prev relay" $ twoServersPrevRelay $ deliver supportedClientSMPRelayVRange
      describe "stress test 1k" $ do
        let deliver n = deliverMessagesViaProxy srv1 srv2 C.SEd448 [] (map bshow [1 :: Int .. n])
-        it "1x1000" $ twoServersFirstProxy $ deliver 1000
-        it "5x200" $ twoServersFirstProxy $ 5 `inParrallel` deliver 200
-        it "10x100" $ twoServersFirstProxy $ 10 `inParrallel` deliver 100
+        it "1x1000" . twoServersFirstProxy $ deliver 1000
+        it "5x200" . twoServersFirstProxy $ 5 `inParrallel` deliver 200
+        it "10x100" . twoServersFirstProxy $ 10 `inParrallel` deliver 100
      describe "stress test - no host" $ do
-        it "1x1000, no delay" $ oneServer $ proxyConnectDeadRelay 1000 0 srv1
-        xit "1x1000, 100ms" $ oneServer $ proxyConnectDeadRelay 1000 100000 srv1
-        xit "100x1000, 100ms" $ oneServer $ 100 `inParrallel` (randomRIO (0, 1000000) >>= threadDelay >> proxyConnectDeadRelay 1000 100000 srv1)
+        it "1x1000, no delay" . oneServer $ proxyConnectDeadRelay 1000 0 srv1
+        xit "1x1000, 100ms" . oneServer $ proxyConnectDeadRelay 1000 100000 srv1
+        xit "100x1000, 100ms" . oneServer $ 100 `inParrallel` (randomRIO (0, 1000000) >>= threadDelay >> proxyConnectDeadRelay 1000 100000 srv1)
      xdescribe "stress test 10k" $ do
        let deliver n = deliverMessagesViaProxy srv1 srv2 C.SEd448 [] (map bshow [1 :: Int .. n])
-        it "1x10000" $ twoServersFirstProxy $ deliver 10000
-        it "5x2000" $ twoServersFirstProxy $ 5 `inParrallel` deliver 2000
-        it "10x1000" $ twoServersFirstProxy $ 10 `inParrallel` deliver 1000
-        it "100x100 N1" $ twoServersFirstProxy $ withNumCapabilities 1 $ 100 `inParrallel` deliver 100
-        it "100x100 N4 C1" $ twoServersNoConc $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
-        it "100x100 N4 C2" $ twoServersFirstProxy $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
-        it "100x100 N4 C16" $ twoServersMoreConc $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
-        it "100x100 N" $ twoServersFirstProxy $ withNCPUCapabilities $ 100 `inParrallel` deliver 100
-        it "500x20" $ twoServersFirstProxy $ 500 `inParrallel` deliver 20
+        it "1x10000" . twoServersFirstProxy $ deliver 10000
+        it "5x2000" . twoServersFirstProxy $ 5 `inParrallel` deliver 2000
+        it "10x1000" . twoServersFirstProxy $ 10 `inParrallel` deliver 1000
+        it "100x100 N1" . twoServersFirstProxy $ withNumCapabilities 1 $ 100 `inParrallel` deliver 100
+        it "100x100 N4 C1" . twoServersNoConc $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
+        it "100x100 N4 C2" . twoServersFirstProxy $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
+        it "100x100 N4 C16" . twoServersMoreConc $ withNumCapabilities 4 $ 100 `inParrallel` deliver 100
+        it "100x100 N" . twoServersFirstProxy $ withNCPUCapabilities $ 100 `inParrallel` deliver 100
+        it "500x20" . twoServersFirstProxy $ 500 `inParrallel` deliver 20
+#if defined(dbPostgres)
+    after_ (dropAllSchemasExceptSystem testDBConnectInfo) . describe "agent API" $ do
+#else
    describe "agent API" $ do
+#endif
      describe "one server" $ do
-        it "always via proxy" $ oneServer $
+        it "always via proxy" . oneServer $
          agentDeliverMessageViaProxy ([srv1], SPMAlways, True) ([srv1], SPMAlways, True) C.SEd448 "hello 1" "hello 2" 1
-        it "without proxy" $ oneServer $
+        it "without proxy" . oneServer $
          agentDeliverMessageViaProxy ([srv1], SPMNever, False) ([srv1], SPMNever, False) C.SEd448 "hello 1" "hello 2" 1
      describe "two servers" $ do
        it "always via proxy" $ \msType -> twoServers
          (agentDeliverMessageViaProxy ([srv1], SPMAlways, True) ([srv2], SPMAlways, True) C.SEd448 "hello 1" "hello 2" 1)
          msType
-        it "both via proxy" $ twoServers $
+        it "both via proxy" . twoServers $
          agentDeliverMessageViaProxy ([srv1], SPMUnknown, True) ([srv2], SPMUnknown, True) C.SEd448 "hello 1" "hello 2" 1
-        it "first via proxy" $ twoServers $
+        it "first via proxy" . twoServers $
          agentDeliverMessageViaProxy ([srv1], SPMUnknown, True) ([srv2], SPMNever, False) C.SEd448 "hello 1" "hello 2" 1
-        it "without proxy" $ twoServers $
+        it "without proxy" . twoServers $
          agentDeliverMessageViaProxy ([srv1], SPMNever, False) ([srv2], SPMNever, False) C.SEd448 "hello 1" "hello 2" 1
-        it "first via proxy for unknown" $ twoServers $
+        it "first via proxy for unknown" . twoServers $
          agentDeliverMessageViaProxy ([srv1], SPMUnknown, True) ([srv1, srv2], SPMUnknown, False) C.SEd448 "hello 1" "hello 2" 1
        it "retries sending when destination or proxy relay is offline" $ \_ ->
          agentViaProxyRetryOffline
@@ -148,19 +143,19 @@ smpProxyTests = do
          agentViaProxyRetryNoSession
      describe "stress test 1k" $ do
        let deliver nAgents nMsgs = agentDeliverMessagesViaProxyConc (replicate nAgents [srv1]) (map bshow [1 :: Int .. nMsgs])
-        it "2 agents, 250 messages" $ oneServer $ deliver 2 250
+        it "2 agents, 250 messages" . oneServer $ deliver 2 250
+        it "5 agents, 10 pairs, 50 messages, N1" . oneServer . withNumCapabilities 1 $ deliver 5 50
+        it "5 agents, 10 pairs, 50 messages. N4" . oneServer . withNumCapabilities 4 $ deliver 5 50
      xdescribe "stress test 10k" $ do
        let deliver nAgents nMsgs = agentDeliverMessagesViaProxyConc (replicate nAgents [srv1]) (map bshow [1 :: Int .. nMsgs])
-        it "25 agents, 300 pairs, 17 messages" $ oneServer $ withNumCapabilities 4 $ deliver 25 17
+        it "25 agents, 300 pairs, 17 messages" . oneServer . withNumCapabilities 4 $ deliver 25 17
  where
+    oneServer test msType = withSmpServerConfigOn (transport @TLS) (updateCfg (proxyCfgMS msType) $ \cfg_ -> cfg_ {msgQueueQuota = 128, maxJournalMsgCount = 256}) testPort $ const test
    twoServers test msType = twoServers_ (proxyCfgMS msType) (proxyCfgMS msType) test msType
    twoServersFirstProxy test msType = twoServers_ (proxyCfgMS msType) (updateCfg (cfgMS msType) $ \cfg_ -> cfg_ {msgQueueQuota = 128, maxJournalMsgCount = 256}) test msType
    twoServersMoreConc test msType = twoServers_ (updateCfg (proxyCfgMS msType) $ \cfg_ -> cfg_ {serverClientConcurrency = 128}) (updateCfg (cfgMS msType) $ \cfg_ -> cfg_ {msgQueueQuota = 128, maxJournalMsgCount = 256}) test msType
    twoServersNoConc test msType = twoServers_ (updateCfg (proxyCfgMS msType) $ \cfg_ -> cfg_ {serverClientConcurrency = 1}) (updateCfg (cfgMS msType) $ \cfg_ -> cfg_ {msgQueueQuota = 128, maxJournalMsgCount = 256}) test msType
-    twoServersPrevProxy test msType = twoServers_ (proxyCfgVPrev msType) (cfgMS msType) test msType
-    twoServersPrevRelay test msType = twoServers_ (proxyCfgMS msType) (prevServerVRange $ cfgMS msType) test msType
-    prevServerVRange cfg' = updateCfg cfg' $ \cfg_ -> cfg_ {smpServerVRange = prevRange $ smpServerVRange cfg_}
-    twoServers_ :: HasTestEnv => AServerConfig -> AServerConfig -> IO () -> AStoreType -> IO ()
+    twoServers_ :: AServerConfig -> AServerConfig -> IO () -> AStoreType -> IO ()
    twoServers_ cfg1 cfg2 runTest (ASType qsType _) =
      withSmpServerConfigOn (transport @TLS) cfg1 testPort $ \_ ->
        let cfg2' = case qsType of
@@ -168,27 +163,15 @@ smpProxyTests = do
              SQSPostgres -> journalCfgDB cfg2 testStoreDBOpts2 testStoreMsgsDir2
         in withSmpServerConfigOn (transport @TLS) cfg2' testPort2 $ const runTest

-smpProxyCapabilityTests :: SpecWith AStoreType
-smpProxyCapabilityTests = do
-  let deliver nAgents nMsgs = agentDeliverMessagesViaProxyConc (replicate nAgents [testSMPServer]) (map bshow [1 :: Int .. nMsgs])
-  it "5 agents, 10 pairs, 50 messages, N1" $ oneServer $ withNumCapabilities 1 $ deliver 5 50
-  it "5 agents, 10 pairs, 50 messages. N4" $ oneServer $ withNumCapabilities 4 $ deliver 5 50
-
-oneServer :: HasTestEnv => IO a -> AStoreType -> IO a
-oneServer test msType = withSmpServerConfigOn (transport @TLS) (updateCfg (proxyCfgMS msType) $ \cfg_ -> cfg_ {msgQueueQuota = 128, maxJournalMsgCount = 256}) testPort $ const test
-
 deliverMessageViaProxy :: (C.AlgorithmI a, C.AuthAlgorithm a) => SMPServer -> SMPServer -> C.SAlgorithm a -> ByteString -> ByteString -> IO ()
 deliverMessageViaProxy proxyServ relayServ alg msg msg' = deliverMessagesViaProxy proxyServ relayServ alg [msg] [msg']

 deliverMessagesViaProxy :: (C.AlgorithmI a, C.AuthAlgorithm a) => SMPServer -> SMPServer -> C.SAlgorithm a -> [ByteString] -> [ByteString] -> IO ()
-deliverMessagesViaProxy = deliverMessagesViaProxyVR $ mkVersionRange minServerSMPRelayVersion currentClientSMPRelayVersion
-
-deliverMessagesViaProxyVR :: (C.AlgorithmI a, C.AuthAlgorithm a) => VersionRangeSMP -> SMPServer -> SMPServer -> C.SAlgorithm a -> [ByteString] -> [ByteString] -> IO ()
-deliverMessagesViaProxyVR clientVR proxyServ relayServ alg unsecuredMsgs securedMsgs = do
+deliverMessagesViaProxy proxyServ relayServ alg unsecuredMsgs securedMsgs = do
  g <- C.newRandom
  -- set up proxy
  ts <- getCurrentTime
-  pc' <- getProtocolClient g NRMInteractive (1, proxyServ, Nothing) defaultSMPClientConfig {serverVRange = clientVR, proxiedRelayVRange = clientVR} [] Nothing ts (\_ -> pure ())
+  pc' <- getProtocolClient g NRMInteractive (1, proxyServ, Nothing) defaultSMPClientConfig {serverVRange = mkVersionRange minServerSMPRelayVersion currentClientSMPRelayVersion} [] Nothing ts (\_ -> pure ())
  pc <- either (fail . show) pure pc'
  THAuthClient {} <- maybe (fail "getProtocolClient returned no thAuth") pure $ thAuth $ thParams pc
  -- set up relay
@@ -243,7 +226,7 @@ proxyConnectDeadRelay n d proxyServ = do
      Right !_noWay -> error "got unexpected client"
      Left !_err -> threadDelay d

-agentDeliverMessageViaProxy :: (HasTestEnv, C.AlgorithmI a, C.AuthAlgorithm a) => (NonEmpty SMPServer, SMPProxyMode, Bool) -> (NonEmpty SMPServer, SMPProxyMode, Bool) -> C.SAlgorithm a -> ByteString -> ByteString -> AgentMsgId -> IO ()
+agentDeliverMessageViaProxy :: (C.AlgorithmI a, C.AuthAlgorithm a) => (NonEmpty SMPServer, SMPProxyMode, Bool) -> (NonEmpty SMPServer, SMPProxyMode, Bool) -> C.SAlgorithm a -> ByteString -> ByteString -> AgentMsgId -> IO ()
 agentDeliverMessageViaProxy aTestCfg@(aSrvs, _, aViaProxy) bTestCfg@(bSrvs, _, bViaProxy) alg msg1 msg2 baseId =
  withAgent 1 aCfg (servers aTestCfg) testDB $ \alice ->
    withAgent 2 aCfg (servers bTestCfg) testDB2 $ \bob -> runRight_ $ do
@@ -282,7 +265,7 @@ agentDeliverMessageViaProxy aTestCfg@(aSrvs, _, aViaProxy) bTestCfg@(bSrvs, _, b
    aCfg = agentCfg {sndAuthAlg = C.AuthAlg alg, rcvAuthAlg = C.AuthAlg alg}
    servers (srvs, smpProxyMode, _) = (initAgentServersProxy_ smpProxyMode SPFAllow) {smp = userServers srvs}

-agentDeliverMessagesViaProxyConc :: HasTestEnv => [NonEmpty SMPServer] -> [MsgBody] -> IO ()
+agentDeliverMessagesViaProxyConc :: [NonEmpty SMPServer] -> [MsgBody] -> IO ()
 agentDeliverMessagesViaProxyConc agentServers msgs =
  withAgents $ \agents -> do
    let pairs = combinations 2 agents
@@ -349,7 +332,7 @@ agentDeliverMessagesViaProxyConc agentServers msgs =
    aCfg = agentCfg {sndAuthAlg = C.AuthAlg C.SEd448, rcvAuthAlg = C.AuthAlg C.SEd448}
    servers srvs = (initAgentServersProxy_ SPMAlways SPFAllow) {smp = userServers srvs}

-agentViaProxyRetryOffline :: HasTestEnv => IO ()
+agentViaProxyRetryOffline :: IO ()
 agentViaProxyRetryOffline = do
  let srv1 = SMPServer testHost testPort testKeyHash
      srv2 = SMPServer testHost testPort2 testKeyHash
@@ -422,7 +405,7 @@ agentViaProxyRetryOffline = do
    msgId = subtract baseId . fst
    servers srv = initAgentServersProxy {smp = userServers [srv]}

-agentViaProxyRetryNoSession :: HasTestEnv => IO ()
+agentViaProxyRetryNoSession :: IO ()
 agentViaProxyRetryNoSession = do
  let srv1 = SMPServer testHost testPort testKeyHash
      srv2 = SMPServer testHost testPort2 testKeyHash
@@ -442,14 +425,14 @@ agentViaProxyRetryNoSession = do
    withServer2 = withSmpServerConfigOn (transport @TLS) proxyCfgJ2 testPort2
    servers srv = initAgentServersProxy {smp = userServers [srv]}

-testNoProxy :: HasTestEnv => AStoreType -> IO ()
+testNoProxy :: AStoreType -> IO ()
 testNoProxy msType = do
  withSmpServerConfigOn (transport @TLS) (cfgMS msType) testPort2 $ \_ -> do
    testSMPClient_ "127.0.0.1" testPort2 supportedServerSMPRelayVRange Nothing $ \(th :: THandleSMP TLS 'TClient) -> do
      (_, _, reply) <- sendRecv th (Nothing, "0", NoEntity, SMP.PRXY testSMPServer Nothing)
      reply `shouldBe` Right (SMP.ERR $ SMP.PROXY SMP.BASIC_AUTH)

-testProxyAuth :: HasTestEnv => AStoreType -> IO ()
+testProxyAuth :: AStoreType -> IO ()
 testProxyAuth msType = do
  withSmpServerConfigOn (transport @TLS) proxyCfgAuth testPort $ \_ -> do
    testSMPClient_ "127.0.0.1" testPort supportedServerSMPRelayVRange Nothing $ \(th :: THandleSMP TLS 'TClient) -> do
@@ -460,55 +443,15 @@ testProxyAuth msType = do

 -- Connect a sender client to the proxy and request a relay session to testSMPServer2 (PRXY).
 -- On success the reply is PKEY; otherwise it is the proxy error for the relay connection.
-requestRelaySession :: HasTestEnv => IO (Either SMP.ErrorType SMP.BrokerMsg)
+requestRelaySession :: IO (Either SMP.ErrorType SMP.BrokerMsg)
 requestRelaySession =
  testSMPClient_ "localhost" testPort supportedServerSMPRelayVRange Nothing $ \(th :: THandleSMP TLS 'TClient) ->
    (\(_, _, reply) -> reply) <$> sendRecv th (Nothing, "1", NoEntity, SMP.PRXY testSMPServer2 Nothing)

-testChangedFwdVersion :: HasTestEnv => IO ()
-testChangedFwdVersion =
-  withSmpServerConfigOn (transport @TLS) cfg testPort $ \_ -> do
-    g <- C.newRandom
-    ts <- getCurrentTime
-    rc <- either (fail . show) pure =<< getProtocolClient g NRMInteractive (1, testSMPServer, Nothing) defaultSMPClientConfig [] Nothing ts (\_ -> pure ())
-    THAuthClient {peerServerPubKey} <- maybe (fail "getProtocolClient returned no thAuth") pure $ thAuth $ thParams rc
-    (cmdPubKey, cmdPrivKey) <- atomically $ C.generateKeyPair g
-    nonce@(C.CbNonce corrId) <- atomically $ C.randomCbNonce g
-    let v = currentClientSMPRelayVersion
-    et <- either (fail . show) (pure . SMP.EncTransmission) $ C.cbEncrypt (C.dh' peerServerPubKey cmdPrivKey) (SMP.encTransmissionNonce v nonce) "" SMP.paddedProxiedTLength
-    let forward fwdVersion = forwardSMPTransmission rc (either error id $ C.corrCbNonce corrId) fwdVersion cmdPubKey et
-    _ <- runExceptT' $ forward v
-    runExceptT (forward $ prevVersion v) `shouldReturn` Left (PCEProtocolError SMP.CRYPTO)
-
-testFwdCorrIdSize :: HasTestEnv => IO ()
-testFwdCorrIdSize =
-  withSmpServerConfigOn (transport @TLS) proxyCfg testPort $ \_ ->
-    withSmpServerConfigOn (transport @TLS) cfgJ2 testPort2 $ \_ ->
-      testSMPClient_ "localhost" testPort supportedServerSMPRelayVRange Nothing $ \(th :: THandleSMP TLS 'TClient) -> do
-        (_, _, Right (SMP.PKEY sessId _ _)) <- sendRecv th (Nothing, "1", NoEntity, SMP.PRXY testSMPServer2 Nothing)
-        g <- C.newRandom
-        (cmdPubKey, _) <- atomically $ C.generateKeyPair g
-        forM_ (["", "2", "3333333333333333333333333"] :: [ByteString]) $ \corrId -> do
-          (_, _, reply) <- sendRecv th (Nothing, corrId, SMP.EntityId sessId, SMP.PFWD currentClientSMPRelayVersion cmdPubKey (SMP.EncTransmission ""))
-          reply `shouldBe` Right (SMP.ERR $ SMP.CMD SMP.SYNTAX)
-
-testForwardedAuthErrorDelay :: HasTestEnv => IO ()
-testForwardedAuthErrorDelay =
-  withSmpServerConfigOn (transport @TLS) proxyCfg testPort $ \_ ->
-    withSmpServerConfigOn (transport @TLS) (updateCfg cfgJ2 $ \cfg_ -> cfg_ {authErrorDelay = 500000}) testPort2 $ \_ -> do
-      g <- C.newRandom
-      ts <- getCurrentTime
-      pc <- either (fail . show) pure =<< getProtocolClient g NRMInteractive (1, testSMPServer, Nothing) defaultSMPClientConfig [] Nothing ts (\_ -> pure ())
-      sess <- runExceptT' $ connectSMPProxiedRelay pc NRMInteractive testSMPServer2 Nothing
-      (sendTime, Left (PCEProtocolError SMP.AUTH)) <- responseTime $ runExceptT $ proxySMPMessage pc NRMInteractive sess Nothing (SMP.EntityId "1234") noMsgFlags "hello"
-      (getLinkTime, Left (PCEProtocolError SMP.AUTH)) <- responseTime $ runExceptT $ proxyGetSMPQueueLink pc NRMInteractive sess (SMP.EntityId "1234")
-      sendTime `shouldSatisfy` (>= 0.5)
-      getLinkTime `shouldSatisfy` (>= 0.5)
-
 -- Shared "phase 2" of the reconnection tests: start a healthy relay, confirm it is reachable
 -- directly (PING, not via the proxy) so a proxy failure can only mean the proxy didn't reconnect,
 -- let any stored connection error expire, then require the proxy to establish the session (PKEY).
-requireProxyReconnect :: HasTestEnv => IO ()
+requireProxyReconnect :: IO ()
 requireProxyReconnect =
  withSmpServerConfigOn (transport @TLS) proxyCfgJ2 testPort2 $ \_ -> do
    testSMPClient_ "127.0.0.1" testPort2 supportedServerSMPRelayVRange Nothing $ \(th :: THandleSMP TLS 'TClient) -> do
@@ -523,7 +466,7 @@ requireProxyReconnect =
 -- The connect fails by timing out (storing a Left error that self-heals via persistErrorInterval),
 -- so once a healthy relay is running the proxy reconnects. This proves the stalling relay alone
 -- does not cause the permanent failure - only the mid-connection disconnect does.
-testProxyRecoversWithoutDisconnect :: HasTestEnv => IO ()
+testProxyRecoversWithoutDisconnect :: IO ()
 testProxyRecoversWithoutDisconnect =
  withSmpServerConfigOn (transport @TLS) proxyCfgShortTimeout testPort $ \_ -> do
    withStallingServerOn testPort2 $
@@ -545,7 +488,7 @@ testProxyRecoversWithoutDisconnect =
 -- The stalling relay (accepts TCP, never completes TLS) holds the connect open long enough to
 -- interleave the disconnect. Phase 2 (requireProxyReconnect) is identical to the control above;
 -- the only difference is this disconnect.
-testProxyReconnectAfterRelayRestart :: HasTestEnv => IO ()
+testProxyReconnectAfterRelayRestart :: IO ()
 testProxyReconnectAfterRelayRestart =
  withSmpServerConfigOn (transport @TLS) proxyCfgShortTimeout testPort $ \_ -> do
    -- disconnect the sender 1s into the 4s connect to the stalling relay, killing the in-flight worker
@@ -559,7 +502,7 @@ testProxyReconnectAfterRelayRestart =
 -- skipped and the empty var is left in smpClients, so every later connection to that server times
 -- out on it. Phase 1 cancels a connect to a stalling relay; phase 2 requires a fresh connect to a
 -- healthy relay to succeed.
-testAgentClientReconnectAfterCancel :: HasTestEnv => IO ()
+testAgentClientReconnectAfterCancel :: IO ()
 testAgentClientReconnectAfterCancel =
  withAgent 1 agentCfg agentServersLeak testDB $ \a -> do
    withStallingServerOn testPort2 $ do
@@ -36,7 +36,6 @@ import Data.List.NonEmpty (NonEmpty)
 import Data.List (isPrefixOf)
 import Data.Maybe (catMaybes)
 import Data.String (IsString (..))
-import Data.Time.Clock (NominalDiffTime, diffUTCTime, getCurrentTime)
 import Text.Read (readMaybe)
 import Data.Type.Equality
 import qualified Data.X509.Validation as XV
@@ -59,9 +58,10 @@ import Simplex.Messaging.Transport.Credentials
 import Simplex.Messaging.Util (whenM)
 import System.Directory (doesDirectoryExist, doesFileExist, removeDirectoryRecursive, removeFile)
 import System.IO (IOMode (..), withFile)
+import System.TimeIt (timeItT)
 import System.Timeout
 import Test.HUnit
-import Test.Hspec hiding (fit, it, xit)
+import Test.Hspec hiding (fit, it)
 import Util

 #if defined(dbServerPostgres)
@@ -96,7 +96,7 @@ serverTests = do
  describe "Restore messages" testRestoreMessages
  describe "Restore messages (old / v2)" testRestoreExpireMessages
  describe "Save prometheus metrics" testPrometheusMetrics
-  describe "Delay of AUTH error" testAuthErrorDelay
+  describe "Timing of AUTH error" testTiming
  describe "Message notifications" $ do
    testMessageNotifications
    testMessageServiceNotifications
@@ -166,7 +166,7 @@ signSend_ h@THandle {params} (C.APrivateAuthKey a pk) serviceKey_ (corrId, qId,
    authorize t = (,(`C.sign'` t) <$> serviceKey_) <$> case a of
      C.SEd25519 -> Just . TASignature . C.ASignature C.SEd25519 $ C.sign' pk t'
      C.SEd448 -> Just . TASignature . C.ASignature C.SEd448 $ C.sign' pk t'
-      C.SX25519 -> (\THAuthClient {peerServerPubKey = k} -> TAAuthenticator $ C.cbAuthenticate k pk (C.unsafeCbNonce corrId) t') <$> thAuth params
+      C.SX25519 -> (\THAuthClient {peerServerPubKey = k} -> TAAuthenticator $ C.cbAuthenticate k pk (C.cbNonce corrId) t') <$> thAuth params
 #if !MIN_VERSION_base(4,18,0)
      _sx448 -> undefined -- ghc8107 fails to the branch excluded by types
 #endif
@@ -194,12 +194,12 @@ _SEND = SEND noMsgFlags
 _SEND' :: MsgBody -> Command 'Sender
 _SEND' = SEND MsgFlags {notification = True}

-decryptMsgV2 :: C.DhSecret 'C.X25519 -> MsgId -> ByteString -> Either C.CryptoError ByteString
-decryptMsgV2 = C.cbDecrypt
+decryptMsgV2 :: C.DhSecret 'C.X25519 -> ByteString -> ByteString -> Either C.CryptoError ByteString
+decryptMsgV2 dhShared = C.cbDecrypt dhShared . C.cbNonce

-decryptMsgV3 :: C.DhSecret 'C.X25519 -> MsgId -> ByteString -> Either String MsgBody
+decryptMsgV3 :: C.DhSecret 'C.X25519 -> ByteString -> ByteString -> Either String MsgBody
 decryptMsgV3 dhShared nonce body =
-  case parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt dhShared nonce body) of
+  case parseAll clientRcvMsgBodyP =<< first show (C.cbDecrypt dhShared (C.cbNonce nonce) body) of
    Right ClientRcvMsgBody {msgBody} -> Right msgBody
    Right ClientRcvMsgQuota {} -> Left "ClientRcvMsgQuota"
    Left e -> Left e
@@ -425,7 +425,7 @@ testCreateDelete =
      Resp "dabc" _ err8 <- sendRecv sh ("", "dabc", sId, _SEND "hello")
      (err8, ERR AUTH) #== "rejects unsigned SEND too when deleted"

-      Resp "abcd" _ err11 <- signSendRecv rh rKey ("abcd", rId, ACK mId2)
+      Resp "abcd" _ err11 <- signSendRecv rh rKey ("abcd", rId, ACK "")
      (err11, ERR AUTH) #== "rejects ACK when conn deleted - the second message is deleted"

      Resp "bcda" _ err9 <- signSendRecv rh rKey ("bcda", rId, OFF)
@@ -609,7 +609,7 @@ testGetSubCommands =
      Resp "4" _ (Msg mId2 msg2) <- signSendRecv rh1 rKey ("4", rId, ACK mId1)
      (dec mId2 msg2, Right "hello 2") #== "received from queue via SUB"
      -- bad msgId returns error
-      Resp "5" _ (ERR NO_MSG) <- signSendRecv rh2 rKey ("5", rId, ACK mId2)
+      Resp "5" _ (ERR NO_MSG) <- signSendRecv rh2 rKey ("5", rId, ACK "1234")
      -- already ACK'd by subscriber, but still returns OK when msgId matches
      Resp "5a" _ OK <- signSendRecv rh2 rKey ("5a", rId, ACK mId1)
      -- msg2 is not lost - even if subscriber does not ACK it, it is delivered to getter
@@ -904,7 +904,7 @@ testServiceSubsTotalCount =
                _ -> pure Nothing
            ]
        threadDelay 1500000
-        B.readFile testPrometheusMetricsFile >>= \m -> readServiceSubsMetric (B.unpack m) `shouldBe` Just 2
+        readFile testPrometheusMetricsFile >>= \m -> readServiceSubsMetric m `shouldBe` Just 2

      -- Phase 2: associate 1 more queue via SUB, reconnect with SUBS 3, check metric = 3
      (rPub3, rKey3) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
@@ -934,7 +934,7 @@ testServiceSubsTotalCount =
                _ -> pure Nothing
            ]
        threadDelay 1500000
-        B.readFile testPrometheusMetricsFile >>= \m -> readServiceSubsMetric (B.unpack m) `shouldBe` Just 3
+        readFile testPrometheusMetricsFile >>= \m -> readServiceSubsMetric m `shouldBe` Just 3

 readServiceSubsMetric :: String -> Maybe Int
 readServiceSubsMetric content =
@@ -1034,15 +1034,15 @@ testWithStoreLog =
    logSize testStoreLogFile `shouldReturn` (if compacting then 1 else 6)
    removeFile testStoreLogFile
  where
-    runTest :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
+    runTest :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
    runTest _ test' server = do
      testSMPClient test' `shouldReturn` ()
      killThread server

-    runClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
+    runClient :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
    runClient _ test' = testSMPClient test' `shouldReturn` ()

-serverStoreLogCfg :: HasTestEnv => AStoreType -> (AServerConfig, Bool)
+serverStoreLogCfg :: AStoreType -> (AServerConfig, Bool)
 serverStoreLogCfg msType =
  let cfg' =
        withServerCfg (cfgMS msType) $ \cfg_ ->
@@ -1141,12 +1141,12 @@ testRestoreMessages =
    whenM (doesDirectoryExist testStoreMsgsDir) $ removeDirectoryRecursive testStoreMsgsDir
    removeFile testServerStatsBackupFile
  where
-    runTest :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
+    runTest :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
    runTest _ test' server = do
      testSMPClient test' `shouldReturn` ()
      killThread server

-    runClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
+    runClient :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
    runClient _ test' = testSMPClient test' `shouldReturn` ()

 checkStats :: ServerStatsData -> [RecipientId] -> Int -> Int -> Expectation
@@ -1216,7 +1216,7 @@ testRestoreExpireMessages =
    Right ServerStatsData {_msgExpired} <- strDecode <$> B.readFile testServerStatsBackupFile
    _msgExpired `shouldBe` 2
  where
-    exportStoreMessages :: HasTestEnv => AStoreType -> IO ()
+    exportStoreMessages :: AStoreType -> IO ()
    exportStoreMessages = \case
      ASType _ SMSJournal -> export
      ASType _ SMSPostgres -> exportDB
@@ -1240,12 +1240,12 @@ testRestoreExpireMessages =
          readWriteQueueStore True (mkQueue ms True) testStoreLogFile (stmQueueStore ms) >>= closeStoreLog
          removeFileIfExists testStoreMsgsFile
          pure ms
-    runTest :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
+    runTest :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> ThreadId -> Expectation
    runTest _ test' server = do
      testSMPClient test' `shouldReturn` ()
      killThread server

-    runClient :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
+    runClient :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO ()) -> Expectation
    runClient _ test' = testSMPClient test' `shouldReturn` ()

 testPrometheusMetrics :: SpecWith (ASrvTransport, AStoreType)
@@ -1274,21 +1274,21 @@ testTiming =
        smpTest2Cfg (cfgMS msType) supportedServerSMPRelayVRange t $ \rh sh ->
          testSameTiming rh sh tst msType
  where
-    testName :: (C.AuthAlg, C.AuthAlg) -> String
-    testName (C.AuthAlg goodKeyAlg, C.AuthAlg badKeyAlg) = unwords ["queue key:", show goodKeyAlg, "/ used key:", show badKeyAlg]
-    timingTests :: [(C.AuthAlg, C.AuthAlg)]
+    testName :: (C.AuthAlg, C.AuthAlg, Int) -> String
+    testName (C.AuthAlg goodKeyAlg, C.AuthAlg badKeyAlg, _) = unwords ["queue key:", show goodKeyAlg, "/ used key:", show badKeyAlg]
+    timingTests :: [(C.AuthAlg, C.AuthAlg, Int)]
    timingTests =
-      [ (C.AuthAlg C.SEd25519, C.AuthAlg C.SEd25519), -- correct key type
-      -- (C.AuthAlg C.SEd25519, C.AuthAlg C.SEd448),
-      -- (C.AuthAlg C.SEd25519, C.AuthAlg C.SX25519),
-        (C.AuthAlg C.SEd448, C.AuthAlg C.SEd25519),
-        (C.AuthAlg C.SEd448, C.AuthAlg C.SEd448), -- correct key type
-        (C.AuthAlg C.SEd448, C.AuthAlg C.SX25519),
-        (C.AuthAlg C.SX25519, C.AuthAlg C.SEd25519),
-        (C.AuthAlg C.SX25519, C.AuthAlg C.SEd448),
-        (C.AuthAlg C.SX25519, C.AuthAlg C.SX25519) -- correct key type
+      [ (C.AuthAlg C.SEd25519, C.AuthAlg C.SEd25519, 200), -- correct key type
+      -- (C.AuthAlg C.SEd25519, C.AuthAlg C.SEd448, 150),
+      -- (C.AuthAlg C.SEd25519, C.AuthAlg C.SX25519, 200),
+        (C.AuthAlg C.SEd448, C.AuthAlg C.SEd25519, 200),
+        (C.AuthAlg C.SEd448, C.AuthAlg C.SEd448, 150), -- correct key type
+        (C.AuthAlg C.SEd448, C.AuthAlg C.SX25519, 200),
+        (C.AuthAlg C.SX25519, C.AuthAlg C.SEd25519, 200),
+        (C.AuthAlg C.SX25519, C.AuthAlg C.SEd448, 150),
+        (C.AuthAlg C.SX25519, C.AuthAlg C.SX25519, 200) -- correct key type
      ]
-    timeRepeat = fmap fst . responseTime . replicateM_ 5
+    timeRepeat n = fmap fst . timeItT . forM_ (replicate n ()) . const
    similarTime t1 t2 msType
      | t1 <= t2 = abs (1 - t1 / t2) < diff
      | otherwise = similarTime t2 t1 msType
@@ -1297,14 +1297,14 @@ testTiming =
        diff = case msType of
          ASType SQSPostgres _ -> 0.45
          _ -> 0.3
-    testSameTiming :: forall c. Transport c => THandleSMP c 'TClient -> THandleSMP c 'TClient -> (C.AuthAlg, C.AuthAlg) -> AStoreType -> Expectation
-    testSameTiming rh sh (C.AuthAlg goodKeyAlg, C.AuthAlg badKeyAlg) msType = do
+    testSameTiming :: forall c. Transport c => THandleSMP c 'TClient -> THandleSMP c 'TClient -> (C.AuthAlg, C.AuthAlg, Int) -> AStoreType -> Expectation
+    testSameTiming rh sh (C.AuthAlg goodKeyAlg, C.AuthAlg badKeyAlg, n) msType = do
      g <- C.newRandom
      (rPub, rKey) <- atomically $ C.generateAuthKeyPair goodKeyAlg g
      (dhPub, dhPriv :: C.PrivateKeyX25519) <- atomically $ C.generateKeyPair g
-      Resp "abcdabcdabcdabcdabcdabcd" NoEntity (Ids rId sId srvDh) <- signSendRecv rh rKey ("abcdabcdabcdabcdabcdabcd", NoEntity, New rPub dhPub)
+      Resp "abcd" NoEntity (Ids rId sId srvDh) <- signSendRecv rh rKey ("abcd", NoEntity, New rPub dhPub)
      let dec = decryptMsgV3 $ C.dh' srvDh dhPriv
-      Resp "cdabcdabcdabcdabcdabcdab" _ resp <- signSendRecv rh rKey ("cdabcdabcdabcdabcdabcdab", rId, SUB)
+      Resp "cdab" _ resp <- signSendRecv rh rKey ("cdab", rId, SUB)
      case resp of
        OK -> pure ()
        SOK Nothing -> pure ()
@@ -1314,9 +1314,9 @@ testTiming =
      runTimingTest rh badKey rId SUB

      (sPub, sKey) <- atomically $ C.generateAuthKeyPair goodKeyAlg g
-      Resp "dabcdabcdabcdabcdabcdabc" _ OK <- signSendRecv rh rKey ("dabcdabcdabcdabcdabcdabc", rId, KEY sPub)
+      Resp "dabc" _ OK <- signSendRecv rh rKey ("dabc", rId, KEY sPub)

-      Resp "bcdabcdabcdabcdabcdabcda" _ OK <- signSendRecv sh sKey ("bcdabcdabcdabcdabcdabcda", sId, _SEND "hello")
+      Resp "bcda" _ OK <- signSendRecv sh sKey ("bcda", sId, _SEND "hello")
      Resp "" _ (Msg mId msg) <- tGet1 rh
      (dec mId msg, Right "hello") #== "delivered from queue"

@@ -1325,23 +1325,21 @@ testTiming =
        runTimingTest :: PartyI p => THandleSMP c 'TClient -> C.APrivateAuthKey -> EntityId -> Command p -> IO ()
        runTimingTest h badKey qId cmd = do
          threadDelay 100000
-          _ <- timeRepeat $ do
+          _ <- timeRepeat n $ do
            -- "warm up" the server
-            Resp "dabcdabcdabcdabcdabcdabc" _ (ERR AUTH) <- signSendRecv h badKey ("dabcdabcdabcdabcdabcdabc", EntityId "1234", cmd)
+            Resp "dabc" _ (ERR AUTH) <- signSendRecv h badKey ("dabc", EntityId "1234", cmd)
            return ()
          threadDelay 100000
-          timeWrongKey <- timeRepeat $ do
-            Resp "cdabcdabcdabcdabcdabcdab" _ (ERR AUTH) <- signSendRecv h badKey ("cdabcdabcdabcdabcdabcdab", qId, cmd)
+          timeWrongKey <- timeRepeat n $ do
+            Resp "cdab" _ (ERR AUTH) <- signSendRecv h badKey ("cdab", qId, cmd)
            return ()
          threadDelay 100000
-          timeNoQueue <- timeRepeat $ do
-            Resp "dabcdabcdabcdabcdabcdabc" _ (ERR AUTH) <- signSendRecv h badKey ("dabcdabcdabcdabcdabcdabc", EntityId "1234", cmd)
+          timeNoQueue <- timeRepeat n $ do
+            Resp "dabc" _ (ERR AUTH) <- signSendRecv h badKey ("dabc", EntityId "1234", cmd)
            return ()
          let ok = similarTime timeNoQueue timeWrongKey msType
-          putStrLn . unwords $
-            [ "DEBUG timing",
-              show ok,
-              show goodKeyAlg,
+          unless ok . putStrLn . unwords $
+            [ show goodKeyAlg,
              show badKeyAlg,
              show timeWrongKey,
              show timeNoQueue,
@@ -1349,33 +1347,6 @@ testTiming =
            ]
          ok `shouldBe` True

-testAuthErrorDelay :: SpecWith (ASrvTransport, AStoreType)
-testAuthErrorDelay =
-  it "should send AUTH errors after the delay and other responses without it" $ \(ATransport t, msType) ->
-    smpTest2Cfg (updateCfg (cfgMS msType) $ \cfg' -> cfg' {authErrorDelay = 500000}) supportedClientSMPRelayVRange t $ \rh sh -> do
-      g <- C.newRandom
-      (rPub, rKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-      (dhPub, _ :: C.PrivateKeyX25519) <- atomically $ C.generateKeyPair g
-      Resp "1" NoEntity (Ids rId sId _) <- signSendRecv rh rKey ("1", NoEntity, New rPub dhPub)
-      (_, badKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-      (wrongKeyTime, Resp "2" _ (ERR AUTH)) <- responseTime $ signSendRecv rh badKey ("2", rId, SUB)
-      (noQueueTime, Resp "3" _ (ERR AUTH)) <- responseTime $ signSendRecv rh badKey ("3", EntityId "1234", SUB)
-      (noLinkTime, Resp "4" _ (ERR AUTH)) <- responseTime $ sendRecv sh ("", "4", EntityId "1234", LGET)
-      (subTime, Resp "5" _ (SOK Nothing)) <- responseTime $ signSendRecv rh rKey ("5", rId, SUB)
-      Resp "6" _ OK <- signSendRecv rh rKey ("6", rId, OFF)
-      (suspendedTime, Resp "7" _ (ERR AUTH)) <- responseTime $ sendRecv sh ("", "7", sId, _SEND "hello")
-      wrongKeyTime `shouldSatisfy` (>= 0.5)
-      noQueueTime `shouldSatisfy` (>= 0.5)
-      suspendedTime `shouldSatisfy` (>= 0.5)
-      noLinkTime `shouldSatisfy` (>= 0.5)
-      subTime `shouldSatisfy` (< 0.5)
-
-responseTime :: IO a -> IO (NominalDiffTime, a)
-responseTime action = do
-  t <- getCurrentTime
-  r <- action
-  (,r) . (`diffUTCTime` t) <$> getCurrentTime
-
 testMessageNotifications :: SpecWith (ASrvTransport, AStoreType)
 testMessageNotifications =
  it "should create simplex connection, subscribe notifier and deliver notifications" $ \(ATransport t, msType) -> do
@@ -1540,7 +1511,7 @@ testServiceNotificationsTwoRestarts =
        Resp "3.2" _ (SOK Nothing) <- signSendRecv rh rKey ("3.2", rId, SUB)
        deliverMessage rh rId rKey sh sId sKey nh "hello 3" dec
    where
-      runTest2 :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO a) -> ThreadId -> IO a
+      runTest2 :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> THandleSMP c 'TClient -> IO a) -> ThreadId -> IO a
      runTest2 _ test' server = do
        a <- testSMPClient $ \h1 -> testSMPClient $ \h2 -> test' h1 h2
        killThread server
@@ -1631,7 +1602,7 @@ testBlockMessageQueue =
      Resp "dabc" sId2 (ERR (BLOCKED (BlockingInfo BRContent Nothing))) <- signSendRecv h sKey ("dabc", sId, SKEY sPub)
      (sId2, sId) #== "same queue ID in response"
  where
-    runTest :: (HasTestEnv, Transport c) => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO a) -> ThreadId -> IO a
+    runTest :: Transport c => TProxy c 'TServer -> (THandleSMP c 'TClient -> IO a) -> ThreadId -> IO a
    runTest _ test' server = do
      a <- testSMPClient test'
      killThread server
@@ -1843,10 +1814,10 @@ serverSyntaxTests (ATransport t) = do
    it "no parameters" $ (sampleSig, "abcd", "12345678", SEND_) >#> ("", "abcd", "12345678", ERR $ CMD SYNTAX)
    it "no queue ID" $ (sampleSig, "bcda", "", (SEND_, ' ', noMsgFlags, ' ', "hello" :: ByteString)) >#> ("", "bcda", "", ERR $ CMD NO_ENTITY)
  describe "ACK" $ do
-    it "valid syntax" $ (sampleSig, "cdab", "12345678", (ACK_, ' ', "123456789012345678901234" :: ByteString)) >#> ("", "cdab", "12345678", ERR AUTH)
+    it "valid syntax" $ (sampleSig, "cdab", "12345678", (ACK_, ' ', "1234" :: ByteString)) >#> ("", "cdab", "12345678", ERR AUTH)
    it "no parameters" $ (sampleSig, "abcd", "12345678", ACK_) >#> ("", "abcd", "12345678", ERR $ CMD SYNTAX)
-    it "no queue ID" $ (sampleSig, "bcda", "", (ACK_, ' ', "123456789012345678901234" :: ByteString)) >#> ("", "bcda", "", ERR $ CMD NO_AUTH)
-    it "no signature" $ ("", "cdab", "12345678", (ACK_, ' ', "123456789012345678901234" :: ByteString)) >#> ("", "cdab", "12345678", ERR $ CMD NO_AUTH)
+    it "no queue ID" $ (sampleSig, "bcda", "", (ACK_, ' ', "1234" :: ByteString)) >#> ("", "bcda", "", ERR $ CMD NO_AUTH)
+    it "no signature" $ ("", "cdab", "12345678", (ACK_, ' ', "1234" :: ByteString)) >#> ("", "cdab", "12345678", ERR $ CMD NO_AUTH)
  describe "PING" $ do
    it "valid syntax" $ ("", "abcd", "", PING_) >#> ("", "abcd", "", PONG)
  describe "broker response not allowed" $ do
@@ -1859,7 +1830,7 @@ serverSyntaxTests (ATransport t) = do
      it "no signature" $ ("", "cdab", "12345678", cmd) >#> ("", "cdab", "12345678", ERR $ CMD NO_AUTH)
      it "no queue ID" $ (sampleSig, "dabc", "", cmd) >#> ("", "dabc", "", ERR $ CMD NO_AUTH)
    (>#>) ::
-      (HasTestEnv, Encoding smp) =>
+      Encoding smp =>
      (Maybe TAuthorizations, ByteString, ByteString, smp) ->
      (Maybe TAuthorizations, ByteString, ByteString, BrokerMsg) ->
      Expectation
@@ -1,10 +1,11 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE TypeApplications #-}

 import AgentTests (agentCoreTests, agentTests)
-import AgentTests.FunctionalAPITests (functionalAPITimingTests)
 import CLITests
-import Control.Exception (bracket_)
+import Control.Concurrent (threadDelay)
+import qualified Control.Exception as E
 import Control.Logger.Simple
 import CoreTests.BatchingTests
 import CoreTests.CryptoFileTests
@@ -18,16 +19,18 @@ import CoreTests.TSessionSubs
 import CoreTests.UtilTests
 import CoreTests.VersionRangeTests
 import FileDescriptionTests (fileDescriptionTests)
+import GHC.IO.Exception (IOException (..))
+import qualified GHC.IO.Exception as IOException
 import RSLVTests (rslvTests)
 import RemoteControl (remoteControlTests)
 import SMPNamesTests (smpNamesTests)
-import SMPProxyTests (smpProxyCapabilityTests, smpProxyTests)
+import SMPProxyTests (smpProxyTests)
 import ServerTests
 import Simplex.Messaging.Server.Env.STM (AStoreType (..))
 import Simplex.Messaging.Server.MsgStore.Types (SMSType (..), SQSType (..))
 import Simplex.Messaging.Transport (TLS, Transport (..))
 -- import Simplex.Messaging.Transport.WebSockets (WS)
-import System.Directory (createDirectory, removePathForcibly)
+import System.Directory (createDirectoryIfMissing, removeDirectoryRecursive)
 import System.Environment (setEnv)
 import Test.Hspec hiding (fit, it)
 import Util
@@ -41,18 +44,18 @@ import XFTPWebTests (xftpWebTests)

 #if defined(dbPostgres)
 import Fixtures
+import SMPAgentClient (testDB)
 import Simplex.Messaging.Agent.Store.Postgres.Migrations.App
+import Simplex.Messaging.Agent.Store.Postgres.Util (dropAllSchemasExceptSystem)
 #else
 import AgentTests.SchemaDump (schemaDumpTest)
-import System.Directory (listDirectory)
-import System.FilePath ((</>))
 #endif

 #if defined(dbServerPostgres)
 import CoreTests.XFTPStoreTests (xftpStoreTests, xftpMigrationTests)
 import NtfServerTests (ntfServerTests)
-import NtfClient (ntfTestServerDBConnectInfo, ntfTestServerDBOpts)
-import SMPClient (testServerDBConnectInfo, testServerDBOpts)
+import NtfClient (ntfTestServerDBConnectInfo, ntfTestStoreDBOpts)
+import SMPClient (testServerDBConnectInfo, testStoreDBOpts)
 import Simplex.Messaging.Notifications.Server.Store.Migrations (ntfServerMigrations)
 import Simplex.Messaging.Server.QueueStore.Postgres.Migrations (serverMigrations)
 import XFTPClient (testXFTPDBConnectInfo)
@@ -72,54 +75,75 @@ main = do
  withGlobalLogging logCfg $ do
    setEnv "APNS_KEY_ID" "H82WD9K9AQ"
    setEnv "APNS_KEY_FILE" "./tests/fixtures/AuthKey_H82WD9K9AQ.p8"
-    withTmpDir . hspec
+    hspec
 #if defined(dbPostgres)
      . aroundAll_ (postgressBracket testDBConnectInfo)
 #endif
-#if defined(dbServerPostgres)
-      . aroundAll_ (postgressBracket testServerDBConnectInfo)
-      . aroundAll_ (postgressBracket ntfTestServerDBConnectInfo)
-      . aroundAll_ (postgressBracket testXFTPDBConnectInfo)
-#endif
+      . before_ (createDirectoryIfMissing False "tests/tmp")
+      . after_ (eventuallyRemove "tests/tmp" 3)
      $ do
-        parallel $ do
-          describe "Core tests" $ do
-            describe "Batching tests" batchingTests
-            describe "Encoding tests" encodingTests
-            describe "Version range" versionRangeTests
-            describe "Encryption tests" cryptoTests
-            describe "Encrypted files tests" cryptoFileTests
-            describe "Message store tests" msgStoreTests
-            describe "SOCKS settings tests" socksSettingsTests
-            describe "Store log tests" storeLogTests
-            describe "XFTP store log tests" fileStoreLogTests
-            fileExpirationTests
-            describe "TSessionSubs tests" tSessionSubsTests
-            describe "Util tests" utilTests
-            describe "Names resolver tests" smpNamesTests
-            describe "RSLV functional API tests" rslvTests
-            describe "Agent core tests" agentCoreTests
+        describe "Core tests" $ do
+          describe "Batching tests" batchingTests
+          describe "Encoding tests" encodingTests
+          describe "Version range" versionRangeTests
+          describe "Encryption tests" cryptoTests
+          describe "Encrypted files tests" cryptoFileTests
+          describe "Message store tests" msgStoreTests
+          describe "Retry interval tests" retryIntervalTests
+          describe "SOCKS settings tests" socksSettingsTests
 #if defined(dbServerPostgres)
+          around_ (postgressBracket testServerDBConnectInfo) $
+            describe "Store log tests" storeLogTests
+#else
+          describe "Store log tests" storeLogTests
+#endif
+          describe "XFTP store log tests" fileStoreLogTests
+          fileExpirationTests
+          describe "TSessionSubs tests" tSessionSubsTests
+          describe "Util tests" utilTests
+          describe "Names resolver tests" smpNamesTests
+          describe "RSLV functional API tests" rslvTests
+          describe "Agent core tests" agentCoreTests
+#if defined(dbServerPostgres)
+        around_ (postgressBracket testServerDBConnectInfo) $
+          describe "SMP server schema dump" $
+            postgresSchemaDumpTest
+              serverMigrations
+              [ "20250320_short_links" -- snd_secure moves to the bottom on down migration
+              ] -- skipComparisonForDownMigrations
+              testStoreDBOpts
+              "src/Simplex/Messaging/Server/QueueStore/Postgres/server_schema.sql"
+        around_ (postgressBracket testServerDBConnectInfo) $ do
          -- xdescribe "SMP server via TLS, postgres+jornal message store" $
          --   before (pure (transport @TLS, ASType SQSPostgres SMSJournal)) serverTests
          describe "SMP server via TLS, postgres-only message store" $
            before (pure (transport @TLS, ASType SQSPostgres SMSPostgres)) serverTests
 #endif
-          describe "SMP server via TLS, jornal message store" $ do
-            describe "SMP syntax" $ serverSyntaxTests (transport @TLS)
-            before (pure (transport @TLS, ASType SQSMemory SMSJournal)) serverTests
-          describe "SMP server via TLS, memory message store" $
-            before (pure (transport @TLS, ASType SQSMemory SMSMemory)) serverTests
-          -- xdescribe "SMP server via WebSockets" $ do
-          --   describe "SMP syntax" $ serverSyntaxTests (transport @WS)
-          --   before (pure (transport @WS, ASType SQSMemory SMSJournal)) serverTests
+        describe "SMP server via TLS, jornal message store" $ do
+          describe "SMP syntax" $ serverSyntaxTests (transport @TLS)
+          before (pure (transport @TLS, ASType SQSMemory SMSJournal)) serverTests
+        describe "SMP server via TLS, memory message store" $
+          before (pure (transport @TLS, ASType SQSMemory SMSMemory)) serverTests
+        -- xdescribe "SMP server via WebSockets" $ do
+        --   describe "SMP syntax" $ serverSyntaxTests (transport @WS)
+        --   before (pure (transport @WS, ASType SQSMemory SMSJournal)) serverTests
 #if defined(dbServerPostgres)
+        around_ (postgressBracket ntfTestServerDBConnectInfo) $
+          describe "Ntf server schema dump" $
+            postgresSchemaDumpTest
+              ntfServerMigrations
+              [] -- skipComparisonForDownMigrations
+              ntfTestStoreDBOpts
+              "src/Simplex/Messaging/Notifications/Server/Store/ntf_server_schema.sql"
+        around_ (postgressBracket ntfTestServerDBConnectInfo) $ do
          describe "Notifications server (SMP server: memory store)" $
            ntfServerTests (transport @TLS, ASType SQSMemory SMSMemory)
-          -- xdescribe "Notifications server (SMP server: postgres+jornal store)" $
-          --   ntfServerTests (transport @TLS, ASType SQSPostgres SMSJournal)
-          describe "Notifications server (SMP server: postgres-only store)" $
-            ntfServerTests (transport @TLS, ASType SQSPostgres SMSPostgres)
+          around_ (postgressBracket testServerDBConnectInfo) $ do
+            -- xdescribe "Notifications server (SMP server: postgres+jornal store)" $
+            --   ntfServerTests (transport @TLS, ASType SQSPostgres SMSJournal)
+            describe "Notifications server (SMP server: postgres-only store)" $
+              ntfServerTests (transport @TLS, ASType SQSPostgres SMSPostgres)
+        around_ (postgressBracket testServerDBConnectInfo) $ do
          -- xdescribe "SMP client agent, postgres+jornal message store" $ agentTests (transport @TLS, ASType SQSPostgres SMSJournal)
          describe "SMP client agent, server postgres-only message store" $ agentTests (transport @TLS, ASType SQSPostgres SMSPostgres)
          -- xdescribe "SMP proxy, postgres+jornal message store" $
@@ -127,86 +151,55 @@ main = do
          describe "SMP proxy, postgres-only message store" $
            before (pure $ ASType SQSPostgres SMSPostgres) smpProxyTests
 #endif
-          -- xdescribe "SMP client agent, server jornal message store" $ agentTests (transport @TLS, ASType SQSMemory SMSJournal)
-          describe "SMP client agent, server memory message store" $ agentTests (transport @TLS, ASType SQSMemory SMSMemory)
-          describe "SMP proxy, jornal message store" $
-            before (pure $ ASType SQSMemory SMSJournal) smpProxyTests
-          describe "XFTP" $ do
-            describe "XFTP server" $
-              before (pure $ AFSType SFSMemory) xftpServerTests
-            describe "XFTP file description" fileDescriptionTests
-            describe "XFTP agent" $
-              before (pure $ AFSType SFSMemory) xftpAgentTests
+        -- xdescribe "SMP client agent, server jornal message store" $ agentTests (transport @TLS, ASType SQSMemory SMSJournal)
+        describe "SMP client agent, server memory message store" $ agentTests (transport @TLS, ASType SQSMemory SMSMemory)
+        describe "SMP proxy, jornal message store" $
+          before (pure $ ASType SQSMemory SMSJournal) smpProxyTests
+        describe "XFTP" $ do
+          describe "XFTP server" $
+            before (pure $ AFSType SFSMemory) xftpServerTests
+          describe "XFTP file description" fileDescriptionTests
+          describe "XFTP CLI (memory)" $
+            before (pure $ AFSType SFSMemory) xftpCLIFileTests
+          describe "XFTP agent" $
+            before (pure $ AFSType SFSMemory) xftpAgentTests
 #if defined(dbServerPostgres)
+        around_ (postgressBracket testXFTPDBConnectInfo) $ do
          describe "XFTP Postgres store operations" xftpStoreTests
          describe "XFTP migration round-trip" xftpMigrationTests
          describe "XFTP server (PostgreSQL)" $
            before (pure $ AFSType SFSPostgres) xftpServerTests
          describe "XFTP agent (PostgreSQL)" $
            before (pure $ AFSType SFSPostgres) xftpAgentTests
-#endif
-          describe "XFTP Web Client" xftpWebTests
-          describe "XRCP" remoteControlTests
-          describe "Web" webTests
-        sequential $ do
-          describe "Core tests" $ describe "Retry interval tests" retryIntervalTests
-#if defined(dbServerPostgres)
-          describe "SMP server via TLS, postgres-only message store" $
-            before (pure (transport @TLS, ASType SQSPostgres SMSPostgres)) $ describe "Timing of AUTH error" testTiming
-#endif
-          describe "SMP server via TLS, jornal message store" $
-            before (pure (transport @TLS, ASType SQSMemory SMSJournal)) $ describe "Timing of AUTH error" testTiming
-          describe "SMP server via TLS, memory message store" $
-            before (pure (transport @TLS, ASType SQSMemory SMSMemory)) $ describe "Timing of AUTH error" testTiming
-#if defined(dbServerPostgres)
-          describe "SMP client agent, server postgres-only message store" $
-            describe "Functional API" $ functionalAPITimingTests (transport @TLS, ASType SQSPostgres SMSPostgres)
-#endif
-          describe "SMP client agent, server memory message store" $
-            describe "Functional API" $ functionalAPITimingTests (transport @TLS, ASType SQSMemory SMSMemory)
-#if defined(dbServerPostgres)
-          describe "SMP proxy capabilities, postgres-only message store" $
-            before (pure $ ASType SQSPostgres SMSPostgres) smpProxyCapabilityTests
-#endif
-          describe "SMP proxy capabilities, jornal message store" $
-            before (pure $ ASType SQSMemory SMSJournal) smpProxyCapabilityTests
-          describe "XFTP CLI (memory)" $
-            before (pure $ AFSType SFSMemory) xftpCLIFileTests
-#if defined(dbServerPostgres)
          describe "XFTP CLI (PostgreSQL)" $
            before (pure $ AFSType SFSPostgres) xftpCLIFileTests
-#endif
-          describe "Server CLIs" cliTests
-#if defined(dbServerPostgres)
-          around_ (postgressBracket testServerDBConnectInfo) $
-            describe "SMP server schema dump" $
-              postgresSchemaDumpTest
-                serverMigrations
-                [ "20250320_short_links", -- snd_secure moves to the bottom on down migration
-                  "20260918_expire_messages" -- msg_queue_expire moves to the bottom on down migration
-                ] -- skipComparisonForDownMigrations
-                testServerDBOpts
-                "src/Simplex/Messaging/Server/QueueStore/Postgres/server_schema.sql"
-          around_ (postgressBracket ntfTestServerDBConnectInfo) $
-            describe "Ntf server schema dump" $
-              postgresSchemaDumpTest
-                ntfServerMigrations
-                [] -- skipComparisonForDownMigrations
-                ntfTestServerDBOpts
-                "src/Simplex/Messaging/Notifications/Server/Store/ntf_server_schema.sql"
 #endif
 #if defined(dbPostgres)
-          around_ (postgressBracket testDBConnectInfo) $
-            describe "Agent PostgreSQL schema dump" $
-              postgresSchemaDumpTest
-                appMigrations
-                ["20250322_short_links"] -- snd_secure and last_broker_ts columns swap order on down migration
-                (testDBOpts "smp_agent_test_protocol_schema")
-                "src/Simplex/Messaging/Agent/Store/Postgres/Migrations/agent_postgres_schema.sql"
+        describe "XFTP Web Client" $ xftpWebTests (dropAllSchemasExceptSystem testDBConnectInfo)
 #else
-          after_ (listDirectory tmpDir >>= mapM_ (removeFileIfExists . (tmpDir </>))) $
-            describe "Agent SQLite schema dump" schemaDumpTest
+        describe "XFTP Web Client" $ xftpWebTests (pure ())
+#endif
+        describe "XRCP" remoteControlTests
+        describe "Web" webTests
+        describe "Server CLIs" cliTests
+#if defined(dbPostgres)
+        around_ (postgressBracket testDBConnectInfo) $
+          describe "Agent PostgreSQL schema dump" $
+            postgresSchemaDumpTest
+              appMigrations
+              ["20250322_short_links"] -- snd_secure and last_broker_ts columns swap order on down migration
+              (testDBOpts testDB)
+              "src/Simplex/Messaging/Agent/Store/Postgres/Migrations/agent_postgres_schema.sql"
+#else
+        describe "Agent SQLite schema dump" schemaDumpTest
 #endif

-withTmpDir :: IO a -> IO a
-withTmpDir = bracket_ (removePathForcibly tmpDir >> createDirectory tmpDir) (eventuallyRemove tmpDir 3)
+eventuallyRemove :: FilePath -> Int -> IO ()
+eventuallyRemove path retries = case retries of
+  0 -> action
+  n ->
+    action `E.catch` \ioe@IOError {ioe_type, ioe_filename} -> case ioe_type of
+      IOException.UnsatisfiedConstraints | ioe_filename == Just path -> threadDelay 1000000 >> eventuallyRemove path (n - 1)
+      _ -> E.throwIO ioe
+  where
+    action = removeDirectoryRecursive path
@@ -1,33 +1,21 @@
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE ImplicitParams #-}
 {-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}

 module Util where

-import Control.Concurrent (threadDelay)
 import Control.Concurrent.Async
-import Control.Concurrent.STM
 import Control.Exception as E
 import Control.Logger.Simple
 import Control.Monad (replicateM, when)
 import Data.Either (partitionEithers)
 import Data.List (tails)
-import Data.String (IsString (..))
 import GHC.Conc (getNumCapabilities, getNumProcessors, setNumCapabilities)
-import GHC.IO.Exception (IOException (..))
-import qualified GHC.IO.Exception as IOException
-import Network.Socket (ServiceName)
-import System.Directory (createDirectoryIfMissing, doesFileExist, removeDirectoryRecursive, removeFile)
+import System.Directory (doesFileExist, removeFile)
 import System.Environment (lookupEnv)
-import System.FilePath ((</>))
-import System.IO.Unsafe (unsafePerformIO)
 import System.Process (callCommand)
 import System.Timeout (timeout)
-import Test.Hspec hiding (fit, it, xit)
+import Test.Hspec hiding (fit, it)
 import qualified Test.Hspec as Hspec
 import Test.Hspec.Core.Spec (Example (..), Result (..), ResultStatus (..))

@@ -56,70 +44,7 @@ removeFileIfExists filePath = do
  fileExists <- doesFileExist filePath
  when fileExists $ removeFile filePath

-data TestEnv = TestEnv
-  { testNo :: Int,
-    portBase :: Int
-  }
-
-type HasTestEnv = (?testEnv :: TestEnv)
-
-tmpDir :: FilePath
-tmpDir = "tests/tmp"
-
-testDir :: HasTestEnv => FilePath
-testDir = tmpDir </> show (testNo ?testEnv)
-
-testPath :: HasTestEnv => FilePath -> FilePath
-testPath = (testDir </>)
-
-testServerPort :: HasTestEnv => Int -> ServiceName
-testServerPort offset = show (portBase ?testEnv + offset)
-
-testSchemaName :: (HasTestEnv, IsString s) => String -> s
-testSchemaName name = fromString $ "test" <> show (testNo ?testEnv) <> "_" <> name
-
-senderFiles :: HasTestEnv => FilePath
-senderFiles = testPath "xftp-sender-files"
-
-recipientFiles :: HasTestEnv => FilePath
-recipientFiles = testPath "xftp-recipient-files"
-
-testCounter :: TVar Int
-testCounter = unsafePerformIO $ newTVarIO 0
-{-# NOINLINE testCounter #-}
-
-portBases :: TVar [Int]
-portBases = unsafePerformIO $ newTVarIO [10000, 10010 .. 19990]
-{-# NOINLINE portBases #-}
-
-withTestEnv :: (HasTestEnv => IO a) -> IO a
-withTestEnv action =
-  bracket takePortBase releasePortBase $ \portBase -> do
-    testNo <- atomically $ stateTVar testCounter $ \n -> (n, n + 1)
-    let ?testEnv = TestEnv {testNo, portBase}
-    bracket_
-      (mapM_ (createDirectoryIfMissing True) [senderFiles, recipientFiles])
-      (eventuallyRemove testDir 3)
-      action
-  where
-    takePortBase =
-      atomically $
-        readTVar portBases >>= \case
-          b : bs -> b <$ writeTVar portBases bs
-          [] -> retry
-    releasePortBase b = atomically $ modifyTVar' portBases (<> [b])
-
-eventuallyRemove :: FilePath -> Int -> IO ()
-eventuallyRemove path retries = case retries of
-  0 -> action
-  n ->
-    action `E.catch` \ioe@IOError {ioe_type, ioe_filename} -> case ioe_type of
-      IOException.UnsatisfiedConstraints | ioe_filename == Just path -> threadDelay 1000000 >> eventuallyRemove path (n - 1)
-      _ -> E.throwIO ioe
-  where
-    action = removeDirectoryRecursive path
-
-data TestWrapper a = TestWrapper (HasTestEnv => a)
+newtype TestWrapper a = TestWrapper a

 -- TODO [ntfdb] running wiht LogWarn level shows potential issue "Queue count differs"
 testLogLevel :: LogLevel
@@ -131,12 +56,11 @@ instance Example a => Example (TestWrapper a) where
    ci <- envCI
    runTest `E.catches` [E.Handler (onTestFailure ci), E.Handler (onTestException ci)]
    where
-      tt = 300
+      tt = 120
      runTest =
-        withTestEnv $
-          timeout (tt * 1000000) (evaluateExample action params hooks state) `finally` callCommand "sync" >>= \case
-            Just r -> pure r
-            Nothing -> throwIO $ userError $ "test timed out after " <> show tt <> " seconds"
+        timeout (tt * 1000000) (evaluateExample action params hooks state) `finally` callCommand "sync" >>= \case
+          Just r -> pure r
+          Nothing -> throwIO $ userError $ "test timed out after " <> show tt <> " seconds"
      onTestFailure :: Bool -> ResultStatus -> IO Result
      onTestFailure ci = \case
        Failure loc_ reason | ci -> do
@@ -156,11 +80,8 @@ instance Example a => Example (TestWrapper a) where
 envCI :: IO Bool
 envCI = (Just "true" ==) <$> lookupEnv "CI"

-it :: (HasCallStack, Example a) => String -> (HasTestEnv => a) -> SpecWith (Arg a)
+it :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
 it label action = Hspec.it label (TestWrapper action)

-fit :: (HasCallStack, Example a) => String -> (HasTestEnv => a) -> SpecWith (Arg a)
-fit label action = focus $ it label action
-
-xit :: (HasCallStack, Example a) => String -> (HasTestEnv => a) -> SpecWith (Arg a)
-xit label action = Hspec.xit label (TestWrapper action)
+fit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
+fit = fmap focus . it
@@ -48,25 +48,34 @@ import Simplex.Messaging.Crypto.Entitlement (Entitlement (..), MasterKey (..), s
 import Simplex.Messaging.Crypto.File (CryptoFile (..), CryptoFileArgs)
 import qualified Simplex.Messaging.Crypto.File as CF
 import Simplex.Messaging.Encoding.String (StrEncoding (..))
-import Simplex.Messaging.Protocol (BasicAuth, NetworkError (..), ProtoServerWithAuth (..), ProtocolServer (..), XFTPServer, XFTPServerWithAuth)
+import Simplex.Messaging.Protocol (BasicAuth, NetworkError (..), ProtoServerWithAuth (..), ProtocolServer (..), XFTPServerWithAuth)
 import Simplex.Messaging.Server.Expiration (ExpirationConfig (..))
 import Simplex.Messaging.Server.Information (ServerPublicInfo)
 import Simplex.Messaging.Transport (EntitlementConfig (..))
 import Simplex.Messaging.Util (tshow)
 import System.Directory (doesDirectoryExist, doesFileExist, getFileSize, listDirectory, removeFile)
 import System.FilePath ((</>))
-import Test.Hspec hiding (fit, it, xit)
+import Test.Hspec hiding (fit, it)
 import UnliftIO
 import UnliftIO.Concurrent
 import Util
+import XFTPCLI
 import XFTPClient
+#if defined(dbPostgres)
+import Fixtures
+import Simplex.Messaging.Agent.Store.Postgres.Util (dropAllSchemasExceptSystem)
+#endif

 pattern SFDONE :: ValidFileDescription 'FSender -> [ValidFileDescription 'FRecipient] -> AEvent 'AESndFile
 pattern SFDONE sndDescr rcvDescrs <- A.SFDONE sndDescr rcvDescrs _

 xftpAgentTests :: SpecWith AFStoreType
 xftpAgentTests =
-  describe "agent XFTP API" $ do
+  around_ testBracket
+#if defined(dbPostgres)
+    . after_ (dropAllSchemasExceptSystem testDBConnectInfo)
+#endif
+    . describe "agent XFTP API" $ do
      it "should send and receive file" $ withXFTPServer testXFTPAgentSendReceive
      -- uncomment CPP option slow_servers and run hpack to run this test
      xit "should send and receive file with slow server responses" $ \_ ->
@@ -91,21 +100,18 @@ xftpAgentTests =
      it "should request additional recipient IDs when number of recipients exceeds maximum per request" testXFTPAgentRequestAdditionalRecipientIDs
      describe "XFTP server test via agent API" $ do
        it "should pass without basic auth" $ \_ -> testXFTPServerTest Nothing (noAuthSrv testXFTPServer2) `shouldReturn` Right (Just (Right testServerInformation))
-        let srv1 :: HasTestEnv => XFTPServer
-            srv1 = testXFTPServer2 {keyHash = "1234"}
+        let srv1 = testXFTPServer2 {keyHash = "1234"}
        it "should fail with incorrect fingerprint" $ \_ -> do
          testXFTPServerTest Nothing (noAuthSrv srv1) `shouldReturn` Left (ProtocolTestFailure TSConnect $ BROKER (B.unpack $ strEncode srv1) $ NETWORK NEUnknownCAError)
        describe "server with password" $ do
          let auth = Just "abcd"
-              srv :: HasTestEnv => Maybe BasicAuth -> XFTPServerWithAuth
              srv = ProtoServerWithAuth testXFTPServer2
-              authErr :: HasTestEnv => ProtocolTestFailure
              authErr = ProtocolTestFailure TSCreateFile $ XFTP (B.unpack $ strEncode testXFTPServer2) AUTH
          it "should pass with correct password" $ \_ -> testXFTPServerTest auth (srv auth) `shouldReturn` Right (Just (Right testServerInformation))
          it "should fail without password" $ \_ -> testXFTPServerTest auth (srv Nothing) `shouldReturn` Left authErr
          it "should fail with incorrect password" $ \_ -> testXFTPServerTest auth (srv $ Just "wrong") `shouldReturn` Left authErr

-testXFTPServerTest :: (HasCallStack, HasTestEnv) => Maybe BasicAuth -> XFTPServerWithAuth -> IO (Either ProtocolTestFailure (Maybe (Either String ServerPublicInfo)))
+testXFTPServerTest :: HasCallStack => Maybe BasicAuth -> XFTPServerWithAuth -> IO (Either ProtocolTestFailure (Maybe (Either String ServerPublicInfo)))
 testXFTPServerTest newFileBasicAuth srv =
  withXFTPServerCfg testXFTPServerConfig {newFileBasicAuth, xftpPort = xftpTestPort2, information = Just testServerInformation} $ \_ ->
    -- initially passed server is not running
@@ -137,7 +143,7 @@ checkProgress (prev, expected) (progress, total) loop
  | progress < total = loop progress
  | otherwise = pure ()

-testXFTPAgentSendReceive :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentSendReceive :: HasCallStack => IO ()
 testXFTPAgentSendReceive = do
  filePath <- createRandomFile
  -- send file, delete snd file internally
@@ -154,7 +160,7 @@ testXFTPAgentSendReceive = do
        rfId <- runRight $ testReceive rcp rfd originalFilePath
        xftpDeleteRcvFile rcp rfId

-testXFTPAgentSendReceiveEncrypted :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentSendReceiveEncrypted :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentSendReceiveEncrypted = withXFTPServer $ do
  g <- C.newRandom
  filePath <- createRandomFile
@@ -175,7 +181,7 @@ testXFTPAgentSendReceiveEncrypted = withXFTPServer $ do
        rfId <- runRight $ testReceiveCF rcp rfd cfArgs originalFilePath
        xftpDeleteRcvFile rcp rfId

-testXFTPAgentSendReceiveRedirect :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentSendReceiveRedirect :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentSendReceiveRedirect = withXFTPServer $ do
  --- sender
  filePathIn <- createRandomFile
@@ -233,7 +239,7 @@ testXFTPAgentSendReceiveRedirect = withXFTPServer $ do
      inBytes <- B.readFile filePathIn
      B.readFile out `shouldReturn` inBytes

-testXFTPAgentSendReceiveNoRedirect :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentSendReceiveNoRedirect :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentSendReceiveNoRedirect = withXFTPServer $ do
  --- sender
  let fileSize = mb 5
@@ -274,7 +280,7 @@ testXFTPAgentSendReceiveNoRedirect = withXFTPServer $ do
      inBytes <- B.readFile filePathIn
      B.readFile out `shouldReturn` inBytes

-testXFTPAgentPrepareReceive :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentPrepareReceive :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentPrepareReceive = withXFTPServer $ do
  filePath <- createRandomFile
  (_, _, rfd1, rfd2) <- withAgent 1 agentCfg initAgentServers testDB $ \sndr -> runRight $ testSend sndr filePath
@@ -299,7 +305,7 @@ testXFTPAgentPrepareReceive = withXFTPServer $ do
      file <- B.readFile filePath
      B.readFile path `shouldReturn` file

-testXFTPAgentPrepareSend :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentPrepareSend :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentPrepareSend = withXFTPServer $ do
  filePath1 <- createRandomFile' "testfile1"
  filePath2 <- createRandomFile' "testfile2"
@@ -337,12 +343,11 @@ testXFTPAgentSendReceiveMatrix = do
    it "old sender, new recipient" $ run newServer oldClient newClient
    it "old clients" $ run newServer oldClient oldClient
  where
-    oldClient, newClient :: HasTestEnv => AgentConfig
    oldClient = agentCfg {xftpCfg = (xftpCfg agentCfg) {clientALPN = Nothing}}
    newClient = agentCfg
    oldServer = withXFTPServerCfgNoALPN
    newServer = withXFTPServerCfg
-    run :: (HasCallStack, HasTestEnv) => (HasCallStack => XFTPServerConfig STMFileStore -> (ThreadId -> IO ()) -> IO ()) -> AgentConfig -> AgentConfig -> IO ()
+    run :: HasCallStack => (HasCallStack => XFTPServerConfig STMFileStore -> (ThreadId -> IO ()) -> IO ()) -> AgentConfig -> AgentConfig -> IO ()
    run withServer sender receiver =
      withServer testXFTPServerConfig $ \_t -> do
        filePath <- createRandomFile_ (kb 319 :: Integer) "testfile"
@@ -353,26 +358,26 @@ testXFTPAgentSendReceiveMatrix = do
          rfId <- runRight $ testReceiveCF' rcp rfd Nothing filePath (kb 320)
          xftpDeleteRcvFile rcp rfId

-createRandomFile :: (HasCallStack, HasTestEnv) => IO FilePath
+createRandomFile :: HasCallStack => IO FilePath
 createRandomFile = createRandomFile' "testfile"

-createRandomFile' :: (HasCallStack, HasTestEnv) => FilePath -> IO FilePath
+createRandomFile' :: HasCallStack => FilePath -> IO FilePath
 createRandomFile' = createRandomFile_ (mb 17 :: Integer)

-createRandomFile_ :: (HasCallStack, HasTestEnv, Integral s) => s -> FilePath -> IO FilePath
+createRandomFile_ :: (HasCallStack, Integral s, Show s) => s -> FilePath -> IO FilePath
 createRandomFile_ size fileName = do
  let filePath = senderFiles </> fileName
-  B.writeFile filePath =<< atomically . C.randomBytes (fromIntegral size) =<< C.newRandom
+  xftpCLI ["rand", filePath, show size] `shouldReturn` ["File created: " <> filePath]
  getFileSize filePath `shouldReturn` toInteger size
  pure filePath

-testSend :: (HasCallStack, HasTestEnv) => AgentClient -> FilePath -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
+testSend :: HasCallStack => AgentClient -> FilePath -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
 testSend sndr = testSendCF sndr . CF.plain

-testSendCF :: (HasCallStack, HasTestEnv) => AgentClient -> CryptoFile -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
+testSendCF :: HasCallStack => AgentClient -> CryptoFile -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
 testSendCF sndr file = testSendCF' sndr file $ mb 18

-testSendCF' :: (HasCallStack, HasTestEnv) => AgentClient -> CryptoFile -> Int64 -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
+testSendCF' :: HasCallStack => AgentClient -> CryptoFile -> Int64 -> ExceptT AgentErrorType IO (SndFileId, ValidFileDescription 'FSender, ValidFileDescription 'FRecipient, ValidFileDescription 'FRecipient)
 testSendCF' sndr file size = do
  xftpStartWorkers sndr (Just senderFiles)
  sfId <- xftpSendFile sndr 1 file 2
@@ -387,7 +392,7 @@ testNoRedundancy :: HasCallStack => ValidFileDescription 'FRecipient -> IO ()
 testNoRedundancy (ValidFileDescription FileDescription {chunks}) =
  all (\FileChunk {replicas} -> length replicas == 1) chunks `shouldBe` True

-testXFTPAgentEntitlement :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentEntitlement :: HasCallStack => IO ()
 testXFTPAgentEntitlement = do
  Right (issuerPk, issuerSk) <- bbsKeyGen
  now <- getCurrentTime
@@ -424,10 +429,10 @@ testXFTPAgentEntitlement = do
        ("", _, SFPROG _ _) -> waitSndDone sndr
        r -> error $ "Expected SFDONE, got " <> show r

-testReceive :: (HasCallStack, HasTestEnv) => AgentClient -> ValidFileDescription 'FRecipient -> FilePath -> ExceptT AgentErrorType IO RcvFileId
+testReceive :: HasCallStack => AgentClient -> ValidFileDescription 'FRecipient -> FilePath -> ExceptT AgentErrorType IO RcvFileId
 testReceive rcp rfd = testReceiveCF rcp rfd Nothing

-testReceiveCF :: (HasCallStack, HasTestEnv) => AgentClient -> ValidFileDescription 'FRecipient -> Maybe CryptoFileArgs -> FilePath -> ExceptT AgentErrorType IO RcvFileId
+testReceiveCF :: HasCallStack => AgentClient -> ValidFileDescription 'FRecipient -> Maybe CryptoFileArgs -> FilePath -> ExceptT AgentErrorType IO RcvFileId
 testReceiveCF rcp rfd cfArgs originalFilePath = do
  xftpStartWorkers rcp (Just recipientFiles)
  testReceiveCF' rcp rfd cfArgs originalFilePath $ mb 18
@@ -449,7 +454,7 @@ testReceiveCF' rcp rfd cfArgs originalFilePath size = do
 logCfgNoLogs :: LogConfig
 logCfgNoLogs = LogConfig {lc_file = Nothing, lc_stderr = False}

-testXFTPAgentReceiveRestore :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentReceiveRestore :: HasCallStack => IO ()
 testXFTPAgentReceiveRestore = do
  filePath <- createRandomFile

@@ -493,7 +498,7 @@ testXFTPAgentReceiveRestore = do
      -- tmp path should be removed after receiving file
      doesDirectoryExist tmpPath `shouldReturn` False

-testXFTPAgentReceiveCleanup :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentReceiveCleanup :: HasCallStack => IO ()
 testXFTPAgentReceiveCleanup = withGlobalLogging logCfgNoLogs $ do
  filePath <- createRandomFile

@@ -518,14 +523,13 @@ testXFTPAgentReceiveCleanup = withGlobalLogging logCfgNoLogs $ do
    -- receive file - should fail with AUTH error
    withAgent 3 agentCfg initAgentServers testDB2 $ \rcp' -> do
      runRight_ $ xftpStartWorkers rcp' (Just recipientFiles)
-      ("", rfId', RFERR (XFTP srv AUTH)) <- rfGet rcp'
+      ("", rfId', RFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <- rfGet rcp'
      rfId' `shouldBe` rfId
-      srv `shouldBe` testXFTPServerStr

  -- tmp path should be removed after permanent error
  doesDirectoryExist tmpPath `shouldReturn` False

-testXFTPAgentSendRestore :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentSendRestore :: HasCallStack => IO ()
 testXFTPAgentSendRestore = withGlobalLogging logCfgNoLogs $ do
  filePath <- createRandomFile

@@ -572,7 +576,7 @@ testXFTPAgentSendRestore = withGlobalLogging logCfgNoLogs $ do
    withAgent 4 agentCfg initAgentServers testDB2 $ \rcp ->
      runRight_ . void $ testReceive rcp rfd1 filePath

-testXFTPAgentSendCleanup :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentSendCleanup :: HasCallStack => IO ()
 testXFTPAgentSendCleanup = withGlobalLogging logCfgNoLogs $ do
  filePath <- createRandomFile

@@ -598,16 +602,15 @@ testXFTPAgentSendCleanup = withGlobalLogging logCfgNoLogs $ do
    -- send file - should fail with AUTH error
    withAgent 2 agentCfg initAgentServers testDB $ \sndr' -> do
      runRight_ $ xftpStartWorkers sndr' (Just senderFiles)
-      ("", sfId', SFERR (XFTP srv AUTH)) <-
+      ("", sfId', SFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <-
        sfGet sndr'
      sfId' `shouldBe` sfId
-      srv `shouldBe` testXFTPServerStr

  -- prefix path should be removed after permanent error
  doesDirectoryExist prefixPath `shouldReturn` False
  doesFileExist encPath `shouldReturn` False

-testXFTPAgentDelete :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentDelete :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentDelete = withGlobalLogging logCfgNoLogs . withXFTPServer test
  where
    test = do
@@ -636,12 +639,11 @@ testXFTPAgentDelete = withGlobalLogging logCfgNoLogs . withXFTPServer test
        withAgent 3 agentCfg initAgentServers testDB2 $ \rcp2 -> runRight $ do
          xftpStartWorkers rcp2 (Just recipientFiles)
          rfId <- xftpReceiveFile rcp2 1 rfd2 Nothing True
-          ("", rfId', RFERR (XFTP srv AUTH)) <-
+          ("", rfId', RFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <-
            rfGet rcp2
          liftIO $ rfId' `shouldBe` rfId
-          liftIO $ srv `shouldBe` testXFTPServerStr

-testXFTPAgentDeleteRestore :: (HasCallStack, HasTestEnv) => IO ()
+testXFTPAgentDeleteRestore :: HasCallStack => IO ()
 testXFTPAgentDeleteRestore = withGlobalLogging logCfgNoLogs $ do
  filePath <- createRandomFile

@@ -675,12 +677,11 @@ testXFTPAgentDeleteRestore = withGlobalLogging logCfgNoLogs $ do
      withAgent 5 agentCfg initAgentServers testDB3 $ \rcp2 -> runRight $ do
        xftpStartWorkers rcp2 (Just recipientFiles)
        rfId <- xftpReceiveFile rcp2 1 rfd2 Nothing True
-        ("", rfId', RFERR (XFTP srv AUTH)) <-
+        ("", rfId', RFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <-
          rfGet rcp2
        liftIO $ rfId' `shouldBe` rfId
-        liftIO $ srv `shouldBe` testXFTPServerStr

-testXFTPAgentDeleteOnServer :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentDeleteOnServer :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentDeleteOnServer = withGlobalLogging logCfgNoLogs . withXFTPServer test
  where
    test = do
@@ -712,15 +713,14 @@ testXFTPAgentDeleteOnServer = withGlobalLogging logCfgNoLogs . withXFTPServer te
          runRight_ . void $ do
            -- receive file 1 again
            rfId1 <- xftpReceiveFile rcp 1 rfd1_2 Nothing True
-            ("", rfId1', RFERR (XFTP srv AUTH)) <-
+            ("", rfId1', RFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <-
              rfGet rcp
            liftIO $ rfId1 `shouldBe` rfId1'
-            liftIO $ srv `shouldBe` testXFTPServerStr

            -- receive file 2
            testReceive' rcp rfd2 filePath2

-testXFTPAgentExpiredOnServer :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentExpiredOnServer :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentExpiredOnServer fsType = withGlobalLogging logCfgNoLogs $
  withXFTPServerConfigOn (updateXFTPCfg (cfgFS fsType) $ \c -> c {fileExpiration = fastExpiration}) . const $ do
    filePath1 <- createRandomFile' "testfile1"
@@ -745,10 +745,9 @@ testXFTPAgentExpiredOnServer fsType = withGlobalLogging logCfgNoLogs $
        -- receive file 1 again - should fail with AUTH error
        runRight $ do
          rfId <- xftpReceiveFile rcp 1 rfd1_2 Nothing True
-          ("", rfId', RFERR (XFTP srv AUTH)) <-
+          ("", rfId', RFERR (XFTP "xftp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@localhost:8000" AUTH)) <-
            rfGet rcp
          liftIO $ rfId' `shouldBe` rfId
-          liftIO $ srv `shouldBe` testXFTPServerStr

        -- create and send file 2
        filePath2 <- createRandomFile' "testfile2"
@@ -761,7 +760,7 @@ testXFTPAgentExpiredOnServer fsType = withGlobalLogging logCfgNoLogs $
  where
    fastExpiration = ExpirationConfig {ttl = 2, checkInterval = 1}

-testXFTPAgentRequestAdditionalRecipientIDs :: (HasCallStack, HasTestEnv) => AFStoreType -> IO ()
+testXFTPAgentRequestAdditionalRecipientIDs :: HasCallStack => AFStoreType -> IO ()
 testXFTPAgentRequestAdditionalRecipientIDs = withXFTPServer $ do
  filePath <- createRandomFile

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Narasimha-sc	7bc4106bba	Merge branch 'master' into nd/index-active-sub-conns	2026-09-30 15:45:18 +00:00
Narasimha-sc	ed9411b0ab	agent: index connections with active subscriptions instead of folding all subscriptions per batch (cherry picked from commit bae057286d9675bae9a8cf1999f319b25517eda5)	2026-09-26 11:23:43 +00:00