docs: WIP: Adjust suggested value ranges to Timo's suggestion and when to change them

Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>
docs: WIP: Added some suggested range for numeric values
2021-09-15 12:45:13 +02:00 · 2021-09-15 12:38:17 +02:00 · 2021-09-15 12:21:43 +02:00 · 2021-09-15 11:16:19 +02:00 · 2021-09-15 11:16:19 +02:00 · 2021-09-15 11:16:18 +02:00
71 changed files with 1875 additions and 1836 deletions
@@ -14,8 +14,6 @@ docker-compose*
 # Git folder
 .git
 .gitea
-.gitlab
-.github

 # Dot files
 .env
@@ -3,12 +3,14 @@ stages:
  - build docker image
  - test
  - upload artifacts
+  - publish

 variables:
  GIT_SUBMODULE_STRATEGY: recursive
  FF_USE_FASTZIP: 1
  CACHE_COMPRESSION_LEVEL: fastest

+
 # --------------------------------------------------------------------- #
 #  Cargo: Compiling for different architectures                         #
 # --------------------------------------------------------------------- #
@@ -19,7 +21,7 @@ variables:
  rules:
    - if: '$CI_COMMIT_BRANCH == "master"'
    - if: '$CI_COMMIT_BRANCH == "next"'
-    - if: "$CI_COMMIT_TAG"
+    - if: '$CI_COMMIT_TAG'
  interruptible: true
  image: "rust:latest"
  tags: ["docker"]
@@ -27,209 +29,257 @@ variables:
    paths:
      - cargohome
      - target/
-    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH--release"
+    key: "build_cache-$TARGET-release"
  variables:
-    CARGO_PROFILE_RELEASE_LTO: "true"
-    CARGO_PROFILE_RELEASE_CODEGEN_UNITS: "1"
+    CARGO_PROFILE_RELEASE_LTO=true
+    CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
  before_script:
    - 'echo "Building for target $TARGET"'
    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
-    - "rustc --version && cargo --version && rustup show" # Print version info for debugging
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - 'apt-get update -yqq'
+    - 'echo "Installing packages: $NEEDED_PACKAGES"'
+    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
    - "rustup target add $TARGET"
  script:
    - time cargo build --target $TARGET --release
-    - 'cp "target/$TARGET/release/conduit" "conduit-$TARGET"'
+    - 'mv "target/$TARGET/release/conduit" "conduit-$TARGET"'
  artifacts:
    expire_in: never

-build:release:cargo:x86_64-unknown-linux-musl-with-debug:
+
+build:release:cargo:x86_64-unknown-linux-gnu:
  extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:x86_64-musl
  variables:
-    CARGO_PROFILE_RELEASE_DEBUG: 2 # Enable debug info for flamegraph profiling
-    TARGET: "x86_64-unknown-linux-musl"
-  after_script:
-    - "mv ./conduit-x86_64-unknown-linux-musl ./conduit-x86_64-unknown-linux-musl-with-debug"
+    TARGET: "x86_64-unknown-linux-gnu"
  artifacts:
-    name: "conduit-x86_64-unknown-linux-musl-with-debug"
+    name: "conduit-x86_64-unknown-linux-gnu"
    paths:
-      - "conduit-x86_64-unknown-linux-musl-with-debug"
-    expose_as: "Conduit for x86_64-unknown-linux-musl-with-debug"
+      - "conduit-x86_64-unknown-linux-gnu"
+    expose_as: "Conduit for x86_64-unknown-linux-gnu"
+
+build:release:cargo:armv7-unknown-linux-gnueabihf:
+  extends: .build-cargo-shared-settings
+  variables:
+    TARGET: "armv7-unknown-linux-gnueabihf"
+    NEEDED_PACKAGES: "build-essential gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf libc6-dev-armhf-cross"
+    CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER: arm-linux-gnueabihf-gcc
+    CC_armv7_unknown_linux_gnueabihf: arm-linux-gnueabihf-gcc
+    CXX_armv7_unknown_linux_gnueabihf: arm-linux-gnueabihf-g++
+  artifacts:
+    name: "conduit-armv7-unknown-linux-gnueabihf"
+    paths:
+      - "conduit-armv7-unknown-linux-gnueabihf"
+    expose_as: "Conduit for armv7-unknown-linux-gnueabihf"
+
+build:release:cargo:aarch64-unknown-linux-gnu:
+  extends: .build-cargo-shared-settings
+  variables:
+    TARGET: "aarch64-unknown-linux-gnu"
+    NEEDED_PACKAGES: "build-essential gcc-8-aarch64-linux-gnu g++-aarch64-linux-gnu libc6-dev-arm64-cross"
+    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+    CC_aarch64_unknown_linux_gnu: aarch64-linux-gnu-gcc
+    CXX_aarch64_unknown_linux_gnu: aarch64-linux-gnu-g++
+    TARGET_CC: "/usr/bin/aarch64-linux-gnu-gcc-8"
+    TARGET_AR: "/usr/bin/aarch64-linux-gnu-gcc-ar-8"
+  artifacts:
+    name: "conduit-aarch64-unknown-linux-gnu"
+    paths:
+      - "conduit-aarch64-unknown-linux-gnu"
+    expose_as: "Conduit for aarch64-unknown-linux-gnu"

 build:release:cargo:x86_64-unknown-linux-musl:
  extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:x86_64-musl
+  image: "rust:alpine"
  variables:
    TARGET: "x86_64-unknown-linux-musl"
+  before_script:
+    - 'echo "Building for target $TARGET"'
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - "rustup target add $TARGET"
+    - "apk add libc-dev"
  artifacts:
    name: "conduit-x86_64-unknown-linux-musl"
    paths:
      - "conduit-x86_64-unknown-linux-musl"
    expose_as: "Conduit for x86_64-unknown-linux-musl"

-build:release:cargo:arm-unknown-linux-musleabihf:
-  extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:arm-musleabihf
-  variables:
-    TARGET: "arm-unknown-linux-musleabihf"
-  artifacts:
-    name: "conduit-arm-unknown-linux-musleabihf"
-    paths:
-      - "conduit-arm-unknown-linux-musleabihf"
-    expose_as: "Conduit for arm-unknown-linux-musleabihf"

-build:release:cargo:armv7-unknown-linux-musleabihf:
-  extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:armv7-musleabihf
-  variables:
-    TARGET: "armv7-unknown-linux-musleabihf"
-  artifacts:
-    name: "conduit-armv7-unknown-linux-musleabihf"
-    paths:
-      - "conduit-armv7-unknown-linux-musleabihf"
-    expose_as: "Conduit for armv7-unknown-linux-musleabihf"
-
-build:release:cargo:aarch64-unknown-linux-musl:
-  extends: .build-cargo-shared-settings
-  image: messense/rust-musl-cross:aarch64-musl
-  variables:
-    TARGET: "aarch64-unknown-linux-musl"
-  artifacts:
-    name: "conduit-aarch64-unknown-linux-musl"
-    paths:
-      - "conduit-aarch64-unknown-linux-musl"
-    expose_as: "Conduit for aarch64-unknown-linux-musl"

 .cargo-debug-shared-settings:
  extends: ".build-cargo-shared-settings"
  rules:
-    - if: '$CI_COMMIT_BRANCH != "master"'
+    - if: '$CI_COMMIT_BRANCH'
+    - if: '$CI_COMMIT_TAG'
  cache:
-    key: "build_cache--$TARGET--$CI_COMMIT_BRANCH--debug"
+    key: "build_cache-$TARGET-debug"
  script:
    - "time cargo build --target $TARGET"
    - 'mv "target/$TARGET/debug/conduit" "conduit-debug-$TARGET"'
  artifacts:
    expire_in: 4 weeks

+build:debug:cargo:x86_64-unknown-linux-gnu:
+  extends: ".cargo-debug-shared-settings"
+  variables:
+    TARGET: "x86_64-unknown-linux-gnu"
+  artifacts:
+    name: "conduit-debug-x86_64-unknown-linux-gnu"
+    paths:
+      - "conduit-debug-x86_64-unknown-linux-gnu"
+    expose_as: "Conduit DEBUG for x86_64-unknown-linux-gnu"
+
 build:debug:cargo:x86_64-unknown-linux-musl:
  extends: ".cargo-debug-shared-settings"
-  image: messense/rust-musl-cross:x86_64-musl
+  image: "rust:alpine"
  variables:
    TARGET: "x86_64-unknown-linux-musl"
+  before_script:
+    - 'echo "Building for target $TARGET"'
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - "rustup target add $TARGET"
+    - "apk add libc-dev"
  artifacts:
    name: "conduit-debug-x86_64-unknown-linux-musl"
    paths:
      - "conduit-debug-x86_64-unknown-linux-musl"
    expose_as: "Conduit DEBUG for x86_64-unknown-linux-musl"

+
+
+# --------------------------------------------------------------------- #
+#  Cargo: Compiling deb packages for different architectures            #
+# --------------------------------------------------------------------- #
+
+
+.build-cargo-deb-shared-settings:
+  stage: "build"
+  needs: [ ]
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "master"'
+    - if: '$CI_COMMIT_BRANCH == "next"'
+    - if: '$CI_COMMIT_TAG'
+  interruptible: true
+  image: "rust:latest"
+  tags: ["docker"]
+  cache:
+    paths:
+      - cargohome
+      - target/
+    key: "build_cache-deb-$TARGET"
+  before_script:
+    - 'echo "Building debian package for target $TARGET"'
+    - 'mkdir -p cargohome && CARGOHOME="cargohome"'
+    - "cat /etc/*-release && rustc --version && cargo --version"  # Print version info for debugging
+    - 'apt-get update -yqq'
+    - 'echo "Installing packages: $NEEDED_PACKAGES"'
+    - "apt-get install -yqq --no-install-recommends $NEEDED_PACKAGES"
+    - "rustup target add $TARGET"
+    - "cargo install cargo-deb"
+  script:
+    - time cargo deb --target $TARGET
+    - 'mv target/$TARGET/debian/*.deb "conduit-$TARGET.deb"'
+
+build:cargo-deb:x86_64-unknown-linux-gnu:
+  extends: .build-cargo-deb-shared-settings
+  variables:
+    TARGET: "x86_64-unknown-linux-gnu"
+    NEEDED_PACKAGES: ""
+  artifacts:
+    name: "conduit-x86_64-unknown-linux-gnu.deb"
+    paths:
+      - "conduit-x86_64-unknown-linux-gnu.deb"
+    expose_as: "Debian Package x86_64"
+
+
 # --------------------------------------------------------------------- #
 #  Create and publish docker image                                      #
 # --------------------------------------------------------------------- #

+# Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
 .docker-shared-settings:
  stage: "build docker image"
-  image: jdrouet/docker-with-buildx:stable
+  needs: []
+  interruptible: true
+  image:
+    name: "gcr.io/kaniko-project/executor:debug"
+    entrypoint: [""]
  tags: ["docker"]
-  services:
-    - docker:dind
-  needs:
-    - "build:release:cargo:x86_64-unknown-linux-musl"
-    - "build:release:cargo:arm-unknown-linux-musleabihf"
-    - "build:release:cargo:armv7-unknown-linux-musleabihf"
-    - "build:release:cargo:aarch64-unknown-linux-musl"
  variables:
-    DOCKER_HOST: tcp://docker:2375/
-    DOCKER_TLS_CERTDIR: ""
-    DOCKER_DRIVER: overlay2
-    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64/v8,linux/amd64"
-    DOCKER_FILE: "docker/ci-binaries-packaging.Dockerfile"
+    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
+    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
  before_script:
-    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
-    # Only log in to Dockerhub if the credentials are given:
-    - if [ -n "${DOCKER_HUB}" ]; then docker login -u "$DOCKER_HUB_USER" -p "$DOCKER_HUB_PASSWORD" "$DOCKER_HUB"; fi
-  script:
-    # Prepare buildx to build multiarch stuff:
-    - docker context create 'ci-context'
-    - docker buildx create --name 'multiarch-builder' --use 'ci-context'
-    # Copy binaries to their docker arch path
-    - mkdir -p linux/ && mv ./conduit-x86_64-unknown-linux-musl linux/amd64
-    - mkdir -p linux/arm/ && mv ./conduit-arm-unknown-linux-musleabihf linux/arm/v6
-    - mkdir -p linux/arm/ && mv ./conduit-armv7-unknown-linux-musleabihf linux/arm/v7
-    - mkdir -p linux/arm64/ && mv ./conduit-aarch64-unknown-linux-musl linux/arm64/v8
-    # Actually create multiarch image:
-    - >
-      docker buildx build
-      --pull
-      --push
-      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
-      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
-      --platform "$PLATFORMS"
-      --tag "$GL_IMAGE_TAG"
-      --tag "$GL_IMAGE_TAG-commit-$CI_COMMIT_SHORT_SHA"
-      --file "$DOCKER_FILE" .
-    # Only try to push to docker hub, if auth data for dockerhub exists:
-    - if [ -n "${DOCKER_HUB}" ]; then docker push "$DH_IMAGE_TAG"; fi
-    - if [ -n "${DOCKER_HUB}" ]; then docker push "$DH_IMAGE_TAG-commit-$CI_COMMIT_SHORT_SHA"; fi
+    - "mkdir -p /kaniko/.docker"
+    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
+

 build:docker:next:
  extends: .docker-shared-settings
+  needs:
+    - "build:release:cargo:x86_64-unknown-linux-musl"
+  script:
+    - >
+      /kaniko/executor
+      $KANIKO_CACHE_ARGS
+      --context $CI_PROJECT_DIR
+      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
+      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:next"
+      --destination "$CI_REGISTRY_IMAGE/conduit:next-alpine"
+      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
  rules:
    - if: '$CI_COMMIT_BRANCH == "next"'
-  variables:
-    GL_IMAGE_TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:next"
-    DH_IMAGE_TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
+

 build:docker:master:
  extends: .docker-shared-settings
+  needs:
+    - "build:release:cargo:x86_64-unknown-linux-musl"
+  script:
+    - >
+      /kaniko/executor
+      $KANIKO_CACHE_ARGS
+      --context $CI_PROJECT_DIR
+      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
+      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:latest"
+      --destination "$CI_REGISTRY_IMAGE/conduit:latest-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest-alpine"
  rules:
    - if: '$CI_COMMIT_BRANCH == "master"'
-  variables:
-    GL_IMAGE_TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:latest"
-    DH_IMAGE_TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"

-## Build a docker image by packaging up the x86_64-unknown-linux-musl binary into an alpine image
-#.docker-shared-settings:
-#  stage: "build docker image"
-#  needs: []
-#  interruptible: true
-#  image:
-#    name: "gcr.io/kaniko-project/executor:debug"
-#    entrypoint: [""]
-#  tags: ["docker"]
-#  variables:
-#    # Configure Kaniko Caching: https://cloud.google.com/build/docs/kaniko-cache
-#    KANIKO_CACHE_ARGS: "--cache=true --cache-copy-layers=true --cache-ttl=120h --cache-repo $CI_REGISTRY_IMAGE/kaniko-ci-cache"
-#  before_script:
-#    - "mkdir -p /kaniko/.docker"
-#    - 'echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"},\"$DOCKER_HUB\":{\"username\":\"$DOCKER_HUB_USER\",\"password\":\"$DOCKER_HUB_PASSWORD\"}}}" > /kaniko/.docker/config.json'
-#
-#
-#build:docker:next:
-#  extends: .docker-shared-settings
-#  needs:
-#    - "build:release:cargo:x86_64-unknown-linux-musl"
-#  script:
-#    - >
-#      /kaniko/executor
-#      $KANIKO_CACHE_ARGS
-#      --force
-#      --context $CI_PROJECT_DIR
-#      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-#      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
-#      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
-#      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
-#      --destination "$CI_REGISTRY_IMAGE/conduit:next"
-#      --destination "$CI_REGISTRY_IMAGE/conduit:next-alpine"
-#      --destination "$CI_REGISTRY_IMAGE/conduit:commit-$CI_COMMIT_SHORT_SHA"
-#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
-#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next-alpine"
-#      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:commit-$CI_COMMIT_SHORT_SHA"
-#  rules:
-#    - if: '$CI_COMMIT_BRANCH == "next"'
-#
-#
+
+build:docker:tags:
+  extends: .docker-shared-settings
+  needs:
+    - "build:release:cargo:x86_64-unknown-linux-musl"
+  script:
+    - >
+      /kaniko/executor
+      $KANIKO_CACHE_ARGS
+      --context $CI_PROJECT_DIR
+      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+      --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
+      --build-arg "GIT_REF=$CI_COMMIT_SHORT_SHA"
+      --dockerfile "$CI_PROJECT_DIR/docker/ci-binaries-packaging.Dockerfile"
+      --destination "$CI_REGISTRY_IMAGE/conduit:$CI_COMMIT_TAG"
+      --destination "$CI_REGISTRY_IMAGE/conduit:$CI_COMMIT_TAG-alpine"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:$CI_COMMIT_TAG"
+      --destination "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:$CI_COMMIT_TAG-alpine"
+  rules:
+    - if: '$CI_COMMIT_TAG'
+
+

 # --------------------------------------------------------------------- #
 #  Run tests                                                            #
@@ -251,20 +301,13 @@ test:cargo:
  before_script:
    - mkdir -p $CARGO_HOME && echo "using $CARGO_HOME to cache cargo deps"
    - apt-get update -yqq
-    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config wget
+    - apt-get install -yqq --no-install-recommends build-essential libssl-dev pkg-config
    - rustup component add clippy rustfmt
-    - wget "https://faulty-storage.de/gitlab-report"
-    - chmod +x ./gitlab-report
  script:
    - rustc --version && cargo --version  # Print version info for debugging
    - cargo fmt --all -- --check
-    - "cargo test --color always --workspace --verbose --locked --no-fail-fast -- -Z unstable-options --format json | ./gitlab-report -p test > $CI_PROJECT_DIR/report.xml"
-    - "cargo clippy --color always --verbose --message-format=json | ./gitlab-report -p clippy > $CI_PROJECT_DIR/gl-code-quality-report.json"
-  artifacts:
-    when: always
-    reports:
-      junit: report.xml
-      codequality: gl-code-quality-report.json
+    - cargo test --workspace --verbose --locked
+    - cargo clippy

 test:sytest:
  stage: "test"
@@ -287,7 +330,7 @@ test:sytest:
  script:
    - "SYTEST_EXIT_CODE=0"
    - "/bootstrap.sh conduit || SYTEST_EXIT_CODE=1"
-    - 'perl /sytest/tap-to-junit-xml.pl --puretap --input /logs/results.tap --output $CI_PROJECT_DIR/sytest.xml "Sytest" && cp /logs/results.tap $CI_PROJECT_DIR/results.tap'
+    - "perl /sytest/tap-to-junit-xml.pl --puretap --input /logs/results.tap --output $CI_PROJECT_DIR/sytest.xml \"Sytest\" && cp /logs/results.tap $CI_PROJECT_DIR/results.tap"
    - "exit $SYTEST_EXIT_CODE"
  artifacts:
    when: always
@@ -297,6 +340,7 @@ test:sytest:
    reports:
      junit: "$CI_PROJECT_DIR/sytest.xml"

+
 # --------------------------------------------------------------------- #
 #  Store binaries as package so they have download urls                 #
 # --------------------------------------------------------------------- #
@@ -304,31 +348,39 @@ test:sytest:
 publish:package:
  stage: "upload artifacts"
  needs:
+    - "build:release:cargo:x86_64-unknown-linux-gnu"
+    - "build:release:cargo:armv7-unknown-linux-gnueabihf"
+    - "build:release:cargo:aarch64-unknown-linux-gnu"
    - "build:release:cargo:x86_64-unknown-linux-musl"
-    - "build:release:cargo:arm-unknown-linux-musleabihf"
-    - "build:release:cargo:armv7-unknown-linux-musleabihf"
-    - "build:release:cargo:aarch64-unknown-linux-musl"
-  #    - "build:cargo-deb:x86_64-unknown-linux-gnu"
+    - "build:cargo-deb:x86_64-unknown-linux-gnu"
  rules:
    - if: '$CI_COMMIT_BRANCH == "master"'
    - if: '$CI_COMMIT_BRANCH == "next"'
-    - if: "$CI_COMMIT_TAG"
+    - if: '$CI_COMMIT_TAG'
  image: curlimages/curl:latest
  tags: ["docker"]
  variables:
    GIT_STRATEGY: "none" # Don't need a clean copy of the code, we just operate on artifacts
  script:
    - 'BASE_URL="${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/conduit-${CI_COMMIT_REF_SLUG}/build-${CI_PIPELINE_ID}"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu "${BASE_URL}/conduit-x86_64-unknown-linux-gnu"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-gnueabihf "${BASE_URL}/conduit-armv7-unknown-linux-gnueabihf"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-gnu "${BASE_URL}/conduit-aarch64-unknown-linux-gnu"'
    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-musl "${BASE_URL}/conduit-x86_64-unknown-linux-musl"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-arm-unknown-linux-musleabihf "${BASE_URL}/conduit-arm-unknown-linux-musleabihf"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-armv7-unknown-linux-musleabihf "${BASE_URL}/conduit-armv7-unknown-linux-musleabihf"'
-    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-aarch64-unknown-linux-musl "${BASE_URL}/conduit-aarch64-unknown-linux-musl"'
+    - 'curl --header "JOB-TOKEN: $CI_JOB_TOKEN" --upload-file conduit-x86_64-unknown-linux-gnu.deb "${BASE_URL}/conduit-x86_64-unknown-linux-gnu.deb"'

-# Avoid duplicate pipelines
-# See: https://docs.gitlab.com/ee/ci/yaml/workflow.html#switch-between-branch-pipelines-and-merge-request-pipelines
-workflow:
+
+pages:
+  stage: "publish"
+  image:
+    name: "squidfunk/mkdocs-material"
+    entrypoint: [""]
+  tags: ["docker"]
+  needs: []
  rules:
-    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
-    - if: "$CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS"
-      when: never
-    - if: "$CI_COMMIT_BRANCH"
+    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
+  script:
+    - "mkdocs build --site-dir public"
+  artifacts:
+    paths:
+      - "public"
@@ -1,86 +0,0 @@
-# Setting up Appservices
-
-## Getting help
-
-If you run into any problems while setting up an Appservice, write an email to `timo@koesters.xyz`, ask us in `#conduit:matrix.org` or [open an issue on GitLab](https://gitlab.com/famedly/conduit/-/issues/new).
-
-## Set up the appservice - general instructions
-
-Follow whatever instructions are given by the appservice. This usually includes
-downloading, changing its config (setting domain, homeserver url, port etc.)
-and later starting it.
-
-At some point the appservice guide should ask you to add a registration yaml
-file to the homeserver. In Synapse you would do this by adding the path to the
-homeserver.yaml, but in Conduit you can do this from within Matrix:
-
-First, go into the #admins room of your homeserver. The first person that
-registered on the homeserver automatically joins it. Then send a message into
-the room like this:
-
-    @conduit:your.server.name: register_appservice
-    ```
-    paste
-    the
-    contents
-    of
-    the
-    yaml
-    registration
-    here
-    ```
-
-You can confirm it worked by sending a message like this:
-`@conduit:your.server.name: list_appservices`
-
-The @conduit bot should answer with `Appservices (1): your-bridge`
-
-Then you are done. Conduit will send messages to the appservices and the
-appservice can send requests to the homeserver. You don't need to restart
-Conduit, but if it doesn't work, restarting while the appservice is running
-could help.
-
-## Appservice-specific instructions
-
-### Tested appservices
-
-These appservices have been tested and work with Conduit without any extra steps:
-
- [matrix-appservice-discord](https://github.com/Half-Shot/matrix-appservice-discord)
- [mautrix-hangouts](https://github.com/mautrix/hangouts/)
- [mautrix-telegram](https://github.com/mautrix/telegram/)
-
-### [mautrix-signal](https://github.com/mautrix/signal)
-
-There are a few things you need to do, in order for the Signal bridge (at least
-up to version `0.2.0`) to work. How you do this depends on whether you use
-Docker or `virtualenv` to run it. In either case you need to modify
-[portal.py](https://github.com/mautrix/signal/blob/master/mautrix_signal/portal.py).
-Do this **before** following the bridge installation guide.
-
-1. **Create a copy of `portal.py`**. Go to
-   [portal.py](https://github.com/mautrix/signal/blob/master/mautrix_signal/portal.py)
-at [mautrix-signal](https://github.com/mautrix/signal) (make sure you change to
-the correct commit/version of mautrix-signal you're using) and copy its
-content. Create a new `portal.py` on your system and paste the content in.
-2. **Patch the copy**. Exact line numbers may be slightly different, look nearby if they don't match: 
-  - [Line 1020](https://github.com/mautrix/signal/blob/4ea831536f154aba6419d13292479eb383ea3308/mautrix_signal/portal.py#L1020)
-    ```diff
-    --- levels.users[self.main_intent.mxid] = 9001 if is_initial else 100
-    +++ levels.users[self.main_intent.mxid] = 100 if is_initial else 100
-    ```
-  - [Between lines 1041 and 1042](https://github.com/mautrix/signal/blob/4ea831536f154aba6419d13292479eb383ea3308/mautrix_signal/portal.py#L1041-L1042) add a new line:
-    ```diff
-        "type": str(EventType.ROOM_POWER_LEVELS),
-    +++ "state_key": "",
-        "content": power_levels.serialize(),
-    ```
-3. **Deploy the patch**. This is different depending on how you have `mautrix-signal` deployed:
-  - [*If using virtualenv*] Copy your patched `portal.py` to `./lib/python3.7/site-packages/mautrix_signal/portal.py` (the exact version of Python may be different on your system).
-  -  [*If using Docker*] Map the patched `portal.py` into the `mautrix-signal` container:
-    
-    ```yaml
-    volumes:
-      - ./your/path/on/host/portal.py:/usr/lib/python3.9/site-packages/mautrix_signal/portal.py
-    ```
-4. Now continue with the [bridge installation instructions ](https://docs.mau.fi/bridges/index.html) and the general bridge notes above.
@@ -1,11 +0,0 @@
-Install docker:
-
-```
-$ sudo apt install docker
-$ sudo usermod -aG docker $USER
-$ exec sudo su -l $USER
-$ sudo systemctl start docker
-$ cargo install cross
-$ cross build --release --target armv7-unknown-linux-musleabihf
-```
-The cross-compiled binary is at target/armv7-unknown-linux-musleabihf/release/conduit
@@ -245,7 +245,6 @@ dependencies = [
 "crossbeam",
 "directories",
 "heed",
- "hmac",
 "http",
 "image",
 "jsonwebtoken",
@@ -267,7 +266,6 @@ dependencies = [
 "serde",
 "serde_json",
 "serde_yaml",
- "sha-1",
 "sled",
 "thiserror",
 "thread_local",
@@ -430,16 +428,6 @@ dependencies = [
 "lazy_static",
 ]

-[[package]]
-name = "crypto-mac"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
-dependencies = [
- "generic-array",
- "subtle",
-]
-
 [[package]]
 name = "curve25519-dalek"
 version = "3.2.0"
@@ -909,16 +897,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "hmac"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
-dependencies = [
- "crypto-mac",
- "digest",
-]
-
 [[package]]
 name = "hostname"
 version = "0.3.1"
@@ -1990,7 +1968,7 @@ dependencies = [
 [[package]]
 name = "ruma"
 version = "0.4.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "assign",
 "js_int",
@@ -2010,8 +1988,8 @@ dependencies = [

 [[package]]
 name = "ruma-api"
-version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+version = "0.18.3"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "bytes",
 "http",
@@ -2026,8 +2004,8 @@ dependencies = [

 [[package]]
 name = "ruma-api-macros"
-version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+version = "0.18.3"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2038,7 +2016,7 @@ dependencies = [
 [[package]]
 name = "ruma-appservice-api"
 version = "0.4.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "ruma-api",
 "ruma-common",
@@ -2051,8 +2029,8 @@ dependencies = [

 [[package]]
 name = "ruma-client-api"
-version = "0.12.3"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+version = "0.12.2"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "assign",
 "bytes",
@@ -2072,7 +2050,7 @@ dependencies = [
 [[package]]
 name = "ruma-common"
 version = "0.6.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "indexmap",
 "js_int",
@@ -2086,8 +2064,8 @@ dependencies = [

 [[package]]
 name = "ruma-events"
-version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+version = "0.24.5"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "indoc",
 "js_int",
@@ -2102,8 +2080,8 @@ dependencies = [

 [[package]]
 name = "ruma-events-macros"
-version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+version = "0.24.5"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2114,7 +2092,7 @@ dependencies = [
 [[package]]
 name = "ruma-federation-api"
 version = "0.3.1"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2129,10 +2107,9 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers"
 version = "0.20.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "paste",
- "percent-encoding",
 "rand 0.8.4",
 "ruma-identifiers-macros",
 "ruma-identifiers-validation",
@@ -2144,7 +2121,7 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-macros"
 version = "0.20.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "quote",
 "ruma-identifiers-validation",
@@ -2154,15 +2131,12 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-validation"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
-dependencies = [
- "thiserror",
-]
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"

 [[package]]
 name = "ruma-identity-service-api"
 version = "0.3.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2175,7 +2149,7 @@ dependencies = [
 [[package]]
 name = "ruma-push-gateway-api"
 version = "0.3.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2190,7 +2164,7 @@ dependencies = [
 [[package]]
 name = "ruma-serde"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "bytes",
 "form_urlencoded",
@@ -2204,7 +2178,7 @@ dependencies = [
 [[package]]
 name = "ruma-serde-macros"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2215,7 +2189,7 @@ dependencies = [
 [[package]]
 name = "ruma-signatures"
 version = "0.9.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "base64 0.13.0",
 "ed25519-dalek",
@@ -2232,7 +2206,7 @@ dependencies = [
 [[package]]
 name = "ruma-state-res"
 version = "0.4.1"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=a6a1224652912a957b09f136ec5da2686be6e0e2#a6a1224652912a957b09f136ec5da2686be6e0e2"
 dependencies = [
 "itertools 0.10.1",
 "js_int",
@@ -2444,19 +2418,6 @@ dependencies = [
 "yaml-rust",
 ]

-[[package]]
-name = "sha-1"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
-dependencies = [
- "block-buffer",
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest",
- "opaque-debug",
-]
-
 [[package]]
 name = "sha1"
 version = "0.6.0"
@@ -19,7 +19,7 @@ rocket = { version = "0.5.0-rc.1", features = ["tls"] } # Used to handle request

 # Used for matrix spec type definitions and helpers
 #ruma = { version = "0.4.0", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
-ruma = { git = "https://github.com/ruma/ruma", rev = "e7f01ca55a1eff437bad754bf0554cc09f44ec2a", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
+ruma = { git = "https://github.com/ruma/ruma", rev = "a6a1224652912a957b09f136ec5da2686be6e0e2", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 #ruma = { git = "https://github.com/timokoesters/ruma", rev = "50c1db7e0a3a21fc794b0cce3b64285a4c750c71", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }
 #ruma = { path = "../ruma/crates/ruma", features = ["compat", "rand", "appservice-api-c", "client-api", "federation-api", "push-gateway-api-c", "state-res", "unstable-pre-spec", "unstable-exhaustive-types"] }

@@ -79,9 +79,6 @@ num_cpus = "1.13.0"
 threadpool = "1.8.1"
 heed = { git = "https://github.com/timokoesters/heed.git", rev = "f6f825da7fb2c758867e05ad973ef800a6fe1d5d", optional = true }
 thread_local = "1.1.3"
-# used for TURN server authentication
-hmac = "0.11.0"
-sha-1 = "0.9.8"

 [features]
 default = ["conduit_bin", "backend_sqlite"]
@@ -123,12 +120,13 @@ maintainer-scripts = "debian/"
 systemd-units = { unit-name = "matrix-conduit" }

 [profile.dev]
-lto = 'off'
+lto = 'thin'
 incremental = true

 [profile.release]
 lto = 'thin'
 incremental = true
+
 codegen-units=32
 # If you want to make flamegraphs, enable debug info:
 # debug = true
@@ -2,30 +2,25 @@

 ## Getting help

-If you run into any problems while setting up Conduit, write an email to `timo@koesters.xyz`, ask us
-in `#conduit:matrix.org` or [open an issue on GitLab](https://gitlab.com/famedly/conduit/-/issues/new).
+If you run into any problems while setting up Conduit, write an email to `timo@koesters.xyz`, ask us in `#conduit:matrix.org` or [open an issue on GitLab](https://gitlab.com/famedly/conduit/-/issues/new).

 ## Installing Conduit

-Although you might be able to compile Conduit for Windows, we do recommend running it on a linux server. We therefore
-only offer Linux binaries.
-
 You may simply download the binary that fits your machine. Run `uname -m` to see what you need. Now copy the right url:

-| CPU Architecture                            | Download link           |
-| ------------------------------------------- | ----------------------- |
-| x84_64 / amd64 (Most servers and computers) | [Download][x84_64-musl] |
-| armv6                                       | [Download][armv6-musl]  |
-| armv7 (e.g. Raspberry Pi by default)        | [Download][armv7-musl]  |
-| armv8 / aarch64                             | [Download][armv8-musl]  |
+| CPU Architecture     | GNU (Ubuntu, Debian, ArchLinux, ...)  | MUSL (Alpine, ... )     |
+| -------------------- | ------------------------------------- | ----------------------- |
+| x84_64 / amd64       | [Download][x84_64-gnu]                | [Download][x84_64-musl] |
+| armv7 (Raspberry Pi) | [Download][armv7-gnu]                 | -                       |
+| armv8 / aarch64      | [Download][armv8-gnu]                 | -                       |
+
+[x84_64-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-gnu?job=build:release:cargo:x86_64-unknown-linux-gnu

 [x84_64-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-musl?job=build:release:cargo:x86_64-unknown-linux-musl

-[armv6-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-arm-unknown-linux-musleabihf?job=build:release:cargo:arm-unknown-linux-musleabihf
+[armv7-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-gnueabihf?job=build:release:cargo:armv7-unknown-linux-gnueabihf

-[armv7-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-musleabihf?job=build:release:cargo:armv7-unknown-linux-musleabihf
-
-[armv8-musl]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-musl?job=build:release:cargo:aarch64-unknown-linux-musl
+[armv8-gnu]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-gnu?job=build:release:cargo:aarch64-unknown-linux-gnu

 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>
@@ -37,15 +32,15 @@ Alternatively, you may compile the binary yourself using
 ```bash
 $ cargo build --release
 ```
-
 Note that this currently requires Rust 1.50.

 If you want to cross compile Conduit to another architecture, read the [Cross-Compile Guide](CROSS_COMPILE.md).

+
 ## Adding a Conduit user

-While Conduit can run as any user it is usually better to use dedicated users for different services. This also allows
-you to make sure that the file permissions are correctly set up.
+While Conduit can run as any user it is usually better to use dedicated users for different services.
+This also allows you to make sure that the file permissions are correctly set up.

 In Debian you can use this command to create a Conduit user:

@@ -55,8 +50,9 @@ sudo adduser --system conduit --no-create-home

 ## Setting up a systemd service

-Now we'll set up a systemd service for Conduit, so it's easy to start/stop Conduit and set it to autostart when your
-server reboots. Simply paste the default systemd service you can find below into
+Now we'll set up a systemd service for Conduit, so it's easy to start/stop
+Conduit and set it to autostart when your server reboots. Simply paste the
+default systemd service you can find below into
 `/etc/systemd/system/conduit.service`.

 ```systemd
@@ -81,10 +77,10 @@ Finally, run
 $ sudo systemctl daemon-reload
 ```

+
 ## Creating the Conduit configuration file

-Now we need to create the Conduit's config file in `/etc/matrix-conduit/conduit.toml`. Paste this in **and take a moment
-to read it. You need to change at least the server name.**
+Now we need to create the Conduit's config file in `/etc/matrix-conduit/conduit.toml`. Paste this in **and take a moment to read it. You need to change at least the server name.**

 ```toml
 [global]
@@ -132,8 +128,8 @@ address = "127.0.0.1" # This makes sure Conduit can only be reached using the re

 ## Setting the correct file permissions

-As we are using a Conduit specific user we need to allow it to read the config. To do that you can run this command on
-Debian:
+As we are using a Conduit specific user we need to allow it to read the config.
+To do that you can run this command on Debian:

 ```bash
 sudo chown -R conduit:nogroup /etc/matrix-conduit
@@ -146,6 +142,7 @@ sudo mkdir -p /var/lib/matrix-conduit/conduit_db
 sudo chown -R conduit:nogroup /var/lib/matrix-conduit/conduit_db
 ```

+
 ## Setting up the Reverse Proxy

 This depends on whether you use Apache, Nginx or another web server.
@@ -174,9 +171,11 @@ ProxyPassReverse /_matrix/ http://127.0.0.1:6167/_matrix/
 $ sudo systemctl reload apache2
 ```

+
 ### Nginx

-If you use Nginx and not Apache, add the following server section inside the http section of `/etc/nginx/nginx.conf`
+If you use Nginx and not Apache, add the following server section inside the
+http section of `/etc/nginx/nginx.conf`

 ```nginx
 server {
@@ -199,13 +198,13 @@ server {
    include /etc/letsencrypt/options-ssl-nginx.conf;
 }
 ```
-
 **You need to make some edits again.** When you are done, run

 ```bash
 $ sudo systemctl reload nginx
 ```

+
 ## SSL Certificate

 The easiest way to get an SSL certificate, if you don't have one already, is to install `certbot` and run this:
@@ -214,6 +213,7 @@ The easiest way to get an SSL certificate, if you don't have one already, is to
 $ sudo certbot -d your.server.name
 ```

+
 ## You're done!

 Now you can start Conduit with:
@@ -1,66 +1,75 @@
-# syntax=docker/dockerfile:1
-FROM docker.io/rust:1.53-alpine AS builder
-WORKDIR /usr/src/conduit
-
-# Install required packages to build Conduit and it's dependencies
-RUN apk add musl-dev
-
-# == Build dependencies without our own code separately for caching ==
-#
-# Need a fake main.rs since Cargo refuses to build anything otherwise.
-#
-# See https://github.com/rust-lang/cargo/issues/2644 for a Cargo feature
-# request that would allow just dependencies to be compiled, presumably
-# regardless of whether source files are available.
-RUN mkdir src && touch src/lib.rs && echo 'fn main() {}' > src/main.rs
-COPY Cargo.toml Cargo.lock ./
-RUN cargo build --release && rm -r src
-
-# Copy over actual Conduit sources
-COPY src src
-
-# main.rs and lib.rs need their timestamp updated for this to work correctly since
-# otherwise the build with the fake main.rs from above is newer than the
-# source files (COPY preserves timestamps).
-#
-# Builds conduit and places the binary at /usr/src/conduit/target/release/conduit
-RUN touch src/main.rs && touch src/lib.rs && cargo build --release
+# Using multistage build:
+# 	https://docs.docker.com/develop/develop-images/multistage-build/
+# 	https://whitfin.io/speeding-up-rust-docker-builds/


+##########################  BUILD IMAGE  ##########################
+# Alpine build image to build Conduit's statically compiled binary
+FROM alpine:3.14 as builder

+# Install packages needed for building all crates
+RUN apk add --no-cache \
+        cargo \
+        openssl-dev

-# ---------------------------------------------------------------------------------------------------------------
-# Stuff below this line actually ends up in the resulting docker image
-# ---------------------------------------------------------------------------------------------------------------
-FROM docker.io/alpine:3.14 AS runner
+# Specifies if the local project is build or if Conduit gets build
+# from the official git repository. Defaults to the git repo.
+ARG LOCAL=false
+# Specifies which revision/commit is build. Defaults to HEAD
+ARG GIT_REF=origin/master

-# Standard port on which Conduit launches.
-# You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
+# Copy project files from current folder
+COPY . .
+# Build it from the copied local files or from the official git repository
+RUN if [[ $LOCAL == "true" ]]; then \
+        mv ./docker/healthcheck.sh . ; \
+        echo "Building from local source..." ; \
+        cargo install --path . ; \
+    else \
+        echo "Building revision '${GIT_REF}' from online source..." ; \
+        cargo install --git "https://gitlab.com/famedly/conduit.git" --rev ${GIT_REF} ; \
+        echo "Loadings healthcheck script from online source..." ; \
+        wget "https://gitlab.com/famedly/conduit/-/raw/${GIT_REF#origin/}/docker/healthcheck.sh" ; \
+    fi
+
+########################## RUNTIME IMAGE ##########################
+# Create new stage with a minimal image for the actual
+# runtime image/container
+FROM alpine:3.14
+
+ARG CREATED
+ARG VERSION
+ARG GIT_REF=origin/master

-# Note from @jfowl: I would like to remove this in the future and just have the Docker version be configured with envs. 
 ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"

-# Conduit needs:
-#   ca-certificates: for https
-#   libgcc: Apparently this is needed, even if I (@jfowl) don't know exactly why. But whatever, it's not that big.
-RUN apk add --no-cache \
-        ca-certificates \
-        curl \
-        libgcc
+# Labels according to https://github.com/opencontainers/image-spec/blob/master/annotations.md
+# including a custom label specifying the build command
+LABEL org.opencontainers.image.created=${CREATED} \
+      org.opencontainers.image.authors="Conduit Contributors" \
+      org.opencontainers.image.title="Conduit" \
+      org.opencontainers.image.version=${VERSION} \
+      org.opencontainers.image.vendor="Conduit Contributors" \
+      org.opencontainers.image.description="A Matrix homeserver written in Rust" \
+      org.opencontainers.image.url="https://conduit.rs/" \
+      org.opencontainers.image.revision=${GIT_REF} \
+      org.opencontainers.image.source="https://gitlab.com/famedly/conduit.git" \
+      org.opencontainers.image.licenses="Apache-2.0" \
+      org.opencontainers.image.documentation="" \
+      org.opencontainers.image.ref.name="" \
+      org.label-schema.docker.build="docker build . -t matrixconduit/matrix-conduit:latest --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)" \
+      maintainer="Weasy666"

+# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
+EXPOSE 6167

-# Created directory for the database and media files
+# Copy config files from context and the binary from
+# the "builder" stage to the current stage into folder
+# /srv/conduit and create data folder for database
 RUN mkdir -p /srv/conduit/.local/share/conduit
+COPY --from=builder /root/.cargo/bin/conduit /srv/conduit/
+COPY --from=builder ./healthcheck.sh /srv/conduit/

-# Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/
-HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh
-
-# Copy over the actual Conduit binary from the builder stage
-COPY --from=builder /usr/src/conduit/target/release/conduit /srv/conduit/
-
-# Improve security: Don't run stuff as root, that does not need to run as root:
 # Add www-data user and group with UID 82, as used by alpine
 # https://git.alpinelinux.org/aports/tree/main/nginx/nginx.pre-install
 RUN set -x ; \
@@ -70,13 +79,19 @@ RUN set -x ; \

 # Change ownership of Conduit files to www-data user and group
 RUN chown -cR www-data:www-data /srv/conduit
-RUN chmod +x /srv/conduit/healthcheck.sh

-# Change user to www-data
+# Install packages needed to run Conduit
+RUN apk add --no-cache \
+        ca-certificates \
+        curl \
+        libgcc
+
+# Test if Conduit is still alive, uses the same endpoint as Element
+HEALTHCHECK --start-period=5s --interval=60s CMD ./healthcheck.sh
+
+# Set user to www-data
 USER www-data
 # Set container home directory
 WORKDIR /srv/conduit
-
-# Run Conduit and print backtraces on panics
-ENV RUST_BACKTRACE=1
+# Run Conduit
 ENTRYPOINT [ "/srv/conduit/conduit" ]
@@ -0,0 +1,16 @@
+[book]
+title = "Conduit Docs"
+author = "The Conduit contributors"
+description = "Conduit is a simple, fast and reliable chat server for the Matrix protocol"
+language = "en"
+src = "docs"
+
+[rust]
+edition = "2018"
+
+[build]
+build-dir = "public"
+create-missing = true
+
+[output.html.search]
+limit-results = 15
@@ -40,7 +40,6 @@ trusted_servers = ["matrix.org"]
 #workers = 4 # default: cpu core count * 2

 address = "127.0.0.1" # This makes sure Conduit can only be reached using the reverse proxy
-#address = "0.0.0.0" # If Conduit is running in a container, make sure the reverse proxy (ie. Traefik) can reach it.

 proxy = "none" # more examples can be found at src/database/proxy.rs:6

@@ -2,22 +2,38 @@

 > **Note:** To run and use Conduit you should probably use it with a Domain or Subdomain behind a reverse proxy (like Nginx, Traefik, Apache, ...) with a Lets Encrypt certificate.

+
 ## Docker

 ### Build & Dockerfile

 The Dockerfile provided by Conduit has two stages, each of which creates an image.
-
 1. **Builder:** Builds the binary from local context or by cloning a git revision from the official repository.
-2. **Runner:** Copies the built binary from **Builder** and sets up the runtime environment, like creating a volume to persist the database and applying the correct permissions.
+2. **Runtime:** Copies the built binary from **Builder** and sets up the runtime environment, like creating a volume to persist the database and applying the correct permissions.
+
+The Dockerfile includes a few build arguments that should be supplied when building it.
+
+``` Dockerfile
+ARG LOCAL=false
+ARG CREATED
+ARG VERSION
+ARG GIT_REF=origin/master
+```
+
+- **CREATED:** Date and time as string (date-time as defined by RFC 3339). Will be used to create the Open Container Initiative compliant label `org.opencontainers.image.created`. Supply by it like this `$(date -u +'%Y-%m-%dT%H:%M:%SZ')`
+- **VERSION:** The SemVer version of Conduit, which is in the image. Will be used to create the Open Container Initiative compliant label `org.opencontainers.image.version`. If you have a `Cargo.toml` in your build context, you can get it with `$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)`
+- **LOCAL:** *(Optional)* A boolean value, specifies if the local build context should be used, or if the official repository will be cloned. If not supplied with the build command, it will default to `false`.
+- **GIT_REF:** *(Optional)* A git ref, like `HEAD` or a commit ID. The supplied ref will be used to create the Open Container Initiative compliant label `org.opencontainers.image.revision` and will be the ref that is cloned from the repository when not building from the local context. If not supplied with the build command, it will default to `origin/master`.

 To build the image you can use the following command

 ``` bash
-docker build --tag matrixconduit/matrix-conduit:latest .
+docker build . -t matrixconduit/matrix-conduit:latest --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml)
 ```

 which also will tag the resulting image as `matrixconduit/matrix-conduit:latest`.
+**Note:** it ommits the two optional `build-arg`s.
+

 ### Run

@@ -30,13 +46,9 @@ docker run -d -p 8448:6167 -v ~/conduit.toml:/srv/conduit/conduit.toml -v db:/sr
 or you can skip the build step and pull the image from one of the following registries:

 | Registry        | Image                                                                                                               | Size                                                                                        |
-| --------------- | --------------------------------------------------------------- | --------------------- |
-| Docker Hub      | [matrixconduit/matrix-conduit:latest][dh]                       | ![Image Size][shield] |
-| GitLab Registry | [registry.gitlab.com/famedly/conduit/matrix-conduit:latest][gl] | ![Image Size][shield] |
-
-[dh]: https://hub.docker.com/r/matrixconduit/matrix-conduit
-[gl]: https://gitlab.com/famedly/conduit/container_registry/
-[shield]: https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest
+| --------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Docker Hub      | [matrixconduit/matrix-conduit:latest](https://hub.docker.com/r/matrixconduit/matrix-conduit)                        | ![Image Size](https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest) |
+| GitLab Registry | [registry.gitlab.com/famedly/conduit/conduit:latest](https://gitlab.com/famedly/conduit/container_registry/2134341) | ![Image Size](https://img.shields.io/docker/image-size/matrixconduit/matrix-conduit/latest) |

 The `-d` flag lets the container run in detached mode. You now need to supply a `conduit.toml` config file, an example can be found [here](../conduit-example.toml).
 You can pass in different env vars to change config values on the fly. You can even configure Conduit completely by using env vars, but for that you need
@@ -44,20 +56,23 @@ to pass `-e CONDUIT_CONFIG=""` into your container. For an overview of possible

 If you just want to test Conduit for a short time, you can use the `--rm` flag, which will clean up everything related to your container after you stop it.

+
 ## Docker-compose

 If the docker command is not for you or your setup, you can also use one of the provided `docker-compose` files. Depending on your proxy setup, use the [`docker-compose.traefik.yml`](docker-compose.traefik.yml) and [`docker-compose.override.traefik.yml`](docker-compose.override.traefik.yml) for Traefik (don't forget to remove `.traefik` from the filenames) or the normal [`docker-compose.yml`](../docker-compose.yml) for every other reverse proxy. Additional info about deploying
 Conduit can be found [here](../DEPLOY.md).

+
 ### Build

 To build the Conduit image with docker-compose, you first need to open and modify the `docker-compose.yml` file. There you need to comment the `image:` option and uncomment the `build:` option. Then call docker-compose with:

 ``` bash
-docker-compose up
+CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ') VERSION=$(grep -m1 -o '[0-9].[0-9].[0-9]' Cargo.toml) docker-compose up
 ```

-This will also start the container right afterwards, so if want it to run in detached mode, you also should use the `-d` flag.
+This will also start the container right afterwards, so if want it to run in detached mode, you also should use the `-d` flag. For possible `build-args`, please take a look at the above `Build & Dockerfile` section.
+

 ### Run

@@ -86,9 +101,7 @@ So...step by step:
 3. Create the `conduit.toml` config file, an example can be found [here](../conduit-example.toml), or set `CONDUIT_CONFIG=""` and configure Conduit per env vars.
 4. Uncomment the `element-web` service if you want to host your own Element Web Client and create a `element_config.json`.
 5. Create the files needed by the `well-known` service.
-
    - `./nginx/matrix.conf` (relative to the compose file, you can change this, but then also need to change the volume mapping)
-
      ```nginx
      server {
          server_name <SUBDOMAIN>.<DOMAIN>;
@@ -101,7 +114,6 @@ So...step by step:
          }
      }
      ```
-
    - `./nginx/www/.well-known/matrix/client` (relative to the compose file, you can change this, but then also need to change the volume mapping)
      ```json
      {
@@ -116,6 +128,5 @@ So...step by step:
          "m.server": "<SUBDOMAIN>.<DOMAIN>:443"
      }
      ```
-
 6. Run `docker-compose up -d`
 7. Connect to your homeserver with your preferred client and create a user. You should do this immediatly after starting Conduit, because the first created user is the admin.
@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile:1
 # ---------------------------------------------------------------------------------------------------------
 # This Dockerfile is intended to be built as part of Conduit's CI pipeline.
 # It does not build Conduit in Docker, but just copies the matching build artifact from the build job.
@@ -8,26 +7,20 @@
 # Credit's for the original Dockerfile: Weasy666.
 # ---------------------------------------------------------------------------------------------------------

-FROM docker.io/alpine:3.14 AS runner
+FROM alpine:3.14

-# Standard port on which Conduit launches.
-# You still need to map the port when using the docker command or docker-compose.
-EXPOSE 6167
-
-# Note from @jfowl: I would like to remove this in the future and just have the Docker version be configured with envs. 
-ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
-
-# Conduit needs:
-#   ca-certificates: for https
-#   libgcc: Apparently this is needed, even if I (@jfowl) don't know exactly why. But whatever, it's not that big.
+# Install packages needed to run Conduit
 RUN apk add --no-cache \
        ca-certificates \
+        curl \
        libgcc

-
 ARG CREATED
 ARG VERSION
 ARG GIT_REF
+
+ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
+
 # Labels according to https://github.com/opencontainers/image-spec/blob/master/annotations.md
 # including a custom label specifying the build command
 LABEL org.opencontainers.image.created=${CREATED} \
@@ -40,24 +33,19 @@ LABEL org.opencontainers.image.created=${CREATED} \
      org.opencontainers.image.revision=${GIT_REF} \
      org.opencontainers.image.source="https://gitlab.com/famedly/conduit.git" \
      org.opencontainers.image.licenses="Apache-2.0" \
-      org.opencontainers.image.documentation="https://gitlab.com/famedly/conduit" \
+      org.opencontainers.image.documentation="" \
      org.opencontainers.image.ref.name=""

-# Created directory for the database and media files
+# Standard port on which Conduit launches. You still need to map the port when using the docker command or docker-compose.
+EXPOSE 6167
+
+# create data folder for database
 RUN mkdir -p /srv/conduit/.local/share/conduit

-# Test if Conduit is still alive, uses the same endpoint as Element
+# Copy the Conduit binary into the image at the latest possible moment to maximise caching:
+COPY ./conduit-x86_64-unknown-linux-musl /srv/conduit/conduit
 COPY ./docker/healthcheck.sh /srv/conduit/
-HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh

-
-# Depending on the target platform (e.g. "linux/arm/v7", "linux/arm64/v8", or "linux/amd64")
-# copy the matching binary into this docker image
-ARG TARGETPLATFORM
-COPY ./$TARGETPLATFORM /srv/conduit/conduit
-
-
-# Improve security: Don't run stuff as root, that does not need to run as root:
 # Add www-data user and group with UID 82, as used by alpine
 # https://git.alpinelinux.org/aports/tree/main/nginx/nginx.pre-install
 RUN set -x ; \
@@ -69,11 +57,13 @@ RUN set -x ; \
 RUN chown -cR www-data:www-data /srv/conduit
 RUN chmod +x /srv/conduit/healthcheck.sh

-# Change user to www-data
+
+# Test if Conduit is still alive, uses the same endpoint as Element
+HEALTHCHECK --start-period=5s --interval=60s CMD ./healthcheck.sh
+
+# Set user to www-data
 USER www-data
 # Set container home directory
 WORKDIR /srv/conduit
-
-# Run Conduit and print backtraces on panics
-ENV RUST_BACKTRACE=1
+# Run Conduit
 ENTRYPOINT [ "/srv/conduit/conduit" ]
@@ -7,7 +7,7 @@ fi

 # The actual health check.
 # We try to first get a response on HTTP and when that fails on HTTPS and when that fails, we exit with code 1.
-# TODO: Change this to a single wget call. Do we have a config value that we can check for that?
-wget --no-verbose --tries=1 --spider "http://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
-    wget --no-verbose --tries=1 --spider "https://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
+# TODO: Change this to a single curl call. Do we have a config value that we can check for that?
+curl --fail -s "http://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
+    curl -k --fail -s "https://localhost:${CONDUIT_PORT}/_matrix/client/versions" || \
    exit 1
@@ -0,0 +1,16 @@
+# Summary
+
+[Home](index.md)
+
+- [Installation](installation.md)
+    - [Prerequisites](installation/prerequisites.md)
+    - [From Binaries](installation/manual.md)
+    - [From Packages](installation/packages.md)
+    - [With Docker](installation/docker.md)
+- [Configuration](configuration.md)
+    - [Config options](configuration/configuration.md)
+    - [Appservices](configuration/appservices.md)
+- [Contribute](contribute.md)
+    - [Basics](development/basics.md)
+    - [Cross compilation](development/cross-compilation.md)
+    - [Tests & CI](development/tests-ci.md)
@@ -0,0 +1 @@
+# Configuration
@@ -0,0 +1,2 @@
+# Configuring Conduit
+
@@ -0,0 +1,220 @@
+# Configuring Conduit
+
+Conduit can be configured via a config file (conventionally called Conduit.toml) or environment variables. If a config
+file exists and environment variables are set, environment variables overwrite config options.
+
+You absolutely need to set the environment variable `CONDUIT_CONFIG_FILE` to either point to a config file (
+e.g. `CONDUIT_CONFIG_FILE=/etc/conduit/Conduit.toml`) or to an empty string (`CONDUIT_CONFIG_FILE=''`) if you want to
+configure Conduit with just environment variables.
+
+## Mandatory config options
+
+Mandatory variables must be configured in order for Conduit to run properly.
+
+### Server Name
+
+- Config file key: `server_name`
+- Envirnoment variable: `CONDUIT_SERVER_NAME`
+- Default value: _None, you will need to choose your own._
+
+The server_name is the name of this server. It is used as a suffix for user and room ids. Example: If you set it
+to `conduit.rs`, your usernames will look like `@somebody:conduit.rs`.
+
+The Conduit server needs to be reachable at https://your.server.name/ on port 443 (client-server) and 8448 (
+server-server) OR you can create /.well-known files to redirect requests. See
+the [Client-Server specs](https://matrix.org/docs/spec/client_server/latest#get-well-known-matrix-client) and
+the [Server-Server specs](https://matrix.org/docs/spec/server_server/r0.1.4#get-well-known-matrix-server) for more
+information.
+
+### Database Path
+
+- Config file key: `database_path`
+- Envirnoment variable: `CONDUIT_DATABASE_PATH`
+- Default value: _None, but many people like to use `/var/lib/conduit/`_.
+
+A **directory** where Conduit stores its database and media files. This directory must exist, have enough free space and
+be readable and writable by the user Conduit is running as.
+
+What does _enough free space_ mean? It heavily on the amount of messages your Conduit server will see and the amount and
+size of media files users on your Conduit server send. As a rule of thumb, you should have at least 10 GB of free space
+left. You should be comfortable for quite some time with 50 GB.
+
+### TCP Port
+
+- Config file key: `port`
+- Environment variable: `CONDUIT_PORT`
+- Default value: _None, but many people like to use `6167`_.
+
+The TCP port Conduit will listen on for connections. The port needs to be free (no other program is listeing on it).
+
+Conduit does currently (2021-09) not offer HTTPS by itself. Only unencrypted HTTP requests will be accepted on this
+port. Unless you know what you are doing, this port should not be exposed to the internet. Instead, use a reverse proxy
+capable of doing TLS to offer your Conduit server to the internet via HTTPS. See [TODO] for example configurations.
+
+## Optional configuration options
+
+These config options come with defaults and don't need to be configured for Conduit to run. That said, you should still
+check them to make sure that your Conduit server behaves like you want it to do.
+
+### Maximum request size
+
+- Config file key: `max_request_size`
+- Environment variable: `CONDUIT_MAX_REQUEST_SIZE`
+- Default value: `20_000_000` (~= 20 MB)
+
+The maximum size in bytes for incoming requests to Conduit. You can use underscores to improve readability.
+
+This will effectively limit the size for images, videos and other files users on your Conduit server can send.
+
+### Allow Registration?
+
+- Config file key: `allow_registration`
+- Environment variable: `CONDUIT_ALLOW_REGISTRATION`
+- Default value: `true`
+- Possible values: `true`, `false`
+
+It this is set to `false`, no new users can register accounts on your Conduit server. Already registered users will not
+be affected from this setting and can continue to user your server.
+
+The first user to ever register on your Conduit server will be considered the admin account and is automatically invited
+into the admin room.
+
+### Allow Encryption?
+
+- Config file key: `allow_encryption`
+- Environment variable: `CONDUIT_ALLOW_ENCRYPTION`
+- Default value: `true`
+- Possible values: `true`, `false`
+
+If this is set to `false`, Conduit disables the ability for users to create encrypted chats. Existing encrypted chats
+may continue to work.
+
+### Allow federation?
+
+- Config file key: `allow_federation`
+- Environment variable: `CONDUIT_ALLOW_FEDERATION`
+- Default value: `false`
+- Possible values: `true`, `false`
+
+Federation means that users from different Matrix servers can chat with each other. E.g. `@mathew:matrix.org` can chat
+with `@timo:conduit.rs`.
+
+If this option is set to `false`, users on your Conduit server can only talk with other users on your Conduit server.
+
+Federation with other servers needs to happen over HTTPS, so make sure you have set up a reverse proxy.
+
+### Jaeger Tracing
+
+- Config file key: `allow_jaeger`
+- Environment variable: `CONDUIT_ALLOW_JAEGER`
+- Default value: `false`
+- Possible values: `true`, `false`
+
+Enable Jaeger to support monitoring and troubleshooting through Jaeger.
+
+If you don't know what Jaeger is, you can safely leave this set to `false`.
+
+### Trusted servers
+
+- Config file key: `trusted_servers`
+- Environment variable: `CONDUIT_TRUSTED_SERVERS`
+- Default value: `[]`
+- Possible values: JSON-Array of server domains, e.g. `["matrix.org"]` or `["matrix.org", "conduit.rs"]`.
+
+Matrix servers have so-called "server keys", which authenticate messages from their users. Because your Conduit server
+might not know the server keys from every server it encounters, it can ask a _trusted server_ for them. This speeds
+things up for rooms with people from a lot of different servers.
+
+You should only set this to include trustworthy servers. Most people consider a good default to be `["matrix.org"]`.
+
+Only relevant if you have federation enabled.
+
+### Limit amount of concurrent requests
+
+- Config file key: `max_concurrent_requests`
+- Environment variable: `CONDUIT_MAX_CONCURRENT_REQUESTS`
+- Default value: `100`
+- Suggested values: `1` - `1000` (u16)
+
+How many requests Conduit can make at the same time. This affects federation with other Matrix servers, push
+notifications and app_services.
+
+// TODO Timo: When does it make sense to change this?
+
+### Configure logging
+
+- Config file key: `log`
+- Environment variable: `CONDUIT_LOG`
+- Default value: `info,state_res=warn,rocket=off,_=off,sled=off`
+
+Configures which kind of messages Conduit logs.
+
+> // TODO: Better and more thorough explanation
+
+### Worker threads
+
+- Config file key: `workers`
+- Environment variable: `CONDUIT_WORKERS`
+- Default value: cpu core count * 2
+- Possible values: // TODO
+
+> // TODO: Which thing exactly threads? What not?
+
+### Listening address
+
+- Config file key: `address`
+- Environment variable: `CONDUIT_ADDRESS`
+- Default value: `127.0.0.1`
+- Possible values: Valid IP addresses.
+
+Which IP address conduit is listening on. 127.0.0.1 means that Conduit can only be accessed from the same server or
+through a reverse proxy on that server. If you want it to be accessible from any network interface (which you should
+not, because other matrix servers should talk to your Conduit via a reverse proxy and not directly), you can set it
+to `0.0.0.0`.
+
+### Database cache capacity
+
+- Config file key: `db_cache_capacity_mb`
+- Environment variable: `CONDUIT_DB_CACHE_CAPACITY_MB`
+- Default value: `200`
+- Possible values: `true`, `false`
+
+The total amount of memory (RAM) that the database cache will be able to use.
+
+> // TODO: this needs clearification: In RAM or on disk and for what exactly?
+
+### PDU cache capacity
+
+- Config file key: `pdu_cache_capacity`
+- Environment variable: `CONDUIT_PDU_CACHE_CAPACITY`
+- Default value: `100_000`
+- Suggested values: `1_000` - `1_000_000` (u32)
+
+The total capacity (read: number of items) the pdu cache can hold in memory. Setting this to a lower number may slow
+Conduit down, as it must fetch more data from the database. Increasing it will mean that Conduit will start to use more
+memory as the cache slowly fills up.
+
+### SQLite WAL clean interval
+
+- Config file key: `sqlite_wal_clean_second_interval`
+- Environment variable: `CONDUIT_SQLITE_WAL_CLEAN_SECOND_INTERVAL`
+- Default value: `60` (every 60 seconds)
+- Suggested values: `1` - `3600` (u32)
+
+How often the WAL file should be cleaned up. The WAL file will be written to until cleaned up, after which it restarts
+writing from the beginning.
+
+The file's size will correspond to how long it could write to it in one go. (e.g. if conduit writes 100MB of data to the
+database inbetween that period, the file will grow to 100MB). You can read more about that in
+the [SQLite Docs](https://www.sqlite.org/draft/wal.html).
+
+Reducing this down too much can offset the benefits of using a WAL at all. However, having this too high can result in a
+large WAL file.
+
+Only relevant when using SQLite as the database.
+
+### Still undocumented config options
+
+- `tracing_flame`
+- `proxy`
+- `jwt_secret`
@@ -0,0 +1 @@
+# Contribute
@@ -0,0 +1 @@
+# Basics
@@ -0,0 +1,13 @@
+# Cross compilation
+
+Install docker:
+
+```bash
+sudo apt install docker
+sudo usermod -aG docker $USER
+exec sudo su -l $USER
+sudo systemctl start docker
+cargo install cross
+cross build --release --target armv7-unknown-linux-musleabihf
+```
+The cross-compiled binary is at target/armv7-unknown-linux-musleabihf/release/conduit
@@ -0,0 +1 @@
+# Tests & CI
@@ -0,0 +1,52 @@
+# Conduit
+
+Conduit is a simple, fast and reliable chat server for the [Matrix] protocol written in [Rust].
+
+-----
+> Note: This project is work-in-progress. Do *not* rely on it yet.
+
+## What is Matrix?
+
+[Matrix] is an open network for secure and decentralized
+communication. It allows you to chat with friends even if they are using
+another servers and client. You can even use bridges to communicate with users
+outside of Matrix, like a community on Discord or your family on Hangouts.
+
+## Why Conduit?
+
+Conduit is an open-source server implementation of the [Matrix
+Specification] with a focus on easy setup and low
+system requirements, making it very easy to set up.
+
+Other server implementations try to be extremely scalable, which makes sense if
+the goal is to support millions of users on a single instance, but makes
+smaller deployments a lot more inefficient. Conduit tries to keep it simple but
+takes full advantage of that, for example by using an in-memory database for
+[huge performance gains](https://github.com/timokoesters/romeo-and-juliet-benchmark).
+
+The future for Conduit in peer-to-peer Matrix (every client contains a server)
+is also bright.
+
+Conduit tries to be reliable by using the Rust programming language and paying
+close attention to error handling to make sure that evil clients, misbehaving
+servers or even a partially broken database will not cause the whole server to
+stop working.
+
+## Chat with us!
+
+We have a room on Matrix: [#conduit:matrix.org](https://matrix.to/#/#conduit:matrix.org)
+
+You can also contact us using:
+- Matrix: [@timo:koesters.xyz](https://matrix.to/#/@timo:koesters.xyz)
+- Email: [conduit@koesters.xyz](mailto:conduit@koesters.xyz)
+
+
+## Donate
+
+Liberapay: <https://liberapay.com/timokoesters/>\
+Bitcoin: `bc1qnnykf986tw49ur7wx9rpw2tevpsztvar5x8w4n`
+
+
+[Matrix]: https://matrix.org/
+[Rust]: https://rust-lang.org
+[Matrix Specification]: https://matrix.org/docs/spec
@@ -0,0 +1 @@
+# Installation
@@ -0,0 +1,2 @@
+:::warning Test
+:::
@@ -0,0 +1,12 @@
+# Distribution packages
+
+## Debian / Ubuntu
+
+[@paul:luon.net](https://matrix.to/#/@paul:luon.net) plans to package Conduit for Debian as soon as it reaches 1.0.
+Until it is available in the official repos, you can install the development version of it manually:
+
+```bash
+sudo apt-get install ca-certificates
+wget --https-only -O /tmp/conduit.deb https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-x86_64-unknown-linux-gnu.deb?job=build:cargo-deb:x86_64-unknown-linux-gnu
+sudo dpkg -i /tmp/conduit.deb
+```
@@ -0,0 +1,31 @@
+# Prerequisites for running Conduit
+
+You'll need:
+
+- A domain. Commonly cost about $10/year.
+- A Linux server with a stable internet connection, at least 500 MB of RAM and some disk space for messages and
+  attachments. Commonly start at $5/month.
+- Some basic knowledge about using a shell, SSH and configuring and protecting a server.
+  
+  
+## A word of caution:
+
+Don't underestimate the toll of administrating your own server.
+Conduit can't protect your conversations if your server gets compromised or deleted.
+
+Make sure that you got:
+
+- Automatic security updates
+    - On Ubuntu/Debian: Set up unattended-upgrades
+    - On RHEL/CentOS: Have a look at yum-cron
+- A firewall blocking all but the needed incoming ports
+    - ufw is an easy interface for the linux firewall
+- Protection against automatic attacks
+    - fail2ban scans logs and bans IPs which try to brute force their way into your server.
+    - Disable ssh login for root and switch from password to key based authentication.
+- Automated backups
+    - Most VPS hosting companies offer whole server backups for a small fee.
+    - Or run your own backup with something like borg.
+- A way to get notified if your disk fills up.
+    - If you send too much cat videos to your friends, Conduit might at some point become unable to
+      store any important messages.
@@ -0,0 +1,40 @@
+# About Matrix Homeservers
+
+Matrix homeservers manage its users chats. Every Matrix username includes the homserver it belongs to:
+`@alice:matrix.org` means that the `matrix.org` homeserver hosts a user called `@alice`.
+Every time someone chats with Alice, the `matrix.org` homeserver stores these messages.
+When `@alice:matrix.org` talks with `@adelaide:matrix.org`, that's easy. Both users use the same server.
+
+But how can `@bob:vector.tld`, who uses the `vector.tld` homeserver, exchange messages with `@alice:matrix.org`?
+This is where it get's a bit more complicated.
+
+## Matrix Homeserver discovery
+
+The Matrix specification specifies multiple ways how servers can discover and then talk to each other.
+Let's look at the most common one:
+
+### .well-known files
+
+At first, the only information a server has about a user (e.g. `@bob:vector.tld`) is its homeserver name: `vector.tld`.
+It then makes a HTTP GET request to `https://vector.tld/.well-known/matrix/server`.
+In the ideal case, this file contains a content like this: 
+
+```json
+{
+  "m.server": "matrix.vector.tld:443"
+}
+```
+
+This translates to: The matrix homeserver software for users with a username ending on `vector.tld`
+can be found at the address `matrix.vector.tld` at port 443 (which is the common port for HTTPS).
+
+The homeserver on it's quest to find `@bob:vector.tld` now contacts `matrix.vector.tld:443` and is then
+able to exchange chat messages with it.
+
+
+### Why so complicated?
+
+Organizations often don't want to run their Matrix server on the same machine that hosts their website,
+but `@foo:matrix.evil.corp` usernames are ugly and everyone wants to be `@foo:evil.corp`.
+
+To solve that problem, Matrix implements this extra step via a .well-known file or a DNS entry.
@@ -0,0 +1,20 @@
+site_name: Conduit Docs
+site_description: Conduit is a simple, fast and reliable chat server for the Matrix protocol
+theme:
+  name: material
+repo_url: https://gitlab.com/famedly/conduit
+nav:
+  - Home: index.md
+  - Installation:
+      - Prerequisites: installation/prerequisites.md
+      - Distribution Packages: installation/packages.md
+      - Manual: installation/manual.md
+      - Docker: installation/docker.md
+  - Configuration:
+      - Conduit.toml: configuration/conduit.toml.md
+      - Appservices: configuration/appservices.md
+  - Development:
+      - Basics: development/basics.md
+      - Cross compilation: development/cross-compilation.md
+      - Tests & CI: development/tests-ci.md
+
@@ -1 +1 @@
-1.53
+1.52
@@ -15,28 +15,19 @@ use ruma::{
                ThirdPartyIdRemovalStatus,
            },
            contact::get_contacts,
-            uiaa::{AuthFlow, AuthType, UiaaInfo},
+            uiaa::{AuthFlow, UiaaInfo},
        },
    },
    events::{
        room::{
-            canonical_alias::RoomCanonicalAliasEventContent,
-            create::RoomCreateEventContent,
-            guest_access::{GuestAccess, RoomGuestAccessEventContent},
-            history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
-            join_rules::{JoinRule, RoomJoinRulesEventContent},
-            member::{MembershipState, RoomMemberEventContent},
-            message::RoomMessageEventContent,
-            name::RoomNameEventContent,
-            power_levels::RoomPowerLevelsEventContent,
-            topic::RoomTopicEventContent,
+            canonical_alias, guest_access, history_visibility, join_rules, member, message, name,
+            topic,
        },
        EventType,
    },
    identifiers::RoomName,
-    push, RoomAliasId, RoomId, UserId,
+    push, RoomAliasId, RoomId, RoomVersionId, UserId,
 };
-use serde_json::value::to_raw_value;
 use tracing::info;

 use register::RegistrationKind;
@@ -156,7 +147,7 @@ pub async fn register_route(
    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Dummy],
+            stages: vec!["m.login.dummy".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -279,16 +270,16 @@ pub async fn register_route(
        );
        let state_lock = mutex_state.lock().await;

-        let mut content = RoomCreateEventContent::new(conduit_user.clone());
+        let mut content = ruma::events::room::create::CreateEventContent::new(conduit_user.clone());
        content.federate = true;
        content.predecessor = None;
-        content.room_version = db.globals.default_room_version();
+        content.room_version = RoomVersionId::Version6;

        // 1. The room create event
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomCreate,
-                content: to_raw_value(&content).expect("event is valid, we just created it"),
+                content: serde_json::to_value(content).expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
                redacts: None,
@@ -303,8 +294,8 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
-                content: to_raw_value(&RoomMemberEventContent {
-                    membership: MembershipState::Join,
+                content: serde_json::to_value(member::MemberEventContent {
+                    membership: member::MembershipState::Join,
                    displayname: None,
                    avatar_url: None,
                    is_direct: None,
@@ -331,10 +322,12 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomPowerLevels,
-                content: to_raw_value(&RoomPowerLevelsEventContent {
+                content: serde_json::to_value(
+                    ruma::events::room::power_levels::PowerLevelsEventContent {
                        users,
                        ..Default::default()
-                })
+                    },
+                )
                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -350,7 +343,9 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomJoinRules,
-                content: to_raw_value(&RoomJoinRulesEventContent::new(JoinRule::Invite))
+                content: serde_json::to_value(join_rules::JoinRulesEventContent::new(
+                    join_rules::JoinRule::Invite,
+                ))
                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -366,9 +361,11 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomHistoryVisibility,
-                content: to_raw_value(&RoomHistoryVisibilityEventContent::new(
-                    HistoryVisibility::Shared,
-                ))
+                content: serde_json::to_value(
+                    history_visibility::HistoryVisibilityEventContent::new(
+                        history_visibility::HistoryVisibility::Shared,
+                    ),
+                )
                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -384,7 +381,9 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomGuestAccess,
-                content: to_raw_value(&RoomGuestAccessEventContent::new(GuestAccess::Forbidden))
+                content: serde_json::to_value(guest_access::GuestAccessEventContent::new(
+                    guest_access::GuestAccess::Forbidden,
+                ))
                .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -403,7 +402,7 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomName,
-                content: to_raw_value(&RoomNameEventContent::new(Some(room_name)))
+                content: serde_json::to_value(name::NameEventContent::new(Some(room_name)))
                    .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -418,7 +417,7 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomTopic,
-                content: to_raw_value(&RoomTopicEventContent {
+                content: serde_json::to_value(topic::TopicEventContent {
                    topic: format!("Manage {}", db.globals.server_name()),
                })
                .expect("event is valid, we just created it"),
@@ -440,7 +439,7 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomCanonicalAlias,
-                content: to_raw_value(&RoomCanonicalAliasEventContent {
+                content: serde_json::to_value(canonical_alias::CanonicalAliasEventContent {
                    alias: Some(alias.clone()),
                    alt_aliases: Vec::new(),
                })
@@ -461,8 +460,8 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
-                content: to_raw_value(&RoomMemberEventContent {
-                    membership: MembershipState::Invite,
+                content: serde_json::to_value(member::MemberEventContent {
+                    membership: member::MembershipState::Invite,
                    displayname: None,
                    avatar_url: None,
                    is_direct: None,
@@ -483,8 +482,8 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
-                content: to_raw_value(&RoomMemberEventContent {
-                    membership: MembershipState::Join,
+                content: serde_json::to_value(member::MemberEventContent {
+                    membership: member::MembershipState::Join,
                    displayname: Some(displayname),
                    avatar_url: None,
                    is_direct: None,
@@ -507,7 +506,7 @@ pub async fn register_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMessage,
-                content: to_raw_value(&RoomMessageEventContent::text_html(
+                content: serde_json::to_value(message::MessageEventContent::text_html(
                        "## Thank you for trying out Conduit!\n\nConduit is currently in Beta. This means you can join and participate in most Matrix rooms, but not all features are supported and you might run into bugs from time to time.\n\nHelpful links:\n> Website: https://conduit.rs\n> Git and Documentation: https://gitlab.com/famedly/conduit\n> Report issues: https://gitlab.com/famedly/conduit/-/issues\n\nHere are some rooms you can join (by typing the command):\n\nConduit room (Ask questions and get notified on updates):\n`/join #conduit:fachschaften.org`\n\nConduit lounge (Off-topic, only Conduit users are allowed to join)\n`/join #conduit-lounge:conduit.rs`".to_owned(),
                        "<h2>Thank you for trying out Conduit!</h2>\n<p>Conduit is currently in Beta. This means you can join and participate in most Matrix rooms, but not all features are supported and you might run into bugs from time to time.</p>\n<p>Helpful links:</p>\n<blockquote>\n<p>Website: https://conduit.rs<br>Git and Documentation: https://gitlab.com/famedly/conduit<br>Report issues: https://gitlab.com/famedly/conduit/-/issues</p>\n</blockquote>\n<p>Here are some rooms you can join (by typing the command):</p>\n<p>Conduit room (Ask questions and get notified on updates):<br><code>/join #conduit:fachschaften.org</code></p>\n<p>Conduit lounge (Off-topic, only Conduit users are allowed to join)<br><code>/join #conduit-lounge:conduit.rs</code></p>\n".to_owned(),
                ))
@@ -563,7 +562,7 @@ pub async fn change_password_route(

    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Password],
+            stages: vec!["m.login.password".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -655,7 +654,7 @@ pub async fn deactivate_route(

    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Password],
+            stages: vec!["m.login.password".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -699,8 +698,8 @@ pub async fn deactivate_route(

    for room_id in all_rooms {
        let room_id = room_id?;
-        let event = RoomMemberEventContent {
-            membership: MembershipState::Leave,
+        let event = member::MemberEventContent {
+            membership: member::MembershipState::Leave,
            displayname: None,
            avatar_url: None,
            is_direct: None,
@@ -722,7 +721,7 @@ pub async fn deactivate_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
-                content: to_raw_value(&event).expect("event is valid, we just created it"),
+                content: serde_json::to_value(event).expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some(sender_user.to_string()),
                redacts: None,
@@ -1,6 +1,9 @@
-use crate::{database::DatabaseGuard, ConduitResult, Ruma};
-use ruma::api::client::r0::capabilities::{
+use crate::{ConduitResult, Ruma};
+use ruma::{
+    api::client::r0::capabilities::{
        get_capabilities, Capabilities, RoomVersionStability, RoomVersionsCapability,
+    },
+    RoomVersionId,
 };
 use std::collections::BTreeMap;

@@ -14,28 +17,17 @@ use rocket::get;
    feature = "conduit_bin",
    get("/_matrix/client/r0/capabilities", data = "<_body>")
 )]
-#[tracing::instrument(skip(_body, db))]
+#[tracing::instrument(skip(_body))]
 pub async fn get_capabilities_route(
    _body: Ruma<get_capabilities::Request>,
-    db: DatabaseGuard,
 ) -> ConduitResult<get_capabilities::Response> {
    let mut available = BTreeMap::new();
-    if db.globals.allow_unstable_room_versions() {
-        for room_version in &db.globals.unstable_room_versions {
-            available.insert(room_version.clone(), RoomVersionStability::Stable);
-        }
-    } else {
-        for room_version in &db.globals.unstable_room_versions {
-            available.insert(room_version.clone(), RoomVersionStability::Unstable);
-        }
-    }
-    for room_version in &db.globals.stable_room_versions {
-        available.insert(room_version.clone(), RoomVersionStability::Stable);
-    }
+    available.insert(RoomVersionId::Version5, RoomVersionStability::Stable);
+    available.insert(RoomVersionId::Version6, RoomVersionStability::Stable);

    let mut capabilities = Capabilities::new();
    capabilities.room_versions = RoomVersionsCapability {
-        default: db.globals.default_room_version(),
+        default: RoomVersionId::Version6,
        available,
    };

@@ -30,7 +30,7 @@ pub async fn set_global_account_data_route(
 ) -> ConduitResult<set_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let data: serde_json::Value = serde_json::from_str(body.data.get())
+    let data = serde_json::from_str::<serde_json::Value>(body.data.get())
        .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;

    let event_type = body.event_type.to_string();
@@ -68,7 +68,7 @@ pub async fn set_room_account_data_route(
 ) -> ConduitResult<set_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let data: serde_json::Value = serde_json::from_str(body.data.get())
+    let data = serde_json::from_str::<serde_json::Value>(body.data.get())
        .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Data is invalid."))?;

    let event_type = body.event_type.to_string();
@@ -103,9 +103,9 @@ pub async fn get_global_account_data_route(
 ) -> ConduitResult<get_global_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let event: Box<RawJsonValue> = db
+    let event = db
        .account_data
-        .get(None, sender_user, body.event_type.clone().into())?
+        .get::<Box<RawJsonValue>>(None, sender_user, body.event_type.clone().into())?
        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Data not found."))?;

    let account_data = serde_json::from_str::<ExtractGlobalEventContent>(event.get())
@@ -132,9 +132,9 @@ pub async fn get_room_account_data_route(
 ) -> ConduitResult<get_room_account_data::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let event: Box<RawJsonValue> = db
+    let event = db
        .account_data
-        .get(
+        .get::<Box<RawJsonValue>>(
            Some(&body.room_id),
            sender_user,
            body.event_type.clone().into(),
@@ -48,7 +48,7 @@ pub async fn get_context_route(
        ))?
        .to_room_event();

-    let events_before: Vec<_> = db
+    let events_before = db
        .rooms
        .pdus_until(sender_user, &body.room_id, base_token)?
        .take(
@@ -58,19 +58,19 @@ pub async fn get_context_route(
                / 2,
        )
        .filter_map(|r| r.ok()) // Remove buggy events
-        .collect();
+        .collect::<Vec<_>>();

    let start_token = events_before
        .last()
        .and_then(|(pdu_id, _)| db.rooms.pdu_count(pdu_id).ok())
        .map(|count| count.to_string());

-    let events_before: Vec<_> = events_before
+    let events_before = events_before
        .into_iter()
        .map(|(_, pdu)| pdu.to_room_event())
-        .collect();
+        .collect::<Vec<_>>();

-    let events_after: Vec<_> = db
+    let events_after = db
        .rooms
        .pdus_after(sender_user, &body.room_id, base_token)?
        .take(
@@ -80,17 +80,17 @@ pub async fn get_context_route(
                / 2,
        )
        .filter_map(|r| r.ok()) // Remove buggy events
-        .collect();
+        .collect::<Vec<_>>();

    let end_token = events_after
        .last()
        .and_then(|(pdu_id, _)| db.rooms.pdu_count(pdu_id).ok())
        .map(|count| count.to_string());

-    let events_after: Vec<_> = events_after
+    let events_after = events_after
        .into_iter()
        .map(|(_, pdu)| pdu.to_room_event())
-        .collect();
+        .collect::<Vec<_>>();

    let mut resp = get_context::Response::new();
    resp.start = start_token;
@@ -3,7 +3,7 @@ use ruma::api::client::{
    error::ErrorKind,
    r0::{
        device::{self, delete_device, delete_devices, get_device, get_devices, update_device},
-        uiaa::{AuthFlow, AuthType, UiaaInfo},
+        uiaa::{AuthFlow, UiaaInfo},
    },
 };

@@ -25,11 +25,11 @@ pub async fn get_devices_route(
 ) -> ConduitResult<get_devices::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let devices: Vec<device::Device> = db
+    let devices = db
        .users
        .all_devices_metadata(sender_user)
        .filter_map(|r| r.ok()) // Filter out buggy devices
-        .collect();
+        .collect::<Vec<device::Device>>();

    Ok(get_devices::Response { devices }.into())
 }
@@ -109,7 +109,7 @@ pub async fn delete_device_route(
    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Password],
+            stages: vec!["m.login.password".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -172,7 +172,7 @@ pub async fn delete_devices_route(
    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Password],
+            stages: vec!["m.login.password".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -17,16 +17,10 @@ use ruma::{
    },
    directory::{Filter, IncomingFilter, IncomingRoomNetwork, PublicRoomsChunk, RoomNetwork},
    events::{
-        room::{
-            avatar::RoomAvatarEventContent,
-            canonical_alias::RoomCanonicalAliasEventContent,
-            guest_access::{GuestAccess, RoomGuestAccessEventContent},
-            history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
-            name::RoomNameEventContent,
-            topic::RoomTopicEventContent,
-        },
+        room::{avatar, canonical_alias, guest_access, history_visibility, name, topic},
        EventType,
    },
+    serde::Raw,
    ServerName, UInt,
 };
 use tracing::{info, warn};
@@ -223,8 +217,8 @@ pub(crate) async fn get_public_rooms_filtered_helper(
        }
    }

-    let mut all_rooms: Vec<_> = db
-        .rooms
+    let mut all_rooms =
+        db.rooms
            .public_rooms()
            .map(|room_id| {
                let room_id = room_id?;
@@ -234,22 +228,30 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                    canonical_alias: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomCanonicalAlias, "")?
-                    .map_or(Ok(None), |s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomCanonicalAliasEventContent| c.alias)
+                        .map_or(Ok::<_, Error>(None), |s| {
+                            Ok(serde_json::from_value::<
+                                Raw<canonical_alias::CanonicalAliasEventContent>,
+                            >(s.content.clone())
+                            .expect("from_value::<Raw<..>> can never fail")
+                            .deserialize()
                            .map_err(|_| {
                                Error::bad_database("Invalid canonical alias event in database.")
-                            })
+                            })?
+                            .alias)
                        })?,
                    name: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomName, "")?
-                    .map_or(Ok(None), |s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomNameEventContent| c.name)
+                        .map_or(Ok::<_, Error>(None), |s| {
+                            Ok(serde_json::from_value::<Raw<name::NameEventContent>>(
+                                s.content.clone(),
+                            )
+                            .expect("from_value::<Raw<..>> can never fail")
+                            .deserialize()
                            .map_err(|_| {
                                Error::bad_database("Invalid room name event in database.")
-                            })
+                            })?
+                            .name)
                        })?,
                    num_joined_members: db
                        .rooms
@@ -263,48 +265,68 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                    topic: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomTopic, "")?
-                    .map_or(Ok(None), |s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomTopicEventContent| Some(c.topic))
+                        .map_or(Ok::<_, Error>(None), |s| {
+                            Ok(Some(
+                                serde_json::from_value::<Raw<topic::TopicEventContent>>(
+                                    s.content.clone(),
+                                )
+                                .expect("from_value::<Raw<..>> can never fail")
+                                .deserialize()
                                .map_err(|_| {
                                    Error::bad_database("Invalid room topic event in database.")
-                            })
+                                })?
+                                .topic,
+                            ))
                        })?,
                    world_readable: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomHistoryVisibility, "")?
-                    .map_or(Ok(false), |s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomHistoryVisibilityEventContent| {
-                                c.history_visibility == HistoryVisibility::WorldReadable
-                            })
+                        .map_or(Ok::<_, Error>(false), |s| {
+                            Ok(serde_json::from_value::<
+                                Raw<history_visibility::HistoryVisibilityEventContent>,
+                            >(s.content.clone())
+                            .expect("from_value::<Raw<..>> can never fail")
+                            .deserialize()
                            .map_err(|_| {
                                Error::bad_database(
                                    "Invalid room history visibility event in database.",
                                )
-                            })
+                            })?
+                            .history_visibility
+                                == history_visibility::HistoryVisibility::WorldReadable)
                        })?,
                    guest_can_join: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomGuestAccess, "")?
-                    .map_or(Ok(false), |s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomGuestAccessEventContent| {
-                                c.guest_access == GuestAccess::CanJoin
-                            })
+                        .map_or(Ok::<_, Error>(false), |s| {
+                            Ok(
+                            serde_json::from_value::<Raw<guest_access::GuestAccessEventContent>>(
+                                s.content.clone(),
+                            )
+                            .expect("from_value::<Raw<..>> can never fail")
+                            .deserialize()
                            .map_err(|_| {
                                Error::bad_database("Invalid room guest access event in database.")
-                            })
+                            })?
+                            .guest_access
+                                == guest_access::GuestAccess::CanJoin,
+                        )
                        })?,
                    avatar_url: db
                        .rooms
                        .room_state_get(&room_id, &EventType::RoomAvatar, "")?
                        .map(|s| {
-                        serde_json::from_str(s.content.get())
-                            .map(|c: RoomAvatarEventContent| c.url)
+                            Ok::<_, Error>(
+                                serde_json::from_value::<Raw<avatar::AvatarEventContent>>(
+                                    s.content.clone(),
+                                )
+                                .expect("from_value::<Raw<..>> can never fail")
+                                .deserialize()
                                .map_err(|_| {
                                    Error::bad_database("Invalid room avatar event in database.")
-                            })
+                                })?
+                                .url,
+                            )
                        })
                        .transpose()?
                        // url is now an Option<String> so we must flatten
@@ -345,17 +367,17 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                }
            })
            // We need to collect all, so we can sort by member count
-        .collect();
+            .collect::<Vec<_>>();

    all_rooms.sort_by(|l, r| r.num_joined_members.cmp(&l.num_joined_members));

    let total_room_count_estimate = (all_rooms.len() as u32).into();

-    let chunk: Vec<_> = all_rooms
+    let chunk = all_rooms
        .into_iter()
        .skip(num_since as usize)
        .take(limit as usize)
-        .collect();
+        .collect::<Vec<_>>();

    let prev_batch = if num_since == 0 {
        None
@@ -10,7 +10,7 @@ use ruma::{
                    claim_keys, get_key_changes, get_keys, upload_keys, upload_signatures,
                    upload_signing_keys,
                },
-                uiaa::{AuthFlow, AuthType, UiaaInfo},
+                uiaa::{AuthFlow, UiaaInfo},
            },
        },
        federation,
@@ -148,7 +148,7 @@ pub async fn upload_signing_keys_route(
    // UIAA
    let mut uiaainfo = UiaaInfo {
        flows: vec![AuthFlow {
-            stages: vec![AuthType::Password],
+            stages: vec!["m.login.password".to_owned()],
        }],
        completed: Vec::new(),
        params: Default::default(),
@@ -395,7 +395,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(

    let mut failures = BTreeMap::new();

-    let mut futures: FuturesUnordered<_> = get_over_federation
+    let mut futures = get_over_federation
        .into_iter()
        .map(|(server, vec)| async move {
            let mut device_keys_input_fed = BTreeMap::new();
@@ -415,7 +415,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
                    .await,
            )
        })
-        .collect();
+        .collect::<FuturesUnordered<_>>();

    while let Some((server, response)) = futures.next().await {
        match response {
@@ -1,9 +1,10 @@
 use crate::{
    client_server,
    database::DatabaseGuard,
-    pdu::{EventHash, PduBuilder, PduEvent},
+    pdu::{PduBuilder, PduEvent},
    server_server, utils, ConduitResult, Database, Error, Result, Ruma,
 };
+use member::{MemberEventContent, MembershipState};
 use ruma::{
    api::{
        client::{
@@ -17,17 +18,14 @@ use ruma::{
        federation::{self, membership::create_invite},
    },
    events::{
-        room::{
-            create::RoomCreateEventContent,
-            member::{MembershipState, RoomMemberEventContent},
-        },
+        pdu::Pdu,
+        room::{create::CreateEventContent, member},
        EventType,
    },
-    serde::{to_canonical_value, CanonicalJsonObject, CanonicalJsonValue},
+    serde::{to_canonical_value, CanonicalJsonObject, CanonicalJsonValue, Raw},
    state_res::{self, RoomVersion},
    uint, EventId, RoomId, RoomVersionId, ServerName, UserId,
 };
-use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use std::{
    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
    convert::{TryFrom, TryInto},
@@ -56,17 +54,19 @@ pub async fn join_room_by_id_route(
 ) -> ConduitResult<join_room_by_id::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let mut servers: HashSet<_> = db
+    let mut servers = db
        .rooms
        .invite_state(sender_user, &body.room_id)?
        .unwrap_or_default()
        .iter()
-        .filter_map(|event| serde_json::from_str(event.json().get()).ok())
-        .filter_map(|event: serde_json::Value| event.get("sender").cloned())
+        .filter_map(|event| {
+            serde_json::from_str::<serde_json::Value>(&event.json().to_string()).ok()
+        })
+        .filter_map(|event| event.get("sender").cloned())
        .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
        .filter_map(|sender| UserId::try_from(sender).ok())
        .map(|user| user.server_name().to_owned())
-        .collect();
+        .collect::<HashSet<_>>();

    servers.insert(body.room_id.server_name().to_owned());

@@ -103,17 +103,19 @@ pub async fn join_room_by_id_or_alias_route(

    let (servers, room_id) = match RoomId::try_from(body.room_id_or_alias.clone()) {
        Ok(room_id) => {
-            let mut servers: HashSet<_> = db
+            let mut servers = db
                .rooms
                .invite_state(sender_user, &room_id)?
                .unwrap_or_default()
                .iter()
-                .filter_map(|event| serde_json::from_str(event.json().get()).ok())
-                .filter_map(|event: serde_json::Value| event.get("sender").cloned())
+                .filter_map(|event| {
+                    serde_json::from_str::<serde_json::Value>(&event.json().to_string()).ok()
+                })
+                .filter_map(|event| event.get("sender").cloned())
                .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
                .filter_map(|sender| UserId::try_from(sender).ok())
                .map(|user| user.server_name().to_owned())
-                .collect();
+                .collect::<HashSet<_>>();

            servers.insert(room_id.server_name().to_owned());
            (servers, room_id)
@@ -202,7 +204,7 @@ pub async fn kick_user_route(
 ) -> ConduitResult<kick_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let mut event: RoomMemberEventContent = serde_json::from_str(
+    let mut event = serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
        db.rooms
            .room_state_get(
                &body.room_id,
@@ -214,11 +216,13 @@ pub async fn kick_user_route(
                "Cannot kick member that's not in the room.",
            ))?
            .content
-            .get(),
+            .clone(),
    )
+    .expect("Raw::from_value always works")
+    .deserialize()
    .map_err(|_| Error::bad_database("Invalid member event in database."))?;

-    event.membership = MembershipState::Leave;
+    event.membership = ruma::events::room::member::MembershipState::Leave;
    // TODO: reason

    let mutex_state = Arc::clone(
@@ -234,7 +238,7 @@ pub async fn kick_user_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&event).expect("event is valid, we just created it"),
+            content: serde_json::to_value(event).expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some(body.user_id.to_string()),
            redacts: None,
@@ -276,8 +280,8 @@ pub async fn ban_user_route(
            &body.user_id.to_string(),
        )?
        .map_or(
-            Ok(RoomMemberEventContent {
-                membership: MembershipState::Ban,
+            Ok::<_, Error>(member::MemberEventContent {
+                membership: member::MembershipState::Ban,
                displayname: db.users.displayname(&body.user_id)?,
                avatar_url: db.users.avatar_url(&body.user_id)?,
                is_direct: None,
@@ -286,12 +290,14 @@ pub async fn ban_user_route(
                reason: None,
            }),
            |event| {
-                serde_json::from_str(event.content.get())
-                    .map(|event: RoomMemberEventContent| RoomMemberEventContent {
-                        membership: MembershipState::Ban,
-                        ..event
-                    })
-                    .map_err(|_| Error::bad_database("Invalid member event in database."))
+                let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
+                    event.content.clone(),
+                )
+                .expect("Raw::from_value always works")
+                .deserialize()
+                .map_err(|_| Error::bad_database("Invalid member event in database."))?;
+                event.membership = ruma::events::room::member::MembershipState::Ban;
+                Ok(event)
            },
        )?;

@@ -308,7 +314,7 @@ pub async fn ban_user_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&event).expect("event is valid, we just created it"),
+            content: serde_json::to_value(event).expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some(body.user_id.to_string()),
            redacts: None,
@@ -340,7 +346,7 @@ pub async fn unban_user_route(
 ) -> ConduitResult<unban_user::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let mut event: RoomMemberEventContent = serde_json::from_str(
+    let mut event = serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
        db.rooms
            .room_state_get(
                &body.room_id,
@@ -352,11 +358,13 @@ pub async fn unban_user_route(
                "Cannot unban a user who is not banned.",
            ))?
            .content
-            .get(),
+            .clone(),
    )
+    .expect("from_value::<Raw<..>> can never fail")
+    .deserialize()
    .map_err(|_| Error::bad_database("Invalid member event in database."))?;

-    event.membership = MembershipState::Leave;
+    event.membership = ruma::events::room::member::MembershipState::Leave;

    let mutex_state = Arc::clone(
        db.globals
@@ -371,7 +379,7 @@ pub async fn unban_user_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&event).expect("event is valid, we just created it"),
+            content: serde_json::to_value(event).expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some(body.user_id.to_string()),
            redacts: None,
@@ -551,7 +559,7 @@ async fn join_room_by_id_helper(
                    federation::membership::create_join_event_template::v1::Request {
                        room_id,
                        user_id: sender_user,
-                        ver: &db.globals.supported_room_versions(),
+                        ver: &[RoomVersionId::Version5, RoomVersionId::Version6],
                    },
                )
                .await;
@@ -566,12 +574,18 @@ async fn join_room_by_id_helper(
        let (make_join_response, remote_server) = make_join_response_and_server?;

        let room_version = match make_join_response.room_version {
-            Some(room_version) if db.rooms.is_supported_version(&db, &room_version) => room_version,
+            Some(room_version)
+                if room_version == RoomVersionId::Version5
+                    || room_version == RoomVersionId::Version6 =>
+            {
+                room_version
+            }
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

-        let mut join_event_stub: CanonicalJsonObject =
-            serde_json::from_str(make_join_response.event.get()).map_err(|_| {
+        let mut join_event_stub =
+            serde_json::from_str::<CanonicalJsonObject>(make_join_response.event.json().get())
+                .map_err(|_| {
                    Error::BadServerResponse("Invalid make_join event json received from server.")
                })?;

@@ -590,8 +604,8 @@ async fn join_room_by_id_helper(
        );
        join_event_stub.insert(
            "content".to_owned(),
-            to_canonical_value(RoomMemberEventContent {
-                membership: MembershipState::Join,
+            to_canonical_value(member::MemberEventContent {
+                membership: member::MembershipState::Join,
                displayname: db.users.displayname(sender_user)?,
                avatar_url: db.users.avatar_url(sender_user)?,
                is_direct: None,
@@ -639,7 +653,7 @@ async fn join_room_by_id_helper(
                federation::membership::create_join_event::v2::Request {
                    room_id,
                    event_id: &event_id,
-                    pdu: &PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
+                    pdu: PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
                },
            )
            .await?;
@@ -709,7 +723,7 @@ async fn join_room_by_id_helper(
            state
                .into_iter()
                .map(|(k, id)| db.rooms.compress_state_event(k, &id, &db.globals))
-                .collect::<Result<_>>()?,
+                .collect::<Result<HashSet<_>>>()?,
            db,
        )?;

@@ -742,8 +756,8 @@ async fn join_room_by_id_helper(
        // where events in the current room state do not exist
        db.rooms.set_room_state(room_id, statehashid)?;
    } else {
-        let event = RoomMemberEventContent {
-            membership: MembershipState::Join,
+        let event = member::MemberEventContent {
+            membership: member::MembershipState::Join,
            displayname: db.users.displayname(sender_user)?,
            avatar_url: db.users.avatar_url(sender_user)?,
            is_direct: None,
@@ -755,7 +769,7 @@ async fn join_room_by_id_helper(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomMember,
-                content: to_raw_value(&event).expect("event is valid, we just created it"),
+                content: serde_json::to_value(event).expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some(sender_user.to_string()),
                redacts: None,
@@ -775,12 +789,12 @@ async fn join_room_by_id_helper(
 }

 fn validate_and_add_event_id(
-    pdu: &RawJsonValue,
+    pdu: &Raw<Pdu>,
    room_version: &RoomVersionId,
    pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
    db: &Database,
 ) -> Result<(EventId, CanonicalJsonObject)> {
-    let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
+    let mut value = serde_json::from_str::<CanonicalJsonObject>(pdu.json().get()).map_err(|e| {
        error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
        Error::BadServerResponse("Invalid PDU in server response")
    })?;
@@ -856,21 +870,24 @@ pub(crate) async fn invite_helper<'a>(
            );
            let state_lock = mutex_state.lock().await;

-            let prev_events: Vec<_> = db
+            let prev_events = db
                .rooms
                .get_pdu_leaves(room_id)?
                .into_iter()
                .take(20)
-                .collect();
+                .collect::<Vec<_>>();

            let create_event = db
                .rooms
                .room_state_get(room_id, &EventType::RoomCreate, "")?;

-            let create_event_content: Option<RoomCreateEventContent> = create_event
+            let create_event_content = create_event
                .as_ref()
                .map(|create_event| {
-                    serde_json::from_str(create_event.content.get()).map_err(|e| {
+                    serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+                        .expect("Raw::from_value always works.")
+                        .deserialize()
+                        .map_err(|e| {
                            warn!("Invalid create event: {}", e);
                            Error::bad_database("Invalid create event in db.")
                        })
@@ -885,16 +902,15 @@ pub(crate) async fn invite_helper<'a>(
                None
            };

-            // If there was no create event yet, assume we are creating a room with the default
-            // version right now
+            // If there was no create event yet, assume we are creating a version 6 room right now
            let room_version_id = create_event_content
-                .map_or(db.globals.default_room_version(), |create_event| {
+                .map_or(RoomVersionId::Version6, |create_event| {
                    create_event.room_version
                });
            let room_version =
                RoomVersion::new(&room_version_id).expect("room version is supported");

-            let content = to_raw_value(&RoomMemberEventContent {
+            let content = serde_json::to_value(MemberEventContent {
                avatar_url: None,
                displayname: None,
                is_direct: Some(is_direct),
@@ -930,7 +946,7 @@ pub(crate) async fn invite_helper<'a>(
                unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
                unsigned.insert(
                    "prev_sender".to_owned(),
-                    to_raw_value(&prev_pdu.sender).expect("UserId is valid"),
+                    serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
                );
            }

@@ -951,15 +967,11 @@ pub(crate) async fn invite_helper<'a>(
                    .map(|(_, pdu)| pdu.event_id.clone())
                    .collect(),
                redacts: None,
-                unsigned: if unsigned.is_empty() {
-                    None
-                } else {
-                    Some(to_raw_value(&unsigned).expect("to_raw_value always works"))
-                },
-                hashes: EventHash {
+                unsigned,
+                hashes: ruma::events::pdu::EventHash {
                    sha256: "aaa".to_owned(),
                },
-                signatures: None,
+                signatures: BTreeMap::new(),
            };

            let auth_check = state_res::auth_check(
@@ -1023,11 +1035,11 @@ pub(crate) async fn invite_helper<'a>(
                &db.globals,
                user_id.server_name(),
                create_invite::v2::Request {
-                    room_id,
-                    event_id: &expected_event_id,
-                    room_version: &room_version_id,
-                    event: &PduEvent::convert_to_outgoing_federation_event(pdu_json.clone()),
-                    invite_room_state: &invite_room_state,
+                    room_id: room_id.clone(),
+                    event_id: expected_event_id.clone(),
+                    room_version: room_version_id,
+                    event: PduEvent::convert_to_outgoing_federation_event(pdu_json.clone()),
+                    invite_room_state,
                },
            )
            .await?;
@@ -1035,8 +1047,7 @@ pub(crate) async fn invite_helper<'a>(
        let pub_key_map = RwLock::new(BTreeMap::new());

        // We do not add the event_id field to the pdu here because of signature and hashes checks
-        let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(&response.event, &db)
-        {
+        let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(&response.event) {
            Ok(t) => t,
            Err(_) => {
                // Event could not be converted to canonical json
@@ -1051,7 +1062,7 @@ pub(crate) async fn invite_helper<'a>(
            warn!("Server {} changed invite event, that's not allowed in the spec: ours: {:?}, theirs: {:?}", user_id.server_name(), pdu_json, value);
        }

-        let origin: Box<ServerName> = serde_json::from_value(
+        let origin = serde_json::from_value::<Box<ServerName>>(
            serde_json::to_value(value.get("origin").ok_or(Error::BadRequest(
                ErrorKind::InvalidParam,
                "Event needs an origin field.",
@@ -1081,13 +1092,14 @@ pub(crate) async fn invite_helper<'a>(
            "Could not accept incoming PDU as timeline event.",
        ))?;

-        let servers = db
+        for server in db
            .rooms
            .room_servers(room_id)
            .filter_map(|r| r.ok())
-            .filter(|server| &**server != db.globals.server_name());
-
-        db.sending.send_pdu(servers, &pdu_id)?;
+            .filter(|server| &**server != db.globals.server_name())
+        {
+            db.sending.send_pdu(&server, &pdu_id)?;
+        }

        return Ok(());
    }
@@ -1105,8 +1117,8 @@ pub(crate) async fn invite_helper<'a>(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&RoomMemberEventContent {
-                membership: MembershipState::Invite,
+            content: serde_json::to_value(member::MemberEventContent {
+                membership: member::MembershipState::Invite,
                displayname: db.users.displayname(user_id)?,
                avatar_url: db.users.avatar_url(user_id)?,
                is_direct: Some(is_direct),
@@ -45,14 +45,6 @@ pub async fn send_message_event_route(
    );
    let state_lock = mutex_state.lock().await;

-    // Forbid m.room.encrypted if encryption is disabled
-    if &body.event_type == "m.room.encrypted" && !db.globals.allow_encryption() {
-        return Err(Error::BadRequest(
-            ErrorKind::Forbidden,
-            "Encryption has been disabled",
-        ));
-    }
-
    // Check if this is a new transaction id
    if let Some(response) =
        db.transaction_ids
@@ -140,11 +132,14 @@ pub async fn get_message_events_route(
    let to = body.to.as_ref().map(|t| t.parse());

    // Use limit or else 10
-    let limit = body.limit.try_into().map_or(10_usize, |l: u32| l as usize);
+    let limit = body
+        .limit
+        .try_into()
+        .map_or(Ok::<_, Error>(10_usize), |l: u32| Ok(l as usize))?;

    match body.dir {
        get_message_events::Direction::Forward => {
-            let events_after: Vec<_> = db
+            let events_after = db
                .rooms
                .pdus_after(sender_user, &body.room_id, from)?
                .take(limit)
@@ -156,14 +151,14 @@ pub async fn get_message_events_route(
                        .ok()
                })
                .take_while(|&(k, _)| Some(Ok(k)) != to) // Stop at `to`
-                .collect();
+                .collect::<Vec<_>>();

            let end_token = events_after.last().map(|(count, _)| count.to_string());

-            let events_after: Vec<_> = events_after
+            let events_after = events_after
                .into_iter()
                .map(|(_, pdu)| pdu.to_room_event())
-                .collect();
+                .collect::<Vec<_>>();

            let mut resp = get_message_events::Response::new();
            resp.start = Some(body.from.to_owned());
@@ -174,7 +169,7 @@ pub async fn get_message_events_route(
            Ok(resp.into())
        }
        get_message_events::Direction::Backward => {
-            let events_before: Vec<_> = db
+            let events_before = db
                .rooms
                .pdus_until(sender_user, &body.room_id, from)?
                .take(limit)
@@ -186,14 +181,14 @@ pub async fn get_message_events_route(
                        .ok()
                })
                .take_while(|&(k, _)| Some(Ok(k)) != to) // Stop at `to`
-                .collect();
+                .collect::<Vec<_>>();

            let start_token = events_before.last().map(|(count, _)| count.to_string());

-            let events_before: Vec<_> = events_before
+            let events_before = events_before
                .into_iter()
                .map(|(_, pdu)| pdu.to_room_event())
-                .collect();
+                .collect::<Vec<_>>();

            let mut resp = get_message_events::Response::new();
            resp.start = Some(body.from.to_owned());
@@ -16,7 +16,6 @@ mod profile;
 mod push;
 mod read_marker;
 mod redact;
-mod report;
 mod room;
 mod search;
 mod session;
@@ -48,7 +47,6 @@ pub use profile::*;
 pub use push::*;
 pub use read_marker::*;
 pub use redact::*;
-pub use report::*;
 pub use room::*;
 pub use search::*;
 pub use session::*;
@@ -9,9 +9,9 @@ use ruma::{
        },
        federation::{self, query::get_profile_information::v1::ProfileField},
    },
-    events::{room::member::RoomMemberEventContent, EventType},
+    events::EventType,
+    serde::Raw,
 };
-use serde_json::value::to_raw_value;
 use std::{convert::TryInto, sync::Arc};

 #[cfg(feature = "conduit_bin")]
@@ -45,9 +45,9 @@ pub async fn set_displayname_route(
            Ok::<_, Error>((
                PduBuilder {
                    event_type: EventType::RoomMember,
-                    content: to_raw_value(&RoomMemberEventContent {
+                    content: serde_json::to_value(ruma::events::room::member::MemberEventContent {
                        displayname: body.displayname.clone(),
-                        ..serde_json::from_str(
+                        ..serde_json::from_value::<Raw<_>>(
                            db.rooms
                                .room_state_get(
                                    &room_id,
@@ -61,8 +61,10 @@ pub async fn set_displayname_route(
                                    )
                                })?
                                .content
-                                .get(),
+                                .clone(),
                        )
+                        .expect("from_value::<Raw<..>> can never fail")
+                        .deserialize()
                        .map_err(|_| Error::bad_database("Database contains invalid PDU."))?
                    })
                    .expect("event is valid, we just created it"),
@@ -188,9 +190,9 @@ pub async fn set_avatar_url_route(
            Ok::<_, Error>((
                PduBuilder {
                    event_type: EventType::RoomMember,
-                    content: to_raw_value(&RoomMemberEventContent {
+                    content: serde_json::to_value(ruma::events::room::member::MemberEventContent {
                        avatar_url: body.avatar_url.clone(),
-                        ..serde_json::from_str(
+                        ..serde_json::from_value::<Raw<_>>(
                            db.rooms
                                .room_state_get(
                                    &room_id,
@@ -204,8 +206,10 @@ pub async fn set_avatar_url_route(
                                    )
                                })?
                                .content
-                                .get(),
+                                .clone(),
                        )
+                        .expect("from_value::<Raw<..>> can never fail")
+                        .deserialize()
                        .map_err(|_| Error::bad_database("Database contains invalid PDU."))?
                    })
                    .expect("event is valid, we just created it"),
@@ -8,7 +8,7 @@ use ruma::{
            set_pushrule_enabled, RuleKind,
        },
    },
-    events::{push_rules::PushRulesEvent, EventType},
+    events::{push_rules, EventType},
    push::{ConditionalPushRuleInit, PatternedPushRuleInit, SimplePushRuleInit},
 };

@@ -29,9 +29,9 @@ pub async fn get_pushrules_all_route(
 ) -> ConduitResult<get_pushrules_all::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let event: PushRulesEvent = db
+    let event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -57,9 +57,9 @@ pub async fn get_pushrule_route(
 ) -> ConduitResult<get_pushrule::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    let event: PushRulesEvent = db
+    let event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -122,9 +122,9 @@ pub async fn set_pushrule_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -222,9 +222,9 @@ pub async fn get_pushrule_actions_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -284,9 +284,9 @@ pub async fn set_pushrule_actions_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -356,9 +356,9 @@ pub async fn get_pushrule_enabled_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -420,9 +420,9 @@ pub async fn set_pushrule_enabled_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<ruma::events::push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -497,9 +497,9 @@ pub async fn delete_pushrule_route(
        ));
    }

-    let mut event: PushRulesEvent = db
+    let mut event = db
        .account_data
-        .get(None, sender_user, EventType::PushRules)?
+        .get::<push_rules::PushRulesEvent>(None, sender_user, EventType::PushRules)?
        .ok_or(Error::BadRequest(
            ErrorKind::NotFound,
            "PushRules event not found.",
@@ -3,12 +3,11 @@ use std::sync::Arc;
 use crate::{database::DatabaseGuard, pdu::PduBuilder, ConduitResult, Ruma};
 use ruma::{
    api::client::r0::redact::redact_event,
-    events::{room::redaction::RoomRedactionEventContent, EventType},
+    events::{room::redaction, EventType},
 };

 #[cfg(feature = "conduit_bin")]
 use rocket::put;
-use serde_json::value::to_raw_value;

 /// # `PUT /_matrix/client/r0/rooms/{roomId}/redact/{eventId}/{txnId}`
 ///
@@ -39,7 +38,7 @@ pub async fn redact_event_route(
    let event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomRedaction,
-            content: to_raw_value(&RoomRedactionEventContent {
+            content: serde_json::to_value(redaction::RedactionEventContent {
                reason: body.reason.clone(),
            })
            .expect("event is valid, we just created it"),
@@ -1,83 +0,0 @@
-use crate::{database::admin::AdminCommand, database::DatabaseGuard, ConduitResult, Error, Ruma};
-use ruma::{
-    api::client::{error::ErrorKind, r0::room::report_content},
-    events::room::message,
-    Int,
-};
-
-#[cfg(feature = "conduit_bin")]
-use rocket::{http::RawStr, post};
-
-/// # `POST /_matrix/client/r0/rooms/{roomId}/report/{eventId}`
-///
-/// Reports an inappropriate event to homeserver admins
-///
-#[cfg_attr(
-    feature = "conduit_bin",
-    post("/_matrix/client/r0/rooms/<_>/report/<_>", data = "<body>")
-)]
-#[tracing::instrument(skip(db, body))]
-pub async fn report_event_route(
-    db: DatabaseGuard,
-    body: Ruma<report_content::Request<'_>>,
-) -> ConduitResult<report_content::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
-    let pdu = match db.rooms.get_pdu(&body.event_id)? {
-        Some(pdu) => pdu,
-        _ => {
-            return Err(Error::BadRequest(
-                ErrorKind::InvalidParam,
-                "Invalid Event ID",
-            ))
-        }
-    };
-
-    if body.score > Int::from(0) || body.score < Int::from(-100) {
-        return Err(Error::BadRequest(
-            ErrorKind::InvalidParam,
-            "Invalid score, must be within 0 to -100",
-        ));
-    };
-
-    if body.reason.chars().count() > 250 {
-        return Err(Error::BadRequest(
-            ErrorKind::InvalidParam,
-            "Reason too long, should be 250 characters or fewer",
-        ));
-    };
-
-    db.admin.send(AdminCommand::SendMessage(
-        message::RoomMessageEventContent::text_html(
-            format!(
-                "Report received from: {}\n\n\
-                Event ID: {}\n\
-                Room ID: {}\n\
-                Sent By: {}\n\n\
-                Report Score: {}\n\
-                Report Reason: {}",
-                sender_user, pdu.event_id, pdu.room_id, pdu.sender, body.score, body.reason
-            )
-            .to_owned(),
-            format!(
-                "<details><summary>Report received from: <a href=\"https://matrix.to/#/{0}\">{0}\
-                </a></summary><ul><li>Event Info<ul><li>Event ID: <code>{1}</code>\
-                <a href=\"https://matrix.to/#/{2}/{1}\">🔗</a></li><li>Room ID: <code>{2}</code>\
-                </li><li>Sent By: <a href=\"https://matrix.to/#/{3}\">{3}</a></li></ul></li><li>\
-                Report Info<ul><li>Report Score: {4}</li><li>Report Reason: {5}</li></ul></li>\
-                </ul></details>",
-                sender_user,
-                pdu.event_id,
-                pdu.room_id,
-                pdu.sender,
-                body.score,
-                RawStr::new(&body.reason).html_escape()
-            )
-            .to_owned(),
-        ),
-    ));
-
-    db.flush()?;
-
-    Ok(report_content::Response {}.into())
-}
@@ -8,30 +8,13 @@ use ruma::{
        r0::room::{self, aliases, create_room, get_room_event, upgrade_room},
    },
    events::{
-        room::{
-            canonical_alias::RoomCanonicalAliasEventContent,
-            create::RoomCreateEventContent,
-            guest_access::{GuestAccess, RoomGuestAccessEventContent},
-            history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
-            join_rules::{JoinRule, RoomJoinRulesEventContent},
-            member::{MembershipState, RoomMemberEventContent},
-            name::RoomNameEventContent,
-            power_levels::RoomPowerLevelsEventContent,
-            tombstone::RoomTombstoneEventContent,
-            topic::RoomTopicEventContent,
-        },
+        room::{guest_access, history_visibility, join_rules, member, name, topic},
        EventType,
    },
-    serde::{CanonicalJsonObject, JsonObject},
-    RoomAliasId, RoomId,
-};
-use serde_json::{json, value::to_raw_value};
-use std::{
-    cmp::max,
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
+    serde::Raw,
+    RoomAliasId, RoomId, RoomVersionId,
 };
+use std::{cmp::max, collections::BTreeMap, convert::TryFrom, sync::Arc};
 use tracing::{info, warn};

 #[cfg(feature = "conduit_bin")]
@@ -78,16 +61,6 @@ pub async fn create_room_route(
    );
    let state_lock = mutex_state.lock().await;

-    if !db.globals.allow_room_creation()
-        && !body.from_appservice
-        && !db.users.is_admin(sender_user, &db.rooms, &db.globals)?
-    {
-        return Err(Error::BadRequest(
-            ErrorKind::Forbidden,
-            "Room creation has been disabled.",
-        ));
-    }
-
    let alias: Option<RoomAliasId> =
        body.room_alias_name
            .as_ref()
@@ -107,9 +80,12 @@ pub async fn create_room_route(
                }
            })?;

-    let room_version = match body.room_version.clone() {
+    let mut content = ruma::events::room::create::CreateEventContent::new(sender_user.clone());
+    content.federate = body.creation_content.federate;
+    content.predecessor = body.creation_content.predecessor.clone();
+    content.room_version = match body.room_version.clone() {
        Some(room_version) => {
-            if db.rooms.is_supported_version(&db, &room_version) {
+            if room_version == RoomVersionId::Version5 || room_version == RoomVersionId::Version6 {
                room_version
            } else {
                return Err(Error::BadRequest(
@@ -118,64 +94,14 @@ pub async fn create_room_route(
                ));
            }
        }
-        None => db.globals.default_room_version(),
+        None => RoomVersionId::Version6,
    };

-    let content = match &body.creation_content {
-        Some(content) => {
-            let mut content = content
-                .deserialize_as::<CanonicalJsonObject>()
-                .expect("Invalid creation content");
-            content.insert(
-                "creator".into(),
-                json!(&sender_user).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content.insert(
-                "room_version".into(),
-                json!(room_version.as_str()).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content
-        }
-        None => {
-            let mut content = serde_json::from_str::<CanonicalJsonObject>(
-                to_raw_value(&RoomCreateEventContent::new(sender_user.clone()))
-                    .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid creation content"))?
-                    .get(),
-            )
-            .unwrap();
-            content.insert(
-                "room_version".into(),
-                json!(room_version.as_str()).try_into().map_err(|_| {
-                    Error::BadRequest(ErrorKind::BadJson, "Invalid creation content")
-                })?,
-            );
-            content
-        }
-    };
-
-    // Validate creation content
-    let de_result = serde_json::from_str::<CanonicalJsonObject>(
-        to_raw_value(&content)
-            .expect("Invalid creation content")
-            .get(),
-    );
-
-    if let Err(_) = de_result {
-        return Err(Error::BadRequest(
-            ErrorKind::BadJson,
-            "Invalid creation content",
-        ));
-    }
-
    // 1. The room create event
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomCreate,
-            content: to_raw_value(&content).expect("event is valid, we just created it"),
+            content: serde_json::to_value(content).expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some("".to_owned()),
            redacts: None,
@@ -190,8 +116,8 @@ pub async fn create_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&RoomMemberEventContent {
-                membership: MembershipState::Join,
+            content: serde_json::to_value(member::MemberEventContent {
+                membership: member::MembershipState::Join,
                displayname: db.users.displayname(sender_user)?,
                avatar_url: db.users.avatar_url(sender_user)?,
                is_direct: Some(body.is_direct),
@@ -231,14 +157,17 @@ pub async fn create_room_route(
        }
    }

-    let mut power_levels_content = serde_json::to_value(RoomPowerLevelsEventContent {
+    let mut power_levels_content =
+        serde_json::to_value(ruma::events::room::power_levels::PowerLevelsEventContent {
            users,
            ..Default::default()
        })
        .expect("event is valid, we just created it");

    if let Some(power_level_content_override) = &body.power_level_content_override {
-        let json: JsonObject = serde_json::from_str(power_level_content_override.json().get())
+        let json = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(
+            power_level_content_override.json().get(),
+        )
        .map_err(|_| {
            Error::BadRequest(ErrorKind::BadJson, "Invalid power_level_content_override.")
        })?;
@@ -251,8 +180,7 @@ pub async fn create_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomPowerLevels,
-            content: to_raw_value(&power_levels_content)
-                .expect("to_raw_value always works on serde_json::Value"),
+            content: power_levels_content,
            unsigned: None,
            state_key: Some("".to_owned()),
            redacts: None,
@@ -268,10 +196,12 @@ pub async fn create_room_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomCanonicalAlias,
-                content: to_raw_value(&RoomCanonicalAliasEventContent {
+                content: serde_json::to_value(
+                    ruma::events::room::canonical_alias::CanonicalAliasEventContent {
                        alias: Some(room_alias_id.clone()),
                        alt_aliases: vec![],
-                })
+                    },
+                )
                .expect("We checked that alias earlier, it must be fine"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -290,12 +220,17 @@ pub async fn create_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomJoinRules,
-            content: to_raw_value(&RoomJoinRulesEventContent::new(match preset {
-                create_room::RoomPreset::PublicChat => JoinRule::Public,
-                // according to spec "invite" is the default
-                _ => JoinRule::Invite,
-            }))
+            content: match preset {
+                create_room::RoomPreset::PublicChat => serde_json::to_value(
+                    join_rules::JoinRulesEventContent::new(join_rules::JoinRule::Public),
+                )
                .expect("event is valid, we just created it"),
+                // according to spec "invite" is the default
+                _ => serde_json::to_value(join_rules::JoinRulesEventContent::new(
+                    join_rules::JoinRule::Invite,
+                ))
+                .expect("event is valid, we just created it"),
+            },
            unsigned: None,
            state_key: Some("".to_owned()),
            redacts: None,
@@ -310,8 +245,8 @@ pub async fn create_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomHistoryVisibility,
-            content: to_raw_value(&RoomHistoryVisibilityEventContent::new(
-                HistoryVisibility::Shared,
+            content: serde_json::to_value(history_visibility::HistoryVisibilityEventContent::new(
+                history_visibility::HistoryVisibility::Shared,
            ))
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -328,11 +263,18 @@ pub async fn create_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomGuestAccess,
-            content: to_raw_value(&RoomGuestAccessEventContent::new(match preset {
-                create_room::RoomPreset::PublicChat => GuestAccess::Forbidden,
-                _ => GuestAccess::CanJoin,
-            }))
+            content: match preset {
+                create_room::RoomPreset::PublicChat => {
+                    serde_json::to_value(guest_access::GuestAccessEventContent::new(
+                        guest_access::GuestAccess::Forbidden,
+                    ))
+                    .expect("event is valid, we just created it")
+                }
+                _ => serde_json::to_value(guest_access::GuestAccessEventContent::new(
+                    guest_access::GuestAccess::CanJoin,
+                ))
                .expect("event is valid, we just created it"),
+            },
            unsigned: None,
            state_key: Some("".to_owned()),
            redacts: None,
@@ -364,7 +306,7 @@ pub async fn create_room_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomName,
-                content: to_raw_value(&RoomNameEventContent::new(Some(name.clone())))
+                content: serde_json::to_value(name::NameEventContent::new(Some(name.clone())))
                    .expect("event is valid, we just created it"),
                unsigned: None,
                state_key: Some("".to_owned()),
@@ -381,7 +323,7 @@ pub async fn create_room_route(
        db.rooms.build_and_append_pdu(
            PduBuilder {
                event_type: EventType::RoomTopic,
-                content: to_raw_value(&RoomTopicEventContent {
+                content: serde_json::to_value(topic::TopicEventContent {
                    topic: topic.clone(),
                })
                .expect("event is valid, we just created it"),
@@ -484,7 +426,7 @@ pub async fn get_room_aliases_route(
    .into())
 }

-/// # `POST /_matrix/client/r0/rooms/{roomId}/upgrade`
+/// # `GET /_matrix/client/r0/rooms/{roomId}/upgrade`
 ///
 /// Upgrades the room.
 ///
@@ -505,7 +447,10 @@ pub async fn upgrade_room_route(
 ) -> ConduitResult<upgrade_room::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    if !db.rooms.is_supported_version(&db, &body.new_version) {
+    if !matches!(
+        body.new_version,
+        RoomVersionId::Version5 | RoomVersionId::Version6
+    ) {
        return Err(Error::BadRequest(
            ErrorKind::UnsupportedRoomVersion,
            "This server does not support that room version.",
@@ -532,8 +477,8 @@ pub async fn upgrade_room_route(
    let tombstone_event_id = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomTombstone,
-            content: to_raw_value(&RoomTombstoneEventContent {
-                body: "This room has been replaced".to_owned(),
+            content: serde_json::to_value(ruma::events::room::tombstone::TombstoneEventContent {
+                body: "This room has been replaced".to_string(),
                replacement_room: replacement_room.clone(),
            })
            .expect("event is valid, we just created it"),
@@ -559,15 +504,18 @@ pub async fn upgrade_room_route(
    );
    let state_lock = mutex_state.lock().await;

-    // Get the old room creation event
-    let mut create_event_content = serde_json::from_str::<CanonicalJsonObject>(
+    // Get the old room federations status
+    let federate = serde_json::from_value::<Raw<ruma::events::room::create::CreateEventContent>>(
        db.rooms
            .room_state_get(&body.room_id, &EventType::RoomCreate, "")?
            .ok_or_else(|| Error::bad_database("Found room without m.room.create event."))?
            .content
-            .get(),
+            .clone(),
    )
-    .map_err(|_| Error::bad_database("Invalid room event in database."))?;
+    .expect("Raw::from_value always works")
+    .deserialize()
+    .map_err(|_| Error::bad_database("Invalid room event in database."))?
+    .federate;

    // Use the m.room.tombstone event as the predecessor
    let predecessor = Some(ruma::events::room::create::PreviousRoom::new(
@@ -576,43 +524,16 @@ pub async fn upgrade_room_route(
    ));

    // Send a m.room.create event containing a predecessor field and the applicable room_version
-    create_event_content.insert(
-        "creator".into(),
-        json!(&sender_user)
-            .try_into()
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-    create_event_content.insert(
-        "room_version".into(),
-        json!(&body.new_version)
-            .try_into()
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-    create_event_content.insert(
-        "predecessor".into(),
-        json!(predecessor)
-            .try_into()
-            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Error forming creation event"))?,
-    );
-
-    // Validate creation event content
-    let de_result = serde_json::from_str::<CanonicalJsonObject>(
-        to_raw_value(&create_event_content)
-            .expect("Error forming creation event")
-            .get(),
-    );
-
-    if let Err(_) = de_result {
-        return Err(Error::BadRequest(
-            ErrorKind::BadJson,
-            "Error forming creation event",
-        ));
-    }
+    let mut create_event_content =
+        ruma::events::room::create::CreateEventContent::new(sender_user.clone());
+    create_event_content.federate = federate;
+    create_event_content.room_version = body.new_version.clone();
+    create_event_content.predecessor = predecessor;

    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomCreate,
-            content: to_raw_value(&create_event_content)
+            content: serde_json::to_value(create_event_content)
                .expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some("".to_owned()),
@@ -628,8 +549,8 @@ pub async fn upgrade_room_route(
    db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomMember,
-            content: to_raw_value(&RoomMemberEventContent {
-                membership: MembershipState::Join,
+            content: serde_json::to_value(member::MemberEventContent {
+                membership: member::MembershipState::Join,
                displayname: db.users.displayname(sender_user)?,
                avatar_url: db.users.avatar_url(sender_user)?,
                is_direct: None,
@@ -690,13 +611,16 @@ pub async fn upgrade_room_route(
    }

    // Get the old room power levels
-    let mut power_levels_event_content: RoomPowerLevelsEventContent = serde_json::from_str(
+    let mut power_levels_event_content =
+        serde_json::from_value::<Raw<ruma::events::room::power_levels::PowerLevelsEventContent>>(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomPowerLevels, "")?
                .ok_or_else(|| Error::bad_database("Found room without m.room.create event."))?
                .content
-            .get(),
+                .clone(),
        )
+        .expect("database contains invalid PDU")
+        .deserialize()
        .map_err(|_| Error::bad_database("Invalid room event in database."))?;

    // Setting events_default and invite to the greater of 50 and users_default + 1
@@ -711,7 +635,7 @@ pub async fn upgrade_room_route(
    let _ = db.rooms.build_and_append_pdu(
        PduBuilder {
            event_type: EventType::RoomPowerLevels,
-            content: to_raw_value(&power_levels_event_content)
+            content: serde_json::to_value(power_levels_event_content)
                .expect("event is valid, we just created it"),
            unsigned: None,
            state_key: Some("".to_owned()),
@@ -74,7 +74,7 @@ pub async fn search_events_route(
        }
    }

-    let results: Vec<_> = results
+    let results = results
        .iter()
        .map(|result| {
            Ok::<_, Error>(SearchResult {
@@ -95,7 +95,7 @@ pub async fn search_events_route(
        .filter_map(|r| r.ok())
        .skip(skip)
        .take(limit)
-        .collect();
+        .collect::<Vec<_>>();

    let next_batch = if results.len() < limit as usize {
        None
@@ -114,7 +114,7 @@ pub async fn search_events_route(
                .search_term
                .split_terminator(|c: char| !c.is_alphanumeric())
                .map(str::to_lowercase)
-                .collect(),
+                .collect::<Vec<_>>(),
        },
    })
    .into())
@@ -60,10 +60,10 @@ pub async fn login_route(
    // Validate login method
    // TODO: Other login methods
    let user_id = match &body.login_info {
-        login::IncomingLoginInfo::Password(login::IncomingPassword {
+        login::IncomingLoginInfo::Password {
            identifier,
            password,
-        }) => {
+        } => {
            let username = if let IncomingUserIdentifier::MatrixId(matrix_id) = identifier {
                matrix_id
            } else {
@@ -97,7 +97,7 @@ pub async fn login_route(

            user_id
        }
-        login::IncomingLoginInfo::Token(login::IncomingToken { token }) => {
+        login::IncomingLoginInfo::Token { token } => {
            if let Some(jwt_decoding_key) = db.globals.jwt_decoding_key() {
                let token = jsonwebtoken::decode::<Claims>(
                    token,
@@ -116,12 +116,6 @@ pub async fn login_route(
                ));
            }
        }
-        _ => {
-            return Err(Error::BadRequest(
-                ErrorKind::Unknown,
-                "Unsupported login type.",
-            ));
-        }
    };

    // Generate new device id if the user didn't specify one
@@ -10,8 +10,8 @@ use ruma::{
    },
    events::{
        room::{
-            canonical_alias::RoomCanonicalAliasEventContent,
-            history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
+            canonical_alias::CanonicalAliasEventContent,
+            history_visibility::{HistoryVisibility, HistoryVisibilityEventContent},
        },
        AnyStateEventContent, EventType,
    },
@@ -73,14 +73,6 @@ pub async fn send_state_event_for_empty_key_route(
 ) -> ConduitResult<send_state_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    // Forbid m.room.encryption if encryption is disabled
-    if &body.event_type == "m.room.encryption" && !db.globals.allow_encryption() {
-        return Err(Error::BadRequest(
-            ErrorKind::Forbidden,
-            "Encryption has been disabled",
-        ));
-    }
-
    let event_id = send_state_event_for_key_helper(
        &db,
        sender_user,
@@ -120,13 +112,13 @@ pub async fn get_state_events_route(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
-                    serde_json::from_str(event.content.get())
-                        .map(|e: RoomHistoryVisibilityEventContent| e.history_visibility)
+                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
+                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
@@ -172,13 +164,13 @@ pub async fn get_state_events_for_key_route(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
-                    serde_json::from_str(event.content.get())
-                        .map(|e: RoomHistoryVisibilityEventContent| e.history_visibility)
+                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
+                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
@@ -198,7 +190,7 @@ pub async fn get_state_events_for_key_route(
        ))?;

    Ok(get_state_events_for_key::Response {
-        content: serde_json::from_str(event.content.get())
+        content: serde_json::from_value(event.content.clone())
            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
    }
    .into())
@@ -228,13 +220,13 @@ pub async fn get_state_events_for_empty_key_route(
            db.rooms
                .room_state_get(&body.room_id, &EventType::RoomHistoryVisibility, "")?
                .map(|event| {
-                    serde_json::from_str(event.content.get())
-                        .map(|e: RoomHistoryVisibilityEventContent| e.history_visibility)
+                    serde_json::from_value::<HistoryVisibilityEventContent>(event.content.clone())
                        .map_err(|_| {
                            Error::bad_database(
                                "Invalid room history visibility event in database.",
                            )
                        })
+                        .map(|e| e.history_visibility)
                }),
            Some(Ok(HistoryVisibility::WorldReadable))
        )
@@ -254,7 +246,7 @@ pub async fn get_state_events_for_empty_key_route(
        ))?;

    Ok(get_state_events_for_key::Response {
-        content: serde_json::from_str(event.content.get())
+        content: serde_json::from_value(event.content.clone())
            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
    }
    .into())
@@ -273,7 +265,7 @@ async fn send_state_event_for_key_helper(
    // TODO: Review this check, error if event is unparsable, use event type, allow alias if it
    // previously existed
    if let Ok(canonical_alias) =
-        serde_json::from_str::<RoomCanonicalAliasEventContent>(json.json().get())
+        serde_json::from_str::<CanonicalAliasEventContent>(json.json().get())
    {
        let mut aliases = canonical_alias.alt_aliases.clone();

@@ -1,10 +1,7 @@
 use crate::{database::DatabaseGuard, ConduitResult, Database, Error, Result, Ruma, RumaResponse};
 use ruma::{
    api::client::r0::{sync::sync_events, uiaa::UiaaResponse},
-    events::{
-        room::member::{MembershipState, RoomMemberEventContent},
-        AnySyncEphemeralRoomEvent, EventType,
-    },
+    events::{room::member::MembershipState, AnySyncEphemeralRoomEvent, EventType},
    serde::Raw,
    DeviceId, RoomId, UserId,
 };
@@ -60,7 +57,7 @@ use rocket::{get, tokio};
 pub async fn sync_events_route(
    db: DatabaseGuard,
    body: Ruma<sync_events::Request<'_>>,
-) -> Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
+) -> std::result::Result<RumaResponse<sync_events::Response>, RumaResponse<UiaaResponse>> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

@@ -182,7 +179,7 @@ async fn sync_helper(
    full_state: bool,
    timeout: Option<Duration>,
    // bool = caching allowed
-) -> Result<(sync_events::Response, bool), Error> {
+) -> std::result::Result<(sync_events::Response, bool), Error> {
    // TODO: match body.set_presence {
    db.rooms.edus.ping_presence(&sender_user)?;

@@ -244,13 +241,13 @@ async fn sync_helper(
            });

        // Take the last 10 events for the timeline
-        let timeline_pdus: Vec<_> = non_timeline_pdus
+        let timeline_pdus = non_timeline_pdus
            .by_ref()
            .take(10)
            .collect::<Vec<_>>()
            .into_iter()
            .rev()
-            .collect();
+            .collect::<Vec<_>>();

        let send_notification_counts = !timeline_pdus.is_empty()
            || db
@@ -290,10 +287,10 @@ async fn sync_helper(
                    .filter_map(|pdu| pdu.ok()) // Ignore all broken pdus
                    .filter(|(_, pdu)| pdu.kind == EventType::RoomMember)
                    .map(|(_, pdu)| {
-                        let content: RoomMemberEventContent =
-                            serde_json::from_str(pdu.content.get()).map_err(|_| {
-                                Error::bad_database("Invalid member event in database.")
-                            })?;
+                        let content = serde_json::from_value::<
+                            ruma::events::room::member::MemberEventContent,
+                        >(pdu.content.clone())
+                        .map_err(|_| Error::bad_database("Invalid member event in database."))?;

                        if let Some(state_key) = &pdu.state_key {
                            let user_id = UserId::try_from(state_key.clone()).map_err(|_| {
@@ -346,11 +343,11 @@ async fn sync_helper(
            let (joined_member_count, invited_member_count, heroes) = calculate_counts()?;

            let current_state_ids = db.rooms.state_full_ids(current_shortstatehash)?;
-            let state_events: Vec<_> = current_state_ids
+            let state_events = current_state_ids
                .iter()
                .map(|(_, id)| db.rooms.get_pdu(id))
                .filter_map(|r| r.ok().flatten())
-                .collect();
+                .collect::<Vec<_>>();

            (
                heroes,
@@ -366,7 +363,7 @@ async fn sync_helper(
            // Incremental /sync
            let since_shortstatehash = since_shortstatehash.unwrap();

-            let since_sender_member: Option<RoomMemberEventContent> = db
+            let since_sender_member = db
                .rooms
                .state_get(
                    since_shortstatehash,
@@ -374,7 +371,11 @@ async fn sync_helper(
                    sender_user.as_str(),
                )?
                .and_then(|pdu| {
-                    serde_json::from_str(pdu.content.get())
+                    serde_json::from_value::<Raw<ruma::events::room::member::MemberEventContent>>(
+                        pdu.content.clone(),
+                    )
+                    .expect("Raw::from_value always works")
+                    .deserialize()
                    .map_err(|_| Error::bad_database("Invalid PDU in database."))
                    .ok()
                });
@@ -431,9 +432,11 @@ async fn sync_helper(
                            continue;
                        }

-                        let new_membership = serde_json::from_str::<RoomMemberEventContent>(
-                            state_event.content.get(),
-                        )
+                        let new_membership = serde_json::from_value::<
+                            Raw<ruma::events::room::member::MemberEventContent>,
+                        >(state_event.content.clone())
+                        .expect("Raw::from_value always works")
+                        .deserialize()
                        .map_err(|_| Error::bad_database("Invalid PDU in database."))?
                        .membership;

@@ -522,18 +525,18 @@ async fn sync_helper(
                Ok(Some(db.rooms.pdu_count(pdu_id)?.to_string()))
            })?;

-        let room_events: Vec<_> = timeline_pdus
+        let room_events = timeline_pdus
            .iter()
            .map(|(_, pdu)| pdu.to_sync_room_event())
-            .collect();
+            .collect::<Vec<_>>();

-        let mut edus: Vec<_> = db
+        let mut edus = db
            .rooms
            .edus
            .readreceipts_since(&room_id, since)
            .filter_map(|r| r.ok()) // Filter out buggy events
            .map(|(_, _, v)| v)
-            .collect();
+            .collect::<Vec<_>>();

        if db.rooms.edus.last_typing_update(&room_id, &db.globals)? > since {
            edus.push(
@@ -562,7 +565,7 @@ async fn sync_helper(
                            .map_err(|_| Error::bad_database("Invalid account event in database."))
                            .ok()
                    })
-                    .collect(),
+                    .collect::<Vec<_>>(),
            },
            summary: sync_events::RoomSummary {
                heroes,
@@ -627,7 +630,7 @@ async fn sync_helper(
    }

    let mut left_rooms = BTreeMap::new();
-    let all_left_rooms: Vec<_> = db.rooms.rooms_left(&sender_user).collect();
+    let all_left_rooms = db.rooms.rooms_left(&sender_user).collect::<Vec<_>>();
    for result in all_left_rooms {
        let (room_id, left_state_events) = result?;

@@ -667,7 +670,7 @@ async fn sync_helper(
    }

    let mut invited_rooms = BTreeMap::new();
-    let all_invited_rooms: Vec<_> = db.rooms.rooms_invited(&sender_user).collect();
+    let all_invited_rooms = db.rooms.rooms_invited(&sender_user).collect::<Vec<_>>();
    for result in all_invited_rooms {
        let (room_id, invite_state_events) = result?;

@@ -736,7 +739,7 @@ async fn sync_helper(
        presence: sync_events::Presence {
            events: presence_updates
                .into_iter()
-                .map(|(_, v)| Raw::new(&v).expect("PresenceEvent always serializes successfully"))
+                .map(|(_, v)| Raw::from(v))
                .collect(),
        },
        account_data: sync_events::GlobalAccountData {
@@ -749,13 +752,19 @@ async fn sync_helper(
                        .map_err(|_| Error::bad_database("Invalid account event in database."))
                        .ok()
                })
-                .collect(),
+                .collect::<Vec<_>>(),
        },
        device_lists: sync_events::DeviceLists {
            changed: device_list_updates.into_iter().collect(),
            left: device_list_left.into_iter().collect(),
        },
-        device_one_time_keys_count: db.users.count_one_time_keys(&sender_user, &sender_device)?,
+        device_one_time_keys_count: if db.users.last_one_time_keys_update(&sender_user)? > since
+            || since == 0
+        {
+            db.users.count_one_time_keys(&sender_user, &sender_device)?
+        } else {
+            BTreeMap::new()
+        },
        to_device: sync_events::ToDevice {
            events: db
                .users
@@ -769,6 +778,7 @@ async fn sync_helper(
        && response.presence.is_empty()
        && response.account_data.is_empty()
        && response.device_lists.is_empty()
+        && response.device_one_time_keys_count.is_empty()
        && response.to_device.is_empty()
    {
        // Hang a few seconds so requests are not spammed
@@ -1,10 +1,7 @@
 use crate::{database::DatabaseGuard, ConduitResult, Ruma};
 use ruma::{
    api::client::r0::tag::{create_tag, delete_tag, get_tags},
-    events::{
-        tag::{TagEvent, TagEventContent},
-        EventType,
-    },
+    events::EventType,
 };
 use std::collections::BTreeMap;

@@ -29,9 +26,9 @@ pub async fn update_tag_route(

    let mut tags_event = db
        .account_data
-        .get(Some(&body.room_id), sender_user, EventType::Tag)?
-        .unwrap_or_else(|| TagEvent {
-            content: TagEventContent {
+        .get::<ruma::events::tag::TagEvent>(Some(&body.room_id), sender_user, EventType::Tag)?
+        .unwrap_or_else(|| ruma::events::tag::TagEvent {
+            content: ruma::events::tag::TagEventContent {
                tags: BTreeMap::new(),
            },
        });
@@ -71,9 +68,9 @@ pub async fn delete_tag_route(

    let mut tags_event = db
        .account_data
-        .get(Some(&body.room_id), sender_user, EventType::Tag)?
-        .unwrap_or_else(|| TagEvent {
-            content: TagEventContent {
+        .get::<ruma::events::tag::TagEvent>(Some(&body.room_id), sender_user, EventType::Tag)?
+        .unwrap_or_else(|| ruma::events::tag::TagEvent {
+            content: ruma::events::tag::TagEventContent {
                tags: BTreeMap::new(),
            },
        });
@@ -111,9 +108,9 @@ pub async fn get_tags_route(
    Ok(get_tags::Response {
        tags: db
            .account_data
-            .get(Some(&body.room_id), sender_user, EventType::Tag)?
-            .unwrap_or_else(|| TagEvent {
-                content: TagEventContent {
+            .get::<ruma::events::tag::TagEvent>(Some(&body.room_id), sender_user, EventType::Tag)?
+            .unwrap_or_else(|| ruma::events::tag::TagEvent {
+                content: ruma::events::tag::TagEventContent {
                    tags: BTreeMap::new(),
                },
            })
@@ -1,11 +1,6 @@
-use crate::{database::DatabaseGuard, ConduitResult, Ruma};
-use hmac::{Hmac, Mac, NewMac};
+use crate::ConduitResult;
 use ruma::api::client::r0::voip::get_turn_server_info;
-use ruma::SecondsSinceUnixEpoch;
-use sha1::Sha1;
-use std::time::{Duration, SystemTime};
-
-type HmacSha1 = Hmac<Sha1>;
+use std::time::Duration;

 #[cfg(feature = "conduit_bin")]
 use rocket::get;
@@ -13,46 +8,14 @@ use rocket::get;
 /// # `GET /_matrix/client/r0/voip/turnServer`
 ///
 /// TODO: Returns information about the recommended turn server.
-#[cfg_attr(
-    feature = "conduit_bin",
-    get("/_matrix/client/r0/voip/turnServer", data = "<body>")
-)]
-#[tracing::instrument(skip(body, db))]
-pub async fn turn_server_route(
-    body: Ruma<get_turn_server_info::Request>,
-    db: DatabaseGuard,
-) -> ConduitResult<get_turn_server_info::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
-
-    let turn_secret = db.globals.turn_secret();
-
-    let (username, password) = if turn_secret != "" {
-        let expiry = SecondsSinceUnixEpoch::from_system_time(
-            SystemTime::now() + Duration::from_secs(db.globals.turn_ttl()),
-        )
-        .expect("time is valid");
-
-        let username: String = format!("{}:{}", expiry.get(), sender_user);
-
-        let mut mac = HmacSha1::new_from_slice(turn_secret.as_bytes())
-            .expect("HMAC can take key of any size");
-        mac.update(username.as_bytes());
-
-        let password: String = base64::encode_config(mac.finalize().into_bytes(), base64::STANDARD);
-
-        (username, password)
-    } else {
-        (
-            db.globals.turn_username().clone(),
-            db.globals.turn_password().clone(),
-        )
-    };
-
+#[cfg_attr(feature = "conduit_bin", get("/_matrix/client/r0/voip/turnServer"))]
+#[tracing::instrument]
+pub async fn turn_server_route() -> ConduitResult<get_turn_server_info::Response> {
    Ok(get_turn_server_info::Response {
-        username: username,
-        password: password,
-        uris: db.globals.turn_uris().to_vec(),
-        ttl: Duration::from_secs(db.globals.turn_ttl()),
+        username: "".to_owned(),
+        password: "".to_owned(),
+        uris: Vec::new(),
+        ttl: Duration::from_secs(60 * 60 * 24),
    }
    .into())
 }
@@ -24,7 +24,7 @@ use rocket::{
    request::{FromRequest, Request},
    Shutdown, State,
 };
-use ruma::{DeviceId, EventId, RoomId, RoomVersionId, ServerName, UserId};
+use ruma::{DeviceId, EventId, RoomId, ServerName, UserId};
 use serde::{de::IgnoredAny, Deserialize};
 use std::{
    collections::{BTreeMap, HashMap, HashSet},
@@ -61,14 +61,8 @@ pub struct Config {
    allow_encryption: bool,
    #[serde(default = "false_fn")]
    allow_federation: bool,
-    #[serde(default = "true_fn")]
-    allow_room_creation: bool,
-    #[serde(default = "true_fn")]
-    allow_unstable_room_versions: bool,
    #[serde(default = "false_fn")]
    pub allow_jaeger: bool,
-    #[serde(default = "default_room_version")]
-    default_room_version: RoomVersionId,
    #[serde(default = "false_fn")]
    pub tracing_flame: bool,
    #[serde(default)]
@@ -78,16 +72,6 @@ pub struct Config {
    trusted_servers: Vec<Box<ServerName>>,
    #[serde(default = "default_log")]
    pub log: String,
-    #[serde(default)]
-    turn_username: String,
-    #[serde(default)]
-    turn_password: String,
-    #[serde(default = "Vec::new")]
-    turn_uris: Vec<String>,
-    #[serde(default)]
-    turn_secret: String,
-    #[serde(default = "default_turn_ttl")]
-    turn_ttl: u64,

    #[serde(flatten)]
    catchall: BTreeMap<String, IgnoredAny>,
@@ -141,18 +125,10 @@ fn default_max_concurrent_requests() -> u16 {
    100
 }

-fn default_room_version() -> RoomVersionId {
-    RoomVersionId::Version6
-}
-
 fn default_log() -> String {
    "info,state_res=warn,rocket=off,_=off,sled=off".to_owned()
 }

-fn default_turn_ttl() -> u64 {
-    60 * 60 * 24
-}
-
 #[cfg(feature = "sled")]
 pub type Engine = abstraction::sled::Engine;

@@ -523,13 +499,13 @@ impl Database {
                            if let Some(parent_stateinfo) = states_parents.last() {
                                let statediffnew = current_state
                                    .difference(&parent_stateinfo.1)
-                                    .copied()
+                                    .cloned()
                                    .collect::<HashSet<_>>();

                                let statediffremoved = parent_stateinfo
                                    .1
                                    .difference(&current_state)
-                                    .copied()
+                                    .cloned()
                                    .collect::<HashSet<_>>();

                                (statediffnew, statediffremoved)
@@ -723,7 +699,7 @@ impl Database {

                println!("Deleting starts");

-                let batch2: Vec<_> = db
+                let batch2 = db
                    .rooms
                    .tokenids
                    .iter()
@@ -735,7 +711,7 @@ impl Database {
                            None
                        }
                    })
-                    .collect();
+                    .collect::<Vec<_>>();

                for key in batch2 {
                    println!("del");
@@ -22,7 +22,7 @@ pub trait Tree: Send + Sync {
    fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>;

    fn insert(&self, key: &[u8], value: &[u8]) -> Result<()>;
-    fn insert_batch(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()>;
+    fn insert_batch<'a>(&self, iter: &mut dyn Iterator<Item = (Vec<u8>, Vec<u8>)>) -> Result<()>;

    fn remove(&self, key: &[u8]) -> Result<()>;

@@ -35,7 +35,7 @@ pub trait Tree: Send + Sync {
    ) -> Box<dyn Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a>;

    fn increment(&self, key: &[u8]) -> Result<Vec<u8>>;
-    fn increment_batch(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()>;
+    fn increment_batch<'a>(&self, iter: &mut dyn Iterator<Item = Vec<u8>>) -> Result<()>;

    fn scan_prefix<'a>(
        &'a self,
@@ -6,17 +6,16 @@ use std::{
 use crate::{pdu::PduBuilder, Database};
 use rocket::futures::{channel::mpsc, stream::StreamExt};
 use ruma::{
-    events::{room::message::RoomMessageEventContent, EventType},
+    events::{room::message, EventType},
    UserId,
 };
-use serde_json::value::to_raw_value;
 use tokio::sync::{MutexGuard, RwLock, RwLockReadGuard};
 use tracing::warn;

 pub enum AdminCommand {
    RegisterAppservice(serde_yaml::Value),
    ListAppservices,
-    SendMessage(RoomMessageEventContent),
+    SendMessage(message::MessageEventContent),
 }

 #[derive(Clone)]
@@ -59,7 +58,7 @@ impl Admin {

            drop(guard);

-            let send_message = |message: RoomMessageEventContent,
+            let send_message = |message: message::MessageEventContent,
                                guard: RwLockReadGuard<'_, Database>,
                                mutex_lock: &MutexGuard<'_, ()>| {
                guard
@@ -67,7 +66,7 @@ impl Admin {
                    .build_and_append_pdu(
                        PduBuilder {
                            event_type: EventType::RoomMessage,
-                            content: to_raw_value(&message)
+                            content: serde_json::to_value(message)
                                .expect("event is valid, we just created it"),
                            unsigned: None,
                            state_key: None,
@@ -107,9 +106,9 @@ impl Admin {
                                        count,
                                        appservices.into_iter().filter_map(|r| r.ok()).collect::<Vec<_>>().join(", ")
                                    );
-                                    send_message(RoomMessageEventContent::text_plain(output), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain(output), guard, &state_lock);
                                } else {
-                                    send_message(RoomMessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
+                                    send_message(message::MessageEventContent::text_plain("Failed to get appservices."), guard, &state_lock);
                                }
                            }
                            AdminCommand::SendMessage(message) => {
@@ -4,8 +4,7 @@ use ruma::{
        client::r0::sync::sync_events,
        federation::discovery::{ServerSigningKeys, VerifyKey},
    },
-    DeviceId, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
-    ServerSigningKeyId, UserId,
+    DeviceId, EventId, MilliSecondsSinceUnixEpoch, RoomId, ServerName, ServerSigningKeyId, UserId,
 };
 use std::{
    collections::{BTreeMap, HashMap},
@@ -40,8 +39,6 @@ pub struct Globals {
    keypair: Arc<ruma::signatures::Ed25519KeyPair>,
    dns_resolver: TokioAsyncResolver,
    jwt_decoding_key: Option<jsonwebtoken::DecodingKey<'static>>,
-    pub stable_room_versions: Vec<RoomVersionId>,
-    pub unstable_room_versions: Vec<RoomVersionId>,
    pub(super) server_signingkeys: Arc<dyn Tree>,
    pub bad_event_ratelimiter: Arc<RwLock<HashMap<EventId, RateLimitState>>>,
    pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
@@ -60,7 +57,8 @@ pub struct RotationHandler(broadcast::Sender<()>, broadcast::Receiver<()>);

 impl RotationHandler {
    pub fn new() -> Self {
-        let (s, r) = broadcast::channel(1);
+        let (s, r) = broadcast::channel::<()>(1);
+
        Self(s, r)
    }

@@ -135,16 +133,7 @@ impl Globals {
            .as_ref()
            .map(|secret| jsonwebtoken::DecodingKey::from_secret(secret.as_bytes()).into_static());

-        // Supported and stable room versions
-        let stable_room_versions = vec![RoomVersionId::Version6];
-        // Experimental, partially supported room versions
-        let unstable_room_versions = vec![
-            RoomVersionId::Version3,
-            RoomVersionId::Version4,
-            RoomVersionId::Version5,
-        ];
-
-        let mut s = Self {
+        let s = Self {
            globals,
            config,
            keypair: Arc::new(keypair),
@@ -155,8 +144,6 @@ impl Globals {
            tls_name_override,
            server_signingkeys,
            jwt_decoding_key,
-            stable_room_versions,
-            unstable_room_versions,
            bad_event_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
            bad_signature_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
            servername_ratelimiter: Arc::new(RwLock::new(HashMap::new())),
@@ -169,14 +156,6 @@ impl Globals {

        fs::create_dir_all(s.get_media_folder())?;

-        if !s
-            .supported_room_versions()
-            .contains(&s.config.default_room_version)
-        {
-            error!("Room version in config isn't supported, falling back to Version 6");
-            s.config.default_room_version = RoomVersionId::Version6;
-        };
-
        Ok(s)
    }

@@ -232,18 +211,6 @@ impl Globals {
        self.config.allow_federation
    }

-    pub fn allow_room_creation(&self) -> bool {
-        self.config.allow_room_creation
-    }
-
-    pub fn allow_unstable_room_versions(&self) -> bool {
-        self.config.allow_unstable_room_versions
-    }
-
-    pub fn default_room_version(&self) -> RoomVersionId {
-        self.config.default_room_version.clone()
-    }
-
    pub fn trusted_servers(&self) -> &[Box<ServerName>] {
        &self.config.trusted_servers
    }
@@ -256,35 +223,6 @@ impl Globals {
        self.jwt_decoding_key.as_ref()
    }

-    pub fn turn_password(&self) -> &String {
-        &self.config.turn_password
-    }
-
-    pub fn turn_ttl(&self) -> u64 {
-        self.config.turn_ttl
-    }
-
-    pub fn turn_uris(&self) -> &[String] {
-        &self.config.turn_uris
-    }
-
-    pub fn turn_username(&self) -> &String {
-        &self.config.turn_username
-    }
-
-    pub fn turn_secret(&self) -> &String {
-        &self.config.turn_secret
-    }
-
-    pub fn supported_room_versions(&self) -> Vec<RoomVersionId> {
-        let mut room_versions: Vec<RoomVersionId> = vec![];
-        room_versions.extend(self.stable_room_versions.clone());
-        if self.allow_unstable_room_versions() {
-            room_versions.extend(self.unstable_room_versions.clone());
-        };
-        room_versions
-    }
-
    /// TODO: the key valid until timestamp is only honored in room version > 4
    /// Remove the outdated keys and insert the new ones.
    ///
@@ -336,8 +274,8 @@ impl Globals {
        let signingkeys = self
            .server_signingkeys
            .get(origin.as_bytes())?
-            .and_then(|bytes| serde_json::from_slice(&bytes).ok())
-            .map(|keys: ServerSigningKeys| {
+            .and_then(|bytes| serde_json::from_slice::<ServerSigningKeys>(&bytes).ok())
+            .map(|keys| {
                let mut tree = keys.verify_keys;
                tree.extend(
                    keys.old_verify_keys
@@ -81,7 +81,7 @@ impl KeyBackups {
        )?;
        self.backupid_etag
            .insert(&key, &globals.next_count()?.to_be_bytes())?;
-        Ok(version.to_owned())
+        Ok(version.to_string())
    }

    pub fn get_latest_backup_version(&self, user_id: &UserId) -> Result<Option<String>> {
@@ -94,15 +94,15 @@ impl KeyBackups {
            .iter_from(&last_possible_key, true)
            .take_while(move |(k, _)| k.starts_with(&prefix))
            .next()
-            .map(|(key, _)| {
+            .map_or(Ok(None), |(key, _)| {
                utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
                        .expect("rsplit always returns an element"),
                )
                .map_err(|_| Error::bad_database("backupid_algorithm key is invalid."))
+                .map(Some)
            })
-            .transpose()
    }

    pub fn get_latest_backup(&self, user_id: &UserId) -> Result<Option<(String, BackupAlgorithm)>> {
@@ -115,7 +115,7 @@ impl KeyBackups {
            .iter_from(&last_possible_key, true)
            .take_while(move |(k, _)| k.starts_with(&prefix))
            .next()
-            .map(|(key, value)| {
+            .map_or(Ok(None), |(key, value)| {
                let version = utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
@@ -123,14 +123,13 @@ impl KeyBackups {
                )
                .map_err(|_| Error::bad_database("backupid_algorithm key is invalid."))?;

-                Ok((
+                Ok(Some((
                    version,
                    serde_json::from_slice(&value).map_err(|_| {
                        Error::bad_database("Algorithm in backupid_algorithm is invalid.")
                    })?,
-                ))
+                )))
            })
-            .transpose()
    }

    pub fn get_backup(&self, user_id: &UserId, version: &str) -> Result<Option<BackupAlgorithm>> {
@@ -125,7 +125,7 @@ impl WildCardedDomain {
 }
 impl std::str::FromStr for WildCardedDomain {
    type Err = std::convert::Infallible;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        // maybe do some domain validation?
        Ok(if s.starts_with("*.") {
            WildCardedDomain::WildCarded(s[1..].to_owned())
@@ -136,8 +136,8 @@ impl std::str::FromStr for WildCardedDomain {
        })
    }
 }
-impl<'de> Deserialize<'de> for WildCardedDomain {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+impl<'de> serde::de::Deserialize<'de> for WildCardedDomain {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::de::Deserializer<'de>,
    {
@@ -9,10 +9,8 @@ use ruma::{
        },
        IncomingResponse, OutgoingRequest, SendAccessToken,
    },
-    events::{
-        room::{name::RoomNameEventContent, power_levels::RoomPowerLevelsEventContent},
-        AnySyncRoomEvent, EventType,
-    },
+    events::{room::power_levels::PowerLevelsEventContent, AnySyncRoomEvent, EventType},
+    identifiers::RoomName,
    push::{Action, PushConditionRoomCtx, PushFormat, Ruleset, Tweak},
    serde::Raw,
    uint, RoomId, UInt, UserId,
@@ -179,11 +177,11 @@ pub async fn send_push_notice(
    let mut notify = None;
    let mut tweaks = Vec::new();

-    let power_levels: RoomPowerLevelsEventContent = db
+    let power_levels: PowerLevelsEventContent = db
        .rooms
        .room_state_get(&pdu.room_id, &EventType::RoomPowerLevels, "")?
        .map(|ev| {
-            serde_json::from_str(ev.content.get())
+            serde_json::from_value(ev.content.clone())
                .map_err(|_| Error::bad_database("invalid m.room.power_levels event"))
        })
        .transpose()?
@@ -228,7 +226,7 @@ pub async fn send_push_notice(
 pub fn get_actions<'a>(
    user: &UserId,
    ruleset: &'a Ruleset,
-    power_levels: &RoomPowerLevelsEventContent,
+    power_levels: &PowerLevelsEventContent,
    pdu: &Raw<AnySyncRoomEvent>,
    room_id: &RoomId,
    db: &Database,
@@ -320,18 +318,16 @@ async fn send_notice(

        let user_name = db.users.displayname(&event.sender)?;
        notifi.sender_display_name = user_name.as_deref();
-
-        let room_name = if let Some(room_name_pdu) =
-            db.rooms
+        let room_name = db
+            .rooms
            .room_state_get(&event.room_id, &EventType::RoomName, "")?
-        {
-            serde_json::from_str::<RoomNameEventContent>(room_name_pdu.content.get())
-                .map_err(|_| Error::bad_database("Invalid room name event in database."))?
-                .name
-        } else {
-            None
-        };
-
+            .map(|pdu| match pdu.content.get("name") {
+                Some(serde_json::Value::String(s)) => {
+                    Some(Box::<RoomName>::try_from(&**s).expect("room name is valid"))
+                }
+                _ => None,
+            })
+            .flatten();
        notifi.room_name = room_name.as_deref();

        send_request(
@@ -1,11 +1,9 @@
 mod edus;

 pub use edus::RoomEdus;
+use member::MembershipState;

-use crate::{
-    pdu::{EventHash, PduBuilder},
-    server_server, utils, Database, Error, PduEvent, Result,
-};
+use crate::{pdu::PduBuilder, server_server, utils, Database, Error, PduEvent, Result};
 use lru_cache::LruCache;
 use regex::Regex;
 use ring::digest;
@@ -13,27 +11,18 @@ use rocket::http::RawStr;
 use ruma::{
    api::{client::error::ErrorKind, federation},
    events::{
-        direct::DirectEvent,
-        ignored_user_list::IgnoredUserListEvent,
-        push_rules::PushRulesEvent,
+        ignored_user_list, push_rules,
        room::{
-            create::RoomCreateEventContent,
-            member::{MembershipState, RoomMemberEventContent},
-            message::RoomMessageEventContent,
-            power_levels::RoomPowerLevelsEventContent,
+            create::CreateEventContent, member, message, power_levels::PowerLevelsEventContent,
        },
-        tag::TagEvent,
        AnyStrippedStateEvent, AnySyncStateEvent, EventType,
    },
-    push::{Action, Ruleset, Tweak},
+    push::{self, Action, Tweak},
    serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
    state_res::{self, RoomVersion, StateMap},
    uint, EventId, RoomAliasId, RoomId, RoomVersionId, ServerName, UserId,
 };
-use serde::Deserialize;
-use serde_json::value::to_raw_value;
 use std::{
-    borrow::Cow,
    collections::{BTreeMap, HashMap, HashSet},
    convert::{TryFrom, TryInto},
    mem::size_of,
@@ -53,7 +42,7 @@ pub type StateHashId = Vec<u8>;
 pub type CompressedStateEvent = [u8; 2 * size_of::<u64>()];

 pub struct Rooms {
-    pub edus: RoomEdus,
+    pub edus: edus::RoomEdus,
    pub(super) pduid_pdu: Arc<dyn Tree>, // PduId = ShortRoomId + Count
    pub(super) eventid_pduid: Arc<dyn Tree>,
    pub(super) roomid_pduleaves: Arc<dyn Tree>,
@@ -129,12 +118,6 @@ pub struct Rooms {
 }

 impl Rooms {
-    /// Returns true if a given room version is supported
-    #[tracing::instrument(skip(self, db))]
-    pub fn is_supported_version(&self, db: &Database, room_version: &RoomVersionId) -> bool {
-        db.globals.supported_room_versions().contains(room_version)
-    }
-
    /// Builds a StateMap by iterating over all keys that start
    /// with state_hash, this gives the full state for the given state_hash.
    #[tracing::instrument(skip(self))]
@@ -227,16 +210,16 @@ impl Rooms {
        self.eventid_shorteventid
            .get(event_id.as_bytes())?
            .map_or(Ok(None), |shorteventid| {
-                self.shorteventid_shortstatehash
-                    .get(&shorteventid)?
-                    .map(|bytes| {
-                        utils::u64_from_bytes(&bytes).map_err(|_| {
+                self.shorteventid_shortstatehash.get(&shorteventid)?.map_or(
+                    Ok::<_, Error>(None),
+                    |bytes| {
+                        Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
                            Error::bad_database(
                                "Invalid shortstatehash bytes in shorteventid_shortstatehash",
                            )
-                        })
-                    })
-                    .transpose()
+                        })?))
+                    },
+                )
            })
    }

@@ -260,7 +243,7 @@ impl Rooms {
        kind: &EventType,
        sender: &UserId,
        state_key: Option<&str>,
-        content: &serde_json::value::RawValue,
+        content: &serde_json::Value,
    ) -> Result<StateMap<Arc<PduEvent>>> {
        let shortstatehash =
            if let Some(current_shortstatehash) = self.current_shortstatehash(room_id)? {
@@ -269,8 +252,7 @@ impl Rooms {
                return Ok(HashMap::new());
            };

-        let auth_events = state_res::auth_types_for_event(kind, sender, state_key, content)
-            .expect("content is a valid JSON object");
+        let auth_events = state_res::auth_types_for_event(kind, sender, state_key, content);

        let mut sauthevents = auth_events
            .into_iter()
@@ -378,16 +360,16 @@ impl Rooms {

        let (statediffnew, statediffremoved) = if let Some(parent_stateinfo) = states_parents.last()
        {
-            let statediffnew: HashSet<_> = new_state_ids_compressed
+            let statediffnew = new_state_ids_compressed
                .difference(&parent_stateinfo.1)
-                .copied()
-                .collect();
+                .cloned()
+                .collect::<HashSet<_>>();

-            let statediffremoved: HashSet<_> = parent_stateinfo
+            let statediffremoved = parent_stateinfo
                .1
                .difference(&new_state_ids_compressed)
-                .copied()
-                .collect();
+                .cloned()
+                .collect::<HashSet<_>>();

            (statediffnew, statediffremoved)
        } else {
@@ -409,43 +391,37 @@ impl Rooms {
                .ok()
                .map(|(_, id)| id)
        }) {
-            let pdu = match self.get_pdu_json(&event_id)? {
-                Some(pdu) => pdu,
-                None => continue,
-            };
-
-            if pdu.get("type").and_then(|val| val.as_str()) != Some("m.room.member") {
-                continue;
-            }
-
-            let pdu: PduEvent = match serde_json::from_str(
-                &serde_json::to_string(&pdu).expect("CanonicalJsonObj can be serialized to JSON"),
+            if let Some(pdu) = self.get_pdu_json(&event_id)? {
+                if pdu.get("type").and_then(|val| val.as_str()) == Some("m.room.member") {
+                    if let Ok(pdu) = serde_json::from_value::<PduEvent>(
+                        serde_json::to_value(&pdu).expect("CanonicalJsonObj is a valid JsonValue"),
                    ) {
-                Ok(pdu) => pdu,
-                Err(_) => continue,
-            };
-
-            #[derive(Deserialize)]
-            struct ExtractMembership {
-                membership: MembershipState,
+                        if let Some(membership) =
+                            pdu.content.get("membership").and_then(|membership| {
+                                serde_json::from_value::<member::MembershipState>(
+                                    membership.clone(),
+                                )
+                                .ok()
+                            })
+                        {
+                            if let Some(state_key) = pdu
+                                .state_key
+                                .and_then(|state_key| UserId::try_from(state_key).ok())
+                            {
+                                self.update_membership(
+                                    room_id,
+                                    &state_key,
+                                    membership,
+                                    &pdu.sender,
+                                    None,
+                                    db,
+                                    false,
+                                )?;
+                            }
+                        }
+                    }
+                }
            }
-
-            let membership = match serde_json::from_str::<ExtractMembership>(pdu.content.get()) {
-                Ok(e) => e.membership,
-                Err(_) => continue,
-            };
-
-            let state_key = match pdu.state_key {
-                Some(k) => k,
-                None => continue,
-            };
-
-            let user_id = match UserId::try_from(state_key) {
-                Ok(id) => id,
-                Err(_) => continue,
-            };
-
-            self.update_membership(room_id, &user_id, membership, &pdu.sender, None, db, false)?;
        }

        self.update_joined_count(room_id, db)?;
@@ -507,7 +483,7 @@ impl Rooms {
        if parent != 0_u64 {
            let mut response = self.load_shortstatehash_info(parent)?;
            let mut state = response.last().unwrap().1.clone();
-            state.extend(added.iter().copied());
+            state.extend(added.iter().cloned());
            for r in &removed {
                state.remove(r);
            }
@@ -989,8 +965,7 @@ impl Rooms {
    pub fn get_pdu_count(&self, event_id: &EventId) -> Result<Option<u64>> {
        self.eventid_pduid
            .get(event_id.as_bytes())?
-            .map(|pdu_id| self.pdu_count(&pdu_id))
-            .transpose()
+            .map_or(Ok(None), |pdu_id| self.pdu_count(&pdu_id).map(Some))
    }

    #[tracing::instrument(skip(self))]
@@ -1018,7 +993,7 @@ impl Rooms {
    pub fn get_pdu_json(&self, event_id: &EventId) -> Result<Option<CanonicalJsonObject>> {
        self.eventid_pduid
            .get(event_id.as_bytes())?
-            .map_or_else(
+            .map_or_else::<Result<_>, _, _>(
                || self.eventid_outlierpdu.get(event_id.as_bytes()),
                |pduid| {
                    Ok(Some(self.pduid_pdu.get(&pduid)?.ok_or_else(|| {
@@ -1051,12 +1026,14 @@ impl Rooms {
    ) -> Result<Option<CanonicalJsonObject>> {
        self.eventid_pduid
            .get(event_id.as_bytes())?
-            .map(|pduid| {
-                self.pduid_pdu
-                    .get(&pduid)?
-                    .ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
-            })
-            .transpose()?
+            .map_or_else::<Result<_>, _, _>(
+                || Ok(None),
+                |pduid| {
+                    Ok(Some(self.pduid_pdu.get(&pduid)?.ok_or_else(|| {
+                        Error::bad_database("Invalid pduid in eventid_pduid.")
+                    })?))
+                },
+            )?
            .map(|pdu| {
                serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
            })
@@ -1066,7 +1043,9 @@ impl Rooms {
    /// Returns the pdu's id.
    #[tracing::instrument(skip(self))]
    pub fn get_pdu_id(&self, event_id: &EventId) -> Result<Option<Vec<u8>>> {
-        self.eventid_pduid.get(event_id.as_bytes())
+        self.eventid_pduid
+            .get(event_id.as_bytes())?
+            .map_or(Ok(None), |pdu_id| Ok(Some(pdu_id)))
    }

    /// Returns the pdu.
@@ -1076,12 +1055,14 @@ impl Rooms {
    pub fn get_non_outlier_pdu(&self, event_id: &EventId) -> Result<Option<PduEvent>> {
        self.eventid_pduid
            .get(event_id.as_bytes())?
-            .map(|pduid| {
-                self.pduid_pdu
-                    .get(&pduid)?
-                    .ok_or_else(|| Error::bad_database("Invalid pduid in eventid_pduid."))
-            })
-            .transpose()?
+            .map_or_else::<Result<_>, _, _>(
+                || Ok(None),
+                |pduid| {
+                    Ok(Some(self.pduid_pdu.get(&pduid)?.ok_or_else(|| {
+                        Error::bad_database("Invalid pduid in eventid_pduid.")
+                    })?))
+                },
+            )?
            .map(|pdu| {
                serde_json::from_slice(&pdu).map_err(|_| Error::bad_database("Invalid PDU in db."))
            })
@@ -1100,8 +1081,11 @@ impl Rooms {
        if let Some(pdu) = self
            .eventid_pduid
            .get(event_id.as_bytes())?
-            .map_or_else(
-                || self.eventid_outlierpdu.get(event_id.as_bytes()),
+            .map_or_else::<Result<_>, _, _>(
+                || {
+                    let r = self.eventid_outlierpdu.get(event_id.as_bytes());
+                    r
+                },
                |pduid| {
                    Ok(Some(self.pduid_pdu.get(&pduid)?.ok_or_else(|| {
                        Error::bad_database("Invalid pduid in eventid_pduid.")
@@ -1341,11 +1325,11 @@ impl Rooms {
        drop(insert_lock);

        // See if the event matches any known pushers
-        let power_levels: RoomPowerLevelsEventContent = db
+        let power_levels: PowerLevelsEventContent = db
            .rooms
            .room_state_get(&pdu.room_id, &EventType::RoomPowerLevels, "")?
            .map(|ev| {
-                serde_json::from_str(ev.content.get())
+                serde_json::from_value(ev.content.clone())
                    .map_err(|_| Error::bad_database("invalid m.room.power_levels event"))
            })
            .transpose()?
@@ -1364,9 +1348,9 @@ impl Rooms {

            let rules_for_user = db
                .account_data
-                .get(None, user, EventType::PushRules)?
-                .map(|ev: PushRulesEvent| ev.content.global)
-                .unwrap_or_else(|| Ruleset::server_default(user));
+                .get::<push_rules::PushRulesEvent>(None, user, EventType::PushRules)?
+                .map(|ev| ev.content.global)
+                .unwrap_or_else(|| push::Ruleset::server_default(user));

            let mut highlight = false;
            let mut notify = false;
@@ -1420,21 +1404,30 @@ impl Rooms {
            }
            EventType::RoomMember => {
                if let Some(state_key) = &pdu.state_key {
-                    #[derive(Deserialize)]
-                    struct ExtractMembership {
-                        membership: MembershipState,
-                    }
-
                    // if the state_key fails
                    let target_user_id = UserId::try_from(state_key.clone())
                        .expect("This state_key was previously validated");

-                    let content = serde_json::from_str::<ExtractMembership>(pdu.content.get())
-                        .map_err(|_| Error::bad_database("Invalid content in pdu."))?;
+                    let membership = serde_json::from_value::<member::MembershipState>(
+                        pdu.content
+                            .get("membership")
+                            .ok_or(Error::BadRequest(
+                                ErrorKind::InvalidParam,
+                                "Invalid member event content",
+                            ))?
+                            .clone(),
+                    )
+                    .map_err(|_| {
+                        Error::BadRequest(
+                            ErrorKind::InvalidParam,
+                            "Invalid membership state content.",
+                        )
+                    })?;

-                    let invite_state = match content.membership {
-                        MembershipState::Invite => {
+                    let invite_state = match membership {
+                        member::MembershipState::Invite => {
                            let state = self.calculate_invite_state(pdu)?;
+
                            Some(state)
                        }
                        _ => None,
@@ -1445,7 +1438,7 @@ impl Rooms {
                    self.update_membership(
                        &pdu.room_id,
                        &target_user_id,
-                        content.membership,
+                        membership,
                        &pdu.sender,
                        invite_state,
                        db,
@@ -1454,16 +1447,7 @@ impl Rooms {
                }
            }
            EventType::RoomMessage => {
-                #[derive(Deserialize)]
-                struct ExtractBody<'a> {
-                    #[serde(borrow)]
-                    body: Option<Cow<'a, str>>,
-                }
-
-                let content = serde_json::from_str::<ExtractBody<'_>>(pdu.content.get())
-                    .map_err(|_| Error::bad_database("Invalid content in pdu."))?;
-
-                if let Some(body) = content.body {
+                if let Some(body) = pdu.content.get("body").and_then(|b| b.as_str()) {
                    let mut batch = body
                        .split_terminator(|c: char| !c.is_alphanumeric())
                        .filter(|s| !s.is_empty())
@@ -1491,11 +1475,11 @@ impl Rooms {
                    {
                        let mut lines = body.lines();
                        let command_line = lines.next().expect("each string has at least one line");
-                        let body: Vec<_> = lines.collect();
+                        let body = lines.collect::<Vec<_>>();

                        let mut parts = command_line.split_whitespace().skip(1);
                        if let Some(command) = parts.next() {
-                            let args: Vec<_> = parts.collect();
+                            let args = parts.collect::<Vec<_>>();

                            match command {
                                "register_appservice" => {
@@ -1514,16 +1498,18 @@ impl Rooms {
                                            }
                                            Err(e) => {
                                                db.admin.send(AdminCommand::SendMessage(
-                                                    RoomMessageEventContent::text_plain(format!(
+                                                    message::MessageEventContent::text_plain(
+                                                        format!(
                                                            "Could not parse appservice config: {}",
                                                            e
-                                                    )),
+                                                        ),
+                                                    ),
                                                ));
                                            }
                                        }
                                    } else {
                                        db.admin.send(AdminCommand::SendMessage(
-                                            RoomMessageEventContent::text_plain(
+                                            message::MessageEventContent::text_plain(
                                                "Expected code block in command body.",
                                            ),
                                        ));
@@ -1556,10 +1542,12 @@ impl Rooms {
                                                .count();
                                                let elapsed = start.elapsed();
                                                db.admin.send(AdminCommand::SendMessage(
-                                                    RoomMessageEventContent::text_plain(format!(
+                                                    message::MessageEventContent::text_plain(
+                                                        format!(
                                                    "Loaded auth chain with length {} in {:?}",
                                                    count, elapsed
-                                                    )),
+                                                ),
+                                                    ),
                                                ));
                                            }
                                        }
@@ -1592,17 +1580,14 @@ impl Rooms {
                                                ) {
                                                    Ok(pdu) => {
                                                        db.admin.send(AdminCommand::SendMessage(
-                                                            RoomMessageEventContent::text_plain(
-                                                                format!(
-                                                                    "EventId: {:?}\n{:#?}",
-                                                                    event_id, pdu
-                                                                ),
+                                                            message::MessageEventContent::text_plain(
+                                                                format!("EventId: {:?}\n{:#?}", event_id, pdu),
                                                            ),
                                                        ));
                                                    }
                                                    Err(e) => {
                                                        db.admin.send(AdminCommand::SendMessage(
-                                                            RoomMessageEventContent::text_plain(
+                                                            message::MessageEventContent::text_plain(
                                                                format!("EventId: {:?}\nCould not parse event: {}", event_id, e),
                                                            ),
                                                        ));
@@ -1611,16 +1596,18 @@ impl Rooms {
                                            }
                                            Err(e) => {
                                                db.admin.send(AdminCommand::SendMessage(
-                                                    RoomMessageEventContent::text_plain(format!(
+                                                    message::MessageEventContent::text_plain(
+                                                        format!(
                                                            "Invalid json in command body: {}",
                                                            e
-                                                    )),
+                                                        ),
+                                                    ),
                                                ));
                                            }
                                        }
                                    } else {
                                        db.admin.send(AdminCommand::SendMessage(
-                                            RoomMessageEventContent::text_plain(
+                                            message::MessageEventContent::text_plain(
                                                "Expected code block in command body.",
                                            ),
                                        ));
@@ -1642,7 +1629,7 @@ impl Rooms {
                                                        serde_json::to_string_pretty(&json)
                                                            .expect("canonical json is valid json");
                                                    db.admin.send(AdminCommand::SendMessage(
-                                                        RoomMessageEventContent::text_html(
+                                                        message::MessageEventContent::text_html(
                                                            format!("{}\n```json\n{}\n```",
                                                            if outlier {
                                                                "PDU is outlier"
@@ -1656,7 +1643,7 @@ impl Rooms {
                                                }
                                                None => {
                                                    db.admin.send(AdminCommand::SendMessage(
-                                                        RoomMessageEventContent::text_plain(
+                                                        message::MessageEventContent::text_plain(
                                                            "PDU not found.",
                                                        ),
                                                    ));
@@ -1664,14 +1651,14 @@ impl Rooms {
                                            }
                                        } else {
                                            db.admin.send(AdminCommand::SendMessage(
-                                                RoomMessageEventContent::text_plain(
+                                                message::MessageEventContent::text_plain(
                                                    "Event ID could not be parsed.",
                                                ),
                                            ));
                                        }
                                    } else {
                                        db.admin.send(AdminCommand::SendMessage(
-                                            RoomMessageEventContent::text_plain(
+                                            message::MessageEventContent::text_plain(
                                                "Usage: get_pdu <eventid>",
                                            ),
                                        ));
@@ -1679,7 +1666,7 @@ impl Rooms {
                                }
                                _ => {
                                    db.admin.send(AdminCommand::SendMessage(
-                                        RoomMessageEventContent::text_plain(format!(
+                                        message::MessageEventContent::text_plain(format!(
                                            "Unrecognized command: {}",
                                            command
                                        )),
@@ -1772,16 +1759,16 @@ impl Rooms {

            let (statediffnew, statediffremoved) =
                if let Some(parent_stateinfo) = states_parents.last() {
-                    let statediffnew: HashSet<_> = state_ids_compressed
+                    let statediffnew = state_ids_compressed
                        .difference(&parent_stateinfo.1)
-                        .copied()
-                        .collect();
+                        .cloned()
+                        .collect::<HashSet<_>>();

-                    let statediffremoved: HashSet<_> = parent_stateinfo
+                    let statediffremoved = parent_stateinfo
                        .1
                        .difference(&state_ids_compressed)
-                        .copied()
-                        .collect();
+                        .cloned()
+                        .collect::<HashSet<_>>();

                    (statediffnew, statediffremoved)
                } else {
@@ -1971,10 +1958,13 @@ impl Rooms {

        let create_event = self.room_state_get(room_id, &EventType::RoomCreate, "")?;

-        let create_event_content: Option<RoomCreateEventContent> = create_event
+        let create_event_content = create_event
            .as_ref()
            .map(|create_event| {
-                serde_json::from_str(create_event.content.get()).map_err(|e| {
+                serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+                    .expect("Raw::from_value always works.")
+                    .deserialize()
+                    .map_err(|e| {
                        warn!("Invalid create event: {}", e);
                        Error::bad_database("Invalid create event in db.")
                    })
@@ -1989,10 +1979,9 @@ impl Rooms {
            None
        };

-        // If there was no create event yet, assume we are creating a room with the default
-        // version right now
+        // If there was no create event yet, assume we are creating a version 6 room right now
        let room_version_id = create_event_content
-            .map_or(db.globals.default_room_version(), |create_event| {
+            .map_or(RoomVersionId::Version6, |create_event| {
                create_event.room_version
            });
        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
@@ -2011,10 +2000,7 @@ impl Rooms {
        let mut unsigned = unsigned.unwrap_or_default();
        if let Some(state_key) = &state_key {
            if let Some(prev_pdu) = self.room_state_get(room_id, &event_type, state_key)? {
-                unsigned.insert(
-                    "prev_content".to_owned(),
-                    serde_json::from_str(prev_pdu.content.get()).expect("string is valid json"),
-                );
+                unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
                unsigned.insert(
                    "prev_sender".to_owned(),
                    serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
@@ -2039,15 +2025,11 @@ impl Rooms {
                .map(|(_, pdu)| pdu.event_id.clone())
                .collect(),
            redacts,
-            unsigned: if unsigned.is_empty() {
-                None
-            } else {
-                Some(to_raw_value(&unsigned).expect("to_raw_value always works"))
-            },
-            hashes: EventHash {
+            unsigned,
+            hashes: ruma::events::pdu::EventHash {
                sha256: "aaa".to_owned(),
            },
-            signatures: None,
+            signatures: BTreeMap::new(),
        };

        let auth_check = state_res::auth_check(
@@ -2122,12 +2104,13 @@ impl Rooms {
        // where events in the current room state do not exist
        self.set_room_state(room_id, statehashid)?;

-        let servers = self
+        for server in self
            .room_servers(room_id)
            .filter_map(|r| r.ok())
-            .filter(|server| &**server != db.globals.server_name());
-
-        db.sending.send_pdu(servers, &pdu_id)?;
+            .filter(|server| &**server != db.globals.server_name())
+        {
+            db.sending.send_pdu(&server, &pdu_id)?;
+        }

        for appservice in db.appservice.all()? {
            if self.appservice_in_room(room_id, &appservice, db)? {
@@ -2223,7 +2206,7 @@ impl Rooms {
                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
+                    pdu.unsigned.remove("transaction_id");
                }
                Ok((pdu_id, pdu))
            }))
@@ -2260,7 +2243,7 @@ impl Rooms {
                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
+                    pdu.unsigned.remove("transaction_id");
                }
                Ok((pdu_id, pdu))
            }))
@@ -2297,7 +2280,7 @@ impl Rooms {
                let mut pdu = serde_json::from_slice::<PduEvent>(&v)
                    .map_err(|_| Error::bad_database("PDU in db is invalid."))?;
                if pdu.sender != user_id {
-                    pdu.remove_transaction_id()?;
+                    pdu.unsigned.remove("transaction_id");
                }
                Ok((pdu_id, pdu))
            }))
@@ -2327,7 +2310,7 @@ impl Rooms {
        &self,
        room_id: &RoomId,
        user_id: &UserId,
-        membership: MembershipState,
+        membership: member::MembershipState,
        sender: &UserId,
        last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
        db: &Database,
@@ -2356,7 +2339,7 @@ impl Rooms {
        roomuser_id.extend_from_slice(user_id.as_bytes());

        match &membership {
-            MembershipState::Join => {
+            member::MembershipState::Join => {
                // Check if the user never joined this room
                if !self.once_joined(user_id, room_id)? {
                    // Add the user ID to the join list then
@@ -2365,16 +2348,23 @@ impl Rooms {
                    // Check if the room has a predecessor
                    if let Some(predecessor) = self
                        .room_state_get(room_id, &EventType::RoomCreate, "")?
-                        .and_then(|create| serde_json::from_str(create.content.get()).ok())
-                        .and_then(|content: RoomCreateEventContent| content.predecessor)
+                        .and_then(|create| {
+                            serde_json::from_value::<
+                                Raw<ruma::events::room::create::CreateEventContent>,
+                            >(create.content.clone())
+                            .expect("Raw::from_value always works")
+                            .deserialize()
+                            .ok()
+                        })
+                        .and_then(|content| content.predecessor)
                    {
                        // Copy user settings from predecessor to the current room:
                        // - Push rules
                        //
                        // TODO: finish this once push rules are implemented.
                        //
-                        // let mut push_rules_event_content: PushRulesEvent = account_data
-                        //     .get(
+                        // let mut push_rules_event_content = account_data
+                        //     .get::<ruma::events::push_rules::PushRulesEvent>(
                        //         None,
                        //         user_id,
                        //         EventType::PushRules,
@@ -2394,11 +2384,13 @@ impl Rooms {
                        //     .ok();

                        // Copy old tags to new room
-                        if let Some(tag_event) = db.account_data.get::<TagEvent>(
+                        if let Some(tag_event) =
+                            db.account_data.get::<ruma::events::tag::TagEvent>(
                                Some(&predecessor.room_id),
                                user_id,
                                EventType::Tag,
-                        )? {
+                            )?
+                        {
                            db.account_data
                                .update(
                                    Some(room_id),
@@ -2412,8 +2404,11 @@ impl Rooms {

                        // Copy direct chat flag
                        if let Some(mut direct_event) =
-                            db.account_data
-                                .get::<DirectEvent>(None, user_id, EventType::Direct)?
+                            db.account_data.get::<ruma::events::direct::DirectEvent>(
+                                None,
+                                user_id,
+                                EventType::Direct,
+                            )?
                        {
                            let mut room_ids_updated = false;

@@ -2448,11 +2443,11 @@ impl Rooms {
                self.userroomid_leftstate.remove(&userroom_id)?;
                self.roomuserid_leftcount.remove(&roomuser_id)?;
            }
-            MembershipState::Invite => {
+            member::MembershipState::Invite => {
                // We want to know if the sender is ignored by the receiver
                let is_ignored = db
                    .account_data
-                    .get::<IgnoredUserListEvent>(
+                    .get::<ignored_user_list::IgnoredUserListEvent>(
                        None,    // Ignored users are in global account data
                        user_id, // Receiver
                        EventType::IgnoredUserList,
@@ -2481,7 +2476,7 @@ impl Rooms {
                self.userroomid_leftstate.remove(&userroom_id)?;
                self.roomuserid_leftcount.remove(&roomuser_id)?;
            }
-            MembershipState::Leave | MembershipState::Ban => {
+            member::MembershipState::Leave | member::MembershipState::Ban => {
                if update_joined_count
                    && self
                        .room_members(room_id)
@@ -2706,23 +2701,26 @@ impl Rooms {
            );
            let state_lock = mutex_state.lock().await;

-            let mut event: RoomMemberEventContent = serde_json::from_str(
+            let mut event = serde_json::from_value::<Raw<member::MemberEventContent>>(
                self.room_state_get(room_id, &EventType::RoomMember, &user_id.to_string())?
                    .ok_or(Error::BadRequest(
                        ErrorKind::BadState,
                        "Cannot leave a room you are not a member of.",
                    ))?
                    .content
-                    .get(),
+                    .clone(),
            )
+            .expect("from_value::<Raw<..>> can never fail")
+            .deserialize()
            .map_err(|_| Error::bad_database("Invalid member event in database."))?;

-            event.membership = MembershipState::Leave;
+            event.membership = member::MembershipState::Leave;

            self.build_and_append_pdu(
                PduBuilder {
                    event_type: EventType::RoomMember,
-                    content: to_raw_value(&event).expect("event is valid, we just created it"),
+                    content: serde_json::to_value(event)
+                        .expect("event is valid, we just created it"),
                    unsigned: None,
                    state_key: Some(user_id.to_string()),
                    redacts: None,
@@ -2756,14 +2754,16 @@ impl Rooms {
                "User is not invited.",
            ))?;

-        let servers: HashSet<_> = invite_state
+        let servers = invite_state
            .iter()
-            .filter_map(|event| serde_json::from_str(event.json().get()).ok())
-            .filter_map(|event: serde_json::Value| event.get("sender").cloned())
+            .filter_map(|event| {
+                serde_json::from_str::<serde_json::Value>(&event.json().to_string()).ok()
+            })
+            .filter_map(|event| event.get("sender").cloned())
            .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
            .filter_map(|sender| UserId::try_from(sender).ok())
            .map(|user| user.server_name().to_owned())
-            .collect();
+            .collect::<HashSet<_>>();

        for remote_server in servers {
            let make_leave_response = db
@@ -2785,14 +2785,19 @@ impl Rooms {
        let (make_leave_response, remote_server) = make_leave_response_and_server?;

        let room_version_id = match make_leave_response.room_version {
-            Some(version) if self.is_supported_version(&db, &version) => version,
+            Some(version)
+                if version == RoomVersionId::Version5 || version == RoomVersionId::Version6 =>
+            {
+                version
+            }
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

        let mut leave_event_stub =
-            serde_json::from_str::<CanonicalJsonObject>(make_leave_response.event.get()).map_err(
-                |_| Error::BadServerResponse("Invalid make_leave event json received from server."),
-            )?;
+            serde_json::from_str::<CanonicalJsonObject>(make_leave_response.event.json().get())
+                .map_err(|_| {
+                    Error::BadServerResponse("Invalid make_leave event json received from server.")
+                })?;

        // TODO: Is origin needed?
        leave_event_stub.insert(
@@ -2843,7 +2848,7 @@ impl Rooms {
                federation::membership::create_leave_event::v2::Request {
                    room_id,
                    event_id: &event_id,
-                    pdu: &PduEvent::convert_to_outgoing_federation_event(leave_event.clone()),
+                    pdu: PduEvent::convert_to_outgoing_federation_event(leave_event.clone()),
                },
            )
            .await?;
@@ -2908,13 +2913,14 @@ impl Rooms {
    pub fn id_from_alias(&self, alias: &RoomAliasId) -> Result<Option<RoomId>> {
        self.alias_roomid
            .get(alias.alias().as_bytes())?
-            .map(|bytes| {
+            .map_or(Ok(None), |bytes| {
+                Ok(Some(
                    RoomId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
                        Error::bad_database("Room ID in alias_roomid is invalid unicode.")
                    })?)
-                .map_err(|_| Error::bad_database("Room ID in alias_roomid is invalid."))
+                    .map_err(|_| Error::bad_database("Room ID in alias_roomid is invalid."))?,
+                ))
            })
-            .transpose()
    }

    #[tracing::instrument(skip(self))]
@@ -2974,11 +2980,11 @@ impl Rooms {
            .to_vec();
        let prefix_clone = prefix.clone();

-        let words: Vec<_> = search_string
+        let words = search_string
            .split_terminator(|c: char| !c.is_alphanumeric())
            .filter(|s| !s.is_empty())
            .map(str::to_lowercase)
-            .collect();
+            .collect::<Vec<_>>();

        let iterators = words.clone().into_iter().map(move |word| {
            let mut prefix2 = prefix.clone();
@@ -2991,7 +2997,12 @@ impl Rooms {
            self.tokenids
                .iter_from(&last_possible_id, true) // Newest pdus first
                .take_while(move |(k, _)| k.starts_with(&prefix2))
-                .map(|(key, _)| key[key.len() - size_of::<u64>()..].to_vec())
+                .map(|(key, _)| {
+                    let pdu_id = key[key.len() - size_of::<u64>()..].to_vec();
+
+                    Ok::<_, Error>(pdu_id)
+                })
+                .filter_map(|r| r.ok())
        });

        Ok((
@@ -3223,11 +3234,11 @@ impl Rooms {

        self.roomuserid_leftcount
            .get(&key)?
-            .map(|bytes| {
-                utils::u64_from_bytes(&bytes)
-                    .map_err(|_| Error::bad_database("Invalid leftcount in db."))
+            .map_or(Ok(None), |bytes| {
+                Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
+                    Error::bad_database("Invalid leftcount in db.")
+                })?))
            })
-            .transpose()
    }

    /// Returns an iterator over all rooms this user joined.
@@ -3451,24 +3462,4 @@ impl Rooms {

        Ok(())
    }
-
-    /// Returns the room's version.
-    #[tracing::instrument(skip(self))]
-    pub fn get_room_version(&self, room_id: &RoomId) -> Result<RoomVersionId> {
-        let create_event = self.room_state_get(room_id, &EventType::RoomCreate, "")?;
-
-        let create_event_content: Option<RoomCreateEventContent> = create_event
-            .as_ref()
-            .map(|create_event| {
-                serde_json::from_str(create_event.content.get()).map_err(|e| {
-                    warn!("Invalid create event: {}", e);
-                    Error::bad_database("Invalid create event in db.")
-                })
-            })
-            .transpose()?;
-        let room_version = create_event_content
-            .map(|create_event| create_event.room_version)
-            .ok_or_else(|| Error::BadDatabase("Invalid room version"))?;
-        Ok(room_version)
-    }
 }
@@ -162,12 +162,11 @@ impl RoomEdus {
        Ok(self
            .roomuserid_lastprivatereadupdate
            .get(&key)?
-            .map(|bytes| {
-                utils::u64_from_bytes(&bytes).map_err(|_| {
+            .map_or(Ok::<_, Error>(None), |bytes| {
+                Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("Count in roomuserid_lastprivatereadupdate is invalid.")
-                })
-            })
-            .transpose()?
+                })?))
+            })?
            .unwrap_or(0))
    }

@@ -287,12 +286,11 @@ impl RoomEdus {
        Ok(self
            .roomid_lasttypingupdate
            .get(room_id.as_bytes())?
-            .map(|bytes| {
-                utils::u64_from_bytes(&bytes).map_err(|_| {
+            .map_or(Ok::<_, Error>(None), |bytes| {
+                Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("Count in roomid_lastroomactiveupdate is invalid.")
-                })
-            })
-            .transpose()?
+                })?))
+            })?
            .unwrap_or(0))
    }

@@ -333,7 +331,7 @@ impl RoomEdus {
        &self,
        user_id: &UserId,
        room_id: &RoomId,
-        presence: PresenceEvent,
+        presence: ruma::events::presence::PresenceEvent,
        globals: &super::super::globals::Globals,
    ) -> Result<()> {
        // TODO: Remove old entry? Or maybe just wipe completely from time to time?
@@ -401,7 +399,7 @@ impl RoomEdus {
        self.presenceid_presence
            .get(&presence_id)?
            .map(|value| {
-                let mut presence: PresenceEvent = serde_json::from_slice(&value)
+                let mut presence = serde_json::from_slice::<PresenceEvent>(&value)
                    .map_err(|_| Error::bad_database("Invalid presence event in db."))?;
                let current_timestamp: UInt = utils::millis_since_unix_epoch()
                    .try_into()
@@ -523,7 +521,7 @@ impl RoomEdus {
            )
            .map_err(|_| Error::bad_database("Invalid UserId in presenceid_presence."))?;

-            let mut presence: PresenceEvent = serde_json::from_slice(&value)
+            let mut presence = serde_json::from_slice::<PresenceEvent>(&value)
                .map_err(|_| Error::bad_database("Invalid presence event in db."))?;

            let current_timestamp: UInt = utils::millis_since_unix_epoch()
@@ -27,7 +27,7 @@ use ruma::{
        OutgoingRequest,
    },
    device_id,
-    events::{push_rules::PushRulesEvent, AnySyncEphemeralRoomEvent, EventType},
+    events::{push_rules, AnySyncEphemeralRoomEvent, EventType},
    push,
    receipt::ReceiptType,
    uint, MilliSecondsSinceUnixEpoch, ServerName, UInt, UserId,
@@ -84,7 +84,7 @@ pub enum SendingEventType {
 pub struct Sending {
    /// The state for a given state hash.
    pub(super) servername_educount: Arc<dyn Tree>, // EduCount: Count of last EDU sync
-    pub(super) servernameevent_data: Arc<dyn Tree>, // ServernameEvent = (+ / $)SenderKey / ServerName / UserId + PduId / Id (for edus), Data = EDU content
+    pub(super) servernameevent_data: Arc<dyn Tree>, // ServernamEvent = (+ / $)SenderKey / ServerName / UserId + PduId / Id (for edus), Data = EDU content
    pub(super) servercurrentevent_data: Arc<dyn Tree>, // ServerCurrentEvents = (+ / $)ServerName / UserId + PduId / Id (for edus), Data = EDU content
    pub(super) maximum_requests: Arc<Semaphore>,
    pub sender: mpsc::UnboundedSender<(Vec<u8>, Vec<u8>)>,
@@ -165,13 +165,13 @@ impl Sending {
                                }

                                // Find events that have been added since starting the last request
-                                let new_events: Vec<_> = guard.sending.servernameevent_data
+                                let new_events = guard.sending.servernameevent_data
                                    .scan_prefix(prefix.clone())
                                    .filter_map(|(k, v)| {
                                        Self::parse_servercurrentevent(&k, v).ok().map(|ev| (ev, k))
                                    })
                                    .take(30)
-                                    .collect::<>();
+                                    .collect::<Vec<_>>();

                                // TODO: find edus

@@ -344,8 +344,8 @@ impl Sending {
                    continue;
                }

-                let event: AnySyncEphemeralRoomEvent =
-                    serde_json::from_str(read_receipt.json().get())
+                let event =
+                    serde_json::from_str::<AnySyncEphemeralRoomEvent>(read_receipt.json().get())
                        .map_err(|_| Error::bad_database("Invalid edu event in read_receipts."))?;
                let federation_event = match event {
                    AnySyncEphemeralRoomEvent::Receipt(r) => {
@@ -398,7 +398,7 @@ impl Sending {
            let edu = Edu::DeviceListUpdate(DeviceListUpdateContent {
                user_id,
                device_id: device_id!("dummy"),
-                device_display_name: Some("Dummy".to_owned()),
+                device_display_name: "Dummy".to_owned(),
                stream_id: uint!(1),
                prev_id: Vec::new(),
                deleted: None,
@@ -423,23 +423,13 @@ impl Sending {
        Ok(())
    }

-    #[tracing::instrument(skip(self, servers, pdu_id))]
-    pub fn send_pdu<I: Iterator<Item = Box<ServerName>>>(
-        &self,
-        servers: I,
-        pdu_id: &[u8],
-    ) -> Result<()> {
-        let mut batch = servers.map(|server| {
+    #[tracing::instrument(skip(self, server, pdu_id))]
+    pub fn send_pdu(&self, server: &ServerName, pdu_id: &[u8]) -> Result<()> {
        let mut key = server.as_bytes().to_vec();
        key.push(0xff);
        key.extend_from_slice(pdu_id);
-
-            self.sender.unbounded_send((key.clone(), vec![])).unwrap();
-
-            (key, Vec::new())
-        });
-
-        self.servernameevent_data.insert_batch(&mut batch)?;
+        self.servernameevent_data.insert(&key, &[])?;
+        self.sender.unbounded_send((key, vec![])).unwrap();

        Ok(())
    }
@@ -485,7 +475,7 @@ impl Sending {
        kind: OutgoingKind,
        events: Vec<SendingEventType>,
        db: Arc<RwLock<Database>>,
-    ) -> Result<OutgoingKind, (OutgoingKind, Error)> {
+    ) -> std::result::Result<OutgoingKind, (OutgoingKind, Error)> {
        let db = db.read().await;

        match &kind {
@@ -573,15 +563,9 @@ impl Sending {

                for pdu in pdus {
                    // Redacted events are not notification targets (we don't send push for them)
-                    if let Some(unsigned) = &pdu.unsigned {
-                        if let Ok(unsigned) =
-                            serde_json::from_str::<serde_json::Value>(unsigned.get())
-                        {
-                            if unsigned.get("redacted_because").is_some() {
+                    if pdu.unsigned.get("redacted_because").is_some() {
                        continue;
                    }
-                        }
-                    }

                    let userid =
                        UserId::try_from(utils::string_from_bytes(user).map_err(|_| {
@@ -612,9 +596,9 @@ impl Sending {

                    let rules_for_user = db
                        .account_data
-                        .get(None, &userid, EventType::PushRules)
+                        .get::<push_rules::PushRulesEvent>(None, &userid, EventType::PushRules)
                        .unwrap_or_default()
-                        .map(|ev: PushRulesEvent| ev.content.global)
+                        .map(|ev| ev.content.global)
                        .unwrap_or_else(|| push::Ruleset::server_default(&userid));

                    let unread: UInt = db
@@ -5,8 +5,7 @@ use ruma::{
    api::client::{
        error::ErrorKind,
        r0::uiaa::{
-            AuthType, IncomingAuthData, IncomingPassword, IncomingUserIdentifier::MatrixId,
-            UiaaInfo,
+            IncomingAuthData, IncomingPassword, IncomingUserIdentifier::MatrixId, UiaaInfo,
        },
    },
    signatures::CanonicalJsonValue,
@@ -100,10 +99,10 @@ impl Uiaa {
                }

                // Password was correct! Let's add it to `completed`
-                uiaainfo.completed.push(AuthType::Password);
+                uiaainfo.completed.push("m.login.password".to_owned());
            }
            IncomingAuthData::Dummy(_) => {
-                uiaainfo.completed.push(AuthType::Dummy);
+                uiaainfo.completed.push("m.login.dummy".to_owned());
            }
            k => error!("type not supported: {:?}", k),
        }
@@ -175,14 +174,16 @@ impl Uiaa {

        self.userdevicesessionid_uiaarequest
            .get(&userdevicesessionid)?
-            .map(|bytes| {
+            .map_or(Ok(None), |bytes| {
+                Ok::<_, Error>(Some(
                    serde_json::from_str::<CanonicalJsonValue>(
-                    &utils::string_from_bytes(&bytes)
-                        .map_err(|_| Error::bad_database("Invalid uiaa request bytes in db."))?,
+                        &utils::string_from_bytes(&bytes).map_err(|_| {
+                            Error::bad_database("Invalid uiaa request bytes in db.")
+                        })?,
                    )
-                .map_err(|_| Error::bad_database("Invalid uiaa request in db."))
+                    .map_err(|_| Error::bad_database("Invalid uiaa request in db."))?,
+                ))
            })
-            .transpose()
    }

    fn update_uiaa_session(
@@ -223,7 +224,7 @@ impl Uiaa {
        userdevicesessionid.push(0xff);
        userdevicesessionid.extend_from_slice(session.as_bytes());

-        serde_json::from_slice(
+        let uiaainfo = serde_json::from_slice::<UiaaInfo>(
            &self
                .userdevicesessionid_uiaainfo
                .get(&userdevicesessionid)?
@@ -232,6 +233,8 @@ impl Uiaa {
                    "UIAA session does not exist.",
                ))?,
        )
-        .map_err(|_| Error::bad_database("UiaaInfo in userdeviceid_uiaainfo is invalid."))
+        .map_err(|_| Error::bad_database("UiaaInfo in userdeviceid_uiaainfo is invalid."))?;
+
+        Ok(uiaainfo)
    }
 }
@@ -5,8 +5,7 @@ use ruma::{
    events::{AnyToDeviceEvent, EventType},
    identifiers::MxcUri,
    serde::Raw,
-    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, RoomAliasId, UInt,
-    UserId,
+    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, UInt, UserId,
 };
 use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
 use tracing::warn;
@@ -54,22 +53,6 @@ impl Users {
            .is_empty())
    }

-    /// Check if a user is an admin
-    #[tracing::instrument(skip(self, user_id, rooms, globals))]
-    pub fn is_admin(
-        &self,
-        user_id: &UserId,
-        rooms: &super::rooms::Rooms,
-        globals: &super::globals::Globals,
-    ) -> Result<bool> {
-        let admin_room_alias_id =
-            RoomAliasId::try_from(format!("#admins:{}", globals.server_name()))
-                .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
-        let admin_room_id = rooms.id_from_alias(&admin_room_alias_id)?.unwrap();
-
-        Ok(rooms.is_joined(user_id, &admin_room_id)?)
-    }
-
    /// Create a new user account on this homeserver.
    #[tracing::instrument(skip(self, user_id, password))]
    pub fn create(&self, user_id: &UserId, password: Option<&str>) -> Result<()> {
@@ -620,11 +603,10 @@ impl Users {
        key.push(0xff);
        key.extend_from_slice(key_id.as_bytes());

-        let mut cross_signing_key: serde_json::Value =
-            serde_json::from_slice(&self.keyid_key.get(&key)?.ok_or(Error::BadRequest(
-                ErrorKind::InvalidParam,
-                "Tried to sign nonexistent key.",
-            ))?)
+        let mut cross_signing_key =
+            serde_json::from_slice::<serde_json::Value>(&self.keyid_key.get(&key)?.ok_or(
+                Error::BadRequest(ErrorKind::InvalidParam, "Tried to sign nonexistent key."),
+            )?)
            .map_err(|_| Error::bad_database("key in keyid_key is invalid."))?;

        let signatures = cross_signing_key
@@ -20,7 +20,7 @@ use {
    tracing::error,
 };

-pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type Result<T> = std::result::Result<T, Error>;

 #[derive(Error, Debug)]
 pub enum Error {
@@ -1,9 +1,3 @@
-#![warn(
-    rust_2018_idioms,
-    unused_qualifications,
-    clippy::cloned_instead_of_copied,
-    clippy::str_to_string
-)]
 #![allow(clippy::suspicious_else_formatting)]
 #![deny(clippy::dbg_macro)]

@@ -1,9 +1,4 @@
-#![warn(
-    rust_2018_idioms,
-    unused_qualifications,
-    clippy::cloned_instead_of_copied,
-    clippy::str_to_string
-)]
+#![warn(rust_2018_idioms)]
 #![allow(clippy::suspicious_else_formatting)]
 #![deny(clippy::dbg_macro)]

@@ -101,7 +96,6 @@ fn setup_rocket(config: Figment, data: Arc<RwLock<Database>>) -> rocket::Rocket<
                client_server::create_typing_event_route,
                client_server::create_room_route,
                client_server::redact_event_route,
-                client_server::report_event_route,
                client_server::create_alias_route,
                client_server::delete_alias_route,
                client_server::get_alias_route,
@@ -1,28 +1,19 @@
-use crate::{Database, Error};
+use crate::Error;
 use ruma::{
    events::{
-        room::member::RoomMemberEventContent, AnyEphemeralRoomEvent, AnyInitialStateEvent,
-        AnyRoomEvent, AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent,
-        EventType, StateEvent,
+        pdu::EventHash, room::member::MemberEventContent, AnyEphemeralRoomEvent,
+        AnyInitialStateEvent, AnyRoomEvent, AnyStateEvent, AnyStrippedStateEvent, AnySyncRoomEvent,
+        AnySyncStateEvent, EventType, StateEvent,
    },
    serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
-    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, UInt, UserId,
+    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
+    ServerSigningKeyId, UInt, UserId,
 };
 use serde::{Deserialize, Serialize};
-use serde_json::{
-    json,
-    value::{to_raw_value, RawValue as RawJsonValue},
-};
+use serde_json::json;
 use std::{cmp::Ordering, collections::BTreeMap, convert::TryFrom};
 use tracing::warn;

-/// Content hashes of a PDU.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct EventHash {
-    /// The SHA-256 hash.
-    pub sha256: String,
-}
-
 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
    pub event_id: EventId,
@@ -31,7 +22,7 @@ pub struct PduEvent {
    pub origin_server_ts: UInt,
    #[serde(rename = "type")]
    pub kind: EventType,
-    pub content: Box<RawJsonValue>,
+    pub content: serde_json::Value,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state_key: Option<String>,
    pub prev_events: Vec<EventId>,
@@ -39,17 +30,16 @@ pub struct PduEvent {
    pub auth_events: Vec<EventId>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redacts: Option<EventId>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub unsigned: Option<Box<RawJsonValue>>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub unsigned: BTreeMap<String, serde_json::Value>,
    pub hashes: EventHash,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub signatures: Option<Box<RawJsonValue>>, // BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, String>>
+    pub signatures: BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, String>>,
 }

 impl PduEvent {
    #[tracing::instrument(skip(self))]
    pub fn redact(&mut self, reason: &PduEvent) -> crate::Result<()> {
-        self.unsigned = None;
+        self.unsigned.clear();

        let allowed: &[&str] = match self.kind {
            EventType::RoomMember => &["membership"],
@@ -69,9 +59,10 @@ impl PduEvent {
            _ => &[],
        };

-        let mut old_content: BTreeMap<String, serde_json::Value> =
-            serde_json::from_str(self.content.get())
-                .map_err(|_| Error::bad_database("PDU in db has invalid content."))?;
+        let old_content = self
+            .content
+            .as_object_mut()
+            .ok_or_else(|| Error::bad_database("PDU in db has invalid content."))?;

        let mut new_content = serde_json::Map::new();

@@ -81,23 +72,12 @@ impl PduEvent {
            }
        }

-        self.unsigned = Some(to_raw_value(&json!({
-            "redacted_because": serde_json::to_value(reason).expect("to_value(PduEvent) always works")
-        })).expect("to string always works"));
+        self.unsigned.insert(
+            "redacted_because".to_owned(),
+            serde_json::to_value(reason).expect("to_value(PduEvent) always works"),
+        );

-        self.content = to_raw_value(&new_content).expect("to string always works");
-
-        Ok(())
-    }
-
-    pub fn remove_transaction_id(&mut self) -> crate::Result<()> {
-        if let Some(unsigned) = &self.unsigned {
-            let mut unsigned: BTreeMap<String, Box<RawJsonValue>> =
-                serde_json::from_str(unsigned.get())
-                    .map_err(|_| Error::bad_database("Invalid unsigned in pdu event"))?;
-            unsigned.remove("transaction_id");
-            self.unsigned = Some(to_raw_value(&unsigned).expect("unsigned is valid"));
-        }
+        self.content = new_content.into();

        Ok(())
    }
@@ -212,7 +192,7 @@ impl PduEvent {
    }

    #[tracing::instrument(skip(self))]
-    pub fn to_member_event(&self) -> Raw<StateEvent<RoomMemberEventContent>> {
+    pub fn to_member_event(&self) -> Raw<StateEvent<MemberEventContent>> {
        let json = json!({
            "content": self.content,
            "type": self.kind,
@@ -232,7 +212,7 @@ impl PduEvent {
    #[tracing::instrument]
    pub fn convert_to_outgoing_federation_event(
        mut pdu_json: CanonicalJsonObject,
-    ) -> Box<RawJsonValue> {
+    ) -> Raw<ruma::events::pdu::Pdu> {
        if let Some(unsigned) = pdu_json
            .get_mut("unsigned")
            .and_then(|val| val.as_object_mut())
@@ -249,7 +229,10 @@ impl PduEvent {
        // )
        // .expect("Raw::from_value always works")

-        to_raw_value(&pdu_json).expect("CanonicalJson is valid serde_json::Value")
+        serde_json::from_value::<Raw<_>>(
+            serde_json::to_value(pdu_json).expect("CanonicalJson is valid serde_json::Value"),
+        )
+        .expect("Raw::from_value always works")
    }

    pub fn from_id_val(
@@ -257,7 +240,7 @@ impl PduEvent {
        mut json: CanonicalJsonObject,
    ) -> Result<Self, serde_json::Error> {
        json.insert(
-            "event_id".to_owned(),
+            "event_id".to_string(),
            CanonicalJsonValue::String(event_id.as_str().to_owned()),
        );

@@ -282,7 +265,7 @@ impl state_res::Event for PduEvent {
        &self.kind
    }

-    fn content(&self) -> &RawJsonValue {
+    fn content(&self) -> &serde_json::Value {
        &self.content
    }

@@ -298,6 +281,10 @@ impl state_res::Event for PduEvent {
        Box::new(self.prev_events.iter())
    }

+    fn depth(&self) -> &UInt {
+        &self.depth
+    }
+
    fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
        Box::new(self.auth_events.iter())
    }
@@ -305,6 +292,18 @@ impl state_res::Event for PduEvent {
    fn redacts(&self) -> Option<&EventId> {
        self.redacts.as_ref()
    }
+
+    fn hashes(&self) -> &EventHash {
+        &self.hashes
+    }
+
+    fn signatures(&self) -> BTreeMap<Box<ServerName>, BTreeMap<ruma::ServerSigningKeyId, String>> {
+        self.signatures.clone()
+    }
+
+    fn unsigned(&self) -> &BTreeMap<String, serde_json::Value> {
+        &self.unsigned
+    }
 }

 // These impl's allow us to dedup state snapshots when resolving state
@@ -330,25 +329,17 @@ impl Ord for PduEvent {
 ///
 /// Returns a tuple of the new `EventId` and the PDU as a `BTreeMap<String, CanonicalJsonValue>`.
 pub(crate) fn gen_event_id_canonical_json(
-    pdu: &RawJsonValue,
-    db: &Database,
+    pdu: &Raw<ruma::events::pdu::Pdu>,
 ) -> crate::Result<(EventId, CanonicalJsonObject)> {
-    let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
+    let value = serde_json::from_str(pdu.json().get()).map_err(|e| {
        warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
        Error::BadServerResponse("Invalid PDU in server response")
    })?;

-    let room_id = value
-        .get("room_id")
-        .and_then(|id| RoomId::try_from(id.as_str()?).ok())
-        .expect("Invalid room id in event");
-
-    let room_version_id = db.rooms.get_room_version(&room_id);
-
    let event_id = EventId::try_from(&*format!(
        "${}",
        // Anything higher than version3 behaves the same
-        ruma::signatures::reference_hash(&value, &room_version_id?)
+        ruma::signatures::reference_hash(&value, &RoomVersionId::Version6)
            .expect("ruma can calculate reference hashes")
    ))
    .expect("ruma's reference hashes are valid event ids");
@@ -361,7 +352,7 @@ pub(crate) fn gen_event_id_canonical_json(
 pub struct PduBuilder {
    #[serde(rename = "type")]
    pub event_type: EventType,
-    pub content: Box<RawJsonValue>,
+    pub content: serde_json::Value,
    pub unsigned: Option<BTreeMap<String, serde_json::Value>>,
    pub state_key: Option<String>,
    pub redacts: Option<EventId>,
@@ -372,7 +363,7 @@ impl From<AnyInitialStateEvent> for PduBuilder {
    fn from(event: AnyInitialStateEvent) -> Self {
        Self {
            event_type: EventType::from(event.event_type()),
-            content: to_raw_value(&event.content())
+            content: serde_json::value::to_value(event.content())
                .expect("AnyStateEventContent came from JSON and can thus turn back into JSON."),
            unsigned: None,
            state_key: Some(event.state_key().to_owned()),
@@ -344,7 +344,7 @@ impl<T: Outgoing> Deref for Ruma<T> {
 }

 /// This struct converts ruma responses into rocket http responses.
-pub type ConduitResult<T> = Result<RumaResponse<T>, Error>;
+pub type ConduitResult<T> = std::result::Result<RumaResponse<T>, Error>;

 pub fn response<T: OutgoingResponse>(response: RumaResponse<T>) -> response::Result<'static> {
    let http_response = response
@@ -1,7 +1,6 @@
 use crate::{
    client_server::{self, claim_keys_helper, get_keys_helper},
    database::{rooms::CompressedStateEvent, DatabaseGuard},
-    pdu::EventHash,
    utils, ConduitResult, Database, Error, PduEvent, Result, Ruma,
 };
 use get_profile_information::v1::ProfileField;
@@ -40,23 +39,22 @@ use ruma::{
    },
    directory::{IncomingFilter, IncomingRoomNetwork},
    events::{
+        pdu::Pdu,
        receipt::{ReceiptEvent, ReceiptEventContent},
        room::{
-            create::RoomCreateEventContent,
-            member::{MembershipState, RoomMemberEventContent},
+            create::CreateEventContent,
+            member::{MemberEventContent, MembershipState},
        },
        AnyEphemeralRoomEvent, EventType,
    },
-    int,
    receipt::ReceiptType,
-    serde::JsonObject,
+    serde::Raw,
    signatures::{CanonicalJsonObject, CanonicalJsonValue},
    state_res::{self, RoomVersion, StateMap},
    to_device::DeviceIdOrAllDevices,
    uint, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, ServerName,
    ServerSigningKeyId,
 };
-use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use std::{
    collections::{btree_map, hash_map, BTreeMap, BTreeSet, HashMap, HashSet},
    convert::{TryFrom, TryInto},
@@ -65,6 +63,7 @@ use std::{
    mem,
    net::{IpAddr, SocketAddr},
    pin::Pin,
+    result::Result as StdResult,
    sync::{Arc, RwLock, RwLockWriteGuard},
    time::{Duration, Instant, SystemTime},
 };
@@ -336,7 +335,7 @@ fn add_port_to_hostname(destination_str: &str) -> FedDest {
        None => (destination_str, ":8448"),
        Some(pos) => destination_str.split_at(pos),
    };
-    FedDest::Named(host.to_owned(), port.to_owned())
+    FedDest::Named(host.to_string(), port.to_string())
 }

 /// Returns: actual_destination, host header
@@ -358,7 +357,7 @@ async fn find_actual_destination(
            if let Some(pos) = destination_str.find(':') {
                // 2: Hostname with included port
                let (host, port) = destination_str.split_at(pos);
-                FedDest::Named(host.to_owned(), port.to_owned())
+                FedDest::Named(host.to_string(), port.to_string())
            } else {
                match request_well_known(globals, destination.as_str()).await {
                    // 3: A .well-known file is available
@@ -370,7 +369,7 @@ async fn find_actual_destination(
                                if let Some(pos) = delegated_hostname.find(':') {
                                    // 3.2: Hostname with port in .well-known file
                                    let (host, port) = delegated_hostname.split_at(pos);
-                                    FedDest::Named(host.to_owned(), port.to_owned())
+                                    FedDest::Named(host.to_string(), port.to_string())
                                } else {
                                    // Delegated hostname has no port in this branch
                                    if let Some(hostname_override) =
@@ -454,12 +453,12 @@ async fn find_actual_destination(
    let hostname = if let Ok(addr) = hostname.parse::<SocketAddr>() {
        FedDest::Literal(addr)
    } else if let Ok(addr) = hostname.parse::<IpAddr>() {
-        FedDest::Named(addr.to_string(), ":8448".to_owned())
+        FedDest::Named(addr.to_string(), ":8448".to_string())
    } else if let Some(pos) = hostname.find(':') {
        let (host, port) = hostname.split_at(pos);
-        FedDest::Named(host.to_owned(), port.to_owned())
+        FedDest::Named(host.to_string(), port.to_string())
    } else {
-        FedDest::Named(hostname, ":8448".to_owned())
+        FedDest::Named(hostname, ":8448".to_string())
    };
    (actual_destination, hostname)
 }
@@ -476,7 +475,11 @@ async fn query_srv_record(
        .map(|srv| {
            srv.iter().next().map(|result| {
                FedDest::Named(
-                    result.target().to_string().trim_end_matches('.').to_owned(),
+                    result
+                        .target()
+                        .to_string()
+                        .trim_end_matches('.')
+                        .to_string(),
                    format!(":{}", result.port()),
                )
            })
@@ -725,7 +728,7 @@ pub async fn send_transaction_message_route(

    for pdu in &body.pdus {
        // We do not add the event_id field to the pdu here because of signature and hashes checks
-        let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(pdu, &db) {
+        let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(pdu) {
            Ok(t) => t,
            Err(_) => {
                // Event could not be converted to canonical json
@@ -741,7 +744,7 @@ pub async fn send_transaction_message_route(
            Some(id) => id,
            None => {
                // Event is invalid
-                resolved_map.insert(event_id, Err("Event needs a valid RoomId.".to_owned()));
+                resolved_map.insert(event_id, Err("Event needs a valid RoomId.".to_string()));
                continue;
            }
        };
@@ -955,11 +958,11 @@ pub(crate) async fn handle_incoming_pdu<'a>(
    is_timeline_event: bool,
    db: &'a Database,
    pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
-) -> Result<Option<Vec<u8>>, String> {
+) -> StdResult<Option<Vec<u8>>, String> {
    match db.rooms.exists(room_id) {
        Ok(true) => {}
        _ => {
-            return Err("Room is unknown to this server.".to_owned());
+            return Err("Room is unknown to this server.".to_string());
        }
    }

@@ -1003,12 +1006,12 @@ pub(crate) async fn handle_incoming_pdu<'a>(
    // 9. Fetch any missing prev events doing all checks listed here starting at 1. These are timeline events
    let mut graph = HashMap::new();
    let mut eventid_info = HashMap::new();
-    let mut todo_outlier_stack: Vec<_> = incoming_pdu
+    let mut todo_outlier_stack = incoming_pdu
        .prev_events
        .iter()
        .cloned()
        .map(Arc::new)
-        .collect();
+        .collect::<Vec<_>>();

    let mut amount = 0;

@@ -1068,7 +1071,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
        // and lexically by event_id.
        println!("{}", event_id);
        Ok((
-            int!(0),
+            0,
            MilliSecondsSinceUnixEpoch(
                eventid_info
                    .get(event_id)
@@ -1136,7 +1139,8 @@ fn handle_outlier_pdu<'a>(
    value: BTreeMap<String, CanonicalJsonValue>,
    db: &'a Database,
    pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, String>>>,
-) -> AsyncRecursiveType<'a, Result<(Arc<PduEvent>, BTreeMap<String, CanonicalJsonValue>), String>> {
+) -> AsyncRecursiveType<'a, StdResult<(Arc<PduEvent>, BTreeMap<String, CanonicalJsonValue>), String>>
+{
    Box::pin(async move {
        // TODO: For RoomVersion6 we must check that Raw<..> is canonical do we anywhere?: https://matrix.org/docs/spec/rooms/v6#canonical-json

@@ -1149,8 +1153,11 @@ fn handle_outlier_pdu<'a>(
        // 2. Check signatures, otherwise drop
        // 3. check content hash, redact if doesn't match

-        let create_event_content: RoomCreateEventContent =
-            serde_json::from_str(create_event.content.get()).map_err(|e| {
+        let create_event_content =
+            serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+                .expect("Raw::from_value always works.")
+                .deserialize()
+                .map_err(|e| {
                    warn!("Invalid create event: {}", e);
                    "Invalid create event in db.".to_owned()
                })?;
@@ -1166,14 +1173,14 @@ fn handle_outlier_pdu<'a>(
            Err(e) => {
                // Drop
                warn!("Dropping bad event {}: {}", event_id, e);
-                return Err("Signature verification failed".to_owned());
+                return Err("Signature verification failed".to_string());
            }
            Ok(ruma::signatures::Verified::Signatures) => {
                // Redact
                warn!("Calculated hash does not match: {}", event_id);
                match ruma::signatures::redact(&value, room_version_id) {
                    Ok(obj) => obj,
-                    Err(_) => return Err("Redaction failed".to_owned()),
+                    Err(_) => return Err("Redaction failed".to_string()),
                }
            }
            Ok(ruma::signatures::Verified::All) => value,
@@ -1188,7 +1195,7 @@ fn handle_outlier_pdu<'a>(
        let incoming_pdu = serde_json::from_value::<PduEvent>(
            serde_json::to_value(&val).expect("CanonicalJsonObj is a valid JsonValue"),
        )
-        .map_err(|_| "Event is not a valid PDU.".to_owned())?;
+        .map_err(|_| "Event is not a valid PDU.".to_string())?;

        // 4. fetch any missing auth events doing all checks listed here starting at 1. These are not timeline events
        // 5. Reject "due to auth events" if can't get all the auth events or some of the auth events are also rejected "due to auth events"
@@ -1234,7 +1241,7 @@ fn handle_outlier_pdu<'a>(
                    .expect("all auth events have state keys"),
            )) {
                hash_map::Entry::Vacant(v) => {
-                    v.insert(auth_event);
+                    v.insert(auth_event.clone());
                }
                hash_map::Entry::Occupied(_) => {
                    return Err(
@@ -1269,13 +1276,13 @@ fn handle_outlier_pdu<'a>(
        if !state_res::event_auth::auth_check(
            &room_version,
            &incoming_pdu,
-            previous_create.as_ref(),
+            previous_create,
            None::<PduEvent>, // TODO: third party invite
            |k, s| auth_events.get(&(k.clone(), s.to_owned())),
        )
-        .map_err(|_e| "Auth check failed".to_owned())?
+        .map_err(|_e| "Auth check failed".to_string())?
        {
-            return Err("Event has failed auth check with auth events.".to_owned());
+            return Err("Event has failed auth check with auth events.".to_string());
        }

        debug!("Validation successful.");
@@ -1299,7 +1306,7 @@ async fn upgrade_outlier_to_timeline_pdu(
    db: &Database,
    room_id: &RoomId,
    pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
-) -> Result<Option<Vec<u8>>, String> {
+) -> StdResult<Option<Vec<u8>>, String> {
    if let Ok(Some(pduid)) = db.rooms.get_pdu_id(&incoming_pdu.event_id) {
        return Ok(Some(pduid));
    }
@@ -1312,8 +1319,11 @@ async fn upgrade_outlier_to_timeline_pdu(
        return Err("Event has been soft failed".into());
    }

-    let create_event_content: RoomCreateEventContent =
-        serde_json::from_str(create_event.content.get()).map_err(|e| {
+    let create_event_content =
+        serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+            .expect("Raw::from_value always works.")
+            .deserialize()
+            .map_err(|e| {
                warn!("Invalid create event: {}", e);
                "Invalid create event in db.".to_owned()
            })?;
@@ -1446,7 +1456,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                                .map_err(|_| "Failed to get_or_create_shortstatekey".to_owned())?;
                            Ok((shortstatekey, Arc::new(event_id)))
                        })
-                        .collect::<Result<_, String>>()?,
+                        .collect::<StdResult<_, String>>()?,
                ),
                Err(e) => {
                    warn!("State resolution on prev events failed, either an event could not be found or deserialization: {}", e);
@@ -1552,7 +1562,7 @@ async fn upgrade_outlier_to_timeline_pdu(
    let check_result = state_res::event_auth::auth_check(
        &room_version,
        &incoming_pdu,
-        previous_create.as_ref(),
+        previous_create.as_deref(),
        None::<PduEvent>, // TODO: third party invite
        |k, s| {
            db.rooms
@@ -1628,7 +1638,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                .compress_state_event(*shortstatekey, id, &db.globals)
                .map_err(|_| "Failed to compress_state_event".to_owned())
        })
-        .collect::<Result<_, _>>()?;
+        .collect::<StdResult<_, String>>()?;

    // 13. Check if the event passes auth based on the "current state" of the room, if not "soft fail" it
    debug!("starting soft fail auth check");
@@ -1636,7 +1646,7 @@ async fn upgrade_outlier_to_timeline_pdu(
    let soft_fail = !state_res::event_auth::auth_check(
        &room_version,
        &incoming_pdu,
-        previous_create.as_ref(),
+        previous_create.as_deref(),
        None::<PduEvent>,
        |k, s| auth_events.get(&(k.clone(), s.to_owned())),
    )
@@ -1748,7 +1758,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                        .compress_state_event(*k, id, &db.globals)
                        .map_err(|_| "Failed to compress_state_event.".to_owned())
                })
-                .collect::<Result<_, _>>()?
+                .collect::<StdResult<_, String>>()?
        } else {
            // We do need to force an update to this room's state
            update_state = true;
@@ -1767,7 +1777,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                );
            }

-            let fork_states: Vec<_> = fork_states
+            let fork_states = &fork_states
                .into_iter()
                .map(|map| {
                    map.into_iter()
@@ -1778,12 +1788,12 @@ async fn upgrade_outlier_to_timeline_pdu(
                        })
                        .collect::<Result<StateMap<_>>>()
                })
-                .collect::<Result<_>>()
+                .collect::<Result<Vec<_>>>()
                .map_err(|_| "Failed to get_statekey_from_short.".to_owned())?;

            let state = match state_res::resolve(
                room_version_id,
-                &fork_states,
+                fork_states,
                auth_chain_sets,
                |id| {
                    let res = db.rooms.get_pdu(id);
@@ -1810,7 +1820,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                        .compress_state_event(shortstatekey, &event_id, &db.globals)
                        .map_err(|_| "Failed to compress state event".to_owned())
                })
-                .collect::<Result<_, _>>()?
+                .collect::<StdResult<_, String>>()?
        };

        // Set the new room state to the resolved state
@@ -1911,7 +1921,7 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
                        Ok(res) => {
                            warn!("Got {} over federation", id);
                            let (calculated_event_id, value) =
-                                match crate::pdu::gen_event_id_canonical_json(&res.pdu, &db) {
+                                match crate::pdu::gen_event_id_canonical_json(&res.pdu) {
                                    Ok(t) => t,
                                    Err(_) => {
                                        back_off((**id).clone());
@@ -2030,12 +2040,12 @@ pub(crate) async fn fetch_signing_keys(

    trace!("Loading signing keys for {}", origin);

-    let mut result: BTreeMap<_, _> = db
+    let mut result = db
        .globals
        .signing_keys_for(origin)?
        .into_iter()
        .map(|(k, v)| (k.to_string(), v.key))
-        .collect();
+        .collect::<BTreeMap<_, _>>();

    if contains_all_ids(&result) {
        return Ok(result);
@@ -2240,10 +2250,14 @@ pub(crate) fn get_auth_chain<'a>(
            continue;
        }

-        let chunk_key: Vec<u64> = chunk.iter().map(|(short, _)| short).copied().collect();
+        let chunk_key = chunk
+            .iter()
+            .map(|(short, _)| short)
+            .copied()
+            .collect::<Vec<u64>>();
        if let Some(cached) = db.rooms.get_auth_chain_from_cache(&chunk_key)? {
            hits += 1;
-            full_auth_chain.extend(cached.iter().copied());
+            full_auth_chain.extend(cached.iter().cloned());
            continue;
        }
        misses += 1;
@@ -2254,7 +2268,7 @@ pub(crate) fn get_auth_chain<'a>(
        for (sevent_id, event_id) in chunk {
            if let Some(cached) = db.rooms.get_auth_chain_from_cache(&[sevent_id])? {
                hits2 += 1;
-                chunk_cache.extend(cached.iter().copied());
+                chunk_cache.extend(cached.iter().cloned());
            } else {
                misses2 += 1;
                let auth_chain = Arc::new(get_auth_chain_inner(room_id, &event_id, db)?);
@@ -2555,9 +2569,9 @@ pub fn get_room_state_route(
    Ok(get_room_state::v1::Response {
        auth_chain: auth_chain_ids
            .map(|id| {
-                db.rooms.get_pdu_json(&id).map(|maybe_json| {
-                    PduEvent::convert_to_outgoing_federation_event(maybe_json.unwrap())
-                })
+                Ok::<_, Error>(PduEvent::convert_to_outgoing_federation_event(
+                    db.rooms.get_pdu_json(&id)?.unwrap(),
+                ))
            })
            .filter_map(|r| r.ok())
            .collect(),
@@ -2641,21 +2655,24 @@ pub fn create_join_event_template_route(
        ));
    }

-    let prev_events: Vec<_> = db
+    let prev_events = db
        .rooms
        .get_pdu_leaves(&body.room_id)?
        .into_iter()
        .take(20)
-        .collect();
+        .collect::<Vec<_>>();

    let create_event = db
        .rooms
        .room_state_get(&body.room_id, &EventType::RoomCreate, "")?;

-    let create_event_content: Option<RoomCreateEventContent> = create_event
+    let create_event_content = create_event
        .as_ref()
        .map(|create_event| {
-            serde_json::from_str(create_event.content.get()).map_err(|e| {
+            serde_json::from_value::<Raw<CreateEventContent>>(create_event.content.clone())
+                .expect("Raw::from_value always works.")
+                .deserialize()
+                .map_err(|e| {
                    warn!("Invalid create event: {}", e);
                    Error::bad_database("Invalid create event in db.")
                })
@@ -2670,10 +2687,8 @@ pub fn create_join_event_template_route(
        None
    };

-    // If there was no create event yet, assume we are creating a room with the default version
-    // right now
-    let room_version_id = create_event_content
-        .map_or(db.globals.default_room_version(), |create_event| {
+    // If there was no create event yet, assume we are creating a version 6 room right now
+    let room_version_id = create_event_content.map_or(RoomVersionId::Version6, |create_event| {
        create_event.room_version
    });
    let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");
@@ -2687,7 +2702,7 @@ pub fn create_join_event_template_route(
        ));
    }

-    let content = to_raw_value(&RoomMemberEventContent {
+    let content = serde_json::to_value(MemberEventContent {
        avatar_url: None,
        blurhash: None,
        displayname: None,
@@ -2723,7 +2738,7 @@ pub fn create_join_event_template_route(
        unsigned.insert("prev_content".to_owned(), prev_pdu.content.clone());
        unsigned.insert(
            "prev_sender".to_owned(),
-            to_raw_value(&prev_pdu.sender).expect("UserId is valid"),
+            serde_json::to_value(&prev_pdu.sender).expect("UserId::to_value always works"),
        );
    }

@@ -2744,21 +2759,17 @@ pub fn create_join_event_template_route(
            .map(|(_, pdu)| pdu.event_id.clone())
            .collect(),
        redacts: None,
-        unsigned: if unsigned.is_empty() {
-            None
-        } else {
-            Some(to_raw_value(&unsigned).expect("to_raw_value always works"))
-        },
-        hashes: EventHash {
+        unsigned,
+        hashes: ruma::events::pdu::EventHash {
            sha256: "aaa".to_owned(),
        },
-        signatures: None,
+        signatures: BTreeMap::new(),
    };

    let auth_check = state_res::auth_check(
        &room_version,
        &pdu,
-        create_prev_event,
+        create_prev_event.as_deref(),
        None::<PduEvent>, // TODO: third_party_invite
        |k, s| auth_events.get(&(k.clone(), s.to_owned())),
    )
@@ -2788,7 +2799,10 @@ pub fn create_join_event_template_route(

    Ok(create_join_event_template::v1::Response {
        room_version: Some(room_version_id),
-        event: to_raw_value(&pdu_json).expect("CanonicalJson can be serialized to JSON"),
+        event: serde_json::from_value::<Raw<_>>(
+            serde_json::to_value(pdu_json).expect("CanonicalJson is valid serde_json::Value"),
+        )
+        .expect("Raw::from_value always works"),
    }
    .into())
 }
@@ -2796,7 +2810,7 @@ pub fn create_join_event_template_route(
 async fn create_join_event(
    db: &DatabaseGuard,
    room_id: &RoomId,
-    pdu: &RawJsonValue,
+    pdu: &Raw<ruma::events::pdu::Pdu>,
 ) -> Result<RoomState> {
    if !db.globals.allow_federation() {
        return Err(Error::bad_config("Federation is disabled."));
@@ -2815,7 +2829,7 @@ async fn create_join_event(
    // let mut auth_cache = EventMap::new();

    // We do not add the event_id field to the pdu here because of signature and hashes checks
-    let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(pdu, &db) {
+    let (event_id, value) = match crate::pdu::gen_event_id_canonical_json(pdu) {
        Ok(t) => t,
        Err(_) => {
            // Event could not be converted to canonical json
@@ -2826,7 +2840,7 @@ async fn create_join_event(
        }
    };

-    let origin: Box<ServerName> = serde_json::from_value(
+    let origin = serde_json::from_value::<Box<ServerName>>(
        serde_json::to_value(value.get("origin").ok_or(Error::BadRequest(
            ErrorKind::InvalidParam,
            "Event needs an origin field.",
@@ -2866,13 +2880,14 @@ async fn create_join_event(
        db,
    )?;

-    let servers = db
+    for server in db
        .rooms
        .room_servers(room_id)
        .filter_map(|r| r.ok())
-        .filter(|server| &**server != db.globals.server_name());
-
-    db.sending.send_pdu(servers, &pdu_id)?;
+        .filter(|server| &**server != db.globals.server_name())
+    {
+        db.sending.send_pdu(&server, &pdu_id)?;
+    }

    db.flush()?;

@@ -2933,13 +2948,14 @@ pub async fn create_join_event_v2_route(
 #[tracing::instrument(skip(db, body))]
 pub async fn create_invite_route(
    db: DatabaseGuard,
-    body: Ruma<create_invite::v2::Request<'_>>,
+    body: Ruma<create_invite::v2::Request>,
 ) -> ConduitResult<create_invite::v2::Response> {
    if !db.globals.allow_federation() {
        return Err(Error::bad_config("Federation is disabled."));
    }

-    if !db.rooms.is_supported_version(&db, &body.room_version) {
+    if body.room_version != RoomVersionId::Version5 && body.room_version != RoomVersionId::Version6
+    {
        return Err(Error::BadRequest(
            ErrorKind::IncompatibleRoomVersion {
                room_version: body.room_version.clone(),
@@ -2999,12 +3015,14 @@ pub async fn create_invite_route(

    let mut invite_state = body.invite_room_state.clone();

-    let mut event: JsonObject = serde_json::from_str(body.event.get())
+    let mut event = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(
+        &body.event.json().to_string(),
+    )
    .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid invite event bytes."))?;

    event.insert("event_id".to_owned(), "$dummy".into());

-    let pdu: PduEvent = serde_json::from_value(event.into()).map_err(|e| {
+    let pdu = serde_json::from_value::<PduEvent>(event.into()).map_err(|e| {
        warn!("Invalid invite event: {}", e);
        Error::BadRequest(ErrorKind::InvalidParam, "Invalid invite event.")
    })?;
@@ -3263,13 +3281,13 @@ pub(crate) async fn fetch_required_signing_keys(
 // Gets a list of servers for which we don't have the signing key yet. We go over
 // the PDUs and either cache the key or add it to the list that needs to be retrieved.
 fn get_server_keys_from_cache(
-    pdu: &RawJsonValue,
+    pdu: &Raw<Pdu>,
    servers: &mut BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>>,
    room_version: &RoomVersionId,
    pub_key_map: &mut RwLockWriteGuard<'_, BTreeMap<String, BTreeMap<String, String>>>,
    db: &Database,
 ) -> Result<()> {
-    let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
+    let value = serde_json::from_str::<CanonicalJsonObject>(pdu.json().get()).map_err(|e| {
        error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
        Error::BadServerResponse("Invalid PDU in server response")
    })?;
@@ -3330,16 +3348,19 @@ fn get_server_keys_from_cache(

        trace!("Loading signing keys for {}", origin);

-        let result: BTreeMap<_, _> = db
+        let result = db
            .globals
            .signing_keys_for(origin)?
            .into_iter()
            .map(|(k, v)| (k.to_string(), v.key))
-            .collect();
+            .collect::<BTreeMap<_, _>>();

        if !contains_all_ids(&result) {
            trace!("Signing key not loaded for {}", origin);
-            servers.insert(origin.clone(), BTreeMap::new());
+            servers.insert(
+                origin.clone(),
+                BTreeMap::<ServerSigningKeyId, QueryCriteria>::new(),
+            );
        }

        pub_key_map.insert(origin.to_string(), result);
@@ -3354,8 +3375,8 @@ pub(crate) async fn fetch_join_signing_keys(
    pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
    db: &Database,
 ) -> Result<()> {
-    let mut servers: BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>> =
-        BTreeMap::new();
+    let mut servers =
+        BTreeMap::<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>>::new();

    {
        let mut pkm = pub_key_map
@@ -3420,7 +3441,7 @@ pub(crate) async fn fetch_join_signing_keys(
        }
    }

-    let mut futures: FuturesUnordered<_> = servers
+    let mut futures = servers
        .into_iter()
        .map(|(server, _)| async move {
            (
@@ -3434,16 +3455,16 @@ pub(crate) async fn fetch_join_signing_keys(
                server,
            )
        })
-        .collect();
+        .collect::<FuturesUnordered<_>>();

    while let Some(result) = futures.next().await {
        if let (Ok(get_keys_response), origin) = result {
-            let result: BTreeMap<_, _> = db
+            let result = db
                .globals
                .add_signing_key(&origin, get_keys_response.server_key.clone())?
                .into_iter()
                .map(|(k, v)| (k.to_string(), v.key))
-                .collect();
+                .collect::<BTreeMap<_, _>>();

            pub_key_map
                .write()
@@ -123,7 +123,7 @@ pub fn deserialize_from_str<
    E: std::fmt::Display,
 >(
    deserializer: D,
-) -> Result<T, D::Error> {
+) -> std::result::Result<T, D::Error> {
    struct Visitor<T: FromStr<Err = E>, E>(std::marker::PhantomData<T>);
    impl<'de, T: FromStr<Err = Err>, Err: std::fmt::Display> serde::de::Visitor<'de>
        for Visitor<T, Err>
@@ -510,4 +510,3 @@ remote user can join room with version 5
 remote user can join room with version 6
 setting 'm.room.name' respects room powerlevel
 setting 'm.room.power_levels' respects room powerlevel
-Federation publicRoom Name/topic keys are correct
Author	SHA1	Message	Date
Jonas Zohren	d8b3003273	docs: WIP: Adjust suggested value ranges to Timo's suggestion and when to change them Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-09-15 12:45:13 +02:00
Jonas Zohren	edd690c583	docs: WIP: Added some suggested range for numeric values Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-09-15 12:38:17 +02:00
Jonas Zohren	c2068a434e	docs: WIP: More config options Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-09-15 12:21:43 +02:00
Jonas Zohren	b981d3d039	Move some documentation to docs/ and start overhaul	2021-09-15 11:16:19 +02:00
Jonas Zohren	80a2711f45	Move some documentation to docs/ and start overhaul	2021-09-15 11:16:19 +02:00
Jonas Zohren	2f4885c2a1	Remove the "register an account with element" test Broke due to a timeout and Timo does not like broken tests. Less testing means less failing tests. Also, hopefully sytest is less broken now.	2021-09-15 11:16:18 +02:00
Timo Kösters	3fec75a7b6	improvement: more efficient sqlite	2021-09-15 11:16:18 +02:00
Timo Kösters	5094f8e7f1	improvement: deduplicate watchers	2021-09-15 11:16:18 +02:00
Jonas Platte	cd19f02d3b	Clean up (mostly automated with cargo clippy --fix)	2021-09-15 11:16:18 +02:00
Jonas Platte	dbfe16bdb2	Upgrade ruma	2021-09-15 11:16:18 +02:00
Jonas Platte	5bdeb971d8	Get rid of more unnecessary intermediate collections	2021-09-15 11:16:18 +02:00
Daniel Wiesenberg	a38b23d56d	Add mautrix-signal appservice instructions	2021-09-15 11:16:18 +02:00
Jonathan de Jong	25a81c480b	fix sync not firing on new events in room	2021-09-15 11:16:16 +02:00
Rasmus Thomsen	1282405f1d	fix(database): handle errors in config parsin or database creation Showing the user a backtrace can be pretty confusing, so just printing a nice error message makes errors easier to understand for end users. fixes #121	2021-09-15 11:16:16 +02:00
Jonas Platte	ca4b676b4c	Remove unused dependencies	2021-09-15 11:16:16 +02:00
charludo	3db558b2f8	These lines get generated by certbot. Having them in the file before running certbot results in an apache2 error, and putting them in afterwards is not necessary, since certbot places them there on its own.	2021-09-15 11:16:16 +02:00
Daniel Wiesenberg	5ea10bbd8e	Fix deprecated/removed Traefik label	2021-09-15 11:16:16 +02:00
Timo Kösters	31b2728551	fix: make sure old events don't sneek into the timeline	2021-09-15 11:16:16 +02:00
Jonas Zohren	d48b96fda6	chore(CI): Adjust CI for master and next branch development model - Build release builds for branches "master" and "next" - Push docker images under different tags, depending on why the pipeline started - branch master: push to `latest` - branch next: push to `next` - tag: push to `$TAG_NAME` Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-09-15 11:16:16 +02:00
Timo Kösters	fe83c80a65	docs: add thanks to	2021-09-15 11:16:16 +02:00
Jonas Zohren	98ce5f62d5	chore: Also run CI on git tags, not only new commits. Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-09-15 11:16:16 +02:00
Timo Kösters	870c178c8b	fix: avoid panic	2021-09-15 11:16:16 +02:00
Timo Kösters	1b9f56e48c	chore: update dependencies	2021-09-15 11:16:16 +02:00
Timo Kösters	3143d468c7	revert Arc<EventId> commit	2021-09-15 11:16:15 +02:00
Timo Kösters	ac594f5502	docs: update readme and version	2021-09-15 11:16:15 +02:00
Jonas Platte	75701f75e4	Remove unneeded intermediary container collection	2021-09-15 11:16:09 +02:00
Timo Kösters	186722c51f	fix: batch key fetching	2021-09-15 11:16:09 +02:00
Kurt Roeckx	fc3ff86ad9	fixup! Get required keys in batch when joining a room	2021-09-15 11:16:09 +02:00
Kurt Roeckx	a8d181e00e	fixup! Get required keys in batch when joining a room	2021-09-15 11:16:09 +02:00
Kurt Roeckx	61adef8f2c	Let our server signing be valid for 1 week It was valid for 2 minutes, which can result in the server being asked too much for something that never changes.	2021-09-15 11:16:09 +02:00
Kurt Roeckx	13c9f2fb50	Get required keys in batch when joining a room We now ask the trusted server for all keys in 1 request, instead of asking each server individual for it's own keys.	2021-09-15 11:16:09 +02:00
Daniel Wiesenberg	5d279159e3	Add Traefik setup, incl. step-by-step, to docker README.	2021-09-15 11:16:09 +02:00
Jonas Platte	e14db60b6c	Fix a bunch of clippy lints	2021-09-15 11:16:09 +02:00
Timo Kösters	4cba464faf	improvement: make pdu cache capacity configurable	2021-09-15 11:16:09 +02:00
Timo Kösters	828611c0e4	improvement: stop prev event fetching if too many events fail	2021-09-15 11:16:09 +02:00
Timo Kösters	e206b0ca8f	docs: documentation for every endpoint	2021-09-15 11:16:09 +02:00
Daniel Wiesenberg	4c971d7695	Fix healthcheck.sh permissions and rearange ci dockerfile	2021-09-15 11:16:09 +02:00
Jonathan de Jong	8aed9b7711	registration default true	2021-09-15 11:16:09 +02:00
Daniel Wiesenberg	3f766d2a13	Use `$CI_COMMIT_SHORT_SHA` for `GIT_REF` Using `$CI_COMMIT_REF_NAME` means we get `master` for every image build, which is not very useful/informative. Using `$CI_COMMIT_SHORT_SHA`, on the other hand, makes it possible to see exactly from which commit an image was built.	2021-09-15 11:16:09 +02:00
Daniel Wiesenberg	6d6ce0f697	Change healthcheck in ci dockerfile	2021-09-15 11:16:09 +02:00
Daniel Wiesenberg	8b4389e0c2	Move docker healthcheck into dedicated script.	2021-09-15 11:16:09 +02:00
Jonathan de Jong	fc29ad088c	add tls	2021-09-15 11:16:09 +02:00
Timo Kösters	b0aa4fc7f5	improvement: call /state_ids less often by using state res	2021-09-15 11:16:09 +02:00
Timo Kösters	73ae29c0de	fix: inviting dendrite users	2021-09-15 11:16:09 +02:00
Timo Kösters	8c7ae60518	improvement: don't do state updates if the event was soft failed	2021-09-15 11:16:09 +02:00
Timo Kösters	4d6af6ee88	fix: make appservices more efficient	2021-09-15 11:16:09 +02:00
Timo Kösters	4ede0dc2d9	add warning if calculated event id != requested event id	2021-09-15 11:16:09 +02:00
Timo Kösters	4ce02e8ff6	fix: don't retry soft failed events	2021-09-15 11:16:09 +02:00
Devin Ragotzy	4ac40dec9a	Use Arc<EventId> in place of most EventIds	2021-09-15 11:16:09 +02:00
Timo Kösters	51b96b3538	fix: server resolution	2021-09-15 11:16:09 +02:00
Timo Kösters	5b904fbef4	fix: server resolution with well-known files	2021-09-15 11:16:09 +02:00
Timo Kösters	6c0079f2c4	improvement: less IO for auth chains	2021-09-15 11:16:09 +02:00
Timo Kösters	3a588c4561	fix: improve key fetching	2021-09-15 11:16:09 +02:00
Timo Kösters	f22ad5dfba	chore: bump dependencies	2021-09-15 11:16:09 +02:00
Timo Kösters	2b50afcc0a	improvement: persist cached auth chains in db	2021-09-15 11:16:09 +02:00
Timo Kösters	8216abc8c5	fix: better migration, force e2ee device key updates	2021-09-15 11:16:09 +02:00
Timo Kösters	981d054b0c	fix: wrong soft fail check, too many events in /sync state response	2021-09-15 11:16:09 +02:00
Timo Kösters	72e2b643bb	fix: e2ee over federation to device events were not being sent	2021-09-15 11:16:09 +02:00
Timo Kösters	ee4b08c185	improvement: more efficient auth chain cache	2021-09-15 11:16:09 +02:00
Timo Kösters	896427b67f	improvement: better e2ee over fed, faster incoming event handling	2021-09-15 11:16:09 +02:00
Jonas Zohren	95989241db	Only apply max. optimizations in CI builds. The average german man has a life expectancy of 78.7 years, or 689884.2 hours. Assuming that Timo is 20 years old, he has rougly 514564.2 hours left on planet earth. Also assuming that cross release builds took him 25 minutes before, but 2-2.5x of that with the current release compilation config he wasted roughly an hour waiting for it to complete. If he continued to work on Conduit for 20 more years (or 175320 hours), and makes a release compilation about once per day, this means 7305 hours or 304 days wasted waiting for the rust compiler. By cutting that back down to the original settings, he get's 182 days of his life back. That's about 0.63% of his remaining life. 182 joyful days he can spend with family and loved ones.	2021-09-15 11:16:09 +02:00
Timo Kösters	10da08e260	fix: room upgrades	2021-09-15 11:16:09 +02:00
Timo Kösters	6255406de0	fix: correct create event warnings	2021-09-15 11:16:09 +02:00
Kurt Roeckx	4c44a7adf5	Implement federation/v1/send_join	2021-09-15 11:16:09 +02:00
Tom Smeding	48fb8c5d4d	Consistent and escaped response in get_pdu 1. The fallback text of the get_pdu admin room command response message now contains the same text as the formatted_body content (namely, the json instead of Debug-formatting of a serde type). 2. The formatted_body content of the get_pdu response is now html-escaped.	2021-09-15 11:16:09 +02:00
Timo Kösters	d058f6522e	fmt	2021-09-15 11:16:09 +02:00
Timo Kösters	8784df0d3a	improvement: limit prev event fetching	2021-09-15 11:16:09 +02:00
Timo Kösters	524b4960cd	fix: don't save empty tokens	2021-09-15 11:16:09 +02:00
Timo Kösters	0176d40347	improvement: faster incoming transaction handling	2021-09-15 11:16:09 +02:00
Timo Kösters	b74b8c48ce	improvement: better prev event fetching, perf improvements	2021-09-15 11:16:09 +02:00
Timo Kösters	8a4b7cf4bd	fix: faster room joins	2021-09-15 11:16:09 +02:00
Timo Kösters	4a9483c07c	fix: don't load endless prev events and fix room join bug	2021-09-15 11:16:09 +02:00
Timo Kösters	8f1a41dcd2	improvement: better sqlite	2021-09-15 11:16:09 +02:00
Timo Kösters	6f58af0b99	improvement: state info cache	2021-09-15 11:16:09 +02:00
Timo Kösters	ac9dce2bdf	fix: fetch event multiple times	2021-09-15 11:16:09 +02:00
Timo Kösters	197a111748	fix: also fetch prev events that are outliers already	2021-09-15 11:16:09 +02:00
Timo Kösters	b9f138450c	fix: fetch more than one prev event	2021-09-15 11:16:09 +02:00
Timo Kösters	1aecadf990	fix: don't use recursion for prev events	2021-09-15 11:16:09 +02:00
Timo Kösters	7514aa5d95	fmt	2021-09-15 11:16:09 +02:00
Timo Kösters	c0c783fdec	remove prev event fetch limit	2021-09-15 11:16:09 +02:00
Timo Kösters	b02e4bf46c	fix: delta calculation	2021-09-15 11:16:09 +02:00
Timo Kösters	87f5f17134	fix: room exists panic	2021-09-15 11:16:09 +02:00
Timo Kösters	f1aea98384	finish implementing better state store	2021-09-15 11:16:09 +02:00
Timo Kösters	caebb13a98	improvement: migrations, batch inserts	2021-09-15 11:16:09 +02:00
Timo Kösters	0b073c6534	WIP improvement: much better state storage	2021-09-15 11:16:09 +02:00
Timo Kösters	f29a6d7945	fix: long prev event fetch times for huge rooms	2021-09-15 11:16:09 +02:00
Timo Kösters	8696e627b0	less warnings	2021-09-15 11:16:09 +02:00
Timo Kösters	201de77db4	improvement: cache for short event ids	2021-09-15 11:16:09 +02:00
Timo Kösters	33e84c74ac	improvement: use u64s in auth chain cache	2021-09-15 11:16:09 +02:00
Timo Kösters	39d1f86050	improvement: smaller cache, better prev event fetching	2021-09-15 11:16:09 +02:00
Jonas Zohren	afa71756c0	WIP: change layout of config options documentation	2021-09-07 11:36:28 +02:00
Jonas Zohren	d0e06b49da	Switch to mdbook Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-08-19 16:46:03 +02:00
Jonas Zohren	5547c0f579	Merge remote-tracking branch 'origin/docs-overhaul' into docs-overhaul # Conflicts: # mkdocs.yml	2021-08-19 12:37:05 +02:00
Jonas Zohren	66bc3958ff	Document configuration options in own file Signed-off-by: Jonas Zohren <git-pbkyr@jzohren.de>	2021-08-19 12:36:29 +02:00
Jonas Zohren	7e48567d4b	Move some documentation to docs/ and start overhaul	2021-08-19 11:39:30 +02:00
Jonas Zohren	10ee0a53f9	Move some documentation to docs/ and start overhaul	2021-07-23 16:56:16 +02:00
@@ -1 +1 @@
 .53
 .52