better test

fix init
Implement plaintext encryption v2
2026-01-10 22:08:09 -05:00 · 2022-12-16 13:45:21 +01:00 · 2022-12-16 12:05:55 +01:00 · 2022-12-16 11:58:40 +01:00
203 changed files with 4678 additions and 8512 deletions
--- a/.github/workflows/bumper.yml
+++ b/.github/workflows/bumper.yml
@@ -10,12 +10,11 @@ jobs:
  bumpProjects:
    runs-on: ubuntu-latest
    strategy:
-      fail-fast: false
      matrix:
        target: [
          { repo: status-im/nimbus-eth2, branch: unstable },
-          { repo: waku-org/nwaku, branch: master },
-          { repo: codex-storage/nim-codex, branch: master }
+          { repo: status-im/nwaku, branch: master },
+          { repo: status-im/nim-codex, branch: main }
        ]
    steps:
      - name: Clone repo
@@ -24,14 +23,13 @@ jobs:
          repository: ${{ matrix.target.repo }}
          ref: ${{ matrix.target.branch }}
          path: nbc
+          submodules: true
          fetch-depth: 0
          token:  ${{ secrets.ACTIONS_GITHUB_TOKEN }}

      - name: Checkout this ref
        run: |
-          cd nbc
-          git submodule update --init vendor/nim-libp2p
-          cd vendor/nim-libp2p
+          cd nbc/vendor/nim-libp2p
          git checkout $GITHUB_SHA

      - name: Commit this bump
@@ -39,7 +37,7 @@ jobs:
          cd nbc
          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
          git config --global user.name = "${{ github.actor }}"
-          git commit --allow-empty -a -m "auto-bump nim-libp2p"
+          git commit -a -m "auto-bump nim-libp2p"
          git branch -D nim-libp2p-auto-bump-${GITHUB_REF##*/} || true
          git switch -c nim-libp2p-auto-bump-${GITHUB_REF##*/}
          git push -f origin nim-libp2p-auto-bump-${GITHUB_REF##*/}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,7 +28,7 @@ jobs:
            cpu: amd64
          #- os: windows
            #cpu: i386
-        branch: [version-1-6]
+        branch: [version-1-2, version-1-6]
        include:
          - target:
              os: linux
--- a/.github/workflows/daily.yml
+++ b/.github/workflows/daily.yml
@@ -1,12 +0,0 @@
-name: Daily
-on:
-  schedule:
-    - cron: "30 6 * * *"
-  workflow_dispatch:
-
-jobs:
-  call-multi-nim-common:
-    uses: ./.github/workflows/daily_common.yml
-    with:
-      nim-branch: "['version-1-6','version-2-0']"
-      cpu: "['amd64']"
--- a/.github/workflows/daily_common.yml
+++ b/.github/workflows/daily_common.yml
@@ -1,84 +0,0 @@
-name: daily-common
-
-on:
-  workflow_call:
-    inputs:
-      nim-branch:
-        description: 'Nim branch'
-        required: true
-        type: string
-      cpu:
-        description: 'CPU'
-        required: true
-        type: string
-      exclude:
-        description: 'Exclude matrix configurations'
-        required: false
-        type: string
-        default: "[]"
-
-jobs:
-  delete-cache:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: snnaplab/delete-branch-cache-action@v1
-
-  build:
-    needs: delete-cache
-    timeout-minutes: 120
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - os: linux
-            builder: ubuntu-20
-            shell: bash
-          - os: macos
-            builder: macos-12
-            shell: bash
-          - os: windows
-            builder: windows-2019
-            shell: msys2 {0}
-        branch: ${{ fromJSON(inputs.nim-branch) }}
-        cpu: ${{ fromJSON(inputs.cpu) }}
-        exclude: ${{ fromJSON(inputs.exclude) }}
-
-    defaults:
-      run:
-        shell: ${{ matrix.platform.shell }}
-
-    name: '${{ matrix.platform.os }}-${{ matrix.cpu }} (Nim ${{ matrix.branch }})'
-    runs-on: ${{ matrix.platform.builder }}
-    continue-on-error: ${{ matrix.branch == 'devel' || matrix.branch == 'version-2-0' }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Nim
-        uses: "./.github/actions/install_nim"
-        with:
-          os: ${{ matrix.platform.os }}
-          shell: ${{ matrix.platform.shell }}
-          nim_branch: ${{ matrix.branch }}
-          cpu: ${{ matrix.cpu }}
-
-      - name: Setup Go
-        uses: actions/setup-go@v4
-        with:
-          go-version: '~1.15.5'
-          cache: false
-
-      - name: Install p2pd
-        run: |
-          V=1 bash scripts/build_p2pd.sh p2pdCache 124530a3
-
-      - name: Run tests
-        run: |
-          nim --version
-          nimble --version
-          nimble install -y --depsOnly
-          NIMFLAGS="${NIMFLAGS} --mm:refc" nimble test
-          if [[ "${{ matrix.branch }}" == "devel" ]]; then
-            echo -e "\nTesting with '--mm:orc':\n"
-            NIMFLAGS="${NIMFLAGS} --mm:orc" nimble test
-          fi
--- a/.github/workflows/daily_i386.yml
+++ b/.github/workflows/daily_i386.yml
@@ -1,13 +0,0 @@
-name: Daily i386
-on:
-  schedule:
-    - cron: "30 6 * * *"
-  workflow_dispatch:
-
-jobs:
-  call-multi-nim-common:
-    uses: ./.github/workflows/daily_common.yml
-    with:
-      nim-branch: "['version-1-6','version-2-0', 'devel']"
-      cpu: "['i386']"
-      exclude: "[{'platform': {'os':'macos'}}, {'platform': {'os':'windows'}}]"
--- a/.github/workflows/daily_nim_devel.yml
+++ b/.github/workflows/daily_nim_devel.yml
@@ -1,12 +0,0 @@
-name: Daily Nim Devel
-on:
-  schedule:
-    - cron: "30 6 * * *"
-  workflow_dispatch:
-
-jobs:
-  call-multi-nim-common:
-    uses: ./.github/workflows/daily_common.yml
-    with:
-      nim-branch: "['devel']"
-      cpu: "['amd64']"
--- a/.github/workflows/doc.yml
+++ b/.github/workflows/doc.yml
@@ -19,7 +19,7 @@ jobs:

      - uses: jiro4989/setup-nim-action@v1
        with:
-          nim-version: '1.6.x'
+          nim-version: 'stable'

      - name: Generate doc
        run: |
--- a/.github/workflows/interop.yml
+++ b/.github/workflows/interop.yml
@@ -1,68 +0,0 @@
-name: Interoperability Testing
-on:
-  pull_request:
-  push:
-    branches:
-      - unstable
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  run-multidim-interop:
-    name: Run multidimensional interoperability tests
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          repository: libp2p/test-plans
-          submodules: true
-          fetch-depth: 0
-
-      - name: Build image
-        run: >
-          cd transport-interop/impl/nim/v1.0 &&
-          make commitSha=$GITHUB_SHA image_name=nim-libp2p-head
-
-      - name: Create ping-version.json
-        run: >
-          (cat << EOF
-            {
-                "id": "nim-libp2p-head",
-                "containerImageID": "nim-libp2p-head",
-                "transports": [
-                    "tcp",
-                    "ws"
-                ],
-                "secureChannels": [
-                    "noise"
-                ],
-                "muxers": [
-                    "mplex",
-                    "yamux"
-                ]
-            }
-          EOF
-
-          ) > ${{ github.workspace }}/test_head.json
-
-      - uses: libp2p/test-plans/.github/actions/run-transport-interop-test@master
-        with:
-          test-filter: nim-libp2p-head
-          extra-versions: ${{ github.workspace }}/test_head.json
-
-  run-hole-punching-interop:
-    name: Run hole-punching interoperability tests
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: docker/setup-buildx-action@v3
-      - name: Build image
-        run: docker buildx build --load -t nim-libp2p-head -f tests/hole-punching-interop/Dockerfile .
-      - name: Run tests
-        uses: libp2p/test-plans/.github/actions/run-interop-hole-punch-test@master
-        with:
-          test-filter: nim-libp2p-head
-          extra-versions: ${{ github.workspace }}/tests/hole-punching-interop/version.json
--- a/.github/workflows/multi_nim.yml
+++ b/.github/workflows/multi_nim.yml
@@ -0,0 +1,82 @@
+name: Daily
+on:
+  schedule:
+    - cron: "30 6 * * *"
+  workflow_dispatch:
+
+jobs:
+  delete-cache:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: snnaplab/delete-branch-cache-action@v1
+
+  build:
+    needs: delete-cache
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - os: linux
+            cpu: amd64
+          - os: linux
+            cpu: i386
+          - os: macos
+            cpu: amd64
+          - os: windows
+            cpu: amd64
+          #- os: windows
+            #cpu: i386
+        branch: [version-1-2, version-1-6, devel]
+        include:
+          - target:
+              os: linux
+            builder: ubuntu-20.04
+            shell: bash
+          - target:
+              os: macos
+            builder: macos-12
+            shell: bash
+          - target:
+              os: windows
+            builder: windows-2019
+            shell: msys2 {0}
+
+    defaults:
+      run:
+        shell: ${{ matrix.shell }}
+
+    name: '${{ matrix.target.os }}-${{ matrix.target.cpu }} (Nim ${{ matrix.branch }})'
+    runs-on: ${{ matrix.builder }}
+    continue-on-error: ${{ matrix.branch == 'devel' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup Nim
+        uses: "./.github/actions/install_nim"
+        with:
+          os: ${{ matrix.target.os }}
+          shell: ${{ matrix.shell }}
+          nim_branch: ${{ matrix.branch }}
+          cpu: ${{ matrix.target.cpu }}
+
+      - name: Setup Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: '~1.15.5'
+
+      - name: Install p2pd
+        run: |
+          V=1 bash scripts/build_p2pd.sh p2pdCache 124530a3
+
+      - name: Run tests
+        run: |
+          nim --version
+          nimble --version
+          nimble install -y --depsOnly
+          NIMFLAGS="${NIMFLAGS} --gc:refc" nimble test
+          if [[ "${{ matrix.branch }}" == "devel" ]]; then
+            echo -e "\nTesting with '--gc:orc':\n"
+            NIMFLAGS="${NIMFLAGS} --gc:orc" nimble test
+          fi
--- a/.gitignore
+++ b/.gitignore
@@ -16,4 +16,3 @@ tests/pubsub/testgossipsub
 examples/*.md
 nimble.develop
 nimble.paths
-go-libp2p-daemon/
--- a/.pinned
+++ b/.pinned
@@ -1,17 +1,16 @@
-bearssl;https://github.com/status-im/nim-bearssl@#e4157639db180e52727712a47deaefcbbac6ec86
+bearssl;https://github.com/status-im/nim-bearssl@#a647994910904b0103a05db3a5ec1ecfc4d91a88
 chronicles;https://github.com/status-im/nim-chronicles@#32ac8679680ea699f7dbc046e8e0131cac97d41a
-chronos;https://github.com/status-im/nim-chronos@#ba143e029f35fd9b4cd3d89d007cc834d0d5ba3c
-dnsclient;https://github.com/ba0f3/dnsclient.nim@#23214235d4784d24aceed99bbfe153379ea557c8
-faststreams;https://github.com/status-im/nim-faststreams@#720fc5e5c8e428d9d0af618e1e27c44b42350309
-httputils;https://github.com/status-im/nim-http-utils@#3b491a40c60aad9e8d3407443f46f62511e63b18
-json_serialization;https://github.com/status-im/nim-json-serialization@#85b7ea093cb85ee4f433a617b97571bd709d30df
-metrics;https://github.com/status-im/nim-metrics@#6142e433fc8ea9b73379770a788017ac528d46ff
-nimcrypto;https://github.com/cheatfate/nimcrypto@#1c8d6e3caf3abc572136ae9a1da81730c4eb4288
-results;https://github.com/arnetheduck/nim-results@#f3c666a272c69d70cb41e7245e7f6844797303ad
-secp256k1;https://github.com/status-im/nim-secp256k1@#7246d91c667f4cc3759fdd50339caa45a2ecd8be
-serialization;https://github.com/status-im/nim-serialization@#4bdbc29e54fe54049950e352bb969aab97173b35
-stew;https://github.com/status-im/nim-stew@#3159137d9a3110edb4024145ce0ba778975de40e
+chronos;https://github.com/status-im/nim-chronos@#75d030ff71264513fb9701c75a326cd36fcb4692
+dnsclient;https://github.com/ba0f3/dnsclient.nim@#fcd7443634b950eaea574e5eaa00a628ae029823
+faststreams;https://github.com/status-im/nim-faststreams@#b42daf41d8eb4fbce40add6836bed838f8d85b6f
+httputils;https://github.com/status-im/nim-http-utils@#a85bd52ae0a956983ca6b3267c72961d2ec0245f
+json_serialization;https://github.com/status-im/nim-json-serialization@#a7d815ed92f200f490c95d3cfd722089cc923ce6
+metrics;https://github.com/status-im/nim-metrics@#21e99a2e9d9f80e68bef65c80ef781613005fccb
+nimcrypto;https://github.com/cheatfate/nimcrypto@#24e006df85927f64916e60511620583b11403178
+secp256k1;https://github.com/status-im/nim-secp256k1@#fd173fdff863ce2e211cf64c9a03bc7539fe40b0
+serialization;https://github.com/status-im/nim-serialization@#d77417cba6896c26287a68e6a95762e45a1b87e5
+stew;https://github.com/status-im/nim-stew@#7184d2424dc3945657884646a72715d494917aad
 testutils;https://github.com/status-im/nim-testutils@#dfc4c1b39f9ded9baf6365014de2b4bfb4dafc34
-unittest2;https://github.com/status-im/nim-unittest2@#2300fa9924a76e6c96bc4ea79d043e3a0f27120c
-websock;https://github.com/status-im/nim-websock@#f8ed9b40a5ff27ad02a3c237c4905b0924e3f982
-zlib;https://github.com/status-im/nim-zlib@#38b72eda9d70067df4a953f56b5ed59630f2a17b
+unittest2;https://github.com/status-im/nim-unittest2@#da8398c45cafd5bd7772da1fc96e3924a18d3823
+websock;https://github.com/status-im/nim-websock@#691f069b209d372b1240d5ae1f57fb7bbafeaba7
+zlib;https://github.com/status-im/nim-zlib@#6a6670afba6b97b29b920340e2641978c05ab4d8
--- a/README.md
+++ b/README.md
@@ -20,7 +20,6 @@
 - [Background](#background)
 - [Install](#install)
 - [Getting Started](#getting-started)
-  - [Go-libp2p-daemon](#go-libp2p-daemon)
 - [Modules](#modules)
 - [Users](#users)
 - [Stability](#stability)
@@ -41,8 +40,6 @@ Learn more about libp2p at [**libp2p.io**](https://libp2p.io) and follow libp2p'
 ## Install
 **Prerequisite**
 - [Nim](https://nim-lang.org/install.html)
-> The currently supported Nim version is 1.6.18.
-
 ```
 nimble install libp2p
 ```
@@ -50,11 +47,11 @@ nimble install libp2p
 ## Getting Started
 You'll find the nim-libp2p documentation [here](https://status-im.github.io/nim-libp2p/docs/).

-### Testing
-Remember you'll need to build the `go-libp2p-daemon` binary to run the `nim-libp2p` tests.
-To do so, please follow the installation instructions in [daemonapi.md](examples/go-daemon/daemonapi.md).
+**Go Daemon:**
+Please find the installation and usage intructions in [daemonapi.md](examples/go-daemon/daemonapi.md).

 ## Modules
+
 List of packages modules implemented in nim-libp2p:

 | Name                                                       | Description                                                                                                      |
@@ -108,7 +105,7 @@ The versioning follows [semver](https://semver.org/), with some additions:
 - Some of libp2p procedures are marked as `.public.`, they will remain compatible during each `MAJOR` version
 - The rest of the procedures are considered internal, and can change at any `MINOR` version (but remain compatible for each new `PATCH`)

-We aim to be compatible at all time with at least 2 Nim `MINOR` versions, currently `1.6 & 2.0`
+We aim to be compatible at all time with at least 2 Nim `MINOR` versions, currently `1.2 & 1.6`

 ## Development
 Clone and Install dependencies:
--- a/config.nims
+++ b/config.nims
@@ -1,16 +1,16 @@
 # to allow locking
 if dirExists("nimbledeps/pkgs"):
  switch("NimblePath", "nimbledeps/pkgs")
-if dirExists("nimbledeps/pkgs2"):
-  switch("NimblePath", "nimbledeps/pkgs2")

 switch("warning", "CaseTransition:off")
 switch("warning", "ObservableStores:off")
 switch("warning", "LockLevel:off")
 --define:chronosStrictException
 --styleCheck:usages
-switch("warningAsError", "UseBase:on")
--styleCheck:error
+if (NimMajor, NimMinor) < (1, 6):
+  --styleCheck:hint
+else:
+  --styleCheck:error

 # Avoid some rare stack corruption while using exceptions with a SEH-enabled
 # toolchain: https://github.com/status-im/nimbus-eth2/issues/3121
--- a/examples/circuitrelay.nim
+++ b/examples/circuitrelay.nim
@@ -57,7 +57,8 @@ proc main() {.async.} =
  let
    # Create a relay address to swDst using swRel as the relay
    addrs = MultiAddress.init($swRel.peerInfo.addrs[0] & "/p2p/" &
-                              $swRel.peerInfo.peerId & "/p2p-circuit").get()
+                              $swRel.peerInfo.peerId & "/p2p-circuit/p2p/" &
+                              $swDst.peerInfo.peerId).get()

  # Connect Dst to the relay
  await swDst.connect(swRel.peerInfo.peerId, swRel.peerInfo.addrs)
--- a/examples/go-daemon/daemonapi.md
+++ b/examples/go-daemon/daemonapi.md
@@ -1,8 +1,6 @@
 # Table of Contents
 - [Introduction](#introduction)
- [Prerequisites](#prerequisites)
 - [Installation](#installation)
-  - [Script](#script)
 - [Usage](#usage)
  - [Example](#example)
  - [Getting Started](#getting-started)
@@ -10,29 +8,26 @@
 # Introduction
 This is a libp2p-backed daemon wrapping the functionalities of go-libp2p for use in Nim. <br>
 For more information about the go daemon, check out [this repository](https://github.com/libp2p/go-libp2p-daemon).
-> **Required only** for running the tests.
-
-# Prerequisites
-Go with version `1.15.15`.
-> You will *likely* be able to build `go-libp2p-daemon` with different Go versions, but **they haven't been tested**.

 # Installation
-Follow one of the methods below:
-
-## Script
-Run the build script while having the `go` command pointing to the correct Go version.
-We recommend using `1.15.15`, as previously stated.
 ```sh
-./scripts/build_p2pd.sh
-```
-If everything goes correctly, the binary (`p2pd`) should be built and placed in the correct directory.
-If you find any issues, please head into our discord and ask for our asistance.
+# clone and install dependencies
+git clone https://github.com/status-im/nim-libp2p
+cd nim-libp2p
+nimble install

-After successfully building the binary, remember to add it to your path so it can be found. You can do that by running:
-```sh
-export PATH="$PATH:$HOME/go/bin"
+# perform unit tests
+nimble test
+
+# update the git submodule to install the go daemon 
+git submodule update --init --recursive
+go version
+git clone https://github.com/libp2p/go-libp2p-daemon
+cd go-libp2p-daemon
+git checkout v0.0.1
+go install ./...
+cd ..
 ```
-> **Tip:** To make this change permanent, add the command above to your `.bashrc` file.

 # Usage 

--- a/examples/helloworld.nim
+++ b/examples/helloworld.nim
@@ -13,7 +13,7 @@ type
 proc new(T: typedesc[TestProto]): T =

  # every incoming connections will be in handled in this closure
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    echo "Got from remote - ", string.fromBytes(await conn.readLp(1024))
    await conn.writeLp("Roger p2p!")

@@ -40,7 +40,7 @@ proc createSwitch(ma: MultiAddress, rng: ref HmacDrbgContext): Switch =
 ##
 # The actual application
 ##
-proc main() {.async.} =
+proc main() {.async, gcsafe.} =
  let
    rng = newRng() # Single random number source for the whole application
    # port 0 will take a random available port
--- a/examples/tutorial_1_connect.nim
+++ b/examples/tutorial_1_connect.nim
@@ -53,7 +53,7 @@ proc createSwitch(ma: MultiAddress, rng: ref HmacDrbgContext): Switch =
 ##
 ##
 ## Let's now start to create our main procedure:
-proc main() {.async.} =
+proc main() {.async, gcsafe.} =
  let
    rng = newRng()
    localAddress = MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()
--- a/examples/tutorial_2_customproto.nim
+++ b/examples/tutorial_2_customproto.nim
@@ -25,7 +25,7 @@ type TestProto = ref object of LPProtocol

 proc new(T: typedesc[TestProto]): T =
  # every incoming connections will in be handled in this closure
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    # Read up to 1024 bytes from this connection, and transform them into
    # a string
    echo "Got from remote - ", string.fromBytes(await conn.readLp(1024))
@@ -44,7 +44,7 @@ proc hello(p: TestProto, conn: Connection) {.async.} =
 ## Again, pretty straight-forward, we just send a message on the connection.
 ##
 ## We can now create our main procedure:
-proc main() {.async.} =
+proc main() {.async, gcsafe.} =
  let
    rng = newRng()
    testProto = TestProto.new()
--- a/examples/tutorial_3_protobuf.nim
+++ b/examples/tutorial_3_protobuf.nim
@@ -108,7 +108,7 @@ type

 proc new(_: typedesc[MetricProto], cb: MetricCallback): MetricProto =
  var res: MetricProto
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    let
      metrics = await res.metricGetter()
      asProtobuf = metrics.encode()
@@ -126,7 +126,7 @@ proc fetch(p: MetricProto, conn: Connection): Future[MetricList] {.async.} =
  return MetricList.decode(protobuf).tryGet()

 ## We can now create our main procedure:
-proc main() {.async.} =
+proc main() {.async, gcsafe.} =
  let rng = newRng()
  proc randomMetricGenerator: Future[MetricList] {.async.} =
    let metricCount = rng[].generate(uint32) mod 16
--- a/examples/tutorial_5_discovery.nim
+++ b/examples/tutorial_5_discovery.nim
@@ -33,7 +33,7 @@ proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
 const DumbCodec = "/dumb/proto/1.0.0"
 type DumbProto = ref object of LPProtocol
 proc new(T: typedesc[DumbProto], nodeNumber: int): T =
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    echo "Node", nodeNumber, " received: ", string.fromBytes(await conn.readLp(1024))
    await conn.close()
  return T.new(codecs = @[DumbCodec], handler = handle)
@@ -49,7 +49,7 @@ proc new(T: typedesc[DumbProto], nodeNumber: int): T =
 ## (rendezvous in this case) as a bootnode. For this example, we'll
 ## create a bootnode, and then every peer will advertise itself on the
 ## bootnode, and use it to find other peers
-proc main() {.async.} =
+proc main() {.async, gcsafe.} =
  let bootNode = createSwitch()
  await bootNode.start()

--- a/examples/tutorial_6_game.nim
+++ b/examples/tutorial_6_game.nim
@@ -143,7 +143,7 @@ proc draw(g: Game) =
 ## peer know that we are available, check that he is also available,
 ## and launch the game.
 proc new(T: typedesc[GameProto], g: Game): T =
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    defer: await conn.closeWithEof()
    if g.peerFound.finished or g.hasCandidate:
      await conn.close()
--- a/libp2p.nim
+++ b/libp2p.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -48,9 +48,12 @@ else:
            stream/connection,
            transports/transport,
            transports/tcptransport,
+            transports/wstransport,
            protocols/secure/noise,
+            protocols/ping,
            cid,
            multihash,
+            multibase,
            multicodec,
            errors,
            switch,
--- a/libp2p.nimble
+++ b/libp2p.nimble
@@ -1,13 +1,13 @@
 mode = ScriptMode.Verbose

 packageName   = "libp2p"
-version       = "1.1.0"
+version       = "1.0.0"
 author        = "Status Research & Development GmbH"
 description   = "LibP2P implementation"
 license       = "MIT"
 skipDirs      = @["tests", "examples", "Nim", "tools", "scripts", "docs"]

-requires "nim >= 1.6.0",
+requires "nim >= 1.2.0",
         "nimcrypto >= 0.4.1",
         "dnsclient >= 0.3.0 & < 0.4.0",
         "bearssl >= 0.1.4",
@@ -17,24 +17,16 @@ requires "nim >= 1.6.0",
         "secp256k1",
         "stew#head",
         "websock",
-         "unittest2"
-
-let nimc = getEnv("NIMC", "nim") # Which nim compiler to use
-let lang = getEnv("NIMLANG", "c") # Which backend (c/cpp/js)
-let flags = getEnv("NIMFLAGS", "") # Extra flags for the compiler
-let verbose = getEnv("V", "") notin ["", "0"]
-
-let cfg =
-  " --styleCheck:usages --styleCheck:error" &
-  (if verbose: "" else: " --verbosity:0 --hints:off") &
-  " --skipParentCfg --skipUserCfg -f" &
-  " --threads:on --opt:speed"
-
-import hashes, strutils
+         "unittest2 >= 0.0.5 & < 0.1.0"

+import hashes
 proc runTest(filename: string, verify: bool = true, sign: bool = true,
             moreoptions: string = "") =
-  var excstr = nimc & " " & lang & " -d:debug " & cfg & " " & flags
+  var excstr = "nim c --skipParentCfg --opt:speed -d:debug -d:libp2p_agents_metrics -d:libp2p_protobuf_metrics -d:libp2p_network_protocols_metrics -d:libp2p_mplex_metrics "
+  excstr.add(" -d:chronicles_sinks=textlines[stdout],json[dynamic] -d:chronicles_log_level=TRACE ")
+  excstr.add(" -d:chronicles_runtime_filtering=TRUE ")
+  excstr.add(" " & getEnv("NIMFLAGS") & " ")
+  excstr.add(" --verbosity:0 --hints:off ")
  excstr.add(" -d:libp2p_pubsub_sign=" & $sign)
  excstr.add(" -d:libp2p_pubsub_verify=" & $verify)
  excstr.add(" " & moreoptions & " ")
@@ -44,7 +36,7 @@ proc runTest(filename: string, verify: bool = true, sign: bool = true,
  rmFile "tests/" & filename.toExe

 proc buildSample(filename: string, run = false, extraFlags = "") =
-  var excstr = nimc & " " & lang & " " & cfg & " " & flags & " -p:. " & extraFlags
+  var excstr = "nim c --opt:speed --threads:on -d:debug --verbosity:0 --hints:off -p:. " & extraFlags
  excstr.add(" examples/" & filename)
  exec excstr
  if run:
@@ -52,7 +44,7 @@ proc buildSample(filename: string, run = false, extraFlags = "") =
  rmFile "examples/" & filename.toExe

 proc tutorialToMd(filename: string) =
-  let markdown = gorge "cat " & filename & " | " & nimc & " " & lang & " -r --verbosity:0 --hints:off tools/markdown_builder.nim "
+  let markdown = gorge "cat " & filename & " | nim c -r --verbosity:0 --hints:off tools/markdown_builder.nim "
  writeFile(filename.replace(".nim", ".md"), markdown)

 task testnative, "Runs libp2p native tests":
@@ -114,12 +106,15 @@ task examples_build, "Build the samples":
  buildSample("circuitrelay", true)
  buildSample("tutorial_1_connect", true)
  buildSample("tutorial_2_customproto", true)
-  buildSample("tutorial_3_protobuf", true)
-  buildSample("tutorial_4_gossipsub", true)
-  buildSample("tutorial_5_discovery", true)
-  exec "nimble install -y nimpng@#HEAD" # this is to fix broken build on 1.7.3, remove it when nimpng version 0.3.2 or later is released
-  exec "nimble install -y nico"
-  buildSample("tutorial_6_game", false, "--styleCheck:off")
+  if (NimMajor, NimMinor) > (1, 2):
+    # These tutorials relies on post 1.4 exception tracking
+    buildSample("tutorial_3_protobuf", true)
+    buildSample("tutorial_4_gossipsub", true)
+    buildSample("tutorial_5_discovery", true)
+    # Nico doesn't work in 1.2
+    exec "nimble install -y nimpng@#HEAD" # this is to fix broken build on 1.7.3, remove it when nimpng version 0.3.2 or later is released
+    exec "nimble install -y nico"
+    buildSample("tutorial_6_game", false, "--styleCheck:off")

 # pin system
 # while nimble lockfile
@@ -130,7 +125,7 @@ task pin, "Create a lockfile":
  # pinner.nim was originally here
  # but you can't read output from
  # a command in a nimscript
-  exec nimc & " c -r tools/pinner.nim"
+  exec "nim c -r tools/pinner.nim"

 import sequtils
 import os
@@ -148,20 +143,10 @@ task install_pinned, "Reads the lockfile":
    if system.dirExists("nimbledeps/pkgs"): "nimbledeps/pkgs"
    else: "nimbledeps/pkgs2"
  for dependency in listDirs(nimblePkgs):
-    let
-      fileName = dependency.extractFilename
-      fileContent = readFile(dependency & "/nimblemeta.json")
-      packageName = fileName.split('-')[0]
-
-    if toInstall.anyIt(
-        it[0] == packageName and
-        (
-          it[1].split('#')[^1] in fileContent or # nimble for nim 2.X
-          fileName.endsWith(it[1].split('#')[^1]) # nimble for nim 1.X
-        )
-      ) == false or
-      fileName.split('-')[^1].len < 20: # safegard for nimble for nim 1.X
-        rmDir(dependency)
+    let filename = dependency.extractFilename
+    if toInstall.anyIt(filename.startsWith(it[0]) and
+       filename.endsWith(it[1].split('#')[^1])) == false:
+      rmDir(dependency)

 task unpin, "Restore global package use":
  rmDir("nimbledeps")
--- a/libp2p/builders.nim
+++ b/libp2p/builders.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -16,16 +16,19 @@ runnableExamples:
   # etc
   .build()

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import
  options, tables, chronos, chronicles, sequtils,
  switch, peerid, peerinfo, stream/connection, multiaddress,
  crypto/crypto, transports/[transport, tcptransport],
  muxers/[muxer, mplex/mplex, yamux/yamux],
-  protocols/[identify, secure/secure, secure/noise, rendezvous],
-  protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport],
-  connmanager, upgrademngrs/muxedupgrade, observedaddrmanager,
+  protocols/[identify, secure/secure, secure/noise, secure/plaintext, rendezvous],
+  protocols/connectivity/[autonat, relay/relay, relay/client, relay/rtransport],
+  connmanager, upgrademngrs/muxedupgrade,
  nameresolving/nameresolver,
  errors, utility

@@ -33,10 +36,11 @@ export
  switch, peerid, peerinfo, connection, multiaddress, crypto, errors

 type
-  TransportProvider* {.public.} = proc(upgr: Upgrade): Transport {.gcsafe, raises: [].}
+  TransportProvider* {.public.} = proc(upgr: Upgrade): Transport {.gcsafe, raises: [Defect].}

  SecureProtocol* {.pure.} = enum
    Noise,
+    PlainText,
    Secio {.deprecated.}

  SwitchBuilder* = ref object
@@ -54,12 +58,10 @@ type
    protoVersion: string
    agentVersion: string
    nameResolver: NameResolver
-    peerStoreCapacity: Opt[int]
+    peerStoreCapacity: Option[int]
    autonat: bool
    circuitRelay: Relay
    rdv: RendezVous
-    services: seq[Service]
-    observedAddrManager: ObservedAddrManager

 proc new*(T: type[SwitchBuilder]): T {.public.} =
  ## Creates a SwitchBuilder
@@ -122,8 +124,8 @@ proc withMplex*(
  b.muxers.add(MuxerProvider.new(newMuxer, MplexCodec))
  b

-proc withYamux*(b: SwitchBuilder, windowSize: int = YamuxDefaultWindowSize): SwitchBuilder =
-  proc newMuxer(conn: Connection): Muxer = Yamux.new(conn, windowSize)
+proc withYamux*(b: SwitchBuilder): SwitchBuilder =
+  proc newMuxer(conn: Connection): Muxer = Yamux.new(conn)

  assert b.muxers.countIt(it.codec == YamuxCodec) == 0, "Yamux build multiple times"
  b.muxers.add(MuxerProvider.new(newMuxer, YamuxCodec))
@@ -133,6 +135,11 @@ proc withNoise*(b: SwitchBuilder): SwitchBuilder {.public.} =
  b.secureManagers.add(SecureProtocol.Noise)
  b

+proc withPlainText*(b: SwitchBuilder): SwitchBuilder {.public.} =
+  warn "Using plain text encryption!"
+  b.secureManagers.add(SecureProtocol.PlainText)
+  b
+
 proc withTransport*(b: SwitchBuilder, prov: TransportProvider): SwitchBuilder {.public.} =
  ## Use a custom transport
  runnableExamples:
@@ -171,7 +178,7 @@ proc withMaxConnsPerPeer*(b: SwitchBuilder, maxConnsPerPeer: int): SwitchBuilder
  b

 proc withPeerStore*(b: SwitchBuilder, capacity: int): SwitchBuilder {.public.} =
-  b.peerStoreCapacity = Opt.some(capacity)
+  b.peerStoreCapacity = some(capacity)
  b

 proc withProtoVersion*(b: SwitchBuilder, protoVersion: string): SwitchBuilder {.public.} =
@@ -198,16 +205,8 @@ proc withRendezVous*(b: SwitchBuilder, rdv: RendezVous = RendezVous.new()): Swit
  b.rdv = rdv
  b

-proc withServices*(b: SwitchBuilder, services: seq[Service]): SwitchBuilder =
-  b.services = services
-  b
-
-proc withObservedAddrManager*(b: SwitchBuilder, observedAddrManager: ObservedAddrManager): SwitchBuilder =
-  b.observedAddrManager = observedAddrManager
-  b
-
 proc build*(b: SwitchBuilder): Switch
-  {.raises: [LPError], public.} =
+  {.raises: [Defect, LPError], public.} =

  if b.rng == nil: # newRng could fail
    raise newException(Defect, "Cannot initialize RNG")
@@ -216,8 +215,13 @@ proc build*(b: SwitchBuilder): Switch
  let
    seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key"))

+  if b.secureManagers.len == 0:
+    b.secureManagers &= SecureProtocol.Noise
+
  var
    secureManagerInstances: seq[Secure]
+  if SecureProtocol.PlainText in b.secureManagers:
+    secureManagerInstances.add(PlainText.new(seckey))
  if SecureProtocol.Noise in b.secureManagers:
    secureManagerInstances.add(Noise.new(b.rng, seckey).Secure)

@@ -228,16 +232,11 @@ proc build*(b: SwitchBuilder): Switch
      protoVersion = b.protoVersion,
      agentVersion = b.agentVersion)

-  let identify =
-    if b.observedAddrManager != nil:
-      Identify.new(peerInfo, b.sendSignedPeerRecord, b.observedAddrManager)
-    else:
-      Identify.new(peerInfo, b.sendSignedPeerRecord)
-
  let
+    identify = Identify.new(peerInfo, b.sendSignedPeerRecord)
    connManager = ConnManager.new(b.maxConnsPerPeer, b.maxConnections, b.maxIn, b.maxOut)
    ms = MultistreamSelect.new()
-    muxedUpgrade = MuxedUpgrade.new(b.muxers, secureManagerInstances, ms)
+    muxedUpgrade = MuxedUpgrade.new(identify, b.muxers, secureManagerInstances, connManager, ms)

  let
    transports = block:
@@ -246,29 +245,24 @@ proc build*(b: SwitchBuilder): Switch
        transports.add(tProvider(muxedUpgrade))
      transports

-  if b.secureManagers.len == 0:
-    b.secureManagers &= SecureProtocol.Noise
-
  if isNil(b.rng):
    b.rng = newRng()

-  let peerStore = block:
-    b.peerStoreCapacity.withValue(capacity):
-      PeerStore.new(identify, capacity)
+  let peerStore =
+    if isSome(b.peerStoreCapacity):
+      PeerStore.new(b.peerStoreCapacity.get())
    else:
-      PeerStore.new(identify)
+      PeerStore.new()

  let switch = newSwitch(
    peerInfo = peerInfo,
    transports = transports,
+    identity = identify,
    secureManagers = secureManagerInstances,
    connManager = connManager,
    ms = ms,
    nameResolver = b.nameResolver,
-    peerStore = peerStore,
-    services = b.services)
-
-  switch.mount(identify)
+    peerStore = peerStore)

  if b.autonat:
    let autonat = Autonat.new(switch)
@@ -303,12 +297,11 @@ proc newStandardSwitch*(
  nameResolver: NameResolver = nil,
  sendSignedPeerRecord = false,
  peerStoreCapacity = 1000): Switch
-  {.raises: [LPError], public.} =
+  {.raises: [Defect, LPError], public.} =
  ## Helper for common switch configurations.
-  {.push warning[Deprecated]:off.}
+
  if SecureProtocol.Secio in secureManagers:
      quit("Secio is deprecated!") # use of secio is unsafe
-  {.pop.}

  let addrs = when addrs is MultiAddress: @[addrs] else: addrs
  var b = SwitchBuilder
@@ -326,7 +319,7 @@ proc newStandardSwitch*(
    .withNameResolver(nameResolver)
    .withNoise()

-  privKey.withValue(pkey):
-    b = b.withPrivateKey(pkey)
+  if privKey.isSome():
+    b = b.withPrivateKey(privKey.get())

  b.build()
--- a/libp2p/cid.nim
+++ b/libp2p/cid.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,7 +9,10 @@

 ## This module implementes CID (Content IDentifier).

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import tables, hashes
 import multibase, multicodec, multihash, vbuffer, varint
@@ -276,6 +279,9 @@ proc `$`*(cid: Cid): string =
    BTCBase58.encode(cid.data.buffer)
  elif cid.cidver == CIDv1:
    let res = MultiBase.encode("base58btc", cid.data.buffer)
-    res.get("")
+    if res.isOk():
+      res.get()
+    else:
+      ""
  else:
    ""
--- a/libp2p/connmanager.nim
+++ b/libp2p/connmanager.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[tables, sequtils, sets]
+import std/[options, tables, sequtils, sets]
 import pkg/[chronos, chronicles, metrics]
 import peerinfo,
       peerstore,
@@ -29,7 +32,6 @@ const

 type
  TooManyConnectionsError* = object of LPError
-  AlreadyExpectingConnectionError* = object of LPError

  ConnEventKind* {.pure.} = enum
    Connected,    # A connection was made and securely upgraded - there may be
@@ -48,10 +50,11 @@ type

  ConnEventHandler* =
    proc(peerId: PeerId, event: ConnEvent): Future[void]
-      {.gcsafe, raises: [].}
+      {.gcsafe, raises: [Defect].}

  PeerEventKind* {.pure.} = enum
    Left,
+    Identified,
    Joined

  PeerEvent* = object
@@ -62,16 +65,20 @@ type
        discard

  PeerEventHandler* =
-    proc(peerId: PeerId, event: PeerEvent): Future[void] {.gcsafe, raises: [].}
+    proc(peerId: PeerId, event: PeerEvent): Future[void] {.gcsafe, raises: [Defect].}
+
+  MuxerHolder = object
+    muxer: Muxer
+    handle: Future[void]

  ConnManager* = ref object of RootObj
    maxConnsPerPeer: int
    inSema*: AsyncSemaphore
    outSema*: AsyncSemaphore
-    muxed: Table[PeerId, seq[Muxer]]
+    conns: Table[PeerId, HashSet[Connection]]
+    muxed: Table[Connection, MuxerHolder]
    connEvents: array[ConnEventKind, OrderedSet[ConnEventHandler]]
    peerEvents: array[PeerEventKind, OrderedSet[PeerEventHandler]]
-    expectedConnectionsOverLimit*: Table[(PeerId, Direction), Future[Muxer]]
    peerStore*: PeerStore

  ConnectionSlot* = object
@@ -101,34 +108,39 @@ proc new*(C: type ConnManager,
    outSema: outSema)

 proc connCount*(c: ConnManager, peerId: PeerId): int =
-  c.muxed.getOrDefault(peerId).len
-
-proc connectedPeers*(c: ConnManager, dir: Direction): seq[PeerId] =
-  var peers = newSeq[PeerId]()
-  for peerId, mux in c.muxed:
-    if mux.anyIt(it.connection.dir == dir):
-      peers.add(peerId)
-  return peers
-
-proc getConnections*(c: ConnManager): Table[PeerId, seq[Muxer]] =
-  return c.muxed
+  c.conns.getOrDefault(peerId).len

 proc addConnEventHandler*(c: ConnManager,
                          handler: ConnEventHandler,
                          kind: ConnEventKind) =
  ## Add peer event handler - handlers must not raise exceptions!
  ##
-  if isNil(handler): return
-  c.connEvents[kind].incl(handler)
+
+  try:
+    if isNil(handler): return
+    c.connEvents[kind].incl(handler)
+  except Exception as exc:
+    # TODO: there is an Exception being raised
+    # somewhere in the depths of the std.
+    # Might be related to https://github.com/nim-lang/Nim/issues/17382
+
+    raiseAssert exc.msg

 proc removeConnEventHandler*(c: ConnManager,
                             handler: ConnEventHandler,
                             kind: ConnEventKind) =
+  try:
    c.connEvents[kind].excl(handler)
+  except Exception as exc:
+    # TODO: there is an Exception being raised
+    # somewhere in the depths of the std.
+    # Might be related to https://github.com/nim-lang/Nim/issues/17382
+
+    raiseAssert exc.msg

 proc triggerConnEvent*(c: ConnManager,
                       peerId: PeerId,
-                       event: ConnEvent) {.async.} =
+                       event: ConnEvent) {.async, gcsafe.} =
  try:
    trace "About to trigger connection events", peer = peerId
    if c.connEvents[event.kind].len() > 0:
@@ -151,22 +163,44 @@ proc addPeerEventHandler*(c: ConnManager,
  ##

  if isNil(handler): return
-  c.peerEvents[kind].incl(handler)
+  try:
+    c.peerEvents[kind].incl(handler)
+  except Exception as exc:
+    # TODO: there is an Exception being raised
+    # somewhere in the depths of the std.
+    # Might be related to https://github.com/nim-lang/Nim/issues/17382
+
+    raiseAssert exc.msg

 proc removePeerEventHandler*(c: ConnManager,
                             handler: PeerEventHandler,
                             kind: PeerEventKind) =
-  c.peerEvents[kind].excl(handler)
+  try:
+    c.peerEvents[kind].excl(handler)
+  except Exception as exc:
+    # TODO: there is an Exception being raised
+    # somewhere in the depths of the std.
+    # Might be related to https://github.com/nim-lang/Nim/issues/17382
+
+    raiseAssert exc.msg

 proc triggerPeerEvents*(c: ConnManager,
                        peerId: PeerId,
-                        event: PeerEvent) {.async.} =
+                        event: PeerEvent) {.async, gcsafe.} =

  trace "About to trigger peer events", peer = peerId
  if c.peerEvents[event.kind].len == 0:
    return

  try:
+    let count = c.connCount(peerId)
+    if event.kind == PeerEventKind.Joined and count != 1:
+      trace "peer already joined", peer = peerId, event = $event
+      return
+    elif event.kind == PeerEventKind.Left and count != 0:
+      trace "peer still connected or already left", peer = peerId, event = $event
+      return
+
    trace "triggering peer events", peer = peerId, event = $event

    var peerEvents: seq[Future[void]]
@@ -179,22 +213,18 @@ proc triggerPeerEvents*(c: ConnManager,
  except CatchableError as exc: # handlers should not raise!
    warn "Exception in triggerPeerEvents", exc = exc.msg, peer = peerId

-proc expectConnection*(c: ConnManager, p: PeerId, dir: Direction): Future[Muxer] {.async.} =
-  ## Wait for a peer to connect to us. This will bypass the `MaxConnectionsPerPeer`
-  let key = (p, dir)
-  if key in c.expectedConnectionsOverLimit:
-    raise newException(AlreadyExpectingConnectionError, "Already expecting an incoming connection from that peer")
+proc contains*(c: ConnManager, conn: Connection): bool =
+  ## checks if a connection is being tracked by the
+  ## connection manager
+  ##

-  let future = newFuture[Muxer]()
-  c.expectedConnectionsOverLimit[key] = future
+  if isNil(conn):
+    return

-  try:
-    return await future
-  finally:
-    c.expectedConnectionsOverLimit.del(key)
+  return conn in c.conns.getOrDefault(conn.peerId)

 proc contains*(c: ConnManager, peerId: PeerId): bool =
-  peerId in c.muxed
+  peerId in c.conns

 proc contains*(c: ConnManager, muxer: Muxer): bool =
  ## checks if a muxer is being tracked by the connection
@@ -202,140 +232,184 @@ proc contains*(c: ConnManager, muxer: Muxer): bool =
  ##

  if isNil(muxer):
-    return false
+    return

  let conn = muxer.connection
-  return muxer in c.muxed.getOrDefault(conn.peerId)
+  if conn notin c:
+    return

-proc closeMuxer(muxer: Muxer) {.async.} =
-  trace "Cleaning up muxer", m = muxer
+  if conn notin c.muxed:
+    return

-  await muxer.close()
-  if not(isNil(muxer.handler)):
+  return muxer == c.muxed.getOrDefault(conn).muxer
+
+proc closeMuxerHolder(muxerHolder: MuxerHolder) {.async.} =
+  trace "Cleaning up muxer", m = muxerHolder.muxer
+
+  await muxerHolder.muxer.close()
+  if not(isNil(muxerHolder.handle)):
    try:
-      await muxer.handler # TODO noraises?
+      await muxerHolder.handle # TODO noraises?
    except CatchableError as exc:
      trace "Exception in close muxer handler", exc = exc.msg
-  trace "Cleaned up muxer", m = muxer
+  trace "Cleaned up muxer", m = muxerHolder.muxer
+
+proc delConn(c: ConnManager, conn: Connection) =
+  let peerId = conn.peerId
+  c.conns.withValue(peerId, peerConns):
+    peerConns[].excl(conn)
+
+    if peerConns[].len == 0:
+      c.conns.del(peerId) # invalidates `peerConns`
+
+    libp2p_peers.set(c.conns.len.int64)
+    trace "Removed connection", conn
+
+proc cleanupConn(c: ConnManager, conn: Connection) {.async.} =
+  ## clean connection's resources such as muxers and streams
+
+  if isNil(conn):
+    trace "Wont cleanup a nil connection"
+    return
+
+  # Remove connection from all tables without async breaks
+  var muxer = some(MuxerHolder())
+  if not c.muxed.pop(conn, muxer.get()):
+    muxer = none(MuxerHolder)
+
+  delConn(c, conn)

-proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
  try:
-    trace "Triggering disconnect events", mux
-    let peerId = mux.connection.peerId
+    if muxer.isSome:
+      await closeMuxerHolder(muxer.get())
+  finally:
+    await conn.close()

-    let muxers = c.muxed.getOrDefault(peerId).filterIt(it != mux)
-    if muxers.len > 0:
-      c.muxed[peerId] = muxers
-    else:
-      c.muxed.del(peerId)
-      libp2p_peers.set(c.muxed.len.int64)
-      await c.triggerPeerEvents(peerId, PeerEvent(kind: PeerEventKind.Left))
+  trace "Connection cleaned up", conn

-      if not(c.peerStore.isNil):
-        c.peerStore.cleanup(peerId)
+proc onConnUpgraded(c: ConnManager, conn: Connection) {.async.} =
+  try:
+    trace "Triggering connect events", conn
+    conn.upgrade()
+
+    let peerId = conn.peerId
+    await c.triggerPeerEvents(
+      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: conn.dir == Direction.Out))

+    await c.triggerConnEvent(
+      peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: conn.dir == Direction.In))
+  except CatchableError as exc:
+    # This is top-level procedure which will work as separate task, so it
+    # do not need to propagate CancelledError and should handle other errors
+    warn "Unexpected exception in switch peer connection cleanup",
+      conn, msg = exc.msg
+
+proc peerCleanup(c: ConnManager, conn: Connection) {.async.} =
+  try:
+    trace "Triggering disconnect events", conn
+    let peerId = conn.peerId
    await c.triggerConnEvent(
      peerId, ConnEvent(kind: ConnEventKind.Disconnected))
+    await c.triggerPeerEvents(peerId, PeerEvent(kind: PeerEventKind.Left))
+
+    if not(c.peerStore.isNil):
+      c.peerStore.cleanup(peerId)
  except CatchableError as exc:
    # This is top-level procedure which will work as separate task, so it
    # do not need to propagate CancelledError and should handle other errors
    warn "Unexpected exception peer cleanup handler",
-      mux, msg = exc.msg
+      conn, msg = exc.msg

-proc onClose(c: ConnManager, mux: Muxer) {.async.} =
+proc onClose(c: ConnManager, conn: Connection) {.async.} =
  ## connection close even handler
  ##
  ## triggers the connections resource cleanup
  ##
  try:
-    await mux.connection.join()
-    trace "Connection closed, cleaning up", mux
+    await conn.join()
+    trace "Connection closed, cleaning up", conn
+    await c.cleanupConn(conn)
+  except CancelledError:
+    # This is top-level procedure which will work as separate task, so it
+    # do not need to propagate CancelledError.
+    debug "Unexpected cancellation in connection manager's cleanup", conn
  except CatchableError as exc:
    debug "Unexpected exception in connection manager's cleanup",
-          errMsg = exc.msg, mux
+          errMsg = exc.msg, conn
  finally:
-    await c.muxCleanup(mux)
+    trace "Triggering peerCleanup", conn
+    asyncSpawn c.peerCleanup(conn)

-proc selectMuxer*(c: ConnManager,
+proc selectConn*(c: ConnManager,
                peerId: PeerId,
-                dir: Direction): Muxer =
+                dir: Direction): Connection =
  ## Select a connection for the provided peer and direction
  ##
  let conns = toSeq(
-    c.muxed.getOrDefault(peerId))
-    .filterIt( it.connection.dir == dir )
+    c.conns.getOrDefault(peerId))
+    .filterIt( it.dir == dir )

  if conns.len > 0:
    return conns[0]

-proc selectMuxer*(c: ConnManager, peerId: PeerId): Muxer =
+proc selectConn*(c: ConnManager, peerId: PeerId): Connection =
  ## Select a connection for the provided giving priority
  ## to outgoing connections
  ##

-  var mux = c.selectMuxer(peerId, Direction.Out)
-  if isNil(mux):
-    mux = c.selectMuxer(peerId, Direction.In)
-  if isNil(mux):
+  var conn = c.selectConn(peerId, Direction.Out)
+  if isNil(conn):
+    conn = c.selectConn(peerId, Direction.In)
+  if isNil(conn):
    trace "connection not found", peerId
-  return mux

-proc storeMuxer*(c: ConnManager,
-                 muxer: Muxer)
-                 {.raises: [CatchableError].} =
-  ## store the connection and muxer
+  return conn
+
+proc selectMuxer*(c: ConnManager, conn: Connection): Muxer =
+  ## select the muxer for the provided connection
  ##

-  if isNil(muxer):
-    raise newException(LPError, "muxer cannot be nil")
+  if isNil(conn):
+    return

-  if isNil(muxer.connection):
-    raise newException(LPError, "muxer's connection cannot be nil")
+  if conn in c.muxed:
+    return c.muxed.getOrDefault(conn).muxer
+  else:
+    debug "no muxer for connection", conn

-  if muxer.connection.closed or muxer.connection.atEof:
+proc storeConn*(c: ConnManager, conn: Connection)
+  {.raises: [Defect, LPError].} =
+  ## store a connection
+  ##
+
+  if isNil(conn):
+    raise newException(LPError, "Connection cannot be nil")
+
+  if conn.closed or conn.atEof:
    raise newException(LPError, "Connection closed or EOF")

-  let
-    peerId = muxer.connection.peerId
-    dir = muxer.connection.dir
+  let peerId = conn.peerId
+  if c.conns.getOrDefault(peerId).len > c.maxConnsPerPeer:
+    debug "Too many connections for peer",
+      conn, conns = c.conns.getOrDefault(peerId).len

-  # we use getOrDefault in the if below instead of [] to avoid the KeyError
-  if c.muxed.getOrDefault(peerId).len > c.maxConnsPerPeer:
-    let key = (peerId, dir)
-    let expectedConn = c.expectedConnectionsOverLimit.getOrDefault(key)
-    if expectedConn != nil and not expectedConn.finished:
-        expectedConn.complete(muxer)
-    else:
-      debug "Too many connections for peer",
-        conns = c.muxed.getOrDefault(peerId).len
+    raise newTooManyConnectionsError()

-      raise newTooManyConnectionsError()
+  c.conns.mgetOrPut(peerId, HashSet[Connection]()).incl(conn)
+  libp2p_peers.set(c.conns.len.int64)

-  assert muxer notin c.muxed.getOrDefault(peerId)
+  # Launch on close listener
+  # All the errors are handled inside `onClose()` procedure.
+  asyncSpawn c.onClose(conn)

-  let
-    newPeer = peerId notin c.muxed
-  assert newPeer or c.muxed[peerId].len > 0
-  c.muxed.mgetOrPut(peerId, newSeq[Muxer]()).add(muxer)
-  libp2p_peers.set(c.muxed.len.int64)
-
-  asyncSpawn c.triggerConnEvent(
-    peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: dir == Direction.In))
-
-  if newPeer:
-    asyncSpawn c.triggerPeerEvents(
-      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: dir == Direction.Out))
-
-  asyncSpawn c.onClose(muxer)
-
-  trace "Stored muxer",
-    muxer, direction = $muxer.connection.dir, peers = c.muxed.len
+  trace "Stored connection",
+    conn, direction = $conn.dir, connections = c.conns.len

 proc getIncomingSlot*(c: ConnManager): Future[ConnectionSlot] {.async.} =
  await c.inSema.acquire()
  return ConnectionSlot(connManager: c, direction: In)

-proc getOutgoingSlot*(c: ConnManager, forceDial = false): ConnectionSlot {.raises: [TooManyConnectionsError].} =
+proc getOutgoingSlot*(c: ConnManager, forceDial = false): Future[ConnectionSlot] {.async.} =
  if forceDial:
    c.outSema.forceAcquire()
  elif not c.outSema.tryAcquire():
@@ -344,13 +418,6 @@ proc getOutgoingSlot*(c: ConnManager, forceDial = false): ConnectionSlot {.raise
    raise newTooManyConnectionsError()
  return ConnectionSlot(connManager: c, direction: Out)

-proc slotsAvailable*(c: ConnManager, dir: Direction): int =
-  case dir:
-    of Direction.In:
-      return c.inSema.count
-    of Direction.Out:
-      return c.outSema.count
-
 proc release*(cs: ConnectionSlot) =
  if cs.direction == In:
    cs.connManager.inSema.release()
@@ -372,44 +439,81 @@ proc trackConnection*(cs: ConnectionSlot, conn: Connection) =

  asyncSpawn semaphoreMonitor()

-proc trackMuxer*(cs: ConnectionSlot, mux: Muxer) =
-  if isNil(mux):
-    cs.release()
-    return
-  cs.trackConnection(mux.connection)
-
-proc getStream*(c: ConnManager,
-                muxer: Muxer): Future[Connection] {.async.} =
-  ## get a muxed stream for the passed muxer
+proc storeMuxer*(c: ConnManager,
+                 muxer: Muxer,
+                 handle: Future[void] = nil)
+                 {.raises: [Defect, CatchableError].} =
+  ## store the connection and muxer
  ##

+  if isNil(muxer):
+    raise newException(CatchableError, "muxer cannot be nil")
+
+  if isNil(muxer.connection):
+    raise newException(CatchableError, "muxer's connection cannot be nil")
+
+  if muxer.connection notin c:
+    raise newException(CatchableError, "cant add muxer for untracked connection")
+
+  c.muxed[muxer.connection] = MuxerHolder(
+    muxer: muxer,
+    handle: handle)
+
+  trace "Stored muxer",
+    muxer, handle = not handle.isNil, connections = c.conns.len
+
+  asyncSpawn c.onConnUpgraded(muxer.connection)
+
+proc getStream*(c: ConnManager,
+                peerId: PeerId,
+                dir: Direction): Future[Connection] {.async, gcsafe.} =
+  ## get a muxed stream for the provided peer
+  ## with the given direction
+  ##
+
+  let muxer = c.selectMuxer(c.selectConn(peerId, dir))
  if not(isNil(muxer)):
    return await muxer.newStream()

 proc getStream*(c: ConnManager,
-                peerId: PeerId): Future[Connection] {.async.} =
+                peerId: PeerId): Future[Connection] {.async, gcsafe.} =
  ## get a muxed stream for the passed peer from any connection
  ##

-  return await c.getStream(c.selectMuxer(peerId))
+  let muxer = c.selectMuxer(c.selectConn(peerId))
+  if not(isNil(muxer)):
+    return await muxer.newStream()

 proc getStream*(c: ConnManager,
-                peerId: PeerId,
-                dir: Direction): Future[Connection] {.async.} =
-  ## get a muxed stream for the passed peer from a connection with `dir`
+                conn: Connection): Future[Connection] {.async, gcsafe.} =
+  ## get a muxed stream for the passed connection
  ##

-  return await c.getStream(c.selectMuxer(peerId, dir))
-
+  let muxer = c.selectMuxer(conn)
+  if not(isNil(muxer)):
+    return await muxer.newStream()

 proc dropPeer*(c: ConnManager, peerId: PeerId) {.async.} =
  ## drop connections and cleanup resources for peer
  ##
  trace "Dropping peer", peerId
-  let muxers = c.muxed.getOrDefault(peerId)
+  let conns = c.conns.getOrDefault(peerId)
+  for conn in conns:
+    trace  "Removing connection", conn
+    delConn(c, conn)
+
+  var muxers: seq[MuxerHolder]
+  for conn in conns:
+    if conn in c.muxed:
+      muxers.add c.muxed[conn]
+      c.muxed.del(conn)

  for muxer in muxers:
-    await closeMuxer(muxer)
+    await closeMuxerHolder(muxer)
+
+  for conn in conns:
+    await conn.close()
+    trace "Dropped peer", peerId

  trace "Peer dropped", peerId

@@ -419,18 +523,17 @@ proc close*(c: ConnManager) {.async.} =
  ##

  trace "Closing ConnManager"
+  let conns = c.conns
+  c.conns.clear()
+
  let muxed = c.muxed
  c.muxed.clear()

-  let expected = c.expectedConnectionsOverLimit
-  c.expectedConnectionsOverLimit.clear()
+  for _, muxer in muxed:
+    await closeMuxerHolder(muxer)

-  for _, fut in expected:
-    await fut.cancelAndWait()
-
-  for _, muxers in muxed:
-    for mux in muxers:
-      await closeMuxer(mux)
+  for _, conns2 in conns:
+    for conn in conns2:
+      await conn.close()

  trace "Closed ConnManager"
-
--- a/libp2p/crypto/chacha20poly1305.nim
+++ b/libp2p/crypto/chacha20poly1305.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -15,11 +15,14 @@

 # RFC @ https://tools.ietf.org/html/rfc7539

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import bearssl/blockx
 from stew/assign2 import assign
-from stew/ptrops import baseAddr
+from stew/ranges/ptr_arith import baseAddr

 const
  ChaChaPolyKeySize = 32
--- a/libp2p/crypto/crypto.nim
+++ b/libp2p/crypto/crypto.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -8,7 +8,10 @@
 # those terms.

 ## This module implements Public Key and Private Key interface for libp2p.
-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 from strutils import split, strip, cmpIgnoreCase

@@ -65,13 +68,11 @@ when supported(PKScheme.Ed25519):
  import ed25519/ed25519
 when supported(PKScheme.Secp256k1):
  import secp
-when supported(PKScheme.ECDSA):
-  import ecnist

-  # These used to be declared in `crypto` itself
-  export ecnist.ephemeral, ecnist.ECDHEScheme
+# We are still importing `ecnist` because, it is used for SECIO handshake,
+# but it will be impossible to create ECNIST keys or import ECNIST keys.

-import bearssl/rand, bearssl/hash as bhash
+import ecnist, bearssl/rand, bearssl/hash as bhash
 import ../protobuf/minprotobuf, ../vbuffer, ../multihash, ../multicodec
 import nimcrypto/[rijndael, twofish, sha2, hash, hmac]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
@@ -88,6 +89,8 @@ type
    Sha256,
    Sha512

+  ECDHEScheme* = EcCurveKind
+
  PublicKey* = object
    case scheme*: PKScheme
    of PKScheme.RSA:
@@ -455,8 +458,7 @@ proc getBytes*(sig: Signature): seq[byte] =
  ## Return signature ``sig`` in binary form.
  result = sig.data

-template initImpl[T: PrivateKey|PublicKey](
-    key: var T, data: openArray[byte]): bool =
+proc init*[T: PrivateKey|PublicKey](key: var T, data: openArray[byte]): bool =
  ## Initialize private key ``key`` from libp2p's protobuf serialized raw
  ## binary form.
  ##
@@ -469,7 +471,7 @@ template initImpl[T: PrivateKey|PublicKey](
    var pb = initProtoBuffer(@data)
    let r1 = pb.getField(1, id)
    let r2 = pb.getField(2, buffer)
-    if not(r1.get(false) and r2.get(false)):
+    if not(r1.isOk() and r1.get() and r2.isOk() and r2.get()):
      false
    else:
      if cast[int8](id) notin SupportedSchemesInt or len(buffer) <= 0:
@@ -518,14 +520,6 @@ template initImpl[T: PrivateKey|PublicKey](
          else:
            false

-{.push warning[ProveField]:off.}  # https://github.com/nim-lang/Nim/issues/22060
-proc init*(key: var PrivateKey, data: openArray[byte]): bool =
-  initImpl(key, data)
-
-proc init*(key: var PublicKey, data: openArray[byte]): bool =
-  initImpl(key, data)
-{.pop.}
-
 proc init*(sig: var Signature, data: openArray[byte]): bool =
  ## Initialize signature ``sig`` from raw binary form.
  ##
@@ -879,6 +873,34 @@ proc mac*(secret: Secret, id: int): seq[byte] {.inline.} =
  offset += secret.ivsize + secret.keysize
  copyMem(addr result[0], unsafeAddr secret.data[offset], secret.macsize)

+proc ephemeral*(
+    scheme: ECDHEScheme,
+    rng: var HmacDrbgContext): CryptoResult[EcKeyPair] =
+  ## Generate ephemeral keys used to perform ECDHE.
+  var keypair: EcKeyPair
+  if scheme == Secp256r1:
+    keypair = ? EcKeyPair.random(Secp256r1, rng).orError(KeyError)
+  elif scheme == Secp384r1:
+    keypair = ? EcKeyPair.random(Secp384r1, rng).orError(KeyError)
+  elif scheme == Secp521r1:
+    keypair = ? EcKeyPair.random(Secp521r1, rng).orError(KeyError)
+  ok(keypair)
+
+proc ephemeral*(
+    scheme: string, rng: var HmacDrbgContext): CryptoResult[EcKeyPair] =
+  ## Generate ephemeral keys used to perform ECDHE using string encoding.
+  ##
+  ## Currently supported encoding strings are P-256, P-384, P-521, if encoding
+  ## string is not supported P-521 key will be generated.
+  if scheme == "P-256":
+    ephemeral(Secp256r1, rng)
+  elif scheme == "P-384":
+    ephemeral(Secp384r1, rng)
+  elif scheme == "P-521":
+    ephemeral(Secp521r1, rng)
+  else:
+    ephemeral(Secp521r1, rng)
+
 proc getOrder*(remotePubkey, localNonce: openArray[byte],
               localPubkey, remoteNonce: openArray[byte]): CryptoResult[int] =
  ## Compare values and calculate `order` parameter.
@@ -954,8 +976,9 @@ proc decodeProposal*(message: seq[byte], nonce, pubkey: var seq[byte],
  let r4 = pb.getField(4, ciphers)
  let r5 = pb.getField(5, hashes)

-  r1.get(false) and r2.get(false) and r3.get(false) and
-  r4.get(false) and r5.get(false)
+  r1.isOk() and r1.get() and r2.isOk() and r2.get() and
+  r3.isOk() and r3.get() and r4.isOk() and r4.get() and
+  r5.isOk() and r5.get()

 proc createExchange*(epubkey, signature: openArray[byte]): seq[byte] =
  ## Create SecIO exchange message using ephemeral public key ``epubkey`` and
@@ -975,32 +998,32 @@ proc decodeExchange*(message: seq[byte],
  var pb = initProtoBuffer(message)
  let r1 = pb.getField(1, pubkey)
  let r2 = pb.getField(2, signature)
-  r1.get(false) and r2.get(false)
+  r1.isOk() and r1.get() and r2.isOk() and r2.get()

 ## Serialization/Deserialization helpers

 proc write*(vb: var VBuffer, pubkey: PublicKey) {.
-     inline, raises: [ResultError[CryptoError]].} =
+     inline, raises: [Defect, ResultError[CryptoError]].} =
  ## Write PublicKey value ``pubkey`` to buffer ``vb``.
  vb.writeSeq(pubkey.getBytes().tryGet())

 proc write*(vb: var VBuffer, seckey: PrivateKey) {.
-     inline, raises: [ResultError[CryptoError]].} =
+     inline, raises: [Defect, ResultError[CryptoError]].} =
  ## Write PrivateKey value ``seckey`` to buffer ``vb``.
  vb.writeSeq(seckey.getBytes().tryGet())

 proc write*(vb: var VBuffer, sig: PrivateKey) {.
-     inline, raises: [ResultError[CryptoError]].} =
+     inline, raises: [Defect, ResultError[CryptoError]].} =
  ## Write Signature value ``sig`` to buffer ``vb``.
  vb.writeSeq(sig.getBytes().tryGet())

 proc write*[T: PublicKey|PrivateKey](pb: var ProtoBuffer, field: int,
                                     key: T) {.
-     inline, raises: [ResultError[CryptoError]].} =
+     inline, raises: [Defect, ResultError[CryptoError]].} =
  write(pb, field, key.getBytes().tryGet())

 proc write*(pb: var ProtoBuffer, field: int, sig: Signature) {.
-     inline, raises: [].} =
+     inline, raises: [Defect].} =
  write(pb, field, sig.getBytes())

 proc getField*[T: PublicKey|PrivateKey](pb: ProtoBuffer, field: int,
--- a/libp2p/crypto/curve25519.nim
+++ b/libp2p/crypto/curve25519.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022-2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -15,9 +15,12 @@

 # RFC @ https://tools.ietf.org/html/rfc7748

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import bearssl/[ec, rand]
+import bearssl/[ec, rand, hash]
 import stew/results
 from stew/assign2 import assign
 export results
--- a/libp2p/crypto/ecnist.nim
+++ b/libp2p/crypto/ecnist.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -14,7 +14,10 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import bearssl/[ec, rand, hash]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
@@ -22,9 +25,6 @@ import nimcrypto/utils as ncrutils
 import minasn1
 export minasn1.Asn1Error
 import stew/[results, ctops]
-
-import ../utility
-
 export results

 const
@@ -74,7 +74,7 @@ type
  EcResult*[T] = Result[T, EcError]

 const
-  EcSupportedCurvesCint* = @[cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)]
+  EcSupportedCurvesCint* = {cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)}

 proc `-`(x: uint32): uint32 {.inline.} =
  result = (0xFFFF_FFFF'u32 - x) + 1'u32
@@ -243,7 +243,7 @@ proc random*(
  var res = new EcPrivateKey
  if ecKeygen(addr rng.vtable, ecimp,
                addr res.key, addr res.buffer[0],
-                safeConvert[cint](kind)) == 0:
+                cast[cint](kind)) == 0:
    err(EcKeyGenError)
  else:
    ok(res)
@@ -630,11 +630,11 @@ proc init*(key: var EcPrivateKey, data: openArray[byte]): Result[void, Asn1Error
    return err(Asn1Error.Incorrect)

  if oid == Asn1OidSecp256r1:
-    curve = safeConvert[cint](Secp256r1)
+    curve = cast[cint](Secp256r1)
  elif oid == Asn1OidSecp384r1:
-    curve = safeConvert[cint](Secp384r1)
+    curve = cast[cint](Secp384r1)
  elif oid == Asn1OidSecp521r1:
-    curve = safeConvert[cint](Secp521r1)
+    curve = cast[cint](Secp521r1)
  else:
    return err(Asn1Error.Incorrect)

@@ -684,11 +684,11 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
    return err(Asn1Error.Incorrect)

  if oid == Asn1OidSecp256r1:
-    curve = safeConvert[cint](Secp256r1)
+    curve = cast[cint](Secp256r1)
  elif oid == Asn1OidSecp384r1:
-    curve = safeConvert[cint](Secp384r1)
+    curve = cast[cint](Secp384r1)
  elif oid == Asn1OidSecp521r1:
-    curve = safeConvert[cint](Secp521r1)
+    curve = cast[cint](Secp521r1)
  else:
    return err(Asn1Error.Incorrect)

@@ -774,13 +774,13 @@ proc initRaw*(key: var EcPrivateKey, data: openArray[byte]): bool =
  ## Procedure returns ``true`` on success, ``false`` otherwise.
  var curve: cint
  if len(data) == SecKey256Length:
-    curve = safeConvert[cint](Secp256r1)
+    curve = cast[cint](Secp256r1)
    result = true
  elif len(data) == SecKey384Length:
-    curve = safeConvert[cint](Secp384r1)
+    curve = cast[cint](Secp384r1)
    result = true
  elif len(data) == SecKey521Length:
-    curve = safeConvert[cint](Secp521r1)
+    curve = cast[cint](Secp521r1)
    result = true
  if result:
    result = false
@@ -805,13 +805,13 @@ proc initRaw*(pubkey: var EcPublicKey, data: openArray[byte]): bool =
  if len(data) > 0:
    if data[0] == 0x04'u8:
      if len(data) == PubKey256Length:
-        curve = safeConvert[cint](Secp256r1)
+        curve = cast[cint](Secp256r1)
        result = true
      elif len(data) == PubKey384Length:
-        curve = safeConvert[cint](Secp384r1)
+        curve = cast[cint](Secp384r1)
        result = true
      elif len(data) == PubKey521Length:
-        curve = safeConvert[cint](Secp521r1)
+        curve = cast[cint](Secp521r1)
        result = true
  if result:
    result = false
@@ -994,33 +994,3 @@ proc verify*[T: byte|char](sig: EcSignature, message: openArray[T],
    # Clear context with initial value
    kv.init(addr hc.vtable)
    result = (res == 1)
-
-type ECDHEScheme* = EcCurveKind
-
-proc ephemeral*(
-    scheme: ECDHEScheme,
-    rng: var HmacDrbgContext): EcResult[EcKeyPair] =
-  ## Generate ephemeral keys used to perform ECDHE.
-  var keypair: EcKeyPair
-  if scheme == Secp256r1:
-    keypair = ? EcKeyPair.random(Secp256r1, rng)
-  elif scheme == Secp384r1:
-    keypair = ? EcKeyPair.random(Secp384r1, rng)
-  elif scheme == Secp521r1:
-    keypair = ? EcKeyPair.random(Secp521r1, rng)
-  ok(keypair)
-
-proc ephemeral*(
-    scheme: string, rng: var HmacDrbgContext): EcResult[EcKeyPair] =
-  ## Generate ephemeral keys used to perform ECDHE using string encoding.
-  ##
-  ## Currently supported encoding strings are P-256, P-384, P-521, if encoding
-  ## string is not supported P-521 key will be generated.
-  if scheme == "P-256":
-    ephemeral(Secp256r1, rng)
-  elif scheme == "P-384":
-    ephemeral(Secp384r1, rng)
-  elif scheme == "P-521":
-    ephemeral(Secp521r1, rng)
-  else:
-    ephemeral(Secp521r1, rng)
--- a/libp2p/crypto/ed25519/constants.nim
+++ b/libp2p/crypto/ed25519/constants.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
--- a/libp2p/crypto/ed25519/ed25519.nim
+++ b/libp2p/crypto/ed25519/ed25519.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -11,7 +11,10 @@
 ## This code is a port of the public domain, "ref10" implementation of ed25519
 ## from SUPERCOP.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import bearssl/rand
 import constants
@@ -19,9 +22,6 @@ import nimcrypto/[hash, sha2]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
 import nimcrypto/utils as ncrutils
 import stew/[results, ctops]
-
-import ../../utility
-
 export results

 # This workaround needed because of some bugs in Nim Static[T].
@@ -170,15 +170,15 @@ proc feCopy(h: var Fe, f: Fe) =
  h[9] = f9

 proc load_3(inp: openArray[byte]): uint64 =
-  result = safeConvert[uint64](inp[0])
-  result = result or (safeConvert[uint64](inp[1]) shl 8)
-  result = result or (safeConvert[uint64](inp[2]) shl 16)
+  result = cast[uint64](inp[0])
+  result = result or (cast[uint64](inp[1]) shl 8)
+  result = result or (cast[uint64](inp[2]) shl 16)

 proc load_4(inp: openArray[byte]): uint64 =
-  result = safeConvert[uint64](inp[0])
-  result = result or (safeConvert[uint64](inp[1]) shl 8)
-  result = result or (safeConvert[uint64](inp[2]) shl 16)
-  result = result or (safeConvert[uint64](inp[3]) shl 24)
+  result = cast[uint64](inp[0])
+  result = result or (cast[uint64](inp[1]) shl 8)
+  result = result or (cast[uint64](inp[2]) shl 16)
+  result = result or (cast[uint64](inp[3]) shl 24)

 proc feFromBytes(h: var Fe, s: openArray[byte]) =
  var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
@@ -299,106 +299,106 @@ proc feMul(h: var Fe, f, g: Fe) =
  var f5_2 = 2 * f5
  var f7_2 = 2 * f7
  var f9_2 = 2 * f9
-  var f0g0 = safeConvert[int64](f0) * safeConvert[int64](g0)
-  var f0g1 = safeConvert[int64](f0) * safeConvert[int64](g1)
-  var f0g2 = safeConvert[int64](f0) * safeConvert[int64](g2)
-  var f0g3 = safeConvert[int64](f0) * safeConvert[int64](g3)
-  var f0g4 = safeConvert[int64](f0) * safeConvert[int64](g4)
-  var f0g5 = safeConvert[int64](f0) * safeConvert[int64](g5)
-  var f0g6 = safeConvert[int64](f0) * safeConvert[int64](g6)
-  var f0g7 = safeConvert[int64](f0) * safeConvert[int64](g7)
-  var f0g8 = safeConvert[int64](f0) * safeConvert[int64](g8)
-  var f0g9 = safeConvert[int64](f0) * safeConvert[int64](g9)
-  var f1g0 = safeConvert[int64](f1) * safeConvert[int64](g0)
-  var f1g1_2 = safeConvert[int64](f1_2) * safeConvert[int64](g1)
-  var f1g2 = safeConvert[int64](f1) * safeConvert[int64](g2)
-  var f1g3_2 = safeConvert[int64](f1_2) * safeConvert[int64](g3)
-  var f1g4 = safeConvert[int64](f1) * safeConvert[int64](g4)
-  var f1g5_2 = safeConvert[int64](f1_2) * safeConvert[int64](g5)
-  var f1g6 = safeConvert[int64](f1) * safeConvert[int64](g6)
-  var f1g7_2 = safeConvert[int64](f1_2) * safeConvert[int64](g7)
-  var f1g8 = safeConvert[int64](f1) * safeConvert[int64](g8)
-  var f1g9_38 = safeConvert[int64](f1_2) * safeConvert[int64](g9_19)
-  var f2g0 = safeConvert[int64](f2) * safeConvert[int64](g0)
-  var f2g1 = safeConvert[int64](f2) * safeConvert[int64](g1)
-  var f2g2 = safeConvert[int64](f2) * safeConvert[int64](g2)
-  var f2g3 = safeConvert[int64](f2) * safeConvert[int64](g3)
-  var f2g4 = safeConvert[int64](f2) * safeConvert[int64](g4)
-  var f2g5 = safeConvert[int64](f2) * safeConvert[int64](g5)
-  var f2g6 = safeConvert[int64](f2) * safeConvert[int64](g6)
-  var f2g7 = safeConvert[int64](f2) * safeConvert[int64](g7)
-  var f2g8_19 = safeConvert[int64](f2) * safeConvert[int64](g8_19)
-  var f2g9_19 = safeConvert[int64](f2) * safeConvert[int64](g9_19)
-  var f3g0 = safeConvert[int64](f3) * safeConvert[int64](g0)
-  var f3g1_2  = safeConvert[int64](f3_2) * safeConvert[int64](g1)
-  var f3g2 = safeConvert[int64](f3) * safeConvert[int64](g2)
-  var f3g3_2  = safeConvert[int64](f3_2) * safeConvert[int64](g3)
-  var f3g4 = safeConvert[int64](f3) * safeConvert[int64](g4)
-  var f3g5_2  = safeConvert[int64](f3_2) * safeConvert[int64](g5)
-  var f3g6 = safeConvert[int64](f3) * safeConvert[int64](g6)
-  var f3g7_38 = safeConvert[int64](f3_2) * safeConvert[int64](g7_19)
-  var f3g8_19 = safeConvert[int64](f3) * safeConvert[int64](g8_19)
-  var f3g9_38 = safeConvert[int64](f3_2) * safeConvert[int64](g9_19)
-  var f4g0 = safeConvert[int64](f4) * safeConvert[int64](g0)
-  var f4g1 = safeConvert[int64](f4) * safeConvert[int64](g1)
-  var f4g2 = safeConvert[int64](f4) * safeConvert[int64](g2)
-  var f4g3 = safeConvert[int64](f4) * safeConvert[int64](g3)
-  var f4g4 = safeConvert[int64](f4) * safeConvert[int64](g4)
-  var f4g5 = safeConvert[int64](f4) * safeConvert[int64](g5)
-  var f4g6_19 = safeConvert[int64](f4) * safeConvert[int64](g6_19)
-  var f4g7_19 = safeConvert[int64](f4) * safeConvert[int64](g7_19)
-  var f4g8_19 = safeConvert[int64](f4) * safeConvert[int64](g8_19)
-  var f4g9_19 = safeConvert[int64](f4) * safeConvert[int64](g9_19)
-  var f5g0 = safeConvert[int64](f5) * safeConvert[int64](g0)
-  var f5g1_2 = safeConvert[int64](f5_2) * safeConvert[int64](g1)
-  var f5g2 = safeConvert[int64](f5) * safeConvert[int64](g2)
-  var f5g3_2 = safeConvert[int64](f5_2) * safeConvert[int64](g3)
-  var f5g4 = safeConvert[int64](f5) * safeConvert[int64](g4)
-  var f5g5_38 = safeConvert[int64](f5_2) * safeConvert[int64](g5_19)
-  var f5g6_19 = safeConvert[int64](f5) * safeConvert[int64](g6_19)
-  var f5g7_38 = safeConvert[int64](f5_2) * safeConvert[int64](g7_19)
-  var f5g8_19 = safeConvert[int64](f5) * safeConvert[int64](g8_19)
-  var f5g9_38 = safeConvert[int64](f5_2) * safeConvert[int64](g9_19)
-  var f6g0 = safeConvert[int64](f6) * safeConvert[int64](g0)
-  var f6g1 = safeConvert[int64](f6) * safeConvert[int64](g1)
-  var f6g2 = safeConvert[int64](f6) * safeConvert[int64](g2)
-  var f6g3 = safeConvert[int64](f6) * safeConvert[int64](g3)
-  var f6g4_19 = safeConvert[int64](f6) * safeConvert[int64](g4_19)
-  var f6g5_19 = safeConvert[int64](f6) * safeConvert[int64](g5_19)
-  var f6g6_19 = safeConvert[int64](f6) * safeConvert[int64](g6_19)
-  var f6g7_19 = safeConvert[int64](f6) * safeConvert[int64](g7_19)
-  var f6g8_19 = safeConvert[int64](f6) * safeConvert[int64](g8_19)
-  var f6g9_19 = safeConvert[int64](f6) * safeConvert[int64](g9_19)
-  var f7g0 = safeConvert[int64](f7) * safeConvert[int64](g0)
-  var f7g1_2 = safeConvert[int64](f7_2) * safeConvert[int64](g1)
-  var f7g2 = safeConvert[int64](f7) * safeConvert[int64](g2)
-  var f7g3_38 = safeConvert[int64](f7_2) * safeConvert[int64](g3_19)
-  var f7g4_19 = safeConvert[int64](f7) * safeConvert[int64](g4_19)
-  var f7g5_38 = safeConvert[int64](f7_2) * safeConvert[int64](g5_19)
-  var f7g6_19 = safeConvert[int64](f7) * safeConvert[int64](g6_19)
-  var f7g7_38 = safeConvert[int64](f7_2) * safeConvert[int64](g7_19)
-  var f7g8_19 = safeConvert[int64](f7) * safeConvert[int64](g8_19)
-  var f7g9_38 = safeConvert[int64](f7_2) * safeConvert[int64](g9_19)
-  var f8g0 = safeConvert[int64](f8) * safeConvert[int64](g0)
-  var f8g1 = safeConvert[int64](f8) * safeConvert[int64](g1)
-  var f8g2_19 = safeConvert[int64](f8) * safeConvert[int64](g2_19)
-  var f8g3_19 = safeConvert[int64](f8) * safeConvert[int64](g3_19)
-  var f8g4_19 = safeConvert[int64](f8) * safeConvert[int64](g4_19)
-  var f8g5_19 = safeConvert[int64](f8) * safeConvert[int64](g5_19)
-  var f8g6_19 = safeConvert[int64](f8) * safeConvert[int64](g6_19)
-  var f8g7_19 = safeConvert[int64](f8) * safeConvert[int64](g7_19)
-  var f8g8_19 = safeConvert[int64](f8) * safeConvert[int64](g8_19)
-  var f8g9_19 = safeConvert[int64](f8) * safeConvert[int64](g9_19)
-  var f9g0 = safeConvert[int64](f9) * safeConvert[int64](g0)
-  var f9g1_38 = safeConvert[int64](f9_2) * safeConvert[int64](g1_19)
-  var f9g2_19 = safeConvert[int64](f9) * safeConvert[int64](g2_19)
-  var f9g3_38 = safeConvert[int64](f9_2) * safeConvert[int64](g3_19)
-  var f9g4_19 = safeConvert[int64](f9) * safeConvert[int64](g4_19)
-  var f9g5_38 = safeConvert[int64](f9_2) * safeConvert[int64](g5_19)
-  var f9g6_19 = safeConvert[int64](f9) * safeConvert[int64](g6_19)
-  var f9g7_38 = safeConvert[int64](f9_2) * safeConvert[int64](g7_19)
-  var f9g8_19 = safeConvert[int64](f9) * safeConvert[int64](g8_19)
-  var f9g9_38 = safeConvert[int64](f9_2) * safeConvert[int64](g9_19)
+  var f0g0 = cast[int64](f0) * cast[int64](g0)
+  var f0g1 = cast[int64](f0) * cast[int64](g1)
+  var f0g2 = cast[int64](f0) * cast[int64](g2)
+  var f0g3 = cast[int64](f0) * cast[int64](g3)
+  var f0g4 = cast[int64](f0) * cast[int64](g4)
+  var f0g5 = cast[int64](f0) * cast[int64](g5)
+  var f0g6 = cast[int64](f0) * cast[int64](g6)
+  var f0g7 = cast[int64](f0) * cast[int64](g7)
+  var f0g8 = cast[int64](f0) * cast[int64](g8)
+  var f0g9 = cast[int64](f0) * cast[int64](g9)
+  var f1g0 = cast[int64](f1) * cast[int64](g0)
+  var f1g1_2 = cast[int64](f1_2) * cast[int64](g1)
+  var f1g2 = cast[int64](f1) * cast[int64](g2)
+  var f1g3_2 = cast[int64](f1_2) * cast[int64](g3)
+  var f1g4 = cast[int64](f1) * cast[int64](g4)
+  var f1g5_2 = cast[int64](f1_2) * cast[int64](g5)
+  var f1g6 = cast[int64](f1) * cast[int64](g6)
+  var f1g7_2 = cast[int64](f1_2) * cast[int64](g7)
+  var f1g8 = cast[int64](f1) * cast[int64](g8)
+  var f1g9_38 = cast[int64](f1_2) * cast[int64](g9_19)
+  var f2g0 = cast[int64](f2) * cast[int64](g0)
+  var f2g1 = cast[int64](f2) * cast[int64](g1)
+  var f2g2 = cast[int64](f2) * cast[int64](g2)
+  var f2g3 = cast[int64](f2) * cast[int64](g3)
+  var f2g4 = cast[int64](f2) * cast[int64](g4)
+  var f2g5 = cast[int64](f2) * cast[int64](g5)
+  var f2g6 = cast[int64](f2) * cast[int64](g6)
+  var f2g7 = cast[int64](f2) * cast[int64](g7)
+  var f2g8_19 = cast[int64](f2) * cast[int64](g8_19)
+  var f2g9_19 = cast[int64](f2) * cast[int64](g9_19)
+  var f3g0 = cast[int64](f3) * cast[int64](g0)
+  var f3g1_2  = cast[int64](f3_2) * cast[int64](g1)
+  var f3g2 = cast[int64](f3) * cast[int64](g2)
+  var f3g3_2  = cast[int64](f3_2) * cast[int64](g3)
+  var f3g4 = cast[int64](f3) * cast[int64](g4)
+  var f3g5_2  = cast[int64](f3_2) * cast[int64](g5)
+  var f3g6 = cast[int64](f3) * cast[int64](g6)
+  var f3g7_38 = cast[int64](f3_2) * cast[int64](g7_19)
+  var f3g8_19 = cast[int64](f3) * cast[int64](g8_19)
+  var f3g9_38 = cast[int64](f3_2) * cast[int64](g9_19)
+  var f4g0 = cast[int64](f4) * cast[int64](g0)
+  var f4g1 = cast[int64](f4) * cast[int64](g1)
+  var f4g2 = cast[int64](f4) * cast[int64](g2)
+  var f4g3 = cast[int64](f4) * cast[int64](g3)
+  var f4g4 = cast[int64](f4) * cast[int64](g4)
+  var f4g5 = cast[int64](f4) * cast[int64](g5)
+  var f4g6_19 = cast[int64](f4) * cast[int64](g6_19)
+  var f4g7_19 = cast[int64](f4) * cast[int64](g7_19)
+  var f4g8_19 = cast[int64](f4) * cast[int64](g8_19)
+  var f4g9_19 = cast[int64](f4) * cast[int64](g9_19)
+  var f5g0 = cast[int64](f5) * cast[int64](g0)
+  var f5g1_2 = cast[int64](f5_2) * cast[int64](g1)
+  var f5g2 = cast[int64](f5) * cast[int64](g2)
+  var f5g3_2 = cast[int64](f5_2) * cast[int64](g3)
+  var f5g4 = cast[int64](f5) * cast[int64](g4)
+  var f5g5_38 = cast[int64](f5_2) * cast[int64](g5_19)
+  var f5g6_19 = cast[int64](f5) * cast[int64](g6_19)
+  var f5g7_38 = cast[int64](f5_2) * cast[int64](g7_19)
+  var f5g8_19 = cast[int64](f5) * cast[int64](g8_19)
+  var f5g9_38 = cast[int64](f5_2) * cast[int64](g9_19)
+  var f6g0 = cast[int64](f6) * cast[int64](g0)
+  var f6g1 = cast[int64](f6) * cast[int64](g1)
+  var f6g2 = cast[int64](f6) * cast[int64](g2)
+  var f6g3 = cast[int64](f6) * cast[int64](g3)
+  var f6g4_19 = cast[int64](f6) * cast[int64](g4_19)
+  var f6g5_19 = cast[int64](f6) * cast[int64](g5_19)
+  var f6g6_19 = cast[int64](f6) * cast[int64](g6_19)
+  var f6g7_19 = cast[int64](f6) * cast[int64](g7_19)
+  var f6g8_19 = cast[int64](f6) * cast[int64](g8_19)
+  var f6g9_19 = cast[int64](f6) * cast[int64](g9_19)
+  var f7g0 = cast[int64](f7) * cast[int64](g0)
+  var f7g1_2 = cast[int64](f7_2) * cast[int64](g1)
+  var f7g2 = cast[int64](f7) * cast[int64](g2)
+  var f7g3_38 = cast[int64](f7_2) * cast[int64](g3_19)
+  var f7g4_19 = cast[int64](f7) * cast[int64](g4_19)
+  var f7g5_38 = cast[int64](f7_2) * cast[int64](g5_19)
+  var f7g6_19 = cast[int64](f7) * cast[int64](g6_19)
+  var f7g7_38 = cast[int64](f7_2) * cast[int64](g7_19)
+  var f7g8_19 = cast[int64](f7) * cast[int64](g8_19)
+  var f7g9_38 = cast[int64](f7_2) * cast[int64](g9_19)
+  var f8g0 = cast[int64](f8) * cast[int64](g0)
+  var f8g1 = cast[int64](f8) * cast[int64](g1)
+  var f8g2_19 = cast[int64](f8) * cast[int64](g2_19)
+  var f8g3_19 = cast[int64](f8) * cast[int64](g3_19)
+  var f8g4_19 = cast[int64](f8) * cast[int64](g4_19)
+  var f8g5_19 = cast[int64](f8) * cast[int64](g5_19)
+  var f8g6_19 = cast[int64](f8) * cast[int64](g6_19)
+  var f8g7_19 = cast[int64](f8) * cast[int64](g7_19)
+  var f8g8_19 = cast[int64](f8) * cast[int64](g8_19)
+  var f8g9_19 = cast[int64](f8) * cast[int64](g9_19)
+  var f9g0 = cast[int64](f9) * cast[int64](g0)
+  var f9g1_38 = cast[int64](f9_2) * cast[int64](g1_19)
+  var f9g2_19 = cast[int64](f9) * cast[int64](g2_19)
+  var f9g3_38 = cast[int64](f9_2) * cast[int64](g3_19)
+  var f9g4_19 = cast[int64](f9) * cast[int64](g4_19)
+  var f9g5_38 = cast[int64](f9_2) * cast[int64](g5_19)
+  var f9g6_19 = cast[int64](f9) * cast[int64](g6_19)
+  var f9g7_38 = cast[int64](f9_2) * cast[int64](g7_19)
+  var f9g8_19 = cast[int64](f9) * cast[int64](g8_19)
+  var f9g9_38 = cast[int64](f9_2) * cast[int64](g9_19)
  var
    c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
    h0: int64 = f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 +
@@ -493,7 +493,7 @@ proc verify32(x: openArray[byte], y: openArray[byte]): int32 =
 proc feIsNegative(f: Fe): int32 =
  var s: array[32, byte]
  feToBytes(s, f)
-  result = safeConvert[int32](s[0] and 1'u8)
+  result = cast[int32](s[0] and 1'u8)

 proc feIsNonZero(f: Fe): int32 =
  var s: array[32, byte]
@@ -516,61 +516,61 @@ proc feSq(h: var Fe, f: Fe) =
  var f7_38: int32 = 38 * f7
  var f8_19: int32 = 19 * f8
  var f9_38: int32 = 38 * f9
-  var f0f0: int64 = f0 * safeConvert[int64](f0)
-  var f0f1_2: int64 = f0_2 * safeConvert[int64](f1)
-  var f0f2_2: int64 = f0_2 * safeConvert[int64](f2)
-  var f0f3_2: int64 = f0_2 * safeConvert[int64](f3)
-  var f0f4_2: int64 = f0_2 * safeConvert[int64](f4)
-  var f0f5_2: int64 = f0_2 * safeConvert[int64](f5)
-  var f0f6_2: int64 = f0_2 * safeConvert[int64](f6)
-  var f0f7_2: int64 = f0_2 * safeConvert[int64](f7)
-  var f0f8_2: int64 = f0_2 * safeConvert[int64](f8)
-  var f0f9_2: int64 = f0_2 * safeConvert[int64](f9)
-  var f1f1_2: int64 = f1_2 * safeConvert[int64](f1)
-  var f1f2_2: int64 = f1_2 * safeConvert[int64](f2)
-  var f1f3_4: int64 = f1_2 * safeConvert[int64](f3_2)
-  var f1f4_2: int64 = f1_2 * safeConvert[int64](f4)
-  var f1f5_4: int64 = f1_2 * safeConvert[int64](f5_2)
-  var f1f6_2: int64 = f1_2 * safeConvert[int64](f6)
-  var f1f7_4: int64 = f1_2 * safeConvert[int64](f7_2)
-  var f1f8_2: int64 = f1_2 * safeConvert[int64](f8)
-  var f1f9_76: int64 = f1_2 * safeConvert[int64](f9_38)
-  var f2f2: int64 = f2 * safeConvert[int64](f2)
-  var f2f3_2: int64 = f2_2 * safeConvert[int64](f3)
-  var f2f4_2: int64 = f2_2 * safeConvert[int64](f4)
-  var f2f5_2: int64 = f2_2 * safeConvert[int64](f5)
-  var f2f6_2: int64 = f2_2 * safeConvert[int64](f6)
-  var f2f7_2: int64 = f2_2 * safeConvert[int64](f7)
-  var f2f8_38: int64 = f2_2 * safeConvert[int64](f8_19)
-  var f2f9_38: int64 = f2 * safeConvert[int64](f9_38)
-  var f3f3_2: int64 = f3_2 * safeConvert[int64](f3)
-  var f3f4_2: int64 = f3_2 * safeConvert[int64](f4)
-  var f3f5_4: int64 = f3_2 * safeConvert[int64](f5_2)
-  var f3f6_2: int64 = f3_2 * safeConvert[int64](f6)
-  var f3f7_76: int64 = f3_2 * safeConvert[int64](f7_38)
-  var f3f8_38: int64 = f3_2 * safeConvert[int64](f8_19)
-  var f3f9_76: int64 = f3_2 * safeConvert[int64](f9_38)
-  var f4f4: int64 = f4 * safeConvert[int64](f4)
-  var f4f5_2: int64 = f4_2 * safeConvert[int64](f5)
-  var f4f6_38: int64 = f4_2 * safeConvert[int64](f6_19)
-  var f4f7_38: int64 = f4 * safeConvert[int64](f7_38)
-  var f4f8_38: int64 = f4_2 * safeConvert[int64](f8_19)
-  var f4f9_38: int64 = f4 * safeConvert[int64](f9_38)
-  var f5f5_38: int64 = f5 * safeConvert[int64](f5_38)
-  var f5f6_38: int64 = f5_2 * safeConvert[int64](f6_19)
-  var f5f7_76: int64 = f5_2 * safeConvert[int64](f7_38)
-  var f5f8_38: int64 = f5_2 * safeConvert[int64](f8_19)
-  var f5f9_76: int64 = f5_2 * safeConvert[int64](f9_38)
-  var f6f6_19: int64 = f6 * safeConvert[int64](f6_19)
-  var f6f7_38: int64 = f6 * safeConvert[int64](f7_38)
-  var f6f8_38: int64 = f6_2 * safeConvert[int64](f8_19)
-  var f6f9_38: int64 = f6 * safeConvert[int64](f9_38)
-  var f7f7_38: int64 = f7 * safeConvert[int64](f7_38)
-  var f7f8_38: int64 = f7_2 * safeConvert[int64](f8_19)
-  var f7f9_76: int64 = f7_2 * safeConvert[int64](f9_38)
-  var f8f8_19: int64 = f8 * safeConvert[int64](f8_19)
-  var f8f9_38: int64 = f8 * safeConvert[int64](f9_38)
-  var f9f9_38: int64 = f9 * safeConvert[int64](f9_38)
+  var f0f0: int64 = f0 * cast[int64](f0)
+  var f0f1_2: int64 = f0_2 * cast[int64](f1)
+  var f0f2_2: int64 = f0_2 * cast[int64](f2)
+  var f0f3_2: int64 = f0_2 * cast[int64](f3)
+  var f0f4_2: int64 = f0_2 * cast[int64](f4)
+  var f0f5_2: int64 = f0_2 * cast[int64](f5)
+  var f0f6_2: int64 = f0_2 * cast[int64](f6)
+  var f0f7_2: int64 = f0_2 * cast[int64](f7)
+  var f0f8_2: int64 = f0_2 * cast[int64](f8)
+  var f0f9_2: int64 = f0_2 * cast[int64](f9)
+  var f1f1_2: int64 = f1_2 * cast[int64](f1)
+  var f1f2_2: int64 = f1_2 * cast[int64](f2)
+  var f1f3_4: int64 = f1_2 * cast[int64](f3_2)
+  var f1f4_2: int64 = f1_2 * cast[int64](f4)
+  var f1f5_4: int64 = f1_2 * cast[int64](f5_2)
+  var f1f6_2: int64 = f1_2 * cast[int64](f6)
+  var f1f7_4: int64 = f1_2 * cast[int64](f7_2)
+  var f1f8_2: int64 = f1_2 * cast[int64](f8)
+  var f1f9_76: int64 = f1_2 * cast[int64](f9_38)
+  var f2f2: int64 = f2 * cast[int64](f2)
+  var f2f3_2: int64 = f2_2 * cast[int64](f3)
+  var f2f4_2: int64 = f2_2 * cast[int64](f4)
+  var f2f5_2: int64 = f2_2 * cast[int64](f5)
+  var f2f6_2: int64 = f2_2 * cast[int64](f6)
+  var f2f7_2: int64 = f2_2 * cast[int64](f7)
+  var f2f8_38: int64 = f2_2 * cast[int64](f8_19)
+  var f2f9_38: int64 = f2 * cast[int64](f9_38)
+  var f3f3_2: int64 = f3_2 * cast[int64](f3)
+  var f3f4_2: int64 = f3_2 * cast[int64](f4)
+  var f3f5_4: int64 = f3_2 * cast[int64](f5_2)
+  var f3f6_2: int64 = f3_2 * cast[int64](f6)
+  var f3f7_76: int64 = f3_2 * cast[int64](f7_38)
+  var f3f8_38: int64 = f3_2 * cast[int64](f8_19)
+  var f3f9_76: int64 = f3_2 * cast[int64](f9_38)
+  var f4f4: int64 = f4 * cast[int64](f4)
+  var f4f5_2: int64 = f4_2 * cast[int64](f5)
+  var f4f6_38: int64 = f4_2 * cast[int64](f6_19)
+  var f4f7_38: int64 = f4 * cast[int64](f7_38)
+  var f4f8_38: int64 = f4_2 * cast[int64](f8_19)
+  var f4f9_38: int64 = f4 * cast[int64](f9_38)
+  var f5f5_38: int64 = f5 * cast[int64](f5_38)
+  var f5f6_38: int64 = f5_2 * cast[int64](f6_19)
+  var f5f7_76: int64 = f5_2 * cast[int64](f7_38)
+  var f5f8_38: int64 = f5_2 * cast[int64](f8_19)
+  var f5f9_76: int64 = f5_2 * cast[int64](f9_38)
+  var f6f6_19: int64 = f6 * cast[int64](f6_19)
+  var f6f7_38: int64 = f6 * cast[int64](f7_38)
+  var f6f8_38: int64 = f6_2 * cast[int64](f8_19)
+  var f6f9_38: int64 = f6 * cast[int64](f9_38)
+  var f7f7_38: int64 = f7 * cast[int64](f7_38)
+  var f7f8_38: int64 = f7_2 * cast[int64](f8_19)
+  var f7f9_76: int64 = f7_2 * cast[int64](f9_38)
+  var f8f8_19: int64 = f8 * cast[int64](f8_19)
+  var f8f9_38: int64 = f8 * cast[int64](f9_38)
+  var f9f9_38: int64 = f9 * cast[int64](f9_38)
  var h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
  var h1: int64 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
  var h2: int64 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
@@ -623,61 +623,61 @@ proc feSq2(h: var Fe, f: Fe) =
  var f7_38 = 38 * f7
  var f8_19 = 19 * f8
  var f9_38 = 38 * f9
-  var f0f0 = safeConvert[int64](f0) * safeConvert[int64](f0)
-  var f0f1_2 = safeConvert[int64](f0_2) * safeConvert[int64](f1)
-  var f0f2_2 = safeConvert[int64](f0_2) * safeConvert[int64](f2)
-  var f0f3_2 = safeConvert[int64](f0_2) * safeConvert[int64](f3)
-  var f0f4_2 = safeConvert[int64](f0_2) * safeConvert[int64](f4)
-  var f0f5_2 = safeConvert[int64](f0_2) * safeConvert[int64](f5)
-  var f0f6_2 = safeConvert[int64](f0_2) * safeConvert[int64](f6)
-  var f0f7_2 = safeConvert[int64](f0_2) * safeConvert[int64](f7)
-  var f0f8_2 = safeConvert[int64](f0_2) * safeConvert[int64](f8)
-  var f0f9_2 = safeConvert[int64](f0_2) * safeConvert[int64](f9)
-  var f1f1_2 = safeConvert[int64](f1_2) * safeConvert[int64](f1)
-  var f1f2_2 = safeConvert[int64](f1_2) * safeConvert[int64](f2)
-  var f1f3_4 = safeConvert[int64](f1_2) * safeConvert[int64](f3_2)
-  var f1f4_2 = safeConvert[int64](f1_2) * safeConvert[int64](f4)
-  var f1f5_4 = safeConvert[int64](f1_2) * safeConvert[int64](f5_2)
-  var f1f6_2 = safeConvert[int64](f1_2) * safeConvert[int64](f6)
-  var f1f7_4 = safeConvert[int64](f1_2) * safeConvert[int64](f7_2)
-  var f1f8_2 = safeConvert[int64](f1_2) * safeConvert[int64](f8)
-  var f1f9_76 = safeConvert[int64](f1_2) * safeConvert[int64](f9_38)
-  var f2f2 = safeConvert[int64](f2) * safeConvert[int64](f2)
-  var f2f3_2 = safeConvert[int64](f2_2) * safeConvert[int64](f3)
-  var f2f4_2 = safeConvert[int64](f2_2) * safeConvert[int64](f4)
-  var f2f5_2 = safeConvert[int64](f2_2) * safeConvert[int64](f5)
-  var f2f6_2 = safeConvert[int64](f2_2) * safeConvert[int64](f6)
-  var f2f7_2 = safeConvert[int64](f2_2) * safeConvert[int64](f7)
-  var f2f8_38 = safeConvert[int64](f2_2) * safeConvert[int64](f8_19)
-  var f2f9_38 = safeConvert[int64](f2) * safeConvert[int64](f9_38)
-  var f3f3_2 = safeConvert[int64](f3_2) * safeConvert[int64](f3)
-  var f3f4_2 = safeConvert[int64](f3_2) * safeConvert[int64](f4)
-  var f3f5_4 = safeConvert[int64](f3_2) * safeConvert[int64](f5_2)
-  var f3f6_2 = safeConvert[int64](f3_2) * safeConvert[int64](f6)
-  var f3f7_76 = safeConvert[int64](f3_2) * safeConvert[int64](f7_38)
-  var f3f8_38 = safeConvert[int64](f3_2) * safeConvert[int64](f8_19)
-  var f3f9_76 = safeConvert[int64](f3_2) * safeConvert[int64](f9_38)
-  var f4f4 = safeConvert[int64](f4) * safeConvert[int64](f4)
-  var f4f5_2 = safeConvert[int64](f4_2) * safeConvert[int64](f5)
-  var f4f6_38 = safeConvert[int64](f4_2) * safeConvert[int64](f6_19)
-  var f4f7_38 = safeConvert[int64](f4) * safeConvert[int64](f7_38)
-  var f4f8_38 = safeConvert[int64](f4_2) * safeConvert[int64](f8_19)
-  var f4f9_38 = safeConvert[int64](f4) * safeConvert[int64](f9_38)
-  var f5f5_38 = safeConvert[int64](f5) * safeConvert[int64](f5_38)
-  var f5f6_38 = safeConvert[int64](f5_2) * safeConvert[int64](f6_19)
-  var f5f7_76 = safeConvert[int64](f5_2) * safeConvert[int64](f7_38)
-  var f5f8_38 = safeConvert[int64](f5_2) * safeConvert[int64](f8_19)
-  var f5f9_76 = safeConvert[int64](f5_2) * safeConvert[int64](f9_38)
-  var f6f6_19 = safeConvert[int64](f6) * safeConvert[int64](f6_19)
-  var f6f7_38 = safeConvert[int64](f6) * safeConvert[int64](f7_38)
-  var f6f8_38 = safeConvert[int64](f6_2) * safeConvert[int64](f8_19)
-  var f6f9_38 = safeConvert[int64](f6) * safeConvert[int64](f9_38)
-  var f7f7_38 = safeConvert[int64](f7) * safeConvert[int64](f7_38)
-  var f7f8_38 = safeConvert[int64](f7_2) * safeConvert[int64](f8_19)
-  var f7f9_76 = safeConvert[int64](f7_2) * safeConvert[int64](f9_38)
-  var f8f8_19 = safeConvert[int64](f8) * safeConvert[int64](f8_19)
-  var f8f9_38 = safeConvert[int64](f8) * safeConvert[int64](f9_38)
-  var f9f9_38 = safeConvert[int64](f9) * safeConvert[int64](f9_38)
+  var f0f0 = cast[int64](f0) * cast[int64](f0)
+  var f0f1_2 = cast[int64](f0_2) * cast[int64](f1)
+  var f0f2_2 = cast[int64](f0_2) * cast[int64](f2)
+  var f0f3_2 = cast[int64](f0_2) * cast[int64](f3)
+  var f0f4_2 = cast[int64](f0_2) * cast[int64](f4)
+  var f0f5_2 = cast[int64](f0_2) * cast[int64](f5)
+  var f0f6_2 = cast[int64](f0_2) * cast[int64](f6)
+  var f0f7_2 = cast[int64](f0_2) * cast[int64](f7)
+  var f0f8_2 = cast[int64](f0_2) * cast[int64](f8)
+  var f0f9_2 = cast[int64](f0_2) * cast[int64](f9)
+  var f1f1_2 = cast[int64](f1_2) * cast[int64](f1)
+  var f1f2_2 = cast[int64](f1_2) * cast[int64](f2)
+  var f1f3_4 = cast[int64](f1_2) * cast[int64](f3_2)
+  var f1f4_2 = cast[int64](f1_2) * cast[int64](f4)
+  var f1f5_4 = cast[int64](f1_2) * cast[int64](f5_2)
+  var f1f6_2 = cast[int64](f1_2) * cast[int64](f6)
+  var f1f7_4 = cast[int64](f1_2) * cast[int64](f7_2)
+  var f1f8_2 = cast[int64](f1_2) * cast[int64](f8)
+  var f1f9_76 = cast[int64](f1_2) * cast[int64](f9_38)
+  var f2f2 = cast[int64](f2) * cast[int64](f2)
+  var f2f3_2 = cast[int64](f2_2) * cast[int64](f3)
+  var f2f4_2 = cast[int64](f2_2) * cast[int64](f4)
+  var f2f5_2 = cast[int64](f2_2) * cast[int64](f5)
+  var f2f6_2 = cast[int64](f2_2) * cast[int64](f6)
+  var f2f7_2 = cast[int64](f2_2) * cast[int64](f7)
+  var f2f8_38 = cast[int64](f2_2) * cast[int64](f8_19)
+  var f2f9_38 = cast[int64](f2) * cast[int64](f9_38)
+  var f3f3_2 = cast[int64](f3_2) * cast[int64](f3)
+  var f3f4_2 = cast[int64](f3_2) * cast[int64](f4)
+  var f3f5_4 = cast[int64](f3_2) * cast[int64](f5_2)
+  var f3f6_2 = cast[int64](f3_2) * cast[int64](f6)
+  var f3f7_76 = cast[int64](f3_2) * cast[int64](f7_38)
+  var f3f8_38 = cast[int64](f3_2) * cast[int64](f8_19)
+  var f3f9_76 = cast[int64](f3_2) * cast[int64](f9_38)
+  var f4f4 = cast[int64](f4) * cast[int64](f4)
+  var f4f5_2 = cast[int64](f4_2) * cast[int64](f5)
+  var f4f6_38 = cast[int64](f4_2) * cast[int64](f6_19)
+  var f4f7_38 = cast[int64](f4) * cast[int64](f7_38)
+  var f4f8_38 = cast[int64](f4_2) * cast[int64](f8_19)
+  var f4f9_38 = cast[int64](f4) * cast[int64](f9_38)
+  var f5f5_38 = cast[int64](f5) * cast[int64](f5_38)
+  var f5f6_38 = cast[int64](f5_2) * cast[int64](f6_19)
+  var f5f7_76 = cast[int64](f5_2) * cast[int64](f7_38)
+  var f5f8_38 = cast[int64](f5_2) * cast[int64](f8_19)
+  var f5f9_76 = cast[int64](f5_2) * cast[int64](f9_38)
+  var f6f6_19 = cast[int64](f6) * cast[int64](f6_19)
+  var f6f7_38 = cast[int64](f6) * cast[int64](f7_38)
+  var f6f8_38 = cast[int64](f6_2) * cast[int64](f8_19)
+  var f6f9_38 = cast[int64](f6) * cast[int64](f9_38)
+  var f7f7_38 = cast[int64](f7) * cast[int64](f7_38)
+  var f7f8_38 = cast[int64](f7_2) * cast[int64](f8_19)
+  var f7f9_76 = cast[int64](f7_2) * cast[int64](f9_38)
+  var f8f8_19 = cast[int64](f8) * cast[int64](f8_19)
+  var f8f9_38 = cast[int64](f8) * cast[int64](f9_38)
+  var f9f9_38 = cast[int64](f9) * cast[int64](f9_38)
  var
    c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
    h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
@@ -834,7 +834,7 @@ proc geFromBytesNegateVartime(h: var GeP3, s: openArray[byte]): int32 =
      return -1;
    feMul(h.x, h.x, SqrTm1)

-  if feIsNegative(h.x) == safeConvert[int32](s[31] shr 7):
+  if feIsNegative(h.x) == cast[int32](s[31] shr 7):
    feNeg(h.x, h.x)

  feMul(h.t, h.x, h.y)
@@ -956,14 +956,14 @@ proc equal(b, c: int8): byte =
  var ub = cast[byte](b)
  var uc = cast[byte](c)
  var x = ub xor uc
-  var y = safeConvert[uint32](x)
+  var y = cast[uint32](x)
  y = y - 1
  y = y shr 31
  result = cast[byte](y)

 proc negative(b: int8): byte =
-  var x = cast[uint8](b)
-  x = x shr 7
+  var x = cast[uint64](b)
+  x = x shr 63
  result = cast[byte](x)

 proc cmov(t: var GePrecomp, u: GePrecomp, b: byte) =
--- a/libp2p/crypto/hkdf.nim
+++ b/libp2p/crypto/hkdf.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,10 +9,13 @@

 # https://tools.ietf.org/html/rfc5869

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import nimcrypto
-import bearssl/[kdf, hash]
+import bearssl/[kdf, rand, hash]

 type HkdfResult*[len: static int] = array[len, byte]

--- a/libp2p/crypto/minasn1.nim
+++ b/libp2p/crypto/minasn1.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,13 +9,15 @@

 ## This module implements minimal ASN.1 encoding/decoding primitives.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import stew/[endians2, results, ctops]
 export results
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
 import nimcrypto/utils as ncrutils
-import ../utility

 type
  Asn1Error* {.pure.} = enum
@@ -117,7 +119,7 @@ template toOpenArray*(af: Asn1Field): untyped =
 template isEmpty*(ab: Asn1Buffer): bool =
  ab.offset >= len(ab.buffer)

-template isEnough*(ab: Asn1Buffer, length: int64): bool =
+template isEnough*(ab: Asn1Buffer, length: int): bool =
  len(ab.buffer) >= ab.offset + length

 proc len*[T: Asn1Buffer|Asn1Composite](abc: T): int {.inline.} =
@@ -342,6 +344,32 @@ proc asn1EncodeTag[T: SomeUnsignedInt](dest: var openArray[byte],
      dest[k - 1] = dest[k - 1] and 0x7F'u8
    res

+proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[int]): int =
+  ## Encode array of integers ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and
+  ## return number of bytes (octets) used.
+  ##
+  ## If length of ``dest`` is less then number of required bytes to encode
+  ## ``value``, then result of encoding will not be stored in ``dest``
+  ## but number of bytes (octets) required will be returned.
+  var buffer: array[16, byte]
+  var res = 1
+  var oidlen = 1
+  for i in 2..<len(value):
+    oidlen += asn1EncodeTag(buffer, cast[uint64](value[i]))
+  res += asn1EncodeLength(buffer, uint64(oidlen))
+  res += oidlen
+  if len(dest) >= res:
+    let last = dest.high
+    var offset = 1
+    dest[0] = Asn1Tag.Oid.code()
+    offset += asn1EncodeLength(dest.toOpenArray(offset, last), uint64(oidlen))
+    dest[offset] = cast[byte](value[0] * 40 + value[1])
+    offset += 1
+    for i in 2..<len(value):
+      offset += asn1EncodeTag(dest.toOpenArray(offset, last),
+                              cast[uint64](value[i]))
+  res
+
 proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[byte]): int =
  ## Encode array of bytes ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and return
  ## number of bytes (octets) used.
@@ -415,29 +443,26 @@ proc asn1EncodeContextTag*(dest: var openArray[byte], value: openArray[byte],
    copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
  res

-proc getLength(ab: var Asn1Buffer): Asn1Result[int] =
+proc getLength(ab: var Asn1Buffer): Asn1Result[uint64] =
  ## Decode length part of ASN.1 TLV triplet.
  if not ab.isEmpty():
    let b = ab.buffer[ab.offset]
    if (b and 0x80'u8) == 0x00'u8:
-      let length = safeConvert[int](b)
+      let length = cast[uint64](b)
      ab.offset += 1
      return ok(length)
    if b == 0x80'u8:
      return err(Asn1Error.Indefinite)
    if b == 0xFF'u8:
      return err(Asn1Error.Incorrect)
-    let octets = safeConvert[int](b and 0x7F'u8)
-    if octets > 8:
+    let octets = cast[uint64](b and 0x7F'u8)
+    if octets > 8'u64:
      return err(Asn1Error.Overflow)
-    if ab.isEnough(octets):
-      var lengthU: uint64 = 0
-      for i in 0..<octets:
-        lengthU = (lengthU shl 8) or safeConvert[uint64](ab.buffer[ab.offset + i + 1])
-      if lengthU > uint64(int64.high):
-        return err(Asn1Error.Overflow)
-      let length = int(lengthU)
-      ab.offset = ab.offset + octets + 1
+    if ab.isEnough(int(octets)):
+      var length: uint64 = 0
+      for i in 0..<int(octets):
+        length = (length shl 8) or cast[uint64](ab.buffer[ab.offset + i + 1])
+      ab.offset = ab.offset + int(octets) + 1
      return ok(length)
    else:
      return err(Asn1Error.Incomplete)
@@ -449,8 +474,8 @@ proc getTag(ab: var Asn1Buffer, tag: var int): Asn1Result[Asn1Class] =
  if not ab.isEmpty():
    let
      b = ab.buffer[ab.offset]
-      c = safeConvert[int]((b and 0xC0'u8) shr 6)
-    tag = safeConvert[int](b and 0x3F)
+      c = int((b and 0xC0'u8) shr 6)
+    tag = int(b and 0x3F)
    ab.offset += 1
    if c >= 0 and c < 4:
      ok(cast[Asn1Class](c))
@@ -464,7 +489,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
  var
    field: Asn1Field
    tag, ttag, offset: int
-    length, tlength: int
+    length, tlength: uint64
    aclass: Asn1Class
    inclass: bool

@@ -494,7 +519,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
        if length != 1:
          return err(Asn1Error.Incorrect)

-        if not ab.isEnough(length):
+        if not ab.isEnough(int(length)):
          return err(Asn1Error.Incomplete)

        let b = ab.buffer[ab.offset]
@@ -502,7 +527,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
           return err(Asn1Error.Incorrect)

        field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass,
-                          index: ttag, offset: ab.offset,
+                          index: ttag, offset: int(ab.offset),
                          length: 1, buffer: ab.buffer)
        field.vbool = (b == 0xFF'u8)
        ab.offset += 1
@@ -513,12 +538,12 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
        if length == 0:
          return err(Asn1Error.Incorrect)

-        if not ab.isEnough(length):
+        if not ab.isEnough(int(length)):
         return err(Asn1Error.Incomplete)

        # Count number of leading zeroes
        var zc = 0
-        while (zc < length) and (ab.buffer[ab.offset + zc] == 0x00'u8):
+        while (zc < int(length)) and (ab.buffer[ab.offset + zc] == 0x00'u8):
          inc(zc)

        if zc > 1:
@@ -527,45 +552,45 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
        if zc == 0:
          # Negative or Positive integer
          field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
-                            index: ttag, offset: ab.offset,
-                            length: length, buffer: ab.buffer)
+                            index: ttag, offset: int(ab.offset),
+                            length: int(length), buffer: ab.buffer)
          if (ab.buffer[ab.offset] and 0x80'u8) == 0x80'u8:
            # Negative integer
            if length <= 8:
              # We need this transformation because our field.vint is uint64.
              for i in 0 ..< 8:
-                if i < 8 - length:
+                if i < 8 - int(length):
                  field.vint = (field.vint shl 8) or 0xFF'u64
                else:
-                  let offset = ab.offset + i - (8 - length)
-                  field.vint = (field.vint shl 8) or safeConvert[uint64](ab.buffer[offset])
+                  let offset = ab.offset + i - (8 - int(length))
+                  field.vint = (field.vint shl 8) or uint64(ab.buffer[offset])
          else:
            # Positive integer
            if length <= 8:
-              for i in 0 ..< length:
+              for i in 0 ..< int(length):
                field.vint = (field.vint shl 8) or
-                              safeConvert[uint64](ab.buffer[ab.offset + i])
-          ab.offset += length
+                              uint64(ab.buffer[ab.offset + i])
+          ab.offset += int(length)
          return ok(field)
        else:
          if length == 1:
            # Zero value integer
            field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
-                              index: ttag, offset: ab.offset,
-                              length: length, vint: 0'u64,
+                              index: ttag, offset: int(ab.offset),
+                              length: int(length), vint: 0'u64,
                              buffer: ab.buffer)
-            ab.offset += length
+            ab.offset += int(length)
            return ok(field)
          else:
            # Positive integer with leading zero
            field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
-                              index: ttag, offset: ab.offset + 1,
-                              length: length - 1, buffer: ab.buffer)
+                              index: ttag, offset: int(ab.offset) + 1,
+                              length: int(length) - 1, buffer: ab.buffer)
            if length <= 9:
-              for i in 1 ..< length:
+              for i in 1 ..< int(length):
                field.vint = (field.vint shl 8) or
-                              safeConvert[uint64](ab.buffer[ab.offset + i])
-            ab.offset += length
+                              uint64(ab.buffer[ab.offset + i])
+            ab.offset += int(length)
            return ok(field)

      of Asn1Tag.BitString.code():
@@ -581,13 +606,13 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
          else:
            # Zero-length BIT STRING.
            field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
-                              index: ttag, offset: ab.offset + 1,
+                              index: ttag, offset: int(ab.offset + 1),
                              length: 0, ubits: 0, buffer: ab.buffer)
-            ab.offset += length
+            ab.offset += int(length)
            return ok(field)

        else:
-          if not ab.isEnough(length):
+          if not ab.isEnough(int(length)):
            return err(Asn1Error.Incomplete)

          let unused = ab.buffer[ab.offset]
@@ -595,27 +620,27 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
            # Number of unused bits should not be bigger then `7`.
            return err(Asn1Error.Incorrect)

-          let mask = (1'u8 shl safeConvert[int](unused)) - 1'u8
-          if (ab.buffer[ab.offset + length - 1] and mask) != 0x00'u8:
+          let mask = (1'u8 shl int(unused)) - 1'u8
+          if (ab.buffer[ab.offset + int(length) - 1] and mask) != 0x00'u8:
            ## All unused bits should be set to `0`.
            return err(Asn1Error.Incorrect)

          field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
-                            index: ttag, offset: ab.offset + 1,
-                            length: length - 1, ubits: safeConvert[int](unused),
+                            index: ttag, offset: int(ab.offset + 1),
+                            length: int(length - 1), ubits: int(unused),
                            buffer: ab.buffer)
-          ab.offset += length
+          ab.offset += int(length)
          return ok(field)

      of Asn1Tag.OctetString.code():
        # OCTET STRING
-        if not ab.isEnough(length):
+        if not ab.isEnough(int(length)):
          return err(Asn1Error.Incomplete)

        field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
-        ab.offset += length
+                          index: ttag, offset: int(ab.offset),
+                          length: int(length), buffer: ab.buffer)
+        ab.offset += int(length)
        return ok(field)

      of Asn1Tag.Null.code():
@@ -624,30 +649,30 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
          return err(Asn1Error.Incorrect)

        field = Asn1Field(kind: Asn1Tag.Null, klass: aclass, index: ttag,
-                          offset: ab.offset, length: 0, buffer: ab.buffer)
-        ab.offset += length
+                          offset: int(ab.offset), length: 0, buffer: ab.buffer)
+        ab.offset += int(length)
        return ok(field)

      of Asn1Tag.Oid.code():
        # OID
-        if not ab.isEnough(length):
+        if not ab.isEnough(int(length)):
          return err(Asn1Error.Incomplete)

        field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
-        ab.offset += length
+                          index: ttag, offset: int(ab.offset),
+                          length: int(length), buffer: ab.buffer)
+        ab.offset += int(length)
        return ok(field)

      of Asn1Tag.Sequence.code():
        # SEQUENCE
-        if not ab.isEnough(length):
+        if not ab.isEnough(int(length)):
          return err(Asn1Error.Incomplete)

        field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
-        ab.offset += length
+                          index: ttag, offset: int(ab.offset),
+                          length: int(length), buffer: ab.buffer)
+        ab.offset += int(length)
        return ok(field)

      else:
--- a/libp2p/crypto/rsa.nim
+++ b/libp2p/crypto/rsa.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -13,7 +13,10 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import bearssl/[rsa, rand, hash]
 import minasn1
@@ -683,7 +686,7 @@ proc `==`*(a, b: RsaPrivateKey): bool =
    false
  else:
    if a.seck.nBitlen == b.seck.nBitlen:
-      if a.seck.nBitlen > 0'u:
+      if cast[int](a.seck.nBitlen) > 0:
        let r1 = CT.isEqual(getArray(a.buffer, a.seck.p, a.seck.plen),
                            getArray(b.buffer, b.seck.p, b.seck.plen))
        let r2 = CT.isEqual(getArray(a.buffer, a.seck.q, a.seck.qlen),
--- a/libp2p/crypto/secp.nim
+++ b/libp2p/crypto/secp.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import bearssl/rand
 import
@@ -32,6 +35,9 @@ type
  SkSignature* = distinct secp256k1.SkSignature
  SkKeyPair* = distinct secp256k1.SkKeyPair

+template pubkey*(v: SkKeyPair): SkPublicKey = SkPublicKey(secp256k1.SkKeyPair(v).pubkey)
+template seckey*(v: SkKeyPair): SkPrivateKey = SkPrivateKey(secp256k1.SkKeyPair(v).seckey)
+
 proc random*(t: typedesc[SkPrivateKey], rng: var HmacDrbgContext): SkPrivateKey =
  #TODO is there a better way?
  var rngPtr = addr rng
--- a/libp2p/daemon/daemonapi.nim
+++ b/libp2p/daemon/daemonapi.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,14 +7,17 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 ## This module implementes API for `go-libp2p-daemon`.
 import std/[os, osproc, strutils, tables, strtabs, sequtils]
 import pkg/[chronos, chronicles]
 import ../varint, ../multiaddress, ../multicodec, ../cid, ../peerid
 import ../wire, ../multihash, ../protobuf/minprotobuf, ../errors
-import ../crypto/crypto, ../utility
+import ../crypto/crypto

 export
  peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors
@@ -150,10 +153,10 @@ type
    key*: PublicKey

  P2PStreamCallback* = proc(api: DaemonAPI,
-                            stream: P2PStream): Future[void] {.gcsafe, raises: [CatchableError].}
+                            stream: P2PStream): Future[void] {.gcsafe, raises: [Defect, CatchableError].}
  P2PPubSubCallback* = proc(api: DaemonAPI,
                            ticket: PubsubTicket,
-                            message: PubSubMessage): Future[bool] {.gcsafe, raises: [CatchableError].}
+                            message: PubSubMessage): Future[bool] {.gcsafe, raises: [Defect, CatchableError].}

  DaemonError* = object of LPError
  DaemonRemoteError* = object of DaemonError
@@ -167,7 +170,7 @@ proc requestIdentity(): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
  ## Processing function `doIdentify(req *pb.Request)`.
  result = initProtoBuffer({WithVarintLength})
-  result.write(1, safeConvert[uint](RequestType.IDENTIFY))
+  result.write(1, cast[uint](RequestType.IDENTIFY))
  result.finish()

 proc requestConnect(peerid: PeerId,
@@ -182,7 +185,7 @@ proc requestConnect(peerid: PeerId,
    msg.write(2, item.data.buffer)
  if timeout > 0:
    msg.write(3, hint64(timeout))
-  result.write(1, safeConvert[uint](RequestType.CONNECT))
+  result.write(1, cast[uint](RequestType.CONNECT))
  result.write(2, msg)
  result.finish()

@@ -192,7 +195,7 @@ proc requestDisconnect(peerid: PeerId): ProtoBuffer =
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, peerid)
-  result.write(1, safeConvert[uint](RequestType.DISCONNECT))
+  result.write(1, cast[uint](RequestType.DISCONNECT))
  result.write(7, msg)
  result.finish()

@@ -208,7 +211,7 @@ proc requestStreamOpen(peerid: PeerId,
    msg.write(2, item)
  if timeout > 0:
    msg.write(3, hint64(timeout))
-  result.write(1, safeConvert[uint](RequestType.STREAM_OPEN))
+  result.write(1, cast[uint](RequestType.STREAM_OPEN))
  result.write(3, msg)
  result.finish()

@@ -221,7 +224,7 @@ proc requestStreamHandler(address: MultiAddress,
  msg.write(1, address.data.buffer)
  for item in protocols:
    msg.write(2, item)
-  result.write(1, safeConvert[uint](RequestType.STREAM_HANDLER))
+  result.write(1, cast[uint](RequestType.STREAM_HANDLER))
  result.write(4, msg)
  result.finish()

@@ -229,13 +232,13 @@ proc requestListPeers(): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
  ## Processing function `doListPeers(req *pb.Request)`
  result = initProtoBuffer({WithVarintLength})
-  result.write(1, safeConvert[uint](RequestType.LIST_PEERS))
+  result.write(1, cast[uint](RequestType.LIST_PEERS))
  result.finish()

 proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTFindPeer(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.FIND_PEER)
+  let msgid = cast[uint](DHTRequestType.FIND_PEER)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -243,7 +246,7 @@ proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

@@ -251,7 +254,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
                                        timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTFindPeersConnectedToPeer(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
+  let msgid = cast[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -259,7 +262,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

@@ -267,7 +270,7 @@ proc requestDHTFindProviders(cid: Cid,
                             count: uint32, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTFindProviders(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.FIND_PROVIDERS)
+  let msgid = cast[uint](DHTRequestType.FIND_PROVIDERS)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -276,14 +279,14 @@ proc requestDHTFindProviders(cid: Cid,
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTGetClosestPeers(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.GET_CLOSEST_PEERS)
+  let msgid = cast[uint](DHTRequestType.GET_CLOSEST_PEERS)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -291,14 +294,14 @@ proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTGetPublicKey(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.GET_PUBLIC_KEY)
+  let msgid = cast[uint](DHTRequestType.GET_PUBLIC_KEY)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -306,14 +309,14 @@ proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTGetValue(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.GET_VALUE)
+  let msgid = cast[uint](DHTRequestType.GET_VALUE)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -321,14 +324,14 @@ proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTSearchValue(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.SEARCH_VALUE)
+  let msgid = cast[uint](DHTRequestType.SEARCH_VALUE)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -336,7 +339,7 @@ proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

@@ -344,7 +347,7 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
                        timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTPutValue(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.PUT_VALUE)
+  let msgid = cast[uint](DHTRequestType.PUT_VALUE)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -353,14 +356,14 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, uint(RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
  ## Processing function `doDHTProvide(req *pb.DHTRequest)`.
-  let msgid = safeConvert[uint](DHTRequestType.PROVIDE)
+  let msgid = cast[uint](DHTRequestType.PROVIDE)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -368,13 +371,13 @@ proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
  if timeout > 0:
    msg.write(7, hint64(timeout))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.DHT))
+  result.write(1, cast[uint](RequestType.DHT))
  result.write(5, msg)
  result.finish()

 proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L18
-  let msgid = safeConvert[uint](ConnManagerRequestType.TAG_PEER)
+  let msgid = cast[uint](ConnManagerRequestType.TAG_PEER)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
@@ -382,83 +385,83 @@ proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
  msg.write(3, tag)
  msg.write(4, hint64(weight))
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
+  result.write(1, cast[uint](RequestType.CONNMANAGER))
  result.write(6, msg)
  result.finish()

 proc requestCMUntagPeer(peer: PeerId, tag: string): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L33
-  let msgid = safeConvert[uint](ConnManagerRequestType.UNTAG_PEER)
+  let msgid = cast[uint](ConnManagerRequestType.UNTAG_PEER)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.write(2, peer)
  msg.write(3, tag)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
+  result.write(1, cast[uint](RequestType.CONNMANAGER))
  result.write(6, msg)
  result.finish()

 proc requestCMTrim(): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L47
-  let msgid = safeConvert[uint](ConnManagerRequestType.TRIM)
+  let msgid = cast[uint](ConnManagerRequestType.TRIM)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
+  result.write(1, cast[uint](RequestType.CONNMANAGER))
  result.write(6, msg)
  result.finish()

 proc requestPSGetTopics(): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
  ## Processing function `doPubsubGetTopics(req *pb.PSRequest)`.
-  let msgid = safeConvert[uint](PSRequestType.GET_TOPICS)
+  let msgid = cast[uint](PSRequestType.GET_TOPICS)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.PUBSUB))
+  result.write(1, cast[uint](RequestType.PUBSUB))
  result.write(8, msg)
  result.finish()

 proc requestPSListPeers(topic: string): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
  ## Processing function `doPubsubListPeers(req *pb.PSRequest)`.
-  let msgid = safeConvert[uint](PSRequestType.LIST_PEERS)
+  let msgid = cast[uint](PSRequestType.LIST_PEERS)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.write(2, topic)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.PUBSUB))
+  result.write(1, cast[uint](RequestType.PUBSUB))
  result.write(8, msg)
  result.finish()

 proc requestPSPublish(topic: string, data: openArray[byte]): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
  ## Processing function `doPubsubPublish(req *pb.PSRequest)`.
-  let msgid = safeConvert[uint](PSRequestType.PUBLISH)
+  let msgid = cast[uint](PSRequestType.PUBLISH)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.write(2, topic)
  msg.write(3, data)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.PUBSUB))
+  result.write(1, cast[uint](RequestType.PUBSUB))
  result.write(8, msg)
  result.finish()

 proc requestPSSubscribe(topic: string): ProtoBuffer =
  ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
  ## Processing function `doPubsubSubscribe(req *pb.PSRequest)`.
-  let msgid = safeConvert[uint](PSRequestType.SUBSCRIBE)
+  let msgid = cast[uint](PSRequestType.SUBSCRIBE)
  result = initProtoBuffer({WithVarintLength})
  var msg = initProtoBuffer()
  msg.write(1, msgid)
  msg.write(2, topic)
  msg.finish()
-  result.write(1, safeConvert[uint](RequestType.PUBSUB))
+  result.write(1, cast[uint](RequestType.PUBSUB))
  result.write(8, msg)
  result.finish()

@@ -471,7 +474,7 @@ proc checkResponse(pb: ProtoBuffer): ResponseKind {.inline.} =
    else:
      result = ResponseKind.Error

-proc getErrorMessage(pb: ProtoBuffer): string {.inline, raises: [DaemonLocalError].} =
+proc getErrorMessage(pb: ProtoBuffer): string {.inline, raises: [Defect, DaemonLocalError].} =
  var error: seq[byte]
  if pb.getRequiredField(ResponseType.ERROR.int, error).isOk():
    if initProtoBuffer(error).getRequiredField(1, result).isErr():
@@ -501,7 +504,7 @@ proc recvMessage(conn: StreamTransport): Future[seq[byte]] {.async.} =
  result = buffer

 proc newConnection*(api: DaemonAPI): Future[StreamTransport]
-  {.raises: [LPError].} =
+  {.raises: [Defect, LPError].} =
  result = connect(api.address)

 proc closeConnection*(api: DaemonAPI, transp: StreamTransport): Future[void] =
@@ -512,7 +515,7 @@ proc socketExists(address: MultiAddress): Future[bool] {.async.} =
    var transp = await connect(address)
    await transp.closeWait()
    result = true
-  except CatchableError:
+  except:
    result = false

 when defined(windows):
@@ -522,7 +525,7 @@ when defined(windows):
    result = cast[int](getCurrentProcessId())
 else:
  proc getProcessId(): int =
-    result = int(posix.getpid())
+    result = cast[int](posix.getpid())

 proc getSocket(pattern: string,
               count: ptr int): Future[MultiAddress] {.async.} =
@@ -553,7 +556,7 @@ proc getSocket(pattern: string,
    closeSocket(sock)

 # This is forward declaration needed for newDaemonApi()
-proc listPeers*(api: DaemonAPI): Future[seq[PeerInfo]] {.async.}
+proc listPeers*(api: DaemonAPI): Future[seq[PeerInfo]] {.async, gcsafe.}

 proc copyEnv(): StringTableRef =
  ## This procedure copy all environment variables into StringTable.
@@ -755,9 +758,13 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},

  # Starting daemon process
  # echo "Starting ", cmd, " ", args.join(" ")
-  api.process =
-    exceptionToAssert:
+  api.process = 
+    try:
      startProcess(cmd, "", args, env, {poParentStreams})
+    except CatchableError as exc:
+      raise exc
+    except Exception as exc:
+      raiseAssert exc.msg
  # Waiting until daemon will not be bound to control socket.
  while true:
    if not api.process.running():
@@ -834,7 +841,7 @@ proc transactMessage(transp: StreamTransport,
  result = initProtoBuffer(message)

 proc getPeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [DaemonLocalError].} =
+  {.raises: [Defect, DaemonLocalError].} =
  ## Get PeerInfo object from ``pb``.
  result.addresses = newSeq[MultiAddress]()
  if pb.getRequiredField(1, result.peer).isErr():
@@ -865,7 +872,7 @@ proc connect*(api: DaemonAPI, peer: PeerId,
                                                         timeout))
    pb.withMessage() do:
      discard
-  except CatchableError:
+  except:
    await api.closeConnection(transp)

 proc disconnect*(api: DaemonAPI, peer: PeerId) {.async.} =
@@ -925,7 +932,7 @@ proc streamHandler(server: StreamServer, transp: StreamTransport) {.async.} =
      asyncSpawn handler(api, stream)

 proc addHandler*(api: DaemonAPI, protocols: seq[string],
-                 handler: P2PStreamCallback) {.async, raises: [LPError].} =
+                 handler: P2PStreamCallback) {.async, raises: [Defect, LPError].} =
  ## Add stream handler ``handler`` for set of protocols ``protocols``.
  var transp = await api.newConnection()
  let maddress = await getSocket(api.pattern, addr api.ucounter)
@@ -995,7 +1002,7 @@ proc cmTrimPeers*(api: DaemonAPI) {.async.} =
    await api.closeConnection(transp)

 proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [DaemonLocalError].} =
+  {.raises: [Defect, DaemonLocalError].} =
  var res: seq[byte]
  if pb.getRequiredField(2, res).isOk():
    result = initProtoBuffer(res).getPeerInfo()
@@ -1003,42 +1010,42 @@ proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo
    raise newException(DaemonLocalError, "Missing required field `peer`!")

 proc dhtGetSingleValue(pb: ProtoBuffer): seq[byte]
-  {.raises: [DaemonLocalError].} =
+  {.raises: [Defect, DaemonLocalError].} =
  result = newSeq[byte]()
  if pb.getRequiredField(3, result).isErr():
    raise newException(DaemonLocalError, "Missing field `value`!")

 proc dhtGetSinglePublicKey(pb: ProtoBuffer): PublicKey
-  {.raises: [DaemonLocalError].} =
+  {.raises: [Defect, DaemonLocalError].} =
  if pb.getRequiredField(3, result).isErr():
    raise newException(DaemonLocalError, "Missing field `value`!")

 proc dhtGetSinglePeerId(pb: ProtoBuffer): PeerId
-  {.raises: [DaemonLocalError].} =
+  {.raises: [Defect, DaemonLocalError].} =
  if pb.getRequiredField(3, result).isErr():
    raise newException(DaemonLocalError, "Missing field `value`!")

 proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
-  {.inline, raises: [DaemonLocalError].} =
+  {.inline, raises: [Defect, DaemonLocalError].} =
  var dhtResponse: seq[byte]
  if pb.getRequiredField(ResponseType.DHT.int, dhtResponse).isOk():
    var pbDhtResponse = initProtoBuffer(dhtResponse)
    var dtype: uint
    if pbDhtResponse.getRequiredField(1, dtype).isErr():
      raise newException(DaemonLocalError, "Missing required DHT field `type`!")
-    if dtype != safeConvert[uint](rt):
+    if dtype != cast[uint](rt):
      raise newException(DaemonLocalError, "Wrong DHT answer type! ")

    var value: seq[byte]
    if pbDhtResponse.getRequiredField(3, value).isErr():
      raise newException(DaemonLocalError, "Missing required DHT field `value`!")
-
+    
    return initProtoBuffer(value)
  else:
    raise newException(DaemonLocalError, "Wrong message type!")

 proc enterPsMessage(pb: ProtoBuffer): ProtoBuffer
-  {.inline, raises: [DaemonLocalError].} =
+  {.inline, raises: [Defect, DaemonLocalError].} =
  var res: seq[byte]
  if pb.getRequiredField(ResponseType.PUBSUB.int, res).isErr():
    raise newException(DaemonLocalError, "Wrong message type!")
@@ -1046,13 +1053,13 @@ proc enterPsMessage(pb: ProtoBuffer): ProtoBuffer
  initProtoBuffer(res)

 proc getDhtMessageType(pb: ProtoBuffer): DHTResponseType
-  {.inline, raises: [DaemonLocalError].} =
+  {.inline, raises: [Defect, DaemonLocalError].} =
  var dtype: uint
  if pb.getRequiredField(1, dtype).isErr():
    raise newException(DaemonLocalError, "Missing required DHT field `type`!")
-  if dtype == safeConvert[uint](DHTResponseType.VALUE):
+  if dtype == cast[uint](DHTResponseType.VALUE):
    result = DHTResponseType.VALUE
-  elif dtype == safeConvert[uint](DHTResponseType.END):
+  elif dtype == cast[uint](DHTResponseType.END):
    result = DHTResponseType.END
  else:
    raise newException(DaemonLocalError, "Wrong DHT answer type!")
--- a/libp2p/daemon/transpool.nim
+++ b/libp2p/daemon/transpool.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 ## This module implements Pool of StreamTransport.
 import chronos
--- a/libp2p/debugutils.nim
+++ b/libp2p/debugutils.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -25,7 +25,7 @@
 ##   5. LocalAddress: optional bytes
 ##   6. RemoteAddress: optional bytes
 ##   7. Message: required bytes
-import os
+import os, options
 import nimcrypto/utils, stew/endians2
 import protobuf/minprotobuf, stream/connection, protocols/secure/secure,
       multiaddress, peerid, varint, muxers/mplex/coder
@@ -33,7 +33,7 @@ import protobuf/minprotobuf, stream/connection, protocols/secure/secure,
 from times import getTime, toUnix, fromUnix, nanosecond, format, Time,
                  NanosecondRange, initTime
 from strutils import toHex, repeat
-export peerid, multiaddress
+export peerid, options, multiaddress

 type
  FlowDirection* = enum
@@ -43,10 +43,10 @@ type
    timestamp*: uint64
    direction*: FlowDirection
    message*: seq[byte]
-    seqID*: Opt[uint64]
-    mtype*: Opt[uint64]
-    local*: Opt[MultiAddress]
-    remote*: Opt[MultiAddress]
+    seqID*: Option[uint64]
+    mtype*: Option[uint64]
+    local*: Option[MultiAddress]
+    remote*: Option[MultiAddress]

 const
  libp2p_dump_dir* {.strdefine.} = "nim-libp2p"
@@ -72,8 +72,7 @@ proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
  var pb = initProtoBuffer(options = {WithVarintLength})
  pb.write(2, getTimestamp())
  pb.write(4, uint64(direction))
-  conn.observedAddr.withValue(oaddr):
-    pb.write(6, oaddr)
+  pb.write(6, conn.observedAddr)
  pb.write(7, data)
  pb.finish()

@@ -101,7 +100,7 @@ proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
  finally:
    close(handle)

-proc decodeDumpMessage*(data: openArray[byte]): Opt[ProtoMessage] =
+proc decodeDumpMessage*(data: openArray[byte]): Option[ProtoMessage] =
  ## Decode protobuf's message ProtoMessage from array of bytes ``data``.
  var
    pb = initProtoBuffer(data)
@@ -109,12 +108,13 @@ proc decodeDumpMessage*(data: openArray[byte]): Opt[ProtoMessage] =
    ma1, ma2: MultiAddress
    pmsg: ProtoMessage

-  let
-    r2 = pb.getField(2, pmsg.timestamp)
-    r4 = pb.getField(4, value)
-    r7 = pb.getField(7, pmsg.message)
-  if not r2.get(false) or not r4.get(false) or not r7.get(false):
-    return Opt.none(ProtoMessage)
+  let res2 = pb.getField(2, pmsg.timestamp)
+  if res2.isErr() or not(res2.get()):
+    return none[ProtoMessage]()
+
+  let res4 = pb.getField(4, value)
+  if res4.isErr() or not(res4.get()):
+    return none[ProtoMessage]()

  # `case` statement could not work here with an error "selector must be of an
  # ordinal type, float or string"
@@ -124,27 +124,30 @@ proc decodeDumpMessage*(data: openArray[byte]): Opt[ProtoMessage] =
    elif value == uint64(Incoming):
      Incoming
    else:
-      return Opt.none(ProtoMessage)
+      return none[ProtoMessage]()

-  let r1 = pb.getField(1, value)
-  if r1.get(false):
-    pmsg.seqID = Opt.some(value)
+  let res7 = pb.getField(7, pmsg.message)
+  if res7.isErr() or not(res7.get()):
+    return none[ProtoMessage]()

-  let r3 = pb.getField(3, value)
-  if r3.get(false):
-    pmsg.mtype = Opt.some(value)
+  value = 0'u64
+  let res1 = pb.getField(1, value)
+  if res1.isOk() and res1.get():
+    pmsg.seqID = some(value)
+  value = 0'u64
+  let res3 = pb.getField(3, value)
+  if res3.isOk() and res3.get():
+    pmsg.mtype = some(value)
+  let res5 = pb.getField(5, ma1)
+  if res5.isOk() and res5.get():
+    pmsg.local = some(ma1)
+  let res6 = pb.getField(6, ma2)
+  if res6.isOk() and res6.get():
+    pmsg.remote = some(ma2)

-  let
-    r5 = pb.getField(5, ma1)
-    r6 = pb.getField(6, ma2)
-  if r5.get(false):
-    pmsg.local = Opt.some(ma1)
-  if r6.get(false):
-    pmsg.remote = Opt.some(ma2)
+  some(pmsg)

-  Opt.some(pmsg)
-
-iterator messages*(data: seq[byte]): Opt[ProtoMessage] =
+iterator messages*(data: seq[byte]): Option[ProtoMessage] =
  ## Iterate over sequence of bytes and decode all the ``ProtoMessage``
  ## messages we found.
  var value: uint64
@@ -239,19 +242,27 @@ proc toString*(msg: ProtoMessage, dump = true): string =
      " >> "
  let address =
    block:
-      let local = block:
-        msg.local.withValue(loc): "[" & $loc & "]"
-        else: "[LOCAL]"
-      let remote = block:
-        msg.remote.withValue(rem): "[" & $rem & "]"
-        else: "[REMOTE]"
+      let local =
+        if msg.local.isSome():
+          "[" & $(msg.local.get()) & "]"
+        else:
+          "[LOCAL]"
+      let remote =
+        if msg.remote.isSome():
+          "[" & $(msg.remote.get()) & "]"
+        else:
+          "[REMOTE]"
      local & direction & remote
-  let seqid = block:
-    msg.seqID.wihValue(seqid): "seqID = " & $seqid & " "
-    else: ""
-  let mtype = block:
-    msg.mtype.withValue(typ): "type = " & $typ & " "
-    else: ""
+  let seqid =
+    if msg.seqID.isSome():
+      "seqID = " & $(msg.seqID.get()) & " "
+    else:
+      ""
+  let mtype =
+    if msg.mtype.isSome():
+      "type = " & $(msg.mtype.get()) & " "
+    else:
+      ""
  res.add(" ")
  res.add(address)
  res.add(" ")
--- a/libp2p/dial.nim
+++ b/libp2p/dial.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos
 import stew/results
@@ -24,9 +27,7 @@ method connect*(
  self: Dial,
  peerId: PeerId,
  addrs: seq[MultiAddress],
-  forceDial = false,
-  reuseConnection = true,
-  dir = Direction.Out) {.async, base.} =
+  forceDial = false) {.async, base.} =
  ## connect remote peer without negotiating
  ## a protocol
  ##
--- a/libp2p/dialer.nim
+++ b/libp2p/dialer.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,7 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-import std/tables
+import std/[sugar, tables, sequtils]

 import stew/results
 import pkg/[chronos,
@@ -17,9 +17,7 @@ import pkg/[chronos,
 import dial,
       peerid,
       peerinfo,
-       peerstore,
       multicodec,
-       muxers/muxer,
       multistream,
       connmanager,
       stream/connection,
@@ -36,68 +34,64 @@ logScope:
 declareCounter(libp2p_total_dial_attempts, "total attempted dials")
 declareCounter(libp2p_successful_dials, "dialed successful peers")
 declareCounter(libp2p_failed_dials, "failed dials")
+declareCounter(libp2p_failed_upgrades_outgoing, "outgoing connections failed upgrades")

 type
  DialFailedError* = object of LPError

  Dialer* = ref object of Dial
    localPeerId*: PeerId
+    ms: MultistreamSelect
    connManager: ConnManager
    dialLock: Table[PeerId, AsyncLock]
    transports: seq[Transport]
-    peerStore: PeerStore
    nameResolver: NameResolver

 proc dialAndUpgrade(
  self: Dialer,
  peerId: Opt[PeerId],
  hostname: string,
-  address: MultiAddress,
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
+  address: MultiAddress):
+  Future[Connection] {.async.} =

  for transport in self.transports: # for each transport
    if transport.handles(address):   # check if it can dial it
-      trace "Dialing address", address, peerId = peerId.get(default(PeerId)), hostname
+      trace "Dialing address", address, peerId, hostname
      let dialed =
        try:
          libp2p_total_dial_attempts.inc()
-          await transport.dial(hostname, address, peerId)
+          await transport.dial(hostname, address)
        except CancelledError as exc:
-          debug "Dialing canceled", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Dialing canceled", msg = exc.msg, peerId
          raise exc
        except CatchableError as exc:
-          debug "Dialing failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Dialing failed", msg = exc.msg, peerId
          libp2p_failed_dials.inc()
          return nil # Try the next address

+      # also keep track of the connection's bottom unsafe transport direction
+      # required by gossipsub scoring
+      dialed.transportDir = Direction.Out
+
      libp2p_successful_dials.inc()

-      let mux =
+      let conn =
        try:
-          # This is for the very specific case of a simultaneous dial during DCUtR. In this case, both sides will have
-          # an Outbound direction at the transport level. Therefore we update the DCUtR initiator transport direction to Inbound.
-          # The if below is more general and might handle other use cases in the future.
-          if dialed.dir != dir:
-            dialed.dir = dir
-          await transport.upgrade(dialed, peerId)
+          await transport.upgradeOutgoing(dialed, peerId)
        except CatchableError as exc:
          # If we failed to establish the connection through one transport,
          # we won't succeeded through another - no use in trying again
          await dialed.close()
-          debug "Upgrade failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Upgrade failed", msg = exc.msg, peerId
          if exc isnot CancelledError:
-            if dialed.dir == Direction.Out:
-              libp2p_failed_upgrades_outgoing.inc()
-            else:
-              libp2p_failed_upgrades_incoming.inc()
+            libp2p_failed_upgrades_outgoing.inc()

          # Try other address
          return nil

-      doAssert not isNil(mux), "connection died after upgrade " & $dialed.dir
-      debug "Dial successful", peerId = mux.connection.peerId
-      return mux
+      doAssert not isNil(conn), "connection died after upgradeOutgoing"
+      debug "Dial successful", conn, peerId = conn.peerId
+      return conn
  return nil

 proc expandDnsAddr(
@@ -131,11 +125,10 @@ proc expandDnsAddr(
 proc dialAndUpgrade(
  self: Dialer,
  peerId: Opt[PeerId],
-  addrs: seq[MultiAddress],
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
+  addrs: seq[MultiAddress]):
+  Future[Connection] {.async.} =

-  debug "Dialing peer", peerId = peerId.get(default(PeerId))
+  debug "Dialing peer", peerId

  for rawAddress in addrs:
    # resolve potential dnsaddr
@@ -150,26 +143,16 @@ proc dialAndUpgrade(
          else: await self.nameResolver.resolveMAddress(expandedAddress)

      for resolvedAddress in resolvedAddresses:
-        result = await self.dialAndUpgrade(addrPeerId, hostname, resolvedAddress, dir)
+        result = await self.dialAndUpgrade(addrPeerId, hostname, resolvedAddress)
        if not isNil(result):
          return result

-proc tryReusingConnection(self: Dialer, peerId: PeerId): Opt[Muxer] =
-  let muxer = self.connManager.selectMuxer(peerId)
-  if muxer == nil:
-    return Opt.none(Muxer)
-
-  trace "Reusing existing connection", muxer, direction = $muxer.connection.dir
-  return Opt.some(muxer)
-
 proc internalConnect(
  self: Dialer,
  peerId: Opt[PeerId],
  addrs: seq[MultiAddress],
-  forceDial: bool,
-  reuseConnection = true,
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
+  forceDial: bool):
+  Future[Connection] {.async.} =
  if Opt.some(self.localPeerId) == peerId:
    raise newException(CatchableError, "can't dial self!")

@@ -178,31 +161,44 @@ proc internalConnect(
  try:
    await lock.acquire()

-    if reuseConnection:
-      peerId.withValue(peerId):
-        self.tryReusingConnection(peerId).withValue(mux):
-          return mux
+    # Check if we have a connection already and try to reuse it
+    var conn =
+      if peerId.isSome: self.connManager.selectConn(peerId.get())
+      else: nil
+    if conn != nil:
+      if conn.atEof or conn.closed:
+        # This connection should already have been removed from the connection
+        # manager - it's essentially a bug that we end up here - we'll fail
+        # for now, hoping that this will clean themselves up later...
+        warn "dead connection in connection manager", conn
+        await conn.close()
+        raise newException(DialFailedError, "Zombie connection encountered")

-    let slot = self.connManager.getOutgoingSlot(forceDial)
-    let muxed =
+      trace "Reusing existing connection", conn, direction = $conn.dir
+      return conn
+
+    let slot = await self.connManager.getOutgoingSlot(forceDial)
+    conn =
      try:
-        await self.dialAndUpgrade(peerId, addrs, dir)
+        await self.dialAndUpgrade(peerId, addrs)
      except CatchableError as exc:
        slot.release()
        raise exc
-    slot.trackMuxer(muxed)
-    if isNil(muxed): # None of the addresses connected
+    slot.trackConnection(conn)
+    if isNil(conn): # None of the addresses connected
      raise newException(DialFailedError, "Unable to establish outgoing link")

-    try:
-      self.connManager.storeMuxer(muxed)
-      await self.peerStore.identify(muxed)
-    except CatchableError as exc:
-      trace "Failed to finish outgoung upgrade", err=exc.msg
-      await muxed.close()
-      raise exc
+    # A disconnect could have happened right after
+    # we've added the connection so we check again
+    # to prevent races due to that.
+    if conn.closed() or conn.atEof():
+      # This can happen when the other ends drops us
+      # before we get a chance to return the connection
+      # back to the dialer.
+      trace "Connection dead on arrival", conn
+      raise newLPStreamClosedError()

-    return muxed
+    return conn
  finally:
    if lock.locked():
      lock.release()
@@ -211,17 +207,15 @@ method connect*(
  self: Dialer,
  peerId: PeerId,
  addrs: seq[MultiAddress],
-  forceDial = false,
-  reuseConnection = true,
-  dir = Direction.Out) {.async.} =
+  forceDial = false) {.async.} =
  ## connect remote peer without negotiating
  ## a protocol
  ##

-  if self.connManager.connCount(peerId) > 0 and reuseConnection:
+  if self.connManager.connCount(peerId) > 0:
    return

-  discard await self.internalConnect(Opt.some(peerId), addrs, forceDial, reuseConnection, dir)
+  discard await self.internalConnect(Opt.some(peerId), addrs, forceDial)

 method connect*(
  self: Dialer,
@@ -229,26 +223,26 @@ method connect*(
  allowUnknownPeerId = false): Future[PeerId] {.async.} =
  ## Connects to a peer and retrieve its PeerId

-  parseFullAddress(address).toOpt().withValue(fullAddress):
+  let fullAddress = parseFullAddress(address)
+  if fullAddress.isOk:
    return (await self.internalConnect(
-      Opt.some(fullAddress[0]),
-      @[fullAddress[1]],
-      false)).connection.peerId
-
-  if allowUnknownPeerId == false:
-    raise newException(DialFailedError, "Address without PeerID and unknown peer id disabled!")
-
-  return (await self.internalConnect(
-    Opt.none(PeerId),
-    @[address],
-    false)).connection.peerId
+      Opt.some(fullAddress.get()[0]),
+      @[fullAddress.get()[1]],
+      false)).peerId
+  else:
+    if allowUnknownPeerId == false:
+      raise newException(DialFailedError, "Address without PeerID and unknown peer id disabled!")
+    return (await self.internalConnect(
+      Opt.none(PeerId),
+      @[address],
+      false)).peerId

 proc negotiateStream(
  self: Dialer,
  conn: Connection,
  protos: seq[string]): Future[Connection] {.async.} =
  trace "Negotiating stream", conn, protos
-  let selected = await MultistreamSelect.select(conn, protos)
+  let selected = await self.ms.select(conn, protos)
  if not protos.contains(selected):
    await conn.closeWithEOF()
    raise newException(DialFailedError, "Unable to select sub-protocol " & $protos)
@@ -266,11 +260,11 @@ method tryDial*(

  trace "Check if it can dial", peerId, addrs
  try:
-    let mux = await self.dialAndUpgrade(Opt.some(peerId), addrs)
-    if mux.isNil():
+    let conn = await self.dialAndUpgrade(Opt.some(peerId), addrs)
+    if conn.isNil():
      raise newException(DialFailedError, "No valid multiaddress")
-    await mux.close()
-    return mux.connection.observedAddr
+    await conn.close()
+    return conn.observedAddr
  except CancelledError as exc:
    raise exc
  except CatchableError as exc:
@@ -302,7 +296,7 @@ method dial*(
  ##

  var
-    conn: Muxer
+    conn: Connection
    stream: Connection

  proc cleanup() {.async.} =
@@ -328,7 +322,7 @@ method dial*(
    await cleanup()
    raise exc
  except CatchableError as exc:
-    debug "Error dialing", conn, err = exc.msg
+    debug "Error dialing", conn, msg = exc.msg
    await cleanup()
    raise exc

@@ -339,12 +333,12 @@ proc new*(
  T: type Dialer,
  localPeerId: PeerId,
  connManager: ConnManager,
-  peerStore: PeerStore,
  transports: seq[Transport],
+  ms: MultistreamSelect,
  nameResolver: NameResolver = nil): Dialer =

  T(localPeerId: localPeerId,
    connManager: connManager,
    transports: transports,
-    peerStore: peerStore,
+    ms: ms,
    nameResolver: nameResolver)
--- a/libp2p/discovery/discoverymngr.nim
+++ b/libp2p/discovery/discoverymngr.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/sequtils
 import chronos, chronicles, stew/results
@@ -15,7 +18,7 @@ import ../errors

 type
  BaseAttr = ref object of RootObj
-    comparator: proc(f, c: BaseAttr): bool {.gcsafe, raises: [].}
+    comparator: proc(f, c: BaseAttr): bool {.gcsafe, raises: [Defect].}

  Attribute[T] = ref object of BaseAttr
    value: T
@@ -57,7 +60,7 @@ proc `{}`*[T](pa: PeerAttributes, t: typedesc[T]): Opt[T] =
      return Opt.some(f.to(T))
  Opt.none(T)

-proc `[]`*[T](pa: PeerAttributes, t: typedesc[T]): T {.raises: [KeyError].} =
+proc `[]`*[T](pa: PeerAttributes, t: typedesc[T]): T {.raises: [Defect, KeyError].} =
  pa{T}.valueOr: raise newException(KeyError, "Attritute not found")

 proc match*(pa, candidate: PeerAttributes): bool =
@@ -70,7 +73,7 @@ proc match*(pa, candidate: PeerAttributes): bool =
  return true

 type
-  PeerFoundCallback* = proc(pa: PeerAttributes) {.raises: [], gcsafe.}
+  PeerFoundCallback* = proc(pa: PeerAttributes) {.raises: [Defect], gcsafe.}

  DiscoveryInterface* = ref object of RootObj
    onPeerFound*: PeerFoundCallback
@@ -122,15 +125,20 @@ proc request*[T](dm: DiscoveryManager, value: T): DiscoveryQuery =
  pa.add(value)
  return dm.request(pa)

-proc advertise*[T](dm: DiscoveryManager, value: T) =
+proc advertise*(dm: DiscoveryManager, pa: PeerAttributes) =
  for i in dm.interfaces:
-    i.toAdvertise.add(value)
+    i.toAdvertise = pa
    if i.advertiseLoop.isNil:
      i.advertisementUpdated = newAsyncEvent()
      i.advertiseLoop = i.advertise()
    else:
      i.advertisementUpdated.fire()

+proc advertise*[T](dm: DiscoveryManager, value: T) =
+  var pa: PeerAttributes
+  pa.add(value)
+  dm.advertise(pa)
+
 template forEach*(query: DiscoveryQuery, code: untyped) =
  ## Will execute `code` for each discovered peer. The
  ## peer attritubtes are available through the variable
--- a/libp2p/discovery/rendezvousinterface.nim
+++ b/libp2p/discovery/rendezvousinterface.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,8 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

+import sequtils
 import chronos
 import ./discoverymngr,
       ../protocols/rendezvous,
@@ -19,7 +23,6 @@ type
    rdv*: RendezVous
    timeToRequest: Duration
    timeToAdvertise: Duration
-    ttl: Duration

  RdvNamespace* = distinct string

@@ -63,16 +66,12 @@ method advertise*(self: RendezVousInterface) {.async.} =

    self.advertisementUpdated.clear()
    for toAdv in toAdvertise:
-      try:
-        await self.rdv.advertise(toAdv, self.ttl)
-      except CatchableError as error:
-        debug "RendezVous advertise error: ", msg = error.msg
+      await self.rdv.advertise(toAdv, self.timeToAdvertise)

    await sleepAsync(self.timeToAdvertise) or self.advertisementUpdated.wait()

 proc new*(T: typedesc[RendezVousInterface],
          rdv: RendezVous,
          ttr: Duration = 1.minutes,
-          tta: Duration = 1.minutes,
-          ttl: Duration = MinimumDuration): RendezVousInterface =
-  T(rdv: rdv, timeToRequest: ttr, timeToAdvertise: tta, ttl: ttl)
+          tta: Duration = MinimumDuration): RendezVousInterface =
+  T(rdv: rdv, timeToRequest: ttr, timeToAdvertise: tta)
--- a/libp2p/errors.nim
+++ b/libp2p/errors.nim
@@ -19,8 +19,7 @@ func toException*(e: string): ref LPError =
 # sadly nim needs more love for hygienic templates
 # so here goes the macro, its based on the proc/template version
 # and uses quote do so it's quite readable
-# TODO https://github.com/nim-lang/Nim/issues/22936
-macro checkFutures*[F](futs: seq[F], exclude: untyped = []): untyped =
+macro checkFutures*[T](futs: seq[Future[T]], exclude: untyped = []): untyped =
  let nexclude = exclude.len
  case nexclude
  of 0:
--- a/libp2p/multiaddress.nim
+++ b/libp2p/multiaddress.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,10 +9,13 @@

 ## This module implements MultiAddress.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}

-import pkg/chronos, chronicles
+import pkg/chronos
 import std/[nativesockets, hashes]
 import tables, strutils, sets, stew/shims/net
 import multicodec, multihash, multibase, transcoder, vbuffer, peerid,
@@ -20,9 +23,6 @@ import multicodec, multihash, multibase, transcoder, vbuffer, peerid,
 import stew/[base58, base32, endians2, results]
 export results, minprotobuf, vbuffer, utility

-logScope:
-  topics = "libp2p multiaddress"
-
 type
  MAKind* = enum
    None, Fixed, Length, Path, Marker
@@ -34,7 +34,7 @@ type
    coder*: Transcoder

  MultiAddress* = object
-    data: VBuffer
+    data*: VBuffer

  MaPatternOp* = enum
    Eq, Or, And
@@ -63,10 +63,6 @@ const
  IPPROTO_TCP = Protocol.IPPROTO_TCP
  IPPROTO_UDP = Protocol.IPPROTO_UDP

-proc data*(ma: MultiAddress): VBuffer =
-  ## Returns the data buffer of the MultiAddress.
-  return ma.data
-
 proc hash*(a: MultiAddress): Hash =
  var h: Hash = 0
  h = h !& hash(a.data.buffer)
@@ -80,7 +76,7 @@ proc ip4StB(s: string, vb: var VBuffer): bool =
    if a.family == IpAddressFamily.IPv4:
      vb.writeArray(a.address_v4)
      result = true
-  except CatchableError:
+  except:
    discard

 proc ip4BtS(vb: var VBuffer, s: var string): bool =
@@ -103,7 +99,7 @@ proc ip6StB(s: string, vb: var VBuffer): bool =
    if a.family == IpAddressFamily.IPv6:
      vb.writeArray(a.address_v6)
      result = true
-  except CatchableError:
+  except:
    discard

 proc ip6BtS(vb: var VBuffer, s: var string): bool =
@@ -147,14 +143,14 @@ proc portStB(s: string, vb: var VBuffer): bool =
      port[1] = cast[byte](nport and 0xFF)
      vb.writeArray(port)
      result = true
-  except CatchableError:
+  except:
    discard

 proc portBtS(vb: var VBuffer, s: var string): bool =
  ## Port number bufferToString() implementation.
  var port: array[2, byte]
  if vb.readArray(port) == 2:
-    var nport = (safeConvert[uint16](port[0]) shl 8) or safeConvert[uint16](port[1])
+    var nport = (cast[uint16](port[0]) shl 8) or cast[uint16](port[1])
    s = $nport
    result = true

@@ -172,7 +168,7 @@ proc p2pStB(s: string, vb: var VBuffer): bool =
    if MultiHash.decode(data, mh).isOk:
      vb.writeSeq(data)
      result = true
-  except CatchableError:
+  except:
    discard

 proc p2pBtS(vb: var VBuffer, s: var string): bool =
@@ -207,14 +203,14 @@ proc onionStB(s: string, vb: var VBuffer): bool =
      address[11] = cast[byte](nport and 0xFF)
      vb.writeArray(address)
      result = true
-  except CatchableError:
+  except:
    discard

 proc onionBtS(vb: var VBuffer, s: var string): bool =
  ## ONION address bufferToString() implementation.
  var buf: array[12, byte]
  if vb.readArray(buf) == 12:
-    var nport = (safeConvert[uint16](buf[10]) shl 8) or safeConvert[uint16](buf[11])
+    var nport = (cast[uint16](buf[10]) shl 8) or cast[uint16](buf[11])
    s = Base32Lower.encode(buf.toOpenArray(0, 9))
    s.add(":")
    s.add($nport)
@@ -241,14 +237,14 @@ proc onion3StB(s: string, vb: var VBuffer): bool =
      address[36] = cast[byte](nport and 0xFF)
      vb.writeArray(address)
      result = true
-  except CatchableError:
+  except:
    discard

 proc onion3BtS(vb: var VBuffer, s: var string): bool =
  ## ONION address bufferToString() implementation.
  var buf: array[37, byte]
  if vb.readArray(buf) == 37:
-    var nport = (safeConvert[uint16](buf[35]) shl 8) or safeConvert[uint16](buf[36])
+    var nport = (cast[uint16](buf[35]) shl 8) or cast[uint16](buf[36])
    s = Base32Lower.encode(buf.toOpenArray(0, 34))
    s.add(":")
    s.add($nport)
@@ -398,9 +394,6 @@ const
    MAProtocol(
      mcodec: multiCodec("quic"), kind: Marker, size: 0
    ),
-    MAProtocol(
-      mcodec: multiCodec("quic-v1"), kind: Marker, size: 0
-    ),
    MAProtocol(
      mcodec: multiCodec("ip6zone"), kind: Length, size: 0,
      coder: TranscoderIP6Zone
@@ -419,9 +412,6 @@ const
    MAProtocol(
      mcodec: multiCodec("wss"), kind: Marker, size: 0
    ),
-    MAProtocol(
-      mcodec: multiCodec("tls"), kind: Marker, size: 0
-    ),
    MAProtocol(
      mcodec: multiCodec("ipfs"), kind: Length, size: 0,
      coder: TranscoderP2P
@@ -472,25 +462,13 @@ const
  IP6* = mapEq("ip6")
  DNS* = mapOr(DNSANY, DNS4, DNS6, DNSADDR)
  IP* = mapOr(IP4, IP6)
-  DNS_OR_IP* = mapOr(DNS, IP)
-  TCP_DNS* = mapAnd(DNS, mapEq("tcp"))
-  TCP_IP* = mapAnd(IP, mapEq("tcp"))
-  TCP* = mapOr(TCP_DNS, TCP_IP)
-  UDP_DNS* = mapAnd(DNS, mapEq("udp"))
-  UDP_IP* = mapAnd(IP, mapEq("udp"))
-  UDP* = mapOr(UDP_DNS, UDP_IP)
+  TCP* = mapOr(mapAnd(DNS, mapEq("tcp")), mapAnd(IP, mapEq("tcp")))
+  UDP* = mapOr(mapAnd(DNS, mapEq("udp")), mapAnd(IP, mapEq("udp")))
  UTP* = mapAnd(UDP, mapEq("utp"))
  QUIC* = mapAnd(UDP, mapEq("quic"))
  UNIX* = mapEq("unix")
-  WS_DNS* = mapAnd(TCP_DNS, mapEq("ws"))
-  WS_IP* = mapAnd(TCP_IP, mapEq("ws"))
  WS* = mapAnd(TCP, mapEq("ws"))
-  TLS_WS* = mapOr(mapEq("wss"), mapAnd(mapEq("tls"), mapEq("ws")))
-  WSS_DNS* = mapAnd(TCP_DNS, TLS_WS)
-  WSS_IP* = mapAnd(TCP_IP, TLS_WS)
-  WSS* = mapAnd(TCP, TLS_WS)
-  WebSockets_DNS* = mapOr(WS_DNS, WSS_DNS)
-  WebSockets_IP* = mapOr(WS_IP, WSS_IP)
+  WSS* = mapAnd(TCP, mapEq("wss"))
  WebSockets* = mapOr(WS, WSS)
  Onion3* = mapEq("onion3")
  TcpOnion3* = mapAnd(TCP, Onion3)
@@ -779,7 +757,7 @@ proc toString*(value: MultiAddress): MaResult[string] =
    res = "/" & parts.join("/")
  ok(res)

-proc `$`*(value: MultiAddress): string =
+proc `$`*(value: MultiAddress): string {.raises: [Defect].} =
  ## Return string representation of MultiAddress ``value``.
  let s = value.toString()
  if s.isErr: s.error
@@ -894,8 +872,6 @@ proc getProtocol(name: string): MAProtocol {.inline.} =
 proc init*(mtype: typedesc[MultiAddress],
           value: string): MaResult[MultiAddress] =
  ## Initialize MultiAddress object from string representation ``value``.
-  if len(value) == 0 or value == "/":
-    return err("multiaddress: Address must not be empty!")
  var parts = value.trimRight('/').split('/')
  if len(parts[0]) != 0:
    err("multiaddress: Invalid MultiAddress, must start with `/`")
@@ -943,7 +919,7 @@ proc init*(mtype: typedesc[MultiAddress],
           data: openArray[byte]): MaResult[MultiAddress] =
  ## Initialize MultiAddress with array of bytes ``data``.
  if len(data) == 0:
-    err("multiaddress: Address must not be empty!")
+    err("multiaddress: Address could not be empty!")
  else:
    var res: MultiAddress
    res.data = initVBuffer()
@@ -958,7 +934,7 @@ proc init*(mtype: typedesc[MultiAddress]): MultiAddress =
  ## Initialize empty MultiAddress.
  result.data = initVBuffer()

-proc init*(mtype: typedesc[MultiAddress], address: IpAddress,
+proc init*(mtype: typedesc[MultiAddress], address: ValidIpAddress,
           protocol: IpTransportProtocol, port: Port): MultiAddress =
  var res: MultiAddress
  res.data = initVBuffer()
@@ -1029,7 +1005,7 @@ proc append*(m1: var MultiAddress, m2: MultiAddress): MaResult[void] =
    ok()

 proc `&`*(m1, m2: MultiAddress): MultiAddress {.
-     raises: [LPError].} =
+     raises: [Defect, LPError].} =
  ## Concatenates two addresses ``m1`` and ``m2``, and returns result.
  ##
  ## This procedure performs validation of concatenated result and can raise
@@ -1039,7 +1015,7 @@ proc `&`*(m1, m2: MultiAddress): MultiAddress {.
  concat(m1, m2).tryGet()

 proc `&=`*(m1: var MultiAddress, m2: MultiAddress) {.
-     raises: [LPError].} =
+     raises: [Defect, LPError].} =
  ## Concatenates two addresses ``m1`` and ``m2``.
  ##
  ## This procedure performs validation of concatenated result and can raise
@@ -1083,15 +1059,19 @@ proc matchPart(pat: MaPattern, protos: seq[MultiCodec]): MaPatResult =
 proc match*(pat: MaPattern, address: MultiAddress): bool =
  ## Match full ``address`` using pattern ``pat`` and return ``true`` if
  ## ``address`` satisfies pattern.
-  let protos = address.protocols().valueOr: return false
-  let res = matchPart(pat, protos)
+  let protos = address.protocols()
+  if protos.isErr():
+    return false
+  let res = matchPart(pat, protos.get())
  res.flag and (len(res.rem) == 0)

 proc matchPartial*(pat: MaPattern, address: MultiAddress): bool =
  ## Match prefix part of ``address`` using pattern ``pat`` and return
  ## ``true`` if ``address`` starts with pattern.
-  let protos = address.protocols().valueOr: return false
-  let res = matchPart(pat, protos)
+  let protos = address.protocols()
+  if protos.isErr():
+    return false
+  let res = matchPart(pat, protos.get())
  res.flag

 proc `$`*(pat: MaPattern): string =
@@ -1120,16 +1100,16 @@ proc getField*(pb: ProtoBuffer, field: int,
  if not(res):
    ok(false)
  else:
-    value = MultiAddress.init(buffer).valueOr: return err(ProtoError.IncorrectBlob)
-    ok(true)
+    let ma = MultiAddress.init(buffer)
+    if ma.isOk():
+      value = ma.get()
+      ok(true)
+    else:
+      err(ProtoError.IncorrectBlob)

 proc getRepeatedField*(pb: ProtoBuffer, field: int,
                       value: var seq[MultiAddress]): ProtoResult[bool] {.
     inline.} =
-  ## Read repeated field from protobuf message. ``field`` is field number. If the message is malformed, an error is returned.
-  ## If field is not present in message, then ``ok(false)`` is returned and value is empty. If field is present,
-  ## but no items could be parsed, then ``err(ProtoError.IncorrectBlob)`` is returned and value is empty.
-  ## If field is present and some item could be parsed, then ``true`` is returned and value contains the parsed values.
  var items: seq[seq[byte]]
  value.setLen(0)
  let res = ? pb.getRepeatedField(field, items)
@@ -1137,12 +1117,10 @@ proc getRepeatedField*(pb: ProtoBuffer, field: int,
    ok(false)
  else:
    for item in items:
-      let ma = MultiAddress.init(item).valueOr:
-        debug "Unsupported MultiAddress in blob", ma = item
-        continue
-
-      value.add(ma)
-    if value.len == 0:
-      err(ProtoError.IncorrectBlob)
-    else:
-      ok(true)
+      let ma = MultiAddress.init(item)
+      if ma.isOk():
+        value.add(ma.get())
+      else:
+        value.setLen(0)
+        return err(ProtoError.IncorrectBlob)
+    ok(true)
--- a/libp2p/multibase.nim
+++ b/libp2p/multibase.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -13,7 +13,10 @@
 ## 1. base32z
 ##

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import tables
 import stew/[base32, base58, base64, results]
@@ -24,17 +27,17 @@ type

  MultiBase* = object

-  MBCodeSize = proc(length: int): int {.nimcall, gcsafe, noSideEffect, raises: [].}
+  MBCodeSize = proc(length: int): int {.nimcall, gcsafe, noSideEffect, raises: [Defect].}

  MBCodec = object
    code: char
    name: string
    encr: proc(inbytes: openArray[byte],
               outbytes: var openArray[char],
-               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [].}
+               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
    decr: proc(inbytes: openArray[char],
               outbytes: var openArray[byte],
-               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [].}
+               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
    encl: MBCodeSize
    decl: MBCodeSize

--- a/libp2p/multicodec.nim
+++ b/libp2p/multicodec.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,13 +9,18 @@

 ## This module implements MultiCodec.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import tables, hashes
 import varint, vbuffer
 import stew/results
 export results

+{.deadCodeElim: on.}
+
 ## List of officially supported codecs can BE found here
 ## https://github.com/multiformats/multicodec/blob/master/table.csv
 const MultiCodecList = [
@@ -191,11 +196,9 @@ const MultiCodecList = [
  ("p2p", 0x01A5),
  ("http", 0x01E0),
  ("https", 0x01BB),
-  ("tls", 0x01C0),
  ("quic", 0x01CC),
-  ("quic-v1", 0x01CD),
  ("ws", 0x01DD),
-  ("wss", 0x01DE),
+  ("wss", 0x01DE), # not in multicodec list
  ("p2p-websocket-star", 0x01DF), # not in multicodec list
  ("p2p-webrtc-star", 0x0113), # not in multicodec list
  ("p2p-webrtc-direct", 0x0114), # not in multicodec list
--- a/libp2p/multihash.nim
+++ b/libp2p/multihash.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -21,7 +21,10 @@
 ## 1. SKEIN
 ## 2. MURMUR

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import tables
 import nimcrypto/[sha, sha2, keccak, blake2, hash, utils]
@@ -42,7 +45,7 @@ const

 type
  MHashCoderProc* = proc(data: openArray[byte],
-                         output: var openArray[byte]) {.nimcall, gcsafe, noSideEffect, raises: [].}
+                         output: var openArray[byte]) {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
  MHash* = object
    mcodec*: MultiCodec
    size*: int
--- a/libp2p/multistream.nim
+++ b/libp2p/multistream.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[strutils, sequtils, tables]
 import chronos, chronicles, stew/byteutils
@@ -18,14 +21,15 @@ logScope:
  topics = "libp2p multistream"

 const
-  MsgSize = 1024
-  Codec = "/multistream/1.0.0"
+  MsgSize* = 1024
+  Codec* = "/multistream/1.0.0"

-  Na = "na\n"
-  Ls = "ls\n"
+  MSCodec* = "\x13" & Codec & "\n"
+  Na* = "\x03na\n"
+  Ls* = "\x03ls\n"

 type
-  Matcher* = proc (proto: string): bool {.gcsafe, raises: [].}
+  Matcher* = proc (proto: string): bool {.gcsafe, raises: [Defect].}

  MultiStreamError* = object of LPError

@@ -41,7 +45,7 @@ type

 proc new*(T: typedesc[MultistreamSelect]): T =
  T(
-    codec: Codec,
+    codec: MSCodec,
  )

 template validateSuffix(str: string): untyped =
@@ -50,13 +54,13 @@ template validateSuffix(str: string): untyped =
    else:
      raise newException(MultiStreamError, "MultistreamSelect failed, malformed message")

-proc select*(_: MultistreamSelect | type MultistreamSelect,
+proc select*(m: MultistreamSelect,
             conn: Connection,
             proto: seq[string]):
             Future[string] {.async.} =
-  trace "initiating handshake", conn, codec = Codec
+  trace "initiating handshake", conn, codec = m.codec
  ## select a remote protocol
-  await conn.writeLp(Codec & "\n") # write handshake
+  await conn.write(m.codec) # write handshake
  if proto.len() > 0:
    trace "selecting proto", conn, proto = proto[0]
    await conn.writeLp((proto[0] & "\n")) # select proto
@@ -98,13 +102,13 @@ proc select*(_: MultistreamSelect | type MultistreamSelect,
      # No alternatives, fail
      return ""

-proc select*(_: MultistreamSelect | type MultistreamSelect,
+proc select*(m: MultistreamSelect,
             conn: Connection,
             proto: string): Future[bool] {.async.} =
  if proto.len > 0:
-    return (await MultistreamSelect.select(conn, @[proto])) == proto
+    return (await m.select(conn, @[proto])) == proto
  else:
-    return (await MultistreamSelect.select(conn, @[])) == Codec
+    return (await m.select(conn, @[])) == Codec

 proc select*(m: MultistreamSelect, conn: Connection): Future[bool] =
  m.select(conn, "")
@@ -115,7 +119,7 @@ proc list*(m: MultistreamSelect,
  if not await m.select(conn):
    return

-  await conn.writeLp(Ls) # send ls
+  await conn.write(Ls) # send ls

  var list = newSeq[string]()
  let ms = string.fromBytes(await conn.readLp(MsgSize))
@@ -125,85 +129,68 @@ proc list*(m: MultistreamSelect,

  result = list

-proc handle*(
-  _: type MultistreamSelect,
-  conn: Connection,
-  protos: seq[string],
-  matchers = newSeq[Matcher](),
-  active: bool = false,
-  ): Future[string] {.async.} =
-  trace "Starting multistream negotiation", conn, handshaked = active
-  var handshaked = active
-  while not conn.atEof:
-    var ms = string.fromBytes(await conn.readLp(MsgSize))
-    validateSuffix(ms)
-
-    if not handshaked and ms != Codec:
-      debug "expected handshake message", conn, instead=ms
-      raise newException(CatchableError,
-                         "MultistreamSelect handling failed, invalid first message")
-
-    trace "handle: got request", conn, ms
-    if ms.len() <= 0:
-      trace "handle: invalid proto", conn
-      await conn.writeLp(Na)
-
-    case ms:
-    of "ls":
-      trace "handle: listing protos", conn
-      #TODO this doens't seem to follow spec, each protocol
-      # should be length prefixed. Not very important
-      # since LS is getting deprecated
-      await conn.writeLp(protos.join("\n") & "\n")
-    of Codec:
-      if not handshaked:
-        await conn.writeLp(Codec & "\n")
-        handshaked = true
-      else:
-        trace "handle: sending `na` for duplicate handshake while handshaked",
-          conn
-        await conn.writeLp(Na)
-    elif ms in protos or matchers.anyIt(it(ms)):
-      trace "found handler", conn, protocol = ms
-      await conn.writeLp(ms & "\n")
-      conn.protocol = ms
-      return ms
-    else:
-      trace "no handlers", conn, protocol = ms
-      await conn.writeLp(Na)
-
-proc handle*(m: MultistreamSelect, conn: Connection, active: bool = false) {.async.} =
+proc handle*(m: MultistreamSelect, conn: Connection, active: bool = false) {.async, gcsafe.} =
  trace "Starting multistream handler", conn, handshaked = active
-  var
-    protos: seq[string]
-    matchers: seq[Matcher]
-  for h in m.handlers:
-    if not isNil(h.match):
-      matchers.add(h.match)
-    for proto in h.protos:
-      protos.add(proto)
-
+  var handshaked = active
  try:
-    let ms = await MultistreamSelect.handle(conn, protos, matchers, active)
-    for h in m.handlers:
-      if (not isNil(h.match) and h.match(ms)) or h.protos.contains(ms):
-        trace "found handler", conn, protocol = ms
+    while not conn.atEof:
+      var ms = string.fromBytes(await conn.readLp(MsgSize))
+      validateSuffix(ms)

-        var protocolHolder = h
-        let maxIncomingStreams = protocolHolder.protocol.maxIncomingStreams
-        if protocolHolder.openedStreams.getOrDefault(conn.peerId) >= maxIncomingStreams:
-          debug "Max streams for protocol reached, blocking new stream",
-            conn, protocol = ms, maxIncomingStreams
-          return
-        protocolHolder.openedStreams.inc(conn.peerId)
-        try:
-          await protocolHolder.protocol.handler(conn, ms)
-        finally:
-          protocolHolder.openedStreams.inc(conn.peerId, -1)
-          if protocolHolder.openedStreams[conn.peerId] == 0:
-            protocolHolder.openedStreams.del(conn.peerId)
-        return
-    debug "no handlers", conn, ms
+      if not handshaked and ms != Codec:
+        notice "expected handshake message", conn, instead=ms
+        raise newException(CatchableError,
+                           "MultistreamSelect handling failed, invalid first message")
+
+      trace "handle: got request", conn, ms
+      if ms.len() <= 0:
+        trace "handle: invalid proto", conn
+        await conn.write(Na)
+
+      if m.handlers.len() == 0:
+        trace "handle: sending `na` for protocol", conn, protocol = ms
+        await conn.write(Na)
+        continue
+
+      case ms:
+      of "ls":
+        trace "handle: listing protos", conn
+        var protos = ""
+        for h in m.handlers:
+          for proto in h.protos:
+            protos &= (proto & "\n")
+        await conn.writeLp(protos)
+      of Codec:
+        if not handshaked:
+          await conn.write(m.codec)
+          handshaked = true
+        else:
+          trace "handle: sending `na` for duplicate handshake while handshaked",
+            conn
+          await conn.write(Na)
+      else:
+        for h in m.handlers:
+          if (not isNil(h.match) and h.match(ms)) or h.protos.contains(ms):
+            trace "found handler", conn, protocol = ms
+
+            var protocolHolder = h
+            let maxIncomingStreams = protocolHolder.protocol.maxIncomingStreams
+            if protocolHolder.openedStreams.getOrDefault(conn.peerId) >= maxIncomingStreams:
+              debug "Max streams for protocol reached, blocking new stream",
+                conn, protocol = ms, maxIncomingStreams
+              return
+            protocolHolder.openedStreams.inc(conn.peerId)
+            try:
+              await conn.writeLp(ms & "\n")
+              conn.protocol = ms
+              await protocolHolder.protocol.handler(conn, ms)
+            finally:
+              protocolHolder.openedStreams.inc(conn.peerId, -1)
+              if protocolHolder.openedStreams[conn.peerId] == 0:
+                protocolHolder.openedStreams.del(conn.peerId)
+            return
+        debug "no handlers", conn, protocol = ms
+        await conn.write(Na)
  except CancelledError as exc:
    raise exc
  except CatchableError as exc:
--- a/libp2p/muxers/mplex/coder.nim
+++ b/libp2p/muxers/mplex/coder.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import pkg/[chronos, chronicles, stew/byteutils]
+import pkg/[chronos, nimcrypto/utils, chronicles, stew/byteutils]
 import ../../stream/connection,
       ../../utility,
       ../../varint,
@@ -42,7 +45,7 @@ const MaxMsgSize* = 1 shl 20 # 1mb
 proc newInvalidMplexMsgType*(): ref InvalidMplexMsgType =
  newException(InvalidMplexMsgType, "invalid message type")

-proc readMsg*(conn: Connection): Future[Msg] {.async.} =
+proc readMsg*(conn: Connection): Future[Msg] {.async, gcsafe.} =
  let header = await conn.readVarint()
  trace "read header varint", varint = header, conn

--- a/libp2p/muxers/mplex/lpchannel.nim
+++ b/libp2p/muxers/mplex/lpchannel.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[oids, strformat]
-import pkg/[chronos, chronicles, metrics]
+import pkg/[chronos, chronicles, metrics, nimcrypto/utils]
 import ./coder,
       ../muxer,
       ../../stream/[bufferstream, connection, streamseq],
@@ -73,7 +76,7 @@ func shortLog*(s: LPChannel): auto =

 chronicles.formatIt(LPChannel): shortLog(it)

-proc open*(s: LPChannel) {.async.} =
+proc open*(s: LPChannel) {.async, gcsafe.} =
  trace "Opening channel", s, conn = s.conn
  if s.conn.isClosed:
    return
@@ -95,7 +98,7 @@ proc closeUnderlying(s: LPChannel): Future[void] {.async.} =
  if s.closedLocal and s.atEof():
    await procCall BufferStream(s).close()

-proc reset*(s: LPChannel) {.async.} =
+proc reset*(s: LPChannel) {.async, gcsafe.} =
  if s.isClosed:
    trace "Already closed", s
    return
@@ -123,7 +126,7 @@ proc reset*(s: LPChannel) {.async.} =

  trace "Channel reset", s

-method close*(s: LPChannel) {.async.} =
+method close*(s: LPChannel) {.async, gcsafe.} =
  ## Close channel for writing - a message will be sent to the other peer
  ## informing them that the channel is closed and that we're waiting for
  ## their acknowledgement.
@@ -233,7 +236,7 @@ proc completeWrite(
    else:
      await fut

-    when defined(libp2p_network_protocols_metrics):
+    when defined(libp2p_network_protocol_metrics):
      if s.protocol.len > 0:
        libp2p_protocols_bytes.inc(msgLen.int64, labelValues=[s.protocol, "out"])

@@ -241,11 +244,7 @@ proc completeWrite(
  except CancelledError as exc:
    # Chronos may still send the data
    raise exc
-  except LPStreamConnDownError as exc:
-    await s.reset()
-    await s.conn.close()
-    raise exc
-  except LPStreamEOFError as exc:
+  except LPStreamClosedError as exc:
    raise exc
  except CatchableError as exc:
    trace "exception in lpchannel write handler", s, msg = exc.msg
--- a/libp2p/muxers/mplex/mplex.nim
+++ b/libp2p/muxers/mplex/mplex.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import tables, sequtils, oids
 import chronos, chronicles, stew/byteutils, metrics
@@ -76,7 +79,7 @@ proc newStreamInternal*(m: Mplex,
                        chanId: uint64 = 0,
                        name: string = "",
                        timeout: Duration): LPChannel
-                        {.gcsafe, raises: [InvalidChannelIdError].} =
+                        {.gcsafe, raises: [Defect, InvalidChannelIdError].} =
  ## create new channel/stream
  ##
  let id = if initiator:
@@ -122,7 +125,7 @@ proc handleStream(m: Mplex, chann: LPChannel) {.async.} =
    trace "Exception in mplex stream handler", m, chann, msg = exc.msg
    await chann.reset()

-method handle*(m: Mplex) {.async.} =
+method handle*(m: Mplex) {.async, gcsafe.} =
  trace "Starting mplex handler", m
  try:
    while not m.connection.atEof:
@@ -174,14 +177,8 @@ method handle*(m: Mplex) {.async.} =
            raise newLPStreamLimitError()

          trace "pushing data to channel", m, channel, len = data.len
-          try:
-            await channel.pushData(data)
-            trace "pushed data to channel", m, channel, len = data.len
-          except LPStreamClosedError as exc:
-            # Channel is being closed, but `cleanupChann` was not yet triggered.
-            trace "pushing data to channel failed", m, channel, len = data.len,
-              msg = exc.msg
-            discard  # Ignore message, same as if `cleanupChann` had completed.
+          await channel.pushData(data)
+          trace "pushed data to channel", m, channel, len = data.len

        of MessageType.CloseIn, MessageType.CloseOut:
          await channel.pushEof()
@@ -200,8 +197,7 @@ method handle*(m: Mplex) {.async.} =

 proc new*(M: type Mplex,
           conn: Connection,
-           inTimeout: Duration = DefaultChanTimeout,
-           outTimeout: Duration = DefaultChanTimeout,
+           inTimeout, outTimeout: Duration = DefaultChanTimeout,
           maxChannCount: int = MaxChannelCount): Mplex =
  M(connection: conn,
    inChannTimeout: inTimeout,
@@ -211,7 +207,7 @@ proc new*(M: type Mplex,

 method newStream*(m: Mplex,
                  name: string = "",
-                  lazy: bool = false): Future[Connection] {.async.} =
+                  lazy: bool = false): Future[Connection] {.async, gcsafe.} =
  let channel = m.newStreamInternal(timeout = m.inChannTimeout)

  if not lazy:
@@ -219,7 +215,7 @@ method newStream*(m: Mplex,

  return Connection(channel)

-method close*(m: Mplex) {.async.} =
+method close*(m: Mplex) {.async, gcsafe.} =
  if m.isClosed:
    trace "Already closed", m
    return
@@ -246,7 +242,3 @@ method close*(m: Mplex) {.async.} =
  m.channels[true].clear()

  trace "Closed mplex", m
-
-method getStreams*(m: Mplex): seq[Connection] =
-  for c in m.channels[false].values: result.add(c)
-  for c in m.channels[true].values: result.add(c)
--- a/libp2p/muxers/muxer.nim
+++ b/libp2p/muxers/muxer.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos, chronicles
-import ../stream/connection,
+import ../protocols/protocol,
+       ../stream/connection,
       ../errors

 logScope:
@@ -23,41 +27,66 @@ type
  MuxerError* = object of LPError
  TooManyChannels* = object of MuxerError

-  StreamHandler* = proc(conn: Connection): Future[void] {.gcsafe, raises: [].}
-  MuxerHandler* = proc(muxer: Muxer): Future[void] {.gcsafe, raises: [].}
+  StreamHandler* = proc(conn: Connection): Future[void] {.gcsafe, raises: [Defect].}
+  MuxerHandler* = proc(muxer: Muxer): Future[void] {.gcsafe, raises: [Defect].}

  Muxer* = ref object of RootObj
    streamHandler*: StreamHandler
-    handler*: Future[void]
    connection*: Connection

  # user provider proc that returns a constructed Muxer
-  MuxerConstructor* = proc(conn: Connection): Muxer {.gcsafe, closure, raises: [].}
+  MuxerConstructor* = proc(conn: Connection): Muxer {.gcsafe, closure, raises: [Defect].}

  # this wraps a creator proc that knows how to make muxers
-  MuxerProvider* = object
+  MuxerProvider* = ref object of LPProtocol
    newMuxer*: MuxerConstructor
-    codec*: string
+    streamHandler*: StreamHandler # triggered every time there is a new stream, called for any muxer instance
+    muxerHandler*: MuxerHandler # triggered every time there is a new muxed connection created

-func shortLog*(m: Muxer): auto =
-  if isNil(m): "nil"
-  else: shortLog(m.connection)
+func shortLog*(m: Muxer): auto = shortLog(m.connection)
 chronicles.formatIt(Muxer): shortLog(it)

 # muxer interface
 method newStream*(m: Muxer, name: string = "", lazy: bool = false):
-  Future[Connection] {.base, async.} = discard
-method close*(m: Muxer) {.base, async.} =
-  if not isNil(m.connection):
-    await m.connection.close()
-method handle*(m: Muxer): Future[void] {.base, async.} = discard
+  Future[Connection] {.base, async, gcsafe.} = discard
+method close*(m: Muxer) {.base, async, gcsafe.} = discard
+method handle*(m: Muxer): Future[void] {.base, async, gcsafe.} = discard

 proc new*(
  T: typedesc[MuxerProvider],
  creator: MuxerConstructor,
  codec: string): T {.gcsafe.} =

-  let muxerProvider = T(newMuxer: creator, codec: codec)
+  let muxerProvider = T(newMuxer: creator)
+  muxerProvider.codec = codec
+  muxerProvider.init()
  muxerProvider

-method getStreams*(m: Muxer): seq[Connection] {.base.} = doAssert false, "not implemented"
+method init(c: MuxerProvider) =
+  proc handler(conn: Connection, proto: string) {.async, gcsafe, closure.} =
+    trace "starting muxer handler", proto=proto, conn
+    try:
+      let
+        muxer = c.newMuxer(conn)
+
+      if not isNil(c.streamHandler):
+        muxer.streamHandler = c.streamHandler
+
+      var futs = newSeq[Future[void]]()
+      futs &= muxer.handle()
+
+      # finally await both the futures
+      if not isNil(c.muxerHandler):
+        await c.muxerHandler(muxer)
+        when defined(libp2p_agents_metrics):
+          conn.shortAgent = muxer.connection.shortAgent
+
+      checkFutures(await allFinished(futs))
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "exception in muxer handler", exc = exc.msg, conn, proto
+    finally:
+      await conn.close()
+
+  c.handler = handler
--- a/libp2p/muxers/yamux/yamux.nim
+++ b/libp2p/muxers/yamux/yamux.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import sequtils, std/[tables]
 import chronos, chronicles, metrics, stew/[endians2, byteutils, objects]
@@ -22,16 +25,15 @@ logScope:
 const
  YamuxCodec* = "/yamux/1.0.0"
  YamuxVersion = 0.uint8
-  YamuxDefaultWindowSize* = 256000
-  MaxSendQueueSize = 256000
+  DefaultWindowSize = 256000
  MaxChannelCount = 200

 when defined(libp2p_yamux_metrics):
  declareGauge(libp2p_yamux_channels, "yamux channels", labels = ["initiator", "peer"])
  declareHistogram libp2p_yamux_send_queue, "message send queue length (in byte)",
-    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
+    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 1600.0, 6400.0, 25600.0, 256000.0]
  declareHistogram libp2p_yamux_recv_queue, "message recv queue length (in byte)",
-    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
+    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 1600.0, 6400.0, 25600.0, 256000.0]

 type
  YamuxError* = object of CatchableError
@@ -60,7 +62,7 @@ type
    streamId: uint32
    length: uint32

-proc readHeader(conn: LPStream): Future[YamuxHeader] {.async.} =
+proc readHeader(conn: LPStream): Future[YamuxHeader] {.async, gcsafe.} =
  var buffer: array[12, byte]
  await conn.readExactly(addr buffer[0], 12)

@@ -82,7 +84,7 @@ proc `$`(header: YamuxHeader): string =
 proc encode(header: YamuxHeader): array[12, byte] =
  result[0] = header.version
  result[1] = uint8(header.msgType)
-  result[2..3] = toBytesBE(uint16(cast[uint8](header.flags))) # workaround https://github.com/nim-lang/Nim/issues/21789
+  result[2..3] = toBytesBE(cast[uint16](header.flags))
  result[4..7] = toBytesBE(header.streamId)
  result[8..11] = toBytesBE(header.length)

@@ -144,7 +146,6 @@ type
    recvWindow: int
    sendWindow: int
    maxRecvWindow: int
-    maxSendQueueSize: int
    conn: Connection
    isSrc: bool
    opened: bool
@@ -171,18 +172,9 @@ proc `$`(channel: YamuxChannel): string =
  if s.len > 0:
    result &= " {" & s.foldl(if a != "": a & ", " & b else: b, "") & "}"

-proc lengthSendQueue(channel: YamuxChannel): int =
-  ## Returns the length of what remains to be sent
-  ##
-  channel.sendQueue.foldl(a + b.data.len - b.sent, 0)
-
-proc lengthSendQueueWithLimit(channel: YamuxChannel): int =
-  ## Returns the length of what remains to be sent, but limit the size of big messages.
-  ##
-  # For leniency, limit big messages size to the third of maxSendQueueSize
-  # This value is arbitrary, it's not in the specs, it permits to store up to
-  # 3 big messages if the peer is stalling.
-  channel.sendQueue.foldl(a + min(b.data.len - b.sent, channel.maxSendQueueSize div 3), 0)
+proc sendQueueBytes(channel: YamuxChannel, limit: bool = false): int =
+  for (elem, sent, _) in channel.sendQueue:
+    result.inc(min(elem.len - sent, if limit: channel.maxRecvWindow div 3 else: elem.len - sent))

 proc actuallyClose(channel: YamuxChannel) {.async.} =
  if channel.closedLocally and channel.sendQueue.len == 0 and
@@ -194,19 +186,15 @@ proc remoteClosed(channel: YamuxChannel) {.async.} =
    channel.closedRemotely.complete()
    await channel.actuallyClose()

-method closeImpl*(channel: YamuxChannel) {.async.} =
+method closeImpl*(channel: YamuxChannel) {.async, gcsafe.} =
  if not channel.closedLocally:
    channel.closedLocally = true
-    channel.isEof = true

    if channel.isReset == false and channel.sendQueue.len == 0:
      await channel.conn.write(YamuxHeader.data(channel.id, 0, {Fin}))
    await channel.actuallyClose()

 proc reset(channel: YamuxChannel, isLocal: bool = false) {.async.} =
-  # If we reset locally, we want to flush up to a maximum of recvWindow
-  # bytes. It's because the peer we're connected to can send us data before
-  # it receives the reset.
  if channel.isReset:
    return
  trace "Reset channel"
@@ -227,14 +215,11 @@ proc reset(channel: YamuxChannel, isLocal: bool = false) {.async.} =
    await channel.remoteClosed()
  channel.receivedData.fire()
  if not isLocal:
-    # If the reset is remote, there's no reason to flush anything.
+    # If we reset locally, we want to flush up to a maximum of recvWindow
+    # bytes. We use the recvWindow in the proc cleanupChann.
    channel.recvWindow = 0

 proc updateRecvWindow(channel: YamuxChannel) {.async.} =
-  ## Send to the peer a window update when the recvWindow is empty enough
-  ##
-  # In order to avoid spamming a window update everytime a byte is read,
-  # we send it everytime half of the maxRecvWindow is read.
  let inWindow = channel.recvWindow + channel.recvQueue.len
  if inWindow > channel.maxRecvWindow div 2:
    return
@@ -252,7 +237,6 @@ method readOnce*(
  pbytes: pointer,
  nbytes: int):
  Future[int] {.async.} =
-  ## Read from a yamux channel

  if channel.isReset:
    raise if channel.remoteReset:
@@ -268,7 +252,6 @@ method readOnce*(
    await channel.closedRemotely or channel.receivedData.wait()
    if channel.closedRemotely.done() and channel.recvQueue.len == 0:
      channel.returnedEof = true
-      channel.isEof = true
      return 0

  let toRead = min(channel.recvQueue.len, nbytes)
@@ -298,22 +281,21 @@ proc trySend(channel: YamuxChannel) {.async.} =
    return
  channel.isSending = true
  defer: channel.isSending = false
-
  while channel.sendQueue.len != 0:
    channel.sendQueue.keepItIf(not (it.fut.cancelled() and it.sent == 0))
    if channel.sendWindow == 0:
-      trace "trying to send while the sendWindow is empty"
-      if channel.lengthSendQueueWithLimit() > channel.maxSendQueueSize:
-        trace "channel send queue too big, resetting", maxSendQueueSize=channel.maxSendQueueSize,
-          currentQueueSize = channel.lengthSendQueueWithLimit()
+      trace "send window empty"
+      if channel.sendQueueBytes(true) > channel.maxRecvWindow:
+        debug "channel send queue too big, resetting", maxSendWindow=channel.maxRecvWindow,
+          currentQueueSize = channel.sendQueueBytes(true)
        try:
          await channel.reset(true)
        except CatchableError as exc:
-          warn "failed to reset", msg=exc.msg
+          debug "failed to reset", msg=exc.msg
      break

    let
-      bytesAvailable = channel.lengthSendQueue()
+      bytesAvailable = channel.sendQueueBytes()
      toSend = min(channel.sendWindow, bytesAvailable)
    var
      sendBuffer = newSeqUninitialized[byte](toSend + 12)
@@ -328,24 +310,20 @@ proc trySend(channel: YamuxChannel) {.async.} =

    var futures: seq[Future[void]]
    while inBuffer < toSend:
-      # concatenate the different message we try to send into one buffer
      let (data, sent, fut) = channel.sendQueue[0]
      let bufferToSend = min(data.len - sent, toSend - inBuffer)
      sendBuffer.toOpenArray(12, 12 + toSend - 1)[inBuffer..<(inBuffer+bufferToSend)] =
        channel.sendQueue[0].data.toOpenArray(sent, sent + bufferToSend - 1)
      channel.sendQueue[0].sent.inc(bufferToSend)
      if channel.sendQueue[0].sent >= data.len:
-        # if every byte of the message is in the buffer, add the write future to the
-        # sequence of futures to be completed (or failed) when the buffer is sent
        futures.add(fut)
        channel.sendQueue.delete(0)
      inBuffer.inc(bufferToSend)

-    trace "try to send the buffer", h = $header
+    trace "build send buffer", h = $header, msg=string.fromBytes(sendBuffer[12..^1])
    channel.sendWindow.dec(toSend)
    try: await channel.conn.write(sendBuffer)
    except CatchableError as exc:
-      trace "failed to send the buffer"
      let connDown = newLPStreamConnDownError(exc)
      for fut in futures.items():
        fut.fail(connDown)
@@ -356,8 +334,6 @@ proc trySend(channel: YamuxChannel) {.async.} =
    channel.activity = true

 method write*(channel: YamuxChannel, msg: seq[byte]): Future[void] =
-  ## Write to yamux channel
-  ##
  result = newFuture[void]("Yamux Send")
  if channel.remoteReset:
    result.fail(newLPStreamResetError())
@@ -370,22 +346,15 @@ method write*(channel: YamuxChannel, msg: seq[byte]): Future[void] =
    return result
  channel.sendQueue.add((msg, 0, result))
  when defined(libp2p_yamux_metrics):
-    libp2p_yamux_send_queue.observe(channel.lengthSendQueue().int64)
+    libp2p_yamux_recv_queue.observe(channel.sendQueueBytes().int64)
  asyncSpawn channel.trySend()

-proc open(channel: YamuxChannel) {.async.} =
-  ## Open a yamux channel by sending a window update with Syn or Ack flag
-  ##
+proc open*(channel: YamuxChannel) {.async, gcsafe.} =
  if channel.opened:
    trace "Try to open channel twice"
    return
  channel.opened = true
-  await channel.conn.write(YamuxHeader.windowUpdate(
-    channel.id,
-    uint32(max(channel.maxRecvWindow - YamuxDefaultWindowSize, 0)),
-    {if channel.isSrc: Syn else: Ack}))
-
-method getWrapped*(channel: YamuxChannel): Connection = channel.conn
+  await channel.conn.write(YamuxHeader.data(channel.id, 0, {if channel.isSrc: Syn else: Ack}))

 type
  Yamux* = ref object of Muxer
@@ -394,14 +363,12 @@ type
    currentId: uint32
    isClosed: bool
    maxChannCount: int
-    windowSize: int
-    maxSendQueueSize: int

 proc lenBySrc(m: Yamux, isSrc: bool): int =
  for v in m.channels.values():
    if v.isSrc == isSrc: result += 1

-proc cleanupChannel(m: Yamux, channel: YamuxChannel) {.async.} =
+proc cleanupChann(m: Yamux, channel: YamuxChannel) {.async.} =
  await channel.join()
  m.channels.del(channel.id)
  when defined(libp2p_yamux_metrics):
@@ -409,19 +376,12 @@ proc cleanupChannel(m: Yamux, channel: YamuxChannel) {.async.} =
  if channel.isReset and channel.recvWindow > 0:
    m.flushed[channel.id] = channel.recvWindow

-proc createStream(m: Yamux, id: uint32, isSrc: bool,
-                  recvWindow: int, maxSendQueueSize: int): YamuxChannel =
-  # As you can see, during initialization, recvWindow can be larger than maxRecvWindow.
-  # This is because the peer we're connected to will always assume
-  # that the initial recvWindow is 256k.
-  # To solve this contradiction, no updateWindow will be sent until recvWindow is less
-  # than maxRecvWindow
+proc createStream(m: Yamux, id: uint32, isSrc: bool): YamuxChannel =
  result = YamuxChannel(
    id: id,
-    maxRecvWindow: recvWindow,
-    recvWindow: if recvWindow > YamuxDefaultWindowSize: recvWindow else: YamuxDefaultWindowSize,
-    sendWindow: YamuxDefaultWindowSize,
-    maxSendQueueSize: maxSendQueueSize,
+    maxRecvWindow: DefaultWindowSize,
+    recvWindow: DefaultWindowSize,
+    sendWindow: DefaultWindowSize,
    isSrc: isSrc,
    conn: m.connection,
    receivedData: newAsyncEvent(),
@@ -439,7 +399,7 @@ proc createStream(m: Yamux, id: uint32, isSrc: bool,
  when defined(libp2p_agents_metrics):
    result.shortAgent = m.connection.shortAgent
  m.channels[id] = result
-  asyncSpawn m.cleanupChannel(result)
+  asyncSpawn m.cleanupChann(result)
  trace "created channel", id, pid=m.connection.peerId
  when defined(libp2p_yamux_metrics):
    libp2p_yamux_channels.set(m.lenBySrc(isSrc).int64, [$isSrc, $result.peerId])
@@ -454,13 +414,12 @@ method close*(m: Yamux) {.async.} =
  let channels = toSeq(m.channels.values())
  for channel in channels:
    await channel.reset(true)
-  try: await m.connection.write(YamuxHeader.goAway(NormalTermination))
-  except CatchableError as exc: trace "failed to send goAway", msg=exc.msg
+  await m.connection.write(YamuxHeader.goAway(NormalTermination))
  await m.connection.close()
  trace "Closed yamux"

 proc handleStream(m: Yamux, channel: YamuxChannel) {.async.} =
-  ## Call the muxer stream handler for this channel
+  ## call the muxer stream handler for this channel
  ##
  try:
    await m.streamHandler(channel)
@@ -470,7 +429,7 @@ proc handleStream(m: Yamux, channel: YamuxChannel) {.async.} =
    trace "Exception in yamux stream handler", msg = exc.msg
    await channel.reset()

-method handle*(m: Yamux) {.async.} =
+method handle*(m: Yamux) {.async, gcsafe.} =
  trace "Starting yamux handler", pid=m.connection.peerId
  try:
    while not m.connection.atEof:
@@ -494,11 +453,9 @@ method handle*(m: Yamux) {.async.} =
          else:
            if header.streamId in m.flushed:
              m.flushed.del(header.streamId)
-
            if header.streamId mod 2 == m.currentId mod 2:
-              debug "Peer used our reserved stream id, skipping", id=header.streamId, currentId=m.currentId, peerId=m.connection.peerId
              raise newException(YamuxError, "Peer used our reserved stream id")
-            let newStream = m.createStream(header.streamId, false, m.windowSize, m.maxSendQueueSize)
+            let newStream = m.createStream(header.streamId, false)
            if m.channels.len >= m.maxChannCount:
              await newStream.reset()
              continue
@@ -548,30 +505,22 @@ method handle*(m: Yamux) {.async.} =
    await m.close()
  trace "Stopped yamux handler"

-method getStreams*(m: Yamux): seq[Connection] =
-  for c in m.channels.values: result.add(c)
-
 method newStream*(
  m: Yamux,
  name: string = "",
-  lazy: bool = false): Future[Connection] {.async.} =
+  lazy: bool = false): Future[Connection] {.async, gcsafe.} =

  if m.channels.len > m.maxChannCount - 1:
    raise newException(TooManyChannels, "max allowed channel count exceeded")
-  let stream = m.createStream(m.currentId, true, m.windowSize, m.maxSendQueueSize)
+  let stream = m.createStream(m.currentId, true)
  m.currentId += 2
  if not lazy:
    await stream.open()
  return stream

-proc new*(T: type[Yamux], conn: Connection,
-          maxChannCount: int = MaxChannelCount,
-          windowSize: int = YamuxDefaultWindowSize,
-          maxSendQueueSize: int = MaxSendQueueSize): T =
+proc new*(T: type[Yamux], conn: Connection, maxChannCount: int = MaxChannelCount): T =
  T(
    connection: conn,
    currentId: if conn.dir == Out: 1 else: 2,
-    maxChannCount: maxChannCount,
-    windowSize: windowSize,
-    maxSendQueueSize: maxSendQueueSize
+    maxChannCount: maxChannCount
  )
--- a/libp2p/nameresolving/dnsresolver.nim
+++ b/libp2p/nameresolving/dnsresolver.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,13 +7,15 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import
  std/[streams, strutils, sets, sequtils],
  chronos, chronicles, stew/byteutils,
-  dnsclientpkg/[protocol, types],
-  ../utility
+  dnsclientpkg/[protocol, types]

 import
  nameresolver
@@ -78,7 +80,9 @@ proc getDnsResponse(
    # parseResponse can has a raises: [Exception, ..] because of
    # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
    # it can't actually raise though
-    return exceptionToAssert: parseResponse(string.fromBytes(rawResponse))
+    return parseResponse(string.fromBytes(rawResponse))
+  except CatchableError as exc: raise exc
+  except Exception as exc: raiseAssert exc.msg
  finally:
    await sock.closeWait()

@@ -114,7 +118,9 @@ method resolveIp*(
          # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
          # it can't actually raise though
          resolvedAddresses.incl(
-            exceptionToAssert(answer.toString())
+            try: answer.toString()
+            except CatchableError as exc: raise exc
+            except Exception as exc: raiseAssert exc.msg
          )
      except CancelledError as e:
        raise e
@@ -145,13 +151,9 @@ method resolveTxt*(
  for _ in 0 ..< self.nameServers.len:
    let server = self.nameServers[0]
    try:
-      # toString can has a raises: [Exception, ..] because of
-      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
-      # it can't actually raise though
      let response = await getDnsResponse(server, address, TXT)
-      return exceptionToAssert:
-        trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
-        response.answers.mapIt(it.toString())
+      trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
+      return response.answers.mapIt(it.toString())
    except CancelledError as e:
      raise e
    except CatchableError as e:
@@ -159,6 +161,11 @@ method resolveTxt*(
      self.nameServers.add(self.nameServers[0])
      self.nameServers.delete(0)
      continue
+    except Exception as e:
+      # toString can has a raises: [Exception, ..] because of
+      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+      # it can't actually raise though
+      raiseAssert e.msg

  debug "Failed to resolve TXT, returning empty set"
  return @[]
--- a/libp2p/nameresolving/mockresolver.nim
+++ b/libp2p/nameresolving/mockresolver.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import
-  std/tables,
+  std/[streams, strutils, tables],
  chronos, chronicles

 import nameresolver
--- a/libp2p/nameresolving/nameresolver.nim
+++ b/libp2p/nameresolving/nameresolver.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,13 +7,16 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[sugar, sets, sequtils, strutils]
 import
  chronos,
  chronicles,
-  stew/endians2
+  stew/[endians2, byteutils]
 import ".."/[multiaddress, multicodec]

 logScope:
@@ -52,7 +55,7 @@ proc resolveOneAddress(
  ma: MultiAddress,
  domain: Domain = Domain.AF_UNSPEC,
  prefix = ""): Future[seq[MultiAddress]]
-  {.async.} =
+  {.async, raises: [Defect, MaError, TransportAddressError].} =
  #Resolve a single address
  var pbuf: array[2, byte]

@@ -118,7 +121,7 @@ proc resolveMAddress*(
  if not DNS.matchPartial(address):
    res.incl(address)
  else:
-    let code = address[0].tryGet().protoCode().tryGet()
+    let code = address[0].get().protoCode().get()
    let seq = case code:
      of multiCodec("dns"):
        await self.resolveOneAddress(address)
@@ -129,7 +132,7 @@ proc resolveMAddress*(
      of multiCodec("dnsaddr"):
        await self.resolveDnsAddr(address)
      else:
-        assert false
+        doAssert false
        @[address]
    for ad in seq:
      res.incl(ad)
--- a/libp2p/observedaddrmanager.nim
+++ b/libp2p/observedaddrmanager.nim
@@ -1,86 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/[sequtils, tables, sugar]
-import chronos
-import multiaddress, multicodec
-
-type
-  ## Manages observed MultiAddresses by reomte peers. It keeps track of the most observed IP and IP/Port.
-  ObservedAddrManager* = ref object of RootObj
-    observedIPsAndPorts: seq[MultiAddress]
-    maxSize: int
-    minCount: int
-
-proc addObservation*(self:ObservedAddrManager, observedAddr: MultiAddress): bool =
-  ## Adds a new observed MultiAddress. If the number of observations exceeds maxSize, the oldest one is removed.
-  if self.observedIPsAndPorts.len >= self.maxSize:
-      self.observedIPsAndPorts.del(0)
-  self.observedIPsAndPorts.add(observedAddr)
-  return true
-
-proc getProtocol(self: ObservedAddrManager, observations: seq[MultiAddress], multiCodec: MultiCodec): Opt[MultiAddress] =
-  var countTable = toCountTable(observations)
-  countTable.sort()
-  var orderedPairs = toSeq(countTable.pairs)
-  for (ma, count) in orderedPairs:
-    let protoCode = (ma[0].flatMap(protoCode)).valueOr: continue
-    if protoCode == multiCodec and count >= self.minCount:
-      return Opt.some(ma)
-  return Opt.none(MultiAddress)
-
-proc getMostObservedProtocol(self: ObservedAddrManager, multiCodec: MultiCodec): Opt[MultiAddress] =
-  ## Returns the most observed IP address or none if the number of observations are less than minCount.
-  let observedIPs = collect:
-    for observedIp in self.observedIPsAndPorts:
-      observedIp[0].valueOr: continue
-  return self.getProtocol(observedIPs, multiCodec)
-
-proc getMostObservedProtoAndPort(self: ObservedAddrManager, multiCodec: MultiCodec): Opt[MultiAddress] =
-  ## Returns the most observed IP/Port address or none if the number of observations are less than minCount.
-  return self.getProtocol(self.observedIPsAndPorts, multiCodec)
-
-proc getMostObservedProtosAndPorts*(self: ObservedAddrManager): seq[MultiAddress] =
-  ## Returns the most observed IP4/Port and IP6/Port address or an empty seq if the number of observations
-  ## are less than minCount.
-  var res: seq[MultiAddress]
-  self.getMostObservedProtoAndPort(multiCodec("ip4")).withValue(ip4):
-    res.add(ip4)
-  self.getMostObservedProtoAndPort(multiCodec("ip6")).withValue(ip6):
-    res.add(ip6)
-  return res
-
-proc guessDialableAddr*(
-  self: ObservedAddrManager,
-  ma: MultiAddress): MultiAddress =
-  ## Replaces the first proto value of each listen address by the corresponding (matching the proto code) most observed value.
-  ## If the most observed value is not available, the original MultiAddress is returned.
-  let
-    maFirst = ma[0].valueOr: return ma
-    maRest = ma[1..^1].valueOr: return ma
-    maFirstProto = maFirst.protoCode().valueOr: return ma
-
-  let observedIP = self.getMostObservedProtocol(maFirstProto).valueOr: return ma
-  return concat(observedIP, maRest).valueOr: ma
-
-proc `$`*(self: ObservedAddrManager): string =
-  ## Returns a string representation of the ObservedAddrManager.
-  return "IPs and Ports: " & $self.observedIPsAndPorts
-
-proc new*(
-  T: typedesc[ObservedAddrManager],
-  maxSize = 10,
-  minCount = 3): T =
-  ## Creates a new ObservedAddrManager.
-  return T(
-    observedIPsAndPorts: newSeq[MultiAddress](),
-    maxSize: maxSize,
-    minCount: minCount)
--- a/libp2p/peerid.nim
+++ b/libp2p/peerid.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,7 +9,10 @@

 ## This module implementes API for libp2p peer.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}

 import
@@ -41,7 +44,10 @@ func shortLog*(pid: PeerId): string =
  if len(spid) > 10:
    spid[3] = '*'

-    spid.delete(4 .. spid.high - 6)
+    when (NimMajor, NimMinor) > (1, 4):
+      spid.delete(4 .. spid.high - 6)
+    else:
+      spid.delete(4, spid.high - 6)

  spid

@@ -185,11 +191,19 @@ proc random*(t: typedesc[PeerId], rng = newRng()): Result[PeerId, cstring] =

 func match*(pid: PeerId, pubkey: PublicKey): bool =
  ## Returns ``true`` if ``pid`` matches public key ``pubkey``.
-  PeerId.init(pubkey) == Result[PeerId, cstring].ok(pid)
+  let p = PeerId.init(pubkey)
+  if p.isErr:
+    false
+  else:
+    pid == p.get()

 func match*(pid: PeerId, seckey: PrivateKey): bool =
  ## Returns ``true`` if ``pid`` matches private key ``seckey``.
-  PeerId.init(seckey) == Result[PeerId, cstring].ok(pid)
+  let p = PeerId.init(seckey)
+  if p.isErr:
+    false
+  else:
+    pid == p.get()

 ## Serialization/Deserialization helpers

--- a/libp2p/peerinfo.nim
+++ b/libp2p/peerinfo.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}

-import std/sequtils
+import std/[options, sequtils]
 import pkg/[chronos, chronicles, stew/results]
 import peerid, multiaddress, multicodec, crypto/crypto, routing_record, errors, utility

@@ -23,7 +26,7 @@ type

  AddressMapper* =
    proc(listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]]
-      {.gcsafe, raises: [].}
+      {.gcsafe, raises: [Defect].}

  PeerInfo* {.public.} = ref object
    peerId*: PeerId
@@ -53,12 +56,15 @@ proc update*(p: PeerInfo) {.async.} =
  for mapper in p.addressMappers:
    p.addrs = await mapper(p.addrs)

-  p.signedPeerRecord = SignedPeerRecord.init(
+  let sprRes = SignedPeerRecord.init(
    p.privateKey,
    PeerRecord.init(p.peerId, p.addrs)
-  ).valueOr():
-    info "Can't update the signed peer record"
-    return
+  )
+  if sprRes.isOk:
+    p.signedPeerRecord = sprRes.get()
+  else:
+    discard
+    #info "Can't update the signed peer record"

 proc addrs*(p: PeerInfo): seq[MultiAddress] =
  p.addrs
@@ -93,7 +99,7 @@ proc new*(
  agentVersion: string = "",
  addressMappers = newSeq[AddressMapper](),
  ): PeerInfo
-  {.raises: [LPError].} =
+  {.raises: [Defect, LPError].} =

  let pubkey = try:
      key.getPublicKey().tryGet()
--- a/libp2p/peerstore.nim
+++ b/libp2p/peerstore.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -16,25 +16,23 @@ runnableExamples:
  # Create a custom book type
  type MoodBook = ref object of PeerBook[string]

-  var somePeerId = PeerId.random().expect("get random key")
+  var somePeerId = PeerId.random().get()

  peerStore[MoodBook][somePeerId] = "Happy"
  doAssert peerStore[MoodBook][somePeerId] == "Happy"

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import
  std/[tables, sets, options, macros],
-  chronos,
  ./crypto/crypto,
  ./protocols/identify,
-  ./protocols/protocol,
  ./peerid, ./peerinfo,
  ./routing_record,
  ./multiaddress,
-  ./stream/connection,
-  ./multistream,
-  ./muxers/muxer,
  utility

 type
@@ -42,7 +40,7 @@ type
  # Handler types #
  #################

-  PeerBookChangeHandler* = proc(peerId: PeerId) {.gcsafe, raises: [].}
+  PeerBookChangeHandler* = proc(peerId: PeerId) {.gcsafe, raises: [Defect].}

  #########
  # Books #
@@ -72,15 +70,11 @@ type

  PeerStore* {.public.} = ref object
    books: Table[string, BasePeerBook]
-    identify: Identify
    capacity*: int
    toClean*: seq[PeerId]

-proc new*(T: type PeerStore, identify: Identify, capacity = 1000): PeerStore {.public.} =
-  T(
-    identify: identify,
-    capacity: capacity
-  )
+proc new*(T: type PeerStore, capacity = 1000): PeerStore {.public.} =
+  T(capacity: capacity)

 #########################
 # Generic Peer Book API #
@@ -158,20 +152,20 @@ proc updatePeerInfo*(
  if info.addrs.len > 0:
    peerStore[AddressBook][info.peerId] = info.addrs

-  info.pubkey.withValue(pubkey):
-    peerStore[KeyBook][info.peerId] = pubkey
+  if info.pubkey.isSome:
+    peerStore[KeyBook][info.peerId] = info.pubkey.get()

-  info.agentVersion.withValue(agentVersion):
-    peerStore[AgentBook][info.peerId] = agentVersion.string
+  if info.agentVersion.isSome:
+    peerStore[AgentBook][info.peerId] = info.agentVersion.get().string

-  info.protoVersion.withValue(protoVersion):
-    peerStore[ProtoVersionBook][info.peerId] = protoVersion.string
+  if info.protoVersion.isSome:
+    peerStore[ProtoVersionBook][info.peerId] = info.protoVersion.get().string

  if info.protos.len > 0:
    peerStore[ProtoBook][info.peerId] = info.protos

-  info.signedPeerRecord.withValue(signedPeerRecord):
-    peerStore[SPRBook][info.peerId] = signedPeerRecord
+  if info.signedPeerRecord.isSome:
+    peerStore[SPRBook][info.peerId] = info.signedPeerRecord.get()

  let cleanupPos = peerStore.toClean.find(info.peerId)
  if cleanupPos >= 0:
@@ -192,34 +186,3 @@ proc cleanup*(
  while peerStore.toClean.len > peerStore.capacity:
    peerStore.del(peerStore.toClean[0])
    peerStore.toClean.delete(0)
-
-proc identify*(
-  peerStore: PeerStore,
-  muxer: Muxer) {.async.} =
-
-  # new stream for identify
-  var stream = await muxer.newStream()
-  if stream == nil:
-    return
-
-  try:
-    if (await MultistreamSelect.select(stream, peerStore.identify.codec())):
-      let info = await peerStore.identify.identify(stream, stream.peerId)
-
-      when defined(libp2p_agents_metrics):
-        var
-          knownAgent = "unknown"
-          shortAgent = info.agentVersion.get("").split("/")[0].safeToLowerAscii().get("")
-        if KnownLibP2PAgentsSeq.contains(shortAgent):
-          knownAgent = shortAgent
-        muxer.connection.setShortAgent(knownAgent)
-
-      peerStore.updatePeerInfo(info)
-  finally:
-    await stream.closeWithEOF()
-
-proc getMostObservedProtosAndPorts*(self: PeerStore): seq[MultiAddress] =
-  return self.identify.observedAddrManager.getMostObservedProtosAndPorts()
-
-proc guessDialableAddr*(self: PeerStore, ma: MultiAddress): MultiAddress =
-  return self.identify.observedAddrManager.guessDialableAddr(ma)
--- a/libp2p/protobuf/minprotobuf.nim
+++ b/libp2p/protobuf/minprotobuf.nim
@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,7 +9,10 @@

 ## This module implements minimal Google's ProtoBuf primitives.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import ../varint, ../utility, stew/[endians2, results]
 export results, utility
@@ -69,12 +72,12 @@ type
                 hint | hint32 | hint64 | float32 | float64

 const
-  SupportedWireTypes* = @[
-    uint64(ProtoFieldKind.Varint),
-    uint64(ProtoFieldKind.Fixed64),
-    uint64(ProtoFieldKind.Length),
-    uint64(ProtoFieldKind.Fixed32)
-  ]
+  SupportedWireTypes* = {
+    int(ProtoFieldKind.Varint),
+    int(ProtoFieldKind.Fixed64),
+    int(ProtoFieldKind.Length),
+    int(ProtoFieldKind.Fixed32)
+  }

 template checkFieldNumber*(i: int) =
  doAssert((i > 0 and i < (1 shl 29)) and not(i >= 19000 and i <= 19999),
@@ -576,18 +579,26 @@ proc getField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
 proc getField*(pb: ProtoBuffer, field: int,
               output: var ProtoBuffer): ProtoResult[bool] {.inline.} =
  var buffer: seq[byte]
-  if ? pb.getField(field, buffer):
-    output = initProtoBuffer(buffer)
-    ok(true)
+  let res = pb.getField(field, buffer)
+  if res.isOk():
+    if res.get():
+      output = initProtoBuffer(buffer)
+      ok(true)
+    else:
+      ok(false)
  else:
-    ok(false)
+    err(res.error)

 proc getRequiredField*[T](pb: ProtoBuffer, field: int,
               output: var T): ProtoResult[void] {.inline.} =
-  if ? pb.getField(field, output):
-    ok()
+  let res = pb.getField(field, output)
+  if res.isOk():
+    if res.get():
+      ok()
+    else:
+      err(RequiredFieldMissing)
  else:
-    err(RequiredFieldMissing)
+    err(res.error)

 proc getRepeatedField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
                                        output: var seq[T]): ProtoResult[bool] =
@@ -667,10 +678,14 @@ proc getRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,

 proc getRequiredRepeatedField*[T](pb: ProtoBuffer, field: int,
               output: var seq[T]): ProtoResult[void] {.inline.} =
-  if ? pb.getRepeatedField(field, output):
-    ok()
+  let res = pb.getRepeatedField(field, output)
+  if res.isOk():
+    if res.get():
+      ok()
+    else:
+      err(RequiredFieldMissing)
  else:
-    err(RequiredFieldMissing)
+    err(res.error)

 proc getPackedRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
                                        output: var seq[T]): ProtoResult[bool] =
--- a/libp2p/protocols/connectivity/autonat.nim
+++ b/libp2p/protocols/connectivity/autonat.nim
@@ -0,0 +1,309 @@
+# Nim-LibP2P
+# Copyright (c) 2022 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import std/[options, sets, sequtils]
+import stew/results
+import chronos, chronicles, stew/objects
+import ../protocol,
+       ../../switch,
+       ../../multiaddress,
+       ../../multicodec,
+       ../../peerid,
+       ../../utils/semaphore,
+       ../../errors
+
+logScope:
+  topics = "libp2p autonat"
+
+const
+  AutonatCodec* = "/libp2p/autonat/1.0.0"
+  AddressLimit = 8
+
+type
+  AutonatError* = object of LPError
+
+  MsgType* = enum
+    Dial = 0
+    DialResponse = 1
+
+  ResponseStatus* = enum
+    Ok = 0
+    DialError = 100
+    DialRefused = 101
+    BadRequest = 200
+    InternalError = 300
+
+  AutonatPeerInfo* = object
+    id: Option[PeerId]
+    addrs: seq[MultiAddress]
+
+  AutonatDial* = object
+    peerInfo: Option[AutonatPeerInfo]
+
+  AutonatDialResponse* = object
+    status*: ResponseStatus
+    text*: Option[string]
+    ma*: Option[MultiAddress]
+
+  AutonatMsg = object
+    msgType: MsgType
+    dial: Option[AutonatDial]
+    response: Option[AutonatDialResponse]
+
+proc encode*(msg: AutonatMsg): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, msg.msgType.uint)
+  if msg.dial.isSome():
+    var dial = initProtoBuffer()
+    if msg.dial.get().peerInfo.isSome():
+      var bufferPeerInfo = initProtoBuffer()
+      let peerInfo = msg.dial.get().peerInfo.get()
+      if peerInfo.id.isSome():
+        bufferPeerInfo.write(1, peerInfo.id.get())
+      for ma in peerInfo.addrs:
+        bufferPeerInfo.write(2, ma.data.buffer)
+      bufferPeerInfo.finish()
+      dial.write(1, bufferPeerInfo.buffer)
+    dial.finish()
+    result.write(2, dial.buffer)
+  if msg.response.isSome():
+    var bufferResponse = initProtoBuffer()
+    let response = msg.response.get()
+    bufferResponse.write(1, response.status.uint)
+    if response.text.isSome():
+      bufferResponse.write(2, response.text.get())
+    if response.ma.isSome():
+      bufferResponse.write(3, response.ma.get())
+    bufferResponse.finish()
+    result.write(3, bufferResponse.buffer)
+  result.finish()
+
+proc encode*(d: AutonatDial): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, MsgType.Dial.uint)
+  var dial = initProtoBuffer()
+  if d.peerInfo.isSome():
+    var bufferPeerInfo = initProtoBuffer()
+    let peerInfo = d.peerInfo.get()
+    if peerInfo.id.isSome():
+      bufferPeerInfo.write(1, peerInfo.id.get())
+    for ma in peerInfo.addrs:
+      bufferPeerInfo.write(2, ma.data.buffer)
+    bufferPeerInfo.finish()
+    dial.write(1, bufferPeerInfo.buffer)
+  dial.finish()
+  result.write(2, dial.buffer)
+  result.finish()
+
+proc encode*(r: AutonatDialResponse): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, MsgType.DialResponse.uint)
+  var bufferResponse = initProtoBuffer()
+  bufferResponse.write(1, r.status.uint)
+  if r.text.isSome():
+    bufferResponse.write(2, r.text.get())
+  if r.ma.isSome():
+    bufferResponse.write(3, r.ma.get())
+  bufferResponse.finish()
+  result.write(3, bufferResponse.buffer)
+  result.finish()
+
+proc decode(_: typedesc[AutonatMsg], buf: seq[byte]): Option[AutonatMsg] =
+  var
+    msgTypeOrd: uint32
+    pbDial: ProtoBuffer
+    pbResponse: ProtoBuffer
+    msg: AutonatMsg
+
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getField(1, msgTypeOrd)
+    r2 = pb.getField(2, pbDial)
+    r3 = pb.getField(3, pbResponse)
+  if r1.isErr() or r2.isErr() or r3.isErr(): return none(AutonatMsg)
+
+  if r1.get() and not checkedEnumAssign(msg.msgType, msgTypeOrd):
+    return none(AutonatMsg)
+  if r2.get():
+    var
+      pbPeerInfo: ProtoBuffer
+      dial: AutonatDial
+    let
+      r4 = pbDial.getField(1, pbPeerInfo)
+    if r4.isErr(): return none(AutonatMsg)
+
+    var peerInfo: AutonatPeerInfo
+    if r4.get():
+      var pid: PeerId
+      let
+        r5 = pbPeerInfo.getField(1, pid)
+        r6 = pbPeerInfo.getRepeatedField(2, peerInfo.addrs)
+      if r5.isErr() or r6.isErr(): return none(AutonatMsg)
+      if r5.get(): peerInfo.id = some(pid)
+      dial.peerInfo = some(peerInfo)
+    msg.dial = some(dial)
+
+  if r3.get():
+    var
+      statusOrd: uint
+      text: string
+      ma: MultiAddress
+      response: AutonatDialResponse
+
+    let
+      r4 = pbResponse.getField(1, statusOrd)
+      r5 = pbResponse.getField(2, text)
+      r6 = pbResponse.getField(3, ma)
+
+    if r4.isErr() or r5.isErr() or r6.isErr() or
+       (r4.get() and not checkedEnumAssign(response.status, statusOrd)):
+      return none(AutonatMsg)
+    if r5.get(): response.text = some(text)
+    if r6.get(): response.ma = some(ma)
+    msg.response = some(response)
+
+  return some(msg)
+
+proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
+  let pb = AutonatDial(peerInfo: some(AutonatPeerInfo(
+                         id: some(pid),
+                         addrs: addrs
+                       ))).encode()
+  await conn.writeLp(pb.buffer)
+
+proc sendResponseError(conn: Connection, status: ResponseStatus, text: string = "") {.async.} =
+  let pb = AutonatDialResponse(
+             status: status,
+             text: if text == "": none(string) else: some(text),
+             ma: none(MultiAddress)
+           ).encode()
+  await conn.writeLp(pb.buffer)
+
+proc sendResponseOk(conn: Connection, ma: MultiAddress) {.async.} =
+  let pb = AutonatDialResponse(
+             status: ResponseStatus.Ok,
+             text: some("Ok"),
+             ma: some(ma)
+           ).encode()
+  await conn.writeLp(pb.buffer)
+
+type
+  Autonat* = ref object of LPProtocol
+    sem: AsyncSemaphore
+    switch*: Switch
+
+proc dialMe*(a: Autonat, pid: PeerId, ma: MultiAddress|seq[MultiAddress]):
+    Future[MultiAddress] {.async.} =
+  let addrs = when ma is MultiAddress: @[ma] else: ma
+  let conn = await a.switch.dial(pid, addrs, AutonatCodec)
+  defer: await conn.close()
+  await conn.sendDial(a.switch.peerInfo.peerId, a.switch.peerInfo.addrs)
+  let msgOpt = AutonatMsg.decode(await conn.readLp(1024))
+  if msgOpt.isNone() or
+     msgOpt.get().msgType != DialResponse or
+     msgOpt.get().response.isNone():
+    raise newException(AutonatError, "Unexpected response")
+  let response = msgOpt.get().response.get()
+  if response.status != ResponseStatus.Ok:
+    raise newException(AutonatError, "Bad status " &
+                                      $response.status & " " &
+                                      response.text.get(""))
+  if response.ma.isNone():
+    raise newException(AutonatError, "Missing address")
+  return response.ma.get()
+
+proc tryDial(a: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.async.} =
+  try:
+    await a.sem.acquire()
+    let ma = await a.switch.dialer.tryDial(conn.peerId, addrs)
+    if ma.isSome:
+      await conn.sendResponseOk(ma.get())
+    else:
+      await conn.sendResponseError(DialError, "Missing observed address")
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    await conn.sendResponseError(DialError, exc.msg)
+  finally:
+    a.sem.release()
+
+proc handleDial(a: Autonat, conn: Connection, msg: AutonatMsg): Future[void] =
+  if msg.dial.isNone() or msg.dial.get().peerInfo.isNone():
+    return conn.sendResponseError(BadRequest, "Missing Peer Info")
+  let peerInfo = msg.dial.get().peerInfo.get()
+  if peerInfo.id.isSome() and peerInfo.id.get() != conn.peerId:
+    return conn.sendResponseError(BadRequest, "PeerId mismatch")
+
+  if conn.observedAddr.isNone:
+    return conn.sendResponseError(BadRequest, "Missing observed address")
+  let observedAddr = conn.observedAddr.get()
+
+  var isRelayed = observedAddr.contains(multiCodec("p2p-circuit"))
+  if isRelayed.isErr() or isRelayed.get():
+    return conn.sendResponseError(DialRefused, "Refused to dial a relayed observed address")
+  let hostIp = observedAddr[0]
+  if hostIp.isErr() or not IP.match(hostIp.get()):
+    trace "wrong observed address", address=observedAddr
+    return conn.sendResponseError(InternalError, "Expected an IP address")
+  var addrs = initHashSet[MultiAddress]()
+  addrs.incl(observedAddr)
+  for ma in peerInfo.addrs:
+    isRelayed = ma.contains(multiCodec("p2p-circuit"))
+    if isRelayed.isErr() or isRelayed.get():
+      continue
+    let maFirst = ma[0]
+    if maFirst.isErr() or not IP.match(maFirst.get()):
+      continue
+
+    try:
+      addrs.incl(
+        if maFirst.get() == hostIp.get():
+          ma
+        else:
+          let maEnd = ma[1..^1]
+          if maEnd.isErr(): continue
+          hostIp.get() & maEnd.get()
+      )
+    except LPError as exc:
+      continue
+    if len(addrs) >= AddressLimit:
+      break
+
+  if len(addrs) == 0:
+    return conn.sendResponseError(DialRefused, "No dialable address")
+  return a.tryDial(conn, toSeq(addrs))
+
+proc new*(T: typedesc[Autonat], switch: Switch, semSize: int = 1): T =
+  let autonat = T(switch: switch, sem: newAsyncSemaphore(semSize))
+  autonat.init()
+  autonat
+
+method init*(a: Autonat) =
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
+    try:
+      let msgOpt = AutonatMsg.decode(await conn.readLp(1024))
+      if msgOpt.isNone() or msgOpt.get().msgType != MsgType.Dial:
+        raise newException(AutonatError, "Received malformed message")
+      let msg = msgOpt.get()
+      await a.handleDial(conn, msg)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "exception in autonat handler", exc = exc.msg, conn
+    finally:
+      trace "exiting autonat handler", conn
+      await conn.close()
+
+  a.handler = handleStream
+  a.codec = AutonatCodec
--- a/libp2p/protocols/connectivity/autonat/client.nim
+++ b/libp2p/protocols/connectivity/autonat/client.nim
@@ -1,70 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import stew/results
-import chronos, chronicles
-import ../../../switch,
-       ../../../multiaddress,
-       ../../../peerid
-import core
-
-logScope:
-  topics = "libp2p autonat"
-
-type
-  AutonatClient* = ref object of RootObj
-
-proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  let pb = AutonatDial(peerInfo: Opt.some(AutonatPeerInfo(
-                         id: Opt.some(pid),
-                         addrs: addrs
-                       ))).encode()
-  await conn.writeLp(pb.buffer)
-
-method dialMe*(self: AutonatClient, switch: Switch, pid: PeerId, addrs: seq[MultiAddress] = newSeq[MultiAddress]()):
-    Future[MultiAddress] {.base, async.} =
-
-  proc getResponseOrRaise(autonatMsg: Opt[AutonatMsg]): AutonatDialResponse {.raises: [AutonatError].} =
-    autonatMsg.withValue(msg):
-      if msg.msgType == DialResponse:
-        msg.response.withValue(res):
-          if not (res.status == Ok and res.ma.isNone()):
-            return res
-    raise newException(AutonatError, "Unexpected response")
-
-  let conn =
-    try:
-      if addrs.len == 0:
-        await switch.dial(pid, @[AutonatCodec])
-      else:
-        await switch.dial(pid, addrs, AutonatCodec)
-    except CatchableError as err:
-      raise newException(AutonatError, "Unexpected error when dialling: " & err.msg, err)
-
-  # To bypass maxConnectionsPerPeer
-  let incomingConnection = switch.connManager.expectConnection(pid, In)
-  if incomingConnection.failed() and incomingConnection.error of AlreadyExpectingConnectionError:
-    raise newException(AutonatError, incomingConnection.error.msg)
-  defer:
-    await conn.close()
-    incomingConnection.cancel() # Safer to always try to cancel cause we aren't sure if the peer dialled us or not
-    if incomingConnection.completed():
-      await (await incomingConnection).connection.close()
-  trace "sending Dial", addrs = switch.peerInfo.addrs
-  await conn.sendDial(switch.peerInfo.peerId, switch.peerInfo.addrs)
-  let response = getResponseOrRaise(AutonatMsg.decode(await conn.readLp(1024)))
-  return case response.status:
-    of ResponseStatus.Ok:
-      response.ma.tryGet()
-    of ResponseStatus.DialError:
-      raise newException(AutonatUnreachableError, "Peer could not dial us back: " & response.text.get(""))
-    else:
-      raise newException(AutonatError, "Bad status " & $response.status & " " & response.text.get(""))
--- a/libp2p/protocols/connectivity/autonat/core.nim
+++ b/libp2p/protocols/connectivity/autonat/core.nim
@@ -1,139 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import stew/[results, objects]
-import chronos, chronicles
-import ../../../multiaddress,
-       ../../../peerid,
-       ../../../errors
-
-logScope:
-  topics = "libp2p autonat"
-
-const
-  AutonatCodec* = "/libp2p/autonat/1.0.0"
-  AddressLimit* = 8
-
-type
-  AutonatError* = object of LPError
-  AutonatUnreachableError* = object of LPError
-
-  MsgType* = enum
-    Dial = 0
-    DialResponse = 1
-
-  ResponseStatus* = enum
-    Ok = 0
-    DialError = 100
-    DialRefused = 101
-    BadRequest = 200
-    InternalError = 300
-
-  AutonatPeerInfo* = object
-    id*: Opt[PeerId]
-    addrs*: seq[MultiAddress]
-
-  AutonatDial* = object
-    peerInfo*: Opt[AutonatPeerInfo]
-
-  AutonatDialResponse* = object
-    status*: ResponseStatus
-    text*: Opt[string]
-    ma*: Opt[MultiAddress]
-
-  AutonatMsg* = object
-    msgType*: MsgType
-    dial*: Opt[AutonatDial]
-    response*: Opt[AutonatDialResponse]
-
-  NetworkReachability* {.pure.} = enum
-    Unknown, NotReachable, Reachable
-
-proc encode(p: AutonatPeerInfo): ProtoBuffer =
-  result = initProtoBuffer()
-  p.id.withValue(id):
-    result.write(1, id)
-  for ma in p.addrs:
-    result.write(2, ma.data.buffer)
-  result.finish()
-
-proc encode*(d: AutonatDial): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, MsgType.Dial.uint)
-  var dial = initProtoBuffer()
-  d.peerInfo.withValue(pinfo):
-    dial.write(1, encode(pinfo))
-  dial.finish()
-  result.write(2, dial.buffer)
-  result.finish()
-
-proc encode*(r: AutonatDialResponse): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, MsgType.DialResponse.uint)
-  var bufferResponse = initProtoBuffer()
-  bufferResponse.write(1, r.status.uint)
-  r.text.withValue(text):
-    bufferResponse.write(2, text)
-  r.ma.withValue(ma):
-    bufferResponse.write(3, ma)
-  bufferResponse.finish()
-  result.write(3, bufferResponse.buffer)
-  result.finish()
-
-proc encode*(msg: AutonatMsg): ProtoBuffer =
-  msg.dial.withValue(dial):
-    return encode(dial)
-  msg.response.withValue(res):
-    return encode(res)
-
-proc decode*(_: typedesc[AutonatMsg], buf: seq[byte]): Opt[AutonatMsg] =
-  var
-    msgTypeOrd: uint32
-    pbDial: ProtoBuffer
-    pbResponse: ProtoBuffer
-    msg: AutonatMsg
-
-  let pb = initProtoBuffer(buf)
-
-  if ? pb.getField(1, msgTypeOrd).toOpt() and not checkedEnumAssign(msg.msgType, msgTypeOrd):
-    return Opt.none(AutonatMsg)
-  if ? pb.getField(2, pbDial).toOpt():
-    var
-      pbPeerInfo: ProtoBuffer
-      dial: AutonatDial
-    let r4 = ? pbDial.getField(1, pbPeerInfo).toOpt()
-
-    var peerInfo: AutonatPeerInfo
-    if r4:
-      var pid: PeerId
-      let
-        r5 = ? pbPeerInfo.getField(1, pid).toOpt()
-        r6 = ? pbPeerInfo.getRepeatedField(2, peerInfo.addrs).toOpt()
-      if r5: peerInfo.id = Opt.some(pid)
-      dial.peerInfo = Opt.some(peerInfo)
-    msg.dial = Opt.some(dial)
-
-  if ? pb.getField(3, pbResponse).toOpt():
-    var
-      statusOrd: uint
-      text: string
-      ma: MultiAddress
-      response: AutonatDialResponse
-
-    if ? pbResponse.getField(1, statusOrd).optValue():
-      if not checkedEnumAssign(response.status, statusOrd):
-        return Opt.none(AutonatMsg)
-    if ? pbResponse.getField(2, text).optValue():
-      response.text = Opt.some(text)
-    if ? pbResponse.getField(3, ma).optValue():
-      response.ma = Opt.some(ma)
-    msg.response = Opt.some(response)
-  return Opt.some(msg)
--- a/libp2p/protocols/connectivity/autonat/server.nim
+++ b/libp2p/protocols/connectivity/autonat/server.nim
@@ -1,160 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/[sets, sequtils]
-import stew/results
-import chronos, chronicles
-import ../../protocol,
-       ../../../switch,
-       ../../../multiaddress,
-       ../../../multicodec,
-       ../../../peerid,
-       ../../../utils/[semaphore, future],
-       ../../../errors
-import core
-
-export core
-
-logScope:
-  topics = "libp2p autonat"
-
-type
-  Autonat* = ref object of LPProtocol
-    sem: AsyncSemaphore
-    switch*: Switch
-    dialTimeout: Duration
-
-proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  let pb = AutonatDial(peerInfo: Opt.some(AutonatPeerInfo(
-                         id: Opt.some(pid),
-                         addrs: addrs
-                       ))).encode()
-  await conn.writeLp(pb.buffer)
-
-proc sendResponseError(conn: Connection, status: ResponseStatus, text: string = "") {.async.} =
-  let pb = AutonatDialResponse(
-             status: status,
-             text: if text == "": Opt.none(string) else: Opt.some(text),
-             ma: Opt.none(MultiAddress)
-           ).encode()
-  await conn.writeLp(pb.buffer)
-
-proc sendResponseOk(conn: Connection, ma: MultiAddress) {.async.} =
-  let pb = AutonatDialResponse(
-             status: ResponseStatus.Ok,
-             text: Opt.some("Ok"),
-             ma: Opt.some(ma)
-           ).encode()
-  await conn.writeLp(pb.buffer)
-
-proc tryDial(autonat: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.async.} =
-  await autonat.sem.acquire()
-  var futs: seq[Future[Opt[MultiAddress]]]
-  try:
-    # This is to bypass the per peer max connections limit
-    let outgoingConnection = autonat.switch.connManager.expectConnection(conn.peerId, Out)
-    if outgoingConnection.failed() and outgoingConnection.error of AlreadyExpectingConnectionError:
-      await conn.sendResponseError(DialRefused, outgoingConnection.error.msg)
-      return
-    # Safer to always try to cancel cause we aren't sure if the connection was established
-    defer: outgoingConnection.cancel()
-    # tryDial is to bypass the global max connections limit
-    futs = addrs.mapIt(autonat.switch.dialer.tryDial(conn.peerId, @[it]))
-    let fut = await anyCompleted(futs).wait(autonat.dialTimeout)
-    let ma = await fut
-    ma.withValue(maddr):
-      await conn.sendResponseOk(maddr)
-    else:
-      await conn.sendResponseError(DialError, "Missing observed address")
-  except CancelledError as exc:
-    raise exc
-  except AllFuturesFailedError as exc:
-    debug "All dial attempts failed", addrs, exc = exc.msg
-    await conn.sendResponseError(DialError, "All dial attempts failed")
-  except AsyncTimeoutError as exc:
-    debug "Dial timeout", addrs, exc = exc.msg
-    await conn.sendResponseError(DialError, "Dial timeout")
-  except CatchableError as exc:
-    debug "Unexpected error", addrs, exc = exc.msg
-    await conn.sendResponseError(DialError, "Unexpected error")
-  finally:
-    autonat.sem.release()
-    for f in futs:
-      if not f.finished():
-        f.cancel()
-
-proc handleDial(autonat: Autonat, conn: Connection, msg: AutonatMsg): Future[void] =
-  let dial = msg.dial.valueOr:
-    return conn.sendResponseError(BadRequest, "Missing Dial")
-  let peerInfo = dial.peerInfo.valueOr:
-    return conn.sendResponseError(BadRequest, "Missing Peer Info")
-  peerInfo.id.withValue(id):
-    if id != conn.peerId:
-      return conn.sendResponseError(BadRequest, "PeerId mismatch")
-
-  let observedAddr = conn.observedAddr.valueOr:
-    return conn.sendResponseError(BadRequest, "Missing observed address")
-
-  var isRelayed = observedAddr.contains(multiCodec("p2p-circuit")).valueOr:
-    return conn.sendResponseError(DialRefused, "Invalid observed address")
-  if isRelayed:
-    return conn.sendResponseError(DialRefused, "Refused to dial a relayed observed address")
-  let hostIp = observedAddr[0].valueOr:
-    return conn.sendResponseError(InternalError, "Wrong observed address")
-  if not IP.match(hostIp):
-    return conn.sendResponseError(InternalError, "Expected an IP address")
-  var addrs = initHashSet[MultiAddress]()
-  addrs.incl(observedAddr)
-  trace "addrs received", addrs = peerInfo.addrs
-  for ma in peerInfo.addrs:
-    isRelayed = ma.contains(multiCodec("p2p-circuit")).valueOr: continue
-    let maFirst = ma[0].valueOr: continue
-    if not DNS_OR_IP.match(maFirst): continue
-
-    try:
-      addrs.incl(
-        if maFirst == hostIp:
-          ma
-        else:
-          let maEnd = ma[1..^1].valueOr: continue
-          hostIp & maEnd
-      )
-    except LPError as exc:
-      continue
-    if len(addrs) >= AddressLimit:
-      break
-
-  if len(addrs) == 0:
-    return conn.sendResponseError(DialRefused, "No dialable address")
-  let addrsSeq = toSeq(addrs)
-  trace "trying to dial", addrs = addrsSeq
-  return autonat.tryDial(conn, addrsSeq)
-
-proc new*(T: typedesc[Autonat], switch: Switch, semSize: int = 1, dialTimeout = 15.seconds): T =
-  let autonat = T(switch: switch, sem: newAsyncSemaphore(semSize), dialTimeout: dialTimeout)
-  proc handleStream(conn: Connection, proto: string) {.async.} =
-    try:
-      let msg = AutonatMsg.decode(await conn.readLp(1024)).valueOr:
-        raise newException(AutonatError, "Received malformed message")
-      if msg.msgType != MsgType.Dial:
-        raise newException(AutonatError, "Message type should be dial")
-      await autonat.handleDial(conn, msg)
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      debug "exception in autonat handler", exc = exc.msg, conn
-    finally:
-      trace "exiting autonat handler", conn
-      await conn.close()
-
-  autonat.handler = handleStream
-  autonat.codec = AutonatCodec
-  autonat
--- a/libp2p/protocols/connectivity/autonat/service.nim
+++ b/libp2p/protocols/connectivity/autonat/service.nim
@@ -1,217 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/[deques, sequtils]
-import chronos, metrics
-import ../../../switch
-import ../../../wire
-import client
-from core import NetworkReachability, AutonatUnreachableError
-import ../../../utils/heartbeat
-import ../../../crypto/crypto
-
-export core.NetworkReachability
-
-logScope:
-  topics = "libp2p autonatservice"
-
-declarePublicGauge(libp2p_autonat_reachability_confidence, "autonat reachability confidence", labels = ["reachability"])
-
-type
-  AutonatService* = ref object of Service
-    newConnectedPeerHandler: PeerEventHandler
-    addressMapper: AddressMapper
-    scheduleHandle: Future[void]
-    networkReachability*: NetworkReachability
-    confidence: Opt[float]
-    answers: Deque[NetworkReachability]
-    autonatClient: AutonatClient
-    statusAndConfidenceHandler: StatusAndConfidenceHandler
-    rng: ref HmacDrbgContext
-    scheduleInterval: Opt[Duration]
-    askNewConnectedPeers: bool
-    numPeersToAsk: int
-    maxQueueSize: int
-    minConfidence: float
-    dialTimeout: Duration
-    enableAddressMapper: bool
-
-  StatusAndConfidenceHandler* = proc (networkReachability: NetworkReachability, confidence: Opt[float]): Future[void]  {.gcsafe, raises: [].}
-
-proc new*(
-  T: typedesc[AutonatService],
-  autonatClient: AutonatClient,
-  rng: ref HmacDrbgContext,
-  scheduleInterval: Opt[Duration] = Opt.none(Duration),
-  askNewConnectedPeers = true,
-  numPeersToAsk: int = 5,
-  maxQueueSize: int = 10,
-  minConfidence: float = 0.3,
-  dialTimeout = 30.seconds,
-  enableAddressMapper = true): T =
-  return T(
-    scheduleInterval: scheduleInterval,
-    networkReachability: Unknown,
-    confidence: Opt.none(float),
-    answers: initDeque[NetworkReachability](),
-    autonatClient: autonatClient,
-    rng: rng,
-    askNewConnectedPeers: askNewConnectedPeers,
-    numPeersToAsk: numPeersToAsk,
-    maxQueueSize: maxQueueSize,
-    minConfidence: minConfidence,
-    dialTimeout: dialTimeout,
-    enableAddressMapper: enableAddressMapper)
-
-proc callHandler(self: AutonatService) {.async.} =
-  if not isNil(self.statusAndConfidenceHandler):
-    await self.statusAndConfidenceHandler(self.networkReachability, self.confidence)
-
-proc hasEnoughIncomingSlots(switch: Switch): bool =
-  # we leave some margin instead of comparing to 0 as a peer could connect to us while we are asking for the dial back
-  return switch.connManager.slotsAvailable(In) >= 2
-
-proc doesPeerHaveIncomingConn(switch: Switch, peerId: PeerId): bool =
-  return switch.connManager.selectMuxer(peerId, In) != nil
-
-proc handleAnswer(self: AutonatService, ans: NetworkReachability): Future[bool] {.async.} =
-
-  if ans == Unknown:
-    return
-
-  let oldNetworkReachability = self.networkReachability
-  let oldConfidence = self.confidence
-
-  if self.answers.len == self.maxQueueSize:
-    self.answers.popFirst()
-  self.answers.addLast(ans)
-
-  self.networkReachability = Unknown
-  self.confidence = Opt.none(float)
-  const reachabilityPriority = [Reachable, NotReachable]
-  for reachability in reachabilityPriority:
-    let confidence = self.answers.countIt(it == reachability) / self.maxQueueSize
-    libp2p_autonat_reachability_confidence.set(value = confidence, labelValues = [$reachability])
-    if self.confidence.isNone and confidence >= self.minConfidence:
-      self.networkReachability = reachability
-      self.confidence = Opt.some(confidence)
-
-  debug "Current status", currentStats = $self.networkReachability, confidence = $self.confidence, answers = self.answers
-
-  # Return whether anything has changed
-  return self.networkReachability != oldNetworkReachability or self.confidence != oldConfidence
-
-proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[NetworkReachability] {.async.} =
-  logScope:
-    peerId = $peerId
-
-  if doesPeerHaveIncomingConn(switch, peerId):
-    return Unknown
-
-  if not hasEnoughIncomingSlots(switch):
-    debug "No incoming slots available, not asking peer", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
-    return Unknown
-
-  trace "Asking peer for reachability"
-  let ans =
-    try:
-      discard await self.autonatClient.dialMe(switch, peerId).wait(self.dialTimeout)
-      debug "dialMe answer is reachable"
-      Reachable
-    except AutonatUnreachableError as error:
-      debug "dialMe answer is not reachable", msg = error.msg
-      NotReachable
-    except AsyncTimeoutError as error:
-      debug "dialMe timed out", msg = error.msg
-      Unknown
-    except CatchableError as error:
-      debug "dialMe unexpected error", msg = error.msg
-      Unknown
-  let hasReachabilityOrConfidenceChanged = await self.handleAnswer(ans)
-  if hasReachabilityOrConfidenceChanged:
-    await self.callHandler()
-  await switch.peerInfo.update()
-  return ans
-
-proc askConnectedPeers(self: AutonatService, switch: Switch) {.async.} =
-  trace "Asking peers for reachability"
-  var peers = switch.connectedPeers(Direction.Out)
-  self.rng.shuffle(peers)
-  var answersFromPeers = 0
-  for peer in peers:
-    if answersFromPeers >= self.numPeersToAsk:
-      break
-    if not hasEnoughIncomingSlots(switch):
-      debug "No incoming slots available, not asking peers", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
-      break
-    if (await askPeer(self, switch, peer)) != Unknown:
-      answersFromPeers.inc()
-
-proc schedule(service: AutonatService, switch: Switch, interval: Duration) {.async.} =
-  heartbeat "Scheduling AutonatService run", interval:
-    await service.run(switch)
-
-proc addressMapper(
-  self: AutonatService,
-  peerStore: PeerStore,
-  listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.async.} =
-
-  if self.networkReachability != NetworkReachability.Reachable:
-    return listenAddrs
-
-  var addrs = newSeq[MultiAddress]()
-  for listenAddr in listenAddrs:
-    var processedMA = listenAddr
-    try:
-      if not listenAddr.isPublicMA() and self.networkReachability == NetworkReachability.Reachable:
-        processedMA = peerStore.guessDialableAddr(listenAddr) # handle manual port forwarding
-    except CatchableError as exc:
-      debug "Error while handling address mapper", msg = exc.msg
-    addrs.add(processedMA)
-  return addrs
-
-method setup*(self: AutonatService, switch: Switch): Future[bool] {.async.} =
-  self.addressMapper = proc (listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.async.} =
-    return await addressMapper(self, switch.peerStore, listenAddrs)
-
-  info "Setting up AutonatService"
-  let hasBeenSetup = await procCall Service(self).setup(switch)
-  if hasBeenSetup:
-    if self.askNewConnectedPeers:
-      self.newConnectedPeerHandler = proc (peerId: PeerId, event: PeerEvent): Future[void] {.async.} =
-        discard askPeer(self, switch, peerId)
-      switch.connManager.addPeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
-    self.scheduleInterval.withValue(interval):
-      self.scheduleHandle = schedule(self, switch, interval)
-    if self.enableAddressMapper:
-      switch.peerInfo.addressMappers.add(self.addressMapper)
-  return hasBeenSetup
-
-method run*(self: AutonatService, switch: Switch) {.async, public.} =
-  trace "Running AutonatService"
-  await askConnectedPeers(self, switch)
-
-method stop*(self: AutonatService, switch: Switch): Future[bool] {.async, public.} =
-  info "Stopping AutonatService"
-  let hasBeenStopped = await procCall Service(self).stop(switch)
-  if hasBeenStopped:
-    if not isNil(self.scheduleHandle):
-      self.scheduleHandle.cancel()
-      self.scheduleHandle = nil
-    if not isNil(self.newConnectedPeerHandler):
-      switch.connManager.removePeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
-    if self.enableAddressMapper:
-      switch.peerInfo.addressMappers.keepItIf(it != self.addressMapper)
-    await switch.peerInfo.update()
-  return hasBeenStopped
-
-proc statusAndConfidenceHandler*(self: AutonatService, statusAndConfidenceHandler: StatusAndConfidenceHandler) =
-  self.statusAndConfidenceHandler = statusAndConfidenceHandler
--- a/libp2p/protocols/connectivity/dcutr/client.nim
+++ b/libp2p/protocols/connectivity/dcutr/client.nim
@@ -1,89 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/sequtils
-
-import stew/results
-import chronos, chronicles
-
-import core
-import ../../protocol,
-       ../../../stream/connection,
-       ../../../switch,
-       ../../../utils/future
-
-export DcutrError
-
-type
-  DcutrClient* = ref object
-    connectTimeout: Duration
-    maxDialableAddrs: int
-
-logScope:
-  topics = "libp2p dcutrclient"
-
-proc new*(T: typedesc[DcutrClient], connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
-  return T(connectTimeout: connectTimeout, maxDialableAddrs: maxDialableAddrs)
-
-proc startSync*(self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  logScope:
-    peerId = switch.peerInfo.peerId
-
-  var
-    peerDialableAddrs: seq[MultiAddress]
-    stream: Connection
-  try:
-    var ourDialableAddrs = getHolePunchableAddrs(addrs)
-    if ourDialableAddrs.len == 0:
-      debug "Dcutr initiator has no supported dialable addresses. Aborting Dcutr.", addrs
-      return
-
-    stream = await switch.dial(remotePeerId, DcutrCodec)
-    await stream.send(MsgType.Connect, addrs)
-    debug "Dcutr initiator has sent a Connect message."
-    let rttStart = Moment.now()
-    let connectAnswer = DcutrMsg.decode(await stream.readLp(1024))
-
-    peerDialableAddrs = getHolePunchableAddrs(connectAnswer.addrs)
-    if peerDialableAddrs.len == 0:
-      debug "Dcutr receiver has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectAnswer.addrs
-      return
-
-    let rttEnd = Moment.now()
-    debug "Dcutr initiator has received a Connect message back.", connectAnswer
-    let halfRtt = (rttEnd - rttStart) div 2'i64
-    await stream.send(MsgType.Sync, @[])
-    debug "Dcutr initiator has sent a Sync message."
-    await sleepAsync(halfRtt)
-
-    if peerDialableAddrs.len > self.maxDialableAddrs:
-        peerDialableAddrs = peerDialableAddrs[0..<self.maxDialableAddrs]
-    var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false, dir = Direction.In))
-    try:
-      discard await anyCompleted(futs).wait(self.connectTimeout)
-      debug "Dcutr initiator has directly connected to the remote peer."
-    finally:
-      for fut in futs: fut.cancel()
-  except CancelledError as err:
-    raise err
-  except AllFuturesFailedError as err:
-    debug "Dcutr initiator could not connect to the remote peer, all connect attempts failed", peerDialableAddrs, msg = err.msg
-    raise newException(DcutrError, "Dcutr initiator could not connect to the remote peer, all connect attempts failed", err)
-  except AsyncTimeoutError as err:
-    debug "Dcutr initiator could not connect to the remote peer, all connect attempts timed out", peerDialableAddrs, msg = err.msg
-    raise newException(DcutrError, "Dcutr initiator could not connect to the remote peer, all connect attempts timed out", err)
-  except CatchableError as err:
-    debug "Unexpected error when Dcutr initiator tried to connect to the remote peer", err = err.msg
-    raise newException(DcutrError, "Unexpected error when Dcutr initiator tried to connect to the remote peer", err)
-  finally:
-    if stream != nil:
-      await stream.close()
-
--- a/libp2p/protocols/connectivity/dcutr/core.nim
+++ b/libp2p/protocols/connectivity/dcutr/core.nim
@@ -1,65 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/sequtils
-
-import chronos
-import stew/objects
-
-import ../../../multiaddress,
-       ../../../errors,
-       ../../../stream/connection
-
-export multiaddress
-
-const
-  DcutrCodec* = "/libp2p/dcutr"
-
-type
-  MsgType* = enum
-    Connect = 100
-    Sync = 300
-
-  DcutrMsg* = object
-    msgType*: MsgType
-    addrs*: seq[MultiAddress]
-
-  DcutrError* = object of LPError
-
-proc encode*(msg: DcutrMsg): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, msg.msgType.uint)
-  for addr in msg.addrs:
-    result.write(2, addr)
-  result.finish()
-
-proc decode*(_: typedesc[DcutrMsg], buf: seq[byte]): DcutrMsg {.raises: [DcutrError].} =
-  var
-    msgTypeOrd: uint32
-    dcutrMsg: DcutrMsg
-  var pb = initProtoBuffer(buf)
-  var r1 = pb.getField(1, msgTypeOrd)
-  let r2 = pb.getRepeatedField(2, dcutrMsg.addrs)
-  if r1.isErr or r2.isErr or not checkedEnumAssign(dcutrMsg.msgType, msgTypeOrd):
-    raise newException(DcutrError, "Received malformed message")
-  return dcutrMsg
-
-proc send*(conn: Connection, msgType: MsgType, addrs: seq[MultiAddress]) {.async.} =
-  let pb = DcutrMsg(msgType: msgType, addrs: addrs).encode()
-  await conn.writeLp(pb.buffer)
-
-proc getHolePunchableAddrs*(addrs: seq[MultiAddress]): seq[MultiAddress] {.raises: [LPError]} =
-  var result = newSeq[MultiAddress]()
-  for a in addrs:
-      # This is necessary to also accept addrs like /ip4/198.51.100/tcp/1234/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N
-      if [TCP, mapAnd(TCP_DNS, P2PPattern), mapAnd(TCP_IP, P2PPattern)].anyIt(it.match(a)):
-        result.add(a[0..1].tryGet())
-  return result
--- a/libp2p/protocols/connectivity/dcutr/server.nim
+++ b/libp2p/protocols/connectivity/dcutr/server.nim
@@ -1,80 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-{.push raises: [].}
-
-import std/[sets, sequtils]
-import stew/[results, objects]
-import chronos, chronicles
-
-import core
-import ../../protocol,
-       ../../../stream/connection,
-       ../../../switch,
-       ../../../utils/future
-
-export DcutrError
-export chronicles
-
-type Dcutr* = ref object of LPProtocol
-
-logScope:
-  topics = "libp2p dcutr"
-
-proc new*(T: typedesc[Dcutr], switch: Switch, connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
-
-  proc handleStream(stream: Connection, proto: string) {.async.} =
-    var peerDialableAddrs: seq[MultiAddress]
-    try:
-      let connectMsg = DcutrMsg.decode(await stream.readLp(1024))
-      debug "Dcutr receiver received a Connect message.", connectMsg
-
-      var ourAddrs = switch.peerStore.getMostObservedProtosAndPorts() # likely empty when the peer is reachable
-      if ourAddrs.len == 0:
-        # this list should be the same as the peer's public addrs when it is reachable
-        ourAddrs =  switch.peerInfo.listenAddrs.mapIt(switch.peerStore.guessDialableAddr(it))
-      var ourDialableAddrs = getHolePunchableAddrs(ourAddrs)
-      if ourDialableAddrs.len == 0:
-        debug "Dcutr receiver has no supported dialable addresses. Aborting Dcutr.", ourAddrs
-        return
-
-      await stream.send(MsgType.Connect, ourAddrs)
-      debug "Dcutr receiver has sent a Connect message back."
-      let syncMsg = DcutrMsg.decode(await stream.readLp(1024))
-      debug "Dcutr receiver has received a Sync message.", syncMsg
-
-      peerDialableAddrs = getHolePunchableAddrs(connectMsg.addrs)
-      if peerDialableAddrs.len == 0:
-        debug "Dcutr initiator has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectMsg.addrs
-        return
-
-      if peerDialableAddrs.len > maxDialableAddrs:
-        peerDialableAddrs = peerDialableAddrs[0..<maxDialableAddrs]
-      var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false, dir = Direction.Out))
-      try:
-        discard await anyCompleted(futs).wait(connectTimeout)
-        debug "Dcutr receiver has directly connected to the remote peer."
-      finally:
-        for fut in futs: fut.cancel()
-    except CancelledError as err:
-      raise err
-    except AllFuturesFailedError as err:
-      debug "Dcutr receiver could not connect to the remote peer, all connect attempts failed", peerDialableAddrs, msg = err.msg
-      raise newException(DcutrError, "Dcutr receiver could not connect to the remote peer, all connect attempts failed", err)
-    except AsyncTimeoutError as err:
-      debug "Dcutr receiver could not connect to the remote peer, all connect attempts timed out", peerDialableAddrs, msg = err.msg
-      raise newException(DcutrError, "Dcutr receiver could not connect to the remote peer, all connect attempts timed out", err)
-    except CatchableError as err:
-      warn "Unexpected error when Dcutr receiver tried to connect to the remote peer", msg = err.msg
-      raise newException(DcutrError, "Unexpected error when Dcutr receiver tried to connect to the remote peer", err)
-
-  let self = T()
-  self.handler = handleStream
-  self.codec = DcutrCodec
-  self
--- a/libp2p/protocols/connectivity/relay/client.nim
+++ b/libp2p/protocols/connectivity/relay/client.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,15 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import times, options

-import times
 import chronos, chronicles
+
 import ./relay,
       ./messages,
       ./rconn,
@@ -20,6 +25,7 @@ import ./relay,
       ../../../multiaddress,
       ../../../stream/connection

+
 logScope:
  topics = "libp2p relay relay-client"

@@ -32,7 +38,7 @@ type
  RelayV2DialError* = object of RelayClientError
  RelayClientAddConn* = proc(conn: Connection,
                        duration: uint32,
-                        data: uint64): Future[void] {.gcsafe, raises: [].}
+                        data: uint64): Future[void] {.gcsafe, raises: [Defect].}
  RelayClient* = ref object of Relay
    onNewConnection*: RelayClientAddConn
    canHop: bool
@@ -40,27 +46,28 @@ type
  Rsvp* = object
    expire*: uint64           # required, Unix expiration time (UTC)
    addrs*: seq[MultiAddress] # relay address for reserving peer
-    voucher*: Opt[Voucher]    # optional, reservation voucher
+    voucher*: Option[Voucher] # optional, reservation voucher
    limitDuration*: uint32    # seconds
    limitData*: uint64        # bytes

 proc sendStopError(conn: Connection, code: StatusV2) {.async.} =
  trace "send stop status", status = $code & " (" & $ord(code) & ")"
-  let msg = StopMessage(msgType: StopMessageType.Status, status: Opt.some(code))
+  let msg = StopMessage(msgType: StopMessageType.Status, status: some(code))
  await conn.writeLp(encode(msg).buffer)

 proc handleRelayedConnect(cl: RelayClient, conn: Connection, msg: StopMessage) {.async.} =
+  if msg.peer.isNone():
+    await sendStopError(conn, MalformedMessage)
+    return
  let
    # TODO: check the go version to see in which way this could fail
    # it's unclear in the spec
-    src = msg.peer.valueOr:
-      await sendStopError(conn, MalformedMessage)
-      return
+    src = msg.peer.get()
    limitDuration = msg.limit.duration
    limitData = msg.limit.data
    msg = StopMessage(
      msgType: StopMessageType.Status,
-      status: Opt.some(Ok))
+      status: some(Ok))
    pb = encode(msg)

  trace "incoming relay connection", src
@@ -84,7 +91,7 @@ proc reserve*(cl: RelayClient,
    pb = encode(HopMessage(msgType: HopMessageType.Reserve))
    msg = try:
      await conn.writeLp(pb.buffer)
-      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
+      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).get()
    except CancelledError as exc:
      raise exc
    except CatchableError as exc:
@@ -95,21 +102,21 @@ proc reserve*(cl: RelayClient,
    raise newException(ReservationError, "Unexpected relay response type")
  if msg.status.get(UnexpectedMessage) != Ok:
    raise newException(ReservationError, "Reservation failed")
-
-  let reservation = msg.reservation.valueOr:
+  if msg.reservation.isNone():
    raise newException(ReservationError, "Missing reservation information")
+
+  let reservation = msg.reservation.get()
  if reservation.expire > int64.high().uint64 or
     now().utc > reservation.expire.int64.fromUnix.utc:
    raise newException(ReservationError, "Bad expiration date")
  result.expire = reservation.expire
  result.addrs = reservation.addrs

-  reservation.svoucher.withValue(sv):
-    let svoucher = SignedVoucher.decode(sv).valueOr:
+  if reservation.svoucher.isSome():
+    let svoucher = SignedVoucher.decode(reservation.svoucher.get())
+    if svoucher.isErr() or svoucher.get().data.relayPeerId != peerId:
      raise newException(ReservationError, "Invalid voucher")
-    if svoucher.data.relayPeerId != peerId:
-      raise newException(ReservationError, "Invalid voucher PeerId")
-    result.voucher = Opt.some(svoucher.data)
+    result.voucher = some(svoucher.get().data)

  result.limitDuration = msg.limit.duration
  result.limitData = msg.limit.data
@@ -121,9 +128,9 @@ proc dialPeerV1*(
    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
  var
    msg = RelayMessage(
-      msgType: Opt.some(RelayType.Hop),
-      srcPeer: Opt.some(RelayPeer(peerId: cl.switch.peerInfo.peerId, addrs: cl.switch.peerInfo.addrs)),
-      dstPeer: Opt.some(RelayPeer(peerId: dstPeerId, addrs: dstAddrs)))
+      msgType: some(RelayType.Hop),
+      srcPeer: some(RelayPeer(peerId: cl.switch.peerInfo.peerId, addrs: cl.switch.peerInfo.addrs)),
+      dstPeer: some(RelayPeer(peerId: dstPeerId, addrs: dstAddrs)))
    pb = encode(msg)

  trace "Dial peer", msgSend=msg
@@ -146,18 +153,16 @@ proc dialPeerV1*(
    raise exc

  try:
-    let msgRcvFromRelay = msgRcvFromRelayOpt.valueOr:
+    if msgRcvFromRelayOpt.isNone:
      raise newException(RelayV1DialError, "Hop can't open destination stream")
-    if msgRcvFromRelay.msgType.tryGet() != RelayType.Status:
+    let msgRcvFromRelay = msgRcvFromRelayOpt.get()
+    if msgRcvFromRelay.msgType.isNone or msgRcvFromRelay.msgType.get() != RelayType.Status:
      raise newException(RelayV1DialError, "Hop can't open destination stream: wrong message type")
-    if msgRcvFromRelay.status.tryGet() != StatusV1.Success:
+    if msgRcvFromRelay.status.isNone or msgRcvFromRelay.status.get() != StatusV1.Success:
      raise newException(RelayV1DialError, "Hop can't open destination stream: status failed")
  except RelayV1DialError as exc:
    await sendStatus(conn, StatusV1.HopCantOpenDstStream)
    raise exc
-  except ValueError as exc:
-    await sendStatus(conn, StatusV1.HopCantOpenDstStream)
-    raise newException(RelayV1DialError, exc.msg)
  result = conn

 proc dialPeerV2*(
@@ -167,13 +172,13 @@ proc dialPeerV2*(
    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
  let
    p = Peer(peerId: dstPeerId, addrs: dstAddrs)
-    pb = encode(HopMessage(msgType: HopMessageType.Connect, peer: Opt.some(p)))
+    pb = encode(HopMessage(msgType: HopMessageType.Connect, peer: some(p)))

  trace "Dial peer", p

  let msgRcvFromRelay = try:
    await conn.writeLp(pb.buffer)
-    HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
+    HopMessage.decode(await conn.readLp(RelayClientMsgSize)).get()
  except CancelledError as exc:
    raise exc
  except CatchableError as exc:
@@ -183,17 +188,19 @@ proc dialPeerV2*(
  if msgRcvFromRelay.msgType != HopMessageType.Status:
    raise newException(RelayV2DialError, "Unexpected stop response")
  if msgRcvFromRelay.status.get(UnexpectedMessage) != Ok:
-    trace "Relay stop failed", msg = msgRcvFromRelay.status
+    trace "Relay stop failed", msg = msgRcvFromRelay.status.get()
    raise newException(RelayV2DialError, "Relay stop failure")
  conn.limitDuration = msgRcvFromRelay.limit.duration
  conn.limitData = msgRcvFromRelay.limit.data
  return conn

-proc handleStopStreamV2(cl: RelayClient, conn: Connection) {.async.} =
-  let msg = StopMessage.decode(await conn.readLp(RelayClientMsgSize)).valueOr:
+proc handleStopStreamV2(cl: RelayClient, conn: Connection) {.async, gcsafe.} =
+  let msgOpt = StopMessage.decode(await conn.readLp(RelayClientMsgSize))
+  if msgOpt.isNone():
    await sendHopStatus(conn, MalformedMessage)
    return
-  trace "client circuit relay v2 handle stream", msg
+  trace "client circuit relay v2 handle stream", msg = msgOpt.get()
+  let msg = msgOpt.get()

  if msg.msgType == StopMessageType.Connect:
    await cl.handleRelayedConnect(conn, msg)
@@ -201,15 +208,17 @@ proc handleStopStreamV2(cl: RelayClient, conn: Connection) {.async.} =
    trace "Unexpected client / relayv2 handshake", msgType=msg.msgType
    await sendStopError(conn, MalformedMessage)

-proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async.} =
-  let src = msg.srcPeer.valueOr:
+proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async, gcsafe.} =
+  if msg.srcPeer.isNone:
    await sendStatus(conn, StatusV1.StopSrcMultiaddrInvalid)
    return
+  let src = msg.srcPeer.get()

-  let dst = msg.dstPeer.valueOr:
+  if msg.dstPeer.isNone:
    await sendStatus(conn, StatusV1.StopDstMultiaddrInvalid)
    return

+  let dst = msg.dstPeer.get()
  if dst.peerId != cl.switch.peerInfo.peerId:
    await sendStatus(conn, StatusV1.StopDstMultiaddrInvalid)
    return
@@ -226,17 +235,14 @@ proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async.}
  if cl.onNewConnection != nil: await cl.onNewConnection(conn, 0, 0)
  else: await conn.close()

-proc handleStreamV1(cl: RelayClient, conn: Connection) {.async.} =
-  let msg = RelayMessage.decode(await conn.readLp(RelayClientMsgSize)).valueOr:
+proc handleStreamV1(cl: RelayClient, conn: Connection) {.async, gcsafe.} =
+  let msgOpt = RelayMessage.decode(await conn.readLp(RelayClientMsgSize))
+  if msgOpt.isNone:
    await sendStatus(conn, StatusV1.MalformedMessage)
    return
-  trace "client circuit relay v1 handle stream", msg
-
-  let typ = msg.msgType.valueOr:
-    trace "Message type not set"
-    await sendStatus(conn, StatusV1.MalformedMessage)
-    return
-  case typ:
+  trace "client circuit relay v1 handle stream", msg = msgOpt.get()
+  let msg = msgOpt.get()
+  case msg.msgType.get:
    of RelayType.Hop:
      if cl.canHop: await cl.handleHop(conn, msg)
      else: await sendStatus(conn, StatusV1.HopCantSpeakRelay)
@@ -266,7 +272,7 @@ proc new*(T: typedesc[RelayClient], canHop: bool = false,
             maxCircuitPerPeer: maxCircuitPerPeer,
             msgSize: msgSize,
             isCircuitRelayV1: circuitRelayV1)
-  proc handleStream(conn: Connection, proto: string) {.async.} =
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
    try:
      case proto:
      of RelayV1Codec: await cl.handleStreamV1(conn)
--- a/libp2p/protocols/connectivity/relay/messages.nim
+++ b/libp2p/protocols/connectivity/relay/messages.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import macros
-import stew/[objects, results]
+import options, macros, sequtils
+import stew/objects
 import ../../../peerinfo,
       ../../../signed_envelope

@@ -46,36 +49,36 @@ type
    addrs*: seq[MultiAddress]

  RelayMessage* = object
-    msgType*: Opt[RelayType]
-    srcPeer*: Opt[RelayPeer]
-    dstPeer*: Opt[RelayPeer]
-    status*: Opt[StatusV1]
+    msgType*: Option[RelayType]
+    srcPeer*: Option[RelayPeer]
+    dstPeer*: Option[RelayPeer]
+    status*: Option[StatusV1]

 proc encode*(msg: RelayMessage): ProtoBuffer =
  result = initProtoBuffer()

-  msg.msgType.withValue(typ):
-    result.write(1, typ.ord.uint)
-  msg.srcPeer.withValue(srcPeer):
+  if isSome(msg.msgType):
+    result.write(1, msg.msgType.get().ord.uint)
+  if isSome(msg.srcPeer):
    var peer = initProtoBuffer()
-    peer.write(1, srcPeer.peerId)
-    for ma in srcPeer.addrs:
+    peer.write(1, msg.srcPeer.get().peerId)
+    for ma in msg.srcPeer.get().addrs:
      peer.write(2, ma.data.buffer)
    peer.finish()
    result.write(2, peer.buffer)
-  msg.dstPeer.withValue(dstPeer):
+  if isSome(msg.dstPeer):
    var peer = initProtoBuffer()
-    peer.write(1, dstPeer.peerId)
-    for ma in dstPeer.addrs:
+    peer.write(1, msg.dstPeer.get().peerId)
+    for ma in msg.dstPeer.get().addrs:
      peer.write(2, ma.data.buffer)
    peer.finish()
    result.write(3, peer.buffer)
-  msg.status.withValue(status):
-    result.write(4, status.ord.uint)
+  if isSome(msg.status):
+    result.write(4, msg.status.get().ord.uint)

  result.finish()

-proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Opt[RelayMessage] =
+proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Option[RelayMessage] =
  var
    rMsg: RelayMessage
    msgTypeOrd: uint32
@@ -85,29 +88,37 @@ proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Opt[RelayMessage] =
    pbSrc: ProtoBuffer
    pbDst: ProtoBuffer

-  let pb = initProtoBuffer(buf)
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getField(1, msgTypeOrd)
+    r2 = pb.getField(2, pbSrc)
+    r3 = pb.getField(3, pbDst)
+    r4 = pb.getField(4, statusOrd)

-  if ? pb.getField(1, msgTypeOrd).toOpt():
+  if r1.isErr() or r2.isErr() or r3.isErr() or r4.isErr():
+    return none(RelayMessage)
+
+  if r2.get() and
+     (pbSrc.getField(1, src.peerId).isErr() or
+      pbSrc.getRepeatedField(2, src.addrs).isErr()):
+    return none(RelayMessage)
+
+  if r3.get() and
+     (pbDst.getField(1, dst.peerId).isErr() or
+      pbDst.getRepeatedField(2, dst.addrs).isErr()):
+    return none(RelayMessage)
+
+  if r1.get():
    if msgTypeOrd.int notin RelayType:
-      return Opt.none(RelayMessage)
-    rMsg.msgType = Opt.some(RelayType(msgTypeOrd))
-
-  if ? pb.getField(2, pbSrc).toOpt():
-    discard ? pbSrc.getField(1, src.peerId).toOpt()
-    discard ? pbSrc.getRepeatedField(2, src.addrs).toOpt()
-    rMsg.srcPeer = Opt.some(src)
-
-  if ? pb.getField(3, pbDst).toOpt():
-    discard ? pbDst.getField(1, dst.peerId).toOpt()
-    discard ? pbDst.getRepeatedField(2, dst.addrs).toOpt()
-    rMsg.dstPeer = Opt.some(dst)
-
-  if ? pb.getField(4, statusOrd).toOpt():
-    var status: StatusV1
-    if not checkedEnumAssign(status, statusOrd):
-      return Opt.none(RelayMessage)
-    rMsg.status = Opt.some(status)
-  Opt.some(rMsg)
+      return none(RelayMessage)
+    rMsg.msgType = some(RelayType(msgTypeOrd))
+  if r2.get(): rMsg.srcPeer = some(src)
+  if r3.get(): rMsg.dstPeer = some(dst)
+  if r4.get():
+    if statusOrd.int notin StatusV1:
+      return none(RelayMessage)
+    rMsg.status = some(StatusV1(statusOrd))
+  some(rMsg)

 # Voucher

@@ -167,7 +178,7 @@ type
  Reservation* = object
    expire*: uint64              # required, Unix expiration time (UTC)
    addrs*: seq[MultiAddress]    # relay address for reserving peer
-    svoucher*: Opt[seq[byte]]    # optional, reservation voucher
+    svoucher*: Option[seq[byte]] # optional, reservation voucher
  Limit* = object
    duration*: uint32            # seconds
    data*: uint64                # bytes
@@ -187,29 +198,30 @@ type
    Status = 2
  HopMessage* = object
    msgType*: HopMessageType
-    peer*: Opt[Peer]
-    reservation*: Opt[Reservation]
+    peer*: Option[Peer]
+    reservation*: Option[Reservation]
    limit*: Limit
-    status*: Opt[StatusV2]
+    status*: Option[StatusV2]

 proc encode*(msg: HopMessage): ProtoBuffer =
  var pb = initProtoBuffer()

  pb.write(1, msg.msgType.ord.uint)
-  msg.peer.withValue(peer):
+  if msg.peer.isSome():
    var ppb = initProtoBuffer()
-    ppb.write(1, peer.peerId)
-    for ma in peer.addrs:
+    ppb.write(1, msg.peer.get().peerId)
+    for ma in msg.peer.get().addrs:
      ppb.write(2, ma.data.buffer)
    ppb.finish()
    pb.write(2, ppb.buffer)
-  msg.reservation.withValue(rsrv):
+  if msg.reservation.isSome():
+    let rsrv = msg.reservation.get()
    var rpb = initProtoBuffer()
    rpb.write(1, rsrv.expire)
    for ma in rsrv.addrs:
      rpb.write(2, ma.data.buffer)
-    rsrv.svoucher.withValue(vouch):
-      rpb.write(3, vouch)
+    if rsrv.svoucher.isSome():
+      rpb.write(3, rsrv.svoucher.get())
    rpb.finish()
    pb.write(3, rpb.buffer)
  if msg.limit.duration > 0 or msg.limit.data > 0:
@@ -218,51 +230,65 @@ proc encode*(msg: HopMessage): ProtoBuffer =
    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
    lpb.finish()
    pb.write(4, lpb.buffer)
-  msg.status.withValue(status):
-    pb.write(5, status.ord.uint)
+  if msg.status.isSome():
+    pb.write(5, msg.status.get().ord.uint)

  pb.finish()
  pb

-proc decode*(_: typedesc[HopMessage], buf: seq[byte]): Opt[HopMessage] =
-  var msg: HopMessage
-  let pb = initProtoBuffer(buf)
+proc decode*(_: typedesc[HopMessage], buf: seq[byte]): Option[HopMessage] =
+  var
+    msg: HopMessage
+    msgTypeOrd: uint32
+    pbPeer: ProtoBuffer
+    pbReservation: ProtoBuffer
+    pbLimit: ProtoBuffer
+    statusOrd: uint32
+    peer: Peer
+    reservation: Reservation
+    limit: Limit
+    res: bool
+
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, msgTypeOrd)
+    r2 = pb.getField(2, pbPeer)
+    r3 = pb.getField(3, pbReservation)
+    r4 = pb.getField(4, pbLimit)
+    r5 = pb.getField(5, statusOrd)
+
+  if r1.isErr() or r2.isErr() or r3.isErr() or r4.isErr() or r5.isErr():
+    return none(HopMessage)
+
+  if r2.get() and
+     (pbPeer.getRequiredField(1, peer.peerId).isErr() or
+      pbPeer.getRepeatedField(2, peer.addrs).isErr()):
+    return none(HopMessage)
+
+  if r3.get():
+    var svoucher: seq[byte]
+    let rSVoucher = pbReservation.getField(3, svoucher)
+    if pbReservation.getRequiredField(1, reservation.expire).isErr() or
+       pbReservation.getRepeatedField(2, reservation.addrs).isErr() or
+       rSVoucher.isErr():
+      return none(HopMessage)
+    if rSVoucher.get(): reservation.svoucher = some(svoucher)
+
+  if r4.get() and
+     (pbLimit.getField(1, limit.duration).isErr() or
+      pbLimit.getField(2, limit.data).isErr()):
+    return none(HopMessage)

-  var msgTypeOrd: uint32
-  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
  if not checkedEnumAssign(msg.msgType, msgTypeOrd):
-    return Opt.none(HopMessage)
-
-  var pbPeer: ProtoBuffer
-  if ? pb.getField(2, pbPeer).toOpt():
-    var peer: Peer
-    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
-    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
-    msg.peer = Opt.some(peer)
-
-  var pbReservation: ProtoBuffer
-  if ? pb.getField(3, pbReservation).toOpt():
-    var
-      svoucher: seq[byte]
-      reservation: Reservation
-    if ? pbReservation.getField(3, svoucher).toOpt():
-      reservation.svoucher = Opt.some(svoucher)
-    ? pbReservation.getRequiredField(1, reservation.expire).toOpt()
-    discard ? pbReservation.getRepeatedField(2, reservation.addrs).toOpt()
-    msg.reservation = Opt.some(reservation)
-
-  var pbLimit: ProtoBuffer
-  if ? pb.getField(4, pbLimit).toOpt():
-    discard ? pbLimit.getField(1, msg.limit.duration).toOpt()
-    discard ? pbLimit.getField(2, msg.limit.data).toOpt()
-
-  var statusOrd: uint32
-  if ? pb.getField(5, statusOrd).toOpt():
-    var status: StatusV2
-    if not checkedEnumAssign(status, statusOrd):
-      return Opt.none(HopMessage)
-    msg.status = Opt.some(status)
-  Opt.some(msg)
+    return none(HopMessage)
+  if r2.get(): msg.peer = some(peer)
+  if r3.get(): msg.reservation = some(reservation)
+  if r4.get(): msg.limit = limit
+  if r5.get():
+    if statusOrd.int notin StatusV2:
+      return none(HopMessage)
+    msg.status = some(StatusV2(statusOrd))
+  some(msg)

 # Circuit Relay V2 Stop Message

@@ -272,19 +298,19 @@ type
    Status = 1
  StopMessage* = object
    msgType*: StopMessageType
-    peer*: Opt[Peer]
+    peer*: Option[Peer]
    limit*: Limit
-    status*: Opt[StatusV2]
+    status*: Option[StatusV2]


 proc encode*(msg: StopMessage): ProtoBuffer =
  var pb = initProtoBuffer()

  pb.write(1, msg.msgType.ord.uint)
-  msg.peer.withValue(peer):
+  if msg.peer.isSome():
    var ppb = initProtoBuffer()
-    ppb.write(1, peer.peerId)
-    for ma in peer.addrs:
+    ppb.write(1, msg.peer.get().peerId)
+    for ma in msg.peer.get().addrs:
      ppb.write(2, ma.data.buffer)
    ppb.finish()
    pb.write(2, ppb.buffer)
@@ -294,40 +320,51 @@ proc encode*(msg: StopMessage): ProtoBuffer =
    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
    lpb.finish()
    pb.write(3, lpb.buffer)
-  msg.status.withValue(status):
-    pb.write(4, status.ord.uint)
+  if msg.status.isSome():
+    pb.write(4, msg.status.get().ord.uint)

  pb.finish()
  pb

-proc decode*(_: typedesc[StopMessage], buf: seq[byte]): Opt[StopMessage] =
-  var msg: StopMessage
+proc decode*(_: typedesc[StopMessage], buf: seq[byte]): Option[StopMessage] =
+  var
+    msg: StopMessage
+    msgTypeOrd: uint32
+    pbPeer: ProtoBuffer
+    pbLimit: ProtoBuffer
+    statusOrd: uint32
+    peer: Peer
+    limit: Limit
+    rVoucher: ProtoResult[bool]
+    res: bool

-  let pb = initProtoBuffer(buf)
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, msgTypeOrd)
+    r2 = pb.getField(2, pbPeer)
+    r3 = pb.getField(3, pbLimit)
+    r4 = pb.getField(4, statusOrd)

-  var msgTypeOrd: uint32
-  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
-  if msgTypeOrd.int notin StopMessageType:
-    return Opt.none(StopMessage)
+  if r1.isErr() or r2.isErr() or r3.isErr() or r4.isErr():
+    return none(StopMessage)
+
+  if r2.get() and
+     (pbPeer.getRequiredField(1, peer.peerId).isErr() or
+      pbPeer.getRepeatedField(2, peer.addrs).isErr()):
+    return none(StopMessage)
+
+  if r3.get() and
+     (pbLimit.getField(1, limit.duration).isErr() or
+      pbLimit.getField(2, limit.data).isErr()):
+    return none(StopMessage)
+
+  if msgTypeOrd.int notin StopMessageType.low.ord .. StopMessageType.high.ord:
+    return none(StopMessage)
  msg.msgType = StopMessageType(msgTypeOrd)
-
-
-  var pbPeer: ProtoBuffer
-  if ? pb.getField(2, pbPeer).toOpt():
-    var peer: Peer
-    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
-    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
-    msg.peer = Opt.some(peer)
-
-  var pbLimit: ProtoBuffer
-  if ? pb.getField(3, pbLimit).toOpt():
-    discard ? pbLimit.getField(1, msg.limit.duration).toOpt()
-    discard ? pbLimit.getField(2, msg.limit.data).toOpt()
-
-  var statusOrd: uint32
-  if ? pb.getField(4, statusOrd).toOpt():
-    var status: StatusV2
-    if not checkedEnumAssign(status, statusOrd):
-      return Opt.none(StopMessage)
-    msg.status = Opt.some(status)
-  Opt.some(msg)
+  if r2.get(): msg.peer = some(peer)
+  if r3.get(): msg.limit = limit
+  if r4.get():
+    if statusOrd.int notin StatusV2:
+      return none(StopMessage)
+    msg.status = some(StatusV2(statusOrd))
+  some(msg)
--- a/libp2p/protocols/connectivity/relay/rconn.nim
+++ b/libp2p/protocols/connectivity/relay/rconn.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos

@@ -47,7 +50,6 @@ proc new*(
  limitDuration: uint32,
  limitData: uint64): T =
  let rc = T(conn: conn, limitDuration: limitDuration, limitData: limitData)
-  rc.dir = conn.dir
  rc.initStream()
  if limitDuration > 0:
    proc checkDurationConnection() {.async.} =
--- a/libp2p/protocols/connectivity/relay/relay.nim
+++ b/libp2p/protocols/connectivity/relay/relay.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import sequtils, tables
+import options, sequtils, tables, sugar

 import chronos, chronicles

@@ -22,6 +25,7 @@ import ./messages,
       ../../../multicodec,
       ../../../stream/connection,
       ../../../protocols/protocol,
+       ../../../transports/transport,
       ../../../errors,
       ../../../utils/heartbeat,
       ../../../signed_envelope
@@ -90,14 +94,14 @@ proc createReserveResponse(
    rsrv = Reservation(expire: expireUnix,
                       addrs: r.switch.peerInfo.addrs.mapIt(
                         ? it.concat(ma).orErr(CryptoError.KeyError)),
-                       svoucher: Opt.some(? sv.encode))
+                       svoucher: some(? sv.encode))
    msg = HopMessage(msgType: HopMessageType.Status,
-                     reservation: Opt.some(rsrv),
+                     reservation: some(rsrv),
                     limit: r.limit,
-                     status: Opt.some(Ok))
+                     status: some(Ok))
  return ok(msg)

-proc isRelayed*(conn: Connection): bool =
+proc isRelayed(conn: Connection): bool =
  var wrappedConn = conn
  while not isNil(wrappedConn):
    if wrappedConn of RelayConnection:
@@ -105,7 +109,7 @@ proc isRelayed*(conn: Connection): bool =
    wrappedConn = wrappedConn.getWrapped()
  return false

-proc handleReserve(r: Relay, conn: Connection) {.async.} =
+proc handleReserve(r: Relay, conn: Connection) {.async, gcsafe.} =
  if conn.isRelayed():
    trace "reservation attempt over relay connection", pid = conn.peerId
    await sendHopStatus(conn, PermissionDenied)
@@ -115,30 +119,32 @@ proc handleReserve(r: Relay, conn: Connection) {.async.} =
    trace "Too many reservations", pid = conn.peerId
    await sendHopStatus(conn, ReservationRefused)
    return
-  trace "reserving relay slot for", pid = conn.peerId
  let
    pid = conn.peerId
    expire = now().utc + r.reservationTTL
-    msg = r.createReserveResponse(pid, expire).valueOr:
-      trace "error signing the voucher", pid
-      return
+    msg = r.createReserveResponse(pid, expire)

+  trace "reserving relay slot for", pid
+  if msg.isErr():
+    trace "error signing the voucher", error = error(msg), pid
+    return
  r.rsvp[pid] = expire
-  await conn.writeLp(encode(msg).buffer)
+  await conn.writeLp(encode(msg.get()).buffer)

 proc handleConnect(r: Relay,
                   connSrc: Connection,
-                   msg: HopMessage) {.async.} =
+                   msg: HopMessage) {.async, gcsafe.} =
  if connSrc.isRelayed():
    trace "connection attempt over relay connection"
    await sendHopStatus(connSrc, PermissionDenied)
    return
+  if msg.peer.isNone():
+    await sendHopStatus(connSrc, MalformedMessage)
+    return
+
  let
-    msgPeer = msg.peer.valueOr:
-      await sendHopStatus(connSrc, MalformedMessage)
-      return
    src = connSrc.peerId
-    dst = msgPeer.peerId
+    dst = msg.peer.get().peerId
  if dst notin r.rsvp:
    trace "refusing connection, no reservation", src, dst
    await sendHopStatus(connSrc, NoReservation)
@@ -171,17 +177,16 @@ proc handleConnect(r: Relay,

  proc sendStopMsg() {.async.} =
    let stopMsg = StopMessage(msgType: StopMessageType.Connect,
-                            peer: Opt.some(Peer(peerId: src, addrs: @[])),
+                            peer: some(Peer(peerId: src, addrs: @[])),
                            limit: r.limit)
    await connDst.writeLp(encode(stopMsg).buffer)
-    let msg = StopMessage.decode(await connDst.readLp(r.msgSize)).valueOr:
-      raise newException(SendStopError, "Malformed message")
+    let msg = StopMessage.decode(await connDst.readLp(r.msgSize)).get()
    if msg.msgType != StopMessageType.Status:
      raise newException(SendStopError, "Unexpected stop response, not a status message")
    if msg.status.get(UnexpectedMessage) != Ok:
      raise newException(SendStopError, "Relay stop failure")
    await connSrc.writeLp(encode(HopMessage(msgType: HopMessageType.Status,
-                                          status: Opt.some(Ok))).buffer)
+                                          status: some(Ok))).buffer)
  try:
    await sendStopMsg()
  except CancelledError as exc:
@@ -200,11 +205,13 @@ proc handleConnect(r: Relay,
    await rconnDst.close()
  await bridge(rconnSrc, rconnDst)

-proc handleHopStreamV2*(r: Relay, conn: Connection) {.async.} =
-  let msg = HopMessage.decode(await conn.readLp(r.msgSize)).valueOr:
+proc handleHopStreamV2*(r: Relay, conn: Connection) {.async, gcsafe.} =
+  let msgOpt = HopMessage.decode(await conn.readLp(r.msgSize))
+  if msgOpt.isNone():
    await sendHopStatus(conn, MalformedMessage)
    return
-  trace "relayv2 handle stream", msg = msg
+  trace "relayv2 handle stream", msg = msgOpt.get()
+  let msg = msgOpt.get()
  case msg.msgType:
  of HopMessageType.Reserve: await r.handleReserve(conn)
  of HopMessageType.Connect: await r.handleConnect(conn, msg)
@@ -214,7 +221,7 @@ proc handleHopStreamV2*(r: Relay, conn: Connection) {.async.} =

 # Relay V1

-proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
+proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsafe.} =
  r.streamCount.inc()
  defer: r.streamCount.dec()
  if r.streamCount + r.rsvp.len() >= r.maxCircuit:
@@ -222,14 +229,15 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
    await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
    return

-  var src, dst: RelayPeer
  proc checkMsg(): Result[RelayMessage, StatusV1] =
-    src = msg.srcPeer.valueOr:
+    if msg.srcPeer.isNone:
      return err(StatusV1.HopSrcMultiaddrInvalid)
+    let src = msg.srcPeer.get()
    if src.peerId != connSrc.peerId:
      return err(StatusV1.HopSrcMultiaddrInvalid)
-    dst = msg.dstPeer.valueOr:
+    if msg.dstPeer.isNone:
      return err(StatusV1.HopDstMultiaddrInvalid)
+    let dst = msg.dstPeer.get()
    if dst.peerId == r.switch.peerInfo.peerId:
      return err(StatusV1.HopCantRelayToSelf)
    if not r.switch.isConnected(dst.peerId):
@@ -241,6 +249,9 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
    await sendStatus(connSrc, check.error())
    return

+  let
+    src = msg.srcPeer.get()
+    dst = msg.dstPeer.get()
  if r.peerCount[src.peerId] >= r.maxCircuitPerPeer or
     r.peerCount[dst.peerId] >= r.maxCircuitPerPeer:
    trace "refusing connection; too many connection from src or to dst", src, dst
@@ -264,9 +275,9 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
    await connDst.close()

  let msgToSend = RelayMessage(
-    msgType: Opt.some(RelayType.Stop),
-    srcPeer: Opt.some(src),
-    dstPeer: Opt.some(dst))
+    msgType: some(RelayType.Stop),
+    srcPeer: some(src),
+    dstPeer: some(dst))

  let msgRcvFromDstOpt = try:
    await connDst.writeLp(encode(msgToSend).buffer)
@@ -278,11 +289,12 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
    await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
    return

-  let msgRcvFromDst = msgRcvFromDstOpt.valueOr:
+  if msgRcvFromDstOpt.isNone:
    trace "error reading stop response", msg = msgRcvFromDstOpt
    await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
    return

+  let msgRcvFromDst = msgRcvFromDstOpt.get()
  if msgRcvFromDst.msgType.get(RelayType.Stop) != RelayType.Status or
     msgRcvFromDst.status.get(StatusV1.StopRelayRefused) != StatusV1.Success:
    trace "unexcepted relay stop response", msgRcvFromDst
@@ -293,17 +305,14 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
  trace "relaying connection", src, dst
  await bridge(connSrc, connDst)

-proc handleStreamV1(r: Relay, conn: Connection) {.async.} =
-  let msg = RelayMessage.decode(await conn.readLp(r.msgSize)).valueOr:
+proc handleStreamV1(r: Relay, conn: Connection) {.async, gcsafe.} =
+  let msgOpt = RelayMessage.decode(await conn.readLp(r.msgSize))
+  if msgOpt.isNone:
    await sendStatus(conn, StatusV1.MalformedMessage)
    return
-  trace "relay handle stream", msg
-
-  let typ = msg.msgType.valueOr:
-    trace "Message type not set"
-    await sendStatus(conn, StatusV1.MalformedMessage)
-    return
-  case typ:
+  trace "relay handle stream", msg = msgOpt.get()
+  let msg = msgOpt.get()
+  case msg.msgType.get:
    of RelayType.Hop: await r.handleHop(conn, msg)
    of RelayType.Stop: await sendStatus(conn, StatusV1.StopRelayRefused)
    of RelayType.CanHop: await sendStatus(conn, StatusV1.Success)
@@ -336,7 +345,7 @@ proc new*(T: typedesc[Relay],
            msgSize: msgSize,
            isCircuitRelayV1: circuitRelayV1)

-  proc handleStream(conn: Connection, proto: string) {.async.} =
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
    try:
      case proto:
      of RelayV2HopCodec: await r.handleHopStreamV2(conn)
--- a/libp2p/protocols/connectivity/relay/rtransport.nim
+++ b/libp2p/protocols/connectivity/relay/rtransport.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import sequtils, strutils

@@ -37,33 +40,33 @@ method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
  self.client.onNewConnection = proc(
    conn: Connection,
    duration: uint32 = 0,
-    data: uint64 = 0) {.async.} =
+    data: uint64 = 0) {.async, gcsafe, raises: [Defect].} =
      await self.queue.addLast(RelayConnection.new(conn, duration, data))
      await conn.join()
  self.selfRunning = true
  await procCall Transport(self).start(ma)
  trace "Starting Relay transport"

-method stop*(self: RelayTransport) {.async.} =
+method stop*(self: RelayTransport) {.async, gcsafe.} =
  self.running = false
  self.selfRunning = false
  self.client.onNewConnection = nil
  while not self.queue.empty():
    await self.queue.popFirstNoWait().close()

-method accept*(self: RelayTransport): Future[Connection] {.async.} =
+method accept*(self: RelayTransport): Future[Connection] {.async, gcsafe.} =
  result = await self.queue.popFirst()

-proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async.} =
+proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async, gcsafe.} =
  let
    sma = toSeq(ma.items())
    relayAddrs = sma[0..sma.len-4].mapIt(it.tryGet()).foldl(a & b)
  var
    relayPeerId: PeerId
    dstPeerId: PeerId
-  if not relayPeerId.init(($(sma[^3].tryGet())).split('/')[2]):
+  if not relayPeerId.init(($(sma[^3].get())).split('/')[2]):
    raise newException(RelayV2DialError, "Relay doesn't exist")
-  if not dstPeerId.init(($(sma[^1].tryGet())).split('/')[2]):
+  if not dstPeerId.init(($(sma[^1].get())).split('/')[2]):
    raise newException(RelayV2DialError, "Destination doesn't exist")
  trace "Dial", relayPeerId, dstPeerId

@@ -89,19 +92,15 @@ proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async.}
 method dial*(
  self: RelayTransport,
  hostname: string,
-  ma: MultiAddress,
-  peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection] {.async.} =
-  peerId.withValue(pid):
-    let address = MultiAddress.init($ma & "/p2p/" & $pid).tryGet()
-    result = await self.dial(address)
+  address: MultiAddress): Future[Connection] {.async, gcsafe.} =
+  result = await self.dial(address)

-method handles*(self: RelayTransport, ma: MultiAddress): bool {.gcsafe.} =
-  try:
-    if ma.protocols.isOk():
-      let sma = toSeq(ma.items())
-      result = sma.len >= 2 and CircuitRelay.match(sma[^1].tryGet())
-  except CatchableError as exc:
-    result = false
+method handles*(self: RelayTransport, ma: MultiAddress): bool {.gcsafe} =
+  if ma.protocols.isOk():
+    let sma = toSeq(ma.items())
+    if sma.len >= 3:
+      result = CircuitRelay.match(sma[^2].get()) and
+               P2PPattern.match(sma[^1].get())
  trace "Handles return", ma, result

 proc new*(T: typedesc[RelayTransport], cl: RelayClient, upgrader: Upgrade): T =
--- a/libp2p/protocols/connectivity/relay/utils.nim
+++ b/libp2p/protocols/connectivity/relay/utils.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,15 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import options

 import chronos, chronicles
+
 import ./messages,
       ../../../stream/connection

@@ -21,24 +27,24 @@ const
  RelayV2HopCodec* = "/libp2p/circuit/relay/0.2.0/hop"
  RelayV2StopCodec* = "/libp2p/circuit/relay/0.2.0/stop"

-proc sendStatus*(conn: Connection, code: StatusV1) {.async.} =
+proc sendStatus*(conn: Connection, code: StatusV1) {.async, gcsafe.} =
  trace "send relay/v1 status", status = $code & "(" & $ord(code) & ")"
  let
-    msg = RelayMessage(msgType: Opt.some(RelayType.Status), status: Opt.some(code))
+    msg = RelayMessage(msgType: some(RelayType.Status), status: some(code))
    pb = encode(msg)
  await conn.writeLp(pb.buffer)

-proc sendHopStatus*(conn: Connection, code: StatusV2) {.async.} =
+proc sendHopStatus*(conn: Connection, code: StatusV2) {.async, gcsafe.} =
  trace "send hop relay/v2 status", status = $code & "(" & $ord(code) & ")"
  let
-    msg = HopMessage(msgType: HopMessageType.Status, status: Opt.some(code))
+    msg = HopMessage(msgType: HopMessageType.Status, status: some(code))
    pb = encode(msg)
  await conn.writeLp(pb.buffer)

 proc sendStopStatus*(conn: Connection, code: StatusV2) {.async.} =
  trace "send stop relay/v2 status", status = $code & " (" & $ord(code) & ")"
  let
-    msg = StopMessage(msgType: StopMessageType.Status, status: Opt.some(code))
+    msg = StopMessage(msgType: StopMessageType.Status, status: some(code))
    pb = encode(msg)
  await conn.writeLp(pb.buffer)

--- a/libp2p/protocols/identify.nim
+++ b/libp2p/protocols/identify.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -10,7 +10,10 @@
 ## `Identify <https://docs.libp2p.io/concepts/protocols/#identify>`_ and
 ## `Push Identify <https://docs.libp2p.io/concepts/protocols/#identify-push>`_ implementation

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[sequtils, options, strutils, sugar]
 import stew/results
@@ -21,13 +24,9 @@ import ../protobuf/minprotobuf,
       ../peerid,
       ../crypto/crypto,
       ../multiaddress,
-       ../multicodec,
       ../protocols/protocol,
       ../utility,
-       ../errors,
-       ../observedaddrmanager
-
-export observedaddrmanager
+       ../errors

 logScope:
  topics = "libp2p identify"
@@ -57,13 +56,12 @@ type
  Identify* = ref object of LPProtocol
    peerInfo*: PeerInfo
    sendSignedPeerRecord*: bool
-    observedAddrManager*: ObservedAddrManager

  IdentifyPushHandler* = proc (
    peer: PeerId,
    newInfo: IdentifyInfo):
    Future[void]
-    {.gcsafe, raises: [], public.}
+    {.gcsafe, raises: [Defect], public.}

  IdentifyPush* = ref object of LPProtocol
    identifyHandler: IdentifyPushHandler
@@ -72,28 +70,30 @@ chronicles.expandIt(IdentifyInfo):
  pubkey = ($it.pubkey).shortLog
  addresses = it.addrs.map(x => $x).join(",")
  protocols = it.protos.map(x => $x).join(",")
-  observable_address = $it.observedAddr
+  observable_address =
+    if it.observedAddr.isSome(): $it.observedAddr.get()
+    else: "None"
  proto_version = it.protoVersion.get("None")
  agent_version = it.agentVersion.get("None")
  signedPeerRecord =
    # The SPR contains the same data as the identify message
    # would be cumbersome to log
-    if it.signedPeerRecord.isSome(): "Some"
+    if iinfo.signedPeerRecord.isSome(): "Some"
    else: "None"

 proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool): ProtoBuffer
-  {.raises: [].} =
+  {.raises: [Defect].} =
  result = initProtoBuffer()

  let pkey = peerInfo.publicKey

-  result.write(1, pkey.getBytes().expect("valid key"))
+  result.write(1, pkey.getBytes().get())
  for ma in peerInfo.addrs:
    result.write(2, ma.data.buffer)
  for proto in peerInfo.protocols:
    result.write(3, proto)
-  observedAddr.withValue(observed):
-    result.write(4, observed.data.buffer)
+  if observedAddr.isSome:
+    result.write(4, observedAddr.get().data.buffer)
  let protoVersion = ProtoVersion
  result.write(5, protoVersion)
  let agentVersion = if peerInfo.agentVersion.len <= 0:
@@ -105,12 +105,13 @@ proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: boo
  ## Optionally populate signedPeerRecord field.
  ## See https://github.com/libp2p/go-libp2p/blob/ddf96ce1cfa9e19564feb9bd3e8269958bbc0aba/p2p/protocol/identify/pb/identify.proto for reference.
  if sendSpr:
-    peerInfo.signedPeerRecord.envelope.encode().toOpt().withValue(sprBuff):
-      result.write(8, sprBuff)
+    let sprBuff = peerInfo.signedPeerRecord.envelope.encode()
+    if sprBuff.isOk():
+      result.write(8, sprBuff.get())

  result.finish()

-proc decodeMsg*(buf: seq[byte]): Opt[IdentifyInfo] =
+proc decodeMsg*(buf: seq[byte]): Option[IdentifyInfo] =
  var
    iinfo: IdentifyInfo
    pubkey: PublicKey
@@ -120,38 +121,52 @@ proc decodeMsg*(buf: seq[byte]): Opt[IdentifyInfo] =
    signedPeerRecord: SignedPeerRecord

  var pb = initProtoBuffer(buf)
-  if ? pb.getField(1, pubkey).toOpt():
-    iinfo.pubkey = some(pubkey)
-    if ? pb.getField(8, signedPeerRecord).toOpt() and
-      pubkey == signedPeerRecord.envelope.publicKey:
-      iinfo.signedPeerRecord = some(signedPeerRecord.envelope)
-  discard ? pb.getRepeatedField(2, iinfo.addrs).toOpt()
-  discard ? pb.getRepeatedField(3, iinfo.protos).toOpt()
-  if ? pb.getField(4, oaddr).toOpt():
-    iinfo.observedAddr = some(oaddr)
-  if ? pb.getField(5, protoVersion).toOpt():
-    iinfo.protoVersion = some(protoVersion)
-  if ? pb.getField(6, agentVersion).toOpt():
-    iinfo.agentVersion = some(agentVersion)

-  Opt.some(iinfo)
+  let r1 = pb.getField(1, pubkey)
+  let r2 = pb.getRepeatedField(2, iinfo.addrs)
+  let r3 = pb.getRepeatedField(3, iinfo.protos)
+  let r4 = pb.getField(4, oaddr)
+  let r5 = pb.getField(5, protoVersion)
+  let r6 = pb.getField(6, agentVersion)
+
+  let r8 = pb.getField(8, signedPeerRecord)
+
+  let res = r1.isOk() and r2.isOk() and r3.isOk() and
+            r4.isOk() and r5.isOk() and r6.isOk() and
+            r8.isOk()
+
+  if res:
+    if r1.get():
+      iinfo.pubkey = some(pubkey)
+    if r4.get():
+      iinfo.observedAddr = some(oaddr)
+    if r5.get():
+      iinfo.protoVersion = some(protoVersion)
+    if r6.get():
+      iinfo.agentVersion = some(agentVersion)
+    if r8.get() and r1.get():
+      if iinfo.pubkey.get() == signedPeerRecord.envelope.publicKey:
+        iinfo.signedPeerRecord = some(signedPeerRecord.envelope)
+    debug "decodeMsg: decoded identify", iinfo
+    some(iinfo)
+  else:
+    trace "decodeMsg: failed to decode received message"
+    none[IdentifyInfo]()

 proc new*(
  T: typedesc[Identify],
  peerInfo: PeerInfo,
-  sendSignedPeerRecord = false,
-  observedAddrManager = ObservedAddrManager.new(),
+  sendSignedPeerRecord = false
  ): T =
  let identify = T(
    peerInfo: peerInfo,
-    sendSignedPeerRecord: sendSignedPeerRecord,
-    observedAddrManager: observedAddrManager,
+    sendSignedPeerRecord: sendSignedPeerRecord
  )
  identify.init()
  identify

 method init*(p: Identify) =
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe, closure.} =
    try:
      trace "handling identify request", conn
      var pb = encodeMsg(p.peerInfo, conn.observedAddr, p.sendSignedPeerRecord)
@@ -167,34 +182,34 @@ method init*(p: Identify) =
  p.handler = handle
  p.codec = IdentifyCodec

-proc identify*(self: Identify,
+proc identify*(p: Identify,
               conn: Connection,
-               remotePeerId: PeerId): Future[IdentifyInfo] {.async.} =
+               remotePeerId: PeerId): Future[IdentifyInfo] {.async, gcsafe.} =
  trace "initiating identify", conn
  var message = await conn.readLp(64*1024)
  if len(message) == 0:
    trace "identify: Empty message received!", conn
    raise newException(IdentityInvalidMsgError, "Empty message received!")

-  var info = decodeMsg(message).valueOr: raise newException(IdentityInvalidMsgError, "Incorrect message received!")
-  debug "identify: decoded message", conn, info
-  let
-    pubkey = info.pubkey.valueOr: raise newException(IdentityInvalidMsgError, "No pubkey in identify")
-    peer = PeerId.init(pubkey).valueOr: raise newException(IdentityInvalidMsgError, $error)
+  let infoOpt = decodeMsg(message)
+  if infoOpt.isNone():
+    raise newException(IdentityInvalidMsgError, "Incorrect message received!")
+  result = infoOpt.get()

-  if peer != remotePeerId:
-    trace "Peer ids don't match", remote = peer, local = remotePeerId
-    raise newException(IdentityNoMatchError, "Peer ids don't match")
-  info.peerId = peer
+  if result.pubkey.isSome:
+    let peer = PeerId.init(result.pubkey.get())
+    if peer.isErr:
+      raise newException(IdentityInvalidMsgError, $peer.error)
+    else:
+      result.peerId = peer.get()
+      if peer.get() != remotePeerId:
+        trace "Peer ids don't match",
+              remote = peer,
+              local = remotePeerId

-  info.observedAddr.withValue(observed):
-    # Currently, we use the ObservedAddrManager only to find our dialable external NAT address. Therefore, addresses
-    # like "...\p2p-circuit\p2p\..." and "\p2p\..." are not useful to us.
-    if observed.contains(multiCodec("p2p-circuit")).get(false) or P2PPattern.matchPartial(observed):
-      trace "Not adding address to ObservedAddrManager.", observed
-    elif not self.observedAddrManager.addObservation(observed):
-      trace "Observed address is not valid.", observedAddr = observed
-  return info
+        raise newException(IdentityNoMatchError, "Peer ids don't match")
+  else:
+    raise newException(IdentityInvalidMsgError, "No pubkey in identify")

 proc new*(T: typedesc[IdentifyPush], handler: IdentifyPushHandler = nil): T {.public.} =
  ## Create a IdentifyPush protocol. `handler` will be called every time
@@ -204,24 +219,26 @@ proc new*(T: typedesc[IdentifyPush], handler: IdentifyPushHandler = nil): T {.pu
  identifypush

 proc init*(p: IdentifyPush) =
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe, closure.} =
    trace "handling identify push", conn
    try:
      var message = await conn.readLp(64*1024)

-      var identInfo = decodeMsg(message).valueOr:
+      let infoOpt = decodeMsg(message)
+      if infoOpt.isNone():
        raise newException(IdentityInvalidMsgError, "Incorrect message received!")
-      debug "identify push: decoded message", conn, identInfo

-      identInfo.pubkey.withValue(pubkey):
-        let receivedPeerId = PeerId.init(pubkey).tryGet()
+      var indentInfo = infoOpt.get()
+
+      if indentInfo.pubkey.isSome:
+        let receivedPeerId = PeerId.init(indentInfo.pubkey.get()).tryGet()
        if receivedPeerId != conn.peerId:
          raise newException(IdentityNoMatchError, "Peer ids don't match")
-        identInfo.peerId = receivedPeerId
+        indentInfo.peerId = receivedPeerId

      trace "triggering peer event", peerInfo = conn.peerId
      if not isNil(p.identifyHandler):
-        await p.identifyHandler(conn.peerId, identInfo)
+        await p.identifyHandler(conn.peerId, indentInfo)
    except CancelledError as exc:
      raise exc
    except CatchableError as exc:
--- a/libp2p/protocols/perf/client.nim
+++ b/libp2p/protocols/perf/client.nim
@@ -1,47 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
-
-import chronos, chronicles, sequtils
-import stew/endians2
-import ./core, ../../stream/connection
-
-logScope:
-  topics = "libp2p perf"
-
-type PerfClient* = ref object of RootObj
-
-proc perf*(_: typedesc[PerfClient], conn: Connection,
-           sizeToWrite: uint64 = 0, sizeToRead: uint64 = 0):
-           Future[Duration] {.async, public.} =
-  var
-    size = sizeToWrite
-    buf: array[PerfSize, byte]
-  let start = Moment.now()
-  trace "starting performance benchmark", conn, sizeToWrite, sizeToRead
-
-  await conn.write(toSeq(toBytesBE(sizeToRead)))
-  while size > 0:
-    let toWrite = min(size, PerfSize)
-    await conn.write(buf[0..<toWrite])
-    size -= toWrite
-
-  await conn.close()
-
-  size = sizeToRead
-
-  while size > 0:
-    let toRead = min(size, PerfSize)
-    await conn.readExactly(addr buf[0], toRead.int)
-    size = size - toRead
-
-  let duration = Moment.now() - start
-  trace "finishing performance benchmark", duration
-  return duration
--- a/libp2p/protocols/perf/core.nim
+++ b/libp2p/protocols/perf/core.nim
@@ -1,14 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
-
-const
-  PerfCodec* = "/perf/1.0.0"
-  PerfSize* = 65536
--- a/libp2p/protocols/perf/server.nim
+++ b/libp2p/protocols/perf/server.nim
@@ -1,60 +0,0 @@
-# Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
-# Licensed under either of
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
-# at your option.
-# This file may not be copied, modified, or distributed except according to
-# those terms.
-
-## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
-
-{.push raises: [].}
-
-import chronos, chronicles
-import stew/endians2
-import ./core,
-       ../protocol,
-       ../../stream/connection,
-       ../../utility
-
-export chronicles, connection
-
-logScope:
-  topics = "libp2p perf"
-
-type Perf* = ref object of LPProtocol
-
-proc new*(T: typedesc[Perf]): T {.public.} =
-  var p = T()
-  proc handle(conn: Connection, proto: string) {.async.} =
-    var bytesRead = 0
-    try:
-      trace "Received benchmark performance check", conn
-      var
-        sizeBuffer: array[8, byte]
-        size: uint64
-      await conn.readExactly(addr sizeBuffer[0], 8)
-      size = uint64.fromBytesBE(sizeBuffer)
-
-      var toReadBuffer: array[PerfSize, byte]
-      try:
-        while true:
-          bytesRead += await conn.readOnce(addr toReadBuffer[0], PerfSize)
-      except CatchableError as exc:
-        discard
-
-      var buf: array[PerfSize, byte]
-      while size > 0:
-        let toWrite = min(size, PerfSize)
-        await conn.write(buf[0..<toWrite])
-        size -= toWrite
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      trace "exception in perf handler", exc = exc.msg, conn
-    await conn.close()
-
-  p.handler = handle
-  p.codec = PerfCodec
-  return p
--- a/libp2p/protocols/ping.nim
+++ b/libp2p/protocols/ping.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,10 +9,13 @@

 ## `Ping <https://docs.libp2p.io/concepts/protocols/#ping>`_ protocol implementation

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos, chronicles
-import bearssl/rand
+import bearssl/[rand, hash]
 import ../protobuf/minprotobuf,
       ../peerinfo,
       ../stream/connection,
@@ -39,7 +42,7 @@ type
  PingHandler* {.public.} = proc (
    peer: PeerId):
    Future[void]
-    {.gcsafe, raises: [].}
+    {.gcsafe, raises: [Defect].}

  Ping* = ref object of LPProtocol
    pingHandler*: PingHandler
@@ -51,7 +54,7 @@ proc new*(T: typedesc[Ping], handler: PingHandler = nil, rng: ref HmacDrbgContex
  ping

 method init*(p: Ping) =
-  proc handle(conn: Connection, proto: string) {.async.} =
+  proc handle(conn: Connection, proto: string) {.async, gcsafe, closure.} =
    try:
      trace "handling ping", conn
      var buf: array[PingSize, byte]
@@ -71,7 +74,7 @@ method init*(p: Ping) =
 proc ping*(
  p: Ping,
  conn: Connection,
-  ): Future[Duration] {.async, public.} =
+  ): Future[Duration] {.async, gcsafe, public.} =
  ## Sends ping to `conn`, returns the delay

  trace "initiating ping", conn
--- a/libp2p/protocols/protocol.nim
+++ b/libp2p/protocols/protocol.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos, stew/results
 import ../stream/connection
@@ -22,7 +25,7 @@ type
    conn: Connection,
    proto: string):
    Future[void]
-    {.gcsafe, raises: [].}
+    {.gcsafe, raises: [Defect].}

  LPProtocol* = ref object of RootObj
    codecs*: seq[string]
@@ -52,8 +55,8 @@ func `codec=`*(p: LPProtocol, codec: string) =
 proc new*(
  T: type LPProtocol,
  codecs: seq[string],
-  handler: LPProtoHandler,
-  maxIncomingStreams: Opt[int] | int = Opt.none(int)): T =
+  handler: LPProtoHandler,  # default(Opt[int]) or Opt.none(int) don't work on 1.2
+  maxIncomingStreams: Opt[int] | int = Opt[int]()): T =
  T(
    codecs: codecs,
    handler: handler,
--- a/libp2p/protocols/pubsub/floodsub.nim
+++ b/libp2p/protocols/pubsub/floodsub.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,15 +7,18 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[sets, hashes, tables]
+import std/[sequtils, sets, hashes, tables]
 import chronos, chronicles, metrics
 import ./pubsub,
       ./pubsubpeer,
       ./timedcache,
       ./peertable,
-       ./rpc/[message, messages, protobuf],
+       ./rpc/[message, messages],
       ../../crypto/crypto,
       ../../stream/connection,
       ../../peerid,
@@ -95,16 +98,7 @@ method unsubscribePeer*(f: FloodSub, peer: PeerId) =

 method rpcHandler*(f: FloodSub,
                   peer: PubSubPeer,
-                   data: seq[byte]) {.async.} =
-
-  var rpcMsg = decodeRpcMsg(data).valueOr:
-    debug "failed to decode msg from peer", peer, err = error
-    raise newException(CatchableError, "")
-
-  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
-  # trigger hooks
-  peer.recvObservers(rpcMsg)
-
+                   rpcMsg: RPCMsg) {.async.} =
  for i in 0..<min(f.topicsHigh, rpcMsg.subscriptions.len):
    template sub: untyped = rpcMsg.subscriptions[i]
    f.handleSubscribe(peer, sub.topic, sub.subscribe)
@@ -157,7 +151,7 @@ method rpcHandler*(f: FloodSub,

    # In theory, if topics are the same in all messages, we could batch - we'd
    # also have to be careful to only include validated messages
-    f.broadcast(toSendPeers, RPCMsg(messages: @[msg]), isHighPriority = false)
+    f.broadcast(toSendPeers, RPCMsg(messages: @[msg]))
    trace "Forwared message to peers", peers = toSendPeers.len

  f.updateMetrics(rpcMsg)
@@ -219,7 +213,7 @@ method publish*(f: FloodSub,
    return 0

  # Try to send to all peers that are known to be interested
-  f.broadcast(peers, RPCMsg(messages: @[msg]), isHighPriority = true)
+  f.broadcast(peers, RPCMsg(messages: @[msg]))

  when defined(libp2p_expensive_metrics):
    libp2p_pubsub_messages_published.inc(labelValues = [topic])
@@ -229,7 +223,7 @@ method publish*(f: FloodSub,
  return peers.len

 method initPubSub*(f: FloodSub)
-  {.raises: [InitializationError].} =
+  {.raises: [Defect, InitializationError].} =
  procCall PubSub(f).initPubSub()
  f.seen = TimedCache[MessageId].init(2.minutes)
  f.seenSalt = newSeqUninitialized[byte](sizeof(Hash))
--- a/libp2p/protocols/pubsub/gossipsub.nim
+++ b/libp2p/protocols/pubsub/gossipsub.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,18 +9,20 @@

 ## Gossip based publishing

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[sets, sequtils]
+import std/[tables, sets, options, sequtils]
 import chronos, chronicles, metrics
-import chronos/ratelimit
 import ./pubsub,
       ./floodsub,
       ./pubsubpeer,
       ./peertable,
       ./mcache,
       ./timedcache,
-       ./rpc/[messages, message, protobuf],
+       ./rpc/[messages, message],
       ../protocol,
       ../../stream/connection,
       ../../peerinfo,
@@ -41,14 +43,9 @@ logScope:
 declareCounter(libp2p_gossipsub_failed_publish, "number of failed publish")
 declareCounter(libp2p_gossipsub_invalid_topic_subscription, "number of invalid topic subscriptions that happened")
 declareCounter(libp2p_gossipsub_duplicate_during_validation, "number of duplicates received during message validation")
-declareCounter(libp2p_gossipsub_idontwant_saved_messages, "number of duplicates avoided by idontwant")
-declareCounter(libp2p_gossipsub_saved_bytes, "bytes saved by gossipsub optimizations", labels=["kind"])
 declareCounter(libp2p_gossipsub_duplicate, "number of duplicates received")
 declareCounter(libp2p_gossipsub_received, "number of messages received (deduplicated)")

-when defined(libp2p_expensive_metrics):
-  declareCounter(libp2p_pubsub_received_messages, "number of messages received", labels = ["id", "topic"])
-
 proc init*(_: type[GossipSubParams]): GossipSubParams =
  GossipSubParams(
      explicit: true,
@@ -80,10 +77,7 @@ proc init*(_: type[GossipSubParams]): GossipSubParams =
      behaviourPenaltyWeight: -1.0,
      behaviourPenaltyDecay: 0.999,
      disconnectBadPeers: false,
-      enablePX: false,
-      bandwidthEstimatebps: 100_000_000, # 100 Mbps or 12.5 MBps
-      overheadRateLimit: Opt.none(tuple[bytes: int, interval: Duration]),
-      disconnectPeerAboveRateLimit: false
+      enablePX: false
    )

 proc validateParameters*(parameters: GossipSubParams): Result[void, cstring] =
@@ -156,7 +150,7 @@ method init*(g: GossipSub) =
  g.codecs &= GossipSubCodec
  g.codecs &= GossipSubCodec_10

-method onNewPeer*(g: GossipSub, peer: PubSubPeer) =
+method onNewPeer(g: GossipSub, peer: PubSubPeer) =
  g.withPeerStats(peer.peerId) do (stats: var PeerStats):
    # Make sure stats and peer information match, even when reloading peer stats
    # from a previous connection
@@ -164,11 +158,8 @@ method onNewPeer*(g: GossipSub, peer: PubSubPeer) =
    peer.appScore = stats.appScore
    peer.behaviourPenalty = stats.behaviourPenalty

-    # Check if the score is below the threshold and disconnect the peer if necessary
-    g.disconnectIfBadScorePeer(peer, stats.score)
-
-  peer.iHaveBudget = IHavePeerBudget
-  peer.pingBudget = PingsPeerBudget
+    peer.iWantBudget = IWantPeerBudget
+    peer.iHaveBudget = IHavePeerBudget

 method onPubSubPeerEvent*(p: GossipSub, peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe.} =
  case event.kind
@@ -197,11 +188,11 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =
    return

  # remove from peer IPs collection too
-  pubSubPeer.address.withValue(address):
-    g.peersInIP.withValue(address, s):
+  if pubSubPeer.address.isSome():
+    g.peersInIP.withValue(pubSubPeer.address.get(), s):
      s[].excl(pubSubPeer.peerId)
      if s[].len == 0:
-        g.peersInIP.del(address)
+        g.peersInIP.del(pubSubPeer.address.get())

  for t in toSeq(g.mesh.keys):
    trace "pruning unsubscribing peer", pubSubPeer, score = pubSubPeer.score
@@ -210,8 +201,8 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =

  for t in toSeq(g.gossipsub.keys):
    g.gossipsub.removePeer(t, pubSubPeer)
-    # also try to remove from direct peers table here
-    g.subscribedDirectPeers.removePeer(t, pubSubPeer)
+    # also try to remove from explicit table here
+    g.explicit.removePeer(t, pubSubPeer)

  for t in toSeq(g.fanout.keys):
    g.fanout.removePeer(t, pubSubPeer)
@@ -220,8 +211,6 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =
    for topic, info in stats[].topicInfos.mpairs:
      info.firstMessageDeliveries = 0

-  pubSubPeer.stopSendNonPriorityTask()
-
  procCall FloodSub(g).unsubscribePeer(peer)

 proc handleSubscribe*(g: GossipSub,
@@ -252,7 +241,7 @@ proc handleSubscribe*(g: GossipSub,
    # subscribe remote peer to the topic
    discard g.gossipsub.addPeer(topic, peer)
    if peer.peerId in g.parameters.directPeers:
-      discard g.subscribedDirectPeers.addPeer(topic, peer)
+      discard g.explicit.addPeer(topic, peer)
  else:
    trace "peer unsubscribed from topic"

@@ -266,7 +255,7 @@ proc handleSubscribe*(g: GossipSub,

    g.fanout.removePeer(topic, peer)
    if peer.peerId in g.parameters.directPeers:
-      g.subscribedDirectPeers.removePeer(topic, peer)
+      g.explicit.removePeer(topic, peer)

  trace "gossip peers", peers = g.gossipsub.peers(topic), topic

@@ -274,35 +263,18 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
  g.handlePrune(peer, control.prune)

  var respControl: ControlMessage
-  g.handleIDontWant(peer, control.idontwant)
  let iwant = g.handleIHave(peer, control.ihave)
  if iwant.messageIds.len > 0:
    respControl.iwant.add(iwant)
  respControl.prune.add(g.handleGraft(peer, control.graft))
  let messages = g.handleIWant(peer, control.iwant)

-  let
-    isPruneNotEmpty = respControl.prune.len > 0
-    isIWantNotEmpty = respControl.iwant.len > 0
+  if
+    respControl.prune.len > 0 or
+    respControl.iwant.len > 0 or
+    messages.len > 0:
+    # iwant and prunes from here, also messages

-  if isPruneNotEmpty or isIWantNotEmpty:
-
-    if isIWantNotEmpty:
-      libp2p_pubsub_broadcast_iwant.inc(respControl.iwant.len.int64)
-
-    if isPruneNotEmpty:
-      for prune in respControl.prune:
-        if g.knownTopics.contains(prune.topicId):
-          libp2p_pubsub_broadcast_prune.inc(labelValues = [prune.topicId])
-        else:
-          libp2p_pubsub_broadcast_prune.inc(labelValues = ["generic"])
-
-    trace "sending control message", msg = shortLog(respControl), peer
-    g.send(
-      peer,
-      RPCMsg(control: some(respControl)), isHighPriority = true)
-
-  if messages.len > 0:
    for smsg in messages:
      for topic in smsg.topicIds:
        if g.knownTopics.contains(topic):
@@ -310,11 +282,18 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
        else:
          libp2p_pubsub_broadcast_messages.inc(labelValues = ["generic"])

-    # iwant replies have lower priority
-    trace "sending iwant reply messages", peer
+    libp2p_pubsub_broadcast_iwant.inc(respControl.iwant.len.int64)
+
+    for prune in respControl.prune:
+      if g.knownTopics.contains(prune.topicId):
+        libp2p_pubsub_broadcast_prune.inc(labelValues = [prune.topicId])
+      else:
+        libp2p_pubsub_broadcast_prune.inc(labelValues = ["generic"])
+
+    trace "sending control message", msg = shortLog(respControl), peer
    g.send(
      peer,
-      RPCMsg(messages: messages), isHighPriority = false)
+      RPCMsg(control: some(respControl), messages: messages))

 proc validateAndRelay(g: GossipSub,
                      msg: Message,
@@ -326,13 +305,12 @@ proc validateAndRelay(g: GossipSub,
    var seenPeers: HashSet[PubSubPeer]
    discard g.validationSeen.pop(msgIdSalted, seenPeers)
    libp2p_gossipsub_duplicate_during_validation.inc(seenPeers.len.int64)
-    libp2p_gossipsub_saved_bytes.inc((msg.data.len * seenPeers.len).int64, labelValues = ["validation_duplicate"])

    case validation
    of ValidationResult.Reject:
      debug "Dropping message after validation, reason: reject",
        msgId = shortLog(msgId), peer
-      await g.punishInvalidMessage(peer, msg)
+      g.punishInvalidMessage(peer, msg.topicIds)
      return
    of ValidationResult.Ignore:
      debug "Dropping message after validation, reason: ignore",
@@ -354,35 +332,15 @@ proc validateAndRelay(g: GossipSub,
      g.floodsub.withValue(t, peers): toSendPeers.incl(peers[])
      g.mesh.withValue(t, peers): toSendPeers.incl(peers[])

-      # add direct peers
-      toSendPeers.incl(g.subscribedDirectPeers.getOrDefault(t))
-
    # Don't send it to source peer, or peers that
    # sent it during validation
    toSendPeers.excl(peer)
    toSendPeers.excl(seenPeers)

-    # IDontWant is only worth it if the message is substantially
-    # bigger than the messageId
-    if msg.data.len > msgId.len * 10:
-      g.broadcast(toSendPeers, RPCMsg(control: some(ControlMessage(
-          idontwant: @[ControlIWant(messageIds: @[msgId])]
-        ))), isHighPriority = true)
-
-    for peer in toSendPeers:
-      for heDontWant in peer.heDontWants:
-        if msgId in heDontWant:
-          seenPeers.incl(peer)
-          libp2p_gossipsub_idontwant_saved_messages.inc
-          libp2p_gossipsub_saved_bytes.inc(msg.data.len.int64, labelValues = ["idontwant"])
-          break
-    toSendPeers.excl(seenPeers)
-
-
    # In theory, if topics are the same in all messages, we could batch - we'd
    # also have to be careful to only include validated messages
-    g.broadcast(toSendPeers, RPCMsg(messages: @[msg]), isHighPriority = false, validMsgId = msgId)
-    trace "forwarded message to peers", peers = toSendPeers.len, msgId, peer
+    g.broadcast(toSendPeers, RPCMsg(messages: @[msg]))
+    trace "forwared message to peers", peers = toSendPeers.len, msgId, peer
    for topic in msg.topicIds:
      if topic notin g.topics: continue

@@ -395,65 +353,9 @@ proc validateAndRelay(g: GossipSub,
  except CatchableError as exc:
    info "validateAndRelay failed", msg=exc.msg

-proc dataAndTopicsIdSize(msgs: seq[Message]): int =
-  msgs.mapIt(it.data.len + it.topicIds.mapIt(it.len).foldl(a + b, 0)).foldl(a + b, 0)
-
-proc rateLimit*(g: GossipSub, peer: PubSubPeer, rpcMsgOpt: Opt[RPCMsg], msgSize: int) {.async.} =
-  # In this way we count even ignored fields by protobuf
-
-  var rmsg = rpcMsgOpt.valueOr:
-    peer.overheadRateLimitOpt.withValue(overheadRateLimit):
-      if not overheadRateLimit.tryConsume(msgSize):
-        libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
-        debug "Peer sent a msg that couldn't be decoded and it's above rate limit.", peer, uselessAppBytesNum = msgSize
-        if g.parameters.disconnectPeerAboveRateLimit:
-          await g.disconnectPeer(peer)
-          raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
-
-    raise newException(CatchableError, "Peer msg couldn't be decoded")
-
-  let usefulMsgBytesNum =
-    if g.verifySignature:
-      byteSize(rmsg.messages)
-    else:
-      dataAndTopicsIdSize(rmsg.messages)
-
-  var uselessAppBytesNum = msgSize - usefulMsgBytesNum
-  rmsg.control.withValue(control):
-    uselessAppBytesNum -= (byteSize(control.ihave) + byteSize(control.iwant))
-
-  peer.overheadRateLimitOpt.withValue(overheadRateLimit):
-    if not overheadRateLimit.tryConsume(uselessAppBytesNum):
-      libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
-      debug "Peer sent too much useless application data and it's above rate limit.", peer, msgSize, uselessAppBytesNum, rmsg
-      if g.parameters.disconnectPeerAboveRateLimit:
-        await g.disconnectPeer(peer)
-        raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
-
 method rpcHandler*(g: GossipSub,
                  peer: PubSubPeer,
-                  data: seq[byte]) {.async.} =
-
-  let msgSize = data.len
-  var rpcMsg = decodeRpcMsg(data).valueOr:
-    debug "failed to decode msg from peer", peer, err = error
-    await rateLimit(g, peer, Opt.none(RPCMsg), msgSize)
-    return
-
-  when defined(libp2p_expensive_metrics):
-    for m in rpcMsg.messages:
-      for t in m.topicIds:
-        libp2p_pubsub_received_messages.inc(labelValues = [$peer.peerId, t])
-
-  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
-  await rateLimit(g, peer, Opt.some(rpcMsg), msgSize)
-
-  # trigger hooks
-  peer.recvObservers(rpcMsg)
-
-  if rpcMsg.ping.len in 1..<64 and peer.pingBudget > 0:
-    g.send(peer, RPCMsg(pong: rpcMsg.ping), isHighPriority = true)
-    peer.pingBudget.dec
+                  rpcMsg: RPCMsg) {.async.} =
  for i in 0..<min(g.topicsHigh, rpcMsg.subscriptions.len):
    template sub: untyped = rpcMsg.subscriptions[i]
    g.handleSubscribe(peer, sub.topic, sub.subscribe)
@@ -497,9 +399,6 @@ method rpcHandler*(g: GossipSub,

      libp2p_gossipsub_duplicate.inc()

-      if msg.data.len > msgId.len * 10:     #Dont relay to the peers from which we already received (We just do it for large messages)
-        peer.heDontWants[^1].incl(msgId)
-
      # onto the next message
      continue

@@ -514,14 +413,14 @@ method rpcHandler*(g: GossipSub,
      # always validate if signature is present or required
      debug "Dropping message due to failed signature verification",
        msgId = shortLog(msgId), peer
-      await g.punishInvalidMessage(peer, msg)
+      g.punishInvalidMessage(peer, msg.topicIds)
      continue

    if msg.seqno.len > 0 and msg.seqno.len != 8:
      # if we have seqno should be 8 bytes long
      debug "Dropping message due to invalid seqno length",
        msgId = shortLog(msgId), peer
-      await g.punishInvalidMessage(peer, msg)
+      g.punishInvalidMessage(peer, msg.topicIds)
      continue

    # g.anonymize needs no evaluation when receiving messages
@@ -565,7 +464,7 @@ method onTopicSubscription*(g: GossipSub, topic: string, subscribed: bool) =
            topicID: topic,
            peers: g.peerExchangeList(topic),
            backoff: g.parameters.unsubscribeBackoff.seconds.uint64)])))
-    g.broadcast(mpeers, msg, isHighPriority = true)
+    g.broadcast(mpeers, msg)

    for peer in mpeers:
      g.pruned(peer, topic, backoff = some(g.parameters.unsubscribeBackoff))
@@ -593,38 +492,32 @@ method publish*(g: GossipSub,

  var peers: HashSet[PubSubPeer]

-  # add always direct peers
-  peers.incl(g.subscribedDirectPeers.getOrDefault(topic))
-
-  if topic in g.topics: # if we're subscribed use the mesh
-    peers.incl(g.mesh.getOrDefault(topic))
-
  if g.parameters.floodPublish:
    # With flood publishing enabled, the mesh is used when propagating messages from other peers,
-    # but a peer's own messages will always be published to all known peers in the topic, limited
-    # to the amount of peers we can send it to in one heartbeat
-    var maxPeersToFlodOpt: Opt[int64]
-    if g.parameters.bandwidthEstimatebps > 0:
-      let
-        bandwidth = (g.parameters.bandwidthEstimatebps) div 8 div 1000 # Divisions are to convert it to Bytes per ms TODO replace with bandwidth estimate
-        msToTransmit = max(data.len div bandwidth, 1)
-      maxPeersToFlodOpt = Opt.some(max(g.parameters.heartbeatInterval.milliseconds div msToTransmit, g.parameters.dLow))
-
+    # but a peer's own messages will always be published to all known peers in the topic.
    for peer in g.gossipsub.getOrDefault(topic):
-      maxPeersToFlodOpt.withValue(maxPeersToFlod):
-        if peers.len >= maxPeersToFlod: break
      if peer.score >= g.parameters.publishThreshold:
        trace "publish: including flood/high score peer", peer
        peers.incl(peer)

-  if peers.len < g.parameters.dLow:
-    # not subscribed, or bad mesh, send to fanout peers
+  # add always direct peers
+  peers.incl(g.explicit.getOrDefault(topic))
+
+  if topic in g.topics: # if we're subscribed use the mesh
+    peers.incl(g.mesh.getOrDefault(topic))
+
+  if peers.len < g.parameters.dLow and g.parameters.floodPublish == false:
+    # not subscribed or bad mesh, send to fanout peers
+    # disable for floodPublish, since we already sent to every good peer
+    #
    var fanoutPeers = g.fanout.getOrDefault(topic).toSeq()
-    if fanoutPeers.len < g.parameters.dLow:
+    if fanoutPeers.len == 0:
      g.replenishFanout(topic)
      fanoutPeers = g.fanout.getOrDefault(topic).toSeq()

    g.rng.shuffle(fanoutPeers)
+    if fanoutPeers.len + peers.len > g.parameters.d:
+      fanoutPeers.setLen(g.parameters.d - peers.len)

    for fanPeer in fanoutPeers:
      peers.incl(fanPeer)
@@ -642,6 +535,7 @@ method publish*(g: GossipSub,
    debug "No peers for topic, skipping publish",  peersOnTopic = topicPeers.len,
                                                   connectedPeers = topicPeers.filterIt(it.connected).len,
                                                   topic
+    # skipping topic as our metrics finds that heavy
    libp2p_gossipsub_failed_publish.inc()
    return 0

@@ -669,7 +563,7 @@ method publish*(g: GossipSub,

  g.mcache.put(msgId, msg)

-  g.broadcast(peers, RPCMsg(messages: @[msg]), isHighPriority = true)
+  g.broadcast(peers, RPCMsg(messages: @[msg]))

  if g.knownTopics.contains(topic):
    libp2p_pubsub_messages_published.inc(peers.len.int64, labelValues = [topic])
@@ -677,16 +571,15 @@ method publish*(g: GossipSub,
    libp2p_pubsub_messages_published.inc(peers.len.int64, labelValues = ["generic"])

  trace "Published message to peers", peers=peers.len
+
  return peers.len

 proc maintainDirectPeer(g: GossipSub, id: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  if id notin g.peers:
+  let peer = g.peers.getOrDefault(id)
+  if isNil(peer):
    trace "Attempting to dial a direct peer", peer = id
-    if g.switch.isConnected(id):
-      warn "We are connected to a direct peer, but it isn't a GossipSub peer!", id
-      return
    try:
-      await g.switch.connect(id, addrs, forceDial = true)
+      await g.switch.connect(id, addrs)
      # populate the peer after it's connected
      discard g.getOrCreatePeer(id, g.codecs)
    except CancelledError as exc:
@@ -730,7 +623,7 @@ method stop*(g: GossipSub) {.async.} =
  g.heartbeatFut = nil

 method initPubSub*(g: GossipSub)
-  {.raises: [InitializationError].} =
+  {.raises: [Defect, InitializationError].} =
  procCall FloodSub(g).initPubSub()

  if not g.parameters.explicit:
@@ -745,13 +638,3 @@ method initPubSub*(g: GossipSub)

  # init gossip stuff
  g.mcache = MCache.init(g.parameters.historyGossip, g.parameters.historyLength)
-
-method getOrCreatePeer*(
-    g: GossipSub,
-    peerId: PeerId,
-    protos: seq[string]): PubSubPeer =
-
-  let peer = procCall PubSub(g).getOrCreatePeer(peerId, protos)
-  g.parameters.overheadRateLimit.withValue(overheadRateLimit):
-    peer.overheadRateLimitOpt = Opt.some(TokenBucket.new(overheadRateLimit.bytes, overheadRateLimit.interval))
-  return peer
--- a/libp2p/protocols/pubsub/gossipsub/behavior.nim
+++ b/libp2p/protocols/pubsub/gossipsub/behavior.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,12 +7,15 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[tables, sequtils, sets, algorithm, deques]
+import std/[tables, sequtils, sets, algorithm]
 import chronos, chronicles, metrics
 import "."/[types, scoring]
-import ".."/[pubsubpeer, peertable, mcache, floodsub, pubsub]
+import ".."/[pubsubpeer, peertable, timedcache, mcache, floodsub, pubsub]
 import "../rpc"/[messages]
 import "../../.."/[peerid, multiaddress, utility, switch, routing_record, signed_envelope, utils/heartbeat]

@@ -28,9 +31,9 @@ declareGauge(libp2p_gossipsub_no_peers_topics, "number of topics in mesh with no
 declareGauge(libp2p_gossipsub_low_peers_topics, "number of topics in mesh with at least one but below dlow peers")
 declareGauge(libp2p_gossipsub_healthy_peers_topics, "number of topics in mesh with at least dlow peers (but below dhigh)")
 declareCounter(libp2p_gossipsub_above_dhigh_condition, "number of above dhigh pruning branches ran", labels = ["topic"])
-declareGauge(libp2p_gossipsub_received_iwants, "received iwants", labels = ["kind"])
+declareSummary(libp2p_gossipsub_mcache_hit, "ratio of successful IWANT message cache lookups")

-proc grafted*(g: GossipSub, p: PubSubPeer, topic: string) {.raises: [].} =
+proc grafted*(g: GossipSub, p: PubSubPeer, topic: string) {.raises: [Defect].} =
  g.withPeerStats(p.peerId) do (stats: var PeerStats):
    var info = stats.topicInfos.getOrDefault(topic)
    info.graftTime = Moment.now()
@@ -46,10 +49,12 @@ proc pruned*(g: GossipSub,
             p: PubSubPeer,
             topic: string,
             setBackoff: bool = true,
-             backoff = none(Duration)) {.raises: [].} =
+             backoff = none(Duration)) {.raises: [Defect].} =
  if setBackoff:
    let
-      backoffDuration = backoff.get(g.parameters.pruneBackoff)
+      backoffDuration =
+        if isSome(backoff): backoff.get()
+        else: g.parameters.pruneBackoff
      backoffMoment = Moment.fromNow(backoffDuration)

    g.backingOff
@@ -70,7 +75,7 @@ proc pruned*(g: GossipSub,

      trace "pruned", peer=p, topic

-proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [].} =
+proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [Defect].} =
  let now = Moment.now()
  var expired = toSeq(t.getOrDefault(topic).pairs())
  expired.keepIf do (pair: tuple[peer: PeerId, expire: Moment]) -> bool:
@@ -79,7 +84,7 @@ proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [].} =
    t.withValue(topic, v):
      v[].del(peer)

-proc peerExchangeList*(g: GossipSub, topic: string): seq[PeerInfoMsg] {.raises: [].} =
+proc peerExchangeList*(g: GossipSub, topic: string): seq[PeerInfoMsg] {.raises: [Defect].} =
  if not g.parameters.enablePX:
    return @[]
  var peers = g.gossipsub.getOrDefault(topic, initHashSet[PubSubPeer]()).toSeq()
@@ -106,11 +111,10 @@ proc handleGraft*(g: GossipSub,
    let topic = graft.topicId
    trace "peer grafted topic", peer, topic

-    # It is an error to GRAFT on a direct peer
+    # It is an error to GRAFT on a explicit peer
    if peer.peerId in g.parameters.directPeers:
      # receiving a graft from a direct peer should yield a more prominent warning (protocol violation)
-      # we are trusting direct peer not to abuse this
-      warn "a direct peer attempted to graft us, peering agreements should be reciprocal",
+      warn "an explicit peer attempted to graft us, peering agreements should be reciprocal",
        peer, topic
      # and such an attempt should be logged and rejected with a PRUNE
      prunes.add(ControlPrune(
@@ -126,10 +130,6 @@ proc handleGraft*(g: GossipSub,

      continue

-    if g.mesh.hasPeer(topic, peer):
-      trace "peer already in mesh", peer, topic
-      continue
-
    # Check backingOff
    # Ignore BackoffSlackTime here, since this only for outbound activity
    # and subtract a second time to avoid race conditions
@@ -160,8 +160,7 @@ proc handleGraft*(g: GossipSub,
    # If they send us a graft before they send us a subscribe, what should
    # we do? For now, we add them to mesh but don't add them to gossipsub.
    if topic in g.topics:
-      if g.mesh.peers(topic) < g.parameters.dHigh or
-          (peer.outbound and g.mesh.outboundPeers(topic) < g.parameters.dOut):
+      if g.mesh.peers(topic) < g.parameters.dHigh or peer.outbound:
        # In the spec, there's no mention of DHi here, but implicitly, a
        # peer will be removed from the mesh on next rebalance, so we don't want
        # this peer to push someone else out
@@ -177,10 +176,6 @@ proc handleGraft*(g: GossipSub,
          topicID: topic,
          peers: g.peerExchangeList(topic),
          backoff: g.parameters.pruneBackoff.seconds.uint64))
-
-        let backoff = Moment.fromNow(g.parameters.pruneBackoff)
-        g.backingOff
-          .mgetOrPut(topic, initTable[PeerId, Moment]())[peer.peerId] = backoff
    else:
      trace "peer grafting topic we're not interested in", peer, topic
      # gossip 1.1, we do not send a control message prune anymore
@@ -190,22 +185,27 @@ proc handleGraft*(g: GossipSub,
 proc getPeers(prune: ControlPrune, peer: PubSubPeer): seq[(PeerId, Option[PeerRecord])] =
  var routingRecords: seq[(PeerId, Option[PeerRecord])]
  for record in prune.peers:
-    var peerRecord = none(PeerRecord)
-    if record.signedPeerRecord.len > 0:
-      SignedPeerRecord.decode(record.signedPeerRecord).toOpt().withValue(spr):
-        if record.peerId != spr.data.peerId:
-          trace "peer sent envelope with wrong public key", peer
-        else:
-          peerRecord = some(spr.data)
+    let peerRecord =
+      if record.signedPeerRecord.len == 0:
+        none(PeerRecord)
      else:
-        trace "peer sent invalid SPR", peer
+        let signedRecord = SignedPeerRecord.decode(record.signedPeerRecord)
+        if signedRecord.isErr:
+          trace "peer sent invalid SPR", peer, error=signedRecord.error
+          none(PeerRecord)
+        else:
+          if record.peerId != signedRecord.get().data.peerId:
+            trace "peer sent envelope with wrong public key", peer
+            none(PeerRecord)
+          else:
+            some(signedRecord.get().data)

    routingRecords.add((record.peerId, peerRecord))

  routingRecords


-proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.raises: [].} =
+proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.raises: [Defect].} =
  for prune in prunes:
    let topic = prune.topicId

@@ -239,68 +239,64 @@ proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.r

 proc handleIHave*(g: GossipSub,
                 peer: PubSubPeer,
-                 ihaves: seq[ControlIHave]): ControlIWant {.raises: [].} =
+                 ihaves: seq[ControlIHave]): ControlIWant {.raises: [Defect].} =
  var res: ControlIWant
  if peer.score < g.parameters.gossipThreshold:
    trace "ihave: ignoring low score peer", peer, score = peer.score
  elif peer.iHaveBudget <= 0:
    trace "ihave: ignoring out of budget peer", peer, score = peer.score
  else:
-    for ihave in ihaves:
+    # TODO review deduplicate algorithm
+    # * https://github.com/nim-lang/Nim/blob/5f46474555ee93306cce55342e81130c1da79a42/lib/pure/collections/sequtils.nim#L184
+    # * it's probably not efficient and might give preference to the first dupe
+    let deIhaves = ihaves.deduplicate()
+    for ihave in deIhaves:
      trace "peer sent ihave",
        peer, topic = ihave.topicId, msgs = ihave.messageIds
-      if ihave.topicId in g.topics:
-        for msgId in ihave.messageIds:
+      if ihave.topicId in g.mesh:
+        # also avoid duplicates here!
+        let deIhavesMsgs = ihave.messageIds.deduplicate()
+        for msgId in deIhavesMsgs:
          if not g.hasSeen(msgId):
-            if peer.iHaveBudget <= 0:
-              break
-            elif msgId notin res.messageIds:
+            if peer.iHaveBudget > 0:
              res.messageIds.add(msgId)
              dec peer.iHaveBudget
              trace "requested message via ihave", messageID=msgId
+            else:
+              break
    # shuffling res.messageIDs before sending it out to increase the likelihood
    # of getting an answer if the peer truncates the list due to internal size restrictions.
    g.rng.shuffle(res.messageIds)
    return res

-proc handleIDontWant*(g: GossipSub,
-                      peer: PubSubPeer,
-                      iDontWants: seq[ControlIWant]) =
-  for dontWant in iDontWants:
-    for messageId in dontWant.messageIds:
-      if peer.heDontWants[^1].len > 1000: break
-      if messageId.len > 100: continue
-      peer.heDontWants[^1].incl(messageId)
-
 proc handleIWant*(g: GossipSub,
                 peer: PubSubPeer,
-                 iwants: seq[ControlIWant]): seq[Message] {.raises: [].} =
-  var
-    messages: seq[Message]
-    invalidRequests = 0
+                 iwants: seq[ControlIWant]): seq[Message] {.raises: [Defect].} =
+  var messages: seq[Message]
  if peer.score < g.parameters.gossipThreshold:
    trace "iwant: ignoring low score peer", peer, score = peer.score
+  elif peer.iWantBudget <= 0:
+    trace "iwant: ignoring out of budget peer", peer, score = peer.score
  else:
-    for iwant in iwants:
-      for mid in iwant.messageIds:
+    let deIwants = iwants.deduplicate()
+    for iwant in deIwants:
+      let deIwantsMsgs = iwant.messageIds.deduplicate()
+      for mid in deIwantsMsgs:
        trace "peer sent iwant", peer, messageID = mid
-        # canAskIWant will only return true once for a specific message
-        if not peer.canAskIWant(mid):
-          libp2p_gossipsub_received_iwants.inc(1, labelValues=["notsent"])
-
-          invalidRequests.inc()
-          if invalidRequests > 20:
-            libp2p_gossipsub_received_iwants.inc(1, labelValues=["skipped"])
-            return messages
-          continue
-        let msg = g.mcache.get(mid).valueOr:
-          libp2p_gossipsub_received_iwants.inc(1, labelValues=["unknown"])
-          continue
-        libp2p_gossipsub_received_iwants.inc(1, labelValues=["correct"])
-        messages.add(msg)
+        let msg = g.mcache.get(mid)
+        if msg.isSome:
+          libp2p_gossipsub_mcache_hit.observe(1)
+          # avoid spam
+          if peer.iWantBudget > 0:
+            messages.add(msg.get())
+            dec peer.iWantBudget
+          else:
+            break
+        else:
+          libp2p_gossipsub_mcache_hit.observe(0)
  return messages

-proc commitMetrics(metrics: var MeshMetrics) {.raises: [].} =
+proc commitMetrics(metrics: var MeshMetrics) {.raises: [Defect].} =
  libp2p_gossipsub_low_peers_topics.set(metrics.lowPeersTopics)
  libp2p_gossipsub_no_peers_topics.set(metrics.noPeersTopics)
  libp2p_gossipsub_under_dout_topics.set(metrics.underDoutTopics)
@@ -309,7 +305,7 @@ proc commitMetrics(metrics: var MeshMetrics) {.raises: [].} =
  libp2p_gossipsub_peers_per_topic_fanout.set(metrics.otherPeersPerTopicFanout, labelValues = ["other"])
  libp2p_gossipsub_peers_per_topic_mesh.set(metrics.otherPeersPerTopicMesh, labelValues = ["other"])

-proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil) {.raises: [].} =
+proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil) {.raises: [Defect].} =
  logScope:
    topic
    mesh = g.mesh.peers(topic)
@@ -322,11 +318,10 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
  var
    prunes, grafts: seq[PubSubPeer]
    npeers = g.mesh.peers(topic)
-    nOutPeers = g.mesh.outboundPeers(topic)
    defaultMesh: HashSet[PubSubPeer]
    backingOff = g.backingOff.getOrDefault(topic)

-  if npeers < g.parameters.dLow:
+  if npeers  < g.parameters.dLow:
    trace "replenishing mesh", peers = npeers
    # replenish the mesh if we're below Dlo

@@ -341,7 +336,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
            # avoid negative score peers
            it.score >= 0.0 and
            it notin currentMesh[] and
-            # don't pick direct peers
+            # don't pick explicit peers
            it.peerId notin g.parameters.directPeers and
            # and avoid peers we are backing off
            it.peerId notin backingOff:
@@ -365,7 +360,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
          g.fanout.removePeer(topic, peer)
          grafts &= peer

-  elif nOutPeers < g.parameters.dOut:
+  else:
    trace "replenishing mesh outbound quota", peers = g.mesh.peers(topic)

    var
@@ -381,7 +376,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
            it notin currentMesh[] and
            # avoid negative score peers
            it.score >= 0.0 and
-            # don't pick direct peers
+            # don't pick explicit peers
            it.peerId notin g.parameters.directPeers and
            # and avoid peers we are backing off
            it.peerId notin backingOff:
@@ -393,8 +388,8 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
    # sort peers by score, high score first, we are grafting
    candidates.sort(byScore, SortOrder.Descending)

-    # Graft outgoing peers so we reach a count of dOut
-    candidates.setLen(min(candidates.len, g.parameters.dOut - nOutPeers))
+    # Graft peers so we reach a count of D
+    candidates.setLen(min(candidates.len, g.parameters.dOut))

    trace "grafting outbound peers", topic, peers = candidates.len

@@ -483,7 +478,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
              # avoid negative score peers
              it.score >= median.score and
              it notin currentMesh[] and
-              # don't pick direct peers
+              # don't pick explicit peers
              it.peerId notin g.parameters.directPeers and
              # and avoid peers we are backing off
              it.peerId notin backingOff:
@@ -530,16 +525,16 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
  # Send changes to peers after table updates to avoid stale state
  if grafts.len > 0:
    let graft = RPCMsg(control: some(ControlMessage(graft: @[ControlGraft(topicID: topic)])))
-    g.broadcast(grafts, graft, isHighPriority = true)
+    g.broadcast(grafts, graft)
  if prunes.len > 0:
    let prune = RPCMsg(control: some(ControlMessage(
      prune: @[ControlPrune(
        topicID: topic,
        peers: g.peerExchangeList(topic),
        backoff: g.parameters.pruneBackoff.seconds.uint64)])))
-    g.broadcast(prunes, prune, isHighPriority = true)
+    g.broadcast(prunes, prune)

-proc dropFanoutPeers*(g: GossipSub) {.raises: [].} =
+proc dropFanoutPeers*(g: GossipSub) {.raises: [Defect].} =
  # drop peers that we haven't published to in
  # GossipSubFanoutTTL seconds
  let now = Moment.now()
@@ -552,13 +547,13 @@ proc dropFanoutPeers*(g: GossipSub) {.raises: [].} =
  for topic in drops:
    g.lastFanoutPubSub.del topic

-proc replenishFanout*(g: GossipSub, topic: string) {.raises: [].} =
+proc replenishFanout*(g: GossipSub, topic: string) {.raises: [Defect].} =
  ## get fanout peers for a topic
  logScope: topic
  trace "about to replenish fanout"

+  let currentMesh = g.mesh.getOrDefault(topic)
  if g.fanout.peers(topic) < g.parameters.dLow:
-    let currentMesh = g.mesh.getOrDefault(topic)
    trace "replenishing fanout", peers = g.fanout.peers(topic)
    for peer in g.gossipsub.getOrDefault(topic):
      if peer in currentMesh: continue
@@ -568,7 +563,7 @@ proc replenishFanout*(g: GossipSub, topic: string) {.raises: [].} =

  trace "fanout replenished with peers", peers = g.fanout.peers(topic)

-proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises: [].} =
+proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises: [Defect].} =
  ## gossip iHave messages to peers
  ##

@@ -621,29 +616,20 @@ proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises:
      g.rng.shuffle(allPeers)
      allPeers.setLen(target)

-    let msgIdsAsSet = ihave.messageIds.toHashSet()
-
    for peer in allPeers:
      control.mgetOrPut(peer, ControlMessage()).ihave.add(ihave)
-      peer.sentIHaves[^1].incl(msgIdsAsSet)

  libp2p_gossipsub_cache_window_size.set(cacheWindowSize.int64)

  return control

-proc onHeartbeat(g: GossipSub) {.raises: [].} =
+proc onHeartbeat(g: GossipSub) {.raises: [Defect].} =
    # reset IWANT budget
    # reset IHAVE cap
    block:
      for peer in g.peers.values:
-        peer.sentIHaves.addFirst(default(HashSet[MessageId]))
-        if peer.sentIHaves.len > g.parameters.historyLength:
-          discard peer.sentIHaves.popLast()
-        peer.heDontWants.addFirst(default(HashSet[MessageId]))
-        if peer.heDontWants.len > g.parameters.historyLength:
-          discard peer.heDontWants.popLast()
+        peer.iWantBudget = IWantPeerBudget
        peer.iHaveBudget = IHavePeerBudget
-        peer.pingBudget = PingsPeerBudget

    var meshMetrics = MeshMetrics()

@@ -669,7 +655,7 @@ proc onHeartbeat(g: GossipSub) {.raises: [].} =
            topicID: t,
            peers: g.peerExchangeList(t),
            backoff: g.parameters.pruneBackoff.seconds.uint64)])))
-        g.broadcast(prunes, prune, isHighPriority = true)
+        g.broadcast(prunes, prune)

      # pass by ptr in order to both signal we want to update metrics
      # and as well update the struct for each topic during this iteration
@@ -691,11 +677,11 @@ proc onHeartbeat(g: GossipSub) {.raises: [].} =
          libp2p_pubsub_broadcast_ihave.inc(labelValues = [ihave.topicId])
        else:
          libp2p_pubsub_broadcast_ihave.inc(labelValues = ["generic"])
-      g.send(peer, RPCMsg(control: some(control)), isHighPriority = true)
+      g.send(peer, RPCMsg(control: some(control)))

    g.mcache.shift() # shift the cache

-# {.pop.} # raises []
+# {.pop.} # raises [Defect]

 proc heartbeat*(g: GossipSub) {.async.} =
  heartbeat "GossipSub", g.parameters.heartbeatInterval:
--- a/libp2p/protocols/pubsub/gossipsub/scoring.nim
+++ b/libp2p/protocols/pubsub/gossipsub/scoring.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,16 +7,16 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[tables, sets]
+import std/[tables, sets, options]
 import chronos, chronicles, metrics
-import chronos/ratelimit
 import "."/[types]
 import ".."/[pubsubpeer]
-import ../rpc/messages
-import "../../.."/[peerid, multiaddress, switch, utils/heartbeat]
-import ../pubsub
+import "../../.."/[peerid, multiaddress, utility, switch, utils/heartbeat]

 logScope:
  topics = "libp2p gossipsub"
@@ -30,7 +30,6 @@ declareGauge(libp2p_gossipsub_peers_score_invalidMessageDeliveries, "Detailed go
 declareGauge(libp2p_gossipsub_peers_score_appScore, "Detailed gossipsub scoring metric", labels = ["agent"])
 declareGauge(libp2p_gossipsub_peers_score_behaviourPenalty, "Detailed gossipsub scoring metric", labels = ["agent"])
 declareGauge(libp2p_gossipsub_peers_score_colocationFactor, "Detailed gossipsub scoring metric", labels = ["agent"])
-declarePublicCounter(libp2p_gossipsub_peers_rate_limit_hits, "The number of times peers were above their rate limit", labels = ["agent"])

 proc init*(_: type[TopicParams]): TopicParams =
  TopicParams(
@@ -56,7 +55,7 @@ proc init*(_: type[TopicParams]): TopicParams =
 proc withPeerStats*(
    g: GossipSub,
    peerId: PeerId,
-    action: proc (stats: var PeerStats) {.gcsafe, raises: [].}) =
+    action: proc (stats: var PeerStats) {.gcsafe, raises: [Defect].}) =
  ## Add or update peer statistics for a particular peer id - the statistics
  ## are retained across multiple connections until they expire
  g.peerStats.withValue(peerId, stats) do:
@@ -75,32 +74,39 @@ func `/`(a, b: Duration): float64 =
 func byScore*(x,y: PubSubPeer): int = system.cmp(x.score, y.score)

 proc colocationFactor(g: GossipSub, peer: PubSubPeer): float64 =
-  let address = peer.address.valueOr: return 0.0
-
-  g.peersInIP.mgetOrPut(address, initHashSet[PeerId]()).incl(peer.peerId)
-  let
-    ipPeers = g.peersInIP.getOrDefault(address).len().float64
-  if ipPeers > g.parameters.ipColocationFactorThreshold:
-    trace "colocationFactor over threshold", peer, address, ipPeers
-    let over = ipPeers - g.parameters.ipColocationFactorThreshold
-    over * over
-  else:
+  if peer.address.isNone():
    0.0
+  else:
+    let
+      address = peer.address.get()
+    g.peersInIP.mgetOrPut(address, initHashSet[PeerId]()).incl(peer.peerId)
+    let
+      ipPeers = g.peersInIP.getOrDefault(address).len().float64
+    if ipPeers > g.parameters.ipColocationFactorThreshold:
+      trace "colocationFactor over threshold", peer, address, ipPeers
+      let over = ipPeers - g.parameters.ipColocationFactorThreshold
+      over * over
+    else:
+      0.0

 {.pop.}

-proc disconnectPeer*(g: GossipSub, peer: PubSubPeer) {.async.} =
+proc disconnectPeer(g: GossipSub, peer: PubSubPeer) {.async.} =
+  let agent =
+    when defined(libp2p_agents_metrics):
+      if peer.shortAgent.len > 0:
+        peer.shortAgent
+      else:
+        "unknown"
+    else:
+      "unknown"
+  libp2p_gossipsub_bad_score_disconnection.inc(labelValues = [agent])
+
  try:
    await g.switch.disconnect(peer.peerId)
  except CatchableError as exc: # Never cancelled
    trace "Failed to close connection", peer, error = exc.name, msg = exc.msg

-proc disconnectIfBadScorePeer*(g: GossipSub, peer: PubSubPeer, score: float64) =
-  if g.parameters.disconnectBadPeers and score < g.parameters.graylistThreshold and
-     peer.peerId notin g.parameters.directPeers:
-    debug "disconnecting bad score peer", peer, score = peer.score
-    asyncSpawn(g.disconnectPeer(peer))
-    libp2p_gossipsub_bad_score_disconnection.inc(labelValues = [peer.getAgent()])

 proc updateScores*(g: GossipSub) = # avoid async
  ## https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#the-score-function
@@ -170,7 +176,14 @@ proc updateScores*(g: GossipSub) = # avoid async
        score += topicScore * topicParams.topicWeight

      # Score metrics
-      let agent = peer.getAgent()
+      let agent =
+        when defined(libp2p_agents_metrics):
+          if peer.shortAgent.len > 0:
+            peer.shortAgent
+          else:
+            "unknown"
+        else:
+          "unknown"
      libp2p_gossipsub_peers_score_firstMessageDeliveries.inc(info.firstMessageDeliveries, labelValues = [agent])
      libp2p_gossipsub_peers_score_meshMessageDeliveries.inc(info.meshMessageDeliveries, labelValues = [agent])
      libp2p_gossipsub_peers_score_meshFailurePenalty.inc(info.meshFailurePenalty, labelValues = [agent])
@@ -207,7 +220,14 @@ proc updateScores*(g: GossipSub) = # avoid async
    score += colocationFactor * g.parameters.ipColocationFactorWeight

    # Score metrics
-    let agent = peer.getAgent()
+    let agent =
+      when defined(libp2p_agents_metrics):
+        if peer.shortAgent.len > 0:
+          peer.shortAgent
+        else:
+          "unknown"
+      else:
+        "unknown"
    libp2p_gossipsub_peers_score_appScore.inc(peer.appScore, labelValues = [agent])
    libp2p_gossipsub_peers_score_behaviourPenalty.inc(peer.behaviourPenalty, labelValues = [agent])
    libp2p_gossipsub_peers_score_colocationFactor.inc(colocationFactor, labelValues = [agent])
@@ -227,7 +247,11 @@ proc updateScores*(g: GossipSub) = # avoid async

    trace "updated peer's score", peer, score = peer.score, n_topics, is_grafted

-    g.disconnectIfBadScorePeer(peer, stats.score)
+    if g.parameters.disconnectBadPeers and stats.score < g.parameters.graylistThreshold and
+        peer.peerId notin g.parameters.directPeers:
+      debug "disconnecting bad score peer", peer, score = peer.score
+      asyncSpawn(try: g.disconnectPeer(peer) except Exception as exc: raiseAssert exc.msg)
+
    libp2p_gossipsub_peers_scores.inc(peer.score, labelValues = [agent])

  for peer in evicting:
@@ -240,18 +264,8 @@ proc scoringHeartbeat*(g: GossipSub) {.async.} =
    trace "running scoring heartbeat", instance = cast[int](g)
    g.updateScores()

-proc punishInvalidMessage*(g: GossipSub, peer: PubSubPeer, msg: Message) {.async.}  =
-  let uselessAppBytesNum = msg.data.len
-  peer.overheadRateLimitOpt.withValue(overheadRateLimit):
-    if not overheadRateLimit.tryConsume(uselessAppBytesNum):
-      debug "Peer sent invalid message and it's above rate limit", peer, uselessAppBytesNum
-      libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
-      if g.parameters.disconnectPeerAboveRateLimit:
-        await g.disconnectPeer(peer)
-        raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
-
-
-  for tt in msg.topicIds:
+proc punishInvalidMessage*(g: GossipSub, peer: PubSubPeer, topics: seq[string]) =
+  for tt in topics:
    let t = tt
    if t notin g.topics:
      continue
@@ -281,11 +295,11 @@ proc rewardDelivered*(

    g.withPeerStats(peer.peerId) do (stats: var PeerStats):
      stats.topicInfos.withValue(tt, tstats):
-        if first:
-          tstats[].firstMessageDeliveries.addCapped(
-            1, topicParams.firstMessageDeliveriesCap)
-
        if tstats[].inMesh:
+          if first:
+            tstats[].firstMessageDeliveries.addCapped(
+              1, topicParams.firstMessageDeliveriesCap)
+
          tstats[].meshMessageDeliveries.addCapped(
            1, topicParams.meshMessageDeliveriesCap)
      do: # make sure we don't loose this information
--- a/libp2p/protocols/pubsub/gossipsub/types.nim
+++ b/libp2p/protocols/pubsub/gossipsub/types.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,16 +7,17 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos
-import std/[options, tables, sets]
+import std/[tables, sets]
 import ".."/[floodsub, peertable, mcache, pubsubpeer]
 import "../rpc"/[messages]
 import "../../.."/[peerid, multiaddress, utility]

-export options, tables, sets
-
 const
  GossipSubCodec* = "/meshsub/1.1.0"
  GossipSubCodec_10* = "/meshsub/1.0.0"
@@ -45,7 +46,7 @@ const

 const
  BackoffSlackTime* = 2 # seconds
-  PingsPeerBudget* = 100 # maximum of 6.4kb/heartbeat (6.4kb/s with default 1 second/hb)
+  IWantPeerBudget* = 25 # 25 messages per second ( reset every heartbeat )
  IHavePeerBudget* = 10
  # the max amount of IHave to expose, not by spec, but go as example
  # rust sigp: https://github.com/sigp/rust-libp2p/blob/f53d02bc873fef2bf52cd31e3d5ce366a41d8a8c/protocols/gossipsub/src/config.rs#L572
@@ -142,11 +143,6 @@ type
    disconnectBadPeers*: bool
    enablePX*: bool

-    bandwidthEstimatebps*: int # This is currently used only for limting flood publishing. 0 disables flood-limiting completely
-
-    overheadRateLimit*: Opt[tuple[bytes: int, interval: Duration]]
-    disconnectPeerAboveRateLimit*: bool
-
  BackoffTable* = Table[string, Table[PeerId, Moment]]
  ValidationSeenTable* = Table[MessageId, HashSet[PubSubPeer]]

@@ -155,13 +151,13 @@ type
    proc(peer: PeerId,
    tag: string, # For gossipsub, the topic
    peers: seq[RoutingRecordsPair])
-    {.gcsafe, raises: [].}
+    {.gcsafe, raises: [Defect].}

  GossipSub* = ref object of FloodSub
    mesh*: PeerTable                           # peers that we send messages to when we are subscribed to the topic
    fanout*: PeerTable                         # peers that we send messages to when we're not subscribed to the topic
    gossipsub*: PeerTable                      # peers that are subscribed to a topic
-    subscribedDirectPeers*: PeerTable          # directpeers that we keep alive
+    explicit*: PeerTable                       # directpeers that we keep alive explicitly
    backingOff*: BackoffTable                  # peers to backoff from when replenishing the mesh
    lastFanoutPubSub*: Table[string, Moment]   # last publish time for fanout topics
    gossip*: Table[string, seq[ControlIHave]]  # pending gossip
--- a/libp2p/protocols/pubsub/mcache.nim
+++ b/libp2p/protocols/pubsub/mcache.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[sets, tables, options]
 import rpc/[messages]
--- a/libp2p/protocols/pubsub/peertable.nim
+++ b/libp2p/protocols/pubsub/peertable.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,13 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[tables, sets, sequtils]
+import std/[tables, sets]
 import ./pubsubpeer, ../../peerid

-export tables, sets
-
 type
  PeerTable* = Table[string, HashSet[PubSubPeer]] # topic string to peer map

@@ -50,10 +51,3 @@ func peers*(table: PeerTable, topic: string): int =
    except KeyError: raiseAssert "checked with in"
  else:
    0
-
-func outboundPeers*(table: PeerTable, topic: string): int =
-  if topic in table:
-    try: table[topic].countIt(it.outbound)
-    except KeyError: raiseAssert "checked with in"
-  else:
-    0
--- a/libp2p/protocols/pubsub/pubsub.nim
+++ b/libp2p/protocols/pubsub/pubsub.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -13,11 +13,13 @@
 ## `publish<#publish.e%2CPubSub%2Cstring%2Cseq%5Bbyte%5D>`_ something on it,
 ## and eventually `unsubscribe<#unsubscribe%2CPubSub%2Cstring%2CTopicHandler>`_ from it.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[tables, sequtils, sets, strutils]
 import chronos, chronicles, metrics
-import chronos/ratelimit
 import ./errors as pubsub_errors,
       ./pubsubpeer,
       ./rpc/[message, messages, protobuf],
@@ -34,7 +36,6 @@ import metrics
 import stew/results
 export results

-export tables, sets
 export PubSubPeer
 export PubSubObserver
 export protocol
@@ -84,18 +85,18 @@ type
  InitializationError* = object of LPError

  TopicHandler* {.public.} = proc(topic: string,
-                       data: seq[byte]): Future[void] {.gcsafe, raises: [].}
+                       data: seq[byte]): Future[void] {.gcsafe, raises: [Defect].}

  ValidatorHandler* {.public.} = proc(topic: string,
-                           message: Message): Future[ValidationResult] {.gcsafe, raises: [].}
+                           message: Message): Future[ValidationResult] {.gcsafe, raises: [Defect].}

  TopicPair* = tuple[topic: string, handler: TopicHandler]

  MsgIdProvider* {.public.} =
-    proc(m: Message): Result[MessageId, ValidationResult] {.noSideEffect, raises: [], gcsafe.}
+    proc(m: Message): Result[MessageId, ValidationResult] {.noSideEffect, raises: [Defect], gcsafe.}

  SubscriptionValidator* {.public.} =
-    proc(topic: string): bool {.raises: [], gcsafe.}
+    proc(topic: string): bool {.raises: [Defect], gcsafe.}
    ## Every time a peer send us a subscription (even to an unknown topic),
    ## we have to store it, which may be an attack vector.
    ## This callback can be used to reject topic we're not interested in
@@ -117,7 +118,7 @@ type
    anonymize*: bool                   ## if we omit fromPeer and seqno from RPC messages we send
    subscriptionValidator*: SubscriptionValidator # callback used to validate subscriptions
    topicsHigh*: int                  ## the maximum number of topics a peer is allowed to subscribe to
-    maxMessageSize*: int          ##\
+    maxMessageSize*: int          ##\ 
      ## the maximum raw message size we'll globally allow
      ## for finer tuning, check message size on topic validator
      ##
@@ -138,35 +139,18 @@ method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base, gcsafe.} =

  libp2p_pubsub_peers.set(p.peers.len.int64)

-proc send*(p: PubSub, peer: PubSubPeer, msg: RPCMsg, isHighPriority: bool, id: MessageId = @[]) {.raises: [].} =
-  ## This procedure attempts to send a `msg` (of type `RPCMsg`) to the specified remote peer in the PubSub network.
+proc send*(p: PubSub, peer: PubSubPeer, msg: RPCMsg) {.raises: [Defect].} =
+  ## Attempt to send `msg` to remote peer
  ##
-  ## Parameters:
-  ## - `p`: The `PubSub` instance.
-  ## - `peer`: An instance of `PubSubPeer` representing the peer to whom the message should be sent.
-  ## - `msg`: The `RPCMsg` instance that contains the message to be sent.
-  ## - `isHighPriority`: A boolean indicating whether the message should be treated as high priority.
-  ## High priority messages are sent immediately, while low priority messages are queued and sent only after all high
-  ## priority messages have been sent.

  trace "sending pubsub message to peer", peer, msg = shortLog(msg)
-  asyncSpawn peer.send(msg, p.anonymize, isHighPriority, id)
+  peer.send(msg, p.anonymize)

 proc broadcast*(
  p: PubSub,
  sendPeers: auto, # Iteratble[PubSubPeer]
-  msg: RPCMsg,
-  isHighPriority: bool,
-  validMsgId: MessageId = @[]) {.raises: [].} =
-  ## This procedure attempts to send a `msg` (of type `RPCMsg`) to a specified group of peers in the PubSub network.
-  ##
-  ## Parameters:
-  ## - `p`: The `PubSub` instance.
-  ## - `sendPeers`: An iterable of `PubSubPeer` instances representing the peers to whom the message should be sent.
-  ## - `msg`: The `RPCMsg` instance that contains the message to be broadcast.
-  ## - `isHighPriority`: A boolean indicating whether the message should be treated as high priority.
-  ## High priority messages are sent immediately, while low priority messages are queued and sent only after all high
-  ## priority messages have been sent.
+  msg: RPCMsg) {.raises: [Defect].} =
+  ## Attempt to send `msg` to the given peers

  let npeers = sendPeers.len.int64
  for sub in msg.subscriptions:
@@ -188,9 +172,10 @@ proc broadcast*(
      else:
        libp2p_pubsub_broadcast_messages.inc(npeers, labelValues = ["generic"])

-  msg.control.withValue(control):
-    libp2p_pubsub_broadcast_iwant.inc(npeers * control.iwant.len.int64)
+  if msg.control.isSome():
+    libp2p_pubsub_broadcast_iwant.inc(npeers * msg.control.get().iwant.len.int64)

+    let control = msg.control.get()
    for ihave in control.ihave:
      if p.knownTopics.contains(ihave.topicId):
        libp2p_pubsub_broadcast_ihave.inc(npeers, labelValues = [ihave.topicId])
@@ -212,19 +197,19 @@ proc broadcast*(

  if anyIt(sendPeers, it.hasObservers):
    for peer in sendPeers:
-      p.send(peer, msg, isHighPriority, validMsgId)
+      p.send(peer, msg)
  else:
    # Fast path that only encodes message once
    let encoded = encodeRpcMsg(msg, p.anonymize)
    for peer in sendPeers:
-      asyncSpawn peer.sendEncoded(encoded, isHighPriority, validMsgId)
+      peer.sendEncoded(encoded)

 proc sendSubs*(p: PubSub,
               peer: PubSubPeer,
               topics: openArray[string],
               subscribe: bool) =
  ## send subscriptions to remote peer
-  p.send(peer, RPCMsg.withSubs(topics, subscribe), isHighPriority = true)
+  p.send(peer, RPCMsg.withSubs(topics, subscribe))

  for topic in topics:
    if subscribe:
@@ -261,8 +246,9 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =
      else:
        libp2p_pubsub_received_messages.inc(labelValues = ["generic"])

-  rpcMsg.control.withValue(control):
-    libp2p_pubsub_received_iwant.inc(control.iwant.len.int64)
+  if rpcMsg.control.isSome():
+    libp2p_pubsub_received_iwant.inc(rpcMsg.control.get().iwant.len.int64)
+    template control: untyped = rpcMsg.control.unsafeGet()
    for ihave in control.ihave:
      if p.knownTopics.contains(ihave.topicId):
        libp2p_pubsub_received_ihave.inc(labelValues = [ihave.topicId])
@@ -281,7 +267,7 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =

 method rpcHandler*(p: PubSub,
                   peer: PubSubPeer,
-                   data: seq[byte]): Future[void] {.base, async.} =
+                   rpcMsg: RPCMsg): Future[void] {.base, async.} =
  ## Handler that must be overridden by concrete implementation
  raiseAssert "Unimplemented"

@@ -296,11 +282,10 @@ method onPubSubPeerEvent*(p: PubSub, peer: PubSubPeer, event: PubSubPeerEvent) {
  of PubSubPeerEventKind.Disconnected:
    discard

-method getOrCreatePeer*(
+proc getOrCreatePeer*(
    p: PubSub,
    peerId: PeerId,
-    protos: seq[string]): PubSubPeer {.base, gcsafe.} =
-
+    protos: seq[string]): PubSubPeer =
  p.peers.withValue(peerId, peer):
    return peer[]

@@ -322,6 +307,8 @@ method getOrCreatePeer*(
  # metrics
  libp2p_pubsub_peers.set(p.peers.len.int64)

+  pubSubPeer.connect()
+
  return pubSubPeer

 proc handleData*(p: PubSub, topic: string, data: seq[byte]): Future[void] =
@@ -373,9 +360,9 @@ method handleConn*(p: PubSub,
  ##    that we're interested in
  ##

-  proc handler(peer: PubSubPeer, data: seq[byte]): Future[void] =
+  proc handler(peer: PubSubPeer, msg: RPCMsg): Future[void] =
    # call pubsub rpc handler
-    p.rpcHandler(peer, data)
+    p.rpcHandler(peer, msg)

  let peer = p.getOrCreatePeer(conn.peerId, @[proto])

@@ -395,8 +382,7 @@ method subscribePeer*(p: PubSub, peer: PeerId) {.base, gcsafe.} =
  ## messages
  ##

-  let pubSubPeer = p.getOrCreatePeer(peer, p.codecs)
-  pubSubPeer.connect()
+  discard p.getOrCreatePeer(peer, p.codecs)

 proc updateTopicMetrics(p: PubSub, topic: string) =
  # metrics
@@ -420,11 +406,7 @@ method onTopicSubscription*(p: PubSub, topic: string, subscribed: bool) {.base,

  # Notify others that we are no longer interested in the topic
  for _, peer in p.peers:
-    # If we don't have a sendConn yet, we will
-    # send the full sub list when we get the sendConn,
-    # so no need to send it here
-    if peer.hasSendConn:
-      p.sendSubs(peer, [topic], subscribed)
+    p.sendSubs(peer, [topic], subscribed)

  if subscribed:
    libp2p_pubsub_subscriptions.inc()
@@ -505,7 +487,7 @@ method publish*(p: PubSub,
  return 0

 method initPubSub*(p: PubSub)
-  {.base, raises: [InitializationError].} =
+  {.base, raises: [Defect, InitializationError].} =
  ## perform pubsub initialization
  p.observers = new(seq[PubSubObserver])
  if p.msgIdProvider == nil:
@@ -573,7 +555,7 @@ proc init*[PubParams: object | bool](
  maxMessageSize: int = 1024 * 1024,
  rng: ref HmacDrbgContext = newRng(),
  parameters: PubParams = false): P
-  {.raises: [InitializationError], public.} =
+  {.raises: [Defect, InitializationError], public.} =
  let pubsub =
    when PubParams is bool:
      P(switch: switch,
--- a/libp2p/protocols/pubsub/pubsubpeer.nim
+++ b/libp2p/protocols/pubsub/pubsubpeer.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,12 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/[sequtils, strutils, tables, hashes, options, sets, deques]
+import std/[sequtils, strutils, tables, hashes, options]
 import stew/results
 import chronos, chronicles, nimcrypto/sha2, metrics
-import chronos/ratelimit
 import rpc/[messages, message, protobuf],
       ../../peerid,
       ../../peerinfo,
@@ -21,27 +23,21 @@ import rpc/[messages, message, protobuf],
       ../../protobuf/minprotobuf,
       ../../utility

-#import gossipsub/libp2p_gossipsub_staggerDontWantSave
-
-export peerid, connection, deques
+export peerid, connection

 logScope:
  topics = "libp2p pubsubpeer"

 when defined(libp2p_expensive_metrics):
  declareCounter(libp2p_pubsub_sent_messages, "number of messages sent", labels = ["id", "topic"])
+  declareCounter(libp2p_pubsub_received_messages, "number of messages received", labels = ["id", "topic"])
  declareCounter(libp2p_pubsub_skipped_received_messages, "number of received skipped messages", labels = ["id"])
  declareCounter(libp2p_pubsub_skipped_sent_messages, "number of sent skipped messages", labels = ["id"])

-  declareGauge(libp2p_gossipsub_priority_queue_size, "the number of messages in the priority queue", labels = ["id"])
-  declareGauge(libp2p_gossipsub_non_priority_queue_size, "the number of messages in the non-priority queue", labels = ["id"])
-
 type
-  PeerRateLimitError* = object of CatchableError
-
  PubSubObserver* = ref object
-    onRecv*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [].}
-    onSend*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [].}
+    onRecv*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [Defect].}
+    onSend*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [Defect].}

  PubSubPeerEventKind* {.pure.} = enum
    Connected
@@ -50,70 +46,32 @@ type
  PubSubPeerEvent* = object
    kind*: PubSubPeerEventKind

-  GetConn* = proc(): Future[Connection] {.gcsafe, raises: [].}
-  DropConn* = proc(peer: PubSubPeer) {.gcsafe, raises: [].} # have to pass peer as it's unknown during init
-  OnEvent* = proc(peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe, raises: [].}
-
-  MessageWithId = object
-    message: seq[byte]
-    msgId: MessageId
-
-  RpcMessageQueue* = ref object
-    # Tracks async tasks for sending high-priority peer-published messages.
-    sendPriorityQueue: Deque[Future[void]]
-    # Queue for lower-priority messages, like "IWANT" replies and relay messages.
-    nonPriorityQueue: AsyncQueue[MessageWithId]
-    # Task for processing non-priority message queue.
-    sendNonPriorityTask: Future[void]
+  GetConn* = proc(): Future[Connection] {.gcsafe, raises: [Defect].}
+  DropConn* = proc(peer: PubSubPeer) {.gcsafe, raises: [Defect].} # have to pass peer as it's unknown during init
+  OnEvent* = proc(peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe, raises: [Defect].}

  PubSubPeer* = ref object of RootObj
    getConn*: GetConn                   # callback to establish a new send connection
    onEvent*: OnEvent                   # Connectivity updates for peer
    codec*: string                      # the protocol that this peer joined from
    sendConn*: Connection               # cached send connection
-    connectedFut: Future[void]
    address*: Option[MultiAddress]
    peerId*: PeerId
    handler*: RPCHandler
    observers*: ref seq[PubSubObserver] # ref as in smart_ptr

    score*: float64
-    sentIHaves*: Deque[HashSet[MessageId]]
-    heDontWants*: Deque[HashSet[MessageId]]
+    iWantBudget*: int
    iHaveBudget*: int
-    pingBudget*: int
    maxMessageSize: int
    appScore*: float64 # application specific score
    behaviourPenalty*: float64 # the eventual penalty score
-    overheadRateLimitOpt*: Opt[TokenBucket]

-    rpcmessagequeue: RpcMessageQueue
-
-  RPCHandler* = proc(peer: PubSubPeer, data: seq[byte]): Future[void]
-    {.gcsafe, raises: [].}
-
-when defined(libp2p_agents_metrics):
-  func shortAgent*(p: PubSubPeer): string =
-    if p.sendConn.isNil or p.sendConn.getWrapped().isNil:
-      "unknown"
-    else:
-      #TODO the sendConn is setup before identify,
-      #so we have to read the parents short agent..
-      p.sendConn.getWrapped().shortAgent
-
-proc newMessageWithId(msg: seq[byte], id: MessageId): MessageWithId =
-  result.message = msg
-  result.msgId = id
-
-proc getAgent*(peer: PubSubPeer): string =
-  return
    when defined(libp2p_agents_metrics):
-      if peer.shortAgent.len > 0:
-        peer.shortAgent
-      else:
-        "unknown"
-    else:
-      "unknown"
+      shortAgent*: string
+
+  RPCHandler* = proc(peer: PubSubPeer, msg: RPCMsg): Future[void]
+    {.gcsafe, raises: [Defect].}

 func hash*(p: PubSubPeer): Hash =
  p.peerId.hash
@@ -143,7 +101,7 @@ func outbound*(p: PubSubPeer): bool =
  else:
    false

-proc recvObservers*(p: PubSubPeer, msg: var RPCMsg) =
+proc recvObservers(p: PubSubPeer, msg: var RPCMsg) =
  # trigger hooks
  if not(isNil(p.observers)) and p.observers[].len > 0:
    for obs in p.observers[]:
@@ -170,13 +128,28 @@ proc handle*(p: PubSubPeer, conn: Connection) {.async.} =
          conn, peer = p, closed = conn.closed,
          data = data.shortLog

-        await p.handler(p, data)
+        var rmsg = decodeRpcMsg(data)
        data = newSeq[byte]() # Release memory
-    except PeerRateLimitError as exc:
-      debug "Peer rate limit exceeded, exiting read while", conn, peer = p, error = exc.msg
-    except CatchableError as exc:
-      debug "Exception occurred in PubSubPeer.handle",
-        conn, peer = p, closed = conn.closed, exc = exc.msg
+
+        if rmsg.isErr():
+          notice "failed to decode msg from peer",
+            conn, peer = p, closed = conn.closed,
+            err = rmsg.error()
+          break
+
+        trace "decoded msg from peer",
+          conn, peer = p, closed = conn.closed,
+          msg = rmsg.get().shortLog
+        # trigger hooks
+        p.recvObservers(rmsg.get())
+
+        when defined(libp2p_expensive_metrics):
+          for m in rmsg.get().messages:
+            for t in m.topicIDs:
+              # metrics
+              libp2p_pubsub_received_messages.inc(labelValues = [$p.peerId, t])
+
+        await p.handler(p, rmsg.get())
    finally:
      await conn.close()
  except CancelledError:
@@ -192,9 +165,7 @@ proc handle*(p: PubSubPeer, conn: Connection) {.async.} =

 proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
  try:
-    if p.connectedFut.finished:
-      p.connectedFut = newFuture[void]()
-    let newConn = await p.getConn().wait(5.seconds)
+    let newConn = await p.getConn()
    if newConn.isNil:
      raise (ref LPError)(msg: "Cannot establish send connection")

@@ -203,11 +174,6 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
    # stop working so we make an effort to only keep a single channel alive

    trace "Get new send connection", p, newConn
-
-    # Careful to race conditions here.
-    # Topic subscription relies on either connectedFut
-    # to be completed, or onEvent to be called later
-    p.connectedFut.complete()
    p.sendConn = newConn
    p.address = if p.sendConn.observedAddr.isSome: some(p.sendConn.observedAddr.get) else: none(MultiAddress)

@@ -221,9 +187,6 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
      await p.sendConn.close()
      p.sendConn = nil

-    if not p.connectedFut.finished:
-      p.connectedFut.complete()
-
    try:
      if p.onEvent != nil:
        p.onEvent(p, PubSubPeerEvent(kind: PubSubPeerEventKind.Disconnected))
@@ -245,67 +208,36 @@ proc connectImpl(p: PubSubPeer) {.async.} =
    debug "Could not establish send connection", msg = exc.msg

 proc connect*(p: PubSubPeer) =
-  if p.connected:
-    return
-
  asyncSpawn connectImpl(p)

-proc hasSendConn*(p: PubSubPeer): bool =
-  p.sendConn != nil
+proc sendImpl(conn: Connection, encoded: seq[byte]): Future[void] {.raises: [Defect].} =
+  trace "sending encoded msgs to peer", conn, encoded = shortLog(encoded)
+
+  let fut = conn.writeLp(encoded) # Avoid copying `encoded` into future
+  proc sendWaiter(): Future[void] {.async.} =
+    try:
+      await fut
+      trace "sent pubsub message to remote", conn
+
+    except CatchableError as exc: # never cancelled
+      # Because we detach the send call from the currently executing task using
+      # asyncSpawn, no exceptions may leak out of it
+      trace "Unable to send to remote", conn, msg = exc.msg
+      # Next time sendConn is used, it will be have its close flag set and thus
+      # will be recycled
+
+      await conn.close() # This will clean up the send connection
+
+  return sendWaiter()

 template sendMetrics(msg: RPCMsg): untyped =
  when defined(libp2p_expensive_metrics):
    for x in msg.messages:
-      for t in x.topicIds:
+      for t in x.topicIDs:
        # metrics
        libp2p_pubsub_sent_messages.inc(labelValues = [$p.peerId, t])

-proc clearSendPriorityQueue(p: PubSubPeer) =
-  while p.rpcmessagequeue.sendPriorityQueue.len > 0 and p.rpcmessagequeue.sendPriorityQueue[0].finished:
-    when defined(libp2p_expensive_metrics):
-      libp2p_gossipsub_priority_queue_size.dec(labelValues = [$p.peerId])
-    discard p.rpcmessagequeue.sendPriorityQueue.popFirst()
-
-proc sendMsg(p: PubSubPeer, msg: seq[byte], msgId: MessageId) {.async.} =
-  if p.sendConn == nil:
-    # Wait for a send conn to be setup. `connectOnce` will
-    # complete this even if the sendConn setup failed
-    await p.connectedFut
-
-  var conn = p.sendConn
-  if conn == nil or conn.closed():
-    debug "No send connection", p, msg = shortLog(msg)
-    return
-
-  trace "sending encoded msgs to peer", conn, encoded = shortLog(msg)
-
-  if msgId.len > 0:
-    for dontWants in p.heDontWants:
-      if msgId in dontWants:
-        #libp2p_gossipsub_staggerDontWantSave.inc()
-        trace "Skipped sending msg/dontwant received from peer", conn, encoded = shortLog(msg)
-        return
-  try:
-    await conn.writeLp(msg)
-    trace "sent pubsub message to remote", conn
-  except CatchableError as exc: # never cancelled
-    # Because we detach the send call from the currently executing task using
-    # asyncSpawn, no exceptions may leak out of it
-    trace "Unable to send to remote", conn, msg = exc.msg
-    # Next time sendConn is used, it will be have its close flag set and thus
-    # will be recycled
-
-    await conn.close() # This will clean up the send connection
-
-proc sendEncoded*(p: PubSubPeer, msg: seq[byte], isHighPriority: bool, validMsgId: MessageId = @[]) {.async.} =
-  ## Asynchronously sends an encoded message to a specified `PubSubPeer`.
-  ##
-  ## Parameters:
-  ## - `p`: The `PubSubPeer` instance to which the message is to be sent.
-  ## - `msg`: The message to be sent, encoded as a sequence of bytes (`seq[byte]`).
-  ## - `isHighPriority`: A boolean indicating whether the message should be treated as high priority.
-  ## High priority messages are sent immediately, while low priority messages are queued and sent only after all high
-  ## priority messages have been sent.
+proc sendEncoded*(p: PubSubPeer, msg: seq[byte]) {.raises: [Defect].} =
  doAssert(not isNil(p), "pubsubpeer nil!")

  if msg.len <= 0:
@@ -313,67 +245,21 @@ proc sendEncoded*(p: PubSubPeer, msg: seq[byte], isHighPriority: bool, validMsgI
    return

  if msg.len > p.maxMessageSize:
-    info "trying to send a msg too big for pubsub", maxSize=p.maxMessageSize, msgSize=msg.len
+    info "trying to send a too big for pubsub", maxSize=p.maxMessageSize, msgSize=msg.len
    return

-  if isHighPriority:
-    p.clearSendPriorityQueue()
-    let f = p.sendMsg(msg, validMsgId)
-    if not f.finished:
-      p.rpcmessagequeue.sendPriorityQueue.addLast(f)
-      when defined(libp2p_expensive_metrics):
-        libp2p_gossipsub_priority_queue_size.inc(labelValues = [$p.peerId])
-  else:
-    await p.rpcmessagequeue.nonPriorityQueue.addLast(newMessageWithId(msg, validMsgId))
-    when defined(libp2p_expensive_metrics):
-      libp2p_gossipsub_non_priority_queue_size.inc(labelValues = [$p.peerId])
-  trace "message queued", p, msg = shortLog(msg)
+  let conn = p.sendConn
+  if conn == nil or conn.closed():
+    trace "No send connection, skipping message", p, msg = shortLog(msg)
+    return

-iterator splitRPCMsg(peer: PubSubPeer, rpcMsg: RPCMsg, maxSize: int, anonymize: bool): seq[byte] =
-  ## This iterator takes an `RPCMsg` and sequentially repackages its Messages into new `RPCMsg` instances.
-  ## Each new `RPCMsg` accumulates Messages until reaching the specified `maxSize`. If a single Message
-  ## exceeds the `maxSize` when trying to fit into an empty `RPCMsg`, the latter is skipped as too large to send.
-  ## Every constructed `RPCMsg` is then encoded, optionally anonymized, and yielded as a sequence of bytes.
+  # To limit the size of the closure, we only pass the encoded message and
+  # connection to the spawned send task
+  asyncSpawn sendImpl(conn, msg)

-  var currentRPCMsg = rpcMsg
-  currentRPCMsg.messages = newSeq[Message]()
+proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [Defect].} =
+  trace "sending msg to peer", peer = p, rpcMsg = shortLog(msg)

-  var currentSize = byteSize(currentRPCMsg)
-
-  for msg in rpcMsg.messages:
-    let msgSize = byteSize(msg)
-
-    # Check if adding the next message will exceed maxSize
-    if float(currentSize + msgSize) * 1.1 > float(maxSize): # Guessing 10% protobuf overhead
-      if currentRPCMsg.messages.len == 0:
-        trace "message too big to sent", peer, rpcMsg = shortLog(currentRPCMsg)
-        continue # Skip this message
-
-      trace "sending msg to peer", peer, rpcMsg = shortLog(currentRPCMsg)
-      yield encodeRpcMsg(currentRPCMsg, anonymize)
-      currentRPCMsg = RPCMsg()
-      currentSize = 0
-
-    currentRPCMsg.messages.add(msg)
-    currentSize += msgSize
-
-  # Check if there is a non-empty currentRPCMsg left to be added
-  if currentSize > 0 and currentRPCMsg.messages.len > 0:
-    trace "sending msg to peer", peer, rpcMsg = shortLog(currentRPCMsg)
-    yield encodeRpcMsg(currentRPCMsg, anonymize)
-  else:
-    trace "message too big to sent", peer, rpcMsg = shortLog(currentRPCMsg)
-
-proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool, isHighPriority: bool, validMsgId: MessageId = @[]) {.async.} =
-  ## Asynchronously sends an `RPCMsg` to a specified `PubSubPeer` with an option for anonymization.
-  ##
-  ## Parameters:
-  ## - `p`: The `PubSubPeer` instance to which the message is to be sent.
-  ## - `msg`: The `RPCMsg` instance representing the message to be sent.
-  ## - `anonymize`: A boolean flag indicating whether the message should be sent with anonymization.
-  ## - `isHighPriority`: A boolean flag indicating whether the message should be treated as high priority.
-  ## High priority messages are sent immediately, while low priority messages are queued and sent only after all high
-  ## priority messages have been sent.
  # When sending messages, we take care to re-encode them with the right
  # anonymization flag to ensure that we're not penalized for sending invalid
  # or malicious data on the wire - in particular, re-encoding protects against
@@ -391,57 +277,7 @@ proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool, isHighPriority: bool, va
    sendMetrics(msg)
    encodeRpcMsg(msg, anonymize)

-  if encoded.len > p.maxMessageSize and msg.messages.len > 1:
-    for encodedSplitMsg in splitRPCMsg(p, msg, p.maxMessageSize, anonymize):
-      await p.sendEncoded(encodedSplitMsg, isHighPriority, validMsgId)
-  else:
-    # If the message size is within limits, send it as is
-    trace "sending msg to peer", peer = p, rpcMsg = shortLog(msg)
-    await p.sendEncoded(encoded, isHighPriority, validMsgId)
-
-proc canAskIWant*(p: PubSubPeer, msgId: MessageId): bool =
-  for sentIHave in p.sentIHaves.mitems():
-    if msgId in sentIHave:
-      sentIHave.excl(msgId)
-      return true
-  return false
-
-proc sendNonPriorityTask(p: PubSubPeer) {.async.} =
-  while true:
-     # we send non-priority messages only if there are no pending priority messages
-     let msg = await p.rpcmessagequeue.nonPriorityQueue.popFirst()
-     while p.rpcmessagequeue.sendPriorityQueue.len > 0:
-       p.clearSendPriorityQueue()
-       # this minimizes the number of times we have to wait for something (each wait = performance cost)
-       # we will never wait for a finished future and by waiting for the last one, all that come before it are guaranteed
-       # to be finished already (since sends are processed in order).
-       if p.rpcmessagequeue.sendPriorityQueue.len > 0:
-        await p.rpcmessagequeue.sendPriorityQueue[^1]
-     when defined(libp2p_expensive_metrics):
-       libp2p_gossipsub_non_priority_queue_size.dec(labelValues = [$p.peerId])
-     await p.sendMsg(msg.message, msg.msgId)
-
-proc startSendNonPriorityTask(p: PubSubPeer) =
-  debug "starting sendNonPriorityTask", p
-  if p.rpcmessagequeue.sendNonPriorityTask.isNil:
-    p.rpcmessagequeue.sendNonPriorityTask = p.sendNonPriorityTask()
-
-proc stopSendNonPriorityTask*(p: PubSubPeer) =
-  if not p.rpcmessagequeue.sendNonPriorityTask.isNil:
-    debug "stopping sendNonPriorityTask", p
-    p.rpcmessagequeue.sendNonPriorityTask.cancel()
-    p.rpcmessagequeue.sendNonPriorityTask = nil
-    p.rpcmessagequeue.sendPriorityQueue.clear()
-    p.rpcmessagequeue.nonPriorityQueue.clear()
-    when defined(libp2p_expensive_metrics):
-      libp2p_gossipsub_priority_queue_size.set(labelValues = [$p.peerId], value = 0)
-      libp2p_gossipsub_non_priority_queue_size.set(labelValues = [$p.peerId], value = 0)
-
-proc new(T: typedesc[RpcMessageQueue]): T =
-  return T(
-    sendPriorityQueue: initDeque[Future[void]](),
-    nonPriorityQueue: newAsyncQueue[MessageWithId](),
-  )
+  p.sendEncoded(encoded)

 proc new*(
  T: typedesc[PubSubPeer],
@@ -449,19 +285,12 @@ proc new*(
  getConn: GetConn,
  onEvent: OnEvent,
  codec: string,
-  maxMessageSize: int,
-  overheadRateLimitOpt: Opt[TokenBucket] = Opt.none(TokenBucket)): T =
+  maxMessageSize: int): T =

-  result = T(
+  T(
    getConn: getConn,
    onEvent: onEvent,
    codec: codec,
    peerId: peerId,
-    connectedFut: newFuture[void](),
-    maxMessageSize: maxMessageSize,
-    overheadRateLimitOpt: overheadRateLimitOpt,
-    rpcmessagequeue: RpcMessageQueue.new(),
+    maxMessageSize: maxMessageSize
  )
-  result.sentIHaves.addFirst(default(HashSet[MessageId]))
-  result.heDontWants.addFirst(default(HashSet[MessageId]))
-  result.startSendNonPriorityTask()
--- a/libp2p/protocols/pubsub/rpc/message.nim
+++ b/libp2p/protocols/pubsub/rpc/message.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,8 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

+import hashes
 import chronicles, metrics, stew/[byteutils, endians2]
 import ./messages,
       ./protobuf,
@@ -62,21 +66,22 @@ proc init*(
    topic: string,
    seqno: Option[uint64],
    sign: bool = true): Message
-    {.gcsafe, raises: [LPError].} =
+    {.gcsafe, raises: [Defect, LPError].} =
  var msg = Message(data: data, topicIDs: @[topic])

  # order matters, we want to include seqno in the signature
-  seqno.withValue(seqn):
-    msg.seqno = @(seqn.toBytesBE())
+  if seqno.isSome:
+    msg.seqno = @(seqno.get().toBytesBE())

-  peer.withValue(peer):
+  if peer.isSome:
+    let peer = peer.get()
    msg.fromPeer = peer.peerId
    if sign:
      msg.signature = sign(msg, peer.privateKey).expect("Couldn't sign message!")
      msg.key = peer.privateKey.getPublicKey().expect("Invalid private key!")
        .getBytes().expect("Couldn't get public key bytes!")
-  else:
-    if sign: raise (ref LPError)(msg: "Cannot sign message without peer info")
+  elif sign:
+    raise (ref LPError)(msg: "Cannot sign message without peer info")

  msg

@@ -86,10 +91,10 @@ proc init*(
    data: seq[byte],
    topic: string,
    seqno: Option[uint64]): Message
-    {.gcsafe, raises: [LPError].} =
+    {.gcsafe, raises: [Defect, LPError].} =
  var msg = Message(data: data, topicIDs: @[topic])
  msg.fromPeer = peerId

-  seqno.withValue(seqn):
-    msg.seqno = @(seqn.toBytesBE())
+  if seqno.isSome:
+    msg.seqno = @(seqno.get().toBytesBE())
  msg
--- a/libp2p/protocols/pubsub/rpc/messages.nim
+++ b/libp2p/protocols/pubsub/rpc/messages.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import options, sequtils, sugar
+import options, sequtils
 import "../../.."/[
        peerid,
        routing_record,
@@ -18,14 +21,6 @@ import "../../.."/[

 export options

-proc expectedFields[T](t: typedesc[T], existingFieldNames: seq[string]) {.raises: [CatchableError].} =
-  var fieldNames: seq[string]
-  for name, _ in fieldPairs(T()):
-    fieldNames &= name
-  if fieldNames != existingFieldNames:
-    fieldNames.keepIf(proc(it: string): bool = it notin existingFieldNames)
-    raise newException(CatchableError, $T & " fields changed, please search for and revise all relevant procs. New fields: " & $fieldNames)
-
 type
    PeerInfoMsg* = object
      peerId*: PeerId
@@ -50,7 +45,6 @@ type
      iwant*: seq[ControlIWant]
      graft*: seq[ControlGraft]
      prune*: seq[ControlPrune]
-      idontwant*: seq[ControlIWant]

    ControlIHave* = object
      topicId*: string
@@ -71,8 +65,6 @@ type
      subscriptions*: seq[SubOpts]
      messages*: seq[Message]
      control*: Option[ControlMessage]
-      ping*: seq[byte]
-      pong*: seq[byte]

 func withSubs*(
    T: type RPCMsg, topics: openArray[string], subscribe: bool): T =
@@ -119,59 +111,15 @@ func shortLog*(msg: Message): auto =
  )

 func shortLog*(m: RPCMsg): auto =
-  (
-    subscriptions: m.subscriptions,
-    messages: mapIt(m.messages, it.shortLog),
-    control: m.control.get(ControlMessage()).shortLog
-  )
-
-static: expectedFields(PeerInfoMsg, @["peerId", "signedPeerRecord"])
-proc byteSize(peerInfo: PeerInfoMsg): int =
-  peerInfo.peerId.len + peerInfo.signedPeerRecord.len
-
-static: expectedFields(SubOpts, @["subscribe", "topic"])
-proc byteSize(subOpts: SubOpts): int =
-  1 + subOpts.topic.len # 1 byte for the bool
-
-static: expectedFields(Message, @["fromPeer", "data", "seqno", "topicIds", "signature", "key"])
-proc byteSize*(msg: Message): int =
-  msg.fromPeer.len + msg.data.len + msg.seqno.len +
-         msg.signature.len + msg.key.len + msg.topicIds.foldl(a + b.len, 0)
-
-proc byteSize*(msgs: seq[Message]): int =
-  msgs.foldl(a + b.byteSize, 0)
-
-static: expectedFields(ControlIHave, @["topicId", "messageIds"])
-proc byteSize(controlIHave: ControlIHave): int =
-  controlIHave.topicId.len + controlIHave.messageIds.foldl(a + b.len, 0)
-
-proc byteSize*(ihaves: seq[ControlIHave]): int =
-  ihaves.foldl(a + b.byteSize, 0)
-
-static: expectedFields(ControlIWant, @["messageIds"])
-proc byteSize(controlIWant: ControlIWant): int =
-  controlIWant.messageIds.foldl(a + b.len, 0)
-
-proc byteSize*(iwants: seq[ControlIWant]): int =
-  iwants.foldl(a + b.byteSize, 0)
-
-static: expectedFields(ControlGraft, @["topicId"])
-proc byteSize(controlGraft: ControlGraft): int =
-  controlGraft.topicId.len
-
-static: expectedFields(ControlPrune, @["topicId", "peers", "backoff"])
-proc byteSize(controlPrune: ControlPrune): int =
-  controlPrune.topicId.len + controlPrune.peers.foldl(a + b.byteSize, 0) + 8 # 8 bytes for uint64
-
-static: expectedFields(ControlMessage, @["ihave", "iwant", "graft", "prune", "idontwant"])
-proc byteSize(control: ControlMessage): int =
-  control.ihave.foldl(a + b.byteSize, 0) + control.iwant.foldl(a + b.byteSize, 0) +
-  control.graft.foldl(a + b.byteSize, 0) + control.prune.foldl(a + b.byteSize, 0) +
-  control.idontwant.foldl(a + b.byteSize, 0)
-
-static: expectedFields(RPCMsg, @["subscriptions", "messages", "control", "ping", "pong"])
-proc byteSize*(rpc: RPCMsg): int =
-  result = rpc.subscriptions.foldl(a + b.byteSize, 0) + byteSize(rpc.messages) +
-           rpc.ping.len + rpc.pong.len
-  rpc.control.withValue(ctrl):
-    result += ctrl.byteSize
+  if m.control.isSome:
+    (
+      subscriptions: m.subscriptions,
+      messages: mapIt(m.messages, it.shortLog),
+      control: m.control.get().shortLog
+    )
+  else:
+    (
+      subscriptions: m.subscriptions,
+      messages: mapIt(m.messages, it.shortLog),
+      control: ControlMessage().shortLog
+    )
--- a/libp2p/protocols/pubsub/rpc/protobuf.nim
+++ b/libp2p/protocols/pubsub/rpc/protobuf.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import options
 import stew/assign2
@@ -87,8 +90,6 @@ proc write*(pb: var ProtoBuffer, field: int, control: ControlMessage) =
    ipb.write(3, graft)
  for prune in control.prune:
    ipb.write(4, prune)
-  for idontwant in control.idontwant:
-    ipb.write(5, idontwant)
  if len(ipb.buffer) > 0:
    ipb.finish()
    pb.write(field, ipb)
@@ -212,7 +213,6 @@ proc decodeControl*(pb: ProtoBuffer): ProtoResult[Option[ControlMessage]] {.
    var iwantpbs: seq[seq[byte]]
    var graftpbs: seq[seq[byte]]
    var prunepbs: seq[seq[byte]]
-    var idontwant: seq[seq[byte]]
    if ? cpb.getRepeatedField(1, ihavepbs):
      for item in ihavepbs:
        control.ihave.add(? decodeIHave(initProtoBuffer(item)))
@@ -225,9 +225,6 @@ proc decodeControl*(pb: ProtoBuffer): ProtoResult[Option[ControlMessage]] {.
    if ? cpb.getRepeatedField(4, prunepbs):
      for item in prunepbs:
        control.prune.add(? decodePrune(initProtoBuffer(item)))
-    if ? cpb.getRepeatedField(5, idontwant):
-      for item in idontwant:
-        control.idontwant.add(? decodeIWant(initProtoBuffer(item)))
    trace "decodeControl: message statistics", graft_count = len(control.graft),
                                               prune_count = len(control.prune),
                                               ihave_count = len(control.ihave),
@@ -320,14 +317,8 @@ proc encodeRpcMsg*(msg: RPCMsg, anonymize: bool): seq[byte] =
    pb.write(1, item)
  for item in msg.messages:
    pb.write(2, item, anonymize)
-  msg.control.withValue(control):
-    pb.write(3, control)
-  # nim-libp2p extension, using fields which are unlikely to be used
-  # by other extensions
-  if msg.ping.len > 0:
-    pb.write(60, msg.ping)
-  if msg.pong.len > 0:
-    pb.write(61, msg.pong)
+  if msg.control.isSome():
+    pb.write(3, msg.control.get())
  if len(pb.buffer) > 0:
    pb.finish()
  pb.buffer
@@ -335,10 +326,8 @@ proc encodeRpcMsg*(msg: RPCMsg, anonymize: bool): seq[byte] =
 proc decodeRpcMsg*(msg: seq[byte]): ProtoResult[RPCMsg] {.inline.} =
  trace "decodeRpcMsg: decoding message", msg = msg.shortLog()
  var pb = initProtoBuffer(msg, maxSize = uint.high)
-  var rpcMsg = RPCMsg()
-  assign(rpcMsg.messages, ? pb.decodeMessages())
-  assign(rpcMsg.subscriptions, ? pb.decodeSubscriptions())
-  assign(rpcMsg.control, ? pb.decodeControl())
-  discard ? pb.getField(60, rpcMsg.ping)
-  discard ? pb.getField(61, rpcMsg.pong)
-  ok(rpcMsg)
+  var rpcMsg = ok(RPCMsg())
+  assign(rpcMsg.get().messages, ? pb.decodeMessages())
+  assign(rpcMsg.get().subscriptions, ? pb.decodeSubscriptions())
+  assign(rpcMsg.get().control, ? pb.decodeControl())
+  rpcMsg
--- a/libp2p/protocols/pubsub/timedcache.nim
+++ b/libp2p/protocols/pubsub/timedcache.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,13 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[tables]

-import chronos/timer, stew/results
-
-import ../../utility
+import chronos/timer

 const Timeout* = 10.seconds # default timeout in ms

@@ -21,7 +22,6 @@ type
  TimedEntry*[K] = ref object of RootObj
    key: K
    addedAt: Moment
-    expiresAt: Moment
    next, prev: TimedEntry[K]

  TimedCache*[K] = object of RootObj
@@ -30,14 +30,15 @@ type
    timeout: Duration

 func expire*(t: var TimedCache, now: Moment = Moment.now()) =
-  while t.head != nil and t.head.expiresAt < now:
+  let expirationLimit = now - t.timeout
+  while t.head != nil and t.head.addedAt < expirationLimit:
    t.entries.del(t.head.key)
    t.head.prev = nil
    t.head = t.head.next
    if t.head == nil: t.tail = nil

-func del*[K](t: var TimedCache[K], key: K): Opt[TimedEntry[K]] =
-  # Removes existing key from cache, returning the previous value if present
+func del*[K](t: var TimedCache[K], key: K): bool =
+  # Removes existing key from cache, returning false if it was not present
  var item: TimedEntry[K]
  if t.entries.pop(key, item):
    if t.head == item: t.head = item.next
@@ -45,9 +46,9 @@ func del*[K](t: var TimedCache[K], key: K): Opt[TimedEntry[K]] =

    if item.next != nil: item.next.prev = item.prev
    if item.prev != nil: item.prev.next = item.next
-    Opt.some(item)
+    true
  else:
-    Opt.none(TimedEntry[K])
+    false

 func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
  # Puts k in cache, returning true if the item was already present and false
@@ -55,13 +56,9 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
  # refreshed.
  t.expire(now)

-  var previous = t.del(k) # Refresh existing item
+  var res = t.del(k) # Refresh existing item

-  var addedAt = now
-  previous.withValue(previous):
-    addedAt = previous.addedAt
-
-  let node = TimedEntry[K](key: k, addedAt: addedAt, expiresAt: now + t.timeout)
+  let node = TimedEntry[K](key: k, addedAt: now)

  if t.head == nil:
    t.tail = node
@@ -69,7 +66,7 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
  else:
    # search from tail because typically that's where we add when now grows
    var cur = t.tail
-    while cur != nil and node.expiresAt < cur.expiresAt:
+    while cur != nil and node.addedAt < cur.addedAt:
      cur = cur.prev

    if cur == nil:
@@ -85,7 +82,7 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =

  t.entries[k] = node

-  previous.isSome()
+  res

 func contains*[K](t: TimedCache[K], k: K): bool =
  k in t.entries
--- a/libp2p/protocols/rendezvous.nim
+++ b/libp2p/protocols/rendezvous.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,14 +7,16 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import tables, sequtils, sugar, sets
-import metrics except collect
+import tables, sequtils, sugar, sets, options
 import chronos,
       chronicles,
       bearssl/rand,
-       stew/[byteutils, objects, results]
+       stew/[byteutils, objects]
 import ./protocol,
       ../switch,
       ../routing_record,
@@ -28,11 +30,6 @@ export chronicles
 logScope:
  topics = "libp2p discovery rendezvous"

-declareCounter(libp2p_rendezvous_register, "number of advertise requests")
-declareCounter(libp2p_rendezvous_discover, "number of discovery requests")
-declareGauge(libp2p_rendezvous_registered, "number of registered peers")
-declareGauge(libp2p_rendezvous_namespaces, "number of registered namespaces")
-
 const
  RendezVousCodec* = "/rendezvous/1.0.0"
  MinimumDuration* = 2.hours
@@ -68,34 +65,34 @@ type
  Register = object
    ns : string
    signedPeerRecord: seq[byte]
-    ttl: Opt[uint64] # in seconds
+    ttl: Option[uint64] # in seconds

  RegisterResponse = object
    status: ResponseStatus
-    text: Opt[string]
-    ttl: Opt[uint64] # in seconds
+    text: Option[string]
+    ttl: Option[uint64] # in seconds

  Unregister = object
    ns: string

  Discover = object
    ns: string
-    limit: Opt[uint64]
-    cookie: Opt[seq[byte]]
+    limit: Option[uint64]
+    cookie: Option[seq[byte]]

  DiscoverResponse = object
    registrations: seq[Register]
-    cookie: Opt[seq[byte]]
+    cookie: Option[seq[byte]]
    status: ResponseStatus
-    text: Opt[string]
+    text: Option[string]

  Message = object
    msgType: MessageType
-    register: Opt[Register]
-    registerResponse: Opt[RegisterResponse]
-    unregister: Opt[Unregister]
-    discover: Opt[Discover]
-    discoverResponse: Opt[DiscoverResponse]
+    register: Option[Register]
+    registerResponse: Option[RegisterResponse]
+    unregister: Option[Unregister]
+    discover: Option[Discover]
+    discoverResponse: Option[DiscoverResponse]

 proc encode(c: Cookie): ProtoBuffer =
  result = initProtoBuffer()
@@ -107,17 +104,17 @@ proc encode(r: Register): ProtoBuffer =
  result = initProtoBuffer()
  result.write(1, r.ns)
  result.write(2, r.signedPeerRecord)
-  r.ttl.withValue(ttl):
-    result.write(3, ttl)
+  if r.ttl.isSome():
+    result.write(3, r.ttl.get())
  result.finish()

 proc encode(rr: RegisterResponse): ProtoBuffer =
  result = initProtoBuffer()
  result.write(1, rr.status.uint)
-  rr.text.withValue(text):
-    result.write(2, text)
-  rr.ttl.withValue(ttl):
-    result.write(3, ttl)
+  if rr.text.isSome():
+    result.write(2, rr.text.get())
+  if rr.ttl.isSome():
+    result.write(3, rr.ttl.get())
  result.finish()

 proc encode(u: Unregister): ProtoBuffer =
@@ -128,48 +125,48 @@ proc encode(u: Unregister): ProtoBuffer =
 proc encode(d: Discover): ProtoBuffer =
  result = initProtoBuffer()
  result.write(1, d.ns)
-  d.limit.withValue(limit):
-    result.write(2, limit)
-  d.cookie.withValue(cookie):
-    result.write(3, cookie)
+  if d.limit.isSome():
+    result.write(2, d.limit.get())
+  if d.cookie.isSome():
+    result.write(3, d.cookie.get())
  result.finish()

-proc encode(dr: DiscoverResponse): ProtoBuffer =
+proc encode(d: DiscoverResponse): ProtoBuffer =
  result = initProtoBuffer()
-  for reg in dr.registrations:
+  for reg in d.registrations:
    result.write(1, reg.encode())
-  dr.cookie.withValue(cookie):
-    result.write(2, cookie)
-  result.write(3, dr.status.uint)
-  dr.text.withValue(text):
-    result.write(4, text)
+  if d.cookie.isSome():
+    result.write(2, d.cookie.get())
+  result.write(3, d.status.uint)
+  if d.text.isSome():
+    result.write(4, d.text.get())
  result.finish()

 proc encode(msg: Message): ProtoBuffer =
  result = initProtoBuffer()
  result.write(1, msg.msgType.uint)
-  msg.register.withValue(register):
-    result.write(2, register.encode())
-  msg.registerResponse.withValue(registerResponse):
-    result.write(3, registerResponse.encode())
-  msg.unregister.withValue(unregister):
-    result.write(4, unregister.encode())
-  msg.discover.withValue(discover):
-    result.write(5, discover.encode())
-  msg.discoverResponse.withValue(discoverResponse):
-    result.write(6, discoverResponse.encode())
+  if msg.register.isSome():
+    result.write(2, msg.register.get().encode())
+  if msg.registerResponse.isSome():
+    result.write(3, msg.registerResponse.get().encode())
+  if msg.unregister.isSome():
+    result.write(4, msg.unregister.get().encode())
+  if msg.discover.isSome():
+    result.write(5, msg.discover.get().encode())
+  if msg.discoverResponse.isSome():
+    result.write(6, msg.discoverResponse.get().encode())
  result.finish()

-proc decode(_: typedesc[Cookie], buf: seq[byte]): Opt[Cookie] =
+proc decode(_: typedesc[Cookie], buf: seq[byte]): Option[Cookie] =
  var c: Cookie
  let
    pb = initProtoBuffer(buf)
    r1 = pb.getRequiredField(1, c.offset)
    r2 = pb.getRequiredField(2, c.ns)
-  if r1.isErr() or r2.isErr(): return Opt.none(Cookie)
-  Opt.some(c)
+  if r1.isErr() or r2.isErr(): return none(Cookie)
+  some(c)

-proc decode(_: typedesc[Register], buf: seq[byte]): Opt[Register] =
+proc decode(_: typedesc[Register], buf: seq[byte]): Option[Register] =
  var
    r: Register
    ttl: uint64
@@ -178,11 +175,11 @@ proc decode(_: typedesc[Register], buf: seq[byte]): Opt[Register] =
    r1 = pb.getRequiredField(1, r.ns)
    r2 = pb.getRequiredField(2, r.signedPeerRecord)
    r3 = pb.getField(3, ttl)
-  if r1.isErr() or r2.isErr() or r3.isErr(): return Opt.none(Register)
-  if r3.get(false): r.ttl = Opt.some(ttl)
-  Opt.some(r)
+  if r1.isErr() or r2.isErr() or r3.isErr(): return none(Register)
+  if r3.get(): r.ttl = some(ttl)
+  some(r)

-proc decode(_: typedesc[RegisterResponse], buf: seq[byte]): Opt[RegisterResponse] =
+proc decode(_: typedesc[RegisterResponse], buf: seq[byte]): Option[RegisterResponse] =
  var
    rr: RegisterResponse
    statusOrd: uint
@@ -194,20 +191,20 @@ proc decode(_: typedesc[RegisterResponse], buf: seq[byte]): Opt[RegisterResponse
    r2 = pb.getField(2, text)
    r3 = pb.getField(3, ttl)
  if r1.isErr() or r2.isErr() or r3.isErr() or
-     not checkedEnumAssign(rr.status, statusOrd): return Opt.none(RegisterResponse)
-  if r2.get(false): rr.text = Opt.some(text)
-  if r3.get(false): rr.ttl = Opt.some(ttl)
-  Opt.some(rr)
+     not checkedEnumAssign(rr.status, statusOrd): return none(RegisterResponse)
+  if r2.get(): rr.text = some(text)
+  if r3.get(): rr.ttl = some(ttl)
+  some(rr)

-proc decode(_: typedesc[Unregister], buf: seq[byte]): Opt[Unregister] =
+proc decode(_: typedesc[Unregister], buf: seq[byte]): Option[Unregister] =
  var u: Unregister
  let
    pb = initProtoBuffer(buf)
    r1 = pb.getRequiredField(1, u.ns)
-  if r1.isErr(): return Opt.none(Unregister)
-  Opt.some(u)
+  if r1.isErr(): return none(Unregister)
+  some(u)

-proc decode(_: typedesc[Discover], buf: seq[byte]): Opt[Discover] =
+proc decode(_: typedesc[Discover], buf: seq[byte]): Option[Discover] =
  var
    d: Discover
    limit: uint64
@@ -217,12 +214,12 @@ proc decode(_: typedesc[Discover], buf: seq[byte]): Opt[Discover] =
    r1 = pb.getRequiredField(1, d.ns)
    r2 = pb.getField(2, limit)
    r3 = pb.getField(3, cookie)
-  if r1.isErr() or r2.isErr() or r3.isErr: return Opt.none(Discover)
-  if r2.get(false): d.limit = Opt.some(limit)
-  if r3.get(false): d.cookie = Opt.some(cookie)
-  Opt.some(d)
+  if r1.isErr() or r2.isErr() or r3.isErr: return none(Discover)
+  if r2.get(): d.limit = some(limit)
+  if r3.get(): d.cookie = some(cookie)
+  some(d)

-proc decode(_: typedesc[DiscoverResponse], buf: seq[byte]): Opt[DiscoverResponse] =
+proc decode(_: typedesc[DiscoverResponse], buf: seq[byte]): Option[DiscoverResponse] =
  var
    dr: DiscoverResponse
    registrations: seq[seq[byte]]
@@ -236,47 +233,48 @@ proc decode(_: typedesc[DiscoverResponse], buf: seq[byte]): Opt[DiscoverResponse
    r3 = pb.getRequiredField(3, statusOrd)
    r4 = pb.getField(4, text)
  if r1.isErr() or r2.isErr() or r3.isErr or r4.isErr() or
-     not checkedEnumAssign(dr.status, statusOrd): return Opt.none(DiscoverResponse)
+     not checkedEnumAssign(dr.status, statusOrd): return none(DiscoverResponse)
  for reg in registrations:
    var r: Register
-    let regOpt = Register.decode(reg).valueOr:
-      return
-    dr.registrations.add(regOpt)
-  if r2.get(false): dr.cookie = Opt.some(cookie)
-  if r4.get(false): dr.text = Opt.some(text)
-  Opt.some(dr)
+    let regOpt = Register.decode(reg)
+    if regOpt.isNone(): return none(DiscoverResponse)
+    dr.registrations.add(regOpt.get())
+  if r2.get(): dr.cookie = some(cookie)
+  if r4.get(): dr.text = some(text)
+  some(dr)

-proc decode(_: typedesc[Message], buf: seq[byte]): Opt[Message] =
+proc decode(_: typedesc[Message], buf: seq[byte]): Option[Message] =
  var
    msg: Message
    statusOrd: uint
    pbr, pbrr, pbu, pbd, pbdr: ProtoBuffer
-  let pb = initProtoBuffer(buf)
-
-  ? pb.getRequiredField(1, statusOrd).toOpt
-  if not checkedEnumAssign(msg.msgType, statusOrd): return Opt.none(Message)
-
-  if ? pb.getField(2, pbr).optValue:
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, statusOrd)
+    r2 = pb.getField(2, pbr)
+    r3 = pb.getField(3, pbrr)
+    r4 = pb.getField(4, pbu)
+    r5 = pb.getField(5, pbd)
+    r6 = pb.getField(6, pbdr)
+  if r1.isErr() or r2.isErr() or r3.isErr() or
+     r4.isErr() or r5.isErr() or r6.isErr() or
+     not checkedEnumAssign(msg.msgType, statusOrd): return none(Message)
+  if r2.get():
    msg.register = Register.decode(pbr.buffer)
-    if msg.register.isNone(): return Opt.none(Message)
-
-  if ? pb.getField(3, pbrr).optValue:
+    if msg.register.isNone(): return none(Message)
+  if r3.get():
    msg.registerResponse = RegisterResponse.decode(pbrr.buffer)
-    if msg.registerResponse.isNone(): return Opt.none(Message)
-
-  if ? pb.getField(4, pbu).optValue:
+    if msg.registerResponse.isNone(): return none(Message)
+  if r4.get():
    msg.unregister = Unregister.decode(pbu.buffer)
-    if msg.unregister.isNone(): return Opt.none(Message)
-
-  if ? pb.getField(5, pbd).optValue:
+    if msg.unregister.isNone(): return none(Message)
+  if r5.get():
    msg.discover = Discover.decode(pbd.buffer)
-    if msg.discover.isNone(): return Opt.none(Message)
-
-  if ? pb.getField(6, pbdr).optValue:
+    if msg.discover.isNone(): return none(Message)
+  if r6.get():
    msg.discoverResponse = DiscoverResponse.decode(pbdr.buffer)
-    if msg.discoverResponse.isNone(): return Opt.none(Message)
-
-  Opt.some(msg)
+    if msg.discoverResponse.isNone(): return none(Message)
+  some(msg)


 type
@@ -316,7 +314,7 @@ proc sendRegisterResponse(conn: Connection,
                          ttl: uint64) {.async.} =
  let msg = encode(Message(
        msgType: MessageType.RegisterResponse,
-        registerResponse: Opt.some(RegisterResponse(status: Ok, ttl: Opt.some(ttl)))))
+        registerResponse: some(RegisterResponse(status: Ok, ttl: some(ttl)))))
  await conn.writeLp(msg.buffer)

 proc sendRegisterResponseError(conn: Connection,
@@ -324,7 +322,7 @@ proc sendRegisterResponseError(conn: Connection,
                               text: string = "") {.async.} =
  let msg = encode(Message(
        msgType: MessageType.RegisterResponse,
-        registerResponse: Opt.some(RegisterResponse(status: status, text: Opt.some(text)))))
+        registerResponse: some(RegisterResponse(status: status, text: some(text)))))
  await conn.writeLp(msg.buffer)

 proc sendDiscoverResponse(conn: Connection,
@@ -332,10 +330,10 @@ proc sendDiscoverResponse(conn: Connection,
                          cookie: Cookie) {.async.} =
  let msg = encode(Message(
        msgType: MessageType.DiscoverResponse,
-        discoverResponse: Opt.some(DiscoverResponse(
+        discoverResponse: some(DiscoverResponse(
            status: Ok,
            registrations: s,
-            cookie: Opt.some(cookie.encode().buffer)
+            cookie: some(cookie.encode().buffer)
          ))
        ))
  await conn.writeLp(msg.buffer)
@@ -345,7 +343,7 @@ proc sendDiscoverResponseError(conn: Connection,
                               text: string = "") {.async.} =
  let msg = encode(Message(
        msgType: MessageType.DiscoverResponse,
-        discoverResponse: Opt.some(DiscoverResponse(status: status, text: Opt.some(text)))))
+        discoverResponse: some(DiscoverResponse(status: status, text: some(text)))))
  await conn.writeLp(msg.buffer)

 proc countRegister(rdv: RendezVous, peerId: PeerId): int =
@@ -380,7 +378,6 @@ proc save(rdv: RendezVous,

 proc register(rdv: RendezVous, conn: Connection, r: Register): Future[void] =
  trace "Received Register", peerId = conn.peerId, ns = r.ns
-  libp2p_rendezvous_register.inc()
  if r.ns.len notin 1..255:
    return conn.sendRegisterResponseError(InvalidNamespace)
  let ttl = r.ttl.get(MinimumTTL)
@@ -392,8 +389,6 @@ proc register(rdv: RendezVous, conn: Connection, r: Register): Future[void] =
  if rdv.countRegister(conn.peerId) >= RegistrationLimitPerPeer:
    return conn.sendRegisterResponseError(NotAuthorized, "Registration limit reached")
  rdv.save(r.ns, conn.peerId, r)
-  libp2p_rendezvous_registered.inc()
-  libp2p_rendezvous_namespaces.set(int64(rdv.namespaces.len))
  conn.sendRegisterResponse(ttl)

 proc unregister(rdv: RendezVous, conn: Connection, u: Unregister) =
@@ -403,13 +398,11 @@ proc unregister(rdv: RendezVous, conn: Connection, u: Unregister) =
    for index in rdv.namespaces[nsSalted]:
      if rdv.registered[index].peerId == conn.peerId:
        rdv.registered[index].expiration = rdv.defaultDT
-        libp2p_rendezvous_registered.dec()
  except KeyError:
    return

 proc discover(rdv: RendezVous, conn: Connection, d: Discover) {.async.} =
  trace "Received Discover", peerId = conn.peerId, ns = d.ns
-  libp2p_rendezvous_discover.inc()
  if d.ns.len notin 0..255:
    await conn.sendDiscoverResponseError(InvalidNamespace)
    return
@@ -418,7 +411,7 @@ proc discover(rdv: RendezVous, conn: Connection, d: Discover) {.async.} =
    cookie =
      if d.cookie.isSome():
        try:
-          Cookie.decode(d.cookie.tryGet()).tryGet()
+          Cookie.decode(d.cookie.get()).get()
        except CatchableError:
          await conn.sendDiscoverResponseError(InvalidCookie)
          return
@@ -449,7 +442,7 @@ proc discover(rdv: RendezVous, conn: Connection, d: Discover) {.async.} =
          break
        if reg.expiration < n or index.uint64 <= cookie.offset: continue
        limit.dec()
-        reg.data.ttl = Opt.some((reg.expiration - Moment.now()).seconds.uint64)
+        reg.data.ttl = some((reg.expiration - Moment.now()).seconds.uint64)
        reg.data
  rdv.rng.shuffle(s)
  await conn.sendDiscoverResponse(s, Cookie(offset: offset.uint64, ns: d.ns))
@@ -464,13 +457,12 @@ proc advertisePeer(rdv: RendezVous,
      await conn.writeLp(msg)
      let
        buf = await conn.readLp(4096)
-        msgRecv = Message.decode(buf).tryGet()
+        msgRecv = Message.decode(buf).get()
      if msgRecv.msgType != MessageType.RegisterResponse:
        trace "Unexpected register response", peer, msgType = msgRecv.msgType
-      elif msgRecv.registerResponse.tryGet().status != ResponseStatus.Ok:
+      elif msgRecv.registerResponse.isNone() or
+           msgRecv.registerResponse.get().status != ResponseStatus.Ok:
        trace "Refuse to register", peer, response = msgRecv.registerResponse
-      else:
-        trace "Successfully registered", peer, response = msgRecv.registerResponse
    except CatchableError as exc:
      trace "exception in the advertise", error = exc.msg
    finally:
@@ -478,18 +470,19 @@ proc advertisePeer(rdv: RendezVous,
  await rdv.sema.acquire()
  discard await advertiseWrap().withTimeout(5.seconds)

-method advertise*(rdv: RendezVous,
+proc advertise*(rdv: RendezVous,
                ns: string,
-                ttl: Duration = MinimumDuration) {.async, base.} =
-  let sprBuff = rdv.switch.peerInfo.signedPeerRecord.encode().valueOr:
+                ttl: Duration = MinimumDuration) {.async.} =
+  let sprBuff = rdv.switch.peerInfo.signedPeerRecord.encode()
+  if sprBuff.isErr():
    raise newException(RendezVousError, "Wrong Signed Peer Record")
  if ns.len notin 1..255:
    raise newException(RendezVousError, "Invalid namespace")
  if ttl notin MinimumDuration..MaximumDuration:
    raise newException(RendezVousError, "Invalid time to live")
  let
-    r = Register(ns: ns, signedPeerRecord: sprBuff, ttl: Opt.some(ttl.seconds.uint64))
-    msg = encode(Message(msgType: MessageType.Register, register: Opt.some(r)))
+    r = Register(ns: ns, signedPeerRecord: sprBuff.get(), ttl: some(ttl.seconds.uint64))
+    msg = encode(Message(msgType: MessageType.Register, register: some(r)))
  rdv.save(ns, rdv.switch.peerInfo.peerId, r)
  let fut = collect(newSeq()):
    for peer in rdv.peers:
@@ -505,9 +498,7 @@ proc requestLocally*(rdv: RendezVous, ns: string): seq[PeerRecord] =
    collect(newSeq()):
      for index in rdv.namespaces[nsSalted]:
        if rdv.registered[index].expiration > n:
-          let res = SignedPeerRecord.decode(rdv.registered[index].data.signedPeerRecord).valueOr:
-            continue
-          res.data
+          SignedPeerRecord.decode(rdv.registered[index].data.signedPeerRecord).get().data
  except KeyError as exc:
    @[]

@@ -528,42 +519,38 @@ proc request*(rdv: RendezVous,
  proc requestPeer(peer: PeerId) {.async.} =
    let conn = await rdv.switch.dial(peer, RendezVousCodec)
    defer: await conn.close()
-    d.limit = Opt.some(limit)
+    d.limit = some(limit)
    d.cookie =
      try:
-        Opt.some(rdv.cookiesSaved[peer][ns])
+        some(rdv.cookiesSaved[peer][ns])
      except KeyError as exc:
-        Opt.none(seq[byte])
+        none(seq[byte])
    await conn.writeLp(encode(Message(
      msgType: MessageType.Discover,
-      discover: Opt.some(d))).buffer)
+      discover: some(d))).buffer)
    let
      buf = await conn.readLp(65536)
-      msgRcv = Message.decode(buf).valueOr:
-        debug "Message undecodable"
-        return
-    if msgRcv.msgType != MessageType.DiscoverResponse:
+      msgRcv = Message.decode(buf).get()
+    if msgRcv.msgType != MessageType.DiscoverResponse or
+       msgRcv.discoverResponse.isNone():
      debug "Unexpected discover response", msgType = msgRcv.msgType
      return
-    let resp = msgRcv.discoverResponse.valueOr:
-      debug "Discover response is empty"
-      return
+    let resp = msgRcv.discoverResponse.get()
    if resp.status != ResponseStatus.Ok:
      trace "Cannot discover", ns, status = resp.status, text = resp.text
      return
-    resp.cookie.withValue(cookie):
-      if  cookie.len() < 1000 and rdv.cookiesSaved.hasKeyOrPut(peer, {ns: cookie}.toTable()):
-        rdv.cookiesSaved[peer][ns] = cookie
+    if resp.cookie.isSome() and resp.cookie.get().len < 1000:
+      if rdv.cookiesSaved.hasKeyOrPut(peer, {ns: resp.cookie.get()}.toTable):
+        rdv.cookiesSaved[peer][ns] = resp.cookie.get()
    for r in resp.registrations:
      if limit == 0: return
-      let ttl = r.ttl.get(MaximumTTL + 1)
-      if ttl > MaximumTTL: continue
-      let
-        spr = SignedPeerRecord.decode(r.signedPeerRecord).valueOr: continue
-        pr = spr.data
+      if r.ttl.isNone() or r.ttl.get() > MaximumTTL: continue
+      let sprRes = SignedPeerRecord.decode(r.signedPeerRecord)
+      if sprRes.isErr(): continue
+      let pr = sprRes.get().data
      if s.hasKey(pr.peerId):
        let (prSaved, rSaved) = s[pr.peerId]
-        if (prSaved.seqNo == pr.seqNo and rSaved.ttl.get(MaximumTTL) < ttl) or
+        if (prSaved.seqNo == pr.seqNo and rSaved.ttl.get() < r.ttl.get()) or
          prSaved.seqNo < pr.seqNo:
          s[pr.peerId] = (pr, r)
      else:
@@ -602,7 +589,7 @@ proc unsubscribe*(rdv: RendezVous, ns: string) {.async.} =
  rdv.unsubscribeLocally(ns)
  let msg = encode(Message(
    msgType: MessageType.Unregister,
-    unregister: Opt.some(Unregister(ns: ns))))
+    unregister: some(Unregister(ns: ns))))

  proc unsubscribePeer(rdv: RendezVous, peerId: PeerId) {.async.} =
    try:
@@ -636,17 +623,17 @@ proc new*(T: typedesc[RendezVous],
    sema: newAsyncSemaphore(SemaphoreDefaultSize)
  )
  logScope: topics = "libp2p discovery rendezvous"
-  proc handleStream(conn: Connection, proto: string) {.async.} =
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
    try:
      let
        buf = await conn.readLp(4096)
-        msg = Message.decode(buf).tryGet()
+        msg = Message.decode(buf).get()
      case msg.msgType:
-        of MessageType.Register: await rdv.register(conn, msg.register.tryGet())
+        of MessageType.Register: await rdv.register(conn, msg.register.get())
        of MessageType.RegisterResponse:
          trace "Got an unexpected Register Response", response = msg.registerResponse
-        of MessageType.Unregister: rdv.unregister(conn, msg.unregister.tryGet())
-        of MessageType.Discover: await rdv.discover(conn, msg.discover.tryGet())
+        of MessageType.Unregister: rdv.unregister(conn, msg.unregister.get())
+        of MessageType.Discover: await rdv.discover(conn, msg.discover.get())
        of MessageType.DiscoverResponse:
          trace "Got an unexpected Discover Response", response = msg.discoverResponse
    except CancelledError as exc:
@@ -670,13 +657,9 @@ proc new*(T: typedesc[RendezVous],
 proc deletesRegister(rdv: RendezVous) {.async.} =
  heartbeat "Register timeout", 1.minutes:
    let n = Moment.now()
-    var total = 0
    rdv.registered.flushIfIt(it.expiration < n)
    for data in rdv.namespaces.mvalues():
      data.keepItIf(it >= rdv.registered.offset)
-      total += data.len
-    libp2p_rendezvous_registered.set(int64(total))
-    libp2p_rendezvous_namespaces.set(int64(rdv.namespaces.len))

 method start*(rdv: RendezVous) {.async.} =
  if not rdv.registerDeletionLoop.isNil:
--- a/libp2p/protocols/secure/noise.nim
+++ b/libp2p/protocols/secure/noise.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

-import std/strformat
+import std/[oids, strformat]
 import chronos
 import chronicles
 import bearssl/[rand, hash]
@@ -133,7 +136,7 @@ proc encrypt(
    state: var CipherState,
    data: var openArray[byte],
    ad: openArray[byte]): ChaChaPolyTag
-    {.noinit, raises: [NoiseNonceMaxError].} =
+    {.noinit, raises: [Defect, NoiseNonceMaxError].} =

  var nonce: ChaChaPolyNonce
  nonce[4..<12] = toBytesLE(state.n)
@@ -145,7 +148,7 @@ proc encrypt(
    raise newException(NoiseNonceMaxError, "Noise max nonce value reached")

 proc encryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
-  {.raises: [NoiseNonceMaxError].} =
+  {.raises: [Defect, NoiseNonceMaxError].} =
  result = newSeqOfCap[byte](data.len + sizeof(ChaChaPolyTag))
  result.add(data)

@@ -157,7 +160,7 @@ proc encryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
    tag = byteutils.toHex(tag), data = result.shortLog, nonce = state.n - 1

 proc decryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
-  {.raises: [NoiseDecryptTagError, NoiseNonceMaxError].} =
+  {.raises: [Defect, NoiseDecryptTagError, NoiseNonceMaxError].} =
  var
    tagIn = data.toOpenArray(data.len - ChaChaPolyTag.len, data.high).intoChaChaPolyTag
    tagOut: ChaChaPolyTag
@@ -206,7 +209,7 @@ proc mixKeyAndHash(ss: var SymmetricState, ikm: openArray[byte]) {.used.} =
  ss.cs = CipherState(k: temp_keys[2])

 proc encryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
-  {.raises: [NoiseNonceMaxError].} =
+  {.raises: [Defect, NoiseNonceMaxError].} =
  # according to spec if key is empty leave plaintext
  if ss.cs.hasKey:
    result = ss.cs.encryptWithAd(ss.h.data, data)
@@ -215,7 +218,7 @@ proc encryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
  ss.mixHash(result)

 proc decryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
-  {.raises: [NoiseDecryptTagError, NoiseNonceMaxError].} =
+  {.raises: [Defect, NoiseDecryptTagError, NoiseNonceMaxError].} =
  # according to spec if key is empty leave plaintext
  if ss.cs.hasKey and data.len > ChaChaPolyTag.len:
    result = ss.cs.decryptWithAd(ss.h.data, data)
@@ -445,7 +448,7 @@ proc encryptFrame(
    sconn: NoiseConnection,
    cipherFrame: var openArray[byte],
    src: openArray[byte])
-    {.raises: [NoiseNonceMaxError].} =
+    {.raises: [Defect, NoiseNonceMaxError].} =
  # Frame consists of length + cipher data + tag
  doAssert src.len <= MaxPlainSize
  doAssert cipherFrame.len == 2 + src.len + sizeof(ChaChaPolyTag)
@@ -554,7 +557,8 @@ method handshake*(p: Noise, conn: Connection, initiator: bool, peerId: Opt[PeerI

    trace "Remote peer id", pid = $pid

-    peerId.withValue(targetPid):
+    if peerId.isSome():
+      let targetPid = peerId.get()
      if not targetPid.validate():
        raise newException(NoiseHandshakeError, "Failed to validate expected peerId.")

--- a/libp2p/protocols/secure/plaintext.nim
+++ b/libp2p/protocols/secure/plaintext.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,25 +7,65 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import chronos
 import secure, ../../stream/connection

-const PlainTextCodec* = "/plaintext/1.0.0"
+const PlainTextCodec* = "/plaintext/2.0.0"

 type
  PlainText* = ref object of Secure
+    localPublicKey: PublicKey

-method init(p: PlainText) {.gcsafe.} =
-  proc handle(conn: Connection, proto: string)
-    {.async.} = discard
-    ## plain text doesn't do anything
+  PlainTextError* = object of LPError

+  PlainTextConnection* = ref object of SecureConn
+
+method readMessage*(sconn: PlainTextConnection): Future[seq[byte]] {.async.} =
+  var buffer: array[32768, byte]
+  let length = await sconn.stream.readOnce(addr buffer[0], buffer.len)
+  return @(buffer[0 ..< length])
+
+method write*(sconn: PlainTextConnection, message: seq[byte]): Future[void] =
+  sconn.stream.write(message)
+
+method handshake*(p: PlainText, conn: Connection, initiator: bool, peerId: Opt[PeerId]): Future[SecureConn] {.async.} =
+  var exchange = initProtoBuffer()
+  exchange.write(2, p.localPublicKey)
+
+  await conn.writeLp(exchange.buffer)
+  let
+    remoteData = await conn.readLp(1024)
+    remotePb = initProtoBuffer(remoteData)
+  var remotePk: PublicKey
+  remotePb.getRequiredField(2, remotePk).tryGet()
+
+  let remotePeerId = PeerId.init(remotePk).valueOr:
+    raise newException(PlainTextError, "Invalid remote peer id: " & $error)
+
+  if peerId.isSome:
+    if peerId.get() != remotePeerId:
+      raise newException(PlainTextError, "Plain text handshake, peer id don't match! " & $remotePeerId & " != " & $peerId)
+
+  var res = PlainTextConnection.new(conn, conn.peerId, conn.observedAddr)
+  return res
+
+method init*(p: PlainText) {.gcsafe.} =
+  procCall Secure(p).init()
  p.codec = PlainTextCodec
-  p.handler = handle

-proc new*(T: typedesc[PlainText]): T =
-  let plainText = T()
+proc new*(
+    T: typedesc[PlainText],
+    privateKey: PrivateKey
+    ): T =
+
+  let pk = privateKey.getPublicKey()
+  .expect("Expected valid Private Key")
+
+  let plainText = T(localPublicKey: pk)
  plainText.init()
  plainText
--- a/libp2p/protocols/secure/secio.nim
+++ b/libp2p/protocols/secure/secio.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.

-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[oids, strformat]
 import bearssl/rand
@@ -259,7 +262,7 @@ proc newSecioConn(conn: Connection,
                  secrets: Secret,
                  order: int,
                  remotePubKey: PublicKey): SecioConn
-                  {.raises: [LPError].} =
+                  {.raises: [Defect, LPError].} =
  ## Create new secure stream/lpstream, using specified hash algorithm ``hash``,
  ## cipher algorithm ``cipher``, stretched keys ``secrets`` and order
  ## ``order``.
@@ -339,7 +342,8 @@ method handshake*(s: Secio, conn: Connection, initiator: bool, peerId: Opt[PeerI

  remotePeerId = PeerId.init(remotePubkey).tryGet()

-  peerId.withValue(targetPid):
+  if peerId.isSome():
+    let targetPid = peerId.get()
    if not targetPid.validate():
      raise newException(SecioError, "Failed to validate expected peerId.")

@@ -435,10 +439,14 @@ proc new*(
  T: typedesc[Secio],
  rng: ref HmacDrbgContext,
  localPrivateKey: PrivateKey): T =
+  let pkRes = localPrivateKey.getPublicKey()
+  if pkRes.isErr:
+    raise newException(Defect, "Invalid private key")
+
  let secio = Secio(
    rng: rng,
    localPrivateKey: localPrivateKey,
-    localPublicKey: localPrivateKey.getPublicKey().expect("Invalid private key"),
+    localPublicKey: pkRes.get(),
  )
  secio.init()
  secio
--- a/libp2p/protocols/secure/secure.nim
+++ b/libp2p/protocols/secure/secure.nim
@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2022 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -8,7 +8,10 @@
 # those terms.

 {.push gcsafe.}
-{.push raises: [].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}

 import std/[strformat]
 import stew/results
@@ -53,6 +56,7 @@ proc new*(T: type SecureConn,
             peerId: peerId,
             observedAddr: observedAddr,
             closeEvent: conn.closeEvent,
+             upgraded: conn.upgraded,
             timeout: timeout,
             dir: conn.dir)
  result.initStream()
@@ -135,9 +139,10 @@ method init*(s: Secure) =

 method secure*(s: Secure,
               conn: Connection,
+               initiator: bool,
               peerId: Opt[PeerId]):
               Future[Connection] {.base.} =
-  s.handleConn(conn, conn.dir == Direction.Out, peerId)
+  s.handleConn(conn, initiator, peerId)

 method readOnce*(s: SecureConn,
                 pbytes: pointer,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tanguy	a797b5e408	better test	2022-12-16 13:45:21 +01:00
Tanguy	56b284a964	fix init	2022-12-16 12:05:55 +01:00
Tanguy	1d17859eeb	Implement plaintext encryption v2	2022-12-16 11:58:40 +01:00