Remove ConnManager from Upgrade (#959)

Co-authored-by: Ludovic Chenut <ludovic@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

@@ -10,11 +10,12 @@ jobs:
   bumpProjects:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         target: [
           { repo: status-im/nimbus-eth2, branch: unstable },
-          { repo: status-im/nwaku, branch: master },
-          { repo: status-im/nim-codex, branch: main }
+          { repo: waku-org/nwaku, branch: master },
+          { repo: codex-storage/nim-codex, branch: master }
         ]
     steps:
       - name: Clone repo
@@ -23,13 +24,14 @@ jobs:
           repository: ${{ matrix.target.repo }}
           ref: ${{ matrix.target.branch }}
           path: nbc
-          submodules: true
           fetch-depth: 0
           token:  ${{ secrets.ACTIONS_GITHUB_TOKEN }}
 
       - name: Checkout this ref
         run: |
-          cd nbc/vendor/nim-libp2p
+          cd nbc
+          git submodule update --init vendor/nim-libp2p
+          cd vendor/nim-libp2p
           git checkout $GITHUB_SHA
 
       - name: Commit this bump
@@ -37,7 +39,7 @@ jobs:
           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 commit --allow-empty -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, version-1-6]
+        branch: [version-1-6]
         include:
           - target:
               os: linux
@@ -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,9 +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: |
           nim --version
           nimble --version
-          nimble install_pinned
           nimble test

.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

@@ -25,7 +25,7 @@ jobs:
         run: |
           nim --version
           nimble --version
-          nimble install_pinned
+          nimble install_pinned -y
           # nim doc can "fail", but the doc is still generated
           nim doc --git.url:https://github.com/status-im/nim-libp2p --git.commit:${GITHUB_REF##*/} --outdir:${GITHUB_REF##*/} --project libp2p || true
 
@@ -63,7 +63,7 @@ jobs:
           git push origin gh-pages
 
   update_site:
-    if: github.ref == 'refs/heads/master'
+    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/docs'
     name: 'Rebuild website'
     runs-on: ubuntu-latest
     steps:
@@ -74,8 +74,12 @@ jobs:
         with:
           python-version: 3.x
 
+      - uses: jiro4989/setup-nim-action@v1
+        with:
+          nim-version: 'stable'
+
       - name: Generate website
-        run: pip install mkdocs-material && mkdocs build
+        run: pip install mkdocs-material && nimble website
 
       - name: Clone the gh-pages branch
         uses: actions/checkout@v2

.github/workflows/interop.yml

@@ -0,0 +1,54 @@
+name: Interoperability Testing
+on:
+  pull_request:
+  push:
+    branches:
+      - unstable
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  run-multidim-interop:
+    name: Run multidimensional interoperability tests
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          repository: libp2p/test-plans
+          submodules: true
+          fetch-depth: 0
+
+      - name: Build image
+        run: >
+          cd transport-interop/impl/nim/v1.0 &&
+          make commitSha=$GITHUB_SHA image_name=nim-libp2p-head
+
+      - name: Create ping-version.json
+        run: >
+          (cat << EOF
+            {
+                "id": "nim-libp2p-head",
+                "containerImageID": "nim-libp2p-head",
+                "transports": [
+                    "tcp",
+                    "ws"
+                ],
+                "secureChannels": [
+                    "noise"
+                ],
+                "muxers": [
+                    "mplex",
+                    "yamux"
+                ]
+            }
+          EOF
+
+          ) > ${{ github.workspace }}/test_head.json
+
+      - uses: libp2p/test-plans/.github/actions/run-transport-interop-test@master
+        with:
+          test-filter: nim-libp2p-head
+          extra-versions: ${{ github.workspace }}/test_head.json

.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-6, version-2-0, devel]
         include:
           - target:
               os: linux
@@ -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' || matrix.branch == 'version-2-0' }}
     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
@@ -163,9 +75,8 @@ jobs:
           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,16 +1,17 @@
-bearssl;https://github.com/status-im/nim-bearssl@#25009951ff8e0006171d566e3c7dc73a8231c2ed
+bearssl;https://github.com/status-im/nim-bearssl@#e4157639db180e52727712a47deaefcbbac6ec86
 chronicles;https://github.com/status-im/nim-chronicles@#32ac8679680ea699f7dbc046e8e0131cac97d41a
-chronos;https://github.com/status-im/nim-chronos@#41b82cdea34744148600b67a9154331b76181189
-dnsclient;https://github.com/ba0f3/dnsclient.nim@#4960de2b345f567b12f09a08e9967af104ab39a3
-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@#e5b18fb710c3d0167ec79f3b892f5a7a1bc6d1a4
-metrics;https://github.com/status-im/nim-metrics@#9070af9c830e93e5239ddc488cd65aa6f609ba73
-nimcrypto;https://github.com/cheatfate/nimcrypto@#24e006df85927f64916e60511620583b11403178
-secp256k1;https://github.com/status-im/nim-secp256k1@#5340cf188168d6afcafc8023770d880f067c0b2f
-serialization;https://github.com/status-im/nim-serialization@#493d18b8292fc03aa4f835fd825dea1183f97466
-stew;https://github.com/status-im/nim-stew@#598246620da5c41d0e92a8dd6aab0755381b21cd
+chronos;https://github.com/status-im/nim-chronos@#ba143e029f35fd9b4cd3d89d007cc834d0d5ba3c
+dnsclient;https://github.com/ba0f3/dnsclient.nim@#23214235d4784d24aceed99bbfe153379ea557c8
+faststreams;https://github.com/status-im/nim-faststreams@#720fc5e5c8e428d9d0af618e1e27c44b42350309
+httputils;https://github.com/status-im/nim-http-utils@#3b491a40c60aad9e8d3407443f46f62511e63b18
+json_serialization;https://github.com/status-im/nim-json-serialization@#85b7ea093cb85ee4f433a617b97571bd709d30df
+metrics;https://github.com/status-im/nim-metrics@#6142e433fc8ea9b73379770a788017ac528d46ff
+nimcrypto;https://github.com/cheatfate/nimcrypto@#1c8d6e3caf3abc572136ae9a1da81730c4eb4288
+results;https://github.com/arnetheduck/nim-results@#f3c666a272c69d70cb41e7245e7f6844797303ad
+secp256k1;https://github.com/status-im/nim-secp256k1@#7246d91c667f4cc3759fdd50339caa45a2ecd8be
+serialization;https://github.com/status-im/nim-serialization@#4bdbc29e54fe54049950e352bb969aab97173b35
+stew;https://github.com/status-im/nim-stew@#3159137d9a3110edb4024145ce0ba778975de40e
 testutils;https://github.com/status-im/nim-testutils@#dfc4c1b39f9ded9baf6365014de2b4bfb4dafc34
-unittest2;https://github.com/status-im/nim-unittest2@#f180f596c88dfd266f746ed6f8dbebce39c824db
-websock;https://github.com/status-im/nim-websock@#8a72c0f7690802753b1d59887745b1ce1f0c8b3d
-zlib;https://github.com/status-im/nim-zlib@#6a6670afba6b97b29b920340e2641978c05ab4d8
+unittest2;https://github.com/status-im/nim-unittest2@#2300fa9924a76e6c96bc4ea79d043e3a0f27120c
+websock;https://github.com/status-im/nim-websock@#f8ed9b40a5ff27ad02a3c237c4905b0924e3f982
+zlib;https://github.com/status-im/nim-zlib@#38b72eda9d70067df4a953f56b5ed59630f2a17b

README.md

@@ -2,7 +2,7 @@
   <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>
@@ -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,7 +45,7 @@ nimble install libp2p
 ```
 
 ## Getting Started
-You'll find the documentation [here](https://status-im.github.io/nim-libp2p/docs/).
+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).
@@ -63,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)          |                                                                                                                  |
@@ -98,20 +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.6 & 2.0`
+
+## 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
 ```
+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
 
@@ -122,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,16 +1,16 @@
 # to allow locking
 if dirExists("nimbledeps/pkgs"):
   switch("NimblePath", "nimbledeps/pkgs")
+if dirExists("nimbledeps/pkgs2"):
+  switch("NimblePath", "nimbledeps/pkgs2")
 
 switch("warning", "CaseTransition:off")
 switch("warning", "ObservableStores:off")
 switch("warning", "LockLevel:off")
 --define:chronosStrictException
 --styleCheck:usages
-if (NimMajor, NimMinor) < (1, 6):
-  --styleCheck:hint
-else:
-  --styleCheck:error
+switch("warningAsError", "UseBase:on")
+--styleCheck:error
 
 # Avoid some rare stack corruption while using exceptions with a SEH-enabled
 # toolchain: https://github.com/status-im/nimbus-eth2/issues/3121

examples/README.md

@@ -1,6 +1,5 @@
-# nim-libp2p documentation
+# nim-libp2p examples
 
-Welcome to the nim-libp2p documentation!
+In this folder, you'll find the sources of the [nim-libp2p website](https://status-im.github.io/nim-libp2p/docs/)
 
-Here, you'll find [tutorials](tutorial_1_connect.md) to help you get started, as well as [examples](directchat.nim) and
-the [full reference](https://status-im.github.io/nim-libp2p/master/libp2p.html).
+We recommand to follow the tutorials on the website, but feel free to grok the sources here!

examples/circuitrelay.nim

@@ -1,6 +1,14 @@
+## # 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]
+import libp2p,
+       libp2p/protocols/connectivity/relay/[relay, client]
 
 # Helper to create a circuit relay node
 proc createCircuitRelaySwitch(r: Relay): Switch =
@@ -40,19 +48,18 @@ proc main() {.async.} =
     swSrc = createCircuitRelaySwitch(clSrc)
     swDst = createCircuitRelaySwitch(clDst)
 
-    # Create a relay address to swDst using swRel as the relay
-    addrs = MultiAddress.init($swRel.peerInfo.addrs[0] & "/p2p/" &
-                              $swRel.peerInfo.peerId & "/p2p-circuit/p2p/" &
-                              $swDst.peerInfo.peerId).get()
-
   swDst.mount(proto)
 
   await swRel.start()
   await swSrc.start()
   await swDst.start()
 
-  # Connect both Src and Dst to the relay, but not to each other.
-  await swSrc.connect(swRel.peerInfo.peerId, swRel.peerInfo.addrs)
+  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.

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,108 +0,0 @@
-# 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 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 [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:
-```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,82 +0,0 @@
-# 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:
-```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.} =
-    # 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(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 the `createSwitch` of the first tutorial, 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))
@@ -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
@@ -48,12 +48,9 @@ else:
             stream/connection,
             transports/transport,
             transports/tcptransport,
-            transports/wstransport,
             protocols/secure/noise,
-            protocols/ping,
             cid,
             multihash,
-            multibase,
             multicodec,
             errors,
             switch,

libp2p.nimble

@@ -1,47 +1,59 @@
 mode = ScriptMode.Verbose
 
 packageName   = "libp2p"
-version       = "0.0.2"
+version       = "1.1.0"
 author        = "Status Research & Development GmbH"
 description   = "LibP2P implementation"
 license       = "MIT"
 skipDirs      = @["tests", "examples", "Nim", "tools", "scripts", "docs"]
 
-requires "nim >= 1.2.0",
+requires "nim >= 1.6.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"
+         "websock",
+         "unittest2 >= 0.0.5 & <= 0.1.0"
+
+let nimc = getEnv("NIMC", "nim") # Which nim compiler to use
+let lang = getEnv("NIMLANG", "c") # Which backend (c/cpp/js)
+let flags = getEnv("NIMFLAGS", "") # Extra flags for the compiler
+let verbose = getEnv("V", "") notin ["", "0"]
+
+let cfg =
+  " --styleCheck:usages --styleCheck:error" &
+  (if verbose: "" else: " --verbosity:0 --hints:off") &
+  " --skipParentCfg --skipUserCfg -f" &
+  " --threads:on --opt:speed"
+
+import hashes, strutils
 
 proc runTest(filename: string, verify: bool = true, sign: bool = true,
              moreoptions: string = "") =
-  var excstr = "nim c --skipParentCfg --opt:speed -d:debug -d:libp2p_agents_metrics -d:libp2p_protobuf_metrics -d:libp2p_network_protocols_metrics -d:libp2p_mplex_metrics "
-  excstr.add(" -d:chronicles_sinks=textlines[stdout],json[dynamic] -d:chronicles_log_level=TRACE ")
-  excstr.add(" -d:chronicles_runtime_filtering=TRUE ")
-  excstr.add(" " & getEnv("NIMFLAGS") & " ")
-  excstr.add(" --verbosity:0 --hints:off ")
+  var excstr = nimc & " " & lang & " -d:debug " & cfg & " " & flags
   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 --verbosity:0 --hints:off "
+proc buildSample(filename: string, run = false, extraFlags = "") =
+  var excstr = nimc & " " & lang & " " & cfg & " " & flags & " -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 --verbosity:0 --hints:off c -"
+proc tutorialToMd(filename: string) =
+  let markdown = gorge "cat " & filename & " | " & nimc & " " & lang & " -r --verbosity:0 --hints:off tools/markdown_builder.nim "
+  writeFile(filename.replace(".nim", ".md"), markdown)
 
 task testnative, "Runs libp2p native tests":
   runTest("testnative")
@@ -86,12 +98,28 @@ 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)
   buildSample("circuitrelay", true)
-  buildTutorial("examples/tutorial_1_connect.md")
-  buildTutorial("examples/tutorial_2_customproto.md")
+  buildSample("tutorial_1_connect", true)
+  buildSample("tutorial_2_customproto", true)
+  buildSample("tutorial_3_protobuf", true)
+  buildSample("tutorial_4_gossipsub", true)
+  buildSample("tutorial_5_discovery", true)
+  exec "nimble install -y nimpng@#HEAD" # this is to fix broken build on 1.7.3, remove it when nimpng version 0.3.2 or later is released
+  exec "nimble install -y nico"
+  buildSample("tutorial_6_game", false, "--styleCheck:off")
 
 # pin system
 # while nimble lockfile
@@ -102,7 +130,7 @@ task pin, "Create a lockfile":
   # pinner.nim was originally here
   # but you can't read output from
   # a command in a nimscript
-  exec "nim c -r tools/pinner.nim"
+  exec nimc & " c -r tools/pinner.nim"
 
 import sequtils
 import os
@@ -116,10 +144,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,18 +16,15 @@ runnableExamples:
    # etc
    .build()
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import
   options, tables, chronos, chronicles, sequtils,
   switch, peerid, peerinfo, stream/connection, multiaddress,
   crypto/crypto, transports/[transport, tcptransport],
   muxers/[muxer, mplex/mplex, yamux/yamux],
-  protocols/[identify, secure/secure, secure/noise],
-  protocols/connectivity/[autonat, relay/relay, relay/client, relay/rtransport],
+  protocols/[identify, secure/secure, secure/noise, rendezvous],
+  protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport],
   connmanager, upgrademngrs/muxedupgrade,
   nameresolving/nameresolver,
   errors, utility
@@ -36,7 +33,7 @@ export
   switch, peerid, peerinfo, connection, multiaddress, crypto, errors
 
 type
-  TransportProvider* {.public.} = proc(upgr: Upgrade): Transport {.gcsafe, raises: [Defect].}
+  TransportProvider* {.public.} = proc(upgr: Upgrade): Transport {.gcsafe, raises: [].}
 
   SecureProtocol* {.pure.} = enum
     Noise,
@@ -57,9 +54,11 @@ type
     protoVersion: string
     agentVersion: string
     nameResolver: NameResolver
-    peerStoreCapacity: Option[int]
+    peerStoreCapacity: Opt[int]
     autonat: bool
     circuitRelay: Relay
+    rdv: RendezVous
+    services: seq[Service]
 
 proc new*(T: type[SwitchBuilder]): T {.public.} =
   ## Creates a SwitchBuilder
@@ -171,7 +170,7 @@ proc withMaxConnsPerPeer*(b: SwitchBuilder, maxConnsPerPeer: int): SwitchBuilder
   b
 
 proc withPeerStore*(b: SwitchBuilder, capacity: int): SwitchBuilder {.public.} =
-  b.peerStoreCapacity = some(capacity)
+  b.peerStoreCapacity = Opt.some(capacity)
   b
 
 proc withProtoVersion*(b: SwitchBuilder, protoVersion: string): SwitchBuilder {.public.} =
@@ -194,8 +193,16 @@ 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
-  {.raises: [Defect, LPError], public.} =
+  {.raises: [LPError], public.} =
 
   if b.rng == nil: # newRng could fail
     raise newException(Defect, "Cannot initialize RNG")
@@ -220,7 +227,7 @@ proc build*(b: SwitchBuilder): Switch
     identify = Identify.new(peerInfo, b.sendSignedPeerRecord)
     connManager = ConnManager.new(b.maxConnsPerPeer, b.maxConnections, b.maxIn, b.maxOut)
     ms = MultistreamSelect.new()
-    muxedUpgrade = MuxedUpgrade.new(identify, b.muxers, secureManagerInstances, connManager, ms)
+    muxedUpgrade = MuxedUpgrade.new(b.muxers, secureManagerInstances, ms)
 
   let
     transports = block:
@@ -235,21 +242,23 @@ proc build*(b: SwitchBuilder): Switch
   if isNil(b.rng):
     b.rng = newRng()
 
-  let peerStore =
-    if isSome(b.peerStoreCapacity):
-      PeerStore.new(b.peerStoreCapacity.get())
+  let peerStore = block:
+    b.peerStoreCapacity.withValue(capacity):
+      PeerStore.new(identify, capacity)
     else:
-      PeerStore.new()
+      PeerStore.new(identify)
 
   let switch = newSwitch(
     peerInfo = peerInfo,
     transports = transports,
-    identity = identify,
     secureManagers = secureManagerInstances,
     connManager = connManager,
     ms = ms,
     nameResolver = b.nameResolver,
-    peerStore = peerStore)
+    peerStore = peerStore,
+    services = b.services)
+
+  switch.mount(identify)
 
   if b.autonat:
     let autonat = Autonat.new(switch)
@@ -261,6 +270,10 @@ proc build*(b: SwitchBuilder): Switch
     b.circuitRelay.setup(switch)
     switch.mount(b.circuitRelay)
 
+  if not isNil(b.rdv):
+    b.rdv.setup(switch)
+    switch.mount(b.rdv)
+
   return switch
 
 proc newStandardSwitch*(
@@ -280,11 +293,12 @@ proc newStandardSwitch*(
   nameResolver: NameResolver = nil,
   sendSignedPeerRecord = false,
   peerStoreCapacity = 1000): Switch
-  {.raises: [Defect, LPError], public.} =
+  {.raises: [LPError], public.} =
   ## Helper for common switch configurations.
-
+  {.push warning[Deprecated]:off.}
   if SecureProtocol.Secio in secureManagers:
       quit("Secio is deprecated!") # use of secio is unsafe
+  {.pop.}
 
   let addrs = when addrs is MultiAddress: @[addrs] else: addrs
   var b = SwitchBuilder
@@ -302,7 +316,7 @@ proc newStandardSwitch*(
     .withNameResolver(nameResolver)
     .withNoise()
 
-  if privKey.isSome():
-    b = b.withPrivateKey(privKey.get())
+  privKey.withValue(pkey):
+    b = b.withPrivateKey(pkey)
 
   b.build()

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,10 +9,7 @@
 
 ## This module implementes CID (Content IDentifier).
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import tables, hashes
 import multibase, multicodec, multihash, vbuffer, varint
@@ -279,9 +276,6 @@ proc `$`*(cid: Cid): string =
     BTCBase58.encode(cid.data.buffer)
   elif cid.cidver == CIDv1:
     let res = MultiBase.encode("base58btc", cid.data.buffer)
-    if res.isOk():
-      res.get()
-    else:
-      ""
+    res.get("")
   else:
     ""

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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[options, tables, sequtils, sets]
+import std/[tables, sequtils, sets]
 import pkg/[chronos, chronicles, metrics]
 import peerinfo,
        peerstore,
@@ -32,6 +29,7 @@ const
 
 type
   TooManyConnectionsError* = object of LPError
+  AlreadyExpectingConnectionError* = object of LPError
 
   ConnEventKind* {.pure.} = enum
     Connected,    # A connection was made and securely upgraded - there may be
@@ -50,11 +48,10 @@ type
 
   ConnEventHandler* =
     proc(peerId: PeerId, event: ConnEvent): Future[void]
-      {.gcsafe, raises: [Defect].}
+      {.gcsafe, raises: [].}
 
   PeerEventKind* {.pure.} = enum
     Left,
-    Identified,
     Joined
 
   PeerEvent* = object
@@ -65,20 +62,16 @@ type
         discard
 
   PeerEventHandler* =
-    proc(peerId: PeerId, event: PeerEvent): Future[void] {.gcsafe, raises: [Defect].}
-
-  MuxerHolder = object
-    muxer: Muxer
-    handle: Future[void]
+    proc(peerId: PeerId, event: PeerEvent): Future[void] {.gcsafe, raises: [].}
 
   ConnManager* = ref object of RootObj
     maxConnsPerPeer: int
     inSema*: AsyncSemaphore
     outSema*: AsyncSemaphore
-    conns: Table[PeerId, HashSet[Connection]]
-    muxed: Table[Connection, MuxerHolder]
+    muxed: Table[PeerId, seq[Muxer]]
     connEvents: array[ConnEventKind, OrderedSet[ConnEventHandler]]
     peerEvents: array[PeerEventKind, OrderedSet[PeerEventHandler]]
+    expectedConnectionsOverLimit*: Table[(PeerId, Direction), Future[Muxer]]
     peerStore*: PeerStore
 
   ConnectionSlot* = object
@@ -108,35 +101,30 @@ proc new*(C: type ConnManager,
     outSema: outSema)
 
 proc connCount*(c: ConnManager, peerId: PeerId): int =
-  c.conns.getOrDefault(peerId).len
+  c.muxed.getOrDefault(peerId).len
+
+proc connectedPeers*(c: ConnManager, dir: Direction): seq[PeerId] =
+  var peers = newSeq[PeerId]()
+  for peerId, mux in c.muxed:
+    if mux.anyIt(it.connection.dir == dir):
+      peers.add(peerId)
+  return peers
+
+proc getConnections*(c: ConnManager): Table[PeerId, seq[Muxer]] =
+  return c.muxed
 
 proc addConnEventHandler*(c: ConnManager,
                           handler: ConnEventHandler,
                           kind: ConnEventKind) =
   ## Add peer event handler - handlers must not raise exceptions!
   ##
-
-  try:
-    if isNil(handler): return
-    c.connEvents[kind].incl(handler)
-  except Exception as exc:
-    # TODO: there is an Exception being raised
-    # somewhere in the depths of the std.
-    # Might be related to https://github.com/nim-lang/Nim/issues/17382
-
-    raiseAssert exc.msg
+  if isNil(handler): return
+  c.connEvents[kind].incl(handler)
 
 proc removeConnEventHandler*(c: ConnManager,
                              handler: ConnEventHandler,
                              kind: ConnEventKind) =
-  try:
     c.connEvents[kind].excl(handler)
-  except Exception as exc:
-    # TODO: there is an Exception being raised
-    # somewhere in the depths of the std.
-    # Might be related to https://github.com/nim-lang/Nim/issues/17382
-
-    raiseAssert exc.msg
 
 proc triggerConnEvent*(c: ConnManager,
                        peerId: PeerId,
@@ -163,26 +151,12 @@ proc addPeerEventHandler*(c: ConnManager,
   ##
 
   if isNil(handler): return
-  try:
-    c.peerEvents[kind].incl(handler)
-  except Exception as exc:
-    # TODO: there is an Exception being raised
-    # somewhere in the depths of the std.
-    # Might be related to https://github.com/nim-lang/Nim/issues/17382
-
-    raiseAssert exc.msg
+  c.peerEvents[kind].incl(handler)
 
 proc removePeerEventHandler*(c: ConnManager,
                              handler: PeerEventHandler,
                              kind: PeerEventKind) =
-  try:
-    c.peerEvents[kind].excl(handler)
-  except Exception as exc:
-    # TODO: there is an Exception being raised
-    # somewhere in the depths of the std.
-    # Might be related to https://github.com/nim-lang/Nim/issues/17382
-
-    raiseAssert exc.msg
+  c.peerEvents[kind].excl(handler)
 
 proc triggerPeerEvents*(c: ConnManager,
                         peerId: PeerId,
@@ -193,14 +167,6 @@ proc triggerPeerEvents*(c: ConnManager,
     return
 
   try:
-    let count = c.connCount(peerId)
-    if event.kind == PeerEventKind.Joined and count != 1:
-      trace "peer already joined", peer = peerId, event = $event
-      return
-    elif event.kind == PeerEventKind.Left and count != 0:
-      trace "peer still connected or already left", peer = peerId, event = $event
-      return
-
     trace "triggering peer events", peer = peerId, event = $event
 
     var peerEvents: seq[Future[void]]
@@ -213,18 +179,22 @@ proc triggerPeerEvents*(c: ConnManager,
   except CatchableError as exc: # handlers should not raise!
     warn "Exception in triggerPeerEvents", exc = exc.msg, peer = peerId
 
-proc contains*(c: ConnManager, conn: Connection): bool =
-  ## checks if a connection is being tracked by the
-  ## connection manager
-  ##
+proc expectConnection*(c: ConnManager, p: PeerId, dir: Direction): Future[Muxer] {.async.} =
+  ## Wait for a peer to connect to us. This will bypass the `MaxConnectionsPerPeer`
+  let key = (p, dir)
+  if key in c.expectedConnectionsOverLimit:
+    raise newException(AlreadyExpectingConnectionError, "Already expecting an incoming connection from that peer")
 
-  if isNil(conn):
-    return
+  let future = newFuture[Muxer]()
+  c.expectedConnectionsOverLimit[key] = future
 
-  return conn in c.conns.getOrDefault(conn.peerId)
+  try:
+    return await future
+  finally:
+    c.expectedConnectionsOverLimit.del(key)
 
 proc contains*(c: ConnManager, peerId: PeerId): bool =
-  peerId in c.conns
+  peerId in c.muxed
 
 proc contains*(c: ConnManager, muxer: Muxer): bool =
   ## checks if a muxer is being tracked by the connection
@@ -232,184 +202,140 @@ proc contains*(c: ConnManager, muxer: Muxer): bool =
   ##
 
   if isNil(muxer):
-    return
+    return false
 
   let conn = muxer.connection
-  if conn notin c:
-    return
+  return muxer in c.muxed.getOrDefault(conn.peerId)
 
-  if conn notin c.muxed:
-    return
+proc closeMuxer(muxer: Muxer) {.async.} =
+  trace "Cleaning up muxer", m = muxer
 
-  return muxer == c.muxed.getOrDefault(conn).muxer
-
-proc closeMuxerHolder(muxerHolder: MuxerHolder) {.async.} =
-  trace "Cleaning up muxer", m = muxerHolder.muxer
-
-  await muxerHolder.muxer.close()
-  if not(isNil(muxerHolder.handle)):
+  await muxer.close()
+  if not(isNil(muxer.handler)):
     try:
-      await muxerHolder.handle # TODO noraises?
+      await muxer.handler # TODO noraises?
     except CatchableError as exc:
       trace "Exception in close muxer handler", exc = exc.msg
-  trace "Cleaned up muxer", m = muxerHolder.muxer
-
-proc delConn(c: ConnManager, conn: Connection) =
-  let peerId = conn.peerId
-  c.conns.withValue(peerId, peerConns):
-    peerConns[].excl(conn)
-
-    if peerConns[].len == 0:
-      c.conns.del(peerId) # invalidates `peerConns`
-
-    libp2p_peers.set(c.conns.len.int64)
-    trace "Removed connection", conn
-
-proc cleanupConn(c: ConnManager, conn: Connection) {.async.} =
-  ## clean connection's resources such as muxers and streams
-
-  if isNil(conn):
-    trace "Wont cleanup a nil connection"
-    return
-
-  # Remove connection from all tables without async breaks
-  var muxer = some(MuxerHolder())
-  if not c.muxed.pop(conn, muxer.get()):
-    muxer = none(MuxerHolder)
-
-  delConn(c, conn)
+  trace "Cleaned up muxer", m = muxer
 
+proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
   try:
-    if muxer.isSome:
-      await closeMuxerHolder(muxer.get())
-  finally:
-    await conn.close()
+    trace "Triggering disconnect events", mux
+    let peerId = mux.connection.peerId
 
-  trace "Connection cleaned up", conn
+    let muxers = c.muxed.getOrDefault(peerId).filterIt(it != mux)
+    if muxers.len > 0:
+      c.muxed[peerId] = muxers
+    else:
+      c.muxed.del(peerId)
+      libp2p_peers.set(c.muxed.len.int64)
+      await c.triggerPeerEvents(peerId, PeerEvent(kind: PeerEventKind.Left))
 
-proc onConnUpgraded(c: ConnManager, conn: Connection) {.async.} =
-  try:
-    trace "Triggering connect events", conn
-    conn.upgrade()
+      if not(c.peerStore.isNil):
+        c.peerStore.cleanup(peerId)
 
-    let peerId = conn.peerId
-    await c.triggerPeerEvents(
-      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: conn.dir == Direction.Out))
-
-    await c.triggerConnEvent(
-      peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: conn.dir == Direction.In))
-  except CatchableError as exc:
-    # This is top-level procedure which will work as separate task, so it
-    # do not need to propagate CancelledError and should handle other errors
-    warn "Unexpected exception in switch peer connection cleanup",
-      conn, msg = exc.msg
-
-proc peerCleanup(c: ConnManager, conn: Connection) {.async.} =
-  try:
-    trace "Triggering disconnect events", conn
-    let peerId = conn.peerId
     await c.triggerConnEvent(
       peerId, ConnEvent(kind: ConnEventKind.Disconnected))
-    await c.triggerPeerEvents(peerId, PeerEvent(kind: PeerEventKind.Left))
-
-    if not(c.peerStore.isNil):
-      c.peerStore.cleanup(peerId)
   except CatchableError as exc:
     # This is top-level procedure which will work as separate task, so it
     # do not need to propagate CancelledError and should handle other errors
     warn "Unexpected exception peer cleanup handler",
-      conn, msg = exc.msg
+      mux, msg = exc.msg
 
-proc onClose(c: ConnManager, conn: Connection) {.async.} =
+proc onClose(c: ConnManager, mux: Muxer) {.async.} =
   ## connection close even handler
   ##
   ## triggers the connections resource cleanup
   ##
   try:
-    await conn.join()
-    trace "Connection closed, cleaning up", conn
-    await c.cleanupConn(conn)
-  except CancelledError:
-    # This is top-level procedure which will work as separate task, so it
-    # do not need to propagate CancelledError.
-    debug "Unexpected cancellation in connection manager's cleanup", conn
+    await mux.connection.join()
+    trace "Connection closed, cleaning up", mux
   except CatchableError as exc:
     debug "Unexpected exception in connection manager's cleanup",
-          errMsg = exc.msg, conn
+          errMsg = exc.msg, mux
   finally:
-    trace "Triggering peerCleanup", conn
-    asyncSpawn c.peerCleanup(conn)
+    await c.muxCleanup(mux)
 
-proc selectConn*(c: ConnManager,
+proc selectMuxer*(c: ConnManager,
                 peerId: PeerId,
-                dir: Direction): Connection =
+                dir: Direction): Muxer =
   ## Select a connection for the provided peer and direction
   ##
   let conns = toSeq(
-    c.conns.getOrDefault(peerId))
-    .filterIt( it.dir == dir )
+    c.muxed.getOrDefault(peerId))
+    .filterIt( it.connection.dir == dir )
 
   if conns.len > 0:
     return conns[0]
 
-proc selectConn*(c: ConnManager, peerId: PeerId): Connection =
+proc selectMuxer*(c: ConnManager, peerId: PeerId): Muxer =
   ## Select a connection for the provided giving priority
   ## to outgoing connections
   ##
 
-  var conn = c.selectConn(peerId, Direction.Out)
-  if isNil(conn):
-    conn = c.selectConn(peerId, Direction.In)
-  if isNil(conn):
+  var mux = c.selectMuxer(peerId, Direction.Out)
+  if isNil(mux):
+    mux = c.selectMuxer(peerId, Direction.In)
+  if isNil(mux):
     trace "connection not found", peerId
+  return mux
 
-  return conn
-
-proc selectMuxer*(c: ConnManager, conn: Connection): Muxer =
-  ## select the muxer for the provided connection
+proc storeMuxer*(c: ConnManager,
+                 muxer: Muxer)
+                 {.raises: [CatchableError].} =
+  ## store the connection and muxer
   ##
 
-  if isNil(conn):
-    return
+  if isNil(muxer):
+    raise newException(LPError, "muxer cannot be nil")
 
-  if conn in c.muxed:
-    return c.muxed.getOrDefault(conn).muxer
-  else:
-    debug "no muxer for connection", conn
+  if isNil(muxer.connection):
+    raise newException(LPError, "muxer's connection cannot be nil")
 
-proc storeConn*(c: ConnManager, conn: Connection)
-  {.raises: [Defect, LPError].} =
-  ## store a connection
-  ##
-
-  if isNil(conn):
-    raise newException(LPError, "Connection cannot be nil")
-
-  if conn.closed or conn.atEof:
+  if muxer.connection.closed or muxer.connection.atEof:
     raise newException(LPError, "Connection closed or EOF")
 
-  let peerId = conn.peerId
-  if c.conns.getOrDefault(peerId).len > c.maxConnsPerPeer:
-    debug "Too many connections for peer",
-      conn, conns = c.conns.getOrDefault(peerId).len
+  let
+    peerId = muxer.connection.peerId
+    dir = muxer.connection.dir
 
-    raise newTooManyConnectionsError()
+  # we use getOrDefault in the if below instead of [] to avoid the KeyError
+  if c.muxed.getOrDefault(peerId).len > c.maxConnsPerPeer:
+    let key = (peerId, dir)
+    let expectedConn = c.expectedConnectionsOverLimit.getOrDefault(key)
+    if expectedConn != nil and not expectedConn.finished:
+        expectedConn.complete(muxer)
+    else:
+      debug "Too many connections for peer",
+        conns = c.muxed.getOrDefault(peerId).len
 
-  c.conns.mgetOrPut(peerId, HashSet[Connection]()).incl(conn)
-  libp2p_peers.set(c.conns.len.int64)
+      raise newTooManyConnectionsError()
 
-  # Launch on close listener
-  # All the errors are handled inside `onClose()` procedure.
-  asyncSpawn c.onClose(conn)
+  assert muxer notin c.muxed.getOrDefault(peerId)
 
-  trace "Stored connection",
-    conn, direction = $conn.dir, connections = c.conns.len
+  let
+    newPeer = peerId notin c.muxed
+  assert newPeer or c.muxed[peerId].len > 0
+  c.muxed.mgetOrPut(peerId, newSeq[Muxer]()).add(muxer)
+  libp2p_peers.set(c.muxed.len.int64)
+
+  asyncSpawn c.triggerConnEvent(
+    peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: dir == Direction.In))
+
+  if newPeer:
+    asyncSpawn c.triggerPeerEvents(
+      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: dir == Direction.Out))
+
+  asyncSpawn c.onClose(muxer)
+
+  trace "Stored muxer",
+    muxer, direction = $muxer.connection.dir, peers = c.muxed.len
 
 proc getIncomingSlot*(c: ConnManager): Future[ConnectionSlot] {.async.} =
   await c.inSema.acquire()
   return ConnectionSlot(connManager: c, direction: In)
 
-proc getOutgoingSlot*(c: ConnManager, forceDial = false): Future[ConnectionSlot] {.async.} =
+proc getOutgoingSlot*(c: ConnManager, forceDial = false): ConnectionSlot {.raises: [TooManyConnectionsError].} =
   if forceDial:
     c.outSema.forceAcquire()
   elif not c.outSema.tryAcquire():
@@ -418,6 +344,13 @@ proc getOutgoingSlot*(c: ConnManager, forceDial = false): Future[ConnectionSlot]
     raise newTooManyConnectionsError()
   return ConnectionSlot(connManager: c, direction: Out)
 
+proc slotsAvailable*(c: ConnManager, dir: Direction): int =
+  case dir:
+    of Direction.In:
+      return c.inSema.count
+    of Direction.Out:
+      return c.outSema.count
+
 proc release*(cs: ConnectionSlot) =
   if cs.direction == In:
     cs.connManager.inSema.release()
@@ -439,39 +372,17 @@ proc trackConnection*(cs: ConnectionSlot, conn: Connection) =
 
   asyncSpawn semaphoreMonitor()
 
-proc storeMuxer*(c: ConnManager,
-                 muxer: Muxer,
-                 handle: Future[void] = nil)
-                 {.raises: [Defect, CatchableError].} =
-  ## store the connection and muxer
-  ##
-
-  if isNil(muxer):
-    raise newException(CatchableError, "muxer cannot be nil")
-
-  if isNil(muxer.connection):
-    raise newException(CatchableError, "muxer's connection cannot be nil")
-
-  if muxer.connection notin c:
-    raise newException(CatchableError, "cant add muxer for untracked connection")
-
-  c.muxed[muxer.connection] = MuxerHolder(
-    muxer: muxer,
-    handle: handle)
-
-  trace "Stored muxer",
-    muxer, handle = not handle.isNil, connections = c.conns.len
-
-  asyncSpawn c.onConnUpgraded(muxer.connection)
+proc trackMuxer*(cs: ConnectionSlot, mux: Muxer) =
+  if isNil(mux):
+    cs.release()
+    return
+  cs.trackConnection(mux.connection)
 
 proc getStream*(c: ConnManager,
-                peerId: PeerId,
-                dir: Direction): Future[Connection] {.async, gcsafe.} =
-  ## get a muxed stream for the provided peer
-  ## with the given direction
+                muxer: Muxer): Future[Connection] {.async, gcsafe.} =
+  ## get a muxed stream for the passed muxer
   ##
 
-  let muxer = c.selectMuxer(c.selectConn(peerId, dir))
   if not(isNil(muxer)):
     return await muxer.newStream()
 
@@ -480,40 +391,25 @@ proc getStream*(c: ConnManager,
   ## get a muxed stream for the passed peer from any connection
   ##
 
-  let muxer = c.selectMuxer(c.selectConn(peerId))
-  if not(isNil(muxer)):
-    return await muxer.newStream()
+  return await c.getStream(c.selectMuxer(peerId))
 
 proc getStream*(c: ConnManager,
-                conn: Connection): Future[Connection] {.async, gcsafe.} =
-  ## get a muxed stream for the passed connection
+                peerId: PeerId,
+                dir: Direction): Future[Connection] {.async, gcsafe.} =
+  ## get a muxed stream for the passed peer from a connection with `dir`
   ##
 
-  let muxer = c.selectMuxer(conn)
-  if not(isNil(muxer)):
-    return await muxer.newStream()
+  return await c.getStream(c.selectMuxer(peerId, dir))
+
 
 proc dropPeer*(c: ConnManager, peerId: PeerId) {.async.} =
   ## drop connections and cleanup resources for peer
   ##
   trace "Dropping peer", peerId
-  let conns = c.conns.getOrDefault(peerId)
-  for conn in conns:
-    trace  "Removing connection", conn
-    delConn(c, conn)
-
-  var muxers: seq[MuxerHolder]
-  for conn in conns:
-    if conn in c.muxed:
-      muxers.add c.muxed[conn]
-      c.muxed.del(conn)
+  let muxers = c.muxed.getOrDefault(peerId)
 
   for muxer in muxers:
-    await closeMuxerHolder(muxer)
-
-  for conn in conns:
-    await conn.close()
-    trace "Dropped peer", peerId
+    await closeMuxer(muxer)
 
   trace "Peer dropped", peerId
 
@@ -523,17 +419,18 @@ proc close*(c: ConnManager) {.async.} =
   ##
 
   trace "Closing ConnManager"
-  let conns = c.conns
-  c.conns.clear()
-
   let muxed = c.muxed
   c.muxed.clear()
 
-  for _, muxer in muxed:
-    await closeMuxerHolder(muxer)
+  let expected = c.expectedConnectionsOverLimit
+  c.expectedConnectionsOverLimit.clear()
 
-  for _, conns2 in conns:
-    for conn in conns2:
-      await conn.close()
+  for _, fut in expected:
+    await fut.cancelAndWait()
+
+  for _, muxers in muxed:
+    for mux in muxers:
+      await closeMuxer(mux)
 
   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,14 +15,11 @@
 
 # RFC @ https://tools.ietf.org/html/rfc7539
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import bearssl/blockx
 from stew/assign2 import assign
-from stew/ranges/ptr_arith import baseAddr
+from stew/ptrops import baseAddr
 
 const
   ChaChaPolyKeySize = 32

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,10 +8,7 @@
 # those terms.
 
 ## This module implements Public Key and Private Key interface for libp2p.
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 from strutils import split, strip, cmpIgnoreCase
 
@@ -68,11 +65,13 @@ when supported(PKScheme.Ed25519):
   import ed25519/ed25519
 when supported(PKScheme.Secp256k1):
   import secp
+when supported(PKScheme.ECDSA):
+  import ecnist
 
-# We are still importing `ecnist` because, it is used for SECIO handshake,
-# but it will be impossible to create ECNIST keys or import ECNIST keys.
+  # These used to be declared in `crypto` itself
+  export ecnist.ephemeral, ecnist.ECDHEScheme
 
-import ecnist, bearssl/rand, bearssl/hash as bhash
+import bearssl/rand, bearssl/hash as bhash
 import ../protobuf/minprotobuf, ../vbuffer, ../multihash, ../multicodec
 import nimcrypto/[rijndael, twofish, sha2, hash, hmac]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
@@ -89,8 +88,6 @@ type
     Sha256,
     Sha512
 
-  ECDHEScheme* = EcCurveKind
-
   PublicKey* = object
     case scheme*: PKScheme
     of PKScheme.RSA:
@@ -458,7 +455,8 @@ proc getBytes*(sig: Signature): seq[byte] =
   ## Return signature ``sig`` in binary form.
   result = sig.data
 
-proc init*[T: PrivateKey|PublicKey](key: var T, data: openArray[byte]): bool =
+template initImpl[T: PrivateKey|PublicKey](
+    key: var T, data: openArray[byte]): bool =
   ## Initialize private key ``key`` from libp2p's protobuf serialized raw
   ## binary form.
   ##
@@ -471,7 +469,7 @@ proc init*[T: PrivateKey|PublicKey](key: var T, data: openArray[byte]): bool =
     var pb = initProtoBuffer(@data)
     let r1 = pb.getField(1, id)
     let r2 = pb.getField(2, buffer)
-    if not(r1.isOk() and r1.get() and r2.isOk() and r2.get()):
+    if not(r1.get(false) and r2.get(false)):
       false
     else:
       if cast[int8](id) notin SupportedSchemesInt or len(buffer) <= 0:
@@ -520,6 +518,14 @@ proc init*[T: PrivateKey|PublicKey](key: var T, data: openArray[byte]): bool =
           else:
             false
 
+{.push warning[ProveField]:off.}  # https://github.com/nim-lang/Nim/issues/22060
+proc init*(key: var PrivateKey, data: openArray[byte]): bool =
+  initImpl(key, data)
+
+proc init*(key: var PublicKey, data: openArray[byte]): bool =
+  initImpl(key, data)
+{.pop.}
+
 proc init*(sig: var Signature, data: openArray[byte]): bool =
   ## Initialize signature ``sig`` from raw binary form.
   ##
@@ -873,34 +879,6 @@ proc mac*(secret: Secret, id: int): seq[byte] {.inline.} =
   offset += secret.ivsize + secret.keysize
   copyMem(addr result[0], unsafeAddr secret.data[offset], secret.macsize)
 
-proc ephemeral*(
-    scheme: ECDHEScheme,
-    rng: var HmacDrbgContext): CryptoResult[EcKeyPair] =
-  ## Generate ephemeral keys used to perform ECDHE.
-  var keypair: EcKeyPair
-  if scheme == Secp256r1:
-    keypair = ? EcKeyPair.random(Secp256r1, rng).orError(KeyError)
-  elif scheme == Secp384r1:
-    keypair = ? EcKeyPair.random(Secp384r1, rng).orError(KeyError)
-  elif scheme == Secp521r1:
-    keypair = ? EcKeyPair.random(Secp521r1, rng).orError(KeyError)
-  ok(keypair)
-
-proc ephemeral*(
-    scheme: string, rng: var HmacDrbgContext): CryptoResult[EcKeyPair] =
-  ## Generate ephemeral keys used to perform ECDHE using string encoding.
-  ##
-  ## Currently supported encoding strings are P-256, P-384, P-521, if encoding
-  ## string is not supported P-521 key will be generated.
-  if scheme == "P-256":
-    ephemeral(Secp256r1, rng)
-  elif scheme == "P-384":
-    ephemeral(Secp384r1, rng)
-  elif scheme == "P-521":
-    ephemeral(Secp521r1, rng)
-  else:
-    ephemeral(Secp521r1, rng)
-
 proc getOrder*(remotePubkey, localNonce: openArray[byte],
                localPubkey, remoteNonce: openArray[byte]): CryptoResult[int] =
   ## Compare values and calculate `order` parameter.
@@ -976,9 +954,8 @@ proc decodeProposal*(message: seq[byte], nonce, pubkey: var seq[byte],
   let r4 = pb.getField(4, ciphers)
   let r5 = pb.getField(5, hashes)
 
-  r1.isOk() and r1.get() and r2.isOk() and r2.get() and
-  r3.isOk() and r3.get() and r4.isOk() and r4.get() and
-  r5.isOk() and r5.get()
+  r1.get(false) and r2.get(false) and r3.get(false) and
+  r4.get(false) and r5.get(false)
 
 proc createExchange*(epubkey, signature: openArray[byte]): seq[byte] =
   ## Create SecIO exchange message using ephemeral public key ``epubkey`` and
@@ -998,32 +975,32 @@ proc decodeExchange*(message: seq[byte],
   var pb = initProtoBuffer(message)
   let r1 = pb.getField(1, pubkey)
   let r2 = pb.getField(2, signature)
-  r1.isOk() and r1.get() and r2.isOk() and r2.get()
+  r1.get(false) and r2.get(false)
 
 ## Serialization/Deserialization helpers
 
 proc write*(vb: var VBuffer, pubkey: PublicKey) {.
-     inline, raises: [Defect, ResultError[CryptoError]].} =
+     inline, raises: [ResultError[CryptoError]].} =
   ## Write PublicKey value ``pubkey`` to buffer ``vb``.
   vb.writeSeq(pubkey.getBytes().tryGet())
 
 proc write*(vb: var VBuffer, seckey: PrivateKey) {.
-     inline, raises: [Defect, ResultError[CryptoError]].} =
+     inline, raises: [ResultError[CryptoError]].} =
   ## Write PrivateKey value ``seckey`` to buffer ``vb``.
   vb.writeSeq(seckey.getBytes().tryGet())
 
 proc write*(vb: var VBuffer, sig: PrivateKey) {.
-     inline, raises: [Defect, ResultError[CryptoError]].} =
+     inline, raises: [ResultError[CryptoError]].} =
   ## Write Signature value ``sig`` to buffer ``vb``.
   vb.writeSeq(sig.getBytes().tryGet())
 
 proc write*[T: PublicKey|PrivateKey](pb: var ProtoBuffer, field: int,
                                      key: T) {.
-     inline, raises: [Defect, ResultError[CryptoError]].} =
+     inline, raises: [ResultError[CryptoError]].} =
   write(pb, field, key.getBytes().tryGet())
 
 proc write*(pb: var ProtoBuffer, field: int, sig: Signature) {.
-     inline, raises: [Defect].} =
+     inline, raises: [].} =
   write(pb, field, sig.getBytes())
 
 proc getField*[T: PublicKey|PrivateKey](pb: ProtoBuffer, field: int,

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,12 +15,9 @@
 
 # RFC @ https://tools.ietf.org/html/rfc7748
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
-import bearssl/[ec, rand, hash]
+import bearssl/[ec, rand]
 import stew/results
 from stew/assign2 import assign
 export results

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,10 +14,7 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import bearssl/[ec, rand, hash]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
@@ -25,6 +22,9 @@ import nimcrypto/utils as ncrutils
 import minasn1
 export minasn1.Asn1Error
 import stew/[results, ctops]
+
+import ../utility
+
 export results
 
 const
@@ -74,7 +74,7 @@ type
   EcResult*[T] = Result[T, EcError]
 
 const
-  EcSupportedCurvesCint* = {cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)}
+  EcSupportedCurvesCint* = @[cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)]
 
 proc `-`(x: uint32): uint32 {.inline.} =
   result = (0xFFFF_FFFF'u32 - x) + 1'u32
@@ -243,7 +243,7 @@ proc random*(
   var res = new EcPrivateKey
   if ecKeygen(addr rng.vtable, ecimp,
                 addr res.key, addr res.buffer[0],
-                cast[cint](kind)) == 0:
+                safeConvert[cint](kind)) == 0:
     err(EcKeyGenError)
   else:
     ok(res)
@@ -630,11 +630,11 @@ proc init*(key: var EcPrivateKey, data: openArray[byte]): Result[void, Asn1Error
     return err(Asn1Error.Incorrect)
 
   if oid == Asn1OidSecp256r1:
-    curve = cast[cint](Secp256r1)
+    curve = safeConvert[cint](Secp256r1)
   elif oid == Asn1OidSecp384r1:
-    curve = cast[cint](Secp384r1)
+    curve = safeConvert[cint](Secp384r1)
   elif oid == Asn1OidSecp521r1:
-    curve = cast[cint](Secp521r1)
+    curve = safeConvert[cint](Secp521r1)
   else:
     return err(Asn1Error.Incorrect)
 
@@ -684,11 +684,11 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
     return err(Asn1Error.Incorrect)
 
   if oid == Asn1OidSecp256r1:
-    curve = cast[cint](Secp256r1)
+    curve = safeConvert[cint](Secp256r1)
   elif oid == Asn1OidSecp384r1:
-    curve = cast[cint](Secp384r1)
+    curve = safeConvert[cint](Secp384r1)
   elif oid == Asn1OidSecp521r1:
-    curve = cast[cint](Secp521r1)
+    curve = safeConvert[cint](Secp521r1)
   else:
     return err(Asn1Error.Incorrect)
 
@@ -774,13 +774,13 @@ proc initRaw*(key: var EcPrivateKey, data: openArray[byte]): bool =
   ## Procedure returns ``true`` on success, ``false`` otherwise.
   var curve: cint
   if len(data) == SecKey256Length:
-    curve = cast[cint](Secp256r1)
+    curve = safeConvert[cint](Secp256r1)
     result = true
   elif len(data) == SecKey384Length:
-    curve = cast[cint](Secp384r1)
+    curve = safeConvert[cint](Secp384r1)
     result = true
   elif len(data) == SecKey521Length:
-    curve = cast[cint](Secp521r1)
+    curve = safeConvert[cint](Secp521r1)
     result = true
   if result:
     result = false
@@ -805,13 +805,13 @@ proc initRaw*(pubkey: var EcPublicKey, data: openArray[byte]): bool =
   if len(data) > 0:
     if data[0] == 0x04'u8:
       if len(data) == PubKey256Length:
-        curve = cast[cint](Secp256r1)
+        curve = safeConvert[cint](Secp256r1)
         result = true
       elif len(data) == PubKey384Length:
-        curve = cast[cint](Secp384r1)
+        curve = safeConvert[cint](Secp384r1)
         result = true
       elif len(data) == PubKey521Length:
-        curve = cast[cint](Secp521r1)
+        curve = safeConvert[cint](Secp521r1)
         result = true
   if result:
     result = false
@@ -994,3 +994,33 @@ proc verify*[T: byte|char](sig: EcSignature, message: openArray[T],
     # Clear context with initial value
     kv.init(addr hc.vtable)
     result = (res == 1)
+
+type ECDHEScheme* = EcCurveKind
+
+proc ephemeral*(
+    scheme: ECDHEScheme,
+    rng: var HmacDrbgContext): EcResult[EcKeyPair] =
+  ## Generate ephemeral keys used to perform ECDHE.
+  var keypair: EcKeyPair
+  if scheme == Secp256r1:
+    keypair = ? EcKeyPair.random(Secp256r1, rng)
+  elif scheme == Secp384r1:
+    keypair = ? EcKeyPair.random(Secp384r1, rng)
+  elif scheme == Secp521r1:
+    keypair = ? EcKeyPair.random(Secp521r1, rng)
+  ok(keypair)
+
+proc ephemeral*(
+    scheme: string, rng: var HmacDrbgContext): EcResult[EcKeyPair] =
+  ## Generate ephemeral keys used to perform ECDHE using string encoding.
+  ##
+  ## Currently supported encoding strings are P-256, P-384, P-521, if encoding
+  ## string is not supported P-521 key will be generated.
+  if scheme == "P-256":
+    ephemeral(Secp256r1, rng)
+  elif scheme == "P-384":
+    ephemeral(Secp384r1, rng)
+  elif scheme == "P-521":
+    ephemeral(Secp521r1, rng)
+  else:
+    ephemeral(Secp521r1, rng)

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,10 +11,7 @@
 ## This code is a port of the public domain, "ref10" implementation of ed25519
 ## from SUPERCOP.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import bearssl/rand
 import constants
@@ -22,6 +19,9 @@ import nimcrypto/[hash, sha2]
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
 import nimcrypto/utils as ncrutils
 import stew/[results, ctops]
+
+import ../../utility
+
 export results
 
 # This workaround needed because of some bugs in Nim Static[T].
@@ -170,15 +170,15 @@ proc feCopy(h: var Fe, f: Fe) =
   h[9] = f9
 
 proc load_3(inp: openArray[byte]): uint64 =
-  result = cast[uint64](inp[0])
-  result = result or (cast[uint64](inp[1]) shl 8)
-  result = result or (cast[uint64](inp[2]) shl 16)
+  result = safeConvert[uint64](inp[0])
+  result = result or (safeConvert[uint64](inp[1]) shl 8)
+  result = result or (safeConvert[uint64](inp[2]) shl 16)
 
 proc load_4(inp: openArray[byte]): uint64 =
-  result = cast[uint64](inp[0])
-  result = result or (cast[uint64](inp[1]) shl 8)
-  result = result or (cast[uint64](inp[2]) shl 16)
-  result = result or (cast[uint64](inp[3]) shl 24)
+  result = safeConvert[uint64](inp[0])
+  result = result or (safeConvert[uint64](inp[1]) shl 8)
+  result = result or (safeConvert[uint64](inp[2]) shl 16)
+  result = result or (safeConvert[uint64](inp[3]) shl 24)
 
 proc feFromBytes(h: var Fe, s: openArray[byte]) =
   var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
@@ -299,106 +299,106 @@ proc feMul(h: var Fe, f, g: Fe) =
   var f5_2 = 2 * f5
   var f7_2 = 2 * f7
   var f9_2 = 2 * f9
-  var f0g0 = cast[int64](f0) * cast[int64](g0)
-  var f0g1 = cast[int64](f0) * cast[int64](g1)
-  var f0g2 = cast[int64](f0) * cast[int64](g2)
-  var f0g3 = cast[int64](f0) * cast[int64](g3)
-  var f0g4 = cast[int64](f0) * cast[int64](g4)
-  var f0g5 = cast[int64](f0) * cast[int64](g5)
-  var f0g6 = cast[int64](f0) * cast[int64](g6)
-  var f0g7 = cast[int64](f0) * cast[int64](g7)
-  var f0g8 = cast[int64](f0) * cast[int64](g8)
-  var f0g9 = cast[int64](f0) * cast[int64](g9)
-  var f1g0 = cast[int64](f1) * cast[int64](g0)
-  var f1g1_2 = cast[int64](f1_2) * cast[int64](g1)
-  var f1g2 = cast[int64](f1) * cast[int64](g2)
-  var f1g3_2 = cast[int64](f1_2) * cast[int64](g3)
-  var f1g4 = cast[int64](f1) * cast[int64](g4)
-  var f1g5_2 = cast[int64](f1_2) * cast[int64](g5)
-  var f1g6 = cast[int64](f1) * cast[int64](g6)
-  var f1g7_2 = cast[int64](f1_2) * cast[int64](g7)
-  var f1g8 = cast[int64](f1) * cast[int64](g8)
-  var f1g9_38 = cast[int64](f1_2) * cast[int64](g9_19)
-  var f2g0 = cast[int64](f2) * cast[int64](g0)
-  var f2g1 = cast[int64](f2) * cast[int64](g1)
-  var f2g2 = cast[int64](f2) * cast[int64](g2)
-  var f2g3 = cast[int64](f2) * cast[int64](g3)
-  var f2g4 = cast[int64](f2) * cast[int64](g4)
-  var f2g5 = cast[int64](f2) * cast[int64](g5)
-  var f2g6 = cast[int64](f2) * cast[int64](g6)
-  var f2g7 = cast[int64](f2) * cast[int64](g7)
-  var f2g8_19 = cast[int64](f2) * cast[int64](g8_19)
-  var f2g9_19 = cast[int64](f2) * cast[int64](g9_19)
-  var f3g0 = cast[int64](f3) * cast[int64](g0)
-  var f3g1_2  = cast[int64](f3_2) * cast[int64](g1)
-  var f3g2 = cast[int64](f3) * cast[int64](g2)
-  var f3g3_2  = cast[int64](f3_2) * cast[int64](g3)
-  var f3g4 = cast[int64](f3) * cast[int64](g4)
-  var f3g5_2  = cast[int64](f3_2) * cast[int64](g5)
-  var f3g6 = cast[int64](f3) * cast[int64](g6)
-  var f3g7_38 = cast[int64](f3_2) * cast[int64](g7_19)
-  var f3g8_19 = cast[int64](f3) * cast[int64](g8_19)
-  var f3g9_38 = cast[int64](f3_2) * cast[int64](g9_19)
-  var f4g0 = cast[int64](f4) * cast[int64](g0)
-  var f4g1 = cast[int64](f4) * cast[int64](g1)
-  var f4g2 = cast[int64](f4) * cast[int64](g2)
-  var f4g3 = cast[int64](f4) * cast[int64](g3)
-  var f4g4 = cast[int64](f4) * cast[int64](g4)
-  var f4g5 = cast[int64](f4) * cast[int64](g5)
-  var f4g6_19 = cast[int64](f4) * cast[int64](g6_19)
-  var f4g7_19 = cast[int64](f4) * cast[int64](g7_19)
-  var f4g8_19 = cast[int64](f4) * cast[int64](g8_19)
-  var f4g9_19 = cast[int64](f4) * cast[int64](g9_19)
-  var f5g0 = cast[int64](f5) * cast[int64](g0)
-  var f5g1_2 = cast[int64](f5_2) * cast[int64](g1)
-  var f5g2 = cast[int64](f5) * cast[int64](g2)
-  var f5g3_2 = cast[int64](f5_2) * cast[int64](g3)
-  var f5g4 = cast[int64](f5) * cast[int64](g4)
-  var f5g5_38 = cast[int64](f5_2) * cast[int64](g5_19)
-  var f5g6_19 = cast[int64](f5) * cast[int64](g6_19)
-  var f5g7_38 = cast[int64](f5_2) * cast[int64](g7_19)
-  var f5g8_19 = cast[int64](f5) * cast[int64](g8_19)
-  var f5g9_38 = cast[int64](f5_2) * cast[int64](g9_19)
-  var f6g0 = cast[int64](f6) * cast[int64](g0)
-  var f6g1 = cast[int64](f6) * cast[int64](g1)
-  var f6g2 = cast[int64](f6) * cast[int64](g2)
-  var f6g3 = cast[int64](f6) * cast[int64](g3)
-  var f6g4_19 = cast[int64](f6) * cast[int64](g4_19)
-  var f6g5_19 = cast[int64](f6) * cast[int64](g5_19)
-  var f6g6_19 = cast[int64](f6) * cast[int64](g6_19)
-  var f6g7_19 = cast[int64](f6) * cast[int64](g7_19)
-  var f6g8_19 = cast[int64](f6) * cast[int64](g8_19)
-  var f6g9_19 = cast[int64](f6) * cast[int64](g9_19)
-  var f7g0 = cast[int64](f7) * cast[int64](g0)
-  var f7g1_2 = cast[int64](f7_2) * cast[int64](g1)
-  var f7g2 = cast[int64](f7) * cast[int64](g2)
-  var f7g3_38 = cast[int64](f7_2) * cast[int64](g3_19)
-  var f7g4_19 = cast[int64](f7) * cast[int64](g4_19)
-  var f7g5_38 = cast[int64](f7_2) * cast[int64](g5_19)
-  var f7g6_19 = cast[int64](f7) * cast[int64](g6_19)
-  var f7g7_38 = cast[int64](f7_2) * cast[int64](g7_19)
-  var f7g8_19 = cast[int64](f7) * cast[int64](g8_19)
-  var f7g9_38 = cast[int64](f7_2) * cast[int64](g9_19)
-  var f8g0 = cast[int64](f8) * cast[int64](g0)
-  var f8g1 = cast[int64](f8) * cast[int64](g1)
-  var f8g2_19 = cast[int64](f8) * cast[int64](g2_19)
-  var f8g3_19 = cast[int64](f8) * cast[int64](g3_19)
-  var f8g4_19 = cast[int64](f8) * cast[int64](g4_19)
-  var f8g5_19 = cast[int64](f8) * cast[int64](g5_19)
-  var f8g6_19 = cast[int64](f8) * cast[int64](g6_19)
-  var f8g7_19 = cast[int64](f8) * cast[int64](g7_19)
-  var f8g8_19 = cast[int64](f8) * cast[int64](g8_19)
-  var f8g9_19 = cast[int64](f8) * cast[int64](g9_19)
-  var f9g0 = cast[int64](f9) * cast[int64](g0)
-  var f9g1_38 = cast[int64](f9_2) * cast[int64](g1_19)
-  var f9g2_19 = cast[int64](f9) * cast[int64](g2_19)
-  var f9g3_38 = cast[int64](f9_2) * cast[int64](g3_19)
-  var f9g4_19 = cast[int64](f9) * cast[int64](g4_19)
-  var f9g5_38 = cast[int64](f9_2) * cast[int64](g5_19)
-  var f9g6_19 = cast[int64](f9) * cast[int64](g6_19)
-  var f9g7_38 = cast[int64](f9_2) * cast[int64](g7_19)
-  var f9g8_19 = cast[int64](f9) * cast[int64](g8_19)
-  var f9g9_38 = cast[int64](f9_2) * cast[int64](g9_19)
+  var f0g0 = safeConvert[int64](f0) * safeConvert[int64](g0)
+  var f0g1 = safeConvert[int64](f0) * safeConvert[int64](g1)
+  var f0g2 = safeConvert[int64](f0) * safeConvert[int64](g2)
+  var f0g3 = safeConvert[int64](f0) * safeConvert[int64](g3)
+  var f0g4 = safeConvert[int64](f0) * safeConvert[int64](g4)
+  var f0g5 = safeConvert[int64](f0) * safeConvert[int64](g5)
+  var f0g6 = safeConvert[int64](f0) * safeConvert[int64](g6)
+  var f0g7 = safeConvert[int64](f0) * safeConvert[int64](g7)
+  var f0g8 = safeConvert[int64](f0) * safeConvert[int64](g8)
+  var f0g9 = safeConvert[int64](f0) * safeConvert[int64](g9)
+  var f1g0 = safeConvert[int64](f1) * safeConvert[int64](g0)
+  var f1g1_2 = safeConvert[int64](f1_2) * safeConvert[int64](g1)
+  var f1g2 = safeConvert[int64](f1) * safeConvert[int64](g2)
+  var f1g3_2 = safeConvert[int64](f1_2) * safeConvert[int64](g3)
+  var f1g4 = safeConvert[int64](f1) * safeConvert[int64](g4)
+  var f1g5_2 = safeConvert[int64](f1_2) * safeConvert[int64](g5)
+  var f1g6 = safeConvert[int64](f1) * safeConvert[int64](g6)
+  var f1g7_2 = safeConvert[int64](f1_2) * safeConvert[int64](g7)
+  var f1g8 = safeConvert[int64](f1) * safeConvert[int64](g8)
+  var f1g9_38 = safeConvert[int64](f1_2) * safeConvert[int64](g9_19)
+  var f2g0 = safeConvert[int64](f2) * safeConvert[int64](g0)
+  var f2g1 = safeConvert[int64](f2) * safeConvert[int64](g1)
+  var f2g2 = safeConvert[int64](f2) * safeConvert[int64](g2)
+  var f2g3 = safeConvert[int64](f2) * safeConvert[int64](g3)
+  var f2g4 = safeConvert[int64](f2) * safeConvert[int64](g4)
+  var f2g5 = safeConvert[int64](f2) * safeConvert[int64](g5)
+  var f2g6 = safeConvert[int64](f2) * safeConvert[int64](g6)
+  var f2g7 = safeConvert[int64](f2) * safeConvert[int64](g7)
+  var f2g8_19 = safeConvert[int64](f2) * safeConvert[int64](g8_19)
+  var f2g9_19 = safeConvert[int64](f2) * safeConvert[int64](g9_19)
+  var f3g0 = safeConvert[int64](f3) * safeConvert[int64](g0)
+  var f3g1_2  = safeConvert[int64](f3_2) * safeConvert[int64](g1)
+  var f3g2 = safeConvert[int64](f3) * safeConvert[int64](g2)
+  var f3g3_2  = safeConvert[int64](f3_2) * safeConvert[int64](g3)
+  var f3g4 = safeConvert[int64](f3) * safeConvert[int64](g4)
+  var f3g5_2  = safeConvert[int64](f3_2) * safeConvert[int64](g5)
+  var f3g6 = safeConvert[int64](f3) * safeConvert[int64](g6)
+  var f3g7_38 = safeConvert[int64](f3_2) * safeConvert[int64](g7_19)
+  var f3g8_19 = safeConvert[int64](f3) * safeConvert[int64](g8_19)
+  var f3g9_38 = safeConvert[int64](f3_2) * safeConvert[int64](g9_19)
+  var f4g0 = safeConvert[int64](f4) * safeConvert[int64](g0)
+  var f4g1 = safeConvert[int64](f4) * safeConvert[int64](g1)
+  var f4g2 = safeConvert[int64](f4) * safeConvert[int64](g2)
+  var f4g3 = safeConvert[int64](f4) * safeConvert[int64](g3)
+  var f4g4 = safeConvert[int64](f4) * safeConvert[int64](g4)
+  var f4g5 = safeConvert[int64](f4) * safeConvert[int64](g5)
+  var f4g6_19 = safeConvert[int64](f4) * safeConvert[int64](g6_19)
+  var f4g7_19 = safeConvert[int64](f4) * safeConvert[int64](g7_19)
+  var f4g8_19 = safeConvert[int64](f4) * safeConvert[int64](g8_19)
+  var f4g9_19 = safeConvert[int64](f4) * safeConvert[int64](g9_19)
+  var f5g0 = safeConvert[int64](f5) * safeConvert[int64](g0)
+  var f5g1_2 = safeConvert[int64](f5_2) * safeConvert[int64](g1)
+  var f5g2 = safeConvert[int64](f5) * safeConvert[int64](g2)
+  var f5g3_2 = safeConvert[int64](f5_2) * safeConvert[int64](g3)
+  var f5g4 = safeConvert[int64](f5) * safeConvert[int64](g4)
+  var f5g5_38 = safeConvert[int64](f5_2) * safeConvert[int64](g5_19)
+  var f5g6_19 = safeConvert[int64](f5) * safeConvert[int64](g6_19)
+  var f5g7_38 = safeConvert[int64](f5_2) * safeConvert[int64](g7_19)
+  var f5g8_19 = safeConvert[int64](f5) * safeConvert[int64](g8_19)
+  var f5g9_38 = safeConvert[int64](f5_2) * safeConvert[int64](g9_19)
+  var f6g0 = safeConvert[int64](f6) * safeConvert[int64](g0)
+  var f6g1 = safeConvert[int64](f6) * safeConvert[int64](g1)
+  var f6g2 = safeConvert[int64](f6) * safeConvert[int64](g2)
+  var f6g3 = safeConvert[int64](f6) * safeConvert[int64](g3)
+  var f6g4_19 = safeConvert[int64](f6) * safeConvert[int64](g4_19)
+  var f6g5_19 = safeConvert[int64](f6) * safeConvert[int64](g5_19)
+  var f6g6_19 = safeConvert[int64](f6) * safeConvert[int64](g6_19)
+  var f6g7_19 = safeConvert[int64](f6) * safeConvert[int64](g7_19)
+  var f6g8_19 = safeConvert[int64](f6) * safeConvert[int64](g8_19)
+  var f6g9_19 = safeConvert[int64](f6) * safeConvert[int64](g9_19)
+  var f7g0 = safeConvert[int64](f7) * safeConvert[int64](g0)
+  var f7g1_2 = safeConvert[int64](f7_2) * safeConvert[int64](g1)
+  var f7g2 = safeConvert[int64](f7) * safeConvert[int64](g2)
+  var f7g3_38 = safeConvert[int64](f7_2) * safeConvert[int64](g3_19)
+  var f7g4_19 = safeConvert[int64](f7) * safeConvert[int64](g4_19)
+  var f7g5_38 = safeConvert[int64](f7_2) * safeConvert[int64](g5_19)
+  var f7g6_19 = safeConvert[int64](f7) * safeConvert[int64](g6_19)
+  var f7g7_38 = safeConvert[int64](f7_2) * safeConvert[int64](g7_19)
+  var f7g8_19 = safeConvert[int64](f7) * safeConvert[int64](g8_19)
+  var f7g9_38 = safeConvert[int64](f7_2) * safeConvert[int64](g9_19)
+  var f8g0 = safeConvert[int64](f8) * safeConvert[int64](g0)
+  var f8g1 = safeConvert[int64](f8) * safeConvert[int64](g1)
+  var f8g2_19 = safeConvert[int64](f8) * safeConvert[int64](g2_19)
+  var f8g3_19 = safeConvert[int64](f8) * safeConvert[int64](g3_19)
+  var f8g4_19 = safeConvert[int64](f8) * safeConvert[int64](g4_19)
+  var f8g5_19 = safeConvert[int64](f8) * safeConvert[int64](g5_19)
+  var f8g6_19 = safeConvert[int64](f8) * safeConvert[int64](g6_19)
+  var f8g7_19 = safeConvert[int64](f8) * safeConvert[int64](g7_19)
+  var f8g8_19 = safeConvert[int64](f8) * safeConvert[int64](g8_19)
+  var f8g9_19 = safeConvert[int64](f8) * safeConvert[int64](g9_19)
+  var f9g0 = safeConvert[int64](f9) * safeConvert[int64](g0)
+  var f9g1_38 = safeConvert[int64](f9_2) * safeConvert[int64](g1_19)
+  var f9g2_19 = safeConvert[int64](f9) * safeConvert[int64](g2_19)
+  var f9g3_38 = safeConvert[int64](f9_2) * safeConvert[int64](g3_19)
+  var f9g4_19 = safeConvert[int64](f9) * safeConvert[int64](g4_19)
+  var f9g5_38 = safeConvert[int64](f9_2) * safeConvert[int64](g5_19)
+  var f9g6_19 = safeConvert[int64](f9) * safeConvert[int64](g6_19)
+  var f9g7_38 = safeConvert[int64](f9_2) * safeConvert[int64](g7_19)
+  var f9g8_19 = safeConvert[int64](f9) * safeConvert[int64](g8_19)
+  var f9g9_38 = safeConvert[int64](f9_2) * safeConvert[int64](g9_19)
   var
     c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
     h0: int64 = f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 +
@@ -493,7 +493,7 @@ proc verify32(x: openArray[byte], y: openArray[byte]): int32 =
 proc feIsNegative(f: Fe): int32 =
   var s: array[32, byte]
   feToBytes(s, f)
-  result = cast[int32](s[0] and 1'u8)
+  result = safeConvert[int32](s[0] and 1'u8)
 
 proc feIsNonZero(f: Fe): int32 =
   var s: array[32, byte]
@@ -516,61 +516,61 @@ proc feSq(h: var Fe, f: Fe) =
   var f7_38: int32 = 38 * f7
   var f8_19: int32 = 19 * f8
   var f9_38: int32 = 38 * f9
-  var f0f0: int64 = f0 * cast[int64](f0)
-  var f0f1_2: int64 = f0_2 * cast[int64](f1)
-  var f0f2_2: int64 = f0_2 * cast[int64](f2)
-  var f0f3_2: int64 = f0_2 * cast[int64](f3)
-  var f0f4_2: int64 = f0_2 * cast[int64](f4)
-  var f0f5_2: int64 = f0_2 * cast[int64](f5)
-  var f0f6_2: int64 = f0_2 * cast[int64](f6)
-  var f0f7_2: int64 = f0_2 * cast[int64](f7)
-  var f0f8_2: int64 = f0_2 * cast[int64](f8)
-  var f0f9_2: int64 = f0_2 * cast[int64](f9)
-  var f1f1_2: int64 = f1_2 * cast[int64](f1)
-  var f1f2_2: int64 = f1_2 * cast[int64](f2)
-  var f1f3_4: int64 = f1_2 * cast[int64](f3_2)
-  var f1f4_2: int64 = f1_2 * cast[int64](f4)
-  var f1f5_4: int64 = f1_2 * cast[int64](f5_2)
-  var f1f6_2: int64 = f1_2 * cast[int64](f6)
-  var f1f7_4: int64 = f1_2 * cast[int64](f7_2)
-  var f1f8_2: int64 = f1_2 * cast[int64](f8)
-  var f1f9_76: int64 = f1_2 * cast[int64](f9_38)
-  var f2f2: int64 = f2 * cast[int64](f2)
-  var f2f3_2: int64 = f2_2 * cast[int64](f3)
-  var f2f4_2: int64 = f2_2 * cast[int64](f4)
-  var f2f5_2: int64 = f2_2 * cast[int64](f5)
-  var f2f6_2: int64 = f2_2 * cast[int64](f6)
-  var f2f7_2: int64 = f2_2 * cast[int64](f7)
-  var f2f8_38: int64 = f2_2 * cast[int64](f8_19)
-  var f2f9_38: int64 = f2 * cast[int64](f9_38)
-  var f3f3_2: int64 = f3_2 * cast[int64](f3)
-  var f3f4_2: int64 = f3_2 * cast[int64](f4)
-  var f3f5_4: int64 = f3_2 * cast[int64](f5_2)
-  var f3f6_2: int64 = f3_2 * cast[int64](f6)
-  var f3f7_76: int64 = f3_2 * cast[int64](f7_38)
-  var f3f8_38: int64 = f3_2 * cast[int64](f8_19)
-  var f3f9_76: int64 = f3_2 * cast[int64](f9_38)
-  var f4f4: int64 = f4 * cast[int64](f4)
-  var f4f5_2: int64 = f4_2 * cast[int64](f5)
-  var f4f6_38: int64 = f4_2 * cast[int64](f6_19)
-  var f4f7_38: int64 = f4 * cast[int64](f7_38)
-  var f4f8_38: int64 = f4_2 * cast[int64](f8_19)
-  var f4f9_38: int64 = f4 * cast[int64](f9_38)
-  var f5f5_38: int64 = f5 * cast[int64](f5_38)
-  var f5f6_38: int64 = f5_2 * cast[int64](f6_19)
-  var f5f7_76: int64 = f5_2 * cast[int64](f7_38)
-  var f5f8_38: int64 = f5_2 * cast[int64](f8_19)
-  var f5f9_76: int64 = f5_2 * cast[int64](f9_38)
-  var f6f6_19: int64 = f6 * cast[int64](f6_19)
-  var f6f7_38: int64 = f6 * cast[int64](f7_38)
-  var f6f8_38: int64 = f6_2 * cast[int64](f8_19)
-  var f6f9_38: int64 = f6 * cast[int64](f9_38)
-  var f7f7_38: int64 = f7 * cast[int64](f7_38)
-  var f7f8_38: int64 = f7_2 * cast[int64](f8_19)
-  var f7f9_76: int64 = f7_2 * cast[int64](f9_38)
-  var f8f8_19: int64 = f8 * cast[int64](f8_19)
-  var f8f9_38: int64 = f8 * cast[int64](f9_38)
-  var f9f9_38: int64 = f9 * cast[int64](f9_38)
+  var f0f0: int64 = f0 * safeConvert[int64](f0)
+  var f0f1_2: int64 = f0_2 * safeConvert[int64](f1)
+  var f0f2_2: int64 = f0_2 * safeConvert[int64](f2)
+  var f0f3_2: int64 = f0_2 * safeConvert[int64](f3)
+  var f0f4_2: int64 = f0_2 * safeConvert[int64](f4)
+  var f0f5_2: int64 = f0_2 * safeConvert[int64](f5)
+  var f0f6_2: int64 = f0_2 * safeConvert[int64](f6)
+  var f0f7_2: int64 = f0_2 * safeConvert[int64](f7)
+  var f0f8_2: int64 = f0_2 * safeConvert[int64](f8)
+  var f0f9_2: int64 = f0_2 * safeConvert[int64](f9)
+  var f1f1_2: int64 = f1_2 * safeConvert[int64](f1)
+  var f1f2_2: int64 = f1_2 * safeConvert[int64](f2)
+  var f1f3_4: int64 = f1_2 * safeConvert[int64](f3_2)
+  var f1f4_2: int64 = f1_2 * safeConvert[int64](f4)
+  var f1f5_4: int64 = f1_2 * safeConvert[int64](f5_2)
+  var f1f6_2: int64 = f1_2 * safeConvert[int64](f6)
+  var f1f7_4: int64 = f1_2 * safeConvert[int64](f7_2)
+  var f1f8_2: int64 = f1_2 * safeConvert[int64](f8)
+  var f1f9_76: int64 = f1_2 * safeConvert[int64](f9_38)
+  var f2f2: int64 = f2 * safeConvert[int64](f2)
+  var f2f3_2: int64 = f2_2 * safeConvert[int64](f3)
+  var f2f4_2: int64 = f2_2 * safeConvert[int64](f4)
+  var f2f5_2: int64 = f2_2 * safeConvert[int64](f5)
+  var f2f6_2: int64 = f2_2 * safeConvert[int64](f6)
+  var f2f7_2: int64 = f2_2 * safeConvert[int64](f7)
+  var f2f8_38: int64 = f2_2 * safeConvert[int64](f8_19)
+  var f2f9_38: int64 = f2 * safeConvert[int64](f9_38)
+  var f3f3_2: int64 = f3_2 * safeConvert[int64](f3)
+  var f3f4_2: int64 = f3_2 * safeConvert[int64](f4)
+  var f3f5_4: int64 = f3_2 * safeConvert[int64](f5_2)
+  var f3f6_2: int64 = f3_2 * safeConvert[int64](f6)
+  var f3f7_76: int64 = f3_2 * safeConvert[int64](f7_38)
+  var f3f8_38: int64 = f3_2 * safeConvert[int64](f8_19)
+  var f3f9_76: int64 = f3_2 * safeConvert[int64](f9_38)
+  var f4f4: int64 = f4 * safeConvert[int64](f4)
+  var f4f5_2: int64 = f4_2 * safeConvert[int64](f5)
+  var f4f6_38: int64 = f4_2 * safeConvert[int64](f6_19)
+  var f4f7_38: int64 = f4 * safeConvert[int64](f7_38)
+  var f4f8_38: int64 = f4_2 * safeConvert[int64](f8_19)
+  var f4f9_38: int64 = f4 * safeConvert[int64](f9_38)
+  var f5f5_38: int64 = f5 * safeConvert[int64](f5_38)
+  var f5f6_38: int64 = f5_2 * safeConvert[int64](f6_19)
+  var f5f7_76: int64 = f5_2 * safeConvert[int64](f7_38)
+  var f5f8_38: int64 = f5_2 * safeConvert[int64](f8_19)
+  var f5f9_76: int64 = f5_2 * safeConvert[int64](f9_38)
+  var f6f6_19: int64 = f6 * safeConvert[int64](f6_19)
+  var f6f7_38: int64 = f6 * safeConvert[int64](f7_38)
+  var f6f8_38: int64 = f6_2 * safeConvert[int64](f8_19)
+  var f6f9_38: int64 = f6 * safeConvert[int64](f9_38)
+  var f7f7_38: int64 = f7 * safeConvert[int64](f7_38)
+  var f7f8_38: int64 = f7_2 * safeConvert[int64](f8_19)
+  var f7f9_76: int64 = f7_2 * safeConvert[int64](f9_38)
+  var f8f8_19: int64 = f8 * safeConvert[int64](f8_19)
+  var f8f9_38: int64 = f8 * safeConvert[int64](f9_38)
+  var f9f9_38: int64 = f9 * safeConvert[int64](f9_38)
   var h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
   var h1: int64 = f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
   var h2: int64 = f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
@@ -623,61 +623,61 @@ proc feSq2(h: var Fe, f: Fe) =
   var f7_38 = 38 * f7
   var f8_19 = 19 * f8
   var f9_38 = 38 * f9
-  var f0f0 = cast[int64](f0) * cast[int64](f0)
-  var f0f1_2 = cast[int64](f0_2) * cast[int64](f1)
-  var f0f2_2 = cast[int64](f0_2) * cast[int64](f2)
-  var f0f3_2 = cast[int64](f0_2) * cast[int64](f3)
-  var f0f4_2 = cast[int64](f0_2) * cast[int64](f4)
-  var f0f5_2 = cast[int64](f0_2) * cast[int64](f5)
-  var f0f6_2 = cast[int64](f0_2) * cast[int64](f6)
-  var f0f7_2 = cast[int64](f0_2) * cast[int64](f7)
-  var f0f8_2 = cast[int64](f0_2) * cast[int64](f8)
-  var f0f9_2 = cast[int64](f0_2) * cast[int64](f9)
-  var f1f1_2 = cast[int64](f1_2) * cast[int64](f1)
-  var f1f2_2 = cast[int64](f1_2) * cast[int64](f2)
-  var f1f3_4 = cast[int64](f1_2) * cast[int64](f3_2)
-  var f1f4_2 = cast[int64](f1_2) * cast[int64](f4)
-  var f1f5_4 = cast[int64](f1_2) * cast[int64](f5_2)
-  var f1f6_2 = cast[int64](f1_2) * cast[int64](f6)
-  var f1f7_4 = cast[int64](f1_2) * cast[int64](f7_2)
-  var f1f8_2 = cast[int64](f1_2) * cast[int64](f8)
-  var f1f9_76 = cast[int64](f1_2) * cast[int64](f9_38)
-  var f2f2 = cast[int64](f2) * cast[int64](f2)
-  var f2f3_2 = cast[int64](f2_2) * cast[int64](f3)
-  var f2f4_2 = cast[int64](f2_2) * cast[int64](f4)
-  var f2f5_2 = cast[int64](f2_2) * cast[int64](f5)
-  var f2f6_2 = cast[int64](f2_2) * cast[int64](f6)
-  var f2f7_2 = cast[int64](f2_2) * cast[int64](f7)
-  var f2f8_38 = cast[int64](f2_2) * cast[int64](f8_19)
-  var f2f9_38 = cast[int64](f2) * cast[int64](f9_38)
-  var f3f3_2 = cast[int64](f3_2) * cast[int64](f3)
-  var f3f4_2 = cast[int64](f3_2) * cast[int64](f4)
-  var f3f5_4 = cast[int64](f3_2) * cast[int64](f5_2)
-  var f3f6_2 = cast[int64](f3_2) * cast[int64](f6)
-  var f3f7_76 = cast[int64](f3_2) * cast[int64](f7_38)
-  var f3f8_38 = cast[int64](f3_2) * cast[int64](f8_19)
-  var f3f9_76 = cast[int64](f3_2) * cast[int64](f9_38)
-  var f4f4 = cast[int64](f4) * cast[int64](f4)
-  var f4f5_2 = cast[int64](f4_2) * cast[int64](f5)
-  var f4f6_38 = cast[int64](f4_2) * cast[int64](f6_19)
-  var f4f7_38 = cast[int64](f4) * cast[int64](f7_38)
-  var f4f8_38 = cast[int64](f4_2) * cast[int64](f8_19)
-  var f4f9_38 = cast[int64](f4) * cast[int64](f9_38)
-  var f5f5_38 = cast[int64](f5) * cast[int64](f5_38)
-  var f5f6_38 = cast[int64](f5_2) * cast[int64](f6_19)
-  var f5f7_76 = cast[int64](f5_2) * cast[int64](f7_38)
-  var f5f8_38 = cast[int64](f5_2) * cast[int64](f8_19)
-  var f5f9_76 = cast[int64](f5_2) * cast[int64](f9_38)
-  var f6f6_19 = cast[int64](f6) * cast[int64](f6_19)
-  var f6f7_38 = cast[int64](f6) * cast[int64](f7_38)
-  var f6f8_38 = cast[int64](f6_2) * cast[int64](f8_19)
-  var f6f9_38 = cast[int64](f6) * cast[int64](f9_38)
-  var f7f7_38 = cast[int64](f7) * cast[int64](f7_38)
-  var f7f8_38 = cast[int64](f7_2) * cast[int64](f8_19)
-  var f7f9_76 = cast[int64](f7_2) * cast[int64](f9_38)
-  var f8f8_19 = cast[int64](f8) * cast[int64](f8_19)
-  var f8f9_38 = cast[int64](f8) * cast[int64](f9_38)
-  var f9f9_38 = cast[int64](f9) * cast[int64](f9_38)
+  var f0f0 = safeConvert[int64](f0) * safeConvert[int64](f0)
+  var f0f1_2 = safeConvert[int64](f0_2) * safeConvert[int64](f1)
+  var f0f2_2 = safeConvert[int64](f0_2) * safeConvert[int64](f2)
+  var f0f3_2 = safeConvert[int64](f0_2) * safeConvert[int64](f3)
+  var f0f4_2 = safeConvert[int64](f0_2) * safeConvert[int64](f4)
+  var f0f5_2 = safeConvert[int64](f0_2) * safeConvert[int64](f5)
+  var f0f6_2 = safeConvert[int64](f0_2) * safeConvert[int64](f6)
+  var f0f7_2 = safeConvert[int64](f0_2) * safeConvert[int64](f7)
+  var f0f8_2 = safeConvert[int64](f0_2) * safeConvert[int64](f8)
+  var f0f9_2 = safeConvert[int64](f0_2) * safeConvert[int64](f9)
+  var f1f1_2 = safeConvert[int64](f1_2) * safeConvert[int64](f1)
+  var f1f2_2 = safeConvert[int64](f1_2) * safeConvert[int64](f2)
+  var f1f3_4 = safeConvert[int64](f1_2) * safeConvert[int64](f3_2)
+  var f1f4_2 = safeConvert[int64](f1_2) * safeConvert[int64](f4)
+  var f1f5_4 = safeConvert[int64](f1_2) * safeConvert[int64](f5_2)
+  var f1f6_2 = safeConvert[int64](f1_2) * safeConvert[int64](f6)
+  var f1f7_4 = safeConvert[int64](f1_2) * safeConvert[int64](f7_2)
+  var f1f8_2 = safeConvert[int64](f1_2) * safeConvert[int64](f8)
+  var f1f9_76 = safeConvert[int64](f1_2) * safeConvert[int64](f9_38)
+  var f2f2 = safeConvert[int64](f2) * safeConvert[int64](f2)
+  var f2f3_2 = safeConvert[int64](f2_2) * safeConvert[int64](f3)
+  var f2f4_2 = safeConvert[int64](f2_2) * safeConvert[int64](f4)
+  var f2f5_2 = safeConvert[int64](f2_2) * safeConvert[int64](f5)
+  var f2f6_2 = safeConvert[int64](f2_2) * safeConvert[int64](f6)
+  var f2f7_2 = safeConvert[int64](f2_2) * safeConvert[int64](f7)
+  var f2f8_38 = safeConvert[int64](f2_2) * safeConvert[int64](f8_19)
+  var f2f9_38 = safeConvert[int64](f2) * safeConvert[int64](f9_38)
+  var f3f3_2 = safeConvert[int64](f3_2) * safeConvert[int64](f3)
+  var f3f4_2 = safeConvert[int64](f3_2) * safeConvert[int64](f4)
+  var f3f5_4 = safeConvert[int64](f3_2) * safeConvert[int64](f5_2)
+  var f3f6_2 = safeConvert[int64](f3_2) * safeConvert[int64](f6)
+  var f3f7_76 = safeConvert[int64](f3_2) * safeConvert[int64](f7_38)
+  var f3f8_38 = safeConvert[int64](f3_2) * safeConvert[int64](f8_19)
+  var f3f9_76 = safeConvert[int64](f3_2) * safeConvert[int64](f9_38)
+  var f4f4 = safeConvert[int64](f4) * safeConvert[int64](f4)
+  var f4f5_2 = safeConvert[int64](f4_2) * safeConvert[int64](f5)
+  var f4f6_38 = safeConvert[int64](f4_2) * safeConvert[int64](f6_19)
+  var f4f7_38 = safeConvert[int64](f4) * safeConvert[int64](f7_38)
+  var f4f8_38 = safeConvert[int64](f4_2) * safeConvert[int64](f8_19)
+  var f4f9_38 = safeConvert[int64](f4) * safeConvert[int64](f9_38)
+  var f5f5_38 = safeConvert[int64](f5) * safeConvert[int64](f5_38)
+  var f5f6_38 = safeConvert[int64](f5_2) * safeConvert[int64](f6_19)
+  var f5f7_76 = safeConvert[int64](f5_2) * safeConvert[int64](f7_38)
+  var f5f8_38 = safeConvert[int64](f5_2) * safeConvert[int64](f8_19)
+  var f5f9_76 = safeConvert[int64](f5_2) * safeConvert[int64](f9_38)
+  var f6f6_19 = safeConvert[int64](f6) * safeConvert[int64](f6_19)
+  var f6f7_38 = safeConvert[int64](f6) * safeConvert[int64](f7_38)
+  var f6f8_38 = safeConvert[int64](f6_2) * safeConvert[int64](f8_19)
+  var f6f9_38 = safeConvert[int64](f6) * safeConvert[int64](f9_38)
+  var f7f7_38 = safeConvert[int64](f7) * safeConvert[int64](f7_38)
+  var f7f8_38 = safeConvert[int64](f7_2) * safeConvert[int64](f8_19)
+  var f7f9_76 = safeConvert[int64](f7_2) * safeConvert[int64](f9_38)
+  var f8f8_19 = safeConvert[int64](f8) * safeConvert[int64](f8_19)
+  var f8f9_38 = safeConvert[int64](f8) * safeConvert[int64](f9_38)
+  var f9f9_38 = safeConvert[int64](f9) * safeConvert[int64](f9_38)
   var
     c0, c1, c2, c3, c4, c5, c6, c7, c8, c9: int64
     h0: int64 = f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
@@ -834,7 +834,7 @@ proc geFromBytesNegateVartime(h: var GeP3, s: openArray[byte]): int32 =
       return -1;
     feMul(h.x, h.x, SqrTm1)
 
-  if feIsNegative(h.x) == cast[int32](s[31] shr 7):
+  if feIsNegative(h.x) == safeConvert[int32](s[31] shr 7):
     feNeg(h.x, h.x)
 
   feMul(h.t, h.x, h.y)
@@ -956,14 +956,14 @@ proc equal(b, c: int8): byte =
   var ub = cast[byte](b)
   var uc = cast[byte](c)
   var x = ub xor uc
-  var y = cast[uint32](x)
+  var y = safeConvert[uint32](x)
   y = y - 1
   y = y shr 31
   result = cast[byte](y)
 
 proc negative(b: int8): byte =
-  var x = cast[uint64](b)
-  x = x shr 63
+  var x = cast[uint8](b)
+  x = x shr 7
   result = cast[byte](x)
 
 proc cmov(t: var GePrecomp, u: GePrecomp, b: byte) =

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,13 +9,10 @@
 
 # https://tools.ietf.org/html/rfc5869
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import nimcrypto
-import bearssl/[kdf, rand, hash]
+import bearssl/[kdf, hash]
 
 type HkdfResult*[len: static int] = array[len, byte]
 

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,15 +9,13 @@
 
 ## This module implements minimal ASN.1 encoding/decoding primitives.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import stew/[endians2, results, ctops]
 export results
 # We use `ncrutils` for constant-time hexadecimal encoding/decoding procedures.
 import nimcrypto/utils as ncrutils
+import ../utility
 
 type
   Asn1Error* {.pure.} = enum
@@ -119,7 +117,7 @@ template toOpenArray*(af: Asn1Field): untyped =
 template isEmpty*(ab: Asn1Buffer): bool =
   ab.offset >= len(ab.buffer)
 
-template isEnough*(ab: Asn1Buffer, length: int): bool =
+template isEnough*(ab: Asn1Buffer, length: int64): bool =
   len(ab.buffer) >= ab.offset + length
 
 proc len*[T: Asn1Buffer|Asn1Composite](abc: T): int {.inline.} =
@@ -344,32 +342,6 @@ proc asn1EncodeTag[T: SomeUnsignedInt](dest: var openArray[byte],
       dest[k - 1] = dest[k - 1] and 0x7F'u8
     res
 
-proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[int]): int =
-  ## Encode array of integers ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and
-  ## return number of bytes (octets) used.
-  ##
-  ## If length of ``dest`` is less then number of required bytes to encode
-  ## ``value``, then result of encoding will not be stored in ``dest``
-  ## but number of bytes (octets) required will be returned.
-  var buffer: array[16, byte]
-  var res = 1
-  var oidlen = 1
-  for i in 2..<len(value):
-    oidlen += asn1EncodeTag(buffer, cast[uint64](value[i]))
-  res += asn1EncodeLength(buffer, uint64(oidlen))
-  res += oidlen
-  if len(dest) >= res:
-    let last = dest.high
-    var offset = 1
-    dest[0] = Asn1Tag.Oid.code()
-    offset += asn1EncodeLength(dest.toOpenArray(offset, last), uint64(oidlen))
-    dest[offset] = cast[byte](value[0] * 40 + value[1])
-    offset += 1
-    for i in 2..<len(value):
-      offset += asn1EncodeTag(dest.toOpenArray(offset, last),
-                              cast[uint64](value[i]))
-  res
-
 proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[byte]): int =
   ## Encode array of bytes ``value`` as ASN.1 DER `OBJECT IDENTIFIER` and return
   ## number of bytes (octets) used.
@@ -443,26 +415,29 @@ proc asn1EncodeContextTag*(dest: var openArray[byte], value: openArray[byte],
     copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
   res
 
-proc getLength(ab: var Asn1Buffer): Asn1Result[uint64] =
+proc getLength(ab: var Asn1Buffer): Asn1Result[int] =
   ## Decode length part of ASN.1 TLV triplet.
   if not ab.isEmpty():
     let b = ab.buffer[ab.offset]
     if (b and 0x80'u8) == 0x00'u8:
-      let length = cast[uint64](b)
+      let length = safeConvert[int](b)
       ab.offset += 1
       return ok(length)
     if b == 0x80'u8:
       return err(Asn1Error.Indefinite)
     if b == 0xFF'u8:
       return err(Asn1Error.Incorrect)
-    let octets = cast[uint64](b and 0x7F'u8)
-    if octets > 8'u64:
+    let octets = safeConvert[int](b and 0x7F'u8)
+    if octets > 8:
       return err(Asn1Error.Overflow)
-    if ab.isEnough(int(octets)):
-      var length: uint64 = 0
-      for i in 0..<int(octets):
-        length = (length shl 8) or cast[uint64](ab.buffer[ab.offset + i + 1])
-      ab.offset = ab.offset + int(octets) + 1
+    if ab.isEnough(octets):
+      var lengthU: uint64 = 0
+      for i in 0..<octets:
+        lengthU = (lengthU shl 8) or safeConvert[uint64](ab.buffer[ab.offset + i + 1])
+      if lengthU > uint64(int64.high):
+        return err(Asn1Error.Overflow)
+      let length = int(lengthU)
+      ab.offset = ab.offset + octets + 1
       return ok(length)
     else:
       return err(Asn1Error.Incomplete)
@@ -474,8 +449,8 @@ proc getTag(ab: var Asn1Buffer, tag: var int): Asn1Result[Asn1Class] =
   if not ab.isEmpty():
     let
       b = ab.buffer[ab.offset]
-      c = int((b and 0xC0'u8) shr 6)
-    tag = int(b and 0x3F)
+      c = safeConvert[int]((b and 0xC0'u8) shr 6)
+    tag = safeConvert[int](b and 0x3F)
     ab.offset += 1
     if c >= 0 and c < 4:
       ok(cast[Asn1Class](c))
@@ -489,7 +464,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
   var
     field: Asn1Field
     tag, ttag, offset: int
-    length, tlength: uint64
+    length, tlength: int
     aclass: Asn1Class
     inclass: bool
 
@@ -519,7 +494,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
         if length != 1:
           return err(Asn1Error.Incorrect)
 
-        if not ab.isEnough(int(length)):
+        if not ab.isEnough(length):
           return err(Asn1Error.Incomplete)
 
         let b = ab.buffer[ab.offset]
@@ -527,9 +502,8 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
            return err(Asn1Error.Incorrect)
 
         field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass,
-                          index: ttag, offset: int(ab.offset),
-                          length: 1)
-        shallowCopy(field.buffer, ab.buffer)
+                          index: ttag, offset: ab.offset,
+                          length: 1, buffer: ab.buffer)
         field.vbool = (b == 0xFF'u8)
         ab.offset += 1
         return ok(field)
@@ -539,12 +513,12 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
         if length == 0:
           return err(Asn1Error.Incorrect)
 
-        if not ab.isEnough(int(length)):
+        if not ab.isEnough(length):
          return err(Asn1Error.Incomplete)
 
         # Count number of leading zeroes
         var zc = 0
-        while (zc < int(length)) and (ab.buffer[ab.offset + zc] == 0x00'u8):
+        while (zc < length) and (ab.buffer[ab.offset + zc] == 0x00'u8):
           inc(zc)
 
         if zc > 1:
@@ -553,47 +527,45 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
         if zc == 0:
           # Negative or Positive integer
           field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
-                            index: ttag, offset: int(ab.offset),
-                            length: int(length))
-          shallowCopy(field.buffer, ab.buffer)
+                            index: ttag, offset: ab.offset,
+                            length: length, buffer: ab.buffer)
           if (ab.buffer[ab.offset] and 0x80'u8) == 0x80'u8:
             # Negative integer
             if length <= 8:
               # We need this transformation because our field.vint is uint64.
               for i in 0 ..< 8:
-                if i < 8 - int(length):
+                if i < 8 - length:
                   field.vint = (field.vint shl 8) or 0xFF'u64
                 else:
-                  let offset = ab.offset + i - (8 - int(length))
-                  field.vint = (field.vint shl 8) or uint64(ab.buffer[offset])
+                  let offset = ab.offset + i - (8 - length)
+                  field.vint = (field.vint shl 8) or safeConvert[uint64](ab.buffer[offset])
           else:
             # Positive integer
             if length <= 8:
-              for i in 0 ..< int(length):
+              for i in 0 ..< length:
                 field.vint = (field.vint shl 8) or
-                              uint64(ab.buffer[ab.offset + i])
-          ab.offset += int(length)
+                              safeConvert[uint64](ab.buffer[ab.offset + i])
+          ab.offset += length
           return ok(field)
         else:
           if length == 1:
             # 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)
-            ab.offset += int(length)
+                              index: ttag, offset: ab.offset,
+                              length: length, vint: 0'u64,
+                              buffer: ab.buffer)
+            ab.offset += 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)
+                              index: ttag, offset: ab.offset + 1,
+                              length: length - 1, buffer: ab.buffer)
             if length <= 9:
-              for i in 1 ..< int(length):
+              for i in 1 ..< length:
                 field.vint = (field.vint shl 8) or
-                              uint64(ab.buffer[ab.offset + i])
-            ab.offset += int(length)
+                              safeConvert[uint64](ab.buffer[ab.offset + i])
+            ab.offset += length
             return ok(field)
 
       of Asn1Tag.BitString.code():
@@ -609,14 +581,13 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
           else:
             # 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)
-            ab.offset += int(length)
+                              index: ttag, offset: ab.offset + 1,
+                              length: 0, ubits: 0, buffer: ab.buffer)
+            ab.offset += length
             return ok(field)
 
         else:
-          if not ab.isEnough(int(length)):
+          if not ab.isEnough(length):
             return err(Asn1Error.Incomplete)
 
           let unused = ab.buffer[ab.offset]
@@ -624,28 +595,27 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
             # Number of unused bits should not be bigger then `7`.
             return err(Asn1Error.Incorrect)
 
-          let mask = (1'u8 shl int(unused)) - 1'u8
-          if (ab.buffer[ab.offset + int(length) - 1] and mask) != 0x00'u8:
+          let mask = (1'u8 shl safeConvert[int](unused)) - 1'u8
+          if (ab.buffer[ab.offset + length - 1] and mask) != 0x00'u8:
             ## All unused bits should be set to `0`.
             return err(Asn1Error.Incorrect)
 
           field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
-                            index: ttag, offset: int(ab.offset + 1),
-                            length: int(length - 1), ubits: int(unused))
-          shallowCopy(field.buffer, ab.buffer)
-          ab.offset += int(length)
+                            index: ttag, offset: ab.offset + 1,
+                            length: length - 1, ubits: safeConvert[int](unused),
+                            buffer: ab.buffer)
+          ab.offset += length
           return ok(field)
 
       of Asn1Tag.OctetString.code():
         # OCTET STRING
-        if not ab.isEnough(int(length)):
+        if not ab.isEnough(length):
           return err(Asn1Error.Incomplete)
 
         field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass,
-                          index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
-        ab.offset += int(length)
+                          index: ttag, offset: ab.offset,
+                          length: length, buffer: ab.buffer)
+        ab.offset += length
         return ok(field)
 
       of Asn1Tag.Null.code():
@@ -654,33 +624,30 @@ 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)
-        ab.offset += int(length)
+                          offset: ab.offset, length: 0, buffer: ab.buffer)
+        ab.offset += length
         return ok(field)
 
       of Asn1Tag.Oid.code():
         # OID
-        if not ab.isEnough(int(length)):
+        if not ab.isEnough(length):
           return err(Asn1Error.Incomplete)
 
         field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass,
-                          index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
-        ab.offset += int(length)
+                          index: ttag, offset: ab.offset,
+                          length: length, buffer: ab.buffer)
+        ab.offset += length
         return ok(field)
 
       of Asn1Tag.Sequence.code():
         # SEQUENCE
-        if not ab.isEnough(int(length)):
+        if not ab.isEnough(length):
           return err(Asn1Error.Incomplete)
 
         field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass,
-                          index: ttag, offset: int(ab.offset),
-                          length: int(length))
-        shallowCopy(field.buffer, ab.buffer)
-        ab.offset += int(length)
+                          index: ttag, offset: ab.offset,
+                          length: length, buffer: ab.buffer)
+        ab.offset += length
         return ok(field)
 
       else:

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,10 +13,7 @@
 ## BearSSL library <https://bearssl.org/>
 ## Copyright(C) 2018 Thomas Pornin <pornin@bolet.org>.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import bearssl/[rsa, rand, hash]
 import minasn1
@@ -686,7 +683,7 @@ proc `==`*(a, b: RsaPrivateKey): bool =
     false
   else:
     if a.seck.nBitlen == b.seck.nBitlen:
-      if cast[int](a.seck.nBitlen) > 0:
+      if a.seck.nBitlen > 0'u:
         let r1 = CT.isEqual(getArray(a.buffer, a.seck.p, a.seck.plen),
                             getArray(b.buffer, b.seck.p, b.seck.plen))
         let r2 = CT.isEqual(getArray(a.buffer, a.seck.q, a.seck.qlen),

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,10 +7,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import bearssl/rand
 import
@@ -35,9 +32,6 @@ type
   SkSignature* = distinct secp256k1.SkSignature
   SkKeyPair* = distinct secp256k1.SkKeyPair
 
-template pubkey*(v: SkKeyPair): SkPublicKey = SkPublicKey(secp256k1.SkKeyPair(v).pubkey)
-template seckey*(v: SkKeyPair): SkPrivateKey = SkPrivateKey(secp256k1.SkKeyPair(v).seckey)
-
 proc random*(t: typedesc[SkPrivateKey], rng: var HmacDrbgContext): SkPrivateKey =
   #TODO is there a better way?
   var rngPtr = addr rng

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,17 +7,14 @@
 # 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: [].}
+{.push raises: [].}
 
 ## This module implementes API for `go-libp2p-daemon`.
 import std/[os, osproc, strutils, tables, strtabs, sequtils]
 import pkg/[chronos, chronicles]
 import ../varint, ../multiaddress, ../multicodec, ../cid, ../peerid
 import ../wire, ../multihash, ../protobuf/minprotobuf, ../errors
-import ../crypto/crypto
+import ../crypto/crypto, ../utility
 
 export
   peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors
@@ -153,10 +150,10 @@ type
     key*: PublicKey
 
   P2PStreamCallback* = proc(api: DaemonAPI,
-                            stream: P2PStream): Future[void] {.gcsafe, raises: [Defect, CatchableError].}
+                            stream: P2PStream): Future[void] {.gcsafe, raises: [CatchableError].}
   P2PPubSubCallback* = proc(api: DaemonAPI,
                             ticket: PubsubTicket,
-                            message: PubSubMessage): Future[bool] {.gcsafe, raises: [Defect, CatchableError].}
+                            message: PubSubMessage): Future[bool] {.gcsafe, raises: [CatchableError].}
 
   DaemonError* = object of LPError
   DaemonRemoteError* = object of DaemonError
@@ -170,7 +167,7 @@ proc requestIdentity(): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
   ## Processing function `doIdentify(req *pb.Request)`.
   result = initProtoBuffer({WithVarintLength})
-  result.write(1, cast[uint](RequestType.IDENTIFY))
+  result.write(1, safeConvert[uint](RequestType.IDENTIFY))
   result.finish()
 
 proc requestConnect(peerid: PeerId,
@@ -185,7 +182,7 @@ proc requestConnect(peerid: PeerId,
     msg.write(2, item.data.buffer)
   if timeout > 0:
     msg.write(3, hint64(timeout))
-  result.write(1, cast[uint](RequestType.CONNECT))
+  result.write(1, safeConvert[uint](RequestType.CONNECT))
   result.write(2, msg)
   result.finish()
 
@@ -195,7 +192,7 @@ proc requestDisconnect(peerid: PeerId): ProtoBuffer =
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, peerid)
-  result.write(1, cast[uint](RequestType.DISCONNECT))
+  result.write(1, safeConvert[uint](RequestType.DISCONNECT))
   result.write(7, msg)
   result.finish()
 
@@ -211,7 +208,7 @@ proc requestStreamOpen(peerid: PeerId,
     msg.write(2, item)
   if timeout > 0:
     msg.write(3, hint64(timeout))
-  result.write(1, cast[uint](RequestType.STREAM_OPEN))
+  result.write(1, safeConvert[uint](RequestType.STREAM_OPEN))
   result.write(3, msg)
   result.finish()
 
@@ -224,7 +221,7 @@ proc requestStreamHandler(address: MultiAddress,
   msg.write(1, address.data.buffer)
   for item in protocols:
     msg.write(2, item)
-  result.write(1, cast[uint](RequestType.STREAM_HANDLER))
+  result.write(1, safeConvert[uint](RequestType.STREAM_HANDLER))
   result.write(4, msg)
   result.finish()
 
@@ -232,13 +229,13 @@ proc requestListPeers(): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
   ## Processing function `doListPeers(req *pb.Request)`
   result = initProtoBuffer({WithVarintLength})
-  result.write(1, cast[uint](RequestType.LIST_PEERS))
+  result.write(1, safeConvert[uint](RequestType.LIST_PEERS))
   result.finish()
 
 proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTFindPeer(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.FIND_PEER)
+  let msgid = safeConvert[uint](DHTRequestType.FIND_PEER)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -246,7 +243,7 @@ proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
@@ -254,7 +251,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
                                         timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTFindPeersConnectedToPeer(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
+  let msgid = safeConvert[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -262,7 +259,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
@@ -270,7 +267,7 @@ proc requestDHTFindProviders(cid: Cid,
                              count: uint32, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTFindProviders(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.FIND_PROVIDERS)
+  let msgid = safeConvert[uint](DHTRequestType.FIND_PROVIDERS)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -279,14 +276,14 @@ proc requestDHTFindProviders(cid: Cid,
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTGetClosestPeers(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.GET_CLOSEST_PEERS)
+  let msgid = safeConvert[uint](DHTRequestType.GET_CLOSEST_PEERS)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -294,14 +291,14 @@ proc requestDHTGetClosestPeers(key: string, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTGetPublicKey(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.GET_PUBLIC_KEY)
+  let msgid = safeConvert[uint](DHTRequestType.GET_PUBLIC_KEY)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -309,14 +306,14 @@ proc requestDHTGetPublicKey(peer: PeerId, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTGetValue(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.GET_VALUE)
+  let msgid = safeConvert[uint](DHTRequestType.GET_VALUE)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -324,14 +321,14 @@ proc requestDHTGetValue(key: string, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTSearchValue(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.SEARCH_VALUE)
+  let msgid = safeConvert[uint](DHTRequestType.SEARCH_VALUE)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -339,7 +336,7 @@ proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
@@ -347,7 +344,7 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
                         timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTPutValue(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.PUT_VALUE)
+  let msgid = safeConvert[uint](DHTRequestType.PUT_VALUE)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -356,14 +353,14 @@ proc requestDHTPutValue(key: string, value: openArray[byte],
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, uint(RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTProvide(req *pb.DHTRequest)`.
-  let msgid = cast[uint](DHTRequestType.PROVIDE)
+  let msgid = safeConvert[uint](DHTRequestType.PROVIDE)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -371,13 +368,13 @@ proc requestDHTProvide(cid: Cid, timeout = 0): ProtoBuffer =
   if timeout > 0:
     msg.write(7, hint64(timeout))
   msg.finish()
-  result.write(1, cast[uint](RequestType.DHT))
+  result.write(1, safeConvert[uint](RequestType.DHT))
   result.write(5, msg)
   result.finish()
 
 proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L18
-  let msgid = cast[uint](ConnManagerRequestType.TAG_PEER)
+  let msgid = safeConvert[uint](ConnManagerRequestType.TAG_PEER)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
@@ -385,83 +382,83 @@ proc requestCMTagPeer(peer: PeerId, tag: string, weight: int): ProtoBuffer =
   msg.write(3, tag)
   msg.write(4, hint64(weight))
   msg.finish()
-  result.write(1, cast[uint](RequestType.CONNMANAGER))
+  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
   result.write(6, msg)
   result.finish()
 
 proc requestCMUntagPeer(peer: PeerId, tag: string): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L33
-  let msgid = cast[uint](ConnManagerRequestType.UNTAG_PEER)
+  let msgid = safeConvert[uint](ConnManagerRequestType.UNTAG_PEER)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.write(2, peer)
   msg.write(3, tag)
   msg.finish()
-  result.write(1, cast[uint](RequestType.CONNMANAGER))
+  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
   result.write(6, msg)
   result.finish()
 
 proc requestCMTrim(): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/connmgr.go#L47
-  let msgid = cast[uint](ConnManagerRequestType.TRIM)
+  let msgid = safeConvert[uint](ConnManagerRequestType.TRIM)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.finish()
-  result.write(1, cast[uint](RequestType.CONNMANAGER))
+  result.write(1, safeConvert[uint](RequestType.CONNMANAGER))
   result.write(6, msg)
   result.finish()
 
 proc requestPSGetTopics(): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
   ## Processing function `doPubsubGetTopics(req *pb.PSRequest)`.
-  let msgid = cast[uint](PSRequestType.GET_TOPICS)
+  let msgid = safeConvert[uint](PSRequestType.GET_TOPICS)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.finish()
-  result.write(1, cast[uint](RequestType.PUBSUB))
+  result.write(1, safeConvert[uint](RequestType.PUBSUB))
   result.write(8, msg)
   result.finish()
 
 proc requestPSListPeers(topic: string): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
   ## Processing function `doPubsubListPeers(req *pb.PSRequest)`.
-  let msgid = cast[uint](PSRequestType.LIST_PEERS)
+  let msgid = safeConvert[uint](PSRequestType.LIST_PEERS)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.write(2, topic)
   msg.finish()
-  result.write(1, cast[uint](RequestType.PUBSUB))
+  result.write(1, safeConvert[uint](RequestType.PUBSUB))
   result.write(8, msg)
   result.finish()
 
 proc requestPSPublish(topic: string, data: openArray[byte]): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
   ## Processing function `doPubsubPublish(req *pb.PSRequest)`.
-  let msgid = cast[uint](PSRequestType.PUBLISH)
+  let msgid = safeConvert[uint](PSRequestType.PUBLISH)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.write(2, topic)
   msg.write(3, data)
   msg.finish()
-  result.write(1, cast[uint](RequestType.PUBSUB))
+  result.write(1, safeConvert[uint](RequestType.PUBSUB))
   result.write(8, msg)
   result.finish()
 
 proc requestPSSubscribe(topic: string): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/pubsub.go
   ## Processing function `doPubsubSubscribe(req *pb.PSRequest)`.
-  let msgid = cast[uint](PSRequestType.SUBSCRIBE)
+  let msgid = safeConvert[uint](PSRequestType.SUBSCRIBE)
   result = initProtoBuffer({WithVarintLength})
   var msg = initProtoBuffer()
   msg.write(1, msgid)
   msg.write(2, topic)
   msg.finish()
-  result.write(1, cast[uint](RequestType.PUBSUB))
+  result.write(1, safeConvert[uint](RequestType.PUBSUB))
   result.write(8, msg)
   result.finish()
 
@@ -474,7 +471,7 @@ proc checkResponse(pb: ProtoBuffer): ResponseKind {.inline.} =
     else:
       result = ResponseKind.Error
 
-proc getErrorMessage(pb: ProtoBuffer): string {.inline, raises: [Defect, DaemonLocalError].} =
+proc getErrorMessage(pb: ProtoBuffer): string {.inline, raises: [DaemonLocalError].} =
   var error: seq[byte]
   if pb.getRequiredField(ResponseType.ERROR.int, error).isOk():
     if initProtoBuffer(error).getRequiredField(1, result).isErr():
@@ -492,7 +489,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
@@ -504,7 +501,7 @@ proc recvMessage(conn: StreamTransport): Future[seq[byte]] {.async.} =
   result = buffer
 
 proc newConnection*(api: DaemonAPI): Future[StreamTransport]
-  {.raises: [Defect, LPError].} =
+  {.raises: [LPError].} =
   result = connect(api.address)
 
 proc closeConnection*(api: DaemonAPI, transp: StreamTransport): Future[void] =
@@ -515,7 +512,7 @@ proc socketExists(address: MultiAddress): Future[bool] {.async.} =
     var transp = await connect(address)
     await transp.closeWait()
     result = true
-  except:
+  except CatchableError:
     result = false
 
 when defined(windows):
@@ -525,7 +522,7 @@ when defined(windows):
     result = cast[int](getCurrentProcessId())
 else:
   proc getProcessId(): int =
-    result = cast[int](posix.getpid())
+    result = int(posix.getpid())
 
 proc getSocket(pattern: string,
                count: ptr int): Future[MultiAddress] {.async.} =
@@ -759,12 +756,8 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
   # Starting daemon process
   # echo "Starting ", cmd, " ", args.join(" ")
   api.process = 
-    try:
+    exceptionToAssert:
       startProcess(cmd, "", args, env, {poParentStreams})
-    except CatchableError as exc:
-      raise exc
-    except Exception as exc:
-      raiseAssert exc.msg
   # Waiting until daemon will not be bound to control socket.
   while true:
     if not api.process.running():
@@ -841,7 +834,7 @@ proc transactMessage(transp: StreamTransport,
   result = initProtoBuffer(message)
 
 proc getPeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [Defect, DaemonLocalError].} =
+  {.raises: [DaemonLocalError].} =
   ## Get PeerInfo object from ``pb``.
   result.addresses = newSeq[MultiAddress]()
   if pb.getRequiredField(1, result.peer).isErr():
@@ -872,7 +865,7 @@ proc connect*(api: DaemonAPI, peer: PeerId,
                                                          timeout))
     pb.withMessage() do:
       discard
-  except:
+  except CatchableError:
     await api.closeConnection(transp)
 
 proc disconnect*(api: DaemonAPI, peer: PeerId) {.async.} =
@@ -932,7 +925,7 @@ proc streamHandler(server: StreamServer, transp: StreamTransport) {.async.} =
       asyncSpawn handler(api, stream)
 
 proc addHandler*(api: DaemonAPI, protocols: seq[string],
-                 handler: P2PStreamCallback) {.async, raises: [Defect, LPError].} =
+                 handler: P2PStreamCallback) {.async, raises: [LPError].} =
   ## Add stream handler ``handler`` for set of protocols ``protocols``.
   var transp = await api.newConnection()
   let maddress = await getSocket(api.pattern, addr api.ucounter)
@@ -1002,7 +995,7 @@ proc cmTrimPeers*(api: DaemonAPI) {.async.} =
     await api.closeConnection(transp)
 
 proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [Defect, DaemonLocalError].} =
+  {.raises: [DaemonLocalError].} =
   var res: seq[byte]
   if pb.getRequiredField(2, res).isOk():
     result = initProtoBuffer(res).getPeerInfo()
@@ -1010,30 +1003,30 @@ proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo
     raise newException(DaemonLocalError, "Missing required field `peer`!")
 
 proc dhtGetSingleValue(pb: ProtoBuffer): seq[byte]
-  {.raises: [Defect, DaemonLocalError].} =
+  {.raises: [DaemonLocalError].} =
   result = newSeq[byte]()
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
 proc dhtGetSinglePublicKey(pb: ProtoBuffer): PublicKey
-  {.raises: [Defect, DaemonLocalError].} =
+  {.raises: [DaemonLocalError].} =
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
 proc dhtGetSinglePeerId(pb: ProtoBuffer): PeerId
-  {.raises: [Defect, DaemonLocalError].} =
+  {.raises: [DaemonLocalError].} =
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
 proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
-  {.inline, raises: [Defect, DaemonLocalError].} =
+  {.inline, raises: [DaemonLocalError].} =
   var dhtResponse: seq[byte]
   if pb.getRequiredField(ResponseType.DHT.int, dhtResponse).isOk():
     var pbDhtResponse = initProtoBuffer(dhtResponse)
     var dtype: uint
     if pbDhtResponse.getRequiredField(1, dtype).isErr():
       raise newException(DaemonLocalError, "Missing required DHT field `type`!")
-    if dtype != cast[uint](rt):
+    if dtype != safeConvert[uint](rt):
       raise newException(DaemonLocalError, "Wrong DHT answer type! ")
 
     var value: seq[byte]
@@ -1045,7 +1038,7 @@ proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
     raise newException(DaemonLocalError, "Wrong message type!")
 
 proc enterPsMessage(pb: ProtoBuffer): ProtoBuffer
-  {.inline, raises: [Defect, DaemonLocalError].} =
+  {.inline, raises: [DaemonLocalError].} =
   var res: seq[byte]
   if pb.getRequiredField(ResponseType.PUBSUB.int, res).isErr():
     raise newException(DaemonLocalError, "Wrong message type!")
@@ -1053,13 +1046,13 @@ proc enterPsMessage(pb: ProtoBuffer): ProtoBuffer
   initProtoBuffer(res)
 
 proc getDhtMessageType(pb: ProtoBuffer): DHTResponseType
-  {.inline, raises: [Defect, DaemonLocalError].} =
+  {.inline, raises: [DaemonLocalError].} =
   var dtype: uint
   if pb.getRequiredField(1, dtype).isErr():
     raise newException(DaemonLocalError, "Missing required DHT field `type`!")
-  if dtype == cast[uint](DHTResponseType.VALUE):
+  if dtype == safeConvert[uint](DHTResponseType.VALUE):
     result = DHTResponseType.VALUE
-  elif dtype == cast[uint](DHTResponseType.END):
+  elif dtype == safeConvert[uint](DHTResponseType.END):
     result = DHTResponseType.END
   else:
     raise newException(DaemonLocalError, "Wrong DHT answer type!")

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,10 +7,7 @@
 # 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: [].}
+{.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))
@@ -25,7 +25,7 @@
 ##   5. LocalAddress: optional bytes
 ##   6. RemoteAddress: optional bytes
 ##   7. Message: required bytes
-import os, options
+import os
 import nimcrypto/utils, stew/endians2
 import protobuf/minprotobuf, stream/connection, protocols/secure/secure,
        multiaddress, peerid, varint, muxers/mplex/coder
@@ -33,7 +33,7 @@ import protobuf/minprotobuf, stream/connection, protocols/secure/secure,
 from times import getTime, toUnix, fromUnix, nanosecond, format, Time,
                   NanosecondRange, initTime
 from strutils import toHex, repeat
-export peerid, options, multiaddress
+export peerid, multiaddress
 
 type
   FlowDirection* = enum
@@ -43,10 +43,10 @@ type
     timestamp*: uint64
     direction*: FlowDirection
     message*: seq[byte]
-    seqID*: Option[uint64]
-    mtype*: Option[uint64]
-    local*: Option[MultiAddress]
-    remote*: Option[MultiAddress]
+    seqID*: Opt[uint64]
+    mtype*: Opt[uint64]
+    local*: Opt[MultiAddress]
+    remote*: Opt[MultiAddress]
 
 const
   libp2p_dump_dir* {.strdefine.} = "nim-libp2p"
@@ -72,7 +72,8 @@ proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
   var pb = initProtoBuffer(options = {WithVarintLength})
   pb.write(2, getTimestamp())
   pb.write(4, uint64(direction))
-  pb.write(6, conn.observedAddr)
+  conn.observedAddr.withValue(oaddr):
+    pb.write(6, oaddr)
   pb.write(7, data)
   pb.finish()
 
@@ -100,7 +101,7 @@ proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
   finally:
     close(handle)
 
-proc decodeDumpMessage*(data: openArray[byte]): Option[ProtoMessage] =
+proc decodeDumpMessage*(data: openArray[byte]): Opt[ProtoMessage] =
   ## Decode protobuf's message ProtoMessage from array of bytes ``data``.
   var
     pb = initProtoBuffer(data)
@@ -108,13 +109,12 @@ proc decodeDumpMessage*(data: openArray[byte]): Option[ProtoMessage] =
     ma1, ma2: MultiAddress
     pmsg: ProtoMessage
 
-  let res2 = pb.getField(2, pmsg.timestamp)
-  if res2.isErr() or not(res2.get()):
-    return none[ProtoMessage]()
-
-  let res4 = pb.getField(4, value)
-  if res4.isErr() or not(res4.get()):
-    return none[ProtoMessage]()
+  let
+    r2 = pb.getField(2, pmsg.timestamp)
+    r4 = pb.getField(4, value)
+    r7 = pb.getField(7, pmsg.message)
+  if not r2.get(false) or not r4.get(false) or not r7.get(false):
+    return Opt.none(ProtoMessage)
 
   # `case` statement could not work here with an error "selector must be of an
   # ordinal type, float or string"
@@ -124,30 +124,27 @@ proc decodeDumpMessage*(data: openArray[byte]): Option[ProtoMessage] =
     elif value == uint64(Incoming):
       Incoming
     else:
-      return none[ProtoMessage]()
+      return Opt.none(ProtoMessage)
 
-  let res7 = pb.getField(7, pmsg.message)
-  if res7.isErr() or not(res7.get()):
-    return none[ProtoMessage]()
+  let r1 = pb.getField(1, value)
+  if r1.get(false):
+    pmsg.seqID = Opt.some(value)
 
-  value = 0'u64
-  let res1 = pb.getField(1, value)
-  if res1.isOk() and res1.get():
-    pmsg.seqID = some(value)
-  value = 0'u64
-  let res3 = pb.getField(3, value)
-  if res3.isOk() and res3.get():
-    pmsg.mtype = some(value)
-  let res5 = pb.getField(5, ma1)
-  if res5.isOk() and res5.get():
-    pmsg.local = some(ma1)
-  let res6 = pb.getField(6, ma2)
-  if res6.isOk() and res6.get():
-    pmsg.remote = some(ma2)
+  let r3 = pb.getField(3, value)
+  if r3.get(false):
+    pmsg.mtype = Opt.some(value)
 
-  some(pmsg)
+  let
+    r5 = pb.getField(5, ma1)
+    r6 = pb.getField(6, ma2)
+  if r5.get(false):
+    pmsg.local = Opt.some(ma1)
+  if r6.get(false):
+    pmsg.remote = Opt.some(ma2)
 
-iterator messages*(data: seq[byte]): Option[ProtoMessage] =
+  Opt.some(pmsg)
+
+iterator messages*(data: seq[byte]): Opt[ProtoMessage] =
   ## Iterate over sequence of bytes and decode all the ``ProtoMessage``
   ## messages we found.
   var value: uint64
@@ -242,27 +239,19 @@ proc toString*(msg: ProtoMessage, dump = true): string =
       " >> "
   let address =
     block:
-      let local =
-        if msg.local.isSome():
-          "[" & $(msg.local.get()) & "]"
-        else:
-          "[LOCAL]"
-      let remote =
-        if msg.remote.isSome():
-          "[" & $(msg.remote.get()) & "]"
-        else:
-          "[REMOTE]"
+      let local = block:
+        msg.local.withValue(loc): "[" & $loc & "]"
+        else: "[LOCAL]"
+      let remote = block:
+        msg.remote.withValue(rem): "[" & $rem & "]"
+        else: "[REMOTE]"
       local & direction & remote
-  let seqid =
-    if msg.seqID.isSome():
-      "seqID = " & $(msg.seqID.get()) & " "
-    else:
-      ""
-  let mtype =
-    if msg.mtype.isSome():
-      "type = " & $(msg.mtype.get()) & " "
-    else:
-      ""
+  let seqid = block:
+    msg.seqID.wihValue(seqid): "seqID = " & $seqid & " "
+    else: ""
+  let mtype = block:
+    msg.mtype.withValue(typ): "type = " & $typ & " "
+    else: ""
   res.add(" ")
   res.add(address)
   res.add(" ")

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,16 +7,16 @@
 # 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: [].}
+{.push raises: [].}
 
 import chronos
+import stew/results
 import peerid,
        stream/connection,
        transports/transport
 
+export results
+
 type
   Dial* = ref object of RootObj
 
@@ -24,7 +24,9 @@ method connect*(
   self: Dial,
   peerId: PeerId,
   addrs: seq[MultiAddress],
-  forceDial = false) {.async, base.} =
+  forceDial = false,
+  reuseConnection = true,
+  upgradeDir = Direction.Out) {.async, base.} =
   ## connect remote peer without negotiating
   ## a protocol
   ##
@@ -33,7 +35,8 @@ method connect*(
 
 method connect*(
   self: Dial,
-  addrs: seq[MultiAddress]): Future[PeerId] {.async, base.} =
+  address: MultiAddress,
+  allowUnknownPeerId = false): Future[PeerId] {.async, base.} =
   ## Connects to a peer and retrieve its PeerId
 
   doAssert(false, "Not implemented!")
@@ -69,5 +72,5 @@ method addTransport*(
 method tryDial*(
   self: Dial,
   peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[MultiAddress] {.async, base.} =
+  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/tables
 
+import stew/results
 import pkg/[chronos,
             chronicles,
             metrics]
@@ -16,6 +17,9 @@ import pkg/[chronos,
 import dial,
        peerid,
        peerinfo,
+       peerstore,
+       multicodec,
+       muxers/muxer,
        multistream,
        connmanager,
        stream/connection,
@@ -24,7 +28,7 @@ import dial,
        upgrademngrs/upgrade,
        errors
 
-export dial, errors
+export dial, errors, results
 
 logScope:
   topics = "libp2p dialer"
@@ -32,76 +36,136 @@ logScope:
 declareCounter(libp2p_total_dial_attempts, "total attempted dials")
 declareCounter(libp2p_successful_dials, "dialed successful peers")
 declareCounter(libp2p_failed_dials, "failed dials")
-declareCounter(libp2p_failed_upgrades_outgoing, "outgoing connections failed upgrades")
 
 type
   DialFailedError* = object of LPError
 
   Dialer* = ref object of Dial
     localPeerId*: PeerId
-    ms: MultistreamSelect
     connManager: ConnManager
     dialLock: Table[PeerId, AsyncLock]
     transports: seq[Transport]
+    peerStore: PeerStore
     nameResolver: NameResolver
 
 proc dialAndUpgrade(
   self: Dialer,
   peerId: Opt[PeerId],
-  addrs: seq[MultiAddress]):
-  Future[Connection] {.async.} =
-  debug "Dialing peer", peerId
+  hostname: string,
+  address: MultiAddress,
+  upgradeDir = Direction.Out):
+  Future[Muxer] {.async.} =
 
-  for address in addrs:      # for each address
-    let
-      hostname = address.getHostname()
-      resolvedAddresses =
-        if isNil(self.nameResolver): @[address]
-        else: await self.nameResolver.resolveMAddress(address)
+  for transport in self.transports: # for each transport
+    if transport.handles(address):   # check if it can dial it
+      trace "Dialing address", address, peerId = peerId.get(default(PeerId)), hostname
+      let dialed =
+        try:
+          libp2p_total_dial_attempts.inc()
+          await transport.dial(hostname, address, peerId)
+        except CancelledError as exc:
+          debug "Dialing canceled", err = exc.msg, peerId = peerId.get(default(PeerId))
+          raise exc
+        except CatchableError as exc:
+          debug "Dialing failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          libp2p_failed_dials.inc()
+          return nil # Try the next address
 
-    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 transport.dial(hostname, a)
-            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
+      libp2p_successful_dials.inc()
 
-          # also keep track of the connection's bottom unsafe transport direction
-          # required by gossipsub scoring
-          dialed.transportDir = Direction.Out
+      let mux =
+        try:
+          dialed.transportDir = upgradeDir
+          await transport.upgrade(dialed, upgradeDir, peerId)
+        except CatchableError as exc:
+          # If we failed to establish the connection through one transport,
+          # we won't succeeded through another - no use in trying again
+          await dialed.close()
+          debug "Upgrade failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          if exc isnot CancelledError:
+            if upgradeDir == Direction.Out:
+              libp2p_failed_upgrades_outgoing.inc()
+            else:
+              libp2p_failed_upgrades_incoming.inc()
 
-          libp2p_successful_dials.inc()
+          # Try other address
+          return nil
 
-          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
-              # TODO we should try another address though
-              await dialed.close()
-              debug "Upgrade failed", msg = exc.msg, peerId
-              if exc isnot CancelledError:
-                libp2p_failed_upgrades_outgoing.inc()
-              raise exc
+      doAssert not isNil(mux), "connection died after upgrade " & $upgradeDir
+      debug "Dial successful", peerId = mux.connection.peerId
+      return mux
+  return nil
 
-          doAssert not isNil(conn), "connection died after upgradeOutgoing"
-          debug "Dial successful", conn, peerId = conn.peerId
-          return conn
+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],
+  upgradeDir = Direction.Out):
+  Future[Muxer] {.async.} =
+
+  debug "Dialing peer", peerId = peerId.get(default(PeerId))
+
+  for rawAddress in addrs:
+    # resolve potential dnsaddr
+    let addresses = await self.expandDnsAddr(peerId, rawAddress)
+
+    for (expandedAddress, addrPeerId) in addresses:
+      # DNS resolution
+      let
+        hostname = expandedAddress.getHostname()
+        resolvedAddresses =
+          if isNil(self.nameResolver): @[expandedAddress]
+          else: await self.nameResolver.resolveMAddress(expandedAddress)
+
+      for resolvedAddress in resolvedAddresses:
+        result = await self.dialAndUpgrade(addrPeerId, hostname, resolvedAddress, upgradeDir)
+        if not isNil(result):
+          return result
+
+proc tryReusingConnection(self: Dialer, peerId: PeerId): Opt[Muxer] =
+  let muxer = self.connManager.selectMuxer(peerId)
+  if muxer == nil:
+    return Opt.none(Muxer)
+
+  trace "Reusing existing connection", muxer, direction = $muxer.connection.dir
+  return Opt.some(muxer)
 
 proc internalConnect(
   self: Dialer,
   peerId: Opt[PeerId],
   addrs: seq[MultiAddress],
-  forceDial: bool):
-  Future[Connection] {.async.} =
+  forceDial: bool,
+  reuseConnection = true,
+  upgradeDir = Direction.Out):
+  Future[Muxer] {.async.} =
   if Opt.some(self.localPeerId) == peerId:
     raise newException(CatchableError, "can't dial self!")
 
@@ -110,44 +174,31 @@ proc internalConnect(
   try:
     await lock.acquire()
 
-    # Check if we have a connection already and try to reuse it
-    var conn =
-      if peerId.isSome: self.connManager.selectConn(peerId.get())
-      else: nil
-    if conn != nil:
-      if conn.atEof or conn.closed:
-        # This connection should already have been removed from the connection
-        # manager - it's essentially a bug that we end up here - we'll fail
-        # for now, hoping that this will clean themselves up later...
-        warn "dead connection in connection manager", conn
-        await conn.close()
-        raise newException(DialFailedError, "Zombie connection encountered")
+    if reuseConnection:
+      peerId.withValue(peerId):
+        self.tryReusingConnection(peerId).withValue(mux):
+          return mux
 
-      trace "Reusing existing connection", conn, direction = $conn.dir
-      return conn
-
-    let slot = await self.connManager.getOutgoingSlot(forceDial)
-    conn =
+    let slot = self.connManager.getOutgoingSlot(forceDial)
+    let muxed =
       try:
-        await self.dialAndUpgrade(peerId, addrs)
+        await self.dialAndUpgrade(peerId, addrs, upgradeDir)
       except CatchableError as exc:
         slot.release()
         raise exc
-    slot.trackConnection(conn)
-    if isNil(conn): # None of the addresses connected
+    slot.trackMuxer(muxed)
+    if isNil(muxed): # None of the addresses connected
       raise newException(DialFailedError, "Unable to establish outgoing link")
 
-    # A disconnect could have happened right after
-    # we've added the connection so we check again
-    # to prevent races due to that.
-    if conn.closed() or conn.atEof():
-      # This can happen when the other ends drops us
-      # before we get a chance to return the connection
-      # back to the dialer.
-      trace "Connection dead on arrival", conn
-      raise newLPStreamClosedError()
+    try:
+      self.connManager.storeMuxer(muxed)
+      await self.peerStore.identify(muxed)
+    except CatchableError as exc:
+      trace "Failed to finish outgoung upgrade", err=exc.msg
+      await muxed.close()
+      raise exc
 
-    return conn
+    return muxed
   finally:
     if lock.locked():
       lock.release()
@@ -156,30 +207,44 @@ method connect*(
   self: Dialer,
   peerId: PeerId,
   addrs: seq[MultiAddress],
-  forceDial = false) {.async.} =
+  forceDial = false,
+  reuseConnection = true,
+  upgradeDir = Direction.Out) {.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(Opt.some(peerId), addrs, forceDial)
+  discard await self.internalConnect(Opt.some(peerId), addrs, forceDial, reuseConnection, upgradeDir)
 
 method connect*(
   self: Dialer,
-  addrs: seq[MultiAddress],
-  ): Future[PeerId] {.async.} =
+  address: MultiAddress,
+  allowUnknownPeerId = false): Future[PeerId] {.async.} =
   ## Connects to a peer and retrieve its PeerId
 
-  return (await self.internalConnect(Opt.none(PeerId), addrs, false)).peerId
+  parseFullAddress(address).toOpt().withValue(fullAddress):
+    return (await self.internalConnect(
+      Opt.some(fullAddress[0]),
+      @[fullAddress[1]],
+      false)).connection.peerId
+
+  if allowUnknownPeerId == false:
+    raise newException(DialFailedError, "Address without PeerID and unknown peer id disabled!")
+
+  return (await self.internalConnect(
+    Opt.none(PeerId),
+    @[address],
+    false)).connection.peerId
 
 proc negotiateStream(
   self: Dialer,
   conn: Connection,
   protos: seq[string]): Future[Connection] {.async.} =
   trace "Negotiating stream", conn, protos
-  let selected = await self.ms.select(conn, protos)
+  let selected = await MultistreamSelect.select(conn, protos)
   if not protos.contains(selected):
     await conn.closeWithEOF()
     raise newException(DialFailedError, "Unable to select sub-protocol " & $protos)
@@ -189,7 +254,7 @@ proc negotiateStream(
 method tryDial*(
   self: Dialer,
   peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[MultiAddress] {.async.} =
+  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.
@@ -197,11 +262,11 @@ method tryDial*(
 
   trace "Check if it can dial", peerId, addrs
   try:
-    let conn = await self.dialAndUpgrade(Opt.some(peerId), addrs)
-    if conn.isNil():
+    let mux = await self.dialAndUpgrade(Opt.some(peerId), addrs)
+    if mux.isNil():
       raise newException(DialFailedError, "No valid multiaddress")
-    await conn.close()
-    return conn.observedAddr
+    await mux.close()
+    return mux.connection.observedAddr
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
@@ -233,7 +298,7 @@ method dial*(
   ##
 
   var
-    conn: Connection
+    conn: Muxer
     stream: Connection
 
   proc cleanup() {.async.} =
@@ -259,7 +324,7 @@ method dial*(
     await cleanup()
     raise exc
   except CatchableError as exc:
-    debug "Error dialing", conn, msg = exc.msg
+    debug "Error dialing", conn, err = exc.msg
     await cleanup()
     raise exc
 
@@ -270,12 +335,12 @@ proc new*(
   T: type Dialer,
   localPeerId: PeerId,
   connManager: ConnManager,
+  peerStore: PeerStore,
   transports: seq[Transport],
-  ms: MultistreamSelect,
   nameResolver: NameResolver = nil): Dialer =
 
   T(localPeerId: localPeerId,
     connManager: connManager,
     transports: transports,
-    ms: ms,
+    peerStore: peerStore,
     nameResolver: nameResolver)

libp2p/discovery/discoverymngr.nim

@@ -0,0 +1,174 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import std/sequtils
+import chronos, chronicles, stew/results
+import ../errors
+
+type
+  BaseAttr = ref object of RootObj
+    comparator: proc(f, c: BaseAttr): bool {.gcsafe, raises: [].}
+
+  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: [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: [], 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*[T](dm: DiscoveryManager, value: T) =
+  for i in dm.interfaces:
+    i.toAdvertise.add(value)
+    if i.advertiseLoop.isNil:
+      i.advertisementUpdated = newAsyncEvent()
+      i.advertiseLoop = i.advertise()
+    else:
+      i.advertisementUpdated.fire()
+
+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,78 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import chronos
+import ./discoverymngr,
+       ../protocols/rendezvous,
+       ../peerid
+
+type
+  RendezVousInterface* = ref object of DiscoveryInterface
+    rdv*: RendezVous
+    timeToRequest: Duration
+    timeToAdvertise: Duration
+    ttl: 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:
+      try:
+        await self.rdv.advertise(toAdv, self.ttl)
+      except CatchableError as error:
+        debug "RendezVous advertise error: ", msg = error.msg
+
+    await sleepAsync(self.timeToAdvertise) or self.advertisementUpdated.wait()
+
+proc new*(T: typedesc[RendezVousInterface],
+          rdv: RendezVous,
+          ttr: Duration = 1.minutes,
+          tta: Duration = 1.minutes,
+          ttl: Duration = MinimumDuration): RendezVousInterface =
+  T(rdv: rdv, timeToRequest: ttr, timeToAdvertise: tta, ttl: ttl)

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,13 +9,10 @@
 
 ## This module implements MultiAddress.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 {.push public.}
 
-import pkg/chronos
+import pkg/chronos, chronicles
 import std/[nativesockets, hashes]
 import tables, strutils, sets, stew/shims/net
 import multicodec, multihash, multibase, transcoder, vbuffer, peerid,
@@ -23,6 +20,9 @@ import multicodec, multihash, multibase, transcoder, vbuffer, peerid,
 import stew/[base58, base32, endians2, results]
 export results, minprotobuf, vbuffer, utility
 
+logScope:
+  topics = "libp2p multiaddress"
+
 type
   MAKind* = enum
     None, Fixed, Length, Path, Marker
@@ -34,7 +34,7 @@ type
     coder*: Transcoder
 
   MultiAddress* = object
-    data*: VBuffer
+    data: VBuffer
 
   MaPatternOp* = enum
     Eq, Or, And
@@ -63,6 +63,10 @@ const
   IPPROTO_TCP = Protocol.IPPROTO_TCP
   IPPROTO_UDP = Protocol.IPPROTO_UDP
 
+proc data*(ma: MultiAddress): VBuffer =
+  ## Returns the data buffer of the MultiAddress.
+  return ma.data
+
 proc hash*(a: MultiAddress): Hash =
   var h: Hash = 0
   h = h !& hash(a.data.buffer)
@@ -76,7 +80,7 @@ proc ip4StB(s: string, vb: var VBuffer): bool =
     if a.family == IpAddressFamily.IPv4:
       vb.writeArray(a.address_v4)
       result = true
-  except:
+  except CatchableError:
     discard
 
 proc ip4BtS(vb: var VBuffer, s: var string): bool =
@@ -99,7 +103,7 @@ proc ip6StB(s: string, vb: var VBuffer): bool =
     if a.family == IpAddressFamily.IPv6:
       vb.writeArray(a.address_v6)
       result = true
-  except:
+  except CatchableError:
     discard
 
 proc ip6BtS(vb: var VBuffer, s: var string): bool =
@@ -143,14 +147,14 @@ proc portStB(s: string, vb: var VBuffer): bool =
       port[1] = cast[byte](nport and 0xFF)
       vb.writeArray(port)
       result = true
-  except:
+  except CatchableError:
     discard
 
 proc portBtS(vb: var VBuffer, s: var string): bool =
   ## Port number bufferToString() implementation.
   var port: array[2, byte]
   if vb.readArray(port) == 2:
-    var nport = (cast[uint16](port[0]) shl 8) or cast[uint16](port[1])
+    var nport = (safeConvert[uint16](port[0]) shl 8) or safeConvert[uint16](port[1])
     s = $nport
     result = true
 
@@ -168,7 +172,7 @@ proc p2pStB(s: string, vb: var VBuffer): bool =
     if MultiHash.decode(data, mh).isOk:
       vb.writeSeq(data)
       result = true
-  except:
+  except CatchableError:
     discard
 
 proc p2pBtS(vb: var VBuffer, s: var string): bool =
@@ -203,14 +207,14 @@ proc onionStB(s: string, vb: var VBuffer): bool =
       address[11] = cast[byte](nport and 0xFF)
       vb.writeArray(address)
       result = true
-  except:
+  except CatchableError:
     discard
 
 proc onionBtS(vb: var VBuffer, s: var string): bool =
   ## ONION address bufferToString() implementation.
   var buf: array[12, byte]
   if vb.readArray(buf) == 12:
-    var nport = (cast[uint16](buf[10]) shl 8) or cast[uint16](buf[11])
+    var nport = (safeConvert[uint16](buf[10]) shl 8) or safeConvert[uint16](buf[11])
     s = Base32Lower.encode(buf.toOpenArray(0, 9))
     s.add(":")
     s.add($nport)
@@ -237,14 +241,14 @@ proc onion3StB(s: string, vb: var VBuffer): bool =
       address[36] = cast[byte](nport and 0xFF)
       vb.writeArray(address)
       result = true
-  except:
+  except CatchableError:
     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])
+    var nport = (safeConvert[uint16](buf[35]) shl 8) or safeConvert[uint16](buf[36])
     s = Base32Lower.encode(buf.toOpenArray(0, 34))
     s.add(":")
     s.add($nport)
@@ -412,6 +416,9 @@ const
     MAProtocol(
       mcodec: multiCodec("wss"), kind: Marker, size: 0
     ),
+    MAProtocol(
+      mcodec: multiCodec("tls"), kind: Marker, size: 0
+    ),
     MAProtocol(
       mcodec: multiCodec("ipfs"), kind: Length, size: 0,
       coder: TranscoderP2P
@@ -462,14 +469,28 @@ const
   IP6* = mapEq("ip6")
   DNS* = mapOr(DNSANY, DNS4, DNS6, DNSADDR)
   IP* = mapOr(IP4, IP6)
-  TCP* = mapOr(mapAnd(DNS, mapEq("tcp")), mapAnd(IP, mapEq("tcp")))
-  UDP* = mapOr(mapAnd(DNS, mapEq("udp")), mapAnd(IP, mapEq("udp")))
+  DNS_OR_IP* = mapOr(DNS, IP)
+  TCP_DNS* = mapAnd(DNS, mapEq("tcp"))
+  TCP_IP* = mapAnd(IP, mapEq("tcp"))
+  TCP* = mapOr(TCP_DNS, TCP_IP)
+  UDP_DNS* = mapAnd(DNS, mapEq("udp"))
+  UDP_IP* = mapAnd(IP, mapEq("udp"))
+  UDP* = mapOr(UDP_DNS, UDP_IP)
   UTP* = mapAnd(UDP, mapEq("utp"))
   QUIC* = mapAnd(UDP, mapEq("quic"))
   UNIX* = mapEq("unix")
+  WS_DNS* = mapAnd(TCP_DNS, mapEq("ws"))
+  WS_IP* = mapAnd(TCP_IP, mapEq("ws"))
   WS* = mapAnd(TCP, mapEq("ws"))
-  WSS* = mapAnd(TCP, mapEq("wss"))
+  TLS_WS* = mapOr(mapEq("wss"), mapAnd(mapEq("tls"), mapEq("ws")))
+  WSS_DNS* = mapAnd(TCP_DNS, TLS_WS)
+  WSS_IP* = mapAnd(TCP_IP, TLS_WS)
+  WSS* = mapAnd(TCP, TLS_WS)
+  WebSockets_DNS* = mapOr(WS_DNS, WSS_DNS)
+  WebSockets_IP* = mapOr(WS_IP, WSS_IP)
   WebSockets* = mapOr(WS, WSS)
+  Onion3* = mapEq("onion3")
+  TcpOnion3* = mapAnd(TCP, Onion3)
 
   Unreliable* = mapOr(UDP)
 
@@ -516,15 +537,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:
@@ -537,8 +553,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:
@@ -555,9 +570,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:
@@ -573,7 +587,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:
@@ -594,6 +608,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]()
@@ -601,6 +622,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!")
@@ -618,7 +642,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")
 
@@ -647,9 +671,13 @@ proc getParts[U, V](ma: MultiAddress, slice: HSlice[U, V]): MaResult[MultiAddres
     ? res.append(? ma[i])
   ok(res)
 
-proc `[]`*(ma: MultiAddress, i: int): MaResult[MultiAddress] {.inline.} =
+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``.
@@ -680,7 +708,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")
 
@@ -748,7 +776,7 @@ proc toString*(value: MultiAddress): MaResult[string] =
     res = "/" & parts.join("/")
   ok(res)
 
-proc `$`*(value: MultiAddress): string {.raises: [Defect].} =
+proc `$`*(value: MultiAddress): string =
   ## Return string representation of MultiAddress ``value``.
   let s = value.toString()
   if s.isErr: s.error
@@ -778,8 +806,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
@@ -864,6 +891,8 @@ proc getProtocol(name: string): MAProtocol {.inline.} =
 proc init*(mtype: typedesc[MultiAddress],
            value: string): MaResult[MultiAddress] =
   ## Initialize MultiAddress object from string representation ``value``.
+  if len(value) == 0 or value == "/":
+    return err("multiaddress: Address must not be empty!")
   var parts = value.trimRight('/').split('/')
   if len(parts[0]) != 0:
     err("multiaddress: Invalid MultiAddress, must start with `/`")
@@ -911,7 +940,7 @@ proc init*(mtype: typedesc[MultiAddress],
            data: openArray[byte]): MaResult[MultiAddress] =
   ## Initialize MultiAddress with array of bytes ``data``.
   if len(data) == 0:
-    err("multiaddress: Address could not be empty!")
+    err("multiaddress: Address must not be empty!")
   else:
     var res: MultiAddress
     res.data = initVBuffer()
@@ -997,7 +1026,7 @@ proc append*(m1: var MultiAddress, m2: MultiAddress): MaResult[void] =
     ok()
 
 proc `&`*(m1, m2: MultiAddress): MultiAddress {.
-     raises: [Defect, LPError].} =
+     raises: [LPError].} =
   ## Concatenates two addresses ``m1`` and ``m2``, and returns result.
   ##
   ## This procedure performs validation of concatenated result and can raise
@@ -1007,7 +1036,7 @@ proc `&`*(m1, m2: MultiAddress): MultiAddress {.
   concat(m1, m2).tryGet()
 
 proc `&=`*(m1: var MultiAddress, m2: MultiAddress) {.
-     raises: [Defect, LPError].} =
+     raises: [LPError].} =
   ## Concatenates two addresses ``m1`` and ``m2``.
   ##
   ## This procedure performs validation of concatenated result and can raise
@@ -1051,19 +1080,15 @@ proc matchPart(pat: MaPattern, protos: seq[MultiCodec]): MaPatResult =
 proc match*(pat: MaPattern, address: MultiAddress): bool =
   ## Match full ``address`` using pattern ``pat`` and return ``true`` if
   ## ``address`` satisfies pattern.
-  let protos = address.protocols()
-  if protos.isErr():
-    return false
-  let res = matchPart(pat, protos.get())
+  let protos = address.protocols().valueOr: return false
+  let res = matchPart(pat, protos)
   res.flag and (len(res.rem) == 0)
 
 proc matchPartial*(pat: MaPattern, address: MultiAddress): bool =
   ## Match prefix part of ``address`` using pattern ``pat`` and return
   ## ``true`` if ``address`` starts with pattern.
-  let protos = address.protocols()
-  if protos.isErr():
-    return false
-  let res = matchPart(pat, protos.get())
+  let protos = address.protocols().valueOr: return false
+  let res = matchPart(pat, protos)
   res.flag
 
 proc `$`*(pat: MaPattern): string =
@@ -1078,6 +1103,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)
 
@@ -1089,16 +1117,16 @@ proc getField*(pb: ProtoBuffer, field: int,
   if not(res):
     ok(false)
   else:
-    let ma = MultiAddress.init(buffer)
-    if ma.isOk():
-      value = ma.get()
-      ok(true)
-    else:
-      err(ProtoError.IncorrectBlob)
+    value = MultiAddress.init(buffer).valueOr: return err(ProtoError.IncorrectBlob)
+    ok(true)
 
 proc getRepeatedField*(pb: ProtoBuffer, field: int,
                        value: var seq[MultiAddress]): ProtoResult[bool] {.
      inline.} =
+  ## Read repeated field from protobuf message. ``field`` is field number. If the message is malformed, an error is returned.
+  ## If field is not present in message, then ``ok(false)`` is returned and value is empty. If field is present,
+  ## but no items could be parsed, then ``err(ProtoError.IncorrectBlob)`` is returned and value is empty.
+  ## If field is present and some item could be parsed, then ``true`` is returned and value contains the parsed values.
   var items: seq[seq[byte]]
   value.setLen(0)
   let res = ? pb.getRepeatedField(field, items)
@@ -1106,10 +1134,12 @@ proc getRepeatedField*(pb: ProtoBuffer, field: int,
     ok(false)
   else:
     for item in items:
-      let ma = MultiAddress.init(item)
-      if ma.isOk():
-        value.add(ma.get())
-      else:
-        value.setLen(0)
-        return err(ProtoError.IncorrectBlob)
-    ok(true)
+      let ma = MultiAddress.init(item).valueOr:
+        debug "Unsupported MultiAddress in blob", ma = item
+        continue
+
+      value.add(ma)
+    if value.len == 0:
+      err(ProtoError.IncorrectBlob)
+    else:
+      ok(true)

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,10 +13,7 @@
 ## 1. base32z
 ##
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import tables
 import stew/[base32, base58, base64, results]
@@ -27,17 +24,17 @@ type
 
   MultiBase* = object
 
-  MBCodeSize = proc(length: int): int {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
+  MBCodeSize = proc(length: int): int {.nimcall, gcsafe, noSideEffect, raises: [].}
 
   MBCodec = object
     code: char
     name: string
     encr: proc(inbytes: openArray[byte],
                outbytes: var openArray[char],
-               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
+               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [].}
     decr: proc(inbytes: openArray[char],
                outbytes: var openArray[byte],
-               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
+               outlen: var int): MultiBaseStatus {.nimcall, gcsafe, noSideEffect, raises: [].}
     encl: MBCodeSize
     decl: MBCodeSize
 

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,18 +9,13 @@
 
 ## This module implements MultiCodec.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import tables, hashes
 import varint, vbuffer
 import stew/results
 export results
 
-{.deadCodeElim: on.}
-
 ## List of officially supported codecs can BE found here
 ## https://github.com/multiformats/multicodec/blob/master/table.csv
 const MultiCodecList = [
@@ -196,9 +191,10 @@ const MultiCodecList = [
   ("p2p", 0x01A5),
   ("http", 0x01E0),
   ("https", 0x01BB),
+  ("tls", 0x01C0),
   ("quic", 0x01CC),
   ("ws", 0x01DD),
-  ("wss", 0x01DE), # not in multicodec list
+  ("wss", 0x01DE),
   ("p2p-websocket-star", 0x01DF), # not in multicodec list
   ("p2p-webrtc-star", 0x0113), # not in multicodec list
   ("p2p-webrtc-direct", 0x0114), # not in multicodec list

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,10 +21,7 @@
 ## 1. SKEIN
 ## 2. MURMUR
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import tables
 import nimcrypto/[sha, sha2, keccak, blake2, hash, utils]
@@ -45,7 +42,7 @@ const
 
 type
   MHashCoderProc* = proc(data: openArray[byte],
-                         output: var openArray[byte]) {.nimcall, gcsafe, noSideEffect, raises: [Defect].}
+                         output: var openArray[byte]) {.nimcall, gcsafe, noSideEffect, raises: [].}
   MHash* = object
     mcodec*: MultiCodec
     size*: int

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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[strutils, sequtils]
+import std/[strutils, sequtils, tables]
 import chronos, chronicles, stew/byteutils
 import stream/connection,
        protocols/protocol
@@ -21,29 +18,31 @@ logScope:
   topics = "libp2p multistream"
 
 const
-  MsgSize* = 64*1024
-  Codec* = "/multistream/1.0.0"
+  MsgSize = 1024
+  Codec = "/multistream/1.0.0"
 
-  MSCodec* = "\x13" & Codec & "\n"
-  Na* = "\x03na\n"
-  Ls* = "\x03ls\n"
+  Na = "na\n"
+  Ls = "ls\n"
 
 type
-  Matcher* = proc (proto: string): bool {.gcsafe, raises: [Defect].}
+  Matcher* = proc (proto: string): bool {.gcsafe, raises: [].}
 
   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: Codec,
+  )
 
 template validateSuffix(str: string): untyped =
     if str.endsWith("\n"):
@@ -51,13 +50,13 @@ template validateSuffix(str: string): untyped =
     else:
       raise newException(MultiStreamError, "MultistreamSelect failed, malformed message")
 
-proc select*(m: MultistreamSelect,
+proc select*(_: MultistreamSelect | type MultistreamSelect,
              conn: Connection,
              proto: seq[string]):
              Future[string] {.async.} =
-  trace "initiating handshake", conn, codec = m.codec
+  trace "initiating handshake", conn, codec = Codec
   ## select a remote protocol
-  await conn.write(m.codec) # write handshake
+  await conn.writeLp(Codec & "\n") # write handshake
   if proto.len() > 0:
     trace "selecting proto", conn, proto = proto[0]
     await conn.writeLp((proto[0] & "\n")) # select proto
@@ -99,13 +98,13 @@ proc select*(m: MultistreamSelect,
       # No alternatives, fail
       return ""
 
-proc select*(m: MultistreamSelect,
+proc select*(_: MultistreamSelect | type MultistreamSelect,
              conn: Connection,
              proto: string): Future[bool] {.async.} =
   if proto.len > 0:
-    return (await m.select(conn, @[proto])) == proto
+    return (await MultistreamSelect.select(conn, @[proto])) == proto
   else:
-    return (await m.select(conn, @[])) == Codec
+    return (await MultistreamSelect.select(conn, @[])) == Codec
 
 proc select*(m: MultistreamSelect, conn: Connection): Future[bool] =
   m.select(conn, "")
@@ -116,7 +115,7 @@ proc list*(m: MultistreamSelect,
   if not await m.select(conn):
     return
 
-  await conn.write(Ls) # send ls
+  await conn.writeLp(Ls) # send ls
 
   var list = newSeq[string]()
   let ms = string.fromBytes(await conn.readLp(MsgSize))
@@ -126,55 +125,86 @@ proc list*(m: MultistreamSelect,
 
   result = list
 
+proc handle*(
+  _: type MultistreamSelect,
+  conn: Connection,
+  protos: seq[string],
+  matchers = newSeq[Matcher](),
+  active: bool = false,
+  ): Future[string] {.async, gcsafe.} =
+  trace "Starting multistream negotiation", conn, handshaked = active
+  var handshaked = active
+  while not conn.atEof:
+    var ms = string.fromBytes(await conn.readLp(MsgSize))
+    validateSuffix(ms)
+
+    if not handshaked and ms != Codec:
+      debug "expected handshake message", conn, instead=ms
+      raise newException(CatchableError,
+                         "MultistreamSelect handling failed, invalid first message")
+
+    trace "handle: got request", conn, ms
+    if ms.len() <= 0:
+      trace "handle: invalid proto", conn
+      await conn.writeLp(Na)
+
+    case ms:
+    of "ls":
+      trace "handle: listing protos", conn
+      #TODO this doens't seem to follow spec, each protocol
+      # should be length prefixed. Not very important
+      # since LS is getting deprecated
+      await conn.writeLp(protos.join("\n") & "\n")
+    of Codec:
+      if not handshaked:
+        await conn.writeLp(Codec & "\n")
+        handshaked = true
+      else:
+        trace "handle: sending `na` for duplicate handshake while handshaked",
+          conn
+        await conn.writeLp(Na)
+    elif ms in protos or matchers.anyIt(it(ms)):
+      trace "found handler", conn, protocol = ms
+      await conn.writeLp(ms & "\n")
+      conn.protocol = ms
+      return ms
+    else:
+      trace "no handlers", conn, protocol = ms
+      await conn.writeLp(Na)
+
 proc handle*(m: MultistreamSelect, conn: Connection, active: bool = false) {.async, gcsafe.} =
   trace "Starting multistream handler", conn, handshaked = active
-  var handshaked = active
+  var
+    handshaked = active
+    protos: seq[string]
+    matchers: seq[Matcher]
+  for h in m.handlers:
+    if not isNil(h.match):
+      matchers.add(h.match)
+    for proto in h.protos:
+      protos.add(proto)
+
   try:
-    while not conn.atEof:
-      var ms = string.fromBytes(await conn.readLp(MsgSize))
-      validateSuffix(ms)
+    let ms = await MultistreamSelect.handle(conn, protos, matchers, active)
+    for h in m.handlers:
+      if (not isNil(h.match) and h.match(ms)) or h.protos.contains(ms):
+        trace "found handler", conn, protocol = ms
 
-      if not handshaked and ms != Codec:
-        notice "expected handshake message", conn, instead=ms
-        raise newException(CatchableError,
-                           "MultistreamSelect handling failed, invalid first message")
-
-      trace "handle: got request", conn, ms
-      if ms.len() <= 0:
-        trace "handle: invalid proto", conn
-        await conn.write(Na)
-
-      if m.handlers.len() == 0:
-        trace "handle: sending `na` for protocol", conn, protocol = ms
-        await conn.write(Na)
-        continue
-
-      case ms:
-      of "ls":
-        trace "handle: listing protos", conn
-        var protos = ""
-        for h in m.handlers:
-          for proto in h.protos:
-            protos &= (proto & "\n")
-        await conn.writeLp(protos)
-      of Codec:
-        if not handshaked:
-          await conn.write(m.codec)
-          handshaked = true
-        else:
-          trace "handle: sending `na` for duplicate handshake while handshaked",
-            conn
-          await conn.write(Na)
-      else:
-        for h in m.handlers:
-          if (not isNil(h.match) and h.match(ms)) or h.protos.contains(ms):
-            trace "found handler", conn, protocol = ms
-            await conn.writeLp(ms & "\n")
-            conn.protocol = ms
-            await h.protocol.handler(conn, ms)
-            return
-        debug "no handlers", conn, protocol = ms
-        await conn.write(Na)
+        var protocolHolder = h
+        let maxIncomingStreams = protocolHolder.protocol.maxIncomingStreams
+        if protocolHolder.openedStreams.getOrDefault(conn.peerId) >= maxIncomingStreams:
+          debug "Max streams for protocol reached, blocking new stream",
+            conn, protocol = ms, maxIncomingStreams
+          return
+        protocolHolder.openedStreams.inc(conn.peerId)
+        try:
+          await protocolHolder.protocol.handler(conn, ms)
+        finally:
+          protocolHolder.openedStreams.inc(conn.peerId, -1)
+          if protocolHolder.openedStreams[conn.peerId] == 0:
+            protocolHolder.openedStreams.del(conn.peerId)
+        return
+    debug "no handlers", conn, ms
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:

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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import pkg/[chronos, nimcrypto/utils, chronicles, stew/byteutils]
+import pkg/[chronos, chronicles, stew/byteutils]
 import ../../stream/connection,
        ../../utility,
        ../../varint,

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,13 +7,10 @@
 # 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: [].}
+{.push raises: [].}
 
 import std/[oids, strformat]
-import pkg/[chronos, chronicles, metrics, nimcrypto/utils]
+import pkg/[chronos, chronicles, metrics]
 import ./coder,
        ../muxer,
        ../../stream/[bufferstream, connection, streamseq],
@@ -236,7 +233,7 @@ proc completeWrite(
     else:
       await fut
 
-    when defined(libp2p_network_protocol_metrics):
+    when defined(libp2p_network_protocols_metrics):
       if s.protocol.len > 0:
         libp2p_protocols_bytes.inc(msgLen.int64, labelValues=[s.protocol, "out"])
 
@@ -244,7 +241,11 @@ proc completeWrite(
   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

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,10 +7,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import tables, sequtils, oids
 import chronos, chronicles, stew/byteutils, metrics
@@ -79,7 +76,7 @@ proc newStreamInternal*(m: Mplex,
                         chanId: uint64 = 0,
                         name: string = "",
                         timeout: Duration): LPChannel
-                        {.gcsafe, raises: [Defect, InvalidChannelIdError].} =
+                        {.gcsafe, raises: [InvalidChannelIdError].} =
   ## create new channel/stream
   ##
   let id = if initiator:
@@ -177,8 +174,14 @@ 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()
@@ -197,7 +200,8 @@ method handle*(m: Mplex) {.async, gcsafe.} =
 
 proc new*(M: type Mplex,
            conn: Connection,
-           inTimeout, outTimeout: Duration = DefaultChanTimeout,
+           inTimeout: Duration = DefaultChanTimeout,
+           outTimeout: Duration = DefaultChanTimeout,
            maxChannCount: int = MaxChannelCount): Mplex =
   M(connection: conn,
     inChannTimeout: inTimeout,
@@ -242,3 +246,7 @@ method close*(m: Mplex) {.async, gcsafe.} =
   m.channels[true].clear()
 
   trace "Closed mplex", m
+
+method getStreams*(m: Mplex): seq[Connection] =
+  for c in m.channels[false].values: result.add(c)
+  for c in m.channels[true].values: result.add(c)

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,14 +7,10 @@
 # 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: [].}
+{.push raises: [].}
 
 import chronos, chronicles
-import ../protocols/protocol,
-       ../stream/connection,
+import ../stream/connection,
        ../errors
 
 logScope:
@@ -27,29 +23,33 @@ 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].}
+  StreamHandler* = proc(conn: Connection): Future[void] {.gcsafe, raises: [].}
+  MuxerHandler* = proc(muxer: Muxer): Future[void] {.gcsafe, raises: [].}
 
   Muxer* = ref object of RootObj
     streamHandler*: StreamHandler
+    handler*: Future[void]
     connection*: Connection
 
   # user provider proc that returns a constructed Muxer
-  MuxerConstructor* = proc(conn: Connection): Muxer {.gcsafe, closure, raises: [Defect].}
+  MuxerConstructor* = proc(conn: Connection): Muxer {.gcsafe, closure, raises: [].}
 
   # this wraps a creator proc that knows how to make muxers
-  MuxerProvider* = ref object of LPProtocol
+  MuxerProvider* = object
     newMuxer*: MuxerConstructor
-    streamHandler*: StreamHandler # triggered every time there is a new stream, called for any muxer instance
-    muxerHandler*: MuxerHandler # triggered every time there is a new muxed connection created
+    codec*: string
 
-func shortLog*(m: Muxer): auto = shortLog(m.connection)
+func shortLog*(m: Muxer): auto =
+  if isNil(m): "nil"
+  else: shortLog(m.connection)
 chronicles.formatIt(Muxer): shortLog(it)
 
 # muxer interface
 method newStream*(m: Muxer, name: string = "", lazy: bool = false):
   Future[Connection] {.base, async, gcsafe.} = discard
-method close*(m: Muxer) {.base, async, gcsafe.} = discard
+method close*(m: Muxer) {.base, async, gcsafe.} =
+  if not isNil(m.connection):
+    await m.connection.close()
 method handle*(m: Muxer): Future[void] {.base, async, gcsafe.} = discard
 
 proc new*(
@@ -57,36 +57,7 @@ proc new*(
   creator: MuxerConstructor,
   codec: string): T {.gcsafe.} =
 
-  let muxerProvider = T(newMuxer: creator)
-  muxerProvider.codec = codec
-  muxerProvider.init()
+  let muxerProvider = T(newMuxer: creator, codec: codec)
   muxerProvider
 
-method init(c: MuxerProvider) =
-  proc handler(conn: Connection, proto: string) {.async, gcsafe, closure.} =
-    trace "starting muxer handler", proto=proto, conn
-    try:
-      let
-        muxer = c.newMuxer(conn)
-
-      if not isNil(c.streamHandler):
-        muxer.streamHandler = c.streamHandler
-
-      var futs = newSeq[Future[void]]()
-      futs &= muxer.handle()
-
-      # finally await both the futures
-      if not isNil(c.muxerHandler):
-        await c.muxerHandler(muxer)
-        when defined(libp2p_agents_metrics):
-          conn.shortAgent = muxer.connection.shortAgent
-
-      checkFutures(await allFinished(futs))
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      trace "exception in muxer handler", exc = exc.msg, conn, proto
-    finally:
-      await conn.close()
-
-  c.handler = handler
+method getStreams*(m: Muxer): seq[Connection] {.base.} = doAssert false, "not implemented"

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,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import sequtils, std/[tables]
 import chronos, chronicles, metrics, stew/[endians2, byteutils, objects]
@@ -84,7 +81,7 @@ proc `$`(header: YamuxHeader): string =
 proc encode(header: YamuxHeader): array[12, byte] =
   result[0] = header.version
   result[1] = uint8(header.msgType)
-  result[2..3] = toBytesBE(cast[uint16](header.flags))
+  result[2..3] = toBytesBE(uint16(cast[uint8](header.flags))) # workaround https://github.com/nim-lang/Nim/issues/21789
   result[4..7] = toBytesBE(header.streamId)
   result[8..11] = toBytesBE(header.length)
 
@@ -356,6 +353,8 @@ proc open*(channel: YamuxChannel) {.async, gcsafe.} =
   channel.opened = true
   await channel.conn.write(YamuxHeader.data(channel.id, 0, {if channel.isSrc: Syn else: Ack}))
 
+method getWrapped*(channel: YamuxChannel): Connection = channel.conn
+
 type
   Yamux* = ref object of Muxer
     channels: Table[uint32, YamuxChannel]
@@ -414,7 +413,8 @@ method close*(m: Yamux) {.async.} =
   let channels = toSeq(m.channels.values())
   for channel in channels:
     await channel.reset(true)
-  await m.connection.write(YamuxHeader.goAway(NormalTermination))
+  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"
 
@@ -505,6 +505,9 @@ method handle*(m: Yamux) {.async, gcsafe.} =
     await m.close()
   trace "Stopped yamux handler"
 
+method getStreams*(m: Yamux): seq[Connection] =
+  for c in m.channels.values: result.add(c)
+
 method newStream*(
   m: Yamux,
   name: string = "",

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,15 +7,13 @@
 # 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: [].}
+{.push raises: [].}
 
 import
   std/[streams, strutils, sets, sequtils],
-  chronos, chronicles,
-  dnsclientpkg/[protocol, types]
+  chronos, chronicles, stew/byteutils,
+  dnsclientpkg/[protocol, types],
+  ../utility
 
 import
   nameresolver
@@ -76,17 +74,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)
-  except CatchableError as exc: raise exc
-  except Exception as exc: raiseAssert exc.msg
+    return exceptionToAssert: parseResponse(string.fromBytes(rawResponse))
   finally:
     await sock.closeWait()
 
@@ -118,7 +110,12 @@ 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(
+            exceptionToAssert(answer.toString())
+          )
       except CancelledError as e:
         raise e
       except ValueError as e:
@@ -148,9 +145,13 @@ method resolveTxt*(
   for _ in 0 ..< self.nameServers.len:
     let server = self.nameServers[0]
     try:
+      # toString can has a raises: [Exception, ..] because of
+      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+      # it can't actually raise though
       let response = await getDnsResponse(server, address, TXT)
-      trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
-      return response.answers.mapIt(it.toString())
+      return exceptionToAssert:
+        trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
+        response.answers.mapIt(it.toString())
     except CancelledError as e:
       raise e
     except CatchableError as e:

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,13 +7,10 @@
 # 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: [].}
+{.push raises: [].}
 
 import
-  std/[streams, strutils, tables],
+  std/tables,
   chronos, chronicles
 
 import nameresolver

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,29 +7,26 @@
 # 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: [].}
+{.push raises: [].}
 
 import std/[sugar, sets, sequtils, strutils]
-import 
+import
   chronos,
   chronicles,
-  stew/[endians2, byteutils]
+  stew/endians2
 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!")
 
@@ -39,21 +36,23 @@ 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,
   prefix = ""): Future[seq[MultiAddress]]
-  {.async, raises: [Defect, MaError, TransportAddressError].} =
+  {.async, raises: [MaError, TransportAddressError].} =
   #Resolve a single address
   var pbuf: array[2, byte]
 
@@ -64,29 +63,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:
@@ -104,21 +96,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,17 +118,18 @@ proc resolveMAddress*(
   if not DNS.matchPartial(address):
     res.incl(address)
   else:
-    let code = address[0].get().protoCode().get()
+    let code = address[0].tryGet().protoCode().tryGet()
     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:
+        assert false
         @[address]
     for ad in seq:
       res.incl(ad)

libp2p/observedaddrmanager.nim

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

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,10 +9,7 @@
 
 ## This module implementes API for libp2p peer.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 {.push public.}
 
 import
@@ -44,10 +41,7 @@ func shortLog*(pid: PeerId): string =
   if len(spid) > 10:
     spid[3] = '*'
 
-    when (NimMajor, NimMinor) > (1, 4):
-      spid.delete(4 .. spid.high - 6)
-    else:
-      spid.delete(4, spid.high - 6)
+    spid.delete(4 .. spid.high - 6)
 
   spid
 
@@ -148,7 +142,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
@@ -184,21 +178,18 @@ 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)
-  if p.isErr:
-    false
-  else:
-    pid == p.get()
+  PeerId.init(pubkey) == Result[PeerId, cstring].ok(pid)
 
 func match*(pid: PeerId, seckey: PrivateKey): bool =
   ## Returns ``true`` if ``pid`` matches private key ``seckey``.
-  let p = PeerId.init(seckey)
-  if p.isErr:
-    false
-  else:
-    pid == p.get()
+  PeerId.init(seckey) == Result[PeerId, cstring].ok(pid)
 
 ## Serialization/Deserialization helpers
 

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,26 +7,29 @@
 # 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: [].}
+{.push raises: [].}
 {.push public.}
 
-import std/[options, sequtils]
+import std/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: [].}
 
   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
@@ -37,6 +40,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,
@@ -44,31 +48,58 @@ func shortLog*(p: PeerInfo): auto =
   )
 chronicles.formatIt(PeerInfo): shortLog(it)
 
-proc update*(p: PeerInfo) =
-  let sprRes = SignedPeerRecord.init(
+proc update*(p: PeerInfo) {.async.} =
+  p.addrs = p.listenAddrs
+  for mapper in p.addressMappers:
+    p.addrs = await mapper(p.addrs)
+
+  p.signedPeerRecord = SignedPeerRecord.init(
     p.privateKey,
     PeerRecord.init(p.peerId, p.addrs)
+  ).valueOr():
+    info "Can't update the signed peer record"
+    return
+
+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]
   )
-  if sprRes.isOk:
-    p.signedPeerRecord = sprRes.get()
-  else:
-    discard
-    #info "Can't update the signed peer record"
+  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: [LPError].} =
 
   let pubkey = try:
       key.getPublicKey().tryGet()
     except CatchableError:
       raise newException(PeerInfoError, "invalid private key")
-  
+
   let peerId = PeerId.init(key).tryGet()
 
   let peerInfo = PeerInfo(
@@ -77,10 +108,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,24 +16,25 @@ runnableExamples:
   # Create a custom book type
   type MoodBook = ref object of PeerBook[string]
 
-  var somePeerId: PeerId
-  discard somePeerId.init("")
+  var somePeerId = PeerId.random().expect("get random key")
 
   peerStore[MoodBook][somePeerId] = "Happy"
   doAssert peerStore[MoodBook][somePeerId] == "Happy"
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import
   std/[tables, sets, options, macros],
+  chronos,
   ./crypto/crypto,
   ./protocols/identify,
+  ./protocols/protocol,
   ./peerid, ./peerinfo,
   ./routing_record,
   ./multiaddress,
+  ./stream/connection,
+  ./multistream,
+  ./muxers/muxer,
   utility
 
 type
@@ -41,7 +42,7 @@ type
   # Handler types #
   #################
 
-  PeerBookChangeHandler* = proc(peerId: PeerId) {.gcsafe, raises: [Defect].}
+  PeerBookChangeHandler* = proc(peerId: PeerId) {.gcsafe, raises: [].}
 
   #########
   # Books #
@@ -71,11 +72,15 @@ type
 
   PeerStore* {.public.} = ref object
     books: Table[string, BasePeerBook]
+    identify: Identify
     capacity*: int
     toClean*: seq[PeerId]
 
-proc new*(T: type PeerStore, capacity = 1000): PeerStore {.public.} =
-  T(capacity: capacity)
+proc new*(T: type PeerStore, identify: Identify, capacity = 1000): PeerStore {.public.} =
+  T(
+    identify: identify,
+    capacity: capacity
+  )
 
 #########################
 # Generic Peer Book API #
@@ -153,17 +158,20 @@ proc updatePeerInfo*(
   if info.addrs.len > 0:
     peerStore[AddressBook][info.peerId] = info.addrs
 
-  if info.agentVersion.isSome:
-    peerStore[AgentBook][info.peerId] = info.agentVersion.get().string
+  info.pubkey.withValue(pubkey):
+    peerStore[KeyBook][info.peerId] = pubkey
 
-  if info.protoVersion.isSome:
-    peerStore[ProtoVersionBook][info.peerId] = info.protoVersion.get().string
+  info.agentVersion.withValue(agentVersion):
+    peerStore[AgentBook][info.peerId] = agentVersion.string
+
+  info.protoVersion.withValue(protoVersion):
+    peerStore[ProtoVersionBook][info.peerId] = protoVersion.string
 
   if info.protos.len > 0:
     peerStore[ProtoBook][info.peerId] = info.protos
 
-  if info.signedPeerRecord.isSome:
-    peerStore[SPRBook][info.peerId] = info.signedPeerRecord.get()
+  info.signedPeerRecord.withValue(signedPeerRecord):
+    peerStore[SPRBook][info.peerId] = signedPeerRecord
 
   let cleanupPos = peerStore.toClean.find(info.peerId)
   if cleanupPos >= 0:
@@ -184,3 +192,34 @@ proc cleanup*(
   while peerStore.toClean.len > peerStore.capacity:
     peerStore.del(peerStore.toClean[0])
     peerStore.toClean.delete(0)
+
+proc identify*(
+  peerStore: PeerStore,
+  muxer: Muxer) {.async.} =
+
+  # new stream for identify
+  var stream = await muxer.newStream()
+  if stream == nil:
+    return
+
+  try:
+    if (await MultistreamSelect.select(stream, peerStore.identify.codec())):
+      let info = await peerStore.identify.identify(stream, stream.peerId)
+
+      when defined(libp2p_agents_metrics):
+        var
+          knownAgent = "unknown"
+          shortAgent = info.agentVersion.get("").split("/")[0].safeToLowerAscii().get("")
+        if KnownLibP2PAgentsSeq.contains(shortAgent):
+          knownAgent = shortAgent
+        muxer.connection.setShortAgent(knownAgent)
+
+      peerStore.updatePeerInfo(info)
+  finally:
+    await stream.closeWithEOF()
+
+proc getMostObservedProtosAndPorts*(self: PeerStore): seq[MultiAddress] =
+  return self.identify.observedAddrManager.getMostObservedProtosAndPorts()
+
+proc guessDialableAddr*(self: PeerStore, ma: MultiAddress): MultiAddress =
+  return self.identify.observedAddrManager.guessDialableAddr(ma)

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,18 +9,14 @@
 
 ## This module implements minimal Google's ProtoBuf primitives.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.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
@@ -37,6 +33,7 @@ type
     buffer*: seq[byte]
     offset*: int
     length*: int
+    maxSize*: uint
 
   ProtoHeader* = object
     wire*: ProtoFieldKind
@@ -72,12 +69,12 @@ type
                  hint | hint32 | hint64 | float32 | float64
 
 const
-  SupportedWireTypes* = {
-    int(ProtoFieldKind.Varint),
-    int(ProtoFieldKind.Fixed64),
-    int(ProtoFieldKind.Length),
-    int(ProtoFieldKind.Fixed32)
-  }
+  SupportedWireTypes* = @[
+    uint64(ProtoFieldKind.Varint),
+    uint64(ProtoFieldKind.Fixed64),
+    uint64(ProtoFieldKind.Length),
+    uint64(ProtoFieldKind.Fixed32)
+  ]
 
 template checkFieldNumber*(i: int) =
   doAssert((i > 0 and i < (1 shl 29)) and not(i >= 19000 and i <= 19999),
@@ -122,23 +119,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].
@@ -335,7 +337,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()
@@ -399,7 +401,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):
@@ -427,7 +429,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:
@@ -574,26 +576,18 @@ proc getField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
 proc getField*(pb: ProtoBuffer, field: int,
                output: var ProtoBuffer): ProtoResult[bool] {.inline.} =
   var buffer: seq[byte]
-  let res = pb.getField(field, buffer)
-  if res.isOk():
-    if res.get():
-      output = initProtoBuffer(buffer)
-      ok(true)
-    else:
-      ok(false)
+  if ? pb.getField(field, buffer):
+    output = initProtoBuffer(buffer)
+    ok(true)
   else:
-    err(res.error)
+    ok(false)
 
 proc getRequiredField*[T](pb: ProtoBuffer, field: int,
                output: var T): ProtoResult[void] {.inline.} =
-  let res = pb.getField(field, output)
-  if res.isOk():
-    if res.get():
-      ok()
-    else:
-      err(RequiredFieldMissing)
+  if ? pb.getField(field, output):
+    ok()
   else:
-    err(res.error)
+    err(RequiredFieldMissing)
 
 proc getRepeatedField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
                                         output: var seq[T]): ProtoResult[bool] =
@@ -673,14 +667,10 @@ proc getRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
 
 proc getRequiredRepeatedField*[T](pb: ProtoBuffer, field: int,
                output: var seq[T]): ProtoResult[void] {.inline.} =
-  let res = pb.getRepeatedField(field, output)
-  if res.isOk():
-    if res.get():
-      ok()
-    else:
-      err(RequiredFieldMissing)
+  if ? pb.getRepeatedField(field, output):
+    ok()
   else:
-    err(res.error)
+    err(RequiredFieldMissing)
 
 proc getPackedRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
                                         output: var seq[T]): ProtoResult[bool] =

libp2p/protocols/connectivity/autonat.nim

@@ -1,301 +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.
-
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
-
-import std/[options, sets, sequtils]
-import chronos, chronicles, stew/objects
-import ../protocol,
-       ../../switch,
-       ../../multiaddress,
-       ../../multicodec,
-       ../../peerid,
-       ../../utils/semaphore,
-       ../../errors
-
-logScope:
-  topics = "libp2p autonat"
-
-const
-  AutonatCodec* = "/libp2p/autonat/1.0.0"
-  AddressLimit = 8
-
-type
-  AutonatError* = object of LPError
-
-  MsgType* = enum
-    Dial = 0
-    DialResponse = 1
-
-  ResponseStatus* = enum
-    Ok = 0
-    DialError = 100
-    DialRefused = 101
-    BadRequest = 200
-    InternalError = 300
-
-  AutonatPeerInfo* = object
-    id: Option[PeerId]
-    addrs: seq[MultiAddress]
-
-  AutonatDial* = object
-    peerInfo: Option[AutonatPeerInfo]
-
-  AutonatDialResponse* = object
-    status*: ResponseStatus
-    text*: Option[string]
-    ma*: Option[MultiAddress]
-
-  AutonatMsg = object
-    msgType: MsgType
-    dial: Option[AutonatDial]
-    response: Option[AutonatDialResponse]
-
-proc encode*(msg: AutonatMsg): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, msg.msgType.uint)
-  if msg.dial.isSome():
-    var dial = initProtoBuffer()
-    if msg.dial.get().peerInfo.isSome():
-      var bufferPeerInfo = initProtoBuffer()
-      let peerInfo = msg.dial.get().peerInfo.get()
-      if peerInfo.id.isSome():
-        bufferPeerInfo.write(1, peerInfo.id.get())
-      for ma in peerInfo.addrs:
-        bufferPeerInfo.write(2, ma.data.buffer)
-      bufferPeerInfo.finish()
-      dial.write(1, bufferPeerInfo.buffer)
-    dial.finish()
-    result.write(2, dial.buffer)
-  if msg.response.isSome():
-    var bufferResponse = initProtoBuffer()
-    let response = msg.response.get()
-    bufferResponse.write(1, response.status.uint)
-    if response.text.isSome():
-      bufferResponse.write(2, response.text.get())
-    if response.ma.isSome():
-      bufferResponse.write(3, response.ma.get())
-    bufferResponse.finish()
-    result.write(3, bufferResponse.buffer)
-  result.finish()
-
-proc encode*(d: AutonatDial): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, MsgType.Dial.uint)
-  var dial = initProtoBuffer()
-  if d.peerInfo.isSome():
-    var bufferPeerInfo = initProtoBuffer()
-    let peerInfo = d.peerInfo.get()
-    if peerInfo.id.isSome():
-      bufferPeerInfo.write(1, peerInfo.id.get())
-    for ma in peerInfo.addrs:
-      bufferPeerInfo.write(2, ma.data.buffer)
-    bufferPeerInfo.finish()
-    dial.write(1, bufferPeerInfo.buffer)
-  dial.finish()
-  result.write(2, dial.buffer)
-  result.finish()
-
-proc encode*(r: AutonatDialResponse): ProtoBuffer =
-  result = initProtoBuffer()
-  result.write(1, MsgType.DialResponse.uint)
-  var bufferResponse = initProtoBuffer()
-  bufferResponse.write(1, r.status.uint)
-  if r.text.isSome():
-    bufferResponse.write(2, r.text.get())
-  if r.ma.isSome():
-    bufferResponse.write(3, r.ma.get())
-  bufferResponse.finish()
-  result.write(3, bufferResponse.buffer)
-  result.finish()
-
-proc decode(_: typedesc[AutonatMsg], buf: seq[byte]): Option[AutonatMsg] =
-  var
-    msgTypeOrd: uint32
-    pbDial: ProtoBuffer
-    pbResponse: ProtoBuffer
-    msg: AutonatMsg
-
-  let
-    pb = initProtoBuffer(buf)
-    r1 = pb.getField(1, msgTypeOrd)
-    r2 = pb.getField(2, pbDial)
-    r3 = pb.getField(3, pbResponse)
-  if r1.isErr() or r2.isErr() or r3.isErr(): return none(AutonatMsg)
-
-  if r1.get() and not checkedEnumAssign(msg.msgType, msgTypeOrd):
-    return none(AutonatMsg)
-  if r2.get():
-    var
-      pbPeerInfo: ProtoBuffer
-      dial: AutonatDial
-    let
-      r4 = pbDial.getField(1, pbPeerInfo)
-    if r4.isErr(): return none(AutonatMsg)
-
-    var peerInfo: AutonatPeerInfo
-    if r4.get():
-      var pid: PeerId
-      let
-        r5 = pbPeerInfo.getField(1, pid)
-        r6 = pbPeerInfo.getRepeatedField(2, peerInfo.addrs)
-      if r5.isErr() or r6.isErr(): return none(AutonatMsg)
-      if r5.get(): peerInfo.id = some(pid)
-      dial.peerInfo = some(peerInfo)
-    msg.dial = some(dial)
-
-  if r3.get():
-    var
-      statusOrd: uint
-      text: string
-      ma: MultiAddress
-      response: AutonatDialResponse
-
-    let
-      r4 = pbResponse.getField(1, statusOrd)
-      r5 = pbResponse.getField(2, text)
-      r6 = pbResponse.getField(3, ma)
-
-    if r4.isErr() or r5.isErr() or r6.isErr() or
-       (r4.get() and not checkedEnumAssign(response.status, statusOrd)):
-      return none(AutonatMsg)
-    if r5.get(): response.text = some(text)
-    if r6.get(): response.ma = some(ma)
-    msg.response = some(response)
-
-  return some(msg)
-
-proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  let pb = AutonatDial(peerInfo: some(AutonatPeerInfo(
-                         id: some(pid),
-                         addrs: addrs
-                       ))).encode()
-  await conn.writeLp(pb.buffer)
-
-proc sendResponseError(conn: Connection, status: ResponseStatus, text: string = "") {.async.} =
-  let pb = AutonatDialResponse(
-             status: status,
-             text: if text == "": none(string) else: some(text),
-             ma: none(MultiAddress)
-           ).encode()
-  await conn.writeLp(pb.buffer)
-
-proc sendResponseOk(conn: Connection, ma: MultiAddress) {.async.} =
-  let pb = AutonatDialResponse(
-             status: ResponseStatus.Ok,
-             text: some("Ok"),
-             ma: some(ma)
-           ).encode()
-  await conn.writeLp(pb.buffer)
-
-type
-  Autonat* = ref object of LPProtocol
-    sem: AsyncSemaphore
-    switch*: Switch
-
-proc dialMe*(a: Autonat, pid: PeerId, ma: MultiAddress|seq[MultiAddress]):
-    Future[MultiAddress] {.async.} =
-  let addrs = when ma is MultiAddress: @[ma] else: ma
-  let conn = await a.switch.dial(pid, addrs, AutonatCodec)
-  defer: await conn.close()
-  await conn.sendDial(a.switch.peerInfo.peerId, a.switch.peerInfo.addrs)
-  let msgOpt = AutonatMsg.decode(await conn.readLp(1024))
-  if msgOpt.isNone() or
-     msgOpt.get().msgType != DialResponse or
-     msgOpt.get().response.isNone():
-    raise newException(AutonatError, "Unexpected response")
-  let response = msgOpt.get().response.get()
-  if response.status != ResponseStatus.Ok:
-    raise newException(AutonatError, "Bad status " &
-                                      $response.status & " " &
-                                      response.text.get(""))
-  if response.ma.isNone():
-    raise newException(AutonatError, "Missing address")
-  return response.ma.get()
-
-proc tryDial(a: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.async.} =
-  try:
-    await a.sem.acquire()
-    let ma = await a.switch.dialer.tryDial(conn.peerId, addrs)
-    await conn.sendResponseOk(ma)
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    await conn.sendResponseError(DialError, exc.msg)
-  finally:
-    a.sem.release()
-
-proc handleDial(a: Autonat, conn: Connection, msg: AutonatMsg): Future[void] =
-  if msg.dial.isNone() or msg.dial.get().peerInfo.isNone():
-    return conn.sendResponseError(BadRequest, "Missing Peer Info")
-  let peerInfo = msg.dial.get().peerInfo.get()
-  if peerInfo.id.isSome() and peerInfo.id.get() != conn.peerId:
-    return conn.sendResponseError(BadRequest, "PeerId mismatch")
-
-  var isRelayed = conn.observedAddr.contains(multiCodec("p2p-circuit"))
-  if isRelayed.isErr() or isRelayed.get():
-    return conn.sendResponseError(DialRefused, "Refused to dial a relayed observed address")
-  let hostIp = conn.observedAddr[0]
-  if hostIp.isErr() or not IP.match(hostIp.get()):
-    trace "wrong observed address", address=conn.observedAddr
-    return conn.sendResponseError(InternalError, "Expected an IP address")
-  var addrs = initHashSet[MultiAddress]()
-  addrs.incl(conn.observedAddr)
-  for ma in peerInfo.addrs:
-    isRelayed = ma.contains(multiCodec("p2p-circuit"))
-    if isRelayed.isErr() or isRelayed.get():
-      continue
-    let maFirst = ma[0]
-    if maFirst.isErr() or not IP.match(maFirst.get()):
-      continue
-
-    try:
-      addrs.incl(
-        if maFirst.get() == hostIp.get():
-          ma
-        else:
-          let maEnd = ma[1..^1]
-          if maEnd.isErr(): continue
-          hostIp.get() & maEnd.get()
-      )
-    except LPError as exc:
-      continue
-    if len(addrs) >= AddressLimit:
-      break
-
-  if len(addrs) == 0:
-    return conn.sendResponseError(DialRefused, "No dialable address")
-  return a.tryDial(conn, toSeq(addrs))
-
-proc new*(T: typedesc[Autonat], switch: Switch, semSize: int = 1): T =
-  let autonat = T(switch: switch, sem: newAsyncSemaphore(semSize))
-  autonat.init()
-  autonat
-
-method init*(a: Autonat) =
-  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
-    try:
-      let msgOpt = AutonatMsg.decode(await conn.readLp(1024))
-      if msgOpt.isNone() or msgOpt.get().msgType != MsgType.Dial:
-        raise newException(AutonatError, "Received malformed message")
-      let msg = msgOpt.get()
-      await a.handleDial(conn, msg)
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      trace "exception in autonat handler", exc = exc.msg, conn
-    finally:
-      trace "exiting autonat handler", conn
-      await conn.close()
-
-  a.handler = handleStream
-  a.codec = AutonatCodec

libp2p/protocols/connectivity/autonat/client.nim

@@ -0,0 +1,70 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import stew/results
+import chronos, chronicles
+import ../../../switch,
+       ../../../multiaddress,
+       ../../../peerid
+import core
+
+logScope:
+  topics = "libp2p autonat"
+
+type
+  AutonatClient* = ref object of RootObj
+
+proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
+  let pb = AutonatDial(peerInfo: Opt.some(AutonatPeerInfo(
+                         id: Opt.some(pid),
+                         addrs: addrs
+                       ))).encode()
+  await conn.writeLp(pb.buffer)
+
+method dialMe*(self: AutonatClient, switch: Switch, pid: PeerId, addrs: seq[MultiAddress] = newSeq[MultiAddress]()):
+    Future[MultiAddress] {.base, async.} =
+
+  proc getResponseOrRaise(autonatMsg: Opt[AutonatMsg]): AutonatDialResponse {.raises: [AutonatError].} =
+    autonatMsg.withValue(msg):
+      if msg.msgType == DialResponse:
+        msg.response.withValue(res):
+          if not (res.status == Ok and res.ma.isNone()):
+            return res
+    raise newException(AutonatError, "Unexpected response")
+
+  let conn =
+    try:
+      if addrs.len == 0:
+        await switch.dial(pid, @[AutonatCodec])
+      else:
+        await switch.dial(pid, addrs, AutonatCodec)
+    except CatchableError as err:
+      raise newException(AutonatError, "Unexpected error when dialling: " & err.msg, err)
+
+  # To bypass maxConnectionsPerPeer
+  let incomingConnection = switch.connManager.expectConnection(pid, In)
+  if incomingConnection.failed() and incomingConnection.error of AlreadyExpectingConnectionError:
+    raise newException(AutonatError, incomingConnection.error.msg)
+  defer:
+    await conn.close()
+    incomingConnection.cancel() # Safer to always try to cancel cause we aren't sure if the peer dialled us or not
+    if incomingConnection.completed():
+      await (await incomingConnection).connection.close()
+  trace "sending Dial", addrs = switch.peerInfo.addrs
+  await conn.sendDial(switch.peerInfo.peerId, switch.peerInfo.addrs)
+  let response = getResponseOrRaise(AutonatMsg.decode(await conn.readLp(1024)))
+  return case response.status:
+    of ResponseStatus.Ok:
+      response.ma.tryGet()
+    of ResponseStatus.DialError:
+      raise newException(AutonatUnreachableError, "Peer could not dial us back: " & response.text.get(""))
+    else:
+      raise newException(AutonatError, "Bad status " & $response.status & " " & response.text.get(""))

libp2p/protocols/connectivity/autonat/core.nim

@@ -0,0 +1,139 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import stew/[results, objects]
+import chronos, chronicles
+import ../../../multiaddress,
+       ../../../peerid,
+       ../../../errors
+
+logScope:
+  topics = "libp2p autonat"
+
+const
+  AutonatCodec* = "/libp2p/autonat/1.0.0"
+  AddressLimit* = 8
+
+type
+  AutonatError* = object of LPError
+  AutonatUnreachableError* = object of LPError
+
+  MsgType* = enum
+    Dial = 0
+    DialResponse = 1
+
+  ResponseStatus* = enum
+    Ok = 0
+    DialError = 100
+    DialRefused = 101
+    BadRequest = 200
+    InternalError = 300
+
+  AutonatPeerInfo* = object
+    id*: Opt[PeerId]
+    addrs*: seq[MultiAddress]
+
+  AutonatDial* = object
+    peerInfo*: Opt[AutonatPeerInfo]
+
+  AutonatDialResponse* = object
+    status*: ResponseStatus
+    text*: Opt[string]
+    ma*: Opt[MultiAddress]
+
+  AutonatMsg* = object
+    msgType*: MsgType
+    dial*: Opt[AutonatDial]
+    response*: Opt[AutonatDialResponse]
+
+  NetworkReachability* {.pure.} = enum
+    Unknown, NotReachable, Reachable
+
+proc encode(p: AutonatPeerInfo): ProtoBuffer =
+  result = initProtoBuffer()
+  p.id.withValue(id):
+    result.write(1, id)
+  for ma in p.addrs:
+    result.write(2, ma.data.buffer)
+  result.finish()
+
+proc encode*(d: AutonatDial): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, MsgType.Dial.uint)
+  var dial = initProtoBuffer()
+  d.peerInfo.withValue(pinfo):
+    dial.write(1, encode(pinfo))
+  dial.finish()
+  result.write(2, dial.buffer)
+  result.finish()
+
+proc encode*(r: AutonatDialResponse): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, MsgType.DialResponse.uint)
+  var bufferResponse = initProtoBuffer()
+  bufferResponse.write(1, r.status.uint)
+  r.text.withValue(text):
+    bufferResponse.write(2, text)
+  r.ma.withValue(ma):
+    bufferResponse.write(3, ma)
+  bufferResponse.finish()
+  result.write(3, bufferResponse.buffer)
+  result.finish()
+
+proc encode*(msg: AutonatMsg): ProtoBuffer =
+  msg.dial.withValue(dial):
+    return encode(dial)
+  msg.response.withValue(res):
+    return encode(res)
+
+proc decode*(_: typedesc[AutonatMsg], buf: seq[byte]): Opt[AutonatMsg] =
+  var
+    msgTypeOrd: uint32
+    pbDial: ProtoBuffer
+    pbResponse: ProtoBuffer
+    msg: AutonatMsg
+
+  let pb = initProtoBuffer(buf)
+
+  if ? pb.getField(1, msgTypeOrd).toOpt() and not checkedEnumAssign(msg.msgType, msgTypeOrd):
+    return Opt.none(AutonatMsg)
+  if ? pb.getField(2, pbDial).toOpt():
+    var
+      pbPeerInfo: ProtoBuffer
+      dial: AutonatDial
+    let r4 = ? pbDial.getField(1, pbPeerInfo).toOpt()
+
+    var peerInfo: AutonatPeerInfo
+    if r4:
+      var pid: PeerId
+      let
+        r5 = ? pbPeerInfo.getField(1, pid).toOpt()
+        r6 = ? pbPeerInfo.getRepeatedField(2, peerInfo.addrs).toOpt()
+      if r5: peerInfo.id = Opt.some(pid)
+      dial.peerInfo = Opt.some(peerInfo)
+    msg.dial = Opt.some(dial)
+
+  if ? pb.getField(3, pbResponse).toOpt():
+    var
+      statusOrd: uint
+      text: string
+      ma: MultiAddress
+      response: AutonatDialResponse
+
+    if ? pbResponse.getField(1, statusOrd).optValue():
+      if not checkedEnumAssign(response.status, statusOrd):
+        return Opt.none(AutonatMsg)
+    if ? pbResponse.getField(2, text).optValue():
+      response.text = Opt.some(text)
+    if ? pbResponse.getField(3, ma).optValue():
+      response.ma = Opt.some(ma)
+    msg.response = Opt.some(response)
+  return Opt.some(msg)

libp2p/protocols/connectivity/autonat/server.nim

@@ -0,0 +1,160 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import std/[sets, sequtils]
+import stew/results
+import chronos, chronicles
+import ../../protocol,
+       ../../../switch,
+       ../../../multiaddress,
+       ../../../multicodec,
+       ../../../peerid,
+       ../../../utils/[semaphore, future],
+       ../../../errors
+import core
+
+export core
+
+logScope:
+  topics = "libp2p autonat"
+
+type
+  Autonat* = ref object of LPProtocol
+    sem: AsyncSemaphore
+    switch*: Switch
+    dialTimeout: Duration
+
+proc sendDial(conn: Connection, pid: PeerId, addrs: seq[MultiAddress]) {.async.} =
+  let pb = AutonatDial(peerInfo: Opt.some(AutonatPeerInfo(
+                         id: Opt.some(pid),
+                         addrs: addrs
+                       ))).encode()
+  await conn.writeLp(pb.buffer)
+
+proc sendResponseError(conn: Connection, status: ResponseStatus, text: string = "") {.async.} =
+  let pb = AutonatDialResponse(
+             status: status,
+             text: if text == "": Opt.none(string) else: Opt.some(text),
+             ma: Opt.none(MultiAddress)
+           ).encode()
+  await conn.writeLp(pb.buffer)
+
+proc sendResponseOk(conn: Connection, ma: MultiAddress) {.async.} =
+  let pb = AutonatDialResponse(
+             status: ResponseStatus.Ok,
+             text: Opt.some("Ok"),
+             ma: Opt.some(ma)
+           ).encode()
+  await conn.writeLp(pb.buffer)
+
+proc tryDial(autonat: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.async.} =
+  await autonat.sem.acquire()
+  var futs: seq[Future[Opt[MultiAddress]]]
+  try:
+    # This is to bypass the per peer max connections limit
+    let outgoingConnection = autonat.switch.connManager.expectConnection(conn.peerId, Out)
+    if outgoingConnection.failed() and outgoingConnection.error of AlreadyExpectingConnectionError:
+      await conn.sendResponseError(DialRefused, outgoingConnection.error.msg)
+      return
+    # Safer to always try to cancel cause we aren't sure if the connection was established
+    defer: outgoingConnection.cancel()
+    # tryDial is to bypass the global max connections limit
+    futs = addrs.mapIt(autonat.switch.dialer.tryDial(conn.peerId, @[it]))
+    let fut = await anyCompleted(futs).wait(autonat.dialTimeout)
+    let ma = await fut
+    ma.withValue(maddr):
+      await conn.sendResponseOk(maddr)
+    else:
+      await conn.sendResponseError(DialError, "Missing observed address")
+  except CancelledError as exc:
+    raise exc
+  except AllFuturesFailedError as exc:
+    debug "All dial attempts failed", addrs, exc = exc.msg
+    await conn.sendResponseError(DialError, "All dial attempts failed")
+  except AsyncTimeoutError as exc:
+    debug "Dial timeout", addrs, exc = exc.msg
+    await conn.sendResponseError(DialError, "Dial timeout")
+  except CatchableError as exc:
+    debug "Unexpected error", addrs, exc = exc.msg
+    await conn.sendResponseError(DialError, "Unexpected error")
+  finally:
+    autonat.sem.release()
+    for f in futs:
+      if not f.finished():
+        f.cancel()
+
+proc handleDial(autonat: Autonat, conn: Connection, msg: AutonatMsg): Future[void] =
+  let dial = msg.dial.valueOr:
+    return conn.sendResponseError(BadRequest, "Missing Dial")
+  let peerInfo = dial.peerInfo.valueOr:
+    return conn.sendResponseError(BadRequest, "Missing Peer Info")
+  peerInfo.id.withValue(id):
+    if id != conn.peerId:
+      return conn.sendResponseError(BadRequest, "PeerId mismatch")
+
+  let observedAddr = conn.observedAddr.valueOr:
+    return conn.sendResponseError(BadRequest, "Missing observed address")
+
+  var isRelayed = observedAddr.contains(multiCodec("p2p-circuit")).valueOr:
+    return conn.sendResponseError(DialRefused, "Invalid observed address")
+  if isRelayed:
+    return conn.sendResponseError(DialRefused, "Refused to dial a relayed observed address")
+  let hostIp = observedAddr[0].valueOr:
+    return conn.sendResponseError(InternalError, "Wrong observed address")
+  if not IP.match(hostIp):
+    return conn.sendResponseError(InternalError, "Expected an IP address")
+  var addrs = initHashSet[MultiAddress]()
+  addrs.incl(observedAddr)
+  trace "addrs received", addrs = peerInfo.addrs
+  for ma in peerInfo.addrs:
+    isRelayed = ma.contains(multiCodec("p2p-circuit")).valueOr: continue
+    let maFirst = ma[0].valueOr: continue
+    if not DNS_OR_IP.match(maFirst): continue
+
+    try:
+      addrs.incl(
+        if maFirst == hostIp:
+          ma
+        else:
+          let maEnd = ma[1..^1].valueOr: continue
+          hostIp & maEnd
+      )
+    except LPError as exc:
+      continue
+    if len(addrs) >= AddressLimit:
+      break
+
+  if len(addrs) == 0:
+    return conn.sendResponseError(DialRefused, "No dialable address")
+  let addrsSeq = toSeq(addrs)
+  trace "trying to dial", addrs = addrsSeq
+  return autonat.tryDial(conn, addrsSeq)
+
+proc new*(T: typedesc[Autonat], switch: Switch, semSize: int = 1, dialTimeout = 15.seconds): T =
+  let autonat = T(switch: switch, sem: newAsyncSemaphore(semSize), dialTimeout: dialTimeout)
+  proc handleStream(conn: Connection, proto: string) {.async, gcsafe.} =
+    try:
+      let msg = AutonatMsg.decode(await conn.readLp(1024)).valueOr:
+        raise newException(AutonatError, "Received malformed message")
+      if msg.msgType != MsgType.Dial:
+        raise newException(AutonatError, "Message type should be dial")
+      await autonat.handleDial(conn, msg)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      debug "exception in autonat handler", exc = exc.msg, conn
+    finally:
+      trace "exiting autonat handler", conn
+      await conn.close()
+
+  autonat.handler = handleStream
+  autonat.codec = AutonatCodec
+  autonat

libp2p/protocols/connectivity/autonat/service.nim

@@ -0,0 +1,217 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import std/[deques, sequtils]
+import chronos, metrics
+import ../../../switch
+import ../../../wire
+import client
+from core import NetworkReachability, AutonatUnreachableError
+import ../../../utils/heartbeat
+import ../../../crypto/crypto
+
+export core.NetworkReachability
+
+logScope:
+  topics = "libp2p autonatservice"
+
+declarePublicGauge(libp2p_autonat_reachability_confidence, "autonat reachability confidence", labels = ["reachability"])
+
+type
+  AutonatService* = ref object of Service
+    newConnectedPeerHandler: PeerEventHandler
+    addressMapper: AddressMapper
+    scheduleHandle: Future[void]
+    networkReachability*: NetworkReachability
+    confidence: Opt[float]
+    answers: Deque[NetworkReachability]
+    autonatClient: AutonatClient
+    statusAndConfidenceHandler: StatusAndConfidenceHandler
+    rng: ref HmacDrbgContext
+    scheduleInterval: Opt[Duration]
+    askNewConnectedPeers: bool
+    numPeersToAsk: int
+    maxQueueSize: int
+    minConfidence: float
+    dialTimeout: Duration
+    enableAddressMapper: bool
+
+  StatusAndConfidenceHandler* = proc (networkReachability: NetworkReachability, confidence: Opt[float]): Future[void]  {.gcsafe, raises: [].}
+
+proc new*(
+  T: typedesc[AutonatService],
+  autonatClient: AutonatClient,
+  rng: ref HmacDrbgContext,
+  scheduleInterval: Opt[Duration] = Opt.none(Duration),
+  askNewConnectedPeers = true,
+  numPeersToAsk: int = 5,
+  maxQueueSize: int = 10,
+  minConfidence: float = 0.3,
+  dialTimeout = 30.seconds,
+  enableAddressMapper = true): T =
+  return T(
+    scheduleInterval: scheduleInterval,
+    networkReachability: Unknown,
+    confidence: Opt.none(float),
+    answers: initDeque[NetworkReachability](),
+    autonatClient: autonatClient,
+    rng: rng,
+    askNewConnectedPeers: askNewConnectedPeers,
+    numPeersToAsk: numPeersToAsk,
+    maxQueueSize: maxQueueSize,
+    minConfidence: minConfidence,
+    dialTimeout: dialTimeout,
+    enableAddressMapper: enableAddressMapper)
+
+proc callHandler(self: AutonatService) {.async.} =
+  if not isNil(self.statusAndConfidenceHandler):
+    await self.statusAndConfidenceHandler(self.networkReachability, self.confidence)
+
+proc hasEnoughIncomingSlots(switch: Switch): bool =
+  # we leave some margin instead of comparing to 0 as a peer could connect to us while we are asking for the dial back
+  return switch.connManager.slotsAvailable(In) >= 2
+
+proc doesPeerHaveIncomingConn(switch: Switch, peerId: PeerId): bool =
+  return switch.connManager.selectMuxer(peerId, In) != nil
+
+proc handleAnswer(self: AutonatService, ans: NetworkReachability): Future[bool] {.async.} =
+
+  if ans == Unknown:
+    return
+
+  let oldNetworkReachability = self.networkReachability
+  let oldConfidence = self.confidence
+
+  if self.answers.len == self.maxQueueSize:
+    self.answers.popFirst()
+  self.answers.addLast(ans)
+
+  self.networkReachability = Unknown
+  self.confidence = Opt.none(float)
+  const reachabilityPriority = [Reachable, NotReachable]
+  for reachability in reachabilityPriority:
+    let confidence = self.answers.countIt(it == reachability) / self.maxQueueSize
+    libp2p_autonat_reachability_confidence.set(value = confidence, labelValues = [$reachability])
+    if self.confidence.isNone and confidence >= self.minConfidence:
+      self.networkReachability = reachability
+      self.confidence = Opt.some(confidence)
+
+  debug "Current status", currentStats = $self.networkReachability, confidence = $self.confidence, answers = self.answers
+
+  # Return whether anything has changed
+  return self.networkReachability != oldNetworkReachability or self.confidence != oldConfidence
+
+proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[NetworkReachability] {.async.} =
+  logScope:
+    peerId = $peerId
+
+  if doesPeerHaveIncomingConn(switch, peerId):
+    return Unknown
+
+  if not hasEnoughIncomingSlots(switch):
+    debug "No incoming slots available, not asking peer", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
+    return Unknown
+
+  trace "Asking peer for reachability"
+  let ans =
+    try:
+      discard await self.autonatClient.dialMe(switch, peerId).wait(self.dialTimeout)
+      debug "dialMe answer is reachable"
+      Reachable
+    except AutonatUnreachableError as error:
+      debug "dialMe answer is not reachable", msg = error.msg
+      NotReachable
+    except AsyncTimeoutError as error:
+      debug "dialMe timed out", msg = error.msg
+      Unknown
+    except CatchableError as error:
+      debug "dialMe unexpected error", msg = error.msg
+      Unknown
+  let hasReachabilityOrConfidenceChanged = await self.handleAnswer(ans)
+  if hasReachabilityOrConfidenceChanged:
+    await self.callHandler()
+  await switch.peerInfo.update()
+  return ans
+
+proc askConnectedPeers(self: AutonatService, switch: Switch) {.async.} =
+  trace "Asking peers for reachability"
+  var peers = switch.connectedPeers(Direction.Out)
+  self.rng.shuffle(peers)
+  var answersFromPeers = 0
+  for peer in peers:
+    if answersFromPeers >= self.numPeersToAsk:
+      break
+    if not hasEnoughIncomingSlots(switch):
+      debug "No incoming slots available, not asking peers", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
+      break
+    if (await askPeer(self, switch, peer)) != Unknown:
+      answersFromPeers.inc()
+
+proc schedule(service: AutonatService, switch: Switch, interval: Duration) {.async.} =
+  heartbeat "Scheduling AutonatService run", interval:
+    await service.run(switch)
+
+proc addressMapper(
+  self: AutonatService,
+  peerStore: PeerStore,
+  listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.gcsafe, async.} =
+
+  if self.networkReachability != NetworkReachability.Reachable:
+    return listenAddrs
+
+  var addrs = newSeq[MultiAddress]()
+  for listenAddr in listenAddrs:
+    var processedMA = listenAddr
+    try:
+      if not listenAddr.isPublicMA() and self.networkReachability == NetworkReachability.Reachable:
+        processedMA = peerStore.guessDialableAddr(listenAddr) # handle manual port forwarding
+    except CatchableError as exc:
+      debug "Error while handling address mapper", msg = exc.msg
+    addrs.add(processedMA)
+  return addrs
+
+method setup*(self: AutonatService, switch: Switch): Future[bool] {.async.} =
+  self.addressMapper = proc (listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.gcsafe, async.} =
+    return await addressMapper(self, switch.peerStore, listenAddrs)
+
+  info "Setting up AutonatService"
+  let hasBeenSetup = await procCall Service(self).setup(switch)
+  if hasBeenSetup:
+    if self.askNewConnectedPeers:
+      self.newConnectedPeerHandler = proc (peerId: PeerId, event: PeerEvent): Future[void] {.async.} =
+        discard askPeer(self, switch, peerId)
+      switch.connManager.addPeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
+    self.scheduleInterval.withValue(interval):
+      self.scheduleHandle = schedule(self, switch, interval)
+    if self.enableAddressMapper:
+      switch.peerInfo.addressMappers.add(self.addressMapper)
+  return hasBeenSetup
+
+method run*(self: AutonatService, switch: Switch) {.async, public.} =
+  trace "Running AutonatService"
+  await askConnectedPeers(self, switch)
+
+method stop*(self: AutonatService, switch: Switch): Future[bool] {.async, public.} =
+  info "Stopping AutonatService"
+  let hasBeenStopped = await procCall Service(self).stop(switch)
+  if hasBeenStopped:
+    if not isNil(self.scheduleHandle):
+      self.scheduleHandle.cancel()
+      self.scheduleHandle = nil
+    if not isNil(self.newConnectedPeerHandler):
+      switch.connManager.removePeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
+    if self.enableAddressMapper:
+      switch.peerInfo.addressMappers.keepItIf(it != self.addressMapper)
+    await switch.peerInfo.update()
+  return hasBeenStopped
+
+proc statusAndConfidenceHandler*(self: AutonatService, statusAndConfidenceHandler: StatusAndConfidenceHandler) =
+  self.statusAndConfidenceHandler = statusAndConfidenceHandler

libp2p/protocols/connectivity/dcutr/client.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.
+
+{.push raises: [].}
+
+import std/sequtils
+
+import stew/results
+import chronos, chronicles
+
+import core
+import ../../protocol,
+       ../../../stream/connection,
+       ../../../switch,
+       ../../../utils/future
+
+export DcutrError
+
+type
+  DcutrClient* = ref object
+    connectTimeout: Duration
+    maxDialableAddrs: int
+
+logScope:
+  topics = "libp2p dcutrclient"
+
+proc new*(T: typedesc[DcutrClient], connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
+  return T(connectTimeout: connectTimeout, maxDialableAddrs: maxDialableAddrs)
+
+proc startSync*(self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs: seq[MultiAddress]) {.async.} =
+  logScope:
+    peerId = switch.peerInfo.peerId
+
+  var
+    peerDialableAddrs: seq[MultiAddress]
+    stream: Connection
+  try:
+    var ourDialableAddrs = getHolePunchableAddrs(addrs)
+    if ourDialableAddrs.len == 0:
+      debug "Dcutr initiator has no supported dialable addresses. Aborting Dcutr.", addrs
+      return
+
+    stream = await switch.dial(remotePeerId, DcutrCodec)
+    await stream.send(MsgType.Connect, addrs)
+    debug "Dcutr initiator has sent a Connect message."
+    let rttStart = Moment.now()
+    let connectAnswer = DcutrMsg.decode(await stream.readLp(1024))
+
+    peerDialableAddrs = getHolePunchableAddrs(connectAnswer.addrs)
+    if peerDialableAddrs.len == 0:
+      debug "Dcutr receiver has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectAnswer.addrs
+      return
+
+    let rttEnd = Moment.now()
+    debug "Dcutr initiator has received a Connect message back.", connectAnswer
+    let halfRtt = (rttEnd - rttStart) div 2'i64
+    await stream.send(MsgType.Sync, @[])
+    debug "Dcutr initiator has sent a Sync message."
+    await sleepAsync(halfRtt)
+
+    if peerDialableAddrs.len > self.maxDialableAddrs:
+        peerDialableAddrs = peerDialableAddrs[0..<self.maxDialableAddrs]
+    var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false))
+    try:
+      discard await anyCompleted(futs).wait(self.connectTimeout)
+      debug "Dcutr initiator has directly connected to the remote peer."
+    finally:
+      for fut in futs: fut.cancel()
+  except CancelledError as err:
+    raise err
+  except AllFuturesFailedError as err:
+    debug "Dcutr initiator could not connect to the remote peer, all connect attempts failed", peerDialableAddrs, msg = err.msg
+    raise newException(DcutrError, "Dcutr initiator could not connect to the remote peer, all connect attempts failed", err)
+  except AsyncTimeoutError as err:
+    debug "Dcutr initiator could not connect to the remote peer, all connect attempts timed out", peerDialableAddrs, msg = err.msg
+    raise newException(DcutrError, "Dcutr initiator could not connect to the remote peer, all connect attempts timed out", err)
+  except CatchableError as err:
+    debug "Unexpected error when Dcutr initiator tried to connect to the remote peer", err = err.msg
+    raise newException(DcutrError, "Unexpected error when Dcutr initiator tried to connect to the remote peer", err)
+  finally:
+    if stream != nil:
+      await stream.close()
+

libp2p/protocols/connectivity/dcutr/core.nim

@@ -0,0 +1,60 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import std/sequtils
+
+import chronos
+import stew/objects
+
+import ../../../multiaddress,
+       ../../../errors,
+       ../../../stream/connection
+
+export multiaddress
+
+const
+  DcutrCodec* = "/libp2p/dcutr"
+
+type
+  MsgType* = enum
+    Connect = 100
+    Sync = 300
+
+  DcutrMsg* = object
+    msgType*: MsgType
+    addrs*: seq[MultiAddress]
+
+  DcutrError* = object of LPError
+
+proc encode*(msg: DcutrMsg): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, msg.msgType.uint)
+  for addr in msg.addrs:
+    result.write(2, addr)
+  result.finish()
+
+proc decode*(_: typedesc[DcutrMsg], buf: seq[byte]): DcutrMsg {.raises: [DcutrError].} =
+  var
+    msgTypeOrd: uint32
+    dcutrMsg: DcutrMsg
+  var pb = initProtoBuffer(buf)
+  var r1 = pb.getField(1, msgTypeOrd)
+  let r2 = pb.getRepeatedField(2, dcutrMsg.addrs)
+  if r1.isErr or r2.isErr or not checkedEnumAssign(dcutrMsg.msgType, msgTypeOrd):
+    raise newException(DcutrError, "Received malformed message")
+  return dcutrMsg
+
+proc send*(conn: Connection, msgType: MsgType, addrs: seq[MultiAddress]) {.async.} =
+  let pb = DcutrMsg(msgType: msgType, addrs: addrs).encode()
+  await conn.writeLp(pb.buffer)
+
+proc getHolePunchableAddrs*(addrs: seq[MultiAddress]): seq[MultiAddress] =
+  addrs.filterIt(TCP.match(it))

libp2p/protocols/connectivity/dcutr/server.nim

@@ -0,0 +1,80 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import std/[sets, sequtils]
+import stew/[results, objects]
+import chronos, chronicles
+
+import core
+import ../../protocol,
+       ../../../stream/connection,
+       ../../../switch,
+       ../../../utils/future
+
+export DcutrError
+export chronicles
+
+type Dcutr* = ref object of LPProtocol
+
+logScope:
+  topics = "libp2p dcutr"
+
+proc new*(T: typedesc[Dcutr], switch: Switch, connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
+
+  proc handleStream(stream: Connection, proto: string) {.async, gcsafe.} =
+    var peerDialableAddrs: seq[MultiAddress]
+    try:
+      let connectMsg = DcutrMsg.decode(await stream.readLp(1024))
+      debug "Dcutr receiver received a Connect message.", connectMsg
+
+      var ourAddrs = switch.peerStore.getMostObservedProtosAndPorts() # likely empty when the peer is reachable
+      if ourAddrs.len == 0:
+        # this list should be the same as the peer's public addrs when it is reachable
+        ourAddrs =  switch.peerInfo.listenAddrs.mapIt(switch.peerStore.guessDialableAddr(it))
+      var ourDialableAddrs = getHolePunchableAddrs(ourAddrs)
+      if ourDialableAddrs.len == 0:
+        debug "Dcutr receiver has no supported dialable addresses. Aborting Dcutr.", ourAddrs
+        return
+
+      await stream.send(MsgType.Connect, ourAddrs)
+      debug "Dcutr receiver has sent a Connect message back."
+      let syncMsg = DcutrMsg.decode(await stream.readLp(1024))
+      debug "Dcutr receiver has received a Sync message.", syncMsg
+
+      peerDialableAddrs = getHolePunchableAddrs(connectMsg.addrs)
+      if peerDialableAddrs.len == 0:
+        debug "Dcutr initiator has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectMsg.addrs
+        return
+
+      if peerDialableAddrs.len > maxDialableAddrs:
+        peerDialableAddrs = peerDialableAddrs[0..<maxDialableAddrs]
+      var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false, upgradeDir = Direction.In))
+      try:
+        discard await anyCompleted(futs).wait(connectTimeout)
+        debug "Dcutr receiver has directly connected to the remote peer."
+      finally:
+        for fut in futs: fut.cancel()
+    except CancelledError as err:
+      raise err
+    except AllFuturesFailedError as err:
+      debug "Dcutr receiver could not connect to the remote peer, all connect attempts failed", peerDialableAddrs, msg = err.msg
+      raise newException(DcutrError, "Dcutr receiver could not connect to the remote peer, all connect attempts failed", err)
+    except AsyncTimeoutError as err:
+      debug "Dcutr receiver could not connect to the remote peer, all connect attempts timed out", peerDialableAddrs, msg = err.msg
+      raise newException(DcutrError, "Dcutr receiver could not connect to the remote peer, all connect attempts timed out", err)
+    except CatchableError as err:
+      warn "Unexpected error when Dcutr receiver tried to connect to the remote peer", msg = err.msg
+      raise newException(DcutrError, "Unexpected error when Dcutr receiver tried to connect to the remote peer", err)
+
+  let self = T()
+  self.handler = handleStream
+  self.codec = DcutrCodec
+  self

libp2p/protocols/connectivity/relay/client.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,15 +7,10 @@
 # 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
+{.push raises: [].}
 
+import times
 import chronos, chronicles
-
 import ./relay,
        ./messages,
        ./rconn,
@@ -25,7 +20,6 @@ import ./relay,
        ../../../multiaddress,
        ../../../stream/connection
 
-
 logScope:
   topics = "libp2p relay relay-client"
 
@@ -38,7 +32,7 @@ type
   RelayV2DialError* = object of RelayClientError
   RelayClientAddConn* = proc(conn: Connection,
                         duration: uint32,
-                        data: uint64): Future[void] {.gcsafe, raises: [Defect].}
+                        data: uint64): Future[void] {.gcsafe, raises: [].}
   RelayClient* = ref object of Relay
     onNewConnection*: RelayClientAddConn
     canHop: bool
@@ -46,28 +40,27 @@ type
   Rsvp* = object
     expire*: uint64           # required, Unix expiration time (UTC)
     addrs*: seq[MultiAddress] # relay address for reserving peer
-    voucher*: Option[Voucher] # optional, reservation voucher
+    voucher*: Opt[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))
+  let msg = StopMessage(msgType: StopMessageType.Status, status: Opt.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()
+    src = msg.peer.valueOr:
+      await sendStopError(conn, MalformedMessage)
+      return
     limitDuration = msg.limit.duration
     limitData = msg.limit.data
     msg = StopMessage(
       msgType: StopMessageType.Status,
-      status: some(Ok))
+      status: Opt.some(Ok))
     pb = encode(msg)
 
   trace "incoming relay connection", src
@@ -91,7 +84,7 @@ proc reserve*(cl: RelayClient,
     pb = encode(HopMessage(msgType: HopMessageType.Reserve))
     msg = try:
       await conn.writeLp(pb.buffer)
-      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).get()
+      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
@@ -102,21 +95,21 @@ proc reserve*(cl: RelayClient,
     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()
+  let reservation = msg.reservation.valueOr:
+    raise newException(ReservationError, "Missing reservation information")
   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:
+  reservation.svoucher.withValue(sv):
+    let svoucher = SignedVoucher.decode(sv).valueOr:
       raise newException(ReservationError, "Invalid voucher")
-    result.voucher = some(svoucher.get().data)
+    if svoucher.data.relayPeerId != peerId:
+      raise newException(ReservationError, "Invalid voucher PeerId")
+    result.voucher = Opt.some(svoucher.data)
 
   result.limitDuration = msg.limit.duration
   result.limitData = msg.limit.data
@@ -128,9 +121,9 @@ proc dialPeerV1*(
     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)))
+      msgType: Opt.some(RelayType.Hop),
+      srcPeer: Opt.some(RelayPeer(peerId: cl.switch.peerInfo.peerId, addrs: cl.switch.peerInfo.addrs)),
+      dstPeer: Opt.some(RelayPeer(peerId: dstPeerId, addrs: dstAddrs)))
     pb = encode(msg)
 
   trace "Dial peer", msgSend=msg
@@ -153,16 +146,18 @@ proc dialPeerV1*(
     raise exc
 
   try:
-    if msgRcvFromRelayOpt.isNone:
+    let msgRcvFromRelay = msgRcvFromRelayOpt.valueOr:
       raise newException(RelayV1DialError, "Hop can't open destination stream")
-    let msgRcvFromRelay = msgRcvFromRelayOpt.get()
-    if msgRcvFromRelay.msgType.isNone or msgRcvFromRelay.msgType.get() != RelayType.Status:
+    if msgRcvFromRelay.msgType.tryGet() != RelayType.Status:
       raise newException(RelayV1DialError, "Hop can't open destination stream: wrong message type")
-    if msgRcvFromRelay.status.isNone or msgRcvFromRelay.status.get() != StatusV1.Success:
+    if msgRcvFromRelay.status.tryGet() != StatusV1.Success:
       raise newException(RelayV1DialError, "Hop can't open destination stream: status failed")
   except RelayV1DialError as exc:
     await sendStatus(conn, StatusV1.HopCantOpenDstStream)
     raise exc
+  except ValueError as exc:
+    await sendStatus(conn, StatusV1.HopCantOpenDstStream)
+    raise newException(RelayV1DialError, exc.msg)
   result = conn
 
 proc dialPeerV2*(
@@ -172,13 +167,13 @@ proc dialPeerV2*(
     dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
   let
     p = Peer(peerId: dstPeerId, addrs: dstAddrs)
-    pb = encode(HopMessage(msgType: HopMessageType.Connect, peer: some(p)))
+    pb = encode(HopMessage(msgType: HopMessageType.Connect, peer: Opt.some(p)))
 
   trace "Dial peer", p
 
   let msgRcvFromRelay = try:
     await conn.writeLp(pb.buffer)
-    HopMessage.decode(await conn.readLp(RelayClientMsgSize)).get()
+    HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
@@ -188,19 +183,17 @@ proc dialPeerV2*(
   if msgRcvFromRelay.msgType != HopMessageType.Status:
     raise newException(RelayV2DialError, "Unexpected stop response")
   if msgRcvFromRelay.status.get(UnexpectedMessage) != Ok:
-    trace "Relay stop failed", msg = msgRcvFromRelay.status.get()
+    trace "Relay stop failed", msg = msgRcvFromRelay.status
     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():
+  let msg = StopMessage.decode(await conn.readLp(RelayClientMsgSize)).valueOr:
     await sendHopStatus(conn, MalformedMessage)
     return
-  trace "client circuit relay v2 handle stream", msg = msgOpt.get()
-  let msg = msgOpt.get()
+  trace "client circuit relay v2 handle stream", msg
 
   if msg.msgType == StopMessageType.Connect:
     await cl.handleRelayedConnect(conn, msg)
@@ -209,16 +202,14 @@ proc handleStopStreamV2(cl: RelayClient, conn: Connection) {.async, gcsafe.} =
     await sendStopError(conn, MalformedMessage)
 
 proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async, gcsafe.} =
-  if msg.srcPeer.isNone:
+  let src = msg.srcPeer.valueOr:
     await sendStatus(conn, StatusV1.StopSrcMultiaddrInvalid)
     return
-  let src = msg.srcPeer.get()
 
-  if msg.dstPeer.isNone:
+  let dst = msg.dstPeer.valueOr:
     await sendStatus(conn, StatusV1.StopDstMultiaddrInvalid)
     return
 
-  let dst = msg.dstPeer.get()
   if dst.peerId != cl.switch.peerInfo.peerId:
     await sendStatus(conn, StatusV1.StopDstMultiaddrInvalid)
     return
@@ -236,13 +227,16 @@ proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async, g
   else: await conn.close()
 
 proc handleStreamV1(cl: RelayClient, conn: Connection) {.async, gcsafe.} =
-  let msgOpt = RelayMessage.decode(await conn.readLp(RelayClientMsgSize))
-  if msgOpt.isNone:
+  let msg = RelayMessage.decode(await conn.readLp(RelayClientMsgSize)).valueOr:
     await sendStatus(conn, StatusV1.MalformedMessage)
     return
-  trace "client circuit relay v1 handle stream", msg = msgOpt.get()
-  let msg = msgOpt.get()
-  case msg.msgType.get:
+  trace "client circuit relay v1 handle stream", msg
+
+  let typ = msg.msgType.valueOr:
+    trace "Message type not set"
+    await sendStatus(conn, StatusV1.MalformedMessage)
+    return
+  case typ:
     of RelayType.Hop:
       if cl.canHop: await cl.handleHop(conn, msg)
       else: await sendStatus(conn, StatusV1.HopCantSpeakRelay)

libp2p/protocols/connectivity/relay/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,13 +7,10 @@
 # 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: [].}
+{.push raises: [].}
 
-import options, macros, sequtils
-import stew/objects
+import macros
+import stew/[objects, results]
 import ../../../peerinfo,
        ../../../signed_envelope
 
@@ -49,36 +46,36 @@ type
     addrs*: seq[MultiAddress]
 
   RelayMessage* = object
-    msgType*: Option[RelayType]
-    srcPeer*: Option[RelayPeer]
-    dstPeer*: Option[RelayPeer]
-    status*: Option[StatusV1]
+    msgType*: Opt[RelayType]
+    srcPeer*: Opt[RelayPeer]
+    dstPeer*: Opt[RelayPeer]
+    status*: Opt[StatusV1]
 
 proc encode*(msg: RelayMessage): ProtoBuffer =
   result = initProtoBuffer()
 
-  if isSome(msg.msgType):
-    result.write(1, msg.msgType.get().ord.uint)
-  if isSome(msg.srcPeer):
+  msg.msgType.withValue(typ):
+    result.write(1, typ.ord.uint)
+  msg.srcPeer.withValue(srcPeer):
     var peer = initProtoBuffer()
-    peer.write(1, msg.srcPeer.get().peerId)
-    for ma in msg.srcPeer.get().addrs:
+    peer.write(1, srcPeer.peerId)
+    for ma in srcPeer.addrs:
       peer.write(2, ma.data.buffer)
     peer.finish()
     result.write(2, peer.buffer)
-  if isSome(msg.dstPeer):
+  msg.dstPeer.withValue(dstPeer):
     var peer = initProtoBuffer()
-    peer.write(1, msg.dstPeer.get().peerId)
-    for ma in msg.dstPeer.get().addrs:
+    peer.write(1, dstPeer.peerId)
+    for ma in dstPeer.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)
+  msg.status.withValue(status):
+    result.write(4, status.ord.uint)
 
   result.finish()
 
-proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Option[RelayMessage] =
+proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Opt[RelayMessage] =
   var
     rMsg: RelayMessage
     msgTypeOrd: uint32
@@ -88,37 +85,29 @@ proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Option[RelayMessage] =
     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)
+  let pb = initProtoBuffer(buf)
 
-  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 ? pb.getField(1, msgTypeOrd).toOpt():
     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)
+      return Opt.none(RelayMessage)
+    rMsg.msgType = Opt.some(RelayType(msgTypeOrd))
+
+  if ? pb.getField(2, pbSrc).toOpt():
+    discard ? pbSrc.getField(1, src.peerId).toOpt()
+    discard ? pbSrc.getRepeatedField(2, src.addrs).toOpt()
+    rMsg.srcPeer = Opt.some(src)
+
+  if ? pb.getField(3, pbDst).toOpt():
+    discard ? pbDst.getField(1, dst.peerId).toOpt()
+    discard ? pbDst.getRepeatedField(2, dst.addrs).toOpt()
+    rMsg.dstPeer = Opt.some(dst)
+
+  if ? pb.getField(4, statusOrd).toOpt():
+    var status: StatusV1
+    if not checkedEnumAssign(status, statusOrd):
+      return Opt.none(RelayMessage)
+    rMsg.status = Opt.some(status)
+  Opt.some(rMsg)
 
 # Voucher
 
@@ -178,7 +167,7 @@ type
   Reservation* = object
     expire*: uint64              # required, Unix expiration time (UTC)
     addrs*: seq[MultiAddress]    # relay address for reserving peer
-    svoucher*: Option[seq[byte]] # optional, reservation voucher
+    svoucher*: Opt[seq[byte]]    # optional, reservation voucher
   Limit* = object
     duration*: uint32            # seconds
     data*: uint64                # bytes
@@ -198,30 +187,29 @@ type
     Status = 2
   HopMessage* = object
     msgType*: HopMessageType
-    peer*: Option[Peer]
-    reservation*: Option[Reservation]
+    peer*: Opt[Peer]
+    reservation*: Opt[Reservation]
     limit*: Limit
-    status*: Option[StatusV2]
+    status*: Opt[StatusV2]
 
 proc encode*(msg: HopMessage): ProtoBuffer =
   var pb = initProtoBuffer()
 
   pb.write(1, msg.msgType.ord.uint)
-  if msg.peer.isSome():
+  msg.peer.withValue(peer):
     var ppb = initProtoBuffer()
-    ppb.write(1, msg.peer.get().peerId)
-    for ma in msg.peer.get().addrs:
+    ppb.write(1, peer.peerId)
+    for ma in peer.addrs:
       ppb.write(2, ma.data.buffer)
     ppb.finish()
     pb.write(2, ppb.buffer)
-  if msg.reservation.isSome():
-    let rsrv = msg.reservation.get()
+  msg.reservation.withValue(rsrv):
     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())
+    rsrv.svoucher.withValue(vouch):
+      rpb.write(3, vouch)
     rpb.finish()
     pb.write(3, rpb.buffer)
   if msg.limit.duration > 0 or msg.limit.data > 0:
@@ -230,65 +218,51 @@ proc encode*(msg: HopMessage): ProtoBuffer =
     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)
+  msg.status.withValue(status):
+    pb.write(5, status.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)
+proc decode*(_: typedesc[HopMessage], buf: seq[byte]): Opt[HopMessage] =
+  var msg: HopMessage
+  let pb = initProtoBuffer(buf)
 
+  var msgTypeOrd: uint32
+  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
   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)
+    return Opt.none(HopMessage)
+
+  var pbPeer: ProtoBuffer
+  if ? pb.getField(2, pbPeer).toOpt():
+    var peer: Peer
+    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
+    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
+    msg.peer = Opt.some(peer)
+
+  var pbReservation: ProtoBuffer
+  if ? pb.getField(3, pbReservation).toOpt():
+    var
+      svoucher: seq[byte]
+      reservation: Reservation
+    if ? pbReservation.getField(3, svoucher).toOpt():
+      reservation.svoucher = Opt.some(svoucher)
+    ? pbReservation.getRequiredField(1, reservation.expire).toOpt()
+    discard ? pbReservation.getRepeatedField(2, reservation.addrs).toOpt()
+    msg.reservation = Opt.some(reservation)
+
+  var pbLimit: ProtoBuffer
+  if ? pb.getField(4, pbLimit).toOpt():
+    discard ? pbLimit.getField(1, msg.limit.duration).toOpt()
+    discard ? pbLimit.getField(2, msg.limit.data).toOpt()
+
+  var statusOrd: uint32
+  if ? pb.getField(5, statusOrd).toOpt():
+    var status: StatusV2
+    if not checkedEnumAssign(status, statusOrd):
+      return Opt.none(HopMessage)
+    msg.status = Opt.some(status)
+  Opt.some(msg)
 
 # Circuit Relay V2 Stop Message
 
@@ -298,19 +272,19 @@ type
     Status = 1
   StopMessage* = object
     msgType*: StopMessageType
-    peer*: Option[Peer]
+    peer*: Opt[Peer]
     limit*: Limit
-    status*: Option[StatusV2]
+    status*: Opt[StatusV2]
 
 
 proc encode*(msg: StopMessage): ProtoBuffer =
   var pb = initProtoBuffer()
 
   pb.write(1, msg.msgType.ord.uint)
-  if msg.peer.isSome():
+  msg.peer.withValue(peer):
     var ppb = initProtoBuffer()
-    ppb.write(1, msg.peer.get().peerId)
-    for ma in msg.peer.get().addrs:
+    ppb.write(1, peer.peerId)
+    for ma in peer.addrs:
       ppb.write(2, ma.data.buffer)
     ppb.finish()
     pb.write(2, ppb.buffer)
@@ -320,51 +294,40 @@ proc encode*(msg: StopMessage): ProtoBuffer =
     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)
+  msg.status.withValue(status):
+    pb.write(4, status.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
+proc decode*(_: typedesc[StopMessage], buf: seq[byte]): Opt[StopMessage] =
+  var msg: StopMessage
 
-  let
-    pb = initProtoBuffer(buf)
-    r1 = pb.getRequiredField(1, msgTypeOrd)
-    r2 = pb.getField(2, pbPeer)
-    r3 = pb.getField(3, pbLimit)
-    r4 = pb.getField(4, statusOrd)
+  let pb = initProtoBuffer(buf)
 
-  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)
+  var msgTypeOrd: uint32
+  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
+  if msgTypeOrd.int notin StopMessageType:
+    return Opt.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)
+
+
+  var pbPeer: ProtoBuffer
+  if ? pb.getField(2, pbPeer).toOpt():
+    var peer: Peer
+    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
+    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
+    msg.peer = Opt.some(peer)
+
+  var pbLimit: ProtoBuffer
+  if ? pb.getField(3, pbLimit).toOpt():
+    discard ? pbLimit.getField(1, msg.limit.duration).toOpt()
+    discard ? pbLimit.getField(2, msg.limit.data).toOpt()
+
+  var statusOrd: uint32
+  if ? pb.getField(4, statusOrd).toOpt():
+    var status: StatusV2
+    if not checkedEnumAssign(status, statusOrd):
+      return Opt.none(StopMessage)
+    msg.status = Opt.some(status)
+  Opt.some(msg)

libp2p/protocols/connectivity/relay/rconn.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,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import chronos
 

libp2p/protocols/connectivity/relay/relay.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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import options, sequtils, tables, sugar
+import sequtils, tables
 
 import chronos, chronicles
 
@@ -25,7 +22,6 @@ import ./messages,
        ../../../multicodec,
        ../../../stream/connection,
        ../../../protocols/protocol,
-       ../../../transports/transport,
        ../../../errors,
        ../../../utils/heartbeat,
        ../../../signed_envelope
@@ -94,14 +90,14 @@ proc createReserveResponse(
     rsrv = Reservation(expire: expireUnix,
                        addrs: r.switch.peerInfo.addrs.mapIt(
                          ? it.concat(ma).orErr(CryptoError.KeyError)),
-                       svoucher: some(? sv.encode))
+                       svoucher: Opt.some(? sv.encode))
     msg = HopMessage(msgType: HopMessageType.Status,
-                     reservation: some(rsrv),
+                     reservation: Opt.some(rsrv),
                      limit: r.limit,
-                     status: some(Ok))
+                     status: Opt.some(Ok))
   return ok(msg)
 
-proc isRelayed(conn: Connection): bool =
+proc isRelayed*(conn: Connection): bool =
   var wrappedConn = conn
   while not isNil(wrappedConn):
     if wrappedConn of RelayConnection:
@@ -119,17 +115,16 @@ proc handleReserve(r: Relay, conn: Connection) {.async, gcsafe.} =
     trace "Too many reservations", pid = conn.peerId
     await sendHopStatus(conn, ReservationRefused)
     return
+  trace "reserving relay slot for", pid = conn.peerId
   let
     pid = conn.peerId
     expire = now().utc + r.reservationTTL
-    msg = r.createReserveResponse(pid, expire)
+    msg = r.createReserveResponse(pid, expire).valueOr:
+      trace "error signing the voucher", pid
+      return
 
-  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)
+  await conn.writeLp(encode(msg).buffer)
 
 proc handleConnect(r: Relay,
                    connSrc: Connection,
@@ -138,13 +133,12 @@ proc handleConnect(r: Relay,
     trace "connection attempt over relay connection"
     await sendHopStatus(connSrc, PermissionDenied)
     return
-  if msg.peer.isNone():
-    await sendHopStatus(connSrc, MalformedMessage)
-    return
-
   let
+    msgPeer = msg.peer.valueOr:
+      await sendHopStatus(connSrc, MalformedMessage)
+      return
     src = connSrc.peerId
-    dst = msg.peer.get().peerId
+    dst = msgPeer.peerId
   if dst notin r.rsvp:
     trace "refusing connection, no reservation", src, dst
     await sendHopStatus(connSrc, NoReservation)
@@ -177,16 +171,17 @@ proc handleConnect(r: Relay,
 
   proc sendStopMsg() {.async.} =
     let stopMsg = StopMessage(msgType: StopMessageType.Connect,
-                            peer: some(Peer(peerId: src, addrs: @[])),
+                            peer: Opt.some(Peer(peerId: src, addrs: @[])),
                             limit: r.limit)
     await connDst.writeLp(encode(stopMsg).buffer)
-    let msg = StopMessage.decode(await connDst.readLp(r.msgSize)).get()
+    let msg = StopMessage.decode(await connDst.readLp(r.msgSize)).valueOr:
+      raise newException(SendStopError, "Malformed message")
     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)
+                                          status: Opt.some(Ok))).buffer)
   try:
     await sendStopMsg()
   except CancelledError as exc:
@@ -206,12 +201,10 @@ proc handleConnect(r: Relay,
   await bridge(rconnSrc, rconnDst)
 
 proc handleHopStreamV2*(r: Relay, conn: Connection) {.async, gcsafe.} =
-  let msgOpt = HopMessage.decode(await conn.readLp(r.msgSize))
-  if msgOpt.isNone():
+  let msg = HopMessage.decode(await conn.readLp(r.msgSize)).valueOr:
     await sendHopStatus(conn, MalformedMessage)
     return
-  trace "relayv2 handle stream", msg = msgOpt.get()
-  let msg = msgOpt.get()
+  trace "relayv2 handle stream", msg = msg
   case msg.msgType:
   of HopMessageType.Reserve: await r.handleReserve(conn)
   of HopMessageType.Connect: await r.handleConnect(conn, msg)
@@ -229,15 +222,14 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsaf
     await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
     return
 
+  var src, dst: RelayPeer
   proc checkMsg(): Result[RelayMessage, StatusV1] =
-    if msg.srcPeer.isNone:
+    src = msg.srcPeer.valueOr:
       return err(StatusV1.HopSrcMultiaddrInvalid)
-    let src = msg.srcPeer.get()
     if src.peerId != connSrc.peerId:
       return err(StatusV1.HopSrcMultiaddrInvalid)
-    if msg.dstPeer.isNone:
+    dst = msg.dstPeer.valueOr:
       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):
@@ -249,9 +241,6 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsaf
     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
@@ -275,9 +264,9 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsaf
     await connDst.close()
 
   let msgToSend = RelayMessage(
-    msgType: some(RelayType.Stop),
-    srcPeer: some(src),
-    dstPeer: some(dst))
+    msgType: Opt.some(RelayType.Stop),
+    srcPeer: Opt.some(src),
+    dstPeer: Opt.some(dst))
 
   let msgRcvFromDstOpt = try:
     await connDst.writeLp(encode(msgToSend).buffer)
@@ -289,12 +278,11 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsaf
     await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
     return
 
-  if msgRcvFromDstOpt.isNone:
+  let msgRcvFromDst = msgRcvFromDstOpt.valueOr:
     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
@@ -306,13 +294,16 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async, gcsaf
   await bridge(connSrc, connDst)
 
 proc handleStreamV1(r: Relay, conn: Connection) {.async, gcsafe.} =
-  let msgOpt = RelayMessage.decode(await conn.readLp(r.msgSize))
-  if msgOpt.isNone:
+  let msg = RelayMessage.decode(await conn.readLp(r.msgSize)).valueOr:
     await sendStatus(conn, StatusV1.MalformedMessage)
     return
-  trace "relay handle stream", msg = msgOpt.get()
-  let msg = msgOpt.get()
-  case msg.msgType.get:
+  trace "relay handle stream", msg
+
+  let typ = msg.msgType.valueOr:
+    trace "Message type not set"
+    await sendStatus(conn, StatusV1.MalformedMessage)
+    return
+  case typ:
     of RelayType.Hop: await r.handleHop(conn, msg)
     of RelayType.Stop: await sendStatus(conn, StatusV1.StopRelayRefused)
     of RelayType.CanHop: await sendStatus(conn, StatusV1.Success)

libp2p/protocols/connectivity/relay/rtransport.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,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import sequtils, strutils
 
@@ -40,7 +37,7 @@ method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
   self.client.onNewConnection = proc(
     conn: Connection,
     duration: uint32 = 0,
-    data: uint64 = 0) {.async, gcsafe, raises: [Defect].} =
+    data: uint64 = 0) {.async, gcsafe, raises: [].} =
       await self.queue.addLast(RelayConnection.new(conn, duration, data))
       await conn.join()
   self.selfRunning = true
@@ -64,9 +61,9 @@ proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async,
   var
     relayPeerId: PeerId
     dstPeerId: PeerId
-  if not relayPeerId.init(($(sma[^3].get())).split('/')[2]):
+  if not relayPeerId.init(($(sma[^3].tryGet())).split('/')[2]):
     raise newException(RelayV2DialError, "Relay doesn't exist")
-  if not dstPeerId.init(($(sma[^1].get())).split('/')[2]):
+  if not dstPeerId.init(($(sma[^1].tryGet())).split('/')[2]):
     raise newException(RelayV2DialError, "Destination doesn't exist")
   trace "Dial", relayPeerId, dstPeerId
 
@@ -92,15 +89,19 @@ proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async,
 method dial*(
   self: RelayTransport,
   hostname: string,
-  address: MultiAddress): Future[Connection] {.async, gcsafe.} =
-  result = await self.dial(address)
+  ma: MultiAddress,
+  peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection] {.async, gcsafe.} =
+  peerId.withValue(pid):
+    let address = MultiAddress.init($ma & "/p2p/" & $pid).tryGet()
+    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())
+method handles*(self: RelayTransport, ma: MultiAddress): bool {.gcsafe.} =
+  try:
+    if ma.protocols.isOk():
+      let sma = toSeq(ma.items())
+      result = sma.len >= 2 and CircuitRelay.match(sma[^1].tryGet())
+  except CatchableError as exc:
+    result = false
   trace "Handles return", ma, result
 
 proc new*(T: typedesc[RelayTransport], cl: RelayClient, upgrader: Upgrade): T =

libp2p/protocols/connectivity/relay/utils.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,15 +7,9 @@
 # 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
+{.push raises: [].}
 
 import chronos, chronicles
-
 import ./messages,
        ../../../stream/connection
 
@@ -30,21 +24,21 @@ const
 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))
+    msg = RelayMessage(msgType: Opt.some(RelayType.Status), status: Opt.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))
+    msg = HopMessage(msgType: HopMessageType.Status, status: Opt.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))
+    msg = StopMessage(msgType: StopMessageType.Status, status: Opt.some(code))
     pb = encode(msg)
   await conn.writeLp(pb.buffer)
 
@@ -64,15 +58,17 @@ proc bridge*(connSrc: Connection, connDst: Connection) {.async.} =
       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)
+        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
-        bytesSendFromDstToSrc += bufRead
-        await connSrc.write(bufDstToSrc[0..<bufRead])
-        zeroMem(addr(bufDstToSrc), bufDstToSrc.high + 1)
+        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

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,12 +10,10 @@
 ## `Identify <https://docs.libp2p.io/concepts/protocols/#identify>`_ and
 ## `Push Identify <https://docs.libp2p.io/concepts/protocols/#identify-push>`_ implementation
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import std/[sequtils, options, strutils, sugar]
+import stew/results
 import chronos, chronicles
 import ../protobuf/minprotobuf,
        ../peerinfo,
@@ -25,7 +23,10 @@ import ../protobuf/minprotobuf,
        ../multiaddress,
        ../protocols/protocol,
        ../utility,
-       ../errors
+       ../errors,
+       ../observedaddrmanager
+
+export observedaddrmanager
 
 logScope:
   topics = "libp2p identify"
@@ -55,12 +56,13 @@ type
   Identify* = ref object of LPProtocol
     peerInfo*: PeerInfo
     sendSignedPeerRecord*: bool
+    observedAddrManager*: ObservedAddrManager
 
   IdentifyPushHandler* = proc (
     peer: PeerId,
     newInfo: IdentifyInfo):
     Future[void]
-    {.gcsafe, raises: [Defect], public.}
+    {.gcsafe, raises: [], public.}
 
   IdentifyPush* = ref object of LPProtocol
     identifyHandler: IdentifyPushHandler
@@ -69,9 +71,7 @@ chronicles.expandIt(IdentifyInfo):
   pubkey = ($it.pubkey).shortLog
   addresses = it.addrs.map(x => $x).join(",")
   protocols = it.protos.map(x => $x).join(",")
-  observable_address =
-    if it.observedAddr.isSome(): $it.observedAddr.get()
-    else: "None"
+  observable_address = $it.observedAddr
   proto_version = it.protoVersion.get("None")
   agent_version = it.agentVersion.get("None")
   signedPeerRecord =
@@ -80,18 +80,19 @@ chronicles.expandIt(IdentifyInfo):
     if iinfo.signedPeerRecord.isSome(): "Some"
     else: "None"
 
-proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): ProtoBuffer
-  {.raises: [Defect].} =
+proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool): ProtoBuffer
+  {.raises: [].} =
   result = initProtoBuffer()
 
   let pkey = peerInfo.publicKey
 
-  result.write(1, pkey.getBytes().get())
+  result.write(1, pkey.getBytes().expect("valid key"))
   for ma in peerInfo.addrs:
     result.write(2, ma.data.buffer)
   for proto in peerInfo.protocols:
     result.write(3, proto)
-  result.write(4, observedAddr.data.buffer)
+  observedAddr.withValue(observed):
+    result.write(4, observed.data.buffer)
   let protoVersion = ProtoVersion
   result.write(5, protoVersion)
   let agentVersion = if peerInfo.agentVersion.len <= 0:
@@ -103,13 +104,12 @@ proc encodeMsg(peerInfo: PeerInfo, observedAddr: MultiAddress, sendSpr: bool): P
   ## Optionally populate signedPeerRecord field.
   ## See https://github.com/libp2p/go-libp2p/blob/ddf96ce1cfa9e19564feb9bd3e8269958bbc0aba/p2p/protocol/identify/pb/identify.proto for reference.
   if sendSpr:
-    let sprBuff = peerInfo.signedPeerRecord.envelope.encode()
-    if sprBuff.isOk():
-      result.write(8, sprBuff.get())
+    peerInfo.signedPeerRecord.envelope.encode().toOpt().withValue(sprBuff):
+      result.write(8, sprBuff)
 
   result.finish()
 
-proc decodeMsg*(buf: seq[byte]): Option[IdentifyInfo] =
+proc decodeMsg*(buf: seq[byte]): Opt[IdentifyInfo] =
   var
     iinfo: IdentifyInfo
     pubkey: PublicKey
@@ -119,37 +119,22 @@ proc decodeMsg*(buf: seq[byte]): Option[IdentifyInfo] =
     signedPeerRecord: SignedPeerRecord
 
   var pb = initProtoBuffer(buf)
+  if ? pb.getField(1, pubkey).toOpt():
+    iinfo.pubkey = some(pubkey)
+    if ? pb.getField(8, signedPeerRecord).toOpt() and
+      pubkey == signedPeerRecord.envelope.publicKey:
+      iinfo.signedPeerRecord = some(signedPeerRecord.envelope)
+  discard ? pb.getRepeatedField(2, iinfo.addrs).toOpt()
+  discard ? pb.getRepeatedField(3, iinfo.protos).toOpt()
+  if ? pb.getField(4, oaddr).toOpt():
+    iinfo.observedAddr = some(oaddr)
+  if ? pb.getField(5, protoVersion).toOpt():
+    iinfo.protoVersion = some(protoVersion)
+  if ? pb.getField(6, agentVersion).toOpt():
+    iinfo.agentVersion = some(agentVersion)
 
-  let r1 = pb.getField(1, pubkey)
-  let r2 = pb.getRepeatedField(2, iinfo.addrs)
-  let r3 = pb.getRepeatedField(3, iinfo.protos)
-  let r4 = pb.getField(4, oaddr)
-  let r5 = pb.getField(5, protoVersion)
-  let r6 = pb.getField(6, agentVersion)
-
-  let r8 = pb.getField(8, signedPeerRecord)
-
-  let res = r1.isOk() and r2.isOk() and r3.isOk() and
-            r4.isOk() and r5.isOk() and r6.isOk() and
-            r8.isOk()
-
-  if res:
-    if r1.get():
-      iinfo.pubkey = some(pubkey)
-    if r4.get():
-      iinfo.observedAddr = some(oaddr)
-    if r5.get():
-      iinfo.protoVersion = some(protoVersion)
-    if r6.get():
-      iinfo.agentVersion = some(agentVersion)
-    if r8.get() and r1.get():
-      if iinfo.pubkey.get() == signedPeerRecord.envelope.publicKey:
-        iinfo.signedPeerRecord = some(signedPeerRecord.envelope)
-    debug "decodeMsg: decoded identify", iinfo
-    some(iinfo)
-  else:
-    trace "decodeMsg: failed to decode received message"
-    none[IdentifyInfo]()
+  debug "decodeMsg: decoded identify", iinfo
+  Opt.some(iinfo)
 
 proc new*(
   T: typedesc[Identify],
@@ -158,7 +143,8 @@ proc new*(
   ): T =
   let identify = T(
     peerInfo: peerInfo,
-    sendSignedPeerRecord: sendSignedPeerRecord
+    sendSignedPeerRecord: sendSignedPeerRecord,
+    observedAddrManager: ObservedAddrManager.new(),
   )
   identify.init()
   identify
@@ -180,7 +166,7 @@ method init*(p: Identify) =
   p.handler = handle
   p.codec = IdentifyCodec
 
-proc identify*(p: Identify,
+proc identify*(self: Identify,
                conn: Connection,
                remotePeerId: PeerId): Future[IdentifyInfo] {.async, gcsafe.} =
   trace "initiating identify", conn
@@ -189,25 +175,20 @@ proc identify*(p: Identify,
     trace "identify: Empty message received!", conn
     raise newException(IdentityInvalidMsgError, "Empty message received!")
 
-  let infoOpt = decodeMsg(message)
-  if infoOpt.isNone():
-    raise newException(IdentityInvalidMsgError, "Incorrect message received!")
-  result = infoOpt.get()
+  var info = decodeMsg(message).valueOr: raise newException(IdentityInvalidMsgError, "Incorrect message received!")
+  let
+    pubkey = info.pubkey.valueOr: raise newException(IdentityInvalidMsgError, "No pubkey in identify")
+    peer = PeerId.init(pubkey).valueOr: raise newException(IdentityInvalidMsgError, $error)
 
-  if result.pubkey.isSome:
-    let peer = PeerId.init(result.pubkey.get())
-    if peer.isErr:
-      raise newException(IdentityInvalidMsgError, $peer.error)
-    else:
-      result.peerId = peer.get()
-      if peer.get() != remotePeerId:
-        trace "Peer ids don't match",
-              remote = peer,
-              local = remotePeerId
+  if peer != remotePeerId:
+    trace "Peer ids don't match", remote = peer, local = remotePeerId
+    raise newException(IdentityNoMatchError, "Peer ids don't match")
+  info.peerId = peer
 
-        raise newException(IdentityNoMatchError, "Peer ids don't match")
-  else:
-    raise newException(IdentityInvalidMsgError, "No pubkey in identify")
+  info.observedAddr.withValue(observed):
+    if not self.observedAddrManager.addObservation(observed):
+      debug "Observed address is not valid", observedAddr = observed
+  return info
 
 proc new*(T: typedesc[IdentifyPush], handler: IdentifyPushHandler = nil): T {.public.} =
   ## Create a IdentifyPush protocol. `handler` will be called every time
@@ -222,21 +203,18 @@ proc init*(p: IdentifyPush) =
     try:
       var message = await conn.readLp(64*1024)
 
-      let infoOpt = decodeMsg(message)
-      if infoOpt.isNone():
+      var identInfo = decodeMsg(message).valueOr:
         raise newException(IdentityInvalidMsgError, "Incorrect message received!")
 
-      var indentInfo = infoOpt.get()
-
-      if indentInfo.pubkey.isSome:
-        let receivedPeerId = PeerId.init(indentInfo.pubkey.get()).tryGet()
+      identInfo.pubkey.withValue(pubkey):
+        let receivedPeerId = PeerId.init(pubkey).tryGet()
         if receivedPeerId != conn.peerId:
           raise newException(IdentityNoMatchError, "Peer ids don't match")
-        indentInfo.peerId = receivedPeerId
+        identInfo.peerId = receivedPeerId
 
       trace "triggering peer event", peerInfo = conn.peerId
       if not isNil(p.identifyHandler):
-        await p.identifyHandler(conn.peerId, indentInfo)
+        await p.identifyHandler(conn.peerId, identInfo)
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:

libp2p/protocols/perf/client.nim

@@ -0,0 +1,47 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
+
+import chronos, chronicles, sequtils
+import stew/endians2
+import ./core, ../../stream/connection
+
+logScope:
+  topics = "libp2p perf"
+
+type PerfClient* = ref object of RootObj
+
+proc perf*(_: typedesc[PerfClient], conn: Connection,
+           sizeToWrite: uint64 = 0, sizeToRead: uint64 = 0):
+           Future[Duration] {.async, public.} =
+  var
+    size = sizeToWrite
+    buf: array[PerfSize, byte]
+  let start = Moment.now()
+  trace "starting performance benchmark", conn, sizeToWrite, sizeToRead
+
+  await conn.write(toSeq(toBytesBE(sizeToRead)))
+  while size > 0:
+    let toWrite = min(size, PerfSize)
+    await conn.write(buf[0..<toWrite])
+    size -= toWrite
+
+  await conn.close()
+
+  size = sizeToRead
+
+  while size > 0:
+    let toRead = min(size, PerfSize)
+    await conn.readExactly(addr buf[0], toRead.int)
+    size = size - toRead
+
+  let duration = Moment.now() - start
+  trace "finishing performance benchmark", duration
+  return duration

libp2p/protocols/perf/core.nim

@@ -0,0 +1,14 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
+
+const
+  PerfCodec* = "/perf/1.0.0"
+  PerfSize* = 65536

libp2p/protocols/perf/server.nim

@@ -0,0 +1,60 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+## `Perf <https://github.com/libp2p/specs/blob/master/perf/perf.md>`_ protocol specification
+
+{.push raises: [].}
+
+import chronos, chronicles
+import stew/endians2
+import ./core,
+       ../protocol,
+       ../../stream/connection,
+       ../../utility
+
+export chronicles, connection
+
+logScope:
+  topics = "libp2p perf"
+
+type Perf* = ref object of LPProtocol
+
+proc new*(T: typedesc[Perf]): T {.public.} =
+  var p = T()
+  proc handle(conn: Connection, proto: string) {.async, gcsafe, closure.} =
+    var bytesRead = 0
+    try:
+      trace "Received benchmark performance check", conn
+      var
+        sizeBuffer: array[8, byte]
+        size: uint64
+      await conn.readExactly(addr sizeBuffer[0], 8)
+      size = uint64.fromBytesBE(sizeBuffer)
+
+      var toReadBuffer: array[PerfSize, byte]
+      try:
+        while true:
+          bytesRead += await conn.readOnce(addr toReadBuffer[0], PerfSize)
+      except CatchableError as exc:
+        discard
+
+      var buf: array[PerfSize, byte]
+      while size > 0:
+        let toWrite = min(size, PerfSize)
+        await conn.write(buf[0..<toWrite])
+        size -= toWrite
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "exception in perf handler", exc = exc.msg, conn
+    await conn.close()
+
+  p.handler = handle
+  p.codec = PerfCodec
+  return p

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,13 +9,10 @@
 
 ## `Ping <https://docs.libp2p.io/concepts/protocols/#ping>`_ protocol implementation
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import chronos, chronicles
-import bearssl/[rand, hash]
+import bearssl/rand
 import ../protobuf/minprotobuf,
        ../peerinfo,
        ../stream/connection,
@@ -42,7 +39,7 @@ type
   PingHandler* {.public.} = proc (
     peer: PeerId):
     Future[void]
-    {.gcsafe, raises: [Defect].}
+    {.gcsafe, raises: [].}
 
   Ping* = ref object of LPProtocol
     pingHandler*: PingHandler

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,30 +7,38 @@
 # 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: [].}
+{.push raises: [].}
 
-import chronos
+import chronos, stew/results
 import ../stream/connection
 
+export results
+
+const
+  DefaultMaxIncomingStreams* = 10
+
 type
   LPProtoHandler* = proc (
     conn: Connection,
     proto: string):
     Future[void]
-    {.gcsafe, raises: [Defect].}
+    {.gcsafe, raises: [].}
 
   LPProtocol* = ref object of RootObj
     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!")
@@ -40,3 +48,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,
+  maxIncomingStreams: Opt[int] | int = Opt.none(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,18 +7,15 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[sequtils, sets, hashes, tables]
+import std/[sets, hashes, tables]
 import chronos, chronicles, metrics
 import ./pubsub,
        ./pubsubpeer,
        ./timedcache,
        ./peertable,
-       ./rpc/[message, messages],
+       ./rpc/[message, messages, protobuf],
        ../../crypto/crypto,
        ../../stream/connection,
        ../../peerid,
@@ -98,7 +95,16 @@ method unsubscribePeer*(f: FloodSub, peer: PeerId) =
 
 method rpcHandler*(f: FloodSub,
                    peer: PubSubPeer,
-                   rpcMsg: RPCMsg) {.async.} =
+                   data: seq[byte]) {.async.} =
+
+  var rpcMsg = decodeRpcMsg(data).valueOr:
+    debug "failed to decode msg from peer", peer, err = error
+    raise newException(CatchableError, "")
+
+  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
+  # trigger hooks
+  peer.recvObservers(rpcMsg)
+
   for i in 0..<min(f.topicsHigh, rpcMsg.subscriptions.len):
     template sub: untyped = rpcMsg.subscriptions[i]
     f.handleSubscribe(peer, sub.topic, sub.subscribe)
@@ -223,7 +229,7 @@ method publish*(f: FloodSub,
   return peers.len
 
 method initPubSub*(f: FloodSub)
-  {.raises: [Defect, InitializationError].} =
+  {.raises: [InitializationError].} =
   procCall PubSub(f).initPubSub()
   f.seen = TimedCache[MessageId].init(2.minutes)
   f.seenSalt = newSeqUninitialized[byte](sizeof(Hash))

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,20 +9,18 @@
 
 ## Gossip based publishing
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
-import std/[tables, sets, options, sequtils]
+import std/[sets, sequtils]
 import chronos, chronicles, metrics
+import chronos/ratelimit
 import ./pubsub,
        ./floodsub,
        ./pubsubpeer,
        ./peertable,
        ./mcache,
        ./timedcache,
-       ./rpc/[messages, message],
+       ./rpc/[messages, message, protobuf],
        ../protocol,
        ../../stream/connection,
        ../../peerinfo,
@@ -43,6 +41,8 @@ logScope:
 declareCounter(libp2p_gossipsub_failed_publish, "number of failed publish")
 declareCounter(libp2p_gossipsub_invalid_topic_subscription, "number of invalid topic subscriptions that happened")
 declareCounter(libp2p_gossipsub_duplicate_during_validation, "number of duplicates received during message validation")
+declareCounter(libp2p_gossipsub_idontwant_saved_messages, "number of duplicates avoided by idontwant")
+declareCounter(libp2p_gossipsub_saved_bytes, "bytes saved by gossipsub optimizations", labels=["kind"])
 declareCounter(libp2p_gossipsub_duplicate, "number of duplicates received")
 declareCounter(libp2p_gossipsub_received, "number of messages received (deduplicated)")
 
@@ -77,7 +77,11 @@ proc init*(_: type[GossipSubParams]): GossipSubParams =
       behaviourPenaltyWeight: -1.0,
       behaviourPenaltyDecay: 0.999,
       disconnectBadPeers: false,
-      enablePX: false
+      enablePX: false,
+      bandwidthEstimatebps: 100_000_000, # 100 Mbps or 12.5 MBps
+      iwantTimeout: 3 * GossipSubHeartbeatInterval,
+      overheadRateLimit: Opt.none(tuple[bytes: int, interval: Duration]),
+      disconnectPeerAboveRateLimit: false
     )
 
 proc validateParameters*(parameters: GossipSubParams): Result[void, cstring] =
@@ -150,7 +154,7 @@ method init*(g: GossipSub) =
   g.codecs &= GossipSubCodec
   g.codecs &= GossipSubCodec_10
 
-method onNewPeer(g: GossipSub, peer: PubSubPeer) =
+method onNewPeer*(g: GossipSub, peer: PubSubPeer) =
   g.withPeerStats(peer.peerId) do (stats: var PeerStats):
     # Make sure stats and peer information match, even when reloading peer stats
     # from a previous connection
@@ -158,8 +162,11 @@ method onNewPeer(g: GossipSub, peer: PubSubPeer) =
     peer.appScore = stats.appScore
     peer.behaviourPenalty = stats.behaviourPenalty
 
-    peer.iWantBudget = IWantPeerBudget
-    peer.iHaveBudget = IHavePeerBudget
+    # Check if the score is below the threshold and disconnect the peer if necessary
+    g.disconnectIfBadScorePeer(peer, stats.score)
+
+  peer.iHaveBudget = IHavePeerBudget
+  peer.pingBudget = PingsPeerBudget
 
 method onPubSubPeerEvent*(p: GossipSub, peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe.} =
   case event.kind
@@ -188,11 +195,11 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =
     return
 
   # remove from peer IPs collection too
-  if pubSubPeer.address.isSome():
-    g.peersInIP.withValue(pubSubPeer.address.get(), s):
+  pubSubPeer.address.withValue(address):
+    g.peersInIP.withValue(address, s):
       s[].excl(pubSubPeer.peerId)
       if s[].len == 0:
-        g.peersInIP.del(pubSubPeer.address.get())
+        g.peersInIP.del(address)
 
   for t in toSeq(g.mesh.keys):
     trace "pruning unsubscribing peer", pubSubPeer, score = pubSubPeer.score
@@ -201,8 +208,8 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =
 
   for t in toSeq(g.gossipsub.keys):
     g.gossipsub.removePeer(t, pubSubPeer)
-    # also try to remove from explicit table here
-    g.explicit.removePeer(t, pubSubPeer)
+    # also try to remove from direct peers table here
+    g.subscribedDirectPeers.removePeer(t, pubSubPeer)
 
   for t in toSeq(g.fanout.keys):
     g.fanout.removePeer(t, pubSubPeer)
@@ -241,7 +248,7 @@ proc handleSubscribe*(g: GossipSub,
     # subscribe remote peer to the topic
     discard g.gossipsub.addPeer(topic, peer)
     if peer.peerId in g.parameters.directPeers:
-      discard g.explicit.addPeer(topic, peer)
+      discard g.subscribedDirectPeers.addPeer(topic, peer)
   else:
     trace "peer unsubscribed from topic"
 
@@ -255,7 +262,7 @@ proc handleSubscribe*(g: GossipSub,
 
     g.fanout.removePeer(topic, peer)
     if peer.peerId in g.parameters.directPeers:
-      g.explicit.removePeer(topic, peer)
+      g.subscribedDirectPeers.removePeer(topic, peer)
 
   trace "gossip peers", peers = g.gossipsub.peers(topic), topic
 
@@ -263,6 +270,7 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
   g.handlePrune(peer, control.prune)
 
   var respControl: ControlMessage
+  g.handleIDontWant(peer, control.idontwant)
   let iwant = g.handleIHave(peer, control.ihave)
   if iwant.messageIds.len > 0:
     respControl.iwant.add(iwant)
@@ -305,12 +313,13 @@ proc validateAndRelay(g: GossipSub,
     var seenPeers: HashSet[PubSubPeer]
     discard g.validationSeen.pop(msgIdSalted, seenPeers)
     libp2p_gossipsub_duplicate_during_validation.inc(seenPeers.len.int64)
+    libp2p_gossipsub_saved_bytes.inc((msg.data.len * seenPeers.len).int64, labelValues = ["validation_duplicate"])
 
     case validation
     of ValidationResult.Reject:
       debug "Dropping message after validation, reason: reject",
         msgId = shortLog(msgId), peer
-      g.punishInvalidMessage(peer, msg.topicIds)
+      g.punishInvalidMessage(peer, msg)
       return
     of ValidationResult.Ignore:
       debug "Dropping message after validation, reason: ignore",
@@ -332,15 +341,35 @@ proc validateAndRelay(g: GossipSub,
       g.floodsub.withValue(t, peers): toSendPeers.incl(peers[])
       g.mesh.withValue(t, peers): toSendPeers.incl(peers[])
 
+      # add direct peers
+      toSendPeers.incl(g.subscribedDirectPeers.getOrDefault(t))
+
     # Don't send it to source peer, or peers that
     # sent it during validation
     toSendPeers.excl(peer)
     toSendPeers.excl(seenPeers)
 
+    # IDontWant is only worth it if the message is substantially
+    # bigger than the messageId
+    if msg.data.len > msgId.len * 10:
+      g.broadcast(toSendPeers, RPCMsg(control: some(ControlMessage(
+          idontwant: @[ControlIWant(messageIds: @[msgId])]
+        ))))
+
+    for peer in toSendPeers:
+      for heDontWant in peer.heDontWants:
+        if msgId in heDontWant:
+          seenPeers.incl(peer)
+          libp2p_gossipsub_idontwant_saved_messages.inc
+          libp2p_gossipsub_saved_bytes.inc(msg.data.len.int64, labelValues = ["idontwant"])
+          break
+    toSendPeers.excl(seenPeers)
+
+
     # In theory, if topics are the same in all messages, we could batch - we'd
     # also have to be careful to only include validated messages
     g.broadcast(toSendPeers, RPCMsg(messages: @[msg]))
-    trace "forwared message to peers", peers = toSendPeers.len, msgId, peer
+    trace "forwarded message to peers", peers = toSendPeers.len, msgId, peer
     for topic in msg.topicIds:
       if topic notin g.topics: continue
 
@@ -353,14 +382,65 @@ proc validateAndRelay(g: GossipSub,
   except CatchableError as exc:
     info "validateAndRelay failed", msg=exc.msg
 
+proc dataAndTopicsIdSize(msgs: seq[Message]): int =
+  msgs.mapIt(it.data.len + it.topicIds.mapIt(it.len).foldl(a + b, 0)).foldl(a + b, 0)
+
+proc rateLimit*(g: GossipSub, peer: PubSubPeer, rpcMsgOpt: Opt[RPCMsg], msgSize: int) {.raises:[PeerRateLimitError, CatchableError], async.} =
+  # In this way we count even ignored fields by protobuf
+
+  var rmsg = rpcMsgOpt.valueOr:
+    peer.overheadRateLimitOpt.withValue(overheadRateLimit):
+      if not overheadRateLimit.tryConsume(msgSize):
+        libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
+        debug "Peer sent a msg that couldn't be decoded and it's above rate limit.", peer, uselessAppBytesNum = msgSize
+        if g.parameters.disconnectPeerAboveRateLimit:
+          await g.disconnectPeer(peer)
+          raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
+
+    raise newException(CatchableError, "Peer msg couldn't be decoded")
+
+  let usefulMsgBytesNum =
+    if g.verifySignature:
+      byteSize(rmsg.messages)
+    else:
+      dataAndTopicsIdSize(rmsg.messages)
+
+  var uselessAppBytesNum = msgSize - usefulMsgBytesNum
+  rmsg.control.withValue(control):
+    uselessAppBytesNum -= (byteSize(control.ihave) + byteSize(control.iwant))
+
+  peer.overheadRateLimitOpt.withValue(overheadRateLimit):
+    if not overheadRateLimit.tryConsume(uselessAppBytesNum):
+      libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
+      debug "Peer sent too much useless application data and it's above rate limit.", peer, msgSize, uselessAppBytesNum, rmsg
+      if g.parameters.disconnectPeerAboveRateLimit:
+        await g.disconnectPeer(peer)
+        raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
+
 method rpcHandler*(g: GossipSub,
                   peer: PubSubPeer,
-                  rpcMsg: RPCMsg) {.async.} =
+                  data: seq[byte]) {.async.} =
+
+  let msgSize = data.len
+  var rpcMsg = decodeRpcMsg(data).valueOr:
+    debug "failed to decode msg from peer", peer, err = error
+    await rateLimit(g, peer, Opt.none(RPCMsg), msgSize)
+    return
+
+  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
+  await rateLimit(g, peer, Opt.some(rpcMsg), msgSize)
+
+  # trigger hooks
+  peer.recvObservers(rpcMsg)
+
+  if rpcMsg.ping.len in 1..<64 and peer.pingBudget > 0:
+    g.send(peer, RPCMsg(pong: rpcMsg.ping))
+    peer.pingBudget.dec
   for i in 0..<min(g.topicsHigh, rpcMsg.subscriptions.len):
     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,
@@ -381,6 +461,9 @@ method rpcHandler*(g: GossipSub,
     let
       msgId = msgIdResult.get
       msgIdSalted = msgId & g.seenSalt
+    g.outstandingIWANTs.withValue(msgId, iwantRequest):
+      if iwantRequest.peer.peerId == peer.peerId:
+        g.outstandingIWANTs.del(msgId)
 
     # addSeen adds salt to msgId to avoid
     # remote attacking the hash function
@@ -413,14 +496,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)
       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)
       continue
 
     # g.anonymize needs no evaluation when receiving messages
@@ -492,32 +575,38 @@ method publish*(g: GossipSub,
 
   var peers: HashSet[PubSubPeer]
 
-  if g.parameters.floodPublish:
-    # With flood publishing enabled, the mesh is used when propagating messages from other peers,
-    # but a peer's own messages will always be published to all known peers in the topic.
-    for peer in g.gossipsub.getOrDefault(topic):
-      if peer.score >= g.parameters.publishThreshold:
-        trace "publish: including flood/high score peer", peer
-        peers.incl(peer)
-
   # add always direct peers
-  peers.incl(g.explicit.getOrDefault(topic))
+  peers.incl(g.subscribedDirectPeers.getOrDefault(topic))
 
   if topic in g.topics: # if we're subscribed use the mesh
     peers.incl(g.mesh.getOrDefault(topic))
 
-  if peers.len < g.parameters.dLow and g.parameters.floodPublish == false:
-    # not subscribed or bad mesh, send to fanout peers
-    # disable for floodPublish, since we already sent to every good peer
-    #
+  if g.parameters.floodPublish:
+    # With flood publishing enabled, the mesh is used when propagating messages from other peers,
+    # but a peer's own messages will always be published to all known peers in the topic, limited
+    # to the amount of peers we can send it to in one heartbeat
+    var maxPeersToFlodOpt: Opt[int64]
+    if g.parameters.bandwidthEstimatebps > 0:
+      let
+        bandwidth = (g.parameters.bandwidthEstimatebps) div 8 div 1000 # Divisions are to convert it to Bytes per ms TODO replace with bandwidth estimate
+        msToTransmit = max(data.len div bandwidth, 1)
+      maxPeersToFlodOpt = Opt.some(max(g.parameters.heartbeatInterval.milliseconds div msToTransmit, g.parameters.dLow))
+
+    for peer in g.gossipsub.getOrDefault(topic):
+      maxPeersToFlodOpt.withValue(maxPeersToFlod):
+        if peers.len >= maxPeersToFlod: break
+      if peer.score >= g.parameters.publishThreshold:
+        trace "publish: including flood/high score peer", peer
+        peers.incl(peer)
+
+  if peers.len < g.parameters.dLow:
+    # not subscribed, or bad mesh, send to fanout peers
     var fanoutPeers = g.fanout.getOrDefault(topic).toSeq()
-    if fanoutPeers.len == 0:
+    if fanoutPeers.len < g.parameters.dLow:
       g.replenishFanout(topic)
       fanoutPeers = g.fanout.getOrDefault(topic).toSeq()
 
     g.rng.shuffle(fanoutPeers)
-    if fanoutPeers.len + peers.len > g.parameters.d:
-      fanoutPeers.setLen(g.parameters.d - peers.len)
 
     for fanPeer in fanoutPeers:
       peers.incl(fanPeer)
@@ -535,7 +624,6 @@ method publish*(g: GossipSub,
     debug "No peers for topic, skipping publish",  peersOnTopic = topicPeers.len,
                                                    connectedPeers = topicPeers.filterIt(it.connected).len,
                                                    topic
-    # skipping topic as our metrics finds that heavy
     libp2p_gossipsub_failed_publish.inc()
     return 0
 
@@ -571,15 +659,16 @@ method publish*(g: GossipSub,
     libp2p_pubsub_messages_published.inc(peers.len.int64, labelValues = ["generic"])
 
   trace "Published message to peers", peers=peers.len
-
   return peers.len
 
 proc maintainDirectPeer(g: GossipSub, id: PeerId, addrs: seq[MultiAddress]) {.async.} =
-  let peer = g.peers.getOrDefault(id)
-  if isNil(peer):
+  if id notin g.peers:
     trace "Attempting to dial a direct peer", peer = id
+    if g.switch.isConnected(id):
+      warn "We are connected to a direct peer, but it isn't a GossipSub peer!", id
+      return
     try:
-      await g.switch.connect(id, addrs)
+      await g.switch.connect(id, addrs, forceDial = true)
       # populate the peer after it's connected
       discard g.getOrCreatePeer(id, g.codecs)
     except CancelledError as exc:
@@ -623,7 +712,7 @@ method stop*(g: GossipSub) {.async.} =
   g.heartbeatFut = nil
 
 method initPubSub*(g: GossipSub)
-  {.raises: [Defect, InitializationError].} =
+  {.raises: [InitializationError].} =
   procCall FloodSub(g).initPubSub()
 
   if not g.parameters.explicit:
@@ -638,3 +727,13 @@ method initPubSub*(g: GossipSub)
 
   # init gossip stuff
   g.mcache = MCache.init(g.parameters.historyGossip, g.parameters.historyLength)
+
+method getOrCreatePeer*(
+    g: GossipSub,
+    peerId: PeerId,
+    protos: seq[string]): PubSubPeer =
+
+  let peer = procCall PubSub(g).getOrCreatePeer(peerId, protos)
+  g.parameters.overheadRateLimit.withValue(overheadRateLimit):
+    peer.overheadRateLimitOpt = Opt.some(TokenBucket.new(overheadRateLimit.bytes, overheadRateLimit.interval))
+  return peer

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,18 +7,18 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[tables, sequtils, sets, algorithm]
+import std/[tables, sequtils, sets, algorithm, deques]
 import chronos, chronicles, metrics
 import "."/[types, scoring]
-import ".."/[pubsubpeer, peertable, timedcache, mcache, floodsub, pubsub]
+import ".."/[pubsubpeer, peertable, 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"])
@@ -28,9 +28,9 @@ declareGauge(libp2p_gossipsub_no_peers_topics, "number of topics in mesh with no
 declareGauge(libp2p_gossipsub_low_peers_topics, "number of topics in mesh with at least one but below dlow peers")
 declareGauge(libp2p_gossipsub_healthy_peers_topics, "number of topics in mesh with at least dlow peers (but below dhigh)")
 declareCounter(libp2p_gossipsub_above_dhigh_condition, "number of above dhigh pruning branches ran", labels = ["topic"])
-declareSummary(libp2p_gossipsub_mcache_hit, "ratio of successful IWANT message cache lookups")
+declareGauge(libp2p_gossipsub_received_iwants, "received iwants", labels = ["kind"])
 
-proc grafted*(g: GossipSub, p: PubSubPeer, topic: string) {.raises: [Defect].} =
+proc grafted*(g: GossipSub, p: PubSubPeer, topic: string) {.raises: [].} =
   g.withPeerStats(p.peerId) do (stats: var PeerStats):
     var info = stats.topicInfos.getOrDefault(topic)
     info.graftTime = Moment.now()
@@ -46,12 +46,10 @@ proc pruned*(g: GossipSub,
              p: PubSubPeer,
              topic: string,
              setBackoff: bool = true,
-             backoff = none(Duration)) {.raises: [Defect].} =
+             backoff = none(Duration)) {.raises: [].} =
   if setBackoff:
     let
-      backoffDuration =
-        if isSome(backoff): backoff.get()
-        else: g.parameters.pruneBackoff
+      backoffDuration = backoff.get(g.parameters.pruneBackoff)
       backoffMoment = Moment.fromNow(backoffDuration)
 
     g.backingOff
@@ -72,7 +70,7 @@ proc pruned*(g: GossipSub,
 
       trace "pruned", peer=p, topic
 
-proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [Defect].} =
+proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [].} =
   let now = Moment.now()
   var expired = toSeq(t.getOrDefault(topic).pairs())
   expired.keepIf do (pair: tuple[peer: PeerId, expire: Moment]) -> bool:
@@ -81,7 +79,7 @@ proc handleBackingOff*(t: var BackoffTable, topic: string) {.raises: [Defect].}
     t.withValue(topic, v):
       v[].del(peer)
 
-proc peerExchangeList*(g: GossipSub, topic: string): seq[PeerInfoMsg] {.raises: [Defect].} =
+proc peerExchangeList*(g: GossipSub, topic: string): seq[PeerInfoMsg] {.raises: [].} =
   if not g.parameters.enablePX:
     return @[]
   var peers = g.gossipsub.getOrDefault(topic, initHashSet[PubSubPeer]()).toSeq()
@@ -108,10 +106,11 @@ proc handleGraft*(g: GossipSub,
     let topic = graft.topicId
     trace "peer grafted topic", peer, topic
 
-    # It is an error to GRAFT on a explicit peer
+    # It is an error to GRAFT on a direct peer
     if peer.peerId in g.parameters.directPeers:
       # receiving a graft from a direct peer should yield a more prominent warning (protocol violation)
-      warn "an explicit peer attempted to graft us, peering agreements should be reciprocal",
+      # we are trusting direct peer not to abuse this
+      warn "a direct peer attempted to graft us, peering agreements should be reciprocal",
         peer, topic
       # and such an attempt should be logged and rejected with a PRUNE
       prunes.add(ControlPrune(
@@ -127,6 +126,10 @@ proc handleGraft*(g: GossipSub,
 
       continue
 
+    if g.mesh.hasPeer(topic, peer):
+      trace "peer already in mesh", peer, topic
+      continue
+
     # Check backingOff
     # Ignore BackoffSlackTime here, since this only for outbound activity
     # and subtract a second time to avoid race conditions
@@ -157,7 +160,8 @@ proc handleGraft*(g: GossipSub,
     # If they send us a graft before they send us a subscribe, what should
     # we do? For now, we add them to mesh but don't add them to gossipsub.
     if topic in g.topics:
-      if g.mesh.peers(topic) < g.parameters.dHigh or peer.outbound:
+      if g.mesh.peers(topic) < g.parameters.dHigh or
+          (peer.outbound and g.mesh.outboundPeers(topic) < g.parameters.dOut):
         # In the spec, there's no mention of DHi here, but implicitly, a
         # peer will be removed from the mesh on next rebalance, so we don't want
         # this peer to push someone else out
@@ -173,6 +177,10 @@ proc handleGraft*(g: GossipSub,
           topicID: topic,
           peers: g.peerExchangeList(topic),
           backoff: g.parameters.pruneBackoff.seconds.uint64))
+
+        let backoff = Moment.fromNow(g.parameters.pruneBackoff)
+        g.backingOff
+          .mgetOrPut(topic, initTable[PeerId, Moment]())[peer.peerId] = backoff
     else:
       trace "peer grafting topic we're not interested in", peer, topic
       # gossip 1.1, we do not send a control message prune anymore
@@ -182,27 +190,22 @@ proc handleGraft*(g: GossipSub,
 proc getPeers(prune: ControlPrune, peer: PubSubPeer): seq[(PeerId, Option[PeerRecord])] =
   var routingRecords: seq[(PeerId, Option[PeerRecord])]
   for record in prune.peers:
-    let peerRecord =
-      if record.signedPeerRecord.len == 0:
-        none(PeerRecord)
-      else:
-        let signedRecord = SignedPeerRecord.decode(record.signedPeerRecord)
-        if signedRecord.isErr:
-          trace "peer sent invalid SPR", peer, error=signedRecord.error
-          none(PeerRecord)
+    var peerRecord = none(PeerRecord)
+    if record.signedPeerRecord.len > 0:
+      SignedPeerRecord.decode(record.signedPeerRecord).toOpt().withValue(spr):
+        if record.peerId != spr.data.peerId:
+          trace "peer sent envelope with wrong public key", peer
         else:
-          if record.peerId != signedRecord.get().data.peerId:
-            trace "peer sent envelope with wrong public key", peer
-            none(PeerRecord)
-          else:
-            some(signedRecord.get().data)
+          peerRecord = some(spr.data)
+      else:
+        trace "peer sent invalid SPR", peer
 
     routingRecords.add((record.peerId, peerRecord))
 
   routingRecords
 
 
-proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.raises: [Defect].} =
+proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.raises: [].} =
   for prune in prunes:
     let topic = prune.topicId
 
@@ -236,64 +239,80 @@ proc handlePrune*(g: GossipSub, peer: PubSubPeer, prunes: seq[ControlPrune]) {.r
 
 proc handleIHave*(g: GossipSub,
                  peer: PubSubPeer,
-                 ihaves: seq[ControlIHave]): ControlIWant {.raises: [Defect].} =
+                 ihaves: seq[ControlIHave]): ControlIWant {.raises: [].} =
   var res: ControlIWant
   if peer.score < g.parameters.gossipThreshold:
     trace "ihave: ignoring low score peer", peer, score = peer.score
   elif peer.iHaveBudget <= 0:
     trace "ihave: ignoring out of budget peer", peer, score = peer.score
   else:
-    # TODO review deduplicate algorithm
-    # * https://github.com/nim-lang/Nim/blob/5f46474555ee93306cce55342e81130c1da79a42/lib/pure/collections/sequtils.nim#L184
-    # * it's probably not efficient and might give preference to the first dupe
-    let deIhaves = ihaves.deduplicate()
-    for ihave in deIhaves:
+    for ihave in ihaves:
       trace "peer sent ihave",
         peer, topic = ihave.topicId, msgs = ihave.messageIds
-      if ihave.topicId in g.mesh:
-        # also avoid duplicates here!
-        let deIhavesMsgs = ihave.messageIds.deduplicate()
-        for msgId in deIhavesMsgs:
+      if ihave.topicId in g.topics:
+        for msgId in ihave.messageIds:
           if not g.hasSeen(msgId):
-            if peer.iHaveBudget > 0:
+            if peer.iHaveBudget <= 0:
+              break
+            elif msgId notin res.messageIds and msgId notin g.outstandingIWANTs:
+              g.outstandingIWANTs[msgId] = IWANTRequest(messageId: msgId, peer: peer, timestamp: Moment.now())
               res.messageIds.add(msgId)
               dec peer.iHaveBudget
               trace "requested message via ihave", messageID=msgId
-            else:
-              break
     # shuffling res.messageIDs before sending it out to increase the likelihood
     # of getting an answer if the peer truncates the list due to internal size restrictions.
     g.rng.shuffle(res.messageIds)
     return res
 
+proc handleIDontWant*(g: GossipSub,
+                      peer: PubSubPeer,
+                      iDontWants: seq[ControlIWant]) =
+  for dontWant in iDontWants:
+    for messageId in dontWant.messageIds:
+      if peer.heDontWants[^1].len > 1000: break
+      if messageId.len > 100: continue
+      peer.heDontWants[^1].incl(messageId)
+
 proc handleIWant*(g: GossipSub,
                  peer: PubSubPeer,
-                 iwants: seq[ControlIWant]): seq[Message] {.raises: [Defect].} =
-  var messages: seq[Message]
+                 iwants: seq[ControlIWant]): seq[Message] {.raises: [].} =
+  var
+    messages: seq[Message]
+    invalidRequests = 0
   if peer.score < g.parameters.gossipThreshold:
     trace "iwant: ignoring low score peer", peer, score = peer.score
-  elif peer.iWantBudget <= 0:
-    trace "iwant: ignoring out of budget peer", peer, score = peer.score
   else:
-    let deIwants = iwants.deduplicate()
-    for iwant in deIwants:
-      let deIwantsMsgs = iwant.messageIds.deduplicate()
-      for mid in deIwantsMsgs:
+    for iwant in iwants:
+      for mid in iwant.messageIds:
         trace "peer sent iwant", peer, messageID = mid
-        let msg = g.mcache.get(mid)
-        if msg.isSome:
-          libp2p_gossipsub_mcache_hit.observe(1)
-          # avoid spam
-          if peer.iWantBudget > 0:
-            messages.add(msg.get())
-            dec peer.iWantBudget
-          else:
-            break
-        else:
-          libp2p_gossipsub_mcache_hit.observe(0)
+        # canAskIWant will only return true once for a specific message
+        if not peer.canAskIWant(mid):
+          libp2p_gossipsub_received_iwants.inc(1, labelValues=["notsent"])
+
+          invalidRequests.inc()
+          if invalidRequests > 20:
+            libp2p_gossipsub_received_iwants.inc(1, labelValues=["skipped"])
+            return messages
+          continue
+        let msg = g.mcache.get(mid).valueOr:
+          libp2p_gossipsub_received_iwants.inc(1, labelValues=["unknown"])
+          continue
+        libp2p_gossipsub_received_iwants.inc(1, labelValues=["correct"])
+        messages.add(msg)
   return messages
 
-proc commitMetrics(metrics: var MeshMetrics) {.raises: [Defect].} =
+proc checkIWANTTimeouts(g: GossipSub, timeoutDuration: Duration) {.raises: [].} =
+  let currentTime = Moment.now()
+  var idsToRemove = newSeq[MessageId]()
+  for msgId, request in g.outstandingIWANTs.pairs():
+    if currentTime - request.timestamp > timeoutDuration:
+      trace "IWANT request timed out", messageID=msgId, peer=request.peer
+      request.peer.behaviourPenalty += 0.1
+      idsToRemove.add(msgId)
+  for msgId in idsToRemove:
+      g.outstandingIWANTs.del(msgId)
+
+proc commitMetrics(metrics: var MeshMetrics) {.raises: [].} =
   libp2p_gossipsub_low_peers_topics.set(metrics.lowPeersTopics)
   libp2p_gossipsub_no_peers_topics.set(metrics.noPeersTopics)
   libp2p_gossipsub_under_dout_topics.set(metrics.underDoutTopics)
@@ -302,7 +321,7 @@ proc commitMetrics(metrics: var MeshMetrics) {.raises: [Defect].} =
   libp2p_gossipsub_peers_per_topic_fanout.set(metrics.otherPeersPerTopicFanout, labelValues = ["other"])
   libp2p_gossipsub_peers_per_topic_mesh.set(metrics.otherPeersPerTopicMesh, labelValues = ["other"])
 
-proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil) {.raises: [Defect].} =
+proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil) {.raises: [].} =
   logScope:
     topic
     mesh = g.mesh.peers(topic)
@@ -315,10 +334,11 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
   var
     prunes, grafts: seq[PubSubPeer]
     npeers = g.mesh.peers(topic)
+    nOutPeers = g.mesh.outboundPeers(topic)
     defaultMesh: HashSet[PubSubPeer]
     backingOff = g.backingOff.getOrDefault(topic)
 
-  if npeers  < g.parameters.dLow:
+  if npeers < g.parameters.dLow:
     trace "replenishing mesh", peers = npeers
     # replenish the mesh if we're below Dlo
 
@@ -333,7 +353,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
             # avoid negative score peers
             it.score >= 0.0 and
             it notin currentMesh[] and
-            # don't pick explicit peers
+            # don't pick direct peers
             it.peerId notin g.parameters.directPeers and
             # and avoid peers we are backing off
             it.peerId notin backingOff:
@@ -357,7 +377,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
           g.fanout.removePeer(topic, peer)
           grafts &= peer
 
-  else:
+  elif nOutPeers < g.parameters.dOut:
     trace "replenishing mesh outbound quota", peers = g.mesh.peers(topic)
 
     var
@@ -373,7 +393,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
             it notin currentMesh[] and
             # avoid negative score peers
             it.score >= 0.0 and
-            # don't pick explicit peers
+            # don't pick direct peers
             it.peerId notin g.parameters.directPeers and
             # and avoid peers we are backing off
             it.peerId notin backingOff:
@@ -385,8 +405,8 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
     # sort peers by score, high score first, we are grafting
     candidates.sort(byScore, SortOrder.Descending)
 
-    # Graft peers so we reach a count of D
-    candidates.setLen(min(candidates.len, g.parameters.dOut))
+    # Graft outgoing peers so we reach a count of dOut
+    candidates.setLen(min(candidates.len, g.parameters.dOut - nOutPeers))
 
     trace "grafting outbound peers", topic, peers = candidates.len
 
@@ -475,7 +495,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
               # avoid negative score peers
               it.score >= median.score and
               it notin currentMesh[] and
-              # don't pick explicit peers
+              # don't pick direct peers
               it.peerId notin g.parameters.directPeers and
               # and avoid peers we are backing off
               it.peerId notin backingOff:
@@ -531,7 +551,7 @@ proc rebalanceMesh*(g: GossipSub, topic: string, metrics: ptr MeshMetrics = nil)
         backoff: g.parameters.pruneBackoff.seconds.uint64)])))
     g.broadcast(prunes, prune)
 
-proc dropFanoutPeers*(g: GossipSub) {.raises: [Defect].} =
+proc dropFanoutPeers*(g: GossipSub) {.raises: [].} =
   # drop peers that we haven't published to in
   # GossipSubFanoutTTL seconds
   let now = Moment.now()
@@ -544,13 +564,13 @@ proc dropFanoutPeers*(g: GossipSub) {.raises: [Defect].} =
   for topic in drops:
     g.lastFanoutPubSub.del topic
 
-proc replenishFanout*(g: GossipSub, topic: string) {.raises: [Defect].} =
+proc replenishFanout*(g: GossipSub, topic: string) {.raises: [].} =
   ## get fanout peers for a topic
   logScope: topic
   trace "about to replenish fanout"
 
-  let currentMesh = g.mesh.getOrDefault(topic)
   if g.fanout.peers(topic) < g.parameters.dLow:
+    let currentMesh = g.mesh.getOrDefault(topic)
     trace "replenishing fanout", peers = g.fanout.peers(topic)
     for peer in g.gossipsub.getOrDefault(topic):
       if peer in currentMesh: continue
@@ -560,7 +580,7 @@ proc replenishFanout*(g: GossipSub, topic: string) {.raises: [Defect].} =
 
   trace "fanout replenished with peers", peers = g.fanout.peers(topic)
 
-proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises: [Defect].} =
+proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises: [].} =
   ## gossip iHave messages to peers
   ##
 
@@ -613,20 +633,29 @@ proc getGossipPeers*(g: GossipSub): Table[PubSubPeer, ControlMessage] {.raises:
       g.rng.shuffle(allPeers)
       allPeers.setLen(target)
 
+    let msgIdsAsSet = ihave.messageIds.toHashSet()
+
     for peer in allPeers:
       control.mgetOrPut(peer, ControlMessage()).ihave.add(ihave)
+      peer.sentIHaves[^1].incl(msgIdsAsSet)
 
   libp2p_gossipsub_cache_window_size.set(cacheWindowSize.int64)
 
   return control
 
-proc onHeartbeat(g: GossipSub) {.raises: [Defect].} =
+proc onHeartbeat(g: GossipSub) {.raises: [].} =
     # reset IWANT budget
     # reset IHAVE cap
     block:
       for peer in g.peers.values:
-        peer.iWantBudget = IWantPeerBudget
+        peer.sentIHaves.addFirst(default(HashSet[MessageId]))
+        if peer.sentIHaves.len > g.parameters.historyLength:
+          discard peer.sentIHaves.popLast()
+        peer.heDontWants.addFirst(default(HashSet[MessageId]))
+        if peer.heDontWants.len > g.parameters.historyLength:
+          discard peer.heDontWants.popLast()
         peer.iHaveBudget = IHavePeerBudget
+        peer.pingBudget = PingsPeerBudget
 
     var meshMetrics = MeshMetrics()
 
@@ -678,7 +707,7 @@ proc onHeartbeat(g: GossipSub) {.raises: [Defect].} =
 
     g.mcache.shift() # shift the cache
 
-# {.pop.} # raises [Defect]
+# {.pop.} # raises []
 
 proc heartbeat*(g: GossipSub) {.async.} =
   heartbeat "GossipSub", g.parameters.heartbeatInterval:
@@ -688,3 +717,5 @@ proc heartbeat*(g: GossipSub) {.async.} =
     for trigger in g.heartbeatEvents:
       trace "firing heartbeat event", instance = cast[int](g)
       trigger.fire()
+
+    checkIWANTTimeouts(g, g.parameters.iwantTimeout)

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,16 +7,19 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[tables, sets, options]
+import std/[tables, sets]
 import chronos, chronicles, metrics
+import chronos/ratelimit
 import "."/[types]
 import ".."/[pubsubpeer]
-import "../../.."/[peerid, multiaddress, utility, switch, utils/heartbeat]
+import ../rpc/messages
+import "../../.."/[peerid, multiaddress, switch, utils/heartbeat]
+import ../pubsub
+
+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"])
@@ -27,6 +30,7 @@ declareGauge(libp2p_gossipsub_peers_score_invalidMessageDeliveries, "Detailed go
 declareGauge(libp2p_gossipsub_peers_score_appScore, "Detailed gossipsub scoring metric", labels = ["agent"])
 declareGauge(libp2p_gossipsub_peers_score_behaviourPenalty, "Detailed gossipsub scoring metric", labels = ["agent"])
 declareGauge(libp2p_gossipsub_peers_score_colocationFactor, "Detailed gossipsub scoring metric", labels = ["agent"])
+declarePublicCounter(libp2p_gossipsub_peers_rate_limit_hits, "The number of times peers were above their rate limit", labels = ["agent"])
 
 proc init*(_: type[TopicParams]): TopicParams =
   TopicParams(
@@ -52,7 +56,7 @@ proc init*(_: type[TopicParams]): TopicParams =
 proc withPeerStats*(
     g: GossipSub,
     peerId: PeerId,
-    action: proc (stats: var PeerStats) {.gcsafe, raises: [Defect].}) =
+    action: proc (stats: var PeerStats) {.gcsafe, raises: [].}) =
   ## Add or update peer statistics for a particular peer id - the statistics
   ## are retained across multiple connections until they expire
   g.peerStats.withValue(peerId, stats) do:
@@ -71,39 +75,32 @@ func `/`(a, b: Duration): float64 =
 func byScore*(x,y: PubSubPeer): int = system.cmp(x.score, y.score)
 
 proc colocationFactor(g: GossipSub, peer: PubSubPeer): float64 =
-  if peer.address.isNone():
-    0.0
+  let address = peer.address.valueOr: return 0.0
+
+  g.peersInIP.mgetOrPut(address, initHashSet[PeerId]()).incl(peer.peerId)
+  let
+    ipPeers = g.peersInIP.getOrDefault(address).len().float64
+  if ipPeers > g.parameters.ipColocationFactorThreshold:
+    trace "colocationFactor over threshold", peer, address, ipPeers
+    let over = ipPeers - g.parameters.ipColocationFactorThreshold
+    over * over
   else:
-    let
-      address = peer.address.get()
-    g.peersInIP.mgetOrPut(address, initHashSet[PeerId]()).incl(peer.peerId)
-    let
-      ipPeers = g.peersInIP.getOrDefault(address).len().float64
-    if ipPeers > g.parameters.ipColocationFactorThreshold:
-      trace "colocationFactor over threshold", peer, address, ipPeers
-      let over = ipPeers - g.parameters.ipColocationFactorThreshold
-      over * over
-    else:
-      0.0
+    0.0
 
 {.pop.}
 
-proc disconnectPeer(g: GossipSub, peer: PubSubPeer) {.async.} =
-  let agent =
-    when defined(libp2p_agents_metrics):
-      if peer.shortAgent.len > 0:
-        peer.shortAgent
-      else:
-        "unknown"
-    else:
-      "unknown"
-  libp2p_gossipsub_bad_score_disconnection.inc(labelValues = [agent])
-
+proc disconnectPeer*(g: GossipSub, peer: PubSubPeer) {.async.} =
   try:
     await g.switch.disconnect(peer.peerId)
   except CatchableError as exc: # Never cancelled
     trace "Failed to close connection", peer, error = exc.name, msg = exc.msg
 
+proc disconnectIfBadScorePeer*(g: GossipSub, peer: PubSubPeer, score: float64) =
+  if g.parameters.disconnectBadPeers and score < g.parameters.graylistThreshold and
+     peer.peerId notin g.parameters.directPeers:
+    debug "disconnecting bad score peer", peer, score = peer.score
+    asyncSpawn(g.disconnectPeer(peer))
+    libp2p_gossipsub_bad_score_disconnection.inc(labelValues = [peer.getAgent()])
 
 proc updateScores*(g: GossipSub) = # avoid async
   ## https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md#the-score-function
@@ -173,14 +170,7 @@ proc updateScores*(g: GossipSub) = # avoid async
         score += topicScore * topicParams.topicWeight
 
       # Score metrics
-      let agent =
-        when defined(libp2p_agents_metrics):
-          if peer.shortAgent.len > 0:
-            peer.shortAgent
-          else:
-            "unknown"
-        else:
-          "unknown"
+      let agent = peer.getAgent()
       libp2p_gossipsub_peers_score_firstMessageDeliveries.inc(info.firstMessageDeliveries, labelValues = [agent])
       libp2p_gossipsub_peers_score_meshMessageDeliveries.inc(info.meshMessageDeliveries, labelValues = [agent])
       libp2p_gossipsub_peers_score_meshFailurePenalty.inc(info.meshFailurePenalty, labelValues = [agent])
@@ -217,14 +207,7 @@ proc updateScores*(g: GossipSub) = # avoid async
     score += colocationFactor * g.parameters.ipColocationFactorWeight
 
     # Score metrics
-    let agent =
-      when defined(libp2p_agents_metrics):
-        if peer.shortAgent.len > 0:
-          peer.shortAgent
-        else:
-          "unknown"
-      else:
-        "unknown"
+    let agent = peer.getAgent()
     libp2p_gossipsub_peers_score_appScore.inc(peer.appScore, labelValues = [agent])
     libp2p_gossipsub_peers_score_behaviourPenalty.inc(peer.behaviourPenalty, labelValues = [agent])
     libp2p_gossipsub_peers_score_colocationFactor.inc(colocationFactor, labelValues = [agent])
@@ -244,11 +227,7 @@ proc updateScores*(g: GossipSub) = # avoid async
 
     trace "updated peer's score", peer, score = peer.score, n_topics, is_grafted
 
-    if g.parameters.disconnectBadPeers and stats.score < g.parameters.graylistThreshold and
-        peer.peerId notin g.parameters.directPeers:
-      debug "disconnecting bad score peer", peer, score = peer.score
-      asyncSpawn(try: g.disconnectPeer(peer) except Exception as exc: raiseAssert exc.msg)
-
+    g.disconnectIfBadScorePeer(peer, stats.score)
     libp2p_gossipsub_peers_scores.inc(peer.score, labelValues = [agent])
 
   for peer in evicting:
@@ -261,8 +240,18 @@ proc scoringHeartbeat*(g: GossipSub) {.async.} =
     trace "running scoring heartbeat", instance = cast[int](g)
     g.updateScores()
 
-proc punishInvalidMessage*(g: GossipSub, peer: PubSubPeer, topics: seq[string]) =
-  for tt in topics:
+proc punishInvalidMessage*(g: GossipSub, peer: PubSubPeer, msg: Message) =
+  let uselessAppBytesNum = msg.data.len
+  peer.overheadRateLimitOpt.withValue(overheadRateLimit):
+    if not overheadRateLimit.tryConsume(uselessAppBytesNum):
+      debug "Peer sent invalid message and it's above rate limit", peer, uselessAppBytesNum
+      libp2p_gossipsub_peers_rate_limit_hits.inc(labelValues = [peer.getAgent()]) # let's just measure at the beginning for test purposes.
+      # discard g.disconnectPeer(peer)
+      # debug "Peer disconnected", peer, uselessAppBytesNum
+      # raise newException(PeerRateLimitError, "Peer sent invalid message and it's above rate limit")
+
+
+  for tt in msg.topicIds:
     let t = tt
     if t notin g.topics:
       continue
@@ -292,11 +281,11 @@ proc rewardDelivered*(
 
     g.withPeerStats(peer.peerId) do (stats: var PeerStats):
       stats.topicInfos.withValue(tt, tstats):
-        if tstats[].inMesh:
-          if first:
-            tstats[].firstMessageDeliveries.addCapped(
-              1, topicParams.firstMessageDeliveriesCap)
+        if first:
+          tstats[].firstMessageDeliveries.addCapped(
+            1, topicParams.firstMessageDeliveriesCap)
 
+        if tstats[].inMesh:
           tstats[].meshMessageDeliveries.addCapped(
             1, topicParams.meshMessageDeliveriesCap)
       do: # make sure we don't loose this information

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,16 +7,15 @@
 # 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: [].}
+{.push raises: [].}
 
 import chronos
-import std/[tables, sets]
+import std/[options, tables, sets]
 import ".."/[floodsub, peertable, mcache, pubsubpeer]
 import "../rpc"/[messages]
-import "../../.."/[peerid, multiaddress]
+import "../../.."/[peerid, multiaddress, utility]
+
+export options, tables, sets
 
 const
   GossipSubCodec* = "/meshsub/1.1.0"
@@ -46,7 +45,7 @@ const
 
 const
   BackoffSlackTime* = 2 # seconds
-  IWantPeerBudget* = 25 # 25 messages per second ( reset every heartbeat )
+  PingsPeerBudget* = 100 # maximum of 6.4kb/heartbeat (6.4kb/s with default 1 second/hb)
   IHavePeerBudget* = 10
   # the max amount of IHave to expose, not by spec, but go as example
   # rust sigp: https://github.com/sigp/rust-libp2p/blob/f53d02bc873fef2bf52cd31e3d5ce366a41d8a8c/protocols/gossipsub/src/config.rs#L572
@@ -65,7 +64,7 @@ type
     meshFailurePenalty*: float64
     invalidMessageDeliveries*: float64
 
-  TopicParams* = object
+  TopicParams* {.public.} = object
     topicWeight*: float64
 
     # p1
@@ -102,7 +101,7 @@ type
     appScore*: float64 # application specific score
     behaviourPenalty*: float64 # the eventual penalty score
 
-  GossipSubParams* = object
+  GossipSubParams* {.public.} = object
     explicit*: bool
     pruneBackoff*: Duration
     unsubscribeBackoff*: Duration
@@ -143,6 +142,12 @@ type
     disconnectBadPeers*: bool
     enablePX*: bool
 
+    bandwidthEstimatebps*: int # This is currently used only for limting flood publishing. 0 disables flood-limiting completely
+    iwantTimeout*: Duration
+
+    overheadRateLimit*: Opt[tuple[bytes: int, interval: Duration]]
+    disconnectPeerAboveRateLimit*: bool
+
   BackoffTable* = Table[string, Table[PeerId, Moment]]
   ValidationSeenTable* = Table[MessageId, HashSet[PubSubPeer]]
 
@@ -151,13 +156,13 @@ type
     proc(peer: PeerId,
     tag: string, # For gossipsub, the topic
     peers: seq[RoutingRecordsPair])
-    {.gcsafe, raises: [Defect].}
+    {.gcsafe, raises: [].}
 
   GossipSub* = ref object of FloodSub
     mesh*: PeerTable                           # peers that we send messages to when we are subscribed to the topic
     fanout*: PeerTable                         # peers that we send messages to when we're not subscribed to the topic
     gossipsub*: PeerTable                      # peers that are subscribed to a topic
-    explicit*: PeerTable                       # directpeers that we keep alive explicitly
+    subscribedDirectPeers*: PeerTable          # directpeers that we keep alive
     backingOff*: BackoffTable                  # peers to backoff from when replenishing the mesh
     lastFanoutPubSub*: Table[string, Moment]   # last publish time for fanout topics
     gossip*: Table[string, seq[ControlIHave]]  # pending gossip
@@ -176,6 +181,7 @@ type
     routingRecordsHandler*: seq[RoutingRecordsHandler] # Callback for peer exchange
 
     heartbeatEvents*: seq[AsyncEvent]
+    outstandingIWANTs*: Table[MessageId, IWANTRequest]
 
   MeshMetrics* = object
     # scratch buffers for metrics
@@ -186,3 +192,8 @@ type
     lowPeersTopics*: int64 # npeers < dlow
     healthyPeersTopics*: int64 # npeers >= dlow
     underDoutTopics*: int64
+
+  IWANTRequest* = object
+    messageId*: MessageId
+    peer*: PubSubPeer
+    timestamp*: Moment

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,10 +7,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import std/[sets, tables, options]
 import rpc/[messages]

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,14 +7,13 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[tables, sets]
+import std/[tables, sets, sequtils]
 import ./pubsubpeer, ../../peerid
 
+export tables, sets
+
 type
   PeerTable* = Table[string, HashSet[PubSubPeer]] # topic string to peer map
 
@@ -51,3 +50,10 @@ func peers*(table: PeerTable, topic: string): int =
     except KeyError: raiseAssert "checked with in"
   else:
     0
+
+func outboundPeers*(table: PeerTable, topic: string): int =
+  if topic in table:
+    try: table[topic].countIt(it.outbound)
+    except KeyError: raiseAssert "checked with in"
+  else:
+    0

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,13 +13,11 @@
 ## `publish<#publish.e%2CPubSub%2Cstring%2Cseq%5Bbyte%5D>`_ something on it,
 ## and eventually `unsubscribe<#unsubscribe%2CPubSub%2Cstring%2CTopicHandler>`_ from it.
 
-when (NimMajor, NimMinor) < (1, 4):
-  {.push raises: [Defect].}
-else:
-  {.push raises: [].}
+{.push raises: [].}
 
 import std/[tables, sequtils, sets, strutils]
 import chronos, chronicles, metrics
+import chronos/ratelimit
 import ./errors as pubsub_errors,
        ./pubsubpeer,
        ./rpc/[message, messages, protobuf],
@@ -36,6 +34,7 @@ import metrics
 import stew/results
 export results
 
+export tables, sets
 export PubSubPeer
 export PubSubObserver
 export protocol
@@ -85,18 +84,18 @@ type
   InitializationError* = object of LPError
 
   TopicHandler* {.public.} = proc(topic: string,
-                       data: seq[byte]): Future[void] {.gcsafe, raises: [Defect].}
+                       data: seq[byte]): Future[void] {.gcsafe, raises: [].}
 
   ValidatorHandler* {.public.} = proc(topic: string,
-                           message: Message): Future[ValidationResult] {.gcsafe, raises: [Defect].}
+                           message: Message): Future[ValidationResult] {.gcsafe, raises: [].}
 
   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: [], gcsafe.}
 
   SubscriptionValidator* {.public.} =
-    proc(topic: string): bool {.raises: [Defect], gcsafe.}
+    proc(topic: string): bool {.raises: [], gcsafe.}
     ## Every time a peer send us a subscription (even to an unknown topic),
     ## we have to store it, which may be an attack vector.
     ## This callback can be used to reject topic we're not interested in
@@ -118,7 +117,7 @@ type
     anonymize*: bool                   ## if we omit fromPeer and seqno from RPC messages we send
     subscriptionValidator*: SubscriptionValidator # callback used to validate subscriptions
     topicsHigh*: int                  ## the maximum number of topics a peer is allowed to subscribe to
-    maxMessageSize*: int          ##\ 
+    maxMessageSize*: int          ##\
       ## the maximum raw message size we'll globally allow
       ## for finer tuning, check message size on topic validator
       ##
@@ -130,7 +129,7 @@ type
 
     knownTopics*: HashSet[string]
 
-method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base.} =
+method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base, gcsafe.} =
   ## handle peer disconnects
   ##
 
@@ -139,7 +138,7 @@ method unsubscribePeer*(p: PubSub, peerId: PeerId) {.base.} =
 
   libp2p_pubsub_peers.set(p.peers.len.int64)
 
-proc send*(p: PubSub, peer: PubSubPeer, msg: RPCMsg) {.raises: [Defect].} =
+proc send*(p: PubSub, peer: PubSubPeer, msg: RPCMsg) {.raises: [].} =
   ## Attempt to send `msg` to remote peer
   ##
 
@@ -149,7 +148,7 @@ proc send*(p: PubSub, peer: PubSubPeer, msg: RPCMsg) {.raises: [Defect].} =
 proc broadcast*(
   p: PubSub,
   sendPeers: auto, # Iteratble[PubSubPeer]
-  msg: RPCMsg) {.raises: [Defect].} =
+  msg: RPCMsg) {.raises: [].} =
   ## Attempt to send `msg` to the given peers
 
   let npeers = sendPeers.len.int64
@@ -172,10 +171,9 @@ proc broadcast*(
       else:
         libp2p_pubsub_broadcast_messages.inc(npeers, labelValues = ["generic"])
 
-  if msg.control.isSome():
-    libp2p_pubsub_broadcast_iwant.inc(npeers * msg.control.get().iwant.len.int64)
+  msg.control.withValue(control):
+    libp2p_pubsub_broadcast_iwant.inc(npeers * control.iwant.len.int64)
 
-    let control = msg.control.get()
     for ihave in control.ihave:
       if p.knownTopics.contains(ihave.topicId):
         libp2p_pubsub_broadcast_ihave.inc(npeers, labelValues = [ihave.topicId])
@@ -202,7 +200,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,
@@ -246,9 +244,8 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =
       else:
         libp2p_pubsub_received_messages.inc(labelValues = ["generic"])
 
-  if rpcMsg.control.isSome():
-    libp2p_pubsub_received_iwant.inc(rpcMsg.control.get().iwant.len.int64)
-    template control: untyped = rpcMsg.control.unsafeGet()
+  rpcMsg.control.withValue(control):
+    libp2p_pubsub_received_iwant.inc(control.iwant.len.int64)
     for ihave in control.ihave:
       if p.knownTopics.contains(ihave.topicId):
         libp2p_pubsub_received_ihave.inc(labelValues = [ihave.topicId])
@@ -267,11 +264,11 @@ proc updateMetrics*(p: PubSub, rpcMsg: RPCMsg) =
 
 method rpcHandler*(p: PubSub,
                    peer: PubSubPeer,
-                   rpcMsg: RPCMsg): Future[void] {.base.} =
+                   data: seq[byte]): 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.} =
   # Peer event is raised for the send connection in particular
@@ -282,10 +279,11 @@ method onPubSubPeerEvent*(p: PubSub, peer: PubSubPeer, event: PubSubPeerEvent) {
   of PubSubPeerEventKind.Disconnected:
     discard
 
-proc getOrCreatePeer*(
+method getOrCreatePeer*(
     p: PubSub,
     peerId: PeerId,
-    protos: seq[string]): PubSubPeer =
+    protos: seq[string]): PubSubPeer {.base, gcsafe.} =
+
   p.peers.withValue(peerId, peer):
     return peer[]
 
@@ -307,8 +305,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] =
@@ -360,9 +356,9 @@ method handleConn*(p: PubSub,
   ##    that we're interested in
   ##
 
-  proc handler(peer: PubSubPeer, msg: RPCMsg): Future[void] =
+  proc handler(peer: PubSubPeer, data: seq[byte]): Future[void] =
     # call pubsub rpc handler
-    p.rpcHandler(peer, msg)
+    p.rpcHandler(peer, data)
 
   let peer = p.getOrCreatePeer(conn.peerId, @[proto])
 
@@ -377,12 +373,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
@@ -400,13 +397,17 @@ 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
 
   # Notify others that we are no longer interested in the topic
   for _, peer in p.peers:
-    p.sendSubs(peer, [topic], subscribed)
+    # If we don't have a sendConn yet, we will
+    # send the full sub list when we get the sendConn,
+    # so no need to send it here
+    if peer.hasSendConn:
+      p.sendSubs(peer, [topic], subscribed)
 
   if subscribed:
     libp2p_pubsub_subscriptions.inc()
@@ -433,7 +434,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
@@ -487,7 +488,7 @@ method publish*(p: PubSub,
   return 0
 
 method initPubSub*(p: PubSub)
-  {.base, raises: [Defect, InitializationError].} =
+  {.base, raises: [InitializationError].} =
   ## perform pubsub initialization
   p.observers = new(seq[PubSubObserver])
   if p.msgIdProvider == nil:
@@ -495,7 +496,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)
@@ -555,7 +556,7 @@ proc init*[PubParams: object | bool](
   maxMessageSize: int = 1024 * 1024,
   rng: ref HmacDrbgContext = newRng(),
   parameters: PubParams = false): P
-  {.raises: [Defect, InitializationError], public.} =
+  {.raises: [InitializationError], public.} =
   let pubsub =
     when PubParams is bool:
       P(switch: switch,

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,13 +7,12 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[sequtils, strutils, tables, hashes]
+import std/[sequtils, strutils, tables, hashes, options, sets, deques]
+import stew/results
 import chronos, chronicles, nimcrypto/sha2, metrics
+import chronos/ratelimit
 import rpc/[messages, message, protobuf],
        ../../peerid,
        ../../peerinfo,
@@ -22,7 +21,7 @@ import rpc/[messages, message, protobuf],
        ../../protobuf/minprotobuf,
        ../../utility
 
-export peerid, connection
+export peerid, connection, deques
 
 logScope:
   topics = "libp2p pubsubpeer"
@@ -34,9 +33,11 @@ when defined(libp2p_expensive_metrics):
   declareCounter(libp2p_pubsub_skipped_sent_messages, "number of sent skipped messages", labels = ["id"])
 
 type
+  PeerRateLimitError* = object of CatchableError
+
   PubSubObserver* = ref object
-    onRecv*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [Defect].}
-    onSend*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [Defect].}
+    onRecv*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [].}
+    onSend*: proc(peer: PubSubPeer; msgs: var RPCMsg) {.gcsafe, raises: [].}
 
   PubSubPeerEventKind* {.pure.} = enum
     Connected
@@ -45,32 +46,42 @@ type
   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].}
+  GetConn* = proc(): Future[Connection] {.gcsafe, raises: [].}
+  DropConn* = proc(peer: PubSubPeer) {.gcsafe, raises: [].} # have to pass peer as it's unknown during init
+  OnEvent* = proc(peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe, raises: [].}
 
   PubSubPeer* = ref object of RootObj
     getConn*: GetConn                   # callback to establish a new send connection
     onEvent*: OnEvent                   # Connectivity updates for peer
     codec*: string                      # the protocol that this peer joined from
     sendConn*: Connection               # cached send connection
+    connectedFut: Future[void]
     address*: Option[MultiAddress]
     peerId*: PeerId
     handler*: RPCHandler
     observers*: ref seq[PubSubObserver] # ref as in smart_ptr
 
     score*: float64
-    iWantBudget*: int
+    sentIHaves*: Deque[HashSet[MessageId]]
+    heDontWants*: Deque[HashSet[MessageId]]
     iHaveBudget*: int
+    pingBudget*: int
     maxMessageSize: int
     appScore*: float64 # application specific score
     behaviourPenalty*: float64 # the eventual penalty score
+    overheadRateLimitOpt*: Opt[TokenBucket]
 
-    when defined(libp2p_agents_metrics):
-      shortAgent*: string
+  RPCHandler* = proc(peer: PubSubPeer, data: seq[byte]): Future[void]
+    {.gcsafe, raises: [].}
 
-  RPCHandler* = proc(peer: PubSubPeer, msg: RPCMsg): Future[void]
-    {.gcsafe, raises: [Defect].}
+when defined(libp2p_agents_metrics):
+  func shortAgent*(p: PubSubPeer): string =
+    if p.sendConn.isNil or p.sendConn.getWrapped().isNil:
+      "unknown"
+    else:
+      #TODO the sendConn is setup before identify,
+      #so we have to read the parents short agent..
+      p.sendConn.getWrapped().shortAgent
 
 func hash*(p: PubSubPeer): Hash =
   p.peerId.hash
@@ -100,7 +111,7 @@ func outbound*(p: PubSubPeer): bool =
   else:
     false
 
-proc recvObservers(p: PubSubPeer, msg: var RPCMsg) =
+proc recvObservers*(p: PubSubPeer, msg: var RPCMsg) =
   # trigger hooks
   if not(isNil(p.observers)) and p.observers[].len > 0:
     for obs in p.observers[]:
@@ -127,28 +138,19 @@ proc handle*(p: PubSubPeer, conn: Connection) {.async.} =
           conn, peer = p, closed = conn.closed,
           data = data.shortLog
 
-        var rmsg = decodeRpcMsg(data)
-        data = newSeq[byte]() # Release memory
-
-        if rmsg.isErr():
-          notice "failed to decode msg from peer",
-            conn, peer = p, closed = conn.closed,
-            err = rmsg.error()
-          break
-
-        trace "decoded msg from peer",
-          conn, peer = p, closed = conn.closed,
-          msg = rmsg.get().shortLog
-        # trigger hooks
-        p.recvObservers(rmsg.get())
-
         when defined(libp2p_expensive_metrics):
-          for m in rmsg.get().messages:
+          for m in rmsg.messages:
             for t in m.topicIDs:
               # metrics
               libp2p_pubsub_received_messages.inc(labelValues = [$p.peerId, t])
 
-        await p.handler(p, rmsg.get())
+        await p.handler(p, data)
+        data = newSeq[byte]() # Release memory
+    except PeerRateLimitError as exc:
+      debug "Peer rate limit exceeded, exiting read while", conn, peer = p, error = exc.msg
+    except CatchableError as exc:
+      debug "Exception occurred in PubSubPeer.handle",
+        conn, peer = p, closed = conn.closed, exc = exc.msg
     finally:
       await conn.close()
   except CancelledError:
@@ -164,7 +166,9 @@ proc handle*(p: PubSubPeer, conn: Connection) {.async.} =
 
 proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
   try:
-    let newConn = await p.getConn()
+    if p.connectedFut.finished:
+      p.connectedFut = newFuture[void]()
+    let newConn = await p.getConn().wait(5.seconds)
     if newConn.isNil:
       raise (ref LPError)(msg: "Cannot establish send connection")
 
@@ -173,8 +177,13 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
     # stop working so we make an effort to only keep a single channel alive
 
     trace "Get new send connection", p, newConn
+
+    # Careful to race conditions here.
+    # Topic subscription relies on either connectedFut
+    # to be completed, or onEvent to be called later
+    p.connectedFut.complete()
     p.sendConn = newConn
-    p.address = 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))
@@ -186,6 +195,9 @@ proc connectOnce(p: PubSubPeer): Future[void] {.async.} =
       await p.sendConn.close()
       p.sendConn = nil
 
+    if not p.connectedFut.finished:
+      p.connectedFut.complete()
+
     try:
       if p.onEvent != nil:
         p.onEvent(p, PubSubPeerEvent(kind: PubSubPeerEventKind.Disconnected))
@@ -207,27 +219,13 @@ proc connectImpl(p: PubSubPeer) {.async.} =
     debug "Could not establish send connection", msg = exc.msg
 
 proc connect*(p: PubSubPeer) =
+  if p.connected:
+    return
+
   asyncSpawn connectImpl(p)
 
-proc 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()
+proc hasSendConn*(p: PubSubPeer): bool =
+  p.sendConn != nil
 
 template sendMetrics(msg: RPCMsg): untyped =
   when defined(libp2p_expensive_metrics):
@@ -236,7 +234,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: [], async.} =
   doAssert(not isNil(p), "pubsubpeer nil!")
 
   if msg.len <= 0:
@@ -244,21 +242,69 @@ proc sendEncoded*(p: PubSubPeer, msg: seq[byte]) {.raises: [Defect].} =
     return
 
   if msg.len > p.maxMessageSize:
-    info "trying to send a too big for pubsub", maxSize=p.maxMessageSize, msgSize=msg.len
+    info "trying to send a msg too big for pubsub", maxSize=p.maxMessageSize, msgSize=msg.len
     return
 
-  let conn = p.sendConn
+  if p.sendConn == nil:
+    # Wait for a send conn to be setup. `connectOnce` will
+    # complete this even if the sendConn setup failed
+    await p.connectedFut
+
+  var conn = p.sendConn
   if conn == nil or conn.closed():
-    trace "No send connection, skipping message", p, msg = shortLog(msg)
+    debug "No send connection", 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)
 
-proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [Defect].} =
-  trace "sending msg to peer", peer = p, rpcMsg = 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
+
+iterator splitRPCMsg(peer: PubSubPeer, rpcMsg: RPCMsg, maxSize: int, anonymize: bool): seq[byte] =
+  ## This iterator takes an `RPCMsg` and sequentially repackages its Messages into new `RPCMsg` instances.
+  ## Each new `RPCMsg` accumulates Messages until reaching the specified `maxSize`. If a single Message
+  ## exceeds the `maxSize` when trying to fit into an empty `RPCMsg`, the latter is skipped as too large to send.
+  ## Every constructed `RPCMsg` is then encoded, optionally anonymized, and yielded as a sequence of bytes.
+
+  var currentRPCMsg = rpcMsg
+  currentRPCMsg.messages = newSeq[Message]()
+
+  var currentSize = byteSize(currentRPCMsg)
+
+  for msg in rpcMsg.messages:
+    let msgSize = byteSize(msg)
+
+    # Check if adding the next message will exceed maxSize
+    if float(currentSize + msgSize) * 1.1 > float(maxSize): # Guessing 10% protobuf overhead
+      if currentRPCMsg.messages.len == 0:
+        trace "message too big to sent", peer, rpcMsg = shortLog(currentRPCMsg)
+        continue # Skip this message
+
+      trace "sending msg to peer", peer, rpcMsg = shortLog(currentRPCMsg)
+      yield encodeRpcMsg(currentRPCMsg, anonymize)
+      currentRPCMsg = RPCMsg()
+      currentSize = 0
+
+    currentRPCMsg.messages.add(msg)
+    currentSize += msgSize
+
+  # Check if there is a non-empty currentRPCMsg left to be added
+  if currentSize > 0 and currentRPCMsg.messages.len > 0:
+    trace "sending msg to peer", peer, rpcMsg = shortLog(currentRPCMsg)
+    yield encodeRpcMsg(currentRPCMsg, anonymize)
+  else:
+    trace "message too big to sent", peer, rpcMsg = shortLog(currentRPCMsg)
+
+proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [].} =
   # When sending messages, we take care to re-encode them with the right
   # anonymization flag to ensure that we're not penalized for sending invalid
   # or malicious data on the wire - in particular, re-encoding protects against
@@ -276,7 +322,20 @@ proc send*(p: PubSubPeer, msg: RPCMsg, anonymize: bool) {.raises: [Defect].} =
     sendMetrics(msg)
     encodeRpcMsg(msg, anonymize)
 
-  p.sendEncoded(encoded)
+  if encoded.len > p.maxMessageSize and msg.messages.len > 1:
+    for encodedSplitMsg in splitRPCMsg(p, msg, p.maxMessageSize, anonymize):
+      asyncSpawn p.sendEncoded(encodedSplitMsg)
+  else:
+    # If the message size is within limits, send it as is
+    trace "sending msg to peer", peer = p, rpcMsg = shortLog(msg)
+    asyncSpawn p.sendEncoded(encoded)
+
+proc canAskIWant*(p: PubSubPeer, msgId: MessageId): bool =
+  for sentIHave in p.sentIHaves.mitems():
+    if msgId in sentIHave:
+      sentIHave.excl(msgId)
+      return true
+  return false
 
 proc new*(
   T: typedesc[PubSubPeer],
@@ -284,12 +343,27 @@ proc new*(
   getConn: GetConn,
   onEvent: OnEvent,
   codec: string,
-  maxMessageSize: int): T =
+  maxMessageSize: int,
+  overheadRateLimitOpt: Opt[TokenBucket] = Opt.none(TokenBucket)): T =
 
-  T(
+  result = T(
     getConn: getConn,
     onEvent: onEvent,
     codec: codec,
     peerId: peerId,
-    maxMessageSize: maxMessageSize
+    connectedFut: newFuture[void](),
+    maxMessageSize: maxMessageSize,
+    overheadRateLimitOpt: overheadRateLimitOpt
   )
+  result.sentIHaves.addFirst(default(HashSet[MessageId]))
+  result.heDontWants.addFirst(default(HashSet[MessageId]))
+
+proc getAgent*(peer: PubSubPeer): string =
+  return
+    when defined(libp2p_agents_metrics):
+      if peer.shortAgent.len > 0:
+        peer.shortAgent
+      else:
+        "unknown"
+    else:
+      "unknown"

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,12 +7,8 @@
 # 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: [].}
+{.push raises: [].}
 
-import hashes
 import chronicles, metrics, stew/[byteutils, endians2]
 import ./messages,
        ./protobuf,
@@ -66,22 +62,21 @@ proc init*(
     topic: string,
     seqno: Option[uint64],
     sign: bool = true): Message
-    {.gcsafe, raises: [Defect, LPError].} =
+    {.gcsafe, raises: [LPError].} =
   var msg = Message(data: data, topicIDs: @[topic])
 
   # order matters, we want to include seqno in the signature
-  if seqno.isSome:
-    msg.seqno = @(seqno.get().toBytesBE())
+  seqno.withValue(seqn):
+    msg.seqno = @(seqn.toBytesBE())
 
-  if peer.isSome:
-    let peer = peer.get()
+  peer.withValue(peer):
     msg.fromPeer = peer.peerId
     if sign:
       msg.signature = sign(msg, peer.privateKey).expect("Couldn't sign message!")
       msg.key = peer.privateKey.getPublicKey().expect("Invalid private key!")
         .getBytes().expect("Couldn't get public key bytes!")
-  elif sign:
-    raise (ref LPError)(msg: "Cannot sign message without peer info")
+  else:
+    if sign: raise (ref LPError)(msg: "Cannot sign message without peer info")
 
   msg
 
@@ -91,10 +86,10 @@ proc init*(
     data: seq[byte],
     topic: string,
     seqno: Option[uint64]): Message
-    {.gcsafe, raises: [Defect, LPError].} =
+    {.gcsafe, raises: [LPError].} =
   var msg = Message(data: data, topicIDs: @[topic])
   msg.fromPeer = peerId
 
-  if seqno.isSome:
-    msg.seqno = @(seqno.get().toBytesBE())
+  seqno.withValue(seqn):
+    msg.seqno = @(seqn.toBytesBE())
   msg

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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import options, sequtils
+import options, sequtils, sugar
 import "../../.."/[
         peerid,
         routing_record,
@@ -21,6 +18,14 @@ import "../../.."/[
 
 export options
 
+proc expectedFields[T](t: typedesc[T], existingFieldNames: seq[string]) {.raises: [CatchableError].} =
+  var fieldNames: seq[string]
+  for name, _ in fieldPairs(T()):
+    fieldNames &= name
+  if fieldNames != existingFieldNames:
+    fieldNames.keepIf(proc(it: string): bool = it notin existingFieldNames)
+    raise newException(CatchableError, $T & " fields changed, please search for and revise all relevant procs. New fields: " & $fieldNames)
+
 type
     PeerInfoMsg* = object
       peerId*: PeerId
@@ -45,6 +50,7 @@ type
       iwant*: seq[ControlIWant]
       graft*: seq[ControlGraft]
       prune*: seq[ControlPrune]
+      idontwant*: seq[ControlIWant]
 
     ControlIHave* = object
       topicId*: string
@@ -65,6 +71,8 @@ type
       subscriptions*: seq[SubOpts]
       messages*: seq[Message]
       control*: Option[ControlMessage]
+      ping*: seq[byte]
+      pong*: seq[byte]
 
 func withSubs*(
     T: type RPCMsg, topics: openArray[string], subscribe: bool): T =
@@ -111,15 +119,59 @@ func shortLog*(msg: Message): auto =
   )
 
 func shortLog*(m: RPCMsg): auto =
-  if m.control.isSome:
-    (
-      subscriptions: m.subscriptions,
-      messages: mapIt(m.messages, it.shortLog),
-      control: m.control.get().shortLog
-    )
-  else:
-    (
-      subscriptions: m.subscriptions,
-      messages: mapIt(m.messages, it.shortLog),
-      control: ControlMessage().shortLog
-    )
+  (
+    subscriptions: m.subscriptions,
+    messages: mapIt(m.messages, it.shortLog),
+    control: m.control.get(ControlMessage()).shortLog
+  )
+
+static: expectedFields(PeerInfoMsg, @["peerId", "signedPeerRecord"])
+proc byteSize(peerInfo: PeerInfoMsg): int =
+  peerInfo.peerId.len + peerInfo.signedPeerRecord.len
+
+static: expectedFields(SubOpts, @["subscribe", "topic"])
+proc byteSize(subOpts: SubOpts): int =
+  1 + subOpts.topic.len # 1 byte for the bool
+
+static: expectedFields(Message, @["fromPeer", "data", "seqno", "topicIds", "signature", "key"])
+proc byteSize*(msg: Message): int =
+  msg.fromPeer.len + msg.data.len + msg.seqno.len +
+         msg.signature.len + msg.key.len + msg.topicIds.foldl(a + b.len, 0)
+
+proc byteSize*(msgs: seq[Message]): int =
+  msgs.foldl(a + b.byteSize, 0)
+
+static: expectedFields(ControlIHave, @["topicId", "messageIds"])
+proc byteSize(controlIHave: ControlIHave): int =
+  controlIHave.topicId.len + controlIHave.messageIds.foldl(a + b.len, 0)
+
+proc byteSize*(ihaves: seq[ControlIHave]): int =
+  ihaves.foldl(a + b.byteSize, 0)
+
+static: expectedFields(ControlIWant, @["messageIds"])
+proc byteSize(controlIWant: ControlIWant): int =
+  controlIWant.messageIds.foldl(a + b.len, 0)
+
+proc byteSize*(iwants: seq[ControlIWant]): int =
+  iwants.foldl(a + b.byteSize, 0)
+
+static: expectedFields(ControlGraft, @["topicId"])
+proc byteSize(controlGraft: ControlGraft): int =
+  controlGraft.topicId.len
+
+static: expectedFields(ControlPrune, @["topicId", "peers", "backoff"])
+proc byteSize(controlPrune: ControlPrune): int =
+  controlPrune.topicId.len + controlPrune.peers.foldl(a + b.byteSize, 0) + 8 # 8 bytes for uint64
+
+static: expectedFields(ControlMessage, @["ihave", "iwant", "graft", "prune", "idontwant"])
+proc byteSize(control: ControlMessage): int =
+  control.ihave.foldl(a + b.byteSize, 0) + control.iwant.foldl(a + b.byteSize, 0) +
+  control.graft.foldl(a + b.byteSize, 0) + control.prune.foldl(a + b.byteSize, 0) +
+  control.idontwant.foldl(a + b.byteSize, 0)
+
+static: expectedFields(RPCMsg, @["subscriptions", "messages", "control", "ping", "pong"])
+proc byteSize*(rpc: RPCMsg): int =
+  result = rpc.subscriptions.foldl(a + b.byteSize, 0) + byteSize(rpc.messages) +
+           rpc.ping.len + rpc.pong.len
+  rpc.control.withValue(ctrl):
+    result += ctrl.byteSize

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,10 +7,7 @@
 # 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: [].}
+{.push raises: [].}
 
 import options
 import stew/assign2
@@ -22,7 +19,7 @@ import messages,
 
 
 logScope:
-  topics = "pubsubprotobuf"
+  topics = "libp2p pubsubprotobuf"
 
 when defined(libp2p_protobuf_metrics):
   import metrics
@@ -90,6 +87,8 @@ proc write*(pb: var ProtoBuffer, field: int, control: ControlMessage) =
     ipb.write(3, graft)
   for prune in control.prune:
     ipb.write(4, prune)
+  for idontwant in control.idontwant:
+    ipb.write(5, idontwant)
   if len(ipb.buffer) > 0:
     ipb.finish()
     pb.write(field, ipb)
@@ -213,6 +212,7 @@ proc decodeControl*(pb: ProtoBuffer): ProtoResult[Option[ControlMessage]] {.
     var iwantpbs: seq[seq[byte]]
     var graftpbs: seq[seq[byte]]
     var prunepbs: seq[seq[byte]]
+    var idontwant: seq[seq[byte]]
     if ? cpb.getRepeatedField(1, ihavepbs):
       for item in ihavepbs:
         control.ihave.add(? decodeIHave(initProtoBuffer(item)))
@@ -225,6 +225,9 @@ proc decodeControl*(pb: ProtoBuffer): ProtoResult[Option[ControlMessage]] {.
     if ? cpb.getRepeatedField(4, prunepbs):
       for item in prunepbs:
         control.prune.add(? decodePrune(initProtoBuffer(item)))
+    if ? cpb.getRepeatedField(5, idontwant):
+      for item in idontwant:
+        control.idontwant.add(? decodeIWant(initProtoBuffer(item)))
     trace "decodeControl: message statistics", graft_count = len(control.graft),
                                                prune_count = len(control.prune),
                                                ihave_count = len(control.ihave),
@@ -304,29 +307,38 @@ 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:
     pb.write(2, item, anonymize)
-  if msg.control.isSome():
-    pb.write(3, msg.control.get())
+  msg.control.withValue(control):
+    pb.write(3, control)
+  # nim-libp2p extension, using fields which are unlikely to be used
+  # by other extensions
+  if msg.ping.len > 0:
+    pb.write(60, msg.ping)
+  if msg.pong.len > 0:
+    pb.write(61, msg.pong)
   if len(pb.buffer) > 0:
     pb.finish()
   pb.buffer
 
 proc decodeRpcMsg*(msg: seq[byte]): ProtoResult[RPCMsg] {.inline.} =
   trace "decodeRpcMsg: decoding message", msg = msg.shortLog()
-  var pb = initProtoBuffer(msg)
-  var rpcMsg = ok(RPCMsg())
-  assign(rpcMsg.get().messages, ? pb.decodeMessages())
-  assign(rpcMsg.get().subscriptions, ? pb.decodeSubscriptions())
-  assign(rpcMsg.get().control, ? pb.decodeControl())
-  rpcMsg
+  var pb = initProtoBuffer(msg, maxSize = uint.high)
+  var rpcMsg = RPCMsg()
+  assign(rpcMsg.messages, ? pb.decodeMessages())
+  assign(rpcMsg.subscriptions, ? pb.decodeSubscriptions())
+  assign(rpcMsg.control, ? pb.decodeControl())
+  discard ? pb.getField(60, rpcMsg.ping)
+  discard ? pb.getField(61, rpcMsg.pong)
+  ok(rpcMsg)

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,14 +7,13 @@
 # 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: [].}
+{.push raises: [].}
 
 import std/[tables]
 
-import chronos/timer
+import chronos/timer, stew/results
+
+import ../../utility
 
 const Timeout* = 10.seconds # default timeout in ms
 
@@ -22,6 +21,7 @@ type
   TimedEntry*[K] = ref object of RootObj
     key: K
     addedAt: Moment
+    expiresAt: Moment
     next, prev: TimedEntry[K]
 
   TimedCache*[K] = object of RootObj
@@ -30,15 +30,14 @@ type
     timeout: Duration
 
 func expire*(t: var TimedCache, now: Moment = Moment.now()) =
-  let expirationLimit = now - t.timeout
-  while t.head != nil and t.head.addedAt < expirationLimit:
+  while t.head != nil and t.head.expiresAt < now:
     t.entries.del(t.head.key)
     t.head.prev = nil
     t.head = t.head.next
     if t.head == nil: t.tail = nil
 
-func del*[K](t: var TimedCache[K], key: K): bool =
-  # Removes existing key from cache, returning false if it was not present
+func del*[K](t: var TimedCache[K], key: K): Opt[TimedEntry[K]] =
+  # Removes existing key from cache, returning the previous value if present
   var item: TimedEntry[K]
   if t.entries.pop(key, item):
     if t.head == item: t.head = item.next
@@ -46,9 +45,9 @@ func del*[K](t: var TimedCache[K], key: K): bool =
 
     if item.next != nil: item.next.prev = item.prev
     if item.prev != nil: item.prev.next = item.next
-    true
+    Opt.some(item)
   else:
-    false
+    Opt.none(TimedEntry[K])
 
 func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
   # Puts k in cache, returning true if the item was already present and false
@@ -56,9 +55,13 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
   # refreshed.
   t.expire(now)
 
-  var res = t.del(k) # Refresh existing item
+  var previous = t.del(k) # Refresh existing item
 
-  let node = TimedEntry[K](key: k, addedAt: now)
+  var addedAt = now
+  previous.withValue(previous):
+    addedAt = previous.addedAt
+
+  let node = TimedEntry[K](key: k, addedAt: addedAt, expiresAt: now + t.timeout)
 
   if t.head == nil:
     t.tail = node
@@ -66,7 +69,7 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
   else:
     # search from tail because typically that's where we add when now grows
     var cur = t.tail
-    while cur != nil and node.addedAt < cur.addedAt:
+    while cur != nil and node.expiresAt < cur.expiresAt:
       cur = cur.prev
 
     if cur == nil:
@@ -82,7 +85,7 @@ func put*[K](t: var TimedCache[K], k: K, now = Moment.now()): bool =
 
   t.entries[k] = node
 
-  res
+  previous.isSome()
 
 func contains*[K](t: TimedCache[K], k: K): bool =
   k in t.entries

libp2p/protocols/rendezvous.nim

@@ -0,0 +1,694 @@
+# Nim-LibP2P
+# Copyright (c) 2023 Status Research & Development GmbH
+# Licensed under either of
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+# at your option.
+# This file may not be copied, modified, or distributed except according to
+# those terms.
+
+{.push raises: [].}
+
+import tables, sequtils, sugar, sets
+import metrics except collect
+import chronos,
+       chronicles,
+       bearssl/rand,
+       stew/[byteutils, objects, results]
+import ./protocol,
+       ../switch,
+       ../routing_record,
+       ../utils/heartbeat,
+       ../stream/connection,
+       ../utils/offsettedseq,
+       ../utils/semaphore
+
+export chronicles
+
+logScope:
+  topics = "libp2p discovery rendezvous"
+
+declareCounter(libp2p_rendezvous_register, "number of advertise requests")
+declareCounter(libp2p_rendezvous_discover, "number of discovery requests")
+declareGauge(libp2p_rendezvous_registered, "number of registered peers")
+declareGauge(libp2p_rendezvous_namespaces, "number of registered namespaces")
+
+const
+  RendezVousCodec* = "/rendezvous/1.0.0"
+  MinimumDuration* = 2.hours
+  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: Opt[uint64] # in seconds
+
+  RegisterResponse = object
+    status: ResponseStatus
+    text: Opt[string]
+    ttl: Opt[uint64] # in seconds
+
+  Unregister = object
+    ns: string
+
+  Discover = object
+    ns: string
+    limit: Opt[uint64]
+    cookie: Opt[seq[byte]]
+
+  DiscoverResponse = object
+    registrations: seq[Register]
+    cookie: Opt[seq[byte]]
+    status: ResponseStatus
+    text: Opt[string]
+
+  Message = object
+    msgType: MessageType
+    register: Opt[Register]
+    registerResponse: Opt[RegisterResponse]
+    unregister: Opt[Unregister]
+    discover: Opt[Discover]
+    discoverResponse: Opt[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)
+  r.ttl.withValue(ttl):
+    result.write(3, ttl)
+  result.finish()
+
+proc encode(rr: RegisterResponse): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, rr.status.uint)
+  rr.text.withValue(text):
+    result.write(2, text)
+  rr.ttl.withValue(ttl):
+    result.write(3, ttl)
+  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)
+  d.limit.withValue(limit):
+    result.write(2, limit)
+  d.cookie.withValue(cookie):
+    result.write(3, cookie)
+  result.finish()
+
+proc encode(dr: DiscoverResponse): ProtoBuffer =
+  result = initProtoBuffer()
+  for reg in dr.registrations:
+    result.write(1, reg.encode())
+  dr.cookie.withValue(cookie):
+    result.write(2, cookie)
+  result.write(3, dr.status.uint)
+  dr.text.withValue(text):
+    result.write(4, text)
+  result.finish()
+
+proc encode(msg: Message): ProtoBuffer =
+  result = initProtoBuffer()
+  result.write(1, msg.msgType.uint)
+  msg.register.withValue(register):
+    result.write(2, register.encode())
+  msg.registerResponse.withValue(registerResponse):
+    result.write(3, registerResponse.encode())
+  msg.unregister.withValue(unregister):
+    result.write(4, unregister.encode())
+  msg.discover.withValue(discover):
+    result.write(5, discover.encode())
+  msg.discoverResponse.withValue(discoverResponse):
+    result.write(6, discoverResponse.encode())
+  result.finish()
+
+proc decode(_: typedesc[Cookie], buf: seq[byte]): Opt[Cookie] =
+  var c: Cookie
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, c.offset)
+    r2 = pb.getRequiredField(2, c.ns)
+  if r1.isErr() or r2.isErr(): return Opt.none(Cookie)
+  Opt.some(c)
+
+proc decode(_: typedesc[Register], buf: seq[byte]): Opt[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 Opt.none(Register)
+  if r3.get(false): r.ttl = Opt.some(ttl)
+  Opt.some(r)
+
+proc decode(_: typedesc[RegisterResponse], buf: seq[byte]): Opt[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 Opt.none(RegisterResponse)
+  if r2.get(false): rr.text = Opt.some(text)
+  if r3.get(false): rr.ttl = Opt.some(ttl)
+  Opt.some(rr)
+
+proc decode(_: typedesc[Unregister], buf: seq[byte]): Opt[Unregister] =
+  var u: Unregister
+  let
+    pb = initProtoBuffer(buf)
+    r1 = pb.getRequiredField(1, u.ns)
+  if r1.isErr(): return Opt.none(Unregister)
+  Opt.some(u)
+
+proc decode(_: typedesc[Discover], buf: seq[byte]): Opt[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 Opt.none(Discover)
+  if r2.get(false): d.limit = Opt.some(limit)
+  if r3.get(false): d.cookie = Opt.some(cookie)
+  Opt.some(d)
+
+proc decode(_: typedesc[DiscoverResponse], buf: seq[byte]): Opt[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 Opt.none(DiscoverResponse)
+  for reg in registrations:
+    var r: Register
+    let regOpt = Register.decode(reg).valueOr:
+      return
+    dr.registrations.add(regOpt)
+  if r2.get(false): dr.cookie = Opt.some(cookie)
+  if r4.get(false): dr.text = Opt.some(text)
+  Opt.some(dr)
+
+proc decode(_: typedesc[Message], buf: seq[byte]): Opt[Message] =
+  var
+    msg: Message
+    statusOrd: uint
+    pbr, pbrr, pbu, pbd, pbdr: ProtoBuffer
+  let pb = initProtoBuffer(buf)
+
+  ? pb.getRequiredField(1, statusOrd).toOpt
+  if not checkedEnumAssign(msg.msgType, statusOrd): return Opt.none(Message)
+
+  if ? pb.getField(2, pbr).optValue:
+    msg.register = Register.decode(pbr.buffer)
+    if msg.register.isNone(): return Opt.none(Message)
+
+  if ? pb.getField(3, pbrr).optValue:
+    msg.registerResponse = RegisterResponse.decode(pbrr.buffer)
+    if msg.registerResponse.isNone(): return Opt.none(Message)
+
+  if ? pb.getField(4, pbu).optValue:
+    msg.unregister = Unregister.decode(pbu.buffer)
+    if msg.unregister.isNone(): return Opt.none(Message)
+
+  if ? pb.getField(5, pbd).optValue:
+    msg.discover = Discover.decode(pbd.buffer)
+    if msg.discover.isNone(): return Opt.none(Message)
+
+  if ? pb.getField(6, pbdr).optValue:
+    msg.discoverResponse = DiscoverResponse.decode(pbdr.buffer)
+    if msg.discoverResponse.isNone(): return Opt.none(Message)
+
+  Opt.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: Opt.some(RegisterResponse(status: Ok, ttl: Opt.some(ttl)))))
+  await conn.writeLp(msg.buffer)
+
+proc sendRegisterResponseError(conn: Connection,
+                               status: ResponseStatus,
+                               text: string = "") {.async.} =
+  let msg = encode(Message(
+        msgType: MessageType.RegisterResponse,
+        registerResponse: Opt.some(RegisterResponse(status: status, text: Opt.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: Opt.some(DiscoverResponse(
+            status: Ok,
+            registrations: s,
+            cookie: Opt.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: Opt.some(DiscoverResponse(status: status, text: Opt.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
+  libp2p_rendezvous_register.inc()
+  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)
+  libp2p_rendezvous_registered.inc()
+  libp2p_rendezvous_namespaces.set(int64(rdv.namespaces.len))
+  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
+        libp2p_rendezvous_registered.dec()
+  except KeyError:
+    return
+
+proc discover(rdv: RendezVous, conn: Connection, d: Discover) {.async.} =
+  trace "Received Discover", peerId = conn.peerId, ns = d.ns
+  libp2p_rendezvous_discover.inc()
+  if d.ns.len notin 0..255:
+    await conn.sendDiscoverResponseError(InvalidNamespace)
+    return
+  var limit = min(DiscoverLimit, d.limit.get(DiscoverLimit))
+  var
+    cookie =
+      if d.cookie.isSome():
+        try:
+          Cookie.decode(d.cookie.tryGet()).tryGet()
+        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 = Opt.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).tryGet()
+      if msgRecv.msgType != MessageType.RegisterResponse:
+        trace "Unexpected register response", peer, msgType = msgRecv.msgType
+      elif msgRecv.registerResponse.tryGet().status != ResponseStatus.Ok:
+        trace "Refuse to register", peer, response = msgRecv.registerResponse
+      else:
+        trace "Successfully registered", peer, response = msgRecv.registerResponse
+    except CatchableError as exc:
+      trace "exception in the advertise", error = exc.msg
+    finally:
+      rdv.sema.release()
+  await rdv.sema.acquire()
+  discard await advertiseWrap().withTimeout(5.seconds)
+
+method advertise*(rdv: RendezVous,
+                ns: string,
+                ttl: Duration = MinimumDuration) {.async, base.} =
+  let sprBuff = rdv.switch.peerInfo.signedPeerRecord.encode().valueOr:
+    raise newException(RendezVousError, "Wrong Signed Peer Record")
+  if ns.len notin 1..255:
+    raise newException(RendezVousError, "Invalid namespace")
+  if ttl notin MinimumDuration..MaximumDuration:
+    raise newException(RendezVousError, "Invalid time to live")
+  let
+    r = Register(ns: ns, signedPeerRecord: sprBuff, ttl: Opt.some(ttl.seconds.uint64))
+    msg = encode(Message(msgType: MessageType.Register, register: Opt.some(r)))
+  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:
+          let res = SignedPeerRecord.decode(rdv.registered[index].data.signedPeerRecord).valueOr:
+            continue
+          res.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 = Opt.some(limit)
+    d.cookie =
+      try:
+        Opt.some(rdv.cookiesSaved[peer][ns])
+      except KeyError as exc:
+        Opt.none(seq[byte])
+    await conn.writeLp(encode(Message(
+      msgType: MessageType.Discover,
+      discover: Opt.some(d))).buffer)
+    let
+      buf = await conn.readLp(65536)
+      msgRcv = Message.decode(buf).valueOr:
+        debug "Message undecodable"
+        return
+    if msgRcv.msgType != MessageType.DiscoverResponse:
+      debug "Unexpected discover response", msgType = msgRcv.msgType
+      return
+    let resp = msgRcv.discoverResponse.valueOr:
+      debug "Discover response is empty"
+      return
+    if resp.status != ResponseStatus.Ok:
+      trace "Cannot discover", ns, status = resp.status, text = resp.text
+      return
+    resp.cookie.withValue(cookie):
+      if  cookie.len() < 1000 and rdv.cookiesSaved.hasKeyOrPut(peer, {ns: cookie}.toTable()):
+        rdv.cookiesSaved[peer][ns] = cookie
+    for r in resp.registrations:
+      if limit == 0: return
+      let ttl = r.ttl.get(MaximumTTL + 1)
+      if ttl > MaximumTTL: continue
+      let
+        spr = SignedPeerRecord.decode(r.signedPeerRecord).valueOr: continue
+        pr = spr.data
+      if s.hasKey(pr.peerId):
+        let (prSaved, rSaved) = s[pr.peerId]
+        if (prSaved.seqNo == pr.seqNo and rSaved.ttl.get(MaximumTTL) < ttl) 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: Opt.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).tryGet()
+      case msg.msgType:
+        of MessageType.Register: await rdv.register(conn, msg.register.tryGet())
+        of MessageType.RegisterResponse:
+          trace "Got an unexpected Register Response", response = msg.registerResponse
+        of MessageType.Unregister: rdv.unregister(conn, msg.unregister.tryGet())
+        of MessageType.Discover: await rdv.discover(conn, msg.discover.tryGet())
+        of MessageType.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()
+    var total = 0
+    rdv.registered.flushIfIt(it.expiration < n)
+    for data in rdv.namespaces.mvalues():
+      data.keepItIf(it >= rdv.registered.offset)
+      total += data.len
+    libp2p_rendezvous_registered.set(int64(total))
+    libp2p_rendezvous_namespaces.set(int64(rdv.namespaces.len))
+
+method start*(rdv: RendezVous) {.async.} =
+  if not rdv.registerDeletionLoop.isNil:
+    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,12 +7,9 @@
 # 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: [].}
+{.push raises: [].}
 
-import std/[oids, strformat]
+import std/strformat
 import chronos
 import chronicles
 import bearssl/[rand, hash]
@@ -136,7 +133,7 @@ proc encrypt(
     state: var CipherState,
     data: var openArray[byte],
     ad: openArray[byte]): ChaChaPolyTag
-    {.noinit, raises: [Defect, NoiseNonceMaxError].} =
+    {.noinit, raises: [NoiseNonceMaxError].} =
 
   var nonce: ChaChaPolyNonce
   nonce[4..<12] = toBytesLE(state.n)
@@ -148,7 +145,7 @@ proc encrypt(
     raise newException(NoiseNonceMaxError, "Noise max nonce value reached")
 
 proc encryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
-  {.raises: [Defect, NoiseNonceMaxError].} =
+  {.raises: [NoiseNonceMaxError].} =
   result = newSeqOfCap[byte](data.len + sizeof(ChaChaPolyTag))
   result.add(data)
 
@@ -160,7 +157,7 @@ proc encryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
     tag = byteutils.toHex(tag), data = result.shortLog, nonce = state.n - 1
 
 proc decryptWithAd(state: var CipherState, ad, data: openArray[byte]): seq[byte]
-  {.raises: [Defect, NoiseDecryptTagError, NoiseNonceMaxError].} =
+  {.raises: [NoiseDecryptTagError, NoiseNonceMaxError].} =
   var
     tagIn = data.toOpenArray(data.len - ChaChaPolyTag.len, data.high).intoChaChaPolyTag
     tagOut: ChaChaPolyTag
@@ -209,7 +206,7 @@ proc mixKeyAndHash(ss: var SymmetricState, ikm: openArray[byte]) {.used.} =
   ss.cs = CipherState(k: temp_keys[2])
 
 proc encryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
-  {.raises: [Defect, NoiseNonceMaxError].} =
+  {.raises: [NoiseNonceMaxError].} =
   # according to spec if key is empty leave plaintext
   if ss.cs.hasKey:
     result = ss.cs.encryptWithAd(ss.h.data, data)
@@ -218,7 +215,7 @@ proc encryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
   ss.mixHash(result)
 
 proc decryptAndHash(ss: var SymmetricState, data: openArray[byte]): seq[byte]
-  {.raises: [Defect, NoiseDecryptTagError, NoiseNonceMaxError].} =
+  {.raises: [NoiseDecryptTagError, NoiseNonceMaxError].} =
   # according to spec if key is empty leave plaintext
   if ss.cs.hasKey and data.len > ChaChaPolyTag.len:
     result = ss.cs.decryptWithAd(ss.h.data, data)
@@ -448,7 +445,7 @@ proc encryptFrame(
     sconn: NoiseConnection,
     cipherFrame: var openArray[byte],
     src: openArray[byte])
-    {.raises: [Defect, NoiseNonceMaxError].} =
+    {.raises: [NoiseNonceMaxError].} =
   # Frame consists of length + cipher data + tag
   doAssert src.len <= MaxPlainSize
   doAssert cipherFrame.len == 2 + src.len + sizeof(ChaChaPolyTag)
@@ -557,8 +554,7 @@ method handshake*(p: Noise, conn: Connection, initiator: bool, peerId: Opt[PeerI
 
     trace "Remote peer id", pid = $pid
 
-    if peerId.isSome():
-      let targetPid = peerId.get()
+    peerId.withValue(targetPid):
       if not targetPid.validate():
         raise newException(NoiseHandshakeError, "Failed to validate expected peerId.")