fix: allow removing channel slowmode (#836)

Signed-off-by: Zomatree <me@zomatree.live>

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,147 @@
+name: Bug Report
+description: Report a bug in Stoat — please fill out every required field to help us triage quickly.
+title: "[Bug]: "
+labels:
+  - bug
+  - unconfirmed
+
+body:
+  # ── Thank you section ────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you for taking the time to report a bug for Stoat!**
+
+        Please follow the instructions below and provide as much detail as possible to help us understand and reproduce the issue.
+
+  # ── Pre-flight checks ────────────────────────────────────────────────────────
+  - type: checkboxes
+    id: preflight
+    attributes:
+      label: Pre-flight checklist
+      description: Please confirm all of the following before submitting.
+      options:
+        - label: I am on the latest available version of Stoat.
+          required: true
+        - label: I searched existing issues and did not find a duplicate.
+          required: true
+        - label: This is a bug report, not a support question or feature request.
+          required: true
+
+  # ── Bug description ──────────────────────────────────────────────────────────
+  - type: textarea
+    id: description
+    attributes:
+      label: Bug description
+      description: >
+        What happened? What did you expect to happen instead?
+        Keep this brief — detailed steps go in the next field.
+      placeholder: "Example: When I open a DM thread, new messages from the other person do not appear unless I reload the page."
+    validations:
+      required: true
+
+  # ── Steps to reproduce ───────────────────────────────────────────────────────
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: >
+        Provide a numbered list of every step needed to trigger the bug.
+        The clearer this is, the faster we can fix it.
+      placeholder: |
+        1. Log in to Stoat on the web client.
+        2. Open a direct message conversation.
+        3. Ask the other person to send a message.
+        4. Observe that the message does not appear without reloading.
+    validations:
+      required: true
+
+  # ── Expected behavior ────────────────────────────────────────────────────────
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: What should have happened?
+      placeholder: "New messages should appear in real time without a page reload."
+    validations:
+      required: true
+
+  # ── Client / platform ────────────────────────────────────────────────────────
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Client / platform
+      description: Which Stoat client are you using?
+      options:
+        - Web (browser)
+        - Stoat for Desktop
+        - Android
+        - iOS
+        - Self-hosted server
+    validations:
+      required: true
+
+  # ── Client version ───────────────────────────────────────────────────────────
+  - type: input
+    id: version
+    attributes:
+      label: Client version
+      description: >
+        Find this in **Settings**. For the web client, include the build
+        number shown in the footer or About page.
+      placeholder: "e.g. Stoat for Desktop 1.3.0 or 0.2.1 (2025-10-10)"
+    validations:
+      required: true
+
+  # ── OS / browser details ─────────────────────────────────────────────────────
+  - type: input
+    id: os
+    attributes:
+      label: OS / browser details
+      description: Your operating system and, for web bugs, your browser and its version.
+      placeholder: "e.g. Windows 11, Chrome 121  or  macOS 14.3, Stoat for Desktop 1.3.0  or  Android 14"
+    validations:
+      required: true
+
+  # ── Reproducibility ──────────────────────────────────────────────────────────
+  - type: dropdown
+    id: reproducibility
+    attributes:
+      label: Reproducibility
+      description: How consistently does this bug occur?
+      options:
+        - Always
+        - Usually
+        - Rarely
+        - Only once
+        - Unknown
+    validations:
+      required: true
+
+  # ── Screenshots or video ─────────────────────────────────────────────────────
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots or video
+      description: Paste images or drag-and-drop a screen recording here. GitHub accepts common image and video formats.
+    validations:
+      required: false
+
+  # ── Additional context ───────────────────────────────────────────────────────
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: >
+        Anything else that might help: workarounds you found, links to related issues,
+        self-hosted configuration details (Redis, MongoDB, LiveKit, SMTP), network environment, etc.
+    validations:
+      required: false
+
+  # ── Closing note ─────────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        ---
+        A maintainer will review your report. Please watch for follow-up questions — issues
+        that go unanswered are harder to resolve and may be closed after 30 days of inactivity.

.github/pull_request_template.md

@@ -0,0 +1,24 @@
+<!-- Describe your changes -->
+
+Fixes # (issue)
+
+## How was this PR tested?
+
+<!-- What did you do to test your changes? -->
+
+- [ ] Test A
+- [ ] Test B
+
+## Checklist:
+
+- [ ] I have carefully read [the contributing guidelines](https://developers.stoat.chat/developing/contrib/)
+- [ ] I have performed a self-review of my own code
+- [ ] I have made corresponding changes to the documentation if applicable
+- [ ] I have no unrelated changes in the PR
+- [ ] I have confirmed that any new dependencies are strictly necessary
+- [ ] I have written tests for new code (if applicable)
+- [ ] I have followed naming conventions/patterns in the surrounding code
+
+## Please declare, if any, LLM usage involved in creating this PR
+
+...

.github/workflows/docker-cleanup.yaml

@@ -0,0 +1,46 @@
+name: Docker PR Image Cleanup
+
+on:
+  pull_request:
+    types:
+      - closed
+
+permissions:
+  contents: read
+  packages: write
+
+concurrency:
+  group: docker-cleanup-${{ github.event.pull_request.number }}
+  cancel-in-progress: false
+
+jobs:
+  cleanup:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.pull_request.head.repo.fork }}
+    strategy:
+      fail-fast: false
+      matrix:
+        package:
+          - base
+          - api
+          - events
+          - file-server
+          - proxy
+          - gifbox
+          - crond
+          - pushd
+          - voice-ingress
+    steps:
+      - env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ORG: stoatchat
+          PACKAGE: ${{ matrix.package }}
+          TAG: pr-${{ github.event.pull_request.number }}
+        run: |
+          set -euo pipefail
+          gh api --paginate \
+            "/orgs/${ORG}/packages/container/${PACKAGE}/versions" \
+            --jq ".[] | select(.metadata.container.tags | index(\"${TAG}\")) | .id" \
+          | while read -r id; do
+              gh api -X DELETE "/orgs/${ORG}/packages/container/${PACKAGE}/versions/${id}"
+            done

.github/workflows/docker.yaml

@@ -5,8 +5,6 @@ on:
     tags:
       - "*"
   pull_request:
-    paths:
-      - "Dockerfile"
   workflow_dispatch:
 
 permissions:
@@ -14,14 +12,14 @@ permissions:
   packages: write
 
 concurrency:
-  group: ${{ github.head_ref || github.ref }}
+  group: docker-test-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 jobs:
   base:
-    name: Test base image build
+    name: Test base image build (fork)
     runs-on: arc-runner-set
-    if: github.event_name == 'pull_request'
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork
     steps:
       # Configure build environment
       - name: Checkout
@@ -42,7 +40,7 @@ jobs:
 
   publish:
     runs-on: arc-runner-set
-    if: github.event_name != 'pull_request'
+    if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
     name: Publish Docker images
     steps:
       # Configure build environment
@@ -59,6 +57,15 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Determine base image tag
+        id: base
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            echo "tag=pr-${{ github.event.number }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=latest" >> "$GITHUB_OUTPUT"
+          fi
+
       # Build the image
       - name: Build base image
         uses: docker/build-push-action@v4
@@ -66,7 +73,9 @@ jobs:
           context: .
           push: true
           platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
+          tags: ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+          cache-from: type=gha,scope=buildx-base-multi-arch
+          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
 
       # stoatchat/api
       - name: Docker meta
@@ -84,7 +93,7 @@ jobs:
           file: crates/delta/Dockerfile
           tags: ${{ steps.meta-delta.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-delta.outputs.labels }}
 
       # stoatchat/events
@@ -103,7 +112,7 @@ jobs:
           file: crates/bonfire/Dockerfile
           tags: ${{ steps.meta-bonfire.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-bonfire.outputs.labels }}
 
       # stoatchat/file-server
@@ -122,7 +131,7 @@ jobs:
           file: crates/services/autumn/Dockerfile
           tags: ${{ steps.meta-autumn.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-autumn.outputs.labels }}
 
       # stoatchat/proxy
@@ -141,7 +150,7 @@ jobs:
           file: crates/services/january/Dockerfile
           tags: ${{ steps.meta-january.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-january.outputs.labels }}
 
       # stoatchat/gifbox
@@ -160,7 +169,7 @@ jobs:
           file: crates/services/gifbox/Dockerfile
           tags: ${{ steps.meta-gifbox.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-gifbox.outputs.labels }}
 
       # stoatchat/crond
@@ -179,7 +188,7 @@ jobs:
           file: crates/daemons/crond/Dockerfile
           tags: ${{ steps.meta-crond.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-crond.outputs.labels }}
 
       # stoatchat/pushd
@@ -198,7 +207,7 @@ jobs:
           file: crates/daemons/pushd/Dockerfile
           tags: ${{ steps.meta-pushd.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-pushd.outputs.labels }}
 
       # stoatchat/voice-ingress
@@ -217,5 +226,5 @@ jobs:
           file: crates/daemons/voice-ingress/Dockerfile
           tags: ${{ steps.meta-voice-ingress.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-voice-ingress.outputs.labels }}

.github/workflows/docs-test.yml

@@ -14,16 +14,10 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: pnpm/action-setup@v4
-        with:
-          package_json_file: ./docs/package.json
-      - uses: actions/setup-node@v4
-        with:
-          node-version: lts/*
-          cache: pnpm
-          cache-dependency-path: ./docs/pnpm-lock.yaml
 
-      - name: Install dependencies
-        run: pnpm install
-      - name: Test build website
-        run: pnpm run build
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+        
+      - run: mise docs:build

.github/workflows/docs.yml

@@ -16,19 +16,13 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: pnpm/action-setup@v4
-        with:
-          package_json_file: ./docs/package.json
-      - uses: actions/setup-node@v4
-        with:
-          node-version: lts/*
-          cache: pnpm
-          cache-dependency-path: ./docs/pnpm-lock.yaml
 
-      - name: Install dependencies
-        run: pnpm install
-      - name: Build website
-        run: pnpm run build
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+        
+      - run: mise docs:build
 
       - name: Upload Build Artifact
         uses: actions/upload-pages-artifact@v3

.github/workflows/git-town.yml

@@ -0,0 +1,23 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: Git Town
+
+on:
+  pull_request:
+
+jobs:
+  git-town:
+    name: Display the branch stack
+    runs-on: ubuntu-slim
+
+    if: ${{ github.event.pull_request.head.repo.full_name == github.repository && !startsWith(github.head_ref, 'release-please--') }}
+
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: stoatchat/action-git-town@4bc5c942e4603bffa0806b51d5fe5f0bc5deb0ac
+        continue-on-error: true

.github/workflows/publish-crates.yml

@@ -15,7 +15,12 @@ jobs:
         with:
           persist-credentials: false
 
-      - name: Publish crates
-        uses: katyo/publish-crates@02cc2f1ad653fb25c7d1ff9eb590a8a50d06186b # v2
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
         with:
-          registry-token: ${{ secrets.CRATES_IO_PUBLISH_TOKEN }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: mise publish --workspace

.github/workflows/release-please.yml

@@ -45,8 +45,9 @@ jobs:
         if: ${{ steps.rp.outputs.prs_created == 'true' || steps.rp.outputs.prs_updated == 'true' }}
         env:
           GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          RP_PR_OUTPUT_JSON: ${{ steps.rp.outputs.prs }}
         run: |
-          PR_NUMBER=$(echo '${{ steps.rp.outputs.prs }}' | jq -r '.[0].number')
+          PR_NUMBER=$(echo "$RP_PR_OUTPUT_JSON" | jq -r '.[0].number')
           gh pr checkout "$PR_NUMBER"
           
           cargo update -w

.github/workflows/release-webhook.yml

@@ -1,3 +1,6 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
 name: Release Webhook
 
 on:
@@ -12,8 +15,12 @@ jobs:
 
     steps:
       - name: Send release notification webhook
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name }}
+          REPOSITORY: ${{ github.repository }}
+          WEBHOOK_URL: ${{ secrets.STOAT_WEBHOOK_UPDATES_URL }}
         run: |
-          RELEASE_URL="https://github.com/${{ github.repository }}/releases/tag/${{ github.event.release.tag_name }}"
-          curl -X POST "${{ secrets.STOAT_WEBHOOK_UPDATES_URL }}" \
+          RELEASE_URL="https://github.com/${REPOSITORY}/releases/tag/${TAG_NAME}"
+          curl -X POST "$WEBHOOK_URL" \
             -H "Content-Type: application/json" \
-            -d "{\"content\": \"$RELEASE_URL\"}"
+            -d "{\"content\": \"$RELEASE_URL\"}"

.github/workflows/renovate.yml

@@ -0,0 +1,30 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: Renovate
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0/15 * * * *'
+jobs:
+  renovate:
+    runs-on: ubuntu-latest
+    steps:
+      - id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.GH_STOAT_RELEASE_APP_ID }}
+          private-key: ${{ secrets.GH_STOAT_RELEASE_APP_PRIVATE_KEY }}
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@7b8610a904d57da241e4ddba17fa62b62b15aed4 # use-mise-action-v2.0.2
+        with:
+          github_token: ${{ steps.app-token.outputs.token }}
+
+      - name: Self-hosted Renovate
+        uses: renovatebot/github-action@v46.1.14
+        with:
+          token: '${{ steps.app-token.outputs.token }}'
+        env:
+          RENOVATE_PLATFORM_COMMIT: 'enabled'
+          RENOVATE_REPOSITORIES: '${{ github.repository }}'

.github/workflows/rust.yaml

@@ -6,7 +6,7 @@ on:
   pull_request:
 
 concurrency:
-  group: ${{ github.head_ref || github.ref }}
+  group: rust-build-test-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 env:
@@ -26,43 +26,35 @@ jobs:
       #   run: |
       #     sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc
 
-      - name: Install latest stable
-        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
         with:
-          toolchain: stable
-          components: rustfmt, clippy
-      
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@a58ae9526b2c3acee9ad8e1926b950b7863305d4 # 2.65.16
-        with:
-          tool: cargo-nextest@0.9.119
+          github-token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Run cargo build
-        run: cargo build
-
-      - name: Run services in background
-        run: |
-          docker compose -f compose.yml up -d
-
-      - name: Run cargo test
+      - run: mise build
+      - run: mise docker:start
+    
+      - name: Reference Test
         env:
           TEST_DB: REFERENCE
+        continue-on-error: ${{ github.ref_name == 'main' }}
         run: |
-          cargo nextest run
+          mise test
 
-      - name: Run cargo test (with MongoDB)
+      - name: MongoDB Test
         env:
           TEST_DB: MONGODB
           MONGODB: mongodb://localhost
+        continue-on-error: ${{ github.ref_name == 'main' }}
         run: |
-          cargo nextest run
+          mise test
 
       - name: Start API in background
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
         env:
           TEST_DB: REFERENCE
         run: |
-          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
+          mise build --bin revolt-delta && (mise service:api &)
 
       - name: Wait for API to go up
         if: github.event_name != 'pull_request' && github.ref_name == 'main'

.github/workflows/validate-pr-title.yml

@@ -1,3 +1,6 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
 name: "Lint PR"
 
 on:
@@ -15,6 +18,6 @@ jobs:
     permissions:
       pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@v6
+      - uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.mise/config.toml

@@ -0,0 +1,28 @@
+[tools]
+node = "25.4.0"
+pnpm = "10.28.1"
+
+gh = "2.25.0"
+
+rust = "1.92.0"
+"cargo:cargo-nextest" = "0.9.122"
+
+"github:git-town/git-town" = "22.7.1"
+
+[settings]
+experimental = true
+idiomatic_version_file_enable_tools = ["rust"]
+
+[tasks.start]
+description = "Run all services"
+depends = ["docker:start", "build"]
+wait_for = ["docker:start", "build"]
+run = [{ task = "service:*" }]
+
+[env]
+BUILDER = "cargo"
+DOCKER_NETWORK_NAME = "stoatchat_default"
+DATABASE_PORT = "27017"
+RABBIT_PORT = "5672"
+REDIS_PORT = "6379"
+_.file = { path = ".env", tools = true }

.mise/tasks/build

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Build project"
+set -e
+
+${BUILDER} build "$@"

.mise/tasks/check

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Check project with clippy"
+set -e
+
+cargo clippy

.mise/tasks/docker/start

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+#MISE description="Start Docker containers"
+set -e
+
+docker compose up -d
+
+docker run \
+--network=${DOCKER_NETWORK_NAME} \
+--name wait \
+--rm dokku/wait  -c \
+rabbit:${RABBIT_PORT},\
+database:${DATABASE_PORT},\
+redis:${REDIS_PORT}

.mise/tasks/docker/stop

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Stop Docker containers"
+set -e
+
+docker compose down

.mise/tasks/docs/_default

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+#MISE description="Start the Stoat Developers website"
+#MISE depends=["docs:install"]
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm build

.mise/tasks/docs/build

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+#MISE description="Build the Stoat Developers website"
+#MISE depends=["docs:install"]
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm build

.mise/tasks/docs/install

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+#MISE description="Install dependencies for docs site"
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm i --frozen-lockfile

.mise/tasks/publish

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Publish project"
+set -e
+
+cargo publish "$@"

.mise/tasks/service/api

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run API server"
+set -e
+
+cargo run --bin revolt-delta

.mise/tasks/service/crond

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run cron daemon"
+set -e
+
+cargo run --bin revolt-crond

.mise/tasks/service/events

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run events server"
+set -e
+
+cargo run --bin revolt-bonfire

.mise/tasks/service/files

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run file server"
+set -e
+
+cargo run --bin revolt-autumn

.mise/tasks/service/gifbox

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run GIF proxy server"
+set -e
+
+cargo run --bin revolt-gifbox

.mise/tasks/service/proxy

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run proxy server"
+set -e
+
+cargo run --bin revolt-january

.mise/tasks/service/pushd

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run push daemon"
+set -e
+
+cargo run --bin revolt-pushd

.mise/tasks/test

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+#MISE description="Test project"
+set -e
+
+: "${TEST_DB:=REFERENCE}"
+export TEST_DB
+
+cargo nextest run

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "0.9.4"
+    ".": "0.13.7"
 }

CHANGELOG.md

@@ -1,5 +1,220 @@
 # Changelog
 
+## [0.13.7](https://github.com/stoatchat/stoatchat/compare/v0.13.6...v0.13.7) (2026-05-21)
+
+
+### Bug Fixes
+
+* sanitize emoji input to handle variation selectors ([#774](https://github.com/stoatchat/stoatchat/issues/774)) ([2d308e0](https://github.com/stoatchat/stoatchat/commit/2d308e03d58c19f27b5b4d65dc2a15ef20b56190))
+* update mention count badge for channel acks ([#769](https://github.com/stoatchat/stoatchat/issues/769)) ([0d9ae50](https://github.com/stoatchat/stoatchat/commit/0d9ae508d9d2199f0e408b8ca634d20489be6f61))
+
+## [0.13.6](https://github.com/stoatchat/stoatchat/compare/v0.13.5...v0.13.6) (2026-05-18)
+
+
+### Features
+
+* Update FCM payload for android notifications ([#766](https://github.com/stoatchat/stoatchat/issues/766)) ([acbc087](https://github.com/stoatchat/stoatchat/commit/acbc087982e9aeb05cabc5ab4c9b1291f67490ad))
+* user slowmode events ([#760](https://github.com/stoatchat/stoatchat/issues/760)) ([af0d8aa](https://github.com/stoatchat/stoatchat/commit/af0d8aad14dc68d88159d0e1c714077d362e21e4))
+
+
+### Bug Fixes
+
+* include `minio` region as tests need it ([#761](https://github.com/stoatchat/stoatchat/issues/761)) ([298742d](https://github.com/stoatchat/stoatchat/commit/298742dbad4eafae356f976c56b9db23904b0c3a))
+* set env var for publishing crates ([#768](https://github.com/stoatchat/stoatchat/issues/768)) ([018afaf](https://github.com/stoatchat/stoatchat/commit/018afaf38f6330d92dad2a68b640c0cb3f6b639a))
+* Use proper headers to determine IP when not behind cloudflare ([#764](https://github.com/stoatchat/stoatchat/issues/764)) ([494c8b7](https://github.com/stoatchat/stoatchat/commit/494c8b7cabaae2a51039a7a5b559d5e2e5279554))
+* voice ingress crashing due to new Result in AMQP::new_auto() ([#765](https://github.com/stoatchat/stoatchat/issues/765)) ([2871632](https://github.com/stoatchat/stoatchat/commit/2871632382395cb20cbe0047c542d3ac31ff3f03))
+
+
+### Miscellaneous Chores
+
+* switch to lapin ([#767](https://github.com/stoatchat/stoatchat/issues/767)) ([5b19853](https://github.com/stoatchat/stoatchat/commit/5b1985381ae829a92c80a19e91a414cd9dc4de93))
+
+## [0.13.5](https://github.com/stoatchat/stoatchat/compare/v0.13.4...v0.13.5) (2026-05-17)
+
+
+### Bug Fixes
+
+* dont panic on hash missing when deleting files ([#755](https://github.com/stoatchat/stoatchat/issues/755)) ([c902077](https://github.com/stoatchat/stoatchat/commit/c902077cf51076fee11712eb732dc8a8f786fc4b))
+
+## [0.13.4](https://github.com/stoatchat/stoatchat/compare/v0.13.3...v0.13.4) (2026-05-16)
+
+
+### Bug Fixes
+
+* add TLS feature to livekit-api crate ([#753](https://github.com/stoatchat/stoatchat/issues/753)) ([6cfee1f](https://github.com/stoatchat/stoatchat/commit/6cfee1f601c1e084df7c8f1e7a5e8a560d1dd514))
+
+## [0.13.3](https://github.com/stoatchat/stoatchat/compare/v0.13.2...v0.13.3) (2026-05-15)
+
+
+### Bug Fixes
+
+* don't automatically set up rabbitmq in delta ([#749](https://github.com/stoatchat/stoatchat/issues/749)) ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
+* don't declare queues which seem to cause the backend to crash in prod ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
+
+## [0.13.2](https://github.com/stoatchat/stoatchat/compare/v0.13.1...v0.13.2) (2026-05-11)
+
+
+### Bug Fixes
+
+* update default exchange to `revolt.default` ([#746](https://github.com/stoatchat/stoatchat/issues/746)) ([fcb8091](https://github.com/stoatchat/stoatchat/commit/fcb8091cd7a00d7f26c798daa33aae4b923b2a8b))
+
+## [0.13.1](https://github.com/stoatchat/stoatchat/compare/v0.13.0...v0.13.1) (2026-05-10)
+
+
+### Bug Fixes
+
+* amqprs startup bug ([#744](https://github.com/stoatchat/stoatchat/issues/744)) ([1100eaf](https://github.com/stoatchat/stoatchat/commit/1100eaf46f849f2509ae01ac497556ca33bde778))
+
+## [0.13.0](https://github.com/stoatchat/stoatchat/compare/v0.12.1...v0.13.0) (2026-05-08)
+
+
+### Features
+
+* add embed support for YouTube Shorts ([#734](https://github.com/stoatchat/stoatchat/issues/734)) ([d46c7f7](https://github.com/stoatchat/stoatchat/commit/d46c7f7f3c04524c0639c3e0a122626f8e0b3bf7))
+* add emoji rename endpoint ([#714](https://github.com/stoatchat/stoatchat/issues/714)) ([23ad135](https://github.com/stoatchat/stoatchat/commit/23ad1359834bb7d07a460b8678d6a6ebffc73eb0))
+* add legal links to root payload ([#733](https://github.com/stoatchat/stoatchat/issues/733)) ([21d8201](https://github.com/stoatchat/stoatchat/commit/21d82018cf84ab0fdd10613d254b9562aea8eea3))
+* add role icon support ([#724](https://github.com/stoatchat/stoatchat/issues/724)) ([841985d](https://github.com/stoatchat/stoatchat/commit/841985d3b994df1c6eefab2fc7ecbd77ab22c493))
+* Add webhook endpoints for editing and deleting messages ([#682](https://github.com/stoatchat/stoatchat/issues/682)) ([6f3441c](https://github.com/stoatchat/stoatchat/commit/6f3441cf4acac2a8e6e1bf07a279a153b80f7956))
+* automatically sanitise usernames on create/update ([#689](https://github.com/stoatchat/stoatchat/issues/689)) ([e937697](https://github.com/stoatchat/stoatchat/commit/e93769786c7669485a659ee471630740d3cea702))
+* blacklist private ip ranges and add january domain blocklist ([#731](https://github.com/stoatchat/stoatchat/issues/731)) ([6b41db9](https://github.com/stoatchat/stoatchat/commit/6b41db984bb491b2e58324309cc70d8c14e0b814))
+* Rewrite acks ([#741](https://github.com/stoatchat/stoatchat/issues/741)) ([ab5bd47](https://github.com/stoatchat/stoatchat/commit/ab5bd47a39ee889de0b5ae6e7b560620853daead))
+
+
+### Bug Fixes
+
+* add new_user_hours to configuration limits ([#729](https://github.com/stoatchat/stoatchat/issues/729)) ([279f5d5](https://github.com/stoatchat/stoatchat/commit/279f5d5fd7af2df55902c706859ec07f569cdb1e))
+* add reconnection policy to Redis subscriber to prevent ghost state ([#708](https://github.com/stoatchat/stoatchat/issues/708)) ([057f2bb](https://github.com/stoatchat/stoatchat/commit/057f2bb8b359f8b942741a30ff54eeb8fbe3e0b1))
+* docker compose file had personal url in it ([#742](https://github.com/stoatchat/stoatchat/issues/742)) ([0719985](https://github.com/stoatchat/stoatchat/commit/0719985ac5636590f91e6f9ec4b68f3eded70c13))
+* don't strip ICC from exif ([#735](https://github.com/stoatchat/stoatchat/issues/735)) ([d76a711](https://github.com/stoatchat/stoatchat/commit/d76a71141f3e508f6308ba52fa28eaeb56fb3438))
+* dont send notification in fcm ([#721](https://github.com/stoatchat/stoatchat/issues/721)) ([89171e9](https://github.com/stoatchat/stoatchat/commit/89171e9bd0f15711157e78c6eec0fe7b480de93a))
+* encode filenames in redirects ([#737](https://github.com/stoatchat/stoatchat/issues/737)) ([9fd7128](https://github.com/stoatchat/stoatchat/commit/9fd7128f800badbd184baf943d4f799e601201e4))
+* january ip redirects & domain resolver ([#738](https://github.com/stoatchat/stoatchat/issues/738)) ([356491e](https://github.com/stoatchat/stoatchat/commit/356491e934b274f9e895df883dd63ef0b3123510))
+* update message length validation to remove upper limit ([#723](https://github.com/stoatchat/stoatchat/issues/723)) ([ed4fd5e](https://github.com/stoatchat/stoatchat/commit/ed4fd5ebfe6d0ea534a0898da4afdc1f4e2cd6c5))
+* use correct response for NoEffect errors ([#732](https://github.com/stoatchat/stoatchat/issues/732)) ([5378cd2](https://github.com/stoatchat/stoatchat/commit/5378cd22b4c7d85f44c31a6af0dda00941b80d5c))
+
+## [0.12.1](https://github.com/stoatchat/stoatchat/compare/v0.12.0...v0.12.1) (2026-04-10)
+
+
+### Bug Fixes
+
+* add migration to update existing files to be animated ([#705](https://github.com/stoatchat/stoatchat/issues/705)) ([f2c056a](https://github.com/stoatchat/stoatchat/commit/f2c056a1515be493b195f3f5db5886c2ddf36700))
+* don't send self dm notifications ([#706](https://github.com/stoatchat/stoatchat/issues/706)) ([f30b729](https://github.com/stoatchat/stoatchat/commit/f30b729ca90d0be6853c57ab4935694e5e59ae56))
+* mise start + missing docker image ([#564](https://github.com/stoatchat/stoatchat/issues/564)) ([fb8fe16](https://github.com/stoatchat/stoatchat/commit/fb8fe1655776791421284a6a093e86f0320c258a))
+* test failure due to wrong assertion ([#707](https://github.com/stoatchat/stoatchat/issues/707)) ([f81e329](https://github.com/stoatchat/stoatchat/commit/f81e3291bdd57af9ceedb2987b111acc7051d69c))
+
+## [0.12.0](https://github.com/stoatchat/stoatchat/compare/v0.11.5...v0.12.0) (2026-03-28)
+
+
+### Features
+
+* add bug report template for issue tracking ([#627](https://github.com/stoatchat/stoatchat/issues/627)) ([f777e28](https://github.com/stoatchat/stoatchat/commit/f777e2863c6ca50057c8b5d0a5be14915d287724))
+* Add slowmode functionality to text channels ([#680](https://github.com/stoatchat/stoatchat/issues/680)) ([6107f24](https://github.com/stoatchat/stoatchat/commit/6107f242fd3ebaff71a15f9a16330ffbcb4f2d7b))
+* Allow restricting server creation to specific users ([#685](https://github.com/stoatchat/stoatchat/issues/685)) ([edfa97d](https://github.com/stoatchat/stoatchat/commit/edfa97db108c9c81828547f98a1db5315cb5ba4a))
+* compute thumbhash for images ([#596](https://github.com/stoatchat/stoatchat/issues/596)) ([c2d4369](https://github.com/stoatchat/stoatchat/commit/c2d4369e160f32d79bce0a0b0f14677f89de3669))
+* Detect animation in image files for fetch_preview ([#574](https://github.com/stoatchat/stoatchat/issues/574)) ([3fa0abf](https://github.com/stoatchat/stoatchat/commit/3fa0abf47f5f42ddd8ee041fe4c44fbc5ba800c1))
+* expose global and user limits in root API response ([#644](https://github.com/stoatchat/stoatchat/issues/644)) ([0b522eb](https://github.com/stoatchat/stoatchat/commit/0b522ebddc17f2e3f792ff5e2347793e9849fa23))
+* implement time based message sweep on user ban ([#670](https://github.com/stoatchat/stoatchat/issues/670)) ([98c7b1b](https://github.com/stoatchat/stoatchat/commit/98c7b1b5a5b9fdac5c0ab83be10f0e23114dbfc9))
+* load config from env vars ([#576](https://github.com/stoatchat/stoatchat/issues/576)) ([5191bd1](https://github.com/stoatchat/stoatchat/commit/5191bd16b2a905b8409838e34eb0baca96f08580))
+* parse message push notification content and replace internal formatting ([#693](https://github.com/stoatchat/stoatchat/issues/693)) ([d1e72ce](https://github.com/stoatchat/stoatchat/commit/d1e72cee42c54e16f4e49af569897528b10a28ca))
+* Transfer ownership ([#396](https://github.com/stoatchat/stoatchat/issues/396)) ([735d644](https://github.com/stoatchat/stoatchat/commit/735d644e043793cb86e74aab5b88bb4b8bc17ba2))
+* update livekit ([#698](https://github.com/stoatchat/stoatchat/issues/698)) ([f181edc](https://github.com/stoatchat/stoatchat/commit/f181edc8f2ff3ce4b6d48938dfc73931ecfa2279))
+
+
+### Bug Fixes
+
+* add flag for disabling events instead of commenting them out ([#695](https://github.com/stoatchat/stoatchat/issues/695)) ([a5cd08a](https://github.com/stoatchat/stoatchat/commit/a5cd08a655dece4269f3ac84fa2387ae356709a5))
+* add masquerade permission to default direct message settings ([#665](https://github.com/stoatchat/stoatchat/issues/665)) ([ab52569](https://github.com/stoatchat/stoatchat/commit/ab525699bd6663333f0e9fed6d2455e482e6a09f))
+* Check for appropriate permission for removing other users avatar ([#657](https://github.com/stoatchat/stoatchat/issues/657)) ([d56135e](https://github.com/stoatchat/stoatchat/commit/d56135e0cbc713884c9378832952f7ad490fa315))
+* default video resolution is a non-existent size ([#601](https://github.com/stoatchat/stoatchat/issues/601)) ([0698e11](https://github.com/stoatchat/stoatchat/commit/0698e115e8d003d615e468c4fb9654e6bbc9107f)), closes [#588](https://github.com/stoatchat/stoatchat/issues/588)
+* **docs:** Update GitHub links ([#647](https://github.com/stoatchat/stoatchat/issues/647)) ([b830631](https://github.com/stoatchat/stoatchat/commit/b830631bd25a546844b7bdd30386084bb365e4de))
+* don't use a bitop for OR ([#676](https://github.com/stoatchat/stoatchat/issues/676)) ([5701b5c](https://github.com/stoatchat/stoatchat/commit/5701b5c18c513f796af365169ceaea372a22638c))
+* Fix typo for p256dh in vapid notification flow ([#622](https://github.com/stoatchat/stoatchat/issues/622)) ([a80ad1c](https://github.com/stoatchat/stoatchat/commit/a80ad1cbe58b8af5e45751e51d94d93c1cea1c9f))
+* improve generated openapi.json ([#584](https://github.com/stoatchat/stoatchat/issues/584)) ([52ed510](https://github.com/stoatchat/stoatchat/commit/52ed5100c2446e0b261085639e123e7e124cab2c))
+* no node state set on channel creation ([#653](https://github.com/stoatchat/stoatchat/issues/653)) ([24d0d2b](https://github.com/stoatchat/stoatchat/commit/24d0d2b7266f6f8a692d0a52704acfecf517674c))
+* only show first line on commit messages ([#696](https://github.com/stoatchat/stoatchat/issues/696)) ([91783b9](https://github.com/stoatchat/stoatchat/commit/91783b906697fc85305dee683f7c15dda55f0c50))
+* pass &str to Reference ([#697](https://github.com/stoatchat/stoatchat/issues/697)) ([ccda6f5](https://github.com/stoatchat/stoatchat/commit/ccda6f5c53ee043705f7ff6b5f6c393f020781de))
+* redis_url vs redis_uri in config ([#666](https://github.com/stoatchat/stoatchat/issues/666)) ([b0b728f](https://github.com/stoatchat/stoatchat/commit/b0b728fb0dbc9ee28360301de1c3ea501bbbff1d))
+* replace some links and Revolt mentions to current Stoat ([#515](https://github.com/stoatchat/stoatchat/issues/515)) ([d629e89](https://github.com/stoatchat/stoatchat/commit/d629e89304be2f0011e189293b278f07d346aa7d))
+* send push notifications for DM and group messages ([#660](https://github.com/stoatchat/stoatchat/issues/660)) ([52c0d2f](https://github.com/stoatchat/stoatchat/commit/52c0d2f266b76d8975bba2d5e75c62bb30149c45))
+* store server id in redis and in room metadata to be able to delete voice state in all scenarios ([#656](https://github.com/stoatchat/stoatchat/issues/656)) ([49c6289](https://github.com/stoatchat/stoatchat/commit/49c628958070e4f0a5edc764d3b48158589219d9))
+* uname is missing from crond ([#675](https://github.com/stoatchat/stoatchat/issues/675)) ([dc4438b](https://github.com/stoatchat/stoatchat/commit/dc4438bc3c7b2cad8d442b3cd438afb9ed566a5e))
+
+## [0.11.5](https://github.com/stoatchat/stoatchat/compare/v0.11.4...v0.11.5) (2026-02-17)
+
+
+### Reverts
+
+* disable user update events ([#593](https://github.com/stoatchat/stoatchat/issues/593)) ([1c98ead](https://github.com/stoatchat/stoatchat/commit/1c98ead69579b4700be0b51c9020bb8402336cc6))
+
+## [0.11.4](https://github.com/stoatchat/stoatchat/compare/v0.11.3...v0.11.4) (2026-02-16)
+
+
+### Bug Fixes
+
+* add separate config option for redis events replica url ([#590](https://github.com/stoatchat/stoatchat/issues/590)) ([a75e4ea](https://github.com/stoatchat/stoatchat/commit/a75e4eabfc4b34aba7620c82ba77558a32d9e10a))
+
+## [0.11.3](https://github.com/stoatchat/stoatchat/compare/v0.11.2...v0.11.3) (2026-02-13)
+
+
+### Bug Fixes
+
+* cut presence traffic too while we engineer a new events architecture ([#561](https://github.com/stoatchat/stoatchat/issues/561)) ([1f8ea96](https://github.com/stoatchat/stoatchat/commit/1f8ea963ad742f693f405e6438f1c343c81e6579))
+
+## [0.11.2](https://github.com/stoatchat/stoatchat/compare/v0.11.1...v0.11.2) (2026-02-13)
+
+
+### Bug Fixes
+
+* cut events traffic while we engineer a new events architecture ([#559](https://github.com/stoatchat/stoatchat/issues/559)) ([a11986b](https://github.com/stoatchat/stoatchat/commit/a11986ba1ad16b672ff1080913a684567d88adbb))
+
+## [0.11.1](https://github.com/stoatchat/stoatchat/compare/v0.11.0...v0.11.1) (2026-02-13)
+
+
+### Bug Fixes
+
+* bots in multiple voice channel logic ([#544](https://github.com/stoatchat/stoatchat/issues/544)) ([94cb916](https://github.com/stoatchat/stoatchat/commit/94cb916231b9b8befb2e94065917ff40815bec52))
+
+## [0.11.0](https://github.com/stoatchat/stoatchat/compare/v0.10.3...v0.11.0) (2026-02-10)
+
+
+### Features
+
+* appeal to the almighty Spamhaus ([#524](https://github.com/stoatchat/stoatchat/issues/524)) ([5132270](https://github.com/stoatchat/stoatchat/commit/5132270f2edd6df25ce414daa42ed1b2aa6fa7a9))
+
+## [0.10.3](https://github.com/stoatchat/stoatchat/compare/v0.10.2...v0.10.3) (2026-02-07)
+
+
+### Bug Fixes
+
+* update `Revolt` -> `Stoat` in email titles/desc. ([#508](https://github.com/stoatchat/stoatchat/issues/508)) ([84483ce](https://github.com/stoatchat/stoatchat/commit/84483cee7af3e5dfa16f7fe13e334c4d9f5abd60))
+
+## [0.10.2](https://github.com/stoatchat/stoatchat/compare/v0.10.1...v0.10.2) (2026-01-25)
+
+
+### Bug Fixes
+
+* thumbnailification requires rgb8/rgba8 ([#505](https://github.com/stoatchat/stoatchat/issues/505)) ([413aa04](https://github.com/stoatchat/stoatchat/commit/413aa04dcaf8bff3935ed1e5f31432e11a03ce6f))
+
+## [0.10.1](https://github.com/stoatchat/stoatchat/compare/v0.10.0...v0.10.1) (2026-01-25)
+
+
+### Bug Fixes
+
+* use Rust 1.92.0 for Docker build ([#503](https://github.com/stoatchat/stoatchat/issues/503)) ([98da8a2](https://github.com/stoatchat/stoatchat/commit/98da8a28a0aa2fee4e8eee1d86bd7c49e3187477))
+
+## [0.10.0](https://github.com/stoatchat/stoatchat/compare/v0.9.4...v0.10.0) (2026-01-25)
+
+
+### Features
+
+* allow kicking members from voice channels ([#495](https://github.com/stoatchat/stoatchat/issues/495)) ([0dc5442](https://github.com/stoatchat/stoatchat/commit/0dc544249825a49c793309edee5ec1838458a6da))
+* repository architecture for files crate w. added tests ([#498](https://github.com/stoatchat/stoatchat/issues/498)) ([01ded20](https://github.com/stoatchat/stoatchat/commit/01ded209c62208fc906d6aab9b08c04e860e10ef))
+
+
+### Bug Fixes
+
+* expose ratelimit headers via cors ([#496](https://github.com/stoatchat/stoatchat/issues/496)) ([a1a2125](https://github.com/stoatchat/stoatchat/commit/a1a21252d0ad58937e41f16e5fb86f96bebd2a51))
+
 ## [0.9.4](https://github.com/stoatchat/stoatchat/compare/v0.9.3...v0.9.4) (2026-01-10)
 
 

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 
 members = [
     "crates/delta",
@@ -14,9 +14,192 @@ redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/rev
 #authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
 #rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
 
-# I'm 99% sure this is overloading the GitHub worker
-# hence builds have been failing since, let's just
-# disable it for now. In the future, we could use this
-# if we were rolling our own CI (that is now).
 [profile.release]
 lto = true
+
+[workspace.dependencies]
+# Async
+async-trait = "0.1.89"
+tokio = "1.49.0"
+async-channel = "2.3.1"
+futures = "0.3.32"
+async-tungstenite = "0.17.0"
+futures-locks = "0.7.1"
+async-lock = "2.8.0"
+async-recursion = "1.0.4"
+tokio-util = { version = "0.7.18" }
+
+# Error Handling
+anyhow = "1.0.100"
+thiserror = "2.0.18"
+sentry = "0.31.5"
+sentry-anyhow = "0.38.1"
+
+# Data Validation
+regex = "1.12.3"
+validator = "0.16"
+
+# Data Types
+uuid = "1.19.0"
+ulid = "1.2.1"
+nanoid = "0.4.0"
+typenum = "1.17.0"
+num_enum = "0.6.1"
+bitfield = "0.13.2"
+
+# Time
+chrono = "0.4.15"
+iso8601-timestamp = "0.2.10"
+
+# Data Collections
+lru = "0.16.3"
+indexmap = "2.13.1"
+dashmap = "5.2.0"
+moka = "0.12.8"
+lru_time_cache = "0.11.11"
+deadqueue = "0.2.4"
+
+# Web scraping
+scraper = "0.20.0"
+encoding_rs = "0.8.34"
+
+# Mail
+lettre = "0.10.0-alpha.4"
+handlebars = "4.3.0"
+
+# HTTP Requests
+reqwest = "0.13.2"
+isahc = "1.7"
+
+# Notifications
+fcm_v1 = "0.3.0"
+web-push = "0.10.0"
+revolt_a2 = "0.10"
+
+# Parsing
+logos = "0.15"
+
+# SVG rendering
+usvg = "0.44.0"
+resvg = "0.44.0"
+tiny-skia = "0.11.4"
+
+# Logging
+log = "0.4.29"
+pretty_env_logger = "0.4.0"
+
+# Redis
+redis-kiss = { version = "0.1.4", default-features = false }
+fred = "8.0.1"
+
+# Serialisation
+bincode = "1.3.3"
+serde_json = "1.0.79"
+rmp-serde = "1.0.0"
+serde = { version = "1", features = ["derive"] }
+strum_macros = "0.26.4"
+
+# MongoDB
+bson = { version = "2.1.0" }
+mongodb = { version = "3.1.0" }
+
+# S3
+aws-config = "1.5.5"
+aws-sdk-s3 = "1.46.0"
+
+# Axum (HTTP server)
+axum-macros = "0.4.1"
+axum_typed_multipart = "0.12.1"
+axum = "0.7.5"
+axum-extra = "0.9"
+tower-http = "0.5.2"
+
+# Rocket (HTTP server)
+rocket = "0.5.1"
+rocket_empty = "0.1.1"
+revolt_rocket_okapi = "0.10.0"
+rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "072d90359b23e9b291df6b672c07c93de9c46011" }
+rocket_authifier = "1.0.16"
+rocket_prometheus = "0.10.0-rc.3"
+
+# Spec Generation
+utoipa = "4.2.3"
+revolt_okapi = "0.9.1"
+schemars = "0.8.8"
+utoipa-scalar = "0.1.0"
+
+# Image Processing
+jxl-oxide = "0.12.5"
+sha2 = "0.10.8"
+kamadak-exif = "0.5.4"
+webp = "0.3.0"
+image = "0.25.2"  # avif encode requires dav1d system library: features = ["avif-native"]
+thumbhash = "0.1.0"
+lcms2 = "6.1.1" # for color profile processing
+
+# File processing
+revolt_clamav-client = "0.1.5"
+simdutf8 = "0.1.4"
+
+# Content type processing
+infer = "0.16.0"
+ffprobe = "0.4.0"
+imagesize = "0.13.0"
+
+# OpenTelemetry
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.22", features = [
+    "env-filter",
+] } # consider https://crates.io/crates/better-tracing
+opentelemetry = { version = "0.31.0", features = ["logs"] }
+opentelemetry_sdk = { version = "0.31.0", features = ["logs"] }
+opentelemetry-otlp = { version = "0.31.0", features = ["logs"] }
+opentelemetry-appender-tracing = "0.31.1"
+
+# RabbitMQ
+lapin = "4.7.1"
+
+# Voice
+livekit-api = "=0.4.23"
+livekit-protocol = "=0.7.7"
+livekit-runtime = "0.4.0"
+
+# Other Utilities
+once_cell = "1.9.0"
+config = "0.13.3"
+cached = "0.44.0"
+rand = "0.8.5"
+base64 = "0.21.3"
+decancer = "3.3.3"
+linkify = "0.8.1"
+url-escape = "0.1.1"
+revolt_optional_struct = "0.2.0"
+unicode-segmentation = "1.10.1"
+querystring = "1.1.0"
+tempfile = "3.12.0"
+aes-gcm = "0.10.3"
+auto_ops = "0.3.0"
+url = "2.2.2"
+impl_ops = "0.1.1"
+lazy_static = "1.5.0"
+mime = "0.3.17"
+totp-lite = "2.0.0"
+rust-argon2 = "1.0.0"
+base32 = "0.4.0"
+sha1 = "0.10.6"
+futures-lite = "2.6.1"
+
+# Build Dependencies
+vergen = "7.5.0"
+
+# Local packages
+revolt-coalesced = { version = "0.13.7", path = "crates/core/coalesced" }
+revolt-config = { version = "0.13.7", path = "crates/core/config" }
+revolt-database = { version = "0.13.7", path = "crates/core/database" }
+revolt-files = { version = "0.13.7", path = "crates/core/files" }
+revolt-models = { version = "0.13.7", path = "crates/core/models" }
+revolt-parser = { version = "0.13.7", path = "crates/core/parser" }
+revolt-permissions = { version = "0.13.7", path = "crates/core/permissions" }
+revolt-presence = { version = "0.13.7", path = "crates/core/presence" }
+revolt-ratelimits = { version = "0.13.7", path = "crates/core/ratelimits" }
+revolt-result = { version = "0.13.7", path = "crates/core/result" }

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.92.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 

Dockerfile.useCurrentArch

@@ -1,5 +1,5 @@
 # Build Stage
-FROM rust:1.86.0-slim-bookworm
+FROM rust:1.92.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 

README.md

@@ -1,15 +1,15 @@
 <div align="center">
 <h1>
-  Revolt Backend
+  Stoat Backend
   
-  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
-  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
-  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
-  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
-  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
+  [![Stars](https://img.shields.io/github/stars/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/stargazers)
+  [![Forks](https://img.shields.io/github/forks/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/pulls)
+  [![Issues](https://img.shields.io/github/issues/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/issues)
+  [![Contributors](https://img.shields.io/github/contributors/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/graphs/contributors)
+  [![License](https://img.shields.io/github/license/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Revolt service.<br/>
+The services and libraries that power the Stoat service.<br/>
 <br/>
 
 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -39,17 +39,17 @@ Rust 1.86.0 or higher.
 
 ## Development Guide
 
-Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).
+Before contributing, make yourself familiar with [our contribution guidelines](https://developers.stoat.chat/developing/contrib/) and the [technical documentation for this project](https://developers.stoat.chat/).
 
 Before getting started, you'll want to install:
 
-- Rust toolchain (rustup recommended)
+- mise
 - Docker
 - Git
 - mold (optional, faster compilation)
 
 > A **default.nix** is available for Nix users!
-> Just run `nix-shell` and continue.
+> Run `nix-shell` to activate mise.
 
 As a heads-up, the development environment uses the following ports:
 
@@ -70,11 +70,20 @@ As a heads-up, the development environment uses the following ports:
 Now you can clone and build the project:
 
 ```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
-cargo build
+git clone https://github.com/stoatchat/stoatchat stoat-backend
+cd stoat-backend
+mise install
+mise build
 ```
 
+> [!TIP]
+> You can override `BUILDER` in your `.env` file to run cargo with mold if you installed it:
+>
+> ```bash
+> # .env
+> BUILDER = "mold --run cargo"
+> ```
+
 A default configuration `Revolt.toml` is present in this project that is suited for development.
 
 If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
@@ -111,7 +120,7 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 >       - "14672:15672"
 > ```
 >
-> And corresponding Revolt configuration:
+> With the corresponding Revolt configuration:
 >
 > ```toml
 > #     Revolt.overrides.toml
@@ -123,53 +132,41 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > [rabbit]
 > port = 14072
 > ```
+>
+> And mise configuration
+>
+> ```bash
+> #.env
+> DATABASE_PORT = "14017"
+> RABBIT_PORT = "14072"
+> REDIS_PORT = "14079"
+> ```
 
 Then continue:
 
 ```bash
-# start other necessary services
-docker compose up -d
+cp livekit.example.yml livekit.yml
 
-# run everything together
-./scripts/start.sh
-# .. or individually
-# run the API server
-cargo run --bin revolt-delta
-# run the events server
-cargo run --bin revolt-bonfire
-# run the file server
-cargo run --bin revolt-autumn
-# run the proxy server
-cargo run --bin revolt-january
-# run the tenor proxy
-cargo run --bin revolt-gifbox
-# run the push daemon (not usually needed in regular development)
-cargo run --bin revolt-pushd
-
-# hint:
-# mold -run <cargo build, cargo run, etc...>
-# mold -run ./scripts/start.sh
+mise start
 ```
 
-You can start a web client by doing the following:
+You can start a web client by doing the following in another terminal:
 
 ```bash
 # if you do not have yarn yet and have a modern Node.js:
 corepack enable
 
 # clone the web client and run it:
-git clone --recursive https://github.com/revoltchat/revite
-cd revite
-yarn
-yarn build:deps
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
+git clone --recursive https://github.com/stoatchat/for-web stoat-web
+cd stoat-web
+# refer to stoat-web/README.md for startup, creating an account and loging in
 ```
 
-Then go to http://local.revolt.chat:14701 to create an account/login.
-
 When signing up, go to http://localhost:14080 to find confirmation/password reset emails.
 
+To stop all services, hit (CTRL + c) in the terminal you ran `mise start` and run `mise docker:stop`
+
+
 ## Deployment Guide
 
 ### Cutting new crate releases
@@ -198,14 +195,14 @@ Tag and push a new release by running:
 just release
 ```
 
-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
 
 ## Testing
 
 First, start the required services:
 
 ```sh
-docker compose -f docker-compose.db.yml up -d
+docker compose up -d
 ```
 
 Now run tests for whichever database:
@@ -217,6 +214,6 @@ TEST_DB=MONGODB cargo nextest run
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
+The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
 
 **Individual crates may supply their own licenses!**

Revolt.toml

@@ -15,7 +15,7 @@ host = "127.0.0.1"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"

compose.yml

@@ -8,18 +8,33 @@ services:
   # MongoDB
   database:
     image: mongo
+    command: mongod --replSet rs0
     ports:
       - "27017:27017"
     volumes:
       - ./.data/db:/data/db
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    healthcheck:
+      test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'127.0.0.1:27017'}]}) }" | mongosh --port 27017 --quiet
+      interval: 5s
+      timeout: 30s
+      start_period: 0s
+      start_interval: 1s
+      retries: 30
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
 
   # MinIO
   minio:
-    image: minio/minio
-    command: server /data
+    image: firstfinger/minio:latest
+    #command: server /data
     environment:
       MINIO_ROOT_USER: minioautumn
       MINIO_ROOT_PASSWORD: minioautumn
+      MINIO_REGION: minio
     volumes:
       - ./.data/minio:/data
     ports:
@@ -66,8 +81,8 @@ services:
       MAILDEV_INCOMING_PASS: smtp
 
   livekit:
-    image: ghcr.io/stoatchat/livekit-server:v1.9.9
+    image: ghcr.io/stoatchat/livekit-server:v1.9.13
     command: --config /etc/livekit.yml
     network_mode: "host"
     volumes:
-      - ./livekit.yml:/etc/livekit.yml
+      - ./livekit.yml:/etc/livekit.yml

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.9.4"
+version = "0.13.7"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 publish = false
@@ -9,42 +9,38 @@ publish = false
 
 [dependencies]
 # util
-log = "*"
-sentry = "0.31.5"
-lru = "0.7.6"
-ulid = "0.5.0"
-once_cell = "1.9.0"
-redis-kiss = "0.1.4"
-lru_time_cache = "0.11.11"
-async-channel = "2.3.1"
+log = { workspace = true }
+sentry = { workspace = true }
+lru = { workspace = true }
+ulid = { workspace = true }
+once_cell = { workspace = true }
+redis-kiss = { workspace = true, default-features = false, features = ["tokio-runtime"] }
+lru_time_cache = { workspace = true }
+async-channel = { workspace = true }
 
 # parsing
-querystring = "1.1.0"
-regex = "1.11.1"
+querystring = { workspace = true }
+regex = { workspace = true }
 
 # serde
-bincode = "1.3.3"
-serde_json = "1.0.79"
-rmp-serde = "1.0.0"
-serde = "1.0.136"
+bincode = { workspace = true }
+serde_json = { workspace = true }
+rmp-serde = { workspace = true }
+serde = { workspace = true }
 
 # async
-futures = "0.3.21"
-async-tungstenite = { version = "0.17.0", features = ["async-std-runtime"] }
-async-std = { version = "1.8.0", features = [
-    "tokio1",
-    "tokio02",
-    "attributes",
-] }
+futures = { workspace = true }
+async-tungstenite = { workspace = true, features = ["tokio-runtime"] }
+tokio = { workspace = true }
+tokio-util = { workspace = true, features = ["compat"] }
 
 # core
-authifier = { version = "1.0.15" }
-revolt-result = { path = "../core/result" }
-revolt-models = { path = "../core/models" }
-revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database", features = ["voice"] }
-revolt-permissions = { path = "../core/permissions" }
-revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
+revolt-result = { workspace = true }
+revolt-models = { workspace = true }
+revolt-config = { workspace = true }
+revolt-database = { workspace = true, features = ["voice"] }
+revolt-permissions = { workspace = true }
+revolt-presence = { workspace = true, features = ["redis-is-patched"] }
 
 # redis
-fred = { version = "8.0.1", features = ["subscriber-client"] }
+fred = { workspace = true, features = ["subscriber-client"] }

crates/bonfire/src/events/impl.rs

@@ -1,10 +1,11 @@
 use std::collections::{HashMap, HashSet};
 
 use futures::future::join_all;
+use redis_kiss::AsyncCommands;
 use revolt_database::{
     events::client::{EventV1, ReadyPayloadFields},
     util::permissions::DatabasePermissionQuery,
-    voice::get_channel_voice_state,
+    voice::{get_channel_voice_state, UserVoiceChannel},
     Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
@@ -167,9 +168,13 @@ impl State {
                         | Channel::TextChannel { voice: Some(_), .. }
                 )
             }) {
-                if let Ok(Some(voice_state)) = get_channel_voice_state(channel).await {
+                if let Ok(Some(voice_state)) =
+                    get_channel_voice_state(&UserVoiceChannel::from_channel(channel)).await
+                {
                     if let Some(server) = channel.server() {
-                        let set = voice_state_server_members.entry(server.to_string()).or_default();
+                        let set = voice_state_server_members
+                            .entry(server.to_string())
+                            .or_default();
 
                         for participant in &voice_state.participants {
                             user_ids.insert(participant.id.clone());
@@ -397,6 +402,11 @@ impl State {
 
     /// Push presence change to the user and all associated server topics
     pub async fn broadcast_presence_change(&self, target: bool) {
+        let config = revolt_config::config().await;
+        if config.disable_events_dont_use {
+            return;
+        }
+
         if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
             status.presence != Some(Presence::Invisible)
         } else {

crates/bonfire/src/events/state.rs

@@ -1,10 +1,8 @@
 use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-    time::Duration,
+    collections::{HashMap, HashSet}, num::NonZeroUsize, sync::Arc, time::Duration
 };
 
-use async_std::sync::{Mutex, RwLock};
+use tokio::sync::{Mutex, RwLock};
 use lru::LruCache;
 use lru_time_cache::{LruCache as LruTimeCache, TimedEntry};
 use revolt_database::{Channel, Member, Server, User};
@@ -57,7 +55,7 @@ impl Default for Cache {
             members: Default::default(),
             servers: Default::default(),
 
-            seen_events: LruCache::new(20),
+            seen_events: LruCache::new(NonZeroUsize::new(20).unwrap()),
         }
     }
 }

crates/bonfire/src/main.rs

@@ -1,6 +1,6 @@
 use std::env;
 
-use async_std::net::TcpListener;
+use tokio::net::TcpListener;
 use revolt_presence::clear_region;
 
 #[macro_use]
@@ -12,7 +12,7 @@ pub mod events;
 mod database;
 mod websocket;
 
-#[async_std::main]
+#[tokio::main]
 async fn main() {
     // Configure requirements for Bonfire.
     revolt_config::configure!(events);
@@ -33,7 +33,7 @@ async fn main() {
 
     // Start accepting new connections and spawn a client for each connection.
     while let Ok((stream, addr)) = listener.accept().await {
-        async_std::task::spawn(async move {
+        tokio::task::spawn(async move {
             info!("User connected from {addr:?}");
             websocket::client(database::get_db(), stream, addr).await;
             info!("User disconnected from {addr:?}");

crates/bonfire/src/websocket.rs

@@ -1,11 +1,10 @@
 use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 
 use async_tungstenite::WebSocketStream;
-use authifier::AuthifierEvent;
 use fred::{
     error::RedisErrorKind,
     interfaces::{ClientLike, EventInterface, PubsubInterface},
-    types::RedisConfig,
+    types::{ReconnectPolicy, RedisConfig},
 };
 use futures::{
     channel::oneshot,
@@ -13,7 +12,7 @@ use futures::{
     stream::{SplitSink, SplitStream},
     FutureExt, SinkExt, StreamExt, TryStreamExt,
 };
-use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
+use redis_kiss::{get_connection, AsyncCommands, PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
     events::{client::EventV1, server::ClientMessage},
@@ -22,19 +21,21 @@ use revolt_database::{
 };
 use revolt_presence::{create_session, delete_session};
 
-use async_std::{
+use tokio::{
     net::TcpStream,
     sync::{Mutex, RwLock},
     task::spawn,
 };
+use tokio_util::compat::{TokioAsyncReadCompatExt, Compat};
 use revolt_result::create_error;
 use sentry::Level;
 
 use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
 use crate::events::state::{State, SubscriptionStateChange};
+use revolt_models::v0;
 
-type WsReader = SplitStream<WebSocketStream<TcpStream>>;
-type WsWriter = SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>;
+type WsReader = SplitStream<WebSocketStream<Compat<TcpStream>>>;
+type WsWriter = SplitSink<WebSocketStream<Compat<TcpStream>>, async_tungstenite::tungstenite::Message>;
 
 /// Start a new WebSocket client worker given access to the database,
 /// the relevant TCP stream and the remote address of the client.
@@ -44,7 +45,7 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     // e.g. wss://example.com?format=json&version=1
     let (sender, receiver) = oneshot::channel();
     let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
-        stream,
+        stream.compat(),
         WebsocketHandshakeCallback::from(sender),
         None,
     )
@@ -128,6 +129,14 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
         return;
     }
 
+    let slowmodes = fetch_user_slowmodes(&user_id).await.unwrap_or_default();
+    if !slowmodes.is_empty() {
+        let event = EventV1::UserSlowmodes { slowmodes };
+        if report_internal_error!(write.send(config.encode(&event)).await).is_err() {
+            return;
+        }
+    }
+
     // Create presence session.
     let (first_session, session_id) = create_session(&user_id, 0).await;
 
@@ -218,10 +227,16 @@ async fn listener(
     kill_signal_r: async_channel::Receiver<()>,
     write: &Mutex<WsWriter>,
 ) {
-    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let subscriber = match report_internal_error!(
-        fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    ) {
+    let stoat_config = revolt_config::config().await;
+    let url = stoat_config
+        .database
+        .redis_pubsub
+        .unwrap_or(REDIS_URI.to_string());
+
+    let redis_config = RedisConfig::from_url(&url).unwrap();
+    let mut builder = fred::types::Builder::from_config(redis_config);
+    builder.set_policy(ReconnectPolicy::new_exponential(8, 100, 30_000, 2));
+    let subscriber = match report_internal_error!(builder.build_subscriber_client()) {
         Ok(subscriber) => subscriber,
         Err(_) => return,
     };
@@ -230,16 +245,21 @@ async fn listener(
         return;
     }
 
+    // Let Fred automatically re-subscribe to tracked channels on reconnect.
+    subscriber.manage_subscriptions();
+
     // Handle Redis connection dropping
     let (clean_up_s, clean_up_r) = async_channel::bounded(1);
     let clean_up_s = Arc::new(Mutex::new(clean_up_s));
     subscriber.on_error(move |err| {
+        warn!("Redis subscriber error: {:?}", err);
         if let RedisErrorKind::Canceled = err.kind() {
             let clean_up_s = clean_up_s.clone();
             spawn(async move {
                 clean_up_s.lock().await.send(()).await.ok();
             });
         }
+        // Transient errors (IO, timeout) are handled by the reconnect policy.
 
         Ok(())
     });
@@ -335,22 +355,20 @@ async fn listener(
                     break 'out;
                 };
 
-                if let EventV1::Auth(auth) = &event {
-                    if let AuthifierEvent::DeleteSession { session_id, .. } = auth {
-                        if &state.session_id == session_id {
-                            event = EventV1::Logout;
-                        }
-                    } else if let AuthifierEvent::DeleteAllSessions {
-                        exclude_session_id, ..
-                    } = auth
-                    {
-                        if let Some(excluded) = exclude_session_id {
-                            if &state.session_id != excluded {
-                                event = EventV1::Logout;
-                            }
-                        } else {
+                if let EventV1::DeleteSession { session_id, .. } = &event {
+                    if &state.session_id == session_id {
+                        event = EventV1::Logout;
+                    }
+                } else if let EventV1::DeleteAllSessions {
+                    exclude_session_id, ..
+                } = &event
+                {
+                    if let Some(excluded) = exclude_session_id {
+                        if &state.session_id != excluded {
                             event = EventV1::Logout;
                         }
+                    } else {
+                        event = EventV1::Logout;
                     }
                 } else {
                     let should_send = state.handle_incoming_event_v1(db, &mut event).await;
@@ -422,6 +440,8 @@ async fn worker(
     mut read: WsReader,
     write: &Mutex<WsWriter>,
 ) {
+    let revolt_config = revolt_config::config().await;
+
     loop {
         let t1 = read.try_next().fuse();
         let t2 = kill_signal_r.recv().fuse();
@@ -458,6 +478,10 @@ async fn worker(
 
                 match payload {
                     ClientMessage::BeginTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }
@@ -470,6 +494,10 @@ async fn worker(
                         .await;
                     }
                     ClientMessage::EndTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }
@@ -507,3 +535,42 @@ async fn worker(
         }
     }
 }
+
+async fn fetch_user_slowmodes(user_id: &str) -> Option<Vec<v0::ChannelSlowmode>> {
+    let mut conn = get_connection().await.ok()?.into_inner();
+    let idx_key = format!("slowmode_idx:{}", user_id);
+
+    let channel_ids: Vec<String> = conn.smembers(&idx_key).await.unwrap_or_default();
+    if channel_ids.is_empty() {
+        return Some(vec![]);
+    }
+
+    // Bulk fetch all TTLs in one round trip
+    let mut pipe = redis_kiss::redis::pipe();
+    for channel_id in &channel_ids {
+        pipe.ttl(format!("slowmode:{}:{}", user_id, channel_id));
+    }
+    let ttls: Vec<i64> = pipe.query_async(&mut conn).await.unwrap_or_default();
+
+    // Partition into alive/expired in one pass
+    let mut slowmodes = vec![];
+    let mut expired = vec![];
+    for (channel_id, ttl) in channel_ids.iter().zip(ttls.iter()) {
+        if *ttl > 0 {
+            slowmodes.push(v0::ChannelSlowmode {
+                channel_id: channel_id.clone(),
+                duration: *ttl as u64,
+                retry_after: *ttl as u64,
+            });
+        } else {
+            expired.push(channel_id.as_str());
+        }
+    }
+
+    // Bulk remove all expired members in one SREM call
+    if !expired.is_empty() {
+        conn.srem::<_, _, ()>(&idx_key, expired).await.ok();
+    }
+
+    Some(slowmodes)
+}

crates/core/coalesced/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revolt-coalesced"
-version = "0.9.4"
+version = "0.13.7"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>", "Zomatree <me@zomatree.live>"]
 description = "Revolt Backend: Coalescion service"
+repository = "https://github.com/stoatchat/stoatchat"
 
 [features]
 tokio = ["dep:tokio"]
@@ -14,9 +15,14 @@ cache = ["dep:lru"]
 default = ["tokio"]
 
 [dependencies]
-tokio = { version = "1.47.0", features = ["sync"], optional = true }
-indexmap = { version = "2.13.0", optional = true }
-lru = { version = "0.16.3", optional = true }
+tokio = { workspace = true, features = ["sync"], optional = true }
+indexmap = { workspace = true, optional = true }
+lru = { workspace = true, optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.47.0", features = ["rt", "rt-multi-thread", "macros", "time"] }
+tokio = { workspace = true, features = [
+    "rt",
+    "rt-multi-thread",
+    "macros",
+    "time",
+] }

crates/core/config/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revolt-config"
-version = "0.9.4"
+version = "0.13.7"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Configuration"
+repository = "https://github.com/stoatchat/stoatchat"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -12,29 +13,28 @@ description = "Revolt Backend: Configuration"
 anyhow = ["dep:sentry-anyhow"]
 report-macros = ["revolt-result"]
 sentry = ["dep:sentry"]
-test = ["async-std"]
-default = ["test", "sentry"]
+test = ["tokio"]
+default = ["sentry"]
 
 [dependencies]
 # Utility
-config = "0.13.3"
-cached = "0.44.0"
-once_cell = "1.18.0"
+config = { workspace = true }
+cached = { workspace = true }
 
 # Serde
-serde = { version = "1", features = ["derive"] }
+serde = { workspace = true }
 
 # Async
-futures-locks = "0.7.1"
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
+futures-locks = { workspace = true }
+tokio = { workspace = true, optional = true }
 
 # Logging
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
+log = { workspace = true }
+pretty_env_logger = { workspace = true }
 
 # Sentry
-sentry = { version = "0.31.5", optional = true }
-sentry-anyhow = { version = "0.38.1", optional = true }
+sentry = { workspace = true, optional = true }
+sentry-anyhow = { workspace = true, optional = true }
 
 # Core
-revolt-result = { version = "0.9.4", path = "../result", optional = true }
+revolt-result = { workspace = true, optional = true }

crates/core/config/Revolt.test.toml

@@ -1,3 +1,5 @@
+environment = "test"
+
 [database]
 mongodb = "mongodb://localhost"
 redis = "redis://localhost/"
@@ -10,3 +12,12 @@ password = "rabbitpass"
 
 [features]
 webhooks_enabled = true
+
+[api.smtp]
+host = "localhost"
+username = "smtp"
+password = "smtp"
+from_address = "development@stoat.chat"
+reply_to = "support@stoat.chat"
+port = 14025
+use_tls = false

crates/core/config/Revolt.toml

@@ -1,4 +1,6 @@
 production = false
+disable_events_dont_use = false
+environment = "dev"
 
 [database]
 # MongoDB connection URL
@@ -11,7 +13,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -29,12 +31,16 @@ host = "rabbit"
 port = 5672
 username = "rabbituser"
 password = "rabbitpass"
+default_exchange = "revolt.default"
+
+[rabbit.queues]
+acks = "internal.ack"
 
 [api]
 
 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
 invite_only = false
 
 [api.smtp]
@@ -48,6 +54,10 @@ from_address = "noreply@example.com"
 # port = 587
 # use_tls = true
 
+[api.smtp.expiry]
+expire_verification = 604800  # 3600 * 24 * 7
+expire_password_reset = 86400  # 3600 * 24
+expire_account_deletion = 86400  # 3600 * 24
 
 [api.security]
 # Authifier Shield API key
@@ -66,6 +76,10 @@ tenor_key = ""
 hcaptcha_key = ""
 hcaptcha_sitekey = ""
 
+[api.security.shield]
+host = ""
+key = ""
+
 [api.workers]
 # Maximum concurrent connections (to proxy server)
 max_concurrent_connections = 50
@@ -77,6 +91,8 @@ call_ring_duration = 30
 [api.livekit.nodes]
 
 [api.users]
+# Minimum allowed length of usernames
+min_username_length = 2
 
 [pushd]
 # this changes the names of the queues to not overlap 
@@ -88,6 +104,11 @@ production = true
 # Increasing this will resolve mentions faster, but will consume more memory while resolving.
 mass_mention_chunk_size = 200
 
+# How long pushd will cache resolved names for rendered message notifications.
+# Increasing this will result in lower database usage, but may result in a situation where a user/channel/role name changes 
+# and the notifications still resolve to the old name.
+render_cache_time = 60
+
 # none of these should need changing
 exchange = "revolt.notifications"
 message_queue = "notifications.origin.message"
@@ -124,6 +145,8 @@ pkcs8 = ""
 key_id = ""
 team_id = ""
 
+[january]
+blocked_domains = []
 
 [files]
 # Encryption key for stored files
@@ -220,6 +243,10 @@ new_user_hours = 72
 # (should be greater than any one file upload limit)
 body_limit_size = 20_000_000
 
+# If any userids are entered here, only those users will be able to create servers.
+# Leave empty to allow all users to create servers
+restrict_server_creation = []
+
 [features.limits.new_user]
 # Limits imposed on new users
 
@@ -244,7 +271,7 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true
 
-# Mamimum resolution (width, height) of video streams in voice calls
+# Maximum resolution (width, height) of video streams in voice calls
 video_resolution = [1080, 720]
 
 # Minimum and maximum aspect ratio of video streams in voice calls
@@ -283,8 +310,8 @@ voice_quality = 16000
 # Whether the user can use video streams in voice calls
 video = true
 
-# Mamimum resolution (width, height) of video streams in voice calls
-video_resolution = [1080, 720]
+# Maximum resolution (width, height) of video streams in voice calls
+video_resolution = [1280, 720]
 
 # Minimum and maximum aspect ratio of video streams in voice calls
 video_aspect_ratio = [0.3, 2.5]
@@ -303,6 +330,12 @@ emojis = 500_000
 # default: 5
 process_message_delay_limit = 5
 
+[features.legal_links]
+# URLs for legal documents
+terms_of_service = ""
+privacy_policy = ""
+guidelines = ""
+
 [sentry]
 # Configuration for Sentry error reporting
 api = ""
@@ -312,4 +345,4 @@ files = ""
 proxy = ""
 pushd = ""
 crond = ""
-gifbox = ""
+gifbox = ""

crates/core/config/src/lib.rs

@@ -1,9 +1,10 @@
-use std::collections::HashMap;
+#[cfg(feature = "test")]
+use std::sync::OnceLock;
+use std::{collections::HashMap, path::Path, sync::LazyLock};
 
 use cached::proc_macro::cached;
-use config::{Config, File, FileFormat};
+use config::{Config, Environment, File, FileFormat};
 use futures_locks::RwLock;
-use once_cell::sync::Lazy;
 use serde::Deserialize;
 
 #[cfg(feature = "sentry")]
@@ -66,13 +67,28 @@ static CONFIG_SEARCH_PATHS: [&str; 3] = [
 static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.toml";
 
 /// Configuration builder
-static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
+static CONFIG_BUILDER: LazyLock<RwLock<Config>> = LazyLock::new(|| {
     RwLock::new({
         let mut builder = Config::builder().add_source(File::from_str(
             include_str!("../Revolt.toml"),
             FileFormat::Toml,
         ));
 
+        let cwd = std::env::current_dir().unwrap();
+        let mut cwd: Option<&Path> = Some(&cwd);
+
+        while let Some(path) = cwd {
+            for config_path in CONFIG_SEARCH_PATHS {
+                let config_path = path.join(config_path);
+                if config_path.exists() {
+                    builder = builder
+                        .add_source(File::new(config_path.to_str().unwrap(), FileFormat::Toml));
+                }
+            }
+
+            cwd = path.parent();
+        }
+
         if std::env::var("TEST_DB").is_ok() {
             builder = builder.add_source(File::from_str(
                 include_str!("../Revolt.test.toml"),
@@ -94,11 +110,7 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
             }
         }
 
-        for path in CONFIG_SEARCH_PATHS {
-            if std::path::Path::new(path).exists() {
-                builder = builder.add_source(File::new(path, FileFormat::Toml));
-            }
-        }
+        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
 
         builder.build().unwrap()
     })
@@ -108,6 +120,12 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
 pub struct Database {
     pub mongodb: String,
     pub redis: String,
+    pub redis_pubsub: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct RabbitQueues {
+    pub acks: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -116,6 +134,8 @@ pub struct Rabbit {
     pub port: u16,
     pub username: String,
     pub password: String,
+    pub default_exchange: String,
+    pub queues: RabbitQueues,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -143,6 +163,18 @@ pub struct ApiSmtp {
     pub port: Option<i32>,
     pub use_tls: Option<bool>,
     pub use_starttls: Option<bool>,
+    pub expiry: EmailExpiry,
+}
+
+/// Email expiration config
+#[derive(Deserialize, Debug, Clone)]
+pub struct EmailExpiry {
+    /// How long email verification codes should last for (in seconds)
+    pub expire_verification: i64,
+    /// How long password reset codes should last for (in seconds)
+    pub expire_password_reset: i64,
+    /// How long account deletion codes should last for (in seconds)
+    pub expire_account_deletion: i64,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -182,9 +214,15 @@ pub struct ApiSecurityCaptcha {
     pub hcaptcha_sitekey: String,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiSecurityShield {
+    pub host: String,
+    pub key: String,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct ApiSecurity {
-    pub authifier_shield_key: String,
+    pub shield: ApiSecurityShield,
     pub voso_legacy_token: String,
     pub captcha: ApiSecurityCaptcha,
     pub trust_cloudflare: bool,
@@ -219,6 +257,7 @@ pub struct LiveKitNode {
 #[derive(Deserialize, Debug, Clone)]
 pub struct ApiUsers {
     pub early_adopter_cutoff: Option<u64>,
+    pub min_username_length: usize,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -236,6 +275,7 @@ pub struct Pushd {
     pub production: bool,
     pub exchange: String,
     pub mass_mention_chunk_size: usize,
+    pub render_cache_time: usize,
 
     // Queues
     pub message_queue: String,
@@ -288,6 +328,11 @@ impl Pushd {
     }
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct January {
+    pub blocked_domains: Vec<String>,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct FilesLimit {
     pub min_file_size: usize,
@@ -332,6 +377,8 @@ pub struct GlobalLimits {
     pub new_user_hours: usize,
 
     pub body_limit_size: usize,
+
+    pub restrict_server_creation: Vec<String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -361,6 +408,16 @@ pub struct FeaturesLimitsCollection {
     pub roles: HashMap<String, FeaturesLimits>,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct LegalLinks {
+    /// Terms of Service URL
+    pub terms_of_service: String,
+    /// Privacy Policy URL
+    pub privacy_policy: String,
+    /// Guidelines URL
+    pub guidelines: String,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct FeaturesAdvanced {
     #[serde(default)]
@@ -378,6 +435,7 @@ impl Default for FeaturesAdvanced {
 #[derive(Deserialize, Debug, Clone)]
 pub struct Features {
     pub limits: FeaturesLimitsCollection,
+    pub legal_links: LegalLinks,
     pub webhooks_enabled: bool,
     pub mass_mentions_send_notifications: bool,
     pub mass_mentions_enabled: bool,
@@ -405,10 +463,13 @@ pub struct Settings {
     pub hosts: Hosts,
     pub api: Api,
     pub pushd: Pushd,
+    pub january: January,
     pub files: Files,
     pub features: Features,
     pub sentry: Sentry,
     pub production: bool,
+    pub environment: String,
+    pub disable_events_dont_use: bool,
 }
 
 impl Settings {
@@ -434,23 +495,52 @@ pub async fn read() -> Config {
     CONFIG_BUILDER.read().await.clone()
 }
 
-#[cached(time = 30)]
-pub async fn config() -> Settings {
+pub async fn config_no_cache() -> Settings {
     let mut config = read().await.try_deserialize::<Settings>().unwrap();
 
     // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URL").is_err() {
+    if std::env::var("REDIS_URI").is_err() {
         std::env::set_var("REDIS_URI", config.database.redis.clone());
     }
 
     // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
+    if config.hosts.api.contains("https")
+        && (config.hosts.api.contains("revolt.chat") || config.hosts.api.contains("stoat.chat"))
+    {
         config.production = true;
     }
 
     config
 }
 
+#[cached(time = 30)]
+pub async fn config() -> Settings {
+    #[cfg(feature = "test")]
+    if let Some(overwrites) = CONFIG_OVERWRITES.get() {
+        return overwrites.clone();
+    }
+
+    config_no_cache().await
+}
+
+#[cfg(feature = "test")]
+static CONFIG_OVERWRITES: OnceLock<Settings> = OnceLock::new();
+
+/// Modify the config values for a test, this can only be called once
+///
+/// This will also fail if two or more tests are running in the same process and both try to modify the config,
+/// This could happen if tests where run under `cargo test` instead of `nextest`.
+#[cfg(feature = "test")]
+pub async fn overwrite_config(f: impl FnOnce(&mut Settings)) {
+    let mut config = config_no_cache().await;
+
+    f(&mut config);
+
+    CONFIG_OVERWRITES.set(config).expect(
+        "Cannot overwrite config multiple times, make sure you are running tests through nextest.",
+    );
+}
+
 /// Configure logging and common Rust variables
 #[cfg(feature = "sentry")]
 pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
@@ -496,7 +586,7 @@ macro_rules! configure {
 mod tests {
     use crate::init;
 
-    #[async_std::test]
+    #[tokio::test]
     async fn it_works() {
         init().await;
     }

crates/core/database/Cargo.toml

@@ -1,104 +1,113 @@
 [package]
 name = "revolt-database"
-version = "0.9.4"
+version = "0.13.7"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Database Implementation"
+repository = "https://github.com/stoatchat/stoatchat"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
 # Databases
-mongodb = ["dep:mongodb", "bson", "authifier/database-mongodb"]
+mongodb = ["dep:mongodb", "bson"]
 
 # ... Other
 tasks = ["isahc", "linkify", "url-escape"]
-async-std-runtime = ["async-std", "authifier/async-std-runtime"]
-rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi", "authifier/rocket_impl"]
-axum-impl = ["axum"]
+tokio-runtime = ["tokio"]
+rocket-impl = [
+    "rocket",
+    "schemars",
+    "revolt_okapi",
+    "revolt_rocket_okapi",
+]
+axum-impl = ["axum", "revolt-result/axum", "utoipa"]
 redis-is-patched = ["revolt-presence/redis-is-patched"]
 voice = ["livekit-api", "livekit-protocol", "livekit-runtime"]
 
 # Default Features
-default = ["mongodb", "async-std-runtime", "tasks"]
+default = ["mongodb", "tokio-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.9.4", path = "../config", features = [
-    "report-macros",
-] }
-revolt-result = { version = "0.9.4", path = "../result" }
-revolt-models = { version = "0.9.4", path = "../models", features = [
-    "validator",
-] }
-revolt-presence = { version = "0.9.4", path = "../presence" }
-revolt-permissions = { version = "0.9.4", path = "../permissions", features = [
-    "serde",
-    "bson",
-] }
-revolt-parser = { version = "0.9.4", path = "../parser" }
+revolt-config = { workspace = true, features = ["report-macros"] }
+revolt-result = { workspace = true }
+revolt-models = { workspace = true, features = ["validator"] }
+revolt-presence = { workspace = true }
+revolt-permissions = { workspace = true, features = ["serde", "bson"] }
+revolt-parser = { workspace = true }
+revolt-coalesced = { workspace = true }
 
 # Utility
-log = "0.4"
-lru = "0.11.0"
-rand = "0.8.5"
-ulid = "1.0.0"
-nanoid = "0.4.0"
-base64 = "0.21.3"
-once_cell = "1.17"
-indexmap = "1.9.1"
-decancer = "1.6.2"
-deadqueue = "0.2.4"
-linkify = { optional = true, version = "0.8.1" }
-url-escape = { optional = true, version = "0.1.1" }
-validator = { version = "0.16", features = ["derive"] }
-isahc = { optional = true, version = "1.7", features = ["json"] }
+log = { workspace = true }
+lru = { workspace = true }
+rand = { workspace = true }
+ulid = { workspace = true }
+nanoid = { workspace = true }
+base64 = { workspace = true }
+once_cell = { workspace = true }
+indexmap = { workspace = true }
+decancer = { workspace = true }
+deadqueue = { workspace = true }
+linkify = { workspace = true, optional = true }
+url-escape = { workspace = true, optional = true }
+validator = { workspace = true, features = ["derive"] }
+isahc = { workspace = true, features = ["json"], optional = true }
+base32 = { workspace = true }
+sha1 = { workspace = true }
 
 # Serialisation
-serde_json = "1"
-revolt_optional_struct = "0.2.0"
-serde = { version = "1", features = ["derive"] }
-iso8601-timestamp = { version = "0.2.10", features = ["serde", "bson"] }
+serde_json = { workspace = true }
+revolt_optional_struct = { workspace = true }
+serde = { workspace = true }
+iso8601-timestamp = { workspace = true, features = ["serde", "bson"] }
 
 # Events
-redis-kiss = { version = "0.1.4" }
+redis-kiss = { workspace = true, default-features = false, features = ["tokio-runtime"] }
 
 # Database
-bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "3.1.0" }
+bson = { workspace = true, optional = true }
+mongodb = { workspace = true, optional = true }
 
 # Database Migration
-unicode-segmentation = "1.10.1"
-regex = "1"
+unicode-segmentation = { workspace = true }
+regex = { workspace = true }
 
 # Async Language Features
-futures = "0.3.19"
-async-lock = "2.8.0"
-async-trait = "0.1.51"
-async-recursion = "1.0.4"
+futures = { workspace = true }
+async-lock = { workspace = true }
+async-trait = { workspace = true }
+async-recursion = { workspace = true }
 
 # Async
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
+tokio = { workspace = true, optional = true }
 
 # Axum Impl
-axum = { version = "0.7.5", optional = true }
+axum = { workspace = true, optional = true }
+utoipa = { workspace = true, features = ["axum_extras"], optional = true }
 
 # Rocket Impl
-schemars = { version = "0.8.8", optional = true }
-rocket = { version = "0.5.1", default-features = false, features = [
-    "json",
-], optional = true }
-revolt_okapi = { version = "0.9.1", optional = true }
-revolt_rocket_okapi = { version = "0.10.0", optional = true }
-
-# Authifier
-authifier = { version = "1.0.15" }
+schemars = { workspace = true, optional = true }
+rocket = { workspace = true, features = ["json"], optional = true }
+revolt_okapi = { workspace = true, optional = true }
+revolt_rocket_okapi = { workspace = true, optional = true }
 
 # RabbitMQ
-amqprs = { version = "1.7.0" }
+lapin = { workspace = true, features = ["tokio"] }
 
 # Voice
-livekit-api = { version = "0.4.4", optional = true}
-livekit-protocol = { version = "0.4.0", optional = true }
-livekit-runtime = { version = "0.3.1", features = ["tokio"], optional = true }
+livekit-api = { workspace = true, features = ["rustls-tls-native-roots"], optional = true }
+livekit-protocol = { workspace = true, optional = true }
+livekit-runtime = { workspace = true, features = ["tokio"], optional = true }
+
+# Security
+totp-lite = { workspace = true }
+rust-argon2 = { workspace = true }
+
+# Email
+lettre = { workspace = true }
+handlebars = { workspace = true }
+
+# Web Requests
+reqwest = { workspace = true, features = ["json", "form"] }

crates/core/database/assets/revolt_source_list.txt

@@ -0,0 +1,555 @@
+this is an assorted list of known disposable email providers
+
+#region nobody will ever have an email @example.com so we can safely block it
+----
+example.com
+
+#region list provided by michenriksen at https://gist.github.com/michenriksen/8710649
+----
+0815.ru
+0wnd.net
+0wnd.org
+10minutemail.co.za
+10minutemail.com
+123-m.com
+1fsdfdsfsdf.tk
+1pad.de
+20minutemail.com
+21cn.com
+2fdgdfgdfgdf.tk
+2prong.com
+30minutemail.com
+33mail.com
+3trtretgfrfe.tk
+4gfdsgfdgfd.tk
+4warding.com
+5ghgfhfghfgh.tk
+6hjgjhgkilkj.tk
+6paq.com
+7tags.com
+9ox.net
+a-bc.net
+agedmail.com
+ama-trade.de
+amilegit.com
+amiri.net
+amiriindustries.com
+anonmails.de
+anonymbox.com
+antichef.com
+antichef.net
+antireg.ru
+antispam.de
+antispammail.de
+armyspy.com
+artman-conception.com
+azmeil.tk
+baxomale.ht.cx
+beefmilk.com
+bigstring.com
+binkmail.com
+bio-muesli.net
+bobmail.info
+bodhi.lawlita.com
+bofthew.com
+bootybay.de
+boun.cr
+bouncr.com
+breakthru.com
+brefmail.com
+bsnow.net
+bspamfree.org
+bugmenot.com
+bund.us
+burstmail.info
+buymoreplays.com
+byom.de
+c2.hu
+casualdx.com
+cek.pm
+centermail.com
+centermail.net
+chammy.info
+childsavetrust.org
+chogmail.com
+choicemail1.com
+clixser.com
+cmail.net
+cmail.org
+coldemail.info
+cool.fr.nf
+courriel.fr.nf
+courrieltemporaire.com
+crapmail.org
+cust.in
+cuvox.de
+d3p.dk
+dacoolest.com
+dandikmail.com
+dayrep.com
+dcemail.com
+deadaddress.com
+deadspam.com
+delikkt.de
+despam.it
+despammed.com
+devnullmail.com
+dfgh.net
+digitalsanctuary.com
+dingbone.com
+disposableaddress.com
+disposableemailaddresses.com
+disposableinbox.com
+dispose.it
+dispostable.com
+dodgeit.com
+dodgit.com
+donemail.ru
+dontreg.com
+dontsendmespam.de
+drdrb.net
+dump-email.info
+dumpandjunk.com
+dumpyemail.com
+e-mail.com
+e-mail.org
+e4ward.com
+easytrashmail.com
+einmalmail.de
+einrot.com
+eintagsmail.de
+emailgo.de
+emailias.com
+emaillime.com
+emailsensei.com
+emailtemporanea.com
+emailtemporanea.net
+emailtemporar.ro
+emailtemporario.com.br
+emailthe.net
+emailtmp.com
+emailwarden.com
+emailx.at.hm
+emailxfer.com
+emeil.in
+emeil.ir
+emz.net
+ero-tube.org
+evopo.com
+explodemail.com
+eyepaste.com
+fakeinbox.com
+fakeinformation.com
+fansworldwide.de
+fantasymail.de
+fightallspam.com
+filzmail.com
+fivemail.de
+fleckens.hu
+frapmail.com
+friendlymail.co.uk
+fuckingduh.com
+fudgerub.com
+fyii.de
+garliclife.com
+gehensiemirnichtaufdensack.de
+get2mail.fr
+getairmail.com
+getmails.eu
+getonemail.com
+giantmail.de
+girlsundertheinfluence.com
+gishpuppy.com
+gmial.com
+goemailgo.com
+gotmail.net
+gotmail.org
+gotti.otherinbox.com
+great-host.in
+greensloth.com
+grr.la
+gsrv.co.uk
+guerillamail.biz
+guerillamail.com
+guerrillamail.biz
+guerrillamail.com
+guerrillamail.de
+guerrillamail.info
+guerrillamail.net
+guerrillamail.org
+guerrillamailblock.com
+gustr.com
+harakirimail.com
+hat-geld.de
+hatespam.org
+herp.in
+hidemail.de
+hidzz.com
+hmamail.com
+hopemail.biz
+ieh-mail.de
+ikbenspamvrij.nl
+imails.info
+inbax.tk
+inbox.si
+inboxalias.com
+inboxclean.com
+inboxclean.org
+instant-mail.de
+ip6.li
+irish2me.com
+iwi.net
+jetable.com
+jetable.fr.nf
+jetable.net
+jetable.org
+jnxjn.com
+jourrapide.com
+jsrsolutions.com
+kasmail.com
+kaspop.com
+killmail.com
+killmail.net
+klassmaster.com
+klzlk.com
+koszmail.pl
+kurzepost.de
+lawlita.com
+letthemeatspam.com
+lhsdv.com
+lifebyfood.com
+link2mail.net
+litedrop.com
+lol.ovpn.to
+lolfreak.net
+lookugly.com
+lortemail.dk
+lr78.com
+lroid.com
+lukop.dk
+m21.cc
+mail-filter.com
+mail-temporaire.fr
+mail.mezimages.net
+mail1a.de
+mail21.cc
+mail2rss.org
+mail333.com
+mailbidon.com
+mailbiz.biz
+mailblocks.com
+mailbucket.org
+mailcat.biz
+mailcatch.com
+mailde.de
+mailde.info
+maildrop.cc
+maileimer.de
+mailexpire.com
+mailfa.tk
+mailforspam.com
+mailfreeonline.com
+mailguard.me
+mailin8r.com
+mailinater.com
+mailinator.com
+mailinator.net
+mailinator.org
+mailinator2.com
+mailincubator.com
+mailismagic.com
+mailme.lv
+mailme24.com
+mailmetrash.com
+mailmoat.com
+mailms.com
+mailnesia.com
+mailnull.com
+mailorg.org
+mailpick.biz
+mailrock.biz
+mailscrap.com
+mailshell.com
+mailsiphon.com
+mailtemp.info
+mailtome.de
+mailtothis.com
+mailtrash.net
+mailtv.net
+mailtv.tv
+mailzilla.com
+makemetheking.com
+manybrain.com
+mbx.cc
+mega.zik.dj
+meinspamschutz.de
+meltmail.com
+messagebeamer.de
+mezimages.net
+ministry-of-silly-walks.de
+mintemail.com
+misterpinball.de
+moncourrier.fr.nf
+monemail.fr.nf
+monmail.fr.nf
+monumentmail.com
+mt2009.com
+mt2014.com
+mycleaninbox.net
+mymail-in.net
+mypacks.net
+mypartyclip.de
+myphantomemail.com
+mysamp.de
+mytempemail.com
+mytempmail.com
+mytrashmail.com
+nabuma.com
+neomailbox.com
+nepwk.com
+nervmich.net
+nervtmich.net
+netmails.com
+netmails.net
+neverbox.com
+nice-4u.com
+nincsmail.hu
+nnh.com
+no-spam.ws
+noblepioneer.com
+nomail.pw
+nomail.xl.cx
+nomail2me.com
+nomorespamemails.com
+nospam.ze.tc
+nospam4.us
+nospamfor.us
+nospammail.net
+notmailinator.com
+nowhere.org
+nowmymail.com
+nurfuerspam.de
+nus.edu.sg
+objectmail.com
+obobbo.com
+odnorazovoe.ru
+oneoffemail.com
+onewaymail.com
+onlatedotcom.info
+online.ms
+ordinaryamerican.net
+otherinbox.com
+ovpn.to
+owlpic.com
+pancakemail.com
+pcusers.otherinbox.com
+pjjkp.com
+plexolan.de
+poczta.onet.pl
+politikerclub.de
+poofy.org
+pookmail.com
+privacy.net
+privatdemail.net
+proxymail.eu
+prtnx.com
+putthisinyourspamdatabase.com
+putthisinyourspamdatabase.com
+quickinbox.com
+rcpt.at
+reallymymail.com
+realtyalerts.ca
+recode.me
+recursor.net
+reliable-mail.com
+rhyta.com
+rmqkr.net
+royal.net
+rtrtr.com
+s0ny.net
+safersignup.de
+safetymail.info
+safetypost.de
+saynotospams.com
+schafmail.de
+schrott-email.de
+secretemail.de
+secure-mail.biz
+senseless-entertainment.com
+services391.com
+sharklasers.com
+shieldemail.com
+shiftmail.com
+shitmail.me
+shitware.nl
+shmeriously.com
+shortmail.net
+sinnlos-mail.de
+slapsfromlastnight.com
+slaskpost.se
+smashmail.de
+smellfear.com
+snakemail.com
+sneakemail.com
+sneakmail.de
+snkmail.com
+sofimail.com
+solvemail.info
+sogetthis.com
+soodonims.com
+spam4.me
+spamail.de
+spamarrest.com
+spambob.net
+spambog.ru
+spambox.us
+spamcannon.com
+spamcannon.net
+spamcon.org
+spamcorptastic.com
+spamcowboy.com
+spamcowboy.net
+spamcowboy.org
+spamday.com
+spamex.com
+spamfree.eu
+spamfree24.com
+spamfree24.de
+spamfree24.org
+spamgoes.in
+spamgourmet.com
+spamgourmet.net
+spamgourmet.org
+spamherelots.com
+spamherelots.com
+spamhereplease.com
+spamhereplease.com
+spamhole.com
+spamify.com
+spaml.de
+spammotel.com
+spamobox.com
+spamslicer.com
+spamspot.com
+spamthis.co.uk
+spamtroll.net
+speed.1s.fr
+spoofmail.de
+stuffmail.de
+super-auswahl.de
+supergreatmail.com
+supermailer.jp
+superrito.com
+superstachel.de
+suremail.info
+talkinator.com
+teewars.org
+teleworm.com
+teleworm.us
+temp-mail.org
+temp-mail.ru
+tempe-mail.com
+tempemail.co.za
+tempemail.com
+tempemail.net
+tempemail.net
+tempinbox.co.uk
+tempinbox.com
+tempmail.eu
+tempmaildemo.com
+tempmailer.com
+tempmailer.de
+tempomail.fr
+temporaryemail.net
+temporaryforwarding.com
+temporaryinbox.com
+temporarymailaddress.com
+tempthe.net
+thankyou2010.com
+thc.st
+thelimestones.com
+thisisnotmyrealemail.com
+thismail.net
+throwawayemailaddress.com
+tilien.com
+tittbit.in
+tizi.com
+tmailinator.com
+toomail.biz
+topranklist.de
+tradermail.info
+trash-mail.at
+trash-mail.com
+trash-mail.de
+trash2009.com
+trashdevil.com
+trashemail.de
+trashmail.at
+trashmail.com
+trashmail.de
+trashmail.me
+trashmail.net
+trashmail.org
+trashymail.com
+trialmail.de
+trillianpro.com
+twinmail.de
+tyldd.com
+uggsrock.com
+umail.net
+uroid.com
+us.af
+venompen.com
+veryrealemail.com
+viditag.com
+viralplays.com
+vpn.st
+vsimcard.com
+vubby.com
+wasteland.rfc822.org
+webemail.me
+weg-werf-email.de
+wegwerf-emails.de
+wegwerfadresse.de
+wegwerfemail.com
+wegwerfemail.de
+wegwerfmail.de
+wegwerfmail.info
+wegwerfmail.net
+wegwerfmail.org
+wh4f.org
+whyspam.me
+willhackforfood.biz
+willselfdestruct.com
+winemaven.info
+wronghead.com
+www.e4ward.com
+www.mailinator.com
+wwwnew.eu
+x.ip6.li
+xagloo.com
+xemaps.com
+xents.com
+xmaily.com
+xoxy.net
+yep.it
+yogamaven.com
+yopmail.com
+yopmail.fr
+yopmail.net
+yourdomain.com
+yuurok.com
+z1p.biz
+za.com
+zehnminuten.de
+zehnminutenmail.de
+zippymail.info
+zoemail.net
+zomg.info
+
+#region public emails provided by mail.tm
+----
+trythe.net
+leadwizzer.com
+metalunits.com
+scpulse.com

crates/core/database/src/amqp/amqp.rs

@@ -1,58 +1,77 @@
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use crate::events::rabbit::*;
 use crate::User;
-use amqprs::channel::{BasicPublishArguments, ExchangeDeclareArguments};
-use amqprs::connection::OpenConnectionArguments;
-use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
-use amqprs::{BasicProperties, FieldTable};
+use lapin::{
+    options::BasicPublishOptions,
+    protocol::basic::AMQPProperties,
+    types::{AMQPValue, FieldTable},
+    Channel, Connection, ConnectionProperties, Error as AMQPError,
+};
 use revolt_models::v0::PushNotification;
 use revolt_presence::filter_online;
+use revolt_result::Result;
 
 use serde_json::to_string;
 
 #[derive(Clone)]
 pub struct AMQP {
+    friend_request_accepted: Arc<Channel>,
+    friend_request_received: Arc<Channel>,
+    generic_message: Arc<Channel>,
+    message_sent: Arc<Channel>,
+    mass_mention_message_sent: Arc<Channel>,
+    ack_notification_message: Arc<Channel>,
+    dm_call_updated: Arc<Channel>,
+    process_ack: Arc<Channel>,
     #[allow(unused)]
-    connection: Connection,
-    channel: Channel,
+    connection: Arc<Connection>,
 }
 
 impl AMQP {
-    pub fn new(connection: Connection, channel: Channel) -> AMQP {
-        AMQP {
+    pub async fn new(connection: Arc<Connection>) -> Self {
+        Self {
+            friend_request_accepted: Self::create_channel(&connection).await,
+            friend_request_received: Self::create_channel(&connection).await,
+            generic_message: Self::create_channel(&connection).await,
+            message_sent: Self::create_channel(&connection).await,
+            mass_mention_message_sent: Self::create_channel(&connection).await,
+            ack_notification_message: Self::create_channel(&connection).await,
+            dm_call_updated: Self::create_channel(&connection).await,
+            process_ack: Self::create_channel(&connection).await,
             connection,
-            channel,
         }
     }
 
-    pub async fn new_auto() -> AMQP {
+    pub async fn new_auto() -> Self {
         let config = revolt_config::config().await;
 
-        let connection = Connection::open(&OpenConnectionArguments::new(
-            &config.rabbit.host,
-            config.rabbit.port,
-            &config.rabbit.username,
-            &config.rabbit.password,
-        ))
-        .await
-        .expect("Failed to connect to RabbitMQ");
-
-        let channel = connection
-            .open_channel(None)
-            .await
-            .expect("Failed to open RabbitMQ channel");
-
-        channel
-            .exchange_declare(
-                ExchangeDeclareArguments::new(&config.pushd.exchange, "direct")
-                    .durable(true)
-                    .finish(),
+        let connection = Arc::new(
+            Connection::connect(
+                &format!(
+                    "amqp://{}:{}@{}:{}",
+                    &config.rabbit.username,
+                    &config.rabbit.password,
+                    &config.rabbit.host,
+                    &config.rabbit.port,
+                ),
+                ConnectionProperties::default(),
             )
             .await
-            .expect("Failed to declare exchange");
+            .expect("Failed to connect to RabbitMQ"),
+        );
 
-        AMQP::new(connection, channel)
+        Self::new(connection).await
+    }
+
+    async fn create_channel(connection: &Connection) -> Arc<Channel> {
+        Arc::new(
+            connection
+                .create_channel()
+                .await
+                .expect("Failed to create channel"),
+        )
     }
 
     pub async fn friend_request_accepted(
@@ -72,19 +91,20 @@ impl AMQP {
             config.pushd.get_fr_accepted_routing_key(),
             payload
         );
-        self.channel
+
+        self.friend_request_accepted
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_accepted_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_fr_accepted_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn friend_request_received(
@@ -105,19 +125,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.friend_request_received
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_received_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_fr_received_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn generic_message(
@@ -142,19 +162,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.generic_message
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_generic_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_generic_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn message_sent(
@@ -185,19 +205,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.message_sent
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_message_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_message_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn mass_mention_message_sent(
@@ -220,19 +240,24 @@ impl AMQP {
             routing_key, payload
         );
 
-        self.channel
+        self.mass_mention_message_sent
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, routing_key.as_str()),
+                config.pushd.exchange.clone().into(),
+                routing_key.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
-    pub async fn ack_message(
+    /// # Sends an ack to pushd to update badges on iPhones.
+    /// Not to be confused with the process_ack function, which handles sending all acks to crond for processing.
+    pub async fn ack_notification_message(
         &self,
         user_id: String,
         channel_id: String,
@@ -252,23 +277,25 @@ impl AMQP {
             config.pushd.ack_queue, payload
         );
 
-        let mut headers = FieldTable::new();
+        let mut headers = FieldTable::default();
         headers.insert(
-            "x-deduplication-header".try_into().unwrap(),
-            format!("{}-{}", &user_id, &channel_id).into(),
+            "x-deduplication-header".into(),
+            AMQPValue::LongString(format!("{}-{}", &user_id, &channel_id).into()),
         );
 
-        self.channel
+        self.ack_notification_message
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    //.with_headers(headers)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, &config.pushd.ack_queue),
+                config.pushd.exchange.clone().into(),
+                config.pushd.ack_queue.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     /// # DM Call Update
@@ -302,18 +329,54 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.dm_call_updated
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_dm_call_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_dm_call_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
+    }
+
+    /// # Send an ack to crond for processing
+    pub async fn process_ack(
+        &self,
+        user_id: &str,
+        channel_id: Option<&str>,
+        server_id: Option<&str>,
+    ) -> Result<(), AMQPError> {
+        let config = revolt_config::config().await;
+
+        let payload = AckEventPayload {
+            user_id: user_id.to_string(),
+            channel_id: channel_id.map(|value| value.to_string()),
+            server_id: server_id.map(|value| value.to_string()),
+        };
+        let payload = to_string(&payload).unwrap();
+
+        info!(
+            "Sending ack processor event on exchange {}, channel {}: {}",
+            config.rabbit.default_exchange, config.rabbit.queues.acks, payload
+        );
+
+        self.process_ack
+            .basic_publish(
+                config.rabbit.default_exchange.clone().into(),
+                config.rabbit.queues.acks.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
+            )
+            .await?;
+
+        Ok(())
     }
 }

crates/core/database/src/drivers/mod.rs

@@ -2,15 +2,7 @@
 mod mongodb;
 mod reference;
 
-use authifier::config::Captcha;
-use authifier::config::EmailVerificationConfig;
-use authifier::config::PasswordScanning;
-use authifier::config::ResolveIp;
-use authifier::config::SMTPSettings;
-use authifier::config::Shield;
-use authifier::config::Template;
-use authifier::config::Templates;
-use authifier::Authifier;
+
 use rand::Rng;
 use revolt_config::config;
 
@@ -69,7 +61,7 @@ impl DatabaseInfo {
                     .await;
 
                     #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string())
+                    return Err("MongoDB not enabled.".to_string());
                 } else {
                     DatabaseInfo::Reference.connect().await
                 }
@@ -90,7 +82,7 @@ impl DatabaseInfo {
                         .await;
 
                         #[cfg(not(feature = "mongodb"))]
-                        return Err("MongoDB not enabled.".to_string())
+                        return Err("MongoDB not enabled.".to_string());
                     }
                     _ => unreachable!("must specify REFERENCE or MONGODB"),
                 }
@@ -111,139 +103,3 @@ impl DatabaseInfo {
         }
     }
 }
-
-impl Database {
-    /// Create an Authifier reference
-    pub async fn to_authifier(self) -> Authifier {
-        let config = config().await;
-
-        let mut auth_config = authifier::Config {
-            password_scanning: if config.api.security.easypwned.is_empty() {
-                Default::default()
-            } else {
-                PasswordScanning::EasyPwned {
-                    endpoint: config.api.security.easypwned,
-                }
-            },
-            email_verification: if !config.api.smtp.host.is_empty() {
-                EmailVerificationConfig::Enabled {
-                    smtp: SMTPSettings {
-                        from: config.api.smtp.from_address,
-                        host: config.api.smtp.host,
-                        username: config.api.smtp.username,
-                        password: config.api.smtp.password,
-                        reply_to: Some(
-                            config
-                                .api
-                                .smtp
-                                .reply_to
-                                .unwrap_or("support@revolt.chat".into()),
-                        ),
-                        port: config.api.smtp.port,
-                        use_tls: config.api.smtp.use_tls,
-                        use_starttls: config.api.smtp.use_starttls,
-                    },
-                    expiry: Default::default(),
-                    templates: if config.production {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your Revolt account.".into(),
-                                text: include_str!("../../templates/verify.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: Some(include_str!("../../templates/verify.html").into()),
-                            },
-                            reset: Template {
-                                title: "Reset your Revolt password.".into(),
-                                text: include_str!("../../templates/reset.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(include_str!("../../templates/reset.html").into()),
-                            },
-                            reset_existing: Template {
-                                title: "You already have a Revolt account, reset your password."
-                                    .into(),
-                                text: include_str!("../../templates/reset-existing.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(
-                                    include_str!("../../templates/reset-existing.html").into(),
-                                ),
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.txt").into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: Some(include_str!("../../templates/deletion.html").into()),
-                            },
-                            welcome: None,
-                        }
-                    } else {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your account.".into(),
-                                text: include_str!("../../templates/verify.whitelabel.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: None,
-                            },
-                            reset: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            reset_existing: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.whitelabel.txt")
-                                    .into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: None,
-                            },
-                            welcome: None,
-                        }
-                    },
-                }
-            } else {
-                EmailVerificationConfig::Disabled
-            },
-            ..Default::default()
-        };
-
-        auth_config.invite_only = config.api.registration.invite_only;
-
-        if !config.api.security.captcha.hcaptcha_key.is_empty() {
-            auth_config.captcha = Captcha::HCaptcha {
-                secret: config.api.security.captcha.hcaptcha_key,
-            };
-        }
-
-        if !config.api.security.authifier_shield_key.is_empty() {
-            auth_config.shield = Shield::Enabled {
-                api_key: config.api.security.authifier_shield_key,
-                strict: false,
-            };
-        }
-
-        if config.api.security.trust_cloudflare {
-            auth_config.resolve_ip = ResolveIp::Cloudflare;
-        }
-
-        Authifier {
-            database: match self {
-                Database::Reference(_) => Default::default(),
-                #[cfg(feature = "mongodb")]
-                Database::MongoDb(MongoDb(client, _)) => authifier::Database::MongoDb(
-                    authifier::database::MongoDb(client.database("revolt")),
-                ),
-            },
-            config: auth_config,
-            #[cfg(feature = "tasks")]
-            event_channel: Some(crate::tasks::authifier_relay::sender()),
-            #[cfg(not(feature = "tasks"))]
-            event_channel: None,
-        }
-    }
-}

crates/core/database/src/drivers/reference.rs

@@ -5,7 +5,7 @@ use futures::lock::Mutex;
 use crate::{
     Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
     MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
-    User, UserSettings, Webhook,
+    User, UserSettings, Webhook, Account, AccountInvite, Session, MFATicket
 };
 
 database_derived!(
@@ -30,5 +30,9 @@ database_derived!(
         pub servers: Arc<Mutex<HashMap<String, Server>>>,
         pub safety_reports: Arc<Mutex<HashMap<String, Report>>>,
         pub safety_snapshots: Arc<Mutex<HashMap<String, Snapshot>>>,
+        pub accounts: Arc<Mutex<HashMap<String, Account>>>,
+        pub account_invites: Arc<Mutex<HashMap<String, AccountInvite>>>,
+        pub sessions: Arc<Mutex<HashMap<String, Session>>>,
+        pub tickets: Arc<Mutex<HashMap<String, MFATicket>>>,
     }
 );

crates/core/database/src/events/client.rs

@@ -1,12 +1,16 @@
-use authifier::AuthifierEvent;
 use revolt_result::Error;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelUnread, ChannelVoiceState, Emoji, FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState, PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, UserVoiceState, Webhook
+    AppendMessage, Channel, ChannelSlowmode, ChannelUnread, ChannelVoiceState, Emoji,
+    FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser,
+    FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialEmoji,
+    PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState,
+    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings,
+    UserVoiceState, Webhook,
 };
 
-use crate::Database;
+use crate::{Account, Database, Session};
 
 /// Ping Packet
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -51,9 +55,13 @@ impl Default for ReadyPayloadFields {
 #[serde(tag = "type")]
 pub enum EventV1 {
     /// Multiple events
-    Bulk { v: Vec<EventV1> },
+    Bulk {
+        v: Vec<EventV1>,
+    },
     /// Error event
-    Error { data: Error },
+    Error {
+        data: Error,
+    },
 
     /// Successfully authenticated
     Authenticated,
@@ -84,7 +92,9 @@ pub enum EventV1 {
     },
 
     /// Ping response
-    Pong { data: Ping },
+    Pong {
+        data: Ping,
+    },
     /// New message
     Message(Message),
 
@@ -105,7 +115,10 @@ pub enum EventV1 {
     },
 
     /// Delete message
-    MessageDelete { id: String, channel: String },
+    MessageDelete {
+        id: String,
+        channel: String,
+    },
 
     /// New reaction to a message
     MessageReact {
@@ -131,7 +144,10 @@ pub enum EventV1 {
     },
 
     /// Bulk delete messages
-    BulkMessageDelete { channel: String, ids: Vec<String> },
+    BulkMessageDelete {
+        channel: String,
+        ids: Vec<String>,
+    },
 
     /// New server
     ServerCreate {
@@ -139,7 +155,7 @@ pub enum EventV1 {
         server: Server,
         channels: Vec<Channel>,
         emojis: Vec<Emoji>,
-        voice_states: Vec<ChannelVoiceState>
+        voice_states: Vec<ChannelVoiceState>,
     },
 
     /// Update existing server
@@ -151,7 +167,9 @@ pub enum EventV1 {
     },
 
     /// Delete server
-    ServerDelete { id: String },
+    ServerDelete {
+        id: String,
+    },
 
     /// Update existing server member
     ServerMemberUpdate {
@@ -187,10 +205,16 @@ pub enum EventV1 {
     },
 
     /// Server role deleted
-    ServerRoleDelete { id: String, role_id: String },
+    ServerRoleDelete {
+        id: String,
+        role_id: String,
+    },
 
     /// Server roles ranks updated
-    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
+    ServerRoleRanksUpdate {
+        id: String,
+        ranks: Vec<String>,
+    },
 
     /// Update existing user
     UserUpdate {
@@ -202,9 +226,15 @@ pub enum EventV1 {
     },
 
     /// Relationship with another user changed
-    UserRelationship { id: String, user: User },
+    UserRelationship {
+        id: String,
+        user: User,
+    },
     /// Settings updated remotely
-    UserSettingsUpdate { id: String, update: UserSettings },
+    UserSettingsUpdate {
+        id: String,
+        update: UserSettings,
+    },
 
     /// User has been platform banned or deleted their account
     ///
@@ -215,12 +245,23 @@ pub enum EventV1 {
     /// - Server Memberships
     ///
     /// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
-    UserPlatformWipe { user_id: String, flags: i32 },
+    UserPlatformWipe {
+        user_id: String,
+        flags: i32,
+    },
     /// New emoji
     EmojiCreate(Emoji),
 
+    /// Update existing emoji
+    EmojiUpdate {
+        id: String,
+        data: PartialEmoji,
+    },
+
     /// Delete emoji
-    EmojiDelete { id: String },
+    EmojiDelete {
+        id: String,
+    },
 
     /// New report
     ReportCreate(Report),
@@ -236,19 +277,33 @@ pub enum EventV1 {
     },
 
     /// Delete channel
-    ChannelDelete { id: String },
+    ChannelDelete {
+        id: String,
+    },
 
     /// User joins a group
-    ChannelGroupJoin { id: String, user: String },
+    ChannelGroupJoin {
+        id: String,
+        user: String,
+    },
 
     /// User leaves a group
-    ChannelGroupLeave { id: String, user: String },
+    ChannelGroupLeave {
+        id: String,
+        user: String,
+    },
 
     /// User started typing in a channel
-    ChannelStartTyping { id: String, user: String },
+    ChannelStartTyping {
+        id: String,
+        user: String,
+    },
 
     /// User stopped typing in a channel
-    ChannelStopTyping { id: String, user: String },
+    ChannelStopTyping {
+        id: String,
+        user: String,
+    },
 
     /// User acknowledged message in channel
     ChannelAck {
@@ -268,10 +323,25 @@ pub enum EventV1 {
     },
 
     /// Delete webhook
-    WebhookDelete { id: String },
+    WebhookDelete {
+        id: String,
+    },
 
     /// Auth events
-    Auth(AuthifierEvent),
+    CreateAccount {
+        account: Account,
+    },
+    CreateSession {
+        session: Session,
+    },
+    DeleteSession {
+        user_id: String,
+        session_id: String,
+    },
+    DeleteAllSessions {
+        user_id: String,
+        exclude_session_id: Option<String>,
+    },
 
     /// Voice events
     VoiceChannelJoin {
@@ -286,7 +356,7 @@ pub enum EventV1 {
         user: String,
         from: String,
         to: String,
-        state: UserVoiceState
+        state: UserVoiceState,
     },
     UserVoiceStateUpdate {
         id: String,
@@ -298,7 +368,11 @@ pub enum EventV1 {
         from: String,
         to: String,
         token: String,
-    }
+    },
+    /// User's active slowmodes
+    UserSlowmodes {
+        slowmodes: Vec<ChannelSlowmode>,
+    },
 }
 
 impl EventV1 {

crates/core/database/src/events/rabbit.rs

@@ -78,3 +78,11 @@ pub struct AckPayload {
     pub channel_id: String,
     pub message_id: String,
 }
+
+/// This is not the same as the AckPayload above, as the state for this event is stored in redis to allow for state updates while the event is queued.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct AckEventPayload {
+    pub user_id: String,
+    pub channel_id: Option<String>,
+    pub server_id: Option<String>,
+}

crates/core/database/src/lib.rs

@@ -25,8 +25,8 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;
 
-#[cfg(not(feature = "async-std-runtime"))]
-compile_error!("async-std-runtime feature must be enabled.");
+#[cfg(not(feature = "tokio-runtime"))]
+compile_error!("tokio-runtime feature must be enabled.");
 
 #[macro_export]
 #[cfg(debug_assertions)]

crates/core/database/src/models/account_invites/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/account_invites/model.rs

@@ -0,0 +1,25 @@
+use crate::{if_false, Database};
+use revolt_result::Result;
+
+auto_derived_partial!(
+    /// Account invite ticket
+    pub struct AccountInvite {
+        /// Invite code
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Whether this invite ticket has been used
+        #[serde(skip_serializing_if = "if_false", default)]
+        pub used: bool,
+        /// User ID that this invite was claimed by
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub claimed_by: Option<String>,
+    },
+    "PartialAccountInvite"
+);
+
+impl AccountInvite {
+    /// Save model
+    pub async fn save(&self, db: &Database) -> Result<()> {
+        db.save_account_invite(self).await
+    }
+}

crates/core/database/src/models/account_invites/ops.rs

@@ -0,0 +1,16 @@
+use revolt_result::Result;
+
+use crate::AccountInvite;
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAccountInvites: Sync + Send {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite>;
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()>;
+}

crates/core/database/src/models/account_invites/ops/mongodb.rs

@@ -0,0 +1,31 @@
+use crate::{AbstractAccountInvites, AccountInvite, MongoDb};
+use bson::to_document;
+use mongodb::options::UpdateOptions;
+use revolt_result::Result;
+
+const COL: &str = "account_invites";
+
+#[async_trait]
+impl AbstractAccountInvites for MongoDb {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(InvalidInvite))
+    }
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()> {
+        self.col::<AccountInvite>(COL)
+            .update_one(
+                doc! {
+                    "_id": &invite.id
+                },
+                doc! {
+                    "$set": to_document(invite).map_err(|_| create_database_error!("to_document", COL))?,
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map_err(|_| create_database_error!("upsert_one", COL))
+            .map(|_| ())
+    }
+}

crates/core/database/src/models/account_invites/ops/reference.rs

@@ -0,0 +1,21 @@
+use crate::{AbstractAccountInvites, AccountInvite, ReferenceDb};
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractAccountInvites for ReferenceDb {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite> {
+        let invites = self.account_invites.lock().await;
+        invites
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidInvite))
+    }
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()> {
+        let mut invites = self.account_invites.lock().await;
+        invites.insert(invite.id.to_string(), invite.clone());
+        Ok(())
+    }
+}

crates/core/database/src/models/accounts/axum.rs

@@ -0,0 +1,22 @@
+use axum::{extract::{FromRef, FromRequestParts}, http::request::Parts};
+
+use revolt_result::{Error, Result};
+
+use crate::{Account, Database, Session};
+
+#[async_trait]
+impl<S> FromRequestParts<S> for Account
+where
+    Database: FromRef<S>,
+    S: Send + Sync
+{
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
+        let db = Database::from_ref(state);
+
+        let session = Session::from_request_parts(parts, state).await?;
+
+        db.fetch_account(&session.user_id).await
+    }
+}

crates/core/database/src/models/accounts/mod.rs

@@ -0,0 +1,11 @@
+#[cfg(feature = "axum-impl")]
+mod axum;
+mod model;
+mod ops;
+#[cfg(feature = "rocket-impl")]
+mod rocket;
+#[cfg(feature = "rocket-impl")]
+mod schema;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/accounts/model.rs

@@ -0,0 +1,656 @@
+use iso8601_timestamp::{Duration, Timestamp};
+
+use nanoid::nanoid;
+use revolt_config::config;
+use revolt_result::Result;
+use serde_json::json;
+
+use crate::{
+    events::client::EventV1,
+    util::{
+        email::{email_templates, normalise_email, send_email},
+        password::hash_password,
+    },
+    Database, MFATicket, Session,
+};
+use revolt_models::v0;
+
+auto_derived_partial!(
+    /// Account model
+    pub struct Account {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// User's email
+        pub email: String,
+
+        /// Normalised email
+        ///
+        /// (see https://github.com/insertish/authifier/#how-does-authifier-work)
+        pub email_normalised: String,
+
+        /// Argon2 hashed password
+        pub password: String,
+
+        /// Whether the account is disabled
+        #[serde(default)]
+        pub disabled: bool,
+
+        /// Email verification status
+        pub verification: EmailVerification,
+
+        /// Password reset information
+        pub password_reset: Option<PasswordReset>,
+
+        /// Account deletion information
+        pub deletion: Option<DeletionInfo>,
+
+        /// Account lockout
+        pub lockout: Option<Lockout>,
+
+        /// Multi-factor authentication information
+        pub mfa: MultiFactorAuthentication,
+    },
+    "PartialAccount"
+);
+
+auto_derived!(
+    /// Email verification status
+    #[serde(tag = "status")]
+    pub enum EmailVerification {
+        /// Account is verified
+        Verified,
+        /// Pending email verification
+        Pending { token: String, expiry: Timestamp },
+        /// Moving to a new email
+        Moving {
+            new_email: String,
+            token: String,
+            expiry: Timestamp,
+        },
+    }
+
+    /// Password reset information
+    pub struct PasswordReset {
+        /// Token required to change password
+        pub token: String,
+        /// Time at which this token expires
+        pub expiry: Timestamp,
+    }
+
+    /// Account deletion information
+    #[serde(tag = "status")]
+    pub enum DeletionInfo {
+        /// The user must confirm deletion by email
+        WaitingForVerification { token: String, expiry: Timestamp },
+        /// The account is scheduled for deletion
+        Scheduled { after: Timestamp },
+        /// This account was deleted
+        Deleted,
+    }
+
+    /// Lockout information
+    pub struct Lockout {
+        /// Attempt counter
+        pub attempts: i32,
+        /// Time at which this lockout expires
+        pub expiry: Option<Timestamp>,
+    }
+
+    /// MFA configuration
+    #[derive(Default)]
+    pub struct MultiFactorAuthentication {
+        /// Allow password-less email OTP login
+        /// (1-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_email_otp: bool,
+
+        /// Allow trusted handover
+        /// (1-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_trusted_handover: bool,
+
+        /// Allow email MFA
+        /// (2-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_email_mfa: bool,
+
+        /// TOTP MFA token, enabled if present
+        /// (2-Factor)
+        #[serde(skip_serializing_if = "Totp::is_empty", default)]
+        pub totp_token: Totp,
+
+        /// Security Key MFA token, enabled if present
+        /// (2-Factor)
+        // #[serde(skip_serializing_if = "Option::is_none")]
+        // pub security_key_token: Option<String>,
+
+        /// Recovery codes
+        #[serde(skip_serializing_if = "Vec::is_empty", default)]
+        pub recovery_codes: Vec<String>,
+    }
+
+    /// MFA method
+    #[derive(Hash)]
+    pub enum MFAMethod {
+        Password,
+        Recovery,
+        Totp,
+    }
+
+    #[derive(Default)]
+    #[serde(tag = "status")]
+    pub enum Totp {
+        /// Disabled
+        #[default]
+        Disabled,
+        /// Waiting for user activation
+        Pending { secret: String },
+        /// Required on account
+        Enabled { secret: String },
+    }
+);
+
+impl MultiFactorAuthentication {
+    // Check whether MFA is in-use
+    pub fn is_active(&self) -> bool {
+        matches!(self.totp_token, Totp::Enabled { .. })
+    }
+
+    // Check whether there are still usable recovery codes
+    pub fn has_recovery(&self) -> bool {
+        !self.recovery_codes.is_empty()
+    }
+
+    // Get available MFA methods
+    pub fn get_methods(&self) -> Vec<MFAMethod> {
+        if let Totp::Enabled { .. } = self.totp_token {
+            let mut methods = vec![MFAMethod::Totp];
+
+            if self.has_recovery() {
+                methods.push(MFAMethod::Recovery);
+            }
+
+            methods
+        } else {
+            vec![MFAMethod::Password]
+        }
+    }
+
+    // Generate new recovery codes
+    pub fn generate_recovery_codes(&mut self) {
+        static ALPHABET: [char; 32] = [
+            '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+            'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z',
+        ];
+
+        let mut codes = vec![];
+        for _ in 1..=10 {
+            codes.push(format!(
+                "{}-{}",
+                nanoid!(5, &ALPHABET),
+                nanoid!(5, &ALPHABET)
+            ));
+        }
+
+        self.recovery_codes = codes;
+    }
+
+    // Generate new TOTP secret
+    pub fn generate_new_totp_secret(&mut self) -> Result<String> {
+        if let Totp::Enabled { .. } = self.totp_token {
+            return Err(create_error!(OperationFailed));
+        }
+
+        let secret: [u8; 10] = rand::random();
+        let secret = base32::encode(base32::Alphabet::RFC4648 { padding: false }, &secret);
+
+        self.totp_token = Totp::Pending {
+            secret: secret.clone(),
+        };
+
+        Ok(secret)
+    }
+
+    /// Enable TOTP using a given MFA response
+    pub fn enable_totp(&mut self, response: v0::MFAResponse) -> Result<()> {
+        if let v0::MFAResponse::Totp { totp_code } = response {
+            let code = self.totp_token.generate_code()?;
+
+            if code == totp_code {
+                let mut totp = Totp::Disabled;
+                std::mem::swap(&mut totp, &mut self.totp_token);
+
+                if let Totp::Pending { secret } = totp {
+                    self.totp_token = Totp::Enabled { secret };
+
+                    Ok(())
+                } else {
+                    Err(create_error!(OperationFailed))
+                }
+            } else {
+                Err(create_error!(InvalidToken))
+            }
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+}
+
+impl Totp {
+    /// Whether TOTP information is empty
+    pub fn is_empty(&self) -> bool {
+        matches!(self, Totp::Disabled)
+    }
+
+    /// Whether TOTP is disabled
+    pub fn is_disabled(&self) -> bool {
+        !matches!(self, Totp::Enabled { .. })
+    }
+
+    // Generate a TOTP code from secret
+    pub fn generate_code(&self) -> Result<String> {
+        if let Totp::Enabled { secret } | Totp::Pending { secret } = &self {
+            let seconds: u64 = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs();
+
+            Ok(totp_lite::totp_custom::<totp_lite::Sha1>(
+                totp_lite::DEFAULT_STEP,
+                6,
+                &base32::decode(base32::Alphabet::RFC4648 { padding: false }, secret)
+                    .expect("valid base32 secret"),
+                seconds,
+            ))
+        } else {
+            Err(create_error!(OperationFailed))
+        }
+    }
+}
+
+impl Account {
+    /// Save model
+    pub async fn save(&self, db: &Database) -> Result<()> {
+        db.save_account(self).await
+    }
+
+    /// Create a new account
+    pub async fn new(
+        db: &Database,
+        email: String,
+        plaintext_password: String,
+        verify_email: bool,
+    ) -> Result<Account> {
+        // Get a normalised representation of the user's email
+        let email_normalised = normalise_email(email.clone());
+
+        // Try to find an existing account
+        if let Some(mut account) = db
+            .fetch_account_by_normalised_email(&email_normalised)
+            .await?
+        {
+            // Resend account verification or send password reset
+            if let EmailVerification::Pending { .. } = &account.verification {
+                account.start_email_verification(db).await?;
+            } else {
+                account.start_password_reset(db, true).await?;
+            }
+
+            Ok(account)
+        } else {
+            // Hash the user's password
+            let password = hash_password(plaintext_password)?;
+
+            // Create a new account
+            let mut account = Account {
+                id: ulid::Ulid::new().to_string(),
+
+                email,
+                email_normalised,
+                password,
+
+                disabled: false,
+                verification: EmailVerification::Verified,
+                password_reset: None,
+                deletion: None,
+                lockout: None,
+
+                mfa: Default::default(),
+            };
+
+            // Send email verification
+            if verify_email {
+                account.start_email_verification(db).await?;
+            } else {
+                account.save(db).await?;
+            }
+
+            // Create and push event
+            EventV1::CreateAccount {
+                account: account.clone(),
+            }
+            .global()
+            .await;
+
+            Ok(account)
+        }
+    }
+
+    /// Create a new session
+    pub async fn create_session(&self, db: &Database, name: String) -> Result<Session> {
+        let config = config().await;
+
+        let session = Session {
+            id: ulid::Ulid::new().to_string(),
+            token: nanoid!(64),
+
+            user_id: self.id.clone(),
+            name,
+
+            last_seen: Timestamp::now_utc(),
+
+            origin: Some(config.environment),
+            subscription: None,
+        };
+
+        // Save to database
+        db.save_session(&session).await?;
+
+        // Create and push event
+        EventV1::CreateSession {
+            session: session.clone(),
+        }
+        .global()
+        .await;
+
+        Ok(session)
+    }
+
+    /// Send account verification email
+    pub async fn start_email_verification(&mut self, db: &Database) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.verify.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                &templates.verify,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.verification = EmailVerification::Pending {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_verification,
+                    ))
+                    .unwrap(),
+            };
+        } else {
+            self.verification = EmailVerification::Verified;
+        }
+
+        self.save(db).await
+    }
+
+    /// Send account verification to new email
+    pub async fn start_email_move(&mut self, db: &Database, new_email: String) -> Result<()> {
+        // This method should and will never be called on an unverified account,
+        // but just validate this just in case.
+        if let EmailVerification::Pending { .. } = self.verification {
+            return Err(create_error!(UnverifiedAccount));
+        }
+
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.verify.url, token);
+
+            send_email(
+                &config.api.smtp,
+                new_email.clone(),
+                &templates.verify,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.verification = EmailVerification::Moving {
+                new_email,
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_verification,
+                    ))
+                    .unwrap(),
+            };
+        } else {
+            self.email_normalised = normalise_email(new_email.clone());
+            self.email = new_email;
+        }
+
+        self.save(db).await
+    }
+
+    /// Send password reset email
+    pub async fn start_password_reset(
+        &mut self,
+        db: &Database,
+        existing_account: bool,
+    ) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let template = if existing_account {
+                &templates.reset_existing
+            } else {
+                &templates.reset
+            };
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", template.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                template,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.password_reset = Some(PasswordReset {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_password_reset,
+                    ))
+                    .unwrap(),
+            });
+        } else {
+            return Err(create_error!(OperationFailed));
+        }
+
+        self.save(db).await
+    }
+
+    /// Begin account deletion process by sending confirmation email
+    ///
+    /// If email verification is not on, the account will be marked for deletion instantly
+    pub async fn start_account_deletion(&mut self, db: &Database) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.deletion.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                &templates.deletion,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.deletion = Some(DeletionInfo::WaitingForVerification {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_password_reset,
+                    ))
+                    .unwrap(),
+            });
+
+            self.save(db).await
+        } else {
+            self.schedule_deletion(db).await
+        }
+    }
+
+    /// Verify a user's password is correct
+    pub fn verify_password(&self, plaintext_password: &str) -> Result<()> {
+        argon2::verify_encoded(&self.password, plaintext_password.as_bytes())
+            .map(|v| {
+                if v {
+                    Ok(())
+                } else {
+                    Err(create_error!(InvalidCredentials))
+                }
+            })
+            // To prevent user enumeration, we should ignore
+            // the error and pretend the password is wrong.
+            .map_err(|_| create_error!(InvalidCredentials))?
+    }
+
+    /// Validate an MFA response
+    pub async fn consume_mfa_response(
+        &mut self,
+        db: &Database,
+        response: v0::MFAResponse,
+        ticket: Option<MFATicket>,
+    ) -> Result<()> {
+        let allowed_methods = self.mfa.get_methods();
+
+        match response {
+            v0::MFAResponse::Password { password } => {
+                if allowed_methods.contains(&MFAMethod::Password) {
+                    self.verify_password(&password)
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+            v0::MFAResponse::Totp { totp_code } => {
+                if allowed_methods.contains(&MFAMethod::Totp) {
+                    if let Totp::Enabled { .. } = &self.mfa.totp_token {
+                        // Use TOTP code at generation if applicable
+                        if let Some(ticket) = ticket {
+                            if let Some(code) = ticket.last_totp_code {
+                                if code == totp_code {
+                                    return Ok(());
+                                }
+                            }
+                        }
+
+                        // Otherwise read current TOTP token
+                        if self.mfa.totp_token.generate_code()? == totp_code {
+                            Ok(())
+                        } else {
+                            Err(create_error!(InvalidToken))
+                        }
+                    } else {
+                        unreachable!()
+                    }
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+            v0::MFAResponse::Recovery { recovery_code } => {
+                if allowed_methods.contains(&MFAMethod::Recovery) {
+                    if let Some(index) = self
+                        .mfa
+                        .recovery_codes
+                        .iter()
+                        .position(|x| x == &recovery_code)
+                    {
+                        self.mfa.recovery_codes.remove(index);
+                        self.save(db).await
+                    } else {
+                        Err(create_error!(InvalidToken))
+                    }
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+        }
+    }
+
+    /// Delete all sessions for an account
+    pub async fn delete_all_sessions(
+        &self,
+        db: &Database,
+        exclude_session_id: Option<String>,
+    ) -> Result<()> {
+        db.delete_all_sessions(&self.id, exclude_session_id.clone())
+            .await?;
+
+        // Create and push event
+        EventV1::DeleteAllSessions {
+            user_id: self.id.clone(),
+            exclude_session_id,
+        }
+        .private(self.id.clone())
+        .await;
+
+        Ok(())
+    }
+
+    /// Disable an account
+    pub async fn disable(&mut self, db: &Database) -> Result<()> {
+        self.disabled = true;
+        self.delete_all_sessions(db, None).await?;
+        self.save(db).await
+    }
+
+    /// Schedule an account for deletion
+    pub async fn schedule_deletion(&mut self, db: &Database) -> Result<()> {
+        self.deletion = Some(DeletionInfo::Scheduled {
+            after: Timestamp::now_utc()
+                .checked_add(Duration::weeks(1))
+                .unwrap(),
+        });
+
+        self.disable(db).await
+    }
+
+    /// Removes all information from the account and marks it as fully deleted
+    pub async fn mark_deleted(&mut self, db: &Database) -> Result<()> {
+        self.email = format!("Deleted User {}", &self.id);
+        self.email_normalised = format!("Deleted User {}", &self.id);
+        self.deletion = Some(DeletionInfo::Deleted);
+
+        self.save(db).await?;
+
+        Ok(())
+    }
+}

crates/core/database/src/models/accounts/ops.rs

@@ -0,0 +1,34 @@
+use revolt_result::Result;
+
+use crate::Account;
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAccounts: Sync + Send {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account>;
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>>;
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token: &str) -> Result<Account>;
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account>;
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token: &str) -> Result<Account>;
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>>;
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()>;
+}

crates/core/database/src/models/accounts/ops/mongodb.rs

@@ -0,0 +1,118 @@
+use crate::{AbstractAccounts, Account, MongoDb};
+use bson::{to_bson, to_document};
+use iso8601_timestamp::Timestamp;
+use mongodb::options::{Collation, CollationStrength, FindOneOptions, UpdateOptions};
+use revolt_result::Result;
+
+const COL: &str = "accounts";
+
+#[async_trait]
+impl AbstractAccounts for MongoDb {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(UnknownUser))
+    }
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>> {
+        query!(
+            self,
+            find_one_with_options,
+            COL,
+            doc! {
+                "email_normalised": normalised_email
+            },
+            FindOneOptions::builder()
+                .collation(
+                    Collation::builder()
+                        .locale("en")
+                        .strength(CollationStrength::Secondary)
+                        .build(),
+                )
+                .build()
+        )
+    }
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "verification.token": token,
+                "verification.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "password_reset.token": token,
+                "password_reset.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "deletion.token": token,
+                "deletion.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "deletion.status": "Scheduled",
+                "deletion.after": {
+                    "$lte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )
+    }
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()> {
+        self.col::<Account>(COL)
+            .update_one(
+                doc! {
+                    "_id": &account.id
+                },
+                doc! {
+                    "$set": to_document(account).map_err(|_| create_database_error!("to_document", COL))?
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map_err(|_| create_database_error!("find_one", COL))
+            .map(|_| ())
+    }
+}

crates/core/database/src/models/accounts/ops/reference.rs

@@ -0,0 +1,99 @@
+use crate::{AbstractAccounts, Account, DeletionInfo, EmailVerification, ReferenceDb};
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractAccounts for ReferenceDb {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(UnknownUser))
+    }
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>> {
+        let accounts = self.accounts.lock().await;
+        Ok(accounts
+            .values()
+            .find(|account| account.email_normalised == normalised_email)
+            .cloned())
+    }
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token_to_match: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| match &account.verification {
+                EmailVerification::Pending { token, .. }
+                | EmailVerification::Moving { token, .. } => token == token_to_match,
+                _ => false,
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| {
+                if let Some(reset) = &account.password_reset {
+                    reset.token == token
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token_to_match: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| {
+                if let Some(DeletionInfo::WaitingForVerification { token, .. }) = &account.deletion
+                {
+                    token == token_to_match
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>> {
+        let now = Timestamp::now_utc();
+        let accounts = self.accounts.lock().await;
+
+        Ok(accounts
+            .values()
+            .filter(|account| {
+                if let Some(DeletionInfo::Scheduled { after }) = &account.deletion {
+                    after <= &now
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .collect())
+    }
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()> {
+        let mut accounts = self.accounts.lock().await;
+        accounts.insert(account.id.to_string(), account.clone());
+        Ok(())
+    }
+}

crates/core/database/src/models/accounts/rocket.rs

@@ -0,0 +1,32 @@
+use crate::{Account, Database, Session};
+use revolt_result::Error;
+use rocket::{
+    http::Status,
+    request::{FromRequest, Outcome},
+    Request,
+};
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for Account {
+    type Error = Error;
+
+    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
+        match request.guard::<Session>().await {
+            Outcome::Success(session) => {
+                if let Ok(account) = request
+                    .rocket()
+                    .state::<Database>()
+                    .expect("`Database`")
+                    .fetch_account(&session.user_id)
+                    .await
+                {
+                    Outcome::Success(account)
+                } else {
+                    Outcome::Error((Status::InternalServerError, create_error!(InternalError)))
+                }
+            }
+            Outcome::Forward(_) => unreachable!(),
+            Outcome::Error(err) => Outcome::Error(err),
+        }
+    }
+}

crates/core/database/src/models/accounts/schema.rs

@@ -0,0 +1,32 @@
+use revolt_okapi::openapi3::{SecurityScheme, SecuritySchemeData};
+use revolt_rocket_okapi::{
+    gen::OpenApiGenerator,
+    request::{OpenApiFromRequest, RequestHeaderInput},
+};
+
+use crate::Account;
+
+
+impl<'r> OpenApiFromRequest<'r> for Account {
+    fn from_request_input(
+        _gen: &mut OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
+        let mut requirements = schemars::Map::new();
+        requirements.insert("Session Token".to_owned(), vec![]);
+
+        Ok(RequestHeaderInput::Security(
+            "Session Token".to_owned(),
+            SecurityScheme {
+                data: SecuritySchemeData::ApiKey {
+                    name: "x-session-token".to_owned(),
+                    location: "header".to_owned(),
+                },
+                description: Some("Used to authenticate as a user.".to_owned()),
+                extensions: schemars::Map::new(),
+            },
+            requirements,
+        ))
+    }
+}

crates/core/database/src/models/admin_migrations/model.rs

@@ -11,7 +11,7 @@ auto_derived!(
 
 #[cfg(test)]
 mod tests {
-    #[async_std::test]
+    #[tokio::test]
     async fn migrate() {
         database_test!(|db| async move {
             // Initialise the database

crates/core/database/src/models/admin_migrations/ops/mongodb/init.rs

@@ -98,6 +98,18 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create pubsub collection.");
 
+    db.create_collection("sessions")
+        .await
+        .expect("Failed to create sessions collection.");
+
+    db.create_collection("account_invites")
+        .await
+        .expect("Failed to create account_invites collection.");
+
+    db.create_collection("mfa_tickets")
+        .await
+        .expect("Failed to create mfa_tickets collection.");
+
     db.run_command(doc! {
         "createIndexes": "users",
         "indexes": [
@@ -263,5 +275,89 @@ pub async fn create_database(db: &MongoDb) {
     .await
     .expect("Failed to create ratelimit_events index.");
 
+    db.run_command(doc! {
+        "createIndexes": "accounts",
+        "indexes": [
+            {
+                "key": {
+                    "email": 1
+                },
+                "name": "email",
+                "unique": true,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2
+                }
+            },
+            {
+                "key": {
+                    "email_normalised": 1
+                },
+                "name": "email_normalised",
+                "unique": true,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2
+                }
+            },
+            {
+                "key": {
+                    "verification.token": 1
+                },
+                "name": "email_verification"
+            },
+            {
+                "key": {
+                    "password_reset.token": 1
+                },
+                "name": "password_reset"
+            },
+            {
+                "key": {
+                    "deletion.token": 1
+                },
+                "name": "account_deletion"
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
+    db.run_command(doc! {
+        "createIndexes": "sessions",
+        "indexes": [
+            {
+                "key": {
+                    "token": 1
+                },
+                "name": "token",
+                "unique": true
+            },
+            {
+                "key": {
+                    "user_id": 1
+                },
+                "name": "user_id"
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
+    db.run_command(doc! {
+        "createIndexes": "mfa_tickets",
+        "indexes": [
+            {
+                "key": {
+                    "token": 1
+                },
+                "name": "token",
+                "unique": true
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
     info!("Created database.");
 }

crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs

@@ -17,6 +17,7 @@ use iso8601_timestamp::Timestamp;
 use rand::seq::SliceRandom;
 use revolt_permissions::{ChannelPermission, DEFAULT_WEBHOOK_PERMISSIONS};
 use serde::{Deserialize, Serialize};
+use ulid::Ulid;
 use unicode_segmentation::UnicodeSegmentation;
 
 #[derive(Serialize, Deserialize)]
@@ -25,7 +26,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 50; // MUST BE +1 to last migration
+pub const LATEST_REVISION: i32 = 51; // MUST BE +1 to last migration
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -451,7 +452,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         warn!("This is a destructive operation and will wipe existing permission data (excl. defaults for SendMessage).");
         warn!("Taking a backup is advised.");
         warn!("Continuing in 10 seconds...");
-        async_std::task::sleep(Duration::from_secs(10)).await;
+        tokio::time::sleep(Duration::from_secs(10)).await;
 
         let servers = db.col::<Document>("servers");
         let mut cursor = servers.find(doc! {}).await.unwrap();
@@ -573,20 +574,145 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 15 {
         info!("Running migration [revision 15 / 04-06-2022]: Migrate Authifier to latest version.");
 
-        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        db.run_migration(authifier::Migration::M2022_06_03EnsureUpToSpec)
+        if !db
+            .db()
+            .collection::<Document>("mfa_tickets")
+            .list_index_names()
             .await
-            .unwrap();
+            .unwrap_or_default()
+            .contains(&"token".to_owned())
+        {
+            // Make sure all collections exist
+            let list = db.db().list_collection_names().await.unwrap();
+            let collections = ["accounts", "sessions", "invites", "mfa_tickets"];
+
+            for name in collections {
+                if !list.contains(&name.to_string()) {
+                    db.db().create_collection(name).await.unwrap();
+                }
+            }
+
+            // Setup index for `accounts`
+            let col = db.db().collection::<Document>("accounts");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "accounts",
+                    "indexes": [
+                        {
+                            "key": {
+                                "email": 1
+                            },
+                            "name": "email",
+                            "unique": true,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2
+                            }
+                        },
+                        {
+                            "key": {
+                                "email_normalised": 1
+                            },
+                            "name": "email_normalised",
+                            "unique": true,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2
+                            }
+                        },
+                        {
+                            "key": {
+                                "verification.token": 1
+                            },
+                            "name": "email_verification"
+                        },
+                        {
+                            "key": {
+                                "password_reset.token": 1
+                            },
+                            "name": "password_reset"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+
+            // Setup index for `sessions`
+            let col = db.db().collection::<Document>("sessions");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "sessions",
+                    "indexes": [
+                        {
+                            "key": {
+                                "token": 1
+                            },
+                            "name": "token",
+                            "unique": true
+                        },
+                        {
+                            "key": {
+                                "user_id": 1
+                            },
+                            "name": "user_id"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+
+            // Setup index for `mfa_tickets`
+            let col = db.db().collection::<Document>("mfa_tickets");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "mfa_tickets",
+                    "indexes": [
+                        {
+                            "key": {
+                                "token": 1
+                            },
+                            "name": "token",
+                            "unique": true
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+        }
     }
 
     if revision <= 16 {
         info!("Running migration [revision 16 / 07-07-2022]: Add `emojis` collection and Authifier migration.");
 
-        let authifier_db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        authifier_db
-            .run_migration(authifier::Migration::M2022_06_09AddIndexForDeletion)
+        if !db
+            .db()
+            .collection::<Document>("accounts")
+            .list_index_names()
             .await
-            .unwrap();
+            .expect("list of index names")
+            .contains(&"account_deletion".to_owned())
+        {
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "accounts",
+                    "indexes": [
+                        {
+                            "key": {
+                                "deletion.token": 1
+                            },
+                            "name": "account_deletion"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+        }
 
         db.db()
             .create_collection("emojis")
@@ -1085,7 +1211,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         enum Channel {
             Group { owner: String },
             TextChannel { server: String },
-            VoiceChannel { server: String }
+            VoiceChannel { server: String },
         }
 
         let webhooks = db
@@ -1099,7 +1225,12 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .await;
 
         for webhook in webhooks {
-            match db.col::<Channel>("channels").find_one(doc! { "_id": &webhook.channel_id }).await.unwrap() {
+            match db
+                .col::<Channel>("channels")
+                .find_one(doc! { "_id": &webhook.channel_id })
+                .await
+                .unwrap()
+            {
                 Some(channel) => {
                     let creator_id = match channel {
                         Channel::Group { owner, .. } => owner,
@@ -1141,10 +1272,51 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             "Running migration [revision 32 / 12-05-2025]: (Authifier) Add last_seen to sessions."
         );
 
-        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        db.run_migration(authifier::Migration::M2025_02_20AddLastSeenToSession)
-            .await
-            .unwrap();
+        loop {
+            #[derive(Deserialize)]
+            struct SessionId {
+                _id: String,
+            }
+
+            let sessions: Vec<SessionId> = db
+                .db()
+                .collection("sessions")
+                .find(doc! {
+                    "$or": [
+                        { "last_seen": { "$exists": false } },
+                        { "last_seen": "1970-01-01T00:00:00.000Z" }
+                    ]
+                })
+                .limit(50_000) // about 400 batches for 2 million
+                .await
+                .expect("Failed to create cursor for sessions!")
+                .map(|doc| doc.expect("id and username"))
+                .collect()
+                .await;
+
+            if sessions.is_empty() {
+                break;
+            }
+
+            for session in sessions {
+                let timestamp = iso8601_timestamp::Timestamp::from(Ulid::from_string(&session._id).unwrap().datetime());
+
+                db.db()
+                    .collection::<Document>("sessions")
+                    .update_one(
+                        doc! {
+                            "_id": &session._id.to_string(),
+                        },
+                        doc! {
+                            "$set": {
+                                "last_seen": timestamp.format().to_string()
+                            }
+                        },
+                    )
+                    .await
+                    .expect("Failed to update a session.");
+            }
+        }
     }
 
     if revision <= 40 {
@@ -1240,7 +1412,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         "channel_type": "TextChannel",
                         "voice": {}
                     }
-                }
+                },
             )
             .await
             .expect("Failed to update voice channels");
@@ -1292,10 +1464,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             let mut doc = doc! {};
 
             for id in server.roles.keys() {
-                doc.insert(
-                    format!("roles.{id}._id"),
-                    id,
-                );
+                doc.insert(format!("roles.{id}._id"), id);
             }
 
             db.db()
@@ -1306,6 +1475,21 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         }
     };
 
+    if revision <= 50 {
+        info!("Running migration [revision 50 / 13-04-2026]: Rename invites collection to account_invites");
+
+        db.db()
+            .client()
+            .database("admin")
+            .run_command(doc! {
+                "renameCollection": "revolt.invites",
+                "to": "revolt.account_invites",
+                "dropTarget": true
+            })
+            .await
+            .unwrap();
+    }
+
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION.max(revision)
 }

crates/core/database/src/models/bots/model.rs

@@ -164,7 +164,7 @@ impl Bot {
 mod tests {
     use crate::{Bot, FieldsBot, PartialBot, User};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn crud() {
         database_test!(|db| async move {
             let owner = User::create(&db, "Owner".to_string(), None, None)

crates/core/database/src/models/channel_webhooks/model.rs

@@ -128,7 +128,7 @@ impl Webhook {
 mod tests {
     use crate::{FieldsWebhook, PartialWebhook, Webhook};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn crud() {
         database_test!(|db| async move {
             let webhook_id = "webhook";

crates/core/database/src/models/channels/model.rs

@@ -1,6 +1,7 @@
 #![allow(deprecated)]
 use std::{borrow::Cow, collections::HashMap};
 
+use redis_kiss::get_connection;
 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
 use revolt_permissions::OverrideField;
@@ -110,6 +111,10 @@ auto_derived!(
             /// Voice Information for when this channel is also a voice channel
             #[serde(skip_serializing_if = "Option::is_none")]
             voice: Option<VoiceInformation>,
+
+            /// The channel's slowmode delay in seconds
+            #[serde(skip_serializing_if = "Option::is_none")]
+            slowmode: Option<u64>,
         },
     }
 
@@ -146,6 +151,8 @@ auto_derived!(
         pub last_message_id: Option<String>,
         #[serde(skip_serializing_if = "Option::is_none")]
         pub voice: Option<VoiceInformation>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub slowmode: Option<u64>,
     }
 
     /// Optional fields on channel object
@@ -154,6 +161,7 @@ auto_derived!(
         Icon,
         DefaultPermissions,
         Voice,
+        Slowmode,
     }
 );
 
@@ -206,6 +214,7 @@ impl Channel {
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
                 voice: data.voice.map(|voice| voice.into()),
+                slowmode: None,
             },
             v0::LegacyServerChannelType::Voice => Channel::TextChannel {
                 id: id.clone(),
@@ -218,6 +227,7 @@ impl Channel {
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
                 voice: Some(data.voice.unwrap_or_default().into()),
+                slowmode: None,
             },
         };
 
@@ -399,7 +409,10 @@ impl Channel {
     /// Check whether has a user as a recipient
     pub fn contains_user(&self, user_id: &str) -> bool {
         match self {
-            Channel::Group { recipients, .. } => recipients.contains(&String::from(user_id)),
+            Channel::Group { recipients, .. } | Channel::DirectMessage { recipients, .. } => {
+                recipients.iter().any(|recipient| recipient == user_id)
+            }
+            Channel::SavedMessages { user, .. } => user == user_id,
             _ => false,
         }
     }
@@ -407,7 +420,9 @@ impl Channel {
     /// Get list of recipients
     pub fn users(&self) -> Result<Vec<String>> {
         match self {
-            Channel::Group { recipients, .. } => Ok(recipients.to_owned()),
+            Channel::Group { recipients, .. } | Channel::DirectMessage { recipients, .. } => {
+                Ok(recipients.to_owned())
+            }
             _ => Err(create_error!(NotFound)),
         }
     }
@@ -540,6 +555,12 @@ impl Channel {
                 }
                 _ => {}
             },
+            FieldsChannel::Slowmode => match self {
+                Self::TextChannel { slowmode, .. } => {
+                    slowmode.take();
+                }
+                _ => {}
+            }
         }
     }
 
@@ -635,7 +656,7 @@ impl Channel {
     }
 
     /// Acknowledge a message
-    pub async fn ack(&self, user: &str, message: &str) -> Result<()> {
+    pub async fn ack(&self, user: &str, message: &str, amqp: &AMQP) -> Result<()> {
         EventV1::ChannelAck {
             id: self.id().to_string(),
             user: user.to_string(),
@@ -644,17 +665,7 @@ impl Channel {
         .private(user.to_string())
         .await;
 
-        #[cfg(feature = "tasks")]
-        crate::tasks::ack::queue_ack(
-            self.id().to_string(),
-            user.to_string(),
-            crate::tasks::ack::AckEvent::AckMessage {
-                id: message.to_string(),
-            },
-        )
-        .await;
-
-        Ok(())
+        crate::util::acker::ack_channel(user, self.id(), message, amqp).await
     }
 
     /// Remove user from a group
@@ -773,6 +784,7 @@ impl IntoDocumentPath for FieldsChannel {
             FieldsChannel::Icon => "icon",
             FieldsChannel::DefaultPermissions => "default_permissions",
             FieldsChannel::Voice => "voice",
+            FieldsChannel::Slowmode => "slowmode",
         })
     }
 }
@@ -783,7 +795,7 @@ mod tests {
 
     use crate::{fixture, util::permissions::DatabasePermissionQuery};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn permissions_group_channel() {
         database_test!(|db| async move {
             fixture!(db, "group_with_members",
@@ -809,7 +821,7 @@ mod tests {
         });
     }
 
-    #[async_std::test]
+    #[tokio::test]
     async fn permissions_text_channel() {
         database_test!(|db| async move {
             fixture!(db, "server_with_roles",

crates/core/database/src/models/channels/ops.rs

@@ -1,4 +1,4 @@
-use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
+use crate::{Channel, FieldsChannel, PartialChannel, revolt_result::Result, util::ChunkedDatabaseGenerator};
 use revolt_permissions::OverrideField;
 
 #[cfg(feature = "mongodb")]
@@ -19,6 +19,9 @@ pub trait AbstractChannels: Sync + Send {
     /// Fetch all direct messages for a user
     async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>>;
 
+    // Fetch all group dms for a user
+    async fn find_group_message_channels(&self, user_id: &str) -> Result<ChunkedDatabaseGenerator<Channel>>;
+
     // Fetch saved messages channel
     async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel>;
 
@@ -47,6 +50,9 @@ pub trait AbstractChannels: Sync + Send {
     // Remove a user from a group
     async fn remove_user_from_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
 
+    // Remove a user from all specified groups
+    async fn remove_user_from_groups(&self, channel_ids: Vec<String>, user_id: &str) -> Result<()>;
+
     // Delete a channel
     async fn delete_channel(&self, channel_id: &Channel) -> Result<()>;
 }

crates/core/database/src/models/channels/ops/mongodb.rs

@@ -1,7 +1,8 @@
 use super::AbstractChannels;
-use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
+use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel, util::ChunkedDatabaseGenerator};
 use bson::{Bson, Document};
 use futures::StreamExt;
+use mongodb::options::ReadConcern;
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
 
@@ -69,6 +70,32 @@ impl AbstractChannels for MongoDb {
         )
     }
 
+    // Fetch all group dms for a user
+    async fn find_group_message_channels(&self, user_id: &str) -> Result<ChunkedDatabaseGenerator<Channel>> {
+        let mut session = self
+            .start_session()
+            .await
+            .map_err(|_| create_database_error!("start_session", COL))?;
+
+        session
+            .start_transaction()
+            .read_concern(ReadConcern::snapshot())
+            .await
+            .map_err(|_| create_database_error!("start_transaction", COL))?;
+
+        let cursor = self.col(COL)
+            .find(doc! {
+                "channel_type": "Group",
+                "recipients": user_id
+            })
+            .session(&mut session)
+            .batch_size(100)
+            .await
+            .map_err(|_| create_database_error!("find", COL))?;
+
+        Ok(ChunkedDatabaseGenerator::new_mongo(session, cursor))
+    }
+
     // Fetch saved messages channel
     async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
         query!(
@@ -180,13 +207,29 @@ impl AbstractChannels for MongoDb {
             .map_err(|_| create_database_error!("update_one", "channels"))
     }
 
+    // Remove a user from all specified groups
+    async fn remove_user_from_groups(&self, channel_ids: Vec<String>, user_id: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_many(
+                doc! {
+                    "_id": { "$in": channel_ids },
+                },
+                doc! {
+                    "$pull": {
+                        "recipients": user_id
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", COL))
+    }
+
     // Delete a channel
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
         let id = channel.id().to_string();
         let server_id = match channel {
-            Channel::TextChannel { server, .. } => {
-                Some(server)
-            }
+            Channel::TextChannel { server, .. } => Some(server),
             _ => None,
         };
 

crates/core/database/src/models/channels/ops/reference.rs

@@ -2,6 +2,7 @@ use std::collections::hash_map::Entry;
 
 use super::AbstractChannels;
 use crate::ReferenceDb;
+use crate::util::ChunkedDatabaseGenerator;
 use crate::{Channel, FieldsChannel, PartialChannel};
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
@@ -51,6 +52,23 @@ impl AbstractChannels for ReferenceDb {
             .collect())
     }
 
+    // Fetch all group dms for a user
+    async fn find_group_message_channels(&self, user_id: &str) -> Result<ChunkedDatabaseGenerator<Channel>> {
+        let channels = self.channels.lock().await;
+        let groups = channels
+            .values()
+            .filter(|channel| match channel {
+                Channel::Group { recipients, .. } => {
+                    recipients.iter().any(|recipient| recipient == user_id)
+                }
+                _ => false,
+            })
+            .cloned()
+            .collect();
+
+        Ok(ChunkedDatabaseGenerator::new_reference(groups))
+    }
+
     // Fetch saved messages channel
     async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
         let channels = self.channels.lock().await;
@@ -131,9 +149,9 @@ impl AbstractChannels for ReferenceDb {
     // Remove a user from a group
     async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
         let mut channels = self.channels.lock().await;
-        if let Some(channel_data) = channels.get_mut(channel) {
-            if channel_data.users()?.contains(&String::from(user)) {
-                channel_data.users()?.retain(|x| x != user);
+        if let Some(Channel::Group { recipients, .. }) = channels.get_mut(channel) {
+            if let Some(index) = recipients.iter().position(|recipient| recipient == user) {
+                recipients.remove(index);
                 return Ok(());
             } else {
                 return Err(create_error!(NotFound));
@@ -142,6 +160,19 @@ impl AbstractChannels for ReferenceDb {
         Err(create_error!(NotFound))
     }
 
+    // Remove a user from all specified groups
+    async fn remove_user_from_groups(&self, channel_ids: Vec<String>, user_id: &str) -> Result<()> {
+        let mut channels = self.channels.lock().await;
+
+        for channel_id in channel_ids {
+            if let Some(Channel::Group { recipients, .. }) = channels.get_mut(&channel_id) {
+                recipients.retain(|recipient| recipient != user_id);
+            }
+        };
+
+        Ok(())
+    }
+
     // Delete a channel
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
         let mut channels = self.channels.lock().await;

crates/core/database/src/models/emojis/model.rs

@@ -2,6 +2,7 @@ use std::collections::HashSet;
 use std::str::FromStr;
 
 use once_cell::sync::Lazy;
+use revolt_models::v0;
 use revolt_result::Result;
 use ulid::Ulid;
 
@@ -11,7 +12,7 @@ use crate::Database;
 static PERMISSIBLE_EMOJIS: Lazy<HashSet<String>> = Lazy::new(|| {
     include_str!("unicode_emoji.txt")
         .split('\n')
-        .map(|x| x.into())
+        .map(|x| x.replace('\u{FE0F}', ""))
         .collect()
 });
 
@@ -41,6 +42,12 @@ auto_derived!(
         Server { id: String },
         Detached,
     }
+
+    /// Partial representation of an emoji
+    pub struct PartialEmoji {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
 );
 
 #[allow(clippy::disallowed_methods)]
@@ -75,13 +82,34 @@ impl Emoji {
         db.detach_emoji(&self).await
     }
 
+    /// Update an emoji
+    pub async fn update(&mut self, db: &Database, partial: PartialEmoji) -> Result<()> {
+        if let Some(name) = partial.name.clone() {
+            self.name = name;
+        }
+
+        db.update_emoji(&self.id, &partial).await?;
+
+        EventV1::EmojiUpdate {
+            id: self.id.clone(),
+            data: v0::PartialEmoji {
+                name: partial.name.clone(),
+            },
+        }
+        .p(self.parent().to_string())
+        .await;
+
+        Ok(())
+    }
+
     /// Check whether we can use a given emoji
     pub async fn can_use(db: &Database, emoji: &str) -> Result<bool> {
         if Ulid::from_str(emoji).is_ok() {
             db.fetch_emoji(emoji).await?;
             Ok(true)
         } else {
-            Ok(PERMISSIBLE_EMOJIS.contains(emoji))
+            let sanitized_emoji = emoji.replace('\u{FE0F}', "");
+            Ok(PERMISSIBLE_EMOJIS.contains(&sanitized_emoji))
         }
     }
 }

crates/core/database/src/models/emojis/ops.rs

@@ -1,6 +1,6 @@
 use revolt_result::Result;
 
-use crate::Emoji;
+use crate::{Emoji, PartialEmoji};
 
 #[cfg(feature = "mongodb")]
 mod mongodb;
@@ -20,6 +20,9 @@ pub trait AbstractEmojis: Sync + Send {
     /// Fetch emoji by their parent ids
     async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>>;
 
+    /// Update emoji with new information
+    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()>;
+
     /// Detach an emoji by its id
     async fn detach_emoji(&self, emoji: &Emoji) -> Result<()>;
 }

crates/core/database/src/models/emojis/ops/mongodb.rs

@@ -1,7 +1,7 @@
 use bson::Document;
 use revolt_result::Result;
 
-use crate::Emoji;
+use crate::{Emoji, PartialEmoji};
 use crate::MongoDb;
 
 use super::AbstractEmojis;
@@ -46,6 +46,11 @@ impl AbstractEmojis for MongoDb {
         )
     }
 
+    /// Update emoji with new information
+    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()> {
+        query!(self, update_one_by_id, COL, emoji_id, partial, vec![], None).map(|_| ())
+    }
+
     /// Detach an emoji by its id
     async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
         self.col::<Document>(COL)

crates/core/database/src/models/emojis/ops/reference.rs

@@ -1,6 +1,6 @@
 use revolt_result::Result;
 
-use crate::Emoji;
+use crate::{Emoji, PartialEmoji};
 use crate::EmojiParent;
 use crate::ReferenceDb;
 
@@ -54,6 +54,19 @@ impl AbstractEmojis for ReferenceDb {
             .collect())
     }
 
+    /// Update emoji with new information
+    async fn update_emoji(&self, emoji_id: &str, partial: &PartialEmoji) -> Result<()> {
+        let mut emojis = self.emojis.lock().await;
+        if let Some(emoji) = emojis.get_mut(emoji_id) {
+            if let Some(name) = partial.name.clone() {
+                emoji.name = name;
+            }
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
     /// Detach an emoji by its id
     async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
         let mut emojis = self.emojis.lock().await;

crates/core/database/src/models/file_hashes/model.rs

@@ -45,7 +45,8 @@ auto_derived!(
         Image {
             width: isize,
             height: isize,
-            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
+            thumbhash: Option<Vec<u8>>,
+            animated: Option<bool>,
         },
         /// File is a video with specific dimensions
         Video { width: isize, height: isize },

crates/core/database/src/models/file_hashes/ops.rs

@@ -17,6 +17,12 @@ pub trait AbstractAttachmentHashes: Sync + Send {
     /// Update an attachment hash nonce value.
     async fn set_attachment_hash_nonce(&self, hash: &str, nonce: &str) -> Result<()>;
 
+    /// Updates the attachments animated metadata value.
+    ///
+    /// The primary use for this is to update the metadata for existing uploaded files, this
+    /// can only be used for images.
+    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()>;
+
     /// Delete attachment hash by id.
     async fn delete_attachment_hash(&self, id: &str) -> Result<()>;
 }

crates/core/database/src/models/file_hashes/ops/mongodb.rs

@@ -48,6 +48,29 @@ impl AbstractAttachmentHashes for MongoDb {
             .map_err(|_| create_database_error!("update_one", COL))
     }
 
+    /// Updates the attachments animated metadata value.
+    ///
+    /// The primary use for this is to update the metadata for existing uploaded files, this
+    /// can only be used for images.
+    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()> {
+        self.col::<FileHash>(COL)
+            .update_one(
+                doc! {
+                    "_id": hash,
+                    "metadata.type": "Image",
+                    "metadata.animated": { "$exists": false },
+                },
+                doc! {
+                    "$set": {
+                        "metadata.animated": animated
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_one", COL))
+    }
+
     /// Delete attachment hash by id.
     async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
         query!(self, delete_one_by_id, COL, id).map(|_| ())

crates/core/database/src/models/file_hashes/ops/reference.rs

@@ -1,7 +1,6 @@
 use revolt_result::Result;
 
-use crate::FileHash;
-use crate::ReferenceDb;
+use crate::{FileHash, Metadata, ReferenceDb};
 
 use super::AbstractAttachmentHashes;
 
@@ -39,6 +38,29 @@ impl AbstractAttachmentHashes for ReferenceDb {
         }
     }
 
+    /// Updates the attachments animated metadata value.
+    ///
+    /// The primary use for this is to update the metadata for existing uploaded files, this
+    /// can only be used for images.
+    async fn set_attachment_hash_animated(&self, hash: &str, animated: bool) -> Result<()> {
+        let mut hashes = self.file_hashes.lock().await;
+        if let Some(FileHash {
+            metadata:
+                Metadata::Image {
+                    animated: Some(animated_metadata),
+                    ..
+                },
+            ..
+        }) = hashes.get_mut(hash)
+        {
+            *animated_metadata = animated;
+
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
     /// Delete attachment hash by id.
     async fn delete_attachment_hash(&self, id: &str) -> Result<()> {
         let mut file_hashes = self.file_hashes.lock().await;

crates/core/database/src/models/files/model.rs

@@ -70,6 +70,7 @@ auto_derived!(
         LegacyGroupIcon,
         ChannelIcon,
         ServerIcon,
+        RoleIcon,
     }
 
     /// Information about what the file was used for
@@ -239,4 +240,23 @@ impl File {
         )
         .await
     }
+
+    /// Use a file for a role icon
+    pub async fn use_role_icon(
+        db: &Database,
+        id: &str,
+        parent: &str,
+        uploader_id: &str,
+    ) -> Result<File> {
+        db.find_and_use_attachment(
+            id,
+            "icons",
+            FileUsedFor {
+                id: parent.to_owned(),
+                object_type: FileUsedForType::RoleIcon,
+            },
+            uploader_id.to_owned(),
+        )
+        .await
+    }
 }

crates/core/database/src/models/messages/model.rs

@@ -1,5 +1,3 @@
-use std::{collections::HashSet, hash::RandomState};
-
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
@@ -9,6 +7,8 @@ use revolt_models::v0::{
 };
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
 use revolt_result::{ErrorType, Result};
+use std::time::SystemTime;
+use std::{collections::HashSet, hash::RandomState};
 use ulid::Ulid;
 use validator::Validate;
 
@@ -388,6 +388,7 @@ impl Message {
             mut role_mentions,
             mut mentions_everyone,
             mut mentions_online,
+            ..
         } = message_mentions;
 
         if allow_mass_mentions && server_id.is_some() && !role_mentions.is_empty() {
@@ -497,7 +498,7 @@ impl Message {
                     user_mentions.retain(|m| recipients_hash.contains(m));
                     role_mentions.clear();
                 }
-                Channel::TextChannel { ref server, .. }=> {
+                Channel::TextChannel { ref server, .. } => {
                     let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());
 
                     let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
@@ -687,8 +688,13 @@ impl Message {
         )
         .await?;
 
+        let is_dm_or_group = matches!(
+            channel,
+            Channel::DirectMessage { .. } | Channel::Group { .. }
+        );
+
         if !self.has_suppressed_notifications()
-            && (self.mentions.is_some() || self.contains_mass_push_mention())
+            && (is_dm_or_group || self.mentions.is_some() || self.contains_mass_push_mention())
         {
             // send Push notifications
             #[cfg(feature = "tasks")]
@@ -699,7 +705,7 @@ impl Message {
                         Some(
                             PushNotification::from(
                                 self.clone().into_model(user, member),
-                                Some(author),
+                                Some(author.clone()),
                                 channel.to_owned().into(),
                             )
                             .await,
@@ -707,7 +713,11 @@ impl Message {
                         self.clone(),
                         match channel {
                             Channel::DirectMessage { recipients, .. }
-                            | Channel::Group { recipients, .. } => recipients.clone(),
+                            | Channel::Group { recipients, .. } => recipients
+                                .iter()
+                                .filter(|uid| *uid != author.id())
+                                .cloned()
+                                .collect(),
                             Channel::TextChannel { .. } => {
                                 self.mentions.clone().unwrap_or_default()
                             }
@@ -1029,6 +1039,31 @@ impl Message {
         Ok(())
     }
 
+    /// Bulk delete messages by an author since a given time
+    pub async fn bulk_delete_by_author_since(
+        db: &Database,
+        channels: &[String],
+        author: &str,
+        since: SystemTime,
+    ) -> Result<()> {
+        let deleted_groups = db
+            .delete_messages_by_author_since(channels, author, since)
+            .await?;
+
+        for (channel_id, message_ids) in deleted_groups {
+            if !message_ids.is_empty() {
+                EventV1::BulkMessageDelete {
+                    channel: channel_id.clone(),
+                    ids: message_ids,
+                }
+                .p(channel_id)
+                .await;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Remove a reaction from a message
     pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
         // Check if it actually exists

crates/core/database/src/models/messages/ops.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::time::SystemTime;
 use revolt_result::Result;
 
 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
@@ -40,4 +42,14 @@ pub trait AbstractMessages: Sync + Send {
 
     /// Delete messages from a channel by their ids and corresponding channel id
     async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()>;
+
+    /// Delete all messages from a specific author in a server from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime
+    ) -> Result<HashMap<String, Vec<String>>>;
+
+    async fn delete_messages_by_user(&self, user_id: &str) -> Result<()>;
 }

crates/core/database/src/models/messages/ops/mongodb.rs

@@ -1,8 +1,12 @@
 use bson::{to_bson, Document};
 use futures::try_join;
+use futures::StreamExt;
 use mongodb::options::FindOptions;
 use revolt_models::v0::MessageSort;
 use revolt_result::Result;
+use std::collections::{HashMap, HashSet};
+use std::time::SystemTime;
+use ulid::Ulid;
 
 use crate::{
     AppendMessage, DocumentId, FieldsMessage, IntoDocumentPath, Message, MessageQuery,
@@ -306,6 +310,118 @@ impl AbstractMessages for MongoDb {
             .map(|_| ())
             .map_err(|_| create_database_error!("delete_many", COL))
     }
+
+    /// Delete all messages from a specific author in a server from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime,
+    ) -> Result<HashMap<String, Vec<String>>> {
+        let threshold_ulid = Ulid::from_datetime(since).to_string();
+
+        let filter = doc! {
+            "author": author,
+            "channel": { "$in": channels },
+            "_id": { "$gte": &threshold_ulid }
+        };
+
+        let pipeline = vec![
+            doc! { "$match": filter.clone() },
+            doc! {
+                "$project": {
+                    "channel": 1_i32,
+                    "message_id": "$_id",
+                    "attachment_ids": {
+                        "$map": {
+                            "input": { "$ifNull": ["$attachments", Vec::<bson::Bson>::new()] },
+                            "as": "a",
+                            "in": "$$a._id"
+                        }
+                    }
+                }
+            },
+            doc! {
+                "$group": {
+                    "_id": "$channel",
+                    "message_ids": { "$push": "$message_id" },
+                    "attachment_ids_nested": { "$push": "$attachment_ids" }
+                }
+            },
+            doc! {
+                "$project": {
+                    "message_ids": 1_i32,
+                    "attachment_ids": {
+                        "$reduce": {
+                            "input": "$attachment_ids_nested",
+                            "initialValue": Vec::<bson::Bson>::new(),
+                            "in": { "$setUnion": ["$$value", "$$this"] }
+                        }
+                    }
+                }
+            },
+        ];
+
+        #[derive(serde::Deserialize)]
+        struct AggregatedChannel {
+            #[serde(rename = "_id")]
+            channel: String,
+            message_ids: Vec<String>,
+            #[serde(default)]
+            attachment_ids: Vec<String>,
+        }
+
+        let mut cursor = self
+            .col::<Document>(COL)
+            .aggregate(pipeline)
+            .await
+            .map_err(|_| create_database_error!("aggregate", COL))?
+            .with_type::<AggregatedChannel>();
+
+        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
+        let mut attachment_ids: HashSet<String> = HashSet::new();
+
+        while let Some(result) = cursor.next().await {
+            if let Ok(item) = result {
+                for id in item.attachment_ids {
+                    attachment_ids.insert(id);
+                }
+                deleted_messages.insert(item.channel, item.message_ids);
+            }
+        }
+
+        // Mark attachments as deleted before deleting messages
+        if !attachment_ids.is_empty() {
+            self.col::<Document>("attachments")
+                .update_many(
+                    doc! {
+                        "_id": {
+                            "$in": attachment_ids.into_iter().collect::<Vec<String>>()
+                        }
+                    },
+                    doc! {
+                        "$set": {
+                            "deleted": true
+                        }
+                    },
+                )
+                .await
+                .map_err(|_| create_database_error!("update_many", "attachments"))?;
+        }
+
+        self.col::<Document>(COL)
+            .delete_many(filter)
+            .await
+            .map_err(|_| create_database_error!("delete_many", COL))?;
+
+        Ok(deleted_messages)
+    }
+
+    async fn delete_messages_by_user(&self, user_id: &str) -> Result<()> {
+        self.delete_bulk_messages(doc! {
+            "author": user_id,
+        }).await
+    }
 }
 
 impl IntoDocumentPath for FieldsMessage {

crates/core/database/src/models/messages/ops/reference.rs

@@ -1,8 +1,13 @@
+use crate::{
+    AppendMessage, FieldsMessage, Message, MessageQuery,
+    PartialMessage, ReferenceDb,
+};
 use futures::future::try_join_all;
 use indexmap::IndexSet;
 use revolt_result::Result;
-
-use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
+use std::collections::HashMap;
+use std::time::SystemTime;
+use ulid::Ulid;
 
 use super::AbstractMessages;
 
@@ -58,7 +63,7 @@ impl AbstractMessages for ReferenceDb {
 
                 if let Some(pinned) = query.filter.pinned {
                     if message.pinned.unwrap_or_default() == pinned {
-                        return false
+                        return false;
                     }
                 }
 
@@ -189,7 +194,12 @@ impl AbstractMessages for ReferenceDb {
     }
 
     /// Update a given message with new information
-    async fn update_message(&self, id: &str, message: &PartialMessage, remove: Vec<FieldsMessage>) -> Result<()> {
+    async fn update_message(
+        &self,
+        id: &str,
+        message: &PartialMessage,
+        remove: Vec<FieldsMessage>,
+    ) -> Result<()> {
         let mut messages = self.messages.lock().await;
         if let Some(message_data) = messages.get_mut(id) {
             message_data.apply_options(message.to_owned());
@@ -247,7 +257,7 @@ impl AbstractMessages for ReferenceDb {
         let mut messages = self.messages.lock().await;
         if let Some(message) = messages.get_mut(id) {
             if let Some(users) = message.reactions.get_mut(emoji) {
-                users.remove(&user.to_string());
+                users.swap_remove(&user.to_string());
             }
 
             Ok(())
@@ -260,7 +270,7 @@ impl AbstractMessages for ReferenceDb {
     async fn clear_reaction(&self, id: &str, emoji: &str) -> Result<()> {
         let mut messages = self.messages.lock().await;
         if let Some(message) = messages.get_mut(id) {
-            message.reactions.remove(emoji);
+            message.reactions.swap_remove(emoji);
             Ok(())
         } else {
             Err(create_error!(NotFound))
@@ -286,4 +296,70 @@ impl AbstractMessages for ReferenceDb {
 
         Ok(())
     }
+
+    /// Delete all messages from a specific author in a list of channels from a certain ULID onwards
+    async fn delete_messages_by_author_since(
+        &self,
+        channels: &[String],
+        author: &str,
+        since: SystemTime,
+    ) -> Result<HashMap<String, Vec<String>>> {
+        let threshold_ulid = Ulid::from_datetime(since).to_string();
+        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
+        let mut attachment_ids: Vec<String> = Vec::new();
+
+        let messages = self.messages.lock().await;
+
+        // First pass: collect attachment IDs and message IDs to delete
+        for (id, message) in messages.iter() {
+            let should_delete = message.author == author
+                && channels.contains(&message.channel)
+                && id.as_str() >= threshold_ulid.as_str();
+
+            if should_delete {
+                // Collect attachment IDs
+                if let Some(attachments) = &message.attachments {
+                    for attachment in attachments {
+                        attachment_ids.push(attachment.id.clone());
+                    }
+                }
+
+                deleted_messages
+                    .entry(message.channel.clone())
+                    .or_default()
+                    .push(id.clone());
+            }
+        }
+        drop(messages);
+
+        // Mark attachments as deleted
+        if !attachment_ids.is_empty() {
+            let mut files = self.files.lock().await;
+            for attachment_id in attachment_ids {
+                if let Some(file) = files.get_mut(&attachment_id) {
+                    file.deleted = Some(true);
+                }
+            }
+        }
+
+        // Delete the messages
+        self.messages.lock().await.retain(|id, message| {
+            let should_keep = !(message.author == author
+                && channels.contains(&message.channel)
+                && id.as_str() >= threshold_ulid.as_str());
+            should_keep
+        });
+
+        Ok(deleted_messages)
+    }
+
+    async fn delete_messages_by_user(&self, user_id: &str) -> Result<()> {
+        let mut messages = self.messages.lock().await;
+
+        messages.retain(|_, message| message.author != user_id);
+
+        // TODO: remove attachments as well
+
+        Ok(())
+    }
 }

crates/core/database/src/models/mfa_tickets/axum.rs

@@ -0,0 +1,67 @@
+use axum::{
+    extract::{FromRef, FromRequestParts},
+    http::request::Parts,
+};
+
+use revolt_result::{Error, Result};
+
+use crate::{Database, MFATicket, UnvalidatedTicket, ValidatedTicket};
+
+#[async_trait]
+impl<S> FromRequestParts<S> for MFATicket
+where
+    Database: FromRef<S>,
+    S: Send + Sync,
+{
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
+        let db = Database::from_ref(state);
+
+        if let Some(Ok(token)) = parts.headers.get("x-mfa-ticket").map(|v| v.to_str()) {
+            db.fetch_ticket_by_token(token).await
+        } else {
+            Err(create_error!(MissingHeaders))
+        }
+    }
+}
+
+#[async_trait]
+impl<S> FromRequestParts<S> for ValidatedTicket
+where
+    Database: FromRef<S>,
+    S: Send + Sync,
+{
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
+        let db = Database::from_ref(state);
+
+        let ticket = MFATicket::from_request_parts(parts, state).await?;
+
+        if ticket.validated && ticket.claim(&db).await.is_ok() {
+            Ok(ValidatedTicket(ticket))
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+}
+
+#[async_trait]
+impl<S> FromRequestParts<S> for UnvalidatedTicket
+where
+    Database: FromRef<S>,
+    S: Send + Sync,
+{
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
+        let ticket = MFATicket::from_request_parts(parts, state).await?;
+
+        if !ticket.validated {
+            Ok(UnvalidatedTicket(ticket))
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+}

crates/core/database/src/models/mfa_tickets/mod.rs

@@ -0,0 +1,11 @@
+#[cfg(feature = "axum-impl")]
+mod axum;
+mod model;
+mod ops;
+#[cfg(feature = "rocket-impl")]
+mod rocket;
+#[cfg(feature = "rocket-impl")]
+mod schema;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/mfa_tickets/model.rs

@@ -0,0 +1,105 @@
+use iso8601_timestamp::{Duration, Timestamp};
+use std::ops::Deref;
+
+use nanoid::nanoid;
+use revolt_result::Result;
+
+use crate::{Database, MultiFactorAuthentication};
+
+auto_derived_partial!(
+    /// Multi-factor auth ticket
+    pub struct MFATicket {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// Account Id
+        pub account_id: String,
+
+        /// Unique Token
+        pub token: String,
+
+        /// Whether this ticket has been validated
+        /// (can be used for account actions)
+        pub validated: bool,
+
+        /// Whether this ticket is authorised
+        /// (can be used to log a user in)
+        pub authorised: bool,
+
+        /// TOTP code at time of ticket creation
+        pub last_totp_code: Option<String>,
+    },
+    "PartialMFATicket"
+);
+
+/// Ticket which is guaranteed to be valid for use
+///
+/// If used in a Rocket guard, it will be consumed on match
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ValidatedTicket(pub MFATicket);
+
+/// Ticket which is guaranteed to not be valid for use
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UnvalidatedTicket(pub MFATicket);
+
+impl MFATicket {
+    /// Create a new MFA ticket
+    pub fn new(account_id: String, validated: bool) -> MFATicket {
+        MFATicket {
+            id: ulid::Ulid::new().to_string(),
+            account_id,
+            token: nanoid!(64),
+            validated,
+            authorised: false,
+            last_totp_code: None,
+        }
+    }
+
+    /// Populate an MFA ticket with valid MFA codes
+    pub async fn populate(&mut self, mfa: &MultiFactorAuthentication) {
+        self.last_totp_code = mfa.totp_token.generate_code().ok();
+    }
+
+    /// Save model
+    pub async fn save(&self, db: &Database) -> Result<()> {
+        db.save_ticket(self).await
+    }
+
+    /// Check if this MFA ticket has expired
+    pub fn is_expired(&self) -> bool {
+        let now = Timestamp::now_utc();
+
+        let datetime: Timestamp = ulid::Ulid::from_string(&self.id)
+            .expect("Valid `ulid`")
+            .datetime()
+            .into();
+
+        now > (datetime.checked_add(Duration::minutes(5)).unwrap())
+    }
+
+    /// Claim and remove this MFA ticket
+    pub async fn claim(&self, db: &Database) -> Result<()> {
+        if self.is_expired() {
+            return Err(create_error!(InvalidToken));
+        }
+
+        db.delete_ticket(&self.id).await
+    }
+}
+
+impl Deref for ValidatedTicket {
+    type Target = MFATicket;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Deref for UnvalidatedTicket {
+    type Target = MFATicket;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

crates/core/database/src/models/mfa_tickets/ops.rs

@@ -0,0 +1,22 @@
+use revolt_result::Result;
+
+use crate::MFATicket;
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractMFATickets: Sync + Send {
+    /// Find ticket by token
+    async fn fetch_ticket_by_token(&self, token: &str) -> Result<MFATicket>;
+
+    /// Save ticket
+    async fn save_ticket(&self, ticket: &MFATicket) -> Result<()>;
+
+    /// Delete ticket
+    async fn delete_ticket(&self, id: &str) -> Result<()>;
+
+    /// Delete all expired tickets
+    async fn delete_expired_tickets(&self) -> Result<usize>;
+}

crates/core/database/src/models/mfa_tickets/ops/mongodb.rs

@@ -0,0 +1,67 @@
+use std::time::{Duration, SystemTime};
+
+use crate::{AbstractMFATickets, MFATicket, MongoDb};
+use bson::{to_document, Document};
+use iso8601_timestamp::Timestamp;
+use mongodb::options::UpdateOptions;
+use revolt_result::Result;
+use ulid::Ulid;
+
+const COL: &str = "mfa_tickets";
+
+#[async_trait]
+impl AbstractMFATickets for MongoDb {
+    /// Find ticket by token
+    ///
+    /// Ticket is only valid for 5 minute
+    async fn fetch_ticket_by_token(&self, token: &str) -> Result<MFATicket> {
+        let ticket: MFATicket = query!(self, find_one, COL, doc! { "token": token })?
+            .ok_or_else(|| create_error!(InvalidToken))?;
+
+        if let Ok(ulid) = Ulid::from_string(&ticket.id) {
+            if Timestamp::from(ulid.datetime() + Duration::from_mins(5)) > Timestamp::now_utc() {
+                Ok(ticket)
+            } else {
+                Err(create_error!(InvalidToken))
+            }
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+
+    /// Save ticket
+    async fn save_ticket(&self, ticket: &MFATicket) -> Result<()> {
+        self.col::<MFATicket>(COL)
+            .update_one(
+                doc! {
+                    "_id": &ticket.id
+                },
+                doc! {
+                    "$set": to_document(ticket).map_err(|_| create_database_error!("to_document", COL))?,
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map_err(|_| create_database_error!("upsert_one", COL))
+            .map(|_| ())
+    }
+
+    /// Delete ticket
+    async fn delete_ticket(&self, id: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, id).map(|_| ())
+    }
+
+    /// Delete all expired tickets
+    async fn delete_expired_tickets(&self) -> Result<usize> {
+        let threshhold =
+            Ulid::from_datetime(SystemTime::now() - Duration::from_mins(5)).to_string();
+
+        self.col::<Document>(COL)
+            .delete_many(doc! {
+                "_id": { "$lt": threshhold }
+            })
+            .await
+            .map_err(|_| create_database_error!("delete_many", COL))
+            .map(|result| result.deleted_count as usize)
+    }
+}

crates/core/database/src/models/mfa_tickets/ops/reference.rs

@@ -0,0 +1,57 @@
+use std::time::{Duration, SystemTime};
+
+use crate::{AbstractMFATickets, MFATicket, ReferenceDb};
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+use ulid::Ulid;
+
+#[async_trait]
+impl AbstractMFATickets for ReferenceDb {
+    /// Find ticket by token
+    async fn fetch_ticket_by_token(&self, token: &str) -> Result<MFATicket> {
+        let tickets = self.tickets.lock().await;
+        let ticket = tickets
+            .values()
+            .find(|ticket| ticket.token == token)
+            .ok_or_else(|| create_error!(InvalidToken))?;
+
+        if let Ok(ulid) = Ulid::from_string(&ticket.id) {
+            if Timestamp::from(ulid.datetime() + Duration::from_mins(5)) > Timestamp::now_utc() {
+                Ok(ticket.clone())
+            } else {
+                Err(create_error!(InvalidToken))
+            }
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+
+    /// Save ticket
+    async fn save_ticket(&self, ticket: &MFATicket) -> Result<()> {
+        let mut tickets = self.tickets.lock().await;
+        tickets.insert(ticket.id.to_string(), ticket.clone());
+        Ok(())
+    }
+
+    /// Delete ticket
+    async fn delete_ticket(&self, id: &str) -> Result<()> {
+        let mut tickets = self.tickets.lock().await;
+        if tickets.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+
+    /// Delete all expired tickets
+    async fn delete_expired_tickets(&self) -> Result<usize> {
+        let threshhold =
+            Ulid::from_datetime(SystemTime::now() - Duration::from_mins(5)).to_string();
+        let mut tickets = self.tickets.lock().await;
+
+        let before = tickets.len();
+        tickets.retain(|_, ticket| ticket.id >= threshhold);
+
+        Ok(before - tickets.len())
+    }
+}