Upgrade Ruma

Merge branch 'more-event-id-arcs' into 'next'
Use Arc for EventIds in PDUs See merge request famedly/conduit!229
2021-12-23 17:40:42 +01:00 · 2021-12-16 13:06:30 +00:00 · 2021-12-16 13:55:24 +01:00 · 2021-12-15 14:22:30 +00:00 · 2021-12-15 13:58:25 +01:00 · 2021-12-15 13:00:37 +01:00
31 changed files with 651 additions and 736 deletions
@@ -142,8 +142,12 @@ build:debug:cargo:x86_64-unknown-linux-musl:
    DOCKER_HOST: tcp://docker:2375/
    DOCKER_TLS_CERTDIR: ""
    DOCKER_DRIVER: overlay2
-    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64/v8,linux/amd64"
+    PLATFORMS: "linux/arm/v6,linux/arm/v7,linux/arm64,linux/amd64"
    DOCKER_FILE: "docker/ci-binaries-packaging.Dockerfile"
+  cache:
+    paths:
+      - docker_cache
+    key: "$CI_JOB_NAME"
  before_script:
    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" $CI_REGISTRY
    # Only log in to Dockerhub if the credentials are given:
@@ -156,80 +160,51 @@ build:debug:cargo:x86_64-unknown-linux-musl:
    - 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:
+    - mv ./conduit-aarch64-unknown-linux-musl linux/arm64
+    - 'export CREATED=$(date -u +''%Y-%m-%dT%H:%M:%SZ'') && echo "Docker image creation date: $CREATED"'
+    # Build and push image:
    - >
      docker buildx build
      --pull
      --push
-      --build-arg CREATED=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+      --cache-from=type=local,src=$CI_PROJECT_DIR/docker_cache
+      --cache-to=type=local,dest=$CI_PROJECT_DIR/docker_cache
+      --build-arg CREATED=$CREATED
      --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"
+      --tag "$TAG"
+      --tag "$TAG-alpine"
+      --tag "$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

-build:docker:next:
+docker:next:gitlab:
  extends: .docker-shared-settings
  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"
+    TAG: "$CI_REGISTRY_IMAGE/matrix-conduit:next"

-build:docker:master:
+docker:next:dockerhub:
+  extends: .docker-shared-settings
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "next" && $DOCKER_HUB'
+  variables:
+    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:next"
+
+docker:master:gitlab:
  extends: .docker-shared-settings
  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"
+    TAG: "$CI_REGISTRY_IMAGE/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"'
-#
-#
+docker:master:dockerhub:
+  extends: .docker-shared-settings
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "master" && $DOCKER_HUB'
+  variables:
+    TAG: "$DOCKER_HUB_IMAGE/matrixconduit/matrix-conduit:latest"

 # --------------------------------------------------------------------- #
 #  Run tests                                                            #
@@ -938,7 +938,7 @@ checksum = "527e8c9ac747e28542699a951517aa9a6945af506cd1f2e1b53a576c17b6cc11"
 dependencies = [
 "bytes",
 "fnv",
- "itoa",
+ "itoa 0.4.8",
 ]

 [[package]]
@@ -979,7 +979,7 @@ dependencies = [
 "http-body",
 "httparse",
 "httpdate",
- "itoa",
+ "itoa 0.4.8",
 "pin-project-lite",
 "socket2 0.4.1",
 "tokio",
@@ -1114,6 +1114,12 @@ version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"

+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
 [[package]]
 name = "jobserver"
 version = "0.1.24"
@@ -1516,12 +1522,6 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "paste"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
-
 [[package]]
 name = "pear"
 version = "0.2.3"
@@ -1990,7 +1990,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "assign",
 "js_int",
@@ -2011,7 +2011,7 @@ dependencies = [
 [[package]]
 name = "ruma-api"
 version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "bytes",
 "http",
@@ -2027,7 +2027,7 @@ dependencies = [
 [[package]]
 name = "ruma-api-macros"
 version = "0.18.5"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2038,7 +2038,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "ruma-api",
 "ruma-common",
@@ -2052,7 +2052,7 @@ dependencies = [
 [[package]]
 name = "ruma-client-api"
 version = "0.12.3"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "assign",
 "bytes",
@@ -2072,7 +2072,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "indexmap",
 "js_int",
@@ -2087,7 +2087,7 @@ dependencies = [
 [[package]]
 name = "ruma-events"
 version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "indoc",
 "js_int",
@@ -2103,7 +2103,7 @@ dependencies = [
 [[package]]
 name = "ruma-events-macros"
 version = "0.24.6"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2114,7 +2114,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2129,9 +2129,8 @@ 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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
- "paste",
 "percent-encoding",
 "rand 0.8.4",
 "ruma-identifiers-macros",
@@ -2144,7 +2143,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "quote",
 "ruma-identifiers-validation",
@@ -2154,7 +2153,7 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-validation"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma?rev=e7f01ca55a1eff437bad754bf0554cc09f44ec2a#e7f01ca55a1eff437bad754bf0554cc09f44ec2a"
+source = "git+https://github.com/ruma/ruma?rev=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "thiserror",
 ]
@@ -2162,7 +2161,7 @@ dependencies = [
 [[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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2175,7 +2174,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "js_int",
 "ruma-api",
@@ -2190,11 +2189,11 @@ 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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "bytes",
 "form_urlencoded",
- "itoa",
+ "itoa 0.4.8",
 "js_int",
 "ruma-serde-macros",
 "serde",
@@ -2204,7 +2203,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -2215,7 +2214,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "base64 0.13.0",
 "ed25519-dalek",
@@ -2232,7 +2231,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=7cf3abbaf02995b03db74429090ca5af1cd71edc#7cf3abbaf02995b03db74429090ca5af1cd71edc"
 dependencies = [
 "itertools 0.10.1",
 "js_int",
@@ -2411,11 +2410,11 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.67"
+version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f9e390c27c3c0ce8bc5d725f6e4d30a29d26659494aa4b17535f7522c5c950"
+checksum = "bcbd0344bc6533bc7ec56df11d42fb70f1b912351c0825ccb7211b59d8af7cf5"
 dependencies = [
- "itoa",
+ "itoa 1.0.1",
 "ryu",
 "serde",
 ]
@@ -2427,7 +2426,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9"
 dependencies = [
 "form_urlencoded",
- "itoa",
+ "itoa 0.4.8",
 "ryu",
 "serde",
 ]
@@ -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 = "7cf3abbaf02995b03db74429090ca5af1cd71edc", 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"] }

@@ -36,11 +36,11 @@ http = "0.2.4"
 # Used to find data directory for default db path
 directories = "3.0.2"
 # Used for ruma wrapper
-serde_json = { version = "1.0.67", features = ["raw_value"] }
+serde_json = { version = "1.0.70", features = ["raw_value"] }
 # Used for appservice registration files
 serde_yaml = "0.8.20"
 # Used for pdu definition
-serde = "1.0.130"
+serde = { version = "1.0.130", features = ["rc"] }
 # Used for secure identifiers
 rand = "0.8.4"
 # Used to hash passwords
@@ -12,20 +12,17 @@ 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                            | Download stable version        |
+| ------------------------------------------- | ------------------------------ |
+| x84_64 / amd64 (Most servers and computers) | [Download][x84_64-musl-master] |
+| armv6                                       | [Download][armv6-musl-master]  |
+| armv7 (e.g. Raspberry Pi by default)        | [Download][armv7-musl-master]  |
+| armv8 / aarch64                             | [Download][armv8-musl-master]  |

-[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-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
+[x84_64-musl-master]: 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-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-arm-unknown-linux-musleabihf?job=build:release:cargo:arm-unknown-linux-musleabihf
+[armv7-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-armv7-unknown-linux-musleabihf?job=build:release:cargo:armv7-unknown-linux-musleabihf
+[armv8-musl-master]: https://gitlab.com/famedly/conduit/-/jobs/artifacts/master/raw/conduit-aarch64-unknown-linux-musl?job=build:release:cargo:aarch64-unknown-linux-musl

 ```bash
 $ sudo wget -O /usr/local/bin/matrix-conduit <url>
@@ -32,7 +32,7 @@ RUN touch src/main.rs && touch src/lib.rs && cargo build --release
 # ---------------------------------------------------------------------------------------------------------------
 # Stuff below this line actually ends up in the resulting docker image
 # ---------------------------------------------------------------------------------------------------------------
-FROM docker.io/alpine:3.14 AS runner
+FROM docker.io/alpine:3.15.0 AS runner

 # Standard port on which Conduit launches.
 # You still need to map the port when using the docker command or docker-compose.
@@ -46,7 +46,6 @@ ENV CONDUIT_CONFIG="/srv/conduit/conduit.toml"
 #   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


@@ -54,11 +53,11 @@ RUN apk add --no-cache \
 RUN mkdir -p /srv/conduit/.local/share/conduit

 # Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/
+COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
 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/
+COPY --from=builder /usr/src/conduit/target/release/conduit /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
@@ -1,14 +1,13 @@
 # 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.
-# As a consequence, this is not a multiarch capable image. It always expects and packages a x86_64 binary.
+# It does not build Conduit in Docker, but just copies the matching build artifact from the build jobs.
 #
 # It is mostly based on the normal Conduit Dockerfile, but adjusted in a few places to maximise caching.
 # Credit's for the original Dockerfile: Weasy666.
 # ---------------------------------------------------------------------------------------------------------

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

 # Standard port on which Conduit launches.
 # You still need to map the port when using the docker command or docker-compose.
@@ -47,7 +46,7 @@ LABEL org.opencontainers.image.created=${CREATED} \
 RUN mkdir -p /srv/conduit/.local/share/conduit

 # Test if Conduit is still alive, uses the same endpoint as Element
-COPY ./docker/healthcheck.sh /srv/conduit/
+COPY ./docker/healthcheck.sh /srv/conduit/healthcheck.sh
 HEALTHCHECK --start-period=5s --interval=5s CMD ./healthcheck.sh


@@ -1,8 +1,4 @@
-use std::{
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
-};
+use std::{collections::BTreeMap, convert::TryInto, sync::Arc};

 use super::{DEVICE_ID_LENGTH, SESSION_ID_LENGTH, TOKEN_LENGTH};
 use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
@@ -11,10 +7,9 @@ use ruma::{
        error::ErrorKind,
        r0::{
            account::{
-                change_password, deactivate, get_username_availability, register, whoami,
-                ThirdPartyIdRemovalStatus,
+                change_password, deactivate, get_3pids, get_username_availability, register,
+                whoami, ThirdPartyIdRemovalStatus,
            },
-            contact::get_contacts,
            uiaa::{AuthFlow, AuthType, UiaaInfo},
        },
    },
@@ -34,7 +29,7 @@ use ruma::{
        EventType,
    },
    identifiers::RoomName,
-    push, RoomAliasId, RoomId, UserId,
+    push, RoomAliasId, RoomId, RoomVersionId, UserId,
 };
 use serde_json::value::to_raw_value;
 use tracing::info;
@@ -282,7 +277,7 @@ pub async fn register_route(
        let mut content = RoomCreateEventContent::new(conduit_user.clone());
        content.federate = true;
        content.predecessor = None;
-        content.room_version = db.globals.default_room_version();
+        content.room_version = RoomVersionId::V6;

        // 1. The room create event
        db.rooms.build_and_append_pdu(
@@ -311,6 +306,7 @@ pub async fn register_route(
                    third_party_invite: None,
                    blurhash: None,
                    reason: None,
+                    join_authorized_via_users_server: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -397,8 +393,7 @@ pub async fn register_route(
        )?;

        // 6. Events implied by name and topic
-        let room_name =
-            Box::<RoomName>::try_from(format!("{} Admin Room", db.globals.server_name()))
+        let room_name = RoomName::parse(format!("{} Admin Room", db.globals.server_name()))
            .expect("Room name is valid");
        db.rooms.build_and_append_pdu(
            PduBuilder {
@@ -433,7 +428,7 @@ pub async fn register_route(
        )?;

        // Room alias
-        let alias: RoomAliasId = format!("#admins:{}", db.globals.server_name())
+        let alias: Box<RoomAliasId> = format!("#admins:{}", db.globals.server_name())
            .try_into()
            .expect("#admins:server_name is a valid alias name");

@@ -469,6 +464,7 @@ pub async fn register_route(
                    third_party_invite: None,
                    blurhash: None,
                    reason: None,
+                    join_authorized_via_users_server: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -491,6 +487,7 @@ pub async fn register_route(
                    third_party_invite: None,
                    blurhash: None,
                    reason: None,
+                    join_authorized_via_users_server: None,
                })
                .expect("event is valid, we just created it"),
                unsigned: None,
@@ -707,6 +704,7 @@ pub async fn deactivate_route(
            third_party_invite: None,
            blurhash: None,
            reason: None,
+            join_authorized_via_users_server: None,
        };

        let mutex_state = Arc::clone(
@@ -757,9 +755,9 @@ pub async fn deactivate_route(
    get("/_matrix/client/r0/account/3pid", data = "<body>")
 )]
 pub async fn third_party_route(
-    body: Ruma<get_contacts::Request>,
-) -> ConduitResult<get_contacts::Response> {
+    body: Ruma<get_3pids::Request>,
+) -> ConduitResult<get_3pids::Response> {
    let _sender_user = body.sender_user.as_ref().expect("user is authenticated");

-    Ok(get_contacts::Response::new(Vec::new()).into())
+    Ok(get_3pids::Response::new(Vec::new()).into())
 }
@@ -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::V5, RoomVersionStability::Stable);
+    available.insert(RoomVersionId::V6, RoomVersionStability::Stable);

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

@@ -167,7 +167,7 @@ pub(crate) async fn get_public_rooms_filtered_helper(
                other_server,
                federation::directory::get_public_rooms_filtered::v1::Request {
                    limit,
-                    since: since.as_deref(),
+                    since,
                    filter: Filter {
                        generic_search_term: filter.generic_search_term.as_deref(),
                    },
@@ -15,7 +15,7 @@ use ruma::{
        },
        federation,
    },
-    encryption::UnsignedDeviceInfo,
+    serde::Raw,
    DeviceId, DeviceKeyAlgorithm, UserId,
 };
 use serde_json::json;
@@ -42,16 +42,9 @@ pub async fn upload_keys_route(
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
    let sender_device = body.sender_device.as_ref().expect("user is authenticated");

-    if let Some(one_time_keys) = &body.one_time_keys {
-        for (key_key, key_value) in one_time_keys {
-            db.users.add_one_time_key(
-                sender_user,
-                sender_device,
-                key_key,
-                key_value,
-                &db.globals,
-            )?;
-        }
+    for (key_key, key_value) in &body.one_time_keys {
+        db.users
+            .add_one_time_key(sender_user, sender_device, key_key, key_value, &db.globals)?;
    }

    if let Some(device_keys) = &body.device_keys {
@@ -316,7 +309,7 @@ pub async fn get_key_changes_route(

 pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
    sender_user: Option<&UserId>,
-    device_keys_input: &BTreeMap<UserId, Vec<Box<DeviceId>>>,
+    device_keys_input: &BTreeMap<Box<UserId>, Vec<Box<DeviceId>>>,
    allowed_signatures: F,
    db: &Database,
 ) -> Result<get_keys::Response> {
@@ -328,6 +321,8 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
    let mut get_over_federation = HashMap::new();

    for (user_id, device_ids) in device_keys_input {
+        let user_id: &UserId = &**user_id;
+
        if user_id.server_name() != db.globals.server_name() {
            get_over_federation
                .entry(user_id.server_name())
@@ -348,18 +343,16 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
                            Error::bad_database("all_device_keys contained nonexistent device.")
                        })?;

-                    keys.unsigned = UnsignedDeviceInfo {
-                        device_display_name: metadata.display_name,
-                    };
-
+                    add_unsigned_device_display_name(&mut keys, metadata)
+                        .map_err(|_| Error::bad_database("invalid device keys in database"))?;
                    container.insert(device_id, keys);
                }
            }
-            device_keys.insert(user_id.clone(), container);
+            device_keys.insert(user_id.to_owned(), container);
        } else {
            for device_id in device_ids {
                let mut container = BTreeMap::new();
-                if let Some(mut keys) = db.users.get_device_keys(&user_id.clone(), device_id)? {
+                if let Some(mut keys) = db.users.get_device_keys(user_id, device_id)? {
                    let metadata = db.users.get_device_metadata(user_id, device_id)?.ok_or(
                        Error::BadRequest(
                            ErrorKind::InvalidParam,
@@ -367,28 +360,26 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
                        ),
                    )?;

-                    keys.unsigned = UnsignedDeviceInfo {
-                        device_display_name: metadata.display_name,
-                    };
-
-                    container.insert(device_id.clone(), keys);
+                    add_unsigned_device_display_name(&mut keys, metadata)
+                        .map_err(|_| Error::bad_database("invalid device keys in database"))?;
+                    container.insert(device_id.to_owned(), keys);
                }
-                device_keys.insert(user_id.clone(), container);
+                device_keys.insert(user_id.to_owned(), container);
            }
        }

        if let Some(master_key) = db.users.get_master_key(user_id, &allowed_signatures)? {
-            master_keys.insert(user_id.clone(), master_key);
+            master_keys.insert(user_id.to_owned(), master_key);
        }
        if let Some(self_signing_key) = db
            .users
            .get_self_signing_key(user_id, &allowed_signatures)?
        {
-            self_signing_keys.insert(user_id.clone(), self_signing_key);
+            self_signing_keys.insert(user_id.to_owned(), self_signing_key);
        }
        if Some(user_id) == sender_user {
            if let Some(user_signing_key) = db.users.get_user_signing_key(user_id)? {
-                user_signing_keys.insert(user_id.clone(), user_signing_key);
+                user_signing_keys.insert(user_id.to_owned(), user_signing_key);
            }
        }
    }
@@ -400,7 +391,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
        .map(|(server, vec)| async move {
            let mut device_keys_input_fed = BTreeMap::new();
            for (user_id, keys) in vec {
-                device_keys_input_fed.insert(user_id.clone(), keys.clone());
+                device_keys_input_fed.insert(user_id.to_owned(), keys.clone());
            }
            (
                server,
@@ -439,8 +430,26 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
    })
 }

+fn add_unsigned_device_display_name(
+    keys: &mut Raw<ruma::encryption::DeviceKeys>,
+    metadata: ruma::api::client::r0::device::Device,
+) -> serde_json::Result<()> {
+    if let Some(display_name) = metadata.display_name {
+        let mut object = keys.deserialize_as::<serde_json::Map<String, serde_json::Value>>()?;
+
+        let unsigned = object.entry("unsigned").or_insert_with(|| json!({}));
+        if let serde_json::Value::Object(unsigned_object) = unsigned {
+            unsigned_object.insert("device_display_name".to_owned(), display_name.into());
+        }
+
+        *keys = Raw::from_json(serde_json::value::to_raw_value(&object)?);
+    }
+
+    Ok(())
+}
+
 pub(crate) async fn claim_keys_helper(
-    one_time_keys_input: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
+    one_time_keys_input: &BTreeMap<Box<UserId>, BTreeMap<Box<DeviceId>, DeviceKeyAlgorithm>>,
    db: &Database,
 ) -> Result<claim_keys::Response> {
    let mut one_time_keys = BTreeMap::new();
@@ -31,6 +31,7 @@ use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use std::{
    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
    convert::{TryFrom, TryInto},
+    iter,
    sync::{Arc, RwLock},
    time::{Duration, Instant},
 };
@@ -64,7 +65,7 @@ pub async fn join_room_by_id_route(
        .filter_map(|event| serde_json::from_str(event.json().get()).ok())
        .filter_map(|event: serde_json::Value| event.get("sender").cloned())
        .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-        .filter_map(|sender| UserId::try_from(sender).ok())
+        .filter_map(|sender| UserId::parse(sender).ok())
        .map(|user| user.server_name().to_owned())
        .collect();

@@ -72,7 +73,7 @@ pub async fn join_room_by_id_route(

    let ret = join_room_by_id_helper(
        &db,
-        body.sender_user.as_ref(),
+        body.sender_user.as_deref(),
        &body.room_id,
        &servers,
        body.third_party_signed.as_ref(),
@@ -99,9 +100,10 @@ pub async fn join_room_by_id_or_alias_route(
    db: DatabaseGuard,
    body: Ruma<join_room_by_id_or_alias::Request<'_>>,
 ) -> ConduitResult<join_room_by_id_or_alias::Response> {
-    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    let sender_user = body.sender_user.as_deref().expect("user is authenticated");
+    let body = body.body;

-    let (servers, room_id) = match RoomId::try_from(body.room_id_or_alias.clone()) {
+    let (servers, room_id) = match Box::<RoomId>::try_from(body.room_id_or_alias) {
        Ok(room_id) => {
            let mut servers: HashSet<_> = db
                .rooms
@@ -111,7 +113,7 @@ pub async fn join_room_by_id_or_alias_route(
                .filter_map(|event| serde_json::from_str(event.json().get()).ok())
                .filter_map(|event: serde_json::Value| event.get("sender").cloned())
                .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-                .filter_map(|sender| UserId::try_from(sender).ok())
+                .filter_map(|sender| UserId::parse(sender).ok())
                .map(|user| user.server_name().to_owned())
                .collect();

@@ -127,7 +129,7 @@ pub async fn join_room_by_id_or_alias_route(

    let join_room_response = join_room_by_id_helper(
        &db,
-        body.sender_user.as_ref(),
+        Some(sender_user),
        &room_id,
        &servers,
        body.third_party_signed.as_ref(),
@@ -284,6 +286,7 @@ pub async fn ban_user_route(
                third_party_invite: None,
                blurhash: db.users.blurhash(&body.user_id)?,
                reason: None,
+                join_authorized_via_users_server: None,
            }),
            |event| {
                serde_json::from_str(event.content.get())
@@ -531,7 +534,7 @@ async fn join_room_by_id_helper(
            .roomid_mutex_state
            .write()
            .unwrap()
-            .entry(room_id.clone())
+            .entry(room_id.to_owned())
            .or_default(),
    );
    let state_lock = mutex_state.lock().await;
@@ -551,7 +554,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::V5, RoomVersionId::V6],
                    },
                )
                .await;
@@ -566,7 +569,11 @@ 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::V5 || room_version == RoomVersionId::V6 =>
+            {
+                room_version
+            }
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

@@ -598,6 +605,7 @@ async fn join_room_by_id_helper(
                third_party_invite: None,
                blurhash: db.users.blurhash(sender_user)?,
                reason: None,
+                join_authorized_via_users_server: None,
            })
            .expect("event is valid, we just created it"),
        );
@@ -615,11 +623,12 @@ async fn join_room_by_id_helper(
        .expect("event is valid, we just created it");

        // Generate event id
-        let event_id = EventId::try_from(&*format!(
+        let event_id = format!(
            "${}",
            ruma::signatures::reference_hash(&join_event_stub, &room_version)
                .expect("ruma can calculate reference hashes")
-        ))
+        );
+        let event_id = <&EventId>::try_from(event_id.as_str())
            .expect("ruma's reference hashes are valid event ids");

        // Add event_id back
@@ -638,7 +647,7 @@ async fn join_room_by_id_helper(
                remote_server,
                federation::membership::create_join_event::v2::Request {
                    room_id,
-                    event_id: &event_id,
+                    event_id,
                    pdu: &PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
                },
            )
@@ -646,7 +655,7 @@ async fn join_room_by_id_helper(

        db.rooms.get_or_create_shortroomid(room_id, &db.globals)?;

-        let pdu = PduEvent::from_id_val(&event_id, join_event.clone())
+        let pdu = PduEvent::from_id_val(event_id, join_event.clone())
            .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;

        let mut state = HashMap::new();
@@ -734,7 +743,7 @@ async fn join_room_by_id_helper(
        db.rooms.append_pdu(
            &pdu,
            utils::to_canonical_object(&pdu).expect("Pdu is valid canonical object"),
-            &[pdu.event_id.clone()],
+            iter::once(&*pdu.event_id),
            db,
        )?;

@@ -750,6 +759,7 @@ async fn join_room_by_id_helper(
            third_party_invite: None,
            blurhash: db.users.blurhash(sender_user)?,
            reason: None,
+            join_authorized_via_users_server: None,
        };

        db.rooms.build_and_append_pdu(
@@ -771,7 +781,7 @@ async fn join_room_by_id_helper(

    db.flush()?;

-    Ok(join_room_by_id::Response::new(room_id.clone()).into())
+    Ok(join_room_by_id::Response::new(room_id.to_owned()).into())
 }

 fn validate_and_add_event_id(
@@ -779,12 +789,12 @@ fn validate_and_add_event_id(
    room_version: &RoomVersionId,
    pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, String>>>,
    db: &Database,
-) -> Result<(EventId, CanonicalJsonObject)> {
+) -> Result<(Box<EventId>, CanonicalJsonObject)> {
    let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
        error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
        Error::BadServerResponse("Invalid PDU in server response")
    })?;
-    let event_id = EventId::try_from(&*format!(
+    let event_id = EventId::parse(format!(
        "${}",
        ruma::signatures::reference_hash(&value, room_version)
            .expect("ruma can calculate reference hashes")
@@ -851,7 +861,7 @@ pub(crate) async fn invite_helper<'a>(
                    .roomid_mutex_state
                    .write()
                    .unwrap()
-                    .entry(room_id.clone())
+                    .entry(room_id.to_owned())
                    .or_default(),
            );
            let state_lock = mutex_state.lock().await;
@@ -885,12 +895,9 @@ 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| {
-                    create_event.room_version
-                });
+                .map_or(RoomVersionId::V6, |create_event| create_event.room_version);
            let room_version =
                RoomVersion::new(&room_version_id).expect("room version is supported");

@@ -902,6 +909,7 @@ pub(crate) async fn invite_helper<'a>(
                third_party_invite: None,
                blurhash: None,
                reason: None,
+                join_authorized_via_users_server: None,
            })
            .expect("member event is valid value");

@@ -935,9 +943,9 @@ pub(crate) async fn invite_helper<'a>(
            }

            let pdu = PduEvent {
-                event_id: ruma::event_id!("$thiswillbefilledinlater"),
-                room_id: room_id.clone(),
-                sender: sender_user.clone(),
+                event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
+                room_id: room_id.to_owned(),
+                sender: sender_user.to_owned(),
                origin_server_ts: utils::millis_since_unix_epoch()
                    .try_into()
                    .expect("time is valid"),
@@ -1010,11 +1018,12 @@ pub(crate) async fn invite_helper<'a>(
        };

        // Generate event id
-        let expected_event_id = EventId::try_from(&*format!(
+        let expected_event_id = format!(
            "${}",
            ruma::signatures::reference_hash(&pdu_json, &room_version_id)
                .expect("ruma can calculate reference hashes")
-        ))
+        );
+        let expected_event_id = <&EventId>::try_from(expected_event_id.as_str())
            .expect("ruma's reference hashes are valid event ids");

        let response = db
@@ -1024,7 +1033,7 @@ pub(crate) async fn invite_helper<'a>(
                user_id.server_name(),
                create_invite::v2::Request {
                    room_id,
-                    event_id: &expected_event_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,
@@ -1035,8 +1044,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
@@ -1097,7 +1105,7 @@ pub(crate) async fn invite_helper<'a>(
            .roomid_mutex_state
            .write()
            .unwrap()
-            .entry(room_id.clone())
+            .entry(room_id.to_owned())
            .or_default(),
    );
    let state_lock = mutex_state.lock().await;
@@ -1113,6 +1121,7 @@ pub(crate) async fn invite_helper<'a>(
                third_party_invite: None,
                blurhash: db.users.blurhash(user_id)?,
                reason: None,
+                join_authorized_via_users_server: None,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -5,13 +5,8 @@ use ruma::{
        r0::message::{get_message_events, send_message_event},
    },
    events::EventType,
-    EventId,
-};
-use std::{
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
 };
+use std::{collections::BTreeMap, convert::TryInto, sync::Arc};

 #[cfg(feature = "conduit_bin")]
 use rocket::{get, put};
@@ -67,10 +62,9 @@ pub async fn send_message_event_route(
            ));
        }

-        let event_id = EventId::try_from(
-            utils::string_from_bytes(&response)
-                .map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?,
-        )
+        let event_id = utils::string_from_bytes(&response)
+            .map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?
+            .try_into()
            .map_err(|_| Error::bad_database("Invalid event id in txnid data."))?;
        return Ok(send_message_event::Response { event_id }.into());
    }
@@ -104,7 +98,7 @@ pub async fn send_message_event_route(

    db.flush()?;

-    Ok(send_message_event::Response::new(event_id).into())
+    Ok(send_message_event::Response::new((*event_id).to_owned()).into())
 }

 /// # `GET /_matrix/client/r0/rooms/{roomId}/messages`
@@ -105,15 +105,15 @@ pub async fn get_pushrule_route(
 /// Creates a single specified push rule for this user.
 #[cfg_attr(
    feature = "conduit_bin",
-    put("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<req>")
+    put("/_matrix/client/r0/pushrules/<_>/<_>/<_>", data = "<body>")
 )]
-#[tracing::instrument(skip(db, req))]
+#[tracing::instrument(skip(db, body))]
 pub async fn set_pushrule_route(
    db: DatabaseGuard,
-    req: Ruma<set_pushrule::Request<'_>>,
+    body: Ruma<set_pushrule::Request<'_>>,
 ) -> ConduitResult<set_pushrule::Response> {
-    let sender_user = req.sender_user.as_ref().expect("user is authenticated");
-    let body = req.body;
+    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    let body = body.body;

    if body.scope != "global" {
        return Err(Error::BadRequest(
@@ -25,6 +25,7 @@ pub async fn redact_event_route(
    body: Ruma<redact_event::Request<'_>>,
 ) -> ConduitResult<redact_event::Response> {
    let sender_user = body.sender_user.as_ref().expect("user is authenticated");
+    let body = body.body;

    let mutex_state = Arc::clone(
        db.globals
@@ -45,7 +46,7 @@ pub async fn redact_event_route(
            .expect("event is valid, we just created it"),
            unsigned: None,
            state_key: None,
-            redacts: Some(body.event_id.clone()),
+            redacts: Some(body.event_id.into()),
        },
        sender_user,
        &body.room_id,
@@ -57,5 +58,6 @@ pub async fn redact_event_route(

    db.flush()?;

+    let event_id = (*event_id).to_owned();
    Ok(redact_event::Response { event_id }.into())
 }
@@ -1,8 +1,11 @@
-use crate::{database::admin::AdminCommand, database::DatabaseGuard, ConduitResult, Error, Ruma};
+use crate::{
+    database::{admin::AdminCommand, DatabaseGuard},
+    ConduitResult, Error, Ruma,
+};
 use ruma::{
    api::client::{error::ErrorKind, r0::room::report_content},
    events::room::message,
-    Int,
+    int,
 };

 #[cfg(feature = "conduit_bin")]
@@ -33,7 +36,7 @@ pub async fn report_event_route(
        }
    };

-    if body.score > Int::from(0) || body.score < Int::from(-100) {
+    if body.score > int!(0) || body.score < int!(-100) {
        return Err(Error::BadRequest(
            ErrorKind::InvalidParam,
            "Invalid score, must be within 0 to -100",
@@ -57,8 +60,7 @@ pub async fn report_event_route(
                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>\
@@ -72,8 +74,7 @@ pub async fn report_event_route(
                pdu.sender,
                body.score,
                RawStr::new(&body.reason).html_escape()
-            )
-            .to_owned(),
+            ),
        ),
    ));

@@ -22,16 +22,12 @@ use ruma::{
        },
        EventType,
    },
+    int,
    serde::{CanonicalJsonObject, JsonObject},
-    RoomAliasId, RoomId,
+    RoomAliasId, RoomId, RoomVersionId,
 };
 use serde_json::{json, value::to_raw_value};
-use std::{
-    cmp::max,
-    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
-    sync::Arc,
-};
+use std::{cmp::max, collections::BTreeMap, convert::TryInto, sync::Arc};
 use tracing::{info, warn};

 #[cfg(feature = "conduit_bin")]
@@ -88,14 +84,16 @@ pub async fn create_room_route(
        ));
    }

-    let alias: Option<RoomAliasId> =
+    let alias: Option<Box<RoomAliasId>> =
        body.room_alias_name
            .as_ref()
            .map_or(Ok(None), |localpart| {
                // TODO: Check for invalid characters and maximum length
                let alias =
-                    RoomAliasId::try_from(format!("#{}:{}", localpart, db.globals.server_name()))
-                        .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias."))?;
+                    RoomAliasId::parse(format!("#{}:{}", localpart, db.globals.server_name()))
+                        .map_err(|_| {
+                            Error::BadRequest(ErrorKind::InvalidParam, "Invalid alias.")
+                        })?;

                if db.rooms.id_from_alias(&alias)?.is_some() {
                    Err(Error::BadRequest(
@@ -109,7 +107,7 @@ pub async fn create_room_route(

    let room_version = match body.room_version.clone() {
        Some(room_version) => {
-            if db.rooms.is_supported_version(&db, &room_version) {
+            if room_version == RoomVersionId::V5 || room_version == RoomVersionId::V6 {
                room_version
            } else {
                return Err(Error::BadRequest(
@@ -118,7 +116,7 @@ pub async fn create_room_route(
                ));
            }
        }
-        None => db.globals.default_room_version(),
+        None => RoomVersionId::V6,
    };

    let content = match &body.creation_content {
@@ -164,7 +162,7 @@ pub async fn create_room_route(
            .get(),
    );

-    if let Err(_) = de_result {
+    if de_result.is_err() {
        return Err(Error::BadRequest(
            ErrorKind::BadJson,
            "Invalid creation content",
@@ -198,6 +196,7 @@ pub async fn create_room_route(
                third_party_invite: None,
                blurhash: db.users.blurhash(sender_user)?,
                reason: None,
+                join_authorized_via_users_server: None,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -223,11 +222,11 @@ pub async fn create_room_route(
        });

    let mut users = BTreeMap::new();
-    users.insert(sender_user.clone(), 100.into());
+    users.insert(sender_user.clone(), int!(100));

    if preset == create_room::RoomPreset::TrustedPrivateChat {
        for invite_ in &body.invite {
-            users.insert(invite_.clone(), 100.into());
+            users.insert(invite_.clone(), int!(100));
        }
    }

@@ -269,7 +268,7 @@ pub async fn create_room_route(
            PduBuilder {
                event_type: EventType::RoomCanonicalAlias,
                content: to_raw_value(&RoomCanonicalAliasEventContent {
-                    alias: Some(room_alias_id.clone()),
+                    alias: Some(room_alias_id.to_owned()),
                    alt_aliases: vec![],
                })
                .expect("We checked that alias earlier, it must be fine"),
@@ -505,7 +504,7 @@ 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::V5 | RoomVersionId::V6) {
        return Err(Error::BadRequest(
            ErrorKind::UnsupportedRoomVersion,
            "This server does not support that room version.",
@@ -572,7 +571,7 @@ pub async fn upgrade_room_route(
    // Use the m.room.tombstone event as the predecessor
    let predecessor = Some(ruma::events::room::create::PreviousRoom::new(
        body.room_id.clone(),
-        tombstone_event_id,
+        (*tombstone_event_id).to_owned(),
    ));

    // Send a m.room.create event containing a predecessor field and the applicable room_version
@@ -602,7 +601,7 @@ pub async fn upgrade_room_route(
            .get(),
    );

-    if let Err(_) = de_result {
+    if de_result.is_err() {
        return Err(Error::BadRequest(
            ErrorKind::BadJson,
            "Error forming creation event",
@@ -636,6 +635,7 @@ pub async fn upgrade_room_route(
                third_party_invite: None,
                blurhash: db.users.blurhash(sender_user)?,
                reason: None,
+                join_authorized_via_users_server: None,
            })
            .expect("event is valid, we just created it"),
            unsigned: None,
@@ -700,10 +700,7 @@ pub async fn upgrade_room_route(
    .map_err(|_| Error::bad_database("Invalid room event in database."))?;

    // Setting events_default and invite to the greater of 50 and users_default + 1
-    let new_level = max(
-        50.into(),
-        power_levels_event_content.users_default + 1.into(),
-    );
+    let new_level = max(int!(50), power_levels_event_content.users_default + int!(1));
    power_levels_event_content.events_default = new_level;
    power_levels_event_content.invite = new_level;

@@ -52,6 +52,7 @@ pub async fn send_state_event_for_key_route(

    db.flush()?;

+    let event_id = (*event_id).to_owned();
    Ok(send_state_event::Response { event_id }.into())
 }

@@ -93,6 +94,7 @@ pub async fn send_state_event_for_empty_key_route(

    db.flush()?;

+    let event_id = (*event_id).to_owned();
    Ok(send_state_event::Response { event_id }.into())
 }

@@ -267,7 +269,7 @@ async fn send_state_event_for_key_helper(
    event_type: EventType,
    json: &Raw<AnyStateEventContent>,
    state_key: String,
-) -> Result<EventId> {
+) -> Result<Arc<EventId>> {
    let sender_user = sender;

    // TODO: Review this check, error if event is unparsable, use event type, allow alias if it
@@ -303,7 +305,7 @@ async fn send_state_event_for_key_helper(
            .roomid_mutex_state
            .write()
            .unwrap()
-            .entry(room_id.clone())
+            .entry(room_id.to_owned())
            .or_default(),
    );
    let state_lock = mutex_state.lock().await;
@@ -10,7 +10,7 @@ use ruma::{
 };
 use std::{
    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
-    convert::{TryFrom, TryInto},
+    convert::TryInto,
    sync::Arc,
    time::Duration,
 };
@@ -61,8 +61,9 @@ pub async fn sync_events_route(
    db: DatabaseGuard,
    body: Ruma<sync_events::Request<'_>>,
 ) -> 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");
+    let sender_user = body.sender_user.expect("user is authenticated");
+    let sender_device = body.sender_device.expect("user is authenticated");
+    let body = body.body;

    let arc_db = Arc::new(db);

@@ -132,7 +133,7 @@ pub async fn sync_events_route(

 async fn sync_helper_wrapper(
    db: Arc<DatabaseGuard>,
-    sender_user: UserId,
+    sender_user: Box<UserId>,
    sender_device: Box<DeviceId>,
    since: Option<String>,
    full_state: bool,
@@ -176,7 +177,7 @@ async fn sync_helper_wrapper(

 async fn sync_helper(
    db: Arc<DatabaseGuard>,
-    sender_user: UserId,
+    sender_user: Box<UserId>,
    sender_device: Box<DeviceId>,
    since: Option<String>,
    full_state: bool,
@@ -296,7 +297,7 @@ async fn sync_helper(
                            })?;

                        if let Some(state_key) = &pdu.state_key {
-                            let user_id = UserId::try_from(state_key.clone()).map_err(|_| {
+                            let user_id = UserId::parse(state_key.clone()).map_err(|_| {
                                Error::bad_database("Invalid UserId in member PDU.")
                            })?;

@@ -424,7 +425,7 @@ async fn sync_helper(
                    }

                    if let Some(state_key) = &state_event.state_key {
-                        let user_id = UserId::try_from(state_key.clone())
+                        let user_id = UserId::parse(state_key.clone())
                            .map_err(|_| Error::bad_database("Invalid UserId in member PDU."))?;

                        if user_id == sender_user {
@@ -761,6 +762,8 @@ async fn sync_helper(
                .users
                .get_to_device_events(&sender_user, &sender_device)?,
        },
+        // Fallback keys are not yet supported
+        device_unused_fallback_key_types: None,
    };

    // TODO: Retry the endpoint instead of returning (waiting for #118)
@@ -793,7 +796,7 @@ fn share_encrypted_room(
 ) -> Result<bool> {
    Ok(db
        .rooms
-        .get_shared_rooms(vec![sender_user.clone(), user_id.clone()])?
+        .get_shared_rooms(vec![sender_user.to_owned(), user_id.to_owned()])?
        .filter_map(|r| r.ok())
        .filter(|room_id| room_id != ignore_room)
        .filter_map(|other_room_id| {
@@ -26,7 +26,7 @@ pub async fn turn_server_route(

    let turn_secret = db.globals.turn_secret();

-    let (username, password) = if turn_secret != "" {
+    let (username, password) = if !turn_secret.is_empty() {
        let expiry = SecondsSinceUnixEpoch::from_system_time(
            SystemTime::now() + Duration::from_secs(db.globals.turn_ttl()),
        )
@@ -49,8 +49,8 @@ pub async fn turn_server_route(
    };

    Ok(get_turn_server_info::Response {
-        username: username,
-        password: password,
+        username,
+        password,
        uris: db.globals.turn_uris().to_vec(),
        ttl: Duration::from_secs(db.globals.turn_ttl()),
    }
@@ -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},
@@ -63,12 +63,8 @@ pub struct Config {
    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)]
@@ -141,10 +137,6 @@ 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()
 }
@@ -484,10 +476,9 @@ impl Database {
            if db.globals.database_version()? < 6 {
                // Set room member count
                for (roomid, _) in db.rooms.roomid_shortstatehash.iter() {
-                    let room_id =
-                        RoomId::try_from(utils::string_from_bytes(&roomid).unwrap()).unwrap();
-
-                    db.rooms.update_joined_count(&room_id, &db)?;
+                    let string = utils::string_from_bytes(&roomid).unwrap();
+                    let room_id = <&RoomId>::try_from(string.as_str()).unwrap();
+                    db.rooms.update_joined_count(room_id, &db)?;
                }

                db.globals.bump_database_version(6)?;
@@ -497,7 +488,7 @@ impl Database {

            if db.globals.database_version()? < 7 {
                // Upgrade state store
-                let mut last_roomstates: HashMap<RoomId, u64> = HashMap::new();
+                let mut last_roomstates: HashMap<Box<RoomId>, u64> = HashMap::new();
                let mut current_sstatehash: Option<u64> = None;
                let mut current_room = None;
                let mut current_state = HashSet::new();
@@ -578,7 +569,7 @@ impl Database {
                        if let Some(current_sstatehash) = current_sstatehash {
                            handle_state(
                                current_sstatehash,
-                                current_room.as_ref().unwrap(),
+                                current_room.as_deref().unwrap(),
                                current_state,
                                &mut last_roomstates,
                            )?;
@@ -594,10 +585,9 @@ impl Database {
                            .get(&seventid)
                            .unwrap()
                            .unwrap();
-                        let event_id =
-                            EventId::try_from(utils::string_from_bytes(&event_id).unwrap())
-                                .unwrap();
-                        let pdu = db.rooms.get_pdu(&event_id).unwrap().unwrap();
+                        let string = utils::string_from_bytes(&event_id).unwrap();
+                        let event_id = <&EventId>::try_from(string.as_str()).unwrap();
+                        let pdu = db.rooms.get_pdu(event_id).unwrap().unwrap();

                        if Some(&pdu.room_id) != current_room.as_ref() {
                            current_room = Some(pdu.room_id.clone());
@@ -612,7 +602,7 @@ impl Database {
                if let Some(current_sstatehash) = current_sstatehash {
                    handle_state(
                        current_sstatehash,
-                        current_room.as_ref().unwrap(),
+                        current_room.as_deref().unwrap(),
                        current_state,
                        &mut last_roomstates,
                    )?;
@@ -1,7 +1,4 @@
-use std::{
-    convert::{TryFrom, TryInto},
-    sync::Arc,
-};
+use std::{convert::TryInto, sync::Arc};

 use crate::{pdu::PduBuilder, Database};
 use rocket::futures::{channel::mpsc, stream::StreamExt};
@@ -36,14 +33,14 @@ impl Admin {

            let guard = db.read().await;

-            let conduit_user =
-                UserId::try_from(format!("@conduit:{}", guard.globals.server_name()))
+            let conduit_user = UserId::parse(format!("@conduit:{}", guard.globals.server_name()))
                .expect("@conduit:server_name is valid");

            let conduit_room = guard
                .rooms
                .id_from_alias(
-                    &format!("#admins:{}", guard.globals.server_name())
+                    format!("#admins:{}", guard.globals.server_name())
+                        .as_str()
                        .try_into()
                        .expect("#admins:server_name is a valid room alias"),
                )
@@ -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,16 +39,14 @@ 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_event_ratelimiter: Arc<RwLock<HashMap<Box<EventId>, RateLimitState>>>,
    pub bad_signature_ratelimiter: Arc<RwLock<HashMap<Vec<String>, RateLimitState>>>,
    pub servername_ratelimiter: Arc<RwLock<HashMap<Box<ServerName>, Arc<Semaphore>>>>,
-    pub sync_receivers: RwLock<HashMap<(UserId, Box<DeviceId>), SyncHandle>>,
-    pub roomid_mutex_insert: RwLock<HashMap<RoomId, Arc<Mutex<()>>>>,
-    pub roomid_mutex_state: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>,
-    pub roomid_mutex_federation: RwLock<HashMap<RoomId, Arc<TokioMutex<()>>>>, // this lock will be held longer
+    pub sync_receivers: RwLock<HashMap<(Box<UserId>, Box<DeviceId>), SyncHandle>>,
+    pub roomid_mutex_insert: RwLock<HashMap<Box<RoomId>, Arc<Mutex<()>>>>,
+    pub roomid_mutex_state: RwLock<HashMap<Box<RoomId>, Arc<TokioMutex<()>>>>,
+    pub roomid_mutex_federation: RwLock<HashMap<Box<RoomId>, Arc<TokioMutex<()>>>>, // this lock will be held longer
    pub rotate: RotationHandler,
 }

@@ -135,16 +132,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 +143,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 +155,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)
    }

@@ -236,14 +214,6 @@ impl Globals {
        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
    }
@@ -276,15 +246,6 @@ impl Globals {
        &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.
    ///
@@ -293,7 +254,7 @@ impl Globals {
        &self,
        origin: &ServerName,
        new_keys: ServerSigningKeys,
-    ) -> Result<BTreeMap<ServerSigningKeyId, VerifyKey>> {
+    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
        // Not atomic, but this is not critical
        let signingkeys = self.server_signingkeys.get(origin.as_bytes())?;

@@ -332,7 +293,7 @@ impl Globals {
    pub fn signing_keys_for(
        &self,
        origin: &ServerName,
-    ) -> Result<BTreeMap<ServerSigningKeyId, VerifyKey>> {
+    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
        let signingkeys = self
            .server_signingkeys
            .get(origin.as_bytes())?
@@ -4,9 +4,11 @@ use ruma::{
        error::ErrorKind,
        r0::backup::{BackupAlgorithm, KeyBackupData, RoomKeyBackup},
    },
+    serde::Raw,
    RoomId, UserId,
 };
-use std::{collections::BTreeMap, convert::TryFrom, sync::Arc};
+use serde_json::json;
+use std::{collections::BTreeMap, sync::Arc};

 use super::abstraction::Tree;

@@ -20,7 +22,7 @@ impl KeyBackups {
    pub fn create_backup(
        &self,
        user_id: &UserId,
-        backup_metadata: &BackupAlgorithm,
+        backup_metadata: &Raw<BackupAlgorithm>,
        globals: &super::globals::Globals,
    ) -> Result<String> {
        let version = globals.next_count()?.to_string();
@@ -59,7 +61,7 @@ impl KeyBackups {
        &self,
        user_id: &UserId,
        version: &str,
-        backup_metadata: &BackupAlgorithm,
+        backup_metadata: &Raw<BackupAlgorithm>,
        globals: &super::globals::Globals,
    ) -> Result<String> {
        let mut key = user_id.as_bytes().to_vec();
@@ -73,12 +75,8 @@ impl KeyBackups {
            ));
        }

-        self.backupid_algorithm.insert(
-            &key,
-            serde_json::to_string(backup_metadata)
-                .expect("BackupAlgorithm::to_string always works")
-                .as_bytes(),
-        )?;
+        self.backupid_algorithm
+            .insert(&key, backup_metadata.json().get().as_bytes())?;
        self.backupid_etag
            .insert(&key, &globals.next_count()?.to_be_bytes())?;
        Ok(version.to_owned())
@@ -105,7 +103,10 @@ impl KeyBackups {
            .transpose()
    }

-    pub fn get_latest_backup(&self, user_id: &UserId) -> Result<Option<(String, BackupAlgorithm)>> {
+    pub fn get_latest_backup(
+        &self,
+        user_id: &UserId,
+    ) -> Result<Option<(String, Raw<BackupAlgorithm>)>> {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);
        let mut last_possible_key = prefix.clone();
@@ -133,7 +134,11 @@ impl KeyBackups {
            .transpose()
    }

-    pub fn get_backup(&self, user_id: &UserId, version: &str) -> Result<Option<BackupAlgorithm>> {
+    pub fn get_backup(
+        &self,
+        user_id: &UserId,
+        version: &str,
+    ) -> Result<Option<Raw<BackupAlgorithm>>> {
        let mut key = user_id.as_bytes().to_vec();
        key.push(0xff);
        key.extend_from_slice(version.as_bytes());
@@ -152,7 +157,7 @@ impl KeyBackups {
        version: &str,
        room_id: &RoomId,
        session_id: &str,
-        key_data: &KeyBackupData,
+        key_data: &Raw<KeyBackupData>,
        globals: &super::globals::Globals,
    ) -> Result<()> {
        let mut key = user_id.as_bytes().to_vec();
@@ -174,10 +179,8 @@ impl KeyBackups {
        key.push(0xff);
        key.extend_from_slice(session_id.as_bytes());

-        self.backupkeyid_backup.insert(
-            &key,
-            &serde_json::to_vec(&key_data).expect("KeyBackupData::to_vec always works"),
-        )?;
+        self.backupkeyid_backup
+            .insert(&key, key_data.json().get().as_bytes())?;

        Ok(())
    }
@@ -209,13 +212,13 @@ impl KeyBackups {
        &self,
        user_id: &UserId,
        version: &str,
-    ) -> Result<BTreeMap<RoomId, RoomKeyBackup>> {
+    ) -> Result<BTreeMap<Box<RoomId>, Raw<RoomKeyBackup>>> {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);
        prefix.extend_from_slice(version.as_bytes());
        prefix.push(0xff);

-        let mut rooms = BTreeMap::<RoomId, RoomKeyBackup>::new();
+        let mut rooms = BTreeMap::<Box<RoomId>, Raw<RoomKeyBackup>>::new();

        for result in self
            .backupkeyid_backup
@@ -231,7 +234,7 @@ impl KeyBackups {
                        Error::bad_database("backupkeyid_backup session_id is invalid.")
                    })?;

-                let room_id = RoomId::try_from(
+                let room_id = RoomId::parse(
                    utils::string_from_bytes(parts.next().ok_or_else(|| {
                        Error::bad_database("backupkeyid_backup key is invalid.")
                    })?)
@@ -241,7 +244,7 @@ impl KeyBackups {
                    Error::bad_database("backupkeyid_backup room_id is invalid room id.")
                })?;

-                let key_data = serde_json::from_slice(&value).map_err(|_| {
+                let key_data: serde_json::Value = serde_json::from_slice(&value).map_err(|_| {
                    Error::bad_database("KeyBackupData in backupkeyid_backup is invalid.")
                })?;

@@ -249,13 +252,25 @@ impl KeyBackups {
            })
        {
            let (room_id, session_id, key_data) = result?;
-            rooms
-                .entry(room_id)
-                .or_insert_with(|| RoomKeyBackup {
+            let room_key_backup = rooms.entry(room_id).or_insert_with(|| {
+                Raw::new(&RoomKeyBackup {
                    sessions: BTreeMap::new(),
                })
-                .sessions
-                .insert(session_id, key_data);
+                .expect("RoomKeyBackup serialization")
+            });
+
+            let mut object = room_key_backup
+                .deserialize_as::<serde_json::Map<String, serde_json::Value>>()
+                .map_err(|_| Error::bad_database("RoomKeyBackup is not an object"))?;
+
+            let sessions = object.entry("session").or_insert_with(|| json!({}));
+            if let serde_json::Value::Object(unsigned_object) = sessions {
+                unsigned_object.insert(session_id, key_data);
+            }
+
+            *room_key_backup = Raw::from_json(
+                serde_json::value::to_raw_value(&object).expect("Value => RawValue serialization"),
+            );
        }

        Ok(rooms)
@@ -266,7 +281,7 @@ impl KeyBackups {
        user_id: &UserId,
        version: &str,
        room_id: &RoomId,
-    ) -> Result<BTreeMap<String, KeyBackupData>> {
+    ) -> Result<BTreeMap<String, Raw<KeyBackupData>>> {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);
        prefix.extend_from_slice(version.as_bytes());
@@ -304,7 +319,7 @@ impl KeyBackups {
        version: &str,
        room_id: &RoomId,
        session_id: &str,
-    ) -> Result<Option<KeyBackupData>> {
+    ) -> Result<Option<Raw<KeyBackupData>>> {
        let mut key = user_id.as_bytes().to_vec();
        key.push(0xff);
        key.extend_from_slice(version.as_bytes());
@@ -234,7 +234,7 @@ pub fn get_actions<'a>(
    db: &Database,
 ) -> Result<&'a [Action]> {
    let ctx = PushConditionRoomCtx {
-        room_id: room_id.clone(),
+        room_id: room_id.to_owned(),
        member_count: 10_u32.into(), // TODO: get member count efficiently
        user_display_name: db
            .users
@@ -277,7 +277,7 @@ async fn send_notice(
    let mut data_minus_url = pusher.data.clone();
    // The url must be stripped off according to spec
    data_minus_url.url = None;
-    device.data = Some(data_minus_url);
+    device.data = data_minus_url;

    // Tweaks are only added if the format is NOT event_id_only
    if !event_id_only {
@@ -36,6 +36,8 @@ use std::{
    borrow::Cow,
    collections::{BTreeMap, HashMap, HashSet},
    convert::{TryFrom, TryInto},
+    fmt::Debug,
+    iter,
    mem::size_of,
    sync::{Arc, Mutex, RwLock},
    time::Instant,
@@ -107,14 +109,14 @@ pub struct Rooms {
    /// RoomId + EventId -> Parent PDU EventId.
    pub(super) referencedevents: Arc<dyn Tree>,

-    pub(super) pdu_cache: Mutex<LruCache<EventId, Arc<PduEvent>>>,
+    pub(super) pdu_cache: Mutex<LruCache<Box<EventId>, Arc<PduEvent>>>,
    pub(super) shorteventid_cache: Mutex<LruCache<u64, Arc<EventId>>>,
    pub(super) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<HashSet<u64>>>>,
-    pub(super) eventidshort_cache: Mutex<LruCache<EventId, u64>>,
+    pub(super) eventidshort_cache: Mutex<LruCache<Box<EventId>, u64>>,
    pub(super) statekeyshort_cache: Mutex<LruCache<(EventType, String), u64>>,
    pub(super) shortstatekey_cache: Mutex<LruCache<u64, (EventType, String)>>,
-    pub(super) our_real_users_cache: RwLock<HashMap<RoomId, Arc<HashSet<UserId>>>>,
-    pub(super) appservice_in_room_cache: RwLock<HashMap<RoomId, HashMap<String, bool>>>,
+    pub(super) our_real_users_cache: RwLock<HashMap<Box<RoomId>, Arc<HashSet<Box<UserId>>>>>,
+    pub(super) appservice_in_room_cache: RwLock<HashMap<Box<RoomId>, HashMap<String, bool>>>,
    pub(super) stateinfo_cache: Mutex<
        LruCache<
            u64,
@@ -129,12 +131,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))]
@@ -440,7 +436,7 @@ impl Rooms {
                None => continue,
            };

-            let user_id = match UserId::try_from(state_key) {
+            let user_id = match UserId::parse(state_key) {
                Ok(id) => id,
                Err(_) => continue,
            };
@@ -748,7 +744,7 @@ impl Rooms {
        self.eventidshort_cache
            .lock()
            .unwrap()
-            .insert(event_id.clone(), short);
+            .insert(event_id.to_owned(), short);

        Ok(short)
    }
@@ -877,12 +873,10 @@ impl Rooms {
            .get(&shorteventid.to_be_bytes())?
            .ok_or_else(|| Error::bad_database("Shorteventid does not exist"))?;

-        let event_id = Arc::new(
-            EventId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
+        let event_id = EventId::parse_arc(utils::string_from_bytes(&bytes).map_err(|_| {
            Error::bad_database("EventID in shorteventid_eventid is invalid unicode.")
        })?)
-            .map_err(|_| Error::bad_database("EventId in shorteventid_eventid is invalid."))?,
-        );
+        .map_err(|_| Error::bad_database("EventId in shorteventid_eventid is invalid."))?;

        self.shorteventid_cache
            .lock()
@@ -1118,7 +1112,7 @@ impl Rooms {
            self.pdu_cache
                .lock()
                .unwrap()
-                .insert(event_id.clone(), Arc::clone(&pdu));
+                .insert(event_id.to_owned(), Arc::clone(&pdu));
            Ok(Some(pdu))
        } else {
            Ok(None)
@@ -1168,14 +1162,14 @@ impl Rooms {

    /// Returns the leaf pdus of a room.
    #[tracing::instrument(skip(self))]
-    pub fn get_pdu_leaves(&self, room_id: &RoomId) -> Result<HashSet<EventId>> {
+    pub fn get_pdu_leaves(&self, room_id: &RoomId) -> Result<HashSet<Arc<EventId>>> {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.roomid_pduleaves
            .scan_prefix(prefix)
            .map(|(_, bytes)| {
-                EventId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
+                EventId::parse_arc(utils::string_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("EventID in roomid_pduleaves is invalid unicode.")
                })?)
                .map_err(|_| Error::bad_database("EventId in roomid_pduleaves is invalid."))
@@ -1184,7 +1178,7 @@ impl Rooms {
    }

    #[tracing::instrument(skip(self, room_id, event_ids))]
-    pub fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<()> {
+    pub fn mark_as_referenced(&self, room_id: &RoomId, event_ids: &[Arc<EventId>]) -> Result<()> {
        for prev in event_ids {
            let mut key = room_id.as_bytes().to_vec();
            key.extend_from_slice(prev.as_bytes());
@@ -1199,7 +1193,11 @@ impl Rooms {
    /// The provided `event_ids` become the new leaves, this allows a room to have multiple
    /// `prev_events`.
    #[tracing::instrument(skip(self))]
-    pub fn replace_pdu_leaves(&self, room_id: &RoomId, event_ids: &[EventId]) -> Result<()> {
+    pub fn replace_pdu_leaves<'a>(
+        &self,
+        room_id: &RoomId,
+        event_ids: impl IntoIterator<Item = &'a EventId> + Debug,
+    ) -> Result<()> {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

@@ -1263,11 +1261,11 @@ impl Rooms {
    ///
    /// Returns pdu id
    #[tracing::instrument(skip(self, pdu, pdu_json, leaves, db))]
-    pub fn append_pdu(
+    pub fn append_pdu<'a>(
        &self,
        pdu: &PduEvent,
        mut pdu_json: CanonicalJsonObject,
-        leaves: &[EventId],
+        leaves: impl IntoIterator<Item = &'a EventId> + Debug,
        db: &Database,
    ) -> Result<Vec<u8>> {
        let shortroomid = self.get_shortroomid(&pdu.room_id)?.expect("room exists");
@@ -1426,7 +1424,7 @@ impl Rooms {
                    }

                    // if the state_key fails
-                    let target_user_id = UserId::try_from(state_key.clone())
+                    let target_user_id = UserId::parse(state_key.clone())
                        .expect("This state_key was previously validated");

                    let content = serde_json::from_str::<ExtractMembership>(pdu.content.get())
@@ -1482,8 +1480,9 @@ impl Rooms {
                    if body.starts_with(&format!("@conduit:{}: ", db.globals.server_name()))
                        && self
                            .id_from_alias(
-                                &format!("#admins:{}", db.globals.server_name())
-                                    .try_into()
+                                <&RoomAliasId>::try_from(
+                                    format!("#admins:{}", db.globals.server_name()).as_str(),
+                                )
                                .expect("#admins:server_name is a valid room alias"),
                            )?
                            .as_ref()
@@ -1534,7 +1533,7 @@ impl Rooms {
                                }
                                "get_auth_chain" => {
                                    if args.len() == 1 {
-                                        if let Ok(event_id) = EventId::try_from(args[0]) {
+                                        if let Ok(event_id) = EventId::parse_arc(args[0]) {
                                            if let Some(event) = db.rooms.get_pdu_json(&event_id)? {
                                                let room_id_str = event
                                                    .get("room_id")
@@ -1545,12 +1544,12 @@ impl Rooms {
                                                        )
                                                    })?;

-                                                let room_id = RoomId::try_from(room_id_str)
+                                                let room_id = <&RoomId>::try_from(room_id_str)
                                                    .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;
                                                let start = Instant::now();
                                                let count = server_server::get_auth_chain(
-                                                    &room_id,
-                                                    vec![Arc::new(event_id)],
+                                                    room_id,
+                                                    vec![event_id],
                                                    db,
                                                )?
                                                .count();
@@ -1573,12 +1572,12 @@ impl Rooms {
                                        let string = body[1..body.len() - 1].join("\n");
                                        match serde_json::from_str(&string) {
                                            Ok(value) => {
-                                                let event_id = EventId::try_from(&*format!(
+                                                let event_id = EventId::parse(format!(
                                                    "${}",
                                                    // Anything higher than version3 behaves the same
                                                    ruma::signatures::reference_hash(
                                                        &value,
-                                                        &RoomVersionId::Version6
+                                                        &RoomVersionId::V6
                                                    )
                                                    .expect("ruma can calculate reference hashes")
                                                ))
@@ -1628,7 +1627,7 @@ impl Rooms {
                                }
                                "get_pdu" => {
                                    if args.len() == 1 {
-                                        if let Ok(event_id) = EventId::try_from(args[0]) {
+                                        if let Ok(event_id) = EventId::parse(args[0]) {
                                            let mut outlier = false;
                                            let mut pdu_json =
                                                db.rooms.get_non_outlier_pdu_json(&event_id)?;
@@ -1954,7 +1953,7 @@ impl Rooms {
        room_id: &RoomId,
        db: &Database,
        _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room mutex
-    ) -> Result<EventId> {
+    ) -> Result<Arc<EventId>> {
        let PduBuilder {
            event_type,
            content,
@@ -1989,12 +1988,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| {
-                create_event.room_version
-            });
+            .map_or(RoomVersionId::V6, |create_event| create_event.room_version);
        let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");

        let auth_events =
@@ -2023,9 +2019,9 @@ impl Rooms {
        }

        let mut pdu = PduEvent {
-            event_id: ruma::event_id!("$thiswillbefilledinlater"),
-            room_id: room_id.clone(),
-            sender: sender.clone(),
+            event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
+            room_id: room_id.to_owned(),
+            sender: sender.to_owned(),
            origin_server_ts: utils::millis_since_unix_epoch()
                .try_into()
                .expect("time is valid"),
@@ -2090,7 +2086,7 @@ impl Rooms {
        .expect("event is valid, we just created it");

        // Generate event id
-        pdu.event_id = EventId::try_from(&*format!(
+        pdu.event_id = EventId::parse_arc(format!(
            "${}",
            ruma::signatures::reference_hash(&pdu_json, &room_version_id)
                .expect("ruma can calculate reference hashes")
@@ -2114,7 +2110,7 @@ impl Rooms {
            pdu_json,
            // Since this PDU references all pdu_leaves we can update the leaves
            // of the room
-            &[pdu.event_id.clone()],
+            iter::once(&*pdu.event_id),
            db,
        )?;

@@ -2213,7 +2209,7 @@ impl Rooms {
        let mut first_pdu_id = prefix.clone();
        first_pdu_id.extend_from_slice(&(since + 1).to_be_bytes());

-        let user_id = user_id.clone();
+        let user_id = user_id.to_owned();

        Ok(self
            .pduid_pdu
@@ -2250,7 +2246,7 @@ impl Rooms {

        let current: &[u8] = &current;

-        let user_id = user_id.clone();
+        let user_id = user_id.to_owned();

        Ok(self
            .pduid_pdu
@@ -2287,7 +2283,7 @@ impl Rooms {

        let current: &[u8] = &current;

-        let user_id = user_id.clone();
+        let user_id = user_id.to_owned();

        Ok(self
            .pduid_pdu
@@ -2419,7 +2415,7 @@ impl Rooms {

                            for room_ids in direct_event.content.0.values_mut() {
                                if room_ids.iter().any(|r| r == &predecessor.room_id) {
-                                    room_ids.push(room_id.clone());
+                                    room_ids.push(room_id.to_owned());
                                    room_ids_updated = true;
                                }
                            }
@@ -2458,7 +2454,11 @@ impl Rooms {
                        EventType::IgnoredUserList,
                    )?
                    .map_or(false, |ignored| {
-                        ignored.content.ignored_users.contains(sender)
+                        ignored
+                            .content
+                            .ignored_users
+                            .iter()
+                            .any(|user| user == sender)
                    });

                if is_ignored {
@@ -2544,7 +2544,7 @@ impl Rooms {
        self.our_real_users_cache
            .write()
            .unwrap()
-            .insert(room_id.clone(), Arc::new(real_users));
+            .insert(room_id.to_owned(), Arc::new(real_users));

        for old_joined_server in self.room_servers(room_id).filter_map(|r| r.ok()) {
            if !joined_servers.remove(&old_joined_server) {
@@ -2589,7 +2589,7 @@ impl Rooms {
        &self,
        room_id: &RoomId,
        db: &Database,
-    ) -> Result<Arc<HashSet<UserId>>> {
+    ) -> Result<Arc<HashSet<Box<UserId>>>> {
        let maybe = self
            .our_real_users_cache
            .read()
@@ -2657,7 +2657,7 @@ impl Rooms {
            self.appservice_in_room_cache
                .write()
                .unwrap()
-                .entry(room_id.clone())
+                .entry(room_id.to_owned())
                .or_default()
                .insert(appservice.0.clone(), in_room);

@@ -2701,7 +2701,7 @@ impl Rooms {
                    .roomid_mutex_state
                    .write()
                    .unwrap()
-                    .entry(room_id.clone())
+                    .entry(room_id.to_owned())
                    .or_default(),
            );
            let state_lock = mutex_state.lock().await;
@@ -2761,7 +2761,7 @@ impl Rooms {
            .filter_map(|event| serde_json::from_str(event.json().get()).ok())
            .filter_map(|event: serde_json::Value| event.get("sender").cloned())
            .filter_map(|sender| sender.as_str().map(|s| s.to_owned()))
-            .filter_map(|sender| UserId::try_from(sender).ok())
+            .filter_map(|sender| UserId::parse(sender).ok())
            .map(|user| user.server_name().to_owned())
            .collect();

@@ -2785,7 +2785,9 @@ 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::V5 || version == RoomVersionId::V6 => {
+                version
+            }
            _ => return Err(Error::BadServerResponse("Room version is not supported")),
        };

@@ -2820,7 +2822,7 @@ impl Rooms {
        .expect("event is valid, we just created it");

        // Generate event id
-        let event_id = EventId::try_from(&*format!(
+        let event_id = EventId::parse(format!(
            "${}",
            ruma::signatures::reference_hash(&leave_event_stub, &room_version_id)
                .expect("ruma can calculate reference hashes")
@@ -2905,11 +2907,11 @@ impl Rooms {
    }

    #[tracing::instrument(skip(self))]
-    pub fn id_from_alias(&self, alias: &RoomAliasId) -> Result<Option<RoomId>> {
+    pub fn id_from_alias(&self, alias: &RoomAliasId) -> Result<Option<Box<RoomId>>> {
        self.alias_roomid
            .get(alias.alias().as_bytes())?
            .map(|bytes| {
-                RoomId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
+                RoomId::parse(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."))
@@ -2921,7 +2923,7 @@ impl Rooms {
    pub fn room_aliases<'a>(
        &'a self,
        room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<RoomAliasId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<RoomAliasId>>> + 'a {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

@@ -2950,9 +2952,9 @@ impl Rooms {
    }

    #[tracing::instrument(skip(self))]
-    pub fn public_rooms(&self) -> impl Iterator<Item = Result<RoomId>> + '_ {
+    pub fn public_rooms(&self) -> impl Iterator<Item = Result<Box<RoomId>>> + '_ {
        self.publicroomids.iter().map(|(bytes, _)| {
-            RoomId::try_from(
+            RoomId::parse(
                utils::string_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("Room ID in publicroomids is invalid unicode.")
                })?,
@@ -3012,8 +3014,8 @@ impl Rooms {
    #[tracing::instrument(skip(self))]
    pub fn get_shared_rooms<'a>(
        &'a self,
-        users: Vec<UserId>,
-    ) -> Result<impl Iterator<Item = Result<RoomId>> + 'a> {
+        users: Vec<Box<UserId>>,
+    ) -> Result<impl Iterator<Item = Result<Box<RoomId>>> + 'a> {
        let iterators = users.into_iter().map(move |user_id| {
            let mut prefix = user_id.as_bytes().to_vec();
            prefix.push(0xff);
@@ -3040,7 +3042,7 @@ impl Rooms {
        Ok(utils::common_elements(iterators, Ord::cmp)
            .expect("users is not empty")
            .map(|bytes| {
-                RoomId::try_from(utils::string_from_bytes(&*bytes).map_err(|_| {
+                RoomId::parse(utils::string_from_bytes(&*bytes).map_err(|_| {
                    Error::bad_database("Invalid RoomId bytes in userroomid_joined")
                })?)
                .map_err(|_| Error::bad_database("Invalid RoomId in userroomid_joined."))
@@ -3057,7 +3059,7 @@ impl Rooms {
        prefix.push(0xff);

        self.roomserverids.scan_prefix(prefix).map(|(key, _)| {
-            Box::<ServerName>::try_from(
+            ServerName::parse(
                utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
@@ -3085,12 +3087,12 @@ impl Rooms {
    pub fn server_rooms<'a>(
        &'a self,
        server: &ServerName,
-    ) -> impl Iterator<Item = Result<RoomId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<RoomId>>> + 'a {
        let mut prefix = server.as_bytes().to_vec();
        prefix.push(0xff);

        self.serverroomids.scan_prefix(prefix).map(|(key, _)| {
-            RoomId::try_from(
+            RoomId::parse(
                utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
@@ -3107,12 +3109,12 @@ impl Rooms {
    pub fn room_members<'a>(
        &'a self,
        room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<UserId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.roomuserid_joined.scan_prefix(prefix).map(|(key, _)| {
-            UserId::try_from(
+            UserId::parse(
                utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
@@ -3153,14 +3155,14 @@ impl Rooms {
    pub fn room_useroncejoined<'a>(
        &'a self,
        room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<UserId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.roomuseroncejoinedids
            .scan_prefix(prefix)
            .map(|(key, _)| {
-                UserId::try_from(
+                UserId::parse(
                    utils::string_from_bytes(
                        key.rsplit(|&b| b == 0xff)
                            .next()
@@ -3179,14 +3181,14 @@ impl Rooms {
    pub fn room_members_invited<'a>(
        &'a self,
        room_id: &RoomId,
-    ) -> impl Iterator<Item = Result<UserId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.roomuserid_invitecount
            .scan_prefix(prefix)
            .map(|(key, _)| {
-                UserId::try_from(
+                UserId::parse(
                    utils::string_from_bytes(
                        key.rsplit(|&b| b == 0xff)
                            .next()
@@ -3235,11 +3237,11 @@ impl Rooms {
    pub fn rooms_joined<'a>(
        &'a self,
        user_id: &UserId,
-    ) -> impl Iterator<Item = Result<RoomId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<RoomId>>> + 'a {
        self.userroomid_joined
            .scan_prefix(user_id.as_bytes().to_vec())
            .map(|(key, _)| {
-                RoomId::try_from(
+                RoomId::parse(
                    utils::string_from_bytes(
                        key.rsplit(|&b| b == 0xff)
                            .next()
@@ -3258,14 +3260,14 @@ impl Rooms {
    pub fn rooms_invited<'a>(
        &'a self,
        user_id: &UserId,
-    ) -> impl Iterator<Item = Result<(RoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
+    ) -> impl Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.userroomid_invitestate
            .scan_prefix(prefix)
            .map(|(key, state)| {
-                let room_id = RoomId::try_from(
+                let room_id = RoomId::parse(
                    utils::string_from_bytes(
                        key.rsplit(|&b| b == 0xff)
                            .next()
@@ -3331,14 +3333,14 @@ impl Rooms {
    pub fn rooms_left<'a>(
        &'a self,
        user_id: &UserId,
-    ) -> impl Iterator<Item = Result<(RoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a {
+    ) -> impl Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnySyncStateEvent>>)>> + 'a {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);

        self.userroomid_leftstate
            .scan_prefix(prefix)
            .map(|(key, state)| {
-                let room_id = RoomId::try_from(
+                let room_id = RoomId::parse(
                    utils::string_from_bytes(
                        key.rsplit(|&b| b == 0xff)
                            .next()
@@ -3451,24 +3453,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)
-    }
 }
@@ -11,7 +11,7 @@ use ruma::{
 };
 use std::{
    collections::{HashMap, HashSet},
-    convert::{TryFrom, TryInto},
+    convert::TryInto,
    mem,
    sync::Arc,
 };
@@ -76,8 +76,13 @@ impl RoomEdus {
        &'a self,
        room_id: &RoomId,
        since: u64,
-    ) -> impl Iterator<Item = Result<(UserId, u64, Raw<ruma::events::AnySyncEphemeralRoomEvent>)>> + 'a
-    {
+    ) -> impl Iterator<
+        Item = Result<(
+            Box<UserId>,
+            u64,
+            Raw<ruma::events::AnySyncEphemeralRoomEvent>,
+        )>,
+    > + 'a {
        let mut prefix = room_id.as_bytes().to_vec();
        prefix.push(0xff);
        let prefix2 = prefix.clone();
@@ -92,7 +97,7 @@ impl RoomEdus {
                let count =
                    utils::u64_from_bytes(&k[prefix.len()..prefix.len() + mem::size_of::<u64>()])
                        .map_err(|_| Error::bad_database("Invalid readreceiptid count in db."))?;
-                let user_id = UserId::try_from(
+                let user_id = UserId::parse(
                    utils::string_from_bytes(&k[prefix.len() + mem::size_of::<u64>() + 1..])
                        .map_err(|_| {
                            Error::bad_database("Invalid readreceiptid userid bytes in db.")
@@ -305,17 +310,13 @@ impl RoomEdus {

        let mut user_ids = HashSet::new();

-        for user_id in self
-            .typingid_userid
-            .scan_prefix(prefix)
-            .map(|(_, user_id)| {
-                UserId::try_from(utils::string_from_bytes(&user_id).map_err(|_| {
+        for (_, user_id) in self.typingid_userid.scan_prefix(prefix) {
+            let user_id = UserId::parse(utils::string_from_bytes(&user_id).map_err(|_| {
                Error::bad_database("User ID in typingid_userid is invalid unicode.")
            })?)
-                .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))
-            })
-        {
-            user_ids.insert(user_id?);
+            .map_err(|_| Error::bad_database("User ID in typingid_userid is invalid."))?;
+
+            user_ids.insert(user_id);
        }

        Ok(SyncEphemeralRoomEvent {
@@ -449,7 +450,7 @@ impl RoomEdus {
        {
            // Send new presence events to set the user offline
            let count = globals.next_count()?.to_be_bytes();
-            let user_id = utils::string_from_bytes(&user_id_bytes)
+            let user_id: Box<_> = utils::string_from_bytes(&user_id_bytes)
                .map_err(|_| {
                    Error::bad_database("Invalid UserId bytes in userid_lastpresenceupdate.")
                })?
@@ -475,7 +476,7 @@ impl RoomEdus {
                            presence: PresenceState::Offline,
                            status_msg: None,
                        },
-                        sender: user_id.clone(),
+                        sender: user_id.to_owned(),
                    })
                    .expect("PresenceEvent can be serialized"),
                )?;
@@ -498,7 +499,7 @@ impl RoomEdus {
        since: u64,
        _rooms: &super::Rooms,
        _globals: &super::super::globals::Globals,
-    ) -> Result<HashMap<UserId, PresenceEvent>> {
+    ) -> Result<HashMap<Box<UserId>, PresenceEvent>> {
        //self.presence_maintain(rooms, globals)?;

        let mut prefix = room_id.as_bytes().to_vec();
@@ -513,7 +514,7 @@ impl RoomEdus {
            .iter_from(&*first_possible_edu, false)
            .take_while(|(key, _)| key.starts_with(&prefix))
        {
-            let user_id = UserId::try_from(
+            let user_id = UserId::parse(
                utils::string_from_bytes(
                    key.rsplit(|&b| b == 0xff)
                        .next()
@@ -1,6 +1,6 @@
 use std::{
    collections::{BTreeMap, HashMap, HashSet},
-    convert::{TryFrom, TryInto},
+    convert::TryInto,
    fmt::Debug,
    sync::Arc,
    time::{Duration, Instant},
@@ -397,7 +397,7 @@ impl Sending {
            // Because synapse resyncs, we can just insert dummy data
            let edu = Edu::DeviceListUpdate(DeviceListUpdateContent {
                user_id,
-                device_id: device_id!("dummy"),
+                device_id: device_id!("dummy").to_owned(),
                device_display_name: Some("Dummy".to_owned()),
                stream_id: uint!(1),
                prev_id: Vec::new(),
@@ -583,8 +583,7 @@ impl Sending {
                        }
                    }

-                    let userid =
-                        UserId::try_from(utils::string_from_bytes(user).map_err(|_| {
+                    let userid = UserId::parse(utils::string_from_bytes(user).map_err(|_| {
                        (
                            kind.clone(),
                            Error::bad_database("Invalid push user string in db."),
@@ -732,7 +731,7 @@ impl Sending {
            })?;

            (
-                OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| {
+                OutgoingKind::Appservice(ServerName::parse(server).map_err(|_| {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
                if value.is_empty() {
@@ -771,7 +770,7 @@ impl Sending {
            })?;

            (
-                OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| {
+                OutgoingKind::Normal(ServerName::parse(server).map_err(|_| {
                    Error::bad_database("Invalid server string in server_currenttransaction")
                })?),
                if value.is_empty() {
@@ -8,7 +8,12 @@ use ruma::{
    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, RoomAliasId, UInt,
    UserId,
 };
-use std::{collections::BTreeMap, convert::TryFrom, mem, sync::Arc};
+use std::{
+    collections::BTreeMap,
+    convert::{TryFrom, TryInto},
+    mem,
+    sync::Arc,
+};
 use tracing::warn;

 use super::abstraction::Tree;
@@ -62,12 +67,11 @@ impl Users {
        rooms: &super::rooms::Rooms,
        globals: &super::globals::Globals,
    ) -> Result<bool> {
-        let admin_room_alias_id =
-            RoomAliasId::try_from(format!("#admins:{}", globals.server_name()))
+        let admin_room_alias_id = RoomAliasId::parse(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)?)
+        rooms.is_joined(user_id, &admin_room_id)
    }

    /// Create a new user account on this homeserver.
@@ -85,7 +89,7 @@ impl Users {

    /// Find out which user an access token belongs to.
    #[tracing::instrument(skip(self, token))]
-    pub fn find_from_token(&self, token: &str) -> Result<Option<(UserId, String)>> {
+    pub fn find_from_token(&self, token: &str) -> Result<Option<(Box<UserId>, String)>> {
        self.token_userdeviceid
            .get(token.as_bytes())?
            .map_or(Ok(None), |bytes| {
@@ -98,7 +102,7 @@ impl Users {
                })?;

                Ok(Some((
-                    UserId::try_from(utils::string_from_bytes(user_bytes).map_err(|_| {
+                    UserId::parse(utils::string_from_bytes(user_bytes).map_err(|_| {
                        Error::bad_database("User ID in token_userdeviceid is invalid unicode.")
                    })?)
                    .map_err(|_| {
@@ -113,9 +117,9 @@ impl Users {

    /// Returns an iterator over all users on this homeserver.
    #[tracing::instrument(skip(self))]
-    pub fn iter(&self) -> impl Iterator<Item = Result<UserId>> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = Result<Box<UserId>>> + '_ {
        self.userid_password.iter().map(|(bytes, _)| {
-            UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
+            UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
                Error::bad_database("User ID in userid_password is invalid unicode.")
            })?)
            .map_err(|_| Error::bad_database("User ID in userid_password is invalid."))
@@ -181,20 +185,21 @@ impl Users {

    /// Get the avatar_url of a user.
    #[tracing::instrument(skip(self, user_id))]
-    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<MxcUri>> {
+    pub fn avatar_url(&self, user_id: &UserId) -> Result<Option<Box<MxcUri>>> {
        self.userid_avatarurl
            .get(user_id.as_bytes())?
            .map(|bytes| {
                let s = utils::string_from_bytes(&bytes)
                    .map_err(|_| Error::bad_database("Avatar URL in db is invalid."))?;
-                MxcUri::try_from(s).map_err(|_| Error::bad_database("Avatar URL in db is invalid."))
+                s.try_into()
+                    .map_err(|_| Error::bad_database("Avatar URL in db is invalid."))
            })
            .transpose()
    }

    /// Sets a new avatar_url or removes it if avatar_url is None.
    #[tracing::instrument(skip(self, user_id, avatar_url))]
-    pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<MxcUri>) -> Result<()> {
+    pub fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<Box<MxcUri>>) -> Result<()> {
        if let Some(avatar_url) = avatar_url {
            self.userid_avatarurl
                .insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
@@ -359,7 +364,7 @@ impl Users {
        user_id: &UserId,
        device_id: &DeviceId,
        one_time_key_key: &DeviceKeyId,
-        one_time_key_value: &OneTimeKey,
+        one_time_key_value: &Raw<OneTimeKey>,
        globals: &super::globals::Globals,
    ) -> Result<()> {
        let mut key = user_id.as_bytes().to_vec();
@@ -409,7 +414,7 @@ impl Users {
        device_id: &DeviceId,
        key_algorithm: &DeviceKeyAlgorithm,
        globals: &super::globals::Globals,
-    ) -> Result<Option<(DeviceKeyId, OneTimeKey)>> {
+    ) -> Result<Option<(Box<DeviceKeyId>, Raw<OneTimeKey>)>> {
        let mut prefix = user_id.as_bytes().to_vec();
        prefix.push(0xff);
        prefix.extend_from_slice(device_id.as_bytes());
@@ -459,7 +464,7 @@ impl Users {
                .scan_prefix(userdeviceid)
                .map(|(bytes, _)| {
                    Ok::<_, Error>(
-                        serde_json::from_slice::<DeviceKeyId>(
+                        serde_json::from_slice::<Box<DeviceKeyId>>(
                            &*bytes.rsplit(|&b| b == 0xff).next().ok_or_else(|| {
                                Error::bad_database("OneTimeKey ID in db is invalid.")
                            })?,
@@ -480,7 +485,7 @@ impl Users {
        &self,
        user_id: &UserId,
        device_id: &DeviceId,
-        device_keys: &DeviceKeys,
+        device_keys: &Raw<DeviceKeys>,
        rooms: &super::rooms::Rooms,
        globals: &super::globals::Globals,
    ) -> Result<()> {
@@ -509,9 +514,9 @@ impl Users {
    pub fn add_cross_signing_keys(
        &self,
        user_id: &UserId,
-        master_key: &CrossSigningKey,
-        self_signing_key: &Option<CrossSigningKey>,
-        user_signing_key: &Option<CrossSigningKey>,
+        master_key: &Raw<CrossSigningKey>,
+        self_signing_key: &Option<Raw<CrossSigningKey>>,
+        user_signing_key: &Option<Raw<CrossSigningKey>>,
        rooms: &super::rooms::Rooms,
        globals: &super::globals::Globals,
    ) -> Result<()> {
@@ -521,7 +526,12 @@ impl Users {
        prefix.push(0xff);

        // Master key
-        let mut master_key_ids = master_key.keys.values();
+        let master_key_map = master_key
+            .deserialize()
+            .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid master key"))?
+            .keys;
+        let mut master_key_ids = master_key_map.values();
+
        let master_key_id = master_key_ids.next().ok_or(Error::BadRequest(
            ErrorKind::InvalidParam,
            "Master key contained no key.",
@@ -537,17 +547,21 @@ impl Users {
        let mut master_key_key = prefix.clone();
        master_key_key.extend_from_slice(master_key_id.as_bytes());

-        self.keyid_key.insert(
-            &master_key_key,
-            &serde_json::to_vec(&master_key).expect("CrossSigningKey::to_vec always works"),
-        )?;
+        self.keyid_key
+            .insert(&master_key_key, master_key.json().get().as_bytes())?;

        self.userid_masterkeyid
            .insert(user_id.as_bytes(), &master_key_key)?;

        // Self-signing key
        if let Some(self_signing_key) = self_signing_key {
-            let mut self_signing_key_ids = self_signing_key.keys.values();
+            let self_signing_key_map = self_signing_key
+                .deserialize()
+                .map_err(|_| {
+                    Error::BadRequest(ErrorKind::InvalidParam, "Invalid self signing key")
+                })?
+                .keys;
+            let mut self_signing_key_ids = self_signing_key_map.values();
            let self_signing_key_id = self_signing_key_ids.next().ok_or(Error::BadRequest(
                ErrorKind::InvalidParam,
                "Self signing key contained no key.",
@@ -565,8 +579,7 @@ impl Users {

            self.keyid_key.insert(
                &self_signing_key_key,
-                &serde_json::to_vec(&self_signing_key)
-                    .expect("CrossSigningKey::to_vec always works"),
+                self_signing_key.json().get().as_bytes(),
            )?;

            self.userid_selfsigningkeyid
@@ -575,7 +588,13 @@ impl Users {

        // User-signing key
        if let Some(user_signing_key) = user_signing_key {
-            let mut user_signing_key_ids = user_signing_key.keys.values();
+            let user_signing_key_map = user_signing_key
+                .deserialize()
+                .map_err(|_| {
+                    Error::BadRequest(ErrorKind::InvalidParam, "Invalid user signing key")
+                })?
+                .keys;
+            let mut user_signing_key_ids = user_signing_key_map.values();
            let user_signing_key_id = user_signing_key_ids.next().ok_or(Error::BadRequest(
                ErrorKind::InvalidParam,
                "User signing key contained no key.",
@@ -593,8 +612,7 @@ impl Users {

            self.keyid_key.insert(
                &user_signing_key_key,
-                &serde_json::to_vec(&user_signing_key)
-                    .expect("CrossSigningKey::to_vec always works"),
+                user_signing_key.json().get().as_bytes(),
            )?;

            self.userid_usersigningkeyid
@@ -632,7 +650,7 @@ impl Users {
            .ok_or_else(|| Error::bad_database("key in keyid_key has no signatures field."))?
            .as_object_mut()
            .ok_or_else(|| Error::bad_database("key in keyid_key has invalid signatures field."))?
-            .entry(sender_id.clone())
+            .entry(sender_id.to_owned())
            .or_insert_with(|| serde_json::Map::new().into());

        signatures
@@ -657,7 +675,7 @@ impl Users {
        user_or_room_id: &str,
        from: u64,
        to: Option<u64>,
-    ) -> impl Iterator<Item = Result<UserId>> + 'a {
+    ) -> impl Iterator<Item = Result<Box<UserId>>> + 'a {
        let mut prefix = user_or_room_id.as_bytes().to_vec();
        prefix.push(0xff);

@@ -683,7 +701,7 @@ impl Users {
                    }
            })
            .map(|(_, bytes)| {
-                UserId::try_from(utils::string_from_bytes(&bytes).map_err(|_| {
+                UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
                    Error::bad_database("User ID in devicekeychangeid_userid is invalid unicode.")
                })?)
                .map_err(|_| Error::bad_database("User ID in devicekeychangeid_userid is invalid."))
@@ -727,7 +745,7 @@ impl Users {
        &self,
        user_id: &UserId,
        device_id: &DeviceId,
-    ) -> Result<Option<DeviceKeys>> {
+    ) -> Result<Option<Raw<DeviceKeys>>> {
        let mut key = user_id.as_bytes().to_vec();
        key.push(0xff);
        key.extend_from_slice(device_id.as_bytes());
@@ -744,25 +762,19 @@ impl Users {
        &self,
        user_id: &UserId,
        allowed_signatures: F,
-    ) -> Result<Option<CrossSigningKey>> {
+    ) -> Result<Option<Raw<CrossSigningKey>>> {
        self.userid_masterkeyid
            .get(user_id.as_bytes())?
            .map_or(Ok(None), |key| {
                self.keyid_key.get(&key)?.map_or(Ok(None), |bytes| {
-                    let mut cross_signing_key = serde_json::from_slice::<CrossSigningKey>(&bytes)
-                        .map_err(|_| {
-                        Error::bad_database("CrossSigningKey in db is invalid.")
-                    })?;
+                    let mut cross_signing_key = serde_json::from_slice::<serde_json::Value>(&bytes)
+                        .map_err(|_| Error::bad_database("CrossSigningKey in db is invalid."))?;
+                    clean_signatures(&mut cross_signing_key, user_id, allowed_signatures)?;

-                    // A user is not allowed to see signatures from users other than himself and
-                    // the target user
-                    cross_signing_key.signatures = cross_signing_key
-                        .signatures
-                        .into_iter()
-                        .filter(|(user, _)| allowed_signatures(user))
-                        .collect();
-
-                    Ok(Some(cross_signing_key))
+                    Ok(Some(Raw::from_json(
+                        serde_json::value::to_raw_value(&cross_signing_key)
+                            .expect("Value to RawValue serialization"),
+                    )))
                })
            })
    }
@@ -772,31 +784,25 @@ impl Users {
        &self,
        user_id: &UserId,
        allowed_signatures: F,
-    ) -> Result<Option<CrossSigningKey>> {
+    ) -> Result<Option<Raw<CrossSigningKey>>> {
        self.userid_selfsigningkeyid
            .get(user_id.as_bytes())?
            .map_or(Ok(None), |key| {
                self.keyid_key.get(&key)?.map_or(Ok(None), |bytes| {
-                    let mut cross_signing_key = serde_json::from_slice::<CrossSigningKey>(&bytes)
-                        .map_err(|_| {
-                        Error::bad_database("CrossSigningKey in db is invalid.")
-                    })?;
+                    let mut cross_signing_key = serde_json::from_slice::<serde_json::Value>(&bytes)
+                        .map_err(|_| Error::bad_database("CrossSigningKey in db is invalid."))?;
+                    clean_signatures(&mut cross_signing_key, user_id, allowed_signatures)?;

-                    // A user is not allowed to see signatures from users other than himself and
-                    // the target user
-                    cross_signing_key.signatures = cross_signing_key
-                        .signatures
-                        .into_iter()
-                        .filter(|(user, _)| user == user_id || allowed_signatures(user))
-                        .collect();
-
-                    Ok(Some(cross_signing_key))
+                    Ok(Some(Raw::from_json(
+                        serde_json::value::to_raw_value(&cross_signing_key)
+                            .expect("Value to RawValue serialization"),
+                    )))
                })
            })
    }

    #[tracing::instrument(skip(self, user_id))]
-    pub fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<CrossSigningKey>> {
+    pub fn get_user_signing_key(&self, user_id: &UserId) -> Result<Option<Raw<CrossSigningKey>>> {
        self.userid_usersigningkeyid
            .get(user_id.as_bytes())?
            .map_or(Ok(None), |key| {
@@ -991,3 +997,30 @@ impl Users {
        Ok(())
    }
 }
+
+/// Ensure that a user only sees signatures from themselves and the target user
+fn clean_signatures<F: Fn(&UserId) -> bool>(
+    cross_signing_key: &mut serde_json::Value,
+    user_id: &UserId,
+    allowed_signatures: F,
+) -> Result<(), Error> {
+    if let Some(signatures) = cross_signing_key
+        .get_mut("signatures")
+        .and_then(|v| v.as_object_mut())
+    {
+        // Don't allocate for the full size of the current signatures, but require
+        // at most one resize if nothing is dropped
+        let new_capacity = signatures.len() / 2;
+        for (user, signature) in
+            mem::replace(signatures, serde_json::Map::with_capacity(new_capacity))
+        {
+            let id = <&UserId>::try_from(user.as_str())
+                .map_err(|_| Error::bad_database("Invalid user ID in database."))?;
+            if id == user_id || allowed_signatures(id) {
+                signatures.insert(user, signature);
+            }
+        }
+    }
+
+    Ok(())
+}
@@ -1,4 +1,4 @@
-use crate::{Database, Error};
+use crate::Error;
 use ruma::{
    events::{
        room::member::RoomMemberEventContent, AnyEphemeralRoomEvent, AnyInitialStateEvent,
@@ -6,14 +6,14 @@ use ruma::{
        EventType, StateEvent,
    },
    serde::{CanonicalJsonObject, CanonicalJsonValue, Raw},
-    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, UInt, UserId,
+    state_res, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UInt, UserId,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{
    json,
    value::{to_raw_value, RawValue as RawJsonValue},
 };
-use std::{cmp::Ordering, collections::BTreeMap, convert::TryFrom};
+use std::{cmp::Ordering, collections::BTreeMap, convert::TryInto, sync::Arc};
 use tracing::warn;

 /// Content hashes of a PDU.
@@ -25,20 +25,20 @@ pub struct EventHash {

 #[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct PduEvent {
-    pub event_id: EventId,
-    pub room_id: RoomId,
-    pub sender: UserId,
+    pub event_id: Arc<EventId>,
+    pub room_id: Box<RoomId>,
+    pub sender: Box<UserId>,
    pub origin_server_ts: UInt,
    #[serde(rename = "type")]
    pub kind: EventType,
    pub content: Box<RawJsonValue>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state_key: Option<String>,
-    pub prev_events: Vec<EventId>,
+    pub prev_events: Vec<Arc<EventId>>,
    pub depth: UInt,
-    pub auth_events: Vec<EventId>,
+    pub auth_events: Vec<Arc<EventId>>,
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub redacts: Option<EventId>,
+    pub redacts: Option<Arc<EventId>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unsigned: Option<Box<RawJsonValue>>,
    pub hashes: EventHash,
@@ -266,7 +266,9 @@ impl PduEvent {
 }

 impl state_res::Event for PduEvent {
-    fn event_id(&self) -> &EventId {
+    type Id = Arc<EventId>;
+
+    fn event_id(&self) -> &Self::Id {
        &self.event_id
    }

@@ -294,15 +296,15 @@ impl state_res::Event for PduEvent {
        self.state_key.as_deref()
    }

-    fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
+    fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + '_> {
        Box::new(self.prev_events.iter())
    }

-    fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &EventId> + '_> {
+    fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + '_> {
        Box::new(self.auth_events.iter())
    }

-    fn redacts(&self) -> Option<&EventId> {
+    fn redacts(&self) -> Option<&Self::Id> {
        self.redacts.as_ref()
    }
 }
@@ -331,26 +333,19 @@ 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,
-) -> crate::Result<(EventId, CanonicalJsonObject)> {
-    let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
+) -> crate::Result<(Box<EventId>, CanonicalJsonObject)> {
+    let value = serde_json::from_str(pdu.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!(
+    let event_id = format!(
        "${}",
        // Anything higher than version3 behaves the same
-        ruma::signatures::reference_hash(&value, &room_version_id?)
+        ruma::signatures::reference_hash(&value, &RoomVersionId::V6)
            .expect("ruma can calculate reference hashes")
-    ))
+    )
+    .try_into()
    .expect("ruma's reference hashes are valid event ids");

    Ok((event_id, value))
@@ -364,7 +359,7 @@ pub struct PduBuilder {
    pub content: Box<RawJsonValue>,
    pub unsigned: Option<BTreeMap<String, serde_json::Value>>,
    pub state_key: Option<String>,
-    pub redacts: Option<EventId>,
+    pub redacts: Option<Arc<EventId>>,
 }

 /// Direct conversion prevents loss of the empty `state_key` that ruma requires.
@@ -20,7 +20,6 @@ use {
    },
    ruma::api::{AuthScheme, IncomingRequest},
    std::collections::BTreeMap,
-    std::convert::TryFrom,
    std::io::Cursor,
    tracing::{debug, warn},
 };
@@ -29,7 +28,7 @@ use {
 /// first.
 pub struct Ruma<T: Outgoing> {
    pub body: T::Incoming,
-    pub sender_user: Option<UserId>,
+    pub sender_user: Option<Box<UserId>>,
    pub sender_device: Option<Box<DeviceId>>,
    pub sender_servername: Option<Box<ServerName>>,
    // This is None when body is not a valid string
@@ -86,7 +85,7 @@ where
                registration
                    .get("as_token")
                    .and_then(|as_token| as_token.as_str())
-                    .map_or(false, |as_token| token.as_deref() == Some(as_token))
+                    .map_or(false, |as_token| token == Some(as_token))
            }) {
            match metadata.authentication {
                AuthScheme::AccessToken | AuthScheme::QueryOnlyAccessToken => {
@@ -103,8 +102,7 @@ where
                            .unwrap()
                        },
                        |string| {
-                            UserId::try_from(string.expect("parsing to string always works"))
-                                .unwrap()
+                            UserId::parse(string.expect("parsing to string always works")).unwrap()
                        },
                    );

@@ -171,7 +169,7 @@ where
                        }
                    };

-                    let origin = match Box::<ServerName>::try_from(origin_str) {
+                    let origin = match ServerName::parse(origin_str) {
                        Ok(s) => s,
                        _ => {
                            warn!(
@@ -64,6 +64,7 @@ use std::{
    future::Future,
    mem,
    net::{IpAddr, SocketAddr},
+    ops::Deref,
    pin::Pin,
    sync::{Arc, RwLock, RwLockWriteGuard},
    time::{Duration, Instant, SystemTime},
@@ -396,10 +397,7 @@ async fn find_actual_destination(
                                        }

                                        if let Some(port) = force_port {
-                                            FedDest::Named(
-                                                delegated_hostname,
-                                                format!(":{}", port.to_string()),
-                                            )
+                                            FedDest::Named(delegated_hostname, format!(":{}", port))
                                        } else {
                                            add_port_to_hostname(&delegated_hostname)
                                        }
@@ -432,10 +430,7 @@ async fn find_actual_destination(
                                }

                                if let Some(port) = force_port {
-                                    FedDest::Named(
-                                        hostname.clone(),
-                                        format!(":{}", port.to_string()),
-                                    )
+                                    FedDest::Named(hostname.clone(), format!(":{}", port))
                                } else {
                                    add_port_to_hostname(&hostname)
                                }
@@ -550,11 +545,10 @@ pub fn get_server_keys_route(db: DatabaseGuard) -> Json<String> {
        return Json("Federation is disabled.".to_owned());
    }

-    let mut verify_keys = BTreeMap::new();
+    let mut verify_keys: BTreeMap<Box<ServerSigningKeyId>, VerifyKey> = BTreeMap::new();
    verify_keys.insert(
-        ServerSigningKeyId::try_from(
-            format!("ed25519:{}", db.globals.keypair().version()).as_str(),
-        )
+        format!("ed25519:{}", db.globals.keypair().version())
+            .try_into()
            .expect("found invalid server signing keys in DB"),
        VerifyKey {
            key: base64::encode_config(db.globals.keypair().public_key(), base64::STANDARD_NO_PAD),
@@ -725,7 +719,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
@@ -736,7 +730,7 @@ pub async fn send_transaction_message_route(
        // 0. Check the server is in the room
        let room_id = match value
            .get("room_id")
-            .and_then(|id| RoomId::try_from(id.as_str()?).ok())
+            .and_then(|id| RoomId::parse(id.as_str()?).ok())
        {
            Some(id) => id,
            None => {
@@ -1001,14 +995,9 @@ 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 graph: HashMap<Arc<EventId>, _> = HashMap::new();
    let mut eventid_info = HashMap::new();
-    let mut todo_outlier_stack: Vec<_> = incoming_pdu
-        .prev_events
-        .iter()
-        .cloned()
-        .map(Arc::new)
-        .collect();
+    let mut todo_outlier_stack: Vec<Arc<EventId>> = incoming_pdu.prev_events.clone();

    let mut amount = 0;

@@ -1027,7 +1016,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
            if amount > 100 {
                // Max limit reached
                warn!("Max prev event limit reached!");
-                graph.insert((*prev_event_id).clone(), HashSet::new());
+                graph.insert(prev_event_id.clone(), HashSet::new());
                continue;
            }

@@ -1038,27 +1027,27 @@ pub(crate) async fn handle_incoming_pdu<'a>(
                    amount += 1;
                    for prev_prev in &pdu.prev_events {
                        if !graph.contains_key(prev_prev) {
-                            todo_outlier_stack.push(dbg!(Arc::new(prev_prev.clone())));
+                            todo_outlier_stack.push(dbg!(prev_prev.clone()));
                        }
                    }

                    graph.insert(
-                        (*prev_event_id).clone(),
+                        prev_event_id.clone(),
                        pdu.prev_events.iter().cloned().collect(),
                    );
                } else {
                    // Time based check failed
-                    graph.insert((*prev_event_id).clone(), HashSet::new());
+                    graph.insert(prev_event_id.clone(), HashSet::new());
                }

                eventid_info.insert(prev_event_id.clone(), (pdu, json));
            } else {
                // Get json failed
-                graph.insert((*prev_event_id).clone(), HashSet::new());
+                graph.insert(prev_event_id.clone(), HashSet::new());
            }
        } else {
            // Fetch and handle failed
-            graph.insert((*prev_event_id).clone(), HashSet::new());
+            graph.insert(prev_event_id.clone(), HashSet::new());
        }
    }

@@ -1074,7 +1063,6 @@ pub(crate) async fn handle_incoming_pdu<'a>(
                    .get(event_id)
                    .map_or_else(|| uint!(0), |info| info.0.origin_server_ts),
            ),
-            ruma::event_id!("$notimportant"),
        ))
    })
    .map_err(|_| "Error sorting prev events".to_owned())?;
@@ -1084,7 +1072,7 @@ pub(crate) async fn handle_incoming_pdu<'a>(
        if errors >= 5 {
            break;
        }
-        if let Some((pdu, json)) = eventid_info.remove(&prev_id) {
+        if let Some((pdu, json)) = eventid_info.remove(&*prev_id) {
            if pdu.origin_server_ts < first_pdu_in_room.origin_server_ts {
                continue;
            }
@@ -1200,8 +1188,7 @@ fn handle_outlier_pdu<'a>(
            &incoming_pdu
                .auth_events
                .iter()
-                .cloned()
-                .map(Arc::new)
+                .map(|x| Arc::from(&**x))
                .collect::<Vec<_>>(),
            create_event,
            room_id,
@@ -1331,7 +1318,7 @@ async fn upgrade_outlier_to_timeline_pdu(
    let mut state_at_incoming_event = None;

    if incoming_pdu.prev_events.len() == 1 {
-        let prev_event = &incoming_pdu.prev_events[0];
+        let prev_event = &*incoming_pdu.prev_events[0];
        let prev_event_sstatehash = db
            .rooms
            .pdu_shortstatehash(prev_event)
@@ -1353,7 +1340,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                    .get_or_create_shortstatekey(&prev_pdu.kind, state_key, &db.globals)
                    .map_err(|_| "Failed to create shortstatekey.".to_owned())?;

-                state.insert(shortstatekey, Arc::new(prev_event.clone()));
+                state.insert(shortstatekey, Arc::from(prev_event));
                // Now it's the state after the pdu
            }

@@ -1397,7 +1384,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                        .rooms
                        .get_or_create_shortstatekey(&prev_event.kind, state_key, &db.globals)
                        .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
-                    leaf_state.insert(shortstatekey, Arc::new(prev_event.event_id.clone()));
+                    leaf_state.insert(shortstatekey, Arc::from(&*prev_event.event_id));
                    // Now it's the state after the pdu
                }

@@ -1410,14 +1397,13 @@ async fn upgrade_outlier_to_timeline_pdu(
                        .get_statekey_from_short(k)
                        .map_err(|_| "Failed to get_statekey_from_short.".to_owned())?;

-                    state.insert(k, (*id).clone());
+                    state.insert(k, id.clone());
                    starting_events.push(id);
                }

                auth_chain_sets.push(
                    get_auth_chain(room_id, starting_events, db)
                        .map_err(|_| "Failed to load auth chain.".to_owned())?
-                        .map(|event_id| (*event_id).clone())
                        .collect(),
                );

@@ -1444,7 +1430,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                                .rooms
                                .get_or_create_shortstatekey(&event_type, &state_key, &db.globals)
                                .map_err(|_| "Failed to get_or_create_shortstatekey".to_owned())?;
-                            Ok((shortstatekey, Arc::new(event_id)))
+                            Ok((shortstatekey, event_id))
                        })
                        .collect::<Result<_, String>>()?,
                ),
@@ -1479,8 +1465,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                    origin,
                    &res.pdu_ids
                        .iter()
-                        .cloned()
-                        .map(Arc::new)
+                        .map(|x| Arc::from(&**x))
                        .collect::<Vec<_>>(),
                    create_event,
                    room_id,
@@ -1488,7 +1473,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                )
                .await;

-                let mut state = BTreeMap::new();
+                let mut state: BTreeMap<_, Arc<EventId>> = BTreeMap::new();
                for (pdu, _) in state_vec {
                    let state_key = pdu
                        .state_key
@@ -1502,7 +1487,7 @@ async fn upgrade_outlier_to_timeline_pdu(

                    match state.entry(shortstatekey) {
                        btree_map::Entry::Vacant(v) => {
-                            v.insert(Arc::new(pdu.event_id.clone()));
+                            v.insert(Arc::from(&*pdu.event_id));
                        }
                        btree_map::Entry::Occupied(_) => return Err(
                            "State event's type and state_key combination exists multiple times."
@@ -1577,7 +1562,7 @@ async fn upgrade_outlier_to_timeline_pdu(
            .roomid_mutex_state
            .write()
            .unwrap()
-            .entry(room_id.clone())
+            .entry(room_id.to_owned())
            .or_default(),
    );
    let state_lock = mutex_state.lock().await;
@@ -1647,7 +1632,7 @@ async fn upgrade_outlier_to_timeline_pdu(
            db,
            &incoming_pdu,
            val,
-            extremities,
+            extremities.iter().map(Deref::deref),
            state_ids_compressed,
            soft_fail,
            &state_lock,
@@ -1715,7 +1700,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                    .rooms
                    .get_or_create_shortstatekey(&leaf_pdu.kind, state_key, &db.globals)
                    .map_err(|_| "Failed to create shortstatekey.".to_owned())?;
-                leaf_state.insert(shortstatekey, Arc::new(leaf_pdu.event_id.clone()));
+                leaf_state.insert(shortstatekey, Arc::from(&*leaf_pdu.event_id));
                // Now it's the state after the pdu
            }

@@ -1730,7 +1715,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                .get_or_create_shortstatekey(&incoming_pdu.kind, state_key, &db.globals)
                .map_err(|_| "Failed to create shortstatekey.".to_owned())?;

-            state_after.insert(shortstatekey, Arc::new(incoming_pdu.event_id.clone()));
+            state_after.insert(shortstatekey, Arc::from(&*incoming_pdu.event_id));
        }
        fork_states.push(state_after);

@@ -1762,7 +1747,6 @@ async fn upgrade_outlier_to_timeline_pdu(
                        db,
                    )
                    .map_err(|_| "Failed to load auth chain.".to_owned())?
-                    .map(|event_id| (*event_id).clone())
                    .collect(),
                );
            }
@@ -1771,11 +1755,7 @@ async fn upgrade_outlier_to_timeline_pdu(
                .into_iter()
                .map(|map| {
                    map.into_iter()
-                        .map(|(k, id)| {
-                            db.rooms
-                                .get_statekey_from_short(k)
-                                .map(|k| (k, (*id).clone()))
-                        })
+                        .map(|(k, id)| db.rooms.get_statekey_from_short(k).map(|k| (k, id)))
                        .collect::<Result<StateMap<_>>>()
                })
                .collect::<Result<_>>()
@@ -1832,7 +1812,7 @@ async fn upgrade_outlier_to_timeline_pdu(
        db,
        &incoming_pdu,
        val,
-        extremities,
+        extremities.iter().map(Deref::deref),
        state_ids_compressed,
        soft_fail,
        &state_lock,
@@ -1874,7 +1854,8 @@ pub(crate) fn fetch_and_handle_outliers<'a>(

        let mut pdus = vec![];
        for id in events {
-            if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(id) {
+            if let Some((time, tries)) = db.globals.bad_event_ratelimiter.read().unwrap().get(&**id)
+            {
                // Exponential backoff
                let mut min_elapsed_duration = Duration::from_secs(5 * 60) * (*tries) * (*tries);
                if min_elapsed_duration > Duration::from_secs(60 * 60 * 24) {
@@ -1911,10 +1892,10 @@ 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());
+                                        back_off((**id).to_owned());
                                        continue;
                                    }
                                };
@@ -1939,14 +1920,14 @@ pub(crate) fn fetch_and_handle_outliers<'a>(
                                Ok((pdu, json)) => (pdu, Some(json)),
                                Err(e) => {
                                    warn!("Authentication of event {} failed: {:?}", id, e);
-                                    back_off((**id).clone());
+                                    back_off((**id).to_owned());
                                    continue;
                                }
                            }
                        }
                        Err(_) => {
                            warn!("Failed to fetch event: {}", id);
-                            back_off((**id).clone());
+                            back_off((**id).to_owned());
                            continue;
                        }
                    }
@@ -2124,11 +2105,11 @@ pub(crate) async fn fetch_signing_keys(
 /// Append the incoming event setting the state snapshot to the state from the
 /// server that sent the event.
 #[tracing::instrument(skip(db, pdu, pdu_json, new_room_leaves, state_ids_compressed, _mutex_lock))]
-fn append_incoming_pdu(
+fn append_incoming_pdu<'a>(
    db: &Database,
    pdu: &PduEvent,
    pdu_json: CanonicalJsonObject,
-    new_room_leaves: HashSet<EventId>,
+    new_room_leaves: impl IntoIterator<Item = &'a EventId> + Clone + Debug,
    state_ids_compressed: HashSet<CompressedStateEvent>,
    soft_fail: bool,
    _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room mutex
@@ -2145,19 +2126,11 @@ fn append_incoming_pdu(
    if soft_fail {
        db.rooms
            .mark_as_referenced(&pdu.room_id, &pdu.prev_events)?;
-        db.rooms.replace_pdu_leaves(
-            &pdu.room_id,
-            &new_room_leaves.into_iter().collect::<Vec<_>>(),
-        )?;
+        db.rooms.replace_pdu_leaves(&pdu.room_id, new_room_leaves)?;
        return Ok(None);
    }

-    let pdu_id = db.rooms.append_pdu(
-        pdu,
-        pdu_json,
-        &new_room_leaves.into_iter().collect::<Vec<_>>(),
-        db,
-    )?;
+    let pdu_id = db.rooms.append_pdu(pdu, pdu_json, new_room_leaves, db)?;

    for appservice in db.appservice.all()? {
        if db.rooms.appservice_in_room(&pdu.room_id, &appservice, db)? {
@@ -2298,13 +2271,13 @@ fn get_auth_chain_inner(
    event_id: &EventId,
    db: &Database,
 ) -> Result<HashSet<u64>> {
-    let mut todo = vec![event_id.clone()];
+    let mut todo = vec![Arc::from(event_id)];
    let mut found = HashSet::new();

    while let Some(event_id) = todo.pop() {
        match db.rooms.get_pdu(&event_id) {
            Ok(Some(pdu)) => {
-                if &pdu.room_id != room_id {
+                if pdu.room_id != room_id {
                    return Err(Error::BadRequest(ErrorKind::Forbidden, "Evil event in db"));
                }
                for auth_event in &pdu.auth_events {
@@ -2363,10 +2336,10 @@ pub fn get_event_route(
        .and_then(|val| val.as_str())
        .ok_or_else(|| Error::bad_database("Invalid event in database"))?;

-    let room_id = RoomId::try_from(room_id_str)
+    let room_id = <&RoomId>::try_from(room_id_str)
        .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;

-    if !db.rooms.server_in_room(sender_servername, &room_id)? {
+    if !db.rooms.server_in_room(sender_servername, room_id)? {
        return Err(Error::BadRequest(ErrorKind::NotFound, "Event not found."));
    }

@@ -2417,7 +2390,7 @@ pub fn get_missing_events_route(
                .and_then(|val| val.as_str())
                .ok_or_else(|| Error::bad_database("Invalid event in database"))?;

-            let event_room_id = RoomId::try_from(room_id_str)
+            let event_room_id = <&RoomId>::try_from(room_id_str)
                .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;

            if event_room_id != body.room_id {
@@ -2436,7 +2409,7 @@ pub fn get_missing_events_route(
                continue;
            }
            queued_events.extend_from_slice(
-                &serde_json::from_value::<Vec<EventId>>(
+                &serde_json::from_value::<Vec<Box<EventId>>>(
                    serde_json::to_value(pdu.get("prev_events").cloned().ok_or_else(|| {
                        Error::bad_database("Event in db has no prev_events field.")
                    })?)
@@ -2485,14 +2458,14 @@ pub fn get_event_authorization_route(
        .and_then(|val| val.as_str())
        .ok_or_else(|| Error::bad_database("Invalid event in database"))?;

-    let room_id = RoomId::try_from(room_id_str)
+    let room_id = <&RoomId>::try_from(room_id_str)
        .map_err(|_| Error::bad_database("Invalid room id field in event in database"))?;

-    if !db.rooms.server_in_room(sender_servername, &room_id)? {
+    if !db.rooms.server_in_room(sender_servername, room_id)? {
        return Err(Error::BadRequest(ErrorKind::NotFound, "Event not found."));
    }

-    let auth_chain_ids = get_auth_chain(&room_id, vec![Arc::new(body.event_id.clone())], &db)?;
+    let auth_chain_ids = get_auth_chain(room_id, vec![Arc::from(&*body.event_id)], &db)?;

    Ok(get_event_authorization::v1::Response {
        auth_chain: auth_chain_ids
@@ -2550,7 +2523,7 @@ pub fn get_room_state_route(
        })
        .collect();

-    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::new(body.event_id.clone())], &db)?;
+    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)], &db)?;

    Ok(get_room_state::v1::Response {
        auth_chain: auth_chain_ids
@@ -2606,13 +2579,13 @@ pub fn get_room_state_ids_route(
        .rooms
        .state_full_ids(shortstatehash)?
        .into_iter()
-        .map(|(_, id)| (*id).clone())
+        .map(|(_, id)| (*id).to_owned())
        .collect();

-    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::new(body.event_id.clone())], &db)?;
+    let auth_chain_ids = get_auth_chain(&body.room_id, vec![Arc::from(&*body.event_id)], &db)?;

    Ok(get_room_state_ids::v1::Response {
-        auth_chain_ids: auth_chain_ids.map(|id| (*id).clone()).collect(),
+        auth_chain_ids: auth_chain_ids.map(|id| (*id).to_owned()).collect(),
        pdu_ids,
    }
    .into())
@@ -2670,12 +2643,9 @@ 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| {
-            create_event.room_version
-        });
+    // 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::V6, |create_event| create_event.room_version);
    let room_version = RoomVersion::new(&room_version_id).expect("room version is supported");

    if !body.ver.contains(&room_version_id) {
@@ -2695,6 +2665,7 @@ pub fn create_join_event_template_route(
        membership: MembershipState::Join,
        third_party_invite: None,
        reason: None,
+        join_authorized_via_users_server: None,
    })
    .expect("member event is valid value");

@@ -2728,7 +2699,7 @@ pub fn create_join_event_template_route(
    }

    let pdu = PduEvent {
-        event_id: ruma::event_id!("$thiswillbefilledinlater"),
+        event_id: ruma::event_id!("$thiswillbefilledinlater").into(),
        room_id: body.room_id.clone(),
        sender: body.user_id.clone(),
        origin_server_ts: utils::millis_since_unix_epoch()
@@ -2815,7 +2786,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
@@ -2840,7 +2811,7 @@ async fn create_join_event(
            .roomid_mutex_federation
            .write()
            .unwrap()
-            .entry(room_id.clone())
+            .entry(room_id.to_owned())
            .or_default(),
    );
    let mutex_lock = mutex.lock().await;
@@ -2939,7 +2910,7 @@ pub async fn create_invite_route(
        return Err(Error::bad_config("Federation is disabled."));
    }

-    if !db.rooms.is_supported_version(&db, &body.room_version) {
+    if body.room_version != RoomVersionId::V5 && body.room_version != RoomVersionId::V6 {
        return Err(Error::BadRequest(
            ErrorKind::IncompatibleRoomVersion {
                room_version: body.room_version.clone(),
@@ -2960,7 +2931,7 @@ pub async fn create_invite_route(
    .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Failed to sign event."))?;

    // Generate event id
-    let event_id = EventId::try_from(&*format!(
+    let event_id = EventId::parse(format!(
        "${}",
        ruma::signatures::reference_hash(&signed_event, &body.room_version)
            .expect("ruma can calculate reference hashes")
@@ -2973,7 +2944,7 @@ pub async fn create_invite_route(
        CanonicalJsonValue::String(event_id.into()),
    );

-    let sender = serde_json::from_value(
+    let sender: Box<_> = serde_json::from_value(
        signed_event
            .get("sender")
            .ok_or(Error::BadRequest(
@@ -2985,7 +2956,7 @@ pub async fn create_invite_route(
    )
    .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "sender is not a user id."))?;

-    let invited_user = serde_json::from_value(
+    let invited_user: Box<_> = serde_json::from_value(
        signed_event
            .get("state_key")
            .ok_or(Error::BadRequest(
@@ -3236,7 +3207,7 @@ pub(crate) async fn fetch_required_signing_keys(

        let fetch_res = fetch_signing_keys(
            db,
-            &Box::<ServerName>::try_from(&**signature_server).map_err(|_| {
+            signature_server.as_str().try_into().map_err(|_| {
                Error::BadServerResponse("Invalid servername in signatures of server response pdu.")
            })?,
            signature_ids,
@@ -3264,7 +3235,7 @@ pub(crate) async fn fetch_required_signing_keys(
 // 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,
-    servers: &mut BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, QueryCriteria>>,
+    servers: &mut BTreeMap<Box<ServerName>, BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>>,
    room_version: &RoomVersionId,
    pub_key_map: &mut RwLockWriteGuard<'_, BTreeMap<String, BTreeMap<String, String>>>,
    db: &Database,
@@ -3274,11 +3245,12 @@ fn get_server_keys_from_cache(
        Error::BadServerResponse("Invalid PDU in server response")
    })?;

-    let event_id = EventId::try_from(&*format!(
+    let event_id = format!(
        "${}",
        ruma::signatures::reference_hash(&value, room_version)
            .expect("ruma can calculate reference hashes")
-    ))
+    );
+    let event_id = <&EventId>::try_from(event_id.as_str())
        .expect("ruma's reference hashes are valid event ids");

    if let Some((time, tries)) = db
@@ -3286,7 +3258,7 @@ fn get_server_keys_from_cache(
        .bad_event_ratelimiter
        .read()
        .unwrap()
-        .get(&event_id)
+        .get(event_id)
    {
        // Exponential backoff
        let mut min_elapsed_duration = Duration::from_secs(30) * (*tries) * (*tries);
@@ -3320,7 +3292,7 @@ fn get_server_keys_from_cache(
        let contains_all_ids =
            |keys: &BTreeMap<String, String>| signature_ids.iter().all(|id| keys.contains_key(id));

-        let origin = &Box::<ServerName>::try_from(&**signature_server).map_err(|_| {
+        let origin = <&ServerName>::try_from(signature_server.as_str()).map_err(|_| {
            Error::BadServerResponse("Invalid servername in signatures of server response pdu.")
        })?;

@@ -3339,7 +3311,7 @@ fn get_server_keys_from_cache(

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

        pub_key_map.insert(origin.to_string(), result);
@@ -3354,7 +3326,7 @@ 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>> =
+    let mut servers: BTreeMap<Box<ServerName>, BTreeMap<Box<ServerSigningKeyId>, QueryCriteria>> =
        BTreeMap::new();

    {
@@ -3388,10 +3360,6 @@ pub(crate) async fn fetch_join_signing_keys(
                server,
                get_remote_server_keys_batch::v2::Request {
                    server_keys: servers.clone(),
-                    minimum_valid_until_ts: MilliSecondsSinceUnixEpoch::from_system_time(
-                        SystemTime::now() + Duration::from_secs(60),
-                    )
-                    .expect("time is valid"),
                },
            )
            .await
Author	SHA1	Message	Date
Jonas Platte	aba95b20f3	Upgrade Ruma	2021-12-23 17:40:42 +01:00
Timo Kösters	9b57c89df6	Merge branch 'more-event-id-arcs' into 'next' Use Arc for EventIds in PDUs See merge request famedly/conduit!229	2021-12-16 13:06:30 +00:00
Jonas Platte	34d3f74f36	Use Arc for EventIds in PDUs Upgrades Ruma again to make this work.	2021-12-16 13:55:24 +01:00
Timo Kösters	11a21fc136	Merge branch 'up-ruma' into 'next' Upgrade ruma See merge request famedly/conduit!228	2021-12-15 14:22:30 +00:00
Jonas Platte	0183d003d0	Revert rename of Ruma<_> parameters	2021-12-15 13:58:25 +01:00
Jonas Platte	f712455047	Reduce EventId copying	2021-12-15 13:00:37 +01:00
Jonas Platte	58ea081762	Use int! macro instead of Int::from	2021-12-15 13:00:37 +01:00
Jonas Platte	bffddbd487	Simplify identifier parsing code	2021-12-15 13:00:37 +01:00
Jonas Platte	41fef1da64	Remove unnecessary .to_string() calls	2021-12-15 13:00:37 +01:00
Jonas Platte	892a0525f2	Upgrade Ruma	2021-12-15 13:00:37 +01:00
Jonas Platte	1fc616320a	Use struct init shorthand	2021-12-15 13:00:37 +01:00
Timo Kösters	14a178d783	Merge branch 'update-docker-base-image' into 'next' Update docker images See merge request famedly/conduit!230	2021-12-15 10:14:20 +00:00
Jonas Zohren	339a26f56c	Update docker images	2021-12-15 10:14:20 +00:00
Timo Kösters	ca724b6340	Merge branch '226-fix-docker-ci-issues' into 'next' Fixes for !225 See merge request famedly/conduit!226	2021-11-25 22:36:44 +00:00
Jonas Zohren	9bfc7b34b6	Fixes for !225	2021-11-25 22:36:44 +00:00