remove more

refactor
reduce STM more
2026-08-30 16:18:24 +00:00 · 2024-08-09 11:12:17 +01:00 · 2024-08-09 11:01:32 +01:00 · 2024-08-09 10:55:40 +01:00 · 2024-08-08 23:45:54 +01:00
242 changed files with 11913 additions and 36489 deletions
@@ -1,44 +0,0 @@
-name: 'Set Swap Space'
-description: 'Add moar swap'
-branding:
-  icon: 'crop'
-  color: 'orange'
-inputs:
-  swap-size-gb:
-    description: 'Swap space to create, in Gigabytes.'
-    required: false
-    default: '10'
-runs:
-  using: "composite"
-  steps:
-    - name: Swap space report before modification
-      shell: bash
-      run: |
-        echo "Memory and swap:"
-        free -h
-        echo
-        swapon --show
-        echo
-    - name: Set Swap
-      shell: bash
-      run: |
-          export SWAP_FILE=$(swapon --show=NAME | tail -n 1)
-          echo "Swap file: $SWAP_FILE"
-          if [ -z "$SWAP_FILE" ]; then
-            SWAP_FILE=/opt/swapfile
-          else
-            sudo swapoff $SWAP_FILE
-            sudo rm $SWAP_FILE
-          fi
-          sudo fallocate -l ${{ inputs.swap-size-gb }}G $SWAP_FILE
-          sudo chmod 600 $SWAP_FILE
-          sudo mkswap $SWAP_FILE
-          sudo swapon $SWAP_FILE
-    - name: Swap space report after modification
-      shell: bash
-      run: |
-        echo "Memory and swap:"
-        free -h
-        echo
-        swapon --show
-        echo
@@ -10,25 +10,62 @@ on:
  pull_request:

 jobs:
-
-# =============================
-#       Create release
-# =============================
-
-# Create release, but only if it's triggered by tag push.
-# On pull requests/commits push, this job will always complete.
-
-  maybe-release:
-    runs-on: ubuntu-latest
+  build:
+    name: build-${{ matrix.os }}-${{ matrix.ghc }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+            platform_name: 20_04-x86-64
+            ghc: "8.10.7"
+          - os: ubuntu-20.04
+            platform_name: 20_04-x86-64
+            ghc: "9.6.3"
+          - os: ubuntu-22.04
+            platform_name: 22_04-x86-64
+            ghc: "9.6.3"
    steps:
      - name: Clone project
-        if: startsWith(github.ref, 'refs/tags/v')
        uses: actions/checkout@v3

-      - name: Build changelog
-        id: build_changelog
+      - name: Setup Haskell
+        uses: haskell-actions/setup@v2
+        with:
+          ghc-version: ${{ matrix.ghc }}
+          cabal-version: "3.10.1.0"
+
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cabal/store
+            dist-newstyle
+          key: ${{ matrix.os }}-${{ hashFiles('cabal.project', 'simplexmq.cabal') }}
+
+      - name: Build
+        shell: bash
+        run: cabal build --enable-tests
+
+      - name: Test
+        timeout-minutes: 40
+        shell: bash
+        run: cabal test --test-show-details=direct
+
+      - name: Prepare binaries
        if: startsWith(github.ref, 'refs/tags/v')
-        uses: simplex-chat/release-changelog-builder-action@v5
+        shell: bash
+        run: |
+          mv $(cabal list-bin smp-server) smp-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin ntf-server) ntf-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin xftp-server) xftp-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin xftp) xftp-ubuntu-${{ matrix.platform_name}}
+
+      - name: Build changelog
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'ubuntu-22.04'
+        id: build_changelog
+        uses: mikepenz/release-changelog-builder-action@v1
        with:
          configuration: .github/changelog_conf.json
          failOnError: true
@@ -38,8 +75,8 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Create release
-        if: startsWith(github.ref, 'refs/tags/v')
-        uses: simplex-chat/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.ghc != '8.10.7'
+        uses: softprops/action-gh-release@v1
        with:
          body: |
            See full changelog [here](https://github.com/simplex-chat/simplexmq/blob/master/CHANGELOG.md).
@@ -49,241 +86,10 @@ jobs:
          prerelease: true
          files: |
            LICENSE
+            smp-server-ubuntu-${{ matrix.platform_name}}
+            ntf-server-ubuntu-${{ matrix.platform_name}}
+            xftp-server-ubuntu-${{ matrix.platform_name}}
+            xftp-ubuntu-${{ matrix.platform_name}}
          fail_on_unmatched_files: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-# =============================
-#        Main build job
-# =============================
-
-  build:
-    name: "ubuntu-${{ matrix.os }}-${{ matrix.arch }}, GHC: ${{ matrix.ghc }}"
-    needs: maybe-release
-    env:
-      apps: "smp-server xftp-server ntf-server xftp"
-    runs-on: ${{ matrix.runner }}
-    services:
-      postgres:
-        image: postgres:15
-        env:
-          POSTGRES_HOST_AUTH_METHOD: trust # Allows passwordless access
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          # Maps tcp port 5432 on service container to the host
-          - 5432:5432
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: 22.04
-            os_underscore: 22_04
-            arch: x86-64
-            runner: "ubuntu-22.04"
-            ghc: "8.10.7"
-            should_run: ${{ !(github.ref == 'refs/heads/stable' || startsWith(github.ref, 'refs/tags/v')) }}
-          - os: 22.04
-            os_underscore: 22_04
-            arch: x86-64
-            runner: "ubuntu-22.04"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 24.04
-            os_underscore: 24_04
-            arch: x86-64
-            runner: "ubuntu-24.04"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 22.04
-            os_underscore: 22_04
-            arch: aarch64
-            runner: "ubuntu-22.04-arm"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 24.04
-            os_underscore: 24_04
-            arch: aarch64
-            runner: "ubuntu-24.04-arm"
-            ghc: "9.6.3"
-            should_run: true
-    steps:
-      - name: Clone project
-        if: matrix.should_run == true
-        uses: actions/checkout@v3
-
-      - name: Set up Docker Buildx
-        if: matrix.should_run == true
-        uses: simplex-chat/docker-setup-buildx-action@v3
-
-      - name: Setup swap
-        if: matrix.ghc == '8.10.7' && matrix.should_run == true
-        uses: ./.github/actions/swap
-        with:
-          swap-size-gb: 20
-
-      - name: Install PostgreSQL 15 client tools
-        if: matrix.os == '22.04' && matrix.should_run == true
-        shell: bash
-        run: |
-          # Import the repository signing key
-          sudo install -d /usr/share/postgresql-common/pgdg
-          sudo curl -o /usr/share/postgresql-common/pgdg/apt.postgresql.org.asc --fail https://www.postgresql.org/media/keys/ACCC4CF8.asc
-          # Add the PostgreSQL APT repository
-          sudo sh -c 'echo "deb [signed-by=/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc] https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
-          # Update repository and install postgresql tools
-          sudo apt update
-          sudo apt -y install postgresql-client-15
-
-      - name: Build and cache Docker image
-        if: matrix.should_run == true
-        uses: simplex-chat/docker-build-push-action@v6
-        with:
-          context: .
-          load: true
-          file: Dockerfile.build
-          tags: build/${{ matrix.os }}:latest
-          build-args: |
-            TAG=${{ matrix.os }}
-            GHC=${{ matrix.ghc }}
-
-      - 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: |
-          docker run -t -d \
-            --device /dev/fuse \
-            --cap-add SYS_ADMIN \
-            --security-opt apparmor:unconfined \
-            --name builder \
-            -v ~/.cabal:/root/.cabal \
-            -v /home/runner/work/_temp:/home/runner/work/_temp \
-            -v ${{ github.workspace }}:/project \
-            build/${{ matrix.os }}:latest
-
-      - name: Build smp-server (postgresql) and tests
-        if: matrix.should_run == true
-        shell: docker exec -t builder sh -eu {0}
-        run: |
-          chmod -fR 777 ~/.cabal ./dist-newstyle || :; git config --global --add safe.directory '*'
-          cabal clean
-          cabal update
-          cabal build --jobs=$(nproc) --enable-tests -fserver_postgres
-          mkdir -p /out
-          for i in smp-server simplexmq-test; do
-            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
-            chmod +x "$bin"
-            mv "$bin" /out/
-          done
-          strip /out/smp-server
-
-      - name: Copy simplexmq-test from container
-        if: matrix.should_run == true
-        shell: bash
-        run: |
-          docker cp builder:/out/simplexmq-test .
-
-      - name: Copy smp-server (postgresql) from container and prepare it
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        id: prepare-postgres
-        shell: bash
-        run: |
-          name="smp-server-postgres-ubuntu-${{ matrix.os_underscore }}-${{ matrix.arch }}"
-          docker cp builder:/out/smp-server $name
-
-          path="${{ github.workspace }}/$name"
-          echo "bin=$path" >> $GITHUB_OUTPUT
-
-          hash="SHA2-256($name)= $(openssl sha256 $path | cut -d' ' -f 2)"
-          printf 'hash=%s' "$hash" >> $GITHUB_OUTPUT
-
-      - name: Build everything else (standard)
-        if: matrix.should_run == true
-        shell: docker exec -t builder sh -eu {0}
-        run: |
-          cabal build --jobs=$(nproc)
-          mkdir -p /out
-          for i in ${{ env.apps }}; do
-            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
-            strip "$bin"
-            chmod +x "$bin"
-            mv "$bin" /out/
-          done
-
-      - name: Copy binaries from container and prepare them
-        id: prepare-regular
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        shell: bash
-        run: |
-          docker cp builder:/out .
-
-          printf 'bins<<EOF\n' > bins.output
-          printf 'hashes<<EOF\n' > hashes.output
-          for i in ${{ env.apps }}; do
-            name="$i-ubuntu-${{ matrix.os_underscore }}-${{ matrix.arch }}"
-
-            mv ./out/$i ./$name
-
-            path="${{ github.workspace }}/$name"
-            hash="SHA2-256($name)= $(openssl sha256 $path | cut -d' ' -f 2)"
-
-            printf '%s\n' "$path" >> bins.output
-            printf '%s\n\n' "$hash" >> hashes.output
-          done
-          printf 'EOF\n' >> bins.output
-          printf 'EOF\n' >> hashes.output
-
-          cat bins.output >> "$GITHUB_OUTPUT"
-          cat hashes.output >> "$GITHUB_OUTPUT"
-
-      - name: Upload binaries
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        uses: simplex-chat/action-gh-release@v2
-        with:
-          append_body: true
-          prerelease: true
-          fail_on_unmatched_files: true
-          body: |
-            ${{ steps.prepare-regular.outputs.hashes }}
-            ${{ steps.prepare-postgres.outputs.hash }}
-          files: |
-            ${{ steps.prepare-regular.outputs.bins }}
-            ${{ steps.prepare-postgres.outputs.bin }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Test
-        if: matrix.should_run == true && matrix.arch == 'x86-64'
-        timeout-minutes: 120
-        shell: bash
-        env:
-          PGHOST: localhost
-        run: |
-          i=1
-          attempts=1
-          ${{ (github.ref == 'refs/heads/stable' || startsWith(github.ref, 'refs/tags/v')) }} && attempts=3
-          while [ "$i" -le "$attempts" ]; do
-            if ./simplexmq-test; then
-              break
-            else
-              echo "Attempt $i failed, retrying..."
-              i=$((i + 1))
-              sleep 1
-            fi
-          done
-          if [ "$i" -gt "$attempts" ]; then
-            echo "All "$attempts" attempts failed."
-            exit 1
-          fi
@@ -14,22 +14,22 @@ jobs:
      matrix:
        include:
          - app: smp-server
-            app_port: "443 5223"
+            app_port: 5223
          - app: xftp-server
-            app_port: 443
+            app_port: 443 
    steps:
      - name: Clone project
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Log in to Docker Hub
-        uses: simplex-chat/docker-login-action@v3
+        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_PASSWORD }}

      - name: Extract metadata for Docker image
        id: meta
-        uses: simplex-chat/docker-metadata-action@v5
+        uses: docker/metadata-action@v4
        with:
          images: ${{ secrets.DOCKERHUB_USERNAME }}/${{ matrix.app }}
          flavor: |
@@ -40,7 +40,7 @@ jobs:
            type=semver,pattern=v{{major}}

      - name: Build and push Docker image
-        uses: simplex-chat/docker-build-push-action@v6
+        uses: docker/build-push-action@v4
        with:
          push: true
          build-args: |
@@ -1,45 +0,0 @@
-name: Reproduce latest release
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 2 * * *' # every day at 02:00 night
-
-jobs:
-  reproduce:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Get latest release
-        shell: bash
-        run: |
-          curl --proto '=https' \
-               --tlsv1.2 \
-               -sSf -L \
-               'https://api.github.com/repos/simplex-chat/simplexmq/releases/latest' \
-               2>/dev/null | \
-          grep -i "tag_name" | \
-          awk -F \" '{print "TAG="$4}' >> $GITHUB_ENV
-
-      - name: Execute reproduce script
-        run: |
-          ${GITHUB_WORKSPACE}/scripts/simplexmq-reproduce-builds.sh "$TAG" || :
-
-      - name: Check if build has been reproduced
-        env:
-          url: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_URL }}
-          user: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_USER }}
-          pass: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_PASS }}
-        run: |
-          if [ -f "${GITHUB_WORKSPACE}/${TAG}-simplexmq/_sha256sums" ]; then
-            exit 0
-          else
-            curl --proto '=https' --tlsv1.2 -sSf \
-              -u "${user}:${pass}" \
-              -H 'Content-Type: application/json' \
-              -d '{"title": "👾 GitHub: Runner", "description": "⛔️ '"$TAG"' did not reproduce."}' \
-              "$url"
-            exit 1
-          fi
@@ -1,264 +1,3 @@
-# 6.4.4
-
-Servers:
- fix server pages when source code is not specified.
- include commit SHA in printed version and in web page (#1608).
-
-SMP server:
- support short SimpleX addresses in server information page (#1600).
- wrap all queries in transactions (#1603).
-
-SMP agent:
- chat relay address type for short links (#1602).
- extend xrcp certificate validity 1 hour in the past, to allow out of sync clocks (#1601).
-
-# 6.4.3
-
-SMP agent:
- fix some connection errors by updating contact request server hosts to match server in short link (#1597).
-
-SMP server:
- support short link URI as queue identifier in control port commands (#1596).
-
-# 6.4.2
-
-SMP server:
- fix memory leak when connection interrupts straight after client connects.
- do not include repeated queue blocking into stats/quota.
-
-XFTP server:
- prometheus metrics
-
-# 6.4.1
-
-SMP protocol:
- create notification credentials via NEW command that creates the queue (#1586)
-
-SMP server:
- control port session improvements (#1591)
- additional stat counter for ntf credentials created together with the queue (#1589)
-
-# 6.4.0
-
-SMP protocol (server/client):
- support associated queue data and short connection links (see [RFC](./rfcs/2025-03-16-smp-queues.md)).
- service certificates to optimize subscriptions.
-
-SMP agent:
- support retries for interactive connection handshakes.
- use web port 443 by default for preset servers.
- use static RNG function to avoid creating dynamic C stubs when generating sntrup keys (it was detected as Dynamic Code Loading in GrapheneOS).
- different timeouts for interactive and background operations.
-
-Ntf server:
- PostgreSQL storage.
- Prometheus metrics.
- use service certificates.
- fix repeat token registration.
-
-# 6.3.2
-
-Servers:
- enable store log by default (#1501).
-
-SMP server:
- reduce memory usage (#1498)
-
-SMP agent:
- handle client/agent version downgrades after connection was established (#1508).
-
-# 6.3.1
-
-Servers:
- handle ECONNABORTED error on client connections.
- reproducible builds.
- blocking records for content moderation.
- update script (simplex-servers-update) downloads scripts from the specified or the latest stable tag.
-
-SMP server:
- support for PostgreSQL database for queue records for higher traffic servers.
- fix old clients sending messages to new servers (#1443)
- remove empty journals when opening message queues and expiring idle queues (#1456, #1458).
- additional start options (#1465):
-  - `maintenance` to run all start/stop operations without starting server.
-  - `skip-warnings` to ignore the last corrupted line in store log (can happen on abnormal termination).
-
-Ntf server:
- record date of last token activity, to allow expiring inactive tokens.
- additional token invalidation reasons in logs.
-
-SMP agent:
- store message sent to multiple connections only once, to reduce storage when sending to groups (#1453).
- encrypt messages on delivery, to reduce database writes (#1446).
- don't block method calls on congested sockets for better concurrency (#1454).
- check notification token status on client connection.
- option to skip SQLite vacuum on migrations.
-
-# 6.3.0
-
-SMP agent: fix joining connection after failure by using the same ratchet.
-
-# 6.2.2
-
-SMP server:
- add optional Prometheus metrics (#1411).
-
-Build:
- remove three modules from client library.
-
-# 6.2.0
-
-Version 6.2.0.7
-
-Build:
- client_library flag to build only used modules in the clients, remove package yaml
-
-SMP server:
- journal storage for messages (BETA).
- prevent race condition when deleting queue and to avoid "orphan" messages (#1395).
-
-SMP agent:
- support SMP and XFTP server roles (storage/proxy) and operators (#1343).
- treat blocked STM and other critical errors that offer restart as temporary for message delivery (#1405).
- fix inconsistent state after app restart while accepting contact request (#1412).
-
-# 6.1.3
-
-SMP server: fix restoring notification credentials.
-
-# 6.1.2
-
-Servers: more reliable restoring of state.
-
-SMP server: reduced memory usage and faster start.
-
-Notifications: compensate for iOS notifications being dropped by Apple while device is offline (#1378):
- Ntf server: send multiple SMP notifications in one iOS notification.
- Agent: get multiple messages for one iOS notification.
-
-# 6.1.1
-
-SMP:
- stop server faster (#1371)
- add STORE error (#1372)
-
-# 6.1.0
-
-Version 6.1.0.7
-
-SMP server and client:
- transport block encryption (#1317).
-
-Agent:
- batch and optimize iOS notifications processing (#1308, #1311, #1313, #1316, #1330, #1331, #1333, #1337, #1346).
- allow receiving multiple messages from single iOS notification (#1355, #1362).
- prepare connection to accept to avoid race condition with events (#1365).
- transport isolation mode "Session" (default) to use new SOCKS credentials when client restarts or SOCKS proxy configuration changes (#1321).
-
-Ntf server:
- control port (#1354).
- enable pings on ntf subscriptions, to resubscribe on reconnection (#1353).
-
-SMP server:
- support multiple server ports (#1319).
- support serving HTTPS and SMP transport on the same port (#1326, #1327).
- persist iOS notifications to avoid losing them when Ntf server is offline (#1336, #1339, #1350).
- fix lost notification subscriptions (#1347).
- reject SKEY with different key earlier, at verification step (#1366).
- pass server information via CLI during server initialization (#1356).
- show version on server page (#1341).
- explicit graceful shutdown on SIGINT (#1360).
-
-XRCP (remote access protocol):
- use SHA3-256 in hybrid key agreement (#1302).
- session encryption with forward secrecy (#1328).
-
-# 6.0.5
-
-SMP agent:
- support generic SOCKS proxy (without isolate-by-auth).
- reduce max message sizes
-
-# 6.0.4
-
-SMP server:
- better performance/memory: fewer map updates on re-subscriptions (#1297), split and reduce STM transactions (#1294)
- send DELD when subscribed queue is deleted (#1312)
- add created/updated/used date to queues to manage expiration (#1306)
-
-XFTP server: truncate file creation time to 1 hour (#1310)
-
-Servers:
- bind control port only to 127.0.0.1 for better security in case of firewall misconfiguration (#1280)
- reduce memory used for period stats (#1298)
-
-Agent: process last notification from list (#1307)
- report receive file error with redirected file ID, when redirect is present (#1304)
- special error when deleted user record is not in database (#1303)
- fix race when sending a message to the deleted connection (#1296)
- support for multiple messages in a single notification
-
-Ntf server:
- only use SOCKS proxy for servers without public address (#1314)
-
-# 6.0.3
-
-Agent:
- fix possible stuck queue rotation (#1290).
-
-SMP server:
- batch END responses when subscribed client switches to reduce server and client traffic.
- reduce STM transactions for better performance.
- add stats for END events and for SUB/DEL event batches.
- remove "expensive" stats to save memory.
-
-# 6.0.2
-
-SMP agent:
- fix stuck connection commands when a server is not responding.
- store query errors, reduce slow query threshold to 1ms.
-
-Notification server:
- reduce PING interval to 1 minute.
- fix subscriptions disabled on race condition (only mark subscriptions with END status when received via the active connection).
-
-# 6.0.1
-
-SMP agent:
- support changing user of the new connection.
- do not start delivery workers when there are no messages to deliver.
- enable notifications for all connections.
- combine database transactions when subscribing.
-
-SMP server:
- safe compacting of store log.
- fix possible race when creating client that might lead to memory leak.
-
-Dependencies: upgrade tls to 1.9
-
-# 6.0.0
-
-Version 6.0.0.8
-
-Agent:
- enabled fast handshake support.
- batch-send multiple messages in each connection.
- resume subscriptions as soon as agent moves to foreground or as network connection resumes.
- "known" servers to determine whether to use SMP proxy.
- retry on SMP proxy NO_SESSION error.
- fixes to notification subscriptions.
- persistent server statistics.
- better concurrency.
-
-SMP server:
- reduce threads usage.
- additional statistics.
- improve disabling inactive clients.
- additional control port commands for monitoring.
-
-Notification server:
- support onion-only SMP servers.
-
 # 5.8.2

 Agent:
@@ -1,20 +1,15 @@
-# syntax=docker/dockerfile:1.7.0-labs
-ARG TAG=24.04
+ARG TAG=22.04

 FROM ubuntu:${TAG} AS build

 ### Build stage

 # Install curl and git and simplexmq dependencies
-RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev llvm-18 llvm-18-dev libnuma-dev libssl-dev
+RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev llvm-12 llvm-12-dev libnuma-dev libssl-dev

 # Specify bootstrap Haskell versions
 ENV BOOTSTRAP_HASKELL_GHC_VERSION=9.6.3
-ENV BOOTSTRAP_HASKELL_CABAL_VERSION=3.12.1.0
-
-# Do not install Stack
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK=true
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK_HOOK=true
+ENV BOOTSTRAP_HASKELL_CABAL_VERSION=3.10.1.0

 # Install ghcup
 RUN curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
@@ -26,42 +21,26 @@ ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
 RUN ghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}" && \
    ghcup set cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"

-# Copy only the source code
-COPY apps /project/apps/
-COPY cbits /project/cbits/
-COPY src /project/src/
-
-COPY cabal.project Setup.hs simplexmq.cabal LICENSE /project
-
+COPY . /project
 WORKDIR /project

-# Debug
-#ARG CACHEBUST=1
-
-#ADD --chmod=755 https://github.com/MShekow/directory-checksum/releases/download/v1.4.6/directory-checksum_1.4.6_linux_amd64 /usr/local/bin/directory-checksum
-#RUN directory-checksum --max-depth 2 .
-
-# Set build arguments and check if they exist
 ARG APP
-RUN if [ -z "$APP" ]; then printf "Please spcify \$APP build-arg.\n"; exit 1; fi
+ARG APP_PORT
+RUN if [ -z "$APP" ] || [ -z "$APP_PORT" ]; then printf "Please spcify \$APP and \$APP_PORT build-arg.\n"; exit 1; fi

 # Compile app
 RUN cabal update
 RUN cabal build exe:$APP

-# Copy scripts
-COPY scripts /project/scripts/
-
 # Create new path containing all files needed
 RUN mkdir /final
 WORKDIR /final

 # Strip the binary from debug symbols to reduce size
-RUN bin="$(find /project/dist-newstyle -name "$APP" -type f -executable)" && \
+RUN bin=$(find /project/dist-newstyle -name "$APP" -type f -executable) && \
    mv "$bin" ./ && \
    strip ./"$APP" &&\
-    mv /project/scripts/docker/entrypoint-"$APP" ./entrypoint &&\
-    mv /project/scripts/main/simplex-servers-stopscript ./simplex-servers-stopscript
+    mv /project/scripts/docker/entrypoint-"$APP" ./entrypoint

 ### Final stage
 FROM ubuntu:${TAG}
@@ -74,8 +53,6 @@ COPY --from=build /final /usr/local/bin/

 # Open app listening port
 ARG APP_PORT
-RUN if [ -z "$APP_PORT" ]; then printf "Please spcify \$APP_PORT build-arg.\n"; exit 1; fi
-
 EXPOSE $APP_PORT

 # simplexmq requires using SIGINT to correctly preserve undelivered messages and restore them on restart
@@ -1,31 +0,0 @@
-# syntax=docker/dockerfile:1.7.0-labs
-ARG TAG=24.04
-FROM ubuntu:${TAG} AS build
-
-### Build stage
-
-ARG GHC=9.6.3
-ARG CABAL=3.14.1.1
-
-# Install curl, git and and simplexmq dependencies
-RUN apt-get update && apt-get install -y curl libpq-dev git sqlite3 libsqlite3-dev build-essential libgmp3-dev zlib1g-dev llvm llvm-dev libnuma-dev libssl-dev
-
-# Specify bootstrap Haskell versions
-ENV BOOTSTRAP_HASKELL_GHC_VERSION=${GHC}
-ENV BOOTSTRAP_HASKELL_CABAL_VERSION=${CABAL}
-
-# Do not install Stack
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK=true
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK_HOOK=true
-
-# Install ghcup
-RUN curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
-
-# Adjust PATH
-ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
-
-# Set both as default
-RUN ghcup set ghc "${GHC}" && \
-    ghcup set cabal "${CABAL}"
-
-WORKDIR /project
@@ -1,6 +1,6 @@
 # SimpleXMQ

-[![GitHub build](https://github.com/simplex-chat/simplexmq/actions/workflows/build.yml/badge.svg)](https://github.com/simplex-chat/simplexmq/actions/workflows/build.yml)
+[![GitHub build](https://github.com/simplex-chat/simplexmq/workflows/build/badge.svg)](https://github.com/simplex-chat/simplexmq/actions?query=workflow%3Abuild)
 [![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplexmq)](https://github.com/simplex-chat/simplexmq/releases)

 📢 SimpleXMQ v1 is released - with many security, privacy and efficiency improvements, new functionality - see [release notes](https://github.com/simplex-chat/simplexmq/releases/tag/v1.0.0).
@@ -116,7 +116,7 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
 2. Run your Docker container.

   - `smp-server`
-
+   
     You must change **your_ip_or_domain**. `-e "pass=password"` is optional variable to password-protect your `smp` server:
     ```sh
     docker run -d \
@@ -129,7 +129,7 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
     ```

   - `xftp-server`
-
+   
     You must change **your_ip_or_domain** and **maximum_storage**.
     ```sh
     docker run -d \
@@ -149,15 +149,8 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
 You can install and setup servers automatically using our script:

 ```sh
-curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/install.sh -o simplex-server-install.sh &&\
-if echo '53fcdb4ceab324316e2c4cda7e84dbbb344f32550a65975a7895425e5a1be757 simplex-server-install.sh' | sha256sum -c; then
-  chmod +x ./simplex-server-install.sh
-  ./simplex-server-install.sh
-  rm ./simplex-server-install.sh
-else
-  echo "SHA-256 checksum is incorrect!"
-  rm ./simplex-server-install.sh
-fi
+curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/install.sh -o simplex-server-install.sh \
+&& if echo 'b8cf2be103f21f9461d9a500bcd3db06ab7d01d68871b07f4bd245195cbead1d simplex-server-install.sh' | sha256sum -c; then chmod +x ./simplex-server-install.sh && ./simplex-server-install.sh; rm ./simplex-server-install.sh; else echo "SHA-256 checksum is incorrect!" && rm ./simplex-server-install.sh; fi
 ```

 ### Build from source
@@ -187,7 +180,7 @@ On Linux, you can build smp server using Docker.
 3. Run your Docker container.

   - `smp-server`
-
+   
     You must change **your_ip_or_domain**. `-e "pass=password"` is optional variable to password-protect your `smp` server:
     ```sh
     docker run -d \
@@ -200,7 +193,7 @@ On Linux, you can build smp server using Docker.
     ```

   - `xftp-server`
-
+   
     You must change **your_ip_or_domain** and **maximum_storage**.
     ```sh
     docker run -d \
@@ -247,7 +240,7 @@ On Linux, you can build smp server using Docker.

   `xftp-server`
   ```sh
-   cabal list-bin exe:xftp-server
+   cabal list-bin exe:xftp-server 
   ```

 - Initialize SMP server with `smp-server init [-l] -n <fqdn>` or `smp-server init [-l] --ip <ip>` - depending on how you initialize it, either FQDN or IP will be used for server's address.
@@ -15,6 +15,7 @@ logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}

 main :: IO ()
 main = do
+  setLogLevel LogDebug -- change to LogError in production
  cfgPath <- getEnvPath "NTF_SERVER_CFG_PATH" defaultCfgPath
  logPath <- getEnvPath "NTF_SERVER_LOG_PATH" defaultLogPath
  withGlobalLogging logCfg $ ntfServerCLI cfgPath logPath
@@ -16,6 +16,7 @@ logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}

 main :: IO ()
 main = do
+  setLogLevel LogDebug
  cfgPath <- getEnvPath "SMP_SERVER_CFG_PATH" defaultCfgPath
  logPath <- getEnvPath "SMP_SERVER_LOG_PATH" defaultLogPath
-  withGlobalLogging logCfg $ smpServerCLI_ Static.generateSite Static.serveStaticFiles Static.attachStaticFiles cfgPath logPath
+  withGlobalLogging logCfg $ smpServerCLI_ Static.generateSite Static.serveStaticFiles cfgPath logPath
@@ -1,49 +0,0 @@
-{
-  "applinks": {
-    "details": [
-      {
-        "appIDs": [
-          "5NN7GUYB6T.chat.simplex.app"
-        ],
-        "components": [
-          {
-            "/": "/contact/*"
-          },
-          {
-            "/": "/contact"
-          },
-          {
-            "/": "/invitation/*"
-          },
-          {
-            "/": "/invitation"
-          },
-          {
-            "/": "/a/*"
-          },
-          {
-            "/": "/a"
-          },
-          {
-            "/": "/c/*"
-          },
-          {
-            "/": "/c"
-          },
-          {
-            "/": "/g/*"
-          },
-          {
-            "/": "/g"
-          },
-          {
-            "/": "/i/*"
-          },
-          {
-            "/": "/i"
-          }
-        ]
-      }
-    ]
-  }
-}
@@ -1,16 +0,0 @@
-[
-    {
-        "relation": [
-            "delegate_permission/common.handle_all_urls"
-        ],
-        "target": {
-            "namespace": "android_app",
-            "package_name": "chat.simplex.app",
-            "sha256_cert_fingerprints": [
-                "5E:3E:DC:C2:00:FB:A8:D5:F4:88:F3:CA:4C:32:5B:05:78:C5:6A:9C:03:A1:CC:B5:92:9C:D7:5C:7E:57:E2:4D",
-                "3C:52:C4:FD:3C:AD:1C:07:C9:B0:0A:70:80:E3:58:FA:B9:FE:FC:B8:AF:5A:EC:14:77:65:F1:6D:0F:21:AD:85",
-                "AE:C1:95:DC:FD:46:14:BD:3A:91:EC:26:D1:D5:14:C8:75:71:C5:CC:8D:CF:48:08:3F:92:83:14:3C:A2:B9:A6"
-            ]
-        }
-    }
-]
@@ -1 +0,0 @@
-../link.html
@@ -1 +0,0 @@
-../link.html
@@ -1 +0,0 @@
-../link.html
@@ -221,16 +221,9 @@
              Public information
            </h2>
            <table id="public-info">
-              <tr class="text-grey-black dark:text-white text-base">
-                <td>Server version:</td>
-                <td>${version}<x-commit> / <a href="${commitSourceCode}/commit/${commit}" target="_blank">${shortCommit}</a></x-commit></td>
-              </tr>
              <tr class="text-grey-black dark:text-white text-base">
                <td>Source code:</td>
-                <td>
-                  <x-sourceCode><a href="${sourceCode}" target="_blank">${sourceCode}</a></x-sourceCode>
-                  <x-noSourceCode>add to smp-server.ini (required by <a href="https://github.com/simplex-chat/simplexmq/blob/stable/LICENSE" target="_blank">AGPLv3</a>)</x-noSourceCode>
-                </td>
+                <td><a href="${sourceCode}" target="_blank">${sourceCode}</a></td>
              </tr>
              <x-website>
                <tr class="text-grey-black dark:text-white text-base">
@@ -298,12 +291,6 @@
                  <td>${hostingEntity} (${hostingCountry})</td>
                </tr>
              </x-hosting>
-              <x-hostingType>
-                <tr class="text-grey-black dark:text-white text-base">
-                  <td>Hosting type:</td>
-                  <td>${hostingType}</td>
-                </tr>
-              </x-hostingType>
              <x-serverCountry>
                <tr class="text-grey-black dark:text-white text-base">
                  <td>Server country:</td>
@@ -142,7 +142,8 @@
    class="hidden xl:block h-screen pt-[66px] bg-white dark:bg-gradient-radial-mobile dark:lg:bg-gradient-radial">
    <div class="container m-auto h-full flex items-center justify-between px-5">
      <div class="flex flex-col items-start justify-center w-full">
-        <h1 class="text-[38px] leading-[43px] font-bold max-w-[500px] mb-[30px] primary-header-contact">This is a one-time link of the SimpleX&nbsp;network user</h1>
+        <h1 class="text-[38px] leading-[43px] font-bold max-w-[500px] mb-[30px] primary-header-contact">You received a
+          1-time link to connect on SimpleX Chat</h1>
        <h2
          class="text-[20px] leading-[28px] text-[#606C71] dark:text-white font-bold max-w-[475px] mb-[80px] secondary-header-contact">
          Scan the QR code with the SimpleX Chat app on your phone or tablet.</h2>
@@ -183,8 +184,10 @@
    class="block xl:hidden pt-[106px] py-[90px] bg-white dark:bg-gradient-radial-mobile dark:lg:bg-gradient-radial">
    <div class="container m-auto px-5">
      <div class="flex flex-col items-center">
-        <h1 class="text-[28px] font-bold text-center max-w-[602px] mb-[40px] primary-header-contact">This is a one-time link of the SimpleX&nbsp;network user</h1>
-        <p class="text-[20px] leading-[28px] text-grey-black dark:text-white font-medium mb-[30px]">To make a connection:</p>
+        <h1 class="text-[28px] font-bold text-center max-w-[602px] mb-[40px] primary-header-contact">You received a
+          1-time link to connect on SimpleX Chat</h1>
+        <p class="text-[20px] leading-[28px] text-grey-black dark:text-white font-medium mb-[30px]">To make a
+          connection:</p>
        <div
          class="flex flex-col justify-center items-center p-4 w-full max-w-[468px] min-h-[131px] rounded-[30px] border-[1px] border-[#A8B0B4] dark:border-white border-opacity-60 mb-6 relative">
          <p class="text-xl font-medium text-grey-black dark:text-white mb-4">Install SimpleX app</p>
@@ -503,17 +506,13 @@
    const url = window.location.href
    const messageElements = document.getElementsByClassName('primary-header-contact')

-    for (let element of messageElements) {
-      if (url.includes('/g') || url.includes('&data=%7B%22groupLinkId%22%3A')) {
-        element.innerHTML = 'This is a public group address on SimpleX&nbsp;network'
-      } else if (url.includes('/a') || url.includes('/contact')) {
-        element.innerHTML = 'This is a public address of the SimpleX&nbsp;network user'
-      } else if (url.includes('/i') || url.includes('/invitation')) {
-        element.innerHTML = 'This is a one-time link of the SimpleX&nbsp;network user'
-      } else if (url.includes('/c')) {
-        element.innerHTML = 'This is a public channel address on SimpleX&nbsp;network'
-      } else if (url.includes('/r')) {
-        element.innerHTML = 'This is a chat relay address on SimpleX&nbsp;network'
+    if (url.includes('/invitation')) {
+      for (let element of messageElements) {
+        element.textContent = 'You received a 1-time link to connect on SimpleX Chat'
+      }
+    } else {
+      for (let element of messageElements) {
+        element.textContent = 'You received an address to connect on SimpleX Chat'
      }
    }
  </script>
@@ -20,18 +20,7 @@
    parsedURI.pathname = "/" + action
    connURI = parsedURI.toString()
    console.log("connection URI: ", connURI)
-    const hash = parsedURI.hash
-    const hostname = parsedURI.hostname
-    let appURI = "simplex:" + parsedURI.pathname
-    appURI += action.length > 1 // not short link
-              ? hash
-              : !hash.includes("?") // otherwise add server hostname
-              ? hash + "?h=" + hostname // no parameters
-              : !hash.includes("?h=") && !hash.includes("&h=")
-              ? hash + "&h=" + hostname // no "h" parameter
-              : hash.replace(/([?&])h=([^&]+)/, `$1h=${hostname},$2`) // add as the first hostname to "h" parameter
-    mobileConnURIanchor.href = appURI
-    console.log("app URI: ", appURI)
+    mobileConnURIanchor.href = "simplex:" + parsedURI.pathname + parsedURI.hash
    connURIel.innerText = "/c " + connURI
    for (const connQRCode of connQRCodes) {
      try {
@@ -7,119 +7,50 @@ module Static where
 import Control.Logger.Simple
 import Control.Monad
 import Data.ByteString (ByteString)
-import qualified Data.ByteString.Char8 as B
-import Data.Char (toUpper)
-import Data.IORef (readIORef)
+import qualified Data.ByteString as B
 import Data.Maybe (fromMaybe)
 import Data.String (fromString)
-import qualified Data.Text as T
 import Data.Text.Encoding (encodeUtf8)
-import Network.Socket (getPeerName)
-import Network.Wai (Application, Request (..))
-import Network.Wai.Application.Static (StaticSettings (..))
-import qualified Network.Wai.Application.Static as S
-import qualified Network.Wai.Handler.Warp as W
-import qualified Network.Wai.Handler.Warp.Internal as WI
-import qualified Network.Wai.Handler.WarpTLS as WT
+import Network.Wai.Application.Static as S
+import Network.Wai.Handler.Warp as W
+import qualified Network.Wai.Handler.WarpTLS as W
 import Simplex.Messaging.Encoding.String (strEncode)
-import Simplex.Messaging.Server (AttachHTTP)
-import Simplex.Messaging.Server.CLI (simplexmqCommit)
 import Simplex.Messaging.Server.Information
-import Simplex.Messaging.Server.Main (EmbeddedWebParams (..), WebHttpsParams (..), simplexmqSource)
-import Simplex.Messaging.Transport (simplexMQVersion)
+import Simplex.Messaging.Server.Main (EmbeddedWebParams (..), WebHttpsParams (..))
 import Simplex.Messaging.Transport.Client (TransportHost (..))
 import Simplex.Messaging.Util (tshow)
 import Static.Embedded as E
 import System.Directory (createDirectoryIfMissing)
 import System.FilePath
 import UnliftIO.Concurrent (forkFinally)
-import UnliftIO.Exception (bracket, finally)
-import qualified WaiAppStatic.Types as WAT

 serveStaticFiles :: EmbeddedWebParams -> IO ()
 serveStaticFiles EmbeddedWebParams {webStaticPath, webHttpPort, webHttpsParams} = do
  forM_ webHttpPort $ \port -> flip forkFinally (\e -> logError $ "HTTP server crashed: " <> tshow e) $ do
    logInfo $ "Serving static site on port " <> tshow port
-    W.runSettings (mkSettings port) app
+    W.runSettings (mkSettings port) (S.staticApp $ S.defaultFileServerSettings webStaticPath)
  forM_ webHttpsParams $ \WebHttpsParams {port, cert, key} -> flip forkFinally (\e -> logError $ "HTTPS server crashed: " <> tshow e) $ do
    logInfo $ "Serving static site on port " <> tshow port <> " (TLS)"
-    WT.runTLS (WT.tlsSettings cert key) (mkSettings port) app
+    W.runTLS (W.tlsSettings cert key) (mkSettings port) (S.staticApp $ S.defaultFileServerSettings webStaticPath)
  where
-    app = staticFiles webStaticPath
-    mkSettings port = W.setPort port warpSettings
-
-- | Prepare context and prepare HTTP handler for TLS connections that already passed TLS.handshake and ALPN check.
-attachStaticFiles :: FilePath -> (AttachHTTP -> IO ()) -> IO ()
-attachStaticFiles path action =
-  -- Initialize global internal state for http server.
-  WI.withII warpSettings $ \ii -> do
-    action $ \socket cxt -> do
-      -- Initialize internal per-connection resources.
-      addr <- getPeerName socket
-      withConnection addr cxt $ \(conn, transport) ->
-        withTimeout ii conn $ \th ->
-          -- Run Warp connection handler to process HTTP requests for static files.
-          WI.serveConnection conn ii th addr transport warpSettings app
-  where
-    app = staticFiles path
-    -- from warp-tls
-    withConnection socket cxt = bracket (WT.attachConn socket cxt) (terminate . fst)
-    -- from warp
-    withTimeout ii conn =
-      bracket
-        (WI.registerKillThread (WI.timeoutManager ii) (WI.connClose conn))
-        WI.cancel
-    -- shared clean up
-    terminate conn = WI.connClose conn `finally` (readIORef (WI.connWriteBuffer conn) >>= WI.bufFree)
-
-warpSettings :: W.Settings
-warpSettings = W.setGracefulShutdownTimeout (Just 1) W.defaultSettings
-
-staticFiles :: FilePath -> Application
-staticFiles root = S.staticApp settings . changeWellKnownPath
-  where
-    settings = defSettings {ssListing = Nothing, ssGetMimeType = getMimeType}
-    defSettings = S.defaultFileServerSettings root
-    getMimeType f
-      | WAT.fromPiece (WAT.fileName f) == "apple-app-site-association" = pure "application/json"
-      | otherwise = (ssGetMimeType defSettings) f
-    changeWellKnownPath req = case pathInfo req of
-      ".well-known" : rest ->
-        req
-          { pathInfo = "well-known" : rest,
-            rawPathInfo = "/well-known/" <> B.drop pfxLen (rawPathInfo req)
-          }
-      _ -> req
-    pfxLen = B.length "/.well-known/"
+    mkSettings port = setPort port defaultSettings

 generateSite :: ServerInformation -> Maybe TransportHost -> FilePath -> IO ()
 generateSite si onionHost sitePath = do
  createDirectoryIfMissing True sitePath
  B.writeFile (sitePath </> "index.html") $ serverInformation si onionHost
-  copyDir "media" E.mediaContent
-  -- `.well-known` path is re-written in changeWellKnownPath,
-  -- staticApp does not allow hidden folders.
-  copyDir "well-known" E.wellKnown
-  createLinkPage "contact"
-  createLinkPage "invitation"
-  createLinkPage "a"
-  createLinkPage "c"
-  createLinkPage "g"
-  createLinkPage "r"
-  createLinkPage "i"
+  createDirectoryIfMissing True $ sitePath </> "media"
+  forM_ E.mediaContent $ \(path, bs) -> B.writeFile (sitePath </> "media" </> path) bs
+  createDirectoryIfMissing True $ sitePath </> "contact"
+  B.writeFile (sitePath </> "contact" </> "index.html") E.linkHtml
+  createDirectoryIfMissing True $ sitePath </> "invitation"
+  B.writeFile (sitePath </> "invitation" </> "index.html") E.linkHtml
  logInfo $ "Generated static site contents at " <> tshow sitePath
-  where
-    copyDir dir content = do
-      createDirectoryIfMissing True $ sitePath </> dir
-      forM_ content $ \(path, s) -> B.writeFile (sitePath </> dir </> path) s
-    createLinkPage path = do
-      createDirectoryIfMissing True $ sitePath </> path
-      B.writeFile (sitePath </> path </> "index.html") E.linkHtml

 serverInformation :: ServerInformation -> Maybe TransportHost -> ByteString
 serverInformation ServerInformation {config, information} onionHost = render E.indexHtml substs
  where
-    substs = substConfig <> substInfo <> [("onionHost", strEncode <$> onionHost)]
+    substs = substConfig <> maybe [] substInfo information <> [("onionHost", strEncode <$> onionHost)]
    substConfig =
      [ ( "persistence",
          Just $ case persistence config of
@@ -134,7 +65,7 @@ serverInformation ServerInformation {config, information} onionHost = render E.i
      ]
    yesNo True = "Yes"
    yesNo False = "No"
-    substInfo =
+    substInfo spi =
      concat
        [ basic,
          maybe [("usageConditions", Nothing), ("usageAmendments", Nothing)] conds (usageConditions spi),
@@ -146,16 +77,9 @@ serverInformation ServerInformation {config, information} onionHost = render E.i
        ]
      where
        basic =
-          [ ("sourceCode", if T.null sc then Nothing else Just (encodeUtf8 sc)),
-            ("noSourceCode", if T.null sc then Just "none" else Nothing),
-            ("version", Just $ B.pack simplexMQVersion),
-            ("commitSourceCode", Just $ encodeUtf8 $ maybe (T.pack simplexmqSource) sourceCode information),
-            ("shortCommit", Just $ B.pack $ take 7 simplexmqCommit),
-            ("commit", Just $ B.pack simplexmqCommit),
+          [ ("sourceCode", Just . encodeUtf8 $ sourceCode spi),
            ("website", encodeUtf8 <$> website spi)
          ]
-        spi = fromMaybe (emptyServerInfo "") information
-        sc = sourceCode spi
        conds ServerConditions {conditions, amendments} =
          [ ("usageConditions", Just $ encodeUtf8 conditions),
            ("usageAmendments", encodeUtf8 <$> amendments)
@@ -185,8 +109,7 @@ serverInformation ServerInformation {config, information} onionHost = render E.i
            ("hostingCountry", encodeUtf8 <$> country)
          ]
        server =
-          [ ("serverCountry", encodeUtf8 <$> serverCountry spi),
-            ("hostingType",  (\s -> maybe s (\(c, rest) -> toUpper c `B.cons` rest) $ B.uncons s) . strEncode <$> hostingType spi)
+          [ ("serverCountry", fmap encodeUtf8 $ serverCountry =<< information)
          ]

 -- Copy-pasted from simplex-chat Simplex.Chat.Types.Preferences
@@ -237,8 +160,8 @@ section_ label content' src =
        (inside, next') ->
          let next = B.drop (B.length endMarker) next'
           in case content' of
-                Just content | not (B.null content) -> before <> item_ label content inside <> section_ label content' next
-                _ -> before <> next -- collapse section
+                Nothing -> before <> next -- collapse section
+                Just content -> before <> item_ label content inside <> section_ label content' next
  where
    startMarker = "<x-" <> label <> ">"
    endMarker = "</x-" <> label <> ">"
@@ -13,6 +13,3 @@ linkHtml = $(embedFile "apps/smp-server/static/link.html")

 mediaContent :: [(FilePath, ByteString)]
 mediaContent = $(embedDir "apps/smp-server/static/media/")
-
-wellKnown :: [(FilePath, ByteString)]
-wellKnown = $(embedDir "apps/smp-server/static/.well-known/")
@@ -4,15 +4,6 @@ packages: .
 -- packages: . ../http2
 -- packages: . ../network-transport

-- uncomment two sections below to run tests with coverage
-- package *
-   -- coverage: True
-   -- library-coverage: True
-
-- package attoparsec
-   -- coverage: False
-   -- library-coverage: False
-
 index-state: 2023-12-12T00:00:00Z

 package cryptostore
@@ -37,17 +28,3 @@ source-repository-package
    type: git
    location: https://github.com/simplex-chat/sqlcipher-simple.git
    tag: a46bd361a19376c5211f1058908fc0ae6bf42446
-
-- waiting for published warp-tls-3.4.7
-source-repository-package
-    type: git
-    location: https://github.com/yesodweb/wai.git
-    tag: ec5e017d896a78e787a5acea62b37a4e677dec2e
-    subdir: warp-tls
-
-- backported fork due http-5.0
-source-repository-package
-    type: git
-    location: https://github.com/simplex-chat/wai.git
-    tag: 2f6e5aa5f05ba9140ac99e195ee647b4f7d926b0
-    subdir: warp
@@ -2,6 +2,10 @@
 set -eu

 # Links to scripts/configs
+bin="https://github.com/simplex-chat/simplexmq/releases/latest/download"
+bin_smp="$bin/smp-server-ubuntu-20_04-x86-64"
+bin_xftp="$bin/xftp-server-ubuntu-20_04-x86-64"
+
 scripts="https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/scripts/main"
 scripts_systemd_smp="$scripts/smp-server.service"
 scripts_systemd_xftp="$scripts/xftp-server.service"
@@ -22,8 +26,6 @@ path_conf_var="/var/opt"
 path_conf_smp="$path_conf_etc/simplex $path_conf_var/simplex"
 path_conf_xftp="$path_conf_etc/simplex-xftp $path_conf_var/simplex-xftp /srv/xftp"

-path_conf_info="$path_conf_etc/simplex-info"
-
 path_systemd="/etc/systemd/system"
 path_systemd_smp="$path_systemd/smp-server.service"
 path_systemd_xftp="$path_systemd/xftp-server.service"
@@ -54,7 +56,7 @@ ${GRN}1.${NC} Install latest binaries from GitHub releases:
 ${GRN}2.${NC} Create server directories:
    - smp: ${YLW}${path_conf_smp}${NC}
    - xftp: ${YLW}${path_conf_xftp}${NC}
-${GRN}3.${NC} Setup user for server:
+${GRN}3.${NC} Setup user for each server:
    - xmp: ${YLW}${user_smp}${NC}
    - xftp: ${YLW}${user_xftp}${NC}
 ${GRN}4.${NC} Create systemd services:
@@ -63,12 +65,7 @@ ${GRN}4.${NC} Create systemd services:
 ${GRN}5.${NC} Install stopscript (systemd), update and uninstallation script:
    - all: ${YLW}${path_bin_update}${NC}, ${YLW}${path_bin_uninstall}${NC}, ${YLW}${path_bin_stopscript}${NC}

-Press:
-  - ${GRN}1${NC} to install smp server
-  - ${GRN}2${NC} to install xftp server
-  - ${RED}Ctrl+C${NC} to cancel installation
-  
-Selection: "
+Press ${GRN}ENTER${NC} to continue or ${RED}Ctrl+C${NC} to cancel installation"

 end="Installtion is complete!

@@ -79,79 +76,27 @@ Please checkout our server guides:
 To uninstall with full clean-up, simply run: ${YLW}sudo /usr/local/bin/simplex-servers-uninstall${NC}
 "

-set_version() {
-  ver="${VER:-latest}"
-
-  case "$ver" in 
-    latest)
-      bin="https://github.com/simplex-chat/simplexmq/releases/latest/download"
-      remote_version="$(curl --proto '=https' --tlsv1.2 -sSf -L https://api.github.com/repos/simplex-chat/simplexmq/releases/latest | grep -i "tag_name" | awk -F \" '{print $4}')"
-      ;;
-    *)
-      bin="https://github.com/simplex-chat/simplexmq/releases/download/${ver}"
-      remote_version="${ver}"
-      ;;
-  esac
-}
-
-os_test() {
- . /etc/os-release
-
- case "$VERSION_ID" in
-  20.04|22.04) : ;;
-  24.04) VERSION_ID='22.04' ;;
-  *) printf "${RED}Unsupported Ubuntu version!${NC}\nPlease file Github issue with request to support Ubuntu %s: https://github.com/simplex-chat/simplexmq/issues/new\n" "$VERSION_ID" && exit 1 ;;
- esac
-
- version="$(printf '%s' "$VERSION_ID" | tr '.' '_')"
- arch="$(uname -p)"
-
- case "$arch" in
-  x86_64) arch="$(printf '%s' "$arch" | tr '_' '-')" ;;
-  *)  printf "${RED}Unsupported architecture!${NC}\nPlease file Github issue with request to support %s architecture: https://github.com/simplex-chat/simplexmq/issues/new" "$arch" && exit 1 ;;
- esac
-
- bin_smp="$bin/smp-server-ubuntu-${version}-${arch}"
- bin_xftp="$bin/xftp-server-ubuntu-${version}-${arch}"
-}
-
 setup_bins() {
- eval "bin=\$bin_${1}"
- eval "path=\$path_bin_${1}"
-
- curl --proto '=https' --tlsv1.2 -sSf -L "$bin" -o "$path" && chmod +x "$path"
-
- unset bin path
+ curl --proto '=https' --tlsv1.2 -sSf -L "$bin_smp" -o "$path_bin_smp" && chmod +x "$path_bin_smp"
+ curl --proto '=https' --tlsv1.2 -sSf -L "$bin_xftp" -o "$path_bin_xftp" && chmod +x "$path_bin_xftp"
 }

 setup_users() {
- eval "user=\$user_${1}"
-
- useradd -M "$user" 2> /dev/null || true
-
- unset user
+ useradd -M "$user_smp" 2> /dev/null || true
+ useradd -M "$user_xftp" 2> /dev/null || true
 }

 setup_dirs() {
 # Unquoted varibles, so field splitting can occur
- eval "path_conf=\$path_conf_${1}"
- eval "user=\$user_${1}"
-
- mkdir -p $path_conf
- mkdir -p $path_conf_info
- printf "local_version_%s='%s'\n" "$1" "$remote_version" >> "$path_conf_info/release"
- chown -R "$user":"$user" $path_conf
-
- unset path_conf user
+ mkdir -p $path_conf_smp
+ chown "$user_smp":"$user_smp" $path_conf_smp
+ mkdir -p $path_conf_xftp
+ chown "$user_xftp":"$user_xftp" $path_conf_xftp
 }

 setup_systemd() {
- eval "scripts_systemd=\$scripts_systemd_${1}"
- eval "path_systemd=\$path_systemd_${1}"
-
- curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd" -o "$path_systemd"
-
- unset scripts_systemd path_systemd
+ curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_smp" -o "$path_systemd_smp"
+ curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_xftp" -o "$path_systemd_xftp"
 }

 setup_scripts() {
@@ -165,61 +110,32 @@ checks() {
  printf "This script is intended to be run with root privileges. Please re-run script using sudo."
  exit 1
 fi
- 
- set_version
- os_test
-
- mkdir -p $path_conf_info  
 }

 main() {
 checks
 
- printf "%b\n%b" "${BLU}$logo${NC}" "$welcome"
+ printf "%b\n%b\n" "${BLU}$logo${NC}" "$welcome"
 read ans

- case "$ans" in
-  1) setup='smp' ;;
-  2) setup='xftp' ;;
-  *) printf 'Installation aborted.\n' && exit 0 ;;
- esac
-
 printf "Installing binaries..."
- 
- for i in $setup; do
-  setup_bins "$i"
- done
- 
+ setup_bins
 printf "${GRN} Done!${NC}\n"

 printf "Creating users..."
-
- for i in $setup; do
-  setup_users "$i"
- done
-
+ setup_users
 printf "${GRN} Done!${NC}\n"
 
 printf "Creating directories..."
-
- for i in $setup; do
-  setup_dirs "$i"
- done
-
+ setup_dirs
 printf "${GRN} Done!${NC}\n"

 printf "Creating systemd services..."
-
- for i in $setup; do
-  setup_systemd "$i"
- done
-
+ setup_systemd
 printf "${GRN} Done!${NC}\n"

 printf "Installing stopscript, update and uninstallation script..."
-
 setup_scripts
-
 printf "${GRN} Done!${NC}\n"

 printf "%b" "$end"
@@ -0,0 +1,211 @@
+name: simplexmq
+version: 6.0.0.7
+synopsis: SimpleXMQ message broker
+description: |
+  This package includes <./docs/Simplex-Messaging-Server.html server>,
+  <./docs/Simplex-Messaging-Client.html client> and
+  <./docs/Simplex-Messaging-Agent.html agent> for SMP protocols:
+  .
+  * <https://github.com/simplex-chat/simplexmq/blob/master/protocol/simplex-messaging.md SMP protocol>
+  * <https://github.com/simplex-chat/simplexmq/blob/master/protocol/agent-protocol.md SMP agent protocol>
+  .
+  See <https://github.com/simplex-chat/simplex-chat terminal chat prototype> built with SimpleXMQ broker.
+
+homepage: https://github.com/simplex-chat/simplexmq#readme
+license: AGPL-3
+author: simplex.chat
+maintainer: chat@simplex.chat
+copyright: 2020-2022 simplex.chat
+category: Chat, Network, Web, System, Cryptography
+extra-source-files:
+  - README.md
+  - CHANGELOG.md
+  - cbits/sha512.h
+  - cbits/sntrup761.h
+  - apps/smp-server/static/*.html
+  - apps/smp-server/static/media/*
+
+dependencies:
+  - aeson == 2.2.*
+  - ansi-terminal >= 0.10 && < 0.12
+  - asn1-encoding == 0.9.*
+  - asn1-types == 0.3.*
+  - async == 2.2.*
+  - attoparsec == 0.14.*
+  - base >= 4.14 && < 5
+  - base64-bytestring >= 1.0 && < 1.3
+  - case-insensitive == 1.2.*
+  - composition == 1.0.*
+  - constraints >= 0.12 && < 0.14
+  - containers == 0.6.*
+  - crypton == 0.34.*
+  - crypton-x509 == 1.7.*
+  - crypton-x509-store == 1.6.*
+  - crypton-x509-validation == 1.6.*
+  - cryptostore == 0.3.*
+  - data-default == 0.7.*
+  - direct-sqlcipher == 2.3.*
+  - directory == 1.3.*
+  - filepath == 1.4.*
+  - hourglass == 0.2.*
+  - http-types == 0.12.*
+  - http2 >= 4.2.2 && < 4.3
+  - ini == 0.4.1
+  - iproute == 1.7.*
+  - iso8601-time == 0.1.*
+  - memory == 0.18.*
+  - mtl >= 2.3.1 && < 3.0
+  - network >= 3.1.2.7 && < 3.2
+  - network-info >= 0.2 && < 0.3
+  - network-transport == 0.5.6
+  - network-udp >= 0.0 && < 0.1
+  - optparse-applicative >= 0.15 && < 0.17
+  - process == 1.6.*
+  - random >= 1.1 && < 1.3
+  - simple-logger == 0.1.*
+  - socks == 0.6.*
+  - sqlcipher-simple == 0.4.*
+  - stm == 2.5.*
+  - temporary == 1.3.*
+  - time == 1.12.*
+  - time-manager == 0.0.*
+  - tls >= 1.7.0 && < 1.8
+  - transformers == 0.6.*
+  - unliftio == 0.2.*
+  - unliftio-core == 0.2.*
+  - websockets == 0.12.*
+  - yaml == 0.11.*
+  - zstd == 0.1.3.*
+
+flags:
+  swift:
+    description: Enable swift JSON format
+    manual: True
+    default: False
+  use_crypton:
+    description: Use crypton etc. in cryptostore
+    manual: True
+    default: True
+
+# cpp-options:
+#   - -Dslow_servers
+
+when:
+  - condition: flag(swift)
+    cpp-options:
+      - -DswiftJSON
+  - condition: impl(ghc >= 9.6.2)
+    dependencies:
+      - bytestring == 0.11.*
+      - template-haskell == 2.20.*
+      - text >= 2.0.1 && < 2.2
+  - condition: impl(ghc < 9.6.2)
+    dependencies:
+      - bytestring == 0.10.*
+      - template-haskell == 2.16.*
+      - text >= 1.2.3.0 && < 1.3
+
+library:
+  source-dirs: src
+  c-sources:
+    - cbits/sha512.c
+    - cbits/sntrup761.c
+  include-dirs: cbits
+  extra-libraries: crypto
+
+executables:
+  smp-server:
+    source-dirs:
+    - apps/smp-server
+    - apps/smp-server/web
+    main: Main.hs
+    dependencies:
+      - file-embed
+      - simplexmq
+      - wai-app-static
+      - warp
+      - warp-tls
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  ntf-server:
+    source-dirs: apps/ntf-server
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  xftp-server:
+    source-dirs: apps/xftp-server
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  xftp:
+    source-dirs: apps/xftp
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+tests:
+  simplexmq-test:
+    source-dirs: tests
+    main: Test.hs
+    dependencies:
+      - simplexmq
+      - deepseq == 1.4.*
+      - generic-random == 1.5.*
+      - hspec == 2.11.*
+      - hspec-core == 2.11.*
+      - HUnit == 1.6.*
+      - QuickCheck == 2.14.*
+      - silently == 1.2.*
+      - main-tester == 0.2.*
+      - timeit == 2.0.*
+    ghc-options:
+      - -threaded
+      - -rtsopts
+      - -with-rtsopts=-A64M
+      - -with-rtsopts=-N1
+
+ghc-options:
+  # - -haddock
+  - -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-unused-packages
+  - -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
+
+default-extensions:
+  - StrictData
@@ -559,13 +559,11 @@ In current implementation of XFTP protocol in SimpleX Chat clients don't use FAC

 - perform traffic correlation attacks against senders and recipients and correlate senders and recipients within the monitored set, frustrated by the number of users on the servers.

- - observe how much traffic is being sent, and make guesses as to its purpose.
+ - observe how much traffic is being sent, and make guesses as to its purpose

- - in case of a compromised transport protocol, correlate file senders and receivers.
+*cannot, even in case of a compromised transport protocol:*

-*cannot, in case of a non-compromised transport protocol:*
-
- - perform traffic correlation attacks.
+ - perform traffic correlation attacks with any increase in efficiency over a non-compromised transport protocol

 #### XFTP server

@@ -67,7 +67,7 @@ The session invitation contains this data:
 - CA TLS certificate fingerprint of the controller - this is part of long term identity of the controller established during the first session, and repeated in the subsequent session announcements.
 - Session Ed25519 public key used to verify the announcement and commands - this mitigates the compromise of the long term signature key, as the controller will have to sign each command with this key first.
 - Long-term Ed25519 public key used to verify the announcement and commands - this is part of the long term controller identity.
- Session X25519 DH key to agree session encryption (both for multicast announcement and for commands and responses in TLS), as described in https://datatracker.ietf.org/doc/draft-josefsson-ntruprime-hybrid/. The new keys are used for each session, and if client key is already available (from the previous session), the computed shared secret will be used to encrypt the announcement multicast packet. The out-of-band invitation is unencrypted. DH public key and KEM encapsulation key are sent unencrypted. NaCL crypto_box is used for encryption.
+- Session X25519 DH key and SNTRUP761 KEM encapsulation key to agree session encryption (both for multicast announcement and for commands and responses in TLS), as described in https://datatracker.ietf.org/doc/draft-josefsson-ntruprime-hybrid/. The new keys are used for each session, and if client key is already available (from the previous session), the computed shared secret will be used to encrypt the announcement multicast packet. The out-of-band invitation is unencrypted. DH public key and KEM encapsulation key are sent unencrypted. NaCL crypto_box is used for encryption.

 Host application decrypts (except the first session) and validates the invitation:
 - Session signature is valid.
@@ -184,7 +184,7 @@ The controller decrypts (including the first session) and validates the received
 The controller should reply with with `ctrlHello` or `ctrlError` response:

 ```abnf
-ctrlHello = %s"HELLO " kemCiphertext encrypted(unpaddedSize ctrlHelloJSON helloPad) pad
+ctrlHello = %s"HELLO " kemCiphertext nonce encrypted(unpaddedSize ctrlHelloJSON helloPad) pad
 ; ctrlHelloJSON is encrypted with the hybrid secret,
 ; including both previously agreed DH secret and KEM secret from kemCiphertext
 unpaddedSize = largeLength
@@ -206,8 +206,6 @@ JTD schema for the encrypted part of controller HELLO block `ctrlHelloJSON`:
 }
 ```

-Controller `hello` block and all subsequent protocol messages are encrypted with the chain keys derived from the hybrid key (see key exchange below) - that is why conntroller hello block does not include nonce. That provides forward secrecy within the XRCP session. Receiving this `hello` block allows host to compute the same hybrid keys and to derive the same chain keys.
-
 Once the controller replies HELLO to the valid host HELLO block, it should stop accepting new TCP connections.

 ### Controller/host session operation
@@ -225,12 +223,10 @@ tlsunique channel binding from TLS session MUST be included in commands (include
 The syntax for encrypted command and response body encoding:

 ```abnf
-commandBody = counter encBody sessSignature idSignature [attachment]
-responseBody = counter encBody [attachment] ; counter must match command
-; counter is placed outside of encrypted body to allow correlating encryption keys
-; with the chain keys (each command and response are encrypted by different keys)
-encBody = encLength32 encrypted(tlsunique body)
-attachment = %x01 encLength32 encrypted(attachment)
+commandBody = encBody sessSignature idSignature [attachment]
+responseBody = encBody [attachment] ; counter must match command
+encBody = nonce encLength32 encrypted(tlsunique counter body)
+attachment = %x01 nonce encLength32 encrypted(attachment)
 noAttachment = %x00
 tlsunique = length 1*OCTET
 counter = 8*8 OCTET ; int64
@@ -243,7 +239,7 @@ If the command or response includes attachment, its hash must be included in com

 Initial announcement is shared out-of-band (URI with xrcp scheme), and it is not encrypted.

-This announcement contains only DH keys, as KEM key is too large to include in QR code, which are used to agree encryption key for host HELLO block. The host HELLO block will contain DH key in plaintext part and KEM encapsulation (public) key in encrypted part, that will be used to determine the shared secret (using SHA3-256 over concatenated DH shared secret and KEM encapsulated secret) to derive keys for controller HELLO response (that contains KEM ciphertext in plaintext part) and subsequent session commands and responses.
+This announcement contains only DH keys, as KEM key is too large to include in QR code, which are used to agree encryption key for host HELLO block. The host HELLO block will contain DH key in plaintext part and KEM encapsulation (public) key in encrypted part, that will be used to determine the shared secret (using SHA256 over concatenated DH shared secret and KEM encapsulated secret) both for controller HELLO response (that contains KEM ciphertext in plaintext part) and subsequent session commands and responses.

 During the next session the announcement is sent via encrypted multicast block. The shared key for this announcement and for host HELLO block is determined using the KEM shared secret from the previous session and DH shared secret computed using the host DH key from the previous session and the new controller DH key from the announcement.

@@ -254,7 +250,7 @@ In pseudo-code:
 ```
 // session 1
 hostHelloSecret(1) = dhSecret(1)
-sessionSecret(1) = sha3-256(dhSecret(1) || kemSecret(1)) // to encrypt session 1 data, incl. controller hello
+sessionSecret(1) = sha256(dhSecret(1) || kemSecret(1)) // to encrypt session 1 data, incl. controller hello
 dhSecret(1) = dh(hostHelloDhKey(1), controllerInvitationDhKey(1))
 kemCiphertext(1) = enc(kemSecret(1), kemEncKey(1))
 // kemEncKey is included in host HELLO, kemCiphertext - in controller HELLO
@@ -266,7 +262,7 @@ dhSecret(n') = dh(hostHelloDhKey(n - 1), controllerDhKey(n))

 // session n
 hostHelloSecret(n) = dhSecret(n)
-sessionSecret(n) = sha3-256(dhSecret(n) || kemSecret(n)) // to encrypt session n data, incl. controller hello
+sessionSecret(n) = sha256(dhSecret(n) || kemSecret(n)) // to encrypt session n data, incl. controller hello
 dhSecret(n) = dh(hostHelloDhKey(n), controllerDhKey(n))
 // controllerDhKey(n) is either from invitation or from multicast announcement
 kemCiphertext(n) = enc(kemSecret(n), kemEncKey(n))
@@ -277,22 +273,6 @@ If controller fails to store the new host DH key after receiving HELLO block, th

 To decrypt a multicast announcement, the host should try to decrypt it using the keys of all known (paired) remote controllers.

-Once kemSecret is agreed for the session, it is used to derive two chain keys, to receive and to send messages:
-
-```
-host: sndKey, rcvKey = HKDF(kemSecret, "SimpleXSbChainInit", 64)
-controller: rcvKey, sndKey  = HKDF(kemSecret, "SimpleXSbChainInit", 64)
-```
-
-where HKDF is based on SHA512, with empty salt.
-
-Actual keys and nonces to encrypt and decrypt messages are derived from these chain keys:
-
-```
-to send: (sndKey', sk, nonce) = HKDF(sndKey, "SimpleXSbChain", 88)
-to receive: (rcvKey', sk, nonce) = HKDF(rcvKey, "SimpleXSbChain", 88)
-```
-
 ## Threat model

 #### A passive network adversary able to monitor the site-local traffic:
@@ -1,124 +0,0 @@
-# Short invitation links
-
-## Problem
-
-Long links look scary and unsafe for many users. While this is a perceived problem, rather than a real one, it hurts adoption.
-
-What is worse, long links do not fit in profile descriptions of other social networks where people might want to advertize their contact addresses.
-
-The current link size limitation is also the reason for not including PQ KEM keys into invitation links and addresses, postponing the moment when PQ-resistant encryption kicks in - if we include PQ KEM key into the link, the QR code will not be scannable.
-
-Additionally, if we store short links, they can also include chat preferences and public profile data.
-
-## Solution
-
-MITM-resistant link shortening.
-
-Instead of generating the random address that would resolve into the link - doing so would create the possibility of MITM by the server hosting this link - we can use private key as the link ID that will be passed to the accepting party, and the hash of the public key as ID for the server - the accepting party would present this key itself as ID and it will also be used for server to client encryption (see Protocol below). HKDF will be used to derive symmetric key from private key and used in secret_box together with random nonce (to allow replacing data with the same key but with a different nonce - nonce will be sent to the server too). secret_box construction is authenticated encryption, so it would protect from MITM.
-
-The proposed syntax:
-
-```abnf
-shortConnectionRequest = connectionScheme "/" connReqType "#/" smpServer "/" linkHash
-connReqType = %s"invitation" / %s"contact"
-connectionScheme = (%s"https://" clientAppServer) / %s"simplex:"
-clientAppServer = hostname [ ":" port ]
-  ; client app server, e.g. simplex.chat
-smpServer = serverIdentity "@" srvHosts [":" port] ; no smp:// prefix, no escaping
-srvHosts = <hostname> ["," srvHosts] ; RFC1123, RFC5891
-linkHash = <base64url encoded SHA256 or SHA512 hash of the original link>
-```
-
-If SMP server supports pages, its name can be used as clientAppServer, without repeating it after #, for a shorter link.
-
-Example link:
-
-```
-https://simplex.chat/contact/#0YuTwO05YJWS8rkjn9eLJDjQhFKvIYd8d4xG8X1blIU=@smp8.simplex.im/abcdefghij0123456789abcdefghij0123456789abc=
-```
-
-This link has the length of ~136 characters (256 bits), which is shorter than the full contact address (~310 characters) and much shorter than invitation links (~528 characters) even without post-quantum keys added to them.
-
-This size can be further reduced by
- use server domain in the link.
- do not include onion address, as the connection happens via proxy anyway, if it's untrusted server.
- not pinning server TLS certificate - the downside here is that while the attack that compromises TLS will not be able to substitute the link (because it's hash will not match), it will be able to intercept and to block it.
- using shorter hash, e.g. SHA128 - reducing the collision resistance.
-
-If the server is known, the client could use it's hash and onion address, otherwise it could trust the proxy to use any existing session with the same hostname or to accept the risk of interception - given that there is no risk of substitution.
-
-With the first two of these "improvements" the link could be ~122 characters:
-
-```
-https://smp8.simplex.im/contact/#0YuTwO05YJWS8rkjn9eLJDjQhFKvIYd8d4xG8X1blIU@/abcdefghij0123456789abcdefghij0123456789abc
-```
-
-If onion address is preserved the link will be ~184 characters (won't fit in Twitter 160 characters bio):
-
-```
-https://smp8.simplex.im/contact/#0YuTwO05YJWS8rkjn9eLJDjQhFKvIYd8d4xG8X1blIU@beccx4yfxxbvyhqypaavemqurytl6hozr47wfc7uuecacjqdvwpw2xid.onion/abcdefghij0123456789abcdefghij0123456789abc
-```
-
-If we implement it, the request to resolve the link would be made via proxied SMP command (to avoid the direct connection between the client and the recipient's server).
-
-Pros:
- a bit shorter link.
- possibility to include post-quantum keys into the full link keeping the same shortened link size.
- possibility to include chat profile of contact or group, and preferences, for a much better connection experience, and to show this information when the link sent in the conversation (clients can resolve them automatically, without connecting - it can be resolved by the sending clients).
- server will not have access to the link.
-
-Cons:
- protocol complexity.
- observers can access the link content, so for 1-time invitation we should only include permissions and not profile.
-
-Pros are a huge improvement of UX of connecting both within and from outside of the app (e.g., link can be resolved even before creating chat profile, as part of the onboarding).
-
-## Protocol
-
-To support short links, the SMP servers would provide a simple key-value store enabled by three additional commands: `WRT`, `CLR` and `READ`
-
-`WRT` command is used to store and to update values in the store. The size of the value is limited by the same size as sent messages (or, possibly, smaller - as connection information size used in confirmation messages) - the clients would use this fixed size irrespective of the content. `WRT` command will be sent with the data blob ID in the transaction entityId field, public authorization key used to authorize `WRT` and `CLR` commands (subsequent WRT commands to the existing key must use the same key), and the data blob.
-
-`CLR` command must use with the same entity ID and must be authorized by the same key.
-
-`READ` command must use the ID which hash would be equal of the ID used to create the data blob, and this ID would also be used as public authorization
-
-## Algorithm to store and to retrieve data blob.
-
-**Store data blob**
-
- the data blob owner generates X25519 key pair: `(k, pk)`.
- private key `pk` will be included in the short link shared with the other party (only base64url encoded key bytes, not X509 encoding).
- `HKDF(pk)` will be used to encrypt the link data with secret_box before storing it on the server.
- the hash of public key `sha256(k)` will be used as ID by the owner to store and to remove the data blob (`WRT` and `CLR` commands).
-
-**Retrieve data blob**
-
- the sender uses the public key `k` derived from the private key `pk` included in the link as entity ID to retrieve data blob (the server will compute the ID used by the owner as `sha256(k)` and will be able to look it up). This provides the quality that the traffic of the parties has no shared IDs inside TLS. It also means that unlike message queue creation, the ID to retrieve the blob was never sent to the blob creator, and also is not known to the server in advance (the second part is only an observation, in itself it does not increase security, as server has access to an encrypted blob anyway).
- note that the sender does not authorize the request to retrieve the blob, as it would not increase security unless a different key is used to authorize, and adding a key would increase link size.
- server session keys with the sender will be `(sk, spk)`, where `sk` is public key shared with the sender during session handshake, and `spk` is the private key known only to the server.
- this public key `k` will also be combined with server session key `spk` using `dh(k, spk)` to encrypt the response, so that there is no ciphertext in common in sent and received traffic for these blobs. Correlation ID will be used as a nonce for this encryption.
- having received the blob, the client can now decrypt it using secret_box with `HKDF(pk)`.
-
-Using the same key as ID for the request, and also to additionally encrypt the response allows to use a single key in the link, without increasing the link size.
-
-## Threat model
-
-**Compromised SMP server**
-
-can:
- delete link data.
- hide link selectively from some requests.
-
-cannot:
- undetectably replace link data.
- access unencrypted link data, whether it was or was not accessed by the accepting party.
- observe IP addresses of the users accessing link data.
-
-**Passive observer who observed short link**:
-
-can:
- access original unencrypted link data
-
-cannot:
- replace or delete the link data
@@ -1,18 +0,0 @@
-# iOS notifications stability
-
-## Problem
-
-iOS notifications may fail to deliver for several reasons, but there are two important reasons that we could address:
- when notification server is not subscribed to SMP server(s), the notifications can be dropped - it can happen because either notification server restarts or becuase SMP server restarted and some messages are received before notification server resubscribed. We lose approximately 3% of notifications because of this reason.
- when user device is offline or has low power condition, Apple does not deliver notification, but puts them to storage. If while the notification is in storage a new one arrives it would overwrite the previous notification. If it was the message to the same message queue, the client will download messages anyway, up to a limit, but if the message was to another queue, it will not be delivered until the app is opened. Apple delivers about 88% of notifications that should be delivered (not accounting for uninstalled apps), the rest is replaced with the newer notifications.
-
-## Solution
-
-The first problem can be solved by preserving notifications for a limited time (say 1 hour) in case there is no subscription to notification from notification server. At the very least, they can be preserved in SMP server memory but can also be stored to a file on restart, similar to messages, and be delivered when notification server resubscribes. It is sufficient to store one notification per messaging queue.
-
-The second problem is both more damaging and more complex to solve. The solution could be to always deliver several last notifications to different queues in one packet (Apple allows up to ~4-5kb notification size, and we are sending packets of fixed size 512 bytes, so we could fit up to 8-10 of them in each notification).
-
-Every time a client receives such batch of notifications if can:
- check if that notification was already received in the previous batch.
- if it was received, it would be ignored, otherwise it would be processed.
- process them one by one, started from the most recent one while the time allows.
@@ -1,179 +0,0 @@
-# SMP server message storage
-
-## Problem
-
-Currently SMP servers store all queues in server memory. As the traffic grows, so does the number of undelivered messages. What is worse, Haskell is not avoiding heap fragmentation when messages are allocated and then de-allocated - undelivered messages use ByteString and GC cannot move them around, as they use pinned memory.
-
-## Possible solutions
-
-### Solution 1: solve only GC fragmentation problem
-
-Move from ByteString to some other primitive to store messages in memory long term, e.g. ShortByteString, or manage allocation/de-allocation of stored messages manually in some other way.
-
-Pros: the simplest solution that avoids substantial re-engineering of the server.
-
-Cons:
- not a long term solution, as memory growth still has limits.
- may be ineffective, as it introduces additional copying of bytes.
-
-### Solution 2: move message storage to hard drive
-
-Use files or RocksDB to store messages.
-
-Pros:
- much lower memory usage.
- no message loss in case of abnormal server termination (important until clients have delivery redundancy).
- this is a long term solution, and at some point it might need to be done anyway.
-
-Cons:
- substantial re-engineering costs and risks.
- metadata privacy. Currently we only save undelivered messages when server is restarted, with this approach all messages will be stored for some time. this argument is limited, as hosting providers of VMs can make memory snapshots too, on the other hand they are harder to analyze than files. On another hand, with this approach messages will be stored for a shorter time.
-
-#### RocksDB and other key-value stores
-
-The downside of any key-value stores is that they don't seem to have efficient primitives for sequential delivery. While sequential delivery can be modelled with linked lists, they would require 1 key insert (on send), 3 key updates (1 update to update queue data on send, 1 update of the last message to point to the next, 1 update on delivery or message expiration) and 1 key deletion (on delivery or message expiration) for each delivered message.
-
-This might result in substantial write amplification and compacting costs.
-
-In general, tree structures that are efficient for quick lookups and updates, given approximately fixed value size, are inefficient for modelling queues.
-
-#### Files
-
-The upside of files is that they are well suited for sequential delivery and don't result in the same churn, with careful design, as trees do.
-
-The downside of filesystem is that it does not scale well with the large number of files in a folder, so queues will have to be spread across multiple folders, following tree-like structure.
-
-I could not find an available library that efficiently models sequential delivery in highly concurrent environment.
-
-A possible design could be the following.
-
-##### Queue folder and files
-
-Each message queue is stored in its own folder (see below on folder locations). Folder would contain these files:
-
- `messages.abcd.log` - the file that is used to read messages from, sequentially
- `messages.efgh.log` - the optional file that is used to write messages, in case it is different from read file.
- `queue.log` - append-only file where the last line represents the current queue state
- `queue.timestamp.log` - previous states of queue.log file
-
-Each line in "queue.log" file has this syntax
-
-```abnf
-queueLogLine =
-    %s"read_file=" base64
-    %s"read_msg=" digits
-    %s"read_byte=" digits
-    %s"write_file=" base64
-    %s"write_msg=" digits
-```
-
-When queue is first requested by the server:
-
-```c
-if queue folder exists:
-    read queue state from last line of queue.log
-    if queue.log contained more than one line: // compaction
-        copy queue.log to queue.timestamp.log
-        write one line queue state to queue.log
-else:
-    create queue folder
-    create messages.abcd.log (abcd is some random string)
-    read_msg = 0
-    read_byte = 0
-    create queue.log with one line: "read_file=abcd read_msg=0 read_byte=0 write_files=abcd write_msg=0"
-open read_file in ReadMode and seek to read_byte position
-nextReadByte = read_byte
-nextReadMsg = read_msg
-open write_file in AppendMode
-```
-
-When message is added to the queue (assumes that queue state is loaded to server memory, if not the previous section will be done first):
-
-```c
-if write_msg > max_queue_messages:
-    return quota error
-else if write_msg = max_queue_messages:
-    add quota_exceeded message to write_file
-    update queue state: write_msg += 1
-    append updated queue state to queue.log
-else
-    // It is required that `max_queue_messages < max_file_messages`,
-    // so that we never need more than one additional write file.
-    if write_msg >= max_file_messages: // queue file rotation
-        create messages.efgh.log // efgh is some random string
-        update queue state: write_file=efgh write_msg=0 // read file remains the same as it was
-        append updated queue state to queue.log
-        copy queue.log to queue.timestamp.log
-        // `old` needs to be defined to limit the number and storage duration,
-        // preserving not more than N files, and not more than M days files, "and then some"
-        // (that is if the queue has high churn, we have file from M days before in any case, for any debugging).
-        delete `old` `queue.timestamp.log` files
-        write one line queue state to queue.log // compaction
-
-    add message to write_file
-    update queue state: write_msg += 1
-    append updated queue state to queue.log
-```
-
-The above algorithm assumes `max_queue_messages < than max_file_messages`, so that we never need more than one write file.
-
-When message is delivered, it is simply read from the read queue, queue state does not change yet:
-
-```c
-if nextReadMsg > read_msg:
-    deliver cached message, no need to read it again
-else
-    read message from read_file handle
-    nextReadMsg = read_msg + 1
-    nextReadByte = current position in file
-```
-
-When message delivery is acknowledged, the read queue needs to be advanced, and possibly switched to read from the current write_queue:
-
-```c
-if nextReadByte == read_byte:
-    return error // nothing was delivered
-else if nextReadByte = EOF:
-    // end of file is reached, possibly some other condition,
-    // but it should allow changing max_file_messages on server restart
-    currReadFile = read_file
-    read_file = write_file
-    read_msg = 0
-    read_byte = 0
-    append updated queue state to queue.log
-    delete currReadFile
-else
-    read_msg += 1
-    read_byte = nextReadByte
-    // `seek` should not be necessary, as the handle is already at nextReadByte position here
-    // seek to read_byte
-    append updated queue state to queue.log
-```
-
-The above algorithm delegates the problem of compaction and fragmentation management to file system, that is very optimized for such scenarios.
-
-Also, read and write files will grow to almost a constant size, so the space they used may be re-used.
-
-An important consideration is that writes to queue.log and message.log files and queue state modifications have to be sequential, without concurrency - it can be managed with the usual locks.
-
-##### Queue folders structure
-
-Most Linux systems use EXT4 filesystem where the file lookup time scales linearly to the number of files. While alternatives with logarithmic lookup time exist (XFS), they may be very complex to configure on the existing systems.
-
-So storing all queue folders in one folder won't scale.
-
-To solve this problem we could use recipient queue ID in base64url format not as a folder name, but as a folder path, splitting it to path fragments of some length. The number of fragments can be configurable and migration to a different fragment size can be supported as the number of queues on a given server grows.
-
-Currently, queue ID is 24 bytes random number, thus allowing 2^192 possible queue IDs. If we assume that a server must hold 1b queues, it means that we have ~2^162 possible addresses for each existing queue. 24 bytes in base64 is 32 characters that can be split into say 8 fragments with 4 characters each, so that queue folder path for queue with ID `abcdefghijklmnopqrstuvwxyz012345` would be:
-
-`/var/opt/simplex/messages/abcd/efgh/ijkl/mnop/qrst/uvwx/yz01/2345`
-
-The maximum theoretic number of the folders on the 1st level is 64^4, or 2^24 ~ 16m - this is probably still a large number of subfolders for EXT4. Given that addresses are random, all the possible combinations in the first folder can be used with a large number of queues.
-
-So we could use an unequal split of path, two letters each and the last being long:
-
-`/var/opt/simplex/messages/ab/cd/ef/ghijklmnopqrstuvwxyz012345`
-
-The first three levels in this case can have 4096 subfolders each, and it gives 68b possible subfolders (64^2^3), so the last level will be sparse in case of 1b queues on the server. So we could make it 4 levels with 2 letters to never think about it, accounting for a large variance of the random numbers distribution:
-
-`/var/opt/simplex/messages/ab/cd/ef/gh/ijklmnopqrstuvwxyz012345`
@@ -1,81 +0,0 @@
-# Storage considerations for SMP queues
-
-See [Short invitation links](./2024-06-21-short-links.md).
-
-## Problem
-
-1) queue records are created permanently, until the clients delete them.
-
-2) clients only delete queue records based on some user action, pending connections do not expire.
-
-While part 2 should be improved in the client, indefinite storage of queue records becomes a much bigger issue if each of them would result in a permanent storage of 4-16kb blob in server memory, without server-side expiration for short invitation links.
-
-## Possible solutions
-
-1) Add some queue timestamp, e.g. queue creation date, to expire unsecured queues after say 3 weeks.
-
-The problem with this approach is that contact addresses are also unsecured queues, and they should not be expired.
-
-We could set really large expiration time, and require that clients "update" the unsecured queues they need at least every 1-2 years, but it would not solve the problem of storing a large number of blobs in the server memory for unused/abandoned 1-time invitations.
-
-2) Do not store blobs in memory / append-only log, and instead use something like RocksDB. While it may be a correct long term solution, it may be not expedient enough at the current POC stage for this feature. Also, the lack of expiration is wrong in any case and would indefinitely grow server storage.
-
-3) Add flag allowing the server to differentiate permanent queues used as contact addresses, also using different blob sizes for them. In this case, messaging queues will be expired if not secured after 3 weeks, and contact address queues would be expired if not "updated" by the owner within 2 years.
-
-Probably all three solutions need to be used, to avoid creating a non-expiring blob storage in memory, as in case too many of such blobs are created it would not be possible to differentiate between real users and resource exhaustion attacks, and unlike with messages, they won't be expiring too.
-
-Servers already can differentiate messaging queues and contact address queues, if they want to:
- with the old 4-message handshake, the confirmation message on a normal queue was different, and also KEY command was eventually used.
- with the fast 2-message handshake, while the confirmation message has the same syntax, and the differences are inside encrypted envelope, the client still uses SKEY command.
- in both cases, the usual messaging queues are secured, and contact addresses are not, so this difference is visible in the storage as well (although it is not easy to differentiate between abandoned 1-time invitations and contact addresses).
-
-Differentiating these queues can also allow different message retention times - e.g., the queues for contact addresses could have bigger size, but have lower message retention time.
-
-## Proposed solution
-
-1. Add queue updated_at date into queue records. While it adds some metadata, it seems necessary to manage retention and quality of service. It will not include exact time, only date, and the time of creation will be replaced by the time of any update - queue secured, a message is sent, or queue owner subscribes to the queue. To avoid the need to update store log on every message this information can be appended to store log on server termination. Or given that only one update per day is needed it may be ok to make these updates as they happen (temporarily making the sequence and time of these events available in storage).
-
-2. Add flag to indicate the queue usage - messaging queue or queue for contact address connection requests. This would result in different queue size and different retention policy for queue and its messages. We already have "sender can secure flag" which is, effectively, this flag - contact address queues are never secured. So this does not increase stored metadata in any way.
-
-## Possible changes to short links
-
-This is a design considerations and a concept, not a design yet.
-
-Instead of implementing a generic blob storage that can be used as an attack vector, and adds additional failure point (another server storing blob that is necessary to connect to the queue on the current server), but instead adds an extended queue information blobs, most of which could be dropped without the loss of connectivity, so that the attack can be mitigated by deleting these blobs without users losing the ability to connect, as long as the queue and minimal extended information is retained.
-
-So, to make the connection there need to be these elements:
-
- queue server and queue ID - mandatory part, that can be included in short link
- SMP key - mandatory part for all queues. We are considering initializing ratchets earlier for contact addresses, and include ratchet keys and pre-keys into queue data as well, but it is out of scope here.
- Ratchet keys - mandatory part for 1-time invitation that won't fit in short link.
- PQ key - optional part that can be stored with addresses if ratchet keys are added and with 1-time invitations.
- App blobs - chat preferences for 1-time invitation links and profile information for contact addresses.
-
-So rather that storing one blob with a large address inside it, not associated with the queue, increasing probability of failure and reducing our ability to mitigate resource exhaustion, we could store extended blobs associated with the queues.
-
-Also, we need the address shared with the sender (party accepting the connection) to be short. We could use a similar approach that was proposed for data blobs, using a single random seed per queues to derive multiple keys and IDs from it. For example:
-
-1. The queue owner:
-  - generates Ed25529 key pair `(sk, spk)` and X25519 key pair `(dhk, dhpk)` to use with the server, same as now sent in NEW command.
-  - generates queue recipient ID (this ID can still be server-generated).
-  - generates X25519 key pair `(k, pk)` to use with the accepting party.
-  - derives from `k`:
-    - sender ID.
-    - symmetric key for authenticated encryption of blobs.
-  - `k` will be used as short link.
-2. All other data from the invitation can be included in queue creation request and be associated with the queue as 1-3 blobs with different priority:
-  - ratchet keys - it will have a small size, so only this blob cannot be removed, while other blobs can be removed in case of resource exhaustion.
-  - PQ keys - optional blob.
-  - conversation preferences and profile - can be removed depending on creation time, e.g. all new blobs can be removed.
-
-The algorithm used to derive key and ID from `k` needs to be cryptographically secure, e.g. it could be some KDF or ChaCha DRG initialized with `k` as seed, TBC.
-
-So, coupling blob storage with messaging queues has these pros/cons:
-
-Cons:
- no additional layer of privacy - the server used for connection is visible in the link, even after the blobs are removed from the server.
-
-Pros:
- no additional point of failure in the connection process - the same server will be used to retrieve necessary blobs as for connection.
- queue blobs of messaging blobs will be automatically removed once the queue is secured or expired, without additional request from the recipient - reducing the storage and the time these blobs are available.
- queue blobs for contact addresses will be structured and some of the large blobs can be removed in case of resource exhaustion attack (and recreated by the client if needed), with the only downside that PQ handshake will be postponed (which is the case now) and profile will not be available at a point of connection.
@@ -1,80 +0,0 @@
-# Blob extensions for SMP queues
-
-Evolution of the design for short links, see [here](./2024-06-21-short-links.md) and [here](./2024-09-05-queue-storage.md).
-
-## Problems
-
-Allow storing extended information with SMP queues to improve UX and security of making connections:
- short invitation links and contact addresses.
- PQ encryption from the first message.
- present user profile with chat preferences and welcome message when the public address link is scanned.
-
-## Design
-
-1. Queue creation/update date is already added to server persistence, allowing to expire queues and blobs, depending on their usage.
-2. Add "queue type" metadata to NEW command to indicate whether messaging queue is used as public address or as messaging queue (see previous docs on why it doesn't change threat model). While at the moment it would match sndSecure flag there may be future scenarios when they diverge. Initially only "invitation" and "contact" types will be supported.
-3. Prohibit sndSecure flag for "contact" queues, prohibit securing contact queues.
-4. Add "queue blobs" to NEW command:
-  - blob0: ratchetKeys up to N0 bytes - priority 0, can't be removed by the server, only in "invitation"
-  - blob1: PQ key up to N1 bytes - priority 1, can be removed by the server, only used in "invitation"
-  - blob2: Application data up to N2 bytes - priority 2, can be removed by the server.
-5. Add linkId to NEW command
-6. linkId and blobs will be removed when queue is secured.
-7. Add recipient command to remove/upsert blob2 for contact queues.
-8. Add sender command to retrieve blobs.
-
-## Protocol
-
-### Creating a queue:
-
-The queue owner:
- generates Ed25529 key pair `(sk, spk)` and X25519 key pair `(dhk, dhpk)` to use with the server, same as now. `sk` and `dhk` will be sent in NEW command.
- generates X25519 key pair `(k, pk)` to use with the accepting party to encrypt queue messages.
- derives from `k` using HKDF:
- symmetric key `bk` for authenticated encryption of blobs.
- `linkId`, will be sent in NEW command.
- `k` will be used as short link.
- sends NEW command.
-
-NEW command syntax:
-
-```abnf
-create = %s"NEW " linkId queueType recipientAuthPublicKey recipientDhPublicKey
-                  basicAuth subscribe sndSecure [ "0" blob0 ] [ "1" blob1 ] [ "2" blob2 ] 
-queueType = %s"I" / %s "C" ; new parameter
-linkId = length *OCTET ; new parameter,
-                        ; can be empty in which case blobs won't be allowed
-blob0 = word16 *OCTET ; new parameter, encrypted ratchet keys,
-                      ; including nonce and auth tag
-blob1 = word16 *OCTET ; new parameter, encrypted PQ key
-blob2 = word16 *OCTET ; new parameter, encrypted application data
-```
-
-SET - command to update queue blobs (recipientId is used as entity ID):
-
-```abnf
-set = %s"SET " linkId [ "2" blob2 ] ; passing empty blob removes it
-linkId ; updated (or the same) linkId, can be empty to remove blobs
-        ; allows to change the address without removing the queue / changing blobs
-        ; (e.g., to avoid losing the messages).
-```
-
-### Sending messages to the queue
-
-GET - command to get queue blobs (linkId is used as entity ID):
-
-```abnf
-get = %s"GET"
-```
-
-Response to GET:
-
-```abnf
-blobs = %s"BLOB" senderId [ "0" blob0 ] [ "1" blob1 ] [ "2" blob2 ]
-```
-
-As blobs are retrieved using a separate linkId, once blobs are removed it will be impossible to find senderId from short link - it is a threat model improvement. Once server storage is compacted, it will be impossible to find queue related to the link even with the access to server data (unless server preserves the data).
-
-### Possible privacy improvement
-
-We could only allow unauthorized GET and authorized SET commands for long-term "contact" queues, and return BLOB in response to SKEY (or require that GET is authorized) - so that only the person who secures the queue will get access to data blobs. This way it ensures that the parties transmitting the invitation links cannot retrieve their content without the sender noticing it.
@@ -1,26 +0,0 @@
-# Private rendezvous protocol
-
-## Problem
-
-Our current handshake protocol is open to this attack: whoever observes the link exchange, knows on which server connection is being made, and if the traffic on this server is observed, then it can confirm communication between parties. Further, even with the [last proposal](./2024-09-09-smp-blobs.md#possible-privacy-improvement), having real-time access to the server data allows to establish the exact messaging queue that is used to send messages.
-
-## Solution
-
-We could make the initial link exchange more private by making it harder for any observer to discover which server will be used for messaging by hiding this information from the server that hosts the initial link.
-
-Preliminary, the protocol could be the following:
-
-1. Connection initiator stores 224-256 bytes of encrypted connection link on a rendezvous server (link contains server host and linkId on another messaging server, not a rendezvous one).
-
-2. Rendezvous server adds these links to buckets, up to 64 links per bucket. Bucket ID is the timestamp when the bucket was created + a sequential bucket number, in case more than one bucket is created per second.
-
-3. The server responds to the link creator with a bucket ID where this link was added. That bucket ID is its timestamp + a number prevents server "fingerprinting" clients and using say one bucket for each client. If timestamp is different or a bucket number within this timestamp is too large, the client can refuse to use it, depending on the client settings.
-
-4. The initiating party will pass to the accepting party the rendezvous server host, the hash of this bucket ID (bucket link) and the passphrase to derive the key from. The initiating party has an option to pass a link and passphrase via two channels - in which case the link will only contain the bucket ID.
-
-5. The accepting party would then request the bucket via its ID hash (the server would store hashes to be able to look up - hash is used to prevent showing time in the link) and attempt to decrypt all contained links using the provided key.
-The accepting party then will continue the connection via the decrypted link.
-
-This obviously does not protect accepting party from the initiating party, if it can choose rendezvous server it controls. It also does not protect from the malicious rendezvous server that would collaborate with link observers. I think reunion doesn’t protect from it too.
-
-But it does protect connection from whoever observes the link, particularly if this link only contains the bucket and the key is passed separately, via some other channel.
@@ -1,163 +0,0 @@
-# Sharing protocol ports with HTTPS
-
-Some networks block all ports other than web ports, including port 5223 used for SMP protocol by default. Running SMP servers on a common web port 443 would allow them to work on more networks. The servers would need to provide an HTTPS page for browsers (and probes).
-
-## Problem
-
-Browsers and tools rely on system CA bundles instead of certificate pinning.
-The crypto parameters used by HTTPS are different from what the protocols use.
-Public certificate providers like LetsEncrypt can only sign specific types of keys and Ed25519 isn't one of them.
-
-This means a server should distinguish browser and protocol clients and adjust its behavior to match.
-
-## Solution
-
-`tls` package has a server hook that allows producing a different set of `TLS.Credentials` according to a client-provided "Server Name Indication" extension.
-
-Since LE certificates are only handed out to domain names, TLS client will be sending the SNI.
-However client transports are constructed over connected sockets and the SNI wouldn't be present unless explicitly requested.
-When a client sends SNI, then it's a browser and a web credentials should be used.
-Otherwise it's a protocol client to be offered the self-signed ca, cert and key.
-
-When a transport colocated with a HTTPS, its ALPN list should be extended with `h2 http/1.1`.
-The browsers will send it, and it should be checked before running transport client.
-If HTTP ALPN is detected, then the client connection is served with HTTP `Application` instead (the same "server information" page).
-
-If some client connects to server IP, doesn't send SNI and doesn't send ALPN, it will look like a pre-handshake client.
-In that case a server will send its handshake first.
-This can be mitigated by delaying its handshake and letting the probe to issue its HTTP request.
-
-## Implementation plan
-
-An unmodified client should be able to use protocols on port 443 right away.
-
-The switchover happens inside `runTransportServerState` before `runClient`:
-
-```haskell
-runServer (tcpPort, ATransport t) = do
-  -- ...
-  runTransportServerState_ ss started tcpPort serverParams tCfg $ \socket h -> do -- expose raw socket for warp-tls internals to attach
-    negotiated <- getSessionALPN
-    if allowHTTP t && isHTTP negotiated -- only attempt the switch for the TLS transport
-      then runHTTP socket (tlsContext h)-- ... collect data and produce values needed to run WAI Application
-      else runClient serverSignKey t h `runReaderT` env -- performs serverHandshake etc as usual
-```
-
-The web app and server live outside, so `runHttp` has to be provided by the `runSMPServer` caller.
-Additonally, Warp is using its `InternalInfo` object that's scoped to `withII` bracket.
-
-```haskell
-  runServer ini = do
-    -- ...
-
-    runWebServer ini ServerInformation {config, information} $ if sharedHttps then Nothing else webHttpsParams -- suppress serving https
-    if sharedHttps
-      then withRunHTTP staticFilesPath \attachStatic -> runSMPServer cfg (Just attachStatic) -- provide wrapped application runner
-      else runSMPServer cfg Nothing
-```
-
-### Upstream
-
-The implementation relies on a few modification to upstream code:
- `warp-tls`: The library provides `httpOverTls`, but it wants to do handshake itself.
-  Since we have to do the handshake to switch on ALPN, the setup function has to be split.
-  This is a resonable change that may be upstreamed and nothing blocks us from using the recent version.
- `warp`: Only the re-export of `serveConnection` is needed.
-  Unfortunately the most recent `warp` version can't be used right away due to dependency cascade around `http-5` and `auto-update-2`.
-  So a fork containing the backported re-export has to be used until the dependencies are refreshed.
-
-
-### TLS.ServerParams
-
-When a server has port sharing enabled, a new set of TLS params is loaded and combined with transport params:
-
-```haskell
-newEnv config = do
-  -- ...
-  tlsServerParams <- loadTLSServerParams caCertificateFile certificateFile privateKeyFile (alpn transportConfig)
-  sharedServerParams <- forM ((,) <$> sharedHttpsCredentials config <*> alpn transportConfig) $ \((chain, key), alpn) ->
-    let ca = Nothing -- It is possible to provide CA certificate, but it is typical for web server to use combined certificate chains
-    loadHTTPSServerParams tlsServerParams ca chain key alpn
-```
-
-`loadHTTPSServerParams` extends params with:
-1. `onALPNClientSuggest` hook gets `["h2", "http/1.1"]` added to the ALPN list which is now required.
-2. `onServerNameIndication` hook added, which upon detecting client SNI prepends the web credentials.
-3. `sharedCredentials = T.Credentials []` should be done to prevent transport credentials confusing browsers.
-    But that aborts key exchange somewhere in tls internals, so disabled for now.
-    As a workaround, another set of dummy credentials can be provided in the hope that any sane browser would reject them.
-    Like, RC4 ciphers, "impossible" digest combination, etc.
-
-### supportedParameters
-
-TLS certificate chains provided by LetsEncrypt use ECDSA/P256 and that requires extending `supportedParameters` with things disabled in transports:
-
-```haskell
-    browserCiphers =
-      [ TE.cipher_TLS13_AES128CCM8_SHA256
-      , TE.cipher_ECDHE_ECDSA_AES128CCM8_SHA256
-      , TE.cipher_ECDHE_ECDSA_AES256CCM8_SHA256
-      ]
-    browserGroups =
-      [ T.P256
-      ]
-    browserSigs =
-      [ (T.HashSHA256, T.SignatureECDSA),
-        (T.HashSHA384, T.SignatureECDSA)
-      ]
-```
-
-This may not be enough for other certificate providers.
-
-## Configuration
-
-> XXX: This is for the current implementation and should be updated.
-
-Web certificate chain is picked up from the WEB section:
-
-```ini
-[TRANSPORT]
-port: 443
-
-[WEB]
-https: 443
-cert: /etc/opt/simplex/web.cert
-key: /etc/opt/simplex/web.key
-
-# Alternatively, with a proper access configuration, the paths can point to the LE creds directly:
-# cert: /etc/letsencrypt/live/smp.hostname.tld/fullchain.pem
-# key: /etc/letsencrypt/live/smp.hostname.tld/privkey.pem
-```
-
-When `TRANSPORT.port` matches `WEB.https` the transport server becomes shared.
-
-Perhaps a more desirable option would be explicit configuration resulting in additional transported to run:
-
-```ini
-[TRANSPORT]
-port: 5223 ; pure protocol transport
-# control_port: 5224
-shared_port: 443 ; variant 1: register in TRANSPORT
-
-[WEB]
-https: 443
-cert: /etc/opt/simplex/web.cert
-key: /etc/opt/simplex/web.key
-# transport: on ; variant 2:
-```
-
-## Caveats
-
-Serving static files and the protocols togother may pose a problem for those who currently use dedicated web servers as they should switch to embedded http handlers.
-
-As before, using embedded HTTP server is increasing attack surface.
-
-Users who want to run everything on a single host will have to add and extra IP address and bind servers to specific IPs instead of 0.0.0.0.
-An amalgamated server binary can be provided that would contain both SMP and XFTP servers, where transport will dispatch connections by handshake ALPN.
-
-## Alternative: Use transports routable with reverse-proxies
-
-An "industrial" reverse proxy may do the ALPN routing, serving HTTP by itself and delegating `smp` and `xftp` to protocol servers.
-Same with the `websockets`.
-
-Since this in effect does TLS termination, the protocol servers will have to rely on credentials from protocol handshakes.
@@ -1,49 +0,0 @@
-# iOS notifications delivery
-
-## Problem
-
-For iOS notifications to be delivered the client has to create credentials for notification subscription on SMP server using NKEY command and after that create a subscription on notification server using SNEW command. These two commands are sent in sequence, after the connections are created, and for it to happen the client needs to be online and in foreground.
-
-iOS users tend to close the app when it is not used, and iOS has very limited permissions for background activities, so these notification subscriptions are created with a substantial delay, and notifications do not work.
-
-This problem is distinct from and probably more common than other problems affecting notifications delivery described [here](./2024-07-06-ios-notifications.md).
-
-## Solution
-
-1. When the new connection is created, the client already knows if it needs to create notification subscription or not, based on the conversation setting (e.g., if the group is muted, the client will not create notification subscription as well.). We should extend NEW command to avoid the need to send additional NKEY command with an option to create notification subscription at the point where connection is created. NDEL would still be used to disable this notification, and NKEY will be used to re-enable it.
-
-2. In the same way we stopped using SDEL command (NDEL sends notification DELD to subscribed notification server) to delete notificaiton subscriptions from notification server, we should delegate creating notification subscription on notification server to SMP servers. Clients could use keys agreed with ntf server for e2e encryption and for command authorization to encrypt and sign instruction to create notification subscription that will be forwarded to notification server using protocol similar to SMP proxies. This will avoid the need for clients to separately contact notification servers that won't happen until they are online.
-
-3. Instead of making Ntf server trust DELD notifications, we could send deletion instructions signed by the client, which will only fail to send in case notification server is down (and they won't be sent later after server restart).
-
-Cons:
- If SMP servers were to retain in the storage the information about which notification server is used for which queue, it would reduce metadata privacy. While currently it is not an issue, as all notification servers are known and operated by us, once there are other client apps, this can be used for app users fingerprinting, which would act as a deterrence from using new apps – but only if app users use servers of operators who are different from the app provider. To mitigate it, we could only store it in server memory and include notification instruction in subscription commands (SUB) and include notification subscription status in SUB responses. We don't need to mitigate the problem of server being able to store this information, as messaging servers can observe which notification servers connect to them anyway.
- If SMP server is restarted before the subscription request is forwared to the notification server, then it will have to be forwarded again, once the client subscribes. The problem here is that if the client is offline, it will neither subscribe to the queue to send notification subscription request, nor receive notifications from this queue. Storing notification server and subscription request would mitigate that, as in this case we could send all pending requests on server start, without depending on client subscriptions.
- "Small" agent will need to support connections to ntf servers and manage workers that retry sending pending subscription requests.
- Until the client learns the public keys of notification server, it will not be able to decrypt notifications. It potentially can be mitigated by using the public key of the server returned when token is created, in this way different client keys (per-queue) will be combined with the same ntf server key (per-token).
-
-## Implementation details
-
-1. NEW and NKEY commands will need to be extended to include notification subscription request. As the notifier ID needs to be sent to notification server, this notifier ID will have to be client-generated and supplied as part of NEW command.
-
-now:
-
-```haskell
-NEW :: RcvPublicAuthKey -> RcvPublicDhKey -> Maybe BasicAuth -> SubscriptionMode -> SenderCanSecure -> Command Recipient
-NKEY :: NtfPublicAuthKey -> RcvNtfPublicDhKey -> Command Recipient
-```
-
-extended:
-
-```haskell
-NEW :: RcvPublicAuthKey -> RcvPublicDhKey -> Maybe BasicAuth -> SubscriptionMode -> SenderCanSecure -> Maybe NtfRequest -> Command Recipient
-
-data NtfRequest = NtfRequest NotifierId NtfPublicAuthKey RcvNtfPublicDhKey NtfServerRequest
-
-data NtfServerRequest = NtfServerRequest NtfServer EncSingedNtfCmd
-
-NKEY :: NtfPublicAuthKey -> RcvNtfPublicDhKey -> Maybe NtfServerRequest -> Command Recipient
-- NotifierID is passed in entity ID field of the transmission
-```
-
-2. Notification server will need to support an additional command to receive "proxied" subscription commands, `SFWD`, that would include `NtfServerRequest`. This command can include both `SNEW` and `SDEL` commands.
@@ -1,15 +0,0 @@
-# Expiring messages in journal storage
-
-## Problem
-
-The journal storage servers recently migrated to do not delete delivered or expired messages, they only update pointers to journal file lines. The messages are actually deleted when the whole journal file is deleted (when fully deleted or fully expired).
-
-The problem is that in case the queue stops receiving the new messages then writing of messages won't switch to the new journal file, and the current journal file containing delivered or expired messages would never be deleted.
-
-## Solution
-
-Remove current journal file and update queue_state.log during message expiration of "idle" queue (that is, without any new messages received or delivered within 3 hours) in case when:
- the queue is "empty" after the expiration
- the queue contains only quota marker(s), in which case move them to a new journal file and update the queue_state accordingly. Quota markers can be kept indefinitely to prevent writing the new messages to the dormant queues that reached capacity, so it's important to handle this case.
-
-Also remove current journal file when the queue is opened in case it is empty (as it would not be ever expired in case it remains empty), and also update queue_state.log
@@ -1,58 +0,0 @@
-# Blob extensions for SMP queues 2 and queue storage
-
-This document evolves the design proposed [here](./2024-09-09-smp-blobs.md).
-
-## Problems
-
-In addition to problems in the first doc, we have these issues with in-memory queue record storage:
- many queues are idle or rarely used, but they are loaded to memory, and currently just loading all queues uses 20gb RAM on each server, and takes 10 min to process, increasing downtimes during restarts.
- adding blobs to memory would make this problem much worse.
-
-## Proposed solution
-
-Move queues to the same journalling approach as [used for messages](./2024-09-01-smp-message-storage.md) now, with independent file names in the same folders.
-
-Each queue change would be logged to its own file, and every time the queue is opened the whole file will be read and compacted to a single line - replacing one store log for all queues, with individual log files for each queue.
-
-Queue deletion would not be making a record in the file, instead it would be deleting the entire folder - it would reduce retention period for any metadata of deleted queues.
-
-We could additionally record deletions to the central log, for debugging, and reset it on every start. But in this case we should not remove folders at the point of deletion, but rather mark them as deleted and delete on restart. TBC
-
-It would also allow simplifying blob storage by having only one blob per queue - for example, limied to 16kb (a bit smaller to fit in block) for contact address queues and 4-8kb for invitations (to fit PQ keys and conversation preferences).
-
-We would also need to be able to lookup recipient ID via sender/notifier/link IDs.
-
-One possible solution is to use and load to memory a central index file. But it is likely to also consume a lot of memory and result in slow starts.
-
-Another solution that is probably better is to use the same folder structure and put notifier/sender/link files with the ID of the recipient queue inside the files. So to locate recipient queue the sender would have to locate folder containing the reference file pointing to the recipient queue and then to locate the actual queue data.
-
-## Implementation details
-
-Each queue folder would these files:
-
- queue_state.log (and timestamped backups) - to store pointers to message journals (already implemented)
- messages.randomBase64.log - message journals (already implemented)
- queue_rec.log (and timestamped backups) - to log complete queue record every time it is changed (so only the last line needs to be read following the same logic as with queue_state.log, to prevent file corruption).
- blob.data, blob.data.bak, blob.timestamp.data - files for data blobs (to make sure some copy of this file is readable/correct in case of write corruption) - the same two step overwrite process will be used as currently with store log compacting:
-  - on write: 1. if file exists, move it to .bak, 2. store new blob to .data, 3. move .bak to .timestamp.data
-  - on read: 1. if .bak exists, move it to .data 2. use .data
-
-Additional suggestion to reduce probability of queue_state.log and queue_rec.log file corruption is to do one of the following:
- log end of lines in the beginning of the output, not in the end, to prevent the last line from being corrupted in case the previous line was not fully stored. The downside is that the file will not be EOL terminated, and there will be no confirmation that the output was fully made.
- log EOL both in the beginning and at the end of output, and ignore empty lines in between - this would both confirm that the last line is fully logged and prevent corruption of the next line in case it was not.
- check the last byte of the file and log EOL if it is not EOL. Probably cleanest approach, but with a small performance cost.
-
-If queue folder is a reference to the queue, it may have one of these files:
- notifier.id
- sender.id
- link.id
-
-These files would contain a one line with the recipient ID of the queue. These files would never change, they can only be deleted when queue is deleted or when notifier/link is deleted.
-
-There is logic in code preventing using the same ID in different contexts, and the ID size is large enough to make any collisions unlikely (192 bits), so with correctly working code the queue folder would either have one of reference files, and nothing else, or the queue and message files from the beginning of this section. But even if the same ID is re-used in different context, it should not cause any problems as file names don't overlap.
-
-While we could store different types of references in different types of folders, it would have additional costs of maintaining 4 folder hierarchies. Instead we could use the fact that it is one hierarchy to prevent using the same ID in different contexts.
-
-## Protocol
-
-The only change in protocol is that there will be only one blob per queue, without markers (see the previous doc). Otherwise the protocol and proposed privacy improvement seem reasonable.
@@ -1,290 +0,0 @@
-# Protocol changes for creating and connecting to SMP queues
-
-## Problems
-
-This change is related to these problems:
- differentiating queue retention time,
- supporting MITM-resistant short connection links,
-
-This RFC is based on the previous discussions about short links, blob storage and notifications ([1](./2024-06-21-short-links.md), [2](./2024-09-09-smp-blobs.md), [3](./2024-11-25-queue-blobs-2.md), [4](./2024-09-25-ios-notifications-2.md)).
-
-SMP protocol supports two types of queues - queues to send messages (messaging queues) and queues to send invitations to connect (contact queues). While SMP protocol was originally "unaware" of these queue types, it could differentiate it by message flow, and with the recent addition of SKEY command to allow securing the queue by the sender this difference became persistent.
-
-Simply designating queue types would allow to use this information to decide for how long to retain queues, and potentially extending it:
- unsecured 1-time invitation queues with sndSecure (support of securing by sender) - e.g., 3 months.
- contact address queues without sndSecure - e.g., 3 years without activity.
- Possibly, "queues" that prohibit messages and used only as blob storage - they would be used to store group profiles and super-peer addresses for the group.
-
-## Design objectives
-
-We want to achieve these objectives for short links and associated queue data:
-1. no possibility to provide incorrect SenderId inside link data (e.g. from another queue).
-2. link data cannot be accessed by the server unless it has the link.
-3. prevent MITM attack by the server, including the server that obtained the link.
-4. prevent changing of connection request by the user (to prevent MITM via break-in attack in the originating client).
-5. for one-time links, prevent accessing link data by link observers who did not compromise the server.
-6. allow changing the user-defined part of link data.
-7. avoid changing the link when user-defined part of link data changes, while preventing MITM attack by the server on user-defined part, even if it has the link.
-8. retain the quality that it is impossible to check the existence of secured queue from having any of its temporary visible IDs (sender ID and link ID in 1-time invitations) - it requires that these IDs remain server-generated (contrary to the previous RFCs).
-
-To achieve these objectives the queue data will include fixed (immutable) and user-defined (mutable) parts.
-
-Fixed part would include:
- full connection request (the current long link with all keys, including PQ keys). This includes SenderId that must match server response.
- public signature key to verify mutable part of link data.
-
-Signed mutable part would include:
- any links to chat relays that should be contacted instead of this queue (not in this RFC), to allow delegating group connections and contact request connections to prevent spam, hiding online presence, etc.
- and user-defined data - user profile or group profile, chat preferences, welcome message, etc.
-
-The link itself should include both the key and auth tag from the encryption of immutable part. Accessing one-time link data should require providing sender key and signing the command (`LKEY`).
-
-## Solution
-
-Current NEW and NKEY commands:
-
-```haskell
-NEW :: RcvPublicAuthKey -> RcvPublicDhKey -> Maybe BasicAuth -> SubscriptionMode -> SenderCanSecure -> Command Recipient
-
-- | Queue IDs and keys, returned in IDS response
-data QueueIdsKeys = QIK
-  { rcvId :: RecipientId,
-    sndId :: SenderId,
-    rcvPublicDhKey :: RcvPublicDhKey,
-    sndSecure :: SenderCanSecure
-  }
-```
-
-Proposed NEW command replaces SenderCanSecure with QueueMode, adds link data, and combines NKEY command:
-
-```haskell
-NEW :: NewQueueRequest -> Command Recipient
-
-data NewQueueReq = NewQueueReq
-  { rcvAuthKey :: RcvPublicAuthKey,
-    rcvDhKey :: RcvPublicDhKey,
-    auth_ :: Maybe BasicAuth,
-    subMode :: SubscriptionMode,
-    queueReqData :: Maybe QueueReqData,
-  }
-
-- QRMessaging implies that sender can secure the queue.
-- LinkId is not used with QRMessaging, to prevent the possibility of checking when connection is established by re-using the same link ID when creating another queue – the creating would have to fail if it is used.
-- LinkId is required with QRContact, to have shorter link - it will be derived from the link_uri. And in this case we do not need to prevent checks that this queue exists.
-data QueueReqData
-  = QRMessaging (Maybe (SenderId, QueueLinkData))
-  | QRContact (Maybe (LinkId, (SenderId, QueueLinkData)))
-
-- SenderId should be computed client-side as the first 24 bytes of sha3-384(correlation_id),
-- The server must verify it and reject if it is not.
-- It allows to include sender ID inside encrypted associated link data as part of full connection URI without requesting it from the server, but prevents checking if a given sender ID exists (queue creation would fail for a duplicate sender ID), as sha3-384 derivation is not reversible.
-type QueueLinkData = (EncFixedLinkData, EncUserDataBytes)
-
-type EncFixedLinkData = ByteString
-
-type EncUserDataBytes = ByteString
-
-- We need to use binary encoding for ConnectionRequestUri to reduce its size
-- The clients would reject changed immutable data and
-- ConnectionRequestUri where server or SenderId of the queue do not match.
-data FixedLinkData c = FixedLinkData
-  { agentVRange :: VersionRangeSMPA,
-    rootKey :: C.PublicKeyEd25519,
-    connReq :: ConnectionRequestUri c
-  }
-
-data ConnLinkData c where
-  InvitationLinkData :: VersionRangeSMPA -> UserLinkData -> ConnLinkData 'CMInvitation
-  ContactLinkData ::
-    { agentVRange :: VersionRangeSMPA,
-      -- direct connection via connReq in fixed data is allowed.
-      direct :: Bool,
-      -- additional owner keys to sign changes of mutable data.
-      owners :: [OwnerAuth],
-      -- alternative addresses of chat relays that receive requests for this contact address.
-      relays :: [ConnShortLink 'CMContact],
-      userData :: UserLinkData
-    } -> ConnLinkData 'CMContact
-
-newtype UserLinkData = UserLinkData ByteString
-
-- | Updated queue IDs and keys, returned in IDS response
-data QueueIdsKeys = QIK
-  { rcvId :: RecipientId, -- server-generated
-    sndId :: SenderId, -- server-generated
-    rcvPublicDhKey :: RcvPublicDhKey,
-    sndSecure :: SenderCanSecure, -- possibly, can be removed? or implied?
-    linkId :: Maybe LinkId -- server-generated
-  }
-```
-
-In addition to that we add the command allowing to update and also to retrieve and secure the queue and get link data in one request, to have only one request:
-
-```haskell
-- This command allows to set all data or to update mutable part of contact address queue.
-- This command should fail on queues that support sndSecure and also on new queues created with QRMessaging.
-- This should fail if LinkId or immutable part of data is changed with the update, but will succeed if only mutable part is updated, so it can be retried.
-- Entity ID is RecipientId.
-- The response to this command is `OK`.
-LSET :: LinkId -> QueueLinkData -> Command Recipient
-
-- Delete should link and associated data
-- Entity ID is RecipientId
-LDEL :: Command Recipient
-
-- To be used with 1-time links.
-- Sender's key provided on the first request prevents observers from undetectably accessing 1-time link data.
-- If queue mode is QRContact (and queue does NOT allow sndSecure) the command will fail, same as SKEY.
-- Once queue is secured, the key must be the same in subsequent requests - to allow retries in case of network failures, and to prevent passive attacks.
-- The difference with securing queues is that queues allow sending unsecured messages to queues that allow sndSecure (for backwards compatibility), and 1-time links will NOT allow retrieving link data without securing the queue at the same time, preventing undetected access by observers.
-- Entity ID is LinkId
-LKEY :: SndPublicAuthKey -> Command Sender
-
-- If queue mode is QRMessaging the command will fail.
-- Entity ID is LinkId
-LGET :: Command Sender
-
-- Response to LGET and LSET
-- Entity ID is the same as in the command
-LNK :: SenderId -> QueueLinkData -> BrokerMsg
-```
-
-To both include sender_id into the full link before the server response, and to prevent "oracle attack" when a failure to create the queue with the supplied `sender_id` can be used as a proof of queue existence, it is proposed that `sender_id` is computed client-side as the first 24 bytes of 48 in `sha3-384(correlation_id)` and validated server-side, where `corelation_id` is the transmission correlation ID.
-
-To allow retries, every time the command is sent a new random `correlation_id` and new `sender_id` (and for contact queue, also `link_id`, which would be random as it is derived from hash of fixed link data that includes a random signature key) should be used on each attempt, because other IDs would be generated randomly on the server, and in case the previous command succeeded on the server but failed to be communicated to the client, the retry will fail if the same ID is used.
-
-Alternative solutions that would allow retries that were considered and rejected:
- additional request to save queue data, after `sender_id` is returned by the server. The scenarios that require short links are interactive - creating user addresses and 1-time invitations - so making two requests instead of one would make the UX worse.
- include empty sender_id in the immutable data and have it replaced by the accepting party with `sender_id` received in `LINK` response - both a weird design, and might create possibility for some attacks via server, especially for contact addresses.
- making NEW commands idempotent. Doing it would require generating all IDs client-side, not only `sender_id`. It increases complexity, and it is not really necessary as the only scenarios when retries are needed are async NEW commands, that do not require short links. For future short links of chat relays the retries are much less likely, as chat relays will have good network connections.
-
-## Algorithm to prepare and to interpret queue link data.
-
-For contact addresses this approach follows the design proposed in [Short links](./2024-06-21-short-links.md) RFC - when link id is derived from the same random binary as key. For 1-time invitations link ID is independent and server-generated, to prevent existence checks (oracle attack).
-
-This scheme results in 32 byte binary size for contact addresses and 56 bytes for 1-time invitation links.
-
-For fixed link data.
-
-1. Generate random `nonce` (also used as a correlation ID for server command) and signature key (public `rootKey` included in fixed data).
-2. Compute sender ID from `nonce` as the first 24 bytes of sha3-384 of `nonce`.
-3. Generate other keys for queue address, including queue e2e encryption keys and double ratchet connection e2e encryption keys.
-4. Construct the full connection address to be included in fixed data.
-5. `link_key = SHA3-256(fixed_data)` - used as part of the link, and to derive the key to encrypt content.
-6. HKDF:
-  1) contact address: `(link_id, key) = HKDF(link_key, 56 bytes)`.
-  2) 1-time invitation: `key = HKDF(link_key, 32 bytes)`, `link-id` - server-generated.
-7. Encrypt: `(ct1, tag1) = secret_box(fixed_data, key, nonce1)`, where `nonce1` is a random nonce
-5. Store: `(nonce1, ct1, tag1)` stored as fixed link data.
-
-For mutable user data:
-
-1. Random `nonce2` and the same key are used.
-2. Sign `user_data` with key included in `fixed_data`.
-3. Encrypt: `(ct2, tag2) = secret_box(signed_used_data, key, nonce2)`.
-4. Store: `(nonce2, ct2, tag2)`
-
-Link recipient:
-
-1. Receives `link_key` in the link, for 1-time invitations also `link_id`.
-2. HKDF:
-  1) contact address: `(link_id, key) = HKDF(link_key, 56 bytes)`.
-  2) 1-time invitation: `key = HKDF(link_key, 32 bytes)`.
-3. Retrieves via `link_id`: `(nonce1, ct1, tag1)` and `(nonce2, ct2, tag2)`:
-  1) contact address: `LGET` command, that allows retrieving link data multiple times.
-  2) 1-time invitation: `LKEY` command, that non-optionally secures the queue, and only allows repeated link data retrievals if the same sender's key is provided and signs the transmission. This prevents link data retrieval by link observers.
-4. Decrypt: `(signature1, fixed_data) = decrypt (nonce1, ct1, tag1)`.
-5. Verify: `SHA3-256(fixed_data) == link_key`, abort if not.
-6. Decrypt: `(signature2, used_data) = decrypt(nonce2, ct2, tag2)`.
-7. Verify signatures using key in the fixed data, abort if they don't match.
-
-While using content hash as encryption key is unconventional, it is not completely unusual - e.g., it is used in convergent encryption (although in our case using random nonce makes it not convergent, but other use cases suggest that this approach preserves encryption security). It is particularly acceptable for our use case, as `fixed_data` contains mostly random keys.
-
-## Threat model
-
-**Compromised SMP server**
-
-can:
- delete link data.
- hide link data selectively for some or for all requests.
-
-cannot:
- undetectably replace link data, even if it has the link (objective 3).
- access unencrypted link data, whether it was or was not accessed by the accepting party, provided it has no link (objective 2).
- observe IP addresses of the users accessing link data, if private routing is used.
-
-**Passive observer who observed short link**:
-
-can:
- access original unencrypted link data for contact address links.
-
-cannot:
- undetectably access observed 1-time link data, accessing the link would make the link inaccessible to the sender (objective 5).
- undetectably check the existence of messaging queue or 1-time link (objective 8).
- replace or delete the link data.
-
-**Queue owner who did not compromise the server**:
-
-cannot:
- redirect connecting user to another queue, on the same or on another server (objective 1).
- replace connection request in the link (objective 4).
-
-## Correlation of design objectives with design elements
-
-1. The presence of `SenderId` in `LNK` response from the server.
-2. Encryption of link data with crypto_box.
-3. Deriving encryption key from the hash of fixed data prevents it being modified by the server - any change would be detected and rejected by the client, as the hash of fixed data won't match the link. Signature verification with the key from fixed data, and signing of mutable data prevents server modification of mutable data.
-4. No server command to change fixed data once it's set. Also, changing fixed data would require changing the link.
-5. 1-time link data can only be accessed with `LKEY` command, that while allows retries to mitigate network failures, will require the same key for retries.
-6. `LSET` command.
-7. The link is derived from fixed data only, so it does not change when mutable link data changes. Mutable part is signed preventing server MITM attacks.
-8. SenderId is derived from request correlation ID, so it cannot be arbitrary defined to check existence of some known queue. LinkId for 1-time invitation is generated server-side, so it cannot be provided by the client when creating the queues to check if these IDs are used.
-
-## Syntax for short links
-
-The syntax:
-
-```abnf
-shortConnectionLink = uriAuthority "/" linkUri [ "?" param *( "&" param ) ]
-uriAuthority = %s"https://" smpServerHost / "simplex:" ; using simplex: scheme requires including host in the parameter hostParam
-smpServerHost = <hostname> ; RFC1123, RFC5891
-linkUri = %s"i#" oneTimeLink / contactType "#" contactLink
-contactType = %s"a" / %s"g" / %s"c" ; contact / group / channel address, respectively
-oneTimeLink = <base64url(linkId)> "/" <base64url(linkKey)> ; 56 bytes / 75 base64 encoded characters
-contactLink = <base64url(linkKey)> ; 32 bytes / 43 base64 encoded characters
-; linkId - 192 bits/24 bytes
-; linkKey - 256 bits/32 bytes
-
-param = hostsParam / portParam / certHashParam
-hostsParam = %s"h=" host *("," host) ; additional hostnames, e.g. onion
-portParam = %s"p=" 1*DIGIT ; server port
-certHashParam = %s"c=" <base64url(server offline certificate fingerprint)>
-```
-
-To have shorter links fingerprint and additional server hostnames do not need to be specified for pre-configured servers, even if they are disabled - they can be used from the client code. Any user defined servers will require including additional hosts and server fingerprint.
-
-Example one-time link for preset server (104 characters):
-
-```
-https://smp12.simplex.im/i#abcdefghij0123456789abcdefghij01/23456789abcdefghij0123456789abcdefghij01234
-```
-
-Example contact link for preset server (71 characters):
-
-```
-https://smp12.simplex.im/c#abcdefghij0123456789abcdefghij0123456789abc
-```
-
-Example contact link for user-defined server (with fingerprint, but without onion hostname - 117 characters):
-
-```
-https://smp1.example.com/c#abcdefghij0123456789abcdefghij0123456789abc?c=0YuTwO05YJWS8rkjn9eLJDjQhFKvIYd8d4xG8X1blIU
-```
-
-Example contact link for user-defined server (with fingerprint ant onion hostname - 182 characters):
-
-```
-https://smp1.example.com/c#abcdefghij0123456789abcdefghij0123456789abc?c=0YuTwO05YJWS8rkjn9eLJDjQhFKvIYd8d4xG8X1blIU&h=beccx4yfxxbvyhqypaavemqurytl6hozr47wfc7uuecacjqdvwpw2xid.onion
-```
-
-For the links to work in the browser the servers must provide server pages.
@@ -1,93 +0,0 @@
-# New notifications protocol
-
-## Problem
-
-iOS notifications have these problems:
- iOS notification service crashes exceeding memory limit. This is being addressed by changes in GHC RTS.
- there is a large number of connections, because each member in a group requires individual connection. This will improve with chat relays when each group would require 2-3 connections.
- some notification may be not shown if notification with reply/mention is skipped, and instead some other message is delivered, which may be muted. This would not improve without some changes, as notifications may be skipped anyway.
- client devices delay communication with ntf server because it is done in background, and by that time the app may be suspended.
- notification server represents a bottleneck, as it has to be owned by the app vendor, and the current design when ntf server subscribes to notifications scales very badly.
-
-This RFC is based on the previous [RFC related to notifications](./2024-09-25-ios-notifications-2.md).
-
-## Solution
-
-As notification server has to know client token and currently it associates subscriptions with this token anyway, we are not gaining any privacy and security by using per-subscription keys - both authorization and encryption keys of notification subscription can be dropped.
-
-We still need to store the list of queue IDs associated with the token on the notification server, but we do not need any per-queue keys on the notification server, and we don't need subscriptions - it's effectively a simple set of IDs, with no other information.
-
-In this case, when queue is created the client would supply notifier ID - it has to be derived from correlation ID, to prevent existense check (see previous RFC). As we also supply sender ID, instead of deriving it as sha3-192 of correlation ID, they both can be derived as sha3-384 and split to two IDs - 24 bytes each.
-
-The notification server will maintain a rotating list of server keys with the latest key communicated to the client every time the token is registered and checked. The keys would expire after, say, 1 week or 1 month, and removed from notification server on expiration.
-
-The packet containing association between notifier queue ID and token will be crypto_box encrypted using key agreement between identified notification server master key and an ephemeral per packet (effectively, per-queue) client-key.
-
-Deleting the queue may also include encrypted packet that would verify that the client deleted the queue.
-
-Instead of notification server subscribing to the notifications creating a lot of traffic for the queues without messages, the SMP server would push notifications via NTF server connection (whether via NTF or via SMP protocol). This could be used as a mechanism to migrate existing queues when with the next subscription the notification server would communicate it's address to SMP server and this association would be stored together with the queue.
-
-## Protocol design
-
-Additional/changed SMP commands:
-
-```haskell
-- register notification server
-- should be signed with server key
-NSRV :: NtfServerCreds -> Command NtfServer
-
-- response
-NSID :: NtfServerId -> BrokerMsg
-
-- to communicate which server is responsible for the queue
-- should be signed with queue key
-NSUB :: Maybe NtfServerId -> Command Notifier
-
-- subscribe to notificaions from all queues associated with the server
-- should be signed with server key
-- entity ID - NtfServerId
-NSSUB :: Command NtfServer
-
-data NtfServerCreds = NtfServerCreds
-  { server :: NtfServer,
-    -- NTF server certificate chain that should match fingerpring in address
-    cert :: X.CertificateChain,
-    -- server autorizatio key to sign server subscription requests
-    authKey :: X.SignedExact X.PubKey
-  }
-
-- entity ID is recipient ID
-NSKEY :: NtfSubscription -> Command Recipient 
-
-data NtfSubscription = NtfSubscription
-  -- key to encrypt notifications e2e with the client
-  { ntfPubDbKey :: RcvNtfPublicDhKey,
-    ntfServer :: NtfServer,
-    -- should be linked to correlation ID to prevent existense check
-    -- the ID sent to notification server could be its hash?
-    ntfId :: NotifierId,
-    encNtfTokenAssoc :: EncDataBytes
-  }
-
-- before the encryption - equivalent to NSUB command, but without key to authorize requests to specific queue
-data NtfTokenAssoc = NtfTokenAssoc
-  { signature :: SignatureEd25519,
-    tknId :: NtfTokenId,
-    ntfQueue :: SMPQueueNtf
-  }
-```
-
-SMP server will need to maintain the list of Ntf servers and their credentials, and when NSSUB arrives to make only one subscription. When message arrives it would deliver notification to the correct connection via queue / ntf server association.
-
-Ntf server needs to maintain three indices to the same data:
- `(smpServer, queueId) -> tokenId` - to deliver notification to the correct token
- `tokenId -> [smpServer -> [queueId]]` - to remove all queues when token is removed, and to store/update these associations effficiently - store log may have one compact line per token (after compacting), or per token/server combination.
- `[smpServer]` - array of SMP servers to subscribe to.
-
-## Mention notifications
-
-Currently we are marking messages with T (true) for messages that require notifications and F (false) for messages that don't require. Sender does not know whether the recipient has notifications disabled, enabled or in mentions-only mode.
-
-The proposal is to:
- add additional values to this metadata, e.g. 2 (priority) and 3 (high priority) (and T/F could be sent as 0/1 respectively) - that is, to deliver notifications even if notifications are generally disabled (they can still be further filtered by the client).
- instead of deleting notification credentials when notifications are disabled - which is costly - communicate to SMP server the change of notificaion priority level, e.g. the client could set minimal notification priority to deliver notifications, where 0 would mean disabling it completely, 1 enable for all, 2 for priority 2+, 3 for priority 3. The downside here is that it could be used for timing correlation of queues in the group, but it already can be used on bulk deletions of ntf credentials for these queues and when sending messages.
@@ -1,159 +0,0 @@
-# Using short links as group links
-
-## Problem
-
-To use the short links for groups these problems has to be / can be solved:
-1. recognizing link as a group link.
-2. permanent link with the ability to change chat relays.
-3. binding owners signatures to the link.
-4. allowing to add/remove owners, both to share ownership and for reliability in case of one owner losing keys/access.
-
-While current short links solve problems 1-3 (via contact type, and via extension of user data in the link), the problem 4 is solved only partially.
-
-We could include the current list of root owners in the user data, and we could send any history of ownership changes from this baseline as a short blockchain on joining the group, we still requrie one master owner to retain access to the queue associated with the group.
-
-## Possible solution approaches
-
-1. "Kick this can down the road" - ignore this problem until there is a namespace, and a group name can be associated with multiple queues.
-
-Pros: simple and reasonable, and it suggests postponing multisig for owners too. The users can still see the list of owners and their keys in user data of the link, and receive admin roster signed by owners on joining.
-
-Cons: if this "master owner" loses the access to the device, no further changes to group profile will be possible.
-
-2. The queue access can be shared by sharing the key and recipient IDs with all owners.
-
-The problems:
- preventing MITM attack between owners (this protect exists for other solutions too).
- protecting these credentials from chat relays. So somehow there should be direct key agreement between members allowing to send e2e encrypted message inaccessible to chat relays.
-
-Pros: simpler than alternatives, and still provides protection against losing the key.
-Cons:
- quite clunky, and requires the new primitive anyway (e2e encryption).
- no multisig
-
-This could possibly be evolved into the requirement to have a direct connection with other owners, and verifying the security code before they have access to group.
-
-3. Allow "joint management" of SMP queues.
-
-SMP servers can support multiple recipients for contact queues:\
- subscription would be possible to the "subscriber recipient".
- all other changes (update data, change subscriber recipient, add or remove recipients) would require multiple recipient signatures on SMP command in line with n-of-m multisig rules, that the command sender would have to collect out-of-band (from SMP protocol point of view).
-
-Pros: allows joint ownership, and protects from losing access to master owner device.
-Cons:
- complicates queue abstraction with approach that is not needed for most queues.
- still retains the server as a single point of failure.
-
-4. Introduce "group" as a new type of entity managed by SMP servers.
-
-SMP servers would provide a separate set of commands for managing group records that would include in an encrypted container:
- the group profile
- the list of chat relay links
- the list of owner member IDs with their public keys
- multisig rules
- alternative group entity locations
- possibly, a globally unique group identity (as the hash of the initial/seed group data).
-
-While the server domain would be used as the hostname in group link, it may contain alternative hosts (not just hostnames of the same server), both in the link and in the group record data.
-
-Pros: separates additional complexity to where it is needed, allowing reliability and redundancy for group ownership.
-Cons: complexity, coupling between SMP and chat protocol.
-
-## Design for channel/group as a separate queue mode
-
-Option 1.
-
-A queue mode "channel" when owners are represented by their individual queues (either a separate mode, or a submode of "channel", or just normal contact address queues). In this case sending message to channel queue would broadcast message to queue owners, without exposing even the number of owners.
-
-Pros:
- allows chat relays to send messages to all owners (e.g., channel can be secured with the list of snd keys, one per relay).
- quite easy to evolve from the current design.
- extensible.
-Cons:
- close to "solution in search of a problem".
- does not require data model changes - channel queue would simply have a list of owner "recipient IDs", and each owner queue would also point to channel.
-
-Option 2.
-
-Also a separate queue mode "channel", but instead of having a linked owner queues, it would simply maintain a list of owner keys to maintain the data. In this case, messages cannot be sent to this "queue" at all.
-
-Pros:
- simpler design.
- we could allow sending messages to it too, with the "main" owner receiving them. This could be negotiated in the protocol.
- it may be easier to migrate the current groups, as the admin link would be this queue (although for public groups in directory it would have to be recreated anyway).
- Possibly, when queue is created there should be a flag whether it should accept unsigned messages - then contact addresses would be created with unsigned messages ON, messages queues, once SKEY is universally supported, with unsigned messages OFF, and channel queues with unsigned messages OFF too for new public queues.
-Cons:
- if no messages are accepted, this is not even a queue.
- no way to directly contact owners (maybe it is not a downside, as for relays there would be a communication channel anyway as part of the group).
-
-Option 2 looks more simple and attractive, implementing server broadcast for SMP seems unnecessary, as while it could have been used for simple groups, it does not solve such problems as spam and pre-moderation anyway - it requires a higher level protocol.
-
-The command to update owner keys would be `RKEY` with the list of keys, and we can make `NEW` accept multiple keys too, although the use case here is less clear.
-
-## Multiple owners managing queue data.
-
-Option 1: Use the same keys in SMP as when signing queue data.
-
-Option 2: Use different keys.
-
-The value here could be that the server could validate these signatures too, and also maintain the chain of key changes. While tempting, it is probably unnecessary, and this chain of ownership is better to be maintained on chat relay level, as there are no size constraints on the size of this chain. Also, it is better for metadata privacy to not couple transport and chat protocol keys.
-
-We still need to bind the mutable data updates to the "genesis" signature key (the one included in the immutable data).
-
-The proposed design:
-
- when mutable data is signed by genesis key, then it is bound, and no changes is needed.
- mutable data may be signed by the key of the new owner, in which case mutable part itself must contain the binding. We could also use ring signature to sign the mutable data, concealing which owner signed the data - that would increase the signature size from 64 bytes to `32 * (n + 1)` bytes.
-
-Current mutable data:
-
-```haskell
-data UserLinkData = UserLinkData
-  { agentVRange :: VersionRangeSMPA,
-    userData :: ConnInfo
-  }
-```
-
-Proposed mutable data:
-
-```haskell
-data UserLinkData = UserLinkData
-  { agentVRange :: VersionRangeSMPA,
-    owners :: [OwnerInfo]
-    userData :: ConnInfo
-  }
-
-type OwnerId = ByteString
-
-data OwnerInfo = OwnerInfo
-  { ownerId :: OwnerId, -- unique in the list, application specific - e.g., MemberId
-    ownerKey :: PublicKeyEd25519,
-    -- owner signature of sender ID,
-    -- confirms that the owner agreed with being the owner,
-    -- prevents a member being added as an owner without consent.
-    ownerSig :: SignatureEd25519,
-    -- owner authorization, sig(ownerId || ownerKey, prevKey), where prevKey is either a "genesis key" or some other key previously signed by the genesis key.
-    authOwnerId :: OwnerId, -- null for "genesis"
-    authOwnerSig :: SignatureEd25519
-  }
-```
-
-The size of the OwnerInfo record encoding is:
- ownerId: 1 + 12
- ownerKey: 1 + 32
- ownerSig: 1 + 64
- ownerAuthId: 1 + 12
- ownerAuthSig: 1 + 64
-
-~189 bytes, so we should practically limit the number of owners to say 8 - 1 original + 7 addiitonal. Original creator could use a different key as a "genesis" key, to conceal creator identity from other members, and it needs to include the record with memberId anyway.
-
-The structure is simplified, and it does not allow arbitrary ownership changes. Its purpose is not to comprehensively manage ownership changes - while it is possible with a generic blockchain, it seems not appropriate at this stage, - but rather to ensure access continuity and that the server cannot modify the data (although nothing prevents the server from removing the data completely or from serving the previous version of the data).
-
-For example it would only allow any given owner to remove subsequenty added owners, preserving the group link and identity, but it won't allow removing owners that signed this owner authorization. So owners are not equal, with the creator having the highest rank and being able to remove all additional owners, and owners authorise by creator can remove all other owners but themselves and creator, and so on - they have to maintain the chain that authorized themselves, at least. We could explicitely include owner rank into OwnerInfo, or we could require that they are sorted by rank, or the rank can be simply derived from signatures.
-
-When additional owners want to be added to the group, they would have to provide any of the current owners:
- the key for SMP commands authorization - this will be passed to SMP server together with other keys. There could be either RKEY to pass all keys (some risk to miss some, or of race conditions), or RADD/RGET/RDEL to add and remove recipient keys, which has no risk of race conditions.
- the signature of the immutable data by their member key included in their profile.
- the current owner would then include their member key into the queue data, and update it with LSET command. In any case there should be some simple consensus protocol between owners for owner changes, and it has to be maintained as a blockchain by owners and by chat relays, as otherwise it may lead to race conditions with LSET command.
-
-Potentially, there could be one command to update keys and link data, so that they are consistent.
@@ -1,142 +0,0 @@
-# Service certificates for high volume servers and services connecting to SMP servers
-
-## Problem
-
-The absense of user and client identification benefits privacy, but it requires separately authorizing subscription for each messaging queue, that doesn't scale when a high volume server or service acts as a client for SMP server even for the current traffic and network size.
-
-These servers/services include:
- operators' chat relays (aka super-peers),
- notification servers,
- high-traffic service chat bots,
- high-traffic business support clients.
-
-The future chat relays would reduce the number of subscriptions required for the usual clients, by replacing connections with each group member to 1-3 connections with chat relays per group/community, it would shift the burden to the chat relays, that are also clients.
-
-Self-hosted chat relays may want to retain privacy, so they will not use client certificates, but this privacy is not needed (and counter-productive) for the chat relays provided by network operators.
-
-Even today, directory service subscribing to all queues may take 15-20 minutes, which is experienced as downtime by the end users.
-
-Notification servers also acting as clients to messaging servers also take 15-20 minutes to subscribe to all notifications, during which time notifications are not delivered.
-
-Not only these subscription take a lot of time, they also consume a large amount of memory both in the clients and in the servers, as association between clients and queues is currently session-scoped and not persisted anywhere (and it should not be, because end-users' clients do need privacy).
-
-## Solution
-
-High volume "clients" (operators' chat relays, directory service, SimpleX Chat team support client, SimpleX Status bot, etc.) that don't need privacy will identify themselves to the messaging servers at a point of connection by providing client sertificate, both in TLS handshake and in SMP handshake (the same certificate must be provided).
-
-All the new queues and subscriptions made in this session will be creating a permanent association of the messaging queue with the client, and on subsequent reconnections the client can "subscribe" to all their queues with a single client subscription command.
-
-This will save a lot of time subscribing and resubscribing on server and client restarts, servers' bandwidth, servers' traffic spikes, and memory of both clients and servers.
-
-## Protocol
-
-An ephemeral per-session signature key signed by long-term client certificate is used for client authorization – this session signature key will be passed in SMP handshake.
-
-To transition existing queues, the subscription command will have to be double-signed - by the queue key, and then by client key.
-
-When server receives such "hand-over" subscription it would create a permanent association between the client certificate and the queue, and on subsequent re-connections the client can subscribe to all the existing queues still associated with the client with one command.
-
-The server will respond to the client with the number of queues it was subscribed to - it would both inform the client that it has to re-connect in case of interruption, and can be used for client and server statistics.
-
-When client creates a new queue, it would also sign the request with both keys, per-queue and client's. Other queue operations (e.g., deletion, or changing associated queue data for short links) would still require two signatures, both the queue key and the client key.
-
-The open question is whether there is any value in allowing to remove the association between the client and the queue. Probably not, as threat model should assume that the server would retain this information, and the use-case for users controlling their servers is narrow.
-
-## Protocol connection handshake
-
-Currently, the types for handshakes are:
-
-```haskell
-data ServerHandshake = ServerHandshake
-  { smpVersionRange :: VersionRangeSMP,
-    sessionId :: SessionId,
-    -- pub key to agree shared secrets for command authorization and entity ID encryption.
-    -- todo C.PublicKeyX25519
-    authPubKey :: Maybe (X.CertificateChain, X.SignedExact X.PubKey)
-  }
-
-data ClientHandshake = ClientHandshake
-  { -- | agreed SMP server protocol version
-    smpVersion :: VersionSMP,
-    -- | server identity - CA certificate fingerprint
-    keyHash :: C.KeyHash,
-    -- | pub key to agree shared secret for entity ID encryption, shared secret for command authorization is agreed using per-queue keys.
-    authPubKey :: Maybe C.PublicKeyX25519,
-    -- | Whether connecting client is a proxy server (send from SMP v12).
-    -- This property, if True, disables additional transport encrytion inside TLS.
-    -- (Proxy server connection already has additional encryption, so this layer is not needed there).
-    proxyServer :: Bool
-  }
-```
-
-`ServerHandshake` already contains `authPubKey` with the server certificate chain and the signed key for connection encryption and creating a shared secret for denable authorization (with client entity key) and session encryption layer.
-
-`ClientHandshake` contains only ephemeral `authPubKey` to compute a shared secret for session encryption layer, so we need an additional field for an optional client certificate:
-
-```haskell
-serviceCertKey :: Maybe (X.CertificateChain, X.SignedExact X.PubKey)
-```
-
-Certificate here defines client identity. The actual key to be used to sign commands is session-scoped, and is signed by the certificate key. In case of notification server it MUST be the same certificate that is used for server TLS connections.
-
-For operators' clients we may optionally include operators' certificate in the chain, and that would allow servers to identify operators if either wants to. This would improve end-user security, as not only the server would validate that its certificate matches the address, but it would also validate that it is operated by SimpleX Chat or by Flux, preventing any server impersonation (e.g., via DNS manipulations) - the client could then report that the files are hosted on SimpleX Chat servers, but then can stop and show additional warning in case certificate does not match the domain - same as the browsers do with CA stores in the client.
-
-## Protocol transmissions
-
-Each transport block can contain one or several protocol transmissions.
-
-Each transmission has this structure:
-
-```abnf
-transmission = authenticator authorized
-; authenticator - Ed25519 signature for recipients or X25519 authenticator for senders, to provide repudiation.
-; authenticator authorizes the rest of the transmission.
-authorized = sessId corrId entityId command.
-; sessId is tls-unique channel binding, its presense in the transmission prevents replay attacks.
-```
-
-The proposed change would replace authenticator with exactly one or two authenticators, where the first one will remain resource-level authorization (queue key), and the optional second one will be client authorization with the client key.
-
-```abnf
-authenticator = queue_authenticator ("0" / "1" service_authenticator)
-; "0" and "1" characters (digit characters, not x00 or x01) are conventionally used for Maybe types in the protocol.
-```
-
-In case service_authenticator is present, queue_authenticator should authorize over `fingerprint authorized` (concatenation of service identity certificate fingerprint and the rest of the transmission).
-
-All queues created with client key will have to be double-authorized with both the queue key and the client key - both the client and the server would have to maintain this knowledge, whether the queue is associated with the client or not.
-
-Asymmetric retries have to be supported - the first request creating this association may succeed on the server and timeout on the client.
-
-## Subscription
-
-To subscribe to all associated queues the client has to send a single command authorized with the client key passed in handshake.
-
-The command and response:
-
-```haskell
-SUBS :: Command Recipient -- to enable all client subscriptions, empty entity ID in the transmission, signed by client key - it must be the same as was used in handover subscription signature.
-NSUBS :: Command Recipient -- notification subscription
-SOK :: Maybe ServiceId -- new subscription response
-SOKS :: Int64 -> BrokerMsg -- response from the server, includes the number of subscribed queues
-ENDS :: Int64 -> BrokerMsg -- when another session subscribes with the same certificate
-```
-
-Open questions:
- What should used as an entity ID for `SUBS` transmission - certificate fingerprint or an empty string?
- Should there be a command to get the list of all associated queues? It is likely to be useful for debugging?
- What should happen when `SUB` is sent for a single already associated queue? What if it is signed with the correct session key, but that is different from existing association? The current approach is that once associated, this associaiton would require authorization for single subscriptions, with the same certificate as already associated.
-
-## Ephemeral client-session association
-
-This was considered to reduce costs for the usual clients to re-subscribe. Currently it's a big problem, because of groups, and with transition to chat relays it won't be.
-
-For some very busy end-user clients it may help.
-
-Given that server has access to an ephemeral association between recipient client session and queues anyway (even with clients connecting via Tor, unless per-connection transport isolation is used), introducing `sessionPubKey` to allow resubscription to the previously subscribed queues may reduce the traffic. This won't change threat model as the server would only keep this association in memory, and not persist it. Clients on another hand may safely persist this association for fast resubscription on client restarts.
-
-This is not planned for the forseable future, as migrating to chat relays would solve most of the problem.
-
-Assuming an average active user has 20 contacts and 20 groups, and they would need ~3 subscriptions for each (for redundancy), so about 120 subscription to reconnect. The single 16kb transport block allows to send ~136 subscriptions. Which means that ephemeral sessions would create no value for clients at all, unless they are super active.
-
-Further, improving transport efficiency for super-active non-identified clients may help network abuse, so ephemeral sessions may have negative value.
@@ -1,104 +0,0 @@
-# Using the same profile from multiple devices
-
-## Problem
-
-Double Ratchet algorithm makes it hard to send/receive messages sent to the user from different devices, as each message changes the state of Double Ratchet keys, and these state changes must be strictly sequential and they cannot be reversed (although skipping is possible).
-
-Traditional approach for multi-device converts each direct conversation into a group, where each device participates as a member. Likewise, for group conversations each device also participates as a member. While these members *look* as if they are the same user to others, a very simple client app modification may show device ID for each message, and the communication peers, both in direct chats and in groups would know how many devices a user has and which device the user sent the message from. In addition to that, with this approach communication peers can send different messages to different devices (it can be prevented by provider who would request that only message key is encrypted with DR, while the encrypted message is the same) or withheld from some devices (it cannot be prevented by provider, as it cannot add key to the communication in case it is missing, and cannot withhold the message completely too). These opens various vectors for targeted attacks, e.g.:
- tracking movements of the user: once each devices is identified as "desk" and "phone" it would allow to know where the user is at a given time.
- manipulating information by sending messages to one device (to have proof it was sent) and withholding from others, or sending different messages if the protocol allows it.
-
-In addition to that, the specific implementation of this approach in Signal compromises break-in recovery property (aka post-compromise security) of Double-Ratchet algorithm, making its design ineffective - the only reason to have the second ratchet in DR algorithm is to provide break-in recovery, without it a much simpler design with a single ratchet is sufficient. See [this paper](https://eprint.iacr.org/2021/626.pdf) for details.
-
-While this limitation can be addressed with notifications when a new device is added and per-device keys, we still find the remaining attack vectors on user security and privacy to be unacceptable, and opening unsuspecting users to various criminal actions - and it is wrong to say that would only affect security conscious users, and most people would not be affected by these risks. Allowing potential criminals in groups to know which device you are currently using is a real risk for all users.
-
-Another approach was offered by Threema that is ["mediator" server](https://threema.com/en/blog/md-architectural-overview) where the state of encryption ratchets is stored server-side. While it protects the user from their communication peers, it increases required level of trust to the servers, and in case of SimpleX network it would expose the knowledge of who communicates to whom. So while the idea of server-side storage of encryption state is promising, it has to be per-connection, to retain "no-accounts" property of SimpleX messaging network.
-
-Also see [FAQ](https://simplex.chat/faq/#why-cant-i-use-the-same-profile-on-different-devices) and [this issue](https://github.com/simplex-chat/simplex-chat/issues/444#issuecomment-3066968358).
-
-## Proposed solution
-
-One of the ideas presented in FAQ - to store the state of Double Ratchet algorithm in the encrypted container on the server seems promising. The RFC develops this idea.
-
-### Considerations for the design
-
-1. The largest ratchet state size with the current implementation is less than 8kb (which is achieved when both sides shared PQ keys and ciphertexts), so while it cannot fit in the same transport blocks together with sent and received messages, it would fit in one transport block.
-
-2. Protocol commands and events may be changed (even if at the cost of slightly reducing message size) can fit the hash of the ratchet state (32 bytes sha256 would be sufficient), so that the client can determine whether it has the most recent ratchet state or if it needs to retrieve the latest copy. Message size reduction won't affect the users because we use compression, and there is a substantial reserve.
-
-3. Client commands that modify ratchet state would include the hash of the previous ratchet state so that the server can reject or ignore the command in case the previous ratchet state is different or in case command is repeated in case of lost response).
-
-4. The client does not need to retrieve message state for each encryption and decryption operation - it can "speculatively" use the ratchet state it has, and receive correct ratchet state in the "error" response after attempting encryption based on incorrect ratchet state.
-
-## Proposed protocol design
-
-Ratchet state will be stored on the same server that stores message queue, as part of message queue record. 8kb is a sufficient size for this blob (the actual max size is 7800 bytes). The server would also store the hashes of the current and, possibly, the previous ratchet states (TBC).
-
-While ratchet is used for duplex connection, the connection still has primary queue, and with redundancy the same ratchet state can be stored on all secondary queues.
-
-Ratchet state will be encrypted using secret_box - a symmetric encryption scheme, so PQ-resistant. If ratchet state is stored on more than one server, it has to be encrypted with a different key for each server.
-
-Questions: how to rotate the key used to store ratchet? Should key used to encrypt ratchet rotate at the same time when queue is rotated? The latter is a logical option, as it prevents additional complexity and solves the problem anyway. A possible option is to have "ratchet version" that will be used to advance the key used to encrypt ratchet via HKDF.
-
-Security considerations: the scheme may reduce break-in recovery to the points queues are rotated, unless there is some randomness mixed-in into the key derivation (the key used to encrypt ratchet state). But including randomness would defeat the purpose, as other devices wouldn't be able to access the ratchets. Another approach would be to have each device use its own key for encryption, and encrypt to all keys of all devices (or to encrypt key, to avoid size increase). Having multiple encryptions would show how many devices use the queue, but servers already can observe it, so it is a better tradeoff. Another idea would be to rotate the key used to authorize queue commands - we already support multiple recipient keys, and it can be used for multi-device scenario. That would partially mitigate break-in attacks as the attacker who obtained the key from ratchet state would be able to decrypt it, but won't be able to decrypt it (the attacker collusion with the server is not mitigated). Yet another idea would be for each party (device) to share its private (or encapsulation) key and to have a symmetric key (used to encrypt the ratchet state) encrypted (encapsulated) separately for each device. This would reduce the size of the stored data to `ratchet size` + `encrypted key size` * N, so even in case of PQ encryption (e.g. sntrup) the size required to store the ratchet would be under transport block size, while limiting it to say 4-8 devices, which is sufficient.
-
-To participate in multi-device scheme the devices would join the usual group that will be used to share public (encapsulation) device keys and to communicate updates to conversations that were received by the currently "active" device. "Active" means the device that received or sent and processed the message, and while only one device can receive messages from a given queue, device "active" state may be determined per queue, allowing concurrent usage.
-
-The scheme must be resilient to state updates being lost, and in case of direct messages it would result in some messages not being shown (or shown as skipped), while conversation preference and profile updates can be re-requested from peers, while the current profile of the user would become the latest. Likewise, for groups state updates ca be requested from super-peers or for decentralized groups - from owners. Maintaining chat state consistency is an important consideration, but is not a focus of this RFC - the focus is managing message delivery and DR encryption for multiple devices. Other multi-device schemes have the same issues with state consistency. Partially, the profile state consistency can be improved by using a single shared queue (or set of queues) to store user's profile and chat preferences to synchronize profile updates asynchronously between the devices.
-
-## The protocol to send the message
-
-`rsi` - ratchet state on device `i`.
-
-`enc(rs)` - current authoritative ratchet state on the server.
-
-`pt` and `ct` - plaintext and ciphertext messages.
-
-Encryption is a state transition function ratchetEnc: `(ct, rs') = ratchetEnc(pt, rs)`.
-
-1. Device encrypts the message using the stored ratchet state: `(ct, rsi') = ratchetEnc(pt, rsi)`
-
-2. Device sends modified encrypted ratchet state and the hash of the previous encrypted state to the server that stores the queue: `RSET (hash(enc(rsi)), enc(rsi'))`.
-
-3. If the hash of the previous state matches state stored on the server (`hash(enc(rsi)) == hash(enc(rs))`), the server updates the state and responds with `ratchet_ok` (that may include the current state or it's hash, for validation). If the hash is different, the server responds with `bad_ratchet(enc(rs))` message that includes the correct ratchet state. These updates must be atomic. In this case device has to update the local ratchet state (provided it can decrypt it), and repeat encryption attempt. If device cannot decrypt the provided ratchet state, it means that the connection is disrupted (possibly, device is removed from device group, but missed the notifications).
-
-4. After successful state update in primary receiving queue, the device would update it in secondary receiving queues.
-
-5. Device sends encrypted message as usual, via proxy that must be different both from the server that stores the ratchet and from the destination server.
-
-6. Device broadcasts sent message and new ratchet state to other devices in the device group.
-
-This protocol is simple, and it minimizes requests when sending the message to one additional request to update ratchet state in most cases, only requiring two requests when device state was not updated via device group prior to message sending attempt.
-
-## The protocol to receive the message
-
-Decryption is also a state transition function: `(pt, rs') = ratchetDec(ct, rs)`
-
-1. Server sends the message to the device (can be in response to SUB or ACK commands, or with active subscription). Pushed message would include the hash of the currently stored ratchet state: `hash(enc(rs))`.
-
-2. If device has the ratchet state with the same hash (`hash(enc(rs)) == hash(enc(rsi))`), it decrypts the message: `(pt, rsi') = ratchetDec(ct, rsi)`.
-
-3. If device has ratchet state with a different hash, it requests ratchet from the server with additional protocol command `RGET` with response `RCHT (enc(rs))` and updates the local state.
-
-4. Device decrypts the message `(pt, rsi') = ratchetDec(ct, rsi)` and processes it as usual.
-
-5. Device sends acknowledgement to the server as usual, but now it includes the new ratchet state and the hash of the previous state: `ACK msgId (hash(enc(rsi)), enc(rsi'))`
-
-6. The server compares ratchet state with stored state hash, and in case it matches it processes `ACK` and responds with `OK` as usual (or `NO_MSG` in case msgId is incorrect, also as usual - it would happen in repeated ACK requests). If ratchet state hash does not match, the server would respond with `bad_ratchet(enc(rs))` - which means that the message was already processed by another device and ratchet was advanced. This is a complex scenario, as the client has to either revert the change from message processing or somehow combine the change with the updates communicated via device group (as a side note, device group can simply re-broadcast messages, not state updates, but it will result in state divergence between devices when different messages are lost).
-
-Unlike sending messages, this flow does not require any additional requests in most cases, only requiring requesting message state reconciliation when the same message was received and processed by more than one client, but it does not require re-acknowledgement.
-
-## Challenges
-
-This is an idea of the design rather than the actual design, as it requires more thinking about:
- how to handle concurrent ratchet state updates,
- "active" status transitions per queue,
- avoiding concurrent subscriptions to queues from multiple devices,
- state updates and synchronization between devices,
- handling skipped messages,
- costs to update ratchets in bulk send scenario - this scheme would substantially increase costs of preparing large broadcasts, and it makes this scheme not acceptable for chat relays. Which means that "profile" on desktop used as chat relay won't be synched to other devices.
- etc.
-
-## Advantages
-
-The communication peers won't know how many devices the user has, and which device was used to send the message. Also, the communication peers won't be able to send different messages to different user's devices, or to withhold messages from some devices.
@@ -53,7 +53,7 @@ The session invitation contains this data:
 - CA TLS certificate fingerprint of the controller - this is part of long term identity of the controller established during the first session, and repeated in the subsequent session announcements.
 - Session Ed25519 public key used to verify the announcement and commands - this mitigates the compromise of the long term signature key, as the controller will have to sign each command with this key first.
 - Long-term Ed25519 public key used to verify the announcement and commands - this is part of the long term controller identity.
- Session X25519 DH key and sntrup761 KEM encapsulation key to agree session encryption (both for multicast announcement and for commands and responses in TLS), as described in https://datatracker.ietf.org/doc/draft-josefsson-ntruprime-hybrid/. The new keys are used for each session, and if client key is already available (from the previous session), the computed shared secret will be used to encrypt the announcement multicast packet. The out-of-band invitation is unencrypted. This DH public key is always sent unencrypted. NaCL Cryptobox is used for encryption.
+- Session X25519 DH key and sntrup761 KEM encapsulation key to agree session encryption (both for multicast announcement and for commands and responses in TLS), as described in https://datatracker.ietf.org/doc/draft-josefsson-ntruprime-hybrid/. The new keys are used for each session, and if client key is already available (from the previous session), the computed shared secret will be used to encrypt the announcement multicast packet. The out-of-band invitation is unencrypted. These DH public key and KEM encapsulation key are always sent unencrypted. NaCL Cryptobox is used for encryption.

 Host device decrypts (except the first session) and validates the invitation:
 - Session signature is valid.
@@ -1,67 +0,0 @@
-name: SimpleX Chat - smp-server
-
-services:
-  oneshot:
-    image: ubuntu:latest
-    environment:
-      CADDYCONF: |
-        ${CADDY_OPTS:-}
-
-        http://{$$ADDR} {
-            redir https://{$$ADDR}{uri} permanent
-        }
-
-        {$$ADDR}:8443 {
-            tls {
-                key_type rsa4096
-            }
-        }
-    command: sh -c 'if [ ! -f /etc/caddy/Caddyfile ]; then printf "$${CADDYCONF}" > /etc/caddy/Caddyfile; fi'
-    volumes:
-      - ./caddy_conf:/etc/caddy
-
-  caddy:
-    image: caddy:latest
-    depends_on:
-      oneshot:
-        condition: service_completed_successfully
-    cap_add:
-      - NET_ADMIN
-    environment:
-      ADDR: ${ADDR?"Please specify the domain."}
-    volumes:
-      - ./caddy_conf:/etc/caddy
-      - caddy_data:/data
-      - caddy_config:/config
-    ports:
-      - 80:80
-    restart: unless-stopped
-    healthcheck:
-      test: "test -d /data/caddy/certificates/${CERT_PATH:-acme-v02.api.letsencrypt.org-directory}/${ADDR} || exit 1"
-      interval: 1s
-      retries: 60
-
-  smp-server:
-    image: ${SIMPLEX_IMAGE:-simplexchat/smp-server:latest}
-    depends_on:
-      caddy:
-        condition: service_healthy
-    environment:
-      ADDR: ${ADDR?"Please specify the domain."}
-      PASS: ${PASS:-}
-    volumes:
-      - ./smp_configs:/etc/opt/simplex
-      - ./smp_state:/var/opt/simplex
-      - type: volume
-        source: caddy_data
-        target: /certificates
-        volume:
-          subpath: "caddy/certificates/${CERT_PATH:-acme-v02.api.letsencrypt.org-directory}/${ADDR}"
-    ports:
-      - 443:443
-      - 5223:5223
-    restart: unless-stopped
-
-volumes:
-  caddy_data:
-  caddy_config:
@@ -1,15 +0,0 @@
-name: SimpleX Chat - smp-server
-
-services:
-  smp-server:
-    image: ${SIMPLEX_IMAGE:-simplexchat/smp-server:latest}
-    environment:
-      WEB_MANUAL: ${WEB_MANUAL:-1}
-      ADDR: ${ADDR?"Please specify the domain."}
-      PASS: ${PASS:-}
-    volumes:
-      - ./smp_configs:/etc/opt/simplex
-      - ./smp_state:/var/opt/simplex
-    ports:
-      - 5223:5223
-    restart: unless-stopped
@@ -1,11 +0,0 @@
-# Mandatory
-ADDR=your_ip_or_addr
-
-# Optional
-#PASS='123123'
-#WEB_MANUAL=1
-
-# Debug
-#SIMPLEX_SMP_IMAGE=smp-server-dev
-#CERT_PATH=acme-staging-v02.api.letsencrypt.org-directory
-#CADDY_OPTS='{\n    acme_ca https://acme-staging-v02.api.letsencrypt.org/directory\n}'
@@ -1,9 +0,0 @@
-# Mandatory
-ADDR=your_ip_or_addr
-QUOTA=120gb
-
-# Optional
-#PASS='123123'
-
-# Debug
-#SIMPLEX_XFTP_IMAGE=xftp-server-dev
@@ -1,16 +0,0 @@
-name: SimpleX Chat - xftp-server
-
-services:
-  xftp-server:
-    image: ${SIMPLEX_XFTP_IMAGE:-simplexchat/xftp-server:latest}
-    environment:
-      ADDR: ${ADDR?"Please specify the domain."}
-      QUOTA: ${QUOTA?"Please specify disk quota."}
-      PASS: ${PASS:-}
-    volumes:
-      - ./xftp_configs:/etc/opt/simplex-xftp
-      - ./xftp_state:/var/opt/simplex-xftp
-      - ./xftp_files:/srv/xftp
-    ports:
-      - 443:443
-    restart: unless-stopped
@@ -1,87 +1,48 @@
 #!/usr/bin/env sh
-set -e
-
 confd='/etc/opt/simplex'
-cert_path='/certificates'
+logd='/var/opt/simplex/'

 # Check if server has been initialized
 if [ ! -f "${confd}/smp-server.ini" ]; then
  # If not, determine ip or domain
  case "${ADDR}" in
-    '')
-      printf 'Please specify $ADDR environment variable.\n'
-      exit 1
-      ;;
-
-    # Determine domain or IPv6
+    '') printf 'Please specify $ADDR environment variable.\n'; exit 1 ;;
    *[a-zA-Z]*)
      case "${ADDR}" in
-        # IPv6
-        *:*)
-          set -- --ip "${ADDR}"
-          ;;
-
-        # Domain
-        *)
-          case "${ADDR}" in
-            # It's in domain format
-            *.*)
-              # Determine the base domain
-              ADDR_BASE="$(printf '%s' "$ADDR" | awk -F. '{print $(NF-1)"."$NF}')"
-              set -- --fqdn "${ADDR}" --own-domains="${ADDR_BASE}"
-              ;;
-
-            # Incorrect domain
-            *)
-              printf 'Incorrect $ADDR environment variable. Please specify the correct one in format: smp1.example.org / example.org \n'
-              exit 1
-              ;;
-          esac
+        *:*) set -- --ip "${ADDR}" ;;
+        *) set -- -n "${ADDR}" ;;
      esac
      ;;
-
-    # Assume everything else is IPv4
-    *)
-      set -- --ip "${ADDR}" ;;
+    *) set -- --ip "${ADDR}" ;;
  esac

  # Optionally, set password
  case "${PASS}" in
-    # Empty value = no password
-    '')
-      set -- "$@" --no-password
-      ;;
-
-    # Assume that everything else is a password
-    *)
-      set -- "$@" --password "${PASS}"
-      ;;
+    '') set -- "$@" --no-password ;;
+    *) set -- "$@" --password "${PASS}" ;;
  esac

  # And init certificates and configs
-  smp-server init --yes \
-                  --store-log \
-                  --daily-stats \
-                  --source-code \
-                  "$@" > /dev/null 2>&1
-
-  # Fix path to certificates
-  if [ -n "${WEB_MANUAL}" ]; then
-    sed -i -e 's|^[^#]*https: |#&|' \
-           -e 's|^[^#]*cert: |#&|' \
-           -e 's|^[^#]*key: |#&|' \
-           -e 's|^port:.*|port: 5223|' \
-           "${confd}/smp-server.ini"
-  else
-    sed -i -e "s|cert: /etc/opt/simplex/web.crt|cert: $cert_path/$ADDR.crt|" \
-           -e "s|key: /etc/opt/simplex/web.key|key: $cert_path/$ADDR.key|" \
-           "${confd}/smp-server.ini"
-  fi
+  smp-server init -y -l "$@"
 fi

 # Backup store log just in case
-DOCKER=true /usr/local/bin/simplex-servers-stopscript smp-server
+#
+# Uses the UTC (universal) time zone and this
+# format: YYYY-mm-dd'T'HH:MM:SS
+# year, month, day, letter T, hour, minute, second
+#
+# This is the ISO 8601 format without the time zone at the end.
+#
+_file="${logd}/smp-server-store.log"
+if [ -f "${_file}" ]; then
+  _backup_extension="$(date -u '+%Y-%m-%dT%H:%M:%S')"
+  cp -v -p "${_file}" "${_file}.${_backup_extension:-date-failed}"
+  unset -v _backup_extension
+fi
+unset -v _file

 # Finally, run smp-sever. Notice that "exec" here is important:
 # smp-server replaces our helper script, so that it can catch INT signal
 exec smp-server start +RTS -N -RTS
+
@@ -1,90 +1,50 @@
 #!/usr/bin/env sh
-set -eu
-
 confd='/etc/opt/simplex-xftp'
+logd='/var/opt/simplex-xftp'

 # Check if server has been initialized
 if [ ! -f "${confd}/file-server.ini" ]; then
  # If not, determine ip or domain
  case "${ADDR}" in
-    '')
-      printf 'Please specify $ADDR environment variable.\n'
-      exit 1
-      ;;
-
-    # Determine domain or IPv6
+    '') printf 'Please specify $ADDR environment variable.\n'; exit 1 ;;
    *[a-zA-Z]*)
      case "${ADDR}" in
-        # IPv6
-        *:*)
-          set -- --ip "${ADDR}"
-          ;;
-
-        # Domain
-        *)
-          case "${ADDR}" in
-            # Check if format is correct
-            *.*)
-              set -- --fqdn "${ADDR}"
-              ;;
-
-            # Incorrect domain
-            *)
-              printf 'Incorrect $ADDR environment variable. Please specify the correct one in format: smp1.example.org / example.org \n'
-              exit 1
-              ;;
-          esac
-          ;;
+        *:*) set -- --ip "${ADDR}" ;;
+        *) set -- -n "${ADDR}" ;;
      esac
      ;;
-
-    # Assume everything else is IPv4
-    *)
-      set -- --ip "${ADDR}"
-      ;;
+    *) set -- --ip "${ADDR}" ;;
  esac

-  # Set global disk quota
+  # Set quota
  case "${QUOTA}" in
-    '')
-      printf 'Please specify $QUOTA environment variable.\n'
-      exit 1
-      ;;
-
-    # Incorrect format in uppercase, but automagically workaround this, replacing characters to lowercase
-    *GB)
-      QUOTA="$(printf '%s' "${QUOTA}" | tr '[:upper:]' '[:lower:]')"
-      set -- "$@" --quota "${QUOTA}"
-      ;;
-
-    # Correct format  
-    *gb)
-      set -- "$@" --quota "${QUOTA}"
-      ;;
-
-    # Incorrect format
-    *)
-      printf 'Wrong format. Format should be: 1gb, 10gb, 100gb.\n'
-      exit 1
-      ;;
+    '') printf 'Please specify $QUOTA environment variable.\n'; exit 1 ;;
+    *GB) QUOTA="$(printf ${QUOTA} | tr '[:upper:]' '[:lower:]')"; set -- "$@" --quota "${QUOTA}" ;;
+    *gb) set -- "$@" --quota "${QUOTA}" ;;
+    *) printf 'Wrong format. Format should be: 1gb, 10gb, 100gb.\n'; exit 1 ;;
  esac

  # Init the certificates and configs
-  xftp-server init --store-log \
-                   --path /srv/xftp \
-                   "$@" > /dev/null 2>&1
-
-  # Optionally, set password
-  if [ -n "${PASS}" ]; then
-    sed -i -e "/^# create_password:/a create_password: $PASS" \
-           "${confd}/file-server.ini"
-  fi
+  xftp-server init -l -p /srv/xftp "$@"
 fi

 # Backup store log just in case
-
-DOCKER=true /usr/local/bin/simplex-servers-stopscript xftp-server
+#
+# Uses the UTC (universal) time zone and this
+# format: YYYY-mm-dd'T'HH:MM:SS
+# year, month, day, letter T, hour, minute, second
+#
+# This is the ISO 8601 format without the time zone at the end.
+#
+_file="${logd}/file-server-store.log"
+if [ -f "${_file}" ]; then
+  _backup_extension="$(date -u '+%Y-%m-%dT%H:%M:%S')"
+  cp -v -p "${_file}" "${_file}.${_backup_extension:-date-failed}"
+  unset -v _backup_extension
+fi
+unset -v _file

 # Finally, run xftp-sever. Notice that "exec" here is important:
 # smp-server replaces our helper script, so that it can catch INT signal
 exec xftp-server start +RTS -N -RTS
+
@@ -1,176 +1,30 @@
 #!/usr/bin/env sh
 set -eu

-# Common
-# ------
+path_conf_var="/var/opt"
+path_conf_smp="$path_conf_var/simplex"
+path_conf_xftp="$path_conf_var/simplex-xftp"
+path_conf_storelog_smp="$path_conf_smp/smp-server-store.log"
+path_conf_storelog_xftp="$path_conf_xftp/file-server-store.log"
 date="$(date -u '+%Y-%m-%dT%H:%M:%S')"

-GRN='\033[0;32m'
-YLW='\033[1;33m'
-BLU='\033[1;34m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-path_conf_var="/var/opt"
-
-smp_variables() {
-	path_conf_smp="$path_conf_var/simplex"
-	path_conf_smp_archive="$path_conf_smp/backups"
-	path_conf_smp_archive_storelog="$path_conf_smp_archive/queues"
-	path_conf_smp_archive_stats="$path_conf_smp_archive/stats"
-	path_conf_smp_archive_messages="$path_conf_smp_archive/messages"
-	path_conf_storelog_smp="$path_conf_smp/smp-server-store.log"
-	path_conf_storelog_smp_out="$path_conf_smp_archive_storelog/smp-server-store.log.${date:-date-failed}"
-
-	path_conf_stats_smp="$path_conf_smp/smp-server-stats.log"
-	path_conf_stats_smp_out="$path_conf_smp_archive_stats/smp-server-stats.log.${date:-date-failed}"
-
-	path_conf_messages_smp="$path_conf_smp/smp-server-messages.log"
-	path_conf_messages_smp_out="$path_conf_smp_archive_messages/smp-server-messages.log.${date:-date-failed}"
+backup_smp() {
+ if [ -e "$path_conf_storelog_smp" ]; then
+  cp "$path_conf_storelog_smp" "${path_conf_storelog_smp}.${date:-date-failed}"
+ fi
 }

-xftp_variables() {
-	path_conf_xftp="$path_conf_var/simplex-xftp"
-	path_conf_xftp_archive="$path_conf_xftp/backups"
-
-	path_conf_xftp_archive_storelog="$path_conf_xftp_archive/queues"
-	path_conf_xftp_archive_stats="$path_conf_xftp_archive/stats"
-
-	path_conf_storelog_xftp="$path_conf_xftp/file-server-store.log"
-	path_conf_storelog_xftp_out="$path_conf_xftp_archive_storelog/file-server-store.log.${date:-date-failed}"
-
-	path_conf_stats_xftp="$path_conf_xftp/file-server-stats.log"
-	path_conf_stats_xftp_out="$path_conf_xftp_archive_stats/file-server-stats.log.${date:-date-failed}"
+backup_xftp() {
+ if [ -e "$path_conf_storelog_xftp" ]; then
+  cp "$path_conf_storelog_xftp" "${path_conf_storelog_xftp}.${date:-date-failed}"
+ fi
 }

-checks() {
-	result=${SERVICE_RESULT:-exit-code}
-	status=${EXIT_STATUS:-TERM}
-
-	case "$result" in
-		success)
-			case "$status" in
-				TERM)
-					printf "${RED}Refusing to backup files with failed service state${NC}\n"
-					exit 1
-					;;
-				*)
-					:
-					;;
-			esac
-			;;
-		*)
-			printf "${RED}Refusing to backup files with failed service state${NC}\n"
-			exit 1
-			;;
-	esac
-}
-
-smp_check() {
-	if [ ! -d "$path_conf_smp_archive_storelog" ]; then
-		mkdir -p "$path_conf_smp_archive_storelog"
-	fi
-	if [ ! -d "$path_conf_smp_archive_messages" ]; then
-		mkdir -p "$path_conf_smp_archive_messages"
-	fi
-	if [ ! -d "$path_conf_smp_archive_stats" ]; then
-		mkdir -p "$path_conf_smp_archive_stats"
-	fi
-}
-
-xftp_check() {
-	if [ ! -d "$path_conf_xftp_archive_storelog" ]; then
-		mkdir -p "$path_conf_xftp_archive_storelog"
-	fi
-	if [ ! -d "$path_conf_xftp_archive_stats" ]; then
-		mkdir -p "$path_conf_xftp_archive_stats"
-	fi
-}
-
-backup() {
-	file="$1"
-	out="$2"
-	file_type="$3"
-
-	if [ -e "$file" ]; then
-		if cp "$file" "$out"; then
-			printf "${YLW}${file_type}${NC} ${GRN}backup successful:${NC} ${BLU}%s${NC}\n" "${out}"
-		else
-			printf "${YLW}${file_type}${NC} ${RED}backup failed!${NC}\n"
-		fi
-	fi
-
-	unset file out file_type
-}
-
-cleanup() {
-	directory="$1"
-	
-	file_type="$2"
-	
-	files_date=$(find "$directory" -type f -exec stat --format="%y" {} + | awk '{print $1}' | sort -nr | uniq | awk 'NR==2')
-	
-	if [ -n "$files_date" ]; then
-		files=$(find "$directory" -type f -not -newermt "$files_date" -printf "%T@ %Tc %p\n" | sort -n | awk '{print $NF}')
-
-		if [ -n "$files" ]; then
-			printf '%s' "$files" | xargs rm -f
-			printf "${YLW}Old ${file_type} files${NC}${GRN} has been deleted:${NC}\n"
-			files_colored=$(printf '%s' "$files" | awk '{print "\033[1;34m"$0"\033[0m"}')
-			printf "${files_colored}\n"
-		fi
-	fi
-
-	unset directory file_type files_date files
-}
-
-smp_backup() {
-	backup "$path_conf_storelog_smp" "$path_conf_storelog_smp_out" 'Storelog'
-	backup "$path_conf_messages_smp" "$path_conf_messages_smp_out" 'Messages'
-	backup "$path_conf_stats_smp" "$path_conf_stats_smp_out" 'Stats'
-}
-
-smp_cleanup() {
-	cleanup "$path_conf_smp_archive_storelog" 'storelog'
-	cleanup "$path_conf_smp_archive_stats" 'stats'
-	cleanup "$path_conf_smp_archive_messages" 'messages'
-}
-
-xftp_backup() {
-	backup "$path_conf_storelog_xftp" "$path_conf_storelog_xftp_out" 'Storelog'
-	backup "$path_conf_stats_xftp" "$path_conf_stats_xftp_out" 'Stats'
-}
-
-xftp_cleanup() {
-	cleanup "$path_conf_xftp_archive_storelog" 'storelog'
-	cleanup "$path_conf_xftp_archive_stats" 'stats'
-}
-
-main() {
-	type="${1:-}"
-
-  if [ -z "${DOCKER+x}" ]; then
-  	checks
-  fi
-
-	case "$type" in
-		smp-server)
-			smp_variables
-			smp_check
-			smp_backup
-			smp_cleanup
-			;;
-		xftp-server)
-			xftp_variables
-			xftp_check
-			xftp_backup
-			xftp_cleanup
-			;;
-		*)
-			printf "${YLW}Unknown server type.${NC}\n"
-			exit 1
-			;;
-	esac 
-}
-
-main "$@"
+if [ "$1" = 'smp-server' ]; then
+ backup_smp
+elif [ "$1" = 'xftp-server' ]; then
+ backup_xftp
+else
+ backup_smp
+ backup_xftp
+fi
@@ -13,15 +13,11 @@ fi
 printf "${RED}This action will permanently remove all configs, directories, binaries from Installation Script. Please backup any relevant configs if they are needed.${NC}\n\nPress ${GRN}ENTER${NC} to continue or ${RED}Ctrl+C${NC} to cancel installation"
 read ans

-systemctl disable --now smp-server 2>/dev/null || true
-systemctl revert smp-server 2>/dev/null || true
-systemctl disable --now xftp-server 2>/dev/null || true
-systemctl revert xftp-server 2>/dev/null || true
-systemctl daemon-reload 2>/dev/null || true
+systemctl stop smp-server
+systemctl stop xftp-server

-rm -rf /var/opt/simplex /etc/opt/simplex /etc/opt/simplex-info /var/opt/simplex-xftp /etc/opt/simplex-xftp /srv/xftp /etc/systemd/system/smp-server.service /etc/systemd/system/xftp-server.service /usr/local/bin/smp-server /usr/local/bin/xftp-server /usr/local/bin/simplex-servers-update /usr/local/bin/simplex-servers-uninstall /usr/local/bin/simplex-servers-stopscript
+rm -rf /var/opt/simplex /etc/opt/simplex /var/opt/simplex-xftp /etc/opt/simplex-xftp /srv/xftp /etc/systemd/system/smp-server.service /etc/systemd/system/xftp-server.service /usr/local/bin/smp-server /usr/local/bin/xftp-server /usr/local/bin/simplex-servers-update /usr/local/bin/simplex-servers-uninstall

-userdel smp 2>/dev/null || true
-userdel xftp 2>/dev/null || true
+userdel smp && userdel xftp

 printf "Uninstallation is complete! Thanks for trying out SimpleX!\n"
@@ -1,8 +1,17 @@
 #!/usr/bin/env sh
 set -eu

-# Make sure that PATH variable contains /usr/local/bin
-PATH="/usr/local/bin:$PATH"
+# Links to scripts/configs
+bin="https://github.com/simplex-chat/simplexmq/releases/latest/download"
+bin_smp="$bin/smp-server-ubuntu-20_04-x86-64"
+bin_xftp="$bin/xftp-server-ubuntu-20_04-x86-64"
+
+scripts="https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/scripts/main"
+scripts_systemd_smp="$scripts/smp-server.service"
+scripts_systemd_xftp="$scripts/xftp-server.service"
+scripts_update="$scripts/simplex-servers-update"
+scripts_uninstall="$scripts/simplex-servers-uninstall"
+scripts_stopscript="$scripts/simplex-servers-stopscript"

 # Default installation paths
 path_bin="/usr/local/bin"
@@ -17,566 +26,149 @@ path_systemd_smp="$path_systemd/smp-server.service"
 path_systemd_xftp="$path_systemd/xftp-server.service"

 # Temporary paths
-path_tmp_bin="/tmp/simplex-servers"
-path_tmp_bin_smp="$path_tmp_bin/smp-server"
-path_tmp_bin_xftp="$path_tmp_bin/xftp-server"
+path_tmp_bin="$(mktemp -d)"
 path_tmp_bin_update="$path_tmp_bin/simplex-servers-update"
 path_tmp_bin_uninstall="$path_tmp_bin/simplex-servers-uninstall"
 path_tmp_bin_stopscript="$path_tmp_bin/simplex-servers-stopscript"
 path_tmp_systemd_smp="$path_tmp_bin/smp-server.service"
 path_tmp_systemd_xftp="$path_tmp_bin/xftp-server.service"

-path_conf_etc='/etc/opt'
-path_conf_info='/etc/opt/simplex-info'
-
 GRN='\033[0;32m'
 BLU='\033[1;36m'
 YLW='\033[1;33m'
 RED='\033[0;31m'
 NC='\033[0m'
-BLD='\033[1m'
-UNDRL='\033[4m'
-
-NL='
-'
-
-# Set VER globally and only once
-VER="${VER:-latest}"

 # Currently, XFTP default to v0.1.0, so it doesn't make sense to check its version
+local_version="$($path_bin_smp -v | awk '{print $3}')"
+remote_version="$(curl --proto '=https' --tlsv1.2 -sSf -L https://api.github.com/repos/simplex-chat/simplexmq/releases/latest | grep -i "tag_name" | awk -F \" '{print $4}')"

-######################
-### Misc functions ###
-######################
+update_scripts() {
+  curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_update" -o "$path_tmp_bin_update" && chmod +x "$path_tmp_bin_update"
+  curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_uninstall" -o "$path_tmp_bin_uninstall" && chmod +x "$path_tmp_bin_uninstall"
+  curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_stopscript" -o "$path_tmp_bin_stopscript" && chmod +x "$path_tmp_bin_stopscript"

-# Checks "sanity" of downloaded thing, e.g. if it's really a script or binary
-check_sanity() {
-  path="$1"
-  criteria="$2"
-
-  case "$criteria" in
-    string:*)
-      pattern="$(printf '%s' "$criteria" | awk '{print $2}')"
-      
-      if grep -q "$pattern" "$path"; then
-        sane=0
-      else
-        sane=1
-      fi
-      ;;
-    file:*)
-      pattern="$(printf '%s' "$criteria" | awk '{print $2}')"
-
-      if file "$path" | grep -q "$pattern"; then
-        sane=0
-      else
-        sane=1
-      fi
-      ;;
-    *) printf 'Unknown criteria.\n'; sane=1 ;;
-  esac
-
-  unset path string
-
-  return "$sane"
-}
-
-# Checks if old thing and new thing is different
-change_check() {
-  old="$1"
-  new="$2"
-
-  if [ -x "$new" ] || [ -f "$new" ]; then
-    type="$(file $new)"
+  if diff -q "$path_bin_uninstall" "$path_tmp_bin_uninstall" > /dev/null 2>&1; then
+    printf -- "- ${YLW}Uninstall script is up-to-date${NC}.\n"
+    rm "$path_tmp_bin_uninstall"
  else
-    type='string'
+    printf -- "- Updating uninstall script..."
+    mv "$path_tmp_bin_uninstall" "$path_bin_uninstall"
+    printf "${GRN}Done!${NC}\n"
+  fi
+  if diff -q "$path_bin_stopscript" "$path_tmp_bin_stopscript" > /dev/null 2>&1; then
+    printf -- "- ${YLW}Stopscript script is up-to-date${NC}.\n"
+    rm "$path_tmp_bin_stopscript"
+  else
+    printf -- "- Updating stopscript script..."
+    mv "$path_tmp_bin_stopscript" "$path_bin_stopscript"
+    printf "${GRN}Done!${NC}\n"
+  fi
+  if diff -q "$path_bin_update" "$path_tmp_bin_update" > /dev/null 2>&1; then
+    printf -- "- ${YLW}Update script is up-to-date${NC}.\n"
+    rm "$path_tmp_bin_update"
+  else
+    printf -- "- Updating update script..."
+    mv "$path_tmp_bin_update" "$path_bin_update"
+    printf "${GRN}Done!${NC}\n"
+    printf "Re-executing Update script with latest updates..."
+    exec sh "$path_bin_update" "continue"
  fi
-
-  case "$type" in
-    *script*|*text*)
-      if diff -q "$old" "$new" > /dev/null 2>&1; then
-        changed=1
-      else
-        changed=0
-      fi
-      ;;
-    string)
-      if [ "$old" = "$new" ]; then
-        changed=1
-      else
-        changed=0
-      fi
-      ;;
-  esac
-
-  return "$changed"
 }

-##########################
-### Misc functions END ###
-##########################
+update_systemd() {
+  curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_smp" -o "$path_tmp_systemd_smp"
+  curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_xftp" -o "$path_tmp_systemd_xftp"

-#########################
-### Support functions ###
-#########################
+  if diff -q "$path_systemd_smp" "$path_tmp_systemd_smp" > /dev/null 2>&1; then
+    printf -- "- ${YLW}smp-server service is up-to-date${NC}.\n"
+    rm "$path_tmp_systemd_smp"
+  else
+    printf -- "- Updating smp-server service..."
+    mv "$path_tmp_systemd_smp" "$path_systemd_smp"
+    systemctl daemon-reload
+    printf "${GRN}Done!${NC}\n"
+  fi
+  if diff -q "$path_systemd_xftp" "$path_tmp_systemd_xftp" > /dev/null 2>&1; then
+    printf -- "- ${YLW}xftp-server service is up-to-date${NC}.\n"
+    rm "$path_tmp_systemd_xftp"
+  else
+    printf -- "- Updating xftp-server service..."
+    mv "$path_tmp_systemd_xftp" "$path_systemd_xftp"
+    systemctl daemon-reload
+    printf "${GRN}Done!${NC}\n"
+  fi
+}

-# Sets local/remote versions and "apps" variables
-check_versions() {
-  # Sets:
-  # - ver
-  # - bin_url
-  # - remote_version
-  # - local_version
-  # - apps
+update_bins() {
+  if [ "$local_version" != "$remote_version" ]; then
+    if systemctl is-active --quiet smp-server; then
+      printf -- "- Stopping smp-server service..."
+      systemctl stop smp-server
+      printf "${GRN}Done!${NC}\n"

-  case "$VER" in 
-    latest)
-      remote_version="$(curl --proto '=https' --tlsv1.2 -sSf -L https://api.github.com/repos/simplex-chat/simplexmq/releases/latest 2>/dev/null | grep -i "tag_name" | awk -F \" '{print $4}')"
-
-      if [ -z "$remote_version" ]; then
-        printf "${RED}Something went wrong when ${YLW}resolving the lastest version${NC}: either you don't have connection to Github or you're rate-limited.\n"
-        exit 1
-      fi
-      ;;
-    *)
-      # Check if this version really exist
-      ver_check="https://github.com/simplex-chat/simplexmq/releases/tag/${VER}"
+      printf -- "- Updating smp-server bin to %s..." "$remote_version"
+      curl --proto '=https' --tlsv1.2 -sSf -L "$bin_smp" -o "$path_bin_smp" && chmod +x "$path_bin_smp"
+      printf "${GRN}Done!${NC}\n"
      
-      if curl -o /dev/null --proto '=https' --tlsv1.2 -sf -L "${ver_check}"; then
-        remote_version="${VER}"
-      else
-        printf "Provided version ${BLU}%s${NC} ${RED}doesn't exist${NC}! Switching to ${BLU}latest${NC}.\n" "${VER}"
-        VER='latest'
-
-        # Re-execute check
-        check_versions
-
-        # Everything has been done, so return from the function
-        return 0
-      fi
-      ;;
-  esac
-
-  # Links to scripts/configs
-  bin_url="https://github.com/simplex-chat/simplexmq/releases/download/${remote_version}"
-  scripts_url="https://raw.githubusercontent.com/simplex-chat/simplexmq/refs/tags/${remote_version}/scripts/main"
-  scripts_url_systemd_smp="$scripts_url/smp-server.service"
-  scripts_url_systemd_xftp="$scripts_url/xftp-server.service"
-  scripts_url_update="$scripts_url/simplex-servers-update"
-  scripts_url_uninstall="$scripts_url/simplex-servers-uninstall"
-  scripts_url_stopscript="$scripts_url/simplex-servers-stopscript"
-
-  set +u
-  for i in smp xftp; do
-    # Only check local directory where binaries are installed by the script
-    if command -v "/usr/local/bin/$i-server" >/dev/null; then
-      apps="$i $apps"
-    fi
-  done
-  set -u
-
-  if [ -z "$apps" ]; then
-    printf "${RED}No simplex servers installed! Aborting.${NC}\n"
-    exit 1
-  fi
-
-  for server in $apps; do
-    # Check if info file is present
-    if [ -f "$path_conf_info/release" ]; then
-      # If present, source it
-      . "$path_conf_info/release" 2>/dev/null
-
-      # Check if line containing local version exists in file
-      if grep -q "local_version_${server}" "$path_conf_info/release"; then
-        # if exists, set the var
-        eval "local_version=\$local_version_${server}"
-      else
-        # If it doesn't, append it to file
-        printf "local_version_${server}=unset\n" >> "$path_conf_info/release"
-        # And set it in script (so we don't have to re-source the file)
-        eval "local_version_${server}=unset"
-      fi
+      printf -- "- Starting smp-server service..."
+      systemctl start smp-server
+      printf "${GRN}Done!${NC}\n"
    else
-      # If there isn't info file, populate it
-      printf "local_version_${server}=unset\n" >> "$path_conf_info/release"
+      printf -- "- Updating smp-server bin..."
+      curl --proto '=https' --tlsv1.2 -sSf -L "$bin_smp" -o "$path_bin_smp" && chmod +x "$path_bin_smp"
+      printf "${GRN}Done!${NC}\n"
    fi
-  done

-  # Return 
-  return 0
+    if systemctl is-active --quiet xftp-server; then
+      printf -- "- Stopping xftp-server service..."
+      systemctl stop xftp-server
+      printf "${GRN}Done!${NC}\n"
+
+      printf -- "- Updating xftp-server bin to %s..." "$remote_version"
+      curl --proto '=https' --tlsv1.2 -sSf -L "$bin_xftp" -o "$path_bin_xftp" && chmod +x "$path_bin_xftp"
+      printf "${GRN}Done!${NC}\n"
+      
+      printf -- "- Starting xftp-server service..."
+      systemctl start xftp-server
+      printf "${GRN}Done!${NC}\n"
+    else
+      printf -- "- Updating xftp-server bin..."
+      curl --proto '=https' --tlsv1.2 -sSf -L "$bin_smp" -o "$path_bin_xftp" && chmod +x "$path_bin_xftp"
+      printf "${GRN}Done!${NC}\n"
+    fi
+  else
+    printf -- "- ${YLW}smp-server and xftp-server binaries is up-to-date${NC}.\n"
+  fi
 }

-# Checks the distro and sets the urls variables
-check_distro() {
-  . /etc/os-release
-
-  case "$VERSION_ID" in
-    20.04|22.04) : ;;
-    24.04) VERSION_ID='22.04' ;;
-    *) printf "${RED}Unsupported Ubuntu version!${NC}\nPlease file Github issue with request to support Ubuntu %s: https://github.com/simplex-chat/simplexmq/issues/new\n" "$VERSION_ID" && exit 1 ;;
-  esac
-
-  version="$(printf '%s' "$VERSION_ID" | tr '.' '_')"
-  arch="$(uname -p)"
-
-  case "$arch" in
-    x86_64) arch="$(printf '%s' "$arch" | tr '_' '-')" ;;
-    *)  printf "${RED}Unsupported architecture!${NC}\nPlease file Github issue with request to support %s architecture: https://github.com/simplex-chat/simplexmq/issues/new" "$arch" && exit 1 ;;
-  esac
-
-  bin_url_smp="$bin_url/smp-server-ubuntu-${version}-${arch}"
-  bin_url_xftp="$bin_url/xftp-server-ubuntu-${version}-${arch}"
-
-  return 0
-}
-
-# General checks that must be performed on the initial execution of script
 checks() {
  if [ "$(id -u)" -ne 0 ]; then
    printf "This script is intended to be run with root privileges. Please re-run script using sudo.\n"
    exit 1
  fi
-
-  check_versions
-  check_distro
-
-  mkdir -p $path_conf_info $path_tmp_bin
-
-  return 0
 }

-#############################
-### Support functions END ###
-#############################
-
-######################
-### Main functions ###
-######################
-
-# Downloads thing to directory and checks its sanity
-download_thing() {
-  thing="$1"
-  path="$2"
-  check_pattern="$3"
-  err_msg="$4"
-  
-  if ! curl --proto '=https' --tlsv1.2 -sSf -L "$thing" -o "$path"; then
-    printf "${RED}Something went wrong when downloading ${YLW}%s${NC}: either you don't have connection to Github or you're rate-limited.\n" "$err_msg"
-    exit 1
-  fi
-
-  type="$(file "$path")"
-
-  case "$type" in
-    *script*|*executable*) chmod +x "$path" ;;
-  esac
-
-  if ! check_sanity "$path" "$check_pattern"; then
-    printf "${RED}Something went wrong with downloaded ${YLW}%s${NC}: file is corrupted.\n" "$err_msg"
-    exit 1
-  fi
-
-  return 0
-}
-
-# Downloads all necessary files to temp dir and set update messages for the menu
-download_all() {
-  download_thing "$scripts_url_update" "$path_tmp_bin_update" 'string: /usr/bin/env' 'Update script'
-  if change_check "$path_tmp_bin_update" "$path_bin_update"; then
-    msg_scripts="${msg_scripts+$msg_scripts, }${YLW}simplex-servers-update${NC}"
-    msg_scripts_raw="${msg_scripts_raw+$msg_scripts_raw/}update"
-  fi
-
-  download_thing "$scripts_url_stopscript" "$path_tmp_bin_stopscript" 'string: /usr/bin/env' 'Stop script'
-  if change_check "$path_tmp_bin_stopscript" "$path_bin_stopscript"; then
-    msg_scripts="${msg_scripts+$msg_scripts, }${YLW}simplex-servers-stopscript${NC}"
-    msg_scripts_raw="${msg_scripts_raw+$msg_scripts_raw/}stop"
-  fi
-
-  download_thing "$scripts_url_uninstall" "$path_tmp_bin_uninstall" 'string: /usr/bin/env' 'Uninstall script'
-  if change_check "$path_tmp_bin_uninstall" "$path_bin_uninstall"; then
-    msg_scripts="${msg_scripts+$msg_scripts, }${YLW}simplex-servers-uninstall${NC}"
-    msg_scripts_raw="${msg_scripts_raw+$msg_scripts_raw/}uninstall"
-  fi
-
-  for i in $apps; do
-    service="${i}-server"
-    eval "scripts_url_systemd_final=\$scripts_url_systemd_${i}"
-    eval "path_tmp_systemd_final=\$path_tmp_systemd_${i}"
-    eval "path_systemd_final=\$path_systemd_${i}"
-   
-    download_thing "$scripts_url_systemd_final" "$path_tmp_systemd_final" 'string: [Unit]' "$service systemd service"
-    if change_check "$path_tmp_systemd_final" "$path_systemd_final"; then
-      msg_services="${msg_services+$msg_services, }${YLW}$service.service${NC}"
-      msg_services_raw="${msg_services_raw+$msg_services_raw/}$service"
-    fi
-  done
-
-  for i in $apps; do
-    service="${i}-server"
-    eval "local_version=\$local_version_${i}"
-
-    if change_check "$local_version" "$remote_version"; then
-      msg_bins="${msg_bins+$msg_bins$NL}  - ${YLW}$service${NC}: from ${BLU}$local_version${NC} to ${BLU}$remote_version${NC}"
-      msg_bins_alt="${msg_bins_alt+$msg_bins_alt, }${YLW}$service${NC}"
-      msg_bins_raw="${msg_bins_raw+$msg_bins_raw/}$service"
-    fi
-  done
-
-  return 0
-}
-
-# Updates systemd and scripts. This function depends om variables from "download_all"
-update_misc() {
-  OLD_IFS="$IFS"
-
-  IFS='/'
-  for script in ${msg_scripts_raw:-}; do
-    case "$script" in
-      update)
-        printf -- "- Updating update script..."
-        mv "$path_tmp_bin_update" "$path_bin_update"
-        printf "${GRN}Done!${NC}\n"
-        printf -- "- Re-executing Update script..."
-        exec env UPDATE_SCRIPT_DONE=1 VER="$remote_version" "$path_bin_update" "${selection}"
-        ;;
-      stop)
-        printf -- "- Updating stopscript script..."
-        mv "$path_tmp_bin_stopscript" "$path_bin_stopscript"
-        printf "${GRN}Done!${NC}\n"
-        ;;
-      uninstall)
-        printf -- "- Updating uninstall script..."
-        mv "$path_tmp_bin_uninstall" "$path_bin_uninstall"
-        printf "${GRN}Done!${NC}\n"
-        ;;
-    esac
-  done
-
-  for service in ${msg_services_raw:-}; do
-    app="${service%%-*}"
-    eval "path_systemd=\$path_systemd_${app}"
-    eval "path_tmp_systemd=\$path_tmp_systemd_${app}"
-
-    printf -- "- Updating %s service..." "$service"
-    mv "$path_tmp_systemd" "$path_systemd"
-    systemctl daemon-reload
-    printf "${GRN}Done!${NC}\n"
-  done
-
-  IFS="$OLD_IFS"
-  return 0
-}
-
-# Updates binaries. This function depends on variables from "download_all"
-update_bins() {
-  OLD_IFS="$IFS"
-
-  IFS='/'
-  for service in ${msg_bins_raw:-}; do
-    app="${service%%-*}"
-    eval "local_version=\$local_version_${app}"
-    eval "bin_url_final=\$bin_url_${app}"
-    eval "path_tmp_bin_final=\$path_tmp_bin_${app}"
-    eval "path_bin_final=\$path_bin_${app}"
-
-    # If systemd service is active
-    if systemctl is-active --quiet "$service"; then
-      printf -- "- Stopping %s service..." "$service"
-      systemctl stop "$service"
-      printf "${GRN}Done!${NC}\n"
-
-      printf -- "- Updating ${YLW}%s${NC} from ${BLU}%s${NC} to ${BLU}%s${NC}..." "$service" "$local_version" "$remote_version"
-      download_thing "$bin_url_final" "$path_tmp_bin_final" 'file: ELF' "$service"
-      mv "$path_tmp_bin_final" "$path_bin_final"
-      printf "${GRN}Done!${NC}\n"
-      
-      printf -- "- Starting %s service..." "$service"
-      systemctl start "$service"
-      printf "${GRN}Done!${NC}\n"
-    else
-      # If systemd service is NOT active
-      printf -- "- Updating ${YLW}%s${NC} from ${BLU}%s${NC} to ${BLU}%s${NC}..." "$service" "$local_version" "$remote_version"
-      download_thing "$bin_url_final" "$path_tmp_bin_final" 'file: ELF' "$service"
-      mv "$path_tmp_bin_final" "$path_bin_final"
-      printf "${GRN}Done!${NC}\n"
-    fi
-
-    # Don't forget to set version
-    sed -i -- "s|local_version_${app}=.*|local_version_${app}='${remote_version}'|" "$path_conf_info/release"
-  done
-
-  IFS="$OLD_IFS"
-  return 0
-}
-
-# Just download binaries
-download_bins() {
-  OLD_IFS="$IFS"
-
-  IFS='/'
-  for service in ${msg_bins_raw:-}; do
-    app="${service%%-*}"
-    eval "local_version=\$local_version_${app}"
-    eval "bin_url_final=\$bin_url_${app}"
-    eval "path_tmp_bin_final=\$path_tmp_bin_${app}"
-    eval "path_bin_final=\$path_bin_${app}"
-
-    printf -- "- Downloading ${YLW}%s${NC} binary..." "$service"
-    download_thing "$bin_url_final" "$path_tmp_bin_final" 'file: ELF' "$service"
-    printf "${GRN}Done!${NC}\n"
-  done
-
-  IFS="$OLD_IFS"
-  return 0
-}
-
-menu_init_help() {
-  menu_help="Update script for SimpleX servers and scripts.${NL}${NL}"
-  menu_help="${menu_help}${BLD}${UNDRL}Usage:${NC} [<VARIABLE>] ${BLD}simplex-servers-update${NC}${NL}       [<VARIABLE>] ${BLD}simplex-servers-update${NC} [<SUBCOMMAND>]${NL}${NL}"
-  menu_help="${menu_help}${BLD}${UNDRL}Subcommands:${NC}${NL}"
-  menu_help_sub="  ${BLD}[a]ll${NC}		Update everything without confirmation${NL}"
-  menu_help_sub="${menu_help_sub}  ${BLD}[b]inaries${NC}	Update binaries only without confirmation${NL}"
-  menu_help_sub="${menu_help_sub}  ${BLD}[d]ownload${NC}	Download everything without updating${NL}"
-  menu_help_sub="${menu_help_sub}  ${BLD}[h]elp${NC}	Print this message${NL}${NL}"
-  menu_help="${menu_help}${menu_help_sub}"
-  menu_help="${menu_help}${BLD}${UNDRL}Variables:${NC}${NL}"
-  menu_help="${menu_help}  ${BLD}VER=v3.2.1-beta.0${NC}	Update binaries to specified version${NL}"
-
-  return 0
-}
-
-menu_init() {
-  menu_end="${RED}x${NC}) Exit${NL}${NL}Selection: "
-  menu_option_download="${GRN}d${NC}) Download files only${NL}"
-
-  if [ -n "${msg_scripts:-}" ]; then
-    menu_option_misc_raw="${menu_option_misc_raw+${menu_option_misc_raw}${NL}}  - script(s): ${msg_scripts}"
-  fi
-
-  if [ -n "${msg_services:-}" ]; then
-    menu_option_misc_raw="${menu_option_misc_raw+${menu_option_misc_raw}${NL}}  - systemd service file(s): ${msg_services}"
-  fi
-
-  menu_option_all="${GRN}a${NC}) Update all: ${BLU}(recommended)${NC}${NL}${menu_option_misc_raw+${menu_option_misc_raw}${NL}}${msg_bins+${msg_bins}${NL}}"
-
-  if [ -n "${msg_bins:-}" ]; then
-    menu_option_bins="${GRN}b${NC}) Update server binaries: ${msg_bins_alt}${NL}"
-  fi
-
-  # Abort early if there's neither update binaries, nor update scripts options
-  if [ -z "${menu_option_bins:-}" ] && [ -z "${menu_option_misc_raw:-}" ]; then
-    printf "${YLW}Everything is up-to-date${NC}.\n"
-    exit 0
-  fi
-
-  menu="${menu_option_all}${menu_option_bins:-}${menu_option_download}${menu_end}"
-
-  return 0
-}
-
-options_parse() {
-  selection="$1"
-  
-  case "$selection" in
-    a|all)
-      check=0
-      if [ -z "${menu_option_misc_raw:-}" ] && [ -z "${menu_option_bins:-}" ]; then
-        printf "${YLW}Everything is up-to-date${NC}.\n"
-      else
-        if [ -n "${menu_option_misc_raw:-}" ]; then
-          update_misc
-        fi
-        if [ -n "${menu_option_bins:-}" ]; then
-          update_bins
-        fi
-      fi
-      ;;
-    b|binaries)
-      check=0
-      if [ -n "${menu_option_bins:-}" ]; then
-        update_bins
-      else
-        printf "${YLW}Binaries is up-to-date${NC}.\n"
-      fi
-      ;;
-    d|download)
-      check=0
-      if [ -n "${menu_option_bins:-}" ]; then
-        download_bins
-      fi
-
-      printf "\n${YLW}Scripts${NC}/${YLW}services${NC}/${YLW}binaries${NC} has been downloaded to ${BLU}%s${NC}\n" "$path_tmp_bin"
-      ;;
-    x)
-      check=0
-      ;;
-    *)
-      check=1
-      ;;
-  esac
-
-  return "$check"
-}
-
-##########################
-### Main functions END ###
-##########################
-
-############
-### Init ###
-############
-
 main() {
-  # Early hook to print Done after script re-execution
-  if [ -n "${UPDATE_SCRIPT_DONE:-}" ]; then
+  checks
+
+  set +u
+  if [ "$1" != "continue" ]; then
+    set -u
+    printf "Updating scripts...\n"
+    update_scripts
+  else
+    set -u
    printf "${GRN}Done!${NC}\n"
  fi

-  # Early help menu
-  menu_init_help
+  printf "Updating systemd services...\n"
+  update_systemd
+  
+  printf "Updating simplex server binaries...\n"
+  update_bins

-  case "${1:-}" in
-    h|help)
-      printf '%b' "$menu_help"
-      exit 0
-      ;;
-  esac
-
-  checks
-  download_all
-  menu_init
-
-  onetime=0
-  while true; do
-    if [ "$onetime" = 0 ]; then
-      onetime=1
-
-      if [ -n "${1:-}" ]; then
-        selection="$1"
-      else
-        printf '%b' "$menu"
-        read selection
-      fi
-    else
-      read selection
-    fi
-    
-    if options_parse "$selection"; then
-      break
-    else
-      # Rerender whole menu if the first non-interactive option was bogus
-      if [ -n "${1:-}" ]; then
-        onetime=0
-        shift 1
-      else
-        # Erase last line
-        printf '\e[A\e[K'
-        # Only rerended selection
-        printf 'Selection: '
-      fi
-    fi
-  done
+  rm -rf "$path_tmp_bin"
 }

 main "$@"
@@ -5,22 +5,11 @@ Description=SMP server
 User=smp
 Group=smp
 Type=simple
-
 ExecStart=/usr/local/bin/smp-server start +RTS -N -RTS 
 ExecStopPost=/usr/local/bin/simplex-servers-stopscript smp-server
-
 LimitNOFILE=65535
 KillSignal=SIGINT
-
-TimeoutStartSec=infinity
 TimeoutStopSec=infinity

-Restart=on-failure
-RestartSec=10s
-StartLimitBurst=3
-StartLimitInterval=60s
-
-AmbientCapabilities=CAP_NET_BIND_SERVICE
-
 [Install]
 WantedBy=multi-user.target
@@ -5,21 +5,11 @@ Description=XFTP server
 User=xftp
 Group=xftp
 Type=simple
-
 ExecStart=/usr/local/bin/xftp-server start +RTS -N -RTS
 ExecStopPost=/usr/local/bin/simplex-servers-stopscript xftp-server
-
 LimitNOFILE=65535
 KillSignal=SIGINT
-
-TimeoutStartSec=infinity
 TimeoutStopSec=infinity
-
-Restart=on-failure
-RestartSec=10s
-StartLimitBurst=3
-StartLimitInterval=60s
-
 AmbientCapabilities=CAP_NET_BIND_SERVICE
   
 [Install]
@@ -1,139 +0,0 @@
-#!/usr/bin/env sh
-set -eu
-
-TAG="$1"
-
-tempdir="$(mktemp -d)"
-init_dir="$PWD"
-
-repo_name="simplexmq"
-repo="https://github.com/simplex-chat/${repo_name}"
-export DOCKER_BUILDKIT=1
-
-cleanup() {
-	docker exec -t builder sh -c 'rm -rf ./dist-newstyle' 2>/dev/null || :
-	rm -rf -- "$tempdir"
-	docker rm --force builder 2>/dev/null || :
-	docker image rm local 2>/dev/null || :
-	cd "$init_dir"
-}
-trap 'cleanup' EXIT INT
-
-mkdir -p "$init_dir/$TAG-$repo_name/from-source" "$init_dir/$TAG-$repo_name/prebuilt"
-
-git -C "$tempdir" clone "$repo.git" &&\
-	cd "$tempdir/${repo_name}" &&\
-	git checkout "$TAG"
-
-for os in 22.04 24.04; do
-	os_url="$(printf '%s' "$os" | tr '.' '_')"
-
-	# Build image
-	docker build \
-		--no-cache \
-		--build-arg TAG=${os} \
-		--build-arg GHC=9.6.3 \
-		-f "$tempdir/simplexmq/Dockerfile.build" \
-		-t local \
-		.
-
-	# Run container in background
-	docker run -t -d \
-		--name builder \
-		-v "$tempdir/${repo_name}:/project" \
-		local
-
-	# PostgreSQL build (only smp-server)
-	docker exec \
-		-t \
-		builder \
-		sh -c 'git config --global --add safe.directory \*; cabal update && cabal build --jobs=$(nproc) --enable-tests -fserver_postgres && mkdir -p /out && for i in smp-server simplexmq-test; do bin=$(find /project/dist-newstyle -name "$i" -type f -executable) && chmod +x "$bin" && mv "$bin" /out/; done && strip /out/smp-server'
-
-	# Copy smp-server postgresql binary and prepare it
-	docker cp \
-		builder:/out/smp-server \
-		"$init_dir/$TAG-$repo_name/from-source/smp-server-postgres-ubuntu-${os_url}-x86-64"
-
-	# Download prebuilt postgresql binary
-	curl -L \
-		--output-dir "$init_dir/$TAG-$repo_name/prebuilt/" \
-		-O \
-		"$repo/releases/download/${TAG}/smp-server-postgres-ubuntu-${os_url}-x86-64"
-	
-	# Regular build (all)
-	apps='smp-server xftp-server ntf-server xftp'
-
-	docker exec \
-		-t \
-		-e apps="$apps" \
-		builder \
-		sh -c 'cabal build --jobs=$(nproc) && mkdir -p /out && for i in $apps; do bin=$(find /project/dist-newstyle -name "$i" -type f -executable) && strip "$bin" && chmod +x "$bin" && mv "$bin" /out/; done'
-
-	# Copy regular binaries
-	docker cp \
-		builder:/out \
-		out-${os}
-	
-	# Prepare regular binaries and download the prebuilt ones
-	for app in $apps; do
-		curl -L \
-			--output-dir "$init_dir/$TAG-$repo_name/prebuilt/" \
-			-O \
-		       	"$repo/releases/download/${TAG}/${app}-ubuntu-${os_url}-x86-64"
-
-		mv "./out-${os}/$app" "$init_dir/$TAG-$repo_name/from-source/${app}-ubuntu-${os_url}-x86-64"
-	done
-
-	# Important! Remove dist-newstyle for the next interation
-	docker exec \
-		-t \
-		builder \
-		sh -c 'rm -rf ./dist-newstyle'
-
-	# Also restore git to previous state 
-	git reset --hard && git clean -dfx
-
-	# Stop containers, delete images
-	docker stop builder
-	docker rm --force builder
-	docker image rm local
-done
-
-# Cleanup
-rm -rf -- "$tempdir"
-cd "$init_dir"
-
-# Final stage: compare hashes
-
-# Path to binaries
-path_bin="$init_dir/$TAG-$repo_name"
-
-# Assume everything is okay for now
-bad=0
-
-# Check hashes for all binaries
-for file in "$path_bin"/from-source/*; do
-	# Extract binary name
-	app="$(basename $file)"
-
-	# Compute hash for compiled binary
-	compiled=$(sha256sum "$path_bin/from-source/$app" | awk '{print $1}')
-	# Compute hash for prebuilt binary
-	prebuilt=$(sha256sum "$path_bin/prebuilt/$app" | awk '{print $1}')
-
-	# Compare
-	if [ "$compiled" != "$prebuilt" ]; then
-		# If hashes doesn't match, set bad...
-		bad=1
-
-		# ... and print affected binary
-		printf "%s - sha256sum hash doesn't match\n" "$app"
-	fi
-done
-
-# If everything is still okay, compute checksums file
-if [ "$bad" = 0 ]; then
-	sha256sum "$path_bin"/from-source/* | sed -e "s|$PWD/||g" -e 's|from-source/||g' -e "s|-$repo_name||g" > "$path_bin/_sha256sums"
-
-	printf 'Checksums computed - %s\n' "$path_bin/_sha256sums"
-fi
@@ -1,7 +1,11 @@
 cabal-version: 1.12

+-- This file has been generated from package.yaml by hpack version 0.35.0.
+--
+-- see: https://github.com/sol/hpack
+
 name:           simplexmq
-version:        6.5.0.3
+version:        6.0.0.7
 synopsis:       SimpleXMQ message broker
 description:    This package includes <./docs/Simplex-Messaging-Server.html server>,
                <./docs/Simplex-Messaging-Client.html client> and
@@ -62,31 +66,24 @@ flag use_crypton
  manual: True
  default: True

-flag client_library
-  description: Don't build server-related code.
-  manual: True
-  default: False
-
-flag client_postgres
-  description: Build with PostgreSQL instead of SQLite.
-  manual: True
-  default: False
-
-flag server_postgres
-  description: Build server with support of PostgreSQL.
-  manual: True
-  default: False
-
 library
  exposed-modules:
      Simplex.FileTransfer.Agent
      Simplex.FileTransfer.Chunks
      Simplex.FileTransfer.Client
      Simplex.FileTransfer.Client.Agent
+      Simplex.FileTransfer.Client.Main
      Simplex.FileTransfer.Client.Presets
      Simplex.FileTransfer.Crypto
      Simplex.FileTransfer.Description
      Simplex.FileTransfer.Protocol
+      Simplex.FileTransfer.Server
+      Simplex.FileTransfer.Server.Control
+      Simplex.FileTransfer.Server.Env
+      Simplex.FileTransfer.Server.Main
+      Simplex.FileTransfer.Server.Stats
+      Simplex.FileTransfer.Server.Store
+      Simplex.FileTransfer.Server.StoreLog
      Simplex.FileTransfer.Transport
      Simplex.FileTransfer.Types
      Simplex.FileTransfer.Util
@@ -100,16 +97,45 @@ library
      Simplex.Messaging.Agent.RetryInterval
      Simplex.Messaging.Agent.Stats
      Simplex.Messaging.Agent.Store
-      Simplex.Messaging.Agent.Store.AgentStore
-      Simplex.Messaging.Agent.Store.Common
-      Simplex.Messaging.Agent.Store.DB
-      Simplex.Messaging.Agent.Store.Entity
-      Simplex.Messaging.Agent.Store.Interface
-      Simplex.Messaging.Agent.Store.Migrations
-      Simplex.Messaging.Agent.Store.Migrations.App
-      Simplex.Messaging.Agent.Store.Postgres.Options
-      Simplex.Messaging.Agent.Store.Shared
-      Simplex.Messaging.Agent.TSessionSubs
+      Simplex.Messaging.Agent.Store.SQLite
+      Simplex.Messaging.Agent.Store.SQLite.Common
+      Simplex.Messaging.Agent.Store.SQLite.DB
+      Simplex.Messaging.Agent.Store.SQLite.Migrations
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220101_initial
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220301_snd_queue_keys
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220322_notifications
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220608_v2
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220625_v2_ntf_mode
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220811_onion_hosts
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220817_connection_ntfs
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220905_commands
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220915_connection_queues
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230110_users
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230117_fkey_indexes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230120_delete_errors
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230217_server_key_hash
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230223_files
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230320_retry_state
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230401_snd_files
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230510_files_pending_replicas_indexes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230516_encrypted_rcv_message_hashes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230531_switch_status
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230615_ratchet_sync
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230701_delivery_receipts
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230720_delete_expired_messages
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230722_indexes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230814_indexes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230829_crypto_files
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20231222_command_created_at
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20231225_failed_work_items
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240121_message_delivery_indexes
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240124_file_redirect
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240223_connections_wait_delivery
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240225_ratchet_kem
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240417_rcv_files_approved_relays
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240624_snd_secure
+      Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240702_servers_stats
+      Simplex.Messaging.Agent.TRcvQueues
      Simplex.Messaging.Client
      Simplex.Messaging.Client.Agent
      Simplex.Messaging.Compression
@@ -122,22 +148,38 @@ library
      Simplex.Messaging.Crypto.SNTRUP761.Bindings.Defines
      Simplex.Messaging.Crypto.SNTRUP761.Bindings.FFI
      Simplex.Messaging.Crypto.SNTRUP761.Bindings.RNG
-      Simplex.Messaging.Crypto.ShortLink
      Simplex.Messaging.Encoding
      Simplex.Messaging.Encoding.String
      Simplex.Messaging.Notifications.Client
      Simplex.Messaging.Notifications.Protocol
+      Simplex.Messaging.Notifications.Server
+      Simplex.Messaging.Notifications.Server.Env
+      Simplex.Messaging.Notifications.Server.Main
+      Simplex.Messaging.Notifications.Server.Push.APNS
+      Simplex.Messaging.Notifications.Server.Push.APNS.Internal
+      Simplex.Messaging.Notifications.Server.Stats
+      Simplex.Messaging.Notifications.Server.Store
+      Simplex.Messaging.Notifications.Server.StoreLog
      Simplex.Messaging.Notifications.Transport
      Simplex.Messaging.Notifications.Types
      Simplex.Messaging.Parsers
      Simplex.Messaging.Protocol
-      Simplex.Messaging.Protocol.Types
+      Simplex.Messaging.Server
+      Simplex.Messaging.Server.CLI
+      Simplex.Messaging.Server.Control
+      Simplex.Messaging.Server.Env.STM
      Simplex.Messaging.Server.Expiration
-      Simplex.Messaging.Server.QueueStore.Postgres.Config
+      Simplex.Messaging.Server.Information
+      Simplex.Messaging.Server.Main
+      Simplex.Messaging.Server.MsgStore
+      Simplex.Messaging.Server.MsgStore.STM
+      Simplex.Messaging.Server.QueueStore
      Simplex.Messaging.Server.QueueStore.QueueInfo
+      Simplex.Messaging.Server.QueueStore.STM
+      Simplex.Messaging.Server.Stats
+      Simplex.Messaging.Server.StoreLog
      Simplex.Messaging.ServiceScheme
      Simplex.Messaging.Session
-      Simplex.Messaging.SystemTime
      Simplex.Messaging.TMap
      Simplex.Messaging.Transport
      Simplex.Messaging.Transport.Buffer
@@ -149,7 +191,7 @@ library
      Simplex.Messaging.Transport.HTTP2.Server
      Simplex.Messaging.Transport.KeepAlive
      Simplex.Messaging.Transport.Server
-      Simplex.Messaging.Transport.Shared
+      Simplex.Messaging.Transport.WebSockets
      Simplex.Messaging.Util
      Simplex.Messaging.Version
      Simplex.Messaging.Version.Internal
@@ -158,132 +200,13 @@ library
      Simplex.RemoteControl.Discovery.Multicast
      Simplex.RemoteControl.Invitation
      Simplex.RemoteControl.Types
-  if flag(client_postgres)
-      exposed-modules:
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.App
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20241210_initial
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250203_msg_bodies
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250322_short_links
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250702_conn_invitations_remove_cascade_delete
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251009_queue_to_subscribe
-          Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251010_client_notices
-  else
-      exposed-modules:
-          Simplex.Messaging.Agent.Store.SQLite
-          Simplex.Messaging.Agent.Store.SQLite.Common
-          Simplex.Messaging.Agent.Store.SQLite.DB
-          Simplex.Messaging.Agent.Store.SQLite.Migrations
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.App
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220101_initial
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220301_snd_queue_keys
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220322_notifications
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220608_v2
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220625_v2_ntf_mode
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220811_onion_hosts
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220817_connection_ntfs
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220905_commands
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20220915_connection_queues
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230110_users
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230117_fkey_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230120_delete_errors
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230217_server_key_hash
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230223_files
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230320_retry_state
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230401_snd_files
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230510_files_pending_replicas_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230516_encrypted_rcv_message_hashes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230531_switch_status
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230615_ratchet_sync
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230701_delivery_receipts
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230720_delete_expired_messages
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230722_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230814_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20230829_crypto_files
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20231222_command_created_at
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20231225_failed_work_items
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240121_message_delivery_indexes
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240124_file_redirect
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240223_connections_wait_delivery
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240225_ratchet_kem
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240417_rcv_files_approved_relays
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240624_snd_secure
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240702_servers_stats
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20240930_ntf_tokens_to_delete
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20241007_rcv_queues_last_broker_ts
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20241224_ratchet_e2e_snd_params
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20250203_msg_bodies
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20250322_short_links
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20250702_conn_invitations_remove_cascade_delete
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20251009_queue_to_subscribe
-          Simplex.Messaging.Agent.Store.SQLite.Migrations.M20251010_client_notices
-  if flag(client_postgres) || flag(server_postgres)
-      exposed-modules:
-          Simplex.Messaging.Agent.Store.Postgres
-          Simplex.Messaging.Agent.Store.Postgres.Common
-          Simplex.Messaging.Agent.Store.Postgres.DB
-          Simplex.Messaging.Agent.Store.Postgres.Migrations
-          Simplex.Messaging.Agent.Store.Postgres.Util
-  if !flag(client_library)
-      exposed-modules:
-          Simplex.FileTransfer.Client.Main
-          Simplex.FileTransfer.Server
-          Simplex.FileTransfer.Server.Control
-          Simplex.FileTransfer.Server.Env
-          Simplex.FileTransfer.Server.Main
-          Simplex.FileTransfer.Server.Prometheus
-          Simplex.FileTransfer.Server.Stats
-          Simplex.FileTransfer.Server.Store
-          Simplex.FileTransfer.Server.StoreLog
-          Simplex.Messaging.Server
-          Simplex.Messaging.Server.CLI
-          Simplex.Messaging.Server.Control
-          Simplex.Messaging.Server.Env.STM
-          Simplex.Messaging.Server.Information
-          Simplex.Messaging.Server.Main
-          Simplex.Messaging.Server.Main.GitCommit
-          Simplex.Messaging.Server.Main.Init
-          Simplex.Messaging.Server.MsgStore
-          Simplex.Messaging.Server.MsgStore.Journal
-          Simplex.Messaging.Server.MsgStore.Journal.SharedLock
-          Simplex.Messaging.Server.MsgStore.STM
-          Simplex.Messaging.Server.MsgStore.Types
-          Simplex.Messaging.Server.NtfStore
-          Simplex.Messaging.Server.Prometheus
-          Simplex.Messaging.Server.QueueStore
-          Simplex.Messaging.Server.QueueStore.STM
-          Simplex.Messaging.Server.QueueStore.Types
-          Simplex.Messaging.Server.Stats
-          Simplex.Messaging.Server.StoreLog
-          Simplex.Messaging.Server.StoreLog.ReadWrite
-          Simplex.Messaging.Server.StoreLog.Types
-          Simplex.Messaging.Transport.WebSockets
-      if flag(server_postgres)
-          exposed-modules:
-              Simplex.Messaging.Notifications.Server
-              Simplex.Messaging.Notifications.Server.Control
-              Simplex.Messaging.Notifications.Server.Env
-              Simplex.Messaging.Notifications.Server.Main
-              Simplex.Messaging.Notifications.Server.Prometheus
-              Simplex.Messaging.Notifications.Server.Push
-              Simplex.Messaging.Notifications.Server.Push.APNS
-              Simplex.Messaging.Notifications.Server.Push.WebPush
-              Simplex.Messaging.Notifications.Server.Push.APNS.Internal
-              Simplex.Messaging.Notifications.Server.Stats
-              Simplex.Messaging.Notifications.Server.Store
-              Simplex.Messaging.Notifications.Server.Store.Migrations
-              Simplex.Messaging.Notifications.Server.Store.Postgres
-              Simplex.Messaging.Notifications.Server.Store.Types
-              Simplex.Messaging.Notifications.Server.StoreLog
-              Simplex.Messaging.Server.MsgStore.Postgres
-              Simplex.Messaging.Server.QueueStore.Postgres
-              Simplex.Messaging.Server.QueueStore.Postgres.Migrations
  other-modules:
      Paths_simplexmq
  hs-source-dirs:
      src
  default-extensions:
      StrictData
-  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-home-modules -Werror=missing-methods -Werror=tabs -Wredundant-constraints -Wincomplete-record-updates -Wunused-type-patterns -O2
+  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-unused-packages -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
  include-dirs:
      cbits
  c-sources:
@@ -293,29 +216,30 @@ library
      crypto
  build-depends:
      aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
    , asn1-encoding ==0.9.*
    , asn1-types ==0.3.*
    , async ==2.2.*
    , attoparsec ==0.14.*
    , base >=4.14 && <5
    , base64-bytestring >=1.0 && <1.3
-    , binary ==0.8.*
+    , case-insensitive ==1.2.*
    , composition ==1.0.*
    , constraints >=0.12 && <0.14
    , containers ==0.6.*
    , crypton ==0.34.*
    , crypton-x509 ==1.7.*
-    , crypton-x509-system ==1.6.*
    , crypton-x509-store ==1.6.*
    , crypton-x509-validation ==1.6.*
    , cryptostore ==0.3.*
    , data-default ==0.7.*
+    , direct-sqlcipher ==2.3.*
    , directory ==1.3.*
    , filepath ==1.4.*
    , hourglass ==0.2.*
-    , http-client ==0.7.*
    , http-types ==0.12.*
    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
    , iproute ==1.7.*
    , iso8601-time ==0.1.*
    , memory ==0.18.*
@@ -324,47 +248,26 @@ library
    , network-info ==0.2.*
    , network-transport ==0.5.6
    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
    , random >=1.1 && <1.3
-    , scientific ==0.3.7.*
    , simple-logger ==0.1.*
    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
    , stm ==2.5.*
+    , temporary ==1.3.*
    , time ==1.12.*
    , time-manager ==0.0.*
-    , tls >=1.9.0 && <1.10
+    , tls >=1.7.0 && <1.8
    , transformers ==0.6.*
    , unliftio ==0.2.*
    , unliftio-core ==0.2.*
+    , websockets ==0.12.*
    , yaml ==0.11.*
    , zstd ==0.1.3.*
  default-language: Haskell2010
  if flag(swift)
    cpp-options: -DswiftJSON
-  if !flag(client_library)
-    build-depends:
-        case-insensitive ==1.2.*
-      , hashable ==1.4.*
-      , ini ==0.4.1
-      , http-client-tls ==0.3.6.*
-      , optparse-applicative >=0.15 && <0.17
-      , process ==1.6.*
-      , temporary ==1.3.*
-      , websockets ==0.12.*
-  if flag(client_postgres) || flag(server_postgres)
-    build-depends:
-        postgresql-libpq >=0.10.0.0
-      , postgresql-simple ==0.7.*
-      , raw-strings-qq ==1.1.*
-  if flag(client_postgres)
-    cpp-options: -DdbPostgres
-  else
-    build-depends:
-        direct-sqlcipher ==2.3.*
-      , sqlcipher-simple ==0.4.*
-  if flag(server_postgres)
-    cpp-options: -DdbServerPostgres
-    build-depends:
-        hex-text ==0.1.*
  if impl(ghc >= 9.6.2)
    build-depends:
        bytestring ==0.11.*
@@ -377,12 +280,6 @@ library
      , text >=1.2.3.0 && <1.3

 executable ntf-server
-  if flag(client_library)
-      buildable: False
-  if flag(server_postgres)
-    cpp-options: -DdbServerPostgres
-  else
-    buildable: False
  main-is: Main.hs
  other-modules:
      Paths_simplexmq
@@ -390,18 +287,74 @@ executable ntf-server
      apps/ntf-server
  default-extensions:
      StrictData
-  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
+  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-unused-packages -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
  build-depends:
-      base
-    , simple-logger
+      aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
+    , asn1-encoding ==0.9.*
+    , asn1-types ==0.3.*
+    , async ==2.2.*
+    , attoparsec ==0.14.*
+    , base >=4.14 && <5
+    , base64-bytestring >=1.0 && <1.3
+    , case-insensitive ==1.2.*
+    , composition ==1.0.*
+    , constraints >=0.12 && <0.14
+    , containers ==0.6.*
+    , crypton ==0.34.*
+    , crypton-x509 ==1.7.*
+    , crypton-x509-store ==1.6.*
+    , crypton-x509-validation ==1.6.*
+    , cryptostore ==0.3.*
+    , data-default ==0.7.*
+    , direct-sqlcipher ==2.3.*
+    , directory ==1.3.*
+    , filepath ==1.4.*
+    , hourglass ==0.2.*
+    , http-types ==0.12.*
+    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
+    , iproute ==1.7.*
+    , iso8601-time ==0.1.*
+    , memory ==0.18.*
+    , mtl >=2.3.1 && <3.0
+    , network >=3.1.2.7 && <3.2
+    , network-info ==0.2.*
+    , network-transport ==0.5.6
+    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
+    , random >=1.1 && <1.3
+    , simple-logger ==0.1.*
    , simplexmq
+    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
+    , stm ==2.5.*
+    , temporary ==1.3.*
+    , time ==1.12.*
+    , time-manager ==0.0.*
+    , tls >=1.7.0 && <1.8
+    , transformers ==0.6.*
+    , unliftio ==0.2.*
+    , unliftio-core ==0.2.*
+    , websockets ==0.12.*
+    , yaml ==0.11.*
+    , zstd ==0.1.3.*
  default-language: Haskell2010
+  if flag(swift)
+    cpp-options: -DswiftJSON
+  if impl(ghc >= 9.6.2)
+    build-depends:
+        bytestring ==0.11.*
+      , template-haskell ==2.20.*
+      , text >=2.0.1 && <2.2
+  if impl(ghc < 9.6.2)
+    build-depends:
+        bytestring ==0.10.*
+      , template-haskell ==2.16.*
+      , text >=1.2.3.0 && <1.3

 executable smp-server
-  if flag(client_library)
-      buildable: False
-  if flag(server_postgres)
-    cpp-options: -DdbServerPostgres
  main-is: Main.hs
  other-modules:
      Static
@@ -412,27 +365,78 @@ executable smp-server
      apps/smp-server/web
  default-extensions:
      StrictData
-  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
+  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-unused-packages -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
  build-depends:
-      base
-    , bytestring
-    , directory
+      aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
+    , asn1-encoding ==0.9.*
+    , asn1-types ==0.3.*
+    , async ==2.2.*
+    , attoparsec ==0.14.*
+    , base >=4.14 && <5
+    , base64-bytestring >=1.0 && <1.3
+    , case-insensitive ==1.2.*
+    , composition ==1.0.*
+    , constraints >=0.12 && <0.14
+    , containers ==0.6.*
+    , crypton ==0.34.*
+    , crypton-x509 ==1.7.*
+    , crypton-x509-store ==1.6.*
+    , crypton-x509-validation ==1.6.*
+    , cryptostore ==0.3.*
+    , data-default ==0.7.*
+    , direct-sqlcipher ==2.3.*
+    , directory ==1.3.*
    , file-embed
-    , filepath
-    , network
-    , simple-logger
+    , filepath ==1.4.*
+    , hourglass ==0.2.*
+    , http-types ==0.12.*
+    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
+    , iproute ==1.7.*
+    , iso8601-time ==0.1.*
+    , memory ==0.18.*
+    , mtl >=2.3.1 && <3.0
+    , network >=3.1.2.7 && <3.2
+    , network-info ==0.2.*
+    , network-transport ==0.5.6
+    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
+    , random >=1.1 && <1.3
+    , simple-logger ==0.1.*
    , simplexmq
-    , text
-    , unliftio
-    , wai
+    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
+    , stm ==2.5.*
+    , temporary ==1.3.*
+    , time ==1.12.*
+    , time-manager ==0.0.*
+    , tls >=1.7.0 && <1.8
+    , transformers ==0.6.*
+    , unliftio ==0.2.*
+    , unliftio-core ==0.2.*
    , wai-app-static
-    , warp ==3.3.30
-    , warp-tls ==3.4.7
+    , warp
+    , warp-tls
+    , websockets ==0.12.*
+    , yaml ==0.11.*
+    , zstd ==0.1.3.*
  default-language: Haskell2010
+  if flag(swift)
+    cpp-options: -DswiftJSON
+  if impl(ghc >= 9.6.2)
+    build-depends:
+        bytestring ==0.11.*
+      , template-haskell ==2.20.*
+      , text >=2.0.1 && <2.2
+  if impl(ghc < 9.6.2)
+    build-depends:
+        bytestring ==0.10.*
+      , template-haskell ==2.16.*
+      , text >=1.2.3.0 && <1.3

 executable xftp
-  if flag(client_library)
-      buildable: False
  main-is: Main.hs
  other-modules:
      Paths_simplexmq
@@ -440,15 +444,74 @@ executable xftp
      apps/xftp
  default-extensions:
      StrictData
-  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
+  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-unused-packages -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
  build-depends:
-      base
+      aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
+    , asn1-encoding ==0.9.*
+    , asn1-types ==0.3.*
+    , async ==2.2.*
+    , attoparsec ==0.14.*
+    , base >=4.14 && <5
+    , base64-bytestring >=1.0 && <1.3
+    , case-insensitive ==1.2.*
+    , composition ==1.0.*
+    , constraints >=0.12 && <0.14
+    , containers ==0.6.*
+    , crypton ==0.34.*
+    , crypton-x509 ==1.7.*
+    , crypton-x509-store ==1.6.*
+    , crypton-x509-validation ==1.6.*
+    , cryptostore ==0.3.*
+    , data-default ==0.7.*
+    , direct-sqlcipher ==2.3.*
+    , directory ==1.3.*
+    , filepath ==1.4.*
+    , hourglass ==0.2.*
+    , http-types ==0.12.*
+    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
+    , iproute ==1.7.*
+    , iso8601-time ==0.1.*
+    , memory ==0.18.*
+    , mtl >=2.3.1 && <3.0
+    , network >=3.1.2.7 && <3.2
+    , network-info ==0.2.*
+    , network-transport ==0.5.6
+    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
+    , random >=1.1 && <1.3
+    , simple-logger ==0.1.*
    , simplexmq
+    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
+    , stm ==2.5.*
+    , temporary ==1.3.*
+    , time ==1.12.*
+    , time-manager ==0.0.*
+    , tls >=1.7.0 && <1.8
+    , transformers ==0.6.*
+    , unliftio ==0.2.*
+    , unliftio-core ==0.2.*
+    , websockets ==0.12.*
+    , yaml ==0.11.*
+    , zstd ==0.1.3.*
  default-language: Haskell2010
+  if flag(swift)
+    cpp-options: -DswiftJSON
+  if impl(ghc >= 9.6.2)
+    build-depends:
+        bytestring ==0.11.*
+      , template-haskell ==2.20.*
+      , text >=2.0.1 && <2.2
+  if impl(ghc < 9.6.2)
+    build-depends:
+        bytestring ==0.10.*
+      , template-haskell ==2.16.*
+      , text >=1.2.3.0 && <1.3

 executable xftp-server
-  if flag(client_library)
-      buildable: False
  main-is: Main.hs
  other-modules:
      Paths_simplexmq
@@ -456,16 +519,74 @@ executable xftp-server
      apps/xftp-server
  default-extensions:
      StrictData
-  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
+  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-unused-packages -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
  build-depends:
-      base
-    , simple-logger
+      aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
+    , asn1-encoding ==0.9.*
+    , asn1-types ==0.3.*
+    , async ==2.2.*
+    , attoparsec ==0.14.*
+    , base >=4.14 && <5
+    , base64-bytestring >=1.0 && <1.3
+    , case-insensitive ==1.2.*
+    , composition ==1.0.*
+    , constraints >=0.12 && <0.14
+    , containers ==0.6.*
+    , crypton ==0.34.*
+    , crypton-x509 ==1.7.*
+    , crypton-x509-store ==1.6.*
+    , crypton-x509-validation ==1.6.*
+    , cryptostore ==0.3.*
+    , data-default ==0.7.*
+    , direct-sqlcipher ==2.3.*
+    , directory ==1.3.*
+    , filepath ==1.4.*
+    , hourglass ==0.2.*
+    , http-types ==0.12.*
+    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
+    , iproute ==1.7.*
+    , iso8601-time ==0.1.*
+    , memory ==0.18.*
+    , mtl >=2.3.1 && <3.0
+    , network >=3.1.2.7 && <3.2
+    , network-info ==0.2.*
+    , network-transport ==0.5.6
+    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
+    , random >=1.1 && <1.3
+    , simple-logger ==0.1.*
    , simplexmq
+    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
+    , stm ==2.5.*
+    , temporary ==1.3.*
+    , time ==1.12.*
+    , time-manager ==0.0.*
+    , tls >=1.7.0 && <1.8
+    , transformers ==0.6.*
+    , unliftio ==0.2.*
+    , unliftio-core ==0.2.*
+    , websockets ==0.12.*
+    , yaml ==0.11.*
+    , zstd ==0.1.3.*
  default-language: Haskell2010
+  if flag(swift)
+    cpp-options: -DswiftJSON
+  if impl(ghc >= 9.6.2)
+    build-depends:
+        bytestring ==0.11.*
+      , template-haskell ==2.20.*
+      , text >=2.0.1 && <2.2
+  if impl(ghc < 9.6.2)
+    build-depends:
+        bytestring ==0.10.*
+      , template-haskell ==2.16.*
+      , text >=1.2.3.0 && <1.3

 test-suite simplexmq-test
-  if flag(client_library)
-      buildable: False
  type: exitcode-stdio-1.0
  main-is: Test.hs
  other-modules:
@@ -475,21 +596,21 @@ test-suite simplexmq-test
      AgentTests.EqInstances
      AgentTests.FunctionalAPITests
      AgentTests.MigrationTests
-      AgentTests.ServerChoice
-      AgentTests.ShortLinkTests
+      AgentTests.NotificationTests
+      AgentTests.SchemaDump
+      AgentTests.SQLiteTests
      CLITests
      CoreTests.BatchingTests
      CoreTests.CryptoFileTests
      CoreTests.CryptoTests
      CoreTests.EncodingTests
-      CoreTests.MsgStoreTests
      CoreTests.RetryIntervalTests
-      CoreTests.SOCKSSettings
-      CoreTests.StoreLogTests
-      CoreTests.TSessionSubs
+      CoreTests.TRcvQueuesTests
      CoreTests.UtilTests
      CoreTests.VersionRangeTests
      FileDescriptionTests
+      NtfClient
+      NtfServerTests
      RemoteControl
      ServerTests
      SMPAgentClient
@@ -500,88 +621,83 @@ test-suite simplexmq-test
      XFTPCLI
      XFTPClient
      XFTPServerTests
-      Static
-      Static.Embedded
      Paths_simplexmq
-  if flag(client_postgres)
-      other-modules:
-          Fixtures
-  else
-      other-modules:
-          AgentTests.SchemaDump
-          AgentTests.SQLiteTests
-  if flag(server_postgres)
-      other-modules:
-          AgentTests.NotificationTests
-          NtfClient
-          NtfServerTests
-          NtfWPTests
-          PostgresSchemaDump
  hs-source-dirs:
      tests
-      apps/smp-server/web
  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 -with-rtsopts=-N1
+  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-unused-packages -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
-    , async
-    , base64-bytestring
-    , bytestring
-    , containers
-    , crypton
-    , crypton-x509
-    , crypton-x509-store
-    , crypton-x509-validation
-    , directory
-    , file-embed
-    , filepath
+      HUnit ==1.6.*
+    , QuickCheck ==2.14.*
+    , aeson ==2.2.*
+    , ansi-terminal >=0.10 && <0.12
+    , asn1-encoding ==0.9.*
+    , asn1-types ==0.3.*
+    , async ==2.2.*
+    , attoparsec ==0.14.*
+    , base >=4.14 && <5
+    , base64-bytestring >=1.0 && <1.3
+    , case-insensitive ==1.2.*
+    , composition ==1.0.*
+    , constraints >=0.12 && <0.14
+    , containers ==0.6.*
+    , crypton ==0.34.*
+    , crypton-x509 ==1.7.*
+    , crypton-x509-store ==1.6.*
+    , crypton-x509-validation ==1.6.*
+    , cryptostore ==0.3.*
+    , data-default ==0.7.*
+    , deepseq ==1.4.*
+    , direct-sqlcipher ==2.3.*
+    , directory ==1.3.*
+    , filepath ==1.4.*
    , generic-random ==1.5.*
-    , hashable
+    , hourglass ==0.2.*
    , hspec ==2.11.*
    , hspec-core ==2.11.*
-    , http-client
-    , http-types
-    , http2
-    , HUnit ==1.6.*
-    , ini
-    , iso8601-time
+    , http-types ==0.12.*
+    , http2 >=4.2.2 && <4.3
+    , ini ==0.4.1
+    , iproute ==1.7.*
+    , iso8601-time ==0.1.*
    , main-tester ==0.2.*
-    , mtl
-    , network
-    , QuickCheck ==2.14.*
-    , random
+    , memory ==0.18.*
+    , mtl >=2.3.1 && <3.0
+    , network >=3.1.2.7 && <3.2
+    , network-info ==0.2.*
+    , network-transport ==0.5.6
+    , network-udp ==0.0.*
+    , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
+    , random >=1.1 && <1.3
    , silently ==1.2.*
-    , simple-logger
+    , simple-logger ==0.1.*
    , simplexmq
-    , stm
-    , text
-    , time
+    , socks ==0.6.*
+    , sqlcipher-simple ==0.4.*
+    , stm ==2.5.*
+    , temporary ==1.3.*
+    , time ==1.12.*
+    , time-manager ==0.0.*
    , timeit ==2.0.*
-    , transformers
-    , unliftio
-    , unliftio-core
-    , unordered-containers
-    , wai
-    , wai-app-static
-    , warp
-    , warp-tls
-    , yaml
+    , tls >=1.7.0 && <1.8
+    , transformers ==0.6.*
+    , unliftio ==0.2.*
+    , unliftio-core ==0.2.*
+    , websockets ==0.12.*
+    , yaml ==0.11.*
+    , zstd ==0.1.3.*
  default-language: Haskell2010
-  if flag(server_postgres)
-    cpp-options: -DdbServerPostgres
-  if flag(client_postgres)
-    cpp-options: -DdbPostgres
-  else
+  if flag(swift)
+    cpp-options: -DswiftJSON
+  if impl(ghc >= 9.6.2)
    build-depends:
-        memory
-      , sqlcipher-simple
-  if !flag(client_postgres) || flag(client_postgres) || flag(server_postgres)
+        bytestring ==0.11.*
+      , template-haskell ==2.20.*
+      , text >=2.0.1 && <2.2
+  if impl(ghc < 9.6.2)
    build-depends:
-        deepseq ==1.4.*
-      , process
-  if flag(client_postgres) || flag(server_postgres)
-    build-depends:
-        postgresql-simple ==0.7.*
+        bytestring ==0.10.*
+      , template-haskell ==2.16.*
+      , text >=1.2.3.0 && <1.3
@@ -45,13 +45,14 @@ import Data.List (foldl', partition, sortOn)
 import qualified Data.List.NonEmpty as L
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
-import Data.Maybe (fromMaybe, mapMaybe)
+import Data.Maybe (mapMaybe)
 import qualified Data.Set as S
 import Data.Text (Text)
 import Data.Time.Clock (getCurrentTime)
 import Data.Time.Format (defaultTimeLocale, formatTime)
 import Simplex.FileTransfer.Chunks (toKB)
-import Simplex.FileTransfer.Client (XFTPChunkSpec (..), getChunkDigest, prepareChunkSizes, prepareChunkSpecs, singleChunkSize)
+import Simplex.FileTransfer.Client (XFTPChunkSpec (..))
+import Simplex.FileTransfer.Client.Main
 import Simplex.FileTransfer.Crypto
 import Simplex.FileTransfer.Description
 import Simplex.FileTransfer.Protocol (FileParty (..), SFileParty (..))
@@ -65,17 +66,17 @@ import Simplex.Messaging.Agent.Env.SQLite
 import Simplex.Messaging.Agent.Protocol
 import Simplex.Messaging.Agent.RetryInterval
 import Simplex.Messaging.Agent.Stats
-import Simplex.Messaging.Agent.Store.AgentStore
-import qualified Simplex.Messaging.Agent.Store.DB as DB
+import Simplex.Messaging.Agent.Store.SQLite
+import qualified Simplex.Messaging.Agent.Store.SQLite.DB as DB
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.File (CryptoFile (..), CryptoFileArgs)
 import qualified Simplex.Messaging.Crypto.File as CF
 import qualified Simplex.Messaging.Crypto.Lazy as LC
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String (strDecode, strEncode)
-import Simplex.Messaging.Protocol (ProtocolServer, ProtocolType (..), XFTPServer)
+import Simplex.Messaging.Protocol (EntityId, ProtocolServer, ProtocolType (..), XFTPServer)
 import qualified Simplex.Messaging.TMap as TM
-import Simplex.Messaging.Util (allFinally, catchAll_, catchAllErrors, liftError, tshow, unlessM, whenM)
+import Simplex.Messaging.Util (catchAll_, liftError, tshow, unlessM, whenM)
 import System.FilePath (takeFileName, (</>))
 import UnliftIO
 import UnliftIO.Directory
@@ -189,20 +190,19 @@ runXFTPRcvWorker c srv Worker {doWork} = do
    runXFTPOperation :: AgentConfig -> AM ()
    runXFTPOperation AgentConfig {rcvFilesTTL, reconnectInterval = ri, xftpConsecutiveRetries} =
      withWork c doWork (\db -> getNextRcvChunkToDownload db srv rcvFilesTTL) $ \case
-        (RcvFileChunk {rcvFileId, rcvFileEntityId, fileTmpPath, replicas = []}, _, redirectEntityId_) ->
-          rcvWorkerInternalError c rcvFileId rcvFileEntityId redirectEntityId_ (Just fileTmpPath) (INTERNAL "chunk has no replicas")
-        (fc@RcvFileChunk {userId, rcvFileId, rcvFileEntityId, digest, fileTmpPath, replicas = replica@RcvFileChunkReplica {rcvChunkReplicaId, server, delay} : _}, approvedRelays, redirectEntityId_) -> do
+        (RcvFileChunk {rcvFileId, rcvFileEntityId, fileTmpPath, replicas = []}, _) -> rcvWorkerInternalError c rcvFileId rcvFileEntityId (Just fileTmpPath) (INTERNAL "chunk has no replicas")
+        (fc@RcvFileChunk {userId, rcvFileId, rcvFileEntityId, digest, fileTmpPath, replicas = replica@RcvFileChunkReplica {rcvChunkReplicaId, server, delay} : _}, approvedRelays) -> do
          let ri' = maybe ri (\d -> ri {initialInterval = d, increaseAfter = 0}) delay
          withRetryIntervalLimit xftpConsecutiveRetries ri' $ \delay' loop -> do
            liftIO $ waitWhileSuspended c
            liftIO $ waitForUserNetwork c
            atomically $ incXFTPServerStat c userId srv downloadAttempts
            downloadFileChunk fc replica approvedRelays
-              `catchAllErrors` \e -> retryOnError "XFTP rcv worker" (retryLoop loop e delay') (retryDone e) e
+              `catchAgentError` \e -> retryOnError "XFTP rcv worker" (retryLoop loop e delay') (retryDone e) e
          where
            retryLoop loop e replicaDelay = do
-              flip catchAllErrors (\_ -> pure ()) $ do
-                when (serverHostError e) $ notify c (fromMaybe rcvFileEntityId redirectEntityId_) (RFWARN e)
+              flip catchAgentError (\_ -> pure ()) $ do
+                when (serverHostError e) $ notify c rcvFileEntityId $ RFWARN e
                liftIO $ closeXFTPServerClient c userId server digest
                withStore' c $ \db -> updateRcvChunkReplicaDelay db rcvChunkReplicaId replicaDelay
              liftIO $ assertAgentForeground c
@@ -211,7 +211,7 @@ runXFTPRcvWorker c srv Worker {doWork} = do
              atomically . incXFTPServerStat c userId srv $ case e of
                XFTP _ XFTP.AUTH -> downloadAuthErrs
                _ -> downloadErrs
-              rcvWorkerInternalError c rcvFileId rcvFileEntityId redirectEntityId_ (Just fileTmpPath) e
+              rcvWorkerInternalError c rcvFileId rcvFileEntityId (Just fileTmpPath) e
    downloadFileChunk :: RcvFileChunk -> RcvFileChunkReplica -> Bool -> AM ()
    downloadFileChunk RcvFileChunk {userId, rcvFileId, rcvFileEntityId, rcvChunkId, chunkNo, chunkSize, digest, fileTmpPath} replica approvedRelays = do
      unlessM ((approvedRelays ||) <$> ipAddressProtected') $ throwE $ FILE NOT_APPROVED
@@ -262,11 +262,11 @@ retryOnError name loop done e = do
    then loop
    else done

-rcvWorkerInternalError :: AgentClient -> DBRcvFileId -> RcvFileId -> Maybe RcvFileId -> Maybe FilePath -> AgentErrorType -> AM ()
-rcvWorkerInternalError c rcvFileId rcvFileEntityId redirectEntityId_ tmpPath err = do
+rcvWorkerInternalError :: AgentClient -> DBRcvFileId -> RcvFileId -> Maybe FilePath -> AgentErrorType -> AM ()
+rcvWorkerInternalError c rcvFileId rcvFileEntityId tmpPath err = do
  lift $ forM_ tmpPath (removePath <=< toFSFilePath)
  withStore' c $ \db -> updateRcvFileError db rcvFileId (show err)
-  notify c (fromMaybe rcvFileEntityId redirectEntityId_) (RFERR err)
+  notify c rcvFileEntityId $ RFERR err

 runXFTPRcvLocalWorker :: AgentClient -> Worker -> AM ()
 runXFTPRcvLocalWorker c Worker {doWork} = do
@@ -279,8 +279,8 @@ runXFTPRcvLocalWorker c Worker {doWork} = do
    runXFTPOperation :: AgentConfig -> AM ()
    runXFTPOperation AgentConfig {rcvFilesTTL} =
      withWork c doWork (`getNextRcvFileToDecrypt` rcvFilesTTL) $
-        \f@RcvFile {rcvFileId, rcvFileEntityId, tmpPath, redirect} ->
-          decryptFile f `catchAllErrors` rcvWorkerInternalError c rcvFileId rcvFileEntityId (redirectEntityId <$> redirect) tmpPath
+        \f@RcvFile {rcvFileId, rcvFileEntityId, tmpPath} ->
+          decryptFile f `catchAgentError` rcvWorkerInternalError c rcvFileId rcvFileEntityId tmpPath
    decryptFile :: RcvFile -> AM ()
    decryptFile RcvFile {rcvFileId, rcvFileEntityId, size, digest, key, nonce, tmpPath, saveFile, status, chunks, redirect} = do
      let CryptoFile savePath cfArgs = saveFile
@@ -307,7 +307,7 @@ runXFTPRcvLocalWorker c Worker {doWork} = do
          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)
+          yaml <- liftError (FILE . FILE_IO . show) (CF.readFile $ CryptoFile fsSavePath cfArgs) `agentFinally` (lift $ toFSFilePath fsSavePath >>= removePath)
          next@FileDescription {chunks = nextChunks} <- case strDecode (LB.toStrict yaml) of
            -- TODO switch to another error constructor
            Left _ -> throwE . FILE $ REDIRECT "decode error"
@@ -346,7 +346,7 @@ xftpDeleteRcvFiles' c rcvFileEntityIds = do
    batchFiles :: (DB.Connection -> DBRcvFileId -> IO a) -> [RcvFile] -> AM' [Either AgentErrorType a]
    batchFiles f rcvFiles = withStoreBatch' c $ \db -> map (\RcvFile {rcvFileId} -> f db rcvFileId) rcvFiles

-notify :: forall m e. (MonadIO m, AEntityI e) => AgentClient -> AEntityId -> AEvent e -> m ()
+notify :: forall m e. (MonadIO m, AEntityI e) => AgentClient -> EntityId -> AEvent e -> m ()
 notify c entId cmd = atomically $ writeTBQueue (subQ c) ("", entId, AEvt (sAEntity @e) cmd)

 xftpSendFile' :: AgentClient -> UserId -> CryptoFile -> Int -> AM SndFileId
@@ -399,7 +399,7 @@ runXFTPSndPrepareWorker c Worker {doWork} = do
    runXFTPOperation cfg@AgentConfig {sndFilesTTL} =
      withWork c doWork (`getNextSndFileToPrepare` sndFilesTTL) $
        \f@SndFile {sndFileId, sndFileEntityId, prefixPath} ->
-          prepareFile cfg f `catchAllErrors` sndWorkerInternalError c sndFileId sndFileEntityId prefixPath
+          prepareFile cfg f `catchAgentError` sndWorkerInternalError c sndFileId sndFileEntityId prefixPath
    prepareFile :: AgentConfig -> SndFile -> AM ()
    prepareFile _ SndFile {prefixPath = Nothing} =
      throwE $ INTERNAL "no prefix path"
@@ -460,26 +460,26 @@ runXFTPSndPrepareWorker c Worker {doWork} = do
          pure srv
          where
            tryCreate = do
-              triedHosts <- newTVarIO S.empty
+              usedSrvs <- newTVarIO ([] :: [XFTPServer])
              let AgentClient {xftpServers} = c
              userSrvCount <- liftIO $ length <$> TM.lookupIO userId xftpServers
              withRetryIntervalCount (riFast ri) $ \n _ loop -> do
                liftIO $ waitWhileSuspended c
                liftIO $ waitForUserNetwork c
                let triedAllSrvs = n > userSrvCount
-                createWithNextSrv triedHosts
-                  `catchAllErrors` \e -> retryOnError "XFTP prepare worker" (retryLoop loop triedAllSrvs e) (throwE e) e
+                createWithNextSrv usedSrvs
+                  `catchAgentError` \e -> retryOnError "XFTP prepare worker" (retryLoop loop triedAllSrvs e) (throwE e) e
              where
                -- we don't do closeXFTPServerClient here to not risk closing connection for concurrent chunk upload
                retryLoop loop triedAllSrvs e = do
-                  flip catchAllErrors (\_ -> pure ()) $ do
+                  flip catchAgentError (\_ -> pure ()) $ do
                    when (triedAllSrvs && serverHostError e) $ notify c sndFileEntityId $ SFWARN e
                  liftIO $ assertAgentForeground c
                  loop
-            createWithNextSrv triedHosts = do
+            createWithNextSrv usedSrvs = do
              deleted <- withStore' c $ \db -> getSndFileDeleted db sndFileId
              when deleted $ throwE $ FILE NO_FILE
-              withNextSrv c userId storageSrvs triedHosts [] $ \srvAuth -> do
+              withNextSrv c userId usedSrvs [] $ \srvAuth -> do
                replica <- agentXFTPNewChunk c ch numRecipients' srvAuth
                pure (replica, srvAuth)

@@ -508,10 +508,10 @@ runXFTPSndWorker c srv Worker {doWork} = do
            liftIO $ waitForUserNetwork c
            atomically $ incXFTPServerStat c userId srv uploadAttempts
            uploadFileChunk cfg fc replica
-              `catchAllErrors` \e -> retryOnError "XFTP snd worker" (retryLoop loop e delay') (retryDone e) e
+              `catchAgentError` \e -> retryOnError "XFTP snd worker" (retryLoop loop e delay') (retryDone e) e
          where
            retryLoop loop e replicaDelay = do
-              flip catchAllErrors (\_ -> pure ()) $ do
+              flip catchAgentError (\_ -> pure ()) $ do
                when (serverHostError e) $ notify c sndFileEntityId $ SFWARN e
                liftIO $ closeXFTPServerClient c userId server digest
                withStore' c $ \db -> updateSndChunkReplicaDelay db sndChunkReplicaId replicaDelay
@@ -545,8 +545,8 @@ runXFTPSndWorker c srv Worker {doWork} = do
        withStore' c $ \db -> updateSndFileComplete db sndFileId
      where
        addRecipients :: SndFileChunk -> SndFileChunkReplica -> AM SndFileChunkReplica
-        addRecipients ch@SndFileChunk {numRecipients} cr@SndFileChunkReplica {sndChunkReplicaId, rcvIdsKeys}
-          | length rcvIdsKeys > numRecipients = throwE $ INTERNAL ("too many recipients, sndChunkReplicaId = " <> show sndChunkReplicaId)
+        addRecipients ch@SndFileChunk {numRecipients} cr@SndFileChunkReplica {rcvIdsKeys}
+          | length rcvIdsKeys > numRecipients = throwE $ INTERNAL "too many recipients"
          | length rcvIdsKeys == numRecipients = pure cr
          | otherwise = do
              let numRecipients' = min (numRecipients - length rcvIdsKeys) maxRecipients
@@ -681,10 +681,10 @@ runXFTPDelWorker c srv Worker {doWork} = do
            liftIO $ waitForUserNetwork c
            atomically $ incXFTPServerStat c userId srv deleteAttempts
            deleteChunkReplica
-              `catchAllErrors` \e -> retryOnError "XFTP del worker" (retryLoop loop e delay') (retryDone e) e
+              `catchAgentError` \e -> retryOnError "XFTP del worker" (retryLoop loop e delay') (retryDone e) e
          where
            retryLoop loop e replicaDelay = do
-              flip catchAllErrors (\_ -> pure ()) $ do
+              flip catchAgentError (\_ -> pure ()) $ do
                when (serverHostError e) $ notify c "" $ SFWARN e
                liftIO $ closeXFTPServerClient c userId server chunkDigest
                withStore' c $ \db -> updateDeletedSndChunkReplicaDelay db deletedSndChunkReplicaId replicaDelay
@@ -20,33 +20,25 @@ import Data.Bifunctor (first)
 import Data.ByteString.Builder (Builder, byteString)
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
-import qualified Data.ByteString.Lazy as LB
 import Data.Int (Int64)
-import Data.List (foldl')
 import Data.List.NonEmpty (NonEmpty (..))
-import Data.Maybe (listToMaybe)
-import Data.Time.Clock (UTCTime)
 import Data.Word (Word32)
 import qualified Data.X509 as X
 import qualified Data.X509.Validation as XV
 import qualified Network.HTTP.Types as N
 import qualified Network.HTTP2.Client as H
-import Network.Socket (HostName)
-import Simplex.FileTransfer.Chunks
 import Simplex.FileTransfer.Protocol
+import Simplex.FileTransfer.Server.Env (supportedXFTPhandshakes)
 import Simplex.FileTransfer.Transport
 import Simplex.Messaging.Client
  ( NetworkConfig (..),
-    NetworkRequestMode (..),
    ProtocolClientError (..),
    TransportSession,
-    netTimeoutInt,
    chooseTransportHost,
    defaultNetworkConfig,
+    proxyUsername,
    transportClientConfig,
-    clientSocksCredentials,
    unexpectedResponse,
-    useWebPort,
  )
 import qualified Simplex.Messaging.Crypto as C
 import qualified Simplex.Messaging.Crypto.Lazy as LC
@@ -58,12 +50,9 @@ import Simplex.Messaging.Protocol
    ProtocolServer (..),
    RecipientId,
    SenderId,
-    pattern NoEntity,
-    NetworkError (..),
-    toNetworkError,
  )
-import Simplex.Messaging.Transport (ALPN, CertChainPubKey (..), HandshakeError (..), THandleAuth (..), THandleParams (..), TransportError (..), TransportPeer (..), defaultSupportedParams)
-import Simplex.Messaging.Transport.Client (TransportClientConfig (..), TransportHost)
+import Simplex.Messaging.Transport (ALPN, HandshakeError (..), THandleAuth (..), THandleParams (..), TransportError (..), TransportPeer (..), supportedParameters)
+import Simplex.Messaging.Transport.Client (TransportClientConfig, TransportHost, alpn)
 import Simplex.Messaging.Transport.HTTP2
 import Simplex.Messaging.Transport.HTTP2.Client
 import Simplex.Messaging.Transport.HTTP2.File
@@ -105,29 +94,27 @@ defaultXFTPClientConfig =
  XFTPClientConfig
    { xftpNetworkConfig = defaultNetworkConfig,
      serverVRange = supportedFileServerVRange,
-      clientALPN = Just alpnSupportedXFTPhandshakes
+      clientALPN = Just supportedXFTPhandshakes
    }

-getXFTPClient :: TransportSession FileResponse -> XFTPClientConfig -> [HostName] -> UTCTime -> (XFTPClient -> IO ()) -> IO (Either XFTPClientError XFTPClient)
-getXFTPClient transportSession@(_, srv, _) config@XFTPClientConfig {clientALPN, xftpNetworkConfig, serverVRange} presetDomains proxySessTs disconnected = runExceptT $ do
-  let socksCreds = clientSocksCredentials xftpNetworkConfig proxySessTs transportSession
+getXFTPClient :: TransportSession FileResponse -> XFTPClientConfig -> (XFTPClient -> IO ()) -> IO (Either XFTPClientError XFTPClient)
+getXFTPClient transportSession@(_, srv, _) config@XFTPClientConfig {clientALPN, xftpNetworkConfig, serverVRange} disconnected = runExceptT $ do
+  let username = proxyUsername transportSession
      ProtocolServer _ host port keyHash = srv
-      useALPN = if useWebPort xftpNetworkConfig presetDomains srv then Just [httpALPN11] else clientALPN
  useHost <- liftEither $ chooseTransportHost xftpNetworkConfig host
-  let tcConfig = transportClientConfig xftpNetworkConfig NRMBackground useHost False useALPN
+  let tcConfig = (transportClientConfig xftpNetworkConfig useHost) {alpn = clientALPN}
      http2Config = xftpHTTP2Config tcConfig config
  clientVar <- newTVarIO Nothing
  let usePort = if null port then "443" else port
      clientDisconnected = readTVarIO clientVar >>= mapM_ disconnected
-  http2Client <- liftError' xftpClientError $ getVerifiedHTTP2Client socksCreds useHost usePort (Just keyHash) Nothing http2Config clientDisconnected
+  http2Client <- liftError' xftpClientError $ getVerifiedHTTP2Client (Just username) useHost usePort (Just keyHash) Nothing http2Config clientDisconnected
  let HTTP2Client {sessionId, sessionALPN} = http2Client
      v = VersionXFTP 1
      thServerVRange = versionToRange v
-      thParams0 = THandleParams {sessionId, blockSize = xftpBlockSize, thVersion = v, thServerVRange, thAuth = Nothing, implySessId = False, encryptBlock = Nothing, batch = True, serviceAuth = False}
+      thParams0 = THandleParams {sessionId, blockSize = xftpBlockSize, thVersion = v, thServerVRange, thAuth = Nothing, implySessId = False, batch = True}
  logDebug $ "Client negotiated handshake protocol: " <> tshow sessionALPN
  thParams@THandleParams {thVersion} <- case sessionALPN of
-    Just alpn | alpn == xftpALPNv1 || alpn == httpALPN11 ->
-      xftpClientHandshakeV1 serverVRange keyHash http2Client thParams0
+    Just "xftp/1" -> xftpClientHandshakeV1 serverVRange keyHash http2Client thParams0
    _ -> pure thParams0
  logDebug $ "Client negotiated protocol: " <> tshow thVersion
  let c = XFTPClient {http2Client, thParams, transportSession, config}
@@ -140,8 +127,7 @@ xftpClientHandshakeV1 serverVRange keyHash@(C.KeyHash kh) c@HTTP2Client {session
  (vr, sk) <- processServerHandshake shs
  let v = maxVersion vr
  sendClientHandshake XFTPClientHandshake {xftpVersion = v, keyHash}
-  let thAuth = Just THAuthClient {peerServerPubKey = sk, peerServerCertKey = ck, clientService = Nothing, sessSecret = Nothing}
-  pure thParams0 {thAuth, thVersion = v, thServerVRange = vr}
+  pure thParams0 {thAuth = Just THAuthClient {serverPeerPubKey = sk, serverCertKey = ck, sessSecret = Nothing}, thVersion = v, thServerVRange = vr}
  where
    getServerHandshake :: ExceptT XFTPClientError IO XFTPServerHandshake
    getServerHandshake = do
@@ -156,12 +142,12 @@ xftpClientHandshakeV1 serverVRange keyHash@(C.KeyHash kh) c@HTTP2Client {session
        Nothing -> throwE $ PCETransportError TEVersion
        Just (Compatible vr) ->
          fmap (vr,) . liftTransportErr (TEHandshake BAD_AUTH) $ do
-            let CertChainPubKey (X.CertificateChain cert) exact = serverAuth
+            let (X.CertificateChain cert, exact) = serverAuth
            case cert of
              [_leaf, ca] | XV.Fingerprint kh == XV.getFingerprint ca X.HashSHA256 -> pure ()
              _ -> throwError "bad certificate"
            pubKey <- maybe (throwError "bad server key type") (`C.verifyX509` exact) serverKey
-            C.x509ToPublic' pubKey
+            C.x509ToPublic (pubKey, []) >>= C.pubKey
    sendClientHandshake :: XFTPClientHandshake -> ExceptT XFTPClientError IO ()
    sendClientHandshake chs = do
      chs' <- liftTransportErr TELargeMsg $ C.pad (smpEncode chs) xftpBlockSize
@@ -185,15 +171,15 @@ xftpHTTP2Config :: TransportClientConfig -> XFTPClientConfig -> HTTP2ClientConfi
 xftpHTTP2Config transportConfig XFTPClientConfig {xftpNetworkConfig = NetworkConfig {tcpConnectTimeout}} =
  defaultHTTP2ClientConfig
    { bodyHeadSize = xftpBlockSize,
-      suportedTLSParams = defaultSupportedParams,
-      connTimeout = netTimeoutInt tcpConnectTimeout NRMBackground,
+      suportedTLSParams = supportedParameters,
+      connTimeout = tcpConnectTimeout,
      transportConfig
    }

 xftpClientError :: HTTP2ClientError -> XFTPClientError
 xftpClientError = \case
  HCResponseTimeout -> PCEResponseTimeout
-  HCNetworkError e -> PCENetworkError e
+  HCNetworkError -> PCENetworkError
  HCIOError e -> PCEIOError e

 sendXFTPCommand :: forall p. FilePartyI p => XFTPClient -> C.APrivateAuthKey -> XFTPFileId -> FileCommand p -> Maybe XFTPChunkSpec -> ExceptT XFTPClientError IO (FileResponse, HTTP2Body)
@@ -212,7 +198,7 @@ sendXFTPTransmission XFTPClient {config, thParams, http2Client} t chunkSpec_ = d
  HTTP2Response {respBody = body@HTTP2Body {bodyHead}} <- withExceptT xftpClientError . ExceptT $ sendRequest http2Client req (Just reqTimeout)
  when (B.length bodyHead /= xftpBlockSize) $ throwE $ PCEResponseError BLOCK
  -- TODO validate that the file ID is the same as in the request?
-  (_, _fId, respOrErr) <-liftEither $ first PCEResponseError $ xftpDecodeTClient thParams bodyHead
+  (_, _, (_, _fId, respOrErr)) <- liftEither . first PCEResponseError $ xftpDecodeTransmission thParams bodyHead
  case respOrErr of
    Right r -> case protocolError r of
      Just e -> throwE $ PCEProtocolError e
@@ -236,7 +222,7 @@ createXFTPChunk ::
  Maybe BasicAuth ->
  ExceptT XFTPClientError IO (SenderId, NonEmpty RecipientId)
 createXFTPChunk c spKey file rcps auth_ =
-  sendXFTPCommand c spKey NoEntity (FNEW file rcps auth_) Nothing >>= \case
+  sendXFTPCommand c spKey "" (FNEW file rcps auth_) Nothing >>= \case
    (FRSndIds sId rIds, body) -> noFile body (sId, rIds)
    (r, _) -> throwE $ unexpectedResponse r

@@ -263,9 +249,9 @@ downloadXFTPChunk g c@XFTPClient {config} rpKey fId chunkSpec@XFTPRcvChunkSpec {
        ExceptT (sequence <$> (t `timeout` (download cbState `catches` errors))) >>= maybe (throwE PCEResponseTimeout) pure
        where
          errors =
-            [ Handler $ \(e :: H.HTTP2Error) -> pure $ Left $ PCENetworkError $ NEConnectError $ displayException e,
-              Handler $ \(e :: IOException) -> pure $ Left $ PCEIOError e,
-              Handler $ \(e :: SomeException) -> pure $ Left $ PCENetworkError $ toNetworkError e
+            [ Handler $ \(_e :: H.HTTP2Error) -> pure $ Left PCENetworkError,
+              Handler $ \(e :: IOException) -> pure $ Left (PCEIOError e),
+              Handler $ \(_e :: SomeException) -> pure $ Left PCENetworkError
            ]
          download cbState =
            runExceptT . withExceptT PCEResponseError $
@@ -276,11 +262,11 @@ downloadXFTPChunk g c@XFTPClient {config} rpKey fId chunkSpec@XFTPRcvChunkSpec {

 xftpReqTimeout :: XFTPClientConfig -> Maybe Word32 -> Int
 xftpReqTimeout cfg@XFTPClientConfig {xftpNetworkConfig = NetworkConfig {tcpTimeout}} chunkSize_ =
-  maybe (netTimeoutInt tcpTimeout NRMBackground) (chunkTimeout cfg) chunkSize_
+  maybe tcpTimeout (chunkTimeout cfg) chunkSize_

 chunkTimeout :: XFTPClientConfig -> Word32 -> Int
 chunkTimeout XFTPClientConfig {xftpNetworkConfig = NetworkConfig {tcpTimeout, tcpTimeoutPerKb}} sz =
-  netTimeoutInt tcpTimeout NRMBackground + fromIntegral (min ((fromIntegral sz `div` 1024) * tcpTimeoutPerKb) (fromIntegral (maxBound :: Int)))
+  tcpTimeout + fromIntegral (min ((fromIntegral sz `div` 1024) * tcpTimeoutPerKb) (fromIntegral (maxBound :: Int)))

 deleteXFTPChunk :: XFTPClient -> C.APrivateAuthKey -> SenderId -> ExceptT XFTPClientError IO ()
 deleteXFTPChunk c spKey sId = sendXFTPCommand c spKey sId FDEL Nothing >>= okResponse
@@ -292,7 +278,7 @@ pingXFTP :: XFTPClient -> ExceptT XFTPClientError IO ()
 pingXFTP c@XFTPClient {thParams} = do
  t <-
    liftEither . first PCETransportError $
-      xftpEncodeTransmission thParams ("", NoEntity, FileCmd SFRecipient PING)
+      xftpEncodeTransmission thParams ("", "", FileCmd SFRecipient PING)
  (r, _) <- sendXFTPTransmission c t Nothing
  case r of
    FRPong -> pure ()
@@ -311,41 +297,3 @@ noFile HTTP2Body {bodyPart} a = case bodyPart of

 -- FACK :: FileCommand Recipient
 -- PING :: FileCommand Recipient
-
-singleChunkSize :: Int64 -> Maybe Word32
-singleChunkSize size' =
-  listToMaybe $ dropWhile (< chunkSize) serverChunkSizes
-  where
-    chunkSize = fromIntegral size'
-
-prepareChunkSizes :: Int64 -> [Word32]
-prepareChunkSizes size' = prepareSizes size'
-  where
-    (smallSize, bigSize)
-      | size' > size34 chunkSize3 = (chunkSize2, chunkSize3)
-      | size' > size34 chunkSize2 = (chunkSize1, chunkSize2)
-      | otherwise = (chunkSize0, chunkSize1)
-    size34 sz = (fromIntegral sz * 3) `div` 4
-    prepareSizes 0 = []
-    prepareSizes size
-      | size >= fromIntegral bigSize = replicate (fromIntegral n1) bigSize <> prepareSizes remSz
-      | size > size34 bigSize = [bigSize]
-      | otherwise = replicate (fromIntegral n2') smallSize
-      where
-        (n1, remSz) = size `divMod` fromIntegral bigSize
-        n2' = let (n2, remSz2) = (size `divMod` fromIntegral smallSize) in if remSz2 == 0 then n2 else n2 + 1
-
-prepareChunkSpecs :: FilePath -> [Word32] -> [XFTPChunkSpec]
-prepareChunkSpecs filePath chunkSizes = reverse . snd $ foldl' addSpec (0, []) chunkSizes
-  where
-    addSpec :: (Int64, [XFTPChunkSpec]) -> Word32 -> (Int64, [XFTPChunkSpec])
-    addSpec (chunkOffset, specs) sz =
-      let spec = XFTPChunkSpec {filePath, chunkOffset, chunkSize = sz}
-       in (chunkOffset + fromIntegral sz, spec : specs)
-
-getChunkDigest :: XFTPChunkSpec -> IO ByteString
-getChunkDigest XFTPChunkSpec {filePath = chunkPath, chunkOffset, chunkSize} =
-  withFile chunkPath ReadMode $ \h -> do
-    hSeek h AbsoluteSeek $ fromIntegral chunkOffset
-    chunk <- LB.hGet h (fromIntegral chunkSize)
-    pure $! LC.sha256Hash chunk
@@ -16,10 +16,9 @@ import Data.Bifunctor (first)
 import qualified Data.ByteString.Char8 as B
 import Data.Text (Text)
 import Data.Text.Encoding (decodeUtf8)
-import Data.Time.Clock (UTCTime, getCurrentTime)
 import Simplex.FileTransfer.Client
 import Simplex.Messaging.Agent.RetryInterval
-import Simplex.Messaging.Client (NetworkConfig (..), NetworkRequestMode (..), ProtocolClientError (..), netTimeoutInt, temporaryClientError)
+import Simplex.Messaging.Client (NetworkConfig (..), ProtocolClientError (..), temporaryClientError)
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Protocol (ProtocolServer (..), XFTPServer)
 import Simplex.Messaging.TMap (TMap)
@@ -31,7 +30,6 @@ type XFTPClientVar = TMVar (Either XFTPClientAgentError XFTPClient)

 data XFTPClientAgent = XFTPClientAgent
  { xftpClients :: TMap XFTPServer XFTPClientVar,
-    startedAt :: UTCTime,
    config :: XFTPClientAgentConfig
  }

@@ -58,20 +56,19 @@ data XFTPClientAgentError = XFTPClientAgentError XFTPServer XFTPClientError
 newXFTPAgent :: XFTPClientAgentConfig -> IO XFTPClientAgent
 newXFTPAgent config = do
  xftpClients <- TM.emptyIO
-  startedAt <- getCurrentTime
-  pure XFTPClientAgent {xftpClients, startedAt, config}
+  pure XFTPClientAgent {xftpClients, config}

 type ME a = ExceptT XFTPClientAgentError IO a

 getXFTPServerClient :: XFTPClientAgent -> XFTPServer -> ME XFTPClient
-getXFTPServerClient XFTPClientAgent {xftpClients, startedAt, config} srv = do
+getXFTPServerClient XFTPClientAgent {xftpClients, config} srv = do
  atomically getClientVar >>= either newXFTPClient waitForXFTPClient
  where
    connectClient :: ME XFTPClient
    connectClient =
      ExceptT $
        first (XFTPClientAgentError srv)
-          <$> getXFTPClient (1, srv, Nothing) (xftpConfig config) [] startedAt clientDisconnected
+          <$> getXFTPClient (1, srv, Nothing) (xftpConfig config) clientDisconnected

    clientDisconnected :: XFTPClient -> IO ()
    clientDisconnected _ = do
@@ -90,7 +87,7 @@ getXFTPServerClient XFTPClientAgent {xftpClients, startedAt, config} srv = do
    waitForXFTPClient :: XFTPClientVar -> ME XFTPClient
    waitForXFTPClient clientVar = do
      let XFTPClientConfig {xftpNetworkConfig = NetworkConfig {tcpConnectTimeout}} = xftpConfig config
-      client_ <- liftIO $ netTimeoutInt tcpConnectTimeout NRMBackground `timeout` atomically (readTMVar clientVar)
+      client_ <- liftIO $ tcpConnectTimeout `timeout` atomically (readTMVar clientVar)
      liftEither $ case client_ of
        Just (Right c) -> Right c
        Just (Left e) -> Left e
@@ -127,6 +124,6 @@ closeXFTPServerClient XFTPClientAgent {xftpClients, config} srv =
  where
    closeClient cVar = do
      let NetworkConfig {tcpConnectTimeout} = xftpNetworkConfig $ xftpConfig config
-      netTimeoutInt tcpConnectTimeout NRMBackground `timeout` atomically (readTMVar cVar) >>= \case
+      tcpConnectTimeout `timeout` atomically (readTMVar cVar) >>= \case
        Just (Right client) -> closeXFTPClient client `catchAll_` pure ()
        _ -> pure ()
@@ -19,7 +19,11 @@ module Simplex.FileTransfer.Client.Main
    singleChunkSize,
    prepareChunkSizes,
    prepareChunkSpecs,
+    maxFileSize,
+    maxFileSizeHard,
+    fileSizeLen,
    getChunkDigest,
+    SentRecipientReplica (..),
  )
 where

@@ -30,6 +34,7 @@ import Control.Monad.Trans.Except
 import Crypto.Random (ChaChaDRG)
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Bifunctor (first)
+import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
 import qualified Data.ByteString.Lazy.Char8 as LB
 import Data.Char (toLower)
@@ -39,8 +44,8 @@ import Data.List (foldl', sortOn)
 import Data.List.NonEmpty (NonEmpty (..), nonEmpty)
 import qualified Data.List.NonEmpty as L
 import Data.Map.Strict (Map)
-import qualified Data.Map.Strict as M
-import Data.Maybe (fromMaybe)
+import qualified Data.Map as M
+import Data.Maybe (fromMaybe, listToMaybe)
 import qualified Data.Text as T
 import Data.Word (Word32)
 import GHC.Records (HasField (getField))
@@ -75,6 +80,20 @@ import UnliftIO.Directory
 xftpClientVersion :: String
 xftpClientVersion = "1.0.1"

+-- | Soft limit for XFTP clients. Should be checked and reported to user.
+maxFileSize :: Int64
+maxFileSize = gb 1
+
+maxFileSizeStr :: String
+maxFileSizeStr = B.unpack . strEncode $ FileSize maxFileSize
+
+-- | Hard internal limit for XFTP agent after which it refuses to prepare chunks.
+maxFileSizeHard :: Int64
+maxFileSizeHard = gb 5
+
+fileSizeLen :: Int64
+fileSizeLen = 8
+
 newtype CLIError = CLIError String
  deriving (Eq, Show, Exception)

@@ -212,6 +231,16 @@ data SentFileChunkReplica = SentFileChunkReplica
  }
  deriving (Show)

+data SentRecipientReplica = SentRecipientReplica
+  { chunkNo :: Int,
+    server :: XFTPServer,
+    rcvNo :: Int,
+    replicaId :: ChunkReplicaId,
+    replicaKey :: C.APrivateAuthKey,
+    digest :: FileDigest,
+    chunkSize :: FileSize Word32
+  }
+
 logCfg :: LogConfig
 logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}

@@ -280,7 +309,7 @@ cliSendFileOpts SendOptions {filePath, outputDir, numRecipients, xftpServers, re
      let chunkSpecs = prepareChunkSpecs encPath chunkSizes
          fdRcv = FileDescription {party = SFRecipient, size = FileSize encSize, digest = FileDigest digest, key, nonce, chunkSize = FileSize defChunkSize, chunks = [], redirect = Nothing}
          fdSnd = FileDescription {party = SFSender, size = FileSize encSize, digest = FileDigest digest, key, nonce, chunkSize = FileSize defChunkSize, chunks = [], redirect = Nothing}
-      logDebug $ "encrypted file to " <> tshow encPath
+      logInfo $ "encrypted file to " <> tshow encPath
      pure (encPath, fdRcv, fdSnd, chunkSpecs, encSize)
    uploadFile :: TVar ChaChaDRG -> [XFTPChunkSpec] -> TVar [Int64] -> Int64 -> ExceptT CLIError IO [SentFileChunk]
    uploadFile g chunks uploadedChunks encSize = do
@@ -293,14 +322,14 @@ cliSendFileOpts SendOptions {filePath, outputDir, numRecipients, xftpServers, re
      -- TODO shuffle/unshuffle chunks
      -- the reason we don't do pooled downloads here within one server is that http2 library doesn't handle cleint concurrency, even though
      -- upload doesn't allow other requests within the same client until complete (but download does allow).
-      logDebug $ "uploading " <> tshow (length chunks) <> " chunks..."
+      logInfo $ "uploading " <> tshow (length chunks) <> " chunks..."
      (errs, rs) <- partitionEithers . concat <$> liftIO (pooledForConcurrentlyN 16 chunks' . mapM $ runExceptT . uploadFileChunk a)
      mapM_ throwE errs
      pure $ map snd (sortOn fst rs)
      where
        uploadFileChunk :: XFTPClientAgent -> (Int, XFTPChunkSpec, XFTPServerWithAuth) -> ExceptT CLIError IO (Int, SentFileChunk)
        uploadFileChunk a (chunkNo, chunkSpec@XFTPChunkSpec {chunkSize}, ProtoServerWithAuth xftpServer auth) = do
-          logDebug $ "uploading chunk " <> tshow chunkNo <> " to " <> showServer xftpServer <> "..."
+          logInfo $ "uploading chunk " <> tshow chunkNo <> " to " <> showServer xftpServer <> "..."
          (sndKey, spKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
          rKeys <- atomically $ L.fromList <$> replicateM numRecipients (C.generateAuthKeyPair C.SEd25519 g)
          digest <- liftIO $ getChunkDigest chunkSpec
@@ -308,7 +337,7 @@ cliSendFileOpts SendOptions {filePath, outputDir, numRecipients, xftpServers, re
          c <- withRetry retryCount $ getXFTPServerClient a xftpServer
          (sndId, rIds) <- withRetry retryCount $ createXFTPChunk c spKey ch (L.map fst rKeys) auth
          withReconnect a xftpServer retryCount $ \c' -> uploadXFTPChunk c' spKey sndId chunkSpec
-          logDebug $ "uploaded chunk " <> tshow chunkNo
+          logInfo $ "uploaded chunk " <> tshow chunkNo
          uploaded <- atomically . stateTVar uploadedChunks $ \cs ->
            let cs' = fromIntegral chunkSize : cs in (sum cs', cs')
          liftIO $ do
@@ -385,6 +414,13 @@ cliSendFileOpts SendOptions {filePath, outputDir, numRecipients, xftpServers, re
      B.writeFile fdSndPath $ strEncode fdSnd
      pure (fdRcvPaths, fdSndPath)

+getChunkDigest :: XFTPChunkSpec -> IO ByteString
+getChunkDigest XFTPChunkSpec {filePath = chunkPath, chunkOffset, chunkSize} =
+  withFile chunkPath ReadMode $ \h -> do
+    hSeek h AbsoluteSeek $ fromIntegral chunkOffset
+    chunk <- LB.hGet h (fromIntegral chunkSize)
+    pure $! LC.sha256Hash chunk
+
 cliReceiveFile :: ReceiveOptions -> ExceptT CLIError IO ()
 cliReceiveFile ReceiveOptions {fileDescription, filePath, retryCount, tempPath, verbose, yes} =
  getFileDescription' fileDescription >>= receive
@@ -418,11 +454,11 @@ cliReceiveFile ReceiveOptions {fileDescription, filePath, retryCount, tempPath,
    downloadFileChunk :: TVar ChaChaDRG -> XFTPClientAgent -> FilePath -> FileSize Int64 -> TVar [Int64] -> FileChunk -> ExceptT CLIError IO (Int, FilePath)
    downloadFileChunk g a encPath (FileSize encSize) downloadedChunks FileChunk {chunkNo, chunkSize, digest, replicas = replica : _} = do
      let FileChunkReplica {server, replicaId, replicaKey} = replica
-      logDebug $ "downloading chunk " <> tshow chunkNo <> " from " <> showServer server <> "..."
+      logInfo $ "downloading chunk " <> tshow chunkNo <> " from " <> showServer server <> "..."
      chunkPath <- uniqueCombine encPath $ show chunkNo
      let chunkSpec = XFTPRcvChunkSpec chunkPath (unFileSize chunkSize) (unFileDigest digest)
      withReconnect a server retryCount $ \c -> downloadXFTPChunk g c replicaKey (unChunkReplicaId replicaId) chunkSpec
-      logDebug $ "downloaded chunk " <> tshow chunkNo <> " to " <> T.pack chunkPath
+      logInfo $ "downloaded chunk " <> tshow chunkNo <> " to " <> T.pack chunkPath
      downloaded <- atomically . stateTVar downloadedChunks $ \cs ->
        let cs' = fromIntegral (unFileSize chunkSize) : cs in (sum cs', cs')
      liftIO $ do
@@ -467,7 +503,7 @@ cliDeleteFile DeleteOptions {fileDescription, retryCount, yes} = do
    deleteFileChunk a FileChunk {chunkNo, replicas = replica : _} = do
      let FileChunkReplica {server, replicaId, replicaKey} = replica
      withReconnect a server retryCount $ \c -> deleteXFTPChunk c replicaKey (unChunkReplicaId replicaId)
-      logDebug $ "deleted chunk " <> tshow chunkNo <> " from " <> showServer server
+      logInfo $ "deleted chunk " <> tshow chunkNo <> " from " <> showServer server
    deleteFileChunk _ _ = throwE $ CLIError "chunk has no replicas"

 cliFileDescrInfo :: InfoOptions -> ExceptT CLIError IO ()
@@ -500,6 +536,37 @@ getFileDescription' path =
  getFileDescription path >>= \case
    AVFD fd -> either (throwE . CLIError) pure $ checkParty fd

+singleChunkSize :: Int64 -> Maybe Word32
+singleChunkSize size' =
+  listToMaybe $ dropWhile (< chunkSize) serverChunkSizes
+  where
+    chunkSize = fromIntegral size'
+
+prepareChunkSizes :: Int64 -> [Word32]
+prepareChunkSizes size' = prepareSizes size'
+  where
+    (smallSize, bigSize)
+      | size' > size34 chunkSize3 = (chunkSize2, chunkSize3)
+      | size' > size34 chunkSize2 = (chunkSize1, chunkSize2)
+      | otherwise = (chunkSize0, chunkSize1)
+    size34 sz = (fromIntegral sz * 3) `div` 4
+    prepareSizes 0 = []
+    prepareSizes size
+      | size >= fromIntegral bigSize = replicate (fromIntegral n1) bigSize <> prepareSizes remSz
+      | size > size34 bigSize = [bigSize]
+      | otherwise = replicate (fromIntegral n2') smallSize
+      where
+        (n1, remSz) = size `divMod` fromIntegral bigSize
+        n2' = let (n2, remSz2) = (size `divMod` fromIntegral smallSize) in if remSz2 == 0 then n2 else n2 + 1
+
+prepareChunkSpecs :: FilePath -> [Word32] -> [XFTPChunkSpec]
+prepareChunkSpecs filePath chunkSizes = reverse . snd $ foldl' addSpec (0, []) chunkSizes
+  where
+    addSpec :: (Int64, [XFTPChunkSpec]) -> Word32 -> (Int64, [XFTPChunkSpec])
+    addSpec (chunkOffset, specs) sz =
+      let spec = XFTPChunkSpec {filePath, chunkOffset, chunkSize = sz}
+       in (chunkOffset + fromIntegral sz, spec : specs)
+
 getEncPath :: MonadIO m => Maybe FilePath -> String -> m FilePath
 getEncPath path name = (`uniqueCombine` (name <> ".encrypted")) =<< maybe (liftIO getCanonicalTemporaryDirectory) pure path

@@ -1,15 +1,12 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DeriveAnyClass #-}
-{-# LANGUAGE DerivingStrategies #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE GADTs #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# OPTIONS_GHC -fno-warn-ambiguous-fields #-}

@@ -38,10 +35,6 @@ module Simplex.FileTransfer.Description
    FileClientData,
    fileDescriptionURI,
    qrSizeLimit,
-    maxFileSize,
-    maxFileSizeStr,
-    maxFileSizeHard,
-    fileSizeLen,
  )
 where

@@ -60,17 +53,18 @@ import Data.List (foldl', sortOn)
 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 qualified Data.Map as M
 import Data.Maybe (fromMaybe)
 import Data.String
 import Data.Text (Text)
 import Data.Text.Encoding (encodeUtf8)
 import Data.Word (Word32)
 import qualified Data.Yaml as Y
+import Database.SQLite.Simple.FromField (FromField (..))
+import Database.SQLite.Simple.ToField (ToField (..))
 import Simplex.FileTransfer.Chunks
 import Simplex.FileTransfer.Protocol
 import Simplex.Messaging.Agent.QueryString
-import Simplex.Messaging.Agent.Store.DB (Binary (..), FromField (..), ToField (..))
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (defaultJSON, parseAll)
@@ -113,9 +107,6 @@ fdSeparator = "################################\n"

 newtype FileDigest = FileDigest {unFileDigest :: ByteString}
  deriving (Eq, Show)
-  deriving newtype (FromField)
-
-instance ToField FileDigest where toField (FileDigest s) = toField $ Binary s

 instance StrEncoding FileDigest where
  strEncode (FileDigest fd) = strEncode fd
@@ -129,6 +120,10 @@ instance ToJSON FileDigest where
  toJSON = strToJSON
  toEncoding = strToJEncoding

+instance FromField FileDigest where fromField f = FileDigest <$> fromField f
+
+instance ToField FileDigest where toField (FileDigest s) = toField s
+
 data FileChunk = FileChunk
  { chunkNo :: Int,
    chunkSize :: FileSize Word32,
@@ -144,9 +139,12 @@ data FileChunkReplica = FileChunkReplica
  }
  deriving (Eq, Show)

-newtype ChunkReplicaId = ChunkReplicaId {unChunkReplicaId :: XFTPFileId}
+newtype ChunkReplicaId = ChunkReplicaId {unChunkReplicaId :: ByteString}
  deriving (Eq, Show)
-  deriving newtype (StrEncoding)
+
+instance StrEncoding ChunkReplicaId where
+  strEncode (ChunkReplicaId fid) = strEncode fid
+  strP = ChunkReplicaId <$> strP

 instance FromJSON ChunkReplicaId where
  parseJSON = strParseJSON "ChunkReplicaId"
@@ -155,6 +153,10 @@ instance ToJSON ChunkReplicaId where
  toJSON = strToJSON
  toEncoding = strToJEncoding

+instance FromField ChunkReplicaId where fromField f = ChunkReplicaId <$> fromField f
+
+instance ToField ChunkReplicaId where toField (ChunkReplicaId s) = toField s
+
 data YAMLFileDescription = YAMLFileDescription
  { party :: FileParty,
    size :: String,
@@ -269,21 +271,6 @@ instance StrEncoding FileDescriptionURI where
 qrSizeLimit :: Int
 qrSizeLimit = 1002 -- ~2 chunks in URLencoded YAML with some spare size for server hosts

-- | Soft limit for XFTP clients. Should be checked and reported to user.
-maxFileSize :: Int64
-maxFileSize = gb 1
-
-maxFileSizeStr :: String
-maxFileSizeStr = B.unpack . strEncode $ FileSize maxFileSize
-
-- | Hard internal limit for XFTP agent after which it refuses to prepare chunks.
-maxFileSizeHard :: Int64
-maxFileSizeHard = gb 5
-
-fileSizeLen :: Int64
-fileSizeLen = 8
-
-
 instance (Integral a, Show a) => StrEncoding (FileSize a) where
  strEncode (FileSize b)
    | b' /= 0 = bshow b
@@ -306,9 +293,9 @@ instance (Integral a, Show a) => StrEncoding (FileSize a) where
 instance (Integral a, Show a) => IsString (FileSize a) where
  fromString = either error id . strDecode . B.pack

-deriving newtype instance FromField a => FromField (FileSize a)
+instance FromField a => FromField (FileSize a) where fromField f = FileSize <$> fromField f

-deriving newtype instance ToField a => ToField (FileSize a)
+instance ToField a => ToField (FileSize a) where toField (FileSize s) = toField s

 groupReplicasByServer :: FileSize Word32 -> [FileChunk] -> [NonEmpty FileServerReplica]
 groupReplicasByServer defChunkSize =
@@ -25,7 +25,7 @@ import Data.List.NonEmpty (NonEmpty (..))
 import Data.Maybe (isNothing)
 import Data.Type.Equality
 import Data.Word (Word32)
-import Simplex.FileTransfer.Transport (XFTPErrorType (..), XFTPVersion, blockedFilesXFTPVersion, xftpClientHandshakeStub)
+import Simplex.FileTransfer.Transport (XFTPErrorType (..), XFTPVersion, xftpClientHandshakeStub)
 import Simplex.Messaging.Client (authTransmission)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding
@@ -41,12 +41,10 @@ import Simplex.Messaging.Protocol
    ProtocolType (..),
    RcvPublicAuthKey,
    RcvPublicDhKey,
-    EntityId (..),
    RecipientId,
    SenderId,
-    RawTransmission,
    SentRawTransmission,
-    SignedTransmissionOrError,
+    SignedTransmission,
    SndPublicAuthKey,
    Transmission,
    TransmissionForAuth (..),
@@ -54,8 +52,7 @@ import Simplex.Messaging.Protocol
    encodeTransmission,
    encodeTransmissionForAuth,
    messageTagP,
-    tDecodeServer,
-    tDecodeClient,
+    tDecodeParseValidate,
    tEncodeBatch1,
    tParse,
  )
@@ -146,15 +143,10 @@ instance Protocol XFTPVersion XFTPErrorType FileResponse where
  type ProtoCommand FileResponse = FileCmd
  type ProtoType FileResponse = 'PXFTP
  protocolClientHandshake = xftpClientHandshakeStub
-  {-# INLINE protocolClientHandshake #-}
-  useServiceAuth _ = False
-  {-# INLINE useServiceAuth #-}
  protocolPing = FileCmd SFRecipient PING
-  {-# INLINE protocolPing #-}
  protocolError = \case
    FRErr e -> Just e
    _ -> Nothing
-  {-# INLINE protocolError #-}

 data FileCommand (p :: FileParty) where
  FNEW :: FileInfo -> NonEmpty RcvPublicAuthKey -> Maybe BasicAuth -> FileCommand FSender
@@ -178,7 +170,7 @@ data FileInfo = FileInfo
  }
  deriving (Show)

-type XFTPFileId = EntityId
+type XFTPFileId = ByteString

 instance FilePartyI p => ProtocolEncoding XFTPVersion XFTPErrorType (FileCommand p) where
  type Tag (FileCommand p) = FileCommandTag p
@@ -199,7 +191,7 @@ instance FilePartyI p => ProtocolEncoding XFTPVersion XFTPErrorType (FileCommand
  fromProtocolError = fromProtocolError @XFTPVersion @XFTPErrorType @FileResponse
  {-# INLINE fromProtocolError #-}

-  checkCredentials auth (EntityId fileId) cmd = case cmd of
+  checkCredentials (auth, _, fileId, _) cmd = case cmd of
    -- FNEW must not have signature and chunk ID
    FNEW {}
      | isNothing auth -> Left $ CMD NO_AUTH
@@ -233,8 +225,7 @@ instance ProtocolEncoding XFTPVersion XFTPErrorType FileCmd where
  fromProtocolError = fromProtocolError @XFTPVersion @XFTPErrorType @FileResponse
  {-# INLINE fromProtocolError #-}

-  checkCredentials tAuth entId (FileCmd p c) = FileCmd p <$> checkCredentials tAuth entId c
-  {-# INLINE checkCredentials #-}
+  checkCredentials t (FileCmd p c) = FileCmd p <$> checkCredentials t c

 instance Encoding FileInfo where
  smpEncode FileInfo {sndKey, size, digest} = smpEncode (sndKey, size, digest)
@@ -284,14 +275,12 @@ data FileResponse

 instance ProtocolEncoding XFTPVersion XFTPErrorType FileResponse where
  type Tag FileResponse = FileResponseTag
-  encodeProtocol v = \case
+  encodeProtocol _v = \case
    FRSndIds fId rIds -> e (FRSndIds_, ' ', fId, rIds)
    FRRcvIds rIds -> e (FRRcvIds_, ' ', rIds)
    FRFile rDhKey nonce -> e (FRFile_, ' ', rDhKey, nonce)
    FROk -> e FROk_
-    FRErr err -> case err of
-      BLOCKED _ | v < blockedFilesXFTPVersion -> e (FRErr_, ' ', AUTH)
-      _ -> e (FRErr_, ' ', err)
+    FRErr err -> e (FRErr_, ' ', err)
    FRPong -> e FRPong_
    where
      e :: Encoding a => a -> ByteString
@@ -312,7 +301,7 @@ instance ProtocolEncoding XFTPVersion XFTPErrorType FileResponse where
    PEBlock -> BLOCK
  {-# INLINE fromProtocolError #-}

-  checkCredentials _ (EntityId entId) cmd = case cmd of
+  checkCredentials (_, _, entId, _) cmd = case cmd of
    FRSndIds {} -> noEntity
    -- ERR response does not always have entity ID
    FRErr _ -> Right cmd
@@ -337,35 +326,25 @@ checkParty' c = case testEquality (sFileParty @p) (sFileParty @p') of
  Just Refl -> Just c
  _ -> Nothing

-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) (C.cbNonce $ bs corrId) tForAuth
+xftpEncodeAuthTransmission :: ProtocolEncoding XFTPVersion e c => THandleParams XFTPVersion 'TClient -> C.APrivateAuthKey -> Transmission c -> Either TransportError ByteString
+xftpEncodeAuthTransmission thParams@THandleParams {thAuth} pKey (corrId, fId, msg) = do
+  let TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth thParams (corrId, fId, msg)
+  xftpEncodeBatch1 . (,tToSend) =<< authTransmission thAuth (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)
+xftpEncodeTransmission :: ProtocolEncoding XFTPVersion e c => THandleParams XFTPVersion p -> Transmission c -> Either TransportError ByteString
+xftpEncodeTransmission thParams (corrId, fId, msg) = do
+  let t = encodeTransmission thParams (corrId, fId, msg)
+  xftpEncodeBatch1 (Nothing, t)

 -- this function uses batch syntax but puts only one transmission in the batch
 xftpEncodeBatch1 :: SentRawTransmission -> Either TransportError ByteString
-xftpEncodeBatch1 t = first (const TELargeMsg) $ C.pad (tEncodeBatch1 False t) xftpBlockSize
+xftpEncodeBatch1 t = first (const TELargeMsg) $ C.pad (tEncodeBatch1 t) xftpBlockSize

-xftpDecodeTServer :: THandleParams XFTPVersion 'TServer -> ByteString -> Either XFTPErrorType (SignedTransmissionOrError XFTPErrorType FileCmd)
-xftpDecodeTServer = xftpDecodeTransmission tDecodeServer
-{-# INLINE xftpDecodeTServer #-}
-
-xftpDecodeTClient :: THandleParams XFTPVersion 'TClient -> ByteString -> Either XFTPErrorType (Transmission (Either XFTPErrorType FileResponse))
-xftpDecodeTClient = xftpDecodeTransmission tDecodeClient
-{-# INLINE xftpDecodeTClient #-}
-
-xftpDecodeTransmission ::
-  (THandleParams XFTPVersion p -> Either TransportError RawTransmission -> r) ->
-  THandleParams XFTPVersion p ->
-  ByteString ->
-  Either XFTPErrorType r
-xftpDecodeTransmission tDecode thParams t = do
+xftpDecodeTransmission :: ProtocolEncoding XFTPVersion e c => THandleParams XFTPVersion p -> ByteString -> Either XFTPErrorType (SignedTransmission e c)
+xftpDecodeTransmission thParams t = do
  t' <- first (const BLOCK) $ C.unPad t
  case tParse thParams t' of
-    t'' :| [] -> Right $ tDecode thParams t''
+    t'' :| [] -> Right $ tDecodeParseValidate thParams t''
    _ -> Left BLOCK

 $(J.deriveJSON (enumJSON $ dropPrefix "F") ''FileParty)
@@ -9,7 +9,6 @@
 {-# LANGUAGE NumericUnderscores #-}
 {-# LANGUAGE OverloadedLists #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}

@@ -26,18 +25,18 @@ import Data.ByteString.Builder (Builder, byteString)
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
 import Data.Int (Int64)
+import Data.List (intercalate)
 import Data.List.NonEmpty (NonEmpty)
 import qualified Data.List.NonEmpty as L
 import qualified Data.Map.Strict as M
 import Data.Maybe (fromMaybe, isJust)
 import qualified Data.Text as T
-import qualified Data.Text.IO as T
 import Data.Time.Clock (UTCTime (..), diffTimeToPicoseconds, getCurrentTime)
+import Data.Time.Clock.System (SystemTime (..), getSystemTime)
 import Data.Time.Format.ISO8601 (iso8601Show)
 import Data.Word (Word32)
 import qualified Data.X509 as X
 import GHC.IO.Handle (hSetNewlineMode)
-import GHC.IORef (atomicSwapIORef)
 import GHC.Stats (getRTSStats)
 import qualified Network.HTTP.Types as N
 import qualified Network.HTTP2.Server as H
@@ -45,7 +44,6 @@ import Network.Socket
 import Simplex.FileTransfer.Protocol
 import Simplex.FileTransfer.Server.Control
 import Simplex.FileTransfer.Server.Env
-import Simplex.FileTransfer.Server.Prometheus
 import Simplex.FileTransfer.Server.Stats
 import Simplex.FileTransfer.Server.Store
 import Simplex.FileTransfer.Server.StoreLog
@@ -54,24 +52,20 @@ import qualified Simplex.Messaging.Crypto as C
 import qualified Simplex.Messaging.Crypto.Lazy as LC
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
-import Simplex.Messaging.Protocol (BlockingInfo, EntityId (..), RcvPublicAuthKey, RcvPublicDhKey, RecipientId, SignedTransmission, pattern NoEntity)
-import Simplex.Messaging.Server (controlPortAuth, dummyVerifyCmd, verifyCmdAuthorization)
-import Simplex.Messaging.Server.Control (CPClientRole (..))
+import Simplex.Messaging.Protocol (CorrId (..), RcvPublicAuthKey, RcvPublicDhKey, RecipientId, TransmissionAuth)
+import Simplex.Messaging.Server (dummyVerifyCmd, verifyCmdAuthorization)
 import Simplex.Messaging.Server.Expiration
-import Simplex.Messaging.Server.QueueStore (ServerEntityStatus (..))
 import Simplex.Messaging.Server.Stats
-import Simplex.Messaging.SystemTime
 import Simplex.Messaging.TMap (TMap)
 import qualified Simplex.Messaging.TMap as TM
-import Simplex.Messaging.Transport (CertChainPubKey (..), SessionId, THandleAuth (..), THandleParams (..), TransportPeer (..), defaultSupportedParams)
+import Simplex.Messaging.Transport (SessionId, THandleAuth (..), THandleParams (..), TransportPeer (..))
 import Simplex.Messaging.Transport.Buffer (trimCR)
 import Simplex.Messaging.Transport.HTTP2
 import Simplex.Messaging.Transport.HTTP2.File (fileBlockSize)
 import Simplex.Messaging.Transport.HTTP2.Server
-import Simplex.Messaging.Transport.Server (runLocalTCPServer)
+import Simplex.Messaging.Transport.Server (runTCPServer, tlsServerCredentials)
 import Simplex.Messaging.Util
 import Simplex.Messaging.Version
-import System.Environment (lookupEnv)
 import System.Exit (exitFailure)
 import System.FilePath ((</>))
 import System.IO (hPrint, hPutStrLn, universalNewlineMode)
@@ -108,33 +102,27 @@ xftpServer :: XFTPServerConfig -> TMVar Bool -> M ()
 xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpiration, fileExpiration, xftpServerVRange} started = do
  mapM_ (expireServerFiles Nothing) fileExpiration
  restoreServerStats
-  raceAny_
-    ( runServer
-        : expireFilesThread_ cfg
-          <> serverStatsThread_ cfg
-          <> prometheusMetricsThread_ cfg
-          <> controlPortThread_ cfg
-    )
-    `finally` stopServer
+  raceAny_ (runServer : expireFilesThread_ cfg <> serverStatsThread_ cfg <> controlPortThread_ cfg) `finally` stopServer
  where
    runServer :: M ()
    runServer = do
-      srvCreds@(chain, pk) <- asks tlsServerCreds
-      signKey <- liftIO $ case C.x509ToPrivate' pk of
+      serverParams <- asks tlsServerParams
+      let (chain, pk) = tlsServerCredentials serverParams
+      signKey <- liftIO $ case C.x509ToPrivate (pk, []) >>= C.privKey of
        Right pk' -> pure pk'
-        Left e -> putStrLn ("Server has no valid key: " <> show e) >> exitFailure
+        Left e -> putStrLn ("servers has no valid key: " <> show e) >> exitFailure
      env <- ask
      sessions <- liftIO TM.emptyIO
      let cleanup sessionId = atomically $ TM.delete sessionId sessions
-      liftIO . runHTTP2Server started xftpPort defaultHTTP2BufferSize defaultSupportedParams srvCreds transportConfig inactiveClientExpiration cleanup $ \sessionId sessionALPN r sendResponse -> do
+      liftIO . runHTTP2Server started xftpPort defaultHTTP2BufferSize serverParams transportConfig inactiveClientExpiration cleanup $ \sessionId sessionALPN r sendResponse -> do
        reqBody <- getHTTP2Body r xftpBlockSize
        let v = VersionXFTP 1
            thServerVRange = versionToRange v
-            thParams0 = THandleParams {sessionId, blockSize = xftpBlockSize, thVersion = v, thServerVRange, thAuth = Nothing, implySessId = False, encryptBlock = Nothing, batch = True, serviceAuth = False}
+            thParams0 = THandleParams {sessionId, blockSize = xftpBlockSize, thVersion = v, thServerVRange, thAuth = Nothing, implySessId = False, batch = True}
            req0 = XFTPTransportRequest {thParams = thParams0, request = r, reqBody, sendResponse}
        flip runReaderT env $ case sessionALPN of
          Nothing -> processRequest req0
-          Just alpn | alpn == xftpALPNv1 || alpn == httpALPN11 ->
+          Just "xftp/1" ->
            xftpServerHandshakeV1 chain signKey sessions req0 >>= \case
              Nothing -> pure () -- handshake response sent
              Just thParams -> processRequest req0 {thParams} -- proceed with new version (XXX: may as well switch the request handler here)
@@ -152,7 +140,7 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
          unless (B.null bodyHead) $ throwE HANDSHAKE
          (k, pk) <- atomically . C.generateKeyPair =<< asks random
          atomically $ TM.insert sessionId (HandshakeSent pk) sessions
-          let authPubKey = CertChainPubKey chain (C.signX509 serverSignKey $ C.publicToX509 k)
+          let authPubKey = (chain, C.signX509 serverSignKey $ C.publicToX509 k)
          let hs = XFTPServerHandshake {xftpVersionRange = xftpServerVRange, sessionId, authPubKey}
          shs <- encodeXftp hs
 #ifdef slow_servers
@@ -168,7 +156,7 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
          unless (keyHash == kh) $ throwE HANDSHAKE
          case compatibleVRange' xftpServerVRange v of
            Just (Compatible vr) -> do
-              let auth = THAuthServer {serverPrivKey = pk, peerClientService = Nothing, sessSecret' = Nothing}
+              let auth = THAuthServer {serverPrivKey = pk, sessSecret' = Nothing}
                  thParams = thParams0 {thAuth = Just auth, thVersion = v, thServerVRange = vr}
              atomically $ TM.insert sessionId (HandshakeAccepted thParams) sessions
 #ifdef slow_servers
@@ -191,7 +179,6 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
    stopServer = do
      withFileLog closeStoreLog
      saveServerStats
-      logNote "Server stopped"

    expireFilesThread_ :: XFTPServerConfig -> [M ()]
    expireFilesThread_ XFTPServerConfig {fileExpiration = Just fileExp} = [expireFiles fileExp]
@@ -220,60 +207,36 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
        withFile statsFilePath AppendMode $ \h -> liftIO $ do
          hSetBuffering h LineBuffering
          ts <- getCurrentTime
-          fromTime' <- atomicSwapIORef fromTime ts
-          filesCreated' <- atomicSwapIORef filesCreated 0
-          fileRecipients' <- atomicSwapIORef fileRecipients 0
-          filesUploaded' <- atomicSwapIORef filesUploaded 0
-          filesExpired' <- atomicSwapIORef filesExpired 0
-          filesDeleted' <- atomicSwapIORef filesDeleted 0
-          files <- liftIO $ periodStatCounts filesDownloaded ts
-          fileDownloads' <- atomicSwapIORef fileDownloads 0
-          fileDownloadAcks' <- atomicSwapIORef fileDownloadAcks 0
-          filesCount' <- readIORef filesCount
-          filesSize' <- readIORef filesSize
-          T.hPutStrLn h $
-            T.intercalate
+          fromTime' <- atomically $ swapTVar fromTime ts
+          filesCreated' <- atomically $ swapTVar filesCreated 0
+          fileRecipients' <- atomically $ swapTVar fileRecipients 0
+          filesUploaded' <- atomically $ swapTVar filesUploaded 0
+          filesExpired' <- atomically $ swapTVar filesExpired 0
+          filesDeleted' <- atomically $ swapTVar filesDeleted 0
+          files <- atomically $ periodStatCounts filesDownloaded ts
+          fileDownloads' <- atomically $ swapTVar fileDownloads 0
+          fileDownloadAcks' <- atomically $ swapTVar fileDownloadAcks 0
+          filesCount' <- readTVarIO filesCount
+          filesSize' <- readTVarIO filesSize
+          hPutStrLn h $
+            intercalate
              ","
-              [ T.pack $ iso8601Show $ utctDay fromTime',
-                tshow filesCreated',
-                tshow fileRecipients',
-                tshow filesUploaded',
-                tshow filesDeleted',
+              [ iso8601Show $ utctDay fromTime',
+                show filesCreated',
+                show fileRecipients',
+                show filesUploaded',
+                show filesDeleted',
                dayCount files,
                weekCount files,
                monthCount files,
-                tshow fileDownloads',
-                tshow fileDownloadAcks',
-                tshow filesCount',
-                tshow filesSize',
-                tshow filesExpired'
+                show fileDownloads',
+                show fileDownloadAcks',
+                show filesCount',
+                show filesSize',
+                show filesExpired'
              ]
        liftIO $ threadDelay' interval

-    prometheusMetricsThread_ :: XFTPServerConfig -> [M ()]
-    prometheusMetricsThread_ XFTPServerConfig {prometheusInterval = Just interval, prometheusMetricsFile} =
-      [savePrometheusMetrics interval prometheusMetricsFile]
-    prometheusMetricsThread_ _ = []
-
-    savePrometheusMetrics :: Int -> FilePath -> M ()
-    savePrometheusMetrics saveInterval metricsFile = do
-      labelMyThread "savePrometheusMetrics"
-      liftIO $ putStrLn $ "Prometheus metrics saved every " <> show saveInterval <> " seconds to " <> metricsFile
-      ss <- asks serverStats
-      rtsOpts <- liftIO $ maybe ("set " <> rtsOptionsEnv) T.pack <$> lookupEnv (T.unpack rtsOptionsEnv)
-      let interval = 1000000 * saveInterval
-      liftIO $ forever $ do
-        threadDelay interval
-        ts <- getCurrentTime
-        sm <- getFileServerMetrics ss rtsOpts
-        T.writeFile metricsFile $ xftpPrometheusMetrics sm ts
-
-    getFileServerMetrics :: FileServerStats -> T.Text -> IO FileServerMetrics
-    getFileServerMetrics ss rtsOptions = do
-      d <- getFileServerStatsData ss
-      let fd = periodStatDataCounts $ _filesDownloaded d
-      pure FileServerMetrics {statsData = d, filesDownloadedPeriods = fd, rtsOptions}
-
    controlPortThread_ :: XFTPServerConfig -> [M ()]
    controlPortThread_ XFTPServerConfig {controlPort = Just port} = [runCPServer port]
    controlPortThread_ _ = []
@@ -284,7 +247,7 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
      u <- askUnliftIO
      liftIO $ do
        labelMyThread "control port server"
-        runLocalTCPServer cpStarted port $ runCPClient u
+        runTCPServer cpStarted port $ runCPClient u
      where
        runCPClient :: UnliftIO (ReaderT XFTPEnv IO) -> Socket -> IO ()
        runCPClient u sock = do
@@ -311,22 +274,21 @@ xftpServer cfg@XFTPServerConfig {xftpPort, transportConfig, inactiveClientExpira
                  CPSkip -> False
                  _ -> True
            processCP h role = \case
-              CPAuth auth -> controlPortAuth h user admin role auth
+              CPAuth auth -> atomically $ writeTVar role $! newRole cfg
                where
-                  XFTPServerConfig {controlPortUserAuth = user, controlPortAdminAuth = admin} = cfg
+                  newRole XFTPServerConfig {controlPortUserAuth = user, controlPortAdminAuth = admin}
+                    | Just auth == admin = CPRAdmin
+                    | Just auth == user = CPRUser
+                    | otherwise = CPRNone
              CPStatsRTS -> E.tryAny getRTSStats >>= either (hPrint h) (hPrint h)
              CPDelete fileId -> withUserRole $ unliftIO u $ do
                fs <- asks store
                r <- runExceptT $ do
-                  (fr, _) <- ExceptT $ atomically $ getFile fs SFRecipient fileId
+                  let asSender = ExceptT . atomically $ getFile fs SFSender fileId
+                  let asRecipient = ExceptT . atomically $ getFile fs SFRecipient fileId
+                  (fr, _) <- asSender `catchError` const asRecipient
                  ExceptT $ deleteServerFile_ fr
                liftIO . hPutStrLn h $ either (\e -> "error: " <> show e) (\() -> "ok") r
-              CPBlock fileId info -> withUserRole $ unliftIO u $ do
-                fs <- asks store
-                r <- runExceptT $ do
-                  (fr, _) <- ExceptT $ atomically $ getFile fs SFRecipient fileId
-                  ExceptT $ blockServerFile fr info
-                liftIO . hPutStrLn h $ either (\e -> "error: " <> show e) (\() -> "ok") r
              CPHelp -> hPutStrLn h "commands: stats-rts, delete, help, quit"
              CPQuit -> pure ()
              CPSkip -> pure ()
@@ -347,21 +309,23 @@ data ServerFile = ServerFile

 processRequest :: XFTPTransportRequest -> M ()
 processRequest XFTPTransportRequest {thParams, reqBody = body@HTTP2Body {bodyHead}, sendResponse}
-  | B.length bodyHead /= xftpBlockSize = sendXFTPResponse ("", NoEntity, FRErr BLOCK) Nothing
-  | otherwise =
-      case xftpDecodeTServer thParams bodyHead of
-        Right (Right t@(_, _, (corrId, fId, _))) -> do
-          let THandleParams {thAuth} = thParams
-          verifyXFTPTransmission thAuth t >>= \case
-            VRVerified req -> uncurry send =<< processXFTPRequest body req
-            VRFailed e -> send (FRErr e) Nothing
+  | B.length bodyHead /= xftpBlockSize = sendXFTPResponse ("", "", FRErr BLOCK) Nothing
+  | otherwise = do
+      case xftpDecodeTransmission thParams bodyHead of
+        Right (sig_, signed, (corrId, fId, cmdOrErr)) ->
+          case cmdOrErr of
+            Right cmd -> do
+              let THandleParams {thAuth} = thParams
+              verifyXFTPTransmission ((,C.cbNonce (bs corrId)) <$> thAuth) sig_ signed fId cmd >>= \case
+                VRVerified req -> uncurry send =<< processXFTPRequest body req
+                VRFailed -> send (FRErr AUTH) Nothing
+            Left e -> send (FRErr e) Nothing
          where
            send resp = sendXFTPResponse (corrId, fId, resp)
-        Right (Left (corrId, fId, e)) -> sendXFTPResponse (corrId, fId, FRErr e) Nothing
-        Left e -> sendXFTPResponse ("", NoEntity, FRErr e) Nothing
+        Left e -> sendXFTPResponse ("", "", FRErr e) Nothing
  where
-    sendXFTPResponse t' serverFile_ = do
-      let t_ = xftpEncodeTransmission thParams t'
+    sendXFTPResponse (corrId, fId, resp) serverFile_ = do
+      let t_ = xftpEncodeTransmission thParams (corrId, fId, resp)
 #ifdef slow_servers
      randomDelay
 #endif
@@ -388,10 +352,10 @@ randomDelay = do
    threadDelay $ (d * (1000 + pc)) `div` 1000
 #endif

-data VerificationResult = VRVerified XFTPRequest | VRFailed XFTPErrorType
+data VerificationResult = VRVerified XFTPRequest | VRFailed

-verifyXFTPTransmission :: Maybe (THandleAuth 'TServer) -> SignedTransmission FileCmd -> M VerificationResult
-verifyXFTPTransmission thAuth (tAuth, authorized, (corrId, fId, cmd)) =
+verifyXFTPTransmission :: Maybe (THandleAuth 'TServer, C.CbNonce) -> Maybe TransmissionAuth -> ByteString -> XFTPFileId -> FileCmd -> M VerificationResult
+verifyXFTPTransmission auth_ tAuth authorized fId cmd =
  case cmd of
    FileCmd SFSender (FNEW file rcps auth') -> pure $ XFTPReqNew file rcps auth' `verifyWith` sndKey file
    FileCmd SFRecipient PING -> pure $ VRVerified XFTPReqPing
@@ -400,19 +364,13 @@ verifyXFTPTransmission thAuth (tAuth, authorized, (corrId, fId, cmd)) =
    verifyCmd :: SFileParty p -> M VerificationResult
    verifyCmd party = do
      st <- asks store
-      atomically $ verify =<< getFile st party fId
+      atomically $ verify <$> getFile st party fId
      where
        verify = \case
-          Right (fr, k) -> result <$> readTVar (fileStatus fr)
-            where
-              result = \case
-                EntityActive -> XFTPReqCmd fId fr cmd `verifyWith` k
-                EntityBlocked info -> VRFailed $ BLOCKED info
-                EntityOff -> noFileAuth
-          Left _ -> pure noFileAuth
-        noFileAuth = dummyVerifyCmd thAuth tAuth authorized corrId `seq` VRFailed AUTH
+          Right (fr, k) -> XFTPReqCmd fId fr cmd `verifyWith` k
+          _ -> maybe False (dummyVerifyCmd Nothing authorized) tAuth `seq` VRFailed
    -- TODO verify with DH authorization
-    req `verifyWith` k = if verifyCmdAuthorization thAuth tAuth authorized corrId k then VRVerified req else VRFailed AUTH
+    req `verifyWith` k = if verifyCmdAuthorization auth_ tAuth authorized k then VRVerified req else VRFailed

 processXFTPRequest :: HTTP2Body -> XFTPRequest -> M (FileResponse, Maybe ServerFile)
 processXFTPRequest HTTP2Body {bodyPart} = \case
@@ -429,7 +387,7 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
    FACK -> noFile =<< ackFileReception fId fr
    -- it should never get to the commands below, they are passed in other constructors of XFTPRequest
    FNEW {} -> noFile $ FRErr INTERNAL
-    PING -> noFile $ FRErr INTERNAL
+    PING -> noFile FRPong
  XFTPReqPing -> noFile FRPong
  where
    noFile resp = pure (resp, Nothing)
@@ -439,23 +397,23 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
      r <- runExceptT $ do
        sizes <- asks $ allowedChunkSizes . config
        unless (size file `elem` sizes) $ throwE SIZE
-        ts <- liftIO getFileTime
+        ts <- liftIO getSystemTime
        -- TODO validate body empty
        sId <- ExceptT $ addFileRetry st file 3 ts
        rcps <- mapM (ExceptT . addRecipientRetry st 3 sId) rks
        lift $ withFileLog $ \sl -> do
-          logAddFile sl sId file ts EntityActive
+          logAddFile sl sId file ts
          logAddRecipients sl sId rcps
        stats <- asks serverStats
-        lift $ incFileStat filesCreated
-        liftIO $ atomicModifyIORef'_ (fileRecipients stats) (+ length rks)
+        atomically $ modifyTVar' (filesCreated stats) (+ 1)
+        atomically $ modifyTVar' (fileRecipients stats) (+ length rks)
        let rIds = L.map (\(FileRecipient rId _) -> rId) rcps
        pure $ FRSndIds sId rIds
      pure $ either FRErr id r
-    addFileRetry :: FileStore -> FileInfo -> Int -> RoundedFileTime -> M (Either XFTPErrorType XFTPFileId)
+    addFileRetry :: FileStore -> FileInfo -> Int -> SystemTime -> M (Either XFTPErrorType XFTPFileId)
    addFileRetry st file n ts =
      retryAdd n $ \sId -> runExceptT $ do
-        ExceptT $ addFile st sId file ts EntityActive
+        ExceptT $ addFile st sId file ts
        pure sId
    addRecipientRetry :: FileStore -> Int -> XFTPFileId -> RcvPublicAuthKey -> M (Either XFTPErrorType FileRecipient)
    addRecipientRetry st n sId rpk =
@@ -477,7 +435,7 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
        rcps <- mapM (ExceptT . addRecipientRetry st 3 sId) rks
        lift $ withFileLog $ \sl -> logAddRecipients sl sId rcps
        stats <- asks serverStats
-        liftIO $ atomicModifyIORef'_ (fileRecipients stats) (+ length rks)
+        atomically $ modifyTVar' (fileRecipients stats) (+ length rks)
        let rIds = L.map (\(FileRecipient rId _) -> rId) rcps
        pure $ FRRcvIds rIds
      pure $ either FRErr id r
@@ -505,19 +463,19 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
              \used -> let used' = used + fromIntegral size in if used' <= quota then (True, used') else (False, used)
          receive = do
            path <- asks $ filesPath . config
-            let fPath = path </> B.unpack (B64.encode $ unEntityId senderId)
+            let fPath = path </> B.unpack (B64.encode senderId)
            receiveChunk (XFTPRcvChunkSpec fPath size digest) >>= \case
              Right () -> do
                stats <- asks serverStats
                withFileLog $ \sl -> logPutFile sl senderId fPath
                atomically $ writeTVar filePath (Just fPath)
-                incFileStat filesUploaded
-                incFileStat filesCount
-                liftIO $ atomicModifyIORef'_ (filesSize stats) (+ fromIntegral size)
+                atomically $ modifyTVar' (filesUploaded stats) (+ 1)
+                atomically $ modifyTVar' (filesCount stats) (+ 1)
+                atomically $ modifyTVar' (filesSize stats) (+ fromIntegral size)
                pure FROk
              Left e -> do
                us <- asks $ usedStorage . store
-                atomically $ modifyTVar' us $ subtract (fromIntegral size)
+                atomically . modifyTVar' us $ subtract (fromIntegral size)
                liftIO $ whenM (doesFileExist fPath) (removeFile fPath) `catch` logFileError
                pure $ FRErr e
          receiveChunk spec = do
@@ -536,8 +494,8 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
              case LC.cbInit dhSecret cbNonce of
                Right sbState -> do
                  stats <- asks serverStats
-                  incFileStat fileDownloads
-                  liftIO $ updatePeriodStats (filesDownloaded stats) senderId
+                  atomically $ modifyTVar' (fileDownloads stats) (+ 1)
+                  atomically $ updatePeriodStats (filesDownloaded stats) senderId
                  pure (FRFile sDhKey cbNonce, Just ServerFile {filePath = path, fileSize = size, sbState})
                _ -> pure (FRErr INTERNAL, Nothing)
        _ -> pure (FRErr NO_FILE, Nothing)
@@ -553,35 +511,24 @@ processXFTPRequest HTTP2Body {bodyPart} = \case
      withFileLog (`logAckFile` rId)
      st <- asks store
      atomically $ deleteRecipient st rId fr
-      incFileStat fileDownloadAcks
+      stats <- asks serverStats
+      atomically $ modifyTVar' (fileDownloadAcks stats) (+ 1)
      pure FROk

 deleteServerFile_ :: FileRec -> M (Either XFTPErrorType ())
-deleteServerFile_ fr@FileRec {senderId} = do
+deleteServerFile_ FileRec {senderId, fileInfo, filePath} = do
  withFileLog (`logDeleteFile` senderId)
-  deleteOrBlockServerFile_ fr filesDeleted (`deleteFile` senderId)
-
-- this also deletes the file from storage, but doesn't include it in delete statistics
-blockServerFile :: FileRec -> BlockingInfo -> M (Either XFTPErrorType ())
-blockServerFile fr@FileRec {senderId} info = do
-  withFileLog $ \sl -> logBlockFile sl senderId info
-  deleteOrBlockServerFile_ fr filesBlocked $ \st -> blockFile st senderId info True
-
-deleteOrBlockServerFile_ :: FileRec -> (FileServerStats -> IORef Int) -> (FileStore -> STM (Either XFTPErrorType ())) -> M (Either XFTPErrorType ())
-deleteOrBlockServerFile_ FileRec {filePath, fileInfo} stat storeAction = runExceptT $ do
-  path <- readTVarIO filePath
-  stats <- asks serverStats
-  ExceptT $ first (\(_ :: SomeException) -> FILE_IO) <$> try (forM_ path $ \p -> whenM (doesFileExist p) (removeFile p >> deletedStats stats))
-  st <- asks store
-  void $ atomically $ storeAction st
-  lift $ incFileStat stat
+  runExceptT $ do
+    path <- readTVarIO filePath
+    stats <- asks serverStats
+    ExceptT $ first (\(_ :: SomeException) -> FILE_IO) <$> try (forM_ path $ \p -> whenM (doesFileExist p) (removeFile p >> deletedStats stats))
+    st <- asks store
+    void $ atomically $ deleteFile st senderId
+    atomically $ modifyTVar' (filesDeleted stats) (+ 1)
  where
    deletedStats stats = do
-      liftIO $ atomicModifyIORef'_ (filesCount stats) (subtract 1)
-      liftIO $ atomicModifyIORef'_ (filesSize stats) (subtract $ fromIntegral $ size fileInfo)
-
-getFileTime :: IO RoundedFileTime
-getFileTime = getRoundedSystemTime
+      atomically $ modifyTVar' (filesCount stats) (subtract 1)
+      atomically $ modifyTVar' (filesSize stats) (subtract $ fromIntegral $ size fileInfo)

 expireServerFiles :: Maybe Int -> ExpirationConfig -> M ()
 expireServerFiles itemDelay expCfg = do
@@ -589,13 +536,13 @@ expireServerFiles itemDelay expCfg = do
  usedStart <- readTVarIO $ usedStorage st
  old <- liftIO $ expireBeforeEpoch expCfg
  files' <- readTVarIO (files st)
-  logNote $ "Expiration check: " <> tshow (M.size files') <> " files"
+  logInfo $ "Expiration check: " <> tshow (M.size files') <> " files"
  forM_ (M.keys files') $ \sId -> do
    mapM_ threadDelay itemDelay
    atomically (expiredFilePath st sId old)
      >>= mapM_ (maybeRemove $ delete st sId)
  usedEnd <- readTVarIO $ usedStorage st
-  logNote $ "Used " <> mbs usedStart <> " -> " <> mbs usedEnd <> ", " <> mbs (usedStart - usedEnd) <> " reclaimed."
+  logInfo $ "Used " <> mbs usedStart <> " -> " <> mbs usedEnd <> ", " <> mbs (usedStart - usedEnd) <> " reclaimed."
  where
    mbs bs = tshow (bs `div` 1048576) <> "mb"
    maybeRemove del = maybe del (remove del)
@@ -607,21 +554,24 @@ expireServerFiles itemDelay expCfg = do
    delete st sId = do
      withFileLog (`logDeleteFile` sId)
      void . atomically $ deleteFile st sId -- will not update usedStorage if sId isn't in store
-      incFileStat filesExpired
+      FileServerStats {filesExpired} <- asks serverStats
+      atomically $ modifyTVar' filesExpired (+ 1)

 randomId :: Int -> M ByteString
 randomId n = atomically . C.randomBytes n =<< asks random

 getFileId :: M XFTPFileId
-getFileId = fmap EntityId . randomId =<< asks (fileIdSize . config)
+getFileId = do
+  size <- asks (fileIdSize . config)
+  atomically . C.randomBytes size =<< asks random

 withFileLog :: (StoreLog 'WriteMode -> IO a) -> M ()
 withFileLog action = liftIO . mapM_ action =<< asks storeLog

-incFileStat :: (FileServerStats -> IORef Int) -> M ()
+incFileStat :: (FileServerStats -> TVar Int) -> M ()
 incFileStat statSel = do
  stats <- asks serverStats
-  liftIO $ atomicModifyIORef'_ (statSel stats) (+ 1)
+  atomically $ modifyTVar (statSel stats) (+ 1)

 saveServerStats :: M ()
 saveServerStats =
@@ -629,27 +579,27 @@ saveServerStats =
    >>= mapM_ (\f -> asks serverStats >>= liftIO . getFileServerStatsData >>= liftIO . saveStats f)
  where
    saveStats f stats = do
-      logNote $ "saving server stats to file " <> T.pack f
+      logInfo $ "saving server stats to file " <> T.pack f
      B.writeFile f $ strEncode stats
-      logNote "server stats saved"
+      logInfo "server stats saved"

 restoreServerStats :: M ()
 restoreServerStats = asks (serverStatsBackupFile . config) >>= mapM_ restoreStats
  where
    restoreStats f = whenM (doesFileExist f) $ do
-      logNote $ "restoring server stats from file " <> T.pack f
+      logInfo $ "restoring server stats from file " <> T.pack f
      liftIO (strDecode <$> B.readFile f) >>= \case
        Right d@FileServerStatsData {_filesCount = statsFilesCount, _filesSize = statsFilesSize} -> do
          s <- asks serverStats
          FileStore {files, usedStorage} <- asks store
          _filesCount <- M.size <$> readTVarIO files
          _filesSize <- readTVarIO usedStorage
-          liftIO $ setFileServerStats s d {_filesCount, _filesSize}
+          atomically $ setFileServerStats s d {_filesCount, _filesSize}
          renameFile f $ f <> ".bak"
-          logNote "server stats restored"
+          logInfo "server stats restored"
          when (statsFilesCount /= _filesCount) $ logWarn $ "Files count differs: stats: " <> tshow statsFilesCount <> ", store: " <> tshow _filesCount
          when (statsFilesSize /= _filesSize) $ logWarn $ "Files size differs: stats: " <> tshow statsFilesSize <> ", store: " <> tshow _filesSize
-          logNote $ "Restored " <> tshow (_filesSize `div` 1048576) <> " MBs in " <> tshow _filesCount <> " files"
+          logInfo $ "Restored " <> tshow (_filesSize `div` 1048576) <> " MBs in " <> tshow _filesCount <> " files"
        Left e -> do
-          logNote $ "error restoring server stats: " <> T.pack e
+          logInfo $ "error restoring server stats: " <> T.pack e
          liftIO exitFailure
@@ -4,15 +4,16 @@
 module Simplex.FileTransfer.Server.Control where

 import qualified Data.Attoparsec.ByteString.Char8 as A
-import Simplex.FileTransfer.Protocol (XFTPFileId)
+import Data.ByteString (ByteString)
 import Simplex.Messaging.Encoding.String
-import Simplex.Messaging.Protocol (BasicAuth, BlockingInfo)
+import Simplex.Messaging.Protocol (BasicAuth)
+
+data CPClientRole = CPRNone | CPRUser | CPRAdmin

 data ControlProtocol
  = CPAuth BasicAuth
  | CPStatsRTS
-  | CPDelete XFTPFileId
-  | CPBlock XFTPFileId BlockingInfo
+  | CPDelete ByteString
  | CPHelp
  | CPQuit
  | CPSkip
@@ -22,7 +23,6 @@ instance StrEncoding ControlProtocol where
    CPAuth tok -> "auth " <> strEncode tok
    CPStatsRTS -> "stats-rts"
    CPDelete fId -> strEncode (Str "delete", fId)
-    CPBlock fId info -> strEncode (Str "block", fId, info)
    CPHelp -> "help"
    CPQuit -> "quit"
    CPSkip -> ""
@@ -31,7 +31,6 @@ instance StrEncoding ControlProtocol where
      "auth" -> CPAuth <$> _strP
      "stats-rts" -> pure CPStatsRTS
      "delete" -> CPDelete <$> _strP
-      "block" -> CPBlock <$> _strP <*> _strP
      "help" -> pure CPHelp
      "quit" -> pure CPQuit
      "" -> pure CPSkip
@@ -28,7 +28,8 @@ import Simplex.FileTransfer.Transport (VersionRangeXFTP)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Protocol (BasicAuth, RcvPublicAuthKey)
 import Simplex.Messaging.Server.Expiration
-import Simplex.Messaging.Transport.Server (ServerCredentials (..), TransportServerConfig (..), loadFingerprint, loadServerCredential)
+import Simplex.Messaging.Transport (ALPN)
+import Simplex.Messaging.Transport.Server (TransportServerConfig (..), loadFingerprint, loadTLSServerParams)
 import Simplex.Messaging.Util (tshow)
 import System.IO (IOMode (..))
 import UnliftIO.STM
@@ -56,7 +57,10 @@ data XFTPServerConfig = XFTPServerConfig
    fileTimeout :: Int,
    -- | time after which inactive clients can be disconnected and check interval, seconds
    inactiveClientExpiration :: Maybe ExpirationConfig,
-    xftpCredentials :: ServerCredentials,
+    -- CA certificate private key is not needed for initialization
+    caCertificateFile :: FilePath,
+    privateKeyFile :: FilePath,
+    certificateFile :: FilePath,
    -- | XFTP client-server protocol version range
    xftpServerVRange :: VersionRangeXFTP,
    -- stats config - see SMP server config
@@ -64,8 +68,6 @@ data XFTPServerConfig = XFTPServerConfig
    logStatsStartTime :: Int64,
    serverStatsLogFile :: FilePath,
    serverStatsBackupFile :: Maybe FilePath,
-    prometheusInterval :: Maybe Int,
-    prometheusMetricsFile :: FilePath,
    transportConfig :: TransportServerConfig,
    responseDelay :: Int
  }
@@ -73,7 +75,7 @@ data XFTPServerConfig = XFTPServerConfig
 defaultInactiveClientExpiration :: ExpirationConfig
 defaultInactiveClientExpiration =
  ExpirationConfig
-    { ttl = 21600, -- seconds, 6 hours
+    { ttl = 43200, -- seconds, 12 hours
      checkInterval = 3600 -- seconds, 1 hours
    }

@@ -83,7 +85,7 @@ data XFTPEnv = XFTPEnv
    storeLog :: Maybe (StoreLog 'WriteMode),
    random :: TVar ChaChaDRG,
    serverIdentity :: C.KeyHash,
-    tlsServerCreds :: T.Credential,
+    tlsServerParams :: T.ServerParams,
    serverStats :: FileServerStats
  }

@@ -97,20 +99,23 @@ defaultFileExpiration =
      checkInterval = 2 * 3600 -- seconds, 2 hours
    }

+supportedXFTPhandshakes :: [ALPN]
+supportedXFTPhandshakes = ["xftp/1"]
+
 newXFTPServerEnv :: XFTPServerConfig -> IO XFTPEnv
-newXFTPServerEnv config@XFTPServerConfig {storeLogFile, fileSizeQuota, xftpCredentials} = do
+newXFTPServerEnv config@XFTPServerConfig {storeLogFile, fileSizeQuota, caCertificateFile, certificateFile, privateKeyFile, transportConfig} = do
  random <- C.newRandom
  store <- newFileStore
  storeLog <- mapM (`readWriteFileStore` store) storeLogFile
  used <- countUsedStorage <$> readTVarIO (files store)
  atomically $ writeTVar (usedStorage store) used
  forM_ fileSizeQuota $ \quota -> do
-    logNote $ "Total / available storage: " <> tshow quota <> " / " <> tshow (quota - used)
-    when (quota < used) $ logWarn "WARNING: storage quota is less than used storage, no files can be uploaded!"
-  tlsServerCreds <- loadServerCredential xftpCredentials
-  Fingerprint fp <- loadFingerprint xftpCredentials
+    logInfo $ "Total / available storage: " <> tshow quota <> " / " <> tshow (quota - used)
+    when (quota < used) $ logInfo "WARNING: storage quota is less than used storage, no files can be uploaded!"
+  tlsServerParams <- loadTLSServerParams caCertificateFile certificateFile privateKeyFile (alpn transportConfig)
+  Fingerprint fp <- loadFingerprint caCertificateFile
  serverStats <- newFileServerStats =<< getCurrentTime
-  pure XFTPEnv {config, store, storeLog, random, tlsServerCreds, serverIdentity = C.KeyHash fp, serverStats}
+  pure XFTPEnv {config, store, storeLog, random, tlsServerParams, serverIdentity = C.KeyHash fp, serverStats}

 countUsedStorage :: M.Map k FileRec -> Int64
 countUsedStorage = M.foldl' (\acc FileRec {fileInfo = FileInfo {size}} -> acc + fromIntegral size) 0
@@ -1,4 +1,3 @@
-{-# LANGUAGE ApplicativeDo #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
@@ -20,17 +19,17 @@ import Options.Applicative
 import Simplex.FileTransfer.Chunks
 import Simplex.FileTransfer.Description (FileSize (..))
 import Simplex.FileTransfer.Server (runXFTPServer)
-import Simplex.FileTransfer.Server.Env (XFTPServerConfig (..), defFileExpirationHours, defaultFileExpiration, defaultInactiveClientExpiration)
-import Simplex.FileTransfer.Transport (supportedFileServerVRange, alpnSupportedXFTPhandshakes)
+import Simplex.FileTransfer.Server.Env (XFTPServerConfig (..), defFileExpirationHours, defaultFileExpiration, defaultInactiveClientExpiration, supportedXFTPhandshakes)
+import Simplex.FileTransfer.Transport (supportedFileServerVRange)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Protocol (ProtoServerWithAuth (..), pattern XFTPServer)
 import Simplex.Messaging.Server.CLI
 import Simplex.Messaging.Server.Expiration
+import Simplex.Messaging.Transport (simplexMQVersion)
 import Simplex.Messaging.Transport.Client (TransportHost (..))
-import Simplex.Messaging.Transport.HTTP2 (httpALPN)
-import Simplex.Messaging.Transport.Server (ServerCredentials (..), mkTransportServerConfig)
-import Simplex.Messaging.Util (eitherToMaybe, safeDecodeUtf8, tshow)
+import Simplex.Messaging.Transport.Server (TransportServerConfig (..), defaultTransportServerConfig)
+import Simplex.Messaging.Util (safeDecodeUtf8, tshow)
 import System.Directory (createDirectoryIfMissing, doesFileExist)
 import System.FilePath (combine)
 import System.IO (BufferMode (..), hSetBuffering, stderr, stdout)
@@ -52,15 +51,13 @@ xftpServerCLI cfgPath logPath = do
        True -> readIniFile iniFile >>= either exitError runServer
        _ -> exitError $ "Error: server is not initialized (" <> iniFile <> " does not exist).\nRun `" <> executableName <> " init`."
    Delete -> do
-      confirmOrExit
-        "WARNING: deleting the server will make all queues inaccessible, because the server identity (certificate fingerprint) will change.\nTHIS CANNOT BE UNDONE!"
-        "Server NOT deleted"
+      confirmOrExit "WARNING: deleting the server will make all queues inaccessible, because the server identity (certificate fingerprint) will change.\nTHIS CANNOT BE UNDONE!"
      deleteDirIfExists cfgPath
      deleteDirIfExists logPath
      putStrLn "Deleted configuration and log files"
  where
    iniFile = combine cfgPath "file-server.ini"
-    serverVersion = "SimpleX XFTP server v" <> simplexmqVersionCommit
+    serverVersion = "SimpleX XFTP server v" <> simplexMQVersion
    defaultServerPort = "443"
    executableName = "file-server"
    storeLogFilePath = combine logPath "file-server-store.log"
@@ -89,9 +86,6 @@ xftpServerCLI cfgPath logPath = do
            <> "# Expire files after the specified number of hours.\n"
            <> ("expire_files_hours: " <> tshow defFileExpirationHours <> "\n\n")
            <> "log_stats: off\n\
-               \\n\
-               \# Log interval for real-time Prometheus metrics\n\
-               \# prometheus_interval: 60\n\
               \\n\
               \[AUTH]\n\
               \# Set new_files option to off to completely prohibit uploading new files.\n\
@@ -107,7 +101,6 @@ xftpServerCLI cfgPath logPath = do
               \\n\
               \# control_port_admin_password:\n\
               \# control_port_user_password:\n\
-               \\n\
               \[TRANSPORT]\n\
               \# host is only used to print server address on start\n"
            <> ("host: " <> T.pack host <> "\n")
@@ -180,24 +173,19 @@ xftpServerCLI cfgPath logPath = do
                    { ttl = readStrictIni "INACTIVE_CLIENTS" "ttl" ini,
                      checkInterval = readStrictIni "INACTIVE_CLIENTS" "check_interval" ini
                    },
-              xftpCredentials =
-                ServerCredentials
-                  { caCertificateFile = Just $ c caCrtFile,
-                    privateKeyFile = c serverKeyFile,
-                    certificateFile = c serverCrtFile
-                  },
+              caCertificateFile = c caCrtFile,
+              privateKeyFile = c serverKeyFile,
+              certificateFile = c serverCrtFile,
              xftpServerVRange = supportedFileServerVRange,
              logStatsInterval = logStats $> 86400, -- seconds
              logStatsStartTime = 0, -- seconds from 00:00 UTC
              serverStatsLogFile = combine logPath "file-server-stats.daily.log",
              serverStatsBackupFile = logStats $> combine logPath "file-server-stats.log",
-              prometheusInterval = eitherToMaybe $ read . T.unpack <$> lookupValue "STORE_LOG" "prometheus_interval" ini,
-              prometheusMetricsFile = combine logPath "xftp-server-metrics.txt",
              transportConfig =
-                mkTransportServerConfig
-                  (fromMaybe False $ iniOnOff "TRANSPORT" "log_tls_errors" ini)
-                  (Just $ alpnSupportedXFTPhandshakes <> httpALPN)
-                  False,
+                defaultTransportServerConfig
+                  { logTLSErrors = fromMaybe False $ iniOnOff "TRANSPORT" "log_tls_errors" ini,
+                    alpn = Just supportedXFTPhandshakes
+                  },
              responseDelay = 0
            }

@@ -227,19 +215,14 @@ cliCommandP cfgPath logPath iniFile =
    )
  where
    initP :: Parser InitOptions
-    initP = do
-      enableStoreLog <-
-        flag' False
-          ( long "disable-store-log"
-              <> help "Disable store log for persistence (enabled by default)"
+    initP =
+      InitOptions
+        <$> switch
+          ( long "store-log"
+              <> short 'l'
+              <> help "Enable store log for persistence"
          )
-          <|> flag True True
-            ( long "store-log"
-                <> short 'l'
-                <> help "Enable store log for persistence (DEPRECATED, enabled by default)"
-            )
-      signAlgorithm <-
-        option
+        <*> option
          (maybeReader readMaybe)
          ( long "sign-algorithm"
              <> short 'a'
@@ -248,8 +231,7 @@ cliCommandP cfgPath logPath iniFile =
              <> showDefault
              <> metavar "ALG"
          )
-      ip <-
-        strOption
+        <*> strOption
          ( long "ip"
              <> help
                "Server IP address, used as Common Name for TLS online certificate if FQDN is not supplied"
@@ -257,26 +239,22 @@ cliCommandP cfgPath logPath iniFile =
              <> showDefault
              <> metavar "IP"
          )
-      fqdn <-
-        (optional . strOption)
+        <*> (optional . strOption)
          ( long "fqdn"
              <> short 'n'
              <> help "Server FQDN used as Common Name for TLS online certificate"
              <> showDefault
              <> metavar "FQDN"
          )
-      filesPath <-
-        strOption
+        <*> strOption
          ( long "path"
              <> short 'p'
              <> help "Path to the directory to store files"
              <> metavar "PATH"
          )
-      fileSizeQuota <-
-        strOption
+        <*> strOption
          ( long "quota"
              <> short 'q'
              <> help "File storage quota (e.g. 100gb)"
              <> metavar "QUOTA"
          )
-      pure InitOptions {enableStoreLog, signAlgorithm, ip, fqdn, filesPath, fileSizeQuota}
@@ -1,134 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeApplications #-}
-{-# OPTIONS_GHC -fno-warn-unrecognised-pragmas #-}
-
-module Simplex.FileTransfer.Server.Prometheus where
-
-import Data.Int (Int64)
-import Data.Text (Text)
-import qualified Data.Text as T
-import Data.Time.Clock (UTCTime (..), diffUTCTime)
-import Data.Time.Clock.System (systemEpochDay)
-import Data.Time.Format.ISO8601 (iso8601Show)
-import Simplex.FileTransfer.Server.Stats
-import Simplex.Messaging.Server.Stats (PeriodStatCounts (..))
-import Simplex.Messaging.Transport (simplexMQVersion)
-import Simplex.Messaging.Util (tshow)
-
-data FileServerMetrics = FileServerMetrics
-  { statsData :: FileServerStatsData,
-    filesDownloadedPeriods :: PeriodStatCounts,
-    rtsOptions :: Text
-  }
-
-rtsOptionsEnv :: Text
-rtsOptionsEnv = "XFTP_RTS_OPTIONS"
-
-{-# FOURMOLU_DISABLE\n#-}
-xftpPrometheusMetrics :: FileServerMetrics -> UTCTime -> Text
-xftpPrometheusMetrics sm ts =
-  time <> files <> info
-  where
-    FileServerMetrics {statsData, filesDownloadedPeriods, rtsOptions} = sm
-    FileServerStatsData
-      { _fromTime,
-        _filesCreated,
-        _fileRecipients,
-        _filesUploaded,
-        _filesExpired,
-        _filesDeleted,
-        _filesBlocked,
-        _fileDownloads,
-        _fileDownloadAcks,
-        _filesCount,
-        _filesSize
-      } = statsData
-    time =
-      "# Recorded at: " <> T.pack (iso8601Show ts) <> "\n\
-      \# Stats from: " <> T.pack (iso8601Show _fromTime) <> "\n\
-      \\n"
-    files =
-      "# Files\n\
-      \# -----\n\
-      \\n\
-      \# HELP simplex_xftp_files_created Created files\n\
-      \# TYPE simplex_xftp_files_created counter\n\
-      \simplex_xftp_files_created " <> mshow _filesCreated <> "\n\
-      \# filesCreated\n\
-      \\n\
-      \# HELP simplex_xftp_files_recipients Files recipients\n\
-      \# TYPE simplex_xftp_files_recipients counter\n\
-      \simplex_xftp_files_recipients " <> mshow _fileRecipients <> "\n\
-      \# fileRecipients\n\
-      \\n\
-      \# HELP simplex_xftp_files_uploaded Uploaded files\n\
-      \# TYPE simplex_xftp_files_uploaded counter\n\
-      \simplex_xftp_files_uploaded " <> mshow _filesUploaded <> "\n\
-      \# filesUploaded\n\
-      \\n\
-      \# HELP simplex_xftp_files_expired Expired files\n\
-      \# TYPE simplex_xftp_files_expired counter\n\
-      \simplex_xftp_files_expired " <> mshow _filesExpired <> "\n\
-      \# filesExpired\n\
-      \\n\
-      \# HELP simplex_xftp_files_deleted Deleted files\n\
-      \# TYPE simplex_xftp_files_deleted counter\n\
-      \simplex_xftp_files_deleted " <> mshow _filesDeleted <> "\n\
-      \# filesDeleted\n\
-      \\n\
-      \# HELP simplex_xftp_files_blocked Blocked files\n\
-      \# TYPE simplex_xftp_files_blocked counter\n\
-      \simplex_xftp_files_blocked " <> mshow _filesBlocked <> "\n\
-      \# filesBlocked\n\
-      \\n\
-      \# HELP simplex_xftp_file_downloads File downloads\n\
-      \# TYPE simplex_xftp_file_downloads counter\n\
-      \simplex_xftp_file_downloads " <> mshow _fileDownloads <> "\n\
-      \# fileDownloads\n\
-      \\n\
-      \# HELP simplex_xftp_file_download_acks File download ACKs\n\
-      \# TYPE simplex_xftp_file_download_acks counter\n\
-      \simplex_xftp_file_download_acks " <> mshow _fileDownloadAcks <> "\n\
-      \# fileDownloadAcks\n\
-      \\n\
-      \# HELP simplex_xftp_files_count_total Total files count \n\
-      \# TYPE simplex_xftp_files_count_total gauge\n\
-      \simplex_xftp_files_count_total " <> mshow _filesCount <> "\n\
-      \# filesCount\n\
-      \\n\
-      \# HELP simplex_xftp_files_size Size of files \n\
-      \# TYPE simplex_xftp_files_size gauge\n\
-      \simplex_xftp_files_size " <> mshow _filesSize <> "\n\
-      \# filesSize \n\
-      \\n\
-      \# HELP simplex_xftp_files_count_daily Daily files count\n\
-      \# TYPE simplex_xftp_files_count_daily gauge\n\
-      \simplex_xftp_files_count_daily " <> mstr (dayCount filesDownloadedPeriods) <> "\n\
-      \# filesDownloaded.dayCount\n\
-      \\n\
-      \# HELP simplex_xftp_files_count_weekly Weekly files count\n\
-      \# TYPE simplex_xftp_files_count_weekly gauge\n\
-      \simplex_xftp_files_count_weekly " <> mstr (weekCount filesDownloadedPeriods) <> "\n\
-      \# filesDownloaded.weekCount\n\
-      \\n\
-      \# HELP simplex_xftp_files_count_monthly Monthly files count\n\
-      \# TYPE simplex_xftp_files_count_monthly gauge\n\
-      \simplex_xftp_files_count_monthly " <> mstr (monthCount filesDownloadedPeriods) <> "\n\
-      \# filesDownloaded.monthCount\n\
-      \\n"
-    info =
-      "# Info\n\
-      \# ----\n\
-      \\n\
-      \# HELP simplex_xftp_info Server information. RTS options have to be passed via " <> rtsOptionsEnv <> " env var\n\
-      \# TYPE simplex_xftp_info gauge\n\
-      \simplex_xftp_info{version=\"" <> T.pack simplexMQVersion <> "\",rts_options=\"" <> rtsOptions <> "\"} 1\n\
-      \\n"
-    mstr a = a <> " " <> tsEpoch
-    mshow :: Show a => a -> Text
-    mshow = mstr . tshow
-    tsEpoch = tshow @Int64 $ floor @Double $ realToFrac (ts `diffUTCTime` epoch) * 1000
-    epoch = UTCTime systemEpochDay 0
-{-# FOURMOLU_ENABLE\n#-}
@@ -7,25 +7,25 @@ module Simplex.FileTransfer.Server.Stats where
 import Control.Applicative ((<|>))
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import qualified Data.ByteString.Char8 as B
-import Data.IORef
 import Data.Int (Int64)
 import Data.Time.Clock (UTCTime)
 import Simplex.Messaging.Encoding.String
+import Simplex.Messaging.Protocol (SenderId)
 import Simplex.Messaging.Server.Stats (PeriodStats, PeriodStatsData, getPeriodStatsData, newPeriodStats, setPeriodStats)
+import UnliftIO.STM

 data FileServerStats = FileServerStats
-  { fromTime :: IORef UTCTime,
-    filesCreated :: IORef Int,
-    fileRecipients :: IORef Int,
-    filesUploaded :: IORef Int,
-    filesExpired :: IORef Int,
-    filesDeleted :: IORef Int,
-    filesBlocked :: IORef Int,
-    filesDownloaded :: PeriodStats,
-    fileDownloads :: IORef Int,
-    fileDownloadAcks :: IORef Int,
-    filesCount :: IORef Int,
-    filesSize :: IORef Int64
+  { fromTime :: TVar UTCTime,
+    filesCreated :: TVar Int,
+    fileRecipients :: TVar Int,
+    filesUploaded :: TVar Int,
+    filesExpired :: TVar Int,
+    filesDeleted :: TVar Int,
+    filesDownloaded :: PeriodStats SenderId,
+    fileDownloads :: TVar Int,
+    fileDownloadAcks :: TVar Int,
+    filesCount :: TVar Int,
+    filesSize :: TVar Int64
  }

 data FileServerStatsData = FileServerStatsData
@@ -35,8 +35,7 @@ data FileServerStatsData = FileServerStatsData
    _filesUploaded :: Int,
    _filesExpired :: Int,
    _filesDeleted :: Int,
-    _filesBlocked :: Int,
-    _filesDownloaded :: PeriodStatsData,
+    _filesDownloaded :: PeriodStatsData SenderId,
    _fileDownloads :: Int,
    _fileDownloadAcks :: Int,
    _filesCount :: Int,
@@ -46,54 +45,50 @@ data FileServerStatsData = FileServerStatsData

 newFileServerStats :: UTCTime -> IO FileServerStats
 newFileServerStats ts = do
-  fromTime <- newIORef ts
-  filesCreated <- newIORef 0
-  fileRecipients <- newIORef 0
-  filesUploaded <- newIORef 0
-  filesExpired <- newIORef 0
-  filesDeleted <- newIORef 0
-  filesBlocked <- newIORef 0
+  fromTime <- newTVarIO ts
+  filesCreated <- newTVarIO 0
+  fileRecipients <- newTVarIO 0
+  filesUploaded <- newTVarIO 0
+  filesExpired <- newTVarIO 0
+  filesDeleted <- newTVarIO 0
  filesDownloaded <- newPeriodStats
-  fileDownloads <- newIORef 0
-  fileDownloadAcks <- newIORef 0
-  filesCount <- newIORef 0
-  filesSize <- newIORef 0
-  pure FileServerStats {fromTime, filesCreated, fileRecipients, filesUploaded, filesExpired, filesDeleted, filesBlocked, filesDownloaded, fileDownloads, fileDownloadAcks, filesCount, filesSize}
+  fileDownloads <- newTVarIO 0
+  fileDownloadAcks <- newTVarIO 0
+  filesCount <- newTVarIO 0
+  filesSize <- newTVarIO 0
+  pure FileServerStats {fromTime, filesCreated, fileRecipients, filesUploaded, filesExpired, filesDeleted, filesDownloaded, fileDownloads, fileDownloadAcks, filesCount, filesSize}

 getFileServerStatsData :: FileServerStats -> IO FileServerStatsData
 getFileServerStatsData s = do
-  _fromTime <- readIORef $ fromTime (s :: FileServerStats)
-  _filesCreated <- readIORef $ filesCreated s
-  _fileRecipients <- readIORef $ fileRecipients s
-  _filesUploaded <- readIORef $ filesUploaded s
-  _filesExpired <- readIORef $ filesExpired s
-  _filesDeleted <- readIORef $ filesDeleted s
-  _filesBlocked <- readIORef $ filesBlocked s
+  _fromTime <- readTVarIO $ fromTime (s :: FileServerStats)
+  _filesCreated <- readTVarIO $ filesCreated s
+  _fileRecipients <- readTVarIO $ fileRecipients s
+  _filesUploaded <- readTVarIO $ filesUploaded s
+  _filesExpired <- readTVarIO $ filesExpired s
+  _filesDeleted <- readTVarIO $ filesDeleted s
  _filesDownloaded <- getPeriodStatsData $ filesDownloaded s
-  _fileDownloads <- readIORef $ fileDownloads s
-  _fileDownloadAcks <- readIORef $ fileDownloadAcks s
-  _filesCount <- readIORef $ filesCount s
-  _filesSize <- readIORef $ filesSize s
-  pure FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesBlocked, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize}
+  _fileDownloads <- readTVarIO $ fileDownloads s
+  _fileDownloadAcks <- readTVarIO $ fileDownloadAcks s
+  _filesCount <- readTVarIO $ filesCount s
+  _filesSize <- readTVarIO $ filesSize s
+  pure FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize}

-- this function is not thread safe, it is used on server start only
-setFileServerStats :: FileServerStats -> FileServerStatsData -> IO ()
+setFileServerStats :: FileServerStats -> FileServerStatsData -> STM ()
 setFileServerStats s d = do
-  writeIORef (fromTime (s :: FileServerStats)) $! _fromTime (d :: FileServerStatsData)
-  writeIORef (filesCreated s) $! _filesCreated d
-  writeIORef (fileRecipients s) $! _fileRecipients d
-  writeIORef (filesUploaded s) $! _filesUploaded d
-  writeIORef (filesExpired s) $! _filesExpired d
-  writeIORef (filesDeleted s) $! _filesDeleted d
-  writeIORef (filesBlocked s) $! _filesBlocked d
+  writeTVar (fromTime (s :: FileServerStats)) $! _fromTime (d :: FileServerStatsData)
+  writeTVar (filesCreated s) $! _filesCreated d
+  writeTVar (fileRecipients s) $! _fileRecipients d
+  writeTVar (filesUploaded s) $! _filesUploaded d
+  writeTVar (filesExpired s) $! _filesExpired d
+  writeTVar (filesDeleted s) $! _filesDeleted d
  setPeriodStats (filesDownloaded s) $! _filesDownloaded d
-  writeIORef (fileDownloads s) $! _fileDownloads d
-  writeIORef (fileDownloadAcks s) $! _fileDownloadAcks d
-  writeIORef (filesCount s) $! _filesCount d
-  writeIORef (filesSize s) $! _filesSize d
+  writeTVar (fileDownloads s) $! _fileDownloads d
+  writeTVar (fileDownloadAcks s) $! _fileDownloadAcks d
+  writeTVar (filesCount s) $! _filesCount d
+  writeTVar (filesSize s) $! _filesSize d

 instance StrEncoding FileServerStatsData where
-  strEncode FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesBlocked, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize} =
+  strEncode FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize} =
    B.unlines
      [ "fromTime=" <> strEncode _fromTime,
        "filesCreated=" <> strEncode _filesCreated,
@@ -101,7 +96,6 @@ instance StrEncoding FileServerStatsData where
        "filesUploaded=" <> strEncode _filesUploaded,
        "filesExpired=" <> strEncode _filesExpired,
        "filesDeleted=" <> strEncode _filesDeleted,
-        "filesBlocked=" <> strEncode _filesBlocked,
        "filesCount=" <> strEncode _filesCount,
        "filesSize=" <> strEncode _filesSize,
        "filesDownloaded:",
@@ -116,12 +110,9 @@ instance StrEncoding FileServerStatsData where
    _filesUploaded <- "filesUploaded=" *> strP <* A.endOfLine
    _filesExpired <- "filesExpired=" *> strP <* A.endOfLine <|> pure 0
    _filesDeleted <- "filesDeleted=" *> strP <* A.endOfLine
-    _filesBlocked <- opt "filesBlocked="
    _filesCount <- "filesCount=" *> strP <* A.endOfLine <|> pure 0
    _filesSize <- "filesSize=" *> strP <* A.endOfLine <|> pure 0
    _filesDownloaded <- "filesDownloaded:" *> A.endOfLine *> strP <* A.endOfLine
    _fileDownloads <- "fileDownloads=" *> strP <* A.endOfLine
    _fileDownloadAcks <- "fileDownloadAcks=" *> strP <* A.endOfLine
-    pure FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesBlocked, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize}
-    where
-      opt s = A.string s *> strP <* A.endOfLine <|> pure 0
+    pure FileServerStatsData {_fromTime, _filesCreated, _fileRecipients, _filesUploaded, _filesExpired, _filesDeleted, _filesDownloaded, _fileDownloads, _fileDownloadAcks, _filesCount, _filesSize}
@@ -1,4 +1,3 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
@@ -9,34 +8,29 @@ module Simplex.FileTransfer.Server.Store
  ( FileStore (..),
    FileRec (..),
    FileRecipient (..),
-    RoundedFileTime,
    newFileStore,
    addFile,
    setFilePath,
    addRecipient,
    deleteFile,
-    blockFile,
    deleteRecipient,
    expiredFilePath,
    getFile,
    ackFile,
-    fileTimePrecision,
  )
 where

 import Control.Concurrent.STM
-import Control.Monad
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Int (Int64)
 import Data.Set (Set)
 import qualified Data.Set as S
+import Data.Time.Clock.System (SystemTime (..))
 import Simplex.FileTransfer.Protocol (FileInfo (..), SFileParty (..), XFTPFileId)
 import Simplex.FileTransfer.Transport (XFTPErrorType (..))
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String
-import Simplex.Messaging.Protocol (BlockingInfo, RcvPublicAuthKey, RecipientId, SenderId)
-import Simplex.Messaging.Server.QueueStore (ServerEntityStatus (..))
-import Simplex.Messaging.SystemTime
+import Simplex.Messaging.Protocol (RcvPublicAuthKey, RecipientId, SenderId)
 import Simplex.Messaging.TMap (TMap)
 import qualified Simplex.Messaging.TMap as TM
 import Simplex.Messaging.Util (ifM, ($>>=))
@@ -52,17 +46,10 @@ data FileRec = FileRec
    fileInfo :: FileInfo,
    filePath :: TVar (Maybe FilePath),
    recipientIds :: TVar (Set RecipientId),
-    createdAt :: RoundedFileTime,
-    fileStatus :: TVar ServerEntityStatus
+    createdAt :: SystemTime
  }

-type RoundedFileTime = RoundedSystemTime 3600
-
-fileTimePrecision :: Int64
-fileTimePrecision = 3600 -- truncate creation time to 1 hour
-
 data FileRecipient = FileRecipient RecipientId RcvPublicAuthKey
-  deriving (Show)

 instance StrEncoding FileRecipient where
  strEncode (FileRecipient rId rKey) = strEncode rId <> ":" <> strEncode rKey
@@ -75,19 +62,18 @@ newFileStore = do
  usedStorage <- newTVarIO 0
  pure FileStore {files, recipients, usedStorage}

-addFile :: FileStore -> SenderId -> FileInfo -> RoundedFileTime -> ServerEntityStatus -> STM (Either XFTPErrorType ())
-addFile FileStore {files} sId fileInfo createdAt status =
+addFile :: FileStore -> SenderId -> FileInfo -> SystemTime -> STM (Either XFTPErrorType ())
+addFile FileStore {files} sId fileInfo createdAt =
  ifM (TM.member sId files) (pure $ Left DUPLICATE_) $ do
-    f <- newFileRec sId fileInfo createdAt status
+    f <- newFileRec sId fileInfo createdAt
    TM.insert sId f files
    pure $ Right ()

-newFileRec :: SenderId -> FileInfo -> RoundedFileTime -> ServerEntityStatus -> STM FileRec
-newFileRec senderId fileInfo createdAt status = do
+newFileRec :: SenderId -> FileInfo -> SystemTime -> STM FileRec
+newFileRec senderId fileInfo createdAt = do
  recipientIds <- newTVar S.empty
  filePath <- newTVar Nothing
-  fileStatus <- newTVar status
-  pure FileRec {senderId, fileInfo, filePath, recipientIds, createdAt, fileStatus}
+  pure FileRec {senderId, fileInfo, filePath, recipientIds, createdAt}

 setFilePath :: FileStore -> SenderId -> FilePath -> STM (Either XFTPErrorType ())
 setFilePath st sId fPath =
@@ -118,14 +104,6 @@ deleteFile FileStore {files, recipients, usedStorage} senderId = do
      pure $ Right ()
    _ -> pure $ Left AUTH

-- this function must be called after the file is deleted from the file system
-blockFile :: FileStore -> SenderId -> BlockingInfo -> Bool -> STM (Either XFTPErrorType ())
-blockFile st@FileStore {usedStorage} senderId info deleted =
-  withFile st senderId $ \FileRec {fileInfo, fileStatus} -> do
-    when deleted $ modifyTVar' usedStorage $ subtract (fromIntegral $ size fileInfo)
-    writeTVar fileStatus $! EntityBlocked info
-    pure $ Right ()
-
 deleteRecipient :: FileStore -> RecipientId -> FileRec -> STM ()
 deleteRecipient FileStore {recipients} rId FileRec {recipientIds} = do
  TM.delete rId recipients
@@ -142,8 +120,8 @@ getFile st party fId = case party of
 expiredFilePath :: FileStore -> XFTPFileId -> Int64 -> STM (Maybe (Maybe FilePath))
 expiredFilePath FileStore {files} sId old =
  TM.lookup sId files
-    $>>= \FileRec {filePath, createdAt = RoundedSystemTime createdAt} ->
-      if createdAt + fileTimePrecision < old
+    $>>= \FileRec {filePath, createdAt} ->
+      if systemSeconds createdAt < old
        then Just <$> readTVar filePath
        else pure Nothing

@@ -14,63 +14,58 @@ module Simplex.FileTransfer.Server.StoreLog
    logPutFile,
    logAddRecipients,
    logDeleteFile,
-    logBlockFile,
    logAckFile,
  )
 where

-import Control.Applicative ((<|>))
 import Control.Concurrent.STM
 import Control.Monad.Except
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import qualified Data.ByteString.Char8 as B
 import qualified Data.ByteString.Lazy.Char8 as LB
-import Data.Composition ((.:), (.::))
+import Data.Composition ((.:), (.:.))
 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 Data.Time.Clock.System (SystemTime)
 import Simplex.FileTransfer.Protocol (FileInfo (..))
 import Simplex.FileTransfer.Server.Store
 import Simplex.Messaging.Encoding.String
-import Simplex.Messaging.Protocol (BlockingInfo, RcvPublicAuthKey, RecipientId, SenderId)
-import Simplex.Messaging.Server.QueueStore (ServerEntityStatus (..))
+import Simplex.Messaging.Protocol (RcvPublicAuthKey, RecipientId, SenderId)
 import Simplex.Messaging.Server.StoreLog
-import Simplex.Messaging.Util (bshow)
+import Simplex.Messaging.Util (bshow, whenM)
+import System.Directory (doesFileExist, renameFile)
 import System.IO

 data FileStoreLogRecord
-  = AddFile SenderId FileInfo RoundedFileTime ServerEntityStatus
+  = AddFile SenderId FileInfo SystemTime
  | PutFile SenderId FilePath
  | AddRecipients SenderId (NonEmpty FileRecipient)
  | DeleteFile SenderId
-  | BlockFile SenderId BlockingInfo
-  | AckFile RecipientId -- TODO add senderId as well?
-  deriving (Show)
+  | AckFile RecipientId

 instance StrEncoding FileStoreLogRecord where
  strEncode = \case
-    AddFile sId file createdAt status -> strEncode (Str "FNEW", sId, file, createdAt, status)
+    AddFile sId file createdAt -> strEncode (Str "FNEW", sId, file, createdAt)
    PutFile sId path -> strEncode (Str "FPUT", sId, path)
    AddRecipients sId rcps -> strEncode (Str "FADD", sId, rcps)
    DeleteFile sId -> strEncode (Str "FDEL", sId)
-    BlockFile sId info -> strEncode (Str "FBLK", sId, info)
    AckFile rId -> strEncode (Str "FACK", rId)
  strP =
    A.choice
-      [ "FNEW " *> (AddFile <$> strP_ <*> strP_ <*> strP <*> (_strP <|> pure EntityActive)),
+      [ "FNEW " *> (AddFile <$> strP_ <*> strP_ <*> strP),
        "FPUT " *> (PutFile <$> strP_ <*> strP),
        "FADD " *> (AddRecipients <$> strP_ <*> strP),
        "FDEL " *> (DeleteFile <$> strP),
-        "FBLK " *> (BlockFile <$> strP_ <*> strP),
        "FACK " *> (AckFile <$> strP)
      ]

 logFileStoreRecord :: StoreLog 'WriteMode -> FileStoreLogRecord -> IO ()
 logFileStoreRecord = writeStoreLogRecord

-logAddFile :: StoreLog 'WriteMode -> SenderId -> FileInfo -> RoundedFileTime -> ServerEntityStatus -> IO ()
-logAddFile s = logFileStoreRecord s .:: AddFile
+logAddFile :: StoreLog 'WriteMode -> SenderId -> FileInfo -> SystemTime -> IO ()
+logAddFile s = logFileStoreRecord s .:. AddFile

 logPutFile :: StoreLog 'WriteMode -> SenderId -> FilePath -> IO ()
 logPutFile s = logFileStoreRecord s .: PutFile
@@ -81,14 +76,17 @@ logAddRecipients s = logFileStoreRecord s .: AddRecipients
 logDeleteFile :: StoreLog 'WriteMode -> SenderId -> IO ()
 logDeleteFile s = logFileStoreRecord s . DeleteFile

-logBlockFile :: StoreLog 'WriteMode -> SenderId -> BlockingInfo -> IO ()
-logBlockFile s fId = logFileStoreRecord s . BlockFile fId
-
 logAckFile :: StoreLog 'WriteMode -> RecipientId -> IO ()
 logAckFile s = logFileStoreRecord s . AckFile

 readWriteFileStore :: FilePath -> FileStore -> IO (StoreLog 'WriteMode)
-readWriteFileStore = readWriteStoreLog readFileStore writeFileStore
+readWriteFileStore f st = do
+  whenM (doesFileExist f) $ do
+    readFileStore f st
+    renameFile f $ f <> ".bak"
+  s <- openWriteStoreLog f
+  writeFileStore s st
+  pure s

 readFileStore :: FilePath -> FileStore -> IO ()
 readFileStore f st = mapM_ (addFileLogRecord . LB.toStrict) . LB.lines =<< LB.readFile f
@@ -100,11 +98,10 @@ readFileStore f st = mapM_ (addFileLogRecord . LB.toStrict) . LB.lines =<< LB.re
          Left e -> B.putStrLn $ "Log processing error (" <> bshow e <> "): " <> B.take 100 s
          _ -> pure ()
    addToStore = \case
-      AddFile sId file createdAt status -> addFile st sId file createdAt status
+      AddFile sId file createdAt -> addFile st sId file createdAt
      PutFile qId path -> setFilePath st qId path
      AddRecipients sId rcps -> runExceptT $ addRecipients sId rcps
      DeleteFile sId -> deleteFile st sId
-      BlockFile sId info -> blockFile st sId info True
      AckFile rId -> ackFile st rId
    addRecipients sId rcps = mapM_ (ExceptT . addRecipient st sId) rcps

@@ -114,9 +111,8 @@ writeFileStore s FileStore {files, recipients} = do
  readTVarIO files >>= mapM_ (logFile allRcps)
  where
    logFile :: Map RecipientId (SenderId, RcvPublicAuthKey) -> FileRec -> IO ()
-    logFile allRcps FileRec {senderId, fileInfo, filePath, recipientIds, createdAt, fileStatus} = do
-      status <- readTVarIO fileStatus
-      logAddFile s senderId fileInfo createdAt status
+    logFile allRcps FileRec {senderId, fileInfo, filePath, recipientIds, createdAt} = do
+      logAddFile s senderId fileInfo createdAt
      (rcpErrs, rcps) <- M.mapEither getRcp . M.fromSet id <$> readTVarIO recipientIds
      mapM_ (logAddRecipients s senderId) $ L.nonEmpty $ M.elems rcps
      mapM_ (B.putStrLn . ("Error storing log: " <>)) rcpErrs
@@ -11,10 +11,7 @@
 module Simplex.FileTransfer.Transport
  ( supportedFileServerVRange,
    authCmdsXFTPVersion,
-    blockedFilesXFTPVersion,
    xftpClientHandshakeStub,
-    alpnSupportedXFTPhandshakes,
-    xftpALPNv1,
    XFTPClientHandshake (..),
    -- xftpClientHandshake,
    XFTPServerHandshake (..),
@@ -35,6 +32,7 @@ module Simplex.FileTransfer.Transport
  )
 where

+import Control.Applicative ((<|>))
 import qualified Control.Exception as E
 import Control.Logger.Simple
 import Control.Monad
@@ -43,7 +41,7 @@ import Control.Monad.IO.Class
 import Control.Monad.Trans.Except
 import qualified Data.Aeson.TH as J
 import qualified Data.Attoparsec.ByteString.Char8 as A
-import Data.Bifunctor (first)
+import Data.Bifunctor (bimap, first)
 import qualified Data.ByteArray as BA
 import Data.ByteString.Builder (Builder, byteString)
 import Data.ByteString.Char8 (ByteString)
@@ -51,14 +49,15 @@ import qualified Data.ByteString.Char8 as B
 import qualified Data.ByteString.Lazy.Char8 as LB
 import Data.Functor (($>))
 import Data.Word (Word16, Word32)
+import qualified Data.X509 as X
 import Network.HTTP2.Client (HTTP2Error)
 import qualified Simplex.Messaging.Crypto as C
 import qualified Simplex.Messaging.Crypto.Lazy as LC
 import Simplex.Messaging.Encoding
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers
-import Simplex.Messaging.Protocol (BlockingInfo, CommandError)
-import Simplex.Messaging.Transport (ALPN, CertChainPubKey, ServiceCredentials, SessionId, THandle (..), THandleParams (..), TransportError (..), TransportPeer (..))
+import Simplex.Messaging.Protocol (CommandError)
+import Simplex.Messaging.Transport (SessionId, THandle (..), THandleParams (..), TransportError (..), TransportPeer (..))
 import Simplex.Messaging.Transport.HTTP2.File
 import Simplex.Messaging.Util (bshow, tshow)
 import Simplex.Messaging.Version
@@ -92,30 +91,21 @@ initialXFTPVersion = VersionXFTP 1
 authCmdsXFTPVersion :: VersionXFTP
 authCmdsXFTPVersion = VersionXFTP 2

-blockedFilesXFTPVersion :: VersionXFTP
-blockedFilesXFTPVersion = VersionXFTP 3
-
 currentXFTPVersion :: VersionXFTP
-currentXFTPVersion = VersionXFTP 3
+currentXFTPVersion = VersionXFTP 2

 supportedFileServerVRange :: VersionRangeXFTP
 supportedFileServerVRange = mkVersionRange initialXFTPVersion currentXFTPVersion

 -- XFTP protocol does not use this handshake method
-xftpClientHandshakeStub :: c 'TClient -> Maybe C.KeyPairX25519 -> C.KeyHash -> VersionRangeXFTP -> Bool -> Maybe (ServiceCredentials, C.KeyPairEd25519) -> ExceptT TransportError IO (THandle XFTPVersion c 'TClient)
-xftpClientHandshakeStub _c _ks _keyHash _xftpVRange _proxyServer _serviceKeys = throwE TEVersion
-
-alpnSupportedXFTPhandshakes :: [ALPN]
-alpnSupportedXFTPhandshakes = [xftpALPNv1]
-
-xftpALPNv1 :: ALPN
-xftpALPNv1 = "xftp/1"
+xftpClientHandshakeStub :: c -> Maybe C.KeyPairX25519 -> C.KeyHash -> VersionRangeXFTP -> ExceptT TransportError IO (THandle XFTPVersion c 'TClient)
+xftpClientHandshakeStub _c _ks _keyHash _xftpVRange = throwE TEVersion

 data XFTPServerHandshake = XFTPServerHandshake
  { xftpVersionRange :: VersionRangeXFTP,
    sessionId :: SessionId,
    -- | pub key to agree shared secrets for command authorization and entity ID encryption.
-    authPubKey :: CertChainPubKey
+    authPubKey :: (X.CertificateChain, X.SignedExact X.PubKey)
  }

 data XFTPClientHandshake = XFTPClientHandshake
@@ -135,12 +125,15 @@ instance Encoding XFTPClientHandshake where

 instance Encoding XFTPServerHandshake where
  smpEncode XFTPServerHandshake {xftpVersionRange, sessionId, authPubKey} =
-    smpEncode (xftpVersionRange, sessionId, authPubKey)
+    smpEncode (xftpVersionRange, sessionId, auth)
+    where
+      auth = bimap C.encodeCertChain C.SignedObject authPubKey
  smpP = do
    (xftpVersionRange, sessionId) <- smpP
-    authPubKey <- smpP
+    cert <- C.certChainP
+    C.SignedObject key <- smpP
    Tail _compat <- smpP
-    pure XFTPServerHandshake {xftpVersionRange, sessionId, authPubKey}
+    pure XFTPServerHandshake {xftpVersionRange, sessionId, authPubKey = (cert, key)}

 sendEncFile :: Handle -> (Builder -> IO ()) -> LC.SbState -> Word32 -> IO ()
 sendEncFile h send = go
@@ -214,8 +207,6 @@ data XFTPErrorType
    CMD {cmdErr :: CommandError}
  | -- | command authorization error - bad signature or non-existing SMP queue
    AUTH
-  | -- | command with the entity that was blocked
-    BLOCKED {blockInfo :: BlockingInfo}
  | -- | incorrent file size
    SIZE
  | -- | storage quota exceeded
@@ -236,46 +227,15 @@ data XFTPErrorType
    INTERNAL
  | -- | used internally, never returned by the server (to be removed)
    DUPLICATE_ -- not part of SMP protocol, used internally
-  deriving (Eq, Show)
+  deriving (Eq, Read, Show)

 instance StrEncoding XFTPErrorType where
  strEncode = \case
-    BLOCK -> "BLOCK"
-    SESSION -> "SESSION"
-    HANDSHAKE -> "HANDSHAKE"
    CMD e -> "CMD " <> bshow e
-    AUTH -> "AUTH"
-    BLOCKED info -> "BLOCKED " <> strEncode info
-    SIZE -> "SIZE"
-    QUOTA -> "QUOTA"
-    DIGEST -> "DIGEST"
-    CRYPTO -> "CRYPTO"
-    NO_FILE -> "NO_FILE"
-    HAS_FILE -> "HAS_FILE"
-    FILE_IO -> "FILE_IO"
-    TIMEOUT -> "TIMEOUT"
-    INTERNAL -> "INTERNAL"
-    DUPLICATE_ -> "DUPLICATE_"
-
+    e -> bshow e
  strP =
-    A.takeTill (== ' ') >>= \case
-      "BLOCK" -> pure BLOCK
-      "SESSION" -> pure SESSION
-      "HANDSHAKE" -> pure HANDSHAKE
-      "CMD" -> CMD <$> parseRead1
-      "AUTH" -> pure AUTH
-      "BLOCKED" -> BLOCKED <$> _strP
-      "SIZE" -> pure SIZE
-      "QUOTA" -> pure QUOTA
-      "DIGEST" -> pure DIGEST
-      "CRYPTO" -> pure CRYPTO
-      "NO_FILE" -> pure NO_FILE
-      "HAS_FILE" -> pure HAS_FILE
-      "FILE_IO" -> pure FILE_IO
-      "TIMEOUT" -> pure TIMEOUT
-      "INTERNAL" -> pure INTERNAL
-      "DUPLICATE_" -> pure DUPLICATE_
-      _ -> fail "bad error type"
+    "CMD " *> (CMD <$> parseRead1)
+      <|> parseRead1

 instance Encoding XFTPErrorType where
  smpEncode = \case
@@ -284,7 +244,6 @@ instance Encoding XFTPErrorType where
    HANDSHAKE -> "HANDSHAKE"
    CMD err -> "CMD " <> smpEncode err
    AUTH -> "AUTH"
-    BLOCKED info -> "BLOCKED " <> smpEncode info
    SIZE -> "SIZE"
    QUOTA -> "QUOTA"
    DIGEST -> "DIGEST"
@@ -303,7 +262,6 @@ instance Encoding XFTPErrorType where
      "HANDSHAKE" -> pure HANDSHAKE
      "CMD" -> CMD <$> _smpP
      "AUTH" -> pure AUTH
-      "BLOCKED" -> BLOCKED <$> _smpP
      "SIZE" -> pure SIZE
      "QUOTA" -> pure QUOTA
      "DIGEST" -> pure DIGEST
@@ -13,9 +13,10 @@ import Data.Int (Int64)
 import qualified Data.Text as T
 import Data.Text.Encoding (encodeUtf8)
 import Data.Word (Word32)
+import Database.SQLite.Simple.FromField (FromField (..))
+import Database.SQLite.Simple.ToField (ToField (..))
 import Simplex.FileTransfer.Client (XFTPChunkSpec (..))
 import Simplex.FileTransfer.Description
-import Simplex.Messaging.Agent.Store.DB (FromField (..), ToField (..), fromTextField_)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.File (CryptoFile (..))
 import Simplex.Messaging.Encoding
@@ -24,9 +25,9 @@ import Simplex.Messaging.Parsers
 import Simplex.Messaging.Protocol (XFTPServer)
 import System.FilePath ((</>))

-type RcvFileId = ByteString -- Agent entity ID
+type RcvFileId = ByteString

-type SndFileId = ByteString -- Agent entity ID
+type SndFileId = ByteString

 authTagSize :: Int64
 authTagSize = fromIntegral C.authTagSize
@@ -245,16 +246,6 @@ data DeletedSndChunkReplica = DeletedSndChunkReplica
  }
  deriving (Show)

-data SentRecipientReplica = SentRecipientReplica
-  { chunkNo :: Int,
-    server :: XFTPServer,
-    rcvNo :: Int,
-    replicaId :: ChunkReplicaId,
-    replicaKey :: C.APrivateAuthKey,
-    digest :: FileDigest,
-    chunkSize :: FileSize Word32
-  }
-
 data FileErrorType
  = -- | cannot proceed with download from not approved relays without proxy
    NOT_APPROVED
@@ -17,16 +17,18 @@ module Simplex.Messaging.Agent.Env.SQLite
    AgentConfig (..),
    InitialAgentServers (..),
    ServerCfg (..),
-    ServerRoles (..),
-    OperatorId,
    UserServers (..),
    NetworkConfig (..),
    presetServerCfg,
-    allRoles,
+    enabledServerCfg,
    mkUserServers,
-    serverHosts,
    defaultAgentConfig,
    defaultReconnectInterval,
+    tryAgentError,
+    tryAgentError',
+    catchAgentError,
+    catchAgentError',
+    agentFinally,
    Env (..),
    newSMPAgentEnv,
    createAgentStore,
@@ -39,20 +41,18 @@ module Simplex.Messaging.Agent.Env.SQLite
  )
 where

-import Control.Concurrent (ThreadId)
 import Control.Monad.Except
 import Control.Monad.IO.Unlift
 import Control.Monad.Reader
 import Crypto.Random
 import Data.Aeson (FromJSON (..), ToJSON (..))
 import qualified Data.Aeson.TH as JQ
+import Data.ByteArray (ScrubbedBytes)
 import Data.Int (Int64)
 import Data.List.NonEmpty (NonEmpty)
 import qualified Data.List.NonEmpty as L
 import Data.Map.Strict (Map)
 import Data.Maybe (fromMaybe)
-import Data.Set (Set)
-import qualified Data.Set as S
 import Data.Time.Clock (NominalDiffTime, nominalDay)
 import Data.Time.Clock.System (SystemTime (..))
 import Data.Word (Word16)
@@ -61,10 +61,8 @@ import Numeric.Natural
 import Simplex.FileTransfer.Client (XFTPClientConfig (..), defaultXFTPClientConfig)
 import Simplex.Messaging.Agent.Protocol
 import Simplex.Messaging.Agent.RetryInterval
-import Simplex.Messaging.Agent.Store (createStore)
-import Simplex.Messaging.Agent.Store.Common (DBStore)
-import Simplex.Messaging.Agent.Store.Interface (DBOpts)
-import Simplex.Messaging.Agent.Store.Shared (MigrationConfig (..), MigrationError (..))
+import Simplex.Messaging.Agent.Store.SQLite
+import qualified Simplex.Messaging.Agent.Store.SQLite.Migrations as Migrations
 import Simplex.Messaging.Client
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Crypto.Ratchet (VersionRangeE2E, supportedE2EEncryptVRange)
@@ -72,13 +70,14 @@ import Simplex.Messaging.Notifications.Client (defaultNTFClientConfig)
 import Simplex.Messaging.Notifications.Transport (NTFVersion)
 import Simplex.Messaging.Notifications.Types
 import Simplex.Messaging.Parsers (defaultJSON)
-import Simplex.Messaging.Protocol (NtfServer, ProtoServerWithAuth (..), ProtocolServer (..), ProtocolType (..), ProtocolTypeI, VersionRangeSMPC, XFTPServer, supportedSMPClientVRange)
+import Simplex.Messaging.Protocol (NtfServer, ProtoServerWithAuth, ProtocolServer, ProtocolType (..), ProtocolTypeI, VersionRangeSMPC, XFTPServer, supportedSMPClientVRange)
 import Simplex.Messaging.TMap (TMap)
 import qualified Simplex.Messaging.TMap as TM
-import Simplex.Messaging.Transport (SMPVersion)
-import Simplex.Messaging.Transport.Client (TransportHost)
-import System.Mem.Weak (Weak)
+import Simplex.Messaging.Transport (SMPVersion, TLS, Transport (..))
+import Simplex.Messaging.Transport.Client (defaultSMPPort)
+import Simplex.Messaging.Util (allFinally, catchAllErrors, catchAllErrors', tryAllErrors, tryAllErrors')
 import System.Random (StdGen, newStdGen)
+import UnliftIO (Async, SomeException)
 import UnliftIO.STM

 type AM' a = ReaderT Env IO a
@@ -89,49 +88,34 @@ data InitialAgentServers = InitialAgentServers
  { smp :: Map UserId (NonEmpty (ServerCfg 'PSMP)),
    ntf :: [NtfServer],
    xftp :: Map UserId (NonEmpty (ServerCfg 'PXFTP)),
-    netCfg :: NetworkConfig,
-    presetDomains :: [HostName],
-    presetServers :: [SMPServer]
+    netCfg :: NetworkConfig
  }

 data ServerCfg p = ServerCfg
  { server :: ProtoServerWithAuth p,
-    operator :: Maybe OperatorId,
-    enabled :: Bool,
-    roles :: ServerRoles
+    preset :: Bool,
+    tested :: Maybe Bool,
+    enabled :: Bool
  }
  deriving (Show)

-data ServerRoles = ServerRoles
-  { storage :: Bool,
-    proxy :: Bool
-  }
-  deriving (Show)
+enabledServerCfg :: ProtoServerWithAuth p -> ServerCfg p
+enabledServerCfg server = ServerCfg {server, preset = False, tested = Nothing, enabled = True}

-allRoles :: ServerRoles
-allRoles = ServerRoles True True
-
-presetServerCfg :: Bool -> ServerRoles -> Maybe OperatorId -> ProtoServerWithAuth p -> ServerCfg p
-presetServerCfg enabled roles operator server =
-  ServerCfg {server, operator, enabled, roles}
+presetServerCfg :: Bool -> ProtoServerWithAuth p -> ServerCfg p
+presetServerCfg enabled server = ServerCfg {server, preset = True, tested = Nothing, enabled}

 data UserServers p = UserServers
-  { storageSrvs :: NonEmpty (Maybe OperatorId, ProtoServerWithAuth p),
-    proxySrvs :: NonEmpty (Maybe OperatorId, ProtoServerWithAuth p),
-    knownHosts :: Set TransportHost
+  { enabledSrvs :: NonEmpty (ProtoServerWithAuth p),
+    knownSrvs :: NonEmpty (ProtocolServer p)
  }

-type OperatorId = Int64
-
 -- This function sets all servers as enabled in case all passed servers are disabled.
 mkUserServers :: NonEmpty (ServerCfg p) -> UserServers p
-mkUserServers srvs = UserServers {storageSrvs = filterSrvs storage, proxySrvs = filterSrvs proxy, knownHosts}
+mkUserServers srvs = UserServers {enabledSrvs, knownSrvs}
  where
-    filterSrvs role = L.map (\ServerCfg {operator, server} -> (operator, server)) $ fromMaybe srvs $ L.nonEmpty $ L.filter (\ServerCfg {enabled, roles} -> enabled && role roles) srvs
-    knownHosts = S.unions $ L.map (\ServerCfg {server = ProtoServerWithAuth srv _} -> serverHosts srv) srvs
-
-serverHosts :: ProtocolServer p -> Set TransportHost
-serverHosts ProtocolServer {host} = S.fromList $ L.toList host
+    enabledSrvs = L.map (\ServerCfg {server} -> server) $ fromMaybe srvs $ L.nonEmpty $ L.filter (\ServerCfg {enabled} -> enabled) srvs
+    knownSrvs = L.map (\ServerCfg {server = ProtoServerWithAuth srv _} -> srv) srvs

 data AgentConfig = AgentConfig
  { tcpPort :: Maybe ServiceName,
@@ -164,10 +148,7 @@ data AgentConfig = AgentConfig
    xftpMaxRecipientsPerRequest :: Int,
    deleteErrorCount :: Int,
    ntfCron :: Word16,
-    ntfBatchSize :: Int,
-    ntfSubFirstCheckInterval :: NominalDiffTime,
    ntfSubCheckInterval :: NominalDiffTime,
-    maxPendingSubscriptions :: Int,
    caCertificateFile :: FilePath,
    privateKeyFile :: FilePath,
    certificateFile :: FilePath,
@@ -210,9 +191,9 @@ defaultAgentConfig =
      rcvAuthAlg = C.AuthAlg C.SEd25519, -- this will stay as Ed25519
      sndAuthAlg = C.AuthAlg C.SEd25519, -- TODO replace with X25519 when switching to v7
      connIdBytes = 12,
-      tbqSize = 128,
-      smpCfg = defaultSMPClientConfig,
-      ntfCfg = defaultNTFClientConfig,
+      tbqSize = 64,
+      smpCfg = defaultSMPClientConfig {defaultTransport = (show defaultSMPPort, transport @TLS)},
+      ntfCfg = defaultNTFClientConfig {defaultTransport = ("443", transport @TLS)},
      xftpCfg = defaultXFTPClientConfig,
      reconnectInterval = defaultReconnectInterval,
      messageRetryInterval = defaultMessageRetryInterval,
@@ -236,10 +217,7 @@ defaultAgentConfig =
      xftpMaxRecipientsPerRequest = 200,
      deleteErrorCount = 10,
      ntfCron = 20, -- minutes
-      ntfBatchSize = 150,
-      ntfSubFirstCheckInterval = nominalDay,
-      ntfSubCheckInterval = 3 * nominalDay,
-      maxPendingSubscriptions = 35000,
+      ntfSubCheckInterval = nominalDay,
      -- CA certificate private key is not needed for initialization
      -- ! we do not generate these
      caCertificateFile = "/etc/opt/simplex-agent/ca.crt",
@@ -252,7 +230,7 @@ defaultAgentConfig =

 data Env = Env
  { config :: AgentConfig,
-    store :: DBStore,
+    store :: SQLiteStore,
    random :: TVar ChaChaDRG,
    randomServer :: TVar StdGen,
    ntfSupervisor :: NtfSupervisor,
@@ -260,7 +238,7 @@ data Env = Env
    multicastSubscribers :: TMVar Int
  }

-newSMPAgentEnv :: AgentConfig -> DBStore -> IO Env
+newSMPAgentEnv :: AgentConfig -> SQLiteStore -> IO Env
 newSMPAgentEnv config store = do
  random <- C.newRandom
  randomServer <- newTVarIO =<< liftIO newStdGen
@@ -269,18 +247,17 @@ newSMPAgentEnv config store = do
  multicastSubscribers <- newTMVarIO 0
  pure Env {config, store, random, randomServer, ntfSupervisor, xftpAgent, multicastSubscribers}

-createAgentStore :: DBOpts -> MigrationConfig -> IO (Either MigrationError DBStore)
-createAgentStore = createStore
+createAgentStore :: FilePath -> ScrubbedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError SQLiteStore)
+createAgentStore dbFilePath dbKey keepKey = createSQLiteStore dbFilePath dbKey keepKey Migrations.app

 data NtfSupervisor = NtfSupervisor
  { ntfTkn :: TVar (Maybe NtfToken),
-    ntfSubQ :: TBQueue (NtfSupervisorCommand, NonEmpty ConnId),
+    ntfSubQ :: TBQueue (ConnId, NtfSupervisorCommand),
    ntfWorkers :: TMap NtfServer Worker,
-    ntfSMPWorkers :: TMap SMPServer Worker,
-    ntfTknDelWorkers :: TMap NtfServer Worker
+    ntfSMPWorkers :: TMap SMPServer Worker
  }

-data NtfSupervisorCommand = NSCCreate | NSCSmpDelete | NSCDeleteSub
+data NtfSupervisorCommand = NSCCreate | NSCDelete | NSCSmpDelete | NSCNtfWorker NtfServer | NSCNtfSMPWorker SMPServer
  deriving (Show)

 newNtfSubSupervisor :: Natural -> IO NtfSupervisor
@@ -289,8 +266,7 @@ newNtfSubSupervisor qSize = do
  ntfSubQ <- newTBQueueIO qSize
  ntfWorkers <- TM.emptyIO
  ntfSMPWorkers <- TM.emptyIO
-  ntfTknDelWorkers <- TM.emptyIO
-  pure NtfSupervisor {ntfTkn, ntfSubQ, ntfWorkers, ntfSMPWorkers, ntfTknDelWorkers}
+  pure NtfSupervisor {ntfTkn, ntfSubQ, ntfWorkers, ntfSMPWorkers}

 data XFTPAgent = XFTPAgent
  { -- if set, XFTP file paths will be considered as relative to this directory
@@ -308,10 +284,35 @@ newXFTPAgent = do
  xftpDelWorkers <- TM.emptyIO
  pure XFTPAgent {xftpWorkDir, xftpRcvWorkers, xftpSndWorkers, xftpDelWorkers}

+tryAgentError :: AM a -> AM (Either AgentErrorType a)
+tryAgentError = tryAllErrors mkInternal
+{-# INLINE tryAgentError #-}
+
+-- unlike runExceptT, this ensures we catch IO exceptions as well
+tryAgentError' :: AM a -> AM' (Either AgentErrorType a)
+tryAgentError' = tryAllErrors' mkInternal
+{-# INLINE tryAgentError' #-}
+
+catchAgentError :: AM a -> (AgentErrorType -> AM a) -> AM a
+catchAgentError = catchAllErrors mkInternal
+{-# INLINE catchAgentError #-}
+
+catchAgentError' :: AM a -> (AgentErrorType -> AM' a) -> AM' a
+catchAgentError' = catchAllErrors' mkInternal
+{-# INLINE catchAgentError' #-}
+
+agentFinally :: AM a -> AM b -> AM a
+agentFinally = allFinally mkInternal
+{-# INLINE agentFinally #-}
+
+mkInternal :: SomeException -> AgentErrorType
+mkInternal = INTERNAL . show
+{-# INLINE mkInternal #-}
+
 data Worker = Worker
  { workerId :: Int,
    doWork :: TMVar (),
-    action :: TMVar (Maybe (Weak ThreadId)),
+    action :: TMVar (Maybe (Async ())),
    restarts :: TVar RestartCount
  }

@@ -327,8 +328,6 @@ updateRestartCount t (RestartCount minute count) = do

 $(pure [])

-$(JQ.deriveJSON defaultJSON ''ServerRoles)
-
 instance ProtocolTypeI p => ToJSON (ServerCfg p) where
  toEncoding = $(JQ.mkToEncoding defaultJSON ''ServerCfg)
  toJSON = $(JQ.mkToJSON defaultJSON ''ServerCfg)
@@ -1,12 +1,10 @@
 module Simplex.Messaging.Agent.Lock
  ( Lock,
    createLock,
-    createLockIO,
    withLock,
    withLock',
    withGetLock,
    withGetLocks,
-    getPutLock,
  )
 where

@@ -16,39 +14,34 @@ import Control.Monad.IO.Unlift
 import Data.Functor (($>))
 import Data.Set (Set)
 import qualified Data.Set as S
-import Data.Text (Text)
 import UnliftIO.Async (forConcurrently)
 import qualified UnliftIO.Exception as E
 import UnliftIO.STM

-type Lock = TMVar Text
+type Lock = TMVar String

 createLock :: STM Lock
 createLock = newEmptyTMVar
 {-# INLINE createLock #-}

-createLockIO :: IO Lock
-createLockIO = newEmptyTMVarIO
-{-# INLINE createLockIO #-}
-
-withLock :: MonadUnliftIO m => Lock -> Text -> ExceptT e m a -> ExceptT e m a
+withLock :: MonadUnliftIO m => Lock -> String -> ExceptT e m a -> ExceptT e m a
 withLock lock name = ExceptT . withLock' lock name . runExceptT
 {-# INLINE withLock #-}

-withLock' :: MonadUnliftIO m => Lock -> Text -> m a -> m a
+withLock' :: MonadUnliftIO m => Lock -> String -> m a -> m a
 withLock' lock name =
  E.bracket_
    (atomically $ putTMVar lock name)
    (void . atomically $ takeTMVar lock)

-withGetLock :: MonadUnliftIO m => (k -> STM Lock) -> k -> Text -> m a -> m a
+withGetLock :: MonadUnliftIO m => (k -> STM Lock) -> k -> String -> m a -> m a
 withGetLock getLock key name a =
  E.bracket
    (atomically $ getPutLock getLock key name)
    (atomically . takeTMVar)
    (const a)

-withGetLocks :: MonadUnliftIO m => (k -> STM Lock) -> Set k -> Text -> m a -> m a
+withGetLocks :: MonadUnliftIO m => (k -> STM Lock) -> Set k -> String -> m a -> m a
 withGetLocks getLock keys name = E.bracket holdLocks releaseLocks . const
  where
    holdLocks = forConcurrently (S.toList keys) $ \key -> atomically $ getPutLock getLock key name
@@ -56,5 +49,5 @@ withGetLocks getLock keys name = E.bracket holdLocks releaseLocks . const

 -- getLock and putTMVar can be in one transaction on the assumption that getLock doesn't write in case the lock already exists,
 -- and in case it is created and added to some shared resource (we use TMap) it also helps avoid contention for the newly created lock.
-getPutLock :: (k -> STM Lock) -> k -> Text -> STM Lock
+getPutLock :: (k -> STM Lock) -> k -> String -> STM Lock
 getPutLock getLock key name = getLock key >>= \l -> putTMVar l name $> l
@@ -1,9 +1,7 @@
-{-# LANGUAGE DataKinds #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedLists #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TupleSections #-}
@@ -14,9 +12,7 @@ module Simplex.Messaging.Agent.NtfSubSupervisor
    nsUpdateToken,
    nsRemoveNtfToken,
    sendNtfSubCommand,
-    hasInstantNotifications,
    instantNotifications,
-    deleteToken,
    closeNtfSupervisor,
    getNtfServer,
  )
@@ -26,33 +22,23 @@ import Control.Logger.Simple (logError, logInfo)
 import Control.Monad
 import Control.Monad.Reader
 import Control.Monad.Trans.Except
-import Crypto.Random (ChaChaDRG)
 import Data.Bifunctor (first)
-import Data.Either (fromRight, partitionEithers)
-import Data.Functor (($>))
-import Data.List (foldl')
-import Data.List.NonEmpty (NonEmpty (..))
-import qualified Data.List.NonEmpty as L
 import qualified Data.Map.Strict as M
-import Data.Maybe (catMaybes)
-import qualified Data.Set as S
+import Data.Text (Text)
 import Data.Time (UTCTime, addUTCTime, getCurrentTime)
 import Data.Time.Clock (diffUTCTime)
 import Simplex.Messaging.Agent.Client
 import Simplex.Messaging.Agent.Env.SQLite
-import Simplex.Messaging.Agent.Protocol
+import Simplex.Messaging.Agent.Protocol (AEvent (..), AEvt (..), AgentErrorType (..), BrokerErrorType (..), ConnId, NotificationsMode (..), SAEntity (..))
 import Simplex.Messaging.Agent.RetryInterval
 import Simplex.Messaging.Agent.Stats
 import Simplex.Messaging.Agent.Store
-import Simplex.Messaging.Agent.Store.AgentStore
-import qualified Simplex.Messaging.Agent.Store.DB as DB
-import Simplex.Messaging.Client (NetworkRequestMode (..))
+import Simplex.Messaging.Agent.Store.SQLite
 import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Notifications.Protocol
+import Simplex.Messaging.Notifications.Protocol (NtfSubStatus (..), NtfTknStatus (..), SMPQueueNtf (..))
 import Simplex.Messaging.Notifications.Types
-import Simplex.Messaging.Protocol (NtfServer, sameSrvAddr)
-import qualified Simplex.Messaging.Protocol as SMP
-import Simplex.Messaging.Util (catchAllErrors, diffToMicroseconds, threadDelay', tryAllErrors, tshow, whenM)
+import Simplex.Messaging.Protocol (NtfServer, SMPServer, sameSrvAddr)
+import Simplex.Messaging.Util (diffToMicroseconds, threadDelay', tshow, unlessM)
 import System.Random (randomR)
 import UnliftIO
 import UnliftIO.Concurrent (forkIO)
@@ -61,134 +47,91 @@ import qualified UnliftIO.Exception as E
 runNtfSupervisor :: AgentClient -> AM' ()
 runNtfSupervisor c = do
  ns <- asks ntfSupervisor
-  runExceptT startTknDelete >>= \case
-    Left e -> notifyErr e
-    Right _ -> pure ()
  forever $ do
-    cmd <- atomically . readTBQueue $ ntfSubQ ns
-    handleErr . agentOperationBracket c AONtfNetwork waitUntilActive $
-      runExceptT (processNtfCmd c cmd) >>= \case
-        Left e -> notifyErr e
+    cmd@(connId, _) <- atomically . readTBQueue $ ntfSubQ ns
+    handleErr connId . agentOperationBracket c AONtfNetwork waitUntilActive $
+      runExceptT (processNtfSub c cmd) >>= \case
+        Left e -> notifyErr connId e
        Right _ -> return ()
  where
-    startTknDelete :: AM ()
-    startTknDelete = do
-      pendingDelServers <- withStore' c getPendingDelTknServers
-      lift . forM_ pendingDelServers $ getNtfTknDelWorker True c
-    handleErr :: AM' () -> AM' ()
-    handleErr = E.handle $ \(e :: E.SomeException) -> do
+    handleErr :: ConnId -> AM' () -> AM' ()
+    handleErr connId = E.handle $ \(e :: E.SomeException) -> do
      logError $ "runNtfSupervisor error " <> tshow e
-      notifyErr e
-    notifyErr e = notifyInternalError' c $ "runNtfSupervisor error " <> show e
+      notifyErr connId e
+    notifyErr connId e = notifyInternalError c connId $ "runNtfSupervisor error " <> show e

-partitionErrs :: (a -> ConnId) -> [a] -> [Either AgentErrorType b] -> ([(ConnId, AgentErrorType)], [b])
-partitionErrs f xs = partitionEithers . zipWith (\x -> first (f x,)) xs
-{-# INLINE partitionErrs #-}
-
-ntfSubConnId :: NtfSubscription -> ConnId
-ntfSubConnId NtfSubscription {connId} = connId
-
-processNtfCmd :: AgentClient -> (NtfSupervisorCommand, NonEmpty ConnId) -> AM ()
-processNtfCmd c (cmd, connIds) = do
-  logInfo $ "processNtfCmd - cmd = " <> tshow cmd
-  let connIds' = L.toList connIds
+processNtfSub :: AgentClient -> (ConnId, NtfSupervisorCommand) -> AM ()
+processNtfSub c (connId, cmd) = do
+  logInfo $ "processNtfSub - connId = " <> tshow connId <> " - cmd = " <> tshow cmd
  case cmd of
    NSCCreate -> do
-      (cErrs, rqSubActions) <- lift $ partitionErrs id connIds' <$> withStoreBatch c (\db -> map (getQueueSub db) connIds')
-      notifyErrs c cErrs
-      logInfo $ "processNtfCmd, NSCCreate - length rqSubs = " <> tshow (length rqSubActions)
-      let (ns, rs, css, cns) = partitionQueueSubActions rqSubActions
-      createNewSubs ns
-      resetSubs rs
-      lift $ do
-        mapM_ (getNtfSMPWorker True c) (S.fromList css)
-        mapM_ (getNtfNTFWorker True c) (S.fromList cns)
-      where
-        getQueueSub ::
-          DB.Connection ->
-          ConnId ->
-          IO (Either AgentErrorType (RcvQueue, Maybe NtfSupervisorSub))
-        getQueueSub db connId = fmap (first storeError) $ runExceptT $ do
-          rq <- ExceptT $ getPrimaryRcvQueue db connId
-          sub <- liftIO $ getNtfSubscription db connId
-          pure (rq, sub)
-        createNewSubs :: [RcvQueue] -> AM ()
-        createNewSubs rqs = do
+      (a, RcvQueue {userId, server = smpServer, clientNtfCreds}) <- withStore c $ \db -> runExceptT $ do
+        a <- liftIO $ getNtfSubscription db connId
+        q <- ExceptT $ getPrimaryRcvQueue db connId
+        pure (a, q)
+      logInfo $ "processNtfSub, NSCCreate - a = " <> tshow a
+      case a of
+        Nothing -> do
          withTokenServer $ \ntfServer -> do
-            let newSubs = map (rqToNewSub ntfServer) rqs
-            (cErrs, _) <- lift $ partitionErrs ntfSubConnId newSubs <$> withStoreBatch c (\db -> map (storeNewSub db) newSubs)
-            notifyErrs c cErrs
-            kickSMPWorkers rqs
+            case clientNtfCreds of
+              Just ClientNtfCreds {notifierId} -> do
+                let newSub = newNtfSubscription userId connId smpServer (Just notifierId) ntfServer NASKey
+                withStore c $ \db -> createNtfSubscription db newSub $ NSANtf NSACreate
+                lift . void $ getNtfNTFWorker True c ntfServer
+              Nothing -> do
+                let newSub = newNtfSubscription userId connId smpServer Nothing ntfServer NASNew
+                withStore c $ \db -> createNtfSubscription db newSub $ NSASMP NSASmpKey
+                lift . void $ getNtfSMPWorker True c smpServer
+        (Just (sub@NtfSubscription {ntfSubStatus, ntfServer = subNtfServer, smpServer = smpServer', ntfQueueId}, action_)) -> do
+          case (clientNtfCreds, ntfQueueId) of
+            (Just ClientNtfCreds {notifierId}, Just ntfQueueId')
+              | sameSrvAddr smpServer smpServer' && notifierId == ntfQueueId' -> create
+              | otherwise -> rotate
+            (Nothing, Nothing) -> create
+            _ -> rotate
          where
-            rqToNewSub :: NtfServer -> RcvQueue -> NtfSubscription
-            rqToNewSub ntfServer RcvQueue {userId, connId, server} = newNtfSubscription userId connId server Nothing ntfServer NASNew
-            storeNewSub :: DB.Connection -> NtfSubscription -> IO (Either AgentErrorType ())
-            storeNewSub db sub = first storeError <$> createNtfSubscription db sub (NSASMP NSASmpKey)
-        resetSubs :: [(RcvQueue, NtfSubscription)] -> AM ()
-        resetSubs rqSubs = do
-          withTokenServer $ \ntfServer -> do
-            let subsToReset = map (toResetSub ntfServer) rqSubs
-            (cErrs, _) <- lift $ partitionErrs ntfSubConnId subsToReset <$> withStoreBatch' c (\db -> map (storeResetSub db) subsToReset)
-            notifyErrs c cErrs
-            let rqs = map fst rqSubs
-            kickSMPWorkers rqs
-          where
-            toResetSub :: NtfServer -> (RcvQueue, NtfSubscription) -> NtfSubscription
-            toResetSub ntfServer (rq, sub) =
-              let RcvQueue {server = smpServer} = rq
-               in sub {smpServer, ntfQueueId = Nothing, ntfServer, ntfSubId = Nothing, ntfSubStatus = NASNew}
-            storeResetSub :: DB.Connection -> NtfSubscription -> IO ()
-            storeResetSub db sub = supervisorUpdateNtfSub db sub (NSASMP NSASmpKey)
-        partitionQueueSubActions ::
-          [(RcvQueue, Maybe NtfSupervisorSub)] ->
-          ( [RcvQueue], -- new subs
-            [(RcvQueue, NtfSubscription)], -- reset subs
-            [SMPServer], -- continue work (SMP)
-            [NtfServer] -- continue work (Ntf)
-          )
-        partitionQueueSubActions = foldr decideSubWork ([], [], [], [])
-          where
-            -- sub = Nothing, needs to be created
-            decideSubWork (rq, Nothing) (ns, rs, css, cns) = (rq : ns, rs, css, cns)
-            decideSubWork (rq, Just (sub, subAction_)) (ns, rs, css, cns) =
-              case (clientNtfCreds rq, ntfQueueId sub) of
-                -- notifier ID created on SMP server (on ntf server subscription can be registered or not yet),
-                -- need to clarify action
-                (Just ClientNtfCreds {notifierId}, Just ntfQueueId')
-                  | sameSrvAddr (qServer rq) subSMPServer && notifierId == ntfQueueId' -> contOrReset
-                  | otherwise -> reset
-                (Nothing, Nothing) -> contOrReset
-                _ -> reset
-              where
-                NtfSubscription {ntfServer = subNtfServer, smpServer = subSMPServer} = sub
-                contOrReset = case subAction_ of
-                  -- action was set to NULL after worker internal error
-                  Nothing -> reset
-                  Just (action, _)
-                    -- subscription was marked for deletion / is being deleted
-                    | isDeleteNtfSubAction action -> reset
-                    -- continue work on subscription (e.g. supervisor was repeatedly tasked with creating a subscription)
-                    | otherwise -> case action of
-                        NSASMP _ -> (ns, rs, qServer rq : css, cns)
-                        NSANtf _ -> (ns, rs, css, subNtfServer : cns)
-                reset = (ns, (rq, sub) : rs, css, cns)
+            create :: AM ()
+            create = case action_ of
+              -- action was set to NULL after worker internal error
+              Nothing -> resetSubscription
+              Just (action, _)
+                -- subscription was marked for deletion / is being deleted
+                | isDeleteNtfSubAction action -> do
+                    if ntfSubStatus == NASNew || ntfSubStatus == NASOff || ntfSubStatus == NASDeleted
+                      then resetSubscription
+                      else withTokenServer $ \ntfServer -> do
+                        withStore' c $ \db -> supervisorUpdateNtfSub db sub {ntfServer} (NSANtf NSACreate)
+                        lift . void $ getNtfNTFWorker True c ntfServer
+                | otherwise -> case action of
+                    NSANtf _ -> lift . void $ getNtfNTFWorker True c subNtfServer
+                    NSASMP _ -> lift . void $ getNtfSMPWorker True c smpServer
+            rotate :: AM ()
+            rotate = do
+              withStore' c $ \db -> supervisorUpdateNtfSub db sub (NSANtf NSARotate)
+              lift . void $ getNtfNTFWorker True c subNtfServer
+            resetSubscription :: AM ()
+            resetSubscription =
+              withTokenServer $ \ntfServer -> do
+                let sub' = sub {ntfQueueId = Nothing, ntfServer, ntfSubId = Nothing, ntfSubStatus = NASNew}
+                withStore' c $ \db -> supervisorUpdateNtfSub db sub' (NSASMP NSASmpKey)
+                lift . void $ getNtfSMPWorker True c smpServer
+    NSCDelete -> do
+      sub_ <- withStore' c $ \db -> do
+        supervisorUpdateNtfAction db connId (NSANtf NSADelete)
+        getNtfSubscription db connId
+      logInfo $ "processNtfSub, NSCDelete - sub_ = " <> tshow sub_
+      case sub_ of
+        (Just (NtfSubscription {ntfServer}, _)) -> lift . void $ getNtfNTFWorker True c ntfServer
+        _ -> pure () -- err "NSCDelete - no subscription"
    NSCSmpDelete -> do
-      (cErrs, rqs) <- lift $ partitionErrs id connIds' <$> withStoreBatch c (\db -> map (getQueue db) connIds')
-      logInfo $ "processNtfCmd, NSCSmpDelete - length rqs = " <> tshow (length rqs)
-      (cErrs', _) <- lift $ partitionErrs qConnId rqs <$> withStoreBatch' c (\db -> map (updateAction db) rqs)
-      notifyErrs c (cErrs <> cErrs')
-      kickSMPWorkers rqs
-      where
-        getQueue :: DB.Connection -> ConnId -> IO (Either AgentErrorType RcvQueue)
-        getQueue db connId = first storeError <$> getPrimaryRcvQueue db connId
-        updateAction :: DB.Connection -> RcvQueue -> IO ()
-        updateAction db rq = supervisorUpdateNtfAction db (qConnId rq) (NSASMP NSASmpDelete)
-    NSCDeleteSub -> void $ lift $ withStoreBatch' c $ \db -> map (deleteNtfSubscription' db) connIds'
-  where
-    kickSMPWorkers :: [RcvQueue] -> AM ()
-    kickSMPWorkers rqs = do
-      let smpServers = S.fromList $ map qServer rqs
-      lift $ mapM_ (getNtfSMPWorker True c) smpServers
+      withStore' c (`getPrimaryRcvQueue` connId) >>= \case
+        Right rq@RcvQueue {server = smpServer} -> do
+          logInfo $ "processNtfSub, NSCSmpDelete - rq = " <> tshow rq
+          withStore' c $ \db -> supervisorUpdateNtfAction db connId (NSASMP NSASmpDelete)
+          lift . void $ getNtfSMPWorker True c smpServer
+        _ -> notifyInternalError c connId "NSCSmpDelete - no rcv queue"
+    NSCNtfWorker ntfServer -> lift . void $ getNtfNTFWorker True c ntfServer
+    NSCNtfSMPWorker smpServer -> lift . void $ getNtfSMPWorker True c smpServer

 getNtfNTFWorker :: Bool -> AgentClient -> NtfServer -> AM' Worker
 getNtfNTFWorker hasWork c server = do
@@ -200,11 +143,6 @@ getNtfSMPWorker hasWork c server = do
  ws <- asks $ ntfSMPWorkers . ntfSupervisor
  getAgentWorker "ntf_smp" hasWork c server ws $ runNtfSMPWorker c server

-getNtfTknDelWorker :: Bool -> AgentClient -> NtfServer -> AM' Worker
-getNtfTknDelWorker hasWork c server = do
-  ws <- asks $ ntfTknDelWorkers . ntfSupervisor
-  getAgentWorker "ntf_tkn_del" hasWork c server ws $ runNtfTknDelWorker c server
-
 withTokenServer :: (NtfServer -> AM ()) -> AM ()
 withTokenServer action = lift getNtfToken >>= mapM_ (\NtfToken {ntfServer} -> action ntfServer)

@@ -215,288 +153,153 @@ runNtfWorker c srv Worker {doWork} =
    ExceptT $ agentOperationBracket c AONtfNetwork throwWhenInactive $ runExceptT runNtfOperation
  where
    runNtfOperation :: AM ()
-    runNtfOperation = do
-      ntfBatchSize <- asks $ ntfBatchSize . config
-      withWorkItems c doWork (withStore' c $ \db -> getNextNtfSubNTFActions db srv ntfBatchSize) $ \nextSubs -> do
-        logInfo $ "runNtfWorker - length nextSubs = " <> tshow (length nextSubs)
-        currTs <- liftIO getCurrentTime
-        let (creates, checks, deletes, rotates) = splitActions currTs nextSubs
-        if null creates && null checks && null deletes && null rotates
-          then
-            let (_, _, firstActionTs) = L.head nextSubs
-             in lift $ rescheduleWork doWork currTs firstActionTs
-          else do
-            retrySubActions c creates createSubs
-            retrySubActions c checks checkSubs
-            retrySubActions c deletes deleteSubs
-            retrySubActions c rotates rotateSubs
-    splitActions :: UTCTime -> NonEmpty (NtfSubNTFAction, NtfSubscription, NtfActionTs) -> ([NtfSubscription], [NtfSubscription], [NtfSubscription], [NtfSubscription])
-    splitActions currTs = foldr addAction ([], [], [], [])
+    runNtfOperation =
+      withWork c doWork (`getNextNtfSubNTFAction` srv) $
+        \nextSub@(NtfSubscription {connId}, _, _) -> do
+          logInfo $ "runNtfWorker, nextSub " <> tshow nextSub
+          ri <- asks $ reconnectInterval . config
+          withRetryInterval ri $ \_ loop -> do
+            liftIO $ waitWhileSuspended c
+            liftIO $ waitForUserNetwork c
+            processSub nextSub
+              `catchAgentError` retryOnError c "NtfWorker" loop (workerInternalError c connId . show)
+    processSub :: (NtfSubscription, NtfSubNTFAction, NtfActionTs) -> AM ()
+    processSub (sub@NtfSubscription {userId, connId, smpServer, ntfSubId}, action, actionTs) = do
+      ts <- liftIO getCurrentTime
+      unlessM (lift $ rescheduleAction doWork ts actionTs) $
+        case action of
+          NSACreate ->
+            lift getNtfToken >>= \case
+              Just tkn@NtfToken {ntfServer, ntfTokenId = Just tknId, ntfTknStatus = NTActive, ntfMode = NMInstant} -> do
+                RcvQueue {clientNtfCreds} <- withStore c (`getPrimaryRcvQueue` connId)
+                case clientNtfCreds of
+                  Just ClientNtfCreds {ntfPrivateKey, notifierId} -> do
+                    atomically $ incNtfServerStat c userId ntfServer ntfCreateAttempts
+                    nSubId <- agentNtfCreateSubscription c tknId tkn (SMPQueueNtf smpServer notifierId) ntfPrivateKey
+                    atomically $ incNtfServerStat c userId ntfServer ntfCreated
+                    -- possible improvement: smaller retry until Active, less frequently (daily?) once Active
+                    let actionTs' = addUTCTime 30 ts
+                    withStore' c $ \db ->
+                      updateNtfSubscription db sub {ntfSubId = Just nSubId, ntfSubStatus = NASCreated NSNew} (NSANtf NSACheck) actionTs'
+                  _ -> workerInternalError c connId "NSACreate - no notifier queue credentials"
+              _ -> workerInternalError c connId "NSACreate - no active token"
+          NSACheck ->
+            lift getNtfToken >>= \case
+              Just tkn@NtfToken {ntfServer} ->
+                case ntfSubId of
+                  Just nSubId -> do
+                    atomically $ incNtfServerStat c userId ntfServer ntfCheckAttempts
+                    agentNtfCheckSubscription c nSubId tkn >>= \case
+                      NSAuth -> do
+                        withStore' c $ \db ->
+                          updateNtfSubscription db sub {ntfServer, ntfQueueId = Nothing, ntfSubId = Nothing, ntfSubStatus = NASNew} (NSASMP NSASmpKey) ts
+                        ns <- asks ntfSupervisor
+                        atomically $ writeTBQueue (ntfSubQ ns) (connId, NSCNtfSMPWorker smpServer)
+                      status -> updateSubNextCheck ts status
+                    atomically $ incNtfServerStat c userId ntfServer ntfChecked
+                  Nothing -> workerInternalError c connId "NSACheck - no subscription ID"
+              _ -> workerInternalError c connId "NSACheck - no active token"
+          NSADelete ->
+            deleteNtfSub $ do
+              let sub' = sub {ntfSubId = Nothing, ntfSubStatus = NASOff}
+              withStore' c $ \db -> updateNtfSubscription db sub' (NSASMP NSASmpDelete) ts
+              ns <- asks ntfSupervisor
+              atomically $ writeTBQueue (ntfSubQ ns) (connId, NSCNtfSMPWorker smpServer)
+          NSARotate ->
+            deleteNtfSub $ do
+              withStore' c $ \db -> deleteNtfSubscription db connId
+              ns <- asks ntfSupervisor
+              atomically $ writeTBQueue (ntfSubQ ns) (connId, NSCCreate)
      where
-        addAction (cmd, sub, ts) acc@(creates, checks, deletes, rotates) = case cmd of
-          NSACreate -> (sub : creates, checks, deletes, rotates)
-          NSACheck
-            | ts <= currTs -> (creates, sub : checks, deletes, rotates)
-            | otherwise -> acc
-          NSADelete -> (creates, checks, sub : deletes, rotates)
-          NSARotate -> (creates, checks, deletes, sub : rotates)
-    createSubs :: [NtfSubscription] -> AM' [NtfSubscription]
-    createSubs ntfSubs =
-      getNtfToken >>= \case
-        Just tkn@NtfToken {ntfServer, ntfTokenId = Just tknId, ntfTknStatus = NTActive, ntfMode = NMInstant} -> do
-          subsRqs_ <- zip ntfSubs <$> withStoreBatch c (\db -> map (getQueue db) ntfSubs)
-          let (errs1, subs_, newSubs_) = splitSubs tknId subsRqs_
-          incStatByUserId ntfServer ntfCreateAttempts subs_
-          case (L.nonEmpty subs_, L.nonEmpty newSubs_) of
-            (Just subs, Just newSubs) -> do
-              rs <- L.zip subs <$> agentNtfCreateSubscriptions c tkn newSubs
-              let (ntfSubs', errs2, nSubIds) = splitResults $ L.toList rs
-                  subs' = map fst nSubIds
-                  errs2' = map (first ntfSubConnId) errs2
-              incStatByUserId ntfServer ntfCreated subs'
-              ts <- liftIO getCurrentTime
-              int <- asks $ ntfSubFirstCheckInterval . config
-              let checkTs = addUTCTime int ts
-              (errs3, _) <- partitionErrs ntfSubConnId subs' <$> withStoreBatch' c (\db -> map (updateSubNSACheck db checkTs) nSubIds)
-              workerErrors c $ errs1 <> errs2' <> errs3
-              pure ntfSubs'
-            _ -> workerErrors c errs1 $> []
-        _ -> do
-          let errs = map (\sub -> (ntfSubConnId sub, INTERNAL "NSACreate - no active token")) ntfSubs
-          workerErrors c errs
-          pure []
-      where
-        getQueue :: DB.Connection -> NtfSubscription -> IO (Either AgentErrorType RcvQueue)
-        getQueue db NtfSubscription {connId} = first storeError <$> getPrimaryRcvQueue db connId
-        splitSubs :: NtfTokenId -> [(NtfSubscription, Either AgentErrorType RcvQueue)] -> ([(ConnId, AgentErrorType)], [NtfSubscription], [NewNtfEntity 'Subscription])
-        splitSubs tknId = foldr splitSub ([], [], [])
-          where
-            splitSub (sub, rq) (errs, subs, newSubs) = case rq of
-              Right RcvQueue {clientNtfCreds = Just creds} -> (errs, sub : subs, toNewSub sub creds : newSubs)
-              Right _ -> ((ntfSubConnId sub, INTERNAL "NSACreate - no notifier queue credentials") : errs, subs, newSubs)
-              Left e -> ((ntfSubConnId sub, e) : errs, subs, newSubs)
-            toNewSub NtfSubscription {smpServer} ClientNtfCreds {ntfPrivateKey, notifierId} =
-              NewNtfSub tknId (SMPQueueNtf smpServer notifierId) ntfPrivateKey
-        updateSubNSACheck :: DB.Connection -> UTCTime -> (NtfSubscription, NtfSubscriptionId) -> IO ()
-        updateSubNSACheck db checkTs (sub, nSubId) = updateNtfSubscription db sub {ntfSubId = Just nSubId, ntfSubStatus = NASCreated NSNew} (NSANtf NSACheck) checkTs
-    checkSubs :: [NtfSubscription] -> AM' [NtfSubscription]
-    checkSubs ntfSubs =
-      getNtfToken >>= \case
-        Just tkn@NtfToken {ntfServer, ntfTknStatus = NTActive, ntfMode = NMInstant} -> do
-          let (errs1, subs_, subIds_) = splitSubs ntfSubs
-          incStatByUserId ntfServer ntfCheckAttempts subs_
-          case (L.nonEmpty subs_, L.nonEmpty subIds_) of
-            (Just subs, Just subIds) -> do
-              rs <- L.zip subs <$> agentNtfCheckSubscriptions c tkn subIds
-              let (ntfSubs', errs2, nSubStatuses) = splitResults $ L.toList rs
-                  subs' = map fst nSubStatuses
-                  (errs2', authSubs) = partitionEithers $ map (\case (sub, NTF _ SMP.AUTH) -> Right sub; e -> Left $ first ntfSubConnId e) errs2
-              incStatByUserId ntfServer ntfChecked subs'
-              ts <- liftIO getCurrentTime
-              int <- asks $ ntfSubCheckInterval . config
-              let nextCheckTs = addUTCTime int ts
-              (errs3, srvs) <- partitionErrs ntfSubConnId subs' <$> withStoreBatch' c (\db -> map (updateSub db ntfServer ts nextCheckTs) nSubStatuses)
-              (errs4, srvs') <- partitionErrs ntfSubConnId authSubs <$> withStoreBatch' c (\db -> map (recreateNtfSub db ntfServer ts) authSubs)
-              mapM_ (getNtfSMPWorker True c) $ S.fromList (catMaybes srvs <> srvs')
-              workerErrors c $ errs1 <> errs2' <> errs3 <> errs4
-              pure ntfSubs'
-            _ -> workerErrors c errs1 $> []
-        _ -> do
-          let errs = map (\sub -> (ntfSubConnId sub, INTERNAL "NSACheck - no active token")) ntfSubs
-          workerErrors c errs
-          pure []
-      where
-        splitSubs :: [NtfSubscription] -> ([(ConnId, AgentErrorType)], [NtfSubscription], [NtfSubscriptionId])
-        splitSubs = foldr splitSub ([], [], [])
-          where
-            splitSub sub (errs, subs, subIds) = case sub of
-              NtfSubscription {ntfSubId = Just subId} -> (errs, sub : subs, subId : subIds)
-              _ -> ((ntfSubConnId sub, INTERNAL "NSACheck - no subscription ID") : errs, subs, subIds)
-        updateSub :: DB.Connection -> NtfServer -> UTCTime -> UTCTime -> (NtfSubscription, NtfSubStatus) -> IO (Maybe SMPServer)
-        updateSub db ntfServer ts nextCheckTs (sub, status)
-          | ntfShouldSubscribe status =
-              let sub' = sub {ntfSubStatus = NASCreated status}
-               in Nothing <$ updateNtfSubscription db sub' (NSANtf NSACheck) nextCheckTs
-          -- ntf server stopped subscribing to this queue
-          | otherwise = Just <$> recreateNtfSub db ntfServer ts sub
-        recreateNtfSub :: DB.Connection -> NtfServer -> UTCTime -> NtfSubscription -> IO SMPServer
-        recreateNtfSub db ntfServer ts sub@NtfSubscription {smpServer} =
-          let sub' = sub {ntfServer, ntfQueueId = Nothing, ntfSubId = Nothing, ntfSubStatus = NASNew}
-           in smpServer <$ updateNtfSubscription db sub' (NSASMP NSASmpKey) ts
-    incStatByUserId :: NtfServer -> (AgentNtfServerStats -> TVar Int) -> [NtfSubscription] -> AM' ()
-    incStatByUserId ntfServer sel ss =
-      forM_ (M.assocs userIdsCounts) $ \(userId, count) ->
-        atomically $ incNtfServerStat' c userId ntfServer sel count
-      where
-        userIdsCounts = foldl' (\acc NtfSubscription {userId} -> M.insertWith (+) userId 1 acc) M.empty ss
-    -- NSADelete and NSARotate are deprecated, but their processing is kept for legacy db records;
-    -- These actions are not batched
-    deleteSubs :: [NtfSubscription] -> AM' [NtfSubscription]
-    deleteSubs ntfSubs = do
-      retrySubs_ <- mapM (runCatching deleteSub) ntfSubs
-      pure $ catMaybes retrySubs_
-      where
-        deleteSub :: NtfSubscription -> AM (Maybe NtfSubscription)
-        deleteSub sub@NtfSubscription {smpServer} =
-          deleteNtfSub sub $ do
-            let sub' = sub {ntfSubId = Nothing, ntfSubStatus = NASOff}
-            ts <- liftIO getCurrentTime
-            withStore' c $ \db -> updateNtfSubscription db sub' (NSASMP NSASmpDelete) ts
-            lift . void $ getNtfSMPWorker True c smpServer
-    rotateSubs :: [NtfSubscription] -> AM' [NtfSubscription]
-    rotateSubs ntfSubs = do
-      retrySubs_ <- mapM (runCatching rotateSub) ntfSubs
-      pure $ catMaybes retrySubs_
-      where
-        rotateSub :: NtfSubscription -> AM (Maybe NtfSubscription)
-        rotateSub sub@NtfSubscription {connId} =
-          deleteNtfSub sub $ do
-            withStore' c $ \db -> deleteNtfSubscription db connId
-            ns <- asks ntfSupervisor
-            atomically $ writeTBQueue (ntfSubQ ns) (NSCCreate, [connId])
-    runCatching :: (NtfSubscription -> AM (Maybe NtfSubscription)) -> NtfSubscription -> AM' (Maybe NtfSubscription)
-    runCatching action sub@NtfSubscription {connId} =
-      fromRight Nothing
-        <$> runExceptT (action sub `catchAllErrors` \e -> workerInternalError c connId (show e) $> Nothing)
-    -- deleteNtfSub is only used in NSADelete and NSARotate, so also deprecated
-    deleteNtfSub :: NtfSubscription -> AM () -> AM (Maybe NtfSubscription)
-    deleteNtfSub sub@NtfSubscription {userId, ntfSubId} continue = case ntfSubId of
-      Just nSubId ->
-        lift getNtfToken >>= \case
-          Just tkn@NtfToken {ntfServer} -> do
-            atomically $ incNtfServerStat c userId ntfServer ntfDelAttempts
-            tryAllErrors (agentNtfDeleteSubscription c nSubId tkn) >>= \case
-              Right _ -> do
+        deleteNtfSub continue = case ntfSubId of
+          Just nSubId ->
+            lift getNtfToken >>= \case
+              Just tkn@NtfToken {ntfServer} -> do
+                atomically $ incNtfServerStat c userId ntfServer ntfDelAttempts
+                tryAgentError (agentNtfDeleteSubscription c nSubId tkn) >>= \case
+                  Left e | temporaryOrHostError e -> throwE e
+                  _ -> continue
                atomically $ incNtfServerStat c userId ntfServer ntfDeleted
-                continue'
-              Left e
-                | temporaryOrHostError e -> pure $ Just sub -- don't continue, retry
-                | otherwise -> continue'
-          Nothing -> continue'
-      _ -> continue'
-      where
-        continue' = continue $> Nothing -- continue without retry
+              Nothing -> continue
+          _ -> continue
+        updateSubNextCheck ts toStatus = do
+          checkInterval <- asks $ ntfSubCheckInterval . config
+          let nextCheckTs = addUTCTime checkInterval ts
+          updateSub (NASCreated toStatus) (NSANtf NSACheck) nextCheckTs
+        updateSub toStatus toAction actionTs' =
+          withStore' c $ \db ->
+            updateNtfSubscription db sub {ntfSubStatus = toStatus} toAction actionTs'

 runNtfSMPWorker :: AgentClient -> SMPServer -> Worker -> AM ()
-runNtfSMPWorker c srv Worker {doWork} = forever $ do
-  waitForWork doWork
-  ExceptT $ agentOperationBracket c AONtfNetwork throwWhenInactive $ runExceptT runNtfSMPOperation
+runNtfSMPWorker c srv Worker {doWork} = do
+  env <- ask
+  forever $ do
+    waitForWork doWork
+    ExceptT . liftIO . agentOperationBracket c AONtfNetwork throwWhenInactive $
+      runReaderT (runExceptT runNtfSMPOperation) env
  where
-    runNtfSMPOperation :: AM ()
-    runNtfSMPOperation = do
-      ntfBatchSize <- asks $ ntfBatchSize . config
-      withWorkItems c doWork (withStore' c $ \db -> getNextNtfSubSMPActions db srv ntfBatchSize) $ \nextSubs -> do
-        logInfo $ "runNtfSMPWorker - length nextSubs = " <> tshow (length nextSubs)
-        let (creates, deletes) = splitActions nextSubs
-        retrySubActions c creates createNotifierKeys
-        retrySubActions c deletes deleteNotifierKeys
-    splitActions :: NonEmpty (NtfSubSMPAction, NtfSubscription) -> ([NtfSubscription], [NtfSubscription])
-    splitActions = foldr addAction ([], [])
-      where
-        addAction (cmd, sub) (creates, deletes) = case cmd of
-          NSASmpKey -> (sub : creates, deletes)
-          NSASmpDelete -> (creates, sub : deletes)
-    createNotifierKeys :: [NtfSubscription] -> AM' [NtfSubscription]
-    createNotifierKeys ntfSubs =
-      getNtfToken >>= \case
-        Just NtfToken {ntfTknStatus = NTActive, ntfMode = NMInstant} -> do
-          (errs1, subRqKeys) <- prepareQueueSmpKey ntfSubs
-          rs <- enableQueuesNtfs c subRqKeys
-          let (subRqKeys', errs2, successes) = splitResults rs
-              ntfSubs' = map eqnrNtfSub subRqKeys'
-              errs2' = map (first (qConnId . eqnrRq)) errs2
-          ts <- liftIO getCurrentTime
-          (errs3, srvs) <- partitionErrs (qConnId . eqnrRq . fst) successes <$> withStoreBatch' c (\db -> map (storeNtfSubCreds db ts) successes)
-          mapM_ (getNtfNTFWorker True c) $ S.fromList srvs
-          workerErrors c $ errs1 <> errs2' <> errs3
-          pure ntfSubs'
-        _ -> do
-          let errs = map (\sub -> (ntfSubConnId sub, INTERNAL "NSASmpKey - no active token")) ntfSubs
-          workerErrors c errs
-          pure []
-      where
-        prepareQueueSmpKey :: [NtfSubscription] -> AM' ([(ConnId, AgentErrorType)], [EnableQueueNtfReq])
-        prepareQueueSmpKey subs = do
-          alg <- asks (rcvAuthAlg . config)
-          g <- asks random
-          partitionErrs ntfSubConnId subs <$> withStoreBatch c (\db -> map (getQueue db alg g) subs)
-          where
-            getQueue :: DB.Connection -> C.AuthAlg -> TVar ChaChaDRG -> NtfSubscription -> IO (Either AgentErrorType EnableQueueNtfReq)
-            getQueue db (C.AuthAlg a) g sub = fmap (first storeError) $ runExceptT $ do
-              rq <- ExceptT $ getPrimaryRcvQueue db (ntfSubConnId sub)
-              authKeyPair <- atomically $ C.generateAuthKeyPair a g
-              rcvNtfKeyPair <- atomically $ C.generateKeyPair g
-              pure (EnableQueueNtfReq sub rq authKeyPair rcvNtfKeyPair)
-        storeNtfSubCreds :: DB.Connection -> UTCTime -> (EnableQueueNtfReq, (SMP.NotifierId, SMP.RcvNtfPublicDhKey)) -> IO NtfServer
-        storeNtfSubCreds db ts (EnableQueueNtfReq {eqnrNtfSub, eqnrAuthKeyPair = (ntfPublicKey, ntfPrivateKey), eqnrRcvKeyPair = (_, pk)}, (notifierId, srvPubDhKey)) = do
-          let NtfSubscription {ntfServer} = eqnrNtfSub
-              rcvNtfDhSecret = C.dh' srvPubDhKey pk
-          setRcvQueueNtfCreds db (ntfSubConnId eqnrNtfSub) $ Just ClientNtfCreds {ntfPublicKey, ntfPrivateKey, notifierId, rcvNtfDhSecret}
-          updateNtfSubscription db eqnrNtfSub {ntfQueueId = Just notifierId, ntfSubStatus = NASKey} (NSANtf NSACreate) ts
-          pure ntfServer
-    deleteNotifierKeys :: [NtfSubscription] -> AM' [NtfSubscription]
-    deleteNotifierKeys ntfSubs = do
-      (errs1, subRqs) <- partitionErrs ntfSubConnId ntfSubs <$> withStoreBatch c (\db -> map (resetCredsGetQueue db) ntfSubs)
-      rs <- disableQueuesNtfs c subRqs
-      let (subRqs', errs2, successes) = splitResults rs
-          ntfSubs' = map fst subRqs'
-          errs2' = map (first (qConnId . snd)) errs2
-          disabledRqs = map (snd . fst) successes
-      (errs3, _) <- partitionErrs qConnId disabledRqs <$> withStoreBatch' c (\db -> map (deleteSub db) disabledRqs)
-      workerErrors c $ errs1 <> errs2' <> errs3
-      pure ntfSubs'
-      where
-        resetCredsGetQueue :: DB.Connection -> NtfSubscription -> IO (Either AgentErrorType DisableQueueNtfReq)
-        resetCredsGetQueue db sub@NtfSubscription {connId} = fmap (first storeError) $ runExceptT $ do
-          liftIO $ setRcvQueueNtfCreds db connId Nothing
-          rq <- ExceptT $ getPrimaryRcvQueue db connId
-          pure (sub, rq)
-        deleteSub :: DB.Connection -> RcvQueue -> IO ()
-        deleteSub db rq = deleteNtfSubscription db (qConnId rq)
+    runNtfSMPOperation =
+      withWork c doWork (`getNextNtfSubSMPAction` srv) $
+        \nextSub@(NtfSubscription {connId}, _, _) -> do
+          logInfo $ "runNtfSMPWorker, nextSub " <> tshow nextSub
+          ri <- asks $ reconnectInterval . config
+          withRetryInterval ri $ \_ loop -> do
+            liftIO $ waitWhileSuspended c
+            liftIO $ waitForUserNetwork c
+            processSub nextSub
+              `catchAgentError` retryOnError c "NtfSMPWorker" loop (workerInternalError c connId . show)
+    processSub :: (NtfSubscription, NtfSubSMPAction, NtfActionTs) -> AM ()
+    processSub (sub@NtfSubscription {connId, ntfServer}, smpAction, actionTs) = do
+      ts <- liftIO getCurrentTime
+      unlessM (lift $ rescheduleAction doWork ts actionTs) $
+        case smpAction of
+          NSASmpKey ->
+            lift getNtfToken >>= \case
+              Just NtfToken {ntfTknStatus = NTActive, ntfMode = NMInstant} -> do
+                rq <- withStore c (`getPrimaryRcvQueue` connId)
+                C.AuthAlg a <- asks (rcvAuthAlg . config)
+                g <- asks random
+                (ntfPublicKey, ntfPrivateKey) <- atomically $ C.generateAuthKeyPair a g
+                (rcvNtfPubDhKey, rcvNtfPrivDhKey) <- atomically $ C.generateKeyPair g
+                (notifierId, rcvNtfSrvPubDhKey) <- enableQueueNotifications c rq ntfPublicKey rcvNtfPubDhKey
+                let rcvNtfDhSecret = C.dh' rcvNtfSrvPubDhKey rcvNtfPrivDhKey
+                withStore' c $ \db -> do
+                  setRcvQueueNtfCreds db connId $ Just ClientNtfCreds {ntfPublicKey, ntfPrivateKey, notifierId, rcvNtfDhSecret}
+                  updateNtfSubscription db sub {ntfQueueId = Just notifierId, ntfSubStatus = NASKey} (NSANtf NSACreate) ts
+                ns <- asks ntfSupervisor
+                atomically $ sendNtfSubCommand ns (connId, NSCNtfWorker ntfServer)
+              _ -> workerInternalError c connId "NSASmpKey - no active token"
+          NSASmpDelete -> do
+            -- TODO should we remove it after successful removal from the server?
+            rq_ <- withStore' c $ \db -> do
+              setRcvQueueNtfCreds db connId Nothing
+              getPrimaryRcvQueue db connId
+            mapM_ (disableQueueNotifications c) rq_
+            withStore' c $ \db -> deleteNtfSubscription db connId

-retrySubActions :: AgentClient -> [NtfSubscription] -> ([NtfSubscription] -> AM' [NtfSubscription]) -> AM ()
-retrySubActions _ [] _ = pure ()
-retrySubActions c subs action = do
-  v <- newTVarIO subs
-  ri <- asks $ reconnectInterval . config
-  withRetryInterval ri $ \_ loop -> do
-    liftIO $ waitWhileSuspended c
-    liftIO $ waitForUserNetwork c
-    subs' <- readTVarIO v
-    retrySubs <- lift $ action subs'
-    unless (null retrySubs) $ do
-      atomically $ writeTVar v retrySubs
-      retryNetworkLoop c loop
+rescheduleAction :: TMVar () -> UTCTime -> UTCTime -> AM' Bool
+rescheduleAction doWork ts actionTs
+  | actionTs <= ts = pure False
+  | otherwise = do
+      void . atomically $ tryTakeTMVar doWork
+      void . forkIO $ do
+        liftIO $ threadDelay' $ diffToMicroseconds $ diffUTCTime actionTs ts
+        atomically $ hasWorkToDo' doWork
+      pure True

--                                                (temporary errs, other errs, successes)
-splitResults :: [(a, Either AgentErrorType r)] -> ([a], [(a, AgentErrorType)], [(a, r)])
-splitResults = foldr addRes ([], [], [])
+retryOnError :: AgentClient -> Text -> AM () -> (AgentErrorType -> AM ()) -> AgentErrorType -> AM ()
+retryOnError c name loop done e = do
+  logError $ name <> " error: " <> tshow e
+  case e of
+    BROKER _ NETWORK -> retryLoop
+    BROKER _ TIMEOUT -> retryLoop
+    _ -> done e
  where
-    addRes (a, r_) (as, errs, rs) = case r_ of
-      Right r -> (as, errs, (a, r) : rs)
-      Left e
-        | temporaryOrHostError e -> (a : as, errs, rs)
-        | otherwise -> (as, (a, e) : errs, rs)
-
-rescheduleWork :: TMVar () -> UTCTime -> UTCTime -> AM' ()
-rescheduleWork doWork ts actionTs = do
-  void . atomically $ tryTakeTMVar doWork
-  void . forkIO $ do
-    liftIO $ threadDelay' $ diffToMicroseconds $ diffUTCTime actionTs ts
-    atomically $ hasWorkToDo' doWork
-
-retryNetworkLoop :: AgentClient -> AM () -> AM ()
-retryNetworkLoop c loop = do
-  atomically $ endAgentOperation c AONtfNetwork
-  liftIO $ throwWhenInactive c
-  atomically $ beginAgentOperation c AONtfNetwork
-  loop
-
-workerErrors :: AgentClient -> [(ConnId, AgentErrorType)] -> AM' ()
-workerErrors c connErrs =
-  unless (null connErrs) $ do
-    void $ withStoreBatch' c (\db -> map (setNullNtfSubscriptionAction db . fst) connErrs)
-    notifyErrs c connErrs
+    retryLoop = do
+      atomically $ endAgentOperation c AONtfNetwork
+      liftIO $ throwWhenInactive c
+      atomically $ beginAgentOperation c AONtfNetwork
+      loop

 workerInternalError :: AgentClient -> ConnId -> String -> AM ()
 workerInternalError c connId internalErrStr = do
@@ -508,14 +311,6 @@ notifyInternalError :: MonadIO m => AgentClient -> ConnId -> String -> m ()
 notifyInternalError AgentClient {subQ} connId internalErrStr = atomically $ writeTBQueue subQ ("", connId, AEvt SAEConn $ ERR $ INTERNAL internalErrStr)
 {-# INLINE notifyInternalError #-}

-notifyInternalError' :: MonadIO m => AgentClient -> String -> m ()
-notifyInternalError' AgentClient {subQ} internalErrStr = atomically $ writeTBQueue subQ ("", "", AEvt SAEConn $ ERR $ INTERNAL internalErrStr)
-{-# INLINE notifyInternalError' #-}
-
-notifyErrs :: MonadIO m => AgentClient -> [(ConnId, AgentErrorType)] -> m ()
-notifyErrs c = mapM_ (notifySub c . ERRS) . L.nonEmpty
-{-# INLINE notifyErrs #-}
-
 getNtfToken :: AM' (Maybe NtfToken)
 getNtfToken = do
  tkn <- asks $ ntfTkn . ntfSupervisor
@@ -527,65 +322,20 @@ nsUpdateToken ns tkn = writeTVar (ntfTkn ns) $ Just tkn
 nsRemoveNtfToken :: NtfSupervisor -> STM ()
 nsRemoveNtfToken ns = writeTVar (ntfTkn ns) Nothing

-sendNtfSubCommand :: NtfSupervisor -> (NtfSupervisorCommand, NonEmpty ConnId) -> IO ()
-sendNtfSubCommand ns cmd =
-  whenM (hasInstantNotifications ns) $ atomically $ writeTBQueue (ntfSubQ ns) cmd
+sendNtfSubCommand :: NtfSupervisor -> (ConnId, NtfSupervisorCommand) -> STM ()
+sendNtfSubCommand ns cmd = do
+  tkn <- readTVar (ntfTkn ns)
+  when (instantNotifications tkn) $ writeTBQueue (ntfSubQ ns) cmd

-hasInstantNotifications :: NtfSupervisor -> IO Bool
-hasInstantNotifications ns = do
-  tkn <- readTVarIO $ ntfTkn ns
-  pure $ maybe False instantNotifications tkn
-
-instantNotifications :: NtfToken -> Bool
-instantNotifications NtfToken {ntfTknStatus = NTActive, ntfMode = NMInstant} = True
-instantNotifications _ = False
-{-# INLINE instantNotifications #-}
-
-deleteToken :: AgentClient -> NtfToken -> AM ()
-deleteToken c tkn@NtfToken {ntfServer, ntfTokenId, ntfPrivKey} = do
-  setToDelete <- withStore' c $ \db -> do
-    removeNtfToken db tkn
-    case ntfTokenId of
-      Just tknId -> addNtfTokenToDelete db ntfServer ntfPrivKey tknId $> True
-      Nothing -> pure False
-  ns <- asks ntfSupervisor
-  atomically $ nsRemoveNtfToken ns
-  when setToDelete $ void $ lift $ getNtfTknDelWorker True c ntfServer
-
-runNtfTknDelWorker :: AgentClient -> NtfServer -> Worker -> AM ()
-runNtfTknDelWorker c srv Worker {doWork} =
-  forever $ do
-    waitForWork doWork
-    ExceptT $ agentOperationBracket c AONtfNetwork throwWhenInactive $ runExceptT runNtfOperation
-  where
-    runNtfOperation :: AM ()
-    runNtfOperation =
-      withWork c doWork (`getNextNtfTokenToDelete` srv) $
-        \nextTknToDelete -> do
-          logInfo $ "runNtfTknDelWorker, nextTknToDelete " <> tshow nextTknToDelete
-          ri <- asks $ reconnectInterval . config
-          withRetryInterval ri $ \_ loop -> do
-            liftIO $ waitWhileSuspended c
-            liftIO $ waitForUserNetwork c
-            processTknToDelete nextTknToDelete `catchAllErrors` retryTmpError loop nextTknToDelete
-    retryTmpError :: AM () -> NtfTokenToDelete -> AgentErrorType -> AM ()
-    retryTmpError loop (tknDbId, _, _) e = do
-      logError $ "ntf tkn del error: " <> tshow e
-      if temporaryOrHostError e
-        then retryNetworkLoop c loop
-        else do
-          withStore' c $ \db -> deleteNtfTokenToDelete db tknDbId
-          notifyInternalError' c (show e)
-    processTknToDelete :: NtfTokenToDelete -> AM ()
-    processTknToDelete (tknDbId, ntfPrivKey, tknId) = do
-      agentNtfDeleteToken c NRMBackground srv ntfPrivKey tknId
-      withStore' c $ \db -> deleteNtfTokenToDelete db tknDbId
+instantNotifications :: Maybe NtfToken -> Bool
+instantNotifications = \case
+  Just NtfToken {ntfTknStatus = NTActive, ntfMode = NMInstant} -> True
+  _ -> False

 closeNtfSupervisor :: NtfSupervisor -> IO ()
 closeNtfSupervisor ns = do
  stopWorkers $ ntfWorkers ns
  stopWorkers $ ntfSMPWorkers ns
-  stopWorkers $ ntfTknDelWorkers ns
  where
    stopWorkers workers = atomically (swapTVar workers M.empty) >>= mapM_ (liftIO . cancelWorker)

@@ -10,10 +10,11 @@ import qualified Data.Aeson.TH as J
 import Data.Int (Int64)
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
+import Database.SQLite.Simple.FromField (FromField (..))
+import Database.SQLite.Simple.ToField (ToField (..))
 import Simplex.Messaging.Agent.Protocol (UserId)
-import Simplex.Messaging.Agent.Store.DB (FromField (..), ToField (..), fromTextField_)
-import Simplex.Messaging.Parsers (defaultJSON)
-import Simplex.Messaging.Protocol (NtfServer, SMPServer, XFTPServer)
+import Simplex.Messaging.Parsers (defaultJSON, fromTextField_)
+import Simplex.Messaging.Protocol (SMPServer, XFTPServer, NtfServer)
 import Simplex.Messaging.Util (decodeJSON, encodeJSON)
 import UnliftIO.STM

@@ -29,13 +29,8 @@ import Data.Time (UTCTime)
 import Data.Type.Equality
 import Simplex.Messaging.Agent.Protocol
 import Simplex.Messaging.Agent.RetryInterval (RI2State)
-import Simplex.Messaging.Agent.Store.Entity
-import Simplex.Messaging.Agent.Store.Common
-import Simplex.Messaging.Agent.Store.Interface (createDBStore)
-import Simplex.Messaging.Agent.Store.Migrations.App (appMigrations)
-import Simplex.Messaging.Agent.Store.Shared (MigrationConfig (..), MigrationError (..))
 import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Crypto.Ratchet (MsgEncryptKeyX448, PQEncryption, PQSupport, RatchetX448)
+import Simplex.Messaging.Crypto.Ratchet (PQEncryption, PQSupport, RatchetX448)
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Protocol
  ( MsgBody,
@@ -44,27 +39,36 @@ import Simplex.Messaging.Protocol
    NotifierId,
    NtfPrivateAuthKey,
    NtfPublicAuthKey,
-    QueueMode,
    RcvDhSecret,
    RcvNtfDhSecret,
    RcvPrivateAuthKey,
    SndPrivateAuthKey,
+    SndPublicAuthKey,
+    SenderCanSecure,
    VersionSMPC,
  )
 import qualified Simplex.Messaging.Protocol as SMP
-import Simplex.Messaging.Util (AnyError (..), bshow)
-
-createStore :: DBOpts -> MigrationConfig -> IO (Either MigrationError DBStore)
-createStore dbOpts = createDBStore dbOpts appMigrations

 -- * Queue types

-type RcvQueue = StoredRcvQueue 'DBStored
+data QueueStored = QSStored | QSNew

-type NewRcvQueue = StoredRcvQueue 'DBNew
+data SQueueStored (q :: QueueStored) where
+  SQSStored :: SQueueStored 'QSStored
+  SQSNew :: SQueueStored 'QSNew
+
+data DBQueueId (q :: QueueStored) where
+  DBQueueId :: Int64 -> DBQueueId 'QSStored
+  DBNewQueue :: DBQueueId 'QSNew
+
+deriving instance Show (DBQueueId q)
+
+type RcvQueue = StoredRcvQueue 'QSStored
+
+type NewRcvQueue = StoredRcvQueue 'QSNew

 -- | A receive queue. SMP queue through which the agent receives messages from a sender.
-data StoredRcvQueue (q :: DBStored) = RcvQueue
+data StoredRcvQueue (q :: QueueStored) = RcvQueue
  { userId :: UserId,
    connId :: ConnId,
    server :: SMPServer,
@@ -81,19 +85,11 @@ data StoredRcvQueue (q :: DBStored) = RcvQueue
    -- | sender queue ID
    sndId :: SMP.SenderId,
    -- | sender can secure the queue
-    queueMode :: Maybe QueueMode,
-    -- | short link ID and credentials
-    shortLink :: Maybe ShortLinkCreds,
-    -- | associated client service
-    clientService :: Maybe (StoredClientService q),
+    sndSecure :: SenderCanSecure,
    -- | queue status
    status :: QueueStatus,
-    -- | to enable notifications for this queue - this field is duplicated from ConnData
-    enableNtfs :: Bool,
-    -- | client notice
-    clientNoticeId :: Maybe NoticeId,
    -- | database queue ID (within connection)
-    dbQueueId :: DBEntityId' q,
+    dbQueueId :: DBQueueId q,
    -- | True for a primary or a next primary queue of the connection (next if dbReplaceQueueId is set)
    primary :: Bool,
    -- | database queue ID to replace, Nothing if this queue is not replacing another, `Just Nothing` is used for replacing old queues
@@ -107,40 +103,9 @@ data StoredRcvQueue (q :: DBStored) = RcvQueue
  }
  deriving (Show)

-data RcvQueueSub = RcvQueueSub
-  { userId :: UserId,
-    connId :: ConnId,
-    server :: SMPServer,
-    rcvId :: SMP.RecipientId,
-    rcvPrivateKey :: RcvPrivateAuthKey,
-    status :: QueueStatus,
-    enableNtfs :: Bool,
-    clientNoticeId :: Maybe NoticeId,
-    dbQueueId :: Int64,
-    primary :: Bool,
-    dbReplaceQueueId :: Maybe Int64
-  }
-  deriving (Show)
-
-rcvQueueSub :: RcvQueue -> RcvQueueSub
-rcvQueueSub RcvQueue {userId, connId, server, rcvId, rcvPrivateKey, status, enableNtfs, clientNoticeId, dbQueueId = DBEntityId dbQueueId, primary, dbReplaceQueueId} =
-  RcvQueueSub {userId, connId, server, rcvId, rcvPrivateKey, status, enableNtfs, clientNoticeId, dbQueueId, primary, dbReplaceQueueId}
-
-data ShortLinkCreds = ShortLinkCreds
-  { shortLinkId :: SMP.LinkId,
-    shortLinkKey :: LinkKey,
-    linkPrivSigKey :: C.PrivateKeyEd25519,
-    linkEncFixedData :: SMP.EncFixedDataBytes
-  }
-  deriving (Show)
-
-clientServiceId :: RcvQueue -> Maybe ClientServiceId
-clientServiceId = fmap dbServiceId . clientService
-{-# INLINE clientServiceId #-}
-
-rcvSMPQueueAddress :: RcvQueue -> SMPQueueAddress
-rcvSMPQueueAddress RcvQueue {server, sndId, e2ePrivKey, queueMode} =
-  SMPQueueAddress server sndId (C.publicKey e2ePrivKey) queueMode
+rcvQueueInfo :: RcvQueue -> RcvQueueInfo
+rcvQueueInfo rq@RcvQueue {server, rcvSwchStatus} =
+  RcvQueueInfo {rcvServer = server, rcvSwitchStatus = rcvSwchStatus, canAbortSwitch = canAbortRcvSwitch rq}

 canAbortRcvSwitch :: RcvQueue -> Bool
 canAbortRcvSwitch = maybe False canAbort . rcvSwchStatus
@@ -165,32 +130,22 @@ data ClientNtfCreds = ClientNtfCreds
  }
  deriving (Show)

-- This record is stored in inv_short_links table.
-- It is needed only for 1-time invitation links because of "secure-on-read" property of link data,
-- that prevents undetected access to link data from link observers.
-data InvShortLink = InvShortLink
-  { server :: SMPServer,
-    linkId :: SMP.LinkId,
-    linkKey :: LinkKey,
-    sndPrivateKey :: SndPrivateAuthKey, -- stored to allow retries
-    sndId :: Maybe SMP.SenderId
-  }
-  deriving (Show)
+type SndQueue = StoredSndQueue 'QSStored

-type SndQueue = StoredSndQueue 'DBStored
-
-type NewSndQueue = StoredSndQueue 'DBNew
+type NewSndQueue = StoredSndQueue 'QSNew

 -- | A send queue. SMP queue through which the agent sends messages to a recipient.
-data StoredSndQueue (q :: DBStored) = SndQueue
+data StoredSndQueue (q :: QueueStored) = SndQueue
  { userId :: UserId,
    connId :: ConnId,
    server :: SMPServer,
    -- | sender queue ID
    sndId :: SMP.SenderId,
    -- | sender can secure the queue
-    queueMode :: Maybe QueueMode,
-    -- | sender key used to authorize transmissions
+    sndSecure :: SenderCanSecure,
+    -- | key pair used by the sender to authorize transmissions
+    -- TODO combine keys to key pair so that types match
+    sndPublicKey :: SndPublicAuthKey,
    sndPrivateKey :: SndPrivateAuthKey,
    -- | DH public key used to negotiate per-queue e2e encryption
    e2ePubKey :: Maybe C.PublicKeyX25519,
@@ -199,7 +154,7 @@ data StoredSndQueue (q :: DBStored) = SndQueue
    -- | queue status
    status :: QueueStatus,
    -- | database queue ID (within connection)
-    dbQueueId :: DBEntityId' q,
+    dbQueueId :: DBQueueId q,
    -- | True for a primary or a next primary queue of the connection (next if dbReplaceQueueId is set)
    primary :: Bool,
    -- | ID of the queue this one is replacing
@@ -210,6 +165,10 @@ data StoredSndQueue (q :: DBStored) = SndQueue
  }
  deriving (Show)

+sndQueueInfo :: SndQueue -> SndQueueInfo
+sndQueueInfo SndQueue {server, sndSwchStatus} =
+  SndQueueInfo {sndServer = server, sndSwitchStatus = sndSwchStatus}
+
 instance SMPQueue RcvQueue where
  qServer RcvQueue {server} = server
  {-# INLINE qServer #-}
@@ -222,12 +181,6 @@ instance SMPQueue NewRcvQueue where
  queueId RcvQueue {rcvId} = rcvId
  {-# INLINE queueId #-}

-instance SMPQueue RcvQueueSub where
-  qServer RcvQueueSub {server} = server
-  {-# INLINE qServer #-}
-  queueId RcvQueueSub {rcvId} = rcvId
-  {-# INLINE queueId #-}
-
 instance SMPQueue SndQueue where
  qServer SndQueue {server} = server
  {-# INLINE qServer #-}
@@ -267,7 +220,6 @@ class SMPQueue q => SMPQueueRec q where
  qUserId :: q -> UserId
  qConnId :: q -> ConnId
  dbQId :: q -> Int64
-  qPrimary :: q -> Bool
  dbReplaceQId :: q -> Maybe Int64

 instance SMPQueueRec RcvQueue where
@@ -275,48 +227,21 @@ instance SMPQueueRec RcvQueue where
  {-# INLINE qUserId #-}
  qConnId RcvQueue {connId} = connId
  {-# INLINE qConnId #-}
-  dbQId RcvQueue {dbQueueId = DBEntityId qId} = qId
+  dbQId RcvQueue {dbQueueId = DBQueueId qId} = qId
  {-# INLINE dbQId #-}
-  qPrimary RcvQueue {primary} = primary
-  {-# INLINE qPrimary #-}
  dbReplaceQId RcvQueue {dbReplaceQueueId} = dbReplaceQueueId
  {-# INLINE dbReplaceQId #-}

-instance SMPQueueRec RcvQueueSub where
-  qUserId RcvQueueSub {userId} = userId
-  {-# INLINE qUserId #-}
-  qConnId RcvQueueSub {connId} = connId
-  {-# INLINE qConnId #-}
-  dbQId RcvQueueSub {dbQueueId} = dbQueueId
-  {-# INLINE dbQId #-}
-  qPrimary RcvQueueSub {primary} = primary
-  {-# INLINE qPrimary #-}
-  dbReplaceQId RcvQueueSub {dbReplaceQueueId} = dbReplaceQueueId
-  {-# INLINE dbReplaceQId #-}
-
 instance SMPQueueRec SndQueue where
  qUserId SndQueue {userId} = userId
  {-# INLINE qUserId #-}
  qConnId SndQueue {connId} = connId
  {-# INLINE qConnId #-}
-  dbQId SndQueue {dbQueueId = DBEntityId qId} = qId
+  dbQId SndQueue {dbQueueId = DBQueueId qId} = qId
  {-# INLINE dbQId #-}
-  qPrimary SndQueue {primary} = primary
-  {-# INLINE qPrimary #-}
  dbReplaceQId SndQueue {dbReplaceQueueId} = dbReplaceQueueId
  {-# INLINE dbReplaceQId #-}

-class SMPQueueRec q => SomeRcvQueue q where
-  rcvAuthKey :: q -> RcvPrivateAuthKey
-
-instance SomeRcvQueue RcvQueue where
-  rcvAuthKey RcvQueue {rcvPrivateKey} = rcvPrivateKey
-  {-# INLINE rcvAuthKey #-}
-
-instance SomeRcvQueue RcvQueueSub where
-  rcvAuthKey RcvQueueSub {rcvPrivateKey} = rcvPrivateKey
-  {-# INLINE rcvAuthKey #-}
-
 -- * Connection types

 -- | Type of a connection.
@@ -332,18 +257,16 @@ data ConnType = CNew | CRcv | CSnd | CDuplex | CContact deriving (Eq, Show)
 --
 -- - DuplexConnection is a connection that has both receive and send queues set up,
 --   typically created by upgrading a receive or a send connection with a missing queue.
-data Connection' (d :: ConnType) rq sq where
-  NewConnection :: ConnData -> Connection' CNew rq sq
-  RcvConnection :: ConnData -> rq -> Connection' CRcv rq sq
-  SndConnection :: ConnData -> sq -> Connection' CSnd rq sq
-  DuplexConnection :: ConnData -> NonEmpty rq -> NonEmpty sq -> Connection' CDuplex rq sq
-  ContactConnection :: ConnData -> rq -> Connection' CContact rq sq
+data Connection (d :: ConnType) where
+  NewConnection :: ConnData -> Connection CNew
+  RcvConnection :: ConnData -> RcvQueue -> Connection CRcv
+  SndConnection :: ConnData -> SndQueue -> Connection CSnd
+  DuplexConnection :: ConnData -> NonEmpty RcvQueue -> NonEmpty SndQueue -> Connection CDuplex
+  ContactConnection :: ConnData -> RcvQueue -> Connection CContact

-deriving instance (Show rq, Show sq) => Show (Connection' d rq sq)
+deriving instance Show (Connection d)

-type Connection d = Connection' d RcvQueue SndQueue
-
-toConnData :: Connection' d rq sq -> ConnData
+toConnData :: Connection d -> ConnData
 toConnData = \case
  NewConnection cData -> cData
  RcvConnection cData _ -> cData
@@ -351,7 +274,7 @@ toConnData = \case
  DuplexConnection cData _ _ -> cData
  ContactConnection cData _ -> cData

-updateConnection :: ConnData -> Connection' d rq sq -> Connection' d rq sq
+updateConnection :: ConnData -> Connection d -> Connection d
 updateConnection cData = \case
  NewConnection _ -> NewConnection cData
  RcvConnection _ rq -> RcvConnection cData rq
@@ -384,13 +307,9 @@ instance TestEquality SConnType where

 -- | Connection of an unknown type.
 -- Used to refer to an arbitrary connection when retrieving from store.
-data SomeConn' rq sq = forall d. SomeConn (SConnType d) (Connection' d rq sq)
+data SomeConn = forall d. SomeConn (SConnType d) (Connection d)

-deriving instance (Show rq, Show sq) => Show (SomeConn' rq sq)
-
-type SomeConn = SomeConn' RcvQueue SndQueue
-
-type SomeConnSub = SomeConn' RcvQueueSub SndQueue
+deriving instance Show SomeConn

 data ConnData = ConnData
  { connId :: ConnId,
@@ -404,8 +323,6 @@ data ConnData = ConnData
  }
  deriving (Eq, Show)

-type NoticeId = Int64
-
 -- this function should be mirrored in the clients
 ratchetSyncAllowed :: ConnData -> Bool
 ratchetSyncAllowed ConnData {ratchetSyncState, connAgentVersion} =
@@ -569,7 +486,7 @@ data NewInvitation = NewInvitation

 data Invitation = Invitation
  { invitationId :: InvitationId,
-    contactConnId_ :: Maybe ConnId,
+    contactConnId :: ConnId,
    connReq :: ConnectionRequestUri 'CMInvitation,
    recipientConnInfo :: ConnInfo,
    ownConnInfo :: Maybe ConnInfo,
@@ -619,17 +536,9 @@ data SndMsgData = SndMsgData
    msgBody :: MsgBody,
    pqEncryption :: PQEncryption,
    internalHash :: MsgHash,
-    prevMsgHash :: MsgHash,
-    sndMsgPrepData_ :: Maybe SndMsgPrepData
+    prevMsgHash :: MsgHash
  }

-data SndMsgPrepData = SndMsgPrepData
-  { encryptKey :: MsgEncryptKeyX448,
-    paddedLen :: Int,
-    sndMsgBodyId :: Int64
-  }
-  deriving (Show)
-
 data SndMsg = SndMsg
  { internalId :: InternalId,
    internalSndId :: InternalSndId,
@@ -645,17 +554,7 @@ data PendingMsgData = PendingMsgData
    msgBody :: MsgBody,
    pqEncryption :: PQEncryption,
    msgRetryState :: Maybe RI2State,
-    internalTs :: InternalTs,
-    internalSndId :: InternalSndId,
-    prevMsgHash :: PrevSndMsgHash,
-    pendingMsgPrepData_ :: Maybe PendingMsgPrepData
-  }
-  deriving (Show)
-
-data PendingMsgPrepData = PendingMsgPrepData
-  { encryptKey :: MsgEncryptKeyX448,
-    paddedLen :: Int,
-    sndMsgBody :: AMessage
+    internalTs :: InternalTs
  }
  deriving (Show)

@@ -720,13 +619,13 @@ data StoreError
    SESndQueueExists
  | -- | Wrong connection type, e.g. "send" connection when "receive" or "duplex" is expected, or vice versa.
    -- 'upgradeRcvConnToDuplex' and 'upgradeSndConnToDuplex' do not allow duplex connections - they would also return this error.
-    SEBadConnType String ConnType
+    SEBadConnType ConnType
  | -- | Confirmation not found.
    SEConfirmationNotFound
  | -- | Invitation not found
-    SEInvitationNotFound String InvitationId
+    SEInvitationNotFound
  | -- | Message not found
-    SEMsgNotFound String
+    SEMsgNotFound
  | -- | Command not found
    SECmdNotFound
  | -- | Currently not used. The intention was to pass current expected queue status in methods,
@@ -746,20 +645,7 @@ data StoreError
  | -- | XFTP Deleted snd chunk replica not found.
    SEDeletedSndChunkReplicaNotFound
  | -- | Error when reading work item that suspends worker - do not use!
-    SEWorkItemError {errContext :: String}
+    SEWorkItemError ByteString
  | -- | Servers stats not found.
    SEServersStatsNotFound
  deriving (Eq, Show, Exception)
-
-instance AnyError StoreError where
-  fromSomeException = SEInternal . bshow
-
-class (Show e, AnyError e) => AnyStoreError e where
-  isWorkItemError :: e -> Bool
-  mkWorkItemError :: String -> e
-
-instance AnyStoreError StoreError where
-  isWorkItemError = \case
-    SEWorkItemError {} -> True
-    _ -> False
-  mkWorkItemError errContext = SEWorkItemError {errContext}
@@ -1,14 +0,0 @@
-{-# LANGUAGE CPP #-}
-
-module Simplex.Messaging.Agent.Store.Common
-#if defined(dbPostgres)
-  ( module Simplex.Messaging.Agent.Store.Postgres.Common,
-  )
-  where
-import Simplex.Messaging.Agent.Store.Postgres.Common
-#else
-  ( module Simplex.Messaging.Agent.Store.SQLite.Common,
-  )
-  where
-import Simplex.Messaging.Agent.Store.SQLite.Common
-#endif
@@ -1,18 +0,0 @@
-{-# LANGUAGE CPP #-}
-
-module Simplex.Messaging.Agent.Store.DB
-#if defined(dbPostgres)
-  ( module Simplex.Messaging.Agent.Store.Postgres.DB,
-    FromField (..),
-    ToField (..),
-  )
-  where
-import Simplex.Messaging.Agent.Store.Postgres.DB
-#else
-  ( module Simplex.Messaging.Agent.Store.SQLite.DB,
-    FromField (..),
-    ToField (..),
-  )
-  where
-import Simplex.Messaging.Agent.Store.SQLite.DB
-#endif
@@ -1,72 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE KindSignatures #-}
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TypeApplications #-}
-
-module Simplex.Messaging.Agent.Store.Entity where
-
-import Data.Aeson (FromJSON (..), ToJSON (..))
-import qualified Data.Aeson as J
-import qualified Data.Aeson.Encoding as JE
-import Data.Int (Int64)
-import Data.Scientific (floatingOrInteger)
-import Simplex.Messaging.Agent.Store.DB (FromField (..), ToField (..))
-
-data DBStored = DBStored | DBNew
-
-data SDBStored (s :: DBStored) where
-  SDBStored :: SDBStored 'DBStored
-  SDBNew :: SDBStored 'DBNew
-
-deriving instance Show (SDBStored s)
-
-class DBStoredI s where sdbStored :: SDBStored s
-
-instance DBStoredI 'DBStored where sdbStored = SDBStored
-
-instance DBStoredI 'DBNew where sdbStored = SDBNew
-
-data DBEntityId' (s :: DBStored) where
-  DBEntityId :: Int64 -> DBEntityId' 'DBStored
-  DBNewEntity :: DBEntityId' 'DBNew
-
-deriving instance Show (DBEntityId' s)
-
-deriving instance Eq (DBEntityId' s)
-
-type DBEntityId = DBEntityId' 'DBStored
-
-type DBNewEntity = DBEntityId' 'DBNew
-
-instance ToJSON (DBEntityId' s) where
-  toEncoding = \case
-    DBEntityId i -> toEncoding i
-    DBNewEntity -> JE.null_
-  toJSON = \case
-    DBEntityId i -> toJSON i
-    DBNewEntity -> J.Null
-
-instance DBStoredI s => FromJSON (DBEntityId' s) where
-  parseJSON v = case (v, sdbStored @s) of
-    (J.Null, SDBNew) -> pure DBNewEntity
-    (J.Number n, SDBStored) -> case floatingOrInteger n of
-      Left (_ :: Double) -> fail "bad DBEntityId"
-      Right i -> pure $ DBEntityId (fromInteger i)
-    _ -> fail "bad DBEntityId"
-  omittedField = case sdbStored @s of
-    SDBStored -> Nothing
-    SDBNew -> Just DBNewEntity
-
-instance FromField DBEntityId where
-#if defined(dbPostgres)
-  fromField x dat = DBEntityId <$> fromField x dat
-#else
-  fromField x = DBEntityId <$> fromField x
-#endif
-
-instance ToField DBEntityId where toField (DBEntityId i) = toField i
@@ -1,14 +0,0 @@
-{-# LANGUAGE CPP #-}
-
-module Simplex.Messaging.Agent.Store.Interface
-#if defined(dbPostgres)
-  ( module Simplex.Messaging.Agent.Store.Postgres,
-  )
-  where
-import Simplex.Messaging.Agent.Store.Postgres
-#else
-  ( module Simplex.Messaging.Agent.Store.SQLite,
-  )
-  where
-import Simplex.Messaging.Agent.Store.SQLite
-#endif
@@ -1,78 +0,0 @@
-{-# LANGUAGE LambdaCase #-}
-
-module Simplex.Messaging.Agent.Store.Migrations
-  ( Migration (..),
-    MigrationsToRun (..),
-    DownMigration (..),
-    DBMigrate (..),
-    sharedMigrateSchema,
-    -- for tests
-    migrationsToRun,
-    toDownMigration,
-  )
-where
-
-import Control.Monad
-import Data.Char (toLower)
-import Data.Functor (($>))
-import Data.Maybe (isJust, isNothing, mapMaybe)
-import Simplex.Messaging.Agent.Store.Shared
-import System.Exit (exitFailure)
-import System.IO (hFlush, stdout)
-
-migrationsToRun :: [Migration] -> [Migration] -> Either MTRError MigrationsToRun
-migrationsToRun [] [] = Right MTRNone
-migrationsToRun appMs [] = Right $ MTRUp appMs
-migrationsToRun [] dbMs
-  | length dms == length dbMs = Right $ MTRDown dms
-  | otherwise = Left $ MTRENoDown $ mapMaybe nameNoDown dbMs
-  where
-    dms = mapMaybe toDownMigration dbMs
-    nameNoDown m = if isNothing (down m) then Just $ name m else Nothing
-migrationsToRun (a : as) (d : ds)
-  | name a == name d = migrationsToRun as ds
-  | otherwise = Left $ MTREDifferent (name a) (name d)
-
-data DBMigrate = DBMigrate
-  { initialize :: IO (),
-    getCurrent :: IO [Migration],
-    run :: MigrationsToRun -> IO (),
-    backup :: Maybe (IO ())
-  }
-
-sharedMigrateSchema :: DBMigrate -> Bool -> [Migration] -> MigrationConfirmation -> IO (Either MigrationError ())
-sharedMigrateSchema dbm dbNew' migrations confirmMigrations = do
-  initialize dbm
-  currentMs <- getCurrent dbm
-  case migrationsToRun migrations currentMs of
-    Left e -> do
-      when (confirmMigrations == MCConsole) $ confirmOrExit ("Database state error: " <> mtrErrorDescription e)
-      pure . Left $ MigrationError e
-    Right MTRNone -> pure $ Right ()
-    Right ms@(MTRUp ums)
-      | dbNew' -> run dbm ms $> Right ()
-      | otherwise -> case confirmMigrations of
-          MCYesUp -> runWithBackup ms
-          MCYesUpDown -> runWithBackup ms
-          MCConsole -> confirm' err >> runWithBackup ms
-          MCError -> pure $ Left err
-      where
-        err = MEUpgrade $ map upMigration ums -- "The app has a newer version than the database.\nConfirm to back up and upgrade using these migrations: " <> intercalate ", " (map name ums)
-    Right ms@(MTRDown dms) -> case confirmMigrations of
-      MCYesUpDown -> runWithBackup ms
-      MCConsole -> confirm' err >> runWithBackup ms
-      MCYesUp -> pure $ Left err
-      MCError -> pure $ Left err
-      where
-        err = MEDowngrade $ map downName dms
-  where
-    runWithBackup ms = sequence (backup dbm) >> run dbm ms $> Right ()
-    confirm' err = confirmOrExit $ migrationErrorDescription (isJust $ backup dbm) err
-
-confirmOrExit :: String -> IO ()
-confirmOrExit s = do
-  putStrLn s
-  putStr "Continue (y/N): "
-  hFlush stdout
-  ok <- getLine
-  when (map toLower ok /= "y") exitFailure
@@ -1,14 +0,0 @@
-{-# LANGUAGE CPP #-}
-
-module Simplex.Messaging.Agent.Store.Migrations.App
-#if defined(dbPostgres)
-  ( module Simplex.Messaging.Agent.Store.Postgres.Migrations.App,
-  )
-  where
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.App
-#else
-  ( module Simplex.Messaging.Agent.Store.SQLite.Migrations.App,
-  )
-  where
-import Simplex.Messaging.Agent.Store.SQLite.Migrations.App
-#endif
@@ -1,137 +0,0 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-
-module Simplex.Messaging.Agent.Store.Postgres
-  ( DBOpts (..),
-    Migrations.getCurrentMigrations,
-    checkSchemaExists,
-    migrateDBSchema,
-    createDBStore,
-    closeDBStore,
-    reopenDBStore,
-    execSQL,
-  )
-where
-
-import Control.Concurrent.STM
-import Control.Exception (finally, onException, throwIO, uninterruptibleMask_)
-import Control.Logger.Simple (logError)
-import Control.Monad
-import Data.ByteString (ByteString)
-import Data.Functor (($>))
-import Data.Text (Text)
-import Database.PostgreSQL.Simple (Only (..))
-import Database.PostgreSQL.Simple.Types (Query (..))
-import qualified Database.PostgreSQL.Simple as PSQL
-import Database.PostgreSQL.Simple.SqlQQ (sql)
-import Simplex.Messaging.Agent.Store.Migrations (DBMigrate (..), sharedMigrateSchema)
-import qualified Simplex.Messaging.Agent.Store.Postgres.Migrations as Migrations
-import Simplex.Messaging.Agent.Store.Postgres.Common
-import qualified Simplex.Messaging.Agent.Store.Postgres.DB as DB
-import Simplex.Messaging.Agent.Store.Shared (Migration (..), MigrationConfig (..), MigrationError (..))
-import Simplex.Messaging.Util (ifM, safeDecodeUtf8)
-import System.Exit (exitFailure)
-
-- | Create a new Postgres DBStore with the given connection string, schema name and migrations.
-- If passed schema does not exist in connectInfo database, it will be created.
-- Applies necessary migrations to schema.
-createDBStore :: DBOpts -> [Migration] -> MigrationConfig -> IO (Either MigrationError DBStore)
-createDBStore opts migrations migrationConfig = do
-  st <- connectPostgresStore opts
-  r <- migrateDBSchema st opts Nothing migrations migrationConfig `onException` closeDBStore st
-  case r of
-    Right () -> pure $ Right st
-    Left e -> closeDBStore st $> Left e
-
-migrateDBSchema :: DBStore -> DBOpts -> Maybe Query -> [Migration] -> MigrationConfig -> IO (Either MigrationError ())
-migrateDBSchema st _opts migrationsTable migrations MigrationConfig {confirm} =
-  let initialize = Migrations.initialize st migrationsTable
-      getCurrent = withTransaction st $ Migrations.getCurrentMigrations migrationsTable
-      run = Migrations.run st migrationsTable
-      dbm = DBMigrate {initialize, getCurrent, run, backup = Nothing}
-   in sharedMigrateSchema dbm (dbNew st) migrations confirm
-
-connectPostgresStore :: DBOpts -> IO DBStore
-connectPostgresStore DBOpts {connstr, schema, poolSize, createSchema} = do
-  dbPriorityPool <- newDBStorePool poolSize
-  dbPool <- newDBStorePool poolSize
-  dbClosed <- newTVarIO True
-  let dbConnect = fst <$> connectDB connstr schema False
-      st = DBStore {dbConnstr = connstr, dbSchema = schema, dbPoolSize = fromIntegral poolSize, dbPriorityPool, dbPool, dbConnect, dbNew = False, dbClosed}
-  dbNew <- connectStore st createSchema
-  pure st {dbNew}
-
-- uninterruptibleMask_ here and below is used here so that it is not interrupted half-way,
-- it relies on the assumption that when dbClosed = True, the queue is empty,
-- and when it is False, the queue is full (or will have connections returned to it by the threads that use them).
-connectStore :: DBStore -> Bool -> IO Bool
-connectStore DBStore {dbConnstr, dbSchema, dbPoolSize, dbPriorityPool, dbPool, dbClosed} createSchema = uninterruptibleMask_ $ do
-  (conn, dbNew) <- connectDB dbConnstr dbSchema createSchema -- TODO [postgres] analogue for dbBusyLoop?
-  writeConns dbPriorityPool . (conn :) =<< mkConns (dbPoolSize - 1)
-  writeConns dbPool =<< mkConns dbPoolSize
-  atomically $ writeTVar dbClosed False
-  pure dbNew
-  where
-    writeConns pool conns = mapM_ (atomically . writeTBQueue (dbPoolConns pool)) conns
-    mkConns n = replicateM n $ fst <$> connectDB dbConnstr dbSchema False
-
-connectDB :: ByteString -> ByteString -> Bool -> IO (DB.Connection, Bool)
-connectDB connstr schema createSchema = do
-  db <- PSQL.connectPostgreSQL connstr
-  dbNew <- prepare db `onException` PSQL.close db
-  pure (db, dbNew)
-  where
-    prepare db = do
-      void $ PSQL.execute_ db "SET client_min_messages TO WARNING"
-      dbNew <- not <$> doesSchemaExist db schema
-      when dbNew $
-        if createSchema
-          then void $ PSQL.execute_ db $ Query $ "CREATE SCHEMA " <> schema
-          else do
-            logError $ "connectPostgresStore, schema " <> safeDecodeUtf8 schema <> " does not exist, exiting."
-            PSQL.close db
-            exitFailure
-      void $ PSQL.execute_ db $ Query $ "SET search_path TO " <> schema
-      pure dbNew
-
-checkSchemaExists :: ByteString -> ByteString -> IO Bool
-checkSchemaExists connstr schema = do
-  db <- PSQL.connectPostgreSQL connstr
-  doesSchemaExist db schema `finally` DB.close db
-
-doesSchemaExist :: DB.Connection -> ByteString -> IO Bool
-doesSchemaExist db schema = do
-  [Only schemaExists] <-
-    PSQL.query
-      db
-      [sql|
-        SELECT EXISTS (
-          SELECT 1 FROM pg_catalog.pg_namespace
-          WHERE nspname = ?
-        )
-      |]
-      (Only schema)
-  pure schemaExists
-
-closeDBStore :: DBStore -> IO ()
-closeDBStore DBStore {dbPoolSize, dbPriorityPool, dbPool, dbClosed} =
-  ifM (readTVarIO dbClosed) (putStrLn "closeDBStore: already closed") $ uninterruptibleMask_ $ do
-    closePool dbPriorityPool
-    closePool dbPool
-    atomically $ writeTVar dbClosed True
-  where
-    closePool pool = replicateM_ dbPoolSize $ atomically (readTBQueue $ dbPoolConns pool) >>= DB.close
-
-reopenDBStore :: DBStore -> IO ()
-reopenDBStore st =
-  ifM
-    (readTVarIO $ dbClosed st)
-    (void $ connectStore st False)
-    (putStrLn "reopenDBStore: already opened")
-
-- not used with postgres client (used for ExecAgentStoreSQL, ExecChatStoreSQL)
-execSQL :: PSQL.Connection -> Text -> IO [Text]
-execSQL _db _query = throwIO (userError "not implemented")
@@ -1,93 +0,0 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TupleSections #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Common
-  ( DBStore (..),
-    DBStorePool (..),
-    DBOpts (..),
-    newDBStorePool,
-    withConnection,
-    withConnection',
-    withTransaction,
-    withTransaction',
-    withTransactionPriority,
-  )
-where
-
-import Control.Concurrent.MVar
-import Control.Concurrent.STM
-import qualified Control.Exception as E
-import Data.ByteString (ByteString)
-import qualified Database.PostgreSQL.Simple as PSQL
-import Numeric.Natural (Natural)
-import Simplex.Messaging.Agent.Store.Postgres.Options
-
-- TODO [postgres] use log_min_duration_statement instead of custom slow queries (SQLite's Connection type)
-data DBStore = DBStore
-  { dbConnstr :: ByteString,
-    dbSchema :: ByteString,
-    dbPoolSize :: Int,
-    dbPriorityPool :: DBStorePool,
-    dbPool :: DBStorePool,
-    dbConnect :: IO PSQL.Connection,
-    dbClosed :: TVar Bool,
-    dbNew :: Bool
-  }
-
-newDBStorePool :: Natural -> IO DBStorePool
-newDBStorePool poolSize = do
-  dbSem <- newMVar ()
-  dbPoolConns <- newTBQueueIO poolSize
-  pure DBStorePool {dbSem, dbPoolConns}
-
-data DBStorePool = DBStorePool
-  { dbPoolConns :: TBQueue PSQL.Connection,
-    -- MVar is needed for fair pool distribution, without STM retry contention.
-    -- Only one thread can be blocked on STM read.
-    dbSem :: MVar ()
-  }
-
-withConnectionPriority :: DBStore -> Bool -> (PSQL.Connection -> IO a) -> IO a
-withConnectionPriority DBStore {dbPriorityPool, dbPool, dbConnect} priority =
-  withConnectionPool (if priority then dbPriorityPool else dbPool) dbConnect
-{-# INLINE withConnectionPriority #-}
-
-withConnectionPool :: DBStorePool -> IO PSQL.Connection -> (PSQL.Connection -> IO a) -> IO a
-withConnectionPool DBStorePool {dbPoolConns, dbSem} dbConnect action =
-  E.mask $ \restore -> do
-    conn <- withMVar dbSem $ \_ -> atomically $ readTBQueue dbPoolConns
-    r <- restore (action conn) `E.onException` reset conn
-    atomically $ writeTBQueue dbPoolConns conn
-    pure r
-  where
-    reset conn = do
-      conn' <- E.try dbConnect >>= \case
-        Right conn' -> PSQL.close conn >> pure conn'
-        Left (_ :: E.SomeException) -> pure conn
-      atomically $ writeTBQueue dbPoolConns conn'
-
-withConnection :: DBStore -> (PSQL.Connection -> IO a) -> IO a
-withConnection st = withConnectionPriority st False
-{-# INLINE withConnection #-}
-
-withConnection' :: DBStore -> (PSQL.Connection -> IO a) -> IO a
-withConnection' = withConnection
-{-# INLINE withConnection' #-}
-
-withTransaction' :: DBStore -> (PSQL.Connection -> IO a) -> IO a
-withTransaction' = withTransaction
-{-# INLINE withTransaction' #-}
-
-withTransaction :: DBStore -> (PSQL.Connection -> IO a) -> IO a
-withTransaction st = withTransactionPriority st False
-{-# INLINE withTransaction #-}
-
-- TODO [postgres] analogue for dbBusyLoop?
-withTransactionPriority :: DBStore -> Bool -> (PSQL.Connection -> IO a) -> IO a
-withTransactionPriority st priority action = withConnectionPriority st priority transaction
-  where
-    transaction conn = PSQL.withTransaction conn $ action conn
@@ -1,89 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.DB
-  ( BoolInt (..),
-    PSQL.Binary (..),
-    PSQL.Connection,
-    FromField (..),
-    ToField (..),
-    PSQL.connect,
-    PSQL.close,
-    execute,
-    execute_,
-    executeMany,
-    PSQL.query,
-    PSQL.query_,
-    blobFieldDecoder,
-    fromTextField_,
-  )
-where
-
-import Control.Monad (void)
-import Data.ByteString.Char8 (ByteString)
-import Data.Int (Int64)
-import Data.Text (Text)
-import Data.Text.Encoding (decodeUtf8)
-import Data.Typeable (Typeable)
-import Data.Word (Word16, Word32)
-import Database.PostgreSQL.Simple (ResultError (..))
-import qualified Database.PostgreSQL.Simple as PSQL
-import Database.PostgreSQL.Simple.FromField (Field (..), FieldParser, FromField (..), returnError)
-import Database.PostgreSQL.Simple.ToField (ToField (..))
-import Database.PostgreSQL.Simple.TypeInfo.Static (textOid, varcharOid)
-
-newtype BoolInt = BI {unBI :: Bool}
-
-instance FromField BoolInt where
-  fromField field dat = BI . (/= (0 :: Int)) <$> fromField field dat
-  {-# INLINE fromField #-}
-
-instance ToField BoolInt where
-  toField (BI b) = toField ((if b then 1 else 0) :: Int)
-  {-# INLINE toField #-}
-
-execute :: PSQL.ToRow q => PSQL.Connection -> PSQL.Query -> q -> IO ()
-execute db q qs = void $ PSQL.execute db q qs
-{-# INLINE execute #-}
-
-execute_ :: PSQL.Connection -> PSQL.Query -> IO ()
-execute_ db q = void $ PSQL.execute_ db q
-{-# INLINE execute_ #-}
-
-executeMany :: PSQL.ToRow q => PSQL.Connection -> PSQL.Query -> [q] -> IO ()
-executeMany db q qs = void $ PSQL.executeMany db q qs
-{-# INLINE executeMany #-}
-
-- orphan instances
-
-- used in FileSize
-instance FromField Word32 where
-  fromField field dat = do
-    i :: Int64 <- fromField field dat
-    if i >= 0 && i <= fromIntegral (maxBound :: Word32)
-      then pure (fromIntegral i :: Word32)
-      else returnError ConversionFailed field "Negative value can't be converted to Word32"
-
-- used in Version
-instance FromField Word16 where
-  fromField field dat = do
-    i :: Int64 <- fromField field dat
-    if i >= 0 && i <= fromIntegral (maxBound :: Word16)
-      then pure (fromIntegral i :: Word16)
-      else returnError ConversionFailed field "Negative value can't be converted to Word16"
-
-blobFieldDecoder :: Typeable k => (ByteString -> Either String k) -> FieldParser k
-blobFieldDecoder dec f val = do
-  x <- fromField f val
-  case dec x of
-    Right k -> pure k
-    Left e -> returnError ConversionFailed f ("couldn't parse field: " ++ e)
-
-fromTextField_ :: Typeable a => (Text -> Maybe a) -> FieldParser a
-fromTextField_ fromText f val =
-  if typeOid f `elem` [textOid, varcharOid]
-    then case val of
-      Just t -> case fromText $ decodeUtf8 t of
-        Just x -> pure x
-        _ -> returnError ConversionFailed f "invalid text value"
-      Nothing -> returnError UnexpectedNull f "NULL value found for non-NULL field"
-    else returnError Incompatible f "expecting TEXT or VARCHAR column type"
@@ -1,63 +0,0 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-{-# LANGUAGE TupleSections #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations
-  ( initialize,
-    run,
-    getCurrentMigrations,
-  )
-where
-
-import Control.Exception (throwIO)
-import Control.Monad (void)
-import qualified Data.ByteString.Char8 as B
-import Data.Maybe (fromMaybe)
-import qualified Data.Text as T
-import qualified Data.Text.Encoding as TE
-import Data.Time.Clock (getCurrentTime)
-import qualified Database.PostgreSQL.LibPQ as LibPQ
-import Database.PostgreSQL.Simple (Only (..), Query)
-import qualified Database.PostgreSQL.Simple as PSQL
-import Database.PostgreSQL.Simple.Internal (Connection (..))
-import Simplex.Messaging.Agent.Store.Postgres.Common
-import Simplex.Messaging.Agent.Store.Shared
-import Simplex.Messaging.Util (($>>=))
-import UnliftIO.MVar
-
-initialize :: DBStore -> Maybe Query -> IO ()
-initialize st migrationsTable = withTransaction' st $ \db ->
-  void $ PSQL.execute_ db $
-    "CREATE TABLE IF NOT EXISTS "
-      <> fromMaybe "migrations" migrationsTable
-      <> " (name TEXT NOT NULL PRIMARY KEY, ts TIMESTAMP NOT NULL, down TEXT)"
-
-run :: DBStore -> Maybe Query -> MigrationsToRun -> IO ()
-run st migrationsTable = \case
-  MTRUp [] -> pure ()
-  MTRUp ms -> mapM_ runUp ms
-  MTRDown ms -> mapM_ runDown $ reverse ms
-  MTRNone -> pure ()
-  where
-    table = fromMaybe "migrations" migrationsTable
-    runUp Migration {name, up, down} = withTransaction' st $ \db -> do
-      insert db
-      execSQL db up
-      where
-        insert db = void $ PSQL.execute db ("INSERT INTO " <> table <> " (name, down, ts) VALUES (?,?,?)") . (name,down,) =<< getCurrentTime
-    runDown DownMigration {downName, downQuery} = withTransaction' st $ \db -> do
-      execSQL db downQuery
-      void $ PSQL.execute db ("DELETE FROM " <> table <> " WHERE name = ?") (Only downName)
-    execSQL db query =
-      withMVar (connectionHandle db) $ \pqConn ->
-        LibPQ.exec pqConn (TE.encodeUtf8 query) $>>= LibPQ.resultErrorMessage >>= \case
-          Just e | not (B.null e) -> throwIO $ userError $ B.unpack e
-          _ -> pure ()
-
-getCurrentMigrations :: Maybe Query -> PSQL.Connection -> IO [Migration]
-getCurrentMigrations migrationsTable db = map toMigration <$> PSQL.query_ db ("SELECT name, down FROM " <> table <> " ORDER BY name ASC;")
-  where
-    table = fromMaybe "migrations" migrationsTable
-    toMigration (name, down) = Migration {name, up = T.pack "", down}
@@ -1,29 +0,0 @@
-{-# LANGUAGE NamedFieldPuns #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.App (appMigrations) where
-
-import Data.List (sortOn)
-import Data.Text (Text)
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20241210_initial
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250203_msg_bodies
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250322_short_links
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250702_conn_invitations_remove_cascade_delete
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251009_queue_to_subscribe
-import Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251010_client_notices
-import Simplex.Messaging.Agent.Store.Shared (Migration (..))
-
-schemaMigrations :: [(String, Text, Maybe Text)]
-schemaMigrations =
-  [ ("20241210_initial", m20241210_initial, Nothing),
-    ("20250203_msg_bodies", m20250203_msg_bodies, Just down_m20250203_msg_bodies),
-    ("20250322_short_links", m20250322_short_links, Just down_m20250322_short_links),
-    ("20250702_conn_invitations_remove_cascade_delete", m20250702_conn_invitations_remove_cascade_delete, Just down_m20250702_conn_invitations_remove_cascade_delete),
-    ("20251009_queue_to_subscribe", m20251009_queue_to_subscribe, Just down_m20251009_queue_to_subscribe),
-    ("20251010_client_notices", m20251010_client_notices, Just down_m20251010_client_notices)
-  ]
-
-- | The list of migrations in ascending order by date
-appMigrations :: [Migration]
-appMigrations = sortOn name $ map migration schemaMigrations
-  where
-    migration (name, up, down) = Migration {name, up, down = down}
@@ -1,544 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20241210_initial where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20241210_initial :: Text
-m20241210_initial =
-  [r|
-CREATE TABLE users(
-  user_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  deleted SMALLINT NOT NULL DEFAULT 0
-);
-CREATE TABLE servers(
-  host TEXT NOT NULL,
-  port TEXT NOT NULL,
-  key_hash BYTEA NOT NULL,
-  PRIMARY KEY(host, port)
-);
-CREATE TABLE connections(
-  conn_id BYTEA NOT NULL PRIMARY KEY,
-  conn_mode TEXT NOT NULL,
-  last_internal_msg_id BIGINT NOT NULL DEFAULT 0,
-  last_internal_rcv_msg_id BIGINT NOT NULL DEFAULT 0,
-  last_internal_snd_msg_id BIGINT NOT NULL DEFAULT 0,
-  last_external_snd_msg_id BIGINT NOT NULL DEFAULT 0,
-  last_rcv_msg_hash BYTEA NOT NULL DEFAULT ''::BYTEA,
-  last_snd_msg_hash BYTEA NOT NULL DEFAULT ''::BYTEA,
-  smp_agent_version INTEGER NOT NULL DEFAULT 1,
-  duplex_handshake SMALLINT NULL DEFAULT 0,
-  enable_ntfs SMALLINT,
-  deleted SMALLINT NOT NULL DEFAULT 0,
-  user_id BIGINT NOT NULL REFERENCES users ON DELETE CASCADE,
-  ratchet_sync_state TEXT NOT NULL DEFAULT 'ok',
-  deleted_at_wait_delivery TIMESTAMPTZ,
-  pq_support SMALLINT NOT NULL DEFAULT 0
-);
-CREATE TABLE rcv_queues(
-  host TEXT NOT NULL,
-  port TEXT NOT NULL,
-  rcv_id BYTEA NOT NULL,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  rcv_private_key BYTEA NOT NULL,
-  rcv_dh_secret BYTEA NOT NULL,
-  e2e_priv_key BYTEA NOT NULL,
-  e2e_dh_secret BYTEA,
-  snd_id BYTEA NOT NULL,
-  snd_key BYTEA,
-  status TEXT NOT NULL,
-  smp_server_version INTEGER NOT NULL DEFAULT 1,
-  smp_client_version INTEGER,
-  ntf_public_key BYTEA,
-  ntf_private_key BYTEA,
-  ntf_id BYTEA,
-  rcv_ntf_dh_secret BYTEA,
-  rcv_queue_id BIGINT NOT NULL,
-  rcv_primary SMALLINT NOT NULL,
-  replace_rcv_queue_id BIGINT NULL,
-  delete_errors BIGINT NOT NULL DEFAULT 0,
-  server_key_hash BYTEA,
-  switch_status TEXT,
-  deleted SMALLINT NOT NULL DEFAULT 0,
-  snd_secure SMALLINT NOT NULL DEFAULT 0,
-  last_broker_ts TIMESTAMPTZ,
-  PRIMARY KEY(host, port, rcv_id),
-  FOREIGN KEY(host, port) REFERENCES servers
-  ON DELETE RESTRICT ON UPDATE CASCADE,
-  UNIQUE(host, port, snd_id)
-);
-CREATE TABLE snd_queues(
-  host TEXT NOT NULL,
-  port TEXT NOT NULL,
-  snd_id BYTEA NOT NULL,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  snd_private_key BYTEA NOT NULL,
-  e2e_dh_secret BYTEA NOT NULL,
-  status TEXT NOT NULL,
-  smp_server_version INTEGER NOT NULL DEFAULT 1,
-  smp_client_version INTEGER NOT NULL DEFAULT 1,
-  snd_public_key BYTEA,
-  e2e_pub_key BYTEA,
-  snd_queue_id BIGINT NOT NULL,
-  snd_primary SMALLINT NOT NULL,
-  replace_snd_queue_id BIGINT NULL,
-  server_key_hash BYTEA,
-  switch_status TEXT,
-  snd_secure SMALLINT NOT NULL DEFAULT 0,
-  PRIMARY KEY(host, port, snd_id),
-  FOREIGN KEY(host, port) REFERENCES servers
-  ON DELETE RESTRICT ON UPDATE CASCADE
-);
-CREATE TABLE messages(
-  conn_id BYTEA NOT NULL REFERENCES connections(conn_id)
-  ON DELETE CASCADE,
-  internal_id BIGINT NOT NULL,
-  internal_ts TIMESTAMPTZ NOT NULL,
-  internal_rcv_id BIGINT,
-  internal_snd_id BIGINT,
-  msg_type BYTEA NOT NULL,
-  msg_body BYTEA NOT NULL DEFAULT ''::BYTEA,
-  msg_flags TEXT NULL,
-  pq_encryption SMALLINT NOT NULL DEFAULT 0,
-  PRIMARY KEY(conn_id, internal_id)
-);
-CREATE TABLE rcv_messages(
-  conn_id BYTEA NOT NULL,
-  internal_rcv_id BIGINT NOT NULL,
-  internal_id BIGINT NOT NULL,
-  external_snd_id BIGINT NOT NULL,
-  broker_id BYTEA NOT NULL,
-  broker_ts TIMESTAMPTZ NOT NULL,
-  internal_hash BYTEA NOT NULL,
-  external_prev_snd_hash BYTEA NOT NULL,
-  integrity BYTEA NOT NULL,
-  user_ack SMALLINT NULL DEFAULT 0,
-  rcv_queue_id BIGINT NOT NULL,
-  PRIMARY KEY(conn_id, internal_rcv_id),
-  FOREIGN KEY(conn_id, internal_id) REFERENCES messages
-  ON DELETE CASCADE
-);
-ALTER TABLE messages
-ADD CONSTRAINT fk_messages_rcv_messages
-  FOREIGN KEY (conn_id, internal_rcv_id) REFERENCES rcv_messages
-  ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED;
-CREATE TABLE snd_messages(
-  conn_id BYTEA NOT NULL,
-  internal_snd_id BIGINT NOT NULL,
-  internal_id BIGINT NOT NULL,
-  internal_hash BYTEA NOT NULL,
-  previous_msg_hash BYTEA NOT NULL DEFAULT ''::BYTEA,
-  retry_int_slow BIGINT,
-  retry_int_fast BIGINT,
-  rcpt_internal_id BIGINT,
-  rcpt_status TEXT,
-  PRIMARY KEY(conn_id, internal_snd_id),
-  FOREIGN KEY(conn_id, internal_id) REFERENCES messages
-  ON DELETE CASCADE
-);
-ALTER TABLE messages
-ADD CONSTRAINT fk_messages_snd_messages
-  FOREIGN KEY (conn_id, internal_snd_id) REFERENCES snd_messages
-  ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED;
-CREATE TABLE conn_confirmations(
-  confirmation_id BYTEA NOT NULL PRIMARY KEY,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  e2e_snd_pub_key BYTEA NOT NULL,
-  sender_key BYTEA,
-  ratchet_state BYTEA NOT NULL,
-  sender_conn_info BYTEA NOT NULL,
-  accepted SMALLINT NOT NULL,
-  own_conn_info BYTEA,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  smp_reply_queues BYTEA NULL,
-  smp_client_version INTEGER
-);
-CREATE TABLE conn_invitations(
-  invitation_id BYTEA NOT NULL PRIMARY KEY,
-  contact_conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  cr_invitation BYTEA NOT NULL,
-  recipient_conn_info BYTEA NOT NULL,
-  accepted SMALLINT NOT NULL DEFAULT 0,
-  own_conn_info BYTEA,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE ratchets(
-  conn_id BYTEA NOT NULL PRIMARY KEY REFERENCES connections
-  ON DELETE CASCADE,
-  x3dh_priv_key_1 BYTEA,
-  x3dh_priv_key_2 BYTEA,
-  ratchet_state BYTEA,
-  e2e_version INTEGER NOT NULL DEFAULT 1,
-  x3dh_pub_key_1 BYTEA,
-  x3dh_pub_key_2 BYTEA,
-  pq_priv_kem BYTEA,
-  pq_pub_kem BYTEA
-);
-CREATE TABLE skipped_messages(
-  skipped_message_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  conn_id BYTEA NOT NULL REFERENCES ratchets
-  ON DELETE CASCADE,
-  header_key BYTEA NOT NULL,
-  msg_n BIGINT NOT NULL,
-  msg_key BYTEA NOT NULL
-);
-CREATE TABLE ntf_servers(
-  ntf_host TEXT NOT NULL,
-  ntf_port TEXT NOT NULL,
-  ntf_key_hash BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  PRIMARY KEY(ntf_host, ntf_port)
-);
-CREATE TABLE ntf_tokens(
-  provider TEXT NOT NULL,
-  device_token TEXT NOT NULL,
-  ntf_host TEXT NOT NULL,
-  ntf_port TEXT NOT NULL,
-  tkn_id BYTEA,
-  tkn_pub_key BYTEA NOT NULL,
-  tkn_priv_key BYTEA NOT NULL,
-  tkn_pub_dh_key BYTEA NOT NULL,
-  tkn_priv_dh_key BYTEA NOT NULL,
-  tkn_dh_secret BYTEA,
-  tkn_status TEXT NOT NULL,
-  tkn_action BYTEA,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  ntf_mode BYTEA NULL,
-  PRIMARY KEY(provider, device_token, ntf_host, ntf_port),
-  FOREIGN KEY(ntf_host, ntf_port) REFERENCES ntf_servers
-  ON DELETE RESTRICT ON UPDATE CASCADE
-);
-CREATE TABLE ntf_subscriptions(
-  conn_id BYTEA NOT NULL,
-  smp_host TEXT NULL,
-  smp_port TEXT NULL,
-  smp_ntf_id BYTEA,
-  ntf_host TEXT NOT NULL,
-  ntf_port TEXT NOT NULL,
-  ntf_sub_id BYTEA,
-  ntf_sub_status TEXT NOT NULL,
-  ntf_sub_action BYTEA,
-  ntf_sub_smp_action BYTEA,
-  ntf_sub_action_ts TIMESTAMPTZ,
-  updated_by_supervisor SMALLINT NOT NULL DEFAULT 0,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  smp_server_key_hash BYTEA,
-  ntf_failed SMALLINT DEFAULT 0,
-  smp_failed SMALLINT DEFAULT 0,
-  PRIMARY KEY(conn_id),
-  FOREIGN KEY(smp_host, smp_port) REFERENCES servers(host, port)
-  ON DELETE SET NULL ON UPDATE CASCADE,
-  FOREIGN KEY(ntf_host, ntf_port) REFERENCES ntf_servers
-  ON DELETE RESTRICT ON UPDATE CASCADE
-);
-CREATE TABLE commands(
-  command_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  host TEXT,
-  port TEXT,
-  corr_id BYTEA NOT NULL,
-  command_tag BYTEA NOT NULL,
-  command BYTEA NOT NULL,
-  agent_version INTEGER NOT NULL DEFAULT 1,
-  server_key_hash BYTEA,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT '1970-01-01 00:00:00',
-  failed SMALLINT DEFAULT 0,
-  FOREIGN KEY(host, port) REFERENCES servers
-  ON DELETE RESTRICT ON UPDATE CASCADE
-);
-CREATE TABLE snd_message_deliveries(
-  snd_message_delivery_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  snd_queue_id BIGINT NOT NULL,
-  internal_id BIGINT NOT NULL,
-  failed SMALLINT DEFAULT 0,
-  FOREIGN KEY(conn_id, internal_id) REFERENCES messages ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED
-);
-CREATE TABLE xftp_servers(
-  xftp_server_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  xftp_host TEXT NOT NULL,
-  xftp_port TEXT NOT NULL,
-  xftp_key_hash BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  UNIQUE(xftp_host, xftp_port, xftp_key_hash)
-);
-CREATE TABLE rcv_files(
-  rcv_file_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  rcv_file_entity_id BYTEA NOT NULL,
-  user_id BIGINT NOT NULL REFERENCES users ON DELETE CASCADE,
-  size BIGINT NOT NULL,
-  digest BYTEA NOT NULL,
-  key BYTEA NOT NULL,
-  nonce BYTEA NOT NULL,
-  chunk_size BIGINT NOT NULL,
-  prefix_path TEXT NOT NULL,
-  tmp_path TEXT,
-  save_path TEXT NOT NULL,
-  status TEXT NOT NULL,
-  deleted SMALLINT NOT NULL DEFAULT 0,
-  error TEXT,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  save_file_key BYTEA,
-  save_file_nonce BYTEA,
-  failed SMALLINT DEFAULT 0,
-  redirect_id BIGINT REFERENCES rcv_files ON DELETE SET NULL,
-  redirect_entity_id BYTEA,
-  redirect_size BIGINT,
-  redirect_digest BYTEA,
-  approved_relays SMALLINT NOT NULL DEFAULT 0,
-  UNIQUE(rcv_file_entity_id)
-);
-CREATE TABLE rcv_file_chunks(
-  rcv_file_chunk_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  rcv_file_id BIGINT NOT NULL REFERENCES rcv_files ON DELETE CASCADE,
-  chunk_no BIGINT NOT NULL,
-  chunk_size BIGINT NOT NULL,
-  digest BYTEA NOT NULL,
-  tmp_path TEXT,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE rcv_file_chunk_replicas(
-  rcv_file_chunk_replica_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  rcv_file_chunk_id BIGINT NOT NULL REFERENCES rcv_file_chunks ON DELETE CASCADE,
-  replica_number BIGINT NOT NULL,
-  xftp_server_id BIGINT NOT NULL REFERENCES xftp_servers ON DELETE CASCADE,
-  replica_id BYTEA NOT NULL,
-  replica_key BYTEA NOT NULL,
-  received SMALLINT NOT NULL DEFAULT 0,
-  delay BIGINT,
-  retries BIGINT NOT NULL DEFAULT 0,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE snd_files(
-  snd_file_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  snd_file_entity_id BYTEA NOT NULL,
-  user_id BIGINT NOT NULL REFERENCES users ON DELETE CASCADE,
-  num_recipients BIGINT NOT NULL,
-  digest BYTEA,
-  key BYTEA NOT NUll,
-  nonce BYTEA NOT NUll,
-  path TEXT NOT NULL,
-  prefix_path TEXT,
-  status TEXT NOT NULL,
-  deleted SMALLINT NOT NULL DEFAULT 0,
-  error TEXT,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  src_file_key BYTEA,
-  src_file_nonce BYTEA,
-  failed SMALLINT DEFAULT 0,
-  redirect_size BIGINT,
-  redirect_digest BYTEA
-);
-CREATE TABLE snd_file_chunks(
-  snd_file_chunk_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  snd_file_id BIGINT NOT NULL REFERENCES snd_files ON DELETE CASCADE,
-  chunk_no BIGINT NOT NULL,
-  chunk_offset BIGINT NOT NULL,
-  chunk_size BIGINT NOT NULL,
-  digest BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE snd_file_chunk_replicas(
-  snd_file_chunk_replica_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  snd_file_chunk_id BIGINT NOT NULL REFERENCES snd_file_chunks ON DELETE CASCADE,
-  replica_number BIGINT NOT NULL,
-  xftp_server_id BIGINT NOT NULL REFERENCES xftp_servers ON DELETE CASCADE,
-  replica_id BYTEA NOT NULL,
-  replica_key BYTEA NOT NULL,
-  replica_status TEXT NOT NULL,
-  delay BIGINT,
-  retries BIGINT NOT NULL DEFAULT 0,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE snd_file_chunk_replica_recipients(
-  snd_file_chunk_replica_recipient_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  snd_file_chunk_replica_id BIGINT NOT NULL REFERENCES snd_file_chunk_replicas ON DELETE CASCADE,
-  rcv_replica_id BYTEA NOT NULL,
-  rcv_replica_key BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE deleted_snd_chunk_replicas(
-  deleted_snd_chunk_replica_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  user_id BIGINT NOT NULL REFERENCES users ON DELETE CASCADE,
-  xftp_server_id BIGINT NOT NULL REFERENCES xftp_servers ON DELETE CASCADE,
-  replica_id BYTEA NOT NULL,
-  replica_key BYTEA NOT NULL,
-  chunk_digest BYTEA NOT NULL,
-  delay BIGINT,
-  retries BIGINT NOT NULL DEFAULT 0,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  failed SMALLINT DEFAULT 0
-);
-CREATE TABLE encrypted_rcv_message_hashes(
-  encrypted_rcv_message_hash_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  hash BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE processed_ratchet_key_hashes(
-  processed_ratchet_key_hash_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  conn_id BYTEA NOT NULL REFERENCES connections ON DELETE CASCADE,
-  hash BYTEA NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE TABLE servers_stats(
-  servers_stats_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  servers_stats TEXT,
-  started_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now()),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-INSERT INTO servers_stats DEFAULT VALUES;
-CREATE TABLE ntf_tokens_to_delete(
-  ntf_token_to_delete_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  ntf_host TEXT NOT NULL,
-  ntf_port TEXT NOT NULL,
-  ntf_key_hash BYTEA NOT NULL,
-  tkn_id BYTEA NOT NULL,
-  tkn_priv_key BYTEA NOT NULL,
-  del_failed SMALLINT DEFAULT 0,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT (now())
-);
-CREATE UNIQUE INDEX idx_rcv_queues_ntf ON rcv_queues(host, port, ntf_id);
-CREATE UNIQUE INDEX idx_rcv_queue_id ON rcv_queues(conn_id, rcv_queue_id);
-CREATE UNIQUE INDEX idx_snd_queue_id ON snd_queues(conn_id, snd_queue_id);
-CREATE INDEX idx_snd_message_deliveries ON snd_message_deliveries(
-  conn_id,
-  snd_queue_id
-);
-CREATE INDEX idx_connections_user ON connections(user_id);
-CREATE INDEX idx_commands_conn_id ON commands(conn_id);
-CREATE INDEX idx_commands_host_port ON commands(host, port);
-CREATE INDEX idx_conn_confirmations_conn_id ON conn_confirmations(conn_id);
-CREATE INDEX idx_conn_invitations_contact_conn_id ON conn_invitations(
-  contact_conn_id
-);
-CREATE INDEX idx_messages_conn_id_internal_snd_id ON messages(
-  conn_id,
-  internal_snd_id
-);
-CREATE INDEX idx_messages_conn_id_internal_rcv_id ON messages(
-  conn_id,
-  internal_rcv_id
-);
-CREATE INDEX idx_messages_conn_id ON messages(conn_id);
-CREATE INDEX idx_ntf_subscriptions_ntf_host_ntf_port ON ntf_subscriptions(
-  ntf_host,
-  ntf_port
-);
-CREATE INDEX idx_ntf_subscriptions_smp_host_smp_port ON ntf_subscriptions(
-  smp_host,
-  smp_port
-);
-CREATE INDEX idx_ntf_tokens_ntf_host_ntf_port ON ntf_tokens(
-  ntf_host,
-  ntf_port
-);
-CREATE INDEX idx_ratchets_conn_id ON ratchets(conn_id);
-CREATE INDEX idx_rcv_messages_conn_id_internal_id ON rcv_messages(
-  conn_id,
-  internal_id
-);
-CREATE INDEX idx_skipped_messages_conn_id ON skipped_messages(conn_id);
-CREATE INDEX idx_snd_message_deliveries_conn_id_internal_id ON snd_message_deliveries(
-  conn_id,
-  internal_id
-);
-CREATE INDEX idx_snd_messages_conn_id_internal_id ON snd_messages(
-  conn_id,
-  internal_id
-);
-CREATE INDEX idx_snd_queues_host_port ON snd_queues(host, port);
-CREATE INDEX idx_rcv_files_user_id ON rcv_files(user_id);
-CREATE INDEX idx_rcv_file_chunks_rcv_file_id ON rcv_file_chunks(rcv_file_id);
-CREATE INDEX idx_rcv_file_chunk_replicas_rcv_file_chunk_id ON rcv_file_chunk_replicas(
-  rcv_file_chunk_id
-);
-CREATE INDEX idx_rcv_file_chunk_replicas_xftp_server_id ON rcv_file_chunk_replicas(
-  xftp_server_id
-);
-CREATE INDEX idx_snd_files_user_id ON snd_files(user_id);
-CREATE INDEX idx_snd_file_chunks_snd_file_id ON snd_file_chunks(snd_file_id);
-CREATE INDEX idx_snd_file_chunk_replicas_snd_file_chunk_id ON snd_file_chunk_replicas(
-  snd_file_chunk_id
-);
-CREATE INDEX idx_snd_file_chunk_replicas_xftp_server_id ON snd_file_chunk_replicas(
-  xftp_server_id
-);
-CREATE INDEX idx_snd_file_chunk_replica_recipients_snd_file_chunk_replica_id ON snd_file_chunk_replica_recipients(
-  snd_file_chunk_replica_id
-);
-CREATE INDEX idx_deleted_snd_chunk_replicas_user_id ON deleted_snd_chunk_replicas(
-  user_id
-);
-CREATE INDEX idx_deleted_snd_chunk_replicas_xftp_server_id ON deleted_snd_chunk_replicas(
-  xftp_server_id
-);
-CREATE INDEX idx_rcv_file_chunk_replicas_pending ON rcv_file_chunk_replicas(
-  received,
-  replica_number
-);
-CREATE INDEX idx_snd_file_chunk_replicas_pending ON snd_file_chunk_replicas(
-  replica_status,
-  replica_number
-);
-CREATE INDEX idx_deleted_snd_chunk_replicas_pending ON deleted_snd_chunk_replicas(
-  created_at
-);
-CREATE INDEX idx_encrypted_rcv_message_hashes_hash ON encrypted_rcv_message_hashes(
-  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
-);
-CREATE INDEX idx_processed_ratchet_key_hashes_created_at ON processed_ratchet_key_hashes(
-  created_at
-);
-CREATE INDEX idx_encrypted_rcv_message_hashes_created_at ON encrypted_rcv_message_hashes(
-  created_at
-);
-CREATE INDEX idx_messages_internal_ts ON messages(internal_ts);
-CREATE INDEX idx_commands_server_commands ON commands(
-  host,
-  port,
-  created_at,
-  command_id
-);
-CREATE INDEX idx_rcv_files_status_created_at ON rcv_files(status, created_at);
-CREATE INDEX idx_snd_files_status_created_at ON snd_files(status, created_at);
-CREATE INDEX idx_snd_files_snd_file_entity_id ON snd_files(snd_file_entity_id);
-CREATE INDEX idx_messages_snd_expired ON messages(
-  conn_id,
-  internal_snd_id,
-  internal_ts
-);
-CREATE INDEX idx_snd_message_deliveries_expired ON snd_message_deliveries(
-  conn_id,
-  snd_queue_id,
-  failed,
-  internal_id
-);
-CREATE INDEX idx_rcv_files_redirect_id on rcv_files(redirect_id);
-|]
@@ -1,35 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250203_msg_bodies where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20250203_msg_bodies :: Text
-m20250203_msg_bodies =
-  [r|
-ALTER TABLE snd_messages ADD COLUMN msg_encrypt_key BYTEA;
-ALTER TABLE snd_messages ADD COLUMN padded_msg_len BIGINT;
-
-
-CREATE TABLE snd_message_bodies (
-  snd_message_body_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  agent_msg BYTEA NOT NULL DEFAULT ''::BYTEA
-);
-ALTER TABLE snd_messages ADD COLUMN snd_message_body_id BIGINT REFERENCES snd_message_bodies ON DELETE SET NULL;
-CREATE INDEX idx_snd_messages_snd_message_body_id ON snd_messages(snd_message_body_id);
-|]
-
-
-down_m20250203_msg_bodies :: Text
-down_m20250203_msg_bodies =
-  [r|
-DROP INDEX idx_snd_messages_snd_message_body_id;
-ALTER TABLE snd_messages DROP COLUMN snd_message_body_id;
-DROP TABLE snd_message_bodies;
-
-
-ALTER TABLE snd_messages DROP COLUMN msg_encrypt_key;
-ALTER TABLE snd_messages DROP COLUMN padded_msg_len;
-|]
@@ -1,61 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250322_short_links where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20250322_short_links :: Text
-m20250322_short_links =
-  [r|
-ALTER TABLE rcv_queues ADD COLUMN link_id BYTEA;
-ALTER TABLE rcv_queues ADD COLUMN link_key BYTEA;
-ALTER TABLE rcv_queues ADD COLUMN link_priv_sig_key BYTEA;
-ALTER TABLE rcv_queues ADD COLUMN link_enc_fixed_data BYTEA;
-
-CREATE UNIQUE INDEX idx_rcv_queues_link_id ON rcv_queues(host, port, link_id);
-
-ALTER TABLE rcv_queues ADD COLUMN queue_mode TEXT;
-UPDATE rcv_queues SET queue_mode = 'M' WHERE snd_secure = 1;
-ALTER TABLE rcv_queues DROP COLUMN snd_secure;
-
-ALTER TABLE snd_queues ADD COLUMN queue_mode TEXT;
-UPDATE snd_queues SET queue_mode = 'M' WHERE snd_secure = 1;
-ALTER TABLE snd_queues DROP COLUMN snd_secure;
-
-CREATE TABLE inv_short_links(
-  inv_short_link_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  host TEXT NOT NULL,
-  port TEXT NOT NULL,
-  server_key_hash BYTEA,
-  link_id BYTEA NOT NULL,
-  link_key BYTEA NOT NULL,
-  snd_private_key BYTEA NOT NULL,
-  snd_id BYTEA,
-  FOREIGN KEY(host, port) REFERENCES servers ON DELETE RESTRICT ON UPDATE CASCADE
-);
-
-CREATE UNIQUE INDEX idx_inv_short_links_link_id ON inv_short_links(host, port, link_id);
-|]
-
-down_m20250322_short_links :: Text
-down_m20250322_short_links =
-  [r|
-DROP INDEX idx_rcv_queues_link_id;
-ALTER TABLE rcv_queues DROP COLUMN link_id;
-ALTER TABLE rcv_queues DROP COLUMN link_key;
-ALTER TABLE rcv_queues DROP COLUMN link_priv_sig_key;
-ALTER TABLE rcv_queues DROP COLUMN link_enc_fixed_data;
-
-DROP INDEX idx_inv_short_links_link_id;
-DROP TABLE inv_short_links;
-
-ALTER TABLE rcv_queues ADD COLUMN snd_secure INTEGER NOT NULL DEFAULT 0;
-UPDATE rcv_queues SET snd_secure = 1 WHERE queue_mode = 'M';
-ALTER TABLE rcv_queues DROP COLUMN queue_mode;
-
-ALTER TABLE snd_queues ADD COLUMN snd_secure INTEGER NOT NULL DEFAULT 0;
-UPDATE snd_queues SET snd_secure = 1 WHERE queue_mode = 'M';
-ALTER TABLE snd_queues DROP COLUMN queue_mode;
-|]
@@ -1,35 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20250702_conn_invitations_remove_cascade_delete where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20250702_conn_invitations_remove_cascade_delete :: Text
-m20250702_conn_invitations_remove_cascade_delete =
-  [r|
-ALTER TABLE conn_invitations DROP CONSTRAINT conn_invitations_contact_conn_id_fkey;
-
-ALTER TABLE conn_invitations ALTER COLUMN contact_conn_id DROP NOT NULL;
-
-ALTER TABLE conn_invitations
-  ADD CONSTRAINT conn_invitations_contact_conn_id_fkey
-  FOREIGN KEY (contact_conn_id)
-  REFERENCES connections(conn_id)
-  ON DELETE SET NULL;
-|]
-
-down_m20250702_conn_invitations_remove_cascade_delete :: Text
-down_m20250702_conn_invitations_remove_cascade_delete =
-  [r|
-ALTER TABLE conn_invitations DROP CONSTRAINT conn_invitations_contact_conn_id_fkey;
-
-ALTER TABLE conn_invitations ALTER COLUMN contact_conn_id SET NOT NULL;
-
-ALTER TABLE conn_invitations
-  ADD CONSTRAINT conn_invitations_contact_conn_id_fkey
-  FOREIGN KEY (contact_conn_id)
-  REFERENCES connections(conn_id)
-  ON DELETE CASCADE;
-|]
@@ -1,21 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251009_queue_to_subscribe where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20251009_queue_to_subscribe :: Text
-m20251009_queue_to_subscribe =
-  [r|
-ALTER TABLE rcv_queues ADD COLUMN to_subscribe SMALLINT NOT NULL DEFAULT 0;
-CREATE INDEX idx_rcv_queues_to_subscribe ON rcv_queues(to_subscribe);
-|]
-
-down_m20251009_queue_to_subscribe :: Text
-down_m20251009_queue_to_subscribe =
-  [r|
-DROP INDEX idx_rcv_queues_to_subscribe;
-ALTER TABLE rcv_queues DROP COLUMN to_subscribe;
-|]
@@ -1,40 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
-
-module Simplex.Messaging.Agent.Store.Postgres.Migrations.M20251010_client_notices where
-
-import Data.Text (Text)
-import Text.RawString.QQ (r)
-
-m20251010_client_notices :: Text
-m20251010_client_notices =
-  [r|
-CREATE TABLE client_notices(
-  client_notice_id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
-  protocol TEXT NOT NULL,
-  host TEXT NOT NULL,
-  port TEXT NOT NULL,
-  entity_id BYTEA NOT NULL,
-  server_key_hash BYTEA,
-  notice_ttl BIGINT,
-  created_at BIGINT NOT NULL,
-  updated_at BIGINT NOT NULL
-);
-
-CREATE UNIQUE INDEX idx_client_notices_entity ON client_notices(protocol, host, port, entity_id);
-
-ALTER TABLE rcv_queues ADD COLUMN client_notice_id BIGINT
-REFERENCES client_notices ON UPDATE RESTRICT ON DELETE SET NULL;
-
-CREATE INDEX idx_rcv_queues_client_notice_id ON rcv_queues(client_notice_id);
-|]
-
-down_m20251010_client_notices :: Text
-down_m20251010_client_notices =
-  [r|
-DROP INDEX idx_rcv_queues_client_notice_id;
-ALTER TABLE rcv_queues DROP COLUMN client_notice_id;
-
-DROP INDEX idx_client_notices_entity;
-DROP TABLE client_notices;
-|]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Evgeny Poberezkin	692d829dca	remove more	2024-08-09 11:12:17 +01:00
Evgeny Poberezkin	e10cec4c94	refactor	2024-08-09 11:01:32 +01:00
Evgeny Poberezkin	b9654fad31	reduce STM more	2024-08-09 10:55:40 +01:00
Evgeny Poberezkin	0e7471ee00	reduce the number of STM transactions	2024-08-08 23:45:54 +01:00