Add queued send bytes

Co-authored-by: diegomrsantos <diego@status.im>

.github/actions/install_nim/action.yml

@@ -0,0 +1,131 @@
+name: Install Nim
+inputs:
+  os:
+    description: "Operating system to build for"
+    required: true
+  cpu:
+    description: "CPU to build for"
+    default: "amd64"
+  nim_branch:
+    description: "Nim version"
+    default: "version-1-6"
+  shell:
+    description: "Shell to run commands in"
+    default: "bash --noprofile --norc -e -o pipefail"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install build dependencies (Linux i386)
+      shell: ${{ inputs.shell }}
+      if: inputs.os == 'Linux' && inputs.cpu == 'i386'
+      run: |
+        sudo dpkg --add-architecture i386
+        sudo apt-get update -qq
+        sudo DEBIAN_FRONTEND='noninteractive' apt-get install \
+          --no-install-recommends -yq gcc-multilib g++-multilib \
+          libssl-dev:i386
+        mkdir -p external/bin
+        cat << EOF > external/bin/gcc
+        #!/bin/bash
+        exec $(which gcc) -m32 "\$@"
+        EOF
+        cat << EOF > external/bin/g++
+        #!/bin/bash
+        exec $(which g++) -m32 "\$@"
+        EOF
+        chmod 755 external/bin/gcc external/bin/g++
+        echo '${{ github.workspace }}/external/bin' >> $GITHUB_PATH
+
+    - name: MSYS2 (Windows i386)
+      if: inputs.os == 'Windows' && inputs.cpu == 'i386'
+      uses: msys2/setup-msys2@v2
+      with:
+        path-type: inherit
+        msystem: MINGW32
+        install: >-
+          base-devel
+          git
+          mingw-w64-i686-toolchain
+
+    - name: MSYS2 (Windows amd64)
+      if: inputs.os == 'Windows' && inputs.cpu == 'amd64'
+      uses: msys2/setup-msys2@v2
+      with:
+        path-type: inherit
+        install: >-
+          base-devel
+          git
+          mingw-w64-x86_64-toolchain
+
+    - name: Restore Nim DLLs dependencies (Windows) from cache
+      if: inputs.os == 'Windows'
+      id: windows-dlls-cache
+      uses: actions/cache@v3
+      with:
+        path: external/dlls
+        key: 'dlls'
+
+    - name: Install DLL dependencies (Windows)
+      shell: ${{ inputs.shell }}
+      if: >
+        steps.windows-dlls-cache.outputs.cache-hit != 'true' &&
+        inputs.os == 'Windows'
+      run: |
+        mkdir external
+        curl -L "https://nim-lang.org/download/windeps.zip" -o external/windeps.zip
+        7z x external/windeps.zip -oexternal/dlls
+
+    - name: Path to cached dependencies (Windows)
+      shell: ${{ inputs.shell }}
+      if: >
+        inputs.os == 'Windows'
+      run: |
+        echo '${{ github.workspace }}'"/external/dlls" >> $GITHUB_PATH
+
+    - name: Derive environment variables
+      shell: ${{ inputs.shell }}
+      run: |
+        if [[ '${{ inputs.cpu }}' == 'amd64' ]]; then
+          PLATFORM=x64
+        else
+          PLATFORM=x86
+        fi
+        echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
+
+        ncpu=
+        MAKE_CMD="make"
+        case '${{ inputs.os }}' in
+        'Linux')
+          ncpu=$(nproc)
+          ;;
+        'macOS')
+          ncpu=$(sysctl -n hw.ncpu)
+          ;;
+        'Windows')
+          ncpu=$NUMBER_OF_PROCESSORS
+          MAKE_CMD="mingw32-make"
+          ;;
+        esac
+        [[ -z "$ncpu" || $ncpu -le 0 ]] && ncpu=1
+        echo "ncpu=$ncpu" >> $GITHUB_ENV
+        echo "MAKE_CMD=${MAKE_CMD}" >> $GITHUB_ENV
+        echo '${{ github.workspace }}/nim/bin' >> $GITHUB_PATH
+
+    - name: Restore Nim from cache
+      id: nim-cache
+      uses: actions/cache@v3
+      with:
+        path: '${{ github.workspace }}/nim'
+        key: ${{ inputs.os }}-${{ inputs.cpu }}-nim-${{ inputs.nim_branch }}-cache-${{ env.cache_nonce }}
+
+    - name: Build Nim and Nimble
+      shell: ${{ inputs.shell }}
+      if: ${{ steps.nim-cache.outputs.cache-hit != 'true' }}
+      run: |
+        # We don't want partial matches of the cache restored
+        rm -rf nim
+        curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
+        env MAKE="${MAKE_CMD} -j${ncpu}" ARCH_OVERRIDE=${PLATFORM} NIM_COMMIT=${{ inputs.nim_branch }} \
+          QUICK_AND_DIRTY_COMPILER=1 QUICK_AND_DIRTY_NIMBLE=1 CC=gcc \
+          bash build_nim.sh nim csources dist/nimble NimBinaries

.github/workflows/bumper.yml

@@ -0,0 +1,43 @@
+name: Bumper
+on:
+  push:
+    branches:
+      - unstable
+      - bumper
+  workflow_dispatch:
+
+jobs:
+  bumpProjects:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [
+          { repo: status-im/nimbus-eth2, branch: unstable },
+          { repo: status-im/nwaku, branch: master },
+          { repo: status-im/nim-codex, branch: main }
+        ]
+    steps:
+      - name: Clone repo
+        uses: actions/checkout@v2
+        with:
+          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/vendor/nim-libp2p
+          git checkout $GITHUB_SHA
+
+      - name: Commit this bump
+        run: |
+          cd nbc
+          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
+          git config --global user.name = "${{ github.actor }}"
+          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##*/}

.github/workflows/ci.yml

@@ -7,6 +7,10 @@ on:
   pull_request:
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     timeout-minutes: 90
@@ -24,7 +28,7 @@ jobs:
             cpu: amd64
           #- os: windows
             #cpu: i386
-        branch: [version-1-2, devel]
+        branch: [version-1-2, version-1-6]
         include:
           - target:
               os: linux
@@ -32,7 +36,7 @@ jobs:
             shell: bash
           - target:
               os: macos
-            builder: macos-10.15
+            builder: macos-12
             shell: bash
           - target:
               os: windows
@@ -45,111 +49,20 @@ jobs:
 
     name: '${{ matrix.target.os }}-${{ matrix.target.cpu }} (Nim ${{ matrix.branch }})'
     runs-on: ${{ matrix.builder }}
-    continue-on-error: ${{ matrix.branch == 'version-1-6' || matrix.branch == 'devel' }}
+    continue-on-error: ${{ matrix.branch == 'devel' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
         with:
           submodules: true
 
-      - name: Install build dependencies (Linux i386)
-        if: runner.os == 'Linux' && matrix.target.cpu == 'i386'
-        run: |
-          sudo dpkg --add-architecture i386
-          sudo apt-get update -qq
-          sudo DEBIAN_FRONTEND='noninteractive' apt-get install \
-            --no-install-recommends -yq gcc-multilib g++-multilib \
-            libssl-dev:i386
-          mkdir -p external/bin
-          cat << EOF > external/bin/gcc
-          #!/bin/bash
-          exec $(which gcc) -m32 "\$@"
-          EOF
-          cat << EOF > external/bin/g++
-          #!/bin/bash
-          exec $(which g++) -m32 "\$@"
-          EOF
-          chmod 755 external/bin/gcc external/bin/g++
-          echo '${{ github.workspace }}/external/bin' >> $GITHUB_PATH
-
-      - name: MSYS2 (Windows i386)
-        if: runner.os == 'Windows' && matrix.target.cpu == 'i386'
-        uses: msys2/setup-msys2@v2
+      - name: Setup Nim
+        uses: "./.github/actions/install_nim"
         with:
-          path-type: inherit
-          msystem: MINGW32
-          install: >-
-            base-devel
-            git
-            mingw-w64-i686-toolchain
-
-      - name: MSYS2 (Windows amd64)
-        if: runner.os == 'Windows' && matrix.target.cpu == 'amd64'
-        uses: msys2/setup-msys2@v2
-        with:
-          path-type: inherit
-          install: >-
-            base-devel
-            git
-            mingw-w64-x86_64-toolchain
-
-      - name: Restore Nim DLLs dependencies (Windows) from cache
-        if: runner.os == 'Windows'
-        id: windows-dlls-cache
-        uses: actions/cache@v2
-        with:
-          path: external/dlls
-          key: 'dlls'
-
-      - name: Install DLL dependencies (Windows)
-        if: >
-          steps.windows-dlls-cache.outputs.cache-hit != 'true' &&
-          runner.os == 'Windows'
-        run: |
-          mkdir external
-          curl -L "https://nim-lang.org/download/windeps.zip" -o external/windeps.zip
-          7z x external/windeps.zip -oexternal/dlls
-
-      - name: Path to cached dependencies (Windows)
-        if: >
-          runner.os == 'Windows'
-        run: |
-          echo '${{ github.workspace }}'"/external/dlls" >> $GITHUB_PATH
-
-      - name: Derive environment variables
-        run: |
-          if [[ '${{ matrix.target.cpu }}' == 'amd64' ]]; then
-            PLATFORM=x64
-          else
-            PLATFORM=x86
-          fi
-          echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
-
-          ncpu=
-          MAKE_CMD="make"
-          case '${{ runner.os }}' in
-          'Linux')
-            ncpu=$(nproc)
-            ;;
-          'macOS')
-            ncpu=$(sysctl -n hw.ncpu)
-            ;;
-          'Windows')
-            ncpu=$NUMBER_OF_PROCESSORS
-            MAKE_CMD="mingw32-make"
-            ;;
-          esac
-          [[ -z "$ncpu" || $ncpu -le 0 ]] && ncpu=1
-          echo "ncpu=$ncpu" >> $GITHUB_ENV
-          echo "MAKE_CMD=${MAKE_CMD}" >> $GITHUB_ENV
-
-      - name: Build Nim and Nimble
-        run: |
-          curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
-          env MAKE="${MAKE_CMD} -j${ncpu}" ARCH_OVERRIDE=${PLATFORM} NIM_COMMIT=${{ matrix.branch }} \
-            QUICK_AND_DIRTY_COMPILER=1 QUICK_AND_DIRTY_NIMBLE=1 CC=gcc \
-            bash build_nim.sh nim csources dist/nimble NimBinaries
-          echo '${{ github.workspace }}/nim/bin' >> $GITHUB_PATH
+          os: ${{ matrix.target.os }}
+          cpu: ${{ matrix.target.cpu }}
+          shell: ${{ matrix.shell }}
+          nim_branch: ${{ matrix.branch }}
 
       - name: Setup Go
         uses: actions/setup-go@v2
@@ -160,96 +73,20 @@ jobs:
         run: |
           V=1 bash scripts/build_p2pd.sh p2pdCache 124530a3
 
+      - name: Restore deps from cache
+        id: deps-cache
+        uses: actions/cache@v3
+        with:
+          path: nimbledeps
+          key: nimbledeps-${{ hashFiles('.pinned') }}
+
+      - name: Install deps
+        if: ${{ steps.deps-cache.outputs.cache-hit != 'true' }}
+        run: |
+          nimble install_pinned
+
       - name: Run tests
         run: |
-          if [[ "${{ matrix.target.os }}" == "windows" ]]; then
-            # https://github.com/status-im/nimbus-eth2/issues/3121
-            export NIMFLAGS="-d:nimRawSetjmp"
-          fi
           nim --version
           nimble --version
-          nimble install_pinned
           nimble test
-
-  bumpNBC-stable:
-    if: github.ref == 'refs/heads/master'
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: status-im/github-app-token@v1
-        name: Generate token
-        id: generate-token
-        with:
-          app_id: ${{ secrets.BUMP_BOT_APP_ID }}
-          private_key: ${{ secrets.BUMP_BOT_APP_PRIVATE_KEY }}
-
-      - name: Clone NBC
-        uses: actions/checkout@v2
-        with:
-          repository: status-im/nimbus-eth2
-          ref: unstable
-          path: nbc
-          submodules: true
-          fetch-depth: 0
-
-      - name: Checkout this ref
-        run: |
-          cd nbc/vendor/nim-libp2p
-          git checkout $GITHUB_SHA
-
-      - name: Commit this bump
-        run: |
-          cd nbc
-          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-          git config --global user.name = "${{ github.actor }}"
-          git commit -a -m "auto-bump nim-libp2p"
-
-      - name: Make PR
-        uses: peter-evans/create-pull-request@v3.5.0
-        with:
-          branch: nim-libp2p-auto-bump
-          path: nbc
-          token: ${{ steps.generate-token.outputs.token }}
-          title: nim-libp2p auto bump
-
-  bumpNBC-unstable:
-    if: github.ref == 'refs/heads/unstable'
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: status-im/github-app-token@v1
-        name: Generate token
-        id: generate-token
-        with:
-          app_id: ${{ secrets.BUMP_BOT_APP_ID }}
-          private_key: ${{ secrets.BUMP_BOT_APP_PRIVATE_KEY }}
-
-      - name: Clone NBC
-        uses: actions/checkout@v2
-        with:
-          repository: status-im/nimbus-eth2
-          ref: unstable
-          path: nbc
-          submodules: true
-          fetch-depth: 0
-
-      - name: Checkout this ref
-        run: |
-          cd nbc/vendor/nim-libp2p
-          git checkout $GITHUB_SHA
-
-      - name: Commit this bump
-        run: |
-          cd nbc
-          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-          git config --global user.name = "${{ github.actor }}"
-          git commit -a -m "auto-bump nim-libp2p"
-
-      - name: Make PR
-        uses: peter-evans/create-pull-request@v3.5.0
-        with:
-          branch: nim-libp2p-auto-bump-unstable
-          path: nbc
-          token: ${{ steps.generate-token.outputs.token }}
-          title: nim-libp2p unstable auto bump
-          draft: true

.github/workflows/codecov.yml

@@ -5,136 +5,61 @@ on:
   push:
     branches:
       - master
+      - unstable
   pull_request:
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  GossipSub:
+  Coverage:
     runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        nim-options: [
-          "",
-          "-d:libp2p_pubsub_anonymize=true -d:libp2p_pubsub_sign=false -d:libp2p_pubsub_verify=false",
-          "-d:libp2p_pubsub_sign=true -d:libp2p_pubsub_verify=true"
-        ]
-        test-program: [
-          "tests/pubsub/testpubsub",
-          "tests/pubsub/testfloodsub",
-          "tests/pubsub/testgossipinternal"
-        ]
+    env:
+      CICOV: YES
     steps:
       - uses: actions/checkout@v2
         with:
           fetch-depth: 0
+
+      - name: Setup Nim
+        uses: "./.github/actions/install_nim"
+        with:
+          os: linux
+          cpu: amd64
+          shell: bash
+
+      - name: Restore deps from cache
+        id: deps-cache
+        uses: actions/cache@v3
+        with:
+          path: nimbledeps
+          key: nimbledeps-${{ hashFiles('.pinned') }}
+
+      - name: Install deps
+        if: ${{ steps.deps-cache.outputs.cache-hit != 'true' }}
+        run: |
+          nimble install_pinned
+
       - name: Run
         run: |
           sudo apt-get update
           sudo apt-get install -y lcov build-essential git curl
           mkdir coverage
-          curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
-          env MAKE="make -j${NPROC}" bash build_nim.sh Nim csources dist/nimble NimBinaries
-          export PATH="$PATH:$PWD/Nim/bin"
-          nimble install_pinned
-          export NIM_OPTIONS="--opt:speed -d:debug --verbosity:0 --hints:off --lineDir:on -d:chronicles_log_level=INFO --warning[CaseTransition]:off --warning[ObservableStores]:off --warning[LockLevel]:off --nimcache:nimcache --passC:-fprofile-arcs --passC:-ftest-coverage --passL:-fprofile-arcs --passL:-ftest-coverage ${{ matrix.nim-options }}"
-          nim c $NIM_OPTIONS -r ${{ matrix.test-program }}
-          cd nimcache; rm *.c; cd ..
+          export NIMFLAGS="--lineDir:on --passC:-fprofile-arcs --passC:-ftest-coverage --passL:-fprofile-arcs --passL:-ftest-coverage"
+          nimble testnative
+          nimble testpubsub
+          nimble testfilter
+          find nimcache -name *.c -delete
           lcov --capture --directory nimcache --output-file coverage/coverage.info
           shopt -s globstar
           ls `pwd`/libp2p/{*,**/*}.nim
           lcov --extract coverage/coverage.info  `pwd`/libp2p/{*,**/*}.nim --output-file coverage/coverage.f.info
-          export COV_UUID=`cksum <<< "${{ matrix.test-program }} $NIM_OPTIONS" | cut -f 1 -d ' '`
-          genhtml coverage/coverage.f.info --output-directory coverage/$COV_UUID-output
-          echo ${{ matrix.test-program }} > coverage/$COV_UUID-nim_options.txt
-          echo $NIM_OPTIONS >> coverage/$COV_UUID-nim_options.txt
+          genhtml coverage/coverage.f.info --output-directory coverage/output
           bash <(curl -s https://codecov.io/bash) -f coverage/coverage.f.info || echo "Codecov did not collect coverage reports"
-      - uses: actions/upload-artifact@master
-        with:
-          name: coverage
-          path: coverage
-
-  Tests:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        nim-options: [
-          ""
-        ]
-        test-program: [
-          "tests/testnative",
-        ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - name: Run
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y lcov build-essential git curl
-          mkdir coverage
-          curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
-          env MAKE="make -j${NPROC}" bash build_nim.sh Nim csources dist/nimble NimBinaries
-          export PATH="$PATH:$PWD/Nim/bin"
-          nimble install_pinned
-          export NIM_OPTIONS="--opt:speed -d:debug --verbosity:0 --hints:off --lineDir:on -d:chronicles_log_level=INFO --warning[CaseTransition]:off --warning[ObservableStores]:off --warning[LockLevel]:off --nimcache:nimcache --passC:-fprofile-arcs --passC:-ftest-coverage --passL:-fprofile-arcs --passL:-ftest-coverage ${{ matrix.nim-options }} --clearNimblePath --NimblePath:nimbledeps/pkgs"
-          nim c $NIM_OPTIONS -r ${{ matrix.test-program }}
-          cd nimcache; rm *.c; cd ..
-          lcov --capture --directory nimcache --output-file coverage/coverage.info
-          shopt -s globstar
-          ls `pwd`/libp2p/{*,**/*}.nim
-          lcov --extract coverage/coverage.info  `pwd`/libp2p/{*,**/*}.nim --output-file coverage/coverage.f.info
-          export COV_UUID=`cksum <<< "${{ matrix.test-program }} $NIM_OPTIONS" | cut -f 1 -d ' '`
-          genhtml coverage/coverage.f.info --output-directory coverage/$COV_UUID-output
-          echo ${{ matrix.test-program }} > coverage/$COV_UUID-nim_options.txt
-          echo $NIM_OPTIONS >> coverage/$COV_UUID-nim_options.txt
-          bash <(curl -s https://codecov.io/bash) -f coverage/coverage.f.info || echo "Codecov did not collect coverage reports"
-      - uses: actions/upload-artifact@master
-        with:
-          name: coverage
-          path: coverage
-
-  Filter:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        nim-options: [
-          "",
-          "-d:libp2p_pki_schemes=secp256k1",
-          "-d:libp2p_pki_schemes=secp256k1;ed25519",
-          "-d:libp2p_pki_schemes=secp256k1;ed25519;ecnist",
-        ]
-        test-program: [
-          "tests/testpkifilter",
-        ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - name: Run
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y lcov build-essential git curl
-          mkdir coverage
-          curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
-          env MAKE="make -j${NPROC}" bash build_nim.sh Nim csources dist/nimble NimBinaries
-          export PATH="$PATH:$PWD/Nim/bin"
-          nimble install_pinned
-          export NIM_OPTIONS="--opt:speed -d:debug --verbosity:0 --hints:off --lineDir:on -d:chronicles_log_level=INFO --warning[CaseTransition]:off --warning[ObservableStores]:off --warning[LockLevel]:off --nimcache:nimcache --passC:-fprofile-arcs --passC:-ftest-coverage --passL:-fprofile-arcs --passL:-ftest-coverage ${{ matrix.nim-options }}"
-          nim c $NIM_OPTIONS -r ${{ matrix.test-program }}
-          cd nimcache; rm *.c; cd ..
-          lcov --capture --directory nimcache --output-file coverage/coverage.info
-          shopt -s globstar
-          ls `pwd`/libp2p/{*,**/*}.nim
-          lcov --extract coverage/coverage.info  `pwd`/libp2p/{*,**/*}.nim --output-file coverage/coverage.f.info
-          export COV_UUID=`cksum <<< "${{ matrix.test-program }} $NIM_OPTIONS" | cut -f 1 -d ' '`
-          genhtml coverage/coverage.f.info --output-directory coverage/$COV_UUID-output
-          echo ${{ matrix.test-program }} > coverage/$COV_UUID-nim_options.txt
-          echo $NIM_OPTIONS >> coverage/$COV_UUID-nim_options.txt
-          bash <(curl -s https://codecov.io/bash) -f coverage/coverage.f.info || echo "Codecov did not collect coverage reports"
-      - uses: actions/upload-artifact@master
-        with:
-          name: coverage
-          path: coverage
-
-
 
+          #- uses: actions/upload-artifact@master
+          #  with:
+          #    name: coverage
+          #    path: coverage

.github/workflows/doc.yml

@@ -61,3 +61,43 @@ jobs:
           git config --global user.name = "${{ github.actor }}"
           git commit -a -m "update docs for ${GITHUB_REF##*/}"
           git push origin gh-pages
+
+  update_site:
+    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/docs'
+    name: 'Rebuild website'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+
+      - uses: jiro4989/setup-nim-action@v1
+        with:
+          nim-version: 'stable'
+
+      - name: Generate website
+        run: pip install mkdocs-material && nimble website
+
+      - name: Clone the gh-pages branch
+        uses: actions/checkout@v2
+        with:
+          repository: status-im/nim-libp2p
+          ref: gh-pages
+          path: subdoc
+          fetch-depth: 0
+
+      - name: Commit & push
+        run: |
+          cd subdoc
+
+          rm -rf docs
+          mv ../site docs
+
+          git add .
+          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
+          git config --global user.name = "${{ github.actor }}"
+          git commit -a -m "update website"
+          git push origin gh-pages

.github/workflows/multi_nim.yml

@@ -5,7 +5,13 @@ on:
   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
@@ -21,7 +27,7 @@ jobs:
             cpu: amd64
           #- os: windows
             #cpu: i386
-        branch: [version-1-2, version-1-4, version-1-6, devel]
+        branch: [version-1-2, version-1-6, devel]
         include:
           - target:
               os: linux
@@ -29,7 +35,7 @@ jobs:
             shell: bash
           - target:
               os: macos
-            builder: macos-10.15
+            builder: macos-12
             shell: bash
           - target:
               os: windows
@@ -42,112 +48,18 @@ jobs:
 
     name: '${{ matrix.target.os }}-${{ matrix.target.cpu }} (Nim ${{ matrix.branch }})'
     runs-on: ${{ matrix.builder }}
-    continue-on-error: ${{ matrix.branch == 'version-1-6' || matrix.branch == 'devel' }}
+    continue-on-error: ${{ matrix.branch == 'devel' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v2
+
+      - name: Setup Nim
+        uses: "./.github/actions/install_nim"
         with:
-          ref: unstable
-          submodules: true
-
-      - name: Install build dependencies (Linux i386)
-        if: runner.os == 'Linux' && matrix.target.cpu == 'i386'
-        run: |
-          sudo dpkg --add-architecture i386
-          sudo apt-get update -qq
-          sudo DEBIAN_FRONTEND='noninteractive' apt-get install \
-            --no-install-recommends -yq gcc-multilib g++-multilib \
-            libssl-dev:i386
-          mkdir -p external/bin
-          cat << EOF > external/bin/gcc
-          #!/bin/bash
-          exec $(which gcc) -m32 "\$@"
-          EOF
-          cat << EOF > external/bin/g++
-          #!/bin/bash
-          exec $(which g++) -m32 "\$@"
-          EOF
-          chmod 755 external/bin/gcc external/bin/g++
-          echo '${{ github.workspace }}/external/bin' >> $GITHUB_PATH
-
-      - name: MSYS2 (Windows i386)
-        if: runner.os == 'Windows' && matrix.target.cpu == 'i386'
-        uses: msys2/setup-msys2@v2
-        with:
-          path-type: inherit
-          msystem: MINGW32
-          install: >-
-            base-devel
-            git
-            mingw-w64-i686-toolchain
-
-      - name: MSYS2 (Windows amd64)
-        if: runner.os == 'Windows' && matrix.target.cpu == 'amd64'
-        uses: msys2/setup-msys2@v2
-        with:
-          path-type: inherit
-          install: >-
-            base-devel
-            git
-            mingw-w64-x86_64-toolchain
-
-      - name: Restore Nim DLLs dependencies (Windows) from cache
-        if: runner.os == 'Windows'
-        id: windows-dlls-cache
-        uses: actions/cache@v2
-        with:
-          path: external/dlls
-          key: 'dlls'
-
-      - name: Install DLL dependencies (Windows)
-        if: >
-          steps.windows-dlls-cache.outputs.cache-hit != 'true' &&
-          runner.os == 'Windows'
-        run: |
-          mkdir external
-          curl -L "https://nim-lang.org/download/windeps.zip" -o external/windeps.zip
-          7z x external/windeps.zip -oexternal/dlls
-
-      - name: Path to cached dependencies (Windows)
-        if: >
-          runner.os == 'Windows'
-        run: |
-          echo '${{ github.workspace }}'"/external/dlls" >> $GITHUB_PATH
-
-      - name: Derive environment variables
-        run: |
-          if [[ '${{ matrix.target.cpu }}' == 'amd64' ]]; then
-            PLATFORM=x64
-          else
-            PLATFORM=x86
-          fi
-          echo "PLATFORM=$PLATFORM" >> $GITHUB_ENV
-
-          ncpu=
-          MAKE_CMD="make"
-          case '${{ runner.os }}' in
-          'Linux')
-            ncpu=$(nproc)
-            ;;
-          'macOS')
-            ncpu=$(sysctl -n hw.ncpu)
-            ;;
-          'Windows')
-            ncpu=$NUMBER_OF_PROCESSORS
-            MAKE_CMD="mingw32-make"
-            ;;
-          esac
-          [[ -z "$ncpu" || $ncpu -le 0 ]] && ncpu=1
-          echo "ncpu=$ncpu" >> $GITHUB_ENV
-          echo "MAKE_CMD=${MAKE_CMD}" >> $GITHUB_ENV
-
-      - name: Build Nim and Nimble
-        run: |
-          curl -O -L -s -S https://raw.githubusercontent.com/status-im/nimbus-build-system/master/scripts/build_nim.sh
-          env MAKE="${MAKE_CMD} -j${ncpu}" ARCH_OVERRIDE=${PLATFORM} NIM_COMMIT=${{ matrix.branch }} \
-            QUICK_AND_DIRTY_COMPILER=1 QUICK_AND_DIRTY_NIMBLE=1 CC=gcc \
-            bash build_nim.sh nim csources dist/nimble NimBinaries
-          echo '${{ github.workspace }}/nim/bin' >> $GITHUB_PATH
+          os: ${{ matrix.target.os }}
+          shell: ${{ matrix.shell }}
+          nim_branch: ${{ matrix.branch }}
+          cpu: ${{ matrix.target.cpu }}
 
       - name: Setup Go
         uses: actions/setup-go@v2
@@ -160,16 +72,11 @@ jobs:
 
       - name: Run tests
         run: |
-          if [[ "${{ matrix.target.os }}" == "windows" ]]; then
-            # https://github.com/status-im/nimbus-eth2/issues/3121
-            export NIMFLAGS="-d:nimRawSetjmp"
-          fi
           nim --version
           nimble --version
           nimble install -y --depsOnly
-          nimble test
-          if [[ "${{ matrix.branch }}" == "version-1-6" || "${{ matrix.branch }}" == "devel" ]]; then
+          NIMFLAGS="${NIMFLAGS} --gc:refc" nimble test
+          if [[ "${{ matrix.branch }}" == "devel" ]]; then
             echo -e "\nTesting with '--gc:orc':\n"
-            export NIMFLAGS="${NIMFLAGS} --gc:orc"
-            nimble test
+            NIMFLAGS="${NIMFLAGS} --gc:orc" nimble test
           fi

.gitignore

@@ -13,5 +13,6 @@ build/
 .vscode/
 .DS_Store
 tests/pubsub/testgossipsub
+examples/*.md
 nimble.develop
 nimble.paths

.pinned

@@ -1,17 +1,16 @@
-asynctest;https://github.com/markspanbroek/asynctest@#5347c59b4b057443a014722aa40800cd8bb95c69
-bearssl;https://github.com/status-im/nim-bearssl@#c4aec8b664709356060b71b7e495be62ca446a65
-chronicles;https://github.com/status-im/nim-chronicles@#2a2681b60289aaf7895b7056f22616081eb1a882
-chronos;https://github.com/status-im/nim-chronos@#875d7d8e6ef0803ae1c331dbf76b1981b0caeb15
-dnsclient;https://github.com/ba0f3/dnsclient.nim@#fbb76f8af8a33ab818184a7d4406d9fee20993be
-faststreams;https://github.com/status-im/nim-faststreams@#49e2c52eb5dda46b1c9c10d079abe7bffe6cea89
-httputils;https://github.com/status-im/nim-http-utils@#f83fbce4d6ec7927b75be3f85e4fa905fcb69788
-json_serialization;https://github.com/status-im/nim-json-serialization@#3509706517f3562cbcbe9d94988eccdd80474ab8
-metrics;https://github.com/status-im/nim-metrics@#11edec862f96e42374bc2d584c84cc88d5d1f95f
-nimcrypto;https://github.com/cheatfate/nimcrypto@#a5742a9a214ac33f91615f3862c7b099aec43b00
-secp256k1;https://github.com/status-im/nim-secp256k1@#e092373a5cbe1fa25abfc62e0f2a5f138dc3fb13
-serialization;https://github.com/status-im/nim-serialization@#9631fbd1c81c8b25ff8740df440ca7ba87fa6131
-stew;https://github.com/status-im/nim-stew@#cdb1f213d073fd2ecbdaf35a866417657da9294c
-testutils;https://github.com/status-im/nim-testutils@#aa6e5216f4b4ab5aa971cdcdd70e1ec1203cedf2
-unittest2;https://github.com/status-im/nim-unittest2@#4e2893eacb916c7678fdc4935ff7420f13bf3a9c
-websock;https://github.com/status-im/nim-websock@#8927db93f6ca96abaacfea39f8ca50ce9d41bcdb
-zlib;https://github.com/status-im/nim-zlib@#74cdeb54b21bededb5a515d36f608bc1850555a2
+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@#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@#da8398c45cafd5bd7772da1fc96e3924a18d3823
+websock;https://github.com/status-im/nim-websock@#691f069b209d372b1240d5ae1f57fb7bbafeaba7
+zlib;https://github.com/status-im/nim-zlib@#6a6670afba6b97b29b920340e2641978c05ab4d8

README.md

@@ -2,12 +2,12 @@
   <a href="https://libp2p.io"><img width="250" src="./.assets/full-logo.svg?raw=true" alt="nim-libp2p logo" /></a>
 </h1>
 
-<h3 align="center">The Nim implementation of the libp2p Networking Stack.</h3>
+<h3 align="center">The <a href="https://nim-lang.org/">Nim</a> implementation of the <a href="https://libp2p.io/">libp2p</a> Networking Stack.</h3>
 
 <p align="center">
 <a href="https://github.com/status-im/nim-libp2p/actions"><img src="https://github.com/status-im/nim-libp2p/actions/workflows/ci.yml/badge.svg" /></a>
 <a href="https://codecov.io/gh/status-im/nim-libp2p"><img src="https://codecov.io/gh/status-im/nim-libp2p/branch/master/graph/badge.svg?token=UR5JRQ249W"/></a>
-    
+
 </p>
 
 <p align="center">
@@ -16,30 +16,26 @@
 <img src="https://img.shields.io/badge/nim-%3E%3D1.2.0-orange.svg?style=flat-square" />
 </p>
 
-## Introduction
-
-An implementation of [libp2p](https://libp2p.io/) in [Nim](https://nim-lang.org/).
-
 # Table of Contents
 - [Background](#background)
 - [Install](#install)
 - [Getting Started](#getting-started)
 - [Modules](#modules)
 - [Users](#users)
+- [Stability](#stability)
 - [Development](#development)
   - [Contribute](#contribute)
-  - [Core Developers](#core-developers)
+  - [Contributors](#contributors)
+  - [Core Maintainers](#core-maintainers)
 - [License](#license)
 
 ## Background
-libp2p is a networking stack and library modularized out of [The IPFS Project](https://github.com/ipfs/ipfs), and bundled separately for other tools to use.
+libp2p is a [Peer-to-Peer](https://en.wikipedia.org/wiki/Peer-to-peer) networking stack, with [implementations](https://github.com/libp2p/libp2p#implementations) in multiple languages derived from the same [specifications.](https://github.com/libp2p/specs)
 
-libp2p is the product of a long and arduous quest of understanding; a deep dive into the internet's network stack and the peer-to-peer protocols from the past. Building large scale peer-to-peer systems has been complex and difficult in the last 15 years and libp2p is a way to fix that. It is a "network stack", a suite of networking protocols that cleanly separates concerns and enables sophisticated applications to only use the protocols they absolutely need, without giving up interoperability and upgradeability.
+Building large scale peer-to-peer systems has been complex and difficult in the last 15 years and libp2p is a way to fix that. It's striving to be a modular stack, with sane and secure defaults, useful protocols, while remain open and extensible.
+This implementation in native Nim, relying on [chronos](https://github.com/status-im/nim-chronos) for async. It's used in production by a few [projects](#users)
 
-libp2p grew out of IPFS, but it is built so that lots of people can use it, for lots of different projects.
-
-- Learn more about libp2p at [**libp2p.io**](https://libp2p.io) and follow our evolving documentation efforts at [**docs.libp2p.io**](https://docs.libp2p.io).
-- [Here](https://github.com/libp2p/libp2p#description) is an overview of libp2p and its implementations in other programming languages.
+Learn more about libp2p at [**libp2p.io**](https://libp2p.io) and follow libp2p's documentation [**docs.libp2p.io**](https://docs.libp2p.io).
 
 ## Install
 **Prerequisite**
@@ -49,9 +45,7 @@ nimble install libp2p
 ```
 
 ## Getting Started
-You'll find some tutorials [here](examples/tutorial_1_connect.md), or some examples:
-- [hello world (ping)](examples/helloworld.nim)
-- [direct chat](examples/directchat.nim)
+You'll find the nim-libp2p documentation [here](https://status-im.github.io/nim-libp2p/docs/).
 
 **Go Daemon:**
 Please find the installation and usage intructions in [daemonapi.md](examples/go-daemon/daemonapi.md).
@@ -65,25 +59,28 @@ List of packages modules implemented in nim-libp2p:
 | **Libp2p**                                                 |                                                                                                                  |
 | [libp2p](libp2p/switch.nim)                                | The core of the project                                                                                          |
 | [connmanager](libp2p/connmanager.nim)                      | Connection manager                                                                                               |
-| [identify / push identify](libp2p/protocols/identify.nim)  | [Identify](https://docs.libp2p.io/concepts/protocols/#identify) protocol                                         |
-| [ping](libp2p/protocols/ping.nim)                          | [Ping](https://docs.libp2p.io/concepts/protocols/#ping) protocol                                                 |
+| [identify / push identify](libp2p/protocols/identify.nim)  | [Identify](https://docs.libp2p.io/concepts/fundamentals/protocols/#identify) protocol                            |
+| [ping](libp2p/protocols/ping.nim)                          | [Ping](https://docs.libp2p.io/concepts/fundamentals/protocols/#ping) protocol                                    |
 | [libp2p-daemon-client](libp2p/daemon/daemonapi.nim)        | [go-daemon](https://github.com/libp2p/go-libp2p-daemon) nim wrapper                                              |
 | [interop-libp2p](tests/testinterop.nim)                    | Interop tests                                                                                                    |
 | **Transports**                                             |                                                                                                                  |
 | [libp2p-tcp](libp2p/transports/tcptransport.nim)           | TCP transport                                                                                                    |
 | [libp2p-ws](libp2p/transports/wstransport.nim)             | WebSocket & WebSocket Secure transport                                                                           |
+| [libp2p-tor](libp2p/transports/tortransport.nim)           | Tor Transport                                                                                                    |
 | **Secure Channels**                                        |                                                                                                                  |
-| [libp2p-secio](libp2p/protocols/secure/secio.nim)          | [Secio](https://docs.libp2p.io/concepts/protocols/#secio) secure channel                                         |
-| [libp2p-noise](libp2p/protocols/secure/noise.nim)          | [Noise](https://github.com/libp2p/specs/tree/master/noise) secure channel                                        |
-| [libp2p-plaintext](libp2p/protocols/secure/plaintext.nim)  | [Plain Text](https://github.com/libp2p/specs/tree/master/plaintext) for development purposes                     |
+| [libp2p-secio](libp2p/protocols/secure/secio.nim)          | Secio secure channel                                                                                             |
+| [libp2p-noise](libp2p/protocols/secure/noise.nim)          | [Noise](https://docs.libp2p.io/concepts/secure-comm/noise/) secure channel                                       |
+| [libp2p-plaintext](libp2p/protocols/secure/plaintext.nim)  | Plain Text for development purposes                                                                              |
 | **Stream Multiplexers**                                    |                                                                                                                  |
 | [libp2p-mplex](libp2p/muxers/mplex/mplex.nim)              | [MPlex](https://github.com/libp2p/specs/tree/master/mplex) multiplexer                                           |
+| [libp2p-yamux](libp2p/muxers/yamux/yamux.nim)              | [Yamux](https://docs.libp2p.io/concepts/multiplex/yamux/) multiplexer                                            |
 | **Data Types**                                             |                                                                                                                  |
-| [peer-id](libp2p/peerid.nim)                               | [Cryptographic identifiers](https://docs.libp2p.io/concepts/peer-id/)                                            |
-| [peer-store](libp2p/peerstore.nim)                         | ["Phone book" of known peers](https://docs.libp2p.io/concepts/peer-id/#peerinfo)                                 |
+| [peer-id](libp2p/peerid.nim)                               | [Cryptographic identifiers](https://docs.libp2p.io/concepts/fundamentals/peers/#peer-id)                         |
+| [peer-store](libp2p/peerstore.nim)                         | ["Address book" of known peers](https://docs.libp2p.io/concepts/fundamentals/peers/#peer-store)                  |
 | [multiaddress](libp2p/multiaddress.nim)                    | [Composable network addresses](https://github.com/multiformats/multiaddr)                                        |
 | [signed envelope](libp2p/signed_envelope.nim)              | [Signed generic data container](https://github.com/libp2p/specs/blob/master/RFC/0002-signed-envelopes.md)        |
 | [routing record](libp2p/routing_record.nim)                | [Signed peer dialing informations](https://github.com/libp2p/specs/blob/master/RFC/0003-routing-records.md)      |
+| [discovery manager](libp2p/discovery/discoverymngr.nim)    | Discovery Manager                                                                                                |
 | **Utilities**                                              |                                                                                                                  |
 | [libp2p-crypto](libp2p/crypto)                             | Cryptographic backend                                                                                            |
 | [libp2p-crypto-secp256k1](libp2p/crypto/secp.nim)          |                                                                                                                  |
@@ -100,22 +97,34 @@ nim-libp2p is used by:
 - [nim-codex](https://github.com/status-im/nim-codex), a decentralized storage application
 - (open a pull request if you want to be included here)
 
-## Development
-**Clone and Install dependencies:**
+## Stability
+nim-libp2p has been used in production for over a year in high-stake scenarios, so its core is considered stable.
+Some modules are more recent and less stable.
 
+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.2 & 1.6`
+
+## Development
+Clone and Install dependencies:
 ```sh
 git clone https://github.com/status-im/nim-libp2p
 cd nim-libp2p
-nimble install
+# to use dependencies computed by nimble
+nimble install -dy
+# OR to install the dependencies versions used in CI
+nimble install_pinned
 ```
 
-**Run unit tests**
+Run unit tests:
 ```sh
 # run all the unit tests
 nimble test
 ```
-The code follows the [Status Nim Style Guide](https://status-im.github.io/nim-style-guide/).
-
+This requires the go daemon to be available. To only run native tests, use `nimble testnative`.
+Or use `nimble tasks` to show all available tasks.
 
 ### Contribute
 
@@ -126,25 +135,33 @@ The libp2p implementation in Nim is a work in progress. We welcome contributors
 
 The code follows the [Status Nim Style Guide](https://status-im.github.io/nim-style-guide/).
 
-### Core Developers
-[@cheatfate](https://github.com/cheatfate), [Dmitriy Ryajov](https://github.com/dryajov), [Tanguy](https://github.com/Menduist), [Zahary Karadjov](https://github.com/zah)
+### Contributors
+<a href="https://github.com/status-im/nim-libp2p/graphs/contributors"><img src="https://contrib.rocks/image?repo=status-im/nim-libp2p" alt="nim-libp2p contributors"></a>
 
-### Tips and tricks
+### Core Maintainers
+<table>
+  <tbody>
+    <tr>
+      <td align="center"><a href="https://github.com/Menduist"><img src="https://avatars.githubusercontent.com/u/13471753?v=4?s=100" width="100px;" alt="Tanguy"/><br /><sub><b>Tanguy (Menduist)</b></sub></a></td>
+      <td align="center"><a href="https://github.com/lchenut"><img src="https://avatars.githubusercontent.com/u/11214565?v=4?s=100" width="100px;" alt="Ludovic"/><br /><sub><b>Ludovic</b></sub></a></td>
+      <td align="center"><a href="https://github.com/diegomrsantos"><img src="https://avatars.githubusercontent.com/u/7316595?v=4?s=100" width="100px;" alt="Diego"/><br /><sub><b>Diego</b></sub></a></td>
+    </tr>
+  </tbody>
+</table>
 
-**enable expensive metrics:**
+### Compile time flags
 
+Enable expensive metrics (ie, metrics with per-peer cardinality):
 ```bash
 nim c -d:libp2p_expensive_metrics some_file.nim
 ```
 
-**use identify metrics**
-
+Set list of known libp2p agents for metrics:
 ```bash
-nim c -d:libp2p_agents_metrics -d:KnownLibP2PAgents=nimbus,lighthouse,prysm,teku some_file.nim
+nim c -d:libp2p_agents_metrics -d:KnownLibP2PAgents=nimbus,lighthouse,lodestar,prysm,teku some_file.nim
 ```
 
-**specify gossipsub specific topics to measure**
-
+Specify gossipsub specific topics to measure in the metrics:
 ```bash
 nim c -d:KnownLibP2PTopics=topic1,topic2,topic3 some_file.nim
 ```

codecov.yml

@@ -1,14 +1,8 @@
 codecov:
   notify:
     require_ci_to_pass: true
-    # must be the number of coverage report builds
-    # notice that this number is for PRs;
-    # like this we disabled notify on pure branches report
-    # which is fine I guess
-    after_n_builds: 28
 comment:
   layout: "reach, diff, flags, files"
-  after_n_builds: 28 # must be the number of coverage report builds
 coverage:
   status:
     project:
@@ -16,4 +10,4 @@ coverage:
         # basic settings
         target: auto
         threshold: 5%
-        base: auto
+        base: auto

config.nims

@@ -1,9 +1,24 @@
 # 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
+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
+if defined(windows) and not defined(vcc):
+  --define:nimRawSetjmp
 
-when (NimMajor, NimMinor) > (1, 2):
-  switch("hint", "XCannotRaiseY:off")
 # begin Nimble config (version 1)
 when fileExists("nimble.paths"):
   include "nimble.paths"

examples/README.md

@@ -0,0 +1,5 @@
+# nim-libp2p examples
+
+In this folder, you'll find the sources of the [nim-libp2p website](https://status-im.github.io/nim-libp2p/docs/)
+
+We recommand to follow the tutorials on the website, but feel free to grok the sources here!

examples/circuitrelay.nim

@@ -0,0 +1,83 @@
+## # Circuit Relay example
+##
+## Circuit Relay can be used when a node cannot reach another node
+## directly, but can reach it through a another node (the Relay).
+##
+## That may happen because of NAT, Firewalls, or incompatible transports.
+##
+## More informations [here](https://docs.libp2p.io/concepts/circuit-relay/).
+import chronos, stew/byteutils
+import libp2p,
+       libp2p/protocols/connectivity/relay/[relay, client]
+
+# Helper to create a circuit relay node
+proc createCircuitRelaySwitch(r: Relay): Switch =
+  SwitchBuilder.new()
+    .withRng(newRng())
+    .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
+    .withTcpTransport()
+    .withMplex()
+    .withNoise()
+    .withCircuitRelay(r)
+    .build()
+
+proc main() {.async.} =
+  # Create a custom protocol
+  let customProtoCodec = "/test"
+  var proto = new LPProtocol
+  proto.codec = customProtoCodec
+  proto.handler = proc(conn: Connection, proto: string) {.async.} =
+    var msg = string.fromBytes(await conn.readLp(1024))
+    echo "1 - Dst Received: ", msg
+    assert "test1" == msg
+    await conn.writeLp("test2")
+    msg = string.fromBytes(await conn.readLp(1024))
+    echo "2 - Dst Received: ", msg
+    assert "test3" == msg
+    await conn.writeLp("test4")
+
+  let
+    relay = Relay.new()
+    clSrc = RelayClient.new()
+    clDst = RelayClient.new()
+
+    # Create three hosts, enable relay client on two of them.
+    # The third one can relay connections for other peers.
+    # RelayClient can use a relay, Relay is a relay.
+    swRel = createCircuitRelaySwitch(relay)
+    swSrc = createCircuitRelaySwitch(clSrc)
+    swDst = createCircuitRelaySwitch(clDst)
+
+  swDst.mount(proto)
+
+  await swRel.start()
+  await swSrc.start()
+  await swDst.start()
+
+  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()
+
+  # Connect Dst to the relay
+  await swDst.connect(swRel.peerInfo.peerId, swRel.peerInfo.addrs)
+
+  # Dst reserve a slot on the relay.
+  let rsvp = await clDst.reserve(swRel.peerInfo.peerId, swRel.peerInfo.addrs)
+
+  # Src dial Dst using the relay
+  let conn = await swSrc.dial(swDst.peerInfo.peerId, @[ addrs ], customProtoCodec)
+
+  await conn.writeLp("test1")
+  var msg = string.fromBytes(await conn.readLp(1024))
+  echo "1 - Src Received: ", msg
+  assert "test2" == msg
+  await conn.writeLp("test3")
+  msg = string.fromBytes(await conn.readLp(1024))
+  echo "2 - Src Received: ", msg
+  assert "test4" == msg
+
+  await relay.stop()
+  await allFutures(swSrc.stop(), swDst.stop(), swRel.stop())
+
+waitFor(main())

examples/directchat.nim

@@ -5,7 +5,7 @@ import
   strformat, strutils,
   stew/byteutils,
   chronos,
-  ../libp2p
+  libp2p
 
 const DefaultAddr = "/ip4/127.0.0.1/tcp/0"
 

examples/helloworld.nim

@@ -1,6 +1,6 @@
 import chronos         # an efficient library for async
 import stew/byteutils  # various utils
-import ../libp2p       # when installed through nimble, just use `import libp2p`
+import libp2p
 
 ##
 # Create our custom protocol

examples/index.md

@@ -0,0 +1,6 @@
+# nim-libp2p documentation
+
+Welcome to the nim-libp2p documentation!
+
+Here, you'll find [tutorials](tutorial_1_connect.md) to help you get started, as well as 
+the [full reference](https://status-im.github.io/nim-libp2p/master/libp2p.html).

examples/tutorial_1_connect.md

@@ -1,104 +0,0 @@
-Hi all, welcome to the first article of the nim-libp2p's tutorial series!
-
-_This tutorial is for everyone who is interested in building peer-to-peer chatting applications. No Nim programming experience is needed._
-
-To give you a quick overview, **Nim** is the programming language we are using and **nim-libp2p** is the Nim implementation of [libp2p](https://libp2p.io/), a modular library that enables the development of peer-to-peer network applications.
-
-Hope you'll find it helpful in your journey of learning. Happy coding! ;)
-
-# Before you start
-The only prerequisite here is [Nim](https://nim-lang.org/), the programming language with a Python-like syntax and a performance similar to C. Detailed information can be found [here](https://nim-lang.org/docs/tut1.html).
-
-Install Nim via their official website: [https://nim-lang.org/install.html](https://nim-lang.org/install.html)  
-Check Nim's installation via `nim --version` and its package manager Nimble via `nimble --version`.
-
-You can now install the latest version of `nim-libp2p`:
-```bash
-nimble install libp2p@#master
-```
-
-# A simple ping application
-We'll start by creating a simple application, which is starting two libp2p [switch](https://docs.libp2p.io/concepts/stream-multiplexing/#switch-swarm), and pinging each other using the [Ping](https://docs.libp2p.io/concepts/protocols/#ping) protocol.
-
-_TIP: You can extract the code from this tutorial by running `nim c -r tools/markdown_runner.nim examples/tutorial_1_connect.md` in the libp2p folder!_
-
-Let's create a `part1.nim`, and import our dependencies:
-```nim
-import chronos
-
-import libp2p
-import libp2p/protocols/ping
-```
-[chronos](https://github.com/status-im/nim-chronos) the asynchronous framework used by `nim-libp2p`
-
-Next, we'll create an helper procedure to create our switches. A switch needs a bit of configuration, and it will be easier to do this configuration only once:
-```nim
-proc createSwitch(ma: MultiAddress, rng: ref HmacDrbgContext): Switch =
-  var switch = SwitchBuilder
-    .new()
-    .withRng(rng)       # Give the application RNG
-    .withAddress(ma)    # Our local address(es)
-    .withTcpTransport() # Use TCP as transport
-    .withMplex()        # Use Mplex as muxer
-    .withNoise()        # Use Noise as secure manager
-    .build()
-
-  return switch
-```
-This will create a switch using [Mplex](https://docs.libp2p.io/concepts/stream-multiplexing/) as a multiplexer, Noise to secure the communication, and TCP as an underlying transport.
-
-You can of course tweak this, to use a different or multiple transport, or tweak the configuration of Mplex and Noise, but this is some sane defaults that we'll use going forward.
-
-
-Let's now start to create our main procedure:
-```nim
-proc main() {.async, gcsafe.} =
-  let
-    rng = newRng()
-    localAddress = MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()
-    pingProtocol = Ping.new(rng=rng)
-```
-We created some variables that we'll need for the rest of the application: the global `rng` instance, our `localAddress`, and an instance of the `Ping` protocol.  
-The address is in the [MultiAddress](https://github.com/multiformats/multiaddr) format. The port `0` means "take any port available".
-
-`tryGet` is procedure which is part of the [nim-result](https://github.com/arnetheduck/nim-result/), that will throw an exception if the supplied MultiAddress is not valid.
-
-We can now create our two switches:
-```nim
-  let
-    switch1 = createSwitch(localAddress, rng)
-    switch2 = createSwitch(localAddress, rng)
-    
-  switch1.mount(pingProtocol)
-
-  await switch1.start()
-  await switch2.start()
-```
-We've **mounted** the `pingProtocol` on our first switch. This means that the first switch will actually listen for any ping requests coming in, and handle them accordingly.
-
-Now that we've started the nodes, they are listening for incoming peers.  
-We can find out which port was attributed, and the resulting local addresses, by using `switch1.peerInfo.addrs`.
-
-We'll **dial** the first switch from the second one, by specifying it's **Peer ID**, it's **MultiAddress** and the **`Ping` protocol codec**:
-```nim
-  let conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, PingCodec)
-```
-We now have a `Ping` connection setup between the second and the first switch, we can use it to actually ping the node:
-```nim
-  # ping the other node and echo the ping duration
-  echo "ping: ", await pingProtocol.ping(conn)
-
-  # We must close the connection ourselves when we're done with it
-  await conn.close()
-```
-
-And that's it! Just a little bit of cleanup: shutting down the switches, waiting for them to stop, and we'll call our `main` procedure:
-```nim
-  await allFutures(switch1.stop(), switch2.stop()) # close connections and shutdown all transports
-  
-waitFor(main())
-```
-
-You can now run this program using `nim c -r part1.nim`, and you should see the dialing sequence, ending with a ping output.
-
-In the [next tutorial](tutorial_2_customproto.md), we'll look at how to create our own custom protocol.

examples/tutorial_1_connect.nim

@@ -0,0 +1,95 @@
+## # Simple ping tutorial
+##
+## Hi all, welcome to the first nim-libp2p tutorial!
+##
+## !!! tips ""
+##     This tutorial is for everyone who is interested in building peer-to-peer applications. No Nim programming experience is needed.
+##
+## To give you a quick overview, **Nim** is the programming language we are using and **nim-libp2p** is the Nim implementation of [libp2p](https://libp2p.io/), a modular library that enables the development of peer-to-peer network applications.
+##
+## Hope you'll find it helpful in your journey of learning. Happy coding! ;)
+##
+## ## Before you start
+## The only prerequisite here is [Nim](https://nim-lang.org/), the programming language with a Python-like syntax and a performance similar to C. Detailed information can be found [here](https://nim-lang.org/docs/tut1.html).
+##
+## Install Nim via their [official website](https://nim-lang.org/install.html).
+## Check Nim's installation via `nim --version` and its package manager Nimble via `nimble --version`.
+##
+## You can now install the latest version of `nim-libp2p`:
+## ```bash
+## nimble install libp2p@#master
+## ```
+##
+## ## A simple ping application
+## We'll start by creating a simple application, which is starting two libp2p [switch](https://docs.libp2p.io/concepts/stream-multiplexing/#switch-swarm), and pinging each other using the [Ping](https://docs.libp2p.io/concepts/protocols/#ping) protocol.
+##
+## !!! tips ""
+##     You can find the source of this tutorial (and other tutorials) in the [libp2p/examples](https://github.com/status-im/nim-libp2p/tree/master/examples) folder!
+##
+## Let's create a `part1.nim`, and import our dependencies:
+import chronos
+
+import libp2p
+import libp2p/protocols/ping
+
+## [chronos](https://github.com/status-im/nim-chronos) the asynchronous framework used by `nim-libp2p`
+##
+## Next, we'll create an helper procedure to create our switches. A switch needs a bit of configuration, and it will be easier to do this configuration only once:
+proc createSwitch(ma: MultiAddress, rng: ref HmacDrbgContext): Switch =
+  var switch = SwitchBuilder
+    .new()
+    .withRng(rng)       # Give the application RNG
+    .withAddress(ma)    # Our local address(es)
+    .withTcpTransport() # Use TCP as transport
+    .withMplex()        # Use Mplex as muxer
+    .withNoise()        # Use Noise as secure manager
+    .build()
+
+  return switch
+
+## This will create a switch using [Mplex](https://docs.libp2p.io/concepts/stream-multiplexing/) as a multiplexer, Noise to secure the communication, and TCP as an underlying transport.
+##
+## You can of course tweak this, to use a different or multiple transport, or tweak the configuration of Mplex and Noise, but this is some sane defaults that we'll use going forward.
+##
+##
+## Let's now start to create our main procedure:
+proc main() {.async, gcsafe.} =
+  let
+    rng = newRng()
+    localAddress = MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()
+    pingProtocol = Ping.new(rng=rng)
+  ## We created some variables that we'll need for the rest of the application: the global `rng` instance, our `localAddress`, and an instance of the `Ping` protocol.
+  ## The address is in the [MultiAddress](https://github.com/multiformats/multiaddr) format. The port `0` means "take any port available".
+  ##
+  ## `tryGet` is procedure which is part of [nim-result](https://github.com/arnetheduck/nim-result/), that will throw an exception if the supplied MultiAddress is invalid.
+  ##
+  ## We can now create our two switches:
+  let
+    switch1 = createSwitch(localAddress, rng)
+    switch2 = createSwitch(localAddress, rng)
+
+  switch1.mount(pingProtocol)
+
+  await switch1.start()
+  await switch2.start()
+  ## We've **mounted** the `pingProtocol` on our first switch. This means that the first switch will actually listen for any ping requests coming in, and handle them accordingly.
+  ##
+  ## Now that we've started the nodes, they are listening for incoming peers.
+  ## We can find out which port was attributed, and the resulting local addresses, by using `switch1.peerInfo.addrs`.
+  ##
+  ## We'll **dial** the first switch from the second one, by specifying it's **Peer ID**, it's **MultiAddress** and the **`Ping` protocol codec**:
+  let conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, PingCodec)
+  ## We now have a `Ping` connection setup between the second and the first switch, we can use it to actually ping the node:
+  # ping the other node and echo the ping duration
+  echo "ping: ", await pingProtocol.ping(conn)
+
+  # We must close the connection ourselves when we're done with it
+  await conn.close()
+  ## And that's it! Just a little bit of cleanup: shutting down the switches, waiting for them to stop, and we'll call our `main` procedure:
+  await allFutures(switch1.stop(), switch2.stop()) # close connections and shutdown all transports
+
+waitFor(main())
+
+## You can now run this program using `nim c -r part1.nim`, and you should see the dialing sequence, ending with a ping output.
+##
+## In the [next tutorial](tutorial_2_customproto.md), we'll look at how to create our own custom protocol.

examples/tutorial_2_customproto.md

@@ -1,79 +0,0 @@
-In the [previous tutorial](tutorial_1_connect.md), we've looked at how to create a simple ping program using the `nim-libp2p`.
-
-We'll now look at how to create a custom protocol inside the libp2p
-
-# Custom protocol in libp2p
-Let's create a `part2.nim`, and import our dependencies:
-```nim
-import chronos
-import stew/byteutils
-
-import libp2p
-```
-This is similar to the first tutorial, except we don't need to import the `Ping` protocol.
-
-Next, we'll declare our custom protocol
-```nim
-const TestCodec = "/test/proto/1.0.0"
-
-type TestProto = ref object of LPProtocol
-```
-
-We've set a [protocol ID](https://docs.libp2p.io/concepts/protocols/#protocol-ids), and created a custom `LPProtocol`. In a more complex protocol, we could use this structure to store interesting variables.
-
-A protocol generally has two part: and handling/server part, and a dialing/client part.  
-Theses two parts can be identical, but in our trivial protocol, the server will wait for a message from the client, and the client will send a message, so we have to handle the two cases separately.
-
-Let's start with the server part:
-```nim
-proc new(T: typedesc[TestProto]): T =
-  # every incoming connections will in be handled in this closure
-  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
-    echo "Got from remote - ", string.fromBytes(await conn.readLp(1024))
-    # We must close the connections ourselves when we're done with it
-    await conn.close()
-
-  return T(codecs: @[TestCodec], handler: handle)
-```
-This is a constructor for our `TestProto`, that will specify our `codecs` and a `handler`, which will be called for each incoming peer asking for this protocol.  
-In our handle, we simply read a message from the connection and `echo` it.
-
-We can now create our client part:
-```nim
-proc hello(p: TestProto, conn: Connection) {.async.} =
-  await conn.writeLp("Hello p2p!")
-```
-Again, pretty straight-forward, we just send a message on the connection.
-
-We can now create our main procedure:
-```nim
-proc main() {.async, gcsafe.} =
-  let
-    rng = newRng()
-    testProto = TestProto.new()
-    switch1 = newStandardSwitch(rng=rng)
-    switch2 = newStandardSwitch(rng=rng)
-  
-  switch1.mount(testProto)
-  
-  await switch1.start()
-  await switch2.start()
-    
-  let conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, TestCodec)
-
-  await testProto.hello(conn)
-
-  # We must close the connection ourselves when we're done with it
-  await conn.close()
-
-  await allFutures(switch1.stop(), switch2.stop()) # close connections and shutdown all transports
-```
-
-This is very similar to the first tutorial's `main`, the only noteworthy difference is that we use `newStandardSwitch`, which is similar to `createSwitch` but is bundled directly in libp2p
-
-We can now wrap our program by calling our main proc:
-```nim
-waitFor(main())
-```
-
-And that's it!

examples/tutorial_2_customproto.nim

@@ -0,0 +1,74 @@
+## # Custom protocol in libp2p
+##
+## In the [previous tutorial](tutorial_1_connect.md), we've looked at how to create a simple ping program using the `nim-libp2p`.
+##
+## We'll now look at how to create a custom protocol inside the libp2p
+##
+## Let's create a `part2.nim`, and import our dependencies:
+import chronos
+import stew/byteutils
+
+import libp2p
+## This is similar to the first tutorial, except we don't need to import the `Ping` protocol.
+##
+## Next, we'll declare our custom protocol
+const TestCodec = "/test/proto/1.0.0"
+
+type TestProto = ref object of LPProtocol
+
+## We've set a [protocol ID](https://docs.libp2p.io/concepts/protocols/#protocol-ids), and created a custom `LPProtocol`. In a more complex protocol, we could use this structure to store interesting variables.
+##
+## A protocol generally has two part: and handling/server part, and a dialing/client part.
+## Theses two parts can be identical, but in our trivial protocol, the server will wait for a message from the client, and the client will send a message, so we have to handle the two cases separately.
+##
+## Let's start with the server part:
+
+proc new(T: typedesc[TestProto]): T =
+  # every incoming connections will in be handled in this closure
+  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))
+    # We must close the connections ourselves when we're done with it
+    await conn.close()
+
+  return T.new(codecs = @[TestCodec], handler = handle)
+
+## This is a constructor for our `TestProto`, that will specify our `codecs` and a `handler`, which will be called for each incoming peer asking for this protocol.
+## In our handle, we simply read a message from the connection and `echo` it.
+##
+## We can now create our client part:
+proc hello(p: TestProto, conn: Connection) {.async.} =
+  await conn.writeLp("Hello p2p!")
+
+## Again, pretty straight-forward, we just send a message on the connection.
+##
+## We can now create our main procedure:
+proc main() {.async, gcsafe.} =
+  let
+    rng = newRng()
+    testProto = TestProto.new()
+    switch1 = newStandardSwitch(rng=rng)
+    switch2 = newStandardSwitch(rng=rng)
+
+  switch1.mount(testProto)
+
+  await switch1.start()
+  await switch2.start()
+
+  let conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, TestCodec)
+
+  await testProto.hello(conn)
+
+  # We must close the connection ourselves when we're done with it
+  await conn.close()
+
+  await allFutures(switch1.stop(), switch2.stop()) # close connections and shutdown all transports
+
+## This is very similar to the first tutorial's `main`, the only noteworthy difference is that we use `newStandardSwitch`, which is similar to the `createSwitch` of the first tutorial, but is bundled directly in libp2p
+##
+## We can now wrap our program by calling our main proc:
+waitFor(main())
+
+## And that's it!
+## In the [next tutorial](tutorial_3_protobuf.md), we'll create a more complex protocol using Protobuf.

examples/tutorial_3_protobuf.nim

@@ -0,0 +1,162 @@
+## # Protobuf usage
+##
+## In the [previous tutorial](tutorial_2_customproto.md), we created a simple "ping" protocol.
+## Most real protocol want their messages to be structured and extensible, which is why
+## most real protocols use [protobuf](https://developers.google.com/protocol-buffers) to
+## define their message structures.
+##
+## Here, we'll create a slightly more complex protocol, which parses & generate protobuf
+## messages. Let's start by importing our dependencies, as usual:
+import chronos
+import stew/results # for Opt[T]
+
+import libp2p
+
+## ## Protobuf encoding & decoding
+## This will be the structure of our messages:
+## ```protobuf
+## message MetricList {
+##   message Metric {
+##     string name = 1;
+##     float value = 2;
+##   }
+##
+##   repeated Metric metrics = 2;
+## }
+## ```
+## We'll create our protobuf types, encoders & decoders, according to this format.
+## To create the encoders & decoders, we are going to use minprotobuf
+## (included in libp2p).
+##
+## While more modern technics
+## (such as [nim-protobuf-serialization](https://github.com/status-im/nim-protobuf-serialization))
+## exists, minprotobuf is currently the recommended method to handle protobuf, since it has
+## been used in production extensively, and audited.
+type
+  Metric = object
+    name: string
+    value: float
+
+  MetricList = object
+    metrics: seq[Metric]
+
+{.push raises: [].}
+
+proc encode(m: Metric): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, m.name)
+  result.write(2, m.value)
+  result.finish()
+
+proc decode(_: type Metric, buf: seq[byte]): Result[Metric, ProtoError] =
+  var res: Metric
+  let pb = initProtoBuffer(buf)
+  # "getField" will return a Result[bool, ProtoError].
+  # The Result will hold an error if the protobuf is invalid.
+  # The Result will hold "false" if the field is missing
+  #
+  # We are just checking the error, and ignoring whether the value
+  # is present or not (default values are valid).
+  discard ? pb.getField(1, res.name)
+  discard ? pb.getField(2, res.value)
+  ok(res)
+
+proc encode(m: MetricList): ProtoBuffer =
+  result = initProtoBuffer()
+  for metric in m.metrics:
+    result.write(1, metric.encode())
+  result.finish()
+
+proc decode(_: type MetricList, buf: seq[byte]): Result[MetricList, ProtoError] =
+  var
+    res: MetricList
+    metrics: seq[seq[byte]]
+  let pb = initProtoBuffer(buf)
+  discard ? pb.getRepeatedField(1, metrics)
+
+  for metric in metrics:
+    res.metrics &= ? Metric.decode(metric)
+  ok(res)
+
+## ## Results instead of exceptions
+## As you can see, this part of the program also uses Results instead of exceptions for error handling.
+## We start by `{.push raises: [].}`, which will prevent every non-async function from raising
+## exceptions.
+##
+## Then, we use [nim-result](https://github.com/arnetheduck/nim-result) to convey
+## errors to function callers. A `Result[T, E]` will either hold a valid result of type
+## T, or an error of type E.
+##
+## You can check if the call succeeded by using `res.isOk`, and then get the
+## value using `res.value` or the error by using `res.error`.
+##
+## Another useful tool is `?`, which will unpack a Result if it succeeded,
+## or if it failed, exit the current procedure returning the error.
+##
+## nim-result is packed with other functionalities that you'll find in the
+## nim-result repository.
+##
+## Results and exception are generally interchangeable, but have different semantics
+## that you may or may not prefer.
+##
+## ## Creating the protocol
+## We'll next create a protocol, like in the last tutorial, to request these metrics from our host
+type
+  MetricCallback = proc: Future[MetricList] {.raises: [], gcsafe.}
+  MetricProto = ref object of LPProtocol
+    metricGetter: MetricCallback
+
+proc new(_: typedesc[MetricProto], cb: MetricCallback): MetricProto =
+  var res: MetricProto
+  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
+    let
+      metrics = await res.metricGetter()
+      asProtobuf = metrics.encode()
+    await conn.writeLp(asProtobuf.buffer)
+    await conn.close()
+
+  res = MetricProto.new(@["/metric-getter/1.0.0"], handle)
+  res.metricGetter = cb
+  return res
+
+proc fetch(p: MetricProto, conn: Connection): Future[MetricList] {.async.} =
+  let protobuf = await conn.readLp(2048)
+  # tryGet will raise an exception if the Result contains an error.
+  # It's useful to bridge between exception-world and result-world
+  return MetricList.decode(protobuf).tryGet()
+
+## We can now create our main procedure:
+proc main() {.async, gcsafe.} =
+  let rng = newRng()
+  proc randomMetricGenerator: Future[MetricList] {.async.} =
+    let metricCount = rng[].generate(uint32) mod 16
+    for i in 0 ..< metricCount + 1:
+      result.metrics.add(Metric(
+        name: "metric_" & $i,
+        value: float(rng[].generate(uint16)) / 1000.0
+      ))
+    return result
+  let
+    metricProto1 = MetricProto.new(randomMetricGenerator)
+    metricProto2 = MetricProto.new(randomMetricGenerator)
+    switch1 = newStandardSwitch(rng=rng)
+    switch2 = newStandardSwitch(rng=rng)
+
+  switch1.mount(metricProto1)
+
+  await switch1.start()
+  await switch2.start()
+
+  let
+    conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, metricProto2.codecs)
+    metrics = await metricProto2.fetch(conn)
+  await conn.close()
+
+  for metric in metrics.metrics:
+    echo metric.name, " = ", metric.value
+
+  await allFutures(switch1.stop(), switch2.stop()) # close connections and shutdown all transports
+
+waitFor(main())
+
+## If you run this program, you should see random metrics being sent from the switch1 to the switch2.

examples/tutorial_4_gossipsub.nim

@@ -0,0 +1,163 @@
+## # GossipSub
+##
+## In this tutorial, we'll build a simple GossipSub network
+## to broadcast the metrics we built in the previous tutorial.
+##
+## GossipSub is used to broadcast some messages in a network,
+## and allows to balance between latency, bandwidth usage,
+## privacy and attack resistance.
+##
+## You'll find a good explanation on how GossipSub works
+## [here.](https://docs.libp2p.io/concepts/publish-subscribe/) There are a lot
+## of parameters you can tweak to adjust how GossipSub behaves but here we'll
+## use the sane defaults shipped with libp2p.
+##
+## We'll start by creating our metric structure like previously
+
+import chronos
+import stew/results
+
+import libp2p
+import libp2p/protocols/pubsub/rpc/messages
+
+type
+  Metric = object
+    name: string
+    value: float
+
+  MetricList = object
+    hostname: string
+    metrics: seq[Metric]
+
+{.push raises: [].}
+
+proc encode(m: Metric): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, m.name)
+  result.write(2, m.value)
+  result.finish()
+
+proc decode(_: type Metric, buf: seq[byte]): Result[Metric, ProtoError] =
+  var res: Metric
+  let pb = initProtoBuffer(buf)
+  discard ? pb.getField(1, res.name)
+  discard ? pb.getField(2, res.value)
+  ok(res)
+
+proc encode(m: MetricList): ProtoBuffer =
+  result = initProtoBuffer()
+  for metric in m.metrics:
+    result.write(1, metric.encode())
+  result.write(2, m.hostname)
+  result.finish()
+
+proc decode(_: type MetricList, buf: seq[byte]): Result[MetricList, ProtoError] =
+  var
+    res: MetricList
+    metrics: seq[seq[byte]]
+  let pb = initProtoBuffer(buf)
+  discard ? pb.getRepeatedField(1, metrics)
+
+  for metric in metrics:
+    res.metrics &= ? Metric.decode(metric)
+  ? pb.getRequiredField(2, res.hostname)
+  ok(res)
+
+## This is exactly like the previous structure, except that we added
+## a `hostname` to distinguish where the metric is coming from.
+##
+## Now we'll create a small GossipSub network to broadcast the metrics,
+## and collect them on one of the node.
+
+type Node = tuple[switch: Switch, gossip: GossipSub, hostname: string]
+
+proc oneNode(node: Node, rng: ref HmacDrbgContext) {.async.} =
+  # This procedure will handle one of the node of the network
+  node.gossip.addValidator(["metrics"],
+    proc(topic: string, message: Message): Future[ValidationResult] {.async.} =
+      let decoded = MetricList.decode(message.data)
+      if decoded.isErr: return ValidationResult.Reject
+      return ValidationResult.Accept
+  )
+  # This "validator" will attach to the `metrics` topic and make sure
+  # that every message in this topic is valid. This allows us to stop
+  # propagation of invalid messages quickly in the network, and punish
+  # peers sending them.
+
+  # `John` will be responsible to log the metrics, the rest of the nodes
+  # will just forward them in the network
+  if node.hostname == "John":
+    node.gossip.subscribe("metrics",
+      proc (topic: string, data: seq[byte]) {.async.} =
+        echo MetricList.decode(data).tryGet()
+    )
+  else:
+    node.gossip.subscribe("metrics", nil)
+
+  # Create random metrics 10 times and broadcast them
+  for _ in 0..<10:
+    await sleepAsync(500.milliseconds)
+    var metricList = MetricList(hostname: node.hostname)
+    let metricCount = rng[].generate(uint32) mod 4
+    for i in 0 ..< metricCount + 1:
+      metricList.metrics.add(Metric(
+        name: "metric_" & $i,
+        value: float(rng[].generate(uint16)) / 1000.0
+      ))
+
+    discard await node.gossip.publish("metrics", encode(metricList).buffer)
+  await node.switch.stop()
+
+## For our main procedure, we'll create a few nodes, and connect them together.
+## Note that they are not all interconnected, but GossipSub will take care of
+## broadcasting to the full network nonetheless.
+proc main {.async.} =
+  let rng = newRng()
+  var nodes: seq[Node]
+
+  for hostname in ["John", "Walter", "David", "Thuy", "Amy"]:
+    let
+      switch = newStandardSwitch(rng=rng)
+      gossip = GossipSub.init(switch = switch, triggerSelf = true)
+    switch.mount(gossip)
+    await switch.start()
+
+    nodes.add((switch, gossip, hostname))
+
+  for index, node in nodes:
+    # Connect to a few neighbors
+    for otherNodeIdx in index - 1 .. index + 2:
+      if otherNodeIdx notin 0 ..< nodes.len or otherNodeIdx == index: continue
+      let otherNode = nodes[otherNodeIdx]
+      await node.switch.connect(
+        otherNode.switch.peerInfo.peerId,
+        otherNode.switch.peerInfo.addrs)
+
+  var allFuts: seq[Future[void]]
+  for node in nodes:
+    allFuts.add(oneNode(node, rng))
+
+  await allFutures(allFuts)
+
+waitFor(main())
+
+## If you run this program, you should see something like:
+## ```
+## (hostname: "John", metrics: @[(name: "metric_0", value: 42.097), (name: "metric_1", value: 50.99), (name: "metric_2", value: 47.86), (name: "metric_3", value: 5.368)])
+## (hostname: "Walter", metrics: @[(name: "metric_0", value: 39.452), (name: "metric_1", value: 15.606), (name: "metric_2", value: 14.059), (name: "metric_3", value: 6.68)])
+## (hostname: "David", metrics: @[(name: "metric_0", value: 9.82), (name: "metric_1", value: 2.862), (name: "metric_2", value: 15.514)])
+## (hostname: "Thuy", metrics: @[(name: "metric_0", value: 59.038)])
+## (hostname: "Amy", metrics: @[(name: "metric_0", value: 55.616), (name: "metric_1", value: 23.52), (name: "metric_2", value: 59.081), (name: "metric_3", value: 2.516)])
+## ```
+##
+## This is John receiving & logging everyone's metrics.
+##
+## ## Going further
+## Building efficient & safe GossipSub networks is a tricky subject. By tweaking the [gossip params](https://status-im.github.io/nim-libp2p/master/libp2p/protocols/pubsub/gossipsub/types.html#GossipSubParams)
+## and [topic params](https://status-im.github.io/nim-libp2p/master/libp2p/protocols/pubsub/gossipsub/types.html#TopicParams),
+## you can achieve very different properties.
+##
+## Also see reports for [GossipSub v1.1](https://gateway.ipfs.io/ipfs/QmRAFP5DBnvNjdYSbWhEhVRJJDFCLpPyvew5GwCCB4VxM4)
+##
+## If you are interested in broadcasting for your application, you may want to use [Waku](https://waku.org/), which builds on top of GossipSub,
+## and adds features such as history, spam protection, and light node friendliness.

examples/tutorial_5_discovery.nim

@@ -0,0 +1,132 @@
+## # Discovery Manager
+##
+## In the [previous tutorial](tutorial_4_gossipsub.md), we built a custom protocol using [protobuf](https://developers.google.com/protocol-buffers) and
+## spread informations (some metrics) on the network using gossipsub.
+## For this tutorial, on the other hand, we'll go back on a simple example
+## we'll try to discover a specific peers to greet on the network.
+##
+## First, as usual, we import the dependencies:
+import sequtils
+import chronos
+import stew/byteutils
+
+import libp2p
+import libp2p/protocols/rendezvous
+import libp2p/discovery/rendezvousinterface
+import libp2p/discovery/discoverymngr
+
+## We'll not use newStandardSwitch this time as we need the discovery protocol
+## [RendezVous](https://github.com/libp2p/specs/blob/master/rendezvous/README.md) to be mounted on the switch using withRendezVous.
+##
+## Note that other discovery methods such as [Kademlia](https://github.com/libp2p/specs/blob/master/kad-dht/README.md) or [discv5](https://github.com/ethereum/devp2p/blob/master/discv5/discv5.md) exist.
+proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
+  SwitchBuilder.new()
+    .withRng(newRng())
+    .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
+    .withTcpTransport()
+    .withYamux()
+    .withNoise()
+    .withRendezVous(rdv)
+    .build()
+
+# Create a really simple protocol to log one message received then close the stream
+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, gcsafe.} =
+    echo "Node", nodeNumber, " received: ", string.fromBytes(await conn.readLp(1024))
+    await conn.close()
+  return T.new(codecs = @[DumbCodec], handler = handle)
+
+## ## Bootnodes
+## The first time a p2p program is ran, he needs to know how to join
+## its network. This is generally done by hard-coding a list of stable
+## nodes in the binary, called "bootnodes". These bootnodes are a
+## critical part of a p2p network, since they are used by every new
+## user to onboard the network.
+##
+## By using libp2p, we can use any node supporting our discovery protocol
+## (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, gcsafe.} =
+  let bootNode = createSwitch()
+  await bootNode.start()
+
+  # Create 5 nodes in the network
+  var
+    switches: seq[Switch] = @[]
+    discManagers: seq[DiscoveryManager] = @[]
+
+  for i in 0..5:
+    let rdv = RendezVous.new()
+    # Create a remote future to await at the end of the program
+    let switch = createSwitch(rdv)
+    switch.mount(DumbProto.new(i))
+    switches.add(switch)
+
+    # A discovery manager is a simple tool, you can set it up by adding discovery
+    # interfaces (such as RendezVousInterface) then you can use it to advertise
+    # something on the network or to request something from it.
+    let dm = DiscoveryManager()
+    # A RendezVousInterface is a RendezVous protocol wrapped to be usable by the
+    # DiscoveryManager.
+    dm.add(RendezVousInterface.new(rdv))
+    discManagers.add(dm)
+
+    # We can now start the switch and connect to the bootnode
+    await switch.start()
+    await switch.connect(bootNode.peerInfo.peerId, bootNode.peerInfo.addrs)
+
+    # Each nodes of the network will advertise on some topics (EvenGang or OddClub)
+    dm.advertise(RdvNamespace(if i mod 2 == 0: "EvenGang" else: "OddClub"))
+
+  ## We can now create the newcomer. This peer will connect to the boot node, and use
+  ## it to discover peers & greet them.
+  let
+    rdv = RendezVous.new()
+    newcomer = createSwitch(rdv)
+    dm = DiscoveryManager()
+  await newcomer.start()
+  await newcomer.connect(bootNode.peerInfo.peerId, bootNode.peerInfo.addrs)
+  dm.add(RendezVousInterface.new(rdv, ttr = 250.milliseconds))
+
+  # Use the discovery manager to find peers on the OddClub topic to greet them
+  let queryOddClub = dm.request(RdvNamespace("OddClub"))
+  for _ in 0..2:
+    let
+      # getPeer give you a PeerAttribute containing informations about the peer.
+      res = await queryOddClub.getPeer()
+      # Here we will use the PeerId and the MultiAddress to greet him
+      conn = await newcomer.dial(res[PeerId], res.getAll(MultiAddress), DumbCodec)
+    await conn.writeLp("Odd Club suuuucks! Even Gang is better!")
+    # Uh-oh!
+    await conn.close()
+    # Wait for the peer to close the stream
+    await conn.join()
+  # Queries will run in a loop, so we must stop them when we are done
+  queryOddClub.stop()
+
+  # Maybe it was because he wanted to join the EvenGang
+  let queryEvenGang = dm.request(RdvNamespace("EvenGang"))
+  for _ in 0..2:
+    let
+      res = await queryEvenGang.getPeer()
+      conn = await newcomer.dial(res[PeerId], res.getAll(MultiAddress), DumbCodec)
+    await conn.writeLp("Even Gang is sooo laaame! Odd Club rocks!")
+    # Or maybe not...
+    await conn.close()
+    await conn.join()
+  queryEvenGang.stop()
+  # What can I say, some people just want to watch the world burn... Anyway
+
+  # Stop all the discovery managers
+  for d in discManagers:
+    d.stop()
+  dm.stop()
+
+  # Stop all the switches
+  await allFutures(switches.mapIt(it.stop()))
+  await allFutures(bootNode.stop(), newcomer.stop())
+
+waitFor(main())

examples/tutorial_6_game.nim

@@ -0,0 +1,259 @@
+## # Tron example
+##
+## In this tutorial, we will create a video game based on libp2p, using
+## all of the features we talked about in the last tutorials.
+##
+## We will:
+## - Discover peers using the Discovery Manager
+## - Use GossipSub to find a play mate
+## - Create a custom protocol to play with him
+##
+## While this may look like a daunting project, it's less than 150 lines of code.
+##
+## The game will be a simple Tron. We will use [nico](https://github.com/ftsf/nico)
+## as a game engine. (you need to run `nimble install nico` to have it available)
+##
+## ![multiplay](https://user-images.githubusercontent.com/13471753/198852714-b55048e3-f233-4723-900d-2193ad259fe1.gif)
+##
+## We will start by importing our dependencies and creating our types
+import os
+import nico, chronos, stew/byteutils, stew/endians2
+import libp2p
+import libp2p/protocols/rendezvous
+import libp2p/discovery/rendezvousinterface
+import libp2p/discovery/discoverymngr
+
+const
+  directions = @[(K_UP, 0, -1), (K_LEFT, -1, 0), (K_DOWN, 0, 1), (K_RIGHT, 1, 0)]
+  mapSize = 32
+  tickPeriod = 0.2
+
+type
+  Player = ref object
+    x, y: int
+    currentDir, nextDir: int
+    lost: bool
+    color: int
+
+  Game = ref object
+    gameMap: array[mapSize * mapSize, int]
+    tickTime: float
+    localPlayer, remotePlayer: Player
+    peerFound: Future[Connection]
+    hasCandidate: bool
+    tickFinished: Future[int]
+
+  GameProto = ref object of LPProtocol
+
+proc new(_: type[Game]): Game =
+  # Default state of a game
+  result = Game(
+    tickTime: -3.0, # 3 seconds of "warm-up" time
+    localPlayer: Player(x: 4, y: 16, currentDir: 3, nextDir: 3, color: 8),
+    remotePlayer: Player(x: 27, y: 16, currentDir: 1, nextDir: 1, color: 12),
+    peerFound: newFuture[Connection]()
+  )
+  for pos in 0 .. result.gameMap.high:
+    if pos mod mapSize in [0, mapSize - 1] or pos div mapSize in [0, mapSize - 1]:
+      result.gameMap[pos] = 7
+
+## ## Game Logic
+## The networking during the game will work like this:
+##
+## * Each player will have `tickPeriod` (0.1) seconds to choose
+##   a direction that he wants to go to (default to current direction)
+## * After `tickPeriod`, we will send our choosen direction to the peer,
+##   and wait for his direction
+## * Once we have both direction, we will "tick" the game, and restart the
+##   loop, as long as both player are alive.
+##
+## This is a very simplistic scheme, but creating proper networking for
+## video games is an [art](https://developer.valvesoftware.com/wiki/Latency_Compensating_Methods_in_Client/Server_In-game_Protocol_Design_and_Optimization)
+##
+## The main drawback of this scheme is that the more ping you have with
+## the peer, the slower the game will run. Or invertedly, the less ping you
+## have, the faster it runs!
+proc update(g: Game, dt: float32) =
+  # Will be called at each frame of the game.
+  #
+  # Because both Nico and Chronos have a main loop,
+  # they must share the control of the main thread.
+  # This is a hacky way to make this happen
+  waitFor(sleepAsync(1.milliseconds))
+  # Don't do anything if we are still waiting for an opponent
+  if not(g.peerFound.finished()) or isNil(g.tickFinished): return
+  g.tickTime += dt
+
+  # Update the wanted direction, making sure we can't go backward
+  for i in 0 .. directions.high:
+    if i != (g.localPlayer.currentDir + 2 mod 4) and keyp(directions[i][0]):
+      g.localPlayer.nextDir = i
+
+  if g.tickTime > tickPeriod and not g.tickFinished.finished():
+    # We choosen our next direction, let the networking know
+    g.localPlayer.currentDir = g.localPlayer.nextDir
+    g.tickFinished.complete(g.localPlayer.currentDir)
+
+proc tick(g: Game, p: Player) =
+  # Move player and check if he lost
+  p.x += directions[p.currentDir][1]
+  p.y += directions[p.currentDir][2]
+  if g.gameMap[p.y * mapSize + p.x] != 0: p.lost = true
+  g.gameMap[p.y * mapSize + p.x] = p.color
+
+proc mainLoop(g: Game, peer: Connection) {.async.} =
+  while not (g.localPlayer.lost or g.remotePlayer.lost):
+    if g.tickTime > 0.0:
+      g.tickTime = 0
+    g.tickFinished = newFuture[int]()
+
+    # Wait for a choosen direction
+    let dir = await g.tickFinished
+    # Send it
+    await peer.writeLp(toBytes(uint32(dir)))
+
+    # Get the one from the peer
+    g.remotePlayer.currentDir = int uint32.fromBytes(await peer.readLp(8))
+    # Tick the players & restart
+    g.tick(g.remotePlayer)
+    g.tick(g.localPlayer)
+
+## We'll draw the map & put some texts when necessary:
+proc draw(g: Game) =
+  for pos, color in g.gameMap:
+    setColor(color)
+    boxFill(pos mod 32 * 4, pos div 32 * 4, 4, 4)
+  let text = if not(g.peerFound.finished()): "Matchmaking.."
+             elif g.tickTime < -1.5: "Welcome to Etron"
+             elif g.tickTime < 0.0: "- " & $(int(abs(g.tickTime) / 0.5) + 1) & " -"
+             elif g.remotePlayer.lost and g.localPlayer.lost: "DEUCE"
+             elif g.localPlayer.lost: "YOU LOOSE"
+             elif g.remotePlayer.lost: "YOU WON"
+             else: ""
+  printc(text, screenWidth div 2, screenHeight div 2)
+
+
+## ## Matchmaking
+## To find an opponent, we will broadcast our address on a
+## GossipSub topic, and wait for someone to connect to us.
+## We will also listen to that topic, and connect to anyone
+## broadcasting his address.
+##
+## If we are looking for a game, we'll send `ok` to let the
+## 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, gcsafe.} =
+    defer: await conn.closeWithEof()
+    if g.peerFound.finished or g.hasCandidate:
+      await conn.close()
+      return
+    g.hasCandidate = true
+    await conn.writeLp("ok")
+    if "ok" != string.fromBytes(await conn.readLp(1024)):
+      g.hasCandidate = false
+      return
+    g.peerFound.complete(conn)
+    # The handler of a protocol must wait for the stream to
+    # be finished before returning
+    await conn.join()
+  return T.new(codecs = @["/tron/1.0.0"], handler = handle)
+
+proc networking(g: Game) {.async.} =
+  # Create our switch, similar to the GossipSub example and
+  # the Discovery examples combined
+  let
+    rdv = RendezVous.new()
+    switch = SwitchBuilder.new()
+      .withRng(newRng())
+      .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
+      .withTcpTransport()
+      .withYamux()
+      .withNoise()
+      .withRendezVous(rdv)
+      .build()
+    dm = DiscoveryManager()
+    gameProto = GameProto.new(g)
+    gossip = GossipSub.init(
+      switch = switch,
+      triggerSelf = false)
+  dm.add(RendezVousInterface.new(rdv))
+
+  switch.mount(gossip)
+  switch.mount(gameProto)
+
+  gossip.subscribe(
+    "/tron/matchmaking",
+    proc (topic: string, data: seq[byte]) {.async.} =
+      # If we are still looking for an opponent,
+      # try to match anyone broadcasting it's address
+      if g.peerFound.finished or g.hasCandidate: return
+      g.hasCandidate = true
+
+      try:
+        let
+          (peerId, multiAddress) = parseFullAddress(data).tryGet()
+          stream = await switch.dial(peerId, @[multiAddress], gameProto.codec)
+
+        await stream.writeLp("ok")
+        if (await stream.readLp(10)) != "ok".toBytes:
+          g.hasCandidate = false
+          return
+        g.peerFound.complete(stream)
+        # We are "player 2"
+        swap(g.localPlayer, g.remotePlayer)
+      except CatchableError as exc:
+        discard
+  )
+
+  await switch.start()
+  defer: await switch.stop()
+
+  # As explained in the last tutorial, we need a bootnode to be able
+  # to find peers. We could use any libp2p running rendezvous (or any
+  # node running tron). We will take it's MultiAddress from the command
+  # line parameters
+  if paramCount() > 0:
+    let (peerId, multiAddress) = paramStr(1).parseFullAddress().tryGet()
+    await switch.connect(peerId, @[multiAddress])
+  else:
+    echo "No bootnode provided, listening on: ", switch.peerInfo.fullAddrs.tryGet()
+
+  # Discover peers from the bootnode, and connect to them
+  dm.advertise(RdvNamespace("tron"))
+  let discoveryQuery = dm.request(RdvNamespace("tron"))
+  discoveryQuery.forEach:
+    try:
+      await switch.connect(peer[PeerId], peer.getAll(MultiAddress))
+    except CatchableError as exc:
+      echo "Failed to dial a peer: ", exc.msg
+
+  # We will try to publish our address multiple times, in case
+  # it takes time to establish connections with other GossipSub peers
+  var published = false
+  while not published:
+    await sleepAsync(500.milliseconds)
+    for fullAddr in switch.peerInfo.fullAddrs.tryGet():
+      if (await gossip.publish("/tron/matchmaking", fullAddr.bytes)) == 0:
+        published = false
+        break
+      published = true
+
+  discoveryQuery.stop()
+
+  # We now wait for someone to connect to us (or for us to connect to someone)
+  let peerConn = await g.peerFound
+  defer: await peerConn.closeWithEof()
+
+  await g.mainLoop(peerConn)
+
+let
+  game = Game.new()
+  netFut = networking(game)
+nico.init("Status", "Tron")
+nico.createWindow("Tron", mapSize * 4, mapSize * 4, 4, false)
+nico.run(proc = discard, proc(dt: float32) = game.update(dt), proc = game.draw())
+waitFor(netFut.cancelAndWait())
+
+## And that's it! If you want to run this code locally, the simplest way is to use the
+## first node as a boot node for the second one. But you can also use any rendezvous node

libp2p.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -8,7 +8,7 @@
 # those terms.
 
 when defined(nimdoc):
-  ## Welcome to the nim-libp2p documentation!
+  ## Welcome to the nim-libp2p reference!
   ##
   ## On the left, you'll find a switch that allows you to see private
   ## procedures. By default, you'll only see the public one (marked with `{.public.}`)
@@ -17,7 +17,7 @@ when defined(nimdoc):
   ## stay backward compatible during the Major version, whereas private ones can
   ## change at each new Minor version.
   ##
-  ## If you're new to nim-libp2p, you can find a tutorial `here<https://github.com/status-im/nim-libp2p/blob/master/examples/tutorial_1_connect.md>`_
+  ## If you're new to nim-libp2p, you can find a tutorial `here<https://status-im.github.io/nim-libp2p/docs/tutorial_1_connect/>`_
   ## that can help you get started.
 
   # Import stuff for doc

libp2p.nimble

@@ -1,7 +1,7 @@
 mode = ScriptMode.Verbose
 
 packageName   = "libp2p"
-version       = "0.0.2"
+version       = "1.0.0"
 author        = "Status Research & Development GmbH"
 description   = "LibP2P implementation"
 license       = "MIT"
@@ -9,47 +9,41 @@ skipDirs      = @["tests", "examples", "Nim", "tools", "scripts", "docs"]
 
 requires "nim >= 1.2.0",
          "nimcrypto >= 0.4.1",
-         "dnsclient >= 0.1.2",
+         "dnsclient >= 0.3.0 & < 0.4.0",
          "bearssl >= 0.1.4",
          "chronicles >= 0.10.2",
          "chronos >= 3.0.6",
          "metrics",
          "secp256k1",
          "stew#head",
-         "websock"
-
-const nimflags =
-  "--verbosity:0 --hints:off " &
-  "--warning[CaseTransition]:off --warning[ObservableStores]:off " &
-  "--warning[LockLevel]:off " &
-  "-d:chronosStrictException " &
-  "--styleCheck:usages --styleCheck:hint "
+         "websock",
+         "unittest2 >= 0.0.5 & < 0.1.0"
 
+import hashes
 proc runTest(filename: string, verify: bool = true, sign: bool = true,
              moreoptions: string = "") =
-  var excstr = "nim c --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 ")
+  var excstr = "nim c --skipParentCfg --opt:speed -d:debug "
   excstr.add(" " & getEnv("NIMFLAGS") & " ")
-  excstr.add(" " & nimflags & " ")
+  excstr.add(" --verbosity:0 --hints:off ")
   excstr.add(" -d:libp2p_pubsub_sign=" & $sign)
   excstr.add(" -d:libp2p_pubsub_verify=" & $verify)
   excstr.add(" " & moreoptions & " ")
+  if getEnv("CICOV").len > 0:
+    excstr &= " --nimcache:nimcache/" & filename & "-" & $excstr.hash
   exec excstr & " -r " & " tests/" & filename
   rmFile "tests/" & filename.toExe
 
-proc buildSample(filename: string, run = false) =
-  var excstr = "nim c --opt:speed --threads:on -d:debug "
-  excstr.add(" " & nimflags & " ")
+proc buildSample(filename: string, run = false, 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:
     exec "./examples/" & filename.toExe
   rmFile "examples/" & filename.toExe
 
-proc buildTutorial(filename: string) =
-  discard gorge "cat " & filename & " | nim c -r --hints:off tools/markdown_runner.nim | " &
-    " nim " & nimflags & " c -"
+proc tutorialToMd(filename: string) =
+  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":
   runTest("testnative")
@@ -94,28 +88,31 @@ task test_slim, "Runs the (slimmed down) test suite":
   exec "nimble testfilter"
   exec "nimble examples_build"
 
+task website, "Build the website":
+  tutorialToMd("examples/tutorial_1_connect.nim")
+  tutorialToMd("examples/tutorial_2_customproto.nim")
+  tutorialToMd("examples/tutorial_3_protobuf.nim")
+  tutorialToMd("examples/tutorial_4_gossipsub.nim")
+  tutorialToMd("examples/tutorial_5_discovery.nim")
+  tutorialToMd("examples/tutorial_6_game.nim")
+  tutorialToMd("examples/circuitrelay.nim")
+  exec "mkdocs build"
+
 task examples_build, "Build the samples":
   buildSample("directchat")
   buildSample("helloworld", true)
-  buildTutorial("examples/tutorial_1_connect.md")
-  buildTutorial("examples/tutorial_2_customproto.md")
-
-proc tutorialToHtml(source, output: string) =
-  var html = gorge("./nimbledeps/bin/markdown < " & source)
-  html &= """
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/water.css@2/out/water.css">
-<link rel="stylesheet" href="https://unpkg.com/@highlightjs/cdn-assets@11.5.1/styles/default.min.css">
-<script src="https://unpkg.com/@highlightjs/cdn-assets@11.5.1/highlight.min.js"></script>
-<script src="https://unpkg.com/@highlightjs/cdn-assets@11.5.1/languages/nim.min.js"></script>
-<script>hljs.highlightAll();</script>
-  """
-  writeFile(output, html)
-
-
-task markdown_to_html, "Build the tutorials HTML":
-  exec "nimble install -y markdown"
-  tutorialToHtml("examples/tutorial_1_connect.md", "tuto1.html")
-  tutorialToHtml("examples/tutorial_2_customproto.md", "tuto2.html")
+  buildSample("circuitrelay", true)
+  buildSample("tutorial_1_connect", true)
+  buildSample("tutorial_2_customproto", true)
+  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
@@ -140,10 +137,24 @@ task install_pinned, "Reads the lockfile":
 
   # Remove the automatically installed deps
   # (inefficient you say?)
-  let allowedDirectories = toInstall.mapIt(it[0] & "-" & it[1].split('@')[1])
-  for dependency in listDirs("nimbledeps/pkgs"):
-    if dependency.extractFilename notin allowedDirectories:
-      rmDir(dependency)
+  let nimblePkgs =
+    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)
 
 task unpin, "Restore global package use":
   rmDir("nimbledeps")

libp2p/builders.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -16,14 +16,18 @@ runnableExamples:
    # etc
    .build()
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import
-  options, tables, chronos, chronicles,
+  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, relay],
+  protocols/[identify, secure/secure, secure/noise, rendezvous],
+  protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport],
   connmanager, upgrademngrs/muxedupgrade,
   nameresolving/nameresolver,
   errors, utility
@@ -38,15 +42,11 @@ type
     Noise,
     Secio {.deprecated.}
 
-  MuxerBuilder = object
-    codec: string
-    newMuxer: MuxerConstructor
-
   SwitchBuilder* = ref object
     privKey: Option[PrivateKey]
     addresses: seq[MultiAddress]
     secureManagers: seq[SecureProtocol]
-    muxers: seq[MuxerBuilder]
+    muxers: seq[MuxerProvider]
     transports: seq[TransportProvider]
     rng: ref HmacDrbgContext
     maxConnections: int
@@ -58,8 +58,10 @@ type
     agentVersion: string
     nameResolver: NameResolver
     peerStoreCapacity: Option[int]
-    isCircuitRelay: bool
-    circuitRelayCanHop: bool
+    autonat: bool
+    circuitRelay: Relay
+    rdv: RendezVous
+    services: seq[Service]
 
 proc new*(T: type[SwitchBuilder]): T {.public.} =
   ## Creates a SwitchBuilder
@@ -77,8 +79,7 @@ proc new*(T: type[SwitchBuilder]): T {.public.} =
     maxOut: -1,
     maxConnsPerPeer: MaxConnectionsPerPeer,
     protoVersion: ProtoVersion,
-    agentVersion: AgentVersion,
-    isCircuitRelay: false)
+    agentVersion: AgentVersion)
 
 proc withPrivateKey*(b: SwitchBuilder, privateKey: PrivateKey): SwitchBuilder {.public.} =
   ## Set the private key of the switch. Will be used to
@@ -119,13 +120,15 @@ proc withMplex*(
       outTimeout,
       maxChannCount)
 
-  b.muxers.add(MuxerBuilder(codec: MplexCodec, newMuxer: newMuxer))
+  assert b.muxers.countIt(it.codec == MplexCodec) == 0, "Mplex build multiple times"
+  b.muxers.add(MuxerProvider.new(newMuxer, MplexCodec))
   b
 
 proc withYamux*(b: SwitchBuilder): SwitchBuilder =
   proc newMuxer(conn: Connection): Muxer = Yamux.new(conn)
 
-  b.muxers.add(MuxerBuilder(codec: YamuxCodec, newMuxer: newMuxer))
+  assert b.muxers.countIt(it.codec == YamuxCodec) == 0, "Yamux build multiple times"
+  b.muxers.add(MuxerProvider.new(newMuxer, YamuxCodec))
   b
 
 proc withNoise*(b: SwitchBuilder): SwitchBuilder {.public.} =
@@ -185,9 +188,20 @@ proc withNameResolver*(b: SwitchBuilder, nameResolver: NameResolver): SwitchBuil
   b.nameResolver = nameResolver
   b
 
-proc withRelayTransport*(b: SwitchBuilder, canHop: bool): SwitchBuilder =
-  b.isCircuitRelay = true
-  b.circuitRelayCanHop = canHop
+proc withAutonat*(b: SwitchBuilder): SwitchBuilder =
+  b.autonat = true
+  b
+
+proc withCircuitRelay*(b: SwitchBuilder, r: Relay = Relay.new()): SwitchBuilder =
+  b.circuitRelay = r
+  b
+
+proc withRendezVous*(b: SwitchBuilder, rdv: RendezVous = RendezVous.new()): SwitchBuilder =
+  b.rdv = rdv
+  b
+
+proc withServices*(b: SwitchBuilder, services: seq[Service]): SwitchBuilder =
+  b.services = services
   b
 
 proc build*(b: SwitchBuilder): Switch
@@ -212,18 +226,11 @@ proc build*(b: SwitchBuilder): Switch
       protoVersion = b.protoVersion,
       agentVersion = b.agentVersion)
 
-  let
-    muxers = block:
-      var muxers: Table[string, MuxerProvider]
-      for m in b.muxers:
-        muxers[m.codec] = MuxerProvider.new(m.newMuxer, m.codec)
-      muxers
-
   let
     identify = Identify.new(peerInfo, b.sendSignedPeerRecord)
     connManager = ConnManager.new(b.maxConnsPerPeer, b.maxConnections, b.maxIn, b.maxOut)
     ms = MultistreamSelect.new()
-    muxedUpgrade = MuxedUpgrade.new(identify, muxers, secureManagerInstances, connManager, ms)
+    muxedUpgrade = MuxedUpgrade.new(identify, b.muxers, secureManagerInstances, connManager, ms)
 
   let
     transports = block:
@@ -248,17 +255,26 @@ proc build*(b: SwitchBuilder): Switch
     peerInfo = peerInfo,
     transports = transports,
     identity = identify,
-    muxers = muxers,
     secureManagers = secureManagerInstances,
     connManager = connManager,
     ms = ms,
     nameResolver = b.nameResolver,
-    peerStore = peerStore)
+    peerStore = peerStore,
+    services = b.services)
 
-  if b.isCircuitRelay:
-    let relay = Relay.new(switch, b.circuitRelayCanHop)
-    switch.mount(relay)
-    switch.addTransport(RelayTransport.new(relay, muxedUpgrade))
+  if b.autonat:
+    let autonat = Autonat.new(switch)
+    switch.mount(autonat)
+
+  if not isNil(b.circuitRelay):
+    if b.circuitRelay of RelayClient:
+      switch.addTransport(RelayTransport.new(RelayClient(b.circuitRelay), muxedUpgrade))
+    b.circuitRelay.setup(switch)
+    switch.mount(b.circuitRelay)
+
+  if not isNil(b.rdv):
+    b.rdv.setup(switch)
+    switch.mount(b.rdv)
 
   return switch
 

libp2p/cid.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implementes CID (Content IDentifier).
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import tables, hashes
 import multibase, multicodec, multihash, vbuffer, varint

libp2p/connmanager.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[options, tables, sequtils, sets]
 import pkg/[chronos, chronicles, metrics]
@@ -30,9 +33,6 @@ const
 type
   TooManyConnectionsError* = object of LPError
 
-  ConnProvider* = proc(): Future[Connection]
-    {.gcsafe, closure, raises: [Defect].}
-
   ConnEventKind* {.pure.} = enum
     Connected,    # A connection was made and securely upgraded - there may be
                   # more than one concurrent connection thus more than one upgrade
@@ -79,8 +79,13 @@ type
     muxed: Table[Connection, MuxerHolder]
     connEvents: array[ConnEventKind, OrderedSet[ConnEventHandler]]
     peerEvents: array[PeerEventKind, OrderedSet[PeerEventHandler]]
+    expectedConnections: Table[PeerId, Future[Connection]]
     peerStore*: PeerStore
 
+  ConnectionSlot* = object
+    connManager: ConnManager
+    direction: Direction
+
 proc newTooManyConnectionsError(): ref TooManyConnectionsError {.inline.} =
   result = newException(TooManyConnectionsError, "Too many connections")
 
@@ -106,6 +111,13 @@ proc new*(C: type ConnManager,
 proc connCount*(c: ConnManager, peerId: PeerId): int =
   c.conns.getOrDefault(peerId).len
 
+proc connectedPeers*(c: ConnManager, dir: Direction): seq[PeerId] =
+  var peers = newSeq[PeerId]()
+  for peerId, conns in c.conns:
+    if conns.anyIt(it.dir == dir):
+      peers.add(peerId)
+  return peers
+
 proc addConnEventHandler*(c: ConnManager,
                           handler: ConnEventHandler,
                           kind: ConnEventKind) =
@@ -209,6 +221,19 @@ 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): Future[Connection] {.async.} =
+  ## Wait for a peer to connect to us. This will bypass the `MaxConnectionsPerPeer`
+  if p in c.expectedConnections:
+    raise LPError.newException("Already expecting a connection from that peer")
+
+  let future = newFuture[Connection]()
+  c.expectedConnections[p] = future
+
+  try:
+    return await future
+  finally:
+    c.expectedConnections.del(p)
+
 proc contains*(c: ConnManager, conn: Connection): bool =
   ## checks if a connection is being tracked by the
   ## connection manager
@@ -385,7 +410,12 @@ proc storeConn*(c: ConnManager, conn: Connection)
     raise newException(LPError, "Connection closed or EOF")
 
   let peerId = conn.peerId
-  if c.conns.getOrDefault(peerId).len > c.maxConnsPerPeer:
+
+  # we use getOrDefault in the if below instead of [] to avoid the KeyError
+  if peerId in c.expectedConnections and
+     not(c.expectedConnections.getOrDefault(peerId).finished):
+      c.expectedConnections.getOrDefault(peerId).complete(conn)
+  elif c.conns.getOrDefault(peerId).len > c.maxConnsPerPeer:
     debug "Too many connections for peer",
       conn, conns = c.conns.getOrDefault(peerId).len
 
@@ -401,90 +431,46 @@ proc storeConn*(c: ConnManager, conn: Connection)
   trace "Stored connection",
     conn, direction = $conn.dir, connections = c.conns.len
 
-proc trackConn(c: ConnManager,
-               provider: ConnProvider,
-               sema: AsyncSemaphore):
-               Future[Connection] {.async.} =
-  var conn: Connection
-  try:
-    conn = await provider()
-
-    if isNil(conn):
-      return
-
-    trace "Got connection", conn
-
-    proc semaphoreMonitor() {.async.} =
-      try:
-        await conn.join()
-      except CatchableError as exc:
-        trace "Exception in semaphore monitor, ignoring", exc = exc.msg
-
-      sema.release()
-
-    asyncSpawn semaphoreMonitor()
-  except CatchableError as exc:
-    trace "Exception tracking connection", exc = exc.msg
-    if not isNil(conn):
-      await conn.close()
-
-    raise exc
-
-  return conn
-
-proc trackIncomingConn*(c: ConnManager,
-                        provider: ConnProvider):
-                        Future[Connection] {.async.} =
-  ## await for a connection slot before attempting
-  ## to call the connection provider
-  ##
-
-  var conn: Connection
-  try:
-    trace "Tracking incoming connection"
-    await c.inSema.acquire()
-    conn = await c.trackConn(provider, c.inSema)
-    if isNil(conn):
-      trace "Couldn't acquire connection, releasing semaphore slot", dir = $Direction.In
-      c.inSema.release()
-
-    return conn
-  except CatchableError as exc:
-    trace "Exception tracking connection", exc = exc.msg
-    c.inSema.release()
-    raise exc
-
-proc trackOutgoingConn*(c: ConnManager,
-                        provider: ConnProvider,
-                        forceDial = false):
-                        Future[Connection] {.async.} =
-  ## try acquiring a connection if all slots
-  ## are already taken, raise TooManyConnectionsError
-  ## exception
-  ##
-
-  trace "Tracking outgoing connection", count = c.outSema.count,
-                                        max = c.outSema.size
+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: [Defect, TooManyConnectionsError].} =
   if forceDial:
     c.outSema.forceAcquire()
   elif not c.outSema.tryAcquire():
     trace "Too many outgoing connections!", count = c.outSema.count,
                                             max = c.outSema.size
     raise newTooManyConnectionsError()
+  return ConnectionSlot(connManager: c, direction: Out)
 
-  var conn: Connection
-  try:
-    conn = await c.trackConn(provider, c.outSema)
-    if isNil(conn):
-      trace "Couldn't acquire connection, releasing semaphore slot", dir = $Direction.Out
-      c.outSema.release()
+proc slotsAvailable*(c: ConnManager, dir: Direction): int =
+  case dir:
+    of Direction.In:
+      return c.inSema.count
+    of Direction.Out:
+      return c.outSema.count
 
-    return conn
-  except CatchableError as exc:
-    trace "Exception tracking connection", exc = exc.msg
-    c.outSema.release()
-    raise exc
+proc release*(cs: ConnectionSlot) =
+  if cs.direction == In:
+    cs.connManager.inSema.release()
+  else:
+    cs.connManager.outSema.release()
+
+proc trackConnection*(cs: ConnectionSlot, conn: Connection) =
+  if isNil(conn):
+    cs.release()
+    return
+
+  proc semaphoreMonitor() {.async.} =
+    try:
+      await conn.join()
+    except CatchableError as exc:
+      trace "Exception in semaphore monitor, ignoring", exc = exc.msg
+
+    cs.release()
+
+  asyncSpawn semaphoreMonitor()
 
 proc storeMuxer*(c: ConnManager,
                  muxer: Muxer,
@@ -576,6 +562,12 @@ proc close*(c: ConnManager) {.async.} =
   let muxed = c.muxed
   c.muxed.clear()
 
+  let expected = c.expectedConnections
+  c.expectedConnections.clear()
+
+  for _, fut in expected:
+    await fut.cancelAndWait()
+
   for _, muxer in muxed:
     await closeMuxerHolder(muxer)
 
@@ -584,3 +576,4 @@ proc close*(c: ConnManager) {.async.} =
       await conn.close()
 
   trace "Closed ConnManager"
+

libp2p/crypto/chacha20poly1305.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -15,7 +15,10 @@
 
 # RFC @ https://tools.ietf.org/html/rfc7539
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import bearssl/blockx
 from stew/assign2 import assign

libp2p/crypto/crypto.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -8,7 +8,10 @@
 # those terms.
 
 ## This module implements Public Key and Private Key interface for libp2p.
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 from strutils import split, strip, cmpIgnoreCase
 

libp2p/crypto/curve25519.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022-2022 Status Research & Development GmbH
+# 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))
@@ -15,7 +15,10 @@
 
 # RFC @ https://tools.ietf.org/html/rfc7748
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import bearssl/[ec, rand, hash]
 import stew/results
@@ -28,7 +31,6 @@ const
 type
   Curve25519* = object
   Curve25519Key* = array[Curve25519KeySize, byte]
-  pcuchar = ptr char
   Curve25519Error* = enum
     Curver25519GenError
 
@@ -74,7 +76,7 @@ proc mulgen(_: type[Curve25519], dst: var Curve25519Key, point: Curve25519Key) =
       addr rpoint[0],
       Curve25519KeySize,
       EC_curve25519)
-  
+
   assert size == Curve25519KeySize
 
 proc public*(private: Curve25519Key): Curve25519Key =

libp2p/crypto/ecnist.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -14,7 +14,10 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.
 
-{.push raises: [Defect].}
+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.
@@ -55,9 +58,9 @@ type
     buffer*: seq[byte]
 
   EcCurveKind* = enum
-    Secp256r1 = EC_SECP256R1,
-    Secp384r1 = EC_SECP384R1,
-    Secp521r1 = EC_SECP521R1
+    Secp256r1 = EC_secp256r1,
+    Secp384r1 = EC_secp384r1,
+    Secp521r1 = EC_secp521r1
 
   EcPKI* = EcPrivateKey | EcPublicKey | EcSignature
 
@@ -373,11 +376,11 @@ proc toBytes*(seckey: EcPrivateKey, data: var openArray[byte]): EcResult[int] =
     var p = Asn1Composite.init(Asn1Tag.Sequence)
     var c0 = Asn1Composite.init(0)
     var c1 = Asn1Composite.init(1)
-    if seckey.key.curve == EC_SECP256R1:
+    if seckey.key.curve == EC_secp256r1:
       c0.write(Asn1Tag.Oid, Asn1OidSecp256r1)
-    elif seckey.key.curve == EC_SECP384R1:
+    elif seckey.key.curve == EC_secp384r1:
       c0.write(Asn1Tag.Oid, Asn1OidSecp384r1)
-    elif seckey.key.curve == EC_SECP521R1:
+    elif seckey.key.curve == EC_secp521r1:
       c0.write(Asn1Tag.Oid, Asn1OidSecp521r1)
     c0.finish()
     offset = pubkey.getOffset()
@@ -421,11 +424,11 @@ proc toBytes*(pubkey: EcPublicKey, data: var openArray[byte]): EcResult[int] =
     var p = Asn1Composite.init(Asn1Tag.Sequence)
     var c = Asn1Composite.init(Asn1Tag.Sequence)
     c.write(Asn1Tag.Oid, Asn1OidEcPublicKey)
-    if pubkey.key.curve == EC_SECP256R1:
+    if pubkey.key.curve == EC_secp256r1:
       c.write(Asn1Tag.Oid, Asn1OidSecp256r1)
-    elif pubkey.key.curve == EC_SECP384R1:
+    elif pubkey.key.curve == EC_secp384r1:
       c.write(Asn1Tag.Oid, Asn1OidSecp384r1)
-    elif pubkey.key.curve == EC_SECP521R1:
+    elif pubkey.key.curve == EC_secp521r1:
       c.write(Asn1Tag.Oid, Asn1OidSecp521r1)
     c.finish()
     p.write(c)
@@ -913,11 +916,11 @@ proc toSecret*(pubkey: EcPublicKey, seckey: EcPrivateKey,
   doAssert((not isNil(pubkey)) and (not isNil(seckey)))
   var mult = scalarMul(pubkey, seckey)
   if not isNil(mult):
-    if seckey.key.curve == EC_SECP256R1:
+    if seckey.key.curve == EC_secp256r1:
       result = Secret256Length
-    elif seckey.key.curve == EC_SECP384R1:
+    elif seckey.key.curve == EC_secp384r1:
       result = Secret384Length
-    elif seckey.key.curve == EC_SECP521R1:
+    elif seckey.key.curve == EC_secp521r1:
       result = Secret521Length
     if len(data) >= result:
       var qplus1 = cast[pointer](cast[uint](mult.key.q) + 1'u)

libp2p/crypto/ed25519/constants.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))

libp2p/crypto/ed25519/ed25519.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -11,7 +11,10 @@
 ## This code is a port of the public domain, "ref10" implementation of ed25519
 ## from SUPERCOP.
 
-{.push raises: Defect.}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import bearssl/rand
 import constants

libp2p/crypto/hkdf.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 # https://tools.ietf.org/html/rfc5869
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import nimcrypto
 import bearssl/[kdf, rand, hash]

libp2p/crypto/minasn1.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implements minimal ASN.1 encoding/decoding primitives.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import stew/[endians2, results, ctops]
 export results
@@ -525,8 +528,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass,
                           index: ttag, offset: int(ab.offset),
-                          length: 1)
-        shallowCopy(field.buffer, ab.buffer)
+                          length: 1, buffer: ab.buffer)
         field.vbool = (b == 0xFF'u8)
         ab.offset += 1
         return ok(field)
@@ -551,8 +553,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
           # Negative or Positive integer
           field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
                             index: ttag, offset: int(ab.offset),
-                            length: int(length))
-          shallowCopy(field.buffer, ab.buffer)
+                            length: int(length), buffer: ab.buffer)
           if (ab.buffer[ab.offset] and 0x80'u8) == 0x80'u8:
             # Negative integer
             if length <= 8:
@@ -576,16 +577,15 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
             # Zero value integer
             field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
                               index: ttag, offset: int(ab.offset),
-                              length: int(length), vint: 0'u64)
-            shallowCopy(field.buffer, ab.buffer)
+                              length: int(length), vint: 0'u64,
+                              buffer: ab.buffer)
             ab.offset += int(length)
             return ok(field)
           else:
             # Positive integer with leading zero
             field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
                               index: ttag, offset: int(ab.offset) + 1,
-                              length: int(length) - 1)
-            shallowCopy(field.buffer, ab.buffer)
+                              length: int(length) - 1, buffer: ab.buffer)
             if length <= 9:
               for i in 1 ..< int(length):
                 field.vint = (field.vint shl 8) or
@@ -607,8 +607,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
             # Zero-length BIT STRING.
             field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
                               index: ttag, offset: int(ab.offset + 1),
-                              length: 0, ubits: 0)
-            shallowCopy(field.buffer, ab.buffer)
+                              length: 0, ubits: 0, buffer: ab.buffer)
             ab.offset += int(length)
             return ok(field)
 
@@ -628,8 +627,8 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
           field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
                             index: ttag, offset: int(ab.offset + 1),
-                            length: int(length - 1), ubits: int(unused))
-          shallowCopy(field.buffer, ab.buffer)
+                            length: int(length - 1), ubits: int(unused),
+                            buffer: ab.buffer)
           ab.offset += int(length)
           return ok(field)
 
@@ -640,8 +639,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass,
                           index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
+                          length: int(length), buffer: ab.buffer)
         ab.offset += int(length)
         return ok(field)
 
@@ -651,8 +649,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
           return err(Asn1Error.Incorrect)
 
         field = Asn1Field(kind: Asn1Tag.Null, klass: aclass, index: ttag,
-                          offset: int(ab.offset), length: 0)
-        shallowCopy(field.buffer, ab.buffer)
+                          offset: int(ab.offset), length: 0, buffer: ab.buffer)
         ab.offset += int(length)
         return ok(field)
 
@@ -663,8 +660,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass,
                           index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
+                          length: int(length), buffer: ab.buffer)
         ab.offset += int(length)
         return ok(field)
 
@@ -675,8 +671,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass,
                           index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
+                          length: int(length), buffer: ab.buffer)
         ab.offset += int(length)
         return ok(field)
 

libp2p/crypto/rsa.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -13,7 +13,11 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.
 
-{.push raises: Defect.}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
 import bearssl/[rsa, rand, hash]
 import minasn1
 import stew/[results, ctops]

libp2p/crypto/secp.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import bearssl/rand
 import

libp2p/daemon/daemonapi.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+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]
@@ -489,7 +492,7 @@ proc recvMessage(conn: StreamTransport): Future[seq[byte]] {.async.} =
       res = PB.getUVarint(buffer.toOpenArray(0, i), length, size)
       if res.isOk():
         break
-    if res.isErr() or size > MaxMessageSize:
+    if res.isErr() or size > 1'u shl 22:
       buffer.setLen(0)
       result = buffer
       return
@@ -1022,7 +1025,7 @@ proc dhtGetSinglePeerId(pb: ProtoBuffer): PeerId
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
-proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): Protobuffer
+proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
   {.inline, raises: [Defect, DaemonLocalError].} =
   var dhtResponse: seq[byte]
   if pb.getRequiredField(ResponseType.DHT.int, dhtResponse).isOk():

libp2p/daemon/transpool.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 ## This module implements Pool of StreamTransport.
 import chronos

libp2p/debugutils.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))

libp2p/dial.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,13 +7,19 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import chronos
+import stew/results
 import peerid,
        stream/connection,
        transports/transport
 
+export results
+
 type
   Dial* = ref object of RootObj
 
@@ -21,13 +27,22 @@ method connect*(
   self: Dial,
   peerId: PeerId,
   addrs: seq[MultiAddress],
-  forceDial = false) {.async, base.} =
+  forceDial = false,
+  reuseConnection = true) {.async, base.} =
   ## connect remote peer without negotiating
   ## a protocol
   ##
 
   doAssert(false, "Not implemented!")
 
+method connect*(
+  self: Dial,
+  address: MultiAddress,
+  allowUnknownPeerId = false): Future[PeerId] {.async, base.} =
+  ## Connects to a peer and retrieve its PeerId
+
+  doAssert(false, "Not implemented!")
+
 method dial*(
   self: Dial,
   peerId: PeerId,
@@ -55,3 +70,9 @@ method addTransport*(
   self: Dial,
   transport: Transport) {.base.} =
   doAssert(false, "Not implemented!")
+
+method tryDial*(
+  self: Dial,
+  peerId: PeerId,
+  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async, base.} =
+  doAssert(false, "Not implemented!")

libp2p/dialer.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,8 +7,9 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-import std/[sugar, tables]
+import std/[sugar, tables, sequtils]
 
+import stew/results
 import pkg/[chronos,
             chronicles,
             metrics]
@@ -16,14 +17,16 @@ import pkg/[chronos,
 import dial,
        peerid,
        peerinfo,
+       multicodec,
        multistream,
        connmanager,
        stream/connection,
        transports/transport,
        nameresolving/nameresolver,
+       upgrademngrs/upgrade,
        errors
 
-export dial, errors
+export dial, errors, results
 
 logScope:
   topics = "libp2p dialer"
@@ -46,105 +49,152 @@ type
 
 proc dialAndUpgrade(
   self: Dialer,
-  peerId: PeerId,
-  addrs: seq[MultiAddress],
-  forceDial: bool):
+  peerId: Opt[PeerId],
+  hostname: string,
+  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, hostname
+      let dialed =
+        try:
+          libp2p_total_dial_attempts.inc()
+          await transport.dial(hostname, address, peerId)
+        except CancelledError as exc:
+          debug "Dialing canceled", msg = exc.msg, peerId
+          raise exc
+        except CatchableError as exc:
+          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 conn =
+        try:
+          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", msg = exc.msg, peerId
+          if exc isnot CancelledError:
+            libp2p_failed_upgrades_outgoing.inc()
+
+          # Try other address
+          return nil
+
+      doAssert not isNil(conn), "connection died after upgradeOutgoing"
+      debug "Dial successful", conn, peerId = conn.peerId
+      return conn
+  return nil
+
+proc expandDnsAddr(
+  self: Dialer,
+  peerId: Opt[PeerId],
+  address: MultiAddress): Future[seq[(MultiAddress, Opt[PeerId])]] {.async.} =
+
+  if not DNSADDR.matchPartial(address): return @[(address, peerId)]
+  if isNil(self.nameResolver):
+    info "Can't resolve DNSADDR without NameResolver", ma=address
+    return @[]
+
+  let
+    toResolve =
+      if peerId.isSome:
+        address & MultiAddress.init(multiCodec("p2p"), peerId.tryGet()).tryGet()
+      else:
+        address
+    resolved = await self.nameResolver.resolveDnsAddr(toResolve)
+
+  for resolvedAddress in resolved:
+    let lastPart = resolvedAddress[^1].tryGet()
+    if lastPart.protoCode == Result[MultiCodec, string].ok(multiCodec("p2p")):
+      let
+        peerIdBytes = lastPart.protoArgument().tryGet()
+        addrPeerId = PeerId.init(peerIdBytes).tryGet()
+      result.add((resolvedAddress[0..^2].tryGet(), Opt.some(addrPeerId)))
+    else:
+      result.add((resolvedAddress, peerId))
+
+proc dialAndUpgrade(
+  self: Dialer,
+  peerId: Opt[PeerId],
+  addrs: seq[MultiAddress]):
+  Future[Connection] {.async.} =
+
   debug "Dialing peer", peerId
 
-  for address in addrs:      # for each address
-    let
-      hostname = address.getHostname()
-      resolvedAddresses =
-        if isNil(self.nameResolver): @[address]
-        else: await self.nameResolver.resolveMAddress(address)
+  for rawAddress in addrs:
+    # resolve potential dnsaddr
+    let addresses = await self.expandDnsAddr(peerId, rawAddress)
 
-    for a in resolvedAddresses:      # for each resolved address
-      for transport in self.transports: # for each transport
-        if transport.handles(a):   # check if it can dial it
-          trace "Dialing address", address = $a, peerId, hostname
-          let dialed = try:
-              libp2p_total_dial_attempts.inc()
-              # await a connection slot when the total
-              # connection count is equal to `maxConns`
-              #
-              # Need to copy to avoid "cannot be captured" errors in Nim-1.4.x.
-              let
-                transportCopy = transport
-                addressCopy = a
-              await self.connManager.trackOutgoingConn(
-                () => transportCopy.dial(hostname, addressCopy),
-                forceDial
-              )
-            except TooManyConnectionsError as exc:
-              trace "Connection limit reached!"
-              raise exc
-            except CancelledError as exc:
-              debug "Dialing canceled", msg = exc.msg, peerId
-              raise exc
-            except CatchableError as exc:
-              debug "Dialing failed", msg = exc.msg, peerId
-              libp2p_failed_dials.inc()
-              continue # Try the next address
+    for (expandedAddress, addrPeerId) in addresses:
+      # DNS resolution
+      let
+        hostname = expandedAddress.getHostname()
+        resolvedAddresses =
+          if isNil(self.nameResolver): @[expandedAddress]
+          else: await self.nameResolver.resolveMAddress(expandedAddress)
 
-          # make sure to assign the peer to the connection
-          dialed.peerId = peerId
+      for resolvedAddress in resolvedAddresses:
+        result = await self.dialAndUpgrade(addrPeerId, hostname, resolvedAddress)
+        if not isNil(result):
+          return result
 
-          # also keep track of the connection's bottom unsafe transport direction
-          # required by gossipsub scoring
-          dialed.transportDir = Direction.Out
+proc tryReusingConnection(self: Dialer, peerId: PeerId): Future[Opt[Connection]] {.async.} =
+  var conn = self.connManager.selectConn(peerId)
+  if conn == nil:
+    return Opt.none(Connection)
 
-          libp2p_successful_dials.inc()
+  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 conn = try:
-              await transport.upgradeOutgoing(dialed)
-            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", msg = exc.msg, peerId
-              if exc isnot CancelledError:
-                libp2p_failed_upgrades_outgoing.inc()
-              raise exc
-
-          doAssert not isNil(conn), "connection died after upgradeOutgoing"
-          debug "Dial successful", conn, peerId = conn.peerId
-          return conn
+  trace "Reusing existing connection", conn, direction = $conn.dir
+  return Opt.some(conn)
 
 proc internalConnect(
   self: Dialer,
-  peerId: PeerId,
+  peerId: Opt[PeerId],
   addrs: seq[MultiAddress],
-  forceDial: bool):
+  forceDial: bool,
+  reuseConnection = true):
   Future[Connection] {.async.} =
-  if self.localPeerId == peerId:
+  if Opt.some(self.localPeerId) == peerId:
     raise newException(CatchableError, "can't dial self!")
 
   # Ensure there's only one in-flight attempt per peer
-  let lock = self.dialLock.mgetOrPut(peerId, newAsyncLock())
+  let lock = self.dialLock.mgetOrPut(peerId.get(default(PeerId)), newAsyncLock())
   try:
     await lock.acquire()
 
-    # Check if we have a connection already and try to reuse it
-    var conn = self.connManager.selectConn(peerId)
-    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")
+    if peerId.isSome and reuseConnection:
+      let connOpt = await self.tryReusingConnection(peerId.get())
+      if connOpt.isSome:
+        return connOpt.get()
 
-      trace "Reusing existing connection", conn, direction = $conn.dir
-      return conn
-
-    conn = await self.dialAndUpgrade(peerId, addrs, forceDial)
+    let slot = self.connManager.getOutgoingSlot(forceDial)
+    let conn =
+      try:
+        await self.dialAndUpgrade(peerId, addrs)
+      except CatchableError as exc:
+        slot.release()
+        raise exc
+    slot.trackConnection(conn)
     if isNil(conn): # None of the addresses connected
       raise newException(DialFailedError, "Unable to establish outgoing link")
 
-    # We already check for this in Connection manager
-    # but a disconnect could have happened right after
+    # 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():
@@ -163,15 +213,36 @@ method connect*(
   self: Dialer,
   peerId: PeerId,
   addrs: seq[MultiAddress],
-  forceDial = false) {.async.} =
+  forceDial = false,
+  reuseConnection = true) {.async.} =
   ## connect remote peer without negotiating
   ## a protocol
   ##
 
-  if self.connManager.connCount(peerId) > 0:
+  if self.connManager.connCount(peerId) > 0 and reuseConnection:
     return
 
-  discard await self.internalConnect(peerId, addrs, forceDial)
+  discard await self.internalConnect(Opt.some(peerId), addrs, forceDial, reuseConnection)
+
+method connect*(
+  self: Dialer,
+  address: MultiAddress,
+  allowUnknownPeerId = false): Future[PeerId] {.async.} =
+  ## Connects to a peer and retrieve its PeerId
+
+  let fullAddress = parseFullAddress(address)
+  if fullAddress.isOk:
+    return (await self.internalConnect(
+      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,
@@ -185,6 +256,27 @@ proc negotiateStream(
 
   return conn
 
+method tryDial*(
+  self: Dialer,
+  peerId: PeerId,
+  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async.} =
+  ## Create a protocol stream in order to check
+  ## if a connection is possible.
+  ## Doesn't use the Connection Manager to save it.
+  ##
+
+  trace "Check if it can dial", peerId, addrs
+  try:
+    let conn = await self.dialAndUpgrade(Opt.some(peerId), addrs)
+    if conn.isNil():
+      raise newException(DialFailedError, "No valid multiaddress")
+    await conn.close()
+    return conn.observedAddr
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    raise newException(DialFailedError, exc.msg)
+
 method dial*(
   self: Dialer,
   peerId: PeerId,
@@ -223,7 +315,7 @@ method dial*(
 
   try:
     trace "Dialing (new)", peerId, protos
-    conn = await self.internalConnect(peerId, addrs, forceDial)
+    conn = await self.internalConnect(Opt.some(peerId), addrs, forceDial)
     trace "Opening stream", conn
     stream = await self.connManager.getStream(conn)
 

libp2p/discovery/discoverymngr.nim

@@ -0,0 +1,182 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import std/sequtils
+import chronos, chronicles, stew/results
+import ../errors
+
+type
+  BaseAttr = ref object of RootObj
+    comparator: proc(f, c: BaseAttr): bool {.gcsafe, raises: [Defect].}
+
+  Attribute[T] = ref object of BaseAttr
+    value: T
+
+  PeerAttributes* = object
+    attributes: seq[BaseAttr]
+
+  DiscoveryService* = distinct string
+
+proc `==`*(a, b: DiscoveryService): bool {.borrow.}
+
+proc ofType*[T](f: BaseAttr, _: type[T]): bool =
+  return f of Attribute[T]
+
+proc to*[T](f: BaseAttr, _: type[T]): T =
+  Attribute[T](f).value
+
+proc add*[T](pa: var PeerAttributes,
+             value: T) =
+  pa.attributes.add(Attribute[T](
+      value: value,
+      comparator: proc(f: BaseAttr, c: BaseAttr): bool =
+        f.ofType(T) and c.ofType(T) and f.to(T) == c.to(T)
+    )
+  )
+
+iterator items*(pa: PeerAttributes): BaseAttr =
+  for f in pa.attributes:
+    yield f
+
+proc getAll*[T](pa: PeerAttributes, t: typedesc[T]): seq[T] =
+  for f in pa.attributes:
+    if f.ofType(T):
+      result.add(f.to(T))
+
+proc `{}`*[T](pa: PeerAttributes, t: typedesc[T]): Opt[T] =
+  for f in pa.attributes:
+    if f.ofType(T):
+      return Opt.some(f.to(T))
+  Opt.none(T)
+
+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 =
+  for f in pa.attributes:
+    block oneAttribute:
+      for field in candidate.attributes:
+        if field.comparator(field, f):
+          break oneAttribute
+      return false
+  return true
+
+type
+  PeerFoundCallback* = proc(pa: PeerAttributes) {.raises: [Defect], gcsafe.}
+
+  DiscoveryInterface* = ref object of RootObj
+    onPeerFound*: PeerFoundCallback
+    toAdvertise*: PeerAttributes
+    advertisementUpdated*: AsyncEvent
+    advertiseLoop*: Future[void]
+
+method request*(self: DiscoveryInterface, pa: PeerAttributes) {.async, base.} =
+  doAssert(false, "Not implemented!")
+
+method advertise*(self: DiscoveryInterface) {.async, base.} =
+  doAssert(false, "Not implemented!")
+
+type
+  DiscoveryError* = object of LPError
+  DiscoveryFinished* = object of LPError
+
+  DiscoveryQuery* = ref object
+    attr: PeerAttributes
+    peers: AsyncQueue[PeerAttributes]
+    finished: bool
+    futs: seq[Future[void]]
+
+  DiscoveryManager* = ref object
+    interfaces: seq[DiscoveryInterface]
+    queries: seq[DiscoveryQuery]
+
+proc add*(dm: DiscoveryManager, di: DiscoveryInterface) =
+  dm.interfaces &= di
+
+  di.onPeerFound = proc (pa: PeerAttributes) =
+    for query in dm.queries:
+      if query.attr.match(pa):
+        try:
+          query.peers.putNoWait(pa)
+        except AsyncQueueFullError as exc:
+          debug "Cannot push discovered peer to queue"
+
+proc request*(dm: DiscoveryManager, pa: PeerAttributes): DiscoveryQuery =
+  var query = DiscoveryQuery(attr: pa, peers: newAsyncQueue[PeerAttributes]())
+  for i in dm.interfaces:
+    query.futs.add(i.request(pa))
+  dm.queries.add(query)
+  dm.queries.keepItIf(it.futs.anyIt(not it.finished()))
+  return query
+
+proc request*[T](dm: DiscoveryManager, value: T): DiscoveryQuery =
+  var pa: PeerAttributes
+  pa.add(value)
+  return dm.request(pa)
+
+proc advertise*(dm: DiscoveryManager, pa: PeerAttributes) =
+  for i in dm.interfaces:
+    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
+  ## `peer`
+
+  proc forEachInternal(q: DiscoveryQuery) {.async.} =
+    while true:
+      let peer {.inject.} =
+        try: await q.getPeer()
+        except DiscoveryFinished: return
+      code
+
+  asyncSpawn forEachInternal(query)
+
+proc stop*(query: DiscoveryQuery) =
+  query.finished = true
+  for r in query.futs:
+    if not r.finished(): r.cancel()
+
+proc stop*(dm: DiscoveryManager) =
+  for q in dm.queries:
+    q.stop()
+  for i in dm.interfaces:
+    if isNil(i.advertiseLoop): continue
+    i.advertiseLoop.cancel()
+
+proc getPeer*(query: DiscoveryQuery): Future[PeerAttributes] {.async.} =
+  let getter = query.peers.popFirst()
+
+  try:
+    await getter or allFinished(query.futs)
+  except CancelledError as exc:
+    getter.cancel()
+    raise exc
+
+  if not finished(getter):
+    if query.finished:
+      raise newException(DiscoveryFinished, "Discovery query stopped")
+    # discovery loops only finish when they don't handle the query
+    raise newException(DiscoveryError, "Unable to find any peer matching this request")
+  return await getter

libp2p/discovery/rendezvousinterface.nim

@@ -0,0 +1,77 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import sequtils
+import chronos
+import ./discoverymngr,
+       ../protocols/rendezvous,
+       ../peerid
+
+type
+  RendezVousInterface* = ref object of DiscoveryInterface
+    rdv*: RendezVous
+    timeToRequest: Duration
+    timeToAdvertise: Duration
+
+  RdvNamespace* = distinct string
+
+proc `==`*(a, b: RdvNamespace): bool {.borrow.}
+
+method request*(self: RendezVousInterface, pa: PeerAttributes) {.async.} =
+  var namespace = ""
+  for attr in pa:
+    if attr.ofType(RdvNamespace):
+      namespace = string attr.to(RdvNamespace)
+    elif attr.ofType(DiscoveryService):
+      namespace = string attr.to(DiscoveryService)
+    elif attr.ofType(PeerId):
+      namespace = $attr.to(PeerId)
+    else:
+      # unhandled type
+      return
+  while true:
+    for pr in await self.rdv.request(namespace):
+      var peer: PeerAttributes
+      peer.add(pr.peerId)
+      for address in pr.addresses:
+        peer.add(address.address)
+
+      peer.add(DiscoveryService(namespace))
+      peer.add(RdvNamespace(namespace))
+      self.onPeerFound(peer)
+
+    await sleepAsync(self.timeToRequest)
+
+method advertise*(self: RendezVousInterface) {.async.} =
+  while true:
+    var toAdvertise: seq[string]
+    for attr in self.toAdvertise:
+      if attr.ofType(RdvNamespace):
+        toAdvertise.add string attr.to(RdvNamespace)
+      elif attr.ofType(DiscoveryService):
+        toAdvertise.add string attr.to(DiscoveryService)
+      elif attr.ofType(PeerId):
+        toAdvertise.add $attr.to(PeerId)
+
+    self.advertisementUpdated.clear()
+    for toAdv in toAdvertise:
+      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 = MinimumDuration): RendezVousInterface =
+  T(rdv: rdv, timeToRequest: ttr, timeToAdvertise: tta)

libp2p/multiaddress.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implements MultiAddress.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}
 
 import pkg/chronos
@@ -219,6 +222,40 @@ proc onionVB(vb: var VBuffer): bool =
   if vb.readArray(buf) == 12:
     result = true
 
+proc onion3StB(s: string, vb: var VBuffer): bool =
+  try:
+    var parts = s.split(':')
+    if len(parts) != 2:
+      return false
+    if len(parts[0]) != 56:
+      return false
+    var address = Base32Lower.decode(parts[0].toLowerAscii())
+    var nport = parseInt(parts[1])
+    if (nport > 0 and nport < 65536) and len(address) == 35:
+      address.setLen(37)
+      address[35] = cast[byte]((nport shr 8) and 0xFF)
+      address[36] = cast[byte](nport and 0xFF)
+      vb.writeArray(address)
+      result = true
+  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 = (cast[uint16](buf[35]) shl 8) or cast[uint16](buf[36])
+    s = Base32Lower.encode(buf.toOpenArray(0, 34))
+    s.add(":")
+    s.add($nport)
+    result = true
+
+proc onion3VB(vb: var VBuffer): bool =
+  ## ONION address validateBuffer() implementation.
+  var buf: array[37, byte]
+  if vb.readArray(buf) == 37:
+    result = true
+
 proc unixStB(s: string, vb: var VBuffer): bool =
   ## Unix socket name stringToBuffer() implementation.
   if len(s) > 0:
@@ -307,6 +344,11 @@ const
     bufferToString: onionBtS,
     validateBuffer: onionVB
   )
+  TranscoderOnion3* = Transcoder(
+    stringToBuffer: onion3StB,
+    bufferToString: onion3BtS,
+    validateBuffer: onion3VB
+  )
   TranscoderDNS* = Transcoder(
     stringToBuffer: dnsStB,
     bufferToString: dnsBtS,
@@ -360,6 +402,10 @@ const
       mcodec: multiCodec("onion"), kind: Fixed, size: 10,
       coder: TranscoderOnion
     ),
+    MAProtocol(
+      mcodec: multiCodec("onion3"), kind: Fixed, size: 37,
+      coder: TranscoderOnion3
+    ),
     MAProtocol(
       mcodec: multiCodec("ws"), kind: Marker, size: 0
     ),
@@ -416,6 +462,7 @@ const
   IP6* = mapEq("ip6")
   DNS* = mapOr(DNSANY, DNS4, DNS6, DNSADDR)
   IP* = mapOr(IP4, IP6)
+  DNS_OR_IP* = mapOr(DNS, 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"))
@@ -424,6 +471,8 @@ const
   WS* = mapAnd(TCP, mapEq("ws"))
   WSS* = mapAnd(TCP, mapEq("wss"))
   WebSockets* = mapOr(WS, WSS)
+  Onion3* = mapEq("onion3")
+  TcpOnion3* = mapAnd(TCP, Onion3)
 
   Unreliable* = mapOr(UDP)
 
@@ -470,15 +519,10 @@ proc trimRight(s: string, ch: char): string =
       break
   result = s[0..(s.high - m)]
 
-proc shcopy*(m1: var MultiAddress, m2: MultiAddress) =
-  shallowCopy(m1.data.buffer, m2.data.buffer)
-  m1.data.offset = m2.data.offset
-
 proc protoCode*(ma: MultiAddress): MaResult[MultiCodec] =
   ## Returns MultiAddress ``ma`` protocol code.
   var header: uint64
-  var vb: MultiAddress
-  shcopy(vb, ma)
+  var vb = ma
   if vb.data.readVarint(header) == -1:
     err("multiaddress: Malformed binary address!")
   else:
@@ -491,8 +535,7 @@ proc protoCode*(ma: MultiAddress): MaResult[MultiCodec] =
 proc protoName*(ma: MultiAddress): MaResult[string] =
   ## Returns MultiAddress ``ma`` protocol name.
   var header: uint64
-  var vb: MultiAddress
-  shcopy(vb, ma)
+  var vb = ma
   if vb.data.readVarint(header) == -1:
     err("multiaddress: Malformed binary address!")
   else:
@@ -509,9 +552,8 @@ proc protoArgument*(ma: MultiAddress,
   ## If current MultiAddress do not have argument value, then result will be
   ## ``0``.
   var header: uint64
-  var vb: MultiAddress
+  var vb = ma
   var buffer: seq[byte]
-  shcopy(vb, ma)
   if vb.data.readVarint(header) == -1:
     err("multiaddress: Malformed binary address!")
   else:
@@ -527,7 +569,7 @@ proc protoArgument*(ma: MultiAddress,
           err("multiaddress: Decoding protocol error")
         else:
           ok(res)
-      elif proto.kind in {Length, Path}:
+      elif proto.kind in {MAKind.Length, Path}:
         if vb.data.readSeq(buffer) == -1:
           err("multiaddress: Decoding protocol error")
         else:
@@ -548,6 +590,13 @@ proc protoAddress*(ma: MultiAddress): MaResult[seq[byte]] =
   buffer.setLen(res)
   ok(buffer)
 
+proc protoArgument*(ma: MultiAddress): MaResult[seq[byte]] =
+  ## Returns MultiAddress ``ma`` protocol address binary blob.
+  ##
+  ## If current MultiAddress do not have argument value, then result array will
+  ## be empty.
+  ma.protoAddress()
+
 proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
   var header: uint64
   var data = newSeq[byte]()
@@ -555,6 +604,9 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
   var vb = ma
   var res: MultiAddress
   res.data = initVBuffer()
+
+  if index < 0: return err("multiaddress: negative index gived to getPart")
+
   while offset <= index:
     if vb.data.readVarint(header) == -1:
       return err("multiaddress: Malformed binary address!")
@@ -572,7 +624,7 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
         res.data.writeVarint(header)
         res.data.writeArray(data)
         res.data.finish()
-    elif proto.kind in {Length, Path}:
+    elif proto.kind in {MAKind.Length, Path}:
       if vb.data.readSeq(data) == -1:
         return err("multiaddress: Decoding protocol error")
 
@@ -587,9 +639,31 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
     inc(offset)
   ok(res)
 
-proc `[]`*(ma: MultiAddress, i: int): MaResult[MultiAddress] {.inline.} =
+proc getParts[U, V](ma: MultiAddress, slice: HSlice[U, V]): MaResult[MultiAddress] =
+  when slice.a is BackwardsIndex or slice.b is BackwardsIndex:
+    let maLength = ? len(ma)
+  template normalizeIndex(index): int =
+    when index is BackwardsIndex: maLength - int(index)
+    else: int(index)
+  let
+    indexStart = normalizeIndex(slice.a)
+    indexEnd = normalizeIndex(slice.b)
+  var res: MultiAddress
+  for i in indexStart..indexEnd:
+    ? res.append(? ma[i])
+  ok(res)
+
+proc `[]`*(ma: MultiAddress, i: int | BackwardsIndex): MaResult[MultiAddress] {.inline.} =
   ## Returns part with index ``i`` of MultiAddress ``ma``.
-  ma.getPart(i)
+  when i is BackwardsIndex:
+    let maLength = ? len(ma)
+    ma.getPart(maLength - int(i))
+  else:
+    ma.getPart(i)
+
+proc `[]`*(ma: MultiAddress, slice: HSlice): MaResult[MultiAddress] {.inline.} =
+  ## Returns parts with slice ``slice`` of MultiAddress ``ma``.
+  ma.getParts(slice)
 
 iterator items*(ma: MultiAddress): MaResult[MultiAddress] =
   ## Iterates over all addresses inside of MultiAddress ``ma``.
@@ -616,7 +690,7 @@ iterator items*(ma: MultiAddress): MaResult[MultiAddress] =
 
       res.data.writeVarint(header)
       res.data.writeArray(data)
-    elif proto.kind in {Length, Path}:
+    elif proto.kind in {MAKind.Length, Path}:
       if vb.data.readSeq(data) == -1:
         yield err(MaResult[MultiAddress], "Decoding protocol error")
 
@@ -627,6 +701,13 @@ iterator items*(ma: MultiAddress): MaResult[MultiAddress] =
     res.data.finish()
     yield ok(MaResult[MultiAddress], res)
 
+proc len*(ma: MultiAddress): MaResult[int] =
+  var counter: int
+  for part in ma:
+    if part.isErr: return err(part.error)
+    counter.inc()
+  ok(counter)
+
 proc contains*(ma: MultiAddress, codec: MultiCodec): MaResult[bool] {.inline.} =
   ## Returns ``true``, if address with MultiCodec ``codec`` present in
   ## MultiAddress ``ma``.
@@ -707,8 +788,7 @@ proc encode*(mbtype: typedesc[MultiBase], encoding: string,
 proc validate*(ma: MultiAddress): bool =
   ## Returns ``true`` if MultiAddress ``ma`` is valid.
   var header: uint64
-  var vb: MultiAddress
-  shcopy(vb, ma)
+  var vb = ma
   while true:
     if vb.data.isEmpty():
       break
@@ -1007,6 +1087,9 @@ proc `$`*(pat: MaPattern): string =
   elif pat.operator == Eq:
     result = $pat.value
 
+proc bytes*(value: MultiAddress): seq[byte] =
+  value.data.buffer
+
 proc write*(pb: var ProtoBuffer, field: int, value: MultiAddress) {.inline.} =
   write(pb, field, value.data.buffer)
 

libp2p/multibase.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -13,7 +13,10 @@
 ## 1. base32z
 ##
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import tables
 import stew/[base32, base58, base64, results]

libp2p/multicodec.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implements MultiCodec.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import tables, hashes
 import varint, vbuffer
@@ -200,6 +203,7 @@ const MultiCodecList = [
   ("p2p-webrtc-star", 0x0113), # not in multicodec list
   ("p2p-webrtc-direct", 0x0114), # not in multicodec list
   ("onion", 0x01BC),
+  ("onion3", 0x01BD),
   ("p2p-circuit", 0x0122),
   ("libp2p-peer-record", 0x0301),
   ("dns", 0x35),

libp2p/multihash.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -21,7 +21,10 @@
 ## 1. SKEIN
 ## 2. MURMUR
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import tables
 import nimcrypto/[sha, sha2, keccak, blake2, hash, utils]

libp2p/multistream.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,9 +7,12 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
-import std/[strutils, sequtils]
+import std/[strutils, sequtils, tables]
 import chronos, chronicles, stew/byteutils
 import stream/connection,
        protocols/protocol
@@ -18,7 +21,7 @@ logScope:
   topics = "libp2p multistream"
 
 const
-  MsgSize* = 64*1024
+  MsgSize* = 1024
   Codec* = "/multistream/1.0.0"
 
   MSCodec* = "\x13" & Codec & "\n"
@@ -30,17 +33,20 @@ type
 
   MultiStreamError* = object of LPError
 
-  HandlerHolder* = object
+  HandlerHolder* = ref object
     protos*: seq[string]
     protocol*: LPProtocol
     match*: Matcher
+    openedStreams: CountTable[PeerId]
 
   MultistreamSelect* = ref object of RootObj
     handlers*: seq[HandlerHolder]
     codec*: string
 
 proc new*(T: typedesc[MultistreamSelect]): T =
-  T(codec: MSCodec)
+  T(
+    codec: MSCodec,
+  )
 
 template validateSuffix(str: string): untyped =
     if str.endsWith("\n"):
@@ -76,7 +82,7 @@ proc select*(m: MultistreamSelect,
     trace "reading first requested proto", conn
     if s == proto[0]:
       trace "successfully selected ", conn, proto = proto[0]
-      conn.tag = proto[0]
+      conn.protocol = proto[0]
       return proto[0]
     elif proto.len > 1:
       # Try to negotiate alternatives
@@ -89,7 +95,7 @@ proc select*(m: MultistreamSelect,
         validateSuffix(s)
         if s == p:
           trace "selected protocol", conn, protocol = s
-          conn.tag = s
+          conn.protocol = s
           return s
       return ""
     else:
@@ -166,9 +172,22 @@ proc handle*(m: MultistreamSelect, conn: Connection, active: bool = false) {.asy
         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
-            await conn.writeLp(ms & "\n")
-            conn.tag = ms
-            await h.protocol.handler(conn, 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)

libp2p/muxers/mplex/coder.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import pkg/[chronos, nimcrypto/utils, chronicles, stew/byteutils]
 import ../../stream/connection,

libp2p/muxers/mplex/lpchannel.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[oids, strformat]
 import pkg/[chronos, chronicles, metrics, nimcrypto/utils]
@@ -55,10 +58,13 @@ type
     initiator*: bool              # initiated remotely or locally flag
     isOpen*: bool                 # has channel been opened
     closedLocal*: bool            # has channel been closed locally
+    remoteReset*: bool            # has channel been remotely reset
+    localReset*: bool             # has channel been reset locally
     msgCode*: MessageType         # cached in/out message code
     closeCode*: MessageType       # cached in/out close code
     resetCode*: MessageType       # cached in/out reset code
     writes*: int                  # In-flight writes
+    writesBytes*: int             # In-flight writes bytes
 
 func shortLog*(s: LPChannel): auto =
   try:
@@ -84,7 +90,7 @@ proc open*(s: LPChannel) {.async, gcsafe.} =
     await s.conn.close()
     raise exc
 
-method closed*(s: LPChannel): bool {.raises: [Defect].} =
+method closed*(s: LPChannel): bool =
   s.closedLocal
 
 proc closeUnderlying(s: LPChannel): Future[void] {.async.} =
@@ -100,6 +106,7 @@ proc reset*(s: LPChannel) {.async, gcsafe.} =
 
   s.isClosed = true
   s.closedLocal = true
+  s.localReset = not s.remoteReset
 
   trace "Resetting channel", s, len = s.len
 
@@ -165,11 +172,19 @@ method readOnce*(s: LPChannel,
   ## channels are blocked - in particular, this means that reading from one
   ## channel must not be done from within a callback / read handler of another
   ## or the reads will lock each other.
+  if s.remoteReset:
+    raise newLPStreamResetError()
+  if s.localReset:
+    raise newLPStreamClosedError()
+  if s.atEof():
+    raise newLPStreamRemoteClosedError()
+  if s.conn.closed:
+    raise newLPStreamConnDownError()
   try:
     let bytes = await procCall BufferStream(s).readOnce(pbytes, nbytes)
     when defined(libp2p_network_protocols_metrics):
-      if s.tag.len > 0:
-        libp2p_protocols_bytes.inc(bytes.int64, labelValues=[s.tag, "in"])
+      if s.protocol.len > 0:
+        libp2p_protocols_bytes.inc(bytes.int64, labelValues=[s.protocol, "in"])
 
     trace "readOnce", s, bytes
     if bytes == 0:
@@ -181,13 +196,17 @@ method readOnce*(s: LPChannel,
     # data has been lost in s.readBuf and there's no way to gracefully recover /
     # use the channel any more
     await s.reset()
-    raise exc
+    raise newLPStreamConnDownError(exc)
 
 proc prepareWrite(s: LPChannel, msg: seq[byte]): Future[void] {.async.} =
   # prepareWrite is the slow path of writing a message - see conditions in
   # write
-  if s.closedLocal or s.conn.closed:
+  if s.remoteReset:
+    raise newLPStreamResetError()
+  if s.closedLocal:
     raise newLPStreamClosedError()
+  if s.conn.closed:
+    raise newLPStreamConnDownError()
 
   if msg.len == 0:
     return
@@ -210,6 +229,7 @@ proc completeWrite(
     s: LPChannel, fut: Future[void], msgLen: int): Future[void] {.async.} =
   try:
     s.writes += 1
+    s.writesBytes += msgLen
 
     when defined(libp2p_mplex_metrics):
       libp2p_mplex_qlen.observe(s.writes.int64 - 1)
@@ -219,22 +239,30 @@ proc completeWrite(
       await fut
 
     when defined(libp2p_network_protocol_metrics):
-      if s.tag.len > 0:
-        libp2p_protocols_bytes.inc(msgLen.int64, labelValues=[s.tag, "out"])
+      if s.protocol.len > 0:
+        libp2p_protocols_bytes.inc(msgLen.int64, labelValues=[s.protocol, "out"])
 
     s.activity = true
   except CancelledError as exc:
     # Chronos may still send the data
     raise exc
-  except LPStreamClosedError as exc:
+  except LPStreamConnDownError as exc:
+    await s.reset()
+    await s.conn.close()
+    raise exc
+  except LPStreamEOFError as exc:
     raise exc
   except CatchableError as exc:
     trace "exception in lpchannel write handler", s, msg = exc.msg
     await s.reset()
     await s.conn.close()
-    raise exc
+    raise newLPStreamConnDownError(exc)
   finally:
     s.writes -= 1
+    s.writesBytes -= msgLen
+
+
+method queuedSendBytes*(channel: LPChannel): int = channel.writesBytes
 
 method write*(s: LPChannel, msg: seq[byte]): Future[void] =
   ## Write to mplex channel - there may be up to MaxWrite concurrent writes
@@ -254,6 +282,8 @@ method write*(s: LPChannel, msg: seq[byte]): Future[void] =
 
   s.completeWrite(fut, msg.len)
 
+method getWrapped*(s: LPChannel): Connection = s.conn
+
 proc init*(
   L: type LPChannel,
   id: uint64,

libp2p/muxers/mplex/mplex.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import tables, sequtils, oids
 import chronos, chronicles, stew/byteutils, metrics
@@ -34,7 +37,6 @@ when defined(libp2p_expensive_metrics):
     "mplex channels", labels = ["initiator", "peer"])
 
 type
-  TooManyChannels* = object of MuxerError
   InvalidChannelIdError* = object of MuxerError
 
   Mplex* = ref object of Muxer
@@ -175,12 +177,19 @@ method handle*(m: Mplex) {.async, gcsafe.} =
             raise newLPStreamLimitError()
 
           trace "pushing data to channel", m, channel, len = data.len
-          await channel.pushData(data)
-          trace "pushed 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.
 
         of MessageType.CloseIn, MessageType.CloseOut:
           await channel.pushEof()
         of MessageType.ResetIn, MessageType.ResetOut:
+          channel.remoteReset = true
           await channel.reset()
   except CancelledError:
     debug "Unexpected cancellation in mplex handler", m

libp2p/muxers/muxer.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import chronos, chronicles
 import ../protocols/protocol,
@@ -22,6 +25,7 @@ const
 
 type
   MuxerError* = object of LPError
+  TooManyChannels* = object of MuxerError
 
   StreamHandler* = proc(conn: Connection): Future[void] {.gcsafe, raises: [Defect].}
   MuxerHandler* = proc(muxer: Muxer): Future[void] {.gcsafe, raises: [Defect].}

libp2p/muxers/yamux/yamux.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import sequtils, std/[tables]
-import chronos, chronicles, stew/[endians2, byteutils, objects]
+import chronos, chronicles, metrics, stew/[endians2, byteutils, objects]
 import ../muxer,
        ../../stream/connection
 
@@ -23,6 +26,14 @@ const
   YamuxCodec* = "/yamux/1.0.0"
   YamuxVersion = 0.uint8
   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, 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, 1600.0, 6400.0, 25600.0, 256000.0]
 
 type
   YamuxError* = object of CatchableError
@@ -142,6 +153,7 @@ type
     sendQueue: seq[ToSend]
     recvQueue: seq[byte]
     isReset: bool
+    remoteReset: bool
     closedRemotely: Future[void]
     closedLocally: bool
     receivedData: AsyncEvent
@@ -164,6 +176,8 @@ 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))
 
+method queuedSendBytes*(channel: YamuxChannel): int = channel.sendQueueBytes()
+
 proc actuallyClose(channel: YamuxChannel) {.async.} =
   if channel.closedLocally and channel.sendQueue.len == 0 and
      channel.closedRemotely.done():
@@ -183,22 +197,25 @@ method closeImpl*(channel: YamuxChannel) {.async, gcsafe.} =
     await channel.actuallyClose()
 
 proc reset(channel: YamuxChannel, isLocal: bool = false) {.async.} =
-  if not channel.isReset:
-    trace "Reset channel"
-    channel.isReset = true
-    for (d, s, fut) in channel.sendQueue:
-      fut.fail(newLPStreamEOFError())
-    channel.sendQueue = @[]
-    channel.recvQueue = @[]
-    channel.sendWindow = 0
-    if not channel.closedLocally:
-      if isLocal:
-        try: await channel.conn.write(YamuxHeader.data(channel.id, 0, {Rst}))
-        except LPStreamEOFError as exc: discard
-      await channel.close()
-    if not channel.closedRemotely.done():
-      await channel.remoteClosed()
-    channel.receivedData.fire()
+  if channel.isReset:
+    return
+  trace "Reset channel"
+  channel.isReset = true
+  channel.remoteReset = not isLocal
+  for (d, s, fut) in channel.sendQueue:
+    fut.fail(newLPStreamEOFError())
+  channel.sendQueue = @[]
+  channel.recvQueue = @[]
+  channel.sendWindow = 0
+  if not channel.closedLocally:
+    if isLocal:
+      try: await channel.conn.write(YamuxHeader.data(channel.id, 0, {Rst}))
+      except LPStreamEOFError as exc: discard
+      except LPStreamClosedError as exc: discard
+    await channel.close()
+  if not channel.closedRemotely.done():
+    await channel.remoteClosed()
+  channel.receivedData.fire()
   if not isLocal:
     # If we reset locally, we want to flush up to a maximum of recvWindow
     # bytes. We use the recvWindow in the proc cleanupChann.
@@ -223,7 +240,15 @@ method readOnce*(
   nbytes: int):
   Future[int] {.async.} =
 
-  if channel.returnedEof: raise newLPStreamEOFError()
+  if channel.isReset:
+    raise if channel.remoteReset:
+        newLPStreamResetError()
+      elif channel.closedLocally:
+        newLPStreamClosedError()
+      else:
+        newLPStreamConnDownError()
+  if channel.returnedEof:
+    raise newLPStreamRemoteClosedError()
   if channel.recvQueue.len == 0:
     channel.receivedData.clear()
     await channel.closedRemotely or channel.receivedData.wait()
@@ -246,6 +271,8 @@ proc gotDataFromRemote(channel: YamuxChannel, b: seq[byte]) {.async.} =
   channel.recvWindow -= b.len
   channel.recvQueue = channel.recvQueue.concat(b)
   channel.receivedData.fire()
+  when defined(libp2p_yamux_metrics):
+    libp2p_yamux_recv_queue.observe(channel.recvQueue.len.int64)
   await channel.updateRecvWindow()
 
 proc setMaxRecvWindow*(channel: YamuxChannel, maxRecvWindow: int) =
@@ -261,7 +288,12 @@ proc trySend(channel: YamuxChannel) {.async.} =
     if channel.sendWindow == 0:
       trace "send window empty"
       if channel.sendQueueBytes(true) > channel.maxRecvWindow:
-        await channel.reset(true)
+        debug "channel send queue too big, resetting", maxSendWindow=channel.maxRecvWindow,
+          currentQueueSize = channel.sendQueueBytes(true)
+        try:
+          await channel.reset(true)
+        except CatchableError as exc:
+          debug "failed to reset", msg=exc.msg
       break
 
     let
@@ -293,9 +325,10 @@ proc trySend(channel: YamuxChannel) {.async.} =
     trace "build send buffer", h = $header, msg=string.fromBytes(sendBuffer[12..^1])
     channel.sendWindow.dec(toSend)
     try: await channel.conn.write(sendBuffer)
-    except LPStreamEOFError as exc:
+    except CatchableError as exc:
+      let connDown = newLPStreamConnDownError(exc)
       for fut in futures.items():
-        fut.fail(exc)
+        fut.fail(connDown)
       await channel.reset()
       break
     for fut in futures.items():
@@ -304,13 +337,18 @@ proc trySend(channel: YamuxChannel) {.async.} =
 
 method write*(channel: YamuxChannel, msg: seq[byte]): Future[void] =
   result = newFuture[void]("Yamux Send")
+  if channel.remoteReset:
+    result.fail(newLPStreamResetError())
+    return result
   if channel.closedLocally or channel.isReset:
-    result.fail(newLPStreamEOFError())
+    result.fail(newLPStreamClosedError())
     return result
   if msg.len == 0:
     result.complete()
     return result
   channel.sendQueue.add((msg, 0, result))
+  when defined(libp2p_yamux_metrics):
+    libp2p_yamux_recv_queue.observe(channel.sendQueueBytes().int64)
   asyncSpawn channel.trySend()
 
 proc open*(channel: YamuxChannel) {.async, gcsafe.} =
@@ -326,10 +364,17 @@ type
     flushed: Table[uint32, int]
     currentId: uint32
     isClosed: bool
+    maxChannCount: int
+
+proc lenBySrc(m: Yamux, isSrc: bool): int =
+  for v in m.channels.values():
+    if v.isSrc == isSrc: result += 1
 
 proc cleanupChann(m: Yamux, channel: YamuxChannel) {.async.} =
   await channel.join()
   m.channels.del(channel.id)
+  when defined(libp2p_yamux_metrics):
+    libp2p_yamux_channels.set(m.lenBySrc(channel.isSrc).int64, [$channel.isSrc, $channel.peerId])
   if channel.isReset and channel.recvWindow > 0:
     m.flushed[channel.id] = channel.recvWindow
 
@@ -344,6 +389,11 @@ proc createStream(m: Yamux, id: uint32, isSrc: bool): YamuxChannel =
     receivedData: newAsyncEvent(),
     closedRemotely: newFuture[void]()
   )
+  result.objName = "YamuxStream"
+  result.dir = if isSrc: Direction.Out else: Direction.In
+  result.timeoutHandler = proc(): Future[void] {.gcsafe.} =
+    trace "Idle timeout expired, resetting YamuxChannel"
+    result.reset()
   result.initStream()
   result.peerId = m.connection.peerId
   result.observedAddr = m.connection.observedAddr
@@ -353,6 +403,8 @@ proc createStream(m: Yamux, id: uint32, isSrc: bool): YamuxChannel =
   m.channels[id] = 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])
 
 method close*(m: Yamux) {.async.} =
   if m.isClosed == true:
@@ -361,9 +413,11 @@ method close*(m: Yamux) {.async.} =
   m.isClosed = true
 
   trace "Closing yamux"
-  for channel in m.channels.values:
-    await channel.reset()
-  await m.connection.write(YamuxHeader.goAway(NormalTermination))
+  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.close()
   trace "Closed yamux"
 
@@ -405,6 +459,9 @@ method handle*(m: Yamux) {.async, gcsafe.} =
             if header.streamId mod 2 == m.currentId mod 2:
               raise newException(YamuxError, "Peer used our reserved stream id")
             let newStream = m.createStream(header.streamId, false)
+            if m.channels.len >= m.maxChannCount:
+              await newStream.reset()
+              continue
             await newStream.open()
             asyncSpawn m.handleStream(newStream)
         elif header.streamId notin m.channels:
@@ -415,8 +472,9 @@ method handle*(m: Yamux) {.async, gcsafe.} =
             m.flushed[header.streamId].dec(int(header.length))
             if m.flushed[header.streamId] < 0:
               raise newException(YamuxError, "Peer exhausted the recvWindow after reset")
-            var buffer = newSeqUninitialized[byte](header.length)
-            await m.connection.readExactly(addr buffer[0], int(header.length))
+            if header.length > 0:
+              var buffer = newSeqUninitialized[byte](header.length)
+              await m.connection.readExactly(addr buffer[0], int(header.length))
           continue
 
         let channel = m.channels[header.streamId]
@@ -455,14 +513,17 @@ method newStream*(
   name: string = "",
   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.currentId += 2
   if not lazy:
     await stream.open()
   return stream
 
-proc new*(T: type[Yamux], conn: Connection): T =
+proc new*(T: type[Yamux], conn: Connection, maxChannCount: int = MaxChannelCount): T =
   T(
     connection: conn,
-    currentId: if conn.dir == Out: 1 else: 2
+    currentId: if conn.dir == Out: 1 else: 2,
+    maxChannCount: maxChannCount
   )

libp2p/nameresolving/dnsresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,11 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import
   std/[streams, strutils, sets, sequtils],
-  chronos, chronicles,
+  chronos, chronicles, stew/byteutils,
   dnsclientpkg/[protocol, types]
 
 import
@@ -73,15 +76,11 @@ proc getDnsResponse(
     if not receivedDataFuture.finished:
       raise newException(IOError, "DNS server timeout")
 
-    var
-      rawResponse = sock.getMessage()
-      dataStream = newStringStream()
-    dataStream.writeData(addr rawResponse[0], rawResponse.len)
-    dataStream.setPosition(0)
+    let rawResponse = sock.getMessage()
     # parseResponse can has a raises: [Exception, ..] because of
     # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
     # it can't actually raise though
-    return parseResponse(dataStream)
+    return parseResponse(string.fromBytes(rawResponse))
   except CatchableError as exc: raise exc
   except Exception as exc: raiseAssert exc.msg
   finally:
@@ -115,7 +114,14 @@ method resolveIp*(
       try:
         let resp = await fut
         for answer in resp.answers:
-          resolvedAddresses.incl(answer.toString())
+          # toString can has a raises: [Exception, ..] because of
+          # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+          # it can't actually raise though
+          resolvedAddresses.incl(
+            try: answer.toString()
+            except CatchableError as exc: raise exc
+            except Exception as exc: raiseAssert exc.msg
+          )
       except CancelledError as e:
         raise e
       except ValueError as e:
@@ -155,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 @[]

libp2p/nameresolving/mockresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import
   std/[streams, strutils, tables],

libp2p/nameresolving/nameresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,10 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[sugar, sets, sequtils, strutils]
-import 
+import
   chronos,
   chronicles,
   stew/[endians2, byteutils]
@@ -19,14 +22,14 @@ import ".."/[multiaddress, multicodec]
 logScope:
   topics = "libp2p nameresolver"
 
-type 
+type
   NameResolver* = ref object of RootObj
 
 method resolveTxt*(
   self: NameResolver,
   address: string): Future[seq[string]] {.async, base.} =
   ## Get TXT record
-  ## 
+  ##
 
   doAssert(false, "Not implemented!")
 
@@ -36,16 +39,18 @@ method resolveIp*(
   port: Port,
   domain: Domain = Domain.AF_UNSPEC): Future[seq[TransportAddress]] {.async, base.} =
   ## Resolve the specified address
-  ## 
+  ##
 
   doAssert(false, "Not implemented!")
 
 proc getHostname*(ma: MultiAddress): string =
-  let firstPart = ($ma[0].get()).split('/')
-  if firstPart.len > 1: firstPart[2]
+  let
+    firstPart = ma[0].valueOr: return ""
+    fpSplitted = ($firstPart).split('/', 2)
+  if fpSplitted.len > 2: fpSplitted[2]
   else: ""
 
-proc resolveDnsAddress(
+proc resolveOneAddress(
   self: NameResolver,
   ma: MultiAddress,
   domain: Domain = Domain.AF_UNSPEC,
@@ -61,29 +66,22 @@ proc resolveDnsAddress(
   let
     port = Port(fromBytesBE(uint16, pbuf))
     resolvedAddresses = await self.resolveIp(prefix & dnsval, port, domain)
- 
+
   return collect(newSeqOfCap(4)):
     for address in resolvedAddresses:
       var createdAddress = MultiAddress.init(address).tryGet()[0].tryGet()
       for part in ma:
-        if DNS.match(part.get()): continue
+        if DNS.match(part.tryGet()): continue
         createdAddress &= part.tryGet()
       createdAddress
 
-func matchDnsSuffix(m1, m2: MultiAddress): MaResult[bool] =
-  for partMaybe in m1:
-    let part = ?partMaybe
-    if DNS.match(part): continue
-    let entryProt = ?m2[?part.protoCode()]
-    if entryProt != part:
-      return ok(false)
-  return ok(true)
-
-proc resolveDnsAddr(
+proc resolveDnsAddr*(
   self: NameResolver,
   ma: MultiAddress,
-  depth: int = 0): Future[seq[MultiAddress]]
-  {.async.} =
+  depth: int = 0): Future[seq[MultiAddress]] {.async.} =
+
+  if not DNSADDR.matchPartial(ma):
+    return @[ma]
 
   trace "Resolving dnsaddr", ma
   if depth > 6:
@@ -101,21 +99,17 @@ proc resolveDnsAddr(
     if not entry.startsWith("dnsaddr="): continue
     let entryValue = MultiAddress.init(entry[8..^1]).tryGet()
 
-    if not matchDnsSuffix(ma, entryValue).tryGet(): continue
+    if entryValue.contains(multiCodec("p2p")).tryGet() and ma.contains(multiCodec("p2p")).tryGet():
+      if entryValue[multiCodec("p2p")] != ma[multiCodec("p2p")]:
+        continue
 
-    # The spec is not clear wheter only DNSADDR can be recursived
-    # or any DNS addr. Only handling DNSADDR because it's simpler
-    # to avoid infinite recursion
-    if DNSADDR.matchPartial(entryValue):
-      let resolved = await self.resolveDnsAddr(entryValue, depth + 1)
-      for r in resolved:
-        result.add(r)
-    else:
-      result.add(entryValue)
+    let resolved = await self.resolveDnsAddr(entryValue, depth + 1)
+    for r in resolved:
+      result.add(r)
 
   if result.len == 0:
-    debug "Failed to resolve any DNSADDR", ma
-    return @[ma]
+    debug "Failed to resolve a DNSADDR", ma
+    return @[]
   return result
 
 
@@ -130,14 +124,15 @@ proc resolveMAddress*(
     let code = address[0].get().protoCode().get()
     let seq = case code:
       of multiCodec("dns"):
-        await self.resolveDnsAddress(address)
+        await self.resolveOneAddress(address)
       of multiCodec("dns4"):
-        await self.resolveDnsAddress(address, Domain.AF_INET)
+        await self.resolveOneAddress(address, Domain.AF_INET)
       of multiCodec("dns6"):
-        await self.resolveDnsAddress(address, Domain.AF_INET6)
+        await self.resolveOneAddress(address, Domain.AF_INET6)
       of multiCodec("dnsaddr"):
         await self.resolveDnsAddr(address)
       else:
+        doAssert false
         @[address]
     for ad in seq:
       res.incl(ad)

libp2p/peerid.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implementes API for libp2p peer.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}
 
 import
@@ -40,7 +43,7 @@ func shortLog*(pid: PeerId): string =
   var spid = $pid
   if len(spid) > 10:
     spid[3] = '*'
-    
+
     when (NimMajor, NimMinor) > (1, 4):
       spid.delete(4 .. spid.high - 6)
     else:
@@ -145,7 +148,7 @@ func init*(pid: var PeerId, data: string): bool =
   if Base58.decode(data, p, length) == Base58Status.Success:
     p.setLen(length)
     var opid: PeerId
-    shallowCopy(opid.data, p)
+    opid.data = p
     if opid.validate():
       pid = opid
       result = true
@@ -181,6 +184,11 @@ func init*(t: typedesc[PeerId], seckey: PrivateKey): Result[PeerId, cstring] =
   ## Create new peer id from private key ``seckey``.
   PeerId.init(? seckey.getPublicKey().orError(cstring("invalid private key")))
 
+proc random*(t: typedesc[PeerId], rng = newRng()): Result[PeerId, cstring] =
+  ## Create new peer id with random public key.
+  let randomKey = PrivateKey.random(Secp256k1, rng[])[]
+  PeerId.init(randomKey).orError(cstring("failed to generate random key"))
+
 func match*(pid: PeerId, pubkey: PublicKey): bool =
   ## Returns ``true`` if ``pid`` matches public key ``pubkey``.
   let p = PeerId.init(pubkey)

libp2p/peerinfo.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,23 +7,32 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 {.push public.}
 
 import std/[options, sequtils]
 import pkg/[chronos, chronicles, stew/results]
-import peerid, multiaddress, crypto/crypto, routing_record, errors, utility
+import peerid, multiaddress, multicodec, crypto/crypto, routing_record, errors, utility
 
 export peerid, multiaddress, crypto, routing_record, errors, results
 
 ## Our local peer info
 
 type
-  PeerInfoError* = LPError
+  PeerInfoError* = object of LPError
+
+  AddressMapper* =
+    proc(listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]]
+      {.gcsafe, raises: [Defect].}
 
   PeerInfo* {.public.} = ref object
     peerId*: PeerId
-    addrs*: seq[MultiAddress]
+    listenAddrs*: seq[MultiAddress]
+    addrs: seq[MultiAddress]
+    addressMappers*: seq[AddressMapper]
     protocols*: seq[string]
     protoVersion*: string
     agentVersion*: string
@@ -34,6 +43,7 @@ type
 func shortLog*(p: PeerInfo): auto =
   (
     peerId: $p.peerId,
+    listenAddrs: mapIt(p.listenAddrs, $it),
     addrs: mapIt(p.addrs, $it),
     protocols: mapIt(p.protocols, $it),
     protoVersion: p.protoVersion,
@@ -41,7 +51,11 @@ func shortLog*(p: PeerInfo): auto =
   )
 chronicles.formatIt(PeerInfo): shortLog(it)
 
-proc update*(p: PeerInfo) =
+proc update*(p: PeerInfo) {.async.} =
+  p.addrs = p.listenAddrs
+  for mapper in p.addressMappers:
+    p.addrs = await mapper(p.addrs)
+
   let sprRes = SignedPeerRecord.init(
     p.privateKey,
     PeerRecord.init(p.peerId, p.addrs)
@@ -52,21 +66,47 @@ proc update*(p: PeerInfo) =
     discard
     #info "Can't update the signed peer record"
 
+proc addrs*(p: PeerInfo): seq[MultiAddress] =
+  p.addrs
+
+proc fullAddrs*(p: PeerInfo): MaResult[seq[MultiAddress]] =
+  let peerIdPart = ? MultiAddress.init(multiCodec("p2p"), p.peerId.data)
+  var res: seq[MultiAddress]
+  for address in p.addrs:
+    res.add(? concat(address, peerIdPart))
+  ok(res)
+
+proc parseFullAddress*(ma: MultiAddress): MaResult[(PeerId, MultiAddress)] =
+  let p2pPart = ? ma[^1]
+  if ? p2pPart.protoCode != multiCodec("p2p"):
+    return err("Missing p2p part from multiaddress!")
+
+  let res = (
+    ? PeerId.init(? p2pPart.protoArgument()).orErr("invalid peerid"),
+    ? ma[0 .. ^2]
+  )
+  ok(res)
+
+proc parseFullAddress*(ma: string | seq[byte]): MaResult[(PeerId, MultiAddress)] =
+  parseFullAddress(? MultiAddress.init(ma))
+
 proc new*(
   p: typedesc[PeerInfo],
   key: PrivateKey,
-  addrs: openArray[MultiAddress] = [],
+  listenAddrs: openArray[MultiAddress] = [],
   protocols: openArray[string] = [],
   protoVersion: string = "",
-  agentVersion: string = ""): PeerInfo
-  {.raises: [Defect, PeerInfoError].} =
+  agentVersion: string = "",
+  addressMappers = newSeq[AddressMapper](),
+  ): PeerInfo
+  {.raises: [Defect, LPError].} =
 
   let pubkey = try:
       key.getPublicKey().tryGet()
     except CatchableError:
       raise newException(PeerInfoError, "invalid private key")
-  
-  let peerId = PeerID.init(key).tryGet()
+
+  let peerId = PeerId.init(key).tryGet()
 
   let peerInfo = PeerInfo(
     peerId: peerId,
@@ -74,10 +114,9 @@ proc new*(
     privateKey: key,
     protoVersion: protoVersion,
     agentVersion: agentVersion,
-    addrs: @addrs,
+    listenAddrs: @listenAddrs,
     protocols: @protocols,
+    addressMappers: addressMappers
   )
 
-  peerInfo.update()
-
   return peerInfo

libp2p/peerstore.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -16,13 +16,15 @@ runnableExamples:
   # Create a custom book type
   type MoodBook = ref object of PeerBook[string]
 
-  var somePeerId: PeerId
-  discard somePeerId.init("")
+  var somePeerId = PeerId.random().get()
 
   peerStore[MoodBook][somePeerId] = "Happy"
   doAssert peerStore[MoodBook][somePeerId] == "Happy"
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import
   std/[tables, sets, options, macros],
@@ -150,6 +152,9 @@ proc updatePeerInfo*(
   if info.addrs.len > 0:
     peerStore[AddressBook][info.peerId] = info.addrs
 
+  if info.pubkey.isSome:
+    peerStore[KeyBook][info.peerId] = info.pubkey.get()
+
   if info.agentVersion.isSome:
     peerStore[AgentBook][info.peerId] = info.agentVersion.get().string
 

libp2p/protobuf/minprotobuf.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,15 +9,17 @@
 
 ## This module implements minimal Google's ProtoBuf primitives.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import ../varint, ../utility, stew/[endians2, results]
 export results, utility
 
 {.push public.}
 
-const
-  MaxMessageSize* = 1'u shl 22
+const MaxMessageSize = 1'u shl 22
 
 type
   ProtoFieldKind* = enum
@@ -34,6 +36,7 @@ type
     buffer*: seq[byte]
     offset*: int
     length*: int
+    maxSize*: uint
 
   ProtoHeader* = object
     wire*: ProtoFieldKind
@@ -119,23 +122,28 @@ proc vsizeof*(field: ProtoField): int {.inline.} =
     0
 
 proc initProtoBuffer*(data: seq[byte], offset = 0,
-                      options: set[ProtoFlags] = {}): ProtoBuffer =
+                      options: set[ProtoFlags] = {},
+                      maxSize = MaxMessageSize): ProtoBuffer =
   ## Initialize ProtoBuffer with shallow copy of ``data``.
-  shallowCopy(result.buffer, data)
+  result.buffer = data
   result.offset = offset
   result.options = options
+  result.maxSize = maxSize
 
 proc initProtoBuffer*(data: openArray[byte], offset = 0,
-                      options: set[ProtoFlags] = {}): ProtoBuffer =
+                      options: set[ProtoFlags] = {},
+                      maxSize = MaxMessageSize): ProtoBuffer =
   ## Initialize ProtoBuffer with copy of ``data``.
   result.buffer = @data
   result.offset = offset
   result.options = options
+  result.maxSize = maxSize
 
-proc initProtoBuffer*(options: set[ProtoFlags] = {}): ProtoBuffer =
+proc initProtoBuffer*(options: set[ProtoFlags] = {}, maxSize = MaxMessageSize): ProtoBuffer =
   ## Initialize ProtoBuffer with new sequence of capacity ``cap``.
   result.buffer = newSeq[byte]()
   result.options = options
+  result.maxSize = maxSize
   if WithVarintLength in options:
     # Our buffer will start from position 10, so we can store length of buffer
     # in [0, 9].
@@ -332,7 +340,7 @@ proc skipValue(data: var ProtoBuffer, header: ProtoHeader): ProtoResult[void] =
     var bsize = 0'u64
     if PB.getUVarint(data.toOpenArray(), length, bsize).isOk():
       data.offset += length
-      if bsize <= uint64(MaxMessageSize):
+      if bsize <= uint64(data.maxSize):
         if data.isEnough(int(bsize)):
           data.offset += int(bsize)
           ok()
@@ -396,7 +404,7 @@ proc getValue[T:byte|char](data: var ProtoBuffer, header: ProtoHeader,
   outLength = 0
   if PB.getUVarint(data.toOpenArray(), length, bsize).isOk():
     data.offset += length
-    if bsize <= uint64(MaxMessageSize):
+    if bsize <= uint64(data.maxSize):
       if data.isEnough(int(bsize)):
         outLength = int(bsize)
         if len(outBytes) >= int(bsize):
@@ -424,7 +432,7 @@ proc getValue[T:seq[byte]|string](data: var ProtoBuffer, header: ProtoHeader,
 
   if PB.getUVarint(data.toOpenArray(), length, bsize).isOk():
     data.offset += length
-    if bsize <= uint64(MaxMessageSize):
+    if bsize <= uint64(data.maxSize):
       if data.isEnough(int(bsize)):
         outBytes.setLen(bsize)
         if bsize > 0'u64:

libp2p/protocols/connectivity/autonat/client.nim

@@ -0,0 +1,74 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import std/[options, sets, sequtils]
+import stew/[results, objects]
+import chronos, chronicles
+import ../../../switch,
+       ../../../multiaddress,
+       ../../../peerid
+import core
+
+export 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: some(AutonatPeerInfo(
+                         id: 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: Option[AutonatMsg]): AutonatDialResponse {.raises: [UnpackError, AutonatError].} =
+    if autonatMsg.isNone() or
+       autonatMsg.get().msgType != DialResponse or
+       autonatMsg.get().response.isNone() or
+       (autonatMsg.get().response.get().status == Ok and
+        autonatMsg.get().response.get().ma.isNone()):
+      raise newException(AutonatError, "Unexpected response")
+    else:
+      autonatMsg.get().response.get()
+
+  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)
+  defer:
+    await conn.close()
+    incomingConnection.cancel() # Safer to always try to cancel cause we aren't sure if the peer dialled us or not
+  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.get()
+    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(""))

libp2p/protocols/connectivity/autonat/core.nim

@@ -0,0 +1,152 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import std/[options, sets, sequtils]
+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*: 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(p: AutonatPeerInfo): ProtoBuffer =
+  result = initProtoBuffer()
+  if p.id.isSome():
+    result.write(1, p.id.get())
+  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()
+  if d.peerInfo.isSome():
+    dial.write(1, encode(d.peerInfo.get()))
+  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 encode*(msg: AutonatMsg): ProtoBuffer =
+  if msg.dial.isSome():
+    return encode(msg.dial.get())
+  if msg.response.isSome():
+    return encode(msg.response.get())
+
+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)

libp2p/protocols/connectivity/autonat/server.nim

@@ -0,0 +1,162 @@
+# 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.
+
+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, 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: 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)
+
+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)
+    # 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
+    if ma.isSome:
+      await conn.sendResponseOk(ma.get())
+    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] =
+  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)
+  trace "addrs received", addrs = peerInfo.addrs
+  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 DNS_OR_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")
+  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, 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 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

libp2p/protocols/connectivity/autonat/service.nim

@@ -0,0 +1,182 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import std/[options, deques, sequtils]
+import chronos, metrics
+import ../../../switch
+import client
+import ../../../utils/heartbeat
+import ../../../crypto/crypto
+
+logScope:
+  topics = "libp2p autonatservice"
+
+declarePublicGauge(libp2p_autonat_reachability_confidence, "autonat reachability confidence", labels = ["reachability"])
+
+type
+  AutonatService* = ref object of Service
+    newConnectedPeerHandler: PeerEventHandler
+    scheduleHandle: Future[void]
+    networkReachability: NetworkReachability
+    confidence: Option[float]
+    answers: Deque[NetworkReachability]
+    autonatClient: AutonatClient
+    statusAndConfidenceHandler: StatusAndConfidenceHandler
+    rng: ref HmacDrbgContext
+    scheduleInterval: Option[Duration]
+    askNewConnectedPeers: bool
+    numPeersToAsk: int
+    maxQueueSize: int
+    minConfidence: float
+    dialTimeout: Duration
+
+  NetworkReachability* {.pure.} = enum
+    NotReachable, Reachable, Unknown
+
+  StatusAndConfidenceHandler* = proc (networkReachability: NetworkReachability, confidence: Option[float]): Future[void]  {.gcsafe, raises: [Defect].}
+
+proc new*(
+  T: typedesc[AutonatService],
+  autonatClient: AutonatClient,
+  rng: ref HmacDrbgContext,
+  scheduleInterval: Option[Duration] = none(Duration),
+  askNewConnectedPeers = true,
+  numPeersToAsk: int = 5,
+  maxQueueSize: int = 10,
+  minConfidence: float = 0.3,
+  dialTimeout = 30.seconds): T =
+  return T(
+    scheduleInterval: scheduleInterval,
+    networkReachability: Unknown,
+    confidence: none(float),
+    answers: initDeque[NetworkReachability](),
+    autonatClient: autonatClient,
+    rng: rng,
+    askNewConnectedPeers: askNewConnectedPeers,
+    numPeersToAsk: numPeersToAsk,
+    maxQueueSize: maxQueueSize,
+    minConfidence: minConfidence,
+    dialTimeout: dialTimeout)
+
+proc networkReachability*(self: AutonatService): NetworkReachability {.inline.} =
+  return self.networkReachability
+
+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 handleAnswer(self: AutonatService, ans: NetworkReachability) {.async.} =
+
+  if ans == Unknown:
+    return
+
+  if self.answers.len == self.maxQueueSize:
+    self.answers.popFirst()
+  self.answers.addLast(ans)
+
+  self.networkReachability = Unknown
+  self.confidence = 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 = some(confidence)
+
+  debug "Current status", currentStats = $self.networkReachability, confidence = $self.confidence, answers = self.answers
+
+proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[NetworkReachability] {.async.} =
+  logScope:
+    peerId = $peerId
+  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
+  await self.handleAnswer(ans)
+  if not isNil(self.statusAndConfidenceHandler):
+    await self.statusAndConfidenceHandler(self.networkReachability, self.confidence)
+  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)
+
+method setup*(self: AutonatService, switch: Switch): Future[bool] {.async.} =
+  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.} =
+        if switch.connManager.selectConn(peerId, In) != nil: # no need to ask an incoming peer
+          return
+        discard askPeer(self, switch, peerId)
+        await self.callHandler()
+      switch.connManager.addPeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
+    if self.scheduleInterval.isSome():
+      self.scheduleHandle = schedule(self, switch, self.scheduleInterval.get())
+  return hasBeenSetup
+
+method run*(self: AutonatService, switch: Switch) {.async, public.} =
+  trace "Running AutonatService"
+  await askConnectedPeers(self, switch)
+  await self.callHandler()
+
+
+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)
+  return hasBeenStopped
+
+proc statusAndConfidenceHandler*(self: AutonatService, statusAndConfidenceHandler: StatusAndConfidenceHandler) =
+  self.statusAndConfidenceHandler = statusAndConfidenceHandler

libp2p/protocols/connectivity/relay/client.nim

@@ -0,0 +1,295 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import times, options
+
+import chronos, chronicles
+
+import ./relay,
+       ./messages,
+       ./rconn,
+       ./utils,
+       ../../../peerinfo,
+       ../../../switch,
+       ../../../multiaddress,
+       ../../../stream/connection
+
+export options
+
+logScope:
+  topics = "libp2p relay relay-client"
+
+const RelayClientMsgSize = 4096
+
+type
+  RelayClientError* = object of LPError
+  ReservationError* = object of RelayClientError
+  RelayV1DialError* = object of RelayClientError
+  RelayV2DialError* = object of RelayClientError
+  RelayClientAddConn* = proc(conn: Connection,
+                        duration: uint32,
+                        data: uint64): Future[void] {.gcsafe, raises: [Defect].}
+  RelayClient* = ref object of Relay
+    onNewConnection*: RelayClientAddConn
+    canHop: bool
+
+  Rsvp* = object
+    expire*: uint64           # required, Unix expiration time (UTC)
+    addrs*: seq[MultiAddress] # relay address for reserving peer
+    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: 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.get()
+    limitDuration = msg.limit.duration
+    limitData = msg.limit.data
+    msg = StopMessage(
+      msgType: StopMessageType.Status,
+      status: some(Ok))
+    pb = encode(msg)
+
+  trace "incoming relay connection", src
+
+  if cl.onNewConnection == nil:
+    await sendStopError(conn, StatusV2.ConnectionFailed)
+    await conn.close()
+    return
+  await conn.writeLp(pb.buffer)
+  # This sound redundant but the callback could, in theory, be set to nil during
+  # conn.writeLp so it's safer to double check
+  if cl.onNewConnection != nil: await cl.onNewConnection(conn, limitDuration, limitData)
+  else: await conn.close()
+
+proc reserve*(cl: RelayClient,
+              peerId: PeerId,
+              addrs: seq[MultiAddress] = @[]): Future[Rsvp] {.async.} =
+  let conn = await cl.switch.dial(peerId, addrs, RelayV2HopCodec)
+  defer: await conn.close()
+  let
+    pb = encode(HopMessage(msgType: HopMessageType.Reserve))
+    msg = try:
+      await conn.writeLp(pb.buffer)
+      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).get()
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error writing or reading reservation message", exc=exc.msg
+      raise newException(ReservationError, exc.msg)
+
+  if msg.msgType != HopMessageType.Status:
+    raise newException(ReservationError, "Unexpected relay response type")
+  if msg.status.get(UnexpectedMessage) != Ok:
+    raise newException(ReservationError, "Reservation failed")
+  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
+
+  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")
+    result.voucher = some(svoucher.get().data)
+
+  result.limitDuration = msg.limit.duration
+  result.limitData = msg.limit.data
+
+proc dialPeerV1*(
+    cl: RelayClient,
+    conn: Connection,
+    dstPeerId: PeerId,
+    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
+  var
+    msg = RelayMessage(
+      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
+
+  try:
+    await conn.writeLp(pb.buffer)
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error writing hop request", exc=exc.msg
+    raise exc
+
+  let msgRcvFromRelayOpt = try:
+    RelayMessage.decode(await conn.readLp(RelayClientMsgSize))
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error reading stop response", exc=exc.msg
+    await sendStatus(conn, StatusV1.HopCantOpenDstStream)
+    raise exc
+
+  try:
+    if msgRcvFromRelayOpt.isNone:
+      raise newException(RelayV1DialError, "Hop can't open destination stream")
+    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.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
+  result = conn
+
+proc dialPeerV2*(
+    cl: RelayClient,
+    conn: RelayConnection,
+    dstPeerId: PeerId,
+    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
+  let
+    p = Peer(peerId: dstPeerId, addrs: dstAddrs)
+    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)).get()
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error reading stop response", exc=exc.msg
+    raise newException(RelayV2DialError, exc.msg)
+
+  if msgRcvFromRelay.msgType != HopMessageType.Status:
+    raise newException(RelayV2DialError, "Unexpected stop response")
+  if msgRcvFromRelay.status.get(UnexpectedMessage) != Ok:
+    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, 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 = msgOpt.get()
+  let msg = msgOpt.get()
+
+  if msg.msgType == StopMessageType.Connect:
+    await cl.handleRelayedConnect(conn, msg)
+  else:
+    trace "Unexpected client / relayv2 handshake", msgType=msg.msgType
+    await sendStopError(conn, MalformedMessage)
+
+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()
+
+  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
+
+  trace "get a relay connection", src, conn
+
+  if cl.onNewConnection == nil:
+    await sendStatus(conn, StatusV1.StopRelayRefused)
+    await conn.close()
+    return
+  await sendStatus(conn, StatusV1.Success)
+  # This sound redundant but the callback could, in theory, be set to nil during
+  # sendStatus(Success) so it's safer to double check
+  if cl.onNewConnection != nil: await cl.onNewConnection(conn, 0, 0)
+  else: await conn.close()
+
+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 = 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)
+    of RelayType.Stop: await cl.handleStop(conn, msg)
+    of RelayType.CanHop:
+      if cl.canHop: await sendStatus(conn, StatusV1.Success)
+      else: await sendStatus(conn, StatusV1.HopCantSpeakRelay)
+    else:
+      trace "Unexpected relay handshake", msgType=msg.msgType
+      await sendStatus(conn, StatusV1.MalformedMessage)
+
+proc new*(T: typedesc[RelayClient], canHop: bool = false,
+     reservationTTL: times.Duration = DefaultReservationTTL,
+     limitDuration: uint32 = DefaultLimitDuration,
+     limitData: uint64 = DefaultLimitData,
+     heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
+     maxCircuit: int = MaxCircuit,
+     maxCircuitPerPeer: int = MaxCircuitPerPeer,
+     msgSize: int = RelayClientMsgSize,
+     circuitRelayV1: bool = false): T =
+
+  let cl = T(canHop: canHop,
+             reservationTTL: reservationTTL,
+             limit: Limit(duration: limitDuration, data: limitData),
+             heartbeatSleepTime: heartbeatSleepTime,
+             maxCircuit: maxCircuit,
+             maxCircuitPerPeer: maxCircuitPerPeer,
+             msgSize: msgSize,
+             isCircuitRelayV1: circuitRelayV1)
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
+    try:
+      case proto:
+      of RelayV1Codec: await cl.handleStreamV1(conn)
+      of RelayV2StopCodec: await cl.handleStopStreamV2(conn)
+      of RelayV2HopCodec: await cl.handleHopStreamV2(conn)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "exception in client handler", exc = exc.msg, conn
+    finally:
+      trace "exiting client handler", conn
+      await conn.close()
+
+  cl.handler = handleStream
+  cl.codecs = if cl.canHop:
+                @[RelayV1Codec, RelayV2HopCodec, RelayV2StopCodec]
+              else:
+                @[RelayV1Codec, RelayV2StopCodec]
+  cl

libp2p/protocols/connectivity/relay/messages.nim

@@ -0,0 +1,370 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import options, macros, sequtils
+import stew/objects
+import ../../../peerinfo,
+       ../../../signed_envelope
+
+# Circuit Relay V1 Message
+
+type
+  RelayType* {.pure.} = enum
+    Hop = 1
+    Stop = 2
+    Status = 3
+    CanHop = 4
+
+  StatusV1* {.pure.} = enum
+    Success = 100
+    HopSrcAddrTooLong = 220
+    HopDstAddrTooLong = 221
+    HopSrcMultiaddrInvalid = 250
+    HopDstMultiaddrInvalid = 251
+    HopNoConnToDst = 260
+    HopCantDialDst = 261
+    HopCantOpenDstStream = 262
+    HopCantSpeakRelay = 270
+    HopCantRelayToSelf = 280
+    StopSrcAddrTooLong = 320
+    StopDstAddrTooLong = 321
+    StopSrcMultiaddrInvalid = 350
+    StopDstMultiaddrInvalid = 351
+    StopRelayRefused = 390
+    MalformedMessage = 400
+
+  RelayPeer* = object
+    peerId*: PeerId
+    addrs*: seq[MultiAddress]
+
+  RelayMessage* = object
+    msgType*: Option[RelayType]
+    srcPeer*: Option[RelayPeer]
+    dstPeer*: Option[RelayPeer]
+    status*: Option[StatusV1]
+
+proc encode*(msg: RelayMessage): ProtoBuffer =
+  result = initProtoBuffer()
+
+  if isSome(msg.msgType):
+    result.write(1, msg.msgType.get().ord.uint)
+  if isSome(msg.srcPeer):
+    var peer = initProtoBuffer()
+    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)
+  if isSome(msg.dstPeer):
+    var peer = initProtoBuffer()
+    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)
+  if isSome(msg.status):
+    result.write(4, msg.status.get().ord.uint)
+
+  result.finish()
+
+proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Option[RelayMessage] =
+  var
+    rMsg: RelayMessage
+    msgTypeOrd: uint32
+    src: RelayPeer
+    dst: RelayPeer
+    statusOrd: uint32
+    pbSrc: ProtoBuffer
+    pbDst: ProtoBuffer
+
+  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 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 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
+
+type
+  Voucher* = object
+    relayPeerId*: PeerId     # peer ID of the relay
+    reservingPeerId*: PeerId # peer ID of the reserving peer
+    expiration*: uint64      # UNIX UTC expiration time for the reservation
+
+proc decode*(_: typedesc[Voucher], buf: seq[byte]): Result[Voucher, ProtoError] =
+  let pb = initProtoBuffer(buf)
+  var v = Voucher()
+
+  ? pb.getRequiredField(1, v.relayPeerId)
+  ? pb.getRequiredField(2, v.reservingPeerId)
+  ? pb.getRequiredField(3, v.expiration)
+
+  ok(v)
+
+proc encode*(v: Voucher): seq[byte] =
+  var pb = initProtoBuffer()
+
+  pb.write(1, v.relayPeerId)
+  pb.write(2, v.reservingPeerId)
+  pb.write(3, v.expiration)
+
+  pb.finish()
+  pb.buffer
+
+proc init*(T: typedesc[Voucher],
+          relayPeerId: PeerId,
+          reservingPeerId: PeerId,
+          expiration: uint64): T =
+  T(
+    relayPeerId = relayPeerId,
+    reservingPeerId = reservingPeerId,
+    expiration: expiration
+  )
+
+type SignedVoucher* = SignedPayload[Voucher]
+
+proc payloadDomain*(_: typedesc[Voucher]): string = "libp2p-relay-rsvp"
+proc payloadType*(_: typedesc[Voucher]): seq[byte] = @[ (byte)0x03, (byte)0x02 ]
+
+proc checkValid*(spr: SignedVoucher): Result[void, EnvelopeError] =
+  if not spr.data.relayPeerId.match(spr.envelope.publicKey):
+    err(EnvelopeInvalidSignature)
+  else:
+    ok()
+
+# Circuit Relay V2 Hop Message
+
+type
+  Peer* = object
+    peerId*: PeerId
+    addrs*: seq[MultiAddress]
+  Reservation* = object
+    expire*: uint64              # required, Unix expiration time (UTC)
+    addrs*: seq[MultiAddress]    # relay address for reserving peer
+    svoucher*: Option[seq[byte]] # optional, reservation voucher
+  Limit* = object
+    duration*: uint32            # seconds
+    data*: uint64                # bytes
+
+  StatusV2* = enum
+    Ok = 100
+    ReservationRefused = 200
+    ResourceLimitExceeded = 201
+    PermissionDenied = 202
+    ConnectionFailed = 203
+    NoReservation = 204
+    MalformedMessage = 400
+    UnexpectedMessage = 401
+  HopMessageType* {.pure.} = enum
+    Reserve = 0
+    Connect = 1
+    Status = 2
+  HopMessage* = object
+    msgType*: HopMessageType
+    peer*: Option[Peer]
+    reservation*: Option[Reservation]
+    limit*: Limit
+    status*: Option[StatusV2]
+
+proc encode*(msg: HopMessage): ProtoBuffer =
+  var pb = initProtoBuffer()
+
+  pb.write(1, msg.msgType.ord.uint)
+  if msg.peer.isSome():
+    var ppb = initProtoBuffer()
+    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)
+  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)
+    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:
+    var lpb = initProtoBuffer()
+    if msg.limit.duration > 0: lpb.write(1, msg.limit.duration)
+    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
+    lpb.finish()
+    pb.write(4, lpb.buffer)
+  if msg.status.isSome():
+    pb.write(5, msg.status.get().ord.uint)
+
+  pb.finish()
+  pb
+
+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)
+
+  if not checkedEnumAssign(msg.msgType, msgTypeOrd):
+    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
+
+type
+  StopMessageType* {.pure.} = enum
+    Connect = 0
+    Status = 1
+  StopMessage* = object
+    msgType*: StopMessageType
+    peer*: Option[Peer]
+    limit*: Limit
+    status*: Option[StatusV2]
+
+
+proc encode*(msg: StopMessage): ProtoBuffer =
+  var pb = initProtoBuffer()
+
+  pb.write(1, msg.msgType.ord.uint)
+  if msg.peer.isSome():
+    var ppb = initProtoBuffer()
+    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)
+  if msg.limit.duration > 0 or msg.limit.data > 0:
+    var lpb = initProtoBuffer()
+    if msg.limit.duration > 0: lpb.write(1, msg.limit.duration)
+    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
+    lpb.finish()
+    pb.write(3, lpb.buffer)
+  if msg.status.isSome():
+    pb.write(4, msg.status.get().ord.uint)
+
+  pb.finish()
+  pb
+
+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)
+    r1 = pb.getRequiredField(1, msgTypeOrd)
+    r2 = pb.getField(2, pbPeer)
+    r3 = pb.getField(3, pbLimit)
+    r4 = pb.getField(4, statusOrd)
+
+  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)
+  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)

libp2p/protocols/connectivity/relay/rconn.nim

@@ -0,0 +1,61 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import chronos
+
+import ../../../stream/connection
+
+type
+  RelayConnection* = ref object of Connection
+    conn*: Connection
+    limitDuration*: uint32
+    limitData*: uint64
+    dataSent*: uint64
+
+method readOnce*(
+    self: RelayConnection,
+    pbytes: pointer,
+    nbytes: int): Future[int] {.async.} =
+  self.activity = true
+  return await self.conn.readOnce(pbytes, nbytes)
+
+method write*(self: RelayConnection, msg: seq[byte]): Future[void] {.async.} =
+  self.dataSent.inc(msg.len)
+  if self.limitData != 0 and self.dataSent > self.limitData:
+    await self.close()
+    return
+  self.activity = true
+  await self.conn.write(msg)
+
+method closeImpl*(self: RelayConnection): Future[void] {.async.} =
+  await self.conn.close()
+  await procCall Connection(self).closeImpl()
+
+method getWrapped*(self: RelayConnection): Connection = self.conn
+
+proc new*(
+  T: typedesc[RelayConnection],
+  conn: Connection,
+  limitDuration: uint32,
+  limitData: uint64): T =
+  let rc = T(conn: conn, limitDuration: limitDuration, limitData: limitData)
+  rc.initStream()
+  if limitDuration > 0:
+    proc checkDurationConnection() {.async.} =
+      let sleep = sleepAsync(limitDuration.seconds())
+      await sleep or conn.join()
+      if sleep.finished: await conn.close()
+      else: sleep.cancel()
+    asyncSpawn checkDurationConnection()
+  return rc

libp2p/protocols/connectivity/relay/relay.nim

@@ -0,0 +1,386 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import options, sequtils, tables, sugar
+
+import chronos, chronicles
+
+import ./messages,
+       ./rconn,
+       ./utils,
+       ../../../peerinfo,
+       ../../../switch,
+       ../../../multiaddress,
+       ../../../multicodec,
+       ../../../stream/connection,
+       ../../../protocols/protocol,
+       ../../../transports/transport,
+       ../../../errors,
+       ../../../utils/heartbeat,
+       ../../../signed_envelope
+
+# TODO:
+# * Eventually replace std/times by chronos/timer. Currently chronos/timer
+#   doesn't offer the possibility to get a datetime in UNIX UTC
+# * Eventually add an access control list in the handleReserve, handleConnect
+#   and handleHop
+# * Better reservation management ie find a way to re-reserve when the end is nigh
+
+import std/times
+export chronicles
+
+const
+  RelayMsgSize* = 4096
+  DefaultReservationTTL* = initDuration(hours = 1)
+  DefaultLimitDuration* = 120
+  DefaultLimitData* = 1 shl 17
+  DefaultHeartbeatSleepTime* = 1
+  MaxCircuit* = 128
+  MaxCircuitPerPeer* = 16
+
+logScope:
+  topics = "libp2p relay"
+
+type
+  RelayV2Error* = object of LPError
+  SendStopError = object of RelayV2Error
+
+# Relay Side
+
+type
+  Relay* = ref object of LPProtocol
+    switch*: Switch
+    peerCount: CountTable[PeerId]
+
+    # number of reservation (relayv2) + number of connection (relayv1)
+    maxCircuit*: int
+
+    maxCircuitPerPeer*: int
+    msgSize*: int
+    # RelayV1
+    isCircuitRelayV1*: bool
+    streamCount: int
+    # RelayV2
+    rsvp: Table[PeerId, DateTime]
+    reservationLoop: Future[void]
+    reservationTTL*: times.Duration
+    heartbeatSleepTime*: uint32
+    limit*: Limit
+
+# Relay V2
+
+proc createReserveResponse(
+    r: Relay,
+    pid: PeerId,
+    expire: DateTime): Result[HopMessage, CryptoError] =
+  let
+    expireUnix = expire.toTime.toUnix.uint64
+    v = Voucher(relayPeerId: r.switch.peerInfo.peerId,
+                  reservingPeerId: pid,
+                  expiration: expireUnix)
+    sv = ? SignedVoucher.init(r.switch.peerInfo.privateKey, v)
+    ma = ? MultiAddress.init("/p2p/" & $r.switch.peerInfo.peerId).orErr(CryptoError.KeyError)
+    rsrv = Reservation(expire: expireUnix,
+                       addrs: r.switch.peerInfo.addrs.mapIt(
+                         ? it.concat(ma).orErr(CryptoError.KeyError)),
+                       svoucher: some(? sv.encode))
+    msg = HopMessage(msgType: HopMessageType.Status,
+                     reservation: some(rsrv),
+                     limit: r.limit,
+                     status: some(Ok))
+  return ok(msg)
+
+proc isRelayed(conn: Connection): bool =
+  var wrappedConn = conn
+  while not isNil(wrappedConn):
+    if wrappedConn of RelayConnection:
+      return true
+    wrappedConn = wrappedConn.getWrapped()
+  return false
+
+proc handleReserve(r: Relay, conn: Connection) {.async, gcsafe.} =
+  if conn.isRelayed():
+    trace "reservation attempt over relay connection", pid = conn.peerId
+    await sendHopStatus(conn, PermissionDenied)
+    return
+
+  if r.peerCount[conn.peerId] + r.rsvp.len() >= r.maxCircuit:
+    trace "Too many reservations", pid = conn.peerId
+    await sendHopStatus(conn, ReservationRefused)
+    return
+  let
+    pid = conn.peerId
+    expire = now().utc + r.reservationTTL
+    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.get()).buffer)
+
+proc handleConnect(r: Relay,
+                   connSrc: Connection,
+                   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
+    src = connSrc.peerId
+    dst = msg.peer.get().peerId
+  if dst notin r.rsvp:
+    trace "refusing connection, no reservation", src, dst
+    await sendHopStatus(connSrc, NoReservation)
+    return
+
+  r.peerCount.inc(src)
+  r.peerCount.inc(dst)
+  defer:
+    r.peerCount.inc(src, -1)
+    r.peerCount.inc(dst, -1)
+
+  if r.peerCount[src] > r.maxCircuitPerPeer or
+     r.peerCount[dst] > r.maxCircuitPerPeer:
+    trace "too many connections", src = r.peerCount[src],
+                                  dst = r.peerCount[dst],
+                                  max = r.maxCircuitPerPeer
+    await sendHopStatus(connSrc, ResourceLimitExceeded)
+    return
+
+  let connDst = try:
+    await r.switch.dial(dst, RelayV2StopCodec)
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error opening relay stream", dst, exc=exc.msg
+    await sendHopStatus(connSrc, ConnectionFailed)
+    return
+  defer:
+    await connDst.close()
+
+  proc sendStopMsg() {.async.} =
+    let stopMsg = StopMessage(msgType: StopMessageType.Connect,
+                            peer: some(Peer(peerId: src, addrs: @[])),
+                            limit: r.limit)
+    await connDst.writeLp(encode(stopMsg).buffer)
+    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: some(Ok))).buffer)
+  try:
+    await sendStopMsg()
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error sending stop message", msg = exc.msg
+    await sendHopStatus(connSrc, ConnectionFailed)
+    return
+
+  trace "relaying connection", src, dst
+  let
+    rconnSrc = RelayConnection.new(connSrc, r.limit.duration, r.limit.data)
+    rconnDst = RelayConnection.new(connDst, r.limit.duration, r.limit.data)
+  defer:
+    await rconnSrc.close()
+    await rconnDst.close()
+  await bridge(rconnSrc, rconnDst)
+
+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 = msgOpt.get()
+  let msg = msgOpt.get()
+  case msg.msgType:
+  of HopMessageType.Reserve: await r.handleReserve(conn)
+  of HopMessageType.Connect: await r.handleConnect(conn, msg)
+  else:
+    trace "Unexpected relayv2 handshake", msgType=msg.msgType
+    await sendHopStatus(conn, MalformedMessage)
+
+# Relay V1
+
+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:
+    trace "refusing connection; too many active circuit", streamCount = r.streamCount, rsvp = r.rsvp.len()
+    await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
+    return
+
+  proc checkMsg(): Result[RelayMessage, StatusV1] =
+    if msg.srcPeer.isNone:
+      return err(StatusV1.HopSrcMultiaddrInvalid)
+    let src = msg.srcPeer.get()
+    if src.peerId != connSrc.peerId:
+      return err(StatusV1.HopSrcMultiaddrInvalid)
+    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):
+      trace "relay not connected to dst", dst
+      return err(StatusV1.HopNoConnToDst)
+    ok(msg)
+  let check = checkMsg()
+  if check.isErr:
+    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
+    await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
+    return
+  r.peerCount.inc(src.peerId)
+  r.peerCount.inc(dst.peerId)
+  defer:
+    r.peerCount.inc(src.peerId, -1)
+    r.peerCount.inc(dst.peerId, -1)
+
+  let connDst = try:
+    await r.switch.dial(dst.peerId, RelayV1Codec)
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error opening relay stream", dst, exc=exc.msg
+    await sendStatus(connSrc, StatusV1.HopCantDialDst)
+    return
+  defer:
+    await connDst.close()
+
+  let msgToSend = RelayMessage(
+    msgType: some(RelayType.Stop),
+    srcPeer: some(src),
+    dstPeer: some(dst))
+
+  let msgRcvFromDstOpt = try:
+    await connDst.writeLp(encode(msgToSend).buffer)
+    RelayMessage.decode(await connDst.readLp(r.msgSize))
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    trace "error writing stop handshake or reading stop response", exc=exc.msg
+    await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
+    return
+
+  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
+    await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
+    return
+
+  await sendStatus(connSrc, StatusV1.Success)
+  trace "relaying connection", src, dst
+  await bridge(connSrc, connDst)
+
+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 = 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)
+    else:
+      trace "Unexpected relay handshake", msgType=msg.msgType
+      await sendStatus(conn, StatusV1.MalformedMessage)
+
+proc setup*(r: Relay, switch: Switch) =
+  r.switch = switch
+  r.switch.addPeerEventHandler(
+    proc (peerId: PeerId, event: PeerEvent) {.async.} =
+      r.rsvp.del(peerId),
+    Left)
+
+proc new*(T: typedesc[Relay],
+     reservationTTL: times.Duration = DefaultReservationTTL,
+     limitDuration: uint32 = DefaultLimitDuration,
+     limitData: uint64 = DefaultLimitData,
+     heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
+     maxCircuit: int = MaxCircuit,
+     maxCircuitPerPeer: int = MaxCircuitPerPeer,
+     msgSize: int = RelayMsgSize,
+     circuitRelayV1: bool = false): T =
+
+  let r = T(reservationTTL: reservationTTL,
+            limit: Limit(duration: limitDuration, data: limitData),
+            heartbeatSleepTime: heartbeatSleepTime,
+            maxCircuit: maxCircuit,
+            maxCircuitPerPeer: maxCircuitPerPeer,
+            msgSize: msgSize,
+            isCircuitRelayV1: circuitRelayV1)
+
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
+    try:
+      case proto:
+      of RelayV2HopCodec: await r.handleHopStreamV2(conn)
+      of RelayV1Codec: await r.handleStreamV1(conn)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      debug "exception in relayv2 handler", exc = exc.msg, conn
+    finally:
+      trace "exiting relayv2 handler", conn
+      await conn.close()
+
+  r.codecs = if r.isCircuitRelayV1: @[RelayV1Codec]
+             else: @[RelayV2HopCodec, RelayV1Codec]
+  r.handler = handleStream
+  r
+
+proc deletesReservation(r: Relay) {.async.} =
+  heartbeat "Reservation timeout", r.heartbeatSleepTime.seconds():
+    let n = now().utc
+    for k in toSeq(r.rsvp.keys):
+      if n > r.rsvp[k]:
+        r.rsvp.del(k)
+
+method start*(r: Relay) {.async.} =
+  if not r.reservationLoop.isNil:
+    warn "Starting relay twice"
+    return
+  r.reservationLoop = r.deletesReservation()
+  r.started = true
+
+method stop*(r: Relay) {.async.} =
+  if r.reservationLoop.isNil:
+    warn "Stopping relay without starting it"
+    return
+  r.started = false
+  r.reservationLoop.cancel()
+  r.reservationLoop = nil

libp2p/protocols/connectivity/relay/rtransport.nim

@@ -0,0 +1,109 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import sequtils, strutils
+
+import chronos, chronicles
+
+import ./client,
+       ./rconn,
+       ./utils,
+       ../../../switch,
+       ../../../stream/connection,
+       ../../../transports/transport
+
+logScope:
+  topics = "libp2p relay relay-transport"
+
+type
+  RelayTransport* = ref object of Transport
+    client*: RelayClient
+    queue: AsyncQueue[Connection]
+    selfRunning: bool
+
+method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
+  if self.selfRunning:
+    trace "Relay transport already running"
+    return
+
+  self.client.onNewConnection = proc(
+    conn: Connection,
+    duration: uint32 = 0,
+    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, 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, gcsafe.} =
+  result = await self.queue.popFirst()
+
+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].get())).split('/')[2]):
+    raise newException(RelayV2DialError, "Relay doesn't exist")
+  if not dstPeerId.init(($(sma[^1].get())).split('/')[2]):
+    raise newException(RelayV2DialError, "Destination doesn't exist")
+  trace "Dial", relayPeerId, dstPeerId
+
+  let conn = await self.client.switch.dial(
+    relayPeerId,
+    @[ relayAddrs ],
+    @[ RelayV2HopCodec, RelayV1Codec ])
+  conn.dir = Direction.Out
+  var rc: RelayConnection
+  try:
+    case conn.protocol:
+    of RelayV1Codec:
+      return await self.client.dialPeerV1(conn, dstPeerId, @[])
+    of RelayV2HopCodec:
+      rc = RelayConnection.new(conn, 0, 0)
+      return await self.client.dialPeerV2(rc, dstPeerId, @[])
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    if not rc.isNil: await rc.close()
+    raise exc
+
+method dial*(
+  self: RelayTransport,
+  hostname: string,
+  ma: MultiAddress,
+  peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection] {.async, gcsafe.} =
+  let address = MultiAddress.init($ma & "/p2p/" & $peerId.get()).tryGet()
+  result = await self.dial(address)
+
+method handles*(self: RelayTransport, ma: MultiAddress): bool {.gcsafe} =
+  if ma.protocols.isOk():
+    let sma = toSeq(ma.items())
+    result = sma.len >= 2 and CircuitRelay.match(sma[^1].get())
+  trace "Handles return", ma, result
+
+proc new*(T: typedesc[RelayTransport], cl: RelayClient, upgrader: Upgrade): T =
+  result = T(client: cl, upgrader: upgrader)
+  result.running = true
+  result.queue = newAsyncQueue[Connection](0)

libp2p/protocols/connectivity/relay/utils.nim

@@ -0,0 +1,89 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import options
+
+import chronos, chronicles
+
+import ./messages,
+       ../../../stream/connection
+
+logScope:
+  topics = "libp2p relay relay-utils"
+
+const
+  RelayV1Codec* = "/libp2p/circuit/relay/0.1.0"
+  RelayV2HopCodec* = "/libp2p/circuit/relay/0.2.0/hop"
+  RelayV2StopCodec* = "/libp2p/circuit/relay/0.2.0/stop"
+
+proc sendStatus*(conn: Connection, code: StatusV1) {.async, gcsafe.} =
+  trace "send relay/v1 status", status = $code & "(" & $ord(code) & ")"
+  let
+    msg = RelayMessage(msgType: some(RelayType.Status), status: some(code))
+    pb = encode(msg)
+  await conn.writeLp(pb.buffer)
+
+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: 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: some(code))
+    pb = encode(msg)
+  await conn.writeLp(pb.buffer)
+
+proc bridge*(connSrc: Connection, connDst: Connection) {.async.} =
+  const bufferSize = 4096
+  var
+    bufSrcToDst: array[bufferSize, byte]
+    bufDstToSrc: array[bufferSize, byte]
+    futSrc = connSrc.readOnce(addr bufSrcToDst[0], bufSrcToDst.high + 1)
+    futDst = connDst.readOnce(addr bufDstToSrc[0], bufDstToSrc.high + 1)
+    bytesSendFromSrcToDst = 0
+    bytesSendFromDstToSrc = 0
+    bufRead: int
+
+  try:
+    while not connSrc.closed() and not connDst.closed():
+      await futSrc or futDst
+      if futSrc.finished():
+        bufRead = await futSrc
+        if bufRead > 0:
+          bytesSendFromSrcToDst.inc(bufRead)
+          await connDst.write(@bufSrcToDst[0..<bufRead])
+          zeroMem(addr(bufSrcToDst), bufSrcToDst.high + 1)
+        futSrc = connSrc.readOnce(addr bufSrcToDst[0], bufSrcToDst.high + 1)
+      if futDst.finished():
+        bufRead = await futDst
+        if bufRead > 0:
+          bytesSendFromDstToSrc += bufRead
+          await connSrc.write(bufDstToSrc[0..<bufRead])
+          zeroMem(addr(bufDstToSrc), bufDstToSrc.high + 1)
+        futDst = connDst.readOnce(addr bufDstToSrc[0], bufDstToSrc.high + 1)
+  except CancelledError as exc:
+    raise exc
+  except CatchableError as exc:
+    if connSrc.closed() or connSrc.atEof():
+      trace "relay src closed connection", src = connSrc.peerId
+    if connDst.closed() or connDst.atEof():
+      trace "relay dst closed connection", dst = connDst.peerId
+    trace "relay error", exc=exc.msg
+  trace "end relaying", bytesSendFromSrcToDst, bytesSendFromDstToSrc
+  await futSrc.cancelAndWait()
+  await futDst.cancelAndWait()

libp2p/protocols/identify.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -10,9 +10,13 @@
 ## `Identify <https://docs.libp2p.io/concepts/protocols/#identify>`_ and
 ## `Push Identify <https://docs.libp2p.io/concepts/protocols/#identify-push>`_ implementation
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[sequtils, options, strutils, sugar]
+import stew/results
 import chronos, chronicles
 import ../protobuf/minprotobuf,
        ../peerinfo,
@@ -77,7 +81,7 @@ chronicles.expandIt(IdentifyInfo):
     if iinfo.signedPeerRecord.isSome(): "Some"
     else: "None"
 
-proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): ProtoBuffer
+proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool): ProtoBuffer
   {.raises: [Defect].} =
   result = initProtoBuffer()
 
@@ -88,7 +92,8 @@ proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): P
     result.write(2, ma.data.buffer)
   for proto in peerInfo.protocols:
     result.write(3, proto)
-  result.write(4, observedAddr.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:

libp2p/protocols/ping.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## `Ping <https://docs.libp2p.io/concepts/protocols/#ping>`_ protocol implementation
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import chronos, chronicles
 import bearssl/[rand, hash]

libp2p/protocols/protocol.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,11 +7,19 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
-import chronos
+import chronos, stew/results
 import ../stream/connection
 
+export results
+
+const
+  DefaultMaxIncomingStreams* = 10
+
 type
   LPProtoHandler* = proc (
     conn: Connection,
@@ -23,11 +31,17 @@ type
     codecs*: seq[string]
     handler*: LPProtoHandler ## this handler gets invoked by the protocol negotiator
     started*: bool
+    maxIncomingStreams: Opt[int]
 
 method init*(p: LPProtocol) {.base, gcsafe.} = discard
 method start*(p: LPProtocol) {.async, base.} = p.started = true
 method stop*(p: LPProtocol) {.async, base.} = p.started = false
 
+proc maxIncomingStreams*(p: LPProtocol): int =
+  p.maxIncomingStreams.get(DefaultMaxIncomingStreams)
+
+proc `maxIncomingStreams=`*(p: LPProtocol, val: int) =
+  p.maxIncomingStreams = Opt.some(val)
 
 func codec*(p: LPProtocol): string =
   assert(p.codecs.len > 0, "Codecs sequence was empty!")
@@ -37,3 +51,16 @@ func `codec=`*(p: LPProtocol, codec: string) =
   # always insert as first codec
   # if we use this abstraction
   p.codecs.insert(codec, 0)
+
+proc new*(
+  T: type LPProtocol,
+  codecs: seq[string],
+  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,
+    maxIncomingStreams:
+      when maxIncomingStreams is int: Opt.some(maxIncomingStreams)
+      else: maxIncomingStreams
+  )

libp2p/protocols/pubsub/floodsub.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[sequtils, sets, hashes, tables]
 import chronos, chronicles, metrics
@@ -32,23 +35,23 @@ const FloodSubCodec* = "/floodsub/1.0.0"
 type
   FloodSub* {.public.} = ref object of PubSub
     floodsub*: PeerTable      # topic to remote peer map
-    seen*: TimedCache[MessageID] # message id:s already seen on the network
+    seen*: TimedCache[MessageId] # message id:s already seen on the network
     seenSalt*: seq[byte]
 
-proc hasSeen*(f: FloodSub, msgId: MessageID): bool =
+proc hasSeen*(f: FloodSub, msgId: MessageId): bool =
   f.seenSalt & msgId in f.seen
 
-proc addSeen*(f: FloodSub, msgId: MessageID): bool =
+proc addSeen*(f: FloodSub, msgId: MessageId): bool =
   # Salting the seen hash helps avoid attacks against the hash function used
   # in the nim hash table
   # Return true if the message has already been seen
   f.seen.put(f.seenSalt & msgId)
 
-proc firstSeen*(f: FloodSub, msgId: MessageID): Moment =
+proc firstSeen*(f: FloodSub, msgId: MessageId): Moment =
   f.seen.addedAt(f.seenSalt & msgId)
 
 proc handleSubscribe*(f: FloodSub,
-                      peer: PubsubPeer,
+                      peer: PubSubPeer,
                       topic: string,
                       subscribe: bool) =
   logScope:
@@ -139,7 +142,7 @@ method rpcHandler*(f: FloodSub,
       discard
 
     var toSendPeers = initHashSet[PubSubPeer]()
-    for t in msg.topicIDs:                     # for every topic in the message
+    for t in msg.topicIds:                     # for every topic in the message
       if t notin f.topics:
         continue
       f.floodsub.withValue(t, peers): toSendPeers.incl(peers[])
@@ -222,7 +225,7 @@ method publish*(f: FloodSub,
 method initPubSub*(f: FloodSub)
   {.raises: [Defect, InitializationError].} =
   procCall PubSub(f).initPubSub()
-  f.seen = TimedCache[MessageID].init(2.minutes)
+  f.seen = TimedCache[MessageId].init(2.minutes)
   f.seenSalt = newSeqUninitialized[byte](sizeof(Hash))
   hmacDrbgGenerate(f.rng[], f.seenSalt)
 

libp2p/protocols/pubsub/gossipsub.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## Gossip based publishing
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables, sets, options, sequtils]
 import chronos, chronicles, metrics
@@ -158,7 +161,7 @@ method onNewPeer(g: GossipSub, peer: PubSubPeer) =
     peer.iWantBudget = IWantPeerBudget
     peer.iHaveBudget = IHavePeerBudget
 
-method onPubSubPeerEvent*(p: GossipSub, peer: PubsubPeer, event: PubSubPeerEvent) {.gcsafe.} =
+method onPubSubPeerEvent*(p: GossipSub, peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe.} =
   case event.kind
   of PubSubPeerEventKind.Connected:
     discard
@@ -261,7 +264,7 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
 
   var respControl: ControlMessage
   let iwant = g.handleIHave(peer, control.ihave)
-  if iwant.messageIDs.len > 0:
+  if iwant.messageIds.len > 0:
     respControl.iwant.add(iwant)
   respControl.prune.add(g.handleGraft(peer, control.graft))
   let messages = g.handleIWant(peer, control.iwant)
@@ -273,7 +276,7 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
     # iwant and prunes from here, also messages
 
     for smsg in messages:
-      for topic in smsg.topicIDs:
+      for topic in smsg.topicIds:
         if g.knownTopics.contains(topic):
           libp2p_pubsub_broadcast_messages.inc(labelValues = [topic])
         else:
@@ -282,8 +285,8 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
     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])
+      if g.knownTopics.contains(prune.topicId):
+        libp2p_pubsub_broadcast_prune.inc(labelValues = [prune.topicId])
       else:
         libp2p_pubsub_broadcast_prune.inc(labelValues = ["generic"])
 
@@ -307,7 +310,7 @@ proc validateAndRelay(g: GossipSub,
     of ValidationResult.Reject:
       debug "Dropping message after validation, reason: reject",
         msgId = shortLog(msgId), peer
-      g.punishInvalidMessage(peer, msg.topicIDs)
+      g.punishInvalidMessage(peer, msg.topicIds)
       return
     of ValidationResult.Ignore:
       debug "Dropping message after validation, reason: ignore",
@@ -319,10 +322,10 @@ proc validateAndRelay(g: GossipSub,
     # store in cache only after validation
     g.mcache.put(msgId, msg)
 
-    g.rewardDelivered(peer, msg.topicIDs, true)
+    g.rewardDelivered(peer, msg.topicIds, true)
 
     var toSendPeers = HashSet[PubSubPeer]()
-    for t in msg.topicIDs:                      # for every topic in the message
+    for t in msg.topicIds:                      # for every topic in the message
       if t notin g.topics:
         continue
 
@@ -338,7 +341,7 @@ proc validateAndRelay(g: GossipSub,
     # also have to be careful to only include validated messages
     g.broadcast(toSendPeers, RPCMsg(messages: @[msg]))
     trace "forwared message to peers", peers = toSendPeers.len, msgId, peer
-    for topic in msg.topicIDs:
+    for topic in msg.topicIds:
       if topic notin g.topics: continue
 
       if g.knownTopics.contains(topic):
@@ -357,7 +360,7 @@ method rpcHandler*(g: GossipSub,
     template sub: untyped = rpcMsg.subscriptions[i]
     g.handleSubscribe(peer, sub.topic, sub.subscribe)
 
-  # the above call applied limtis to subs number
+  # the above call applied limits to subs number
   # in gossipsub we want to apply scoring as well
   if rpcMsg.subscriptions.len > g.topicsHigh:
     debug "received an rpc message with an oversized amount of subscriptions",  peer,
@@ -392,7 +395,7 @@ method rpcHandler*(g: GossipSub,
 
       if not alreadyReceived:
         let delay = Moment.now() - g.firstSeen(msgId)
-        g.rewardDelivered(peer, msg.topicIDs, false, delay)
+        g.rewardDelivered(peer, msg.topicIds, false, delay)
 
       libp2p_gossipsub_duplicate.inc()
 
@@ -402,7 +405,7 @@ method rpcHandler*(g: GossipSub,
     libp2p_gossipsub_received.inc()
 
     # avoid processing messages we are not interested in
-    if msg.topicIDs.allIt(it notin g.topics):
+    if msg.topicIds.allIt(it notin g.topics):
       debug "Dropping message of topic without subscription", msgId = shortLog(msgId), peer
       continue
 
@@ -410,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
-      g.punishInvalidMessage(peer, msg.topicIDs)
+      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
-      g.punishInvalidMessage(peer, msg.topicIDs)
+      g.punishInvalidMessage(peer, msg.topicIds)
       continue
 
     # g.anonymize needs no evaluation when receiving messages
@@ -432,6 +435,13 @@ method rpcHandler*(g: GossipSub,
   if rpcMsg.control.isSome():
     g.handleControl(peer, rpcMsg.control.unsafeGet())
 
+  # Now, check subscription to update the meshes if required
+  for i in 0..<min(g.topicsHigh, rpcMsg.subscriptions.len):
+    let topic = rpcMsg.subscriptions[i].topic
+    if topic in g.topics and g.mesh.peers(topic) < g.parameters.dLow:
+      # rebalance but don't update metrics here, we do that only in the heartbeat
+      g.rebalanceMesh(topic, metrics = nil)
+
   g.updateMetrics(rpcMsg)
 
 method onTopicSubscription*(g: GossipSub, topic: string, subscribed: bool) =
@@ -624,7 +634,7 @@ method initPubSub*(g: GossipSub)
     raise newException(InitializationError, $validationRes.error)
 
   # init the floodsub stuff here, we customize timedcache in gossip!
-  g.seen = TimedCache[MessageID].init(g.parameters.seenTTL)
+  g.seen = TimedCache[MessageId].init(g.parameters.seenTTL)
 
   # init gossip stuff
   g.mcache = MCache.init(g.parameters.historyGossip, g.parameters.historyLength)

libp2p/protocols/pubsub/gossipsub/behavior.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables, sequtils, sets, algorithm]
 import chronos, chronicles, metrics
@@ -16,6 +19,9 @@ import ".."/[pubsubpeer, peertable, timedcache, mcache, floodsub, pubsub]
 import "../rpc"/[messages]
 import "../../.."/[peerid, multiaddress, utility, switch, routing_record, signed_envelope, utils/heartbeat]
 
+logScope:
+  topics = "libp2p gossipsub"
+
 declareGauge(libp2p_gossipsub_cache_window_size, "the number of messages in the cache")
 declareGauge(libp2p_gossipsub_peers_per_topic_mesh, "gossipsub peers per topic in mesh", labels = ["topic"])
 declareGauge(libp2p_gossipsub_peers_per_topic_fanout, "gossipsub peers per topic in fanout", labels = ["topic"])
@@ -102,7 +108,7 @@ proc handleGraft*(g: GossipSub,
                  grafts: seq[ControlGraft]): seq[ControlPrune] = # {.raises: [Defect].} TODO chronicles exception on windows
   var prunes: seq[ControlPrune]
   for graft in grafts:
-    let topic = graft.topicID
+    let topic = graft.topicId
     trace "peer grafted topic", peer, topic
 
     # It is an error to GRAFT on a explicit peer
@@ -188,7 +194,7 @@ proc getPeers(prune: ControlPrune, peer: PubSubPeer): seq[(PeerId, Option[PeerRe
           trace "peer sent invalid SPR", peer, error=signedRecord.error
           none(PeerRecord)
         else:
-          if record.peerID != signedRecord.get().data.peerId:
+          if record.peerId != signedRecord.get().data.peerId:
             trace "peer sent envelope with wrong public key", peer
             none(PeerRecord)
           else:
@@ -201,7 +207,7 @@ proc getPeers(prune: ControlPrune, peer: PubSubPeer): seq[(PeerId, Option[PeerRe
 
 proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.raises: [Defect].} =
   for prune in prunes:
-    let topic = prune.topicID
+    let topic = prune.topicId
 
     trace "peer pruned topic", peer, topic
 
@@ -246,21 +252,21 @@ proc handleIHave*(g: GossipSub,
     let deIhaves = ihaves.deduplicate()
     for ihave in deIhaves:
       trace "peer sent ihave",
-        peer, topic = ihave.topicID, msgs = ihave.messageIDs
-      if ihave.topicID in g.mesh:
+        peer, topic = ihave.topicId, msgs = ihave.messageIds
+      if ihave.topicId in g.mesh:
         # also avoid duplicates here!
-        let deIhavesMsgs = ihave.messageIDs.deduplicate()
+        let deIhavesMsgs = ihave.messageIds.deduplicate()
         for msgId in deIhavesMsgs:
           if not g.hasSeen(msgId):
             if peer.iHaveBudget > 0:
-              res.messageIDs.add(msgId)
+              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)
+    g.rng.shuffle(res.messageIds)
     return res
 
 proc handleIWant*(g: GossipSub,
@@ -274,7 +280,7 @@ proc handleIWant*(g: GossipSub,
   else:
     let deIwants = iwants.deduplicate()
     for iwant in deIwants:
-      let deIwantsMsgs = iwant.messageIDs.deduplicate()
+      let deIwantsMsgs = iwant.messageIds.deduplicate()
       for mid in deIwantsMsgs:
         trace "peer sent iwant", peer, messageID = mid
         let msg = g.mcache.get(mid)
@@ -323,7 +329,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
       candidates: seq[PubSubPeer]
       currentMesh = addr defaultMesh
     g.mesh.withValue(topic, v): currentMesh = v
-    g.gossipSub.withValue(topic, peerList):
+    g.gossipsub.withValue(topic, peerList):
       for it in peerList[]:
         if
             it.connected and
@@ -361,7 +367,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
       candidates: seq[PubSubPeer]
       currentMesh = addr defaultMesh
     g.mesh.withValue(topic, v): currentMesh = v
-    g.gossipSub.withValue(topic, peerList):
+    g.gossipsub.withValue(topic, peerList):
       for it in peerList[]:
         if
             it.connected and
@@ -466,7 +472,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
         avail: seq[PubSubPeer]
         currentMesh = addr defaultMesh
       g.mesh.withValue(topic, v): currentMesh = v
-      g.gossipSub.withValue(topic, peerList):
+      g.gossipsub.withValue(topic, peerList):
         for it in peerList[]:
           if
               # avoid negative score peers
@@ -611,7 +617,7 @@ proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises:
       allPeers.setLen(target)
 
     for peer in allPeers:
-      control.mGetOrPut(peer, ControlMessage()).ihave.add(ihave)
+      control.mgetOrPut(peer, ControlMessage()).ihave.add(ihave)
 
   libp2p_gossipsub_cache_window_size.set(cacheWindowSize.int64)
 
@@ -667,8 +673,8 @@ proc onHeartbeat(g: GossipSub) {.raises: [Defect].} =
     for peer, control in peers:
       # only ihave from here
       for ihave in control.ihave:
-        if g.knownTopics.contains(ihave.topicID):
-          libp2p_pubsub_broadcast_ihave.inc(labelValues = [ihave.topicID])
+        if g.knownTopics.contains(ihave.topicId):
+          libp2p_pubsub_broadcast_ihave.inc(labelValues = [ihave.topicId])
         else:
           libp2p_pubsub_broadcast_ihave.inc(labelValues = ["generic"])
       g.send(peer, RPCMsg(control: some(control)))

libp2p/protocols/pubsub/gossipsub/scoring.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables, sets, options]
 import chronos, chronicles, metrics
@@ -15,6 +18,9 @@ import "."/[types]
 import ".."/[pubsubpeer]
 import "../../.."/[peerid, multiaddress, utility, switch, utils/heartbeat]
 
+logScope:
+  topics = "libp2p gossipsub"
+
 declareGauge(libp2p_gossipsub_peers_scores, "the scores of the peers in gossipsub", labels = ["agent"])
 declareCounter(libp2p_gossipsub_bad_score_disconnection, "the number of peers disconnected by gossipsub", labels = ["agent"])
 declareGauge(libp2p_gossipsub_peers_score_firstMessageDeliveries, "Detailed gossipsub scoring metric", labels = ["agent"])
@@ -101,7 +107,6 @@ proc disconnectPeer(g: GossipSub, peer: PubSubPeer) {.async.} =
   except CatchableError as exc: # Never cancelled
     trace "Failed to close connection", peer, error = exc.name, msg = exc.msg
 
-{.push raises: [Defect].}
 
 proc updateScores*(g: GossipSub) = # avoid async
   ## https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#the-score-function

libp2p/protocols/pubsub/gossipsub/types.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,13 +7,16 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import chronos
 import std/[tables, sets]
 import ".."/[floodsub, peertable, mcache, pubsubpeer]
 import "../rpc"/[messages]
-import "../../.."/[peerid, multiaddress]
+import "../../.."/[peerid, multiaddress, utility]
 
 const
   GossipSubCodec* = "/meshsub/1.1.0"
@@ -62,7 +65,7 @@ type
     meshFailurePenalty*: float64
     invalidMessageDeliveries*: float64
 
-  TopicParams* = object
+  TopicParams* {.public.} = object
     topicWeight*: float64
 
     # p1
@@ -99,7 +102,7 @@ type
     appScore*: float64 # application specific score
     behaviourPenalty*: float64 # the eventual penalty score
 
-  GossipSubParams* = object
+  GossipSubParams* {.public.} = object
     explicit*: bool
     pruneBackoff*: Duration
     unsubscribeBackoff*: Duration
@@ -141,7 +144,7 @@ type
     enablePX*: bool
 
   BackoffTable* = Table[string, Table[PeerId, Moment]]
-  ValidationSeenTable* = Table[MessageID, HashSet[PubSubPeer]]
+  ValidationSeenTable* = Table[MessageId, HashSet[PubSubPeer]]
 
   RoutingRecordsPair* = tuple[id: PeerId, record: Option[PeerRecord]]
   RoutingRecordsHandler* =

libp2p/protocols/pubsub/mcache.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[sets, tables, options]
 import rpc/[messages]
@@ -16,36 +19,36 @@ export sets, tables, messages, options
 
 type
   CacheEntry* = object
-    mid*: MessageID
-    topicIDs*: seq[string]
+    mid*: MessageId
+    topicIds*: seq[string]
 
   MCache* = object of RootObj
-    msgs*: Table[MessageID, Message]
+    msgs*: Table[MessageId, Message]
     history*: seq[seq[CacheEntry]]
     windowSize*: Natural
 
-func get*(c: MCache, mid: MessageID): Option[Message] =
+func get*(c: MCache, mid: MessageId): Option[Message] =
   if mid in c.msgs:
     try: some(c.msgs[mid])
     except KeyError: raiseAssert "checked"
   else:
     none(Message)
 
-func contains*(c: MCache, mid: MessageID): bool =
+func contains*(c: MCache, mid: MessageId): bool =
   mid in c.msgs
 
-func put*(c: var MCache, msgId: MessageID, msg: Message) =
+func put*(c: var MCache, msgId: MessageId, msg: Message) =
   if not c.msgs.hasKeyOrPut(msgId, msg):
     # Only add cache entry if the message was not already in the cache
-    c.history[0].add(CacheEntry(mid: msgId, topicIDs: msg.topicIDs))
+    c.history[0].add(CacheEntry(mid: msgId, topicIds: msg.topicIds))
 
-func window*(c: MCache, topic: string): HashSet[MessageID] =
+func window*(c: MCache, topic: string): HashSet[MessageId] =
   let
     len = min(c.windowSize, c.history.len)
 
   for i in 0..<len:
     for entry in c.history[i]:
-      for t in entry.topicIDs:
+      for t in entry.topicIds:
         if t == topic:
           result.incl(entry.mid)
           break

libp2p/protocols/pubsub/peertable.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables, sets]
 import ./pubsubpeer, ../../peerid

libp2p/protocols/pubsub/pubsub.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -13,7 +13,10 @@
 ## `publish<#publish.e%2CPubSub%2Cstring%2Cseq%5Bbyte%5D>`_ something on it,
 ## and eventually `unsubscribe<#unsubscribe%2CPubSub%2Cstring%2CTopicHandler>`_ from it.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables, sequtils, sets, strutils]
 import chronos, chronicles, metrics
@@ -90,7 +93,7 @@ type
   TopicPair* = tuple[topic: string, handler: TopicHandler]
 
   MsgIdProvider* {.public.} =
-    proc(m: Message): Result[MessageID, ValidationResult] {.noSideEffect, raises: [Defect], gcsafe.}
+    proc(m: Message): Result[MessageId, ValidationResult] {.noSideEffect, raises: [Defect], gcsafe.}
 
   SubscriptionValidator* {.public.} =
     proc(topic: string): bool {.raises: [Defect], gcsafe.}
@@ -127,7 +130,7 @@ type
 
     knownTopics*: HashSet[string]
 
-method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base.} =
+method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base, gcsafe.} =
   ## handle peer disconnects
   ##
 
@@ -163,7 +166,7 @@ proc broadcast*(
         libp2p_pubsub_broadcast_unsubscriptions.inc(npeers, labelValues = ["generic"])
 
   for smsg in msg.messages:
-    for topic in smsg.topicIDs:
+    for topic in smsg.topicIds:
       if p.knownTopics.contains(topic):
         libp2p_pubsub_broadcast_messages.inc(npeers, labelValues = [topic])
       else:
@@ -174,18 +177,18 @@ proc broadcast*(
 
     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])
+      if p.knownTopics.contains(ihave.topicId):
+        libp2p_pubsub_broadcast_ihave.inc(npeers, labelValues = [ihave.topicId])
       else:
         libp2p_pubsub_broadcast_ihave.inc(npeers, labelValues = ["generic"])
     for graft in control.graft:
-      if p.knownTopics.contains(graft.topicID):
-        libp2p_pubsub_broadcast_graft.inc(npeers, labelValues = [graft.topicID])
+      if p.knownTopics.contains(graft.topicId):
+        libp2p_pubsub_broadcast_graft.inc(npeers, labelValues = [graft.topicId])
       else:
         libp2p_pubsub_broadcast_graft.inc(npeers, labelValues = ["generic"])
     for prune in control.prune:
-      if p.knownTopics.contains(prune.topicID):
-        libp2p_pubsub_broadcast_prune.inc(npeers, labelValues = [prune.topicID])
+      if p.knownTopics.contains(prune.topicId):
+        libp2p_pubsub_broadcast_prune.inc(npeers, labelValues = [prune.topicId])
       else:
         libp2p_pubsub_broadcast_prune.inc(npeers, labelValues = ["generic"])
 
@@ -199,7 +202,7 @@ proc broadcast*(
     # Fast path that only encodes message once
     let encoded = encodeRpcMsg(msg, p.anonymize)
     for peer in sendPeers:
-      peer.sendEncoded(encoded)
+      asyncSpawn peer.sendEncoded(encoded)
 
 proc sendSubs*(p: PubSub,
                peer: PubSubPeer,
@@ -236,8 +239,8 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =
 
   for i in 0..<rpcMsg.messages.len():
     template smsg: untyped = rpcMsg.messages[i]
-    for j in 0..<smsg.topicIDs.len():
-      template topic: untyped = smsg.topicIDs[j]
+    for j in 0..<smsg.topicIds.len():
+      template topic: untyped = smsg.topicIds[j]
       if p.knownTopics.contains(topic):
         libp2p_pubsub_received_messages.inc(labelValues = [topic])
       else:
@@ -247,30 +250,30 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =
     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])
+      if p.knownTopics.contains(ihave.topicId):
+        libp2p_pubsub_received_ihave.inc(labelValues = [ihave.topicId])
       else:
         libp2p_pubsub_received_ihave.inc(labelValues = ["generic"])
     for graft in control.graft:
-      if p.knownTopics.contains(graft.topicID):
-        libp2p_pubsub_received_graft.inc(labelValues = [graft.topicID])
+      if p.knownTopics.contains(graft.topicId):
+        libp2p_pubsub_received_graft.inc(labelValues = [graft.topicId])
       else:
         libp2p_pubsub_received_graft.inc(labelValues = ["generic"])
     for prune in control.prune:
-      if p.knownTopics.contains(prune.topicID):
-        libp2p_pubsub_received_prune.inc(labelValues = [prune.topicID])
+      if p.knownTopics.contains(prune.topicId):
+        libp2p_pubsub_received_prune.inc(labelValues = [prune.topicId])
       else:
         libp2p_pubsub_received_prune.inc(labelValues = ["generic"])
 
 method rpcHandler*(p: PubSub,
                    peer: PubSubPeer,
-                   rpcMsg: RPCMsg): Future[void] {.base.} =
+                   rpcMsg: RPCMsg): Future[void] {.base, async.} =
   ## Handler that must be overridden by concrete implementation
   raiseAssert "Unimplemented"
 
-method onNewPeer(p: PubSub, peer: PubSubPeer) {.base.} = discard
+method onNewPeer(p: PubSub, peer: PubSubPeer) {.base, gcsafe.} = discard
 
-method onPubSubPeerEvent*(p: PubSub, peer: PubsubPeer, event: PubsubPeerEvent) {.base, gcsafe.} =
+method onPubSubPeerEvent*(p: PubSub, peer: PubSubPeer, event: PubSubPeerEvent) {.base, gcsafe.} =
   # Peer event is raised for the send connection in particular
   case event.kind
   of PubSubPeerEventKind.Connected:
@@ -286,22 +289,14 @@ proc getOrCreatePeer*(
   p.peers.withValue(peerId, peer):
     return peer[]
 
-  proc getConn(): Future[Connection] =
-    p.switch.dial(peerId, protos)
+  proc getConn(): Future[Connection] {.async.} =
+    return await p.switch.dial(peerId, protos)
 
-  proc dropConn(peer: PubSubPeer) =
-    proc dropConnAsync(peer: PubsubPeer) {.async.} =
-      try:
-        await p.switch.disconnect(peer.peerId)
-      except CatchableError as exc: # never cancelled
-        trace "Failed to close connection", peer, error = exc.name, msg = exc.msg
-    asyncSpawn dropConnAsync(peer)
-
-  proc onEvent(peer: PubsubPeer, event: PubsubPeerEvent) {.gcsafe.} =
+  proc onEvent(peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe.} =
     p.onPubSubPeerEvent(peer, event)
 
   # create new pubsub peer
-  let pubSubPeer = PubSubPeer.new(peerId, getConn, dropConn, onEvent, protos[0], p.maxMessageSize)
+  let pubSubPeer = PubSubPeer.new(peerId, getConn, onEvent, protos[0], p.maxMessageSize)
   debug "created new pubsub peer", peerId
 
   p.peers[peerId] = pubSubPeer
@@ -312,8 +307,6 @@ proc 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] =
@@ -382,12 +375,13 @@ method handleConn*(p: PubSub,
   finally:
     await conn.closeWithEOF()
 
-method subscribePeer*(p: PubSub, peer: PeerId) {.base.} =
+method subscribePeer*(p: PubSub, peer: PeerId) {.base, gcsafe.} =
   ## subscribe to remote peer to receive/send pubsub
   ## messages
   ##
 
-  discard p.getOrCreatePeer(peer, p.codecs)
+  let pubSubPeer = p.getOrCreatePeer(peer, p.codecs)
+  pubSubPeer.connect()
 
 proc updateTopicMetrics(p: PubSub, topic: string) =
   # metrics
@@ -405,7 +399,7 @@ proc updateTopicMetrics(p: PubSub, topic: string) =
 
     libp2p_pubsub_topic_handlers.set(others, labelValues = ["other"])
 
-method onTopicSubscription*(p: PubSub, topic: string, subscribed: bool) {.base.} =
+method onTopicSubscription*(p: PubSub, topic: string, subscribed: bool) {.base, gcsafe.} =
   # Called when subscribe is called the first time for a topic or unsubscribe
   # removes the last handler
 
@@ -438,7 +432,7 @@ proc unsubscribe*(p: PubSub, topics: openArray[TopicPair]) {.public.} =
   for t in topics:
     p.unsubscribe(t.topic, t.handler)
 
-proc unsubscribeAll*(p: PubSub, topic: string) {.public.} =
+proc unsubscribeAll*(p: PubSub, topic: string) {.public, gcsafe.} =
   ## unsubscribe every `handler` from `topic`
   if topic notin p.topics:
     debug "unsubscribeAll called for an unknown topic", topic
@@ -500,7 +494,7 @@ method initPubSub*(p: PubSub)
 
 method addValidator*(p: PubSub,
                      topic: varargs[string],
-                     hook: ValidatorHandler) {.base, public.} =
+                     hook: ValidatorHandler) {.base, public, gcsafe.} =
   ## Add a validator to a `topic`. Each new message received in this
   ## will be sent to `hook`. `hook` can return either `Accept`,
   ## `Ignore` or `Reject` (which can descore the peer)
@@ -520,11 +514,11 @@ method removeValidator*(p: PubSub,
 method validate*(p: PubSub, message: Message): Future[ValidationResult] {.async, base.} =
   var pending: seq[Future[ValidationResult]]
   trace "about to validate message"
-  for topic in message.topicIDs:
-    trace "looking for validators on topic", topicID = topic,
+  for topic in message.topicIds:
+    trace "looking for validators on topic", topicId = topic,
                                              registered = toSeq(p.validators.keys)
     if topic in p.validators:
-      trace "running validators for topic", topicID = topic
+      trace "running validators for topic", topicId = topic
       for validator in p.validators[topic]:
         pending.add(validator(topic, message))
 

libp2p/protocols/pubsub/pubsubpeer.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,9 +7,13 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
-import std/[sequtils, strutils, tables, hashes]
+import std/[sequtils, strutils, tables, hashes, options]
+import stew/results
 import chronos, chronicles, nimcrypto/sha2, metrics
 import rpc/[messages, message, protobuf],
        ../../peerid,
@@ -39,19 +43,19 @@ type
     Connected
     Disconnected
 
-  PubsubPeerEvent* = object
+  PubSubPeerEvent* = object
     kind*: PubSubPeerEventKind
 
   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].}
+  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
-    dropConn*: DropConn                 # Function pointer to use to drop connections
     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
@@ -70,6 +74,10 @@ type
   RPCHandler* = proc(peer: PubSubPeer, msg: RPCMsg): Future[void]
     {.gcsafe, raises: [Defect].}
 
+proc queuedSendBytes*(p: PubSubPeer): int =
+  if p.sendConn.isNil: 0
+  else: p.sendConn.queuedSendBytes()
+
 func hash*(p: PubSubPeer): Hash =
   p.peerId.hash
 
@@ -162,6 +170,8 @@ 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()
     if newConn.isNil:
       raise (ref LPError)(msg: "Cannot establish send connection")
@@ -171,11 +181,12 @@ 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
+    p.connectedFut.complete()
     p.sendConn = newConn
-    p.address = some(p.sendConn.observedAddr)
+    p.address = if p.sendConn.observedAddr.isSome: some(p.sendConn.observedAddr.get) else: none(MultiAddress)
 
     if p.onEvent != nil:
-      p.onEvent(p, PubsubPeerEvent(kind: PubSubPeerEventKind.Connected))
+      p.onEvent(p, PubSubPeerEvent(kind: PubSubPeerEventKind.Connected))
 
     await handle(p, newConn)
   finally:
@@ -186,7 +197,7 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
 
     try:
       if p.onEvent != nil:
-        p.onEvent(p, PubsubPeerEvent(kind: PubSubPeerEventKind.Disconnected))
+        p.onEvent(p, PubSubPeerEvent(kind: PubSubPeerEventKind.Disconnected))
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
@@ -203,33 +214,13 @@ proc connectImpl(p: PubSubPeer) {.async.} =
       await connectOnce(p)
   except CatchableError as exc: # never cancelled
     debug "Could not establish send connection", msg = exc.msg
-  finally:
-    # drop the connection, else we end up with ghost peers
-    if p.dropConn != nil: p.dropConn(p)
 
 proc connect*(p: PubSubPeer) =
+  if p.connected:
+    return
+
   asyncSpawn connectImpl(p)
 
-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:
@@ -237,7 +228,7 @@ template sendMetrics(msg: RPCMsg): untyped =
         # metrics
         libp2p_pubsub_sent_messages.inc(labelValues = [$p.peerId, t])
 
-proc sendEncoded*(p: PubSubPeer, msg: seq[byte]) {.raises: [Defect].} =
+proc sendEncoded*(p: PubSubPeer, msg: seq[byte]) {.raises: [Defect], async.} =
   doAssert(not isNil(p), "pubsubpeer nil!")
 
   if msg.len <= 0:
@@ -248,14 +239,27 @@ proc sendEncoded*(p: PubSubPeer, msg: seq[byte]) {.raises: [Defect].} =
     info "trying to send a too big for pubsub", maxSize=p.maxMessageSize, msgSize=msg.len
     return
 
-  let conn = p.sendConn
+  if p.sendConn == nil:
+    discard await p.connectedFut.withTimeout(1.seconds)
+
+  var conn = p.sendConn
   if conn == nil or conn.closed():
-    trace "No send connection, skipping message", p, msg = shortLog(msg)
+    debug "No send connection, skipping message", p, msg = shortLog(msg)
     return
 
-  # To limit the size of the closure, we only pass the encoded message and
-  # connection to the spawned send task
-  asyncSpawn sendImpl(conn, msg)
+  trace "sending encoded msgs to peer", conn, encoded = shortLog(msg)
+
+  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 send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [Defect].} =
   trace "sending msg to peer", peer = p, rpcMsg = shortLog(msg)
@@ -277,22 +281,21 @@ proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [Defect].} =
     sendMetrics(msg)
     encodeRpcMsg(msg, anonymize)
 
-  p.sendEncoded(encoded)
+  asyncSpawn p.sendEncoded(encoded)
 
 proc new*(
   T: typedesc[PubSubPeer],
   peerId: PeerId,
   getConn: GetConn,
-  dropConn: DropConn,
   onEvent: OnEvent,
   codec: string,
   maxMessageSize: int): T =
 
   T(
     getConn: getConn,
-    dropConn: dropConn,
     onEvent: onEvent,
     codec: codec,
     peerId: peerId,
+    connectedFut: newFuture[void](),
     maxMessageSize: maxMessageSize
   )

libp2p/protocols/pubsub/rpc/message.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import hashes
 import chronicles, metrics, stew/[byteutils, endians2]
@@ -29,7 +32,7 @@ const PubSubPrefix = toBytes("libp2p-pubsub:")
 declareCounter(libp2p_pubsub_sig_verify_success, "pubsub successfully validated messages")
 declareCounter(libp2p_pubsub_sig_verify_failure, "pubsub failed validated messages")
 
-func defaultMsgIdProvider*(m: Message): Result[MessageID, ValidationResult] =
+func defaultMsgIdProvider*(m: Message): Result[MessageId, ValidationResult] =
   if m.seqno.len > 0 and m.fromPeer.data.len > 0:
     let mid = byteutils.toHex(m.seqno) & $m.fromPeer
     ok mid.toBytes()

libp2p/protocols/pubsub/rpc/messages.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import options, sequtils
 import "../../.."/[
@@ -27,13 +30,13 @@ type
       subscribe*: bool
       topic*: string
 
-    MessageID* = seq[byte]
+    MessageId* = seq[byte]
 
     Message* = object
       fromPeer*: PeerId
       data*: seq[byte]
       seqno*: seq[byte]
-      topicIDs*: seq[string]
+      topicIds*: seq[string]
       signature*: seq[byte]
       key*: seq[byte]
 
@@ -44,17 +47,17 @@ type
       prune*: seq[ControlPrune]
 
     ControlIHave* = object
-      topicID*: string
-      messageIDs*: seq[MessageID]
+      topicId*: string
+      messageIds*: seq[MessageId]
 
     ControlIWant* = object
-      messageIDs*: seq[MessageID]
+      messageIds*: seq[MessageId]
 
     ControlGraft* = object
-      topicID*: string
+      topicId*: string
 
     ControlPrune* = object
-      topicID*: string
+      topicId*: string
       peers*: seq[PeerInfoMsg]
       backoff*: uint64
 
@@ -70,23 +73,23 @@ func withSubs*(
 
 func shortLog*(s: ControlIHave): auto =
   (
-    topicID: s.topicID.shortLog,
-    messageIDs: mapIt(s.messageIDs, it.shortLog)
+    topicId: s.topicId.shortLog,
+    messageIds: mapIt(s.messageIds, it.shortLog)
   )
 
 func shortLog*(s: ControlIWant): auto =
   (
-    messageIDs: mapIt(s.messageIDs, it.shortLog)
+    messageIds: mapIt(s.messageIds, it.shortLog)
   )
 
 func shortLog*(s: ControlGraft): auto =
   (
-    topicID: s.topicID.shortLog
+    topicId: s.topicId.shortLog
   )
 
 func shortLog*(s: ControlPrune): auto =
   (
-    topicID: s.topicID.shortLog
+    topicId: s.topicId.shortLog
   )
 
 func shortLog*(c: ControlMessage): auto =
@@ -102,7 +105,7 @@ func shortLog*(msg: Message): auto =
     fromPeer: msg.fromPeer.shortLog,
     data: msg.data.shortLog,
     seqno: msg.seqno.shortLog,
-    topicIDs: $msg.topicIDs,
+    topicIds: $msg.topicIds,
     signature: msg.signature.shortLog,
     key: msg.key.shortLog
   )

libp2p/protocols/pubsub/rpc/protobuf.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import options
 import stew/assign2
@@ -17,10 +20,9 @@ import messages,
        ../../../utility,
        ../../../protobuf/minprotobuf
 
-{.push raises: [Defect].}
 
 logScope:
-  topics = "pubsubprotobuf"
+  topics = "libp2p pubsubprotobuf"
 
 when defined(libp2p_protobuf_metrics):
   import metrics
@@ -30,7 +32,7 @@ when defined(libp2p_protobuf_metrics):
 
 proc write*(pb: var ProtoBuffer, field: int, graft: ControlGraft) =
   var ipb = initProtoBuffer()
-  ipb.write(1, graft.topicID)
+  ipb.write(1, graft.topicId)
   ipb.finish()
   pb.write(field, ipb)
 
@@ -46,7 +48,7 @@ proc write*(pb: var ProtoBuffer, field: int, infoMsg: PeerInfoMsg) =
 
 proc write*(pb: var ProtoBuffer, field: int, prune: ControlPrune) =
   var ipb = initProtoBuffer()
-  ipb.write(1, prune.topicID)
+  ipb.write(1, prune.topicId)
   for peer in prune.peers:
     ipb.write(2, peer)
   ipb.write(3, prune.backoff)
@@ -58,8 +60,8 @@ proc write*(pb: var ProtoBuffer, field: int, prune: ControlPrune) =
 
 proc write*(pb: var ProtoBuffer, field: int, ihave: ControlIHave) =
   var ipb = initProtoBuffer()
-  ipb.write(1, ihave.topicID)
-  for mid in ihave.messageIDs:
+  ipb.write(1, ihave.topicId)
+  for mid in ihave.messageIds:
     ipb.write(2, mid)
   ipb.finish()
   pb.write(field, ipb)
@@ -69,7 +71,7 @@ proc write*(pb: var ProtoBuffer, field: int, ihave: ControlIHave) =
 
 proc write*(pb: var ProtoBuffer, field: int, iwant: ControlIWant) =
   var ipb = initProtoBuffer()
-  for mid in iwant.messageIDs:
+  for mid in iwant.messageIds:
     ipb.write(1, mid)
   if len(ipb.buffer) > 0:
     ipb.finish()
@@ -109,7 +111,7 @@ proc encodeMessage*(msg: Message, anonymize: bool): seq[byte] =
   pb.write(2, msg.data)
   if len(msg.seqno) > 0 and not anonymize:
     pb.write(3, msg.seqno)
-  for topic in msg.topicIDs:
+  for topic in msg.topicIds:
     pb.write(4, topic)
   if len(msg.signature) > 0 and not anonymize:
     pb.write(5, msg.signature)
@@ -182,8 +184,8 @@ proc decodeIHave*(pb: ProtoBuffer): ProtoResult[ControlIHave] {.
     trace "decodeIHave: read topicId", topic_id = control.topicId
   else:
     trace "decodeIHave: topicId is missing"
-  if ? pb.getRepeatedField(2, control.messageIDs):
-    trace "decodeIHave: read messageIDs", message_ids = control.messageIDs
+  if ? pb.getRepeatedField(2, control.messageIds):
+    trace "decodeIHave: read messageIDs", message_ids = control.messageIds
   else:
     trace "decodeIHave: no messageIDs"
   ok(control)
@@ -194,8 +196,8 @@ proc decodeIWant*(pb: ProtoBuffer): ProtoResult[ControlIWant] {.inline.} =
 
   trace "decodeIWant: decoding message"
   var control = ControlIWant()
-  if ? pb.getRepeatedField(1, control.messageIDs):
-    trace "decodeIWant: read messageIDs", message_ids = control.messageIDs
+  if ? pb.getRepeatedField(1, control.messageIds):
+    trace "decodeIWant: read messageIDs", message_ids = control.messageIds
   else:
     trace "decodeIWant: no messageIDs"
   ok(control)
@@ -281,8 +283,8 @@ proc decodeMessage*(pb: ProtoBuffer): ProtoResult[Message] {.inline.} =
     trace "decodeMessage: read seqno", seqno = msg.seqno
   else:
     trace "decodeMessage: seqno is missing"
-  if ? pb.getRepeatedField(4, msg.topicIDs):
-    trace "decodeMessage: read topics", topic_ids = msg.topicIDs
+  if ? pb.getRepeatedField(4, msg.topicIds):
+    trace "decodeMessage: read topics", topic_ids = msg.topicIds
   else:
     trace "decodeMessage: topics are missing"
   if ? pb.getField(5, msg.signature):
@@ -302,14 +304,15 @@ proc decodeMessages*(pb: ProtoBuffer): ProtoResult[seq[Message]] {.inline.} =
   if ? pb.getRepeatedField(2, msgpbs):
     trace "decodeMessages: read messages", count = len(msgpbs)
     for item in msgpbs:
-      msgs.add(? decodeMessage(initProtoBuffer(item)))
+      # size is constrained at the network level
+      msgs.add(? decodeMessage(initProtoBuffer(item, maxSize = uint.high)))
   else:
     trace "decodeMessages: no messages found"
   ok(msgs)
 
 proc encodeRpcMsg*(msg: RPCMsg, anonymize: bool): seq[byte] =
   trace "encodeRpcMsg: encoding message", msg = msg.shortLog()
-  var pb = initProtoBuffer()
+  var pb = initProtoBuffer(maxSize = uint.high)
   for item in msg.subscriptions:
     pb.write(1, item)
   for item in msg.messages:
@@ -322,7 +325,7 @@ 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)
+  var pb = initProtoBuffer(msg, maxSize = uint.high)
   var rpcMsg = ok(RPCMsg())
   assign(rpcMsg.get().messages, ? pb.decodeMessages())
   assign(rpcMsg.get().subscriptions, ? pb.decodeSubscriptions())

libp2p/protocols/pubsub/timedcache.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[tables]
 

libp2p/protocols/relay.nim

@@ -1,489 +0,0 @@
-# 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.
-
-{.push raises: [Defect].}
-
-import options
-import sequtils, strutils, tables
-import chronos, chronicles
-
-import ../peerinfo,
-       ../switch,
-       ../multiaddress,
-       ../stream/connection,
-       ../protocols/protocol,
-       ../transports/transport,
-       ../utility,
-       ../errors
-
-const
-  RelayCodec* = "/libp2p/circuit/relay/0.1.0"
-  MsgSize* = 4096
-  MaxCircuit* = 1024
-  MaxCircuitPerPeer* = 64
-
-logScope:
-  topics = "libp2p relay"
-
-type
-  RelayType* = enum
-    Hop = 1
-    Stop = 2
-    Status = 3
-    CanHop = 4
-  RelayStatus* = enum
-    Success = 100
-    HopSrcAddrTooLong = 220
-    HopDstAddrTooLong = 221
-    HopSrcMultiaddrInvalid = 250
-    HopDstMultiaddrInvalid = 251
-    HopNoConnToDst = 260
-    HopCantDialDst = 261
-    HopCantOpenDstStream = 262
-    HopCantSpeakRelay = 270
-    HopCantRelayToSelf = 280
-    StopSrcAddrTooLong = 320
-    StopDstAddrTooLong = 321
-    StopSrcMultiaddrInvalid = 350
-    StopDstMultiaddrInvalid = 351
-    StopRelayRefused = 390
-    MalformedMessage = 400
-
-  RelayError* = object of LPError
-
-  RelayPeer* = object
-    peerId*: PeerID
-    addrs*: seq[MultiAddress]
-
-  AddConn* = proc(conn: Connection): Future[void] {.gcsafe, raises: [Defect].}
-
-  RelayMessage* = object
-    msgType*: Option[RelayType]
-    srcPeer*: Option[RelayPeer]
-    dstPeer*: Option[RelayPeer]
-    status*: Option[RelayStatus]
-
-  Relay* = ref object of LPProtocol
-    switch*: Switch
-    peerId: PeerID
-    dialer: Dial
-    canHop: bool
-    streamCount: int
-    hopCount: CountTable[PeerId]
-
-    addConn: AddConn
-
-    maxCircuit*: int
-    maxCircuitPerPeer*: int
-    msgSize*: int
-
-proc encodeMsg*(msg: RelayMessage): ProtoBuffer =
-  result = initProtoBuffer()
-
-  if isSome(msg.msgType):
-    result.write(1, msg.msgType.get().ord.uint)
-  if isSome(msg.srcPeer):
-    var peer = initProtoBuffer()
-    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)
-  if isSome(msg.dstPeer):
-    var peer = initProtoBuffer()
-    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)
-  if isSome(msg.status):
-    result.write(4, msg.status.get().ord.uint)
-
-  result.finish()
-
-proc decodeMsg*(buf: seq[byte]): Option[RelayMessage] =
-  var
-    rMsg: RelayMessage
-    msgTypeOrd: uint32
-    src: RelayPeer
-    dst: RelayPeer
-    statusOrd: uint32
-    pbSrc: ProtoBuffer
-    pbDst: ProtoBuffer
-
-  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 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(): rMsg.msgType = some(RelayType(msgTypeOrd))
-  if r2.get(): rMsg.srcPeer = some(src)
-  if r3.get(): rMsg.dstPeer = some(dst)
-  if r4.get(): rMsg.status = some(RelayStatus(statusOrd))
-  some(rMsg)
-
-proc sendStatus*(conn: Connection, code: RelayStatus) {.async, gcsafe.} =
-  trace "send status", status = $code & "(" & $ord(code) & ")"
-  let
-    msg = RelayMessage(
-      msgType: some(RelayType.Status),
-      status: some(code))
-    pb = encodeMsg(msg)
-
-  await conn.writeLp(pb.buffer)
-
-proc handleHopStream(r: Relay, conn: Connection, msg: RelayMessage) {.async, gcsafe.} =
-  r.streamCount.inc()
-  defer:
-    r.streamCount.dec()
-
-  if r.streamCount > r.maxCircuit:
-    trace "refusing connection; too many active circuit"
-    await sendStatus(conn, RelayStatus.HopCantSpeakRelay)
-    return
-
-  proc checkMsg(): Result[RelayMessage, RelayStatus] =
-    if not r.canHop:
-      return err(RelayStatus.HopCantSpeakRelay)
-    if msg.srcPeer.isNone:
-      return err(RelayStatus.HopSrcMultiaddrInvalid)
-    let src = msg.srcPeer.get()
-    if src.peerId != conn.peerId:
-      return err(RelayStatus.HopSrcMultiaddrInvalid)
-    if msg.dstPeer.isNone:
-      return err(RelayStatus.HopDstMultiaddrInvalid)
-    let dst = msg.dstPeer.get()
-    if dst.peerId == r.switch.peerInfo.peerId:
-      return err(RelayStatus.HopCantRelayToSelf)
-    if not r.switch.isConnected(dst.peerId):
-      trace "relay not connected to dst", dst
-      return err(RelayStatus.HopNoConnToDst)
-    ok(msg)
-
-  let check = checkMsg()
-  if check.isErr:
-    await sendStatus(conn, check.error())
-    return
-  let
-    src = msg.srcPeer.get()
-    dst = msg.dstPeer.get()
-
-  # TODO: if r.acl # access control list
-  #       and not r.acl.AllowHop(src.peerId, dst.peerId)
-  #         sendStatus(conn, RelayStatus.HopCantSpeakRelay)
-
-  r.hopCount.inc(src.peerId)
-  r.hopCount.inc(dst.peerId)
-  defer:
-    r.hopCount.inc(src.peerId, -1)
-    r.hopCount.inc(dst.peerId, -1)
-
-  if r.hopCount[src.peerId] > r.maxCircuitPerPeer:
-    trace "refusing connection; too many connection from src", src, dst
-    await sendStatus(conn, RelayStatus.HopCantSpeakRelay)
-    return
-
-  if r.hopCount[dst.peerId] > r.maxCircuitPerPeer:
-    trace "refusing connection; too many connection to dst", src, dst
-    await sendStatus(conn, RelayStatus.HopCantSpeakRelay)
-    return
-
-  let connDst = try:
-    await r.switch.dial(dst.peerId, @[RelayCodec])
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error opening relay stream", dst, exc=exc.msg
-    await sendStatus(conn, RelayStatus.HopCantDialDst)
-    return
-  defer:
-    await connDst.close()
-
-  let msgToSend = RelayMessage(
-    msgType: some(RelayType.Stop),
-    srcPeer: some(src),
-    dstPeer: some(dst),
-    status: none(RelayStatus))
-
-  let msgRcvFromDstOpt = try:
-    await connDst.writeLp(encodeMsg(msgToSend).buffer)
-    decodeMsg(await connDst.readLp(r.msgSize))
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error writing stop handshake or reading stop response", exc=exc.msg
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    return
-
-  if msgRcvFromDstOpt.isNone:
-    trace "error reading stop response", msg = msgRcvFromDstOpt
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    return
-
-  let msgRcvFromDst = msgRcvFromDstOpt.get()
-  if msgRcvFromDst.msgType.isNone or msgRcvFromDst.msgType.get() != RelayType.Status:
-    trace "unexcepted relay stop response", msgType = msgRcvFromDst.msgType
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    return
-
-  if msgRcvFromDst.status.isNone or msgRcvFromDst.status.get() != RelayStatus.Success:
-    trace "relay stop failure", status=msgRcvFromDst.status
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    return
-
-  await sendStatus(conn, RelayStatus.Success)
-
-  trace "relaying connection", src, dst
-
-  proc bridge(conn: Connection, connDst: Connection) {.async.} =
-    const bufferSize = 4096
-    var
-      bufSrcToDst: array[bufferSize, byte]
-      bufDstToSrc: array[bufferSize, byte]
-      futSrc = conn.readOnce(addr bufSrcToDst[0], bufSrcToDst.high + 1)
-      futDst = connDst.readOnce(addr bufDstToSrc[0], bufDstToSrc.high + 1)
-      bytesSendFromSrcToDst = 0
-      bytesSendFromDstToSrc = 0
-      bufRead: int
-
-    while not conn.closed() and not connDst.closed():
-      try:
-        await futSrc or futDst
-        if futSrc.finished():
-          bufRead = await futSrc
-          bytesSendFromSrcToDst.inc(bufRead)
-          await connDst.write(@bufSrcToDst[0..<bufRead])
-          zeroMem(addr(bufSrcToDst), bufSrcToDst.high + 1)
-          futSrc = conn.readOnce(addr bufSrcToDst[0], bufSrcToDst.high + 1)
-        if futDst.finished():
-          bufRead = await futDst
-          bytesSendFromDstToSrc += bufRead
-          await conn.write(bufDstToSrc[0..<bufRead])
-          zeroMem(addr(bufDstToSrc), bufDstToSrc.high + 1)
-          futDst = connDst.readOnce(addr bufDstToSrc[0], bufDstToSrc.high + 1)
-      except CancelledError as exc:
-        raise exc
-      except CatchableError as exc:
-        if conn.closed() or conn.atEof():
-          trace "relay src closed connection", src
-        if connDst.closed() or connDst.atEof():
-          trace "relay dst closed connection", dst
-        trace "relay error", exc=exc.msg
-        break
-
-    trace "end relaying", bytesSendFromSrcToDst, bytesSendFromDstToSrc
-
-    await futSrc.cancelAndWait()
-    await futDst.cancelAndWait()
-  await bridge(conn, connDst)
-
-proc handleStopStream(r: Relay, conn: Connection, msg: RelayMessage) {.async, gcsafe.} =
-  if msg.srcPeer.isNone:
-    await sendStatus(conn, RelayStatus.StopSrcMultiaddrInvalid)
-    return
-  let src = msg.srcPeer.get()
-
-  if msg.dstPeer.isNone:
-    await sendStatus(conn, RelayStatus.StopDstMultiaddrInvalid)
-    return
-
-  let dst = msg.dstPeer.get()
-  if dst.peerId != r.switch.peerInfo.peerId:
-    await sendStatus(conn, RelayStatus.StopDstMultiaddrInvalid)
-    return
-
-  trace "get a relay connection", src, conn
-
-  if r.addConn == nil:
-    await sendStatus(conn, RelayStatus.StopRelayRefused)
-    await conn.close()
-    return
-  await sendStatus(conn, RelayStatus.Success)
-  # This sound redundant but the callback could, in theory, be set to nil during
-  # sendStatus(Success) so it's safer to double check
-  if r.addConn != nil: await r.addConn(conn)
-  else: await conn.close()
-
-proc handleCanHop(r: Relay, conn: Connection, msg: RelayMessage) {.async, gcsafe.} =
-  await sendStatus(conn,
-    if r.canHop:
-      RelayStatus.Success
-    else:
-      RelayStatus.HopCantSpeakRelay
-  )
-
-proc new*(T: typedesc[Relay], switch: Switch, canHop: bool): T =
-  let relay = T(switch: switch, canHop: canHop)
-  relay.init()
-  relay
-
-method init*(r: Relay) =
-  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
-    try:
-      let msgOpt = decodeMsg(await conn.readLp(r.msgSize))
-
-      if msgOpt.isNone:
-        await sendStatus(conn, RelayStatus.MalformedMessage)
-        return
-      else:
-        trace "relay handle stream", msg = msgOpt.get()
-      let msg = msgOpt.get()
-
-      case msg.msgType.get:
-        of RelayType.Hop: await r.handleHopStream(conn, msg)
-        of RelayType.Stop: await r.handleStopStream(conn, msg)
-        of RelayType.CanHop: await r.handleCanHop(conn, msg)
-        else:
-          trace "Unexpected relay handshake", msgType=msg.msgType
-          await sendStatus(conn, RelayStatus.MalformedMessage)
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      trace "exception in relay handler", exc = exc.msg, conn
-    finally:
-      trace "exiting relay handler", conn
-      await conn.close()
-
-  r.handler = handleStream
-  r.codecs = @[RelayCodec]
-
-  r.maxCircuit = MaxCircuit
-  r.maxCircuitPerPeer = MaxCircuitPerPeer
-  r.msgSize = MsgSize
-
-proc dialPeer(
-    r: Relay,
-    conn: Connection,
-    dstPeerId: PeerId,
-    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
-  var
-    msg = RelayMessage(
-      msgType: some(RelayType.Hop),
-      srcPeer: some(RelayPeer(peerId: r.switch.peerInfo.peerId, addrs: r.switch.peerInfo.addrs)),
-      dstPeer: some(RelayPeer(peerId: dstPeerId, addrs: dstAddrs)),
-      status: none(RelayStatus))
-    pb = encodeMsg(msg)
-
-  trace "Dial peer", msgSend=msg
-
-  try:
-    await conn.writeLp(pb.buffer)
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error writing hop request", exc=exc.msg
-    raise exc
-
-  let msgRcvFromRelayOpt = try:
-    decodeMsg(await conn.readLp(r.msgSize))
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error reading stop response", exc=exc.msg
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    raise exc
-
-  if msgRcvFromRelayOpt.isNone:
-    trace "error reading stop response", msg = msgRcvFromRelayOpt
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    raise newException(RelayError, "Hop can't open destination stream")
-
-  let msgRcvFromRelay = msgRcvFromRelayOpt.get()
-  if msgRcvFromRelay.msgType.isNone or msgRcvFromRelay.msgType.get() != RelayType.Status:
-    trace "unexcepted relay stop response", msgType = msgRcvFromRelay.msgType
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    raise newException(RelayError, "Hop can't open destination stream")
-
-  if msgRcvFromRelay.status.isNone or msgRcvFromRelay.status.get() != RelayStatus.Success:
-    trace "relay stop failure", status=msgRcvFromRelay.status
-    await sendStatus(conn, RelayStatus.HopCantOpenDstStream)
-    raise newException(RelayError, "Hop can't open destination stream")
-  result = conn
-
-#
-# Relay Transport
-#
-
-type
-  RelayTransport* = ref object of Transport
-    relay*: Relay
-    queue: AsyncQueue[Connection]
-    relayRunning: bool
-
-method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
-  if self.relayRunning:
-    trace "Relay transport already running"
-    return
-  await procCall Transport(self).start(ma)
-  self.relayRunning = true
-  self.relay.addConn = proc(conn: Connection) {.async, gcsafe, raises: [Defect].} =
-    await self.queue.addLast(conn)
-    await conn.join()
-  trace "Starting Relay transport"
-
-method stop*(self: RelayTransport) {.async, gcsafe.} =
-  self.running = false
-  self.relayRunning = false
-  self.relay.addConn = nil
-  while not self.queue.empty():
-    await self.queue.popFirstNoWait().close()
-
-method accept*(self: RelayTransport): Future[Connection] {.async, gcsafe.} =
-  result = await self.queue.popFirst()
-
-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].get())).split('/')[2]):
-    raise newException(RelayError, "Relay doesn't exist")
-  if not dstPeerId.init(($(sma[^1].get())).split('/')[2]):
-    raise newException(RelayError, "Destination doesn't exist")
-  trace "Dial", relayPeerId, relayAddrs, dstPeerId
-
-  let conn = await self.relay.switch.dial(relayPeerId, @[ relayAddrs ], RelayCodec)
-  conn.dir = Direction.Out
-  result = await self.relay.dialPeer(conn, dstPeerId, @[])
-
-method dial*(
-  self: RelayTransport,
-  hostname: string,
-  address: MultiAddress): Future[Connection] {.async, gcsafe.} =
-  result = await self.dial(address)
-
-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], relay: Relay, upgrader: Upgrade): T =
-  result = T(relay: relay, upgrader: upgrader)
-  result.running = true
-  result.queue = newAsyncQueue[Connection](0)

libp2p/protocols/rendezvous.nim

@@ -0,0 +1,677 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import tables, sequtils, sugar, sets, options
+import chronos,
+       chronicles,
+       bearssl/rand,
+       stew/[byteutils, objects]
+import ./protocol,
+       ../switch,
+       ../routing_record,
+       ../utils/heartbeat,
+       ../stream/connection,
+       ../utils/offsettedseq,
+       ../utils/semaphore
+
+export chronicles
+
+logScope:
+  topics = "libp2p discovery rendezvous"
+
+const
+  RendezVousCodec* = "/rendezvous/1.0.0"
+  MinimumDuration* = 2.hours
+  MaximumDuration = 72.hours
+  MinimumTTL = MinimumDuration.seconds.uint64
+  MaximumTTL = MaximumDuration.seconds.uint64
+  RegistrationLimitPerPeer = 1000
+  DiscoverLimit = 1000'u64
+  SemaphoreDefaultSize = 5
+
+type
+  MessageType {.pure.} = enum
+    Register = 0
+    RegisterResponse = 1
+    Unregister = 2
+    Discover = 3
+    DiscoverResponse = 4
+
+  ResponseStatus = enum
+    Ok = 0
+    InvalidNamespace = 100
+    InvalidSignedPeerRecord = 101
+    InvalidTTL = 102
+    InvalidCookie = 103
+    NotAuthorized = 200
+    InternalError = 300
+    Unavailable = 400
+
+  Cookie = object
+    offset : uint64
+    ns : string
+
+  Register = object
+    ns : string
+    signedPeerRecord: seq[byte]
+    ttl: Option[uint64] # in seconds
+
+  RegisterResponse = object
+    status: ResponseStatus
+    text: Option[string]
+    ttl: Option[uint64] # in seconds
+
+  Unregister = object
+    ns: string
+
+  Discover = object
+    ns: string
+    limit: Option[uint64]
+    cookie: Option[seq[byte]]
+
+  DiscoverResponse = object
+    registrations: seq[Register]
+    cookie: Option[seq[byte]]
+    status: ResponseStatus
+    text: Option[string]
+
+  Message = object
+    msgType: MessageType
+    register: Option[Register]
+    registerResponse: Option[RegisterResponse]
+    unregister: Option[Unregister]
+    discover: Option[Discover]
+    discoverResponse: Option[DiscoverResponse]
+
+proc encode(c: Cookie): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, c.offset)
+  result.write(2, c.ns)
+  result.finish()
+
+proc encode(r: Register): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, r.ns)
+  result.write(2, r.signedPeerRecord)
+  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)
+  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 =
+  result = initProtoBuffer()
+  result.write(1, u.ns)
+  result.finish()
+
+proc encode(d: Discover): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, d.ns)
+  if d.limit.isSome():
+    result.write(2, d.limit.get())
+  if d.cookie.isSome():
+    result.write(3, d.cookie.get())
+  result.finish()
+
+proc encode(d: DiscoverResponse): ProtoBuffer =
+  result = initProtoBuffer()
+  for reg in d.registrations:
+    result.write(1, reg.encode())
+  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)
+  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]): 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 none(Cookie)
+  some(c)
+
+proc decode(_: typedesc[Register], buf: seq[byte]): Option[Register] =
+  var
+    r: Register
+    ttl: uint64
+  let
+    pb = initProtoBuffer(buf)
+    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 none(Register)
+  if r3.get(): r.ttl = some(ttl)
+  some(r)
+
+proc decode(_: typedesc[RegisterResponse], buf: seq[byte]): Option[RegisterResponse] =
+  var
+    rr: RegisterResponse
+    statusOrd: uint
+    text: string
+    ttl: uint64
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, statusOrd)
+    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 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]): Option[Unregister] =
+  var u: Unregister
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, u.ns)
+  if r1.isErr(): return none(Unregister)
+  some(u)
+
+proc decode(_: typedesc[Discover], buf: seq[byte]): Option[Discover] =
+  var
+    d: Discover
+    limit: uint64
+    cookie: seq[byte]
+  let
+    pb = initProtoBuffer(buf)
+    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 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]): Option[DiscoverResponse] =
+  var
+    dr: DiscoverResponse
+    registrations: seq[seq[byte]]
+    cookie: seq[byte]
+    statusOrd: uint
+    text: string
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRepeatedField(1, registrations)
+    r2 = pb.getField(2, cookie)
+    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 none(DiscoverResponse)
+  for reg in registrations:
+    var r: Register
+    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]): Option[Message] =
+  var
+    msg: Message
+    statusOrd: uint
+    pbr, pbrr, pbu, pbd, pbdr: ProtoBuffer
+  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 none(Message)
+  if r3.get():
+    msg.registerResponse = RegisterResponse.decode(pbrr.buffer)
+    if msg.registerResponse.isNone(): return none(Message)
+  if r4.get():
+    msg.unregister = Unregister.decode(pbu.buffer)
+    if msg.unregister.isNone(): return none(Message)
+  if r5.get():
+    msg.discover = Discover.decode(pbd.buffer)
+    if msg.discover.isNone(): return none(Message)
+  if r6.get():
+    msg.discoverResponse = DiscoverResponse.decode(pbdr.buffer)
+    if msg.discoverResponse.isNone(): return none(Message)
+  some(msg)
+
+
+type
+  RendezVousError* = object of LPError
+  RegisteredData = object
+    expiration: Moment
+    peerId: PeerId
+    data: Register
+
+  RendezVous* = ref object of LPProtocol
+    # Registered needs to be an offsetted sequence
+    # because we need stable index for the cookies.
+    registered: OffsettedSeq[RegisteredData]
+    # Namespaces is a table whose key is a salted namespace and
+    # the value is the index sequence corresponding to this
+    # namespace in the offsettedqueue.
+    namespaces: Table[string, seq[int]]
+    rng: ref HmacDrbgContext
+    salt: string
+    defaultDT: Moment
+    registerDeletionLoop: Future[void]
+    #registerEvent: AsyncEvent # TODO: to raise during the heartbeat
+    # + make the heartbeat sleep duration "smarter"
+    sema: AsyncSemaphore
+    peers: seq[PeerId]
+    cookiesSaved: Table[PeerId, Table[string, seq[byte]]]
+    switch: Switch
+
+proc checkPeerRecord(spr: seq[byte], peerId: PeerId): Result[void, string] =
+  if spr.len == 0: return err("Empty peer record")
+  let signedEnv = ? SignedPeerRecord.decode(spr).mapErr(x => $x)
+  if signedEnv.data.peerId != peerId:
+    return err("Bad Peer ID")
+  return ok()
+
+proc sendRegisterResponse(conn: Connection,
+                          ttl: uint64) {.async.} =
+  let msg = encode(Message(
+        msgType: MessageType.RegisterResponse,
+        registerResponse: some(RegisterResponse(status: Ok, ttl: some(ttl)))))
+  await conn.writeLp(msg.buffer)
+
+proc sendRegisterResponseError(conn: Connection,
+                               status: ResponseStatus,
+                               text: string = "") {.async.} =
+  let msg = encode(Message(
+        msgType: MessageType.RegisterResponse,
+        registerResponse: some(RegisterResponse(status: status, text: some(text)))))
+  await conn.writeLp(msg.buffer)
+
+proc sendDiscoverResponse(conn: Connection,
+                          s: seq[Register],
+                          cookie: Cookie) {.async.} =
+  let msg = encode(Message(
+        msgType: MessageType.DiscoverResponse,
+        discoverResponse: some(DiscoverResponse(
+            status: Ok,
+            registrations: s,
+            cookie: some(cookie.encode().buffer)
+          ))
+        ))
+  await conn.writeLp(msg.buffer)
+
+proc sendDiscoverResponseError(conn: Connection,
+                               status: ResponseStatus,
+                               text: string = "") {.async.} =
+  let msg = encode(Message(
+        msgType: MessageType.DiscoverResponse,
+        discoverResponse: some(DiscoverResponse(status: status, text: some(text)))))
+  await conn.writeLp(msg.buffer)
+
+proc countRegister(rdv: RendezVous, peerId: PeerId): int =
+  let n = Moment.now()
+  for data in rdv.registered:
+    if data.peerId == peerId and data.expiration > n:
+      result.inc()
+
+proc save(rdv: RendezVous,
+          ns: string,
+          peerId: PeerId,
+          r: Register,
+          update: bool = true) =
+  let nsSalted = ns & rdv.salt
+  discard rdv.namespaces.hasKeyOrPut(nsSalted, newSeq[int]())
+  try:
+    for index in rdv.namespaces[nsSalted]:
+      if rdv.registered[index].peerId == peerId:
+        if update == false: return
+        rdv.registered[index].expiration = rdv.defaultDT
+    rdv.registered.add(
+      RegisteredData(
+        peerId: peerId,
+        expiration: Moment.now() + r.ttl.get(MinimumTTL).int64.seconds,
+        data: r
+      )
+    )
+    rdv.namespaces[nsSalted].add(rdv.registered.high)
+#    rdv.registerEvent.fire()
+  except KeyError:
+    doAssert false, "Should have key"
+
+proc register(rdv: RendezVous, conn: Connection, r: Register): Future[void] =
+  trace "Received Register", peerId = conn.peerId, ns = r.ns
+  if r.ns.len notin 1..255:
+    return conn.sendRegisterResponseError(InvalidNamespace)
+  let ttl = r.ttl.get(MinimumTTL)
+  if ttl notin MinimumTTL..MaximumTTL:
+    return conn.sendRegisterResponseError(InvalidTTL)
+  let pr = checkPeerRecord(r.signedPeerRecord, conn.peerId)
+  if pr.isErr():
+    return conn.sendRegisterResponseError(InvalidSignedPeerRecord, pr.error())
+  if rdv.countRegister(conn.peerId) >= RegistrationLimitPerPeer:
+    return conn.sendRegisterResponseError(NotAuthorized, "Registration limit reached")
+  rdv.save(r.ns, conn.peerId, r)
+  conn.sendRegisterResponse(ttl)
+
+proc unregister(rdv: RendezVous, conn: Connection, u: Unregister) =
+  trace "Received Unregister", peerId = conn.peerId, ns = u.ns
+  let nsSalted = u.ns & rdv.salt
+  try:
+    for index in rdv.namespaces[nsSalted]:
+      if rdv.registered[index].peerId == conn.peerId:
+        rdv.registered[index].expiration = rdv.defaultDT
+  except KeyError:
+    return
+
+proc discover(rdv: RendezVous, conn: Connection, d: Discover) {.async.} =
+  trace "Received Discover", peerId = conn.peerId, ns = d.ns
+  if d.ns.len notin 0..255:
+    await conn.sendDiscoverResponseError(InvalidNamespace)
+    return
+  var limit = min(DiscoverLimit, d.limit.get(DiscoverLimit))
+  var
+    cookie =
+      if d.cookie.isSome():
+        try:
+          Cookie.decode(d.cookie.get()).get()
+        except CatchableError:
+          await conn.sendDiscoverResponseError(InvalidCookie)
+          return
+      else: Cookie(offset: rdv.registered.low().uint64 - 1)
+  if cookie.ns != d.ns or
+      cookie.offset notin rdv.registered.low().uint64..rdv.registered.high().uint64:
+    cookie = Cookie(offset: rdv.registered.low().uint64 - 1)
+  let
+    nsSalted = d.ns & rdv.salt
+    namespaces =
+      if d.ns != "":
+        try:
+          rdv.namespaces[nsSalted]
+        except KeyError:
+          await conn.sendDiscoverResponseError(InvalidNamespace)
+          return
+      else: toSeq(cookie.offset.int..rdv.registered.high())
+  if namespaces.len() == 0:
+    await conn.sendDiscoverResponse(@[], Cookie())
+    return
+  var offset = namespaces[^1]
+  let n = Moment.now()
+  var s = collect(newSeq()):
+      for index in namespaces:
+        var reg = rdv.registered[index]
+        if limit == 0:
+          offset = index
+          break
+        if reg.expiration < n or index.uint64 <= cookie.offset: continue
+        limit.dec()
+        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))
+
+proc advertisePeer(rdv: RendezVous,
+                   peer: PeerId,
+                   msg: seq[byte]) {.async.} =
+  proc advertiseWrap() {.async.} =
+    try:
+      let conn = await rdv.switch.dial(peer, RendezVousCodec)
+      defer: await conn.close()
+      await conn.writeLp(msg)
+      let
+        buf = await conn.readLp(4096)
+        msgRecv = Message.decode(buf).get()
+      if msgRecv.msgType != MessageType.RegisterResponse:
+        trace "Unexpected register response", peer, msgType = msgRecv.msgType
+      elif msgRecv.registerResponse.isNone() or
+           msgRecv.registerResponse.get().status != ResponseStatus.Ok:
+        trace "Refuse to register", peer, response = msgRecv.registerResponse
+    except CatchableError as exc:
+      trace "exception in the advertise", error = exc.msg
+    finally:
+      rdv.sema.release()
+  await rdv.sema.acquire()
+  discard await advertiseWrap().withTimeout(5.seconds)
+
+proc advertise*(rdv: RendezVous,
+                ns: string,
+                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.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:
+      trace "Send Advertise", peerId = peer, ns
+      rdv.advertisePeer(peer, msg.buffer)
+  await allFutures(fut)
+
+proc requestLocally*(rdv: RendezVous, ns: string): seq[PeerRecord] =
+  let
+    nsSalted = ns & rdv.salt
+    n = Moment.now()
+  try:
+    collect(newSeq()):
+      for index in rdv.namespaces[nsSalted]:
+        if rdv.registered[index].expiration > n:
+          SignedPeerRecord.decode(rdv.registered[index].data.signedPeerRecord).get().data
+  except KeyError as exc:
+    @[]
+
+proc request*(rdv: RendezVous,
+              ns: string,
+              l: int = DiscoverLimit.int): Future[seq[PeerRecord]] {.async.} =
+  let nsSalted = ns & rdv.salt
+  var
+    s: Table[PeerId, (PeerRecord, Register)]
+    limit: uint64
+    d = Discover(ns: ns)
+
+  if l <= 0 or l > DiscoverLimit.int:
+    raise newException(RendezVousError, "Invalid limit")
+  if ns.len notin 0..255:
+    raise newException(RendezVousError, "Invalid namespace")
+  limit = l.uint64
+  proc requestPeer(peer: PeerId) {.async.} =
+    let conn = await rdv.switch.dial(peer, RendezVousCodec)
+    defer: await conn.close()
+    d.limit = some(limit)
+    d.cookie =
+      try:
+        some(rdv.cookiesSaved[peer][ns])
+      except KeyError as exc:
+        none(seq[byte])
+    await conn.writeLp(encode(Message(
+      msgType: MessageType.Discover,
+      discover: some(d))).buffer)
+    let
+      buf = await conn.readLp(65536)
+      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.get()
+    if resp.status != ResponseStatus.Ok:
+      trace "Cannot discover", ns, status = resp.status, text = resp.text
+      return
+    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
+      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() < r.ttl.get()) or
+          prSaved.seqNo < pr.seqNo:
+          s[pr.peerId] = (pr, r)
+      else:
+        s[pr.peerId] = (pr, r)
+      limit.dec()
+    for (_, r) in s.values():
+      rdv.save(ns, peer, r, false)
+
+  # copy to avoid resizes during the loop
+  let peers = rdv.peers
+  for peer in peers:
+    if limit == 0: break
+    if RendezVousCodec notin rdv.switch.peerStore[ProtoBook][peer]: continue
+    try:
+      trace "Send Request", peerId = peer, ns
+      await peer.requestPeer()
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "exception catch in request", error = exc.msg
+  return toSeq(s.values()).mapIt(it[0])
+
+proc unsubscribeLocally*(rdv: RendezVous, ns: string) =
+  let nsSalted = ns & rdv.salt
+  try:
+    for index in rdv.namespaces[nsSalted]:
+      if rdv.registered[index].peerId == rdv.switch.peerInfo.peerId:
+        rdv.registered[index].expiration = rdv.defaultDT
+  except KeyError:
+    return
+
+proc unsubscribe*(rdv: RendezVous, ns: string) {.async.} =
+  # TODO: find a way to improve this, maybe something similar to the advertise
+  if ns.len notin 1..255:
+    raise newException(RendezVousError, "Invalid namespace")
+  rdv.unsubscribeLocally(ns)
+  let msg = encode(Message(
+    msgType: MessageType.Unregister,
+    unregister: some(Unregister(ns: ns))))
+
+  proc unsubscribePeer(rdv: RendezVous, peerId: PeerId) {.async.} =
+    try:
+      let conn = await rdv.switch.dial(peerId, RendezVousCodec)
+      defer: await conn.close()
+      await conn.writeLp(msg.buffer)
+    except CatchableError as exc:
+      trace "exception while unsubscribing", error = exc.msg
+
+  for peer in rdv.peers:
+    discard await rdv.unsubscribePeer(peer).withTimeout(5.seconds)
+
+proc setup*(rdv: RendezVous, switch: Switch) =
+  rdv.switch = switch
+  proc handlePeer(peerId: PeerId, event: PeerEvent) {.async.} =
+    if event.kind == PeerEventKind.Joined:
+      rdv.peers.add(peerId)
+    elif event.kind == PeerEventKind.Left:
+      rdv.peers.keepItIf(it != peerId)
+  rdv.switch.addPeerEventHandler(handlePeer, Joined)
+  rdv.switch.addPeerEventHandler(handlePeer, Left)
+
+proc new*(T: typedesc[RendezVous],
+          rng: ref HmacDrbgContext = newRng()): T =
+  let rdv = T(
+    rng: rng,
+    salt: string.fromBytes(generateBytes(rng[], 8)),
+    registered: initOffsettedSeq[RegisteredData](1),
+    defaultDT: Moment.now() - 1.days,
+    #registerEvent: newAsyncEvent(),
+    sema: newAsyncSemaphore(SemaphoreDefaultSize)
+  )
+  logScope: topics = "libp2p discovery rendezvous"
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
+    try:
+      let
+        buf = await conn.readLp(4096)
+        msg = Message.decode(buf).get()
+      case msg.msgType:
+        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.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:
+      raise exc
+    except CatchableError as exc:
+      trace "exception in rendezvous handler", error = exc.msg
+    finally:
+      await conn.close()
+
+  rdv.handler = handleStream
+  rdv.codec = RendezVousCodec
+  return rdv
+
+proc new*(T: typedesc[RendezVous],
+         switch: Switch,
+         rng: ref HmacDrbgContext = newRng()): T =
+  let rdv = T.new(rng)
+  rdv.setup(switch)
+  return rdv
+
+proc deletesRegister(rdv: RendezVous) {.async.} =
+  heartbeat "Register timeout", 1.minutes:
+    let n = Moment.now()
+    rdv.registered.flushIfIt(it.expiration < n)
+    for data in rdv.namespaces.mvalues():
+      data.keepItIf(it >= rdv.registered.offset)
+
+method start*(rdv: RendezVous) {.async.} =
+  if not rdv.registerDeletionLoop.isNil:
+    warn "Starting rendezvous twice"
+    return
+  rdv.registerDeletionLoop = rdv.deletesRegister()
+  rdv.started = true
+
+method stop*(rdv: RendezVous) {.async.} =
+  if rdv.registerDeletionLoop.isNil:
+    warn "Stopping rendezvous without starting it"
+    return
+  rdv.started = false
+  rdv.registerDeletionLoop.cancel()
+  rdv.registerDeletionLoop = nil

libp2p/protocols/secure/noise.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[oids, strformat]
 import chronos
@@ -35,7 +38,7 @@ const
   # https://godoc.org/github.com/libp2p/go-libp2p-noise#pkg-constants
   NoiseCodec* = "/noise"
 
-  PayloadString = "noise-libp2p-static-key:"
+  PayloadString = toBytes("noise-libp2p-static-key:")
 
   ProtocolXXName = "Noise_XX_25519_ChaChaPoly_SHA256"
 
@@ -336,7 +339,6 @@ proc handshakeXXOutbound(
     hs = HandshakeState.init()
 
   try:
-
     hs.ss.mixHash(p.commonPrologue)
     hs.s = p.noiseKeys
 
@@ -442,7 +444,6 @@ method readMessage*(sconn: NoiseConnection): Future[seq[byte]] {.async.} =
       dumpMessage(sconn, FlowDirection.Incoming, [])
     trace "Received 0-length message", sconn
 
-
 proc encryptFrame(
     sconn: NoiseConnection,
     cipherFrame: var openArray[byte],
@@ -503,7 +504,7 @@ method write*(sconn: NoiseConnection, message: seq[byte]): Future[void] =
   # sequencing issues
   sconn.stream.write(cipherFrames)
 
-method handshake*(p: Noise, conn: Connection, initiator: bool): Future[SecureConn] {.async.} =
+method handshake*(p: Noise, conn: Connection, initiator: bool, peerId: Opt[PeerId]): Future[SecureConn] {.async.} =
   trace "Starting Noise handshake", conn, initiator
 
   let timeout = conn.timeout
@@ -512,7 +513,7 @@ method handshake*(p: Noise, conn: Connection, initiator: bool): Future[SecureCon
   # https://github.com/libp2p/specs/tree/master/noise#libp2p-data-in-handshake-messages
   let
     signedPayload = p.localPrivateKey.sign(
-      PayloadString.toBytes & p.noiseKeys.publicKey.getBytes).tryGet()
+      PayloadString & p.noiseKeys.publicKey.getBytes).tryGet()
 
   var
     libp2pProof = initProtoBuffer()
@@ -535,11 +536,9 @@ method handshake*(p: Noise, conn: Connection, initiator: bool): Future[SecureCon
       remoteSig: Signature
       remoteSigBytes: seq[byte]
 
-    let r1 = remoteProof.getField(1, remotePubKeyBytes)
-    let r2 = remoteProof.getField(2, remoteSigBytes)
-    if r1.isErr() or not(r1.get()):
+    if not remoteProof.getField(1, remotePubKeyBytes).valueOr(false):
       raise newException(NoiseHandshakeError, "Failed to deserialize remote public key bytes. (initiator: " & $initiator & ")")
-    if r2.isErr() or not(r2.get()):
+    if not remoteProof.getField(2, remoteSigBytes).valueOr(false):
       raise newException(NoiseHandshakeError, "Failed to deserialize remote signature bytes. (initiator: " & $initiator & ")")
 
     if not remotePubKey.init(remotePubKeyBytes):
@@ -547,33 +546,34 @@ method handshake*(p: Noise, conn: Connection, initiator: bool): Future[SecureCon
     if not remoteSig.init(remoteSigBytes):
       raise newException(NoiseHandshakeError, "Failed to decode remote signature. (initiator: " & $initiator & ")")
 
-    let verifyPayload = PayloadString.toBytes & handshakeRes.rs.getBytes
+    let verifyPayload = PayloadString & handshakeRes.rs.getBytes
     if not remoteSig.verify(verifyPayload, remotePubKey):
       raise newException(NoiseHandshakeError, "Noise handshake signature verify failed.")
     else:
       trace "Remote signature verified", conn
 
-    if initiator:
-      let pid = PeerId.init(remotePubKey)
-      if not conn.peerId.validate():
-        raise newException(NoiseHandshakeError, "Failed to validate peerId.")
-      if pid.isErr or pid.get() != conn.peerId:
+    let pid = PeerId.init(remotePubKey).valueOr:
+      raise newException(NoiseHandshakeError, "Invalid remote peer id: " & $error)
+
+    trace "Remote peer id", pid = $pid
+
+    if peerId.isSome():
+      let targetPid = peerId.get()
+      if not targetPid.validate():
+        raise newException(NoiseHandshakeError, "Failed to validate expected peerId.")
+
+      if pid != targetPid:
         var
           failedKey: PublicKey
-        discard extractPublicKey(conn.peerId, failedKey)
-        debug "Noise handshake, peer infos don't match!",
+        discard extractPublicKey(targetPid, failedKey)
+        debug "Noise handshake, peer id doesn't match!",
           initiator, dealt_peer = conn,
           dealt_key = $failedKey, received_peer = $pid,
           received_key = $remotePubKey
-        raise newException(NoiseHandshakeError, "Noise handshake, peer infos don't match! " & $pid & " != " & $conn.peerId)
-    else:
-      let pid = PeerId.init(remotePubKey)
-      if pid.isErr:
-        raise newException(NoiseHandshakeError, "Invalid remote peer id")
-      conn.peerId = pid.get()
+        raise newException(NoiseHandshakeError, "Noise handshake, peer id don't match! " & $pid & " != " & $targetPid)
+    conn.peerId = pid
 
     var tmp = NoiseConnection.new(conn, conn.peerId, conn.observedAddr)
-
     if initiator:
       tmp.readCs = handshakeRes.cs2
       tmp.writeCs = handshakeRes.cs1

libp2p/protocols/secure/plaintext.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import chronos
 import secure, ../../stream/connection

libp2p/protocols/secure/secio.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[oids, strformat]
 import bearssl/rand
@@ -288,7 +291,7 @@ proc transactMessage(conn: Connection,
   await conn.write(msg)
   return await conn.readRawMessage()
 
-method handshake*(s: Secio, conn: Connection, initiator: bool = false): Future[SecureConn] {.async.} =
+method handshake*(s: Secio, conn: Connection, initiator: bool, peerId: Opt[PeerId]): Future[SecureConn] {.async.} =
   var
     localNonce: array[SecioNonceSize, byte]
     remoteNonce: seq[byte]
@@ -339,9 +342,14 @@ method handshake*(s: Secio, conn: Connection, initiator: bool = false): Future[S
 
   remotePeerId = PeerId.init(remotePubkey).tryGet()
 
-  # TODO: PeerId check against supplied PeerId
-  if not initiator:
-    conn.peerId = remotePeerId
+  if peerId.isSome():
+    let targetPid = peerId.get()
+    if not targetPid.validate():
+      raise newException(SecioError, "Failed to validate expected peerId.")
+
+    if remotePeerId != targetPid:
+      raise newException(SecioError, "Peer ids don't match!")
+  conn.peerId = remotePeerId
   let order = getOrder(remoteBytesPubkey, localNonce, localBytesPubkey,
                        remoteNonce).tryGet()
   trace "Remote proposal", schemes = remoteExchanges, ciphers = remoteCiphers,

libp2p/protocols/secure/secure.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,9 +7,14 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+{.push gcsafe.}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[strformat]
+import stew/results
 import chronos, chronicles
 import ../protocol,
        ../../stream/streamseq,
@@ -18,7 +23,7 @@ import ../protocol,
        ../../peerinfo,
        ../../errors
 
-export protocol
+export protocol, results
 
 logScope:
   topics = "libp2p secure"
@@ -45,7 +50,7 @@ chronicles.formatIt(SecureConn): shortLog(it)
 proc new*(T: type SecureConn,
            conn: Connection,
            peerId: PeerId,
-           observedAddr: MultiAddress,
+           observedAddr: Opt[MultiAddress],
            timeout: Duration = DefaultConnectionTimeout): T =
   result = T(stream: conn,
              peerId: peerId,
@@ -72,15 +77,19 @@ method closeImpl*(s: SecureConn) {.async.} =
 method readMessage*(c: SecureConn): Future[seq[byte]] {.async, base.} =
   doAssert(false, "Not implemented!")
 
+method getWrapped*(s: SecureConn): Connection = s.stream
+
 method handshake*(s: Secure,
                   conn: Connection,
-                  initiator: bool): Future[SecureConn] {.async, base.} =
+                  initiator: bool,
+                  peerId: Opt[PeerId]): Future[SecureConn] {.async, base.} =
   doAssert(false, "Not implemented!")
 
 proc handleConn(s: Secure,
                  conn: Connection,
-                 initiator: bool): Future[Connection] {.async.} =
-  var sconn = await s.handshake(conn, initiator)
+                 initiator: bool,
+                 peerId: Opt[PeerId]): Future[Connection] {.async.} =
+  var sconn = await s.handshake(conn, initiator, peerId)
   # mark connection bottom level transport direction
   # this is the safest place to do this
   # we require this information in for example gossipsub
@@ -116,7 +125,7 @@ method init*(s: Secure) =
     try:
       # We don't need the result but we
       # definitely need to await the handshake
-      discard await s.handleConn(conn, false)
+      discard await s.handleConn(conn, false, Opt.none(PeerId))
       trace "connection secured", conn
     except CancelledError as exc:
       warn "securing connection canceled", conn
@@ -130,9 +139,10 @@ method init*(s: Secure) =
 
 method secure*(s: Secure,
                conn: Connection,
-               initiator: bool):
+               initiator: bool,
+               peerId: Opt[PeerId]):
                Future[Connection] {.base.} =
-  s.handleConn(conn, initiator)
+  s.handleConn(conn, initiator, peerId)
 
 method readOnce*(s: SecureConn,
                  pbytes: pointer,

libp2p/routing_record.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implements Routing Records.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[sequtils, times]
 import pkg/stew/results

libp2p/services/autorelayservice.nim

@@ -0,0 +1,133 @@
+# 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.
+
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
+
+import chronos, chronicles, times, tables, sequtils, options
+import ../switch,
+       ../protocols/connectivity/relay/[client, utils]
+
+logScope:
+  topics = "libp2p autorelay"
+
+type
+  OnReservationHandler = proc (addresses: seq[MultiAddress]) {.gcsafe, raises: [Defect].}
+
+  AutoRelayService* = ref object of Service
+    running: bool
+    runner: Future[void]
+    client: RelayClient
+    numRelays: int
+    relayPeers: Table[PeerId, Future[void]]
+    relayAddresses: Table[PeerId, seq[MultiAddress]]
+    backingOff: seq[PeerId]
+    peerAvailable: AsyncEvent
+    onReservation: OnReservationHandler
+    rng: ref HmacDrbgContext
+
+proc reserveAndUpdate(self: AutoRelayService, relayPid: PeerId, selfPid: PeerId) {.async.} =
+  while self.running:
+    let
+      rsvp = await self.client.reserve(relayPid).wait(chronos.seconds(5))
+      relayedAddr = rsvp.addrs.mapIt(
+        MultiAddress.init($it & "/p2p-circuit").tryGet())
+      ttl = rsvp.expire.int64 - times.now().utc.toTime.toUnix
+    if ttl <= 60:
+      # A reservation under a minute is basically useless
+      break
+    if relayPid notin self.relayAddresses or self.relayAddresses[relayPid] != relayedAddr:
+      self.relayAddresses[relayPid] = relayedAddr
+      if not self.onReservation.isNil():
+        self.onReservation(concat(toSeq(self.relayAddresses.values)))
+    await sleepAsync chronos.seconds(ttl - 30)
+
+method setup*(self: AutoRelayService, switch: Switch): Future[bool] {.async, gcsafe.} =
+  let hasBeenSetUp = await procCall Service(self).setup(switch)
+  if hasBeenSetUp:
+    proc handlePeerJoined(peerId: PeerId, event: PeerEvent) {.async.} =
+      trace "Peer Joined", peerId
+      if self.relayPeers.len < self.numRelays:
+        self.peerAvailable.fire()
+    proc handlePeerLeft(peerId: PeerId, event: PeerEvent) {.async.} =
+      trace "Peer Left", peerId
+      self.relayPeers.withValue(peerId, future):
+        future[].cancel()
+    switch.addPeerEventHandler(handlePeerJoined, Joined)
+    switch.addPeerEventHandler(handlePeerLeft, Left)
+    await self.run(switch)
+  return hasBeenSetUp
+
+proc manageBackedOff(self: AutoRelayService, pid: PeerId) {.async.} =
+  await sleepAsync(chronos.seconds(5))
+  self.backingOff.keepItIf(it != pid)
+  self.peerAvailable.fire()
+
+proc innerRun(self: AutoRelayService, switch: Switch) {.async, gcsafe.} =
+  while true:
+    # Remove relayPeers that failed
+    let peers = toSeq(self.relayPeers.keys())
+    for k in peers:
+      if self.relayPeers[k].finished():
+        self.relayPeers.del(k)
+        self.relayAddresses.del(k)
+        if not self.onReservation.isNil():
+          self.onReservation(concat(toSeq(self.relayAddresses.values)))
+        # To avoid ddosing our peers in certain conditions
+        self.backingOff.add(k)
+        asyncSpawn self.manageBackedOff(k)
+
+    # Get all connected relayPeers
+    self.peerAvailable.clear()
+    var connectedPeers = switch.connectedPeers(Direction.Out)
+    connectedPeers.keepItIf(RelayV2HopCodec in switch.peerStore[ProtoBook][it] and
+                            it notin self.relayPeers and
+                            it notin self.backingOff)
+    self.rng.shuffle(connectedPeers)
+
+    for relayPid in connectedPeers:
+      if self.relayPeers.len() >= self.numRelays:
+        break
+      self.relayPeers[relayPid] = self.reserveAndUpdate(relayPid, switch.peerInfo.peerId)
+
+    if self.relayPeers.len() > 0:
+      await one(toSeq(self.relayPeers.values())) or self.peerAvailable.wait()
+    else:
+      await self.peerAvailable.wait()
+      await sleepAsync(200.millis)
+
+method run*(self: AutoRelayService, switch: Switch) {.async, gcsafe.} =
+  if self.running:
+    trace "Autorelay is already running"
+    return
+  self.running = true
+  self.runner = self.innerRun(switch)
+
+method stop*(self: AutoRelayService, switch: Switch): Future[bool] {.async, gcsafe.} =
+  let hasBeenStopped = await procCall Service(self).stop(switch)
+  if hasBeenStopped:
+    self.running = false
+    self.runner.cancel()
+  return hasBeenStopped
+
+proc getAddresses*(self: AutoRelayService): seq[MultiAddress] =
+  result = concat(toSeq(self.relayAddresses.values))
+
+proc new*(T: typedesc[AutoRelayService],
+          numRelays: int,
+          client: RelayClient,
+          onReservation: OnReservationHandler,
+          rng: ref HmacDrbgContext): T =
+  T(numRelays: numRelays,
+    client: client,
+    onReservation: onReservation,
+    peerAvailable: newAsyncEvent(),
+    rng: rng)

libp2p/signed_envelope.nim

@@ -1,5 +1,5 @@
 # Nim-Libp2p
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -9,7 +9,10 @@
 
 ## This module implements Signed Envelope.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/sugar
 import pkg/stew/[results, byteutils]
@@ -119,6 +122,14 @@ proc getField*(pb: ProtoBuffer, field: int,
     else:
       err(ProtoError.IncorrectBlob)
 
+proc write*(pb: var ProtoBuffer, field: int, env: Envelope): Result[void, CryptoError] =
+  let e = env.encode()
+
+  if e.isErr():
+    return err(e.error)
+  pb.write(field, e.get())
+  ok()
+
 type
   SignedPayload*[T] = object
     # T needs to have .encode(), .decode(), .payloadType(), .domain()

libp2p/stream/bufferstream.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,7 +7,10 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/strformat
 import stew/byteutils
@@ -76,7 +79,7 @@ method pushData*(s: BufferStream, data: seq[byte]) {.base, async.} =
     &"Only one concurrent push allowed for stream {s.shortLog()}")
 
   if s.isClosed or s.pushedEof:
-    raise newLPStreamEOFError()
+    raise newLPStreamClosedError()
 
   if data.len == 0:
     return # Don't push 0-length buffers, these signal EOF
@@ -108,7 +111,7 @@ method pushEof*(s: BufferStream) {.base, async.} =
   finally:
     s.pushing = false
 
-method atEof*(s: BufferStream): bool {.raises: [Defect].} =
+method atEof*(s: BufferStream): bool =
   s.isEof and s.readBuf.len == 0
 
 method readOnce*(s: BufferStream,

libp2p/stream/chronosstream.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2022 Status Research & Development GmbH
+# 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))
@@ -7,13 +7,19 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-{.push raises: [Defect].}
+when (NimMajor, NimMinor) < (1, 4):
+  {.push raises: [Defect].}
+else:
+  {.push raises: [].}
 
 import std/[oids, strformat]
+import stew/results
 import chronos, chronicles, metrics
 import connection
 import ../utility
 
+export results
+
 logScope:
   topics = "libp2p chronosstream"
 
@@ -57,7 +63,7 @@ proc init*(C: type ChronosStream,
            client: StreamTransport,
            dir: Direction,
            timeout = DefaultChronosStreamTimeout,
-           observedAddr: MultiAddress = MultiAddress()): ChronosStream =
+           observedAddr: Opt[MultiAddress]): ChronosStream =
   result = C(client: client,
              timeout: timeout,
              dir: dir,
@@ -124,6 +130,9 @@ proc completeWrite(
 method write*(s: ChronosStream, msg: seq[byte]): Future[void] =
   # Avoid a copy of msg being kept in the closure created by `{.async.}` as this
   # drives up memory usage
+  if msg.len == 0:
+    trace "Empty byte seq, nothing to write"
+    return
   if s.closed:
     let fut = newFuture[void]("chronosstream.write.closed")
     fut.fail(newLPStreamClosedError())
@@ -156,3 +165,5 @@ method closeImpl*(s: ChronosStream) {.async.} =
     s.untrackPeerIdentity()
 
   await procCall Connection(s).closeImpl()
+
+method getWrapped*(s: ChronosStream): Connection = nil