chore(version): update libp2p.nimble to 1.8.0 (#1236)

This PR's commit is planned to be tagged as v1.8.0

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Formatted with nph 0.5.1
+dc83a1e9b68f00b3be7e09febdb1a3f877321b9a

.github/actions/install_nim/action.yml

@@ -6,7 +6,7 @@ inputs:
   cpu:
     description: "CPU to build for"
     default: "amd64"
-  nim_branch:
+  nim_ref:
     description: "Nim version"
     default: "version-1-6"
   shell:
@@ -61,7 +61,7 @@ runs:
     - name: Restore Nim DLLs dependencies (Windows) from cache
       if: inputs.os == 'Windows'
       id: windows-dlls-cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: external/dlls
         key: 'dlls'
@@ -88,6 +88,8 @@ runs:
       run: |
         if [[ '${{ inputs.cpu }}' == 'amd64' ]]; then
           PLATFORM=x64
+        elif [[ '${{ inputs.cpu }}' == 'arm64' ]]; then
+          PLATFORM=arm64
         else
           PLATFORM=x86
         fi
@@ -114,10 +116,10 @@ runs:
 
     - name: Restore Nim from cache
       id: nim-cache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: '${{ github.workspace }}/nim'
-        key: ${{ inputs.os }}-${{ inputs.cpu }}-nim-${{ inputs.nim_branch }}-cache-${{ env.cache_nonce }}
+        key: ${{ inputs.os }}-${{ inputs.cpu }}-nim-${{ inputs.nim_ref }}-cache-${{ env.cache_nonce }}
 
     - name: Build Nim and Nimble
       shell: ${{ inputs.shell }}
@@ -126,6 +128,6 @@ runs:
         # 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 }} \
+        env MAKE="${MAKE_CMD} -j${ncpu}" ARCH_OVERRIDE=${PLATFORM} NIM_COMMIT=${{ inputs.nim_ref }} \
           QUICK_AND_DIRTY_COMPILER=1 QUICK_AND_DIRTY_NIMBLE=1 CC=gcc \
           bash build_nim.sh nim csources dist/nimble NimBinaries

.github/scripts/colors.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# Colors
+export YLW='\033[1;33m'
+export RED='\033[0;31m'
+export GRN='\033[0;32m'
+export BLU='\033[0;34m'
+export BLD='\033[1m'
+export RST='\033[0m'
+
+# Clear line
+export CLR='\033[2K'

.github/scripts/commit_check.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+source .github/scripts/parse_commits.sh
+parse_commits "$@"

.github/scripts/parse_commits.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+# The output of this script is as follows:
+# 1. One line "checking commits between: <start_commit> <end_commit>"
+# 2. One line for each commit message that is not well-formed
+
+set -euo pipefail
+
+source .github/scripts/colors.sh
+
+parse_commits() {
+
+    BASE_BRANCH=${BASE_BRANCH:-master}
+
+    start_commit=${1:-origin/${BASE_BRANCH}}
+    end_commit=${2:-HEAD}
+    exit_code=0
+
+    echo -e "${GRN}Checking commits between:${RST} $start_commit $end_commit"
+    # Run the loop in the current shell using process substitution
+    while IFS= read -r message || [ -n "$message" ]; do
+        # Check if commit message follows conventional commits format
+        if [[ ! $message =~ ^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?:.*$ ]]; then
+            echo -e "${YLW}Commit message is ill-formed:${RST} $message"
+            exit_code=1
+        fi
+    done < <(git log --format=%s "$start_commit".."$end_commit")
+
+    exit ${exit_code}
+}

.github/workflows/auto_assign_pr.yml

@@ -0,0 +1,12 @@
+name: Auto Assign PR to Creator
+
+on:
+  pull_request:
+    types:
+      - opened
+
+jobs:
+  assign_creator:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: toshimaru/auto-author-assign@v1.6.2

.github/workflows/bumper.yml

@@ -1,44 +0,0 @@
-name: Bumper
-on:
-  push:
-    branches:
-      - master
-  workflow_dispatch:
-
-jobs:
-  bumpProjects:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        target: [
-          { repo: status-im/nimbus-eth2, branch: unstable },
-          { repo: waku-org/nwaku, branch: master },
-          { repo: codex-storage/nim-codex, branch: master }
-        ]
-    steps:
-      - name: Clone repo
-        uses: actions/checkout@v2
-        with:
-          repository: ${{ matrix.target.repo }}
-          ref: ${{ matrix.target.branch }}
-          path: nbc
-          fetch-depth: 0
-          token:  ${{ secrets.ACTIONS_GITHUB_TOKEN }}
-
-      - name: Checkout this ref
-        run: |
-          cd nbc
-          git submodule update --init vendor/nim-libp2p
-          cd vendor/nim-libp2p
-          git checkout $GITHUB_SHA
-
-      - name: Commit this bump
-        run: |
-          cd nbc
-          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-          git config --global user.name = "${{ github.actor }}"
-          git commit --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

@@ -1,10 +1,11 @@
-name: CI
+name: Continuous Integration
+
 on:
   push:
     branches:
       - master
-      - unstable
   pull_request:
+  merge_group:
   workflow_dispatch:
 
 concurrency:
@@ -12,62 +13,75 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  build:
+  test:
     timeout-minutes: 90
     strategy:
       fail-fast: false
       matrix:
-        target:
+        platform:
           - os: linux
             cpu: amd64
           - os: linux
             cpu: i386
+          - os: linux-gcc-14
+            cpu: amd64
           - os: macos
             cpu: amd64
+          - os: macos-14
+            cpu: arm64
           - os: windows
             cpu: amd64
-          #- os: windows
-            #cpu: i386
-        branch: [version-1-6]
+        nim:
+          - ref: version-1-6
+            memory_management: refc
+          - ref: version-2-0
+            memory_management: refc
         include:
-          - target:
+          - platform:
               os: linux
-            builder: ubuntu-20.04
+            builder: ubuntu-22.04
             shell: bash
-          - target:
+          - platform:
+              os: linux-gcc-14
+            builder: ubuntu-24.04
+            shell: bash
+          - platform:
               os: macos
-            builder: macos-12
+            builder: macos-13
             shell: bash
-          - target:
+          - platform:
+              os: macos-14
+            builder: macos-14
+            shell: bash
+          - platform:
               os: windows
-            builder: windows-2019
+            builder: windows-2022
             shell: msys2 {0}
 
     defaults:
       run:
         shell: ${{ matrix.shell }}
 
-    name: '${{ matrix.target.os }}-${{ matrix.target.cpu }} (Nim ${{ matrix.branch }})'
+    name: '${{ matrix.platform.os }}-${{ matrix.platform.cpu }} (Nim ${{ matrix.nim.ref }})'
     runs-on: ${{ matrix.builder }}
-    continue-on-error: ${{ matrix.branch == 'devel' }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           submodules: true
 
       - name: Setup Nim
         uses: "./.github/actions/install_nim"
         with:
-          os: ${{ matrix.target.os }}
-          cpu: ${{ matrix.target.cpu }}
+          os: ${{ matrix.platform.os }}
+          cpu: ${{ matrix.platform.cpu }}
           shell: ${{ matrix.shell }}
-          nim_branch: ${{ matrix.branch }}
+          nim_ref: ${{ matrix.nim.ref }}
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: '~1.15.5'
+          go-version: '~1.16.0' # That's the minimum Go version that works with arm.
 
       - name: Install p2pd
         run: |
@@ -78,15 +92,29 @@ jobs:
         uses: actions/cache@v3
         with:
           path: nimbledeps
-          key: nimbledeps-${{ hashFiles('.pinned') }}
+          # Using nim.ref as a simple way to differentiate between nimble using the "pkgs" or "pkgs2" directories.
+          # The change happened on Nimble v0.14.0. Also forcing the deps to be reinstalled on each os and cpu.
+          key: nimbledeps-${{ matrix.nim.ref }}-${{ matrix.builder }}-${{ matrix.platform.cpu }}-${{ hashFiles('.pinned') }} # hashFiles returns a different value on windows
 
       - name: Install deps
         if: ${{ steps.deps-cache.outputs.cache-hit != 'true' }}
         run: |
           nimble install_pinned
 
+      - name: Use gcc 14
+        if : ${{ matrix.platform.os == 'linux-gcc-14'}}
+        run: |
+          # Add GCC-14 to alternatives
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 14
+
+          # Set GCC-14 as the default
+          sudo update-alternatives --set gcc /usr/bin/gcc-14
+
       - name: Run tests
         run: |
           nim --version
           nimble --version
+          gcc --version
+
+          NIMFLAGS="${NIMFLAGS} --mm:${{ matrix.nim.memory_management }}"
           nimble test

.github/workflows/commit_lint.yml

@@ -0,0 +1,77 @@
+name: "Conventional Commits"
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - reopened
+      - synchronize
+jobs:
+  main:
+    name: Validate commit messages
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{github.event.pull_request.head.ref}}
+          repository: ${{github.event.pull_request.head.repo.full_name}}
+
+      - name: Check commit message
+        id: check_commit_message
+        if: always()
+        run: |
+          set +e
+          
+          base_sha=${{ github.event.pull_request.base.sha }} 
+          head_sha=${{ github.event.pull_request.head.sha }}
+
+          output=$(.github/scripts/commit_check.sh "${base_sha}" "${head_sha}" 2>&1)
+          exit_code=$?
+          
+          echo "${output}" | sed '$d'
+          echo "exit_code=${exit_code}" >> $GITHUB_OUTPUT
+                    
+          invalid_commit_messages=$(echo "${output}" | sed '1d;$d')
+          invalid_commit_messages=$(echo "${output}" | sed '1d;$d')
+          invalid_commit_messages=$(echo "${invalid_commit_messages}" | sed 's/\x1b\[[0-9;]*m//g') # Remove color codes
+          invalid_commit_messages=$(echo "${invalid_commit_messages}" | sed 's/^Commit message is ill-formed: //') # Remove prefix
+          
+          if [[ $exit_code -ne 0 ]]; then
+            EOF=$(dd if=/dev/urandom bs=15 count=1 status=none | base64)
+            echo "error_message<<$EOF" >> "$GITHUB_ENV"
+            echo "${invalid_commit_messages}" >> "$GITHUB_ENV"
+            echo "$EOF" >> "$GITHUB_ENV"
+          fi
+
+      - name: "Publish failed commit messages"
+        uses: marocchino/sticky-pull-request-comment@v2
+        # When the previous steps fails, the workflow would stop. By adding this
+        # condition you can continue the execution with the populated error message.
+        if: always() && (steps.check_commit_message.outputs.exit_code != 0)
+        with:
+          header: commit-message-lint-error
+          message: |
+            Commits must follow the [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0/)
+            Please fix these commit messages:
+            ```
+            ${{ env.error_message }}
+            ```
+
+      # Delete a previous comment when the issue has been resolved
+      - name: "Delete previous comment"
+        if: ${{ steps.check_commit_message.outputs.exit_code == 0 }}
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: commit-message-lint-error
+          delete: true
+
+      - name: "Mark as failed"
+        if: steps.check_commit_message.outputs.exit_code != 0
+        uses: actions/github-script@v7
+        with:
+          script: |
+            core.setFailed("Some commit messages are ill-formed")

.github/workflows/coverage.yml

@@ -1,12 +1,12 @@
-name: nim-libp2p codecov builds
+name: Coverage
 
 on:
-  #On push to common branches, this computes the "bases stats" for PRs
+  # On push to common branches, this computes the coverage that PRs will use for diff
   push:
     branches:
       - master
-      - unstable
   pull_request:
+  merge_group:
   workflow_dispatch:
 
 concurrency:
@@ -14,12 +14,13 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  Coverage:
-    runs-on: ubuntu-20.04
+  codecov:
+    name: Run coverage and upload to codecov
+    runs-on: ubuntu-22.04
     env:
       CICOV: YES
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -32,7 +33,7 @@ jobs:
 
       - name: Restore deps from cache
         id: deps-cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: nimbledeps
           key: nimbledeps-${{ hashFiles('.pinned') }}
@@ -42,24 +43,28 @@ jobs:
         run: |
           nimble install_pinned
 
-      - name: Run
+      - name: Setup coverage
         run: |
           sudo apt-get update
           sudo apt-get install -y lcov build-essential git curl
           mkdir coverage
+
+      - name: Run test suite with coverage flags
+        run: |
           export NIMFLAGS="--lineDir:on --passC:-fprofile-arcs --passC:-ftest-coverage --passL:-fprofile-arcs --passL:-ftest-coverage"
           nimble testnative
           nimble testpubsub
           nimble testfilter
+
+      - name: Run coverage
+        run: |
           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
           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
+      - name: Upload coverage to codecov
+        run: |
+          bash <(curl -s https://codecov.io/bash) -f coverage/coverage.f.info || echo "Codecov did not collect coverage reports"

.github/workflows/daily_amd64.yml

@@ -0,0 +1,14 @@
+name: Daily amd64
+
+on:
+  schedule:
+    - cron: "30 6 * * *"
+  workflow_dispatch:
+
+jobs:
+  test_amd64:
+    name: Daily amd64
+    uses: ./.github/workflows/daily_common.yml
+    with:
+      nim: "[{'ref': 'version-1-6', 'memory_management': 'refc'}, {'ref': 'version-2-0', 'memory_management': 'refc'}]"
+      cpu: "['amd64']"

.github/workflows/daily_common.yml

@@ -1,12 +1,13 @@
-name: daily-common
+name: Daily Common
+# Serves as base workflow for daily tasks, it's not run by itself.
 
 on:
   workflow_call:
     inputs:
-      nim-branch:
-        description: 'Nim branch'
+      nim:
+        description: 'Nim Configuration'
         required: true
-        type: string
+        type: string # Following this format: [{"ref": ..., "memory_management": ...}, ...]
       cpu:
         description: 'CPU'
         required: true
@@ -16,30 +17,40 @@ on:
         required: false
         type: string
         default: "[]"
+      use_sat_solver:
+        description: 'Install dependencies with SAT Solver'
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  delete-cache:
+  delete_cache:
+    name: Delete github action's branch cache
     runs-on: ubuntu-latest
     steps:
       - uses: snnaplab/delete-branch-cache-action@v1
 
-  build:
-    needs: delete-cache
-    timeout-minutes: 120
+  test:
+    needs: delete_cache
+    timeout-minutes: 90
     strategy:
       fail-fast: false
       matrix:
         platform:
           - os: linux
-            builder: ubuntu-20
+            builder: ubuntu-22.04
             shell: bash
           - os: macos
-            builder: macos-12
+            builder: macos-13
             shell: bash
           - os: windows
-            builder: windows-2019
+            builder: windows-2022
             shell: msys2 {0}
-        branch: ${{ fromJSON(inputs.nim-branch) }}
+        nim: ${{ fromJSON(inputs.nim) }}
         cpu: ${{ fromJSON(inputs.cpu) }}
         exclude: ${{ fromJSON(inputs.exclude) }}
 
@@ -47,9 +58,8 @@ jobs:
       run:
         shell: ${{ matrix.platform.shell }}
 
-    name: '${{ matrix.platform.os }}-${{ matrix.cpu }} (Nim ${{ matrix.branch }})'
+    name: '${{ matrix.platform.os }}-${{ matrix.cpu }} (Nim ${{ matrix.nim.ref }})'
     runs-on: ${{ matrix.platform.builder }}
-    continue-on-error: ${{ matrix.branch == 'devel' || matrix.branch == 'version-2-0' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -59,26 +69,33 @@ jobs:
         with:
           os: ${{ matrix.platform.os }}
           shell: ${{ matrix.platform.shell }}
-          nim_branch: ${{ matrix.branch }}
+          nim_ref: ${{ matrix.nim.ref }}
           cpu: ${{ matrix.cpu }}
 
       - name: Setup Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
-          go-version: '~1.15.5'
+          go-version: '~1.16.0'
           cache: false
 
       - name: Install p2pd
         run: |
           V=1 bash scripts/build_p2pd.sh p2pdCache 124530a3
+        
+      - name: Install dependencies
+        run: |
+          nimble install -y --depsOnly
 
       - name: Run tests
         run: |
           nim --version
           nimble --version
-          nimble install -y --depsOnly
-          NIMFLAGS="${NIMFLAGS} --mm:refc" nimble test
-          if [[ "${{ matrix.branch }}" == "devel" ]]; then
-            echo -e "\nTesting with '--mm:orc':\n"
-            NIMFLAGS="${NIMFLAGS} --mm:orc" nimble test
+
+          if [[ "${{ inputs.use_sat_solver }}" == "true" ]]; then
+            dependency_solver="sat"
+          else
+            dependency_solver="legacy"
           fi
+
+          NIMFLAGS="${NIMFLAGS} --mm:${{ matrix.nim.memory_management }} --solver:${dependency_solver}"
+          nimble test

.github/workflows/daily_devel.yml

@@ -1,12 +1,14 @@
 name: Daily Nim Devel
+
 on:
   schedule:
     - cron: "30 6 * * *"
   workflow_dispatch:
 
 jobs:
-  call-multi-nim-common:
+  test_nim_devel:
+    name: Daily Nim Devel
     uses: ./.github/workflows/daily_common.yml
     with:
-      nim-branch: "['devel']"
+      nim: "[{'ref': 'devel', 'memory_management': 'orc'}]"
       cpu: "['amd64']"

.github/workflows/daily_i386.yml

@@ -1,13 +1,15 @@
 name: Daily i386
+
 on:
   schedule:
     - cron: "30 6 * * *"
   workflow_dispatch:
 
 jobs:
-  call-multi-nim-common:
+  test_i386:
+    name: Daily i386 (Linux)
     uses: ./.github/workflows/daily_common.yml
     with:
-      nim-branch: "['version-1-6','version-2-0', 'devel']"
+      nim: "[{'ref': 'version-1-6', 'memory_management': 'refc'}, {'ref': 'version-2-0', 'memory_management': 'refc'}, {'ref': 'devel', 'memory_management': 'orc'}]"
       cpu: "['i386']"
       exclude: "[{'platform': {'os':'macos'}}, {'platform': {'os':'windows'}}]"

.github/workflows/daily_sat.yml

@@ -1,12 +1,15 @@
-name: Daily
+name: Daily SAT
+
 on:
   schedule:
     - cron: "30 6 * * *"
   workflow_dispatch:
 
 jobs:
-  call-multi-nim-common:
+  test_amd64:
+    name: Daily SAT
     uses: ./.github/workflows/daily_common.yml
     with:
-      nim-branch: "['version-1-6','version-2-0']"
+      nim: "[{'ref': 'version-2-0', 'memory_management': 'refc'}]"
       cpu: "['amd64']"
+      use_sat_solver: true

.github/workflows/dependencies.yml

@@ -0,0 +1,50 @@
+name: Dependencies
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  bumper:
+    # Pushes new refs to interested external repositories, so they can do early testing against libp2p's newer versions
+    runs-on: ubuntu-latest
+    name: Bump libp2p's version for ${{ matrix.target.repository }}:${{ matrix.target.ref }}
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - repository: status-im/nimbus-eth2
+            ref: unstable
+          - repository: waku-org/nwaku
+            ref: master
+          - repository: codex-storage/nim-codex
+            ref: master
+    steps:
+      - name: Clone target repository
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.target.repository }}
+          ref: ${{ matrix.target.ref}}
+          path: nbc
+          fetch-depth: 0
+          token: ${{ secrets.ACTIONS_GITHUB_TOKEN }}
+
+      - name: Checkout this ref in target repository
+        run: |
+          cd nbc
+          git submodule update --init vendor/nim-libp2p
+          cd vendor/nim-libp2p
+          git checkout $GITHUB_SHA
+
+      - name: Push this ref to target repository
+        run: |
+          cd nbc
+          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
+          git config --global user.name = "${{ github.actor }}"
+          git commit --allow-empty -a -m "auto-bump nim-libp2p"
+          git branch -D nim-libp2p-auto-bump-${{ matrix.target.ref }} || true
+          git switch -c nim-libp2p-auto-bump-${{ matrix.target.ref }}
+          git push -f origin nim-libp2p-auto-bump-${{ matrix.target.ref }}
+

.github/workflows/documentation.yml

@@ -1,19 +1,21 @@
-name: Docgen
+name: Documentation Generation And Publishing
+
 on:
   push:
+    branches:
+      - master
   workflow_dispatch:
 
-
 jobs:
   build:
     timeout-minutes: 20
 
     name: 'Generate & upload documentation'
-    runs-on: 'ubuntu-20.04'
+    runs-on: ubuntu-latest
     continue-on-error: true
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           submodules: true
 
@@ -27,15 +29,15 @@ jobs:
           nimble --version
           nimble install_pinned
           # 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
+          nim doc --git.url:https://github.com/vacp2p/nim-libp2p --git.commit:${GITHUB_REF##*/} --outdir:${GITHUB_REF##*/} --project libp2p || true
 
           # check that the folder exists
           ls ${GITHUB_REF##*/}
 
       - name: Clone the gh-pages branch
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
-          repository: status-im/nim-libp2p
+          repository: vacp2p/nim-libp2p
           ref: gh-pages
           path: subdoc
           submodules: true
@@ -45,9 +47,6 @@ jobs:
         run: |
           cd subdoc
 
-          # Delete merged branches doc's
-          for branch in $(git branch -vv | grep ': gone]' | awk '{print $1}'); do rm -rf $branch; done
-
           # Update / create this branch doc
           rm -rf ${GITHUB_REF##*/}
           mv ../${GITHUB_REF##*/} .
@@ -63,12 +62,11 @@ jobs:
           git push origin gh-pages
 
   update_site:
-    if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/docs'
     name: 'Rebuild website'
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - uses: actions/setup-python@v2
         with:
@@ -79,12 +77,12 @@ jobs:
           nim-version: 'stable'
 
       - name: Generate website
-        run: pip install mkdocs-material && nimble website
+        run: pip install mkdocs-material && nimble -y website
 
       - name: Clone the gh-pages branch
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
-          repository: status-im/nim-libp2p
+          repository: vacp2p/nim-libp2p
           ref: gh-pages
           path: subdoc
           fetch-depth: 0
@@ -93,11 +91,21 @@ jobs:
         run: |
           cd subdoc
 
+          # Ensure the latest changes are fetched and reset to the remote branch
+          git fetch origin gh-pages
+          git reset --hard origin/gh-pages
+
           rm -rf docs
           mv ../site docs
 
           git add .
-          git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-          git config --global user.name = "${{ github.actor }}"
-          git commit -a -m "update website"
-          git push origin gh-pages
+ 
+          if git diff-index --quiet HEAD --; then
+            echo "No changes to commit"
+          else
+            git config --global user.email "${{ github.actor }}@users.noreply.github.com"
+            git config --global user.name "${{ github.actor }}"
+
+            git commit -m "update website"
+            git push origin gh-pages
+          fi

.github/workflows/interop.yml

@@ -1,9 +1,11 @@
-name: Interoperability Testing
+name: Interoperability Tests
+
 on:
   pull_request:
+  merge_group:
   push:
     branches:
-      - unstable
+      - master
   workflow_dispatch:
 
 concurrency:
@@ -15,6 +17,13 @@ jobs:
     name: Run transport interoperability tests
     runs-on: ubuntu-22.04
     steps:
+      - name: Free Disk Space
+        # For some reason we have space issues while running this action. Likely while building the image.
+        # This action will free up some space to avoid the issue.
+        uses: jlumbroso/free-disk-space@v1.3.1
+        with:
+          tool-cache: true
+
       - uses: actions/checkout@v4
       - uses: docker/setup-buildx-action@v3
       - name: Build image
@@ -24,6 +33,10 @@ jobs:
         with:
           test-filter: nim-libp2p-head
           extra-versions: ${{ github.workspace }}/tests/transport-interop/version.json
+          s3-cache-bucket: ${{ vars.S3_LIBP2P_BUILD_CACHE_BUCKET_NAME }}
+          s3-access-key-id: ${{ vars.S3_LIBP2P_BUILD_CACHE_AWS_ACCESS_KEY_ID }}
+          s3-secret-access-key: ${{ secrets.S3_LIBP2P_BUILD_CACHE_AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.S3_LIBP2P_BUILD_CACHE_AWS_REGION }}
 
   run-hole-punching-interop:
     name: Run hole-punching interoperability tests
@@ -38,3 +51,7 @@ jobs:
         with:
           test-filter: nim-libp2p-head
           extra-versions: ${{ github.workspace }}/tests/hole-punching-interop/version.json
+          s3-cache-bucket: ${{ vars.S3_LIBP2P_BUILD_CACHE_BUCKET_NAME }}
+          s3-access-key-id: ${{ vars.S3_LIBP2P_BUILD_CACHE_AWS_ACCESS_KEY_ID }}
+          s3-secret-access-key: ${{ secrets.S3_LIBP2P_BUILD_CACHE_AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.S3_LIBP2P_BUILD_CACHE_AWS_REGION }}

.github/workflows/linters.yml

@@ -0,0 +1,34 @@
+name: Linters
+
+on:
+  pull_request:
+  merge_group:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  nph:
+    name: NPH
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2  # In PR, has extra merge commit: ^1 = PR, ^2 = base
+
+      - name: Setup NPH
+        # Pin nph to a specific version to avoid sudden style differences.
+        # Updating nph version should be accompanied with running the new version on the fluffy directory.
+        run: |
+          VERSION="v0.5.1"
+          ARCHIVE="nph-linux_x64.tar.gz"
+          curl -L "https://github.com/arnetheduck/nph/releases/download/${VERSION}/${ARCHIVE}" -o ${ARCHIVE}
+          tar -xzf ${ARCHIVE}
+
+      - name: Check style
+        run: |
+          shopt -s extglob  # Enable extended globbing
+          ./nph examples libp2p tests tools *.@(nim|nims|nimble)
+          git diff --exit-code

.github/workflows/pr_lint.yml

@@ -0,0 +1,35 @@
+name: "Conventional Commits"
+
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - reopened
+      - synchronize
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5
+        id: lint_pr_title
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: marocchino/sticky-pull-request-comment@v2
+        # When the previous steps fails, the workflow would stop. By adding this
+        # condition you can continue the execution with the populated error message.
+        if: always() && (steps.lint_pr_title.outputs.error_message != null)
+        with:
+          header: pr-title-lint-error
+          message: |
+            Pull requests titles must follow the [Conventional Commits specification](https://www.conventionalcommits.org/en/v1.0.0/)
+
+      # Delete a previous comment when the issue has been resolved
+      - if: ${{ steps.lint_pr_title.outputs.error_message == null }}
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:   
+          header: pr-title-lint-error
+          delete: true

.pinned

@@ -1,12 +1,14 @@
-bearssl;https://github.com/status-im/nim-bearssl@#e4157639db180e52727712a47deaefcbbac6ec86
+bearssl;https://github.com/status-im/nim-bearssl@#667b40440a53a58e9f922e29e20818720c62d9ac
 chronicles;https://github.com/status-im/nim-chronicles@#32ac8679680ea699f7dbc046e8e0131cac97d41a
-chronos;https://github.com/status-im/nim-chronos@#672db137b7cad9b384b8f4fb551fb6bbeaabfe1b
+chronos;https://github.com/status-im/nim-chronos@#c04576d829b8a0a1b12baaa8bc92037501b3a4a0
 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
+ngtcp2;https://github.com/status-im/nim-ngtcp2@#6834f4756b6af58356ac9c4fef3d71db3c3ae5fe
 nimcrypto;https://github.com/cheatfate/nimcrypto@#1c8d6e3caf3abc572136ae9a1da81730c4eb4288
+quic;https://github.com/status-im/nim-quic.git@#ddcb31ffb74b5460ab37fd13547eca90594248bc
 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

README.md

@@ -5,8 +5,8 @@
 <h3 align="center">The <a href="https://nim-lang.org/">Nim</a> implementation of the <a href="https://libp2p.io/">libp2p</a> Networking Stack.</h3>
 
 <p align="center">
-<a href="https://github.com/status-im/nim-libp2p/actions"><img src="https://github.com/status-im/nim-libp2p/actions/workflows/ci.yml/badge.svg" /></a>
-<a href="https://codecov.io/gh/status-im/nim-libp2p"><img src="https://codecov.io/gh/status-im/nim-libp2p/branch/master/graph/badge.svg?token=UR5JRQ249W"/></a>
+<a href="https://github.com/vacp2p/nim-libp2p/actions"><img src="https://github.com/vacp2p/nim-libp2p/actions/workflows/ci.yml/badge.svg" /></a>
+<a href="https://codecov.io/gh/vacp2p/nim-libp2p"><img src="https://codecov.io/gh/vacp2p/nim-libp2p/branch/master/graph/badge.svg?token=UR5JRQ249W"/></a>
 
 </p>
 
@@ -48,7 +48,7 @@ nimble install libp2p
 ```
 
 ## Getting Started
-You'll find the nim-libp2p documentation [here](https://status-im.github.io/nim-libp2p/docs/).
+You'll find the nim-libp2p documentation [here](https://vacp2p.github.io/nim-libp2p/docs/).
 
 ### Testing
 Remember you'll need to build the `go-libp2p-daemon` binary to run the `nim-libp2p` tests.
@@ -95,8 +95,8 @@ List of packages modules implemented in nim-libp2p:
 
 nim-libp2p is used by:
 - [Nimbus](https://github.com/status-im/nimbus-eth2), an Ethereum client
-- [nwaku](https://github.com/status-im/nwaku), a decentralized messaging application
-- [nim-codex](https://github.com/status-im/nim-codex), a decentralized storage application
+- [nwaku](https://github.com/waku-org/nwaku), a decentralized messaging application
+- [nim-codex](https://github.com/codex-storage/nim-codex), a decentralized storage application
 - (open a pull request if you want to be included here)
 
 ## Stability
@@ -112,7 +112,7 @@ We aim to be compatible at all time with at least 2 Nim `MINOR` versions, curren
 ## Development
 Clone and Install dependencies:
 ```sh
-git clone https://github.com/status-im/nim-libp2p
+git clone https://github.com/vacp2p/nim-libp2p
 cd nim-libp2p
 # to use dependencies computed by nimble
 nimble install -dy
@@ -135,11 +135,11 @@ The libp2p implementation in Nim is a work in progress. We welcome contributors
 - **Perform code reviews**. Feel free to let us know if you found anything that can a) speed up the project development b) ensure better quality and c) reduce possible future bugs.
 - **Add tests**. Help nim-libp2p to be more robust by adding more tests to the [tests folder](tests/).
 - **Small PRs**. Try to keep PRs atomic and digestible. This makes the review process and pinpointing bugs easier.
-- **Code format**. Please format code using [nph](https://github.com/arnetheduck/nph).
+- **Code format**. Please format code using [nph](https://github.com/arnetheduck/nph) v0.5.1. This will ensure a consistent codebase and make PRs easier to review. A CI rule has been added to ensure that future commits are all formatted using the same nph version.
 The code follows the [Status Nim Style Guide](https://status-im.github.io/nim-style-guide/).
 
 ### 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>
+<a href="https://github.com/vacp2p/nim-libp2p/graphs/contributors"><img src="https://contrib.rocks/image?repo=vacp2p/nim-libp2p" alt="nim-libp2p contributors"></a>
 
 ### Core Maintainers
 <table>

config.nims

@@ -7,14 +7,20 @@ if dirExists("nimbledeps/pkgs2"):
 switch("warning", "CaseTransition:off")
 switch("warning", "ObservableStores:off")
 switch("warning", "LockLevel:off")
---styleCheck:usages
+--styleCheck:
+  usages
 switch("warningAsError", "UseBase:on")
---styleCheck:error
+--styleCheck:
+  error
+--mm:
+  refc
+  # reconsider when there's a version-2-2 branch worth testing with as we might switch to orc
 
 # Avoid some rare stack corruption while using exceptions with a SEH-enabled
 # toolchain: https://github.com/status-im/nimbus-eth2/issues/3121
 if defined(windows) and not defined(vcc):
-  --define:nimRawSetjmp
+  --define:
+    nimRawSetjmp
 
 # begin Nimble config (version 1)
 when fileExists("nimble.paths"):

examples/circuitrelay.nim

@@ -1,25 +1,25 @@
 ## # 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).
+## directly, but can reach it through 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 =
-  SwitchBuilder.new()
-    .withRng(newRng())
-    .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
-    .withTcpTransport()
-    .withMplex()
-    .withNoise()
-    .withCircuitRelay(r)
-    .build()
+  SwitchBuilder
+  .new()
+  .withRng(newRng())
+  .withAddresses(@[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()])
+  .withTcpTransport()
+  .withMplex()
+  .withNoise()
+  .withCircuitRelay(r)
+  .build()
 
 proc main() {.async.} =
   # Create a custom protocol
@@ -56,8 +56,11 @@ proc main() {.async.} =
 
   let
     # Create a relay address to swDst using swRel as the relay
-    addrs = MultiAddress.init($swRel.peerInfo.addrs[0] & "/p2p/" &
-                              $swRel.peerInfo.peerId & "/p2p-circuit").get()
+    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)
@@ -66,7 +69,7 @@ proc main() {.async.} =
   let rsvp = await clDst.reserve(swRel.peerInfo.peerId, swRel.peerInfo.addrs)
 
   # Src dial Dst using the relay
-  let conn = await swSrc.dial(swDst.peerInfo.peerId, @[ addrs ], customProtoCodec)
+  let conn = await swSrc.dial(swDst.peerInfo.peerId, @[addrs], customProtoCodec)
 
   await conn.writeLp("test1")
   var msg = string.fromBytes(await conn.readLp(1024))

examples/directchat.nim

@@ -1,15 +1,12 @@
-when not(compileOption("threads")):
+when not (compileOption("threads")):
   {.fatal: "Please, compile this program with the --threads:on option!".}
 
-import
-  strformat, strutils,
-  stew/byteutils,
-  chronos,
-  libp2p
+import strformat, strutils, stew/byteutils, chronos, libp2p
 
 const DefaultAddr = "/ip4/127.0.0.1/tcp/0"
 
-const Help = """
+const Help =
+  """
   Commands: /[?|help|connect|disconnect|exit]
   help: Prints this help
   connect: dials a remote peer
@@ -17,12 +14,11 @@ const Help = """
   exit: closes the chat
 """
 
-type
-  Chat = ref object
-    switch: Switch          # a single entry point for dialing and listening to peer
-    stdinReader: StreamTransport # transport streams between read & write file descriptor
-    conn: Connection        # connection to the other peer
-    connected: bool         # if the node is connected to another peer
+type Chat = ref object
+  switch: Switch # a single entry point for dialing and listening to peer
+  stdinReader: StreamTransport # transport streams between read & write file descriptor
+  conn: Connection # connection to the other peer
+  connected: bool # if the node is connected to another peer
 
 ##
 # Stdout helpers, to write the prompt
@@ -41,8 +37,7 @@ proc writeStdout(c: Chat, str: string) =
 ##
 const ChatCodec = "/nim-libp2p/chat/1.0.0"
 
-type
-  ChatProto = ref object of LPProtocol
+type ChatProto = ref object of LPProtocol
 
 proc new(T: typedesc[ChatProto], c: Chat): T =
   let chatproto = T()
@@ -77,9 +72,9 @@ proc handlePeer(c: Chat, conn: Connection) {.async.} =
         strData = await conn.readLp(1024)
         str = string.fromBytes(strData)
       c.writeStdout $conn.peerId & ": " & $str
-
   except LPStreamEOFError:
-    defer: c.writeStdout $conn.peerId & " disconnected"
+    defer:
+      c.writeStdout $conn.peerId & " disconnected"
     await c.conn.close()
     c.connected = false
 
@@ -88,10 +83,7 @@ proc dialPeer(c: Chat, address: string) {.async.} =
   let
     multiAddr = MultiAddress.init(address).tryGet()
     # split the peerId part /p2p/...
-    peerIdBytes = multiAddr[multiCodec("p2p")]
-      .tryGet()
-      .protoAddress()
-      .tryGet()
+    peerIdBytes = multiAddr[multiCodec("p2p")].tryGet().protoAddress().tryGet()
     remotePeer = PeerId.init(peerIdBytes).tryGet()
     # split the wire address
     ip4Addr = multiAddr[multiCodec("ip4")].tryGet()
@@ -124,7 +116,6 @@ proc readLoop(c: Chat) {.async.} =
       let address = await c.stdinReader.readLine()
       if address.len > 0:
         await c.dialPeer(address)
-
     elif line.startsWith("/exit"):
       if c.connected and c.conn.closed.not:
         await c.conn.close()
@@ -171,16 +162,18 @@ proc main() {.async.} =
 
   var switch = SwitchBuilder
     .new()
-    .withRng(rng)       # Give the application RNG
+    .withRng(rng)
+    # Give the application RNG
     .withAddress(localAddress)
-    .withTcpTransport() # Use TCP as transport
-    .withMplex()        # Use Mplex as muxer
-    .withNoise()        # Use Noise as secure manager
+    .withTcpTransport()
+    # Use TCP as transport
+    .withMplex()
+    # Use Mplex as muxer
+    .withNoise()
+    # Use Noise as secure manager
     .build()
 
-  let chat = Chat(
-    switch: switch,
-    stdinReader: stdinReader)
+  let chat = Chat(switch: switch, stdinReader: stdinReader)
 
   switch.mount(ChatProto.new(chat))
 

examples/go-daemon/bootstrap.nim

@@ -2,8 +2,7 @@ import chronos, nimcrypto, strutils
 import ../../libp2p/daemon/daemonapi
 import ../hexdump
 
-const
-  PubSubTopic = "test-net"
+const PubSubTopic = "test-net"
 
 proc dumpSubscribedPeers(api: DaemonAPI) {.async.} =
   var peers = await api.pubsubListPeers(PubSubTopic)
@@ -37,12 +36,12 @@ proc main() {.async.} =
 
   asyncSpawn monitor(api)
 
-  proc pubsubLogger(api: DaemonAPI,
-                    ticket: PubsubTicket,
-                    message: PubSubMessage): Future[bool] {.async.} =
+  proc pubsubLogger(
+      api: DaemonAPI, ticket: PubsubTicket, message: PubSubMessage
+  ): Future[bool] {.async.} =
     let msglen = len(message.data)
-    echo "= Recieved pubsub message with length ", msglen,
-         " bytes from peer ", message.peer.pretty()
+    echo "= Recieved pubsub message with length ",
+      msglen, " bytes from peer ", message.peer.pretty()
     echo dumpHex(message.data)
     await api.dumpSubscribedPeers()
     result = true

examples/go-daemon/chat.nim

@@ -2,18 +2,16 @@ import chronos, nimcrypto, strutils
 import ../../libp2p/daemon/daemonapi
 
 ## nim c -r --threads:on chat.nim
-when not(compileOption("threads")):
+when not (compileOption("threads")):
   {.fatal: "Please, compile this program with the --threads:on option!".}
 
-const
-  ServerProtocols = @["/test-chat-stream"]
+const ServerProtocols = @["/test-chat-stream"]
 
-type
-  CustomData = ref object
-    api: DaemonAPI
-    remotes: seq[StreamTransport]
-    consoleFd: AsyncFD
-    serveFut: Future[void]
+type CustomData = ref object
+  api: DaemonAPI
+  remotes: seq[StreamTransport]
+  consoleFd: AsyncFD
+  serveFut: Future[void]
 
 proc threadMain(wfd: AsyncFD) {.thread.} =
   ## This procedure performs reading from `stdin` and sends data over
@@ -82,7 +80,7 @@ proc serveThread(udata: CustomData) {.async.} =
                 relay = true
                 break
             if relay:
-              echo peer.pretty(), " * ",  " [", addresses.join(", "), "]"
+              echo peer.pretty(), " * ", " [", addresses.join(", "), "]"
             else:
               echo peer.pretty(), " [", addresses.join(", "), "]"
       elif line.startsWith("/exit"):

examples/go-daemon/daemonapi.md

@@ -13,7 +13,7 @@ For more information about the go daemon, check out [this repository](https://gi
 > **Required only** for running the tests.
 
 # Prerequisites
-Go with version `1.15.15`.
+Go with version `1.16.0`.
 > You will *likely* be able to build `go-libp2p-daemon` with different Go versions, but **they haven't been tested**.
 
 # Installation
@@ -21,12 +21,12 @@ Follow one of the methods below:
 
 ## Script
 Run the build script while having the `go` command pointing to the correct Go version.
-We recommend using `1.15.15`, as previously stated.
+We recommend using `1.16.0`, as previously stated.
 ```sh
 ./scripts/build_p2pd.sh
 ```
 If everything goes correctly, the binary (`p2pd`) should be built and placed in the correct directory.
-If you find any issues, please head into our discord and ask for our asistance.
+If you find any issues, please head into our discord and ask for our assistance.
 
 After successfully building the binary, remember to add it to your path so it can be found. You can do that by running:
 ```sh

examples/go-daemon/node.nim

@@ -1,26 +1,25 @@
 import chronos, nimcrypto, strutils, os
 import ../../libp2p/daemon/daemonapi
 
-const
-  PubSubTopic = "test-net"
+const PubSubTopic = "test-net"
 
 proc main(bn: string) {.async.} =
   echo "= Starting P2P node"
   var bootnodes = bn.split(",")
-  var api = await newDaemonApi({DHTFull, PSGossipSub, WaitBootstrap},
-                               bootstrapNodes = bootnodes,
-                               peersRequired = 1)
+  var api = await newDaemonApi(
+    {DHTFull, PSGossipSub, WaitBootstrap}, bootstrapNodes = bootnodes, peersRequired = 1
+  )
   var id = await api.identity()
   echo "= P2P node ", id.peer.pretty(), " started:"
   for item in id.addresses:
     echo item
 
-  proc pubsubLogger(api: DaemonAPI,
-                    ticket: PubsubTicket,
-                    message: PubSubMessage): Future[bool] {.async.} =
+  proc pubsubLogger(
+      api: DaemonAPI, ticket: PubsubTicket, message: PubSubMessage
+  ): Future[bool] {.async.} =
     let msglen = len(message.data)
-    echo "= Recieved pubsub message with length ", msglen,
-         " bytes from peer ", message.peer.pretty(), ": "
+    echo "= Recieved pubsub message with length ",
+      msglen, " bytes from peer ", message.peer.pretty(), ": "
     var strdata = cast[string](message.data)
     echo strdata
     result = true

examples/helloworld.nim

@@ -1,5 +1,5 @@
-import chronos         # an efficient library for async
-import stew/byteutils  # various utils
+import chronos # an efficient library for async
+import stew/byteutils # various utils
 import libp2p
 
 ##
@@ -7,11 +7,9 @@ import libp2p
 ##
 const TestCodec = "/test/proto/1.0.0" # custom protocol string identifier
 
-type
-  TestProto = ref object of LPProtocol # declare a custom protocol
+type TestProto = ref object of LPProtocol # declare a custom protocol
 
 proc new(T: typedesc[TestProto]): T =
-
   # every incoming connections will be in handled in this closure
   proc handle(conn: Connection, proto: string) {.async.} =
     echo "Got from remote - ", string.fromBytes(await conn.readLp(1024))
@@ -28,11 +26,16 @@ proc new(T: typedesc[TestProto]): T =
 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
+    .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()
 
   result = switch
@@ -73,7 +76,8 @@ proc main() {.async.} =
   # use the second node to dial the first node
   # using the first node peerid and address
   # and specify our custom protocol codec
-  let conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, TestCodec)
+  let conn =
+    await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, TestCodec)
 
   # conn is now a fully setup connection, we talk directly to the node1 custom protocol handler
   await conn.writeLp("Hello p2p!") # writeLp send a length prefixed buffer over the wire
@@ -84,6 +88,7 @@ proc main() {.async.} =
   # 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
+  await allFutures(switch1.stop(), switch2.stop())
+    # close connections and shutdown all transports
 
 waitFor(main())

examples/hexdump.nim

@@ -35,26 +35,24 @@ proc dumpHex*(pbytes: pointer, nbytes: int, items = 1, ascii = true): string =
   var asciiText = ""
   while i < nbytes:
     if i %% 16 == 0:
-      result = result & toHex(cast[BiggestInt](slider),
-                              sizeof(BiggestInt) * 2) & ":  "
+      result = result & toHex(cast[BiggestInt](slider), sizeof(BiggestInt) * 2) & ":  "
     var k = 0
     while k < items:
       var ch = cast[ptr char](cast[uint](slider) + k.uint)[]
-      if ord(ch) > 31 and ord(ch) < 127: asciiText &= ch else: asciiText &= "."
+      if ord(ch) > 31 and ord(ch) < 127:
+        asciiText &= ch
+      else:
+        asciiText &= "."
       inc(k)
-    case items:
+    case items
     of 1:
-      result = result & toHex(cast[BiggestInt](cast[ptr uint8](slider)[]),
-                              hexSize)
+      result = result & toHex(cast[BiggestInt](cast[ptr uint8](slider)[]), hexSize)
     of 2:
-      result = result & toHex(cast[BiggestInt](cast[ptr uint16](slider)[]),
-                              hexSize)
+      result = result & toHex(cast[BiggestInt](cast[ptr uint16](slider)[]), hexSize)
     of 4:
-      result = result & toHex(cast[BiggestInt](cast[ptr uint32](slider)[]),
-                              hexSize)
+      result = result & toHex(cast[BiggestInt](cast[ptr uint32](slider)[]), hexSize)
     of 8:
-      result = result & toHex(cast[BiggestInt](cast[ptr uint64](slider)[]),
-                              hexSize)
+      result = result & toHex(cast[BiggestInt](cast[ptr uint64](slider)[]), hexSize)
     else:
       raise newException(ValueError, "Wrong items size!")
     result = result & " "

examples/tutorial_1_connect.nim

@@ -34,15 +34,20 @@ 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:
+## Next, we'll create a 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
+    .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
@@ -57,7 +62,7 @@ proc main() {.async.} =
   let
     rng = newRng()
     localAddress = MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()
-    pingProtocol = Ping.new(rng=rng)
+    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".
   ##
@@ -77,8 +82,9 @@ proc main() {.async.} =
   ## 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'll **dial** the first switch from the second one, by specifying its **Peer ID**, its **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)
@@ -86,7 +92,8 @@ proc main() {.async.} =
   # 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
+  await allFutures(switch1.stop(), switch2.stop())
+    # close connections and shutdown all transports
 
 waitFor(main())
 

examples/tutorial_2_customproto.nim

@@ -18,8 +18,8 @@ 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.
+## A protocol generally has two parts: a handling/server part, and a dialing/client part.
+## These 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:
 
@@ -41,29 +41,31 @@ proc new(T: typedesc[TestProto]): T =
 proc hello(p: TestProto, conn: Connection) {.async.} =
   await conn.writeLp("Hello p2p!")
 
-## Again, pretty straight-forward, we just send a message on the connection.
+## Again, pretty straightforward, we just send a message on the connection.
 ##
 ## We can now create our main procedure:
 proc main() {.async.} =
   let
     rng = newRng()
     testProto = TestProto.new()
-    switch1 = newStandardSwitch(rng=rng)
-    switch2 = newStandardSwitch(rng=rng)
+    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)
+  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
+  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
 ##

examples/tutorial_3_protobuf.nim

@@ -57,8 +57,8 @@ proc decode(_: type Metric, buf: seq[byte]): Result[Metric, ProtoError] =
   #
   # 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)
+  discard ?pb.getField(1, res.name)
+  discard ?pb.getField(2, res.value)
   ok(res)
 
 proc encode(m: MetricList): ProtoBuffer =
@@ -72,10 +72,10 @@ proc decode(_: type MetricList, buf: seq[byte]): Result[MetricList, ProtoError]
     res: MetricList
     metrics: seq[seq[byte]]
   let pb = initProtoBuffer(buf)
-  discard ? pb.getRepeatedField(1, metrics)
+  discard ?pb.getRepeatedField(1, metrics)
 
   for metric in metrics:
-    res.metrics &= ? Metric.decode(metric)
+    res.metrics &= ?Metric.decode(metric)
   ok(res)
 
 ## ## Results instead of exceptions
@@ -102,7 +102,7 @@ proc decode(_: type MetricList, buf: seq[byte]): Result[MetricList, ProtoError]
 ## ## 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.}
+  MetricCallback = proc(): Future[MetricList] {.raises: [], gcsafe.}
   MetricProto = ref object of LPProtocol
     metricGetter: MetricCallback
 
@@ -128,19 +128,19 @@ proc fetch(p: MetricProto, conn: Connection): Future[MetricList] {.async.} =
 ## We can now create our main procedure:
 proc main() {.async.} =
   let rng = newRng()
-  proc randomMetricGenerator: Future[MetricList] {.async.} =
+  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
-      ))
+      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 = newStandardSwitch(rng = rng)
+    switch2 = newStandardSwitch(rng = rng)
 
   switch1.mount(metricProto1)
 
@@ -148,14 +148,17 @@ proc main() {.async.} =
   await switch2.start()
 
   let
-    conn = await switch2.dial(switch1.peerInfo.peerId, switch1.peerInfo.addrs, metricProto2.codecs)
+    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
+  await allFutures(switch1.stop(), switch2.stop())
+    # close connections and shutdown all transports
 
 waitFor(main())
 

examples/tutorial_4_gossipsub.nim

@@ -7,7 +7,7 @@
 ## and allows to balance between latency, bandwidth usage,
 ## privacy and attack resistance.
 ##
-## You'll find a good explanation on how GossipSub works
+## You'll find a good explanation of 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.
@@ -40,8 +40,8 @@ proc encode(m: Metric): ProtoBuffer =
 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)
+  discard ?pb.getField(1, res.name)
+  discard ?pb.getField(2, res.value)
   ok(res)
 
 proc encode(m: MetricList): ProtoBuffer =
@@ -56,11 +56,11 @@ proc decode(_: type MetricList, buf: seq[byte]): Result[MetricList, ProtoError]
     res: MetricList
     metrics: seq[seq[byte]]
   let pb = initProtoBuffer(buf)
-  discard ? pb.getRepeatedField(1, metrics)
+  discard ?pb.getRepeatedField(1, metrics)
 
   for metric in metrics:
-    res.metrics &= ? Metric.decode(metric)
-  ? pb.getRequiredField(2, res.hostname)
+    res.metrics &= ?Metric.decode(metric)
+  ?pb.getRequiredField(2, res.hostname)
   ok(res)
 
 ## This is exactly like the previous structure, except that we added
@@ -73,11 +73,14 @@ 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"],
+  node.gossip.addValidator(
+    ["metrics"],
     proc(topic: string, message: Message): Future[ValidationResult] {.async.} =
       let decoded = MetricList.decode(message.data)
-      if decoded.isErr: return ValidationResult.Reject
+      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
@@ -87,23 +90,25 @@ proc oneNode(node: Node, rng: ref HmacDrbgContext) {.async.} =
   # `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()
+    node.gossip.subscribe(
+      "metrics",
+      proc(topic: string, data: seq[byte]) {.async.} =
+        let m = MetricList.decode(data).expect("metric can be decoded")
+        echo m
+      ,
     )
   else:
     node.gossip.subscribe("metrics", nil)
 
   # Create random metrics 10 times and broadcast them
-  for _ in 0..<10:
+  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
-      ))
+      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()
@@ -111,13 +116,13 @@ proc oneNode(node: Node, rng: ref HmacDrbgContext) {.async.} =
 ## 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.} =
+proc main() {.async.} =
   let rng = newRng()
   var nodes: seq[Node]
 
   for hostname in ["John", "Walter", "David", "Thuy", "Amy"]:
     let
-      switch = newStandardSwitch(rng=rng)
+      switch = newStandardSwitch(rng = rng)
       gossip = GossipSub.init(switch = switch, triggerSelf = true)
     switch.mount(gossip)
     await switch.start()
@@ -127,11 +132,12 @@ proc main {.async.} =
   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
+      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)
+        otherNode.switch.peerInfo.peerId, otherNode.switch.peerInfo.addrs
+      )
 
   var allFuts: seq[Future[void]]
   for node in nodes:

examples/tutorial_5_discovery.nim

@@ -2,7 +2,7 @@
 ##
 ## 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
+## For this tutorial, on the other hand, we'll go back to a simple example
 ## we'll try to discover a specific peers to greet on the network.
 ##
 ## First, as usual, we import the dependencies:
@@ -20,14 +20,15 @@ import libp2p/discovery/discoverymngr
 ##
 ## 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()
+  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"
@@ -36,6 +37,7 @@ proc new(T: typedesc[DumbProto], nodeNumber: int): T =
   proc handle(conn: Connection, proto: string) {.async.} =
     echo "Node", nodeNumber, " received: ", string.fromBytes(await conn.readLp(1024))
     await conn.close()
+
   return T.new(codecs = @[DumbCodec], handler = handle)
 
 ## ## Bootnodes
@@ -58,7 +60,7 @@ proc main() {.async.} =
     switches: seq[Switch] = @[]
     discManagers: seq[DiscoveryManager] = @[]
 
-  for i in 0..5:
+  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)
@@ -93,7 +95,7 @@ proc main() {.async.} =
 
   # Use the discovery manager to find peers on the OddClub topic to greet them
   let queryOddClub = dm.request(RdvNamespace("OddClub"))
-  for _ in 0..2:
+  for _ in 0 .. 2:
     let
       # getPeer give you a PeerAttribute containing informations about the peer.
       res = await queryOddClub.getPeer()
@@ -109,7 +111,7 @@ proc main() {.async.} =
 
   # Maybe it was because he wanted to join the EvenGang
   let queryEvenGang = dm.request(RdvNamespace("EvenGang"))
-  for _ in 0..2:
+  for _ in 0 .. 2:
     let
       res = await queryEvenGang.getPeer()
       conn = await newcomer.dial(res[PeerId], res.getAll(MultiAddress), DumbCodec)

examples/tutorial_6_game.nim

@@ -51,7 +51,7 @@ proc new(_: type[Game]): 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]()
+    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]:
@@ -81,7 +81,8 @@ proc update(g: Game, dt: float32) =
   # 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
+  if not (g.peerFound.finished()) or isNil(g.tickFinished):
+    return
   g.tickTime += dt
 
   # Update the wanted direction, making sure we can't go backward
@@ -98,7 +99,8 @@ 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
+  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.} =
@@ -123,16 +125,23 @@ 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: ""
+  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.
@@ -144,7 +153,8 @@ proc draw(g: Game) =
 ## and launch the game.
 proc new(T: typedesc[GameProto], g: Game): T =
   proc handle(conn: Connection, proto: string) {.async.} =
-    defer: await conn.closeWithEof()
+    defer:
+      await conn.closeWithEof()
     if g.peerFound.finished or g.hasCandidate:
       await conn.close()
       return
@@ -157,6 +167,7 @@ proc new(T: typedesc[GameProto], g: Game): T =
     # 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.} =
@@ -164,9 +175,10 @@ proc networking(g: Game) {.async.} =
   # the Discovery examples combined
   let
     rdv = RendezVous.new()
-    switch = SwitchBuilder.new()
+    switch = SwitchBuilder
+      .new()
       .withRng(newRng())
-      .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
+      .withAddresses(@[MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet()])
       .withTcpTransport()
       .withYamux()
       .withNoise()
@@ -174,9 +186,7 @@ proc networking(g: Game) {.async.} =
       .build()
     dm = DiscoveryManager()
     gameProto = GameProto.new(g)
-    gossip = GossipSub.init(
-      switch = switch,
-      triggerSelf = false)
+    gossip = GossipSub.init(switch = switch, triggerSelf = false)
   dm.add(RendezVousInterface.new(rdv))
 
   switch.mount(gossip)
@@ -184,10 +194,11 @@ proc networking(g: Game) {.async.} =
 
   gossip.subscribe(
     "/tron/matchmaking",
-    proc (topic: string, data: seq[byte]) {.async.} =
+    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
+      # try to match anyone broadcasting its address
+      if g.peerFound.finished or g.hasCandidate:
+        return
       g.hasCandidate = true
 
       try:
@@ -204,10 +215,12 @@ proc networking(g: Game) {.async.} =
         swap(g.localPlayer, g.remotePlayer)
       except CatchableError as exc:
         discard
+    ,
   )
 
   await switch.start()
-  defer: await switch.stop()
+  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
@@ -243,7 +256,8 @@ proc networking(g: Game) {.async.} =
 
   # 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()
+  defer:
+    await peerConn.closeWithEof()
 
   await g.mainLoop(peerConn)
 
@@ -252,7 +266,17 @@ let
   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())
+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

funding.json

@@ -0,0 +1,5 @@
+{
+  "opRetro": {
+    "projectId": "0xc9561ba3e4eca5483b40f8b1a254a73c91fefe4f8aee32dc20c0d96dcf33fe80"
+  }
+}

libp2p.nim

@@ -21,7 +21,8 @@ when defined(nimdoc):
   ## that can help you get started.
 
   # Import stuff for doc
-  import libp2p/[
+  import
+    libp2p/[
       protobuf/minprotobuf,
       switch,
       stream/lpstream,
@@ -33,37 +34,40 @@ when defined(nimdoc):
       peerid,
       peerinfo,
       peerstore,
-      multiaddress]
+      multiaddress,
+    ]
 
   proc dummyPrivateProc*() =
     ## A private proc example
     discard
+
 else:
   import
-    libp2p/[protobuf/minprotobuf,
-            muxers/muxer,
-            muxers/mplex/mplex,
-            stream/lpstream,
-            stream/bufferstream,
-            stream/connection,
-            transports/transport,
-            transports/tcptransport,
-            protocols/secure/noise,
-            cid,
-            multihash,
-            multicodec,
-            errors,
-            switch,
-            peerid,
-            peerinfo,
-            multiaddress,
-            builders,
-            crypto/crypto,
-            protocols/pubsub]
+    libp2p/[
+      protobuf/minprotobuf,
+      muxers/muxer,
+      muxers/mplex/mplex,
+      stream/lpstream,
+      stream/bufferstream,
+      stream/connection,
+      transports/transport,
+      transports/tcptransport,
+      transports/quictransport,
+      protocols/secure/noise,
+      cid,
+      multihash,
+      multicodec,
+      errors,
+      switch,
+      peerid,
+      peerinfo,
+      multiaddress,
+      builders,
+      crypto/crypto,
+      protocols/pubsub,
+    ]
 
   export
-    minprotobuf, switch, peerid, peerinfo,
-    connection, multiaddress, crypto, lpstream,
-    bufferstream, muxer, mplex, transport,
-    tcptransport, noise, errors, cid, multihash,
+    minprotobuf, switch, peerid, peerinfo, connection, multiaddress, crypto, lpstream,
+    bufferstream, muxer, mplex, transport, tcptransport, noise, errors, cid, multihash,
     multicodec, builders, pubsub

libp2p.nimble

@@ -1,23 +1,17 @@
 mode = ScriptMode.Verbose
 
-packageName   = "libp2p"
-version       = "1.1.0"
-author        = "Status Research & Development GmbH"
-description   = "LibP2P implementation"
-license       = "MIT"
-skipDirs      = @["tests", "examples", "Nim", "tools", "scripts", "docs"]
+packageName = "libp2p"
+version = "1.8.0"
+author = "Status Research & Development GmbH"
+description = "LibP2P implementation"
+license = "MIT"
+skipDirs = @["tests", "examples", "Nim", "tools", "scripts", "docs"]
 
 requires "nim >= 1.6.0",
-         "nimcrypto >= 0.4.1",
-         "dnsclient >= 0.3.0 & < 0.4.0",
-         "bearssl >= 0.1.4",
-         "chronicles >= 0.10.2",
-         "chronos >= 4.0.0",
-         "metrics",
-         "secp256k1",
-         "stew#head",
-         "websock",
-         "unittest2"
+  "nimcrypto >= 0.6.0 & < 0.7.0", "dnsclient >= 0.3.0 & < 0.4.0", "bearssl >= 0.2.5",
+  "chronicles >= 0.10.2", "chronos >= 4.0.3", "metrics", "secp256k1", "stew#head",
+  "websock", "unittest2",
+  "https://github.com/status-im/nim-quic.git#ddcb31ffb74b5460ab37fd13547eca90594248bc"
 
 let nimc = getEnv("NIMC", "nim") # Which nim compiler to use
 let lang = getEnv("NIMLANG", "c") # Which backend (c/cpp/js)
@@ -26,14 +20,14 @@ let verbose = getEnv("V", "") notin ["", "0"]
 
 let cfg =
   " --styleCheck:usages --styleCheck:error" &
-  (if verbose: "" else: " --verbosity:0 --hints:off") &
-  " --skipParentCfg --skipUserCfg -f" &
+  (if verbose: "" else: " --verbosity:0 --hints:off") & " --skipUserCfg -f" &
   " --threads:on --opt:speed"
 
 import hashes, strutils
 
-proc runTest(filename: string, verify: bool = true, sign: bool = true,
-             moreoptions: string = "") =
+proc runTest(
+    filename: string, verify: bool = true, sign: bool = true, moreoptions: string = ""
+) =
   var excstr = nimc & " " & lang & " -d:debug " & cfg & " " & flags
   excstr.add(" -d:libp2p_pubsub_sign=" & $sign)
   excstr.add(" -d:libp2p_pubsub_verify=" & $verify)
@@ -52,7 +46,8 @@ proc buildSample(filename: string, run = false, extraFlags = "") =
   rmFile "examples/" & filename.toExe
 
 proc tutorialToMd(filename: string) =
-  let markdown = gorge "cat " & filename & " | " & nimc & " " & lang & " -r --verbosity:0 --hints:off tools/markdown_builder.nim "
+  let markdown = gorge "cat " & filename & " | " & nimc & " " & lang &
+    " -r --verbosity:0 --hints:off tools/markdown_builder.nim "
   writeFile(filename.replace(".nim", ".md"), markdown)
 
 task testnative, "Runs libp2p native tests":
@@ -65,24 +60,37 @@ task testinterop, "Runs interop tests":
   runTest("testinterop")
 
 task testpubsub, "Runs pubsub tests":
-  runTest("pubsub/testgossipinternal", sign = false, verify = false, moreoptions = "-d:pubsub_internal_testing")
+  runTest(
+    "pubsub/testgossipinternal",
+    sign = false,
+    verify = false,
+    moreoptions = "-d:pubsub_internal_testing",
+  )
   runTest("pubsub/testpubsub")
   runTest("pubsub/testpubsub", sign = false, verify = false)
-  runTest("pubsub/testpubsub", sign = false, verify = false, moreoptions = "-d:libp2p_pubsub_anonymize=true")
+  runTest(
+    "pubsub/testpubsub",
+    sign = false,
+    verify = false,
+    moreoptions = "-d:libp2p_pubsub_anonymize=true",
+  )
 
 task testpubsub_slim, "Runs pubsub tests":
-  runTest("pubsub/testgossipinternal", sign = false, verify = false, moreoptions = "-d:pubsub_internal_testing")
+  runTest(
+    "pubsub/testgossipinternal",
+    sign = false,
+    verify = false,
+    moreoptions = "-d:pubsub_internal_testing",
+  )
   runTest("pubsub/testpubsub")
 
 task testfilter, "Run PKI filter test":
-  runTest("testpkifilter",
-           moreoptions = "-d:libp2p_pki_schemes=\"secp256k1\"")
-  runTest("testpkifilter",
-           moreoptions = "-d:libp2p_pki_schemes=\"secp256k1;ed25519\"")
-  runTest("testpkifilter",
-           moreoptions = "-d:libp2p_pki_schemes=\"secp256k1;ed25519;ecnist\"")
-  runTest("testpkifilter",
-           moreoptions = "-d:libp2p_pki_schemes=")
+  runTest("testpkifilter", moreoptions = "-d:libp2p_pki_schemes=\"secp256k1\"")
+  runTest("testpkifilter", moreoptions = "-d:libp2p_pki_schemes=\"secp256k1;ed25519\"")
+  runTest(
+    "testpkifilter", moreoptions = "-d:libp2p_pki_schemes=\"secp256k1;ed25519;ecnist\""
+  )
+  runTest("testpkifilter", moreoptions = "-d:libp2p_pki_schemes=")
 
 task test, "Runs the test suite":
   exec "nimble testnative"
@@ -117,8 +125,8 @@ task examples_build, "Build the samples":
   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"
+  exec "nimble install -y nimpng"
+  exec "nimble install -y nico --passNim=--skipParentCfg"
   buildSample("tutorial_6_game", false, "--styleCheck:off")
 
 # pin system
@@ -135,7 +143,9 @@ task pin, "Create a lockfile":
 import sequtils
 import os
 task install_pinned, "Reads the lockfile":
-  let toInstall = readFile(PinFile).splitWhitespace().mapIt((it.split(";", 1)[0], it.split(";", 1)[1]))
+  let toInstall = readFile(PinFile).splitWhitespace().mapIt(
+      (it.split(";", 1)[0], it.split(";", 1)[1])
+    )
   # [('packageName', 'packageFullUri')]
 
   rmDir("nimbledeps")
@@ -145,8 +155,7 @@ task install_pinned, "Reads the lockfile":
   # Remove the automatically installed deps
   # (inefficient you say?)
   let nimblePkgs =
-    if system.dirExists("nimbledeps/pkgs"): "nimbledeps/pkgs"
-    else: "nimbledeps/pkgs2"
+    if system.dirExists("nimbledeps/pkgs"): "nimbledeps/pkgs" else: "nimbledeps/pkgs2"
   for dependency in listDirs(nimblePkgs):
     let
       fileName = dependency.extractFilename
@@ -154,14 +163,12 @@ task install_pinned, "Reads the lockfile":
       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)
+      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

@@ -9,28 +9,33 @@
 
 ## This module contains a Switch Building helper.
 runnableExamples:
-  let switch =
-   SwitchBuilder.new()
-   .withRng(rng)
-   .withAddresses(multiaddress)
-   # etc
-   .build()
+  let switch = SwitchBuilder.new().withRng(rng).withAddresses(multiaddress)
+    # etc
+    .build()
 
 {.push raises: [].}
 
+import options, tables, chronos, chronicles, sequtils
 import
-  options, tables, chronos, chronicles, sequtils,
-  switch, peerid, peerinfo, stream/connection, multiaddress,
-  crypto/crypto, transports/[transport, tcptransport],
+  switch,
+  peerid,
+  peerinfo,
+  stream/connection,
+  multiaddress,
+  crypto/crypto,
+  transports/[transport, tcptransport],
   muxers/[muxer, mplex/mplex, yamux/yamux],
   protocols/[identify, secure/secure, secure/noise, rendezvous],
   protocols/connectivity/[autonat/server, relay/relay, relay/client, relay/rtransport],
-  connmanager, upgrademngrs/muxedupgrade, observedaddrmanager,
+  connmanager,
+  upgrademngrs/muxedupgrade,
+  observedaddrmanager,
   nameresolving/nameresolver,
-  errors, utility
+  errors,
+  utility
+import services/wildcardresolverservice
 
-export
-  switch, peerid, peerinfo, connection, multiaddress, crypto, errors
+export switch, peerid, peerinfo, connection, multiaddress, crypto, errors
 
 type
   TransportProvider* {.public.} = proc(upgr: Upgrade): Transport {.gcsafe, raises: [].}
@@ -59,13 +64,13 @@ type
     rdv: RendezVous
     services: seq[Service]
     observedAddrManager: ObservedAddrManager
+    enableWildcardResolver: bool
 
 proc new*(T: type[SwitchBuilder]): T {.public.} =
   ## Creates a SwitchBuilder
 
-  let address = MultiAddress
-  .init("/ip4/127.0.0.1/tcp/0")
-  .expect("Should initialize to default")
+  let address =
+    MultiAddress.init("/ip4/127.0.0.1/tcp/0").expect("Should initialize to default")
 
   SwitchBuilder(
     privKey: none(PrivateKey),
@@ -76,55 +81,57 @@ proc new*(T: type[SwitchBuilder]): T {.public.} =
     maxOut: -1,
     maxConnsPerPeer: MaxConnectionsPerPeer,
     protoVersion: ProtoVersion,
-    agentVersion: AgentVersion)
+    agentVersion: AgentVersion,
+    enableWildcardResolver: true,
+  )
 
-proc withPrivateKey*(b: SwitchBuilder, privateKey: PrivateKey): SwitchBuilder {.public.} =
+proc withPrivateKey*(
+    b: SwitchBuilder, privateKey: PrivateKey
+): SwitchBuilder {.public.} =
   ## Set the private key of the switch. Will be used to
   ## generate a PeerId
 
   b.privKey = some(privateKey)
   b
 
-proc withAddress*(b: SwitchBuilder, address: MultiAddress): SwitchBuilder {.public.} =
-  ## | Set the listening address of the switch
-  ## | Calling it multiple time will override the value
-
-  b.addresses = @[address]
-  b
-
-proc withAddresses*(b: SwitchBuilder, addresses: seq[MultiAddress]): SwitchBuilder {.public.} =
+proc withAddresses*(
+    b: SwitchBuilder, addresses: seq[MultiAddress], enableWildcardResolver: bool = true
+): SwitchBuilder {.public.} =
   ## | Set the listening addresses of the switch
   ## | Calling it multiple time will override the value
-
   b.addresses = addresses
+  b.enableWildcardResolver = enableWildcardResolver
   b
 
+proc withAddress*(
+    b: SwitchBuilder, address: MultiAddress, enableWildcardResolver: bool = true
+): SwitchBuilder {.public.} =
+  ## | Set the listening address of the switch
+  ## | Calling it multiple time will override the value
+  b.withAddresses(@[address], enableWildcardResolver)
+
 proc withSignedPeerRecord*(b: SwitchBuilder, sendIt = true): SwitchBuilder {.public.} =
   b.sendSignedPeerRecord = sendIt
   b
 
 proc withMplex*(
-    b: SwitchBuilder,
-    inTimeout = 5.minutes,
-    outTimeout = 5.minutes,
-    maxChannCount = 200): SwitchBuilder {.public.} =
+    b: SwitchBuilder, inTimeout = 5.minutes, outTimeout = 5.minutes, maxChannCount = 200
+): SwitchBuilder {.public.} =
   ## | Uses `Mplex <https://docs.libp2p.io/concepts/stream-multiplexing/#mplex>`_ as a multiplexer
   ## | `Timeout` is the duration after which a inactive connection will be closed
   proc newMuxer(conn: Connection): Muxer =
-    Mplex.new(
-      conn,
-      inTimeout,
-      outTimeout,
-      maxChannCount)
+    Mplex.new(conn, inTimeout, outTimeout, maxChannCount)
 
   assert b.muxers.countIt(it.codec == MplexCodec) == 0, "Mplex build multiple times"
   b.muxers.add(MuxerProvider.new(newMuxer, MplexCodec))
   b
 
-proc withYamux*(b: SwitchBuilder,
+proc withYamux*(
+    b: SwitchBuilder,
     windowSize: int = YamuxDefaultWindowSize,
     inTimeout: Duration = 5.minutes,
-    outTimeout: Duration = 5.minutes): SwitchBuilder =
+    outTimeout: Duration = 5.minutes,
+): SwitchBuilder =
   proc newMuxer(conn: Connection): Muxer =
     Yamux.new(conn, windowSize, inTimeout = inTimeout, outTimeout = outTimeout)
 
@@ -136,24 +143,36 @@ proc withNoise*(b: SwitchBuilder): SwitchBuilder {.public.} =
   b.secureManagers.add(SecureProtocol.Noise)
   b
 
-proc withTransport*(b: SwitchBuilder, prov: TransportProvider): SwitchBuilder {.public.} =
+proc withTransport*(
+    b: SwitchBuilder, prov: TransportProvider
+): SwitchBuilder {.public.} =
   ## Use a custom transport
   runnableExamples:
-    let switch =
-      SwitchBuilder.new()
-      .withTransport(proc(upgr: Upgrade): Transport = TcpTransport.new(flags, upgr))
+    let switch = SwitchBuilder
+      .new()
+      .withTransport(
+        proc(upgr: Upgrade): Transport =
+          TcpTransport.new(flags, upgr)
+      )
       .build()
   b.transports.add(prov)
   b
 
-proc withTcpTransport*(b: SwitchBuilder, flags: set[ServerFlags] = {}): SwitchBuilder {.public.} =
-  b.withTransport(proc(upgr: Upgrade): Transport = TcpTransport.new(flags, upgr))
+proc withTcpTransport*(
+    b: SwitchBuilder, flags: set[ServerFlags] = {}
+): SwitchBuilder {.public.} =
+  b.withTransport(
+    proc(upgr: Upgrade): Transport =
+      TcpTransport.new(flags, upgr)
+  )
 
 proc withRng*(b: SwitchBuilder, rng: ref HmacDrbgContext): SwitchBuilder {.public.} =
   b.rng = rng
   b
 
-proc withMaxConnections*(b: SwitchBuilder, maxConnections: int): SwitchBuilder {.public.} =
+proc withMaxConnections*(
+    b: SwitchBuilder, maxConnections: int
+): SwitchBuilder {.public.} =
   ## Maximum concurrent connections of the switch. You should either use this, or
   ## `withMaxIn <#withMaxIn,SwitchBuilder,int>`_ & `withMaxOut<#withMaxOut,SwitchBuilder,int>`_
   b.maxConnections = maxConnections
@@ -169,7 +188,9 @@ proc withMaxOut*(b: SwitchBuilder, maxOut: int): SwitchBuilder {.public.} =
   b.maxOut = maxOut
   b
 
-proc withMaxConnsPerPeer*(b: SwitchBuilder, maxConnsPerPeer: int): SwitchBuilder {.public.} =
+proc withMaxConnsPerPeer*(
+    b: SwitchBuilder, maxConnsPerPeer: int
+): SwitchBuilder {.public.} =
   b.maxConnsPerPeer = maxConnsPerPeer
   b
 
@@ -177,15 +198,21 @@ proc withPeerStore*(b: SwitchBuilder, capacity: int): SwitchBuilder {.public.} =
   b.peerStoreCapacity = Opt.some(capacity)
   b
 
-proc withProtoVersion*(b: SwitchBuilder, protoVersion: string): SwitchBuilder {.public.} =
+proc withProtoVersion*(
+    b: SwitchBuilder, protoVersion: string
+): SwitchBuilder {.public.} =
   b.protoVersion = protoVersion
   b
 
-proc withAgentVersion*(b: SwitchBuilder, agentVersion: string): SwitchBuilder {.public.} =
+proc withAgentVersion*(
+    b: SwitchBuilder, agentVersion: string
+): SwitchBuilder {.public.} =
   b.agentVersion = agentVersion
   b
 
-proc withNameResolver*(b: SwitchBuilder, nameResolver: NameResolver): SwitchBuilder {.public.} =
+proc withNameResolver*(
+    b: SwitchBuilder, nameResolver: NameResolver
+): SwitchBuilder {.public.} =
   b.nameResolver = nameResolver
   b
 
@@ -197,7 +224,9 @@ proc withCircuitRelay*(b: SwitchBuilder, r: Relay = Relay.new()): SwitchBuilder
   b.circuitRelay = r
   b
 
-proc withRendezVous*(b: SwitchBuilder, rdv: RendezVous = RendezVous.new()): SwitchBuilder =
+proc withRendezVous*(
+    b: SwitchBuilder, rdv: RendezVous = RendezVous.new()
+): SwitchBuilder =
   b.rdv = rdv
   b
 
@@ -205,31 +234,26 @@ proc withServices*(b: SwitchBuilder, services: seq[Service]): SwitchBuilder =
   b.services = services
   b
 
-proc withObservedAddrManager*(b: SwitchBuilder, observedAddrManager: ObservedAddrManager): SwitchBuilder =
+proc withObservedAddrManager*(
+    b: SwitchBuilder, observedAddrManager: ObservedAddrManager
+): SwitchBuilder =
   b.observedAddrManager = observedAddrManager
   b
 
-proc build*(b: SwitchBuilder): Switch
-  {.raises: [LPError], public.} =
-
+proc build*(b: SwitchBuilder): Switch {.raises: [LPError], public.} =
   if b.rng == nil: # newRng could fail
     raise newException(Defect, "Cannot initialize RNG")
 
   let pkRes = PrivateKey.random(b.rng[])
-  let
-    seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key"))
+  let seckey = b.privKey.get(otherwise = pkRes.expect("Expected default Private Key"))
 
-  var
-    secureManagerInstances: seq[Secure]
+  var secureManagerInstances: seq[Secure]
   if SecureProtocol.Noise in b.secureManagers:
     secureManagerInstances.add(Noise.new(b.rng, seckey).Secure)
 
-  let
-    peerInfo = PeerInfo.new(
-      seckey,
-      b.addresses,
-      protoVersion = b.protoVersion,
-      agentVersion = b.agentVersion)
+  let peerInfo = PeerInfo.new(
+    seckey, b.addresses, protoVersion = b.protoVersion, agentVersion = b.agentVersion
+  )
 
   let identify =
     if b.observedAddrManager != nil:
@@ -238,16 +262,16 @@ proc build*(b: SwitchBuilder): Switch
       Identify.new(peerInfo, b.sendSignedPeerRecord)
 
   let
-    connManager = ConnManager.new(b.maxConnsPerPeer, b.maxConnections, b.maxIn, b.maxOut)
+    connManager =
+      ConnManager.new(b.maxConnsPerPeer, b.maxConnections, b.maxIn, b.maxOut)
     ms = MultistreamSelect.new()
     muxedUpgrade = MuxedUpgrade.new(b.muxers, secureManagerInstances, ms)
 
-  let
-    transports = block:
-      var transports: seq[Transport]
-      for tProvider in b.transports:
-        transports.add(tProvider(muxedUpgrade))
-      transports
+  let transports = block:
+    var transports: seq[Transport]
+    for tProvider in b.transports:
+      transports.add(tProvider(muxedUpgrade))
+    transports
 
   if b.secureManagers.len == 0:
     b.secureManagers &= SecureProtocol.Noise
@@ -261,6 +285,9 @@ proc build*(b: SwitchBuilder): Switch
     else:
       PeerStore.new(identify)
 
+  if b.enableWildcardResolver:
+    b.services.insert(WildcardAddressResolverService.new(), 0)
+
   let switch = newSwitch(
     peerInfo = peerInfo,
     transports = transports,
@@ -269,7 +296,8 @@ proc build*(b: SwitchBuilder): Switch
     ms = ms,
     nameResolver = b.nameResolver,
     peerStore = peerStore,
-    services = b.services)
+    services = b.services,
+  )
 
   switch.mount(identify)
 
@@ -293,9 +321,7 @@ proc newStandardSwitch*(
     privKey = none(PrivateKey),
     addrs: MultiAddress | seq[MultiAddress] =
       MultiAddress.init("/ip4/127.0.0.1/tcp/0").expect("valid address"),
-    secureManagers: openArray[SecureProtocol] = [
-      SecureProtocol.Noise,
-    ],
+    secureManagers: openArray[SecureProtocol] = [SecureProtocol.Noise],
     transportFlags: set[ServerFlags] = {},
     rng = newRng(),
     inTimeout: Duration = 5.minutes,
@@ -306,10 +332,14 @@ proc newStandardSwitch*(
     maxConnsPerPeer = MaxConnectionsPerPeer,
     nameResolver: NameResolver = nil,
     sendSignedPeerRecord = false,
-    peerStoreCapacity = 1000
+    peerStoreCapacity = 1000,
 ): Switch {.raises: [LPError], public.} =
   ## Helper for common switch configurations.
-  let addrs = when addrs is MultiAddress: @[addrs] else: addrs
+  let addrs =
+    when addrs is MultiAddress:
+      @[addrs]
+    else:
+      addrs
   var b = SwitchBuilder
     .new()
     .withAddresses(addrs)
@@ -319,7 +349,7 @@ proc newStandardSwitch*(
     .withMaxIn(maxIn)
     .withMaxOut(maxOut)
     .withMaxConnsPerPeer(maxConnsPerPeer)
-    .withPeerStore(capacity=peerStoreCapacity)
+    .withPeerStore(capacity = peerStoreCapacity)
     .withMplex(inTimeout, outTimeout)
     .withTcpTransport(transportFlags)
     .withNameResolver(nameResolver)

libp2p/cid.nim

@@ -19,10 +19,16 @@ export results
 
 type
   CidError* {.pure.} = enum
-    Error, Incorrect, Unsupported, Overrun
+    Error
+    Incorrect
+    Unsupported
+    Overrun
 
   CidVersion* = enum
-    CIDvIncorrect, CIDv0, CIDv1, CIDvReserved
+    CIDvIncorrect
+    CIDv0
+    CIDv1
+    CIDvReserved
 
   Cid* = object
     cidver*: CidVersion
@@ -30,54 +36,51 @@ type
     hpos*: int
     data*: VBuffer
 
-const
-  ContentIdsList = [
-    multiCodec("raw"),
-    multiCodec("dag-pb"),
-    multiCodec("dag-cbor"),
-    multiCodec("dag-json"),
-    multiCodec("git-raw"),
-    multiCodec("eth-block"),
-    multiCodec("eth-block-list"),
-    multiCodec("eth-tx-trie"),
-    multiCodec("eth-tx"),
-    multiCodec("eth-tx-receipt-trie"),
-    multiCodec("eth-tx-receipt"),
-    multiCodec("eth-state-trie"),
-    multiCodec("eth-account-snapshot"),
-    multiCodec("eth-storage-trie"),
-    multiCodec("bitcoin-block"),
-    multiCodec("bitcoin-tx"),
-    multiCodec("zcash-block"),
-    multiCodec("zcash-tx"),
-    multiCodec("stellar-block"),
-    multiCodec("stellar-tx"),
-    multiCodec("decred-block"),
-    multiCodec("decred-tx"),
-    multiCodec("dash-block"),
-    multiCodec("dash-tx"),
-    multiCodec("torrent-info"),
-    multiCodec("torrent-file"),
-    multiCodec("ed25519-pub")
-  ]
+const ContentIdsList = [
+  multiCodec("raw"),
+  multiCodec("dag-pb"),
+  multiCodec("dag-cbor"),
+  multiCodec("dag-json"),
+  multiCodec("git-raw"),
+  multiCodec("eth-block"),
+  multiCodec("eth-block-list"),
+  multiCodec("eth-tx-trie"),
+  multiCodec("eth-tx"),
+  multiCodec("eth-tx-receipt-trie"),
+  multiCodec("eth-tx-receipt"),
+  multiCodec("eth-state-trie"),
+  multiCodec("eth-account-snapshot"),
+  multiCodec("eth-storage-trie"),
+  multiCodec("bitcoin-block"),
+  multiCodec("bitcoin-tx"),
+  multiCodec("zcash-block"),
+  multiCodec("zcash-tx"),
+  multiCodec("stellar-block"),
+  multiCodec("stellar-tx"),
+  multiCodec("decred-block"),
+  multiCodec("decred-tx"),
+  multiCodec("dash-block"),
+  multiCodec("dash-tx"),
+  multiCodec("torrent-info"),
+  multiCodec("torrent-file"),
+  multiCodec("ed25519-pub"),
+]
 
 proc initCidCodeTable(): Table[int, MultiCodec] {.compileTime.} =
   for item in ContentIdsList:
     result[int(item)] = item
 
-const
-  CodeContentIds = initCidCodeTable()
+const CodeContentIds = initCidCodeTable()
 
 template orError*(exp: untyped, err: untyped): untyped =
-  (exp.mapErr do (_: auto) -> auto: err)
+  exp.mapErr do(_: auto) -> auto:
+    err
 
 proc decode(data: openArray[byte]): Result[Cid, CidError] =
   if len(data) == 34 and data[0] == 0x12'u8 and data[1] == 0x20'u8:
-    ok(Cid(
-        cidver: CIDv0,
-        mcodec: multiCodec("dag-pb"),
-        hpos: 0,
-        data: initVBuffer(data)))
+    ok(
+      Cid(cidver: CIDv0, mcodec: multiCodec("dag-pb"), hpos: 0, data: initVBuffer(data))
+    )
   else:
     var version, codec: uint64
     var res, offset: int
@@ -98,21 +101,18 @@ proc decode(data: openArray[byte]): Result[Cid, CidError] =
             err(CidError.Incorrect)
           else:
             offset += res
-            var mcodec = CodeContentIds.getOrDefault(cast[int](codec),
-                                                    InvalidMultiCodec)
+            var mcodec =
+              CodeContentIds.getOrDefault(cast[int](codec), InvalidMultiCodec)
             if mcodec == InvalidMultiCodec:
               err(CidError.Incorrect)
             else:
-              if not MultiHash.validate(vb.buffer.toOpenArray(vb.offset,
-                                                              vb.buffer.high)):
+              if not MultiHash.validate(
+                vb.buffer.toOpenArray(vb.offset, vb.buffer.high)
+              ):
                 err(CidError.Incorrect)
               else:
                 vb.finish()
-                ok(Cid(
-                    cidver: CIDv1,
-                    mcodec: mcodec,
-                    hpos: offset,
-                    data: vb))
+                ok(Cid(cidver: CIDv1, mcodec: mcodec, hpos: offset, data: vb))
 
 proc decode(data: openArray[char]): Result[Cid, CidError] =
   var buffer: seq[byte]
@@ -172,7 +172,9 @@ proc mhash*(cid: Cid): Result[MultiHash, CidError] =
   if cid.cidver notin {CIDv0, CIDv1}:
     err(CidError.Incorrect)
   else:
-    MultiHash.init(cid.data.buffer.toOpenArray(cid.hpos, cid.data.high)).orError(CidError.Incorrect)
+    MultiHash.init(cid.data.buffer.toOpenArray(cid.hpos, cid.data.high)).orError(
+      CidError.Incorrect
+    )
 
 proc contentType*(cid: Cid): Result[MultiCodec, CidError] =
   ## Returns content type part of CID
@@ -185,12 +187,15 @@ proc version*(cid: Cid): CidVersion =
   ## Returns CID version
   result = cid.cidver
 
-proc init*[T: char|byte](ctype: typedesc[Cid], data: openArray[T]): Result[Cid, CidError] =
+proc init*[T: char | byte](
+    ctype: typedesc[Cid], data: openArray[T]
+): Result[Cid, CidError] =
   ## Create new content identifier using array of bytes or string ``data``.
   decode(data)
 
-proc init*(ctype: typedesc[Cid], version: CidVersion, content: MultiCodec,
-           hash: MultiHash): Result[Cid, CidError] =
+proc init*(
+    ctype: typedesc[Cid], version: CidVersion, content: MultiCodec, hash: MultiHash
+): Result[Cid, CidError] =
   ## Create new content identifier using content type ``content`` and
   ## MultiHash ``hash`` using version ``version``.
   ##
@@ -213,8 +218,7 @@ proc init*(ctype: typedesc[Cid], version: CidVersion, content: MultiCodec,
     res.data.finish()
     return ok(res)
   elif version == CIDv1:
-    let mcodec = CodeContentIds.getOrDefault(cast[int](content),
-                                             InvalidMultiCodec)
+    let mcodec = CodeContentIds.getOrDefault(cast[int](content), InvalidMultiCodec)
     if mcodec == InvalidMultiCodec:
       return err(CidError.Incorrect)
     res.mcodec = mcodec
@@ -233,11 +237,9 @@ proc `==`*(a: Cid, b: Cid): bool =
   ## are equal, ``false`` otherwise.
   if a.mcodec == b.mcodec:
     var ah, bh: MultiHash
-    if MultiHash.decode(
-      a.data.buffer.toOpenArray(a.hpos, a.data.high), ah).isErr:
+    if MultiHash.decode(a.data.buffer.toOpenArray(a.hpos, a.data.high), ah).isErr:
       return false
-    if MultiHash.decode(
-      b.data.buffer.toOpenArray(b.hpos, b.data.high), bh).isErr:
+    if MultiHash.decode(b.data.buffer.toOpenArray(b.hpos, b.data.high), bh).isErr:
       return false
     result = (ah == bh)
 

libp2p/connmanager.nim

@@ -11,12 +11,7 @@
 
 import std/[tables, sequtils, sets]
 import pkg/[chronos, chronicles, metrics]
-import peerinfo,
-       peerstore,
-       stream/connection,
-       muxers/muxer,
-       utils/semaphore,
-       errors
+import peerinfo, peerstore, stream/connection, muxers/muxer, utils/semaphore, errors
 
 logScope:
   topics = "libp2p connmanager"
@@ -32,12 +27,13 @@ type
   AlreadyExpectingConnectionError* = object of LPError
 
   ConnEventKind* {.pure.} = enum
-    Connected,    # A connection was made and securely upgraded - there may be
-                  # more than one concurrent connection thus more than one upgrade
-                  # event per peer.
-
-    Disconnected  # Peer disconnected - this event is fired once per upgrade
-                  # when the associated connection is terminated.
+    Connected
+      # A connection was made and securely upgraded - there may be
+      # more than one concurrent connection thus more than one upgrade
+      # event per peer.
+    Disconnected
+      # Peer disconnected - this event is fired once per upgrade
+      # when the associated connection is terminated.
 
   ConnEvent* = object
     case kind*: ConnEventKind
@@ -47,19 +43,19 @@ type
       discard
 
   ConnEventHandler* =
-    proc(peerId: PeerId, event: ConnEvent): Future[void]
-      {.gcsafe, raises: [].}
+    proc(peerId: PeerId, event: ConnEvent): Future[void] {.gcsafe, raises: [].}
 
   PeerEventKind* {.pure.} = enum
-    Left,
+    Left
     Joined
+    Identified
 
   PeerEvent* = object
     case kind*: PeerEventKind
-      of PeerEventKind.Joined:
-        initiator*: bool
-      else:
-        discard
+    of PeerEventKind.Joined, PeerEventKind.Identified:
+      initiator*: bool
+    else:
+      discard
 
   PeerEventHandler* =
     proc(peerId: PeerId, event: PeerEvent): Future[void] {.gcsafe, raises: [].}
@@ -81,11 +77,13 @@ type
 proc newTooManyConnectionsError(): ref TooManyConnectionsError {.inline.} =
   result = newException(TooManyConnectionsError, "Too many connections")
 
-proc new*(C: type ConnManager,
-           maxConnsPerPeer = MaxConnectionsPerPeer,
-           maxConnections = MaxConnections,
-           maxIn = -1,
-           maxOut = -1): ConnManager =
+proc new*(
+    C: type ConnManager,
+    maxConnsPerPeer = MaxConnectionsPerPeer,
+    maxConnections = MaxConnections,
+    maxIn = -1,
+    maxOut = -1,
+): ConnManager =
   var inSema, outSema: AsyncSemaphore
   if maxIn > 0 or maxOut > 0:
     inSema = newAsyncSemaphore(maxIn)
@@ -96,9 +94,7 @@ proc new*(C: type ConnManager,
   else:
     raiseAssert "Invalid connection counts!"
 
-  C(maxConnsPerPeer: maxConnsPerPeer,
-    inSema: inSema,
-    outSema: outSema)
+  C(maxConnsPerPeer: maxConnsPerPeer, inSema: inSema, outSema: outSema)
 
 proc connCount*(c: ConnManager, peerId: PeerId): int =
   c.muxed.getOrDefault(peerId).len
@@ -113,22 +109,21 @@ proc connectedPeers*(c: ConnManager, dir: Direction): seq[PeerId] =
 proc getConnections*(c: ConnManager): Table[PeerId, seq[Muxer]] =
   return c.muxed
 
-proc addConnEventHandler*(c: ConnManager,
-                          handler: ConnEventHandler,
-                          kind: ConnEventKind) =
+proc addConnEventHandler*(
+    c: ConnManager, handler: ConnEventHandler, kind: ConnEventKind
+) =
   ## Add peer event handler - handlers must not raise exceptions!
   ##
-  if isNil(handler): return
+  if isNil(handler):
+    return
   c.connEvents[kind].incl(handler)
 
-proc removeConnEventHandler*(c: ConnManager,
-                             handler: ConnEventHandler,
-                             kind: ConnEventKind) =
-    c.connEvents[kind].excl(handler)
+proc removeConnEventHandler*(
+    c: ConnManager, handler: ConnEventHandler, kind: ConnEventKind
+) =
+  c.connEvents[kind].excl(handler)
 
-proc triggerConnEvent*(c: ConnManager,
-                       peerId: PeerId,
-                       event: ConnEvent) {.async.} =
+proc triggerConnEvent*(c: ConnManager, peerId: PeerId, event: ConnEvent) {.async.} =
   try:
     trace "About to trigger connection events", peer = peerId
     if c.connEvents[event.kind].len() > 0:
@@ -142,26 +137,24 @@ proc triggerConnEvent*(c: ConnManager,
     raise exc
   except CatchableError as exc:
     warn "Exception in triggerConnEvents",
-      msg = exc.msg, peer = peerId, event = $event
+      description = exc.msg, peer = peerId, event = $event
 
-proc addPeerEventHandler*(c: ConnManager,
-                          handler: PeerEventHandler,
-                          kind: PeerEventKind) =
+proc addPeerEventHandler*(
+    c: ConnManager, handler: PeerEventHandler, kind: PeerEventKind
+) =
   ## Add peer event handler - handlers must not raise exceptions!
   ##
 
-  if isNil(handler): return
+  if isNil(handler):
+    return
   c.peerEvents[kind].incl(handler)
 
-proc removePeerEventHandler*(c: ConnManager,
-                             handler: PeerEventHandler,
-                             kind: PeerEventKind) =
+proc removePeerEventHandler*(
+    c: ConnManager, handler: PeerEventHandler, kind: PeerEventKind
+) =
   c.peerEvents[kind].excl(handler)
 
-proc triggerPeerEvents*(c: ConnManager,
-                        peerId: PeerId,
-                        event: PeerEvent) {.async.} =
-
+proc triggerPeerEvents*(c: ConnManager, peerId: PeerId, event: PeerEvent) {.async.} =
   trace "About to trigger peer events", peer = peerId
   if c.peerEvents[event.kind].len == 0:
     return
@@ -177,13 +170,18 @@ proc triggerPeerEvents*(c: ConnManager,
   except CancelledError as exc:
     raise exc
   except CatchableError as exc: # handlers should not raise!
-    warn "Exception in triggerPeerEvents", exc = exc.msg, peer = peerId
+    warn "Exception in triggerPeerEvents", description = exc.msg, peer = peerId
 
-proc expectConnection*(c: ConnManager, p: PeerId, dir: Direction): Future[Muxer] {.async.} =
+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")
+    raise newException(
+      AlreadyExpectingConnectionError,
+      "Already expecting an incoming connection from that peer",
+    )
 
   let future = newFuture[Muxer]()
   c.expectedConnectionsOverLimit[key] = future
@@ -211,11 +209,11 @@ proc closeMuxer(muxer: Muxer) {.async.} =
   trace "Cleaning up muxer", m = muxer
 
   await muxer.close()
-  if not(isNil(muxer.handler)):
+  if not (isNil(muxer.handler)):
     try:
       await muxer.handler # TODO noraises?
     except CatchableError as exc:
-      trace "Exception in close muxer handler", exc = exc.msg
+      trace "Exception in close muxer handler", description = exc.msg
   trace "Cleaned up muxer", m = muxer
 
 proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
@@ -231,16 +229,14 @@ proc muxCleanup(c: ConnManager, mux: Muxer) {.async.} =
       libp2p_peers.set(c.muxed.len.int64)
       await c.triggerPeerEvents(peerId, PeerEvent(kind: PeerEventKind.Left))
 
-      if not(c.peerStore.isNil):
+      if not (c.peerStore.isNil):
         c.peerStore.cleanup(peerId)
 
-    await c.triggerConnEvent(
-      peerId, ConnEvent(kind: ConnEventKind.Disconnected))
+    await c.triggerConnEvent(peerId, ConnEvent(kind: ConnEventKind.Disconnected))
   except CatchableError as exc:
     # This is top-level procedure which will work as separate task, so it
     # do not need to propagate CancelledError and should handle other errors
-    warn "Unexpected exception peer cleanup handler",
-      mux, msg = exc.msg
+    warn "Unexpected exception peer cleanup handler", mux, description = exc.msg
 
 proc onClose(c: ConnManager, mux: Muxer) {.async.} =
   ## connection close even handler
@@ -252,18 +248,14 @@ proc onClose(c: ConnManager, mux: Muxer) {.async.} =
     trace "Connection closed, cleaning up", mux
   except CatchableError as exc:
     debug "Unexpected exception in connection manager's cleanup",
-          errMsg = exc.msg, mux
+      description = exc.msg, mux
   finally:
     await c.muxCleanup(mux)
 
-proc selectMuxer*(c: ConnManager,
-                peerId: PeerId,
-                dir: Direction): Muxer =
+proc selectMuxer*(c: ConnManager, peerId: PeerId, dir: Direction): Muxer =
   ## Select a connection for the provided peer and direction
   ##
-  let conns = toSeq(
-    c.muxed.getOrDefault(peerId))
-    .filterIt( it.connection.dir == dir )
+  let conns = toSeq(c.muxed.getOrDefault(peerId)).filterIt(it.connection.dir == dir)
 
   if conns.len > 0:
     return conns[0]
@@ -280,9 +272,7 @@ proc selectMuxer*(c: ConnManager, peerId: PeerId): Muxer =
     trace "connection not found", peerId
   return mux
 
-proc storeMuxer*(c: ConnManager,
-                 muxer: Muxer)
-                 {.raises: [CatchableError].} =
+proc storeMuxer*(c: ConnManager, muxer: Muxer) {.raises: [CatchableError].} =
   ## store the connection and muxer
   ##
 
@@ -304,10 +294,10 @@ proc storeMuxer*(c: ConnManager,
     let key = (peerId, dir)
     let expectedConn = c.expectedConnectionsOverLimit.getOrDefault(key)
     if expectedConn != nil and not expectedConn.finished:
-        expectedConn.complete(muxer)
+      expectedConn.complete(muxer)
     else:
       debug "Too many connections for peer",
-        conns = c.muxed.getOrDefault(peerId).len
+        conns = c.muxed.getOrDefault(peerId).len, peerId, dir
 
       raise newTooManyConnectionsError()
 
@@ -322,36 +312,39 @@ proc storeMuxer*(c: ConnManager,
   libp2p_peers.set(c.muxed.len.int64)
 
   asyncSpawn c.triggerConnEvent(
-    peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: dir == Direction.In))
+    peerId, ConnEvent(kind: ConnEventKind.Connected, incoming: dir == Direction.In)
+  )
 
   if newPeer:
     asyncSpawn c.triggerPeerEvents(
-      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: dir == Direction.Out))
+      peerId, PeerEvent(kind: PeerEventKind.Joined, initiator: dir == Direction.Out)
+    )
 
   asyncSpawn c.onClose(muxer)
 
-  trace "Stored muxer",
-    muxer, direction = $muxer.connection.dir, peers = c.muxed.len
+  trace "Stored 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): ConnectionSlot {.raises: [TooManyConnectionsError].} =
+proc getOutgoingSlot*(
+    c: ConnManager, forceDial = false
+): ConnectionSlot {.raises: [TooManyConnectionsError].} =
   if forceDial:
     c.outSema.forceAcquire()
   elif not c.outSema.tryAcquire():
-    trace "Too many outgoing connections!", count = c.outSema.count,
-                                            max = c.outSema.size
+    trace "Too many outgoing connections!",
+      available = c.outSema.count, max = c.outSema.size
     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
+  case dir
+  of Direction.In:
+    return c.inSema.count
+  of Direction.Out:
+    return c.outSema.count
 
 proc release*(cs: ConnectionSlot) =
   if cs.direction == In:
@@ -368,7 +361,7 @@ proc trackConnection*(cs: ConnectionSlot, conn: Connection) =
     try:
       await conn.join()
     except CatchableError as exc:
-      trace "Exception in semaphore monitor, ignoring", exc = exc.msg
+      trace "Exception in semaphore monitor, ignoring", description = exc.msg
 
     cs.release()
 
@@ -380,30 +373,27 @@ proc trackMuxer*(cs: ConnectionSlot, mux: Muxer) =
     return
   cs.trackConnection(mux.connection)
 
-proc getStream*(c: ConnManager,
-                muxer: Muxer): Future[Connection] {.async.} =
+proc getStream*(c: ConnManager, muxer: Muxer): Future[Connection] {.async.} =
   ## get a muxed stream for the passed muxer
   ##
 
-  if not(isNil(muxer)):
+  if not (isNil(muxer)):
     return await muxer.newStream()
 
-proc getStream*(c: ConnManager,
-                peerId: PeerId): Future[Connection] {.async.} =
+proc getStream*(c: ConnManager, peerId: PeerId): Future[Connection] {.async.} =
   ## get a muxed stream for the passed peer from any connection
   ##
 
   return await c.getStream(c.selectMuxer(peerId))
 
-proc getStream*(c: ConnManager,
-                peerId: PeerId,
-                dir: Direction): Future[Connection] {.async.} =
+proc getStream*(
+    c: ConnManager, peerId: PeerId, dir: Direction
+): Future[Connection] {.async.} =
   ## get a muxed stream for the passed peer from a connection with `dir`
   ##
 
   return await c.getStream(c.selectMuxer(peerId, dir))
 
-
 proc dropPeer*(c: ConnManager, peerId: PeerId) {.async.} =
   ## drop connections and cleanup resources for peer
   ##
@@ -435,4 +425,3 @@ proc close*(c: ConnManager) {.async.} =
       await closeMuxer(mux)
 
   trace "Closed ConnManager"
-

libp2p/crypto/chacha20poly1305.nim

@@ -48,17 +48,19 @@ proc intoChaChaPolyTag*(s: openArray[byte]): ChaChaPolyTag =
 # this is reconciled at runtime
 # we do this in the global scope / module init
 
-proc encrypt*(_: type[ChaChaPoly],
-                 key: ChaChaPolyKey,
-                 nonce: ChaChaPolyNonce,
-                 tag: var ChaChaPolyTag,
-                 data: var openArray[byte],
-                 aad: openArray[byte]) =
-  let
-    ad = if aad.len > 0:
-           unsafeAddr aad[0]
-         else:
-           nil
+proc encrypt*(
+    _: type[ChaChaPoly],
+    key: ChaChaPolyKey,
+    nonce: ChaChaPolyNonce,
+    tag: var ChaChaPolyTag,
+    data: var openArray[byte],
+    aad: openArray[byte],
+) =
+  let ad =
+    if aad.len > 0:
+      unsafeAddr aad[0]
+    else:
+      nil
 
   poly1305CtmulRun(
     unsafeAddr key[0],
@@ -69,20 +71,23 @@ proc encrypt*(_: type[ChaChaPoly],
     uint(aad.len),
     baseAddr(tag),
     # cast is required to workaround https://github.com/nim-lang/Nim/issues/13905
-    cast[Chacha20Run](chacha20CtRun),
-    #[encrypt]# 1.cint)
+    cast[Chacha20Run](chacha20CtRun), #[encrypt]#
+    1.cint,
+  )
 
-proc decrypt*(_: type[ChaChaPoly],
-                 key: ChaChaPolyKey,
-                 nonce: ChaChaPolyNonce,
-                 tag: var ChaChaPolyTag,
-                 data: var openArray[byte],
-                 aad: openArray[byte]) =
-  let
-    ad = if aad.len > 0:
-          unsafeAddr aad[0]
-         else:
-           nil
+proc decrypt*(
+    _: type[ChaChaPoly],
+    key: ChaChaPolyKey,
+    nonce: ChaChaPolyNonce,
+    tag: var ChaChaPolyTag,
+    data: var openArray[byte],
+    aad: openArray[byte],
+) =
+  let ad =
+    if aad.len > 0:
+      unsafeAddr aad[0]
+    else:
+      nil
 
   poly1305CtmulRun(
     unsafeAddr key[0],
@@ -93,5 +98,6 @@ proc decrypt*(_: type[ChaChaPoly],
     uint(aad.len),
     baseAddr(tag),
     # cast is required to workaround https://github.com/nim-lang/Nim/issues/13905
-    cast[Chacha20Run](chacha20CtRun),
-    #[decrypt]# 0.cint)
+    cast[Chacha20Run](chacha20CtRun), #[decrypt]#
+    0.cint,
+  )

libp2p/crypto/crypto.nim

@@ -14,12 +14,11 @@ from strutils import split, strip, cmpIgnoreCase
 
 const libp2p_pki_schemes* {.strdefine.} = "rsa,ed25519,secp256k1,ecnist"
 
-type
-  PKScheme* = enum
-    RSA = 0,
-    Ed25519,
-    Secp256k1,
-    ECDSA
+type PKScheme* = enum
+  RSA = 0
+  Ed25519
+  Secp256k1
+  ECDSA
 
 proc initSupportedSchemes(list: static string): set[PKScheme] =
   var res: set[PKScheme]
@@ -85,7 +84,7 @@ export rijndael, twofish, sha2, hash, hmac, ncrutils, rand
 
 type
   DigestSheme* = enum
-    Sha256,
+    Sha256
     Sha512
 
   PublicKey* = object
@@ -148,15 +147,16 @@ type
     data*: seq[byte]
 
   CryptoError* = enum
-    KeyError,
-    SigError,
-    HashError,
+    KeyError
+    SigError
+    HashError
     SchemeError
 
   CryptoResult*[T] = Result[T, CryptoError]
 
 template orError*(exp: untyped, err: untyped): untyped =
-  (exp.mapErr do (_: auto) -> auto: err)
+  exp.mapErr do(_: auto) -> auto:
+    err
 
 proc newRng*(): ref HmacDrbgContext =
   # You should only create one instance of the RNG per application / library
@@ -172,11 +172,9 @@ proc newRng*(): ref HmacDrbgContext =
     return nil
   rng
 
-proc shuffle*[T](
-  rng: ref HmacDrbgContext,
-  x: var openArray[T]) =
-
-  if x.len == 0: return
+proc shuffle*[T](rng: ref HmacDrbgContext, x: var openArray[T]) =
+  if x.len == 0:
+    return
 
   var randValues = newSeqUninitialized[byte](len(x) * 2)
   hmacDrbgGenerate(rng[], randValues)
@@ -187,9 +185,12 @@ proc shuffle*[T](
       y = rand mod i
     swap(x[i], x[y])
 
-proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
-             rng: var HmacDrbgContext,
-             bits = RsaDefaultKeySize): CryptoResult[PrivateKey] =
+proc random*(
+    T: typedesc[PrivateKey],
+    scheme: PKScheme,
+    rng: var HmacDrbgContext,
+    bits = RsaDefaultKeySize,
+): CryptoResult[PrivateKey] =
   ## Generate random private key for scheme ``scheme``.
   ##
   ## ``bits`` is number of bits for RSA key, ``bits`` value must be in
@@ -197,7 +198,7 @@ proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
   case scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
-      let rsakey = ? RsaPrivateKey.random(rng, bits).orError(KeyError)
+      let rsakey = ?RsaPrivateKey.random(rng, bits).orError(CryptoError.KeyError)
       ok(PrivateKey(scheme: scheme, rsakey: rsakey))
     else:
       err(SchemeError)
@@ -209,7 +210,8 @@ proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
       err(SchemeError)
   of PKScheme.ECDSA:
     when supported(PKScheme.ECDSA):
-      let eckey = ? ecnist.EcPrivateKey.random(Secp256r1, rng).orError(KeyError)
+      let eckey =
+        ?ecnist.EcPrivateKey.random(Secp256r1, rng).orError(CryptoError.KeyError)
       ok(PrivateKey(scheme: scheme, eckey: eckey))
     else:
       err(SchemeError)
@@ -220,8 +222,9 @@ proc random*(T: typedesc[PrivateKey], scheme: PKScheme,
     else:
       err(SchemeError)
 
-proc random*(T: typedesc[PrivateKey], rng: var HmacDrbgContext,
-             bits = RsaDefaultKeySize): CryptoResult[PrivateKey] =
+proc random*(
+    T: typedesc[PrivateKey], rng: var HmacDrbgContext, bits = RsaDefaultKeySize
+): CryptoResult[PrivateKey] =
   ## Generate random private key using default public-key cryptography scheme.
   ##
   ## Default public-key cryptography schemes are following order:
@@ -235,17 +238,21 @@ proc random*(T: typedesc[PrivateKey], rng: var HmacDrbgContext,
     let skkey = SkPrivateKey.random(rng)
     ok(PrivateKey(scheme: PKScheme.Secp256k1, skkey: skkey))
   elif supported(PKScheme.RSA):
-    let rsakey = ? RsaPrivateKey.random(rng, bits).orError(KeyError)
+    let rsakey = ?RsaPrivateKey.random(rng, bits).orError(CryptoError.KeyError)
     ok(PrivateKey(scheme: PKScheme.RSA, rsakey: rsakey))
   elif supported(PKScheme.ECDSA):
-    let eckey = ? ecnist.EcPrivateKey.random(Secp256r1, rng).orError(KeyError)
+    let eckey =
+      ?ecnist.EcPrivateKey.random(Secp256r1, rng).orError(CryptoError.KeyError)
     ok(PrivateKey(scheme: PKScheme.ECDSA, eckey: eckey))
   else:
     err(SchemeError)
 
-proc random*(T: typedesc[KeyPair], scheme: PKScheme,
-             rng: var HmacDrbgContext,
-             bits = RsaDefaultKeySize): CryptoResult[KeyPair] =
+proc random*(
+    T: typedesc[KeyPair],
+    scheme: PKScheme,
+    rng: var HmacDrbgContext,
+    bits = RsaDefaultKeySize,
+): CryptoResult[KeyPair] =
   ## Generate random key pair for scheme ``scheme``.
   ##
   ## ``bits`` is number of bits for RSA key, ``bits`` value must be in
@@ -253,39 +260,52 @@ proc random*(T: typedesc[KeyPair], scheme: PKScheme,
   case scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
-      let pair = ? RsaKeyPair.random(rng, bits).orError(KeyError)
-      ok(KeyPair(
-        seckey: PrivateKey(scheme: scheme, rsakey: pair.seckey),
-        pubkey: PublicKey(scheme: scheme, rsakey: pair.pubkey)))
+      let pair = ?RsaKeyPair.random(rng, bits).orError(CryptoError.KeyError)
+      ok(
+        KeyPair(
+          seckey: PrivateKey(scheme: scheme, rsakey: pair.seckey),
+          pubkey: PublicKey(scheme: scheme, rsakey: pair.pubkey),
+        )
+      )
     else:
       err(SchemeError)
   of PKScheme.Ed25519:
     when supported(PKScheme.Ed25519):
       let pair = EdKeyPair.random(rng)
-      ok(KeyPair(
-        seckey: PrivateKey(scheme: scheme, edkey: pair.seckey),
-        pubkey: PublicKey(scheme: scheme, edkey: pair.pubkey)))
+      ok(
+        KeyPair(
+          seckey: PrivateKey(scheme: scheme, edkey: pair.seckey),
+          pubkey: PublicKey(scheme: scheme, edkey: pair.pubkey),
+        )
+      )
     else:
       err(SchemeError)
   of PKScheme.ECDSA:
     when supported(PKScheme.ECDSA):
-      let pair = ? EcKeyPair.random(Secp256r1, rng).orError(KeyError)
-      ok(KeyPair(
-        seckey: PrivateKey(scheme: scheme, eckey: pair.seckey),
-        pubkey: PublicKey(scheme: scheme, eckey: pair.pubkey)))
+      let pair = ?EcKeyPair.random(Secp256r1, rng).orError(CryptoError.KeyError)
+      ok(
+        KeyPair(
+          seckey: PrivateKey(scheme: scheme, eckey: pair.seckey),
+          pubkey: PublicKey(scheme: scheme, eckey: pair.pubkey),
+        )
+      )
     else:
       err(SchemeError)
   of PKScheme.Secp256k1:
     when supported(PKScheme.Secp256k1):
       let pair = SkKeyPair.random(rng)
-      ok(KeyPair(
-        seckey: PrivateKey(scheme: scheme, skkey: pair.seckey),
-        pubkey: PublicKey(scheme: scheme, skkey: pair.pubkey)))
+      ok(
+        KeyPair(
+          seckey: PrivateKey(scheme: scheme, skkey: pair.seckey),
+          pubkey: PublicKey(scheme: scheme, skkey: pair.pubkey),
+        )
+      )
     else:
       err(SchemeError)
 
-proc random*(T: typedesc[KeyPair], rng: var HmacDrbgContext,
-             bits = RsaDefaultKeySize): CryptoResult[KeyPair] =
+proc random*(
+    T: typedesc[KeyPair], rng: var HmacDrbgContext, bits = RsaDefaultKeySize
+): CryptoResult[KeyPair] =
   ## Generate random private pair of keys using default public-key cryptography
   ## scheme.
   ##
@@ -295,24 +315,36 @@ proc random*(T: typedesc[KeyPair], rng: var HmacDrbgContext,
   ## So will be used first available (supported) method.
   when supported(PKScheme.Ed25519):
     let pair = EdKeyPair.random(rng)
-    ok(KeyPair(
-      seckey: PrivateKey(scheme: PKScheme.Ed25519, edkey: pair.seckey),
-      pubkey: PublicKey(scheme: PKScheme.Ed25519, edkey: pair.pubkey)))
+    ok(
+      KeyPair(
+        seckey: PrivateKey(scheme: PKScheme.Ed25519, edkey: pair.seckey),
+        pubkey: PublicKey(scheme: PKScheme.Ed25519, edkey: pair.pubkey),
+      )
+    )
   elif supported(PKScheme.Secp256k1):
     let pair = SkKeyPair.random(rng)
-    ok(KeyPair(
-      seckey: PrivateKey(scheme: PKScheme.Secp256k1, skkey: pair.seckey),
-      pubkey: PublicKey(scheme: PKScheme.Secp256k1, skkey: pair.pubkey)))
+    ok(
+      KeyPair(
+        seckey: PrivateKey(scheme: PKScheme.Secp256k1, skkey: pair.seckey),
+        pubkey: PublicKey(scheme: PKScheme.Secp256k1, skkey: pair.pubkey),
+      )
+    )
   elif supported(PKScheme.RSA):
-    let pair = ? RsaKeyPair.random(rng, bits).orError(KeyError)
-    ok(KeyPair(
-      seckey: PrivateKey(scheme: PKScheme.RSA, rsakey: pair.seckey),
-      pubkey: PublicKey(scheme: PKScheme.RSA, rsakey: pair.pubkey)))
+    let pair = ?RsaKeyPair.random(rng, bits).orError(KeyError)
+    ok(
+      KeyPair(
+        seckey: PrivateKey(scheme: PKScheme.RSA, rsakey: pair.seckey),
+        pubkey: PublicKey(scheme: PKScheme.RSA, rsakey: pair.pubkey),
+      )
+    )
   elif supported(PKScheme.ECDSA):
-    let pair = ? EcKeyPair.random(Secp256r1, rng).orError(KeyError)
-    ok(KeyPair(
-      seckey: PrivateKey(scheme: PKScheme.ECDSA, eckey: pair.seckey),
-      pubkey: PublicKey(scheme: PKScheme.ECDSA, eckey: pair.pubkey)))
+    let pair = ?EcKeyPair.random(Secp256r1, rng).orError(KeyError)
+    ok(
+      KeyPair(
+        seckey: PrivateKey(scheme: PKScheme.ECDSA, eckey: pair.seckey),
+        pubkey: PublicKey(scheme: PKScheme.ECDSA, eckey: pair.pubkey),
+      )
+    )
   else:
     err(SchemeError)
 
@@ -333,7 +365,7 @@ proc getPublicKey*(key: PrivateKey): CryptoResult[PublicKey] =
       err(SchemeError)
   of PKScheme.ECDSA:
     when supported(PKScheme.ECDSA):
-      let eckey = ? key.eckey.getPublicKey().orError(KeyError)
+      let eckey = ?key.eckey.getPublicKey().orError(KeyError)
       ok(PublicKey(scheme: ECDSA, eckey: eckey))
     else:
       err(SchemeError)
@@ -344,8 +376,9 @@ proc getPublicKey*(key: PrivateKey): CryptoResult[PublicKey] =
     else:
       err(SchemeError)
 
-proc toRawBytes*(key: PrivateKey | PublicKey,
-                 data: var openArray[byte]): CryptoResult[int] =
+proc toRawBytes*(
+    key: PrivateKey | PublicKey, data: var openArray[byte]
+): CryptoResult[int] =
   ## Serialize private key ``key`` (using scheme's own serialization) and store
   ## it to ``data``.
   ##
@@ -404,7 +437,7 @@ proc toBytes*(key: PrivateKey, data: var openArray[byte]): CryptoResult[int] =
   ## Returns number of bytes (octets) needed to store private key ``key``.
   var msg = initProtoBuffer()
   msg.write(1, uint64(key.scheme))
-  msg.write(2, ? key.getRawBytes())
+  msg.write(2, ?key.getRawBytes())
   msg.finish()
   var blen = len(msg.buffer)
   if len(data) >= blen:
@@ -418,7 +451,7 @@ proc toBytes*(key: PublicKey, data: var openArray[byte]): CryptoResult[int] =
   ## Returns number of bytes (octets) needed to store public key ``key``.
   var msg = initProtoBuffer()
   msg.write(1, uint64(key.scheme))
-  msg.write(2, ? key.getRawBytes())
+  msg.write(2, ?key.getRawBytes())
   msg.finish()
   var blen = len(msg.buffer)
   if len(data) >= blen and blen > 0:
@@ -438,7 +471,7 @@ proc getBytes*(key: PrivateKey): CryptoResult[seq[byte]] =
   ## serialization).
   var msg = initProtoBuffer()
   msg.write(1, uint64(key.scheme))
-  msg.write(2, ? key.getRawBytes())
+  msg.write(2, ?key.getRawBytes())
   msg.finish()
   ok(msg.buffer)
 
@@ -447,7 +480,7 @@ proc getBytes*(key: PublicKey): CryptoResult[seq[byte]] =
   ## serialization).
   var msg = initProtoBuffer()
   msg.write(1, uint64(key.scheme))
-  msg.write(2, ? key.getRawBytes())
+  msg.write(2, ?key.getRawBytes())
   msg.finish()
   ok(msg.buffer)
 
@@ -455,8 +488,7 @@ proc getBytes*(sig: Signature): seq[byte] =
   ## Return signature ``sig`` in binary form.
   result = sig.data
 
-template initImpl[T: PrivateKey|PublicKey](
-    key: var T, data: openArray[byte]): bool =
+template initImpl[T: PrivateKey | PublicKey](key: var T, data: openArray[byte]): bool =
   ## Initialize private key ``key`` from libp2p's protobuf serialized raw
   ## binary form.
   ##
@@ -469,7 +501,7 @@ template initImpl[T: PrivateKey|PublicKey](
     var pb = initProtoBuffer(@data)
     let r1 = pb.getField(1, id)
     let r2 = pb.getField(2, buffer)
-    if not(r1.get(false) and r2.get(false)):
+    if not (r1.get(false) and r2.get(false)):
       false
     else:
       if cast[int8](id) notin SupportedSchemesInt or len(buffer) <= 0:
@@ -480,7 +512,7 @@ template initImpl[T: PrivateKey|PublicKey](
           var nkey = PrivateKey(scheme: scheme)
         else:
           var nkey = PublicKey(scheme: scheme)
-        case scheme:
+        case scheme
         of PKScheme.RSA:
           when supported(PKScheme.RSA):
             if init(nkey.rsakey, buffer).isOk:
@@ -518,12 +550,13 @@ template initImpl[T: PrivateKey|PublicKey](
           else:
             false
 
-{.push warning[ProveField]:off.}  # https://github.com/nim-lang/Nim/issues/22060
+{.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 =
@@ -534,7 +567,7 @@ proc init*(sig: var Signature, data: openArray[byte]): bool =
     sig.data = @data
     result = true
 
-proc init*[T: PrivateKey|PublicKey](key: var T, data: string): bool =
+proc init*[T: PrivateKey | PublicKey](key: var T, data: string): bool =
   ## Initialize private/public key ``key`` from libp2p's protobuf serialized
   ## hexadecimal string representation.
   ##
@@ -548,26 +581,23 @@ proc init*(sig: var Signature, data: string): bool =
   ## Returns ``true`` on success.
   sig.init(ncrutils.fromHex(data))
 
-proc init*(t: typedesc[PrivateKey],
-           data: openArray[byte]): CryptoResult[PrivateKey] =
+proc init*(t: typedesc[PrivateKey], data: openArray[byte]): CryptoResult[PrivateKey] =
   ## Create new private key from libp2p's protobuf serialized binary form.
   var res: t
   if not res.init(data):
-    err(KeyError)
+    err(CryptoError.KeyError)
   else:
     ok(res)
 
-proc init*(t: typedesc[PublicKey],
-           data: openArray[byte]): CryptoResult[PublicKey] =
+proc init*(t: typedesc[PublicKey], data: openArray[byte]): CryptoResult[PublicKey] =
   ## Create new public key from libp2p's protobuf serialized binary form.
   var res: t
   if not res.init(data):
-    err(KeyError)
+    err(CryptoError.KeyError)
   else:
     ok(res)
 
-proc init*(t: typedesc[Signature],
-           data: openArray[byte]): CryptoResult[Signature] =
+proc init*(t: typedesc[Signature], data: openArray[byte]): CryptoResult[Signature] =
   ## Create new public key from libp2p's protobuf serialized binary form.
   var res: t
   if not res.init(data):
@@ -583,24 +613,28 @@ proc init*(t: typedesc[PrivateKey], data: string): CryptoResult[PrivateKey] =
 when supported(PKScheme.RSA):
   proc init*(t: typedesc[PrivateKey], key: rsa.RsaPrivateKey): PrivateKey =
     PrivateKey(scheme: RSA, rsakey: key)
+
   proc init*(t: typedesc[PublicKey], key: rsa.RsaPublicKey): PublicKey =
     PublicKey(scheme: RSA, rsakey: key)
 
 when supported(PKScheme.Ed25519):
   proc init*(t: typedesc[PrivateKey], key: EdPrivateKey): PrivateKey =
     PrivateKey(scheme: Ed25519, edkey: key)
+
   proc init*(t: typedesc[PublicKey], key: EdPublicKey): PublicKey =
     PublicKey(scheme: Ed25519, edkey: key)
 
 when supported(PKScheme.Secp256k1):
   proc init*(t: typedesc[PrivateKey], key: SkPrivateKey): PrivateKey =
     PrivateKey(scheme: Secp256k1, skkey: key)
+
   proc init*(t: typedesc[PublicKey], key: SkPublicKey): PublicKey =
     PublicKey(scheme: Secp256k1, skkey: key)
 
 when supported(PKScheme.ECDSA):
   proc init*(t: typedesc[PrivateKey], key: ecnist.EcPrivateKey): PrivateKey =
     PrivateKey(scheme: ECDSA, eckey: key)
+
   proc init*(t: typedesc[PublicKey], key: ecnist.EcPublicKey): PublicKey =
     PublicKey(scheme: ECDSA, eckey: key)
 
@@ -669,9 +703,9 @@ proc `==`*(key1, key2: PrivateKey): bool =
   else:
     false
 
-proc `$`*(key: PrivateKey|PublicKey): string =
+proc `$`*(key: PrivateKey | PublicKey): string =
   ## Get string representation of private/public key ``key``.
-  case key.scheme:
+  case key.scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
       $(key.rsakey)
@@ -693,9 +727,9 @@ proc `$`*(key: PrivateKey|PublicKey): string =
     else:
       "unsupported secp256k1 key"
 
-func shortLog*(key: PrivateKey|PublicKey): string =
+func shortLog*(key: PrivateKey | PublicKey): string =
   ## Get short string representation of private/public key ``key``.
-  case key.scheme:
+  case key.scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
       ($key.rsakey).shortLog
@@ -721,16 +755,15 @@ proc `$`*(sig: Signature): string =
   ## Get string representation of signature ``sig``.
   result = ncrutils.toHex(sig.data)
 
-proc sign*(key: PrivateKey,
-           data: openArray[byte]): CryptoResult[Signature] {.gcsafe.} =
+proc sign*(key: PrivateKey, data: openArray[byte]): CryptoResult[Signature] {.gcsafe.} =
   ## Sign message ``data`` using private key ``key`` and return generated
   ## signature in raw binary form.
   var res: Signature
-  case key.scheme:
+  case key.scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
-      let sig = ? key.rsakey.sign(data).orError(SigError)
-      res.data = ? sig.getBytes().orError(SigError)
+      let sig = ?key.rsakey.sign(data).orError(SigError)
+      res.data = ?sig.getBytes().orError(SigError)
       ok(res)
     else:
       err(SchemeError)
@@ -743,8 +776,8 @@ proc sign*(key: PrivateKey,
       err(SchemeError)
   of PKScheme.ECDSA:
     when supported(PKScheme.ECDSA):
-      let sig = ? key.eckey.sign(data).orError(SigError)
-      res.data = ? sig.getBytes().orError(SigError)
+      let sig = ?key.eckey.sign(data).orError(SigError)
+      res.data = ?sig.getBytes().orError(SigError)
       ok(res)
     else:
       err(SchemeError)
@@ -759,7 +792,7 @@ proc sign*(key: PrivateKey,
 proc verify*(sig: Signature, message: openArray[byte], key: PublicKey): bool =
   ## Verify signature ``sig`` using message ``message`` and public key ``key``.
   ## Return ``true`` if message signature is valid.
-  case key.scheme:
+  case key.scheme
   of PKScheme.RSA:
     when supported(PKScheme.RSA):
       var signature: RsaSignature
@@ -797,12 +830,12 @@ proc verify*(sig: Signature, message: openArray[byte], key: PublicKey): bool =
     else:
       false
 
-template makeSecret(buffer, hmactype, secret, seed: untyped) {.dirty.}=
+template makeSecret(buffer, hmactype, secret, seed: untyped) {.dirty.} =
   var ctx: hmactype
   var j = 0
   # We need to strip leading zeros, because Go bigint serialization do it.
   var offset = 0
-  for i in 0..<len(secret):
+  for i in 0 ..< len(secret):
     if secret[i] != 0x00'u8:
       break
     inc(offset)
@@ -823,8 +856,9 @@ template makeSecret(buffer, hmactype, secret, seed: untyped) {.dirty.}=
     ctx.update(a.data)
     a = ctx.finish()
 
-proc stretchKeys*(cipherType: string, hashType: string,
-                  sharedSecret: seq[byte]): Secret =
+proc stretchKeys*(
+    cipherType: string, hashType: string, sharedSecret: seq[byte]
+): Secret =
   ## Expand shared secret to cryptographic keys.
   if cipherType == "AES-128":
     result.ivsize = aes128.sizeBlock
@@ -850,37 +884,57 @@ template goffset*(secret, id, o: untyped): untyped =
   id * (len(secret.data) shr 1) + o
 
 template ivOpenArray*(secret: Secret, id: int): untyped =
-  toOpenArray(secret.data, goffset(secret, id, 0),
-              goffset(secret, id, secret.ivsize - 1))
+  toOpenArray(
+    secret.data, goffset(secret, id, 0), goffset(secret, id, secret.ivsize - 1)
+  )
 
 template keyOpenArray*(secret: Secret, id: int): untyped =
-  toOpenArray(secret.data, goffset(secret, id, secret.ivsize),
-              goffset(secret, id, secret.ivsize + secret.keysize - 1))
+  toOpenArray(
+    secret.data,
+    goffset(secret, id, secret.ivsize),
+    goffset(secret, id, secret.ivsize + secret.keysize - 1),
+  )
 
 template macOpenArray*(secret: Secret, id: int): untyped =
-  toOpenArray(secret.data, goffset(secret, id, secret.ivsize + secret.keysize),
-       goffset(secret, id, secret.ivsize + secret.keysize + secret.macsize - 1))
+  toOpenArray(
+    secret.data,
+    goffset(secret, id, secret.ivsize + secret.keysize),
+    goffset(secret, id, secret.ivsize + secret.keysize + secret.macsize - 1),
+  )
 
 proc iv*(secret: Secret, id: int): seq[byte] {.inline.} =
   ## Get array of bytes with with initial vector.
   result = newSeq[byte](secret.ivsize)
-  var offset = if id == 0: 0 else: (len(secret.data) div 2)
+  var offset =
+    if id == 0:
+      0
+    else:
+      (len(secret.data) div 2)
   copyMem(addr result[0], unsafeAddr secret.data[offset], secret.ivsize)
 
 proc key*(secret: Secret, id: int): seq[byte] {.inline.} =
   result = newSeq[byte](secret.keysize)
-  var offset = if id == 0: 0 else: (len(secret.data) div 2)
+  var offset =
+    if id == 0:
+      0
+    else:
+      (len(secret.data) div 2)
   offset += secret.ivsize
   copyMem(addr result[0], unsafeAddr secret.data[offset], secret.keysize)
 
 proc mac*(secret: Secret, id: int): seq[byte] {.inline.} =
   result = newSeq[byte](secret.macsize)
-  var offset = if id == 0: 0 else: (len(secret.data) div 2)
+  var offset =
+    if id == 0:
+      0
+    else:
+      (len(secret.data) div 2)
   offset += secret.ivsize + secret.keysize
   copyMem(addr result[0], unsafeAddr secret.data[offset], secret.macsize)
 
-proc getOrder*(remotePubkey, localNonce: openArray[byte],
-               localPubkey, remoteNonce: openArray[byte]): CryptoResult[int] =
+proc getOrder*(
+    remotePubkey, localNonce: openArray[byte], localPubkey, remoteNonce: openArray[byte]
+): CryptoResult[int] =
   ## Compare values and calculate `order` parameter.
   var ctx: sha256
   ctx.init()
@@ -891,9 +945,9 @@ proc getOrder*(remotePubkey, localNonce: openArray[byte],
   ctx.update(localPubkey)
   ctx.update(remoteNonce)
   var digest2 = ctx.finish()
-  var mh1 = ? MultiHash.init(multiCodec("sha2-256"), digest1).orError(HashError)
-  var mh2 = ? MultiHash.init(multiCodec("sha2-256"), digest2).orError(HashError)
-  var res = 0;
+  var mh1 = ?MultiHash.init(multiCodec("sha2-256"), digest1).orError(HashError)
+  var mh2 = ?MultiHash.init(multiCodec("sha2-256"), digest2).orError(HashError)
+  var res = 0
   for i in 0 ..< len(mh1.data.buffer):
     res = int(mh1.data.buffer[i]) - int(mh2.data.buffer[i])
     if res != 0:
@@ -926,40 +980,43 @@ proc selectBest*(order: int, p1, p2: string): string =
 
 ## Serialization/Deserialization helpers
 
-proc write*(vb: var VBuffer, pubkey: PublicKey) {.
-     inline, raises: [ResultError[CryptoError]].} =
+proc write*(
+    vb: var VBuffer, pubkey: PublicKey
+) {.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: [ResultError[CryptoError]].} =
+proc write*(
+    vb: var VBuffer, seckey: PrivateKey
+) {.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: [ResultError[CryptoError]].} =
+proc write*(
+    vb: var VBuffer, sig: PrivateKey
+) {.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: [ResultError[CryptoError]].} =
+proc write*[T: PublicKey | PrivateKey](
+    pb: var ProtoBuffer, field: int, key: T
+) {.inline, raises: [ResultError[CryptoError]].} =
   write(pb, field, key.getBytes().tryGet())
 
-proc write*(pb: var ProtoBuffer, field: int, sig: Signature) {.
-     inline, raises: [].} =
+proc write*(pb: var ProtoBuffer, field: int, sig: Signature) {.inline, raises: [].} =
   write(pb, field, sig.getBytes())
 
-proc getField*[T: PublicKey|PrivateKey](pb: ProtoBuffer, field: int,
-                                        value: var T): ProtoResult[bool] =
+proc getField*[T: PublicKey | PrivateKey](
+    pb: ProtoBuffer, field: int, value: var T
+): ProtoResult[bool] =
   ## Deserialize public/private key from protobuf's message ``pb`` using field
   ## index ``field``.
   ##
   ## On success deserialized key will be stored in ``value``.
   var buffer: seq[byte]
   var key: T
-  let res = ? pb.getField(field, buffer)
-  if not(res):
+  let res = ?pb.getField(field, buffer)
+  if not (res):
     ok(false)
   else:
     if key.init(buffer):
@@ -968,16 +1025,15 @@ proc getField*[T: PublicKey|PrivateKey](pb: ProtoBuffer, field: int,
     else:
       err(ProtoError.IncorrectBlob)
 
-proc getField*(pb: ProtoBuffer, field: int,
-               value: var Signature): ProtoResult[bool] =
+proc getField*(pb: ProtoBuffer, field: int, value: var Signature): ProtoResult[bool] =
   ## Deserialize signature from protobuf's message ``pb`` using field index
   ## ``field``.
   ##
   ## On success deserialized signature will be stored in ``value``.
   var buffer: seq[byte]
   var sig: Signature
-  let res = ? pb.getField(field, buffer)
-  if not(res):
+  let res = ?pb.getField(field, buffer)
+  if not (res):
     ok(false)
   else:
     if sig.init(buffer):

libp2p/crypto/curve25519.nim

@@ -22,8 +22,7 @@ import stew/results
 from stew/assign2 import assign
 export results
 
-const
-  Curve25519KeySize* = 32
+const Curve25519KeySize* = 32
 
 type
   Curve25519* = object
@@ -35,12 +34,12 @@ proc intoCurve25519Key*(s: openArray[byte]): Curve25519Key =
   assert s.len == Curve25519KeySize
   assign(result, s)
 
-proc getBytes*(key: Curve25519Key): seq[byte] = @key
+proc getBytes*(key: Curve25519Key): seq[byte] =
+  @key
 
 proc byteswap(buf: var Curve25519Key) {.inline.} =
-  for i in 0..<16:
-    let
-      x = buf[i]
+  for i in 0 ..< 16:
+    let x = buf[i]
     buf[i] = buf[31 - i]
     buf[31 - i] = x
 
@@ -48,31 +47,25 @@ proc mul*(_: type[Curve25519], point: var Curve25519Key, multiplier: Curve25519K
   let defaultBrEc = ecGetDefault()
 
   # multiplier needs to be big-endian
-  var
-    multiplierBs = multiplier
+  var multiplierBs = multiplier
   multiplierBs.byteswap()
-  let
-    res = defaultBrEc.mul(
-      addr point[0],
-      Curve25519KeySize,
-      addr multiplierBs[0],
-      Curve25519KeySize,
-      EC_curve25519)
+  let res = defaultBrEc.mul(
+    addr point[0],
+    Curve25519KeySize,
+    addr multiplierBs[0],
+    Curve25519KeySize,
+    EC_curve25519,
+  )
   assert res == 1
 
 proc mulgen(_: type[Curve25519], dst: var Curve25519Key, point: Curve25519Key) =
   let defaultBrEc = ecGetDefault()
 
-  var
-    rpoint = point
+  var rpoint = point
   rpoint.byteswap()
 
-  let
-    size = defaultBrEc.mulgen(
-      addr dst[0],
-      addr rpoint[0],
-      Curve25519KeySize,
-      EC_curve25519)
+  let size =
+    defaultBrEc.mulgen(addr dst[0], addr rpoint[0], Curve25519KeySize, EC_curve25519)
 
   assert size == Curve25519KeySize
 
@@ -83,7 +76,8 @@ proc random*(_: type[Curve25519Key], rng: var HmacDrbgContext): Curve25519Key =
   var res: Curve25519Key
   let defaultBrEc = ecGetDefault()
   let len = ecKeygen(
-    addr rng.vtable, defaultBrEc, nil, addr res[0], EC_curve25519)
+    PrngClassPointerConst(addr rng.vtable), defaultBrEc, nil, addr res[0], EC_curve25519
+  )
   # Per bearssl documentation, the keygen only fails if the curve is
   # unrecognised -
   doAssert len == Curve25519KeySize, "Could not generate curve"

libp2p/crypto/ecnist.nim

@@ -58,23 +58,22 @@ type
     buffer*: seq[byte]
 
   EcCurveKind* = enum
-    Secp256r1 = EC_secp256r1,
-    Secp384r1 = EC_secp384r1,
+    Secp256r1 = EC_secp256r1
+    Secp384r1 = EC_secp384r1
     Secp521r1 = EC_secp521r1
 
   EcPKI* = EcPrivateKey | EcPublicKey | EcSignature
 
   EcError* = enum
-    EcRngError,
-    EcKeyGenError,
-    EcPublicKeyError,
-    EcKeyIncorrectError,
+    EcRngError
+    EcKeyGenError
+    EcPublicKeyError
+    EcKeyIncorrectError
     EcSignatureError
 
   EcResult*[T] = Result[T, EcError]
 
-const
-  EcSupportedCurvesCint* = @[cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)]
+const EcSupportedCurvesCint* = @[cint(Secp256r1), cint(Secp384r1), cint(Secp521r1)]
 
 proc `-`(x: uint32): uint32 {.inline.} =
   result = (0xFFFF_FFFF'u32 - x) + 1'u32
@@ -88,7 +87,7 @@ proc CMP(x, y: uint32): int32 {.inline.} =
 
 proc EQ0(x: int32): uint32 {.inline.} =
   var q = cast[uint32](x)
-  result = not(q or -q) shr 31
+  result = not (q or -q) shr 31
 
 proc NEQ(x, y: uint32): uint32 {.inline.} =
   var q = cast[uint32](x xor y)
@@ -113,7 +112,7 @@ proc checkScalar(scalar: openArray[byte], curve: cint): uint32 =
   for u in scalar:
     z = z or u
   if len(scalar) == int(orderlen):
-    for i in 0..<len(scalar):
+    for i in 0 ..< len(scalar):
       c = c or (-(cast[int32](EQ0(c))) and CMP(scalar[i], order[i]))
   else:
     c = -1
@@ -126,8 +125,7 @@ proc checkPublic(key: openArray[byte], curve: cint): uint32 =
   var impl = ecGetDefault()
   var orderlen: uint = 0
   discard impl.order(curve, orderlen)
-  result = impl.mul(unsafeAddr ckey[0], uint(len(ckey)),
-                    addr x[0], uint(len(x)), curve)
+  result = impl.mul(unsafeAddr ckey[0], uint(len(ckey)), addr x[0], uint(len(x)), curve)
 
 proc getOffset(pubkey: EcPublicKey): int {.inline.} =
   let o = cast[uint](pubkey.key.q) - cast[uint](unsafeAddr pubkey.buffer[0])
@@ -145,21 +143,15 @@ proc getOffset(seckey: EcPrivateKey): int {.inline.} =
 
 template getPublicKeyLength*(curve: EcCurveKind): int =
   case curve
-  of Secp256r1:
-    PubKey256Length
-  of Secp384r1:
-    PubKey384Length
-  of Secp521r1:
-    PubKey521Length
+  of Secp256r1: PubKey256Length
+  of Secp384r1: PubKey384Length
+  of Secp521r1: PubKey521Length
 
 template getPrivateKeyLength*(curve: EcCurveKind): int =
   case curve
-  of Secp256r1:
-    SecKey256Length
-  of Secp384r1:
-    SecKey384Length
-  of Secp521r1:
-    SecKey521Length
+  of Secp256r1: SecKey256Length
+  of Secp384r1: SecKey384Length
+  of Secp521r1: SecKey521Length
 
 proc copy*[T: EcPKI](dst: var T, src: T): bool =
   ## Copy EC `private key`, `public key` or `signature` ``src`` to ``dst``.
@@ -201,7 +193,7 @@ proc copy*[T: EcPKI](src: T): T {.inline.} =
   if not copy(result, src):
     raise newException(EcKeyIncorrectError, "Incorrect key or signature")
 
-proc clear*[T: EcPKI|EcKeyPair](pki: var T) =
+proc clear*[T: EcPKI | EcKeyPair](pki: var T) =
   ## Wipe and clear EC `private key`, `public key` or `signature` object.
   doAssert(not isNil(pki))
   when T is EcPrivateKey:
@@ -232,8 +224,8 @@ proc clear*[T: EcPKI|EcKeyPair](pki: var T) =
     pki.pubkey.key.curve = 0
 
 proc random*(
-    T: typedesc[EcPrivateKey], kind: EcCurveKind,
-    rng: var HmacDrbgContext): EcResult[EcPrivateKey] =
+    T: typedesc[EcPrivateKey], kind: EcCurveKind, rng: var HmacDrbgContext
+): EcResult[EcPrivateKey] =
   ## Generate new random EC private key using BearSSL's HMAC-SHA256-DRBG
   ## algorithm.
   ##
@@ -241,9 +233,13 @@ proc random*(
   ## secp521r1).
   var ecimp = ecGetDefault()
   var res = new EcPrivateKey
-  if ecKeygen(addr rng.vtable, ecimp,
-                addr res.key, addr res.buffer[0],
-                safeConvert[cint](kind)) == 0:
+  if ecKeygen(
+    PrngClassPointerConst(addr rng.vtable),
+    ecimp,
+    addr res.key,
+    addr res.buffer[0],
+    safeConvert[cint](kind),
+  ) == 0:
     err(EcKeyGenError)
   else:
     ok(res)
@@ -257,8 +253,7 @@ proc getPublicKey*(seckey: EcPrivateKey): EcResult[EcPublicKey] =
   if seckey.key.curve in EcSupportedCurvesCint:
     var res = new EcPublicKey
     assert res.buffer.len > getPublicKeyLength(cast[EcCurveKind](seckey.key.curve))
-    if ecComputePub(ecimp, addr res.key,
-                    addr res.buffer[0], unsafeAddr seckey.key) == 0:
+    if ecComputePub(ecimp, addr res.key, addr res.buffer[0], unsafeAddr seckey.key) == 0:
       err(EcKeyIncorrectError)
     else:
       ok(res)
@@ -266,23 +261,23 @@ proc getPublicKey*(seckey: EcPrivateKey): EcResult[EcPublicKey] =
     err(EcKeyIncorrectError)
 
 proc random*(
-    T: typedesc[EcKeyPair], kind: EcCurveKind,
-    rng: var HmacDrbgContext): EcResult[T] =
+    T: typedesc[EcKeyPair], kind: EcCurveKind, rng: var HmacDrbgContext
+): EcResult[T] =
   ## Generate new random EC private and public keypair using BearSSL's
   ## HMAC-SHA256-DRBG algorithm.
   ##
   ## ``kind`` elliptic curve kind of your choice (secp256r1, secp384r1 or
   ## secp521r1).
   let
-    seckey = ? EcPrivateKey.random(kind, rng)
-    pubkey = ? seckey.getPublicKey()
+    seckey = ?EcPrivateKey.random(kind, rng)
+    pubkey = ?seckey.getPublicKey()
     key = EcKeyPair(seckey: seckey, pubkey: pubkey)
   ok(key)
 
 proc `$`*(seckey: EcPrivateKey): string =
   ## Return string representation of EC private key.
   if isNil(seckey) or seckey.key.curve == 0 or seckey.key.xlen == 0 or
-     len(seckey.buffer) == 0:
+      len(seckey.buffer) == 0:
     result = "Empty or uninitialized ECNIST key"
   else:
     if seckey.key.curve notin EcSupportedCurvesCint:
@@ -298,7 +293,7 @@ proc `$`*(seckey: EcPrivateKey): string =
 proc `$`*(pubkey: EcPublicKey): string =
   ## Return string representation of EC public key.
   if isNil(pubkey) or pubkey.key.curve == 0 or pubkey.key.qlen == 0 or
-     len(pubkey.buffer) == 0:
+      len(pubkey.buffer) == 0:
     result = "Empty or uninitialized ECNIST key"
   else:
     if pubkey.key.curve notin EcSupportedCurvesCint:
@@ -371,7 +366,7 @@ proc toBytes*(seckey: EcPrivateKey, data: var openArray[byte]): EcResult[int] =
     return err(EcKeyIncorrectError)
   if seckey.key.curve in EcSupportedCurvesCint:
     var offset, length: int
-    var pubkey = ? seckey.getPublicKey()
+    var pubkey = ?seckey.getPublicKey()
     var b = Asn1Buffer.init()
     var p = Asn1Composite.init(Asn1Tag.Sequence)
     var c0 = Asn1Composite.init(0)
@@ -387,16 +382,14 @@ proc toBytes*(seckey: EcPrivateKey, data: var openArray[byte]): EcResult[int] =
     if offset < 0:
       return err(EcKeyIncorrectError)
     length = int(pubkey.key.qlen)
-    c1.write(Asn1Tag.BitString,
-             pubkey.buffer.toOpenArray(offset, offset + length - 1))
+    c1.write(Asn1Tag.BitString, pubkey.buffer.toOpenArray(offset, offset + length - 1))
     c1.finish()
     offset = seckey.getOffset()
     if offset < 0:
       return err(EcKeyIncorrectError)
     length = int(seckey.key.xlen)
     p.write(1'u64)
-    p.write(Asn1Tag.OctetString,
-            seckey.buffer.toOpenArray(offset, offset + length - 1))
+    p.write(Asn1Tag.OctetString, seckey.buffer.toOpenArray(offset, offset + length - 1))
     p.write(c0)
     p.write(c1)
     p.finish()
@@ -410,7 +403,6 @@ proc toBytes*(seckey: EcPrivateKey, data: var openArray[byte]): EcResult[int] =
   else:
     err(EcKeyIncorrectError)
 
-
 proc toBytes*(pubkey: EcPublicKey, data: var openArray[byte]): EcResult[int] =
   ## Serialize EC public key ``pubkey`` to ASN.1 DER binary form and store it
   ## to ``data``.
@@ -436,8 +428,7 @@ proc toBytes*(pubkey: EcPublicKey, data: var openArray[byte]): EcResult[int] =
     if offset < 0:
       return err(EcKeyIncorrectError)
     let length = int(pubkey.key.qlen)
-    p.write(Asn1Tag.BitString,
-            pubkey.buffer.toOpenArray(offset, offset + length - 1))
+    p.write(Asn1Tag.BitString, pubkey.buffer.toOpenArray(offset, offset + length - 1))
     p.finish()
     b.write(p)
     b.finish()
@@ -467,9 +458,9 @@ proc getBytes*(seckey: EcPrivateKey): EcResult[seq[byte]] =
     return err(EcKeyIncorrectError)
   if seckey.key.curve in EcSupportedCurvesCint:
     var res = newSeq[byte]()
-    let length = ? seckey.toBytes(res)
+    let length = ?seckey.toBytes(res)
     res.setLen(length)
-    discard ? seckey.toBytes(res)
+    discard ?seckey.toBytes(res)
     ok(res)
   else:
     err(EcKeyIncorrectError)
@@ -480,9 +471,9 @@ proc getBytes*(pubkey: EcPublicKey): EcResult[seq[byte]] =
     return err(EcKeyIncorrectError)
   if pubkey.key.curve in EcSupportedCurvesCint:
     var res = newSeq[byte]()
-    let length = ? pubkey.toBytes(res)
+    let length = ?pubkey.toBytes(res)
     res.setLen(length)
-    discard ? pubkey.toBytes(res)
+    discard ?pubkey.toBytes(res)
     ok(res)
   else:
     err(EcKeyIncorrectError)
@@ -492,9 +483,9 @@ proc getBytes*(sig: EcSignature): EcResult[seq[byte]] =
   if isNil(sig):
     return err(EcSignatureError)
   var res = newSeq[byte]()
-  let length = ? sig.toBytes(res)
+  let length = ?sig.toBytes(res)
   res.setLen(length)
-  discard ? sig.toBytes(res)
+  discard ?sig.toBytes(res)
   ok(res)
 
 proc getRawBytes*(seckey: EcPrivateKey): EcResult[seq[byte]] =
@@ -503,9 +494,9 @@ proc getRawBytes*(seckey: EcPrivateKey): EcResult[seq[byte]] =
     return err(EcKeyIncorrectError)
   if seckey.key.curve in EcSupportedCurvesCint:
     var res = newSeq[byte]()
-    let length = ? seckey.toRawBytes(res)
+    let length = ?seckey.toRawBytes(res)
     res.setLen(length)
-    discard ? seckey.toRawBytes(res)
+    discard ?seckey.toRawBytes(res)
     ok(res)
   else:
     err(EcKeyIncorrectError)
@@ -516,9 +507,9 @@ proc getRawBytes*(pubkey: EcPublicKey): EcResult[seq[byte]] =
     return err(EcKeyIncorrectError)
   if pubkey.key.curve in EcSupportedCurvesCint:
     var res = newSeq[byte]()
-    let length = ? pubkey.toRawBytes(res)
+    let length = ?pubkey.toRawBytes(res)
     res.setLen(length)
-    discard ? pubkey.toRawBytes(res)
+    discard ?pubkey.toRawBytes(res)
     return ok(res)
   else:
     return err(EcKeyIncorrectError)
@@ -528,9 +519,9 @@ proc getRawBytes*(sig: EcSignature): EcResult[seq[byte]] =
   if isNil(sig):
     return err(EcSignatureError)
   var res = newSeq[byte]()
-  let length = ? sig.toBytes(res)
+  let length = ?sig.toBytes(res)
   res.setLen(length)
-  discard ? sig.toBytes(res)
+  discard ?sig.toBytes(res)
   ok(res)
 
 proc `==`*(pubkey1, pubkey2: EcPublicKey): bool =
@@ -550,8 +541,10 @@ proc `==`*(pubkey1, pubkey2: EcPublicKey): bool =
     let op2 = pubkey2.getOffset()
     if op1 == -1 or op2 == -1:
       return false
-    return CT.isEqual(pubkey1.buffer.toOpenArray(op1, pubkey1.key.qlen - 1),
-                      pubkey2.buffer.toOpenArray(op2, pubkey2.key.qlen - 1))
+    return CT.isEqual(
+      pubkey1.buffer.toOpenArray(op1, pubkey1.key.qlen - 1),
+      pubkey2.buffer.toOpenArray(op2, pubkey2.key.qlen - 1),
+    )
 
 proc `==`*(seckey1, seckey2: EcPrivateKey): bool =
   ## Returns ``true`` if both keys ``seckey1`` and ``seckey2`` are equal.
@@ -570,8 +563,10 @@ proc `==`*(seckey1, seckey2: EcPrivateKey): bool =
     let op2 = seckey2.getOffset()
     if op1 == -1 or op2 == -1:
       return false
-    return CT.isEqual(seckey1.buffer.toOpenArray(op1, seckey1.key.xlen - 1),
-                      seckey2.buffer.toOpenArray(op2, seckey2.key.xlen - 1))
+    return CT.isEqual(
+      seckey1.buffer.toOpenArray(op1, seckey1.key.xlen - 1),
+      seckey2.buffer.toOpenArray(op2, seckey2.key.xlen - 1),
+    )
 
 proc `==`*(a, b: EcSignature): bool =
   ## Return ``true`` if both signatures ``sig1`` and ``sig2`` are equal.
@@ -605,26 +600,26 @@ proc init*(key: var EcPrivateKey, data: openArray[byte]): Result[void, Asn1Error
 
   var ab = Asn1Buffer.init(data)
 
-  field = ? ab.read()
+  field = ?ab.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ib = field.getBuffer()
 
-  field = ? ib.read()
+  field = ?ib.read()
 
   if field.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
   if field.vint != 1'u64:
     return err(Asn1Error.Incorrect)
 
-  raw = ? ib.read()
+  raw = ?ib.read()
 
   if raw.kind != Asn1Tag.OctetString:
     return err(Asn1Error.Incorrect)
 
-  oid = ? ib.read()
+  oid = ?ib.read()
 
   if oid.kind != Asn1Tag.Oid:
     return err(Asn1Error.Incorrect)
@@ -658,19 +653,19 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
 
   var ab = Asn1Buffer.init(data)
 
-  field = ? ab.read()
+  field = ?ab.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ib = field.getBuffer()
-  field = ? ib.read()
+  field = ?ib.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ob = field.getBuffer()
-  oid = ? ob.read()
+  oid = ?ob.read()
 
   if oid.kind != Asn1Tag.Oid:
     return err(Asn1Error.Incorrect)
@@ -678,7 +673,7 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
   if oid != Asn1OidEcPublicKey:
     return err(Asn1Error.Incorrect)
 
-  oid = ? ob.read()
+  oid = ?ob.read()
 
   if oid.kind != Asn1Tag.Oid:
     return err(Asn1Error.Incorrect)
@@ -692,7 +687,7 @@ proc init*(pubkey: var EcPublicKey, data: openArray[byte]): Result[void, Asn1Err
   else:
     return err(Asn1Error.Incorrect)
 
-  raw = ? ib.read()
+  raw = ?ib.read()
 
   if raw.kind != Asn1Tag.BitString:
     return err(Asn1Error.Incorrect)
@@ -718,16 +713,14 @@ proc init*(sig: var EcSignature, data: openArray[byte]): Result[void, Asn1Error]
   else:
     err(Asn1Error.Incorrect)
 
-proc init*[T: EcPKI](sospk: var T,
-                     data: string): Result[void, Asn1Error] {.inline.} =
+proc init*[T: EcPKI](sospk: var T, data: string): Result[void, Asn1Error] {.inline.} =
   ## Initialize EC `private key`, `public key` or `signature` ``sospk`` from
   ## ASN.1 DER hexadecimal string representation ``data``.
   ##
   ## Procedure returns ``Asn1Status``.
   sospk.init(ncrutils.fromHex(data))
 
-proc init*(t: typedesc[EcPrivateKey],
-           data: openArray[byte]): EcResult[EcPrivateKey] =
+proc init*(t: typedesc[EcPrivateKey], data: openArray[byte]): EcResult[EcPrivateKey] =
   ## Initialize EC private key from ASN.1 DER binary representation ``data`` and
   ## return constructed object.
   var key: EcPrivateKey
@@ -737,8 +730,7 @@ proc init*(t: typedesc[EcPrivateKey],
   else:
     ok(key)
 
-proc init*(t: typedesc[EcPublicKey],
-           data: openArray[byte]): EcResult[EcPublicKey] =
+proc init*(t: typedesc[EcPublicKey], data: openArray[byte]): EcResult[EcPublicKey] =
   ## Initialize EC public key from ASN.1 DER binary representation ``data`` and
   ## return constructed object.
   var key: EcPublicKey
@@ -748,8 +740,7 @@ proc init*(t: typedesc[EcPublicKey],
   else:
     ok(key)
 
-proc init*(t: typedesc[EcSignature],
-           data: openArray[byte]): EcResult[EcSignature] =
+proc init*(t: typedesc[EcSignature], data: openArray[byte]): EcResult[EcSignature] =
   ## Initialize EC signature from raw binary representation ``data`` and
   ## return constructed object.
   var sig: EcSignature
@@ -832,8 +823,7 @@ proc initRaw*(sig: var EcSignature, data: openArray[byte]): bool =
   ##
   ## Procedure returns ``true`` on success, ``false`` otherwise.
   let length = len(data)
-  if (length == Sig256Length) or (length == Sig384Length) or
-     (length == Sig521Length):
+  if (length == Sig256Length) or (length == Sig384Length) or (length == Sig521Length):
     result = true
   if result:
     sig = new EcSignature
@@ -846,8 +836,9 @@ proc initRaw*[T: EcPKI](sospk: var T, data: string): bool {.inline.} =
   ## Procedure returns ``true`` on success, ``false`` otherwise.
   result = sospk.initRaw(ncrutils.fromHex(data))
 
-proc initRaw*(t: typedesc[EcPrivateKey],
-              data: openArray[byte]): EcResult[EcPrivateKey] =
+proc initRaw*(
+    t: typedesc[EcPrivateKey], data: openArray[byte]
+): EcResult[EcPrivateKey] =
   ## Initialize EC private key from raw binary representation ``data`` and
   ## return constructed object.
   var res: EcPrivateKey
@@ -856,8 +847,7 @@ proc initRaw*(t: typedesc[EcPrivateKey],
   else:
     ok(res)
 
-proc initRaw*(t: typedesc[EcPublicKey],
-              data: openArray[byte]): EcResult[EcPublicKey] =
+proc initRaw*(t: typedesc[EcPublicKey], data: openArray[byte]): EcResult[EcPublicKey] =
   ## Initialize EC public key from raw binary representation ``data`` and
   ## return constructed object.
   var res: EcPublicKey
@@ -866,8 +856,7 @@ proc initRaw*(t: typedesc[EcPublicKey],
   else:
     ok(res)
 
-proc initRaw*(t: typedesc[EcSignature],
-              data: openArray[byte]): EcResult[EcSignature] =
+proc initRaw*(t: typedesc[EcSignature], data: openArray[byte]): EcResult[EcSignature] =
   ## Initialize EC signature from raw binary representation ``data`` and
   ## return constructed object.
   var res: EcSignature
@@ -894,16 +883,19 @@ proc scalarMul*(pub: EcPublicKey, sec: EcPrivateKey): EcPublicKey =
         let poffset = key.getOffset()
         let soffset = sec.getOffset()
         if poffset >= 0 and soffset >= 0:
-          let res = impl.mul(addr key.buffer[poffset],
-                             key.key.qlen,
-                             unsafeAddr sec.buffer[soffset],
-                             sec.key.xlen,
-                             key.key.curve)
+          let res = impl.mul(
+            addr key.buffer[poffset],
+            key.key.qlen,
+            unsafeAddr sec.buffer[soffset],
+            sec.key.xlen,
+            key.key.curve,
+          )
           if res != 0:
             result = key
 
-proc toSecret*(pubkey: EcPublicKey, seckey: EcPrivateKey,
-               data: var openArray[byte]): int =
+proc toSecret*(
+    pubkey: EcPublicKey, seckey: EcPrivateKey, data: var openArray[byte]
+): int =
   ## Calculate ECDHE shared secret using Go's elliptic/curve approach, using
   ## remote public key ``pubkey`` and local private key ``seckey`` and store
   ## shared secret to ``data``.
@@ -939,8 +931,9 @@ proc getSecret*(pubkey: EcPublicKey, seckey: EcPrivateKey): seq[byte] =
     result = newSeq[byte](res)
     copyMem(addr result[0], addr data[0], res)
 
-proc sign*[T: byte|char](seckey: EcPrivateKey,
-                      message: openArray[T]): EcResult[EcSignature] {.gcsafe.} =
+proc sign*[T: byte | char](
+    seckey: EcPrivateKey, message: openArray[T]
+): EcResult[EcSignature] {.gcsafe.} =
   ## Get ECDSA signature of data ``message`` using private key ``seckey``.
   if isNil(seckey):
     return err(EcKeyIncorrectError)
@@ -957,8 +950,8 @@ proc sign*[T: byte|char](seckey: EcPrivateKey,
     else:
       kv.update(addr hc.vtable, nil, 0)
     kv.out(addr hc.vtable, addr hash[0])
-    let res = ecdsaI31SignAsn1(impl, kv, addr hash[0], addr seckey.key,
-                              addr sig.buffer[0])
+    let res =
+      ecdsaI31SignAsn1(impl, kv, addr hash[0], addr seckey.key, addr sig.buffer[0])
     # Clear context with initial value
     kv.init(addr hc.vtable)
     if res != 0:
@@ -969,8 +962,9 @@ proc sign*[T: byte|char](seckey: EcPrivateKey,
   else:
     err(EcKeyIncorrectError)
 
-proc verify*[T: byte|char](sig: EcSignature, message: openArray[T],
-                           pubkey: EcPublicKey): bool {.inline.} =
+proc verify*[T: byte | char](
+    sig: EcSignature, message: openArray[T], pubkey: EcPublicKey
+): bool {.inline.} =
   ## Verify ECDSA signature ``sig`` using public key ``pubkey`` and data
   ## ``message``.
   ##
@@ -988,30 +982,32 @@ proc verify*[T: byte|char](sig: EcSignature, message: openArray[T],
     else:
       kv.update(addr hc.vtable, nil, 0)
     kv.out(addr hc.vtable, addr hash[0])
-    let res = ecdsaI31VrfyAsn1(impl, addr hash[0], uint(len(hash)),
-                               unsafeAddr pubkey.key,
-                               addr sig.buffer[0], uint(len(sig.buffer)))
+    let res = ecdsaI31VrfyAsn1(
+      impl,
+      addr hash[0],
+      uint(len(hash)),
+      unsafeAddr pubkey.key,
+      addr sig.buffer[0],
+      uint(len(sig.buffer)),
+    )
     # 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] =
+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)
+    keypair = ?EcKeyPair.random(Secp256r1, rng)
   elif scheme == Secp384r1:
-    keypair = ? EcKeyPair.random(Secp384r1, rng)
+    keypair = ?EcKeyPair.random(Secp384r1, rng)
   elif scheme == Secp521r1:
-    keypair = ? EcKeyPair.random(Secp521r1, rng)
+    keypair = ?EcKeyPair.random(Secp521r1, rng)
   ok(keypair)
 
-proc ephemeral*(
-    scheme: string, rng: var HmacDrbgContext): EcResult[EcKeyPair] =
+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

libp2p/crypto/hkdf.nim

@@ -16,18 +16,41 @@ import bearssl/[kdf, hash]
 
 type HkdfResult*[len: static int] = array[len, byte]
 
-proc hkdf*[T: sha256; len: static int](_: type[T]; salt, ikm, info: openArray[byte]; outputs: var openArray[HkdfResult[len]]) =
-  var
-    ctx: HkdfContext
+proc hkdf*[T: sha256, len: static int](
+    _: type[T],
+    salt, ikm, info: openArray[byte],
+    outputs: var openArray[HkdfResult[len]],
+) =
+  var ctx: HkdfContext
   hkdfInit(
-    ctx, addr sha256Vtable,
-    if salt.len > 0: unsafeAddr salt[0] else: nil, csize_t(salt.len))
+    ctx,
+    addr sha256Vtable,
+    if salt.len > 0:
+      unsafeAddr salt[0]
+    else:
+      nil
+    ,
+    csize_t(salt.len),
+  )
   hkdfInject(
-    ctx, if ikm.len > 0: unsafeAddr ikm[0] else: nil, csize_t(ikm.len))
+    ctx,
+    if ikm.len > 0:
+      unsafeAddr ikm[0]
+    else:
+      nil
+    ,
+    csize_t(ikm.len),
+  )
   hkdfFlip(ctx)
-  for i in 0..outputs.high:
+  for i in 0 .. outputs.high:
     discard hkdfProduce(
       ctx,
-      if info.len > 0: unsafeAddr info[0]
-      else: nil, csize_t(info.len),
-      addr outputs[i][0], csize_t(outputs[i].len))
+      if info.len > 0:
+        unsafeAddr info[0]
+      else:
+        nil
+      ,
+      csize_t(info.len),
+      addr outputs[i][0],
+      csize_t(outputs[i].len),
+    )

libp2p/crypto/minasn1.nim

@@ -19,35 +19,34 @@ import ../utility
 
 type
   Asn1Error* {.pure.} = enum
-    Overflow,
-    Incomplete,
-    Indefinite,
-    Incorrect,
-    NoSupport,
+    Overflow
+    Incomplete
+    Indefinite
+    Incorrect
+    NoSupport
     Overrun
 
   Asn1Result*[T] = Result[T, Asn1Error]
 
   Asn1Class* {.pure.} = enum
-    Universal = 0x00,
+    Universal = 0x00
     Application = 0x01
     ContextSpecific = 0x02
     Private = 0x03
 
   Asn1Tag* {.pure.} = enum
     ## Protobuf's field types enum
-    NoSupport,
-    Boolean,
-    Integer,
-    BitString,
-    OctetString,
-    Null,
-    Oid,
-    Sequence,
+    NoSupport
+    Boolean
+    Integer
+    BitString
+    OctetString
+    Null
+    Oid
+    Sequence
     Context
 
-  Asn1Buffer* = object of RootObj
-    ## ASN.1's message representation object
+  Asn1Buffer* = object of RootObj ## ASN.1's message representation object
     buffer*: seq[byte]
     offset*: int
     length*: int
@@ -73,37 +72,23 @@ type
     idx*: int
 
 const
-  Asn1OidSecp256r1* = [
-    0x2A'u8, 0x86'u8, 0x48'u8, 0xCE'u8, 0x3D'u8, 0x03'u8, 0x01'u8, 0x07'u8
-  ]
+  Asn1OidSecp256r1* =
+    [0x2A'u8, 0x86'u8, 0x48'u8, 0xCE'u8, 0x3D'u8, 0x03'u8, 0x01'u8, 0x07'u8]
     ## Encoded OID for `secp256r1` curve (1.2.840.10045.3.1.7)
-  Asn1OidSecp384r1* = [
-    0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x22'u8
-  ]
+  Asn1OidSecp384r1* = [0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x22'u8]
     ## Encoded OID for `secp384r1` curve (1.3.132.0.34)
-  Asn1OidSecp521r1* = [
-    0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x23'u8
-  ]
+  Asn1OidSecp521r1* = [0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x23'u8]
     ## Encoded OID for `secp521r1` curve (1.3.132.0.35)
-  Asn1OidSecp256k1* = [
-    0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x0A'u8
-  ]
+  Asn1OidSecp256k1* = [0x2B'u8, 0x81'u8, 0x04'u8, 0x00'u8, 0x0A'u8]
     ## Encoded OID for `secp256k1` curve (1.3.132.0.10)
-  Asn1OidEcPublicKey* = [
-    0x2A'u8, 0x86'u8, 0x48'u8, 0xCE'u8, 0x3D'u8, 0x02'u8, 0x01'u8
-  ]
+  Asn1OidEcPublicKey* = [0x2A'u8, 0x86'u8, 0x48'u8, 0xCE'u8, 0x3D'u8, 0x02'u8, 0x01'u8]
     ## Encoded OID for Elliptic Curve Public Key (1.2.840.10045.2.1)
-  Asn1OidRsaEncryption* = [
-    0x2A'u8, 0x86'u8, 0x48'u8, 0x86'u8, 0xF7'u8, 0x0D'u8, 0x01'u8,
-    0x01'u8, 0x01'u8
-  ]
+  Asn1OidRsaEncryption* =
+    [0x2A'u8, 0x86'u8, 0x48'u8, 0x86'u8, 0xF7'u8, 0x0D'u8, 0x01'u8, 0x01'u8, 0x01'u8]
     ## Encoded OID for RSA Encryption (1.2.840.113549.1.1.1)
-  Asn1True* = [0x01'u8, 0x01'u8, 0xFF'u8]
-    ## Encoded boolean ``TRUE``.
-  Asn1False* = [0x01'u8, 0x01'u8, 0x00'u8]
-    ## Encoded boolean ``FALSE``.
-  Asn1Null* = [0x05'u8, 0x00'u8]
-    ## Encoded ``NULL`` value.
+  Asn1True* = [0x01'u8, 0x01'u8, 0xFF'u8] ## Encoded boolean ``TRUE``.
+  Asn1False* = [0x01'u8, 0x01'u8, 0x00'u8] ## Encoded boolean ``FALSE``.
+  Asn1Null* = [0x05'u8, 0x00'u8] ## Encoded ``NULL`` value.
 
 template toOpenArray*(ab: Asn1Buffer): untyped =
   toOpenArray(ab.buffer, ab.offset, ab.buffer.high)
@@ -120,7 +105,7 @@ template isEmpty*(ab: Asn1Buffer): bool =
 template isEnough*(ab: Asn1Buffer, length: int64): bool =
   len(ab.buffer) >= ab.offset + length
 
-proc len*[T: Asn1Buffer|Asn1Composite](abc: T): int {.inline.} =
+proc len*[T: Asn1Buffer | Asn1Composite](abc: T): int {.inline.} =
   len(abc.buffer) - abc.offset
 
 proc len*(field: Asn1Field): int {.inline.} =
@@ -129,31 +114,22 @@ proc len*(field: Asn1Field): int {.inline.} =
 template getPtr*(field: untyped): pointer =
   cast[pointer](unsafeAddr field.buffer[field.offset])
 
-proc extend*[T: Asn1Buffer|Asn1Composite](abc: var T, length: int) {.inline.} =
+proc extend*[T: Asn1Buffer | Asn1Composite](abc: var T, length: int) {.inline.} =
   ## Extend buffer or composite's internal buffer by ``length`` octets.
   abc.buffer.setLen(len(abc.buffer) + length)
 
 proc code*(tag: Asn1Tag): byte {.inline.} =
   ## Converts Nim ``tag`` enum to ASN.1 tag code.
-  case tag:
-  of Asn1Tag.NoSupport:
-    0x00'u8
-  of Asn1Tag.Boolean:
-    0x01'u8
-  of Asn1Tag.Integer:
-    0x02'u8
-  of Asn1Tag.BitString:
-    0x03'u8
-  of Asn1Tag.OctetString:
-    0x04'u8
-  of Asn1Tag.Null:
-    0x05'u8
-  of Asn1Tag.Oid:
-    0x06'u8
-  of Asn1Tag.Sequence:
-    0x30'u8
-  of Asn1Tag.Context:
-    0xA0'u8
+  case tag
+  of Asn1Tag.NoSupport: 0x00'u8
+  of Asn1Tag.Boolean: 0x01'u8
+  of Asn1Tag.Integer: 0x02'u8
+  of Asn1Tag.BitString: 0x03'u8
+  of Asn1Tag.OctetString: 0x04'u8
+  of Asn1Tag.Null: 0x05'u8
+  of Asn1Tag.Oid: 0x06'u8
+  of Asn1Tag.Sequence: 0x30'u8
+  of Asn1Tag.Context: 0xA0'u8
 
 proc asn1EncodeLength*(dest: var openArray[byte], length: uint64): int =
   ## Encode ASN.1 DER length part of TLV triple and return number of bytes
@@ -182,8 +158,7 @@ proc asn1EncodeLength*(dest: var openArray[byte], length: uint64): int =
     # then 9, so it is safe to convert it to `int`.
     int(res)
 
-proc asn1EncodeInteger*(dest: var openArray[byte],
-                        value: openArray[byte]): int =
+proc asn1EncodeInteger*(dest: var openArray[byte], value: openArray[byte]): int =
   ## Encode big-endian binary representation of integer as ASN.1 DER `INTEGER`
   ## and return number of bytes (octets) used.
   ##
@@ -193,17 +168,16 @@ proc asn1EncodeInteger*(dest: var openArray[byte],
   var buffer: array[16, byte]
   var lenlen = 0
 
-  let offset =
-    block:
-      var o = 0
-      for i in 0 ..< len(value):
-        if value[o] != 0x00:
-          break
-        inc(o)
-      if o < len(value):
-        o
-      else:
-        o - 1
+  let offset = block:
+    var o = 0
+    for i in 0 ..< len(value):
+      if value[o] != 0x00:
+        break
+      inc(o)
+    if o < len(value):
+      o
+    else:
+      o - 1
 
   let destlen =
     if len(value) > 0:
@@ -225,12 +199,10 @@ proc asn1EncodeInteger*(dest: var openArray[byte],
       if value[offset] >= 0x80'u8:
         dest[1 + lenlen] = 0x00'u8
         shift = 2
-      copyMem(addr dest[shift + lenlen], unsafeAddr value[offset],
-              len(value) - offset)
+      copyMem(addr dest[shift + lenlen], unsafeAddr value[offset], len(value) - offset)
   destlen
 
-proc asn1EncodeInteger*[T: SomeUnsignedInt](dest: var openArray[byte],
-                                            value: T): int =
+proc asn1EncodeInteger*[T: SomeUnsignedInt](dest: var openArray[byte], value: T): int =
   ## Encode Nim's unsigned integer as ASN.1 DER `INTEGER` and return number of
   ## bytes (octets) used.
   ##
@@ -265,8 +237,7 @@ proc asn1EncodeNull*(dest: var openArray[byte]): int =
     dest[1] = 0x00'u8
   res
 
-proc asn1EncodeOctetString*(dest: var openArray[byte],
-                            value: openArray[byte]): int =
+proc asn1EncodeOctetString*(dest: var openArray[byte], value: openArray[byte]): int =
   ## Encode array of bytes as ASN.1 DER `OCTET STRING` and return number of
   ## bytes (octets) used.
   ##
@@ -283,8 +254,9 @@ proc asn1EncodeOctetString*(dest: var openArray[byte],
       copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
   res
 
-proc asn1EncodeBitString*(dest: var openArray[byte],
-                          value: openArray[byte], bits = 0): int =
+proc asn1EncodeBitString*(
+    dest: var openArray[byte], value: openArray[byte], bits = 0
+): int =
   ## Encode array of bytes as ASN.1 DER `BIT STRING` and return number of bytes
   ## (octets) used.
   ##
@@ -305,7 +277,7 @@ proc asn1EncodeBitString*(dest: var openArray[byte],
   let bytelen = (bitlen + 7) shr 3
   # Number of unused bits
   let unused = (8 - (bitlen and 7)) and 7
-  let mask = not((1'u8 shl unused) - 1'u8)
+  let mask = not ((1'u8 shl unused) - 1'u8)
   var lenlen = asn1EncodeLength(buffer, uint64(bytelen + 1))
   let res = 1 + lenlen + 1 + len(value)
   if len(dest) >= res:
@@ -319,8 +291,7 @@ proc asn1EncodeBitString*(dest: var openArray[byte],
       dest[2 + lenlen + bytelen - 1] = lastbyte and mask
   res
 
-proc asn1EncodeTag[T: SomeUnsignedInt](dest: var openArray[byte],
-                                       value: T): int =
+proc asn1EncodeTag[T: SomeUnsignedInt](dest: var openArray[byte], value: T): int =
   var v = value
   if value <= cast[T](0x7F):
     if len(dest) >= 1:
@@ -361,8 +332,7 @@ proc asn1EncodeOid*(dest: var openArray[byte], value: openArray[byte]): int =
     copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
   res
 
-proc asn1EncodeSequence*(dest: var openArray[byte],
-                         value: openArray[byte]): int =
+proc asn1EncodeSequence*(dest: var openArray[byte], value: openArray[byte]): int =
   ## Encode ``value`` as ASN.1 DER `SEQUENCE` and return number of bytes
   ## (octets) used.
   ##
@@ -378,8 +348,7 @@ proc asn1EncodeSequence*(dest: var openArray[byte],
     copyMem(addr dest[1 + lenlen], unsafeAddr value[0], len(value))
   res
 
-proc asn1EncodeComposite*(dest: var openArray[byte],
-                          value: Asn1Composite): int =
+proc asn1EncodeComposite*(dest: var openArray[byte], value: Asn1Composite): int =
   ## Encode composite value and return number of bytes (octets) used.
   ##
   ## If length of ``dest`` is less then number of required bytes to encode
@@ -391,12 +360,12 @@ proc asn1EncodeComposite*(dest: var openArray[byte],
   if len(dest) >= res:
     dest[0] = value.tag.code()
     copyMem(addr dest[1], addr buffer[0], lenlen)
-    copyMem(addr dest[1 + lenlen], unsafeAddr value.buffer[0],
-            len(value.buffer))
+    copyMem(addr dest[1 + lenlen], unsafeAddr value.buffer[0], len(value.buffer))
   res
 
-proc asn1EncodeContextTag*(dest: var openArray[byte], value: openArray[byte],
-                           tag: int): int =
+proc asn1EncodeContextTag*(
+    dest: var openArray[byte], value: openArray[byte], tag: int
+): int =
   ## Encode ASN.1 DER `CONTEXT SPECIFIC TAG` ``tag`` for value ``value`` and
   ## return number of bytes (octets) used.
   ##
@@ -432,7 +401,7 @@ proc getLength(ab: var Asn1Buffer): Asn1Result[int] =
       return err(Asn1Error.Overflow)
     if ab.isEnough(octets):
       var lengthU: uint64 = 0
-      for i in 0..<octets:
+      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)
@@ -471,7 +440,7 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
   inclass = false
   while true:
     offset = ab.offset
-    aclass = ? ab.getTag(tag)
+    aclass = ?ab.getTag(tag)
 
     case aclass
     of Asn1Class.ContextSpecific:
@@ -480,9 +449,9 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
       else:
         inclass = true
         ttag = tag
-        tlength = ? ab.getLength()
+        tlength = ?ab.getLength()
     of Asn1Class.Universal:
-      length = ? ab.getLength()
+      length = ?ab.getLength()
 
       if inclass:
         if length >= tlength:
@@ -499,22 +468,26 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         let b = ab.buffer[ab.offset]
         if b != 0xFF'u8 and b != 0x00'u8:
-           return err(Asn1Error.Incorrect)
+          return err(Asn1Error.Incorrect)
 
-        field = Asn1Field(kind: Asn1Tag.Boolean, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: 1, buffer: ab.buffer)
+        field = Asn1Field(
+          kind: Asn1Tag.Boolean,
+          klass: aclass,
+          index: ttag,
+          offset: ab.offset,
+          length: 1,
+          buffer: ab.buffer,
+        )
         field.vbool = (b == 0xFF'u8)
         ab.offset += 1
         return ok(field)
-
       of Asn1Tag.Integer.code():
         # INTEGER
         if length == 0:
           return err(Asn1Error.Incorrect)
 
         if not ab.isEnough(length):
-         return err(Asn1Error.Incomplete)
+          return err(Asn1Error.Incomplete)
 
         # Count number of leading zeroes
         var zc = 0
@@ -526,9 +499,14 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
 
         if zc == 0:
           # Negative or Positive integer
-          field = Asn1Field(kind: Asn1Tag.Integer, klass: aclass,
-                            index: ttag, offset: ab.offset,
-                            length: length, buffer: ab.buffer)
+          field = Asn1Field(
+            kind: Asn1Tag.Integer,
+            klass: aclass,
+            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:
@@ -538,54 +516,68 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
                   field.vint = (field.vint shl 8) or 0xFF'u64
                 else:
                   let offset = ab.offset + i - (8 - length)
-                  field.vint = (field.vint shl 8) or safeConvert[uint64](ab.buffer[offset])
+                  field.vint =
+                    (field.vint shl 8) or safeConvert[uint64](ab.buffer[offset])
           else:
             # Positive integer
             if length <= 8:
               for i in 0 ..< length:
-                field.vint = (field.vint shl 8) or
-                              safeConvert[uint64](ab.buffer[ab.offset + i])
+                field.vint =
+                  (field.vint shl 8) or 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: ab.offset,
-                              length: length, vint: 0'u64,
-                              buffer: ab.buffer)
+            field = Asn1Field(
+              kind: Asn1Tag.Integer,
+              klass: aclass,
+              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: ab.offset + 1,
-                              length: length - 1, buffer: ab.buffer)
+            field = Asn1Field(
+              kind: Asn1Tag.Integer,
+              klass: aclass,
+              index: ttag,
+              offset: ab.offset + 1,
+              length: length - 1,
+              buffer: ab.buffer,
+            )
             if length <= 9:
               for i in 1 ..< length:
-                field.vint = (field.vint shl 8) or
-                              safeConvert[uint64](ab.buffer[ab.offset + i])
+                field.vint =
+                  (field.vint shl 8) or safeConvert[uint64](ab.buffer[ab.offset + i])
             ab.offset += length
             return ok(field)
-
       of Asn1Tag.BitString.code():
         # BIT STRING
         if length == 0:
           # BIT STRING should include `unused` bits field, so length should be
           # bigger then 1.
           return err(Asn1Error.Incorrect)
-
         elif length == 1:
           if ab.buffer[ab.offset] != 0x00'u8:
             return err(Asn1Error.Incorrect)
           else:
             # Zero-length BIT STRING.
-            field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
-                              index: ttag, offset: ab.offset + 1,
-                              length: 0, ubits: 0, buffer: ab.buffer)
+            field = Asn1Field(
+              kind: Asn1Tag.BitString,
+              klass: aclass,
+              index: ttag,
+              offset: ab.offset + 1,
+              length: 0,
+              ubits: 0,
+              buffer: ab.buffer,
+            )
             ab.offset += length
             return ok(field)
-
         else:
           if not ab.isEnough(length):
             return err(Asn1Error.Incomplete)
@@ -600,56 +592,77 @@ proc read*(ab: var Asn1Buffer): Asn1Result[Asn1Field] =
             ## All unused bits should be set to `0`.
             return err(Asn1Error.Incorrect)
 
-          field = Asn1Field(kind: Asn1Tag.BitString, klass: aclass,
-                            index: ttag, offset: ab.offset + 1,
-                            length: length - 1, ubits: safeConvert[int](unused),
-                            buffer: ab.buffer)
+          field = Asn1Field(
+            kind: Asn1Tag.BitString,
+            klass: aclass,
+            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(length):
           return err(Asn1Error.Incomplete)
 
-        field = Asn1Field(kind: Asn1Tag.OctetString, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
+        field = Asn1Field(
+          kind: Asn1Tag.OctetString,
+          klass: aclass,
+          index: ttag,
+          offset: ab.offset,
+          length: length,
+          buffer: ab.buffer,
+        )
         ab.offset += length
         return ok(field)
-
       of Asn1Tag.Null.code():
         # NULL
         if length != 0:
           return err(Asn1Error.Incorrect)
 
-        field = Asn1Field(kind: Asn1Tag.Null, klass: aclass, index: ttag,
-                          offset: ab.offset, length: 0, buffer: ab.buffer)
+        field = Asn1Field(
+          kind: Asn1Tag.Null,
+          klass: aclass,
+          index: ttag,
+          offset: ab.offset,
+          length: 0,
+          buffer: ab.buffer,
+        )
         ab.offset += length
         return ok(field)
-
       of Asn1Tag.Oid.code():
         # OID
         if not ab.isEnough(length):
           return err(Asn1Error.Incomplete)
 
-        field = Asn1Field(kind: Asn1Tag.Oid, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
+        field = Asn1Field(
+          kind: Asn1Tag.Oid,
+          klass: aclass,
+          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(length):
           return err(Asn1Error.Incomplete)
 
-        field = Asn1Field(kind: Asn1Tag.Sequence, klass: aclass,
-                          index: ttag, offset: ab.offset,
-                          length: length, buffer: ab.buffer)
+        field = Asn1Field(
+          kind: Asn1Tag.Sequence,
+          klass: aclass,
+          index: ttag,
+          offset: ab.offset,
+          length: length,
+          buffer: ab.buffer,
+        )
         ab.offset += length
         return ok(field)
-
       else:
         return err(Asn1Error.NoSupport)
 
@@ -672,9 +685,9 @@ proc `==`*(field: Asn1Field, data: openArray[byte]): bool =
     if length > 0:
       if field.length == len(data):
         CT.isEqual(
-          field.buffer.toOpenArray(field.offset,
-                                   field.offset + field.length - 1),
-          data.toOpenArray(0, field.length - 1))
+          field.buffer.toOpenArray(field.offset, field.offset + field.length - 1),
+          data.toOpenArray(0, field.length - 1),
+        )
       else:
         false
     else:
@@ -752,13 +765,14 @@ proc `$`*(field: Asn1Field): string =
     res.add(ncrutils.toHex(field.toOpenArray()))
     res
 
-proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, tag: Asn1Tag) =
+proc write*[T: Asn1Buffer | Asn1Composite](abc: var T, tag: Asn1Tag) =
   ## Write empty value to buffer or composite with ``tag``.
   ##
   ## This procedure must be used to write `NULL`, `0` or empty `BIT STRING`,
   ## `OCTET STRING` types.
-  doAssert(tag in {Asn1Tag.Null, Asn1Tag.Integer, Asn1Tag.BitString,
-                   Asn1Tag.OctetString})
+  doAssert(
+    tag in {Asn1Tag.Null, Asn1Tag.Integer, Asn1Tag.BitString, Asn1Tag.OctetString}
+  )
   var length: int
   if tag == Asn1Tag.Null:
     length = asn1EncodeNull(abc.toOpenArray())
@@ -780,22 +794,23 @@ proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, tag: Asn1Tag) =
     discard asn1EncodeOctetString(abc.toOpenArray(), tmp.toOpenArray(0, -1))
   abc.offset += length
 
-proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, value: uint64) =
+proc write*[T: Asn1Buffer | Asn1Composite](abc: var T, value: uint64) =
   ## Write uint64 ``value`` to buffer or composite as ASN.1 `INTEGER`.
   let length = asn1EncodeInteger(abc.toOpenArray(), value)
   abc.extend(length)
   discard asn1EncodeInteger(abc.toOpenArray(), value)
   abc.offset += length
 
-proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, value: bool) =
+proc write*[T: Asn1Buffer | Asn1Composite](abc: var T, value: bool) =
   ## Write bool ``value`` to buffer or composite as ASN.1 `BOOLEAN`.
   let length = asn1EncodeBoolean(abc.toOpenArray(), value)
   abc.extend(length)
   discard asn1EncodeBoolean(abc.toOpenArray(), value)
   abc.offset += length
 
-proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, tag: Asn1Tag,
-                                         value: openArray[byte], bits = 0) =
+proc write*[T: Asn1Buffer | Asn1Composite](
+    abc: var T, tag: Asn1Tag, value: openArray[byte], bits = 0
+) =
   ## Write array ``value`` using ``tag``.
   ##
   ## This procedure is used to write ASN.1 `INTEGER`, `OCTET STRING`,
@@ -803,8 +818,9 @@ proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, tag: Asn1Tag,
   ##
   ## For `BIT STRING` you can use ``bits`` argument to specify number of used
   ## bits.
-  doAssert(tag in {Asn1Tag.Integer, Asn1Tag.OctetString, Asn1Tag.BitString,
-                 Asn1Tag.Oid})
+  doAssert(
+    tag in {Asn1Tag.Integer, Asn1Tag.OctetString, Asn1Tag.BitString, Asn1Tag.Oid}
+  )
   var length: int
   if tag == Asn1Tag.Integer:
     length = asn1EncodeInteger(abc.toOpenArray(), value)
@@ -824,7 +840,7 @@ proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, tag: Asn1Tag,
     discard asn1EncodeOid(abc.toOpenArray(), value)
   abc.offset += length
 
-proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, value: Asn1Composite) =
+proc write*[T: Asn1Buffer | Asn1Composite](abc: var T, value: Asn1Composite) =
   doAssert(len(value) > 0, "Composite value not finished")
   var length: int
   if value.tag == Asn1Tag.Sequence:
@@ -841,6 +857,6 @@ proc write*[T: Asn1Buffer|Asn1Composite](abc: var T, value: Asn1Composite) =
     discard asn1EncodeContextTag(abc.toOpenArray(), value.buffer, value.idx)
   abc.offset += length
 
-proc finish*[T: Asn1Buffer|Asn1Composite](abc: var T) {.inline.} =
+proc finish*[T: Asn1Buffer | Asn1Composite](abc: var T) {.inline.} =
   ## Finishes buffer or composite and prepares it for writing.
   abc.offset = 0

libp2p/crypto/rsa.nim

@@ -30,32 +30,17 @@ const
   MinKeySize* = 2048
     ## Minimal allowed RSA key size in bits.
     ## https://github.com/libp2p/go-libp2p-core/blob/master/crypto/rsa_common.go#L13
-  DefaultKeySize* = 3072
-    ## Default RSA key size in bits.
+  DefaultKeySize* = 3072 ## Default RSA key size in bits.
 
-  RsaOidSha1* = [
-    byte 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A
-  ]
+  RsaOidSha1* = [byte 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A]
     ## RSA PKCS#1.5 SHA-1 hash object identifier.
-  RsaOidSha224* = [
-    byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
-    0x02, 0x04
-  ]
+  RsaOidSha224* = [byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04]
     ## RSA PKCS#1.5 SHA-224 hash object identifier.
-  RsaOidSha256* = [
-    byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
-    0x02, 0x01
-  ]
+  RsaOidSha256* = [byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01]
     ## RSA PKCS#1.5 SHA-256 hash object identifier.
-  RsaOidSha384* = [
-    byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
-    0x02, 0x02
-  ]
+  RsaOidSha384* = [byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02]
     ## RSA PKCS#1.5 SHA-384 hash object identifier.
-  RsaOidSha512* = [
-    byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
-    0x02, 0x03
-  ]
+  RsaOidSha512* = [byte 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03]
     ## RSA PKCS#1.5 SHA-512 hash object identifier.
 
 type
@@ -79,9 +64,9 @@ type
   RsaKP* = RsaPrivateKey | RsaKeyPair
 
   RsaError* = enum
-    RsaGenError,
-    RsaKeyIncorrectError,
-    RsaSignatureError,
+    RsaGenError
+    RsaKeyIncorrectError
+    RsaSignatureError
     RsaLowSecurityError
 
   RsaResult*[T] = Result[T, RsaError]
@@ -109,15 +94,18 @@ template getArray*(bs, os, ls: untyped): untyped =
 
 template trimZeroes(b: seq[byte], pt, ptlen: untyped) =
   var length = ptlen
-  for i in 0..<length:
+  for i in 0 ..< length:
     if pt[] != byte(0x00):
       break
     pt = cast[ptr byte](cast[uint](pt) + 1)
     ptlen -= 1
 
-proc random*[T: RsaKP](t: typedesc[T], rng: var HmacDrbgContext,
-                       bits = DefaultKeySize,
-                       pubexp = DefaultPublicExponent): RsaResult[T] =
+proc random*[T: RsaKP](
+    t: typedesc[T],
+    rng: var HmacDrbgContext,
+    bits = DefaultKeySize,
+    pubexp = DefaultPublicExponent,
+): RsaResult[T] =
   ## Generate new random RSA private key using BearSSL's HMAC-SHA256-DRBG
   ## algorithm.
   ##
@@ -139,10 +127,15 @@ proc random*[T: RsaKP](t: typedesc[T], rng: var HmacDrbgContext,
 
   var keygen = rsaKeygenGetDefault()
 
-  if keygen(addr rng.vtable,
-            addr res.seck, addr res.buffer[sko],
-            addr res.pubk, addr res.buffer[pko],
-            cuint(bits), pubexp) == 0:
+  if keygen(
+    addr rng.vtable,
+    addr res.seck,
+    addr res.buffer[sko],
+    addr res.pubk,
+    addr res.buffer[pko],
+    cuint(bits),
+    pubexp,
+  ) == 0:
     return err(RsaGenError)
 
   let
@@ -170,9 +163,10 @@ proc copy*[T: RsaPKI](key: T): T =
   doAssert(not isNil(key))
   when T is RsaPrivateKey:
     if len(key.buffer) > 0:
-      let length = key.seck.plen.uint + key.seck.qlen.uint + key.seck.dplen.uint +
-                   key.seck.dqlen.uint + key.seck.iqlen.uint + key.pubk.nlen.uint +
-                   key.pubk.elen.uint + key.pexplen.uint
+      let length =
+        key.seck.plen.uint + key.seck.qlen.uint + key.seck.dplen.uint +
+        key.seck.dqlen.uint + key.seck.iqlen.uint + key.pubk.nlen.uint +
+        key.pubk.elen.uint + key.pexplen.uint
       result = new RsaPrivateKey
       result.buffer = newSeq[byte](length)
       let po: uint = 0
@@ -235,8 +229,7 @@ proc getPublicKey*(key: RsaPrivateKey): RsaPublicKey =
   result.key.n = addr result.buffer[0]
   result.key.e = addr result.buffer[key.pubk.nlen]
   copyMem(addr result.buffer[0], cast[pointer](key.pubk.n), key.pubk.nlen)
-  copyMem(addr result.buffer[key.pubk.nlen], cast[pointer](key.pubk.e),
-          key.pubk.elen)
+  copyMem(addr result.buffer[key.pubk.nlen], cast[pointer](key.pubk.e), key.pubk.elen)
   result.key.nlen = key.pubk.nlen
   result.key.elen = key.pubk.elen
 
@@ -248,7 +241,7 @@ proc pubkey*(pair: RsaKeyPair): RsaPublicKey {.inline.} =
   ## Get RSA public key from pair ``pair``.
   result = cast[RsaPrivateKey](pair).getPublicKey()
 
-proc clear*[T: RsaPKI|RsaKeyPair](pki: var T) =
+proc clear*[T: RsaPKI | RsaKeyPair](pki: var T) =
   ## Wipe and clear EC private key, public key or scalar object.
   doAssert(not isNil(pki))
   when T is RsaPrivateKey:
@@ -292,21 +285,14 @@ proc toBytes*(key: RsaPrivateKey, data: var openArray[byte]): RsaResult[int] =
     var b = Asn1Buffer.init()
     var p = Asn1Composite.init(Asn1Tag.Sequence)
     p.write(0'u64)
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.pubk.n,
-                                      key.pubk.nlen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.pubk.e,
-                                      key.pubk.elen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.pubk.n, key.pubk.nlen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.pubk.e, key.pubk.elen))
     p.write(Asn1Tag.Integer, getArray(key.buffer, key.pexp, key.pexplen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.p,
-                                      key.seck.plen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.q,
-                                      key.seck.qlen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.dp,
-                                      key.seck.dplen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.dq,
-                                      key.seck.dqlen))
-    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.iq,
-                                      key.seck.iqlen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.p, key.seck.plen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.q, key.seck.qlen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.dp, key.seck.dplen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.dq, key.seck.dqlen))
+    p.write(Asn1Tag.Integer, getArray(key.buffer, key.seck.iq, key.seck.iqlen))
     p.finish()
     b.write(p)
     b.finish()
@@ -371,7 +357,7 @@ proc getBytes*(key: RsaPrivateKey): RsaResult[seq[byte]] =
   if isNil(key):
     return err(RsaKeyIncorrectError)
   var res = newSeq[byte](4096)
-  let length = ? key.toBytes(res)
+  let length = ?key.toBytes(res)
   if length > 0:
     res.setLen(length)
     ok(res)
@@ -384,7 +370,7 @@ proc getBytes*(key: RsaPublicKey): RsaResult[seq[byte]] =
   if isNil(key):
     return err(RsaKeyIncorrectError)
   var res = newSeq[byte](4096)
-  let length = ? key.toBytes(res)
+  let length = ?key.toBytes(res)
   if length > 0:
     res.setLen(length)
     ok(res)
@@ -396,7 +382,7 @@ proc getBytes*(sig: RsaSignature): RsaResult[seq[byte]] =
   if isNil(sig):
     return err(RsaSignatureError)
   var res = newSeq[byte](4096)
-  let length = ? sig.toBytes(res)
+  let length = ?sig.toBytes(res)
   if length > 0:
     res.setLen(length)
     ok(res)
@@ -408,20 +394,19 @@ proc init*(key: var RsaPrivateKey, data: openArray[byte]): Result[void, Asn1Erro
   ## ``data``.
   ##
   ## Procedure returns ``Asn1Status``.
-  var
-    field, rawn, rawpube, rawprie, rawp, rawq, rawdp, rawdq, rawiq: Asn1Field
+  var field, rawn, rawpube, rawprie, rawp, rawq, rawdp, rawdq, rawiq: Asn1Field
 
   # Asn1Field is not trivial so avoid too much Result
 
   var ab = Asn1Buffer.init(data)
-  field = ? ab.read()
+  field = ?ab.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ib = field.getBuffer()
 
-  field = ? ib.read()
+  field = ?ib.read()
 
   if field.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
@@ -429,48 +414,48 @@ proc init*(key: var RsaPrivateKey, data: openArray[byte]): Result[void, Asn1Erro
   if field.vint != 0'u64:
     return err(Asn1Error.Incorrect)
 
-  rawn = ? ib.read()
+  rawn = ?ib.read()
 
   if rawn.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawpube = ? ib.read()
+  rawpube = ?ib.read()
 
   if rawpube.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawprie = ? ib.read()
+  rawprie = ?ib.read()
 
   if rawprie.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawp = ? ib.read()
+  rawp = ?ib.read()
 
   if rawp.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawq = ? ib.read()
+  rawq = ?ib.read()
 
   if rawq.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawdp = ? ib.read()
+  rawdp = ?ib.read()
 
   if rawdp.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawdq = ? ib.read()
+  rawdq = ?ib.read()
 
   if rawdq.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawiq = ? ib.read()
+  rawiq = ?ib.read()
 
   if rawiq.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
   if len(rawn) >= (MinKeySize shr 3) and len(rawp) > 0 and len(rawq) > 0 and
-     len(rawdp) > 0 and len(rawdq) > 0 and len(rawiq) > 0:
+      len(rawdp) > 0 and len(rawdq) > 0 and len(rawiq) > 0:
     key = new RsaPrivateKey
     key.buffer = @data
     key.pubk.n = addr key.buffer[rawn.offset]
@@ -502,52 +487,52 @@ proc init*(key: var RsaPublicKey, data: openArray[byte]): Result[void, Asn1Error
   var field, rawn, rawe: Asn1Field
   var ab = Asn1Buffer.init(data)
 
-  field = ? ab.read()
+  field = ?ab.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ib = field.getBuffer()
 
-  field = ? ib.read()
+  field = ?ib.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var ob = field.getBuffer()
 
-  field = ? ob.read()
+  field = ?ob.read()
 
   if field.kind != Asn1Tag.Oid:
     return err(Asn1Error.Incorrect)
   elif field != Asn1OidRsaEncryption:
     return err(Asn1Error.Incorrect)
 
-  field = ? ob.read()
+  field = ?ob.read()
 
   if field.kind != Asn1Tag.Null:
     return err(Asn1Error.Incorrect)
 
-  field = ? ib.read()
+  field = ?ib.read()
 
   if field.kind != Asn1Tag.BitString:
     return err(Asn1Error.Incorrect)
 
   var vb = field.getBuffer()
 
-  field = ? vb.read()
+  field = ?vb.read()
 
   if field.kind != Asn1Tag.Sequence:
     return err(Asn1Error.Incorrect)
 
   var sb = field.getBuffer()
 
-  rawn = ? sb.read()
+  rawn = ?sb.read()
 
   if rawn.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
 
-  rawe = ? sb.read()
+  rawe = ?sb.read()
 
   if rawe.kind != Asn1Tag.Integer:
     return err(Asn1Error.Incorrect)
@@ -575,16 +560,16 @@ proc init*(sig: var RsaSignature, data: openArray[byte]): Result[void, Asn1Error
   else:
     err(Asn1Error.Incorrect)
 
-proc init*[T: RsaPKI](sospk: var T,
-                      data: string): Result[void, Asn1Error] {.inline.} =
+proc init*[T: RsaPKI](sospk: var T, data: string): Result[void, Asn1Error] {.inline.} =
   ## Initialize EC `private key`, `public key` or `scalar` ``sospk`` from
   ## hexadecimal string representation ``data``.
   ##
   ## Procedure returns ``Result[void, Asn1Status]``.
   sospk.init(ncrutils.fromHex(data))
 
-proc init*(t: typedesc[RsaPrivateKey],
-           data: openArray[byte]): RsaResult[RsaPrivateKey] =
+proc init*(
+    t: typedesc[RsaPrivateKey], data: openArray[byte]
+): RsaResult[RsaPrivateKey] =
   ## Initialize RSA private key from ASN.1 DER binary representation ``data``
   ## and return constructed object.
   var res: RsaPrivateKey
@@ -593,8 +578,7 @@ proc init*(t: typedesc[RsaPrivateKey],
   else:
     ok(res)
 
-proc init*(t: typedesc[RsaPublicKey],
-           data: openArray[byte]): RsaResult[RsaPublicKey] =
+proc init*(t: typedesc[RsaPublicKey], data: openArray[byte]): RsaResult[RsaPublicKey] =
   ## Initialize RSA public key from ASN.1 DER binary representation ``data``
   ## and return constructed object.
   var res: RsaPublicKey
@@ -603,8 +587,7 @@ proc init*(t: typedesc[RsaPublicKey],
   else:
     ok(res)
 
-proc init*(t: typedesc[RsaSignature],
-           data: openArray[byte]): RsaResult[RsaSignature] =
+proc init*(t: typedesc[RsaSignature], data: openArray[byte]): RsaResult[RsaSignature] =
   ## Initialize RSA signature from raw binary representation ``data`` and
   ## return constructed object.
   var res: RsaSignature
@@ -631,14 +614,11 @@ proc `$`*(key: RsaPrivateKey): string =
     result.add("\nq   = ")
     result.add(ncrutils.toHex(getArray(key.buffer, key.seck.q, key.seck.qlen)))
     result.add("\ndp  = ")
-    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.dp,
-                                       key.seck.dplen)))
+    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.dp, key.seck.dplen)))
     result.add("\ndq  = ")
-    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.dq,
-                                       key.seck.dqlen)))
+    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.dq, key.seck.dqlen)))
     result.add("\niq  = ")
-    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.iq,
-                                       key.seck.iqlen)))
+    result.add(ncrutils.toHex(getArray(key.buffer, key.seck.iq, key.seck.iqlen)))
     result.add("\npre = ")
     result.add(ncrutils.toHex(getArray(key.buffer, key.pexp, key.pexplen)))
     result.add("\nm   = ")
@@ -684,22 +664,37 @@ proc `==`*(a, b: RsaPrivateKey): bool =
   else:
     if a.seck.nBitlen == b.seck.nBitlen:
       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),
-                            getArray(b.buffer, b.seck.q, b.seck.qlen))
-        let r3 = CT.isEqual(getArray(a.buffer, a.seck.dp, a.seck.dplen),
-                            getArray(b.buffer, b.seck.dp, b.seck.dplen))
-        let r4 = CT.isEqual(getArray(a.buffer, a.seck.dq, a.seck.dqlen),
-                            getArray(b.buffer, b.seck.dq, b.seck.dqlen))
-        let r5 = CT.isEqual(getArray(a.buffer, a.seck.iq, a.seck.iqlen),
-                            getArray(b.buffer, b.seck.iq, b.seck.iqlen))
-        let r6 = CT.isEqual(getArray(a.buffer, a.pexp, a.pexplen),
-                            getArray(b.buffer, b.pexp, b.pexplen))
-        let r7 = CT.isEqual(getArray(a.buffer, a.pubk.n, a.pubk.nlen),
-                            getArray(b.buffer, b.pubk.n, b.pubk.nlen))
-        let r8 = CT.isEqual(getArray(a.buffer, a.pubk.e, a.pubk.elen),
-                            getArray(b.buffer, b.pubk.e, b.pubk.elen))
+        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),
+          getArray(b.buffer, b.seck.q, b.seck.qlen),
+        )
+        let r3 = CT.isEqual(
+          getArray(a.buffer, a.seck.dp, a.seck.dplen),
+          getArray(b.buffer, b.seck.dp, b.seck.dplen),
+        )
+        let r4 = CT.isEqual(
+          getArray(a.buffer, a.seck.dq, a.seck.dqlen),
+          getArray(b.buffer, b.seck.dq, b.seck.dqlen),
+        )
+        let r5 = CT.isEqual(
+          getArray(a.buffer, a.seck.iq, a.seck.iqlen),
+          getArray(b.buffer, b.seck.iq, b.seck.iqlen),
+        )
+        let r6 = CT.isEqual(
+          getArray(a.buffer, a.pexp, a.pexplen), getArray(b.buffer, b.pexp, b.pexplen)
+        )
+        let r7 = CT.isEqual(
+          getArray(a.buffer, a.pubk.n, a.pubk.nlen),
+          getArray(b.buffer, b.pubk.n, b.pubk.nlen),
+        )
+        let r8 = CT.isEqual(
+          getArray(a.buffer, a.pubk.e, a.pubk.elen),
+          getArray(b.buffer, b.pubk.e, b.pubk.elen),
+        )
         r1 and r2 and r3 and r4 and r5 and r6 and r7 and r8
       else:
         true
@@ -737,14 +732,17 @@ proc `==`*(a, b: RsaPublicKey): bool =
   elif isNil(b) and (not isNil(a)):
     false
   else:
-    let r1 = CT.isEqual(getArray(a.buffer, a.key.n, a.key.nlen),
-                        getArray(b.buffer, b.key.n, b.key.nlen))
-    let r2 = CT.isEqual(getArray(a.buffer, a.key.e, a.key.elen),
-                        getArray(b.buffer, b.key.e, b.key.elen))
+    let r1 = CT.isEqual(
+      getArray(a.buffer, a.key.n, a.key.nlen), getArray(b.buffer, b.key.n, b.key.nlen)
+    )
+    let r2 = CT.isEqual(
+      getArray(a.buffer, a.key.e, a.key.elen), getArray(b.buffer, b.key.e, b.key.elen)
+    )
     (r1 and r2)
 
-proc sign*[T: byte|char](key: RsaPrivateKey,
-                         message: openArray[T]): RsaResult[RsaSignature] {.gcsafe.} =
+proc sign*[T: byte | char](
+    key: RsaPrivateKey, message: openArray[T]
+): RsaResult[RsaSignature] {.gcsafe.} =
   ## Get RSA PKCS1.5 signature of data ``message`` using SHA256 and private
   ## key ``key``.
   if isNil(key):
@@ -763,16 +761,16 @@ proc sign*[T: byte|char](key: RsaPrivateKey,
     kv.update(addr hc.vtable, nil, 0)
   kv.out(addr hc.vtable, addr hash[0])
   var oid = RsaOidSha256
-  let implRes = impl(addr oid[0],
-                 addr hash[0], uint(len(hash)),
-                 addr key.seck, addr res.buffer[0])
+  let implRes =
+    impl(addr oid[0], addr hash[0], uint(len(hash)), addr key.seck, addr res.buffer[0])
   if implRes == 0:
     err(RsaSignatureError)
   else:
     ok(res)
 
-proc verify*[T: byte|char](sig: RsaSignature, message: openArray[T],
-                           pubkey: RsaPublicKey): bool {.inline.} =
+proc verify*[T: byte | char](
+    sig: RsaSignature, message: openArray[T], pubkey: RsaPublicKey
+): bool {.inline.} =
   ## Verify RSA signature ``sig`` using public key ``pubkey`` and data
   ## ``message``.
   ##
@@ -792,8 +790,13 @@ proc verify*[T: byte|char](sig: RsaSignature, message: openArray[T],
       kv.update(addr hc.vtable, nil, 0)
     kv.out(addr hc.vtable, addr hash[0])
     var oid = RsaOidSha256
-    let res = impl(addr sig.buffer[0], uint(len(sig.buffer)),
-                   addr oid[0],
-                   uint(len(check)), addr pubkey.key, addr check[0])
+    let res = impl(
+      addr sig.buffer[0],
+      uint(len(sig.buffer)),
+      addr oid[0],
+      uint(len(check)),
+      addr pubkey.key,
+      addr check[0],
+    )
     if res == 1:
       result = equalMem(addr check[0], addr hash[0], len(hash))

libp2p/crypto/secp.nim

@@ -10,20 +10,15 @@
 {.push raises: [].}
 
 import bearssl/rand
-import
-  secp256k1,
-  stew/[byteutils, results],
-  nimcrypto/[hash, sha2]
+import secp256k1, stew/[byteutils, results], nimcrypto/[hash, sha2]
 
 export sha2, results, rand
 
 const
-  SkRawPrivateKeySize* = 256 div 8
-    ## Size of private key in octets (bytes)
+  SkRawPrivateKeySize* = 256 div 8 ## Size of private key in octets (bytes)
   SkRawSignatureSize* = SkRawPrivateKeySize * 2 + 1
     ## Size of signature in octets (bytes)
-  SkRawPublicKeySize* = SkRawPrivateKeySize + 1
-    ## Size of public key in octets (bytes)
+  SkRawPublicKeySize* = SkRawPrivateKeySize + 1 ## Size of public key in octets (bytes)
 
 # This is extremely confusing but it's to avoid.. confusion between Eth standard and Secp standard
 type
@@ -56,31 +51,31 @@ template pubkey*(v: SkKeyPair): SkPublicKey =
 proc init*(key: var SkPrivateKey, data: openArray[byte]): SkResult[void] =
   ## Initialize Secp256k1 `private key` ``key`` from raw binary
   ## representation ``data``.
-  key = SkPrivateKey(? secp256k1.SkSecretKey.fromRaw(data))
+  key = SkPrivateKey(?secp256k1.SkSecretKey.fromRaw(data))
   ok()
 
 proc init*(key: var SkPrivateKey, data: string): SkResult[void] =
   ## Initialize Secp256k1 `private key` ``key`` from hexadecimal string
   ## representation ``data``.
-  key = SkPrivateKey(? secp256k1.SkSecretKey.fromHex(data))
+  key = SkPrivateKey(?secp256k1.SkSecretKey.fromHex(data))
   ok()
 
 proc init*(key: var SkPublicKey, data: openArray[byte]): SkResult[void] =
   ## Initialize Secp256k1 `public key` ``key`` from raw binary
   ## representation ``data``.
-  key = SkPublicKey(? secp256k1.SkPublicKey.fromRaw(data))
+  key = SkPublicKey(?secp256k1.SkPublicKey.fromRaw(data))
   ok()
 
 proc init*(key: var SkPublicKey, data: string): SkResult[void] =
   ## Initialize Secp256k1 `public key` ``key`` from hexadecimal string
   ## representation ``data``.
-  key = SkPublicKey(? secp256k1.SkPublicKey.fromHex(data))
+  key = SkPublicKey(?secp256k1.SkPublicKey.fromHex(data))
   ok()
 
 proc init*(sig: var SkSignature, data: openArray[byte]): SkResult[void] =
   ## Initialize Secp256k1 `signature` ``sig`` from raw binary
   ## representation ``data``.
-  sig = SkSignature(? secp256k1.SkSignature.fromDer(data))
+  sig = SkSignature(?secp256k1.SkSignature.fromDer(data))
   ok()
 
 proc init*(sig: var SkSignature, data: string): SkResult[void] =
@@ -151,7 +146,7 @@ proc toBytes*(key: SkPrivateKey, data: var openArray[byte]): SkResult[int] =
   ## Procedure returns number of bytes (octets) needed to store
   ## Secp256k1 private key.
   if len(data) >= SkRawPrivateKeySize:
-    data[0..<SkRawPrivateKeySize] = SkSecretKey(key).toRaw()
+    data[0 ..< SkRawPrivateKeySize] = SkSecretKey(key).toRaw()
     ok(SkRawPrivateKeySize)
   else:
     err("secp: Not enough bytes")
@@ -163,7 +158,7 @@ proc toBytes*(key: SkPublicKey, data: var openArray[byte]): SkResult[int] =
   ## Procedure returns number of bytes (octets) needed to store
   ## Secp256k1 public key.
   if len(data) >= SkRawPublicKeySize:
-    data[0..<SkRawPublicKeySize] = secp256k1.SkPublicKey(key).toRawCompressed()
+    data[0 ..< SkRawPublicKeySize] = secp256k1.SkPublicKey(key).toRawCompressed()
     ok(SkRawPublicKeySize)
   else:
     err("secp: Not enough bytes")
@@ -190,22 +185,28 @@ proc getBytes*(sig: SkSignature): seq[byte] {.inline.} =
   let length = toBytes(sig, result)
   result.setLen(length)
 
-proc sign*[T: byte|char](key: SkPrivateKey, msg: openArray[T]): SkSignature =
+proc sign*[T: byte | char](key: SkPrivateKey, msg: openArray[T]): SkSignature =
   ## Sign message `msg` using private key `key` and return signature object.
   let h = sha256.digest(msg)
   SkSignature(sign(SkSecretKey(key), SkMessage(h.data)))
 
-proc verify*[T: byte|char](sig: SkSignature, msg: openArray[T],
-                           key: SkPublicKey): bool =
+proc verify*[T: byte | char](
+    sig: SkSignature, msg: openArray[T], key: SkPublicKey
+): bool =
   let h = sha256.digest(msg)
   verify(secp256k1.SkSignature(sig), SkMessage(h.data), secp256k1.SkPublicKey(key))
 
-func clear*(key: var SkPrivateKey) = clear(secp256k1.SkSecretKey(key))
+func clear*(key: var SkPrivateKey) =
+  clear(secp256k1.SkSecretKey(key))
 
-func `$`*(key: SkPrivateKey): string = $secp256k1.SkSecretKey(key)
-func `$`*(key: SkPublicKey): string = $secp256k1.SkPublicKey(key)
-func `$`*(key: SkSignature): string = $secp256k1.SkSignature(key)
-func `$`*(key: SkKeyPair): string = $secp256k1.SkKeyPair(key)
+func `$`*(key: SkPrivateKey): string =
+  $secp256k1.SkSecretKey(key)
+func `$`*(key: SkPublicKey): string =
+  $secp256k1.SkPublicKey(key)
+func `$`*(key: SkSignature): string =
+  $secp256k1.SkSignature(key)
+func `$`*(key: SkKeyPair): string =
+  $secp256k1.SkKeyPair(key)
 
 func `==`*(a, b: SkPrivateKey): bool =
   secp256k1.SkSecretKey(a) == secp256k1.SkSecretKey(b)

libp2p/daemon/daemonapi.nim

@@ -16,8 +16,7 @@ import ../varint, ../multiaddress, ../multicodec, ../cid, ../peerid
 import ../wire, ../multihash, ../protobuf/minprotobuf, ../errors
 import ../crypto/crypto, ../utility
 
-export
-  peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors
+export peerid, multiaddress, multicodec, multihash, cid, crypto, wire, errors
 
 when not defined(windows):
   import posix
@@ -32,83 +31,93 @@ const
 
 type
   IpfsLogLevel* {.pure.} = enum
-    Critical, Error, Warning, Notice, Info, Debug, Trace
+    Critical
+    Error
+    Warning
+    Notice
+    Info
+    Debug
+    Trace
 
   RequestType* {.pure.} = enum
-    IDENTIFY = 0,
-    CONNECT = 1,
-    STREAM_OPEN = 2,
-    STREAM_HANDLER = 3,
-    DHT = 4,
-    LIST_PEERS = 5,
-    CONNMANAGER = 6,
+    IDENTIFY = 0
+    CONNECT = 1
+    STREAM_OPEN = 2
+    STREAM_HANDLER = 3
+    DHT = 4
+    LIST_PEERS = 5
+    CONNMANAGER = 6
     DISCONNECT = 7
     PUBSUB = 8
 
   DHTRequestType* {.pure.} = enum
-    FIND_PEER = 0,
-    FIND_PEERS_CONNECTED_TO_PEER = 1,
-    FIND_PROVIDERS = 2,
-    GET_CLOSEST_PEERS = 3,
-    GET_PUBLIC_KEY = 4,
-    GET_VALUE = 5,
-    SEARCH_VALUE = 6,
-    PUT_VALUE = 7,
+    FIND_PEER = 0
+    FIND_PEERS_CONNECTED_TO_PEER = 1
+    FIND_PROVIDERS = 2
+    GET_CLOSEST_PEERS = 3
+    GET_PUBLIC_KEY = 4
+    GET_VALUE = 5
+    SEARCH_VALUE = 6
+    PUT_VALUE = 7
     PROVIDE = 8
 
   ConnManagerRequestType* {.pure.} = enum
-    TAG_PEER = 0,
-    UNTAG_PEER = 1,
+    TAG_PEER = 0
+    UNTAG_PEER = 1
     TRIM = 2
 
   PSRequestType* {.pure.} = enum
-    GET_TOPICS = 0,
-    LIST_PEERS = 1,
-    PUBLISH = 2,
+    GET_TOPICS = 0
+    LIST_PEERS = 1
+    PUBLISH = 2
     SUBSCRIBE = 3
 
   ResponseKind* = enum
-    Malformed,
-    Error,
+    Malformed
+    Error
     Success
 
   ResponseType* {.pure.} = enum
-    ERROR = 2,
-    STREAMINFO = 3,
-    IDENTITY = 4,
-    DHT = 5,
+    ERROR = 2
+    STREAMINFO = 3
+    IDENTITY = 4
+    DHT = 5
     PEERINFO = 6
     PUBSUB = 7
 
   DHTResponseType* {.pure.} = enum
-    BEGIN = 0,
-    VALUE = 1,
+    BEGIN = 0
+    VALUE = 1
     END = 2
 
   MultiProtocol* = string
   DHTValue* = seq[byte]
 
   P2PStreamFlags* {.pure.} = enum
-    None, Closed, Inbound, Outbound
+    None
+    Closed
+    Inbound
+    Outbound
 
   P2PDaemonFlags* = enum
-    DHTClient,     ## Start daemon in DHT client mode
-    DHTFull,       ## Start daemon with full DHT support
-    Bootstrap,     ## Start daemon with bootstrap
-    WaitBootstrap, ## Start daemon with bootstrap and wait until daemon
-                   ## establish connection to at least 2 peers
-    PSFloodSub,    ## Enable `FloodSub` protocol in daemon
-    PSGossipSub,   ## Enable `GossipSub` protocol in daemon
-    PSNoSign,      ## Disable pubsub message signing (default true)
-    PSStrictSign,  ## Force strict checking pubsub message signature
-    NATPortMap,    ## Force daemon to use NAT-PMP.
-    AutoNAT,       ## Force daemon to use AutoNAT.
-    AutoRelay,     ## Enables autorelay mode.
-    RelayActive,   ## Enables active mode for relay.
-    RelayDiscovery,## Enables passive discovery for relay.
-    RelayHop,      ## Enables hop for relay.
-    NoInlinePeerId,## Disable inlining of peer ID (not yet in #master).
-    NoProcessCtrl  ## Process was not spawned.
+    DHTClient ## Start daemon in DHT client mode
+    DHTFull ## Start daemon with full DHT support
+    Bootstrap ## Start daemon with bootstrap
+    WaitBootstrap
+      ## Start daemon with bootstrap and wait until daemon
+      ## establish connection to at least 2 peers
+    PSFloodSub ## Enable `FloodSub` protocol in daemon
+    PSGossipSub ## Enable `GossipSub` protocol in daemon
+    PSNoSign ## Disable pubsub message signing (default true)
+    PSStrictSign ## Force strict checking pubsub message signature
+    NATPortMap ## Force daemon to use NAT-PMP.
+    AutoNAT ## Force daemon to use AutoNAT.
+    AutoRelay ## Enables autorelay mode.
+    RelayActive ## Enables active mode for relay.
+    RelayDiscovery ## Enables passive discovery for relay.
+    RelayHop ## Enables hop for relay.
+    NoInlinePeerId ## Disable inlining of peer ID (not yet in #master).
+    NoProcessCtrl ## Process was not spawned.
 
   P2PStream* = ref object
     flags*: set[P2PStreamFlags]
@@ -121,8 +130,7 @@ type
     server*: StreamServer
     address*: MultiAddress
 
-  DaemonAPI* = ref object
-    # pool*: TransportPool
+  DaemonAPI* = ref object # pool*: TransportPool
     flags*: set[P2PDaemonFlags]
     address*: MultiAddress
     pattern*: string
@@ -149,11 +157,12 @@ type
     signature*: Signature
     key*: PublicKey
 
-  P2PStreamCallback* = proc(api: DaemonAPI,
-                            stream: P2PStream): Future[void] {.gcsafe, raises: [CatchableError].}
-  P2PPubSubCallback* = proc(api: DaemonAPI,
-                            ticket: PubsubTicket,
-                            message: PubSubMessage): Future[bool] {.gcsafe, raises: [CatchableError].}
+  P2PStreamCallback* = proc(api: DaemonAPI, stream: P2PStream): Future[void] {.
+    gcsafe, raises: [CatchableError]
+  .}
+  P2PPubSubCallback* = proc(
+    api: DaemonAPI, ticket: PubsubTicket, message: PubSubMessage
+  ): Future[bool] {.gcsafe, async: (raises: [CatchableError]).}
 
   DaemonError* = object of LPError
   DaemonRemoteError* = object of DaemonError
@@ -161,7 +170,8 @@ type
 
 var daemonsCount {.threadvar.}: int
 
-chronicles.formatIt(PeerInfo): shortLog(it)
+chronicles.formatIt(PeerInfo):
+  shortLog(it)
 
 proc requestIdentity(): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
@@ -170,9 +180,9 @@ proc requestIdentity(): ProtoBuffer =
   result.write(1, safeConvert[uint](RequestType.IDENTIFY))
   result.finish()
 
-proc requestConnect(peerid: PeerId,
-                    addresses: openArray[MultiAddress],
-                    timeout = 0): ProtoBuffer =
+proc requestConnect(
+    peerid: PeerId, addresses: openArray[MultiAddress], timeout = 0
+): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
   ## Processing function `doConnect(req *pb.Request)`.
   result = initProtoBuffer({WithVarintLength})
@@ -196,9 +206,9 @@ proc requestDisconnect(peerid: PeerId): ProtoBuffer =
   result.write(7, msg)
   result.finish()
 
-proc requestStreamOpen(peerid: PeerId,
-                       protocols: openArray[string],
-                       timeout = 0): ProtoBuffer =
+proc requestStreamOpen(
+    peerid: PeerId, protocols: openArray[string], timeout = 0
+): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
   ## Processing function `doStreamOpen(req *pb.Request)`.
   result = initProtoBuffer({WithVarintLength})
@@ -212,8 +222,9 @@ proc requestStreamOpen(peerid: PeerId,
   result.write(3, msg)
   result.finish()
 
-proc requestStreamHandler(address: MultiAddress,
-                          protocols: openArray[MultiProtocol]): ProtoBuffer =
+proc requestStreamHandler(
+    address: MultiAddress, protocols: openArray[MultiProtocol]
+): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/conn.go
   ## Processing function `doStreamHandler(req *pb.Request)`.
   result = initProtoBuffer({WithVarintLength})
@@ -247,8 +258,7 @@ proc requestDHTFindPeer(peer: PeerId, timeout = 0): ProtoBuffer =
   result.write(5, msg)
   result.finish()
 
-proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
-                                        timeout = 0): ProtoBuffer =
+proc requestDHTFindPeersConnectedToPeer(peer: PeerId, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTFindPeersConnectedToPeer(req *pb.DHTRequest)`.
   let msgid = safeConvert[uint](DHTRequestType.FIND_PEERS_CONNECTED_TO_PEER)
@@ -263,8 +273,7 @@ proc requestDHTFindPeersConnectedToPeer(peer: PeerId,
   result.write(5, msg)
   result.finish()
 
-proc requestDHTFindProviders(cid: Cid,
-                             count: uint32, timeout = 0): ProtoBuffer =
+proc requestDHTFindProviders(cid: Cid, count: uint32, timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTFindProviders(req *pb.DHTRequest)`.
   let msgid = safeConvert[uint](DHTRequestType.FIND_PROVIDERS)
@@ -340,8 +349,7 @@ proc requestDHTSearchValue(key: string, timeout = 0): ProtoBuffer =
   result.write(5, msg)
   result.finish()
 
-proc requestDHTPutValue(key: string, value: openArray[byte],
-                        timeout = 0): ProtoBuffer =
+proc requestDHTPutValue(key: string, value: openArray[byte], timeout = 0): ProtoBuffer =
   ## https://github.com/libp2p/go-libp2p-daemon/blob/master/dht.go
   ## Processing function `doDHTPutValue(req *pb.DHTRequest)`.
   let msgid = safeConvert[uint](DHTRequestType.PUT_VALUE)
@@ -484,7 +492,7 @@ proc recvMessage(conn: StreamTransport): Future[seq[byte]] {.async.} =
     res: VarintResult[void]
   var buffer = newSeq[byte](10)
   try:
-    for i in 0..<len(buffer):
+    for i in 0 ..< len(buffer):
       await conn.readExactly(addr buffer[i], 1)
       res = PB.getUVarint(buffer.toOpenArray(0, i), length, size)
       if res.isOk():
@@ -500,8 +508,7 @@ proc recvMessage(conn: StreamTransport): Future[seq[byte]] {.async.} =
 
   result = buffer
 
-proc newConnection*(api: DaemonAPI): Future[StreamTransport]
-  {.raises: [LPError].} =
+proc newConnection*(api: DaemonAPI): Future[StreamTransport] {.raises: [LPError].} =
   result = connect(api.address)
 
 proc closeConnection*(api: DaemonAPI, transp: StreamTransport): Future[void] =
@@ -516,16 +523,18 @@ proc socketExists(address: MultiAddress): Future[bool] {.async.} =
     result = false
 
 when defined(windows):
-  proc getCurrentProcessId(): uint32 {.stdcall, dynlib: "kernel32",
-                                       importc: "GetCurrentProcessId".}
+  proc getCurrentProcessId(): uint32 {.
+    stdcall, dynlib: "kernel32", importc: "GetCurrentProcessId"
+  .}
+
   proc getProcessId(): int =
     result = cast[int](getCurrentProcessId())
+
 else:
   proc getProcessId(): int =
     result = int(posix.getpid())
 
-proc getSocket(pattern: string,
-               count: ptr int): Future[MultiAddress] {.async.} =
+proc getSocket(pattern: string, count: ptr int): Future[MultiAddress] {.async.} =
   var sockname = ""
   var pid = $getProcessId()
   sockname = pattern % [pid, $(count[])]
@@ -561,21 +570,23 @@ proc copyEnv(): StringTableRef =
   for key, val in envPairs():
     result[key] = val
 
-proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
-                   bootstrapNodes: seq[string] = @[],
-                   id: string = "",
-                   hostAddresses: seq[MultiAddress] = @[],
-                   announcedAddresses: seq[MultiAddress] = @[],
-                   daemon = DefaultDaemonFile,
-                   sockpath = "",
-                   patternSock = "",
-                   patternHandler = "",
-                   poolSize = 10,
-                   gossipsubHeartbeatInterval = 0,
-                   gossipsubHeartbeatDelay = 0,
-                   peersRequired = 2,
-                   logFile = "",
-                   logLevel = IpfsLogLevel.Debug): Future[DaemonAPI] {.async.} =
+proc newDaemonApi*(
+    flags: set[P2PDaemonFlags] = {},
+    bootstrapNodes: seq[string] = @[],
+    id: string = "",
+    hostAddresses: seq[MultiAddress] = @[],
+    announcedAddresses: seq[MultiAddress] = @[],
+    daemon = DefaultDaemonFile,
+    sockpath = "",
+    patternSock = "",
+    patternHandler = "",
+    poolSize = 10,
+    gossipsubHeartbeatInterval = 0,
+    gossipsubHeartbeatDelay = 0,
+    peersRequired = 2,
+    logFile = "",
+    logLevel = IpfsLogLevel.Debug,
+): Future[DaemonAPI] {.async.} =
   ## Initialize connection to `go-libp2p-daemon` control socket.
   ##
   ## ``flags`` - set of P2PDaemonFlags.
@@ -629,23 +640,15 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
   var env: StringTableRef
 
   when defined(windows):
-    var patternForSocket = if len(patternSock) > 0:
-      patternSock
-    else:
-      DefaultIpSocketPattern
-    var patternForChild = if len(patternHandler) > 0:
-      patternHandler
-    else:
-      DefaultIpChildPattern
+    var patternForSocket =
+      if len(patternSock) > 0: patternSock else: DefaultIpSocketPattern
+    var patternForChild =
+      if len(patternHandler) > 0: patternHandler else: DefaultIpChildPattern
   else:
-    var patternForSocket = if len(patternSock) > 0:
-      patternSock
-    else:
-      DefaultUnixSocketPattern
-    var patternForChild = if len(patternHandler) > 0:
-      patternHandler
-    else:
-      DefaultUnixChildPattern
+    var patternForSocket =
+      if len(patternSock) > 0: patternSock else: DefaultUnixSocketPattern
+    var patternForChild =
+      if len(patternHandler) > 0: patternHandler else: DefaultUnixChildPattern
 
   api.flags = flags
   api.servers = newSeq[P2PServer]()
@@ -734,13 +737,15 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
   if len(hostAddresses) > 0:
     var opt = "-hostAddrs="
     for i, address in hostAddresses:
-      if i > 0: opt.add ","
+      if i > 0:
+        opt.add ","
       opt.add $address
     args.add(opt)
   if len(announcedAddresses) > 0:
     var opt = "-announceAddrs="
     for i, address in announcedAddresses:
-      if i > 0: opt.add ","
+      if i > 0:
+        opt.add ","
       opt.add $address
     args.add(opt)
   args.add("-noise=true")
@@ -755,14 +760,12 @@ proc newDaemonApi*(flags: set[P2PDaemonFlags] = {},
 
   # Starting daemon process
   # echo "Starting ", cmd, " ", args.join(" ")
-  api.process =
-    exceptionToAssert:
-      startProcess(cmd, "", args, env, {poParentStreams})
+  api.process = exceptionToAssert:
+    startProcess(cmd, "", args, env, {poParentStreams})
   # Waiting until daemon will not be bound to control socket.
   while true:
     if not api.process.running():
-      raise newException(DaemonLocalError,
-                         "Daemon executable could not be started!")
+      raise newException(DaemonLocalError, "Daemon executable could not be started!")
     let res = await socketExists(api.address)
     if res:
       break
@@ -822,8 +825,9 @@ template withMessage(m, body: untyped): untyped =
   else:
     body
 
-proc transactMessage(transp: StreamTransport,
-                     pb: ProtoBuffer): Future[ProtoBuffer] {.async.} =
+proc transactMessage(
+    transp: StreamTransport, pb: ProtoBuffer
+): Future[ProtoBuffer] {.async.} =
   let length = pb.getLen()
   let res = await transp.write(pb.getPtr(), length)
   if res != length:
@@ -833,8 +837,7 @@ proc transactMessage(transp: StreamTransport,
     raise newException(DaemonLocalError, "Incorrect or empty message received!")
   result = initProtoBuffer(message)
 
-proc getPeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [DaemonLocalError].} =
+proc getPeerInfo(pb: ProtoBuffer): PeerInfo {.raises: [DaemonLocalError].} =
   ## Get PeerInfo object from ``pb``.
   result.addresses = newSeq[MultiAddress]()
   if pb.getRequiredField(1, result.peer).isErr():
@@ -847,7 +850,7 @@ proc identity*(api: DaemonAPI): Future[PeerInfo] {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transactMessage(transp, requestIdentity())
-    pb.withMessage() do:
+    pb.withMessage:
       var res: seq[byte]
       if pb.getRequiredField(ResponseType.IDENTITY.int, res).isOk():
         var resPb = initProtoBuffer(res)
@@ -855,15 +858,14 @@ proc identity*(api: DaemonAPI): Future[PeerInfo] {.async.} =
   finally:
     await api.closeConnection(transp)
 
-proc connect*(api: DaemonAPI, peer: PeerId,
-              addresses: seq[MultiAddress],
-              timeout = 0) {.async.} =
+proc connect*(
+    api: DaemonAPI, peer: PeerId, addresses: seq[MultiAddress], timeout = 0
+) {.async.} =
   ## Connect to remote peer with id ``peer`` and addresses ``addresses``.
   var transp = await api.newConnection()
   try:
-    var pb = await transp.transactMessage(requestConnect(peer, addresses,
-                                                         timeout))
-    pb.withMessage() do:
+    var pb = await transp.transactMessage(requestConnect(peer, addresses, timeout))
+    pb.withMessage:
       discard
   except CatchableError:
     await api.closeConnection(transp)
@@ -873,22 +875,21 @@ proc disconnect*(api: DaemonAPI, peer: PeerId) {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestDisconnect(peer))
-    pb.withMessage() do:
+    pb.withMessage:
       discard
   finally:
     await api.closeConnection(transp)
 
-proc openStream*(api: DaemonAPI, peer: PeerId,
-                 protocols: seq[string],
-                 timeout = 0): Future[P2PStream] {.async.} =
+proc openStream*(
+    api: DaemonAPI, peer: PeerId, protocols: seq[string], timeout = 0
+): Future[P2PStream] {.async.} =
   ## Open new stream to peer ``peer`` using one of the protocols in
   ## ``protocols``. Returns ``StreamTransport`` for the stream.
   var transp = await api.newConnection()
   var stream = new P2PStream
   try:
-    var pb = await transp.transactMessage(requestStreamOpen(peer, protocols,
-                                                            timeout))
-    pb.withMessage() do:
+    var pb = await transp.transactMessage(requestStreamOpen(peer, protocols, timeout))
+    pb.withMessage:
       var res: seq[byte]
       if pb.getRequiredField(ResponseType.STREAMINFO.int, res).isOk():
         let resPb = initProtoBuffer(res)
@@ -924,8 +925,9 @@ proc streamHandler(server: StreamServer, transp: StreamTransport) {.async.} =
     if not isNil(handler):
       asyncSpawn handler(api, stream)
 
-proc addHandler*(api: DaemonAPI, protocols: seq[string],
-                 handler: P2PStreamCallback) {.async, raises: [LPError].} =
+proc addHandler*(
+    api: DaemonAPI, protocols: seq[string], 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)
@@ -934,9 +936,8 @@ proc addHandler*(api: DaemonAPI, protocols: seq[string],
     for item in protocols:
       api.handlers[item] = handler
     server.start()
-    var pb = await transp.transactMessage(requestStreamHandler(maddress,
-                                                               protocols))
-    pb.withMessage() do:
+    var pb = await transp.transactMessage(requestStreamHandler(maddress, protocols))
+    pb.withMessage:
       api.servers.add(P2PServer(server: server, address: maddress))
   except CatchableError as exc:
     for item in protocols:
@@ -953,7 +954,7 @@ proc listPeers*(api: DaemonAPI): Future[seq[PeerInfo]] {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestListPeers())
-    pb.withMessage() do:
+    pb.withMessage:
       result = newSeq[PeerInfo]()
       var ress: seq[seq[byte]]
       if pb.getRequiredRepeatedField(ResponseType.PEERINFO.int, ress).isOk():
@@ -963,13 +964,12 @@ proc listPeers*(api: DaemonAPI): Future[seq[PeerInfo]] {.async.} =
   finally:
     await api.closeConnection(transp)
 
-proc cmTagPeer*(api: DaemonAPI, peer: PeerId, tag: string,
-              weight: int) {.async.} =
+proc cmTagPeer*(api: DaemonAPI, peer: PeerId, tag: string, weight: int) {.async.} =
   ## Tag peer with id ``peer`` using ``tag`` and ``weight``.
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestCMTagPeer(peer, tag, weight))
-    withMessage(pb) do:
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
@@ -979,7 +979,7 @@ proc cmUntagPeer*(api: DaemonAPI, peer: PeerId, tag: string) {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestCMUntagPeer(peer, tag))
-    withMessage(pb) do:
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
@@ -989,37 +989,34 @@ proc cmTrimPeers*(api: DaemonAPI) {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestCMTrim())
-    withMessage(pb) do:
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
 
-proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo
-  {.raises: [DaemonLocalError].} =
+proc dhtGetSinglePeerInfo(pb: ProtoBuffer): PeerInfo {.raises: [DaemonLocalError].} =
   var res: seq[byte]
   if pb.getRequiredField(2, res).isOk():
     result = initProtoBuffer(res).getPeerInfo()
   else:
     raise newException(DaemonLocalError, "Missing required field `peer`!")
 
-proc dhtGetSingleValue(pb: ProtoBuffer): seq[byte]
-  {.raises: [DaemonLocalError].} =
+proc dhtGetSingleValue(pb: ProtoBuffer): seq[byte] {.raises: [DaemonLocalError].} =
   result = newSeq[byte]()
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
-proc dhtGetSinglePublicKey(pb: ProtoBuffer): PublicKey
-  {.raises: [DaemonLocalError].} =
+proc dhtGetSinglePublicKey(pb: ProtoBuffer): PublicKey {.raises: [DaemonLocalError].} =
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
-proc dhtGetSinglePeerId(pb: ProtoBuffer): PeerId
-  {.raises: [DaemonLocalError].} =
+proc dhtGetSinglePeerId(pb: ProtoBuffer): PeerId {.raises: [DaemonLocalError].} =
   if pb.getRequiredField(3, result).isErr():
     raise newException(DaemonLocalError, "Missing field `value`!")
 
-proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
-  {.inline, raises: [DaemonLocalError].} =
+proc enterDhtMessage(
+    pb: ProtoBuffer, rt: DHTResponseType
+): ProtoBuffer {.inline, raises: [DaemonLocalError].} =
   var dhtResponse: seq[byte]
   if pb.getRequiredField(ResponseType.DHT.int, dhtResponse).isOk():
     var pbDhtResponse = initProtoBuffer(dhtResponse)
@@ -1037,16 +1034,18 @@ proc enterDhtMessage(pb: ProtoBuffer, rt: DHTResponseType): ProtoBuffer
   else:
     raise newException(DaemonLocalError, "Wrong message type!")
 
-proc enterPsMessage(pb: ProtoBuffer): ProtoBuffer
-  {.inline, raises: [DaemonLocalError].} =
+proc enterPsMessage(
+    pb: ProtoBuffer
+): ProtoBuffer {.inline, raises: [DaemonLocalError].} =
   var res: seq[byte]
   if pb.getRequiredField(ResponseType.PUBSUB.int, res).isErr():
     raise newException(DaemonLocalError, "Wrong message type!")
 
   initProtoBuffer(res)
 
-proc getDhtMessageType(pb: ProtoBuffer): DHTResponseType
-  {.inline, raises: [DaemonLocalError].} =
+proc getDhtMessageType(
+    pb: ProtoBuffer
+): DHTResponseType {.inline, raises: [DaemonLocalError].} =
   var dtype: uint
   if pb.getRequiredField(1, dtype).isErr():
     raise newException(DaemonLocalError, "Missing required DHT field `type`!")
@@ -1057,8 +1056,9 @@ proc getDhtMessageType(pb: ProtoBuffer): DHTResponseType
   else:
     raise newException(DaemonLocalError, "Wrong DHT answer type!")
 
-proc dhtFindPeer*(api: DaemonAPI, peer: PeerId,
-                  timeout = 0): Future[PeerInfo] {.async.} =
+proc dhtFindPeer*(
+    api: DaemonAPI, peer: PeerId, timeout = 0
+): Future[PeerInfo] {.async.} =
   ## Find peer with id ``peer`` and return peer information ``PeerInfo``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1066,13 +1066,14 @@ proc dhtFindPeer*(api: DaemonAPI, peer: PeerId,
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestDHTFindPeer(peer, timeout))
-    withMessage(pb) do:
+    withMessage(pb):
       result = pb.enterDhtMessage(DHTResponseType.VALUE).dhtGetSinglePeerInfo()
   finally:
     await api.closeConnection(transp)
 
-proc dhtGetPublicKey*(api: DaemonAPI, peer: PeerId,
-                      timeout = 0): Future[PublicKey] {.async.} =
+proc dhtGetPublicKey*(
+    api: DaemonAPI, peer: PeerId, timeout = 0
+): Future[PublicKey] {.async.} =
   ## Get peer's public key from peer with id ``peer``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1080,13 +1081,14 @@ proc dhtGetPublicKey*(api: DaemonAPI, peer: PeerId,
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestDHTGetPublicKey(peer, timeout))
-    withMessage(pb) do:
+    withMessage(pb):
       result = pb.enterDhtMessage(DHTResponseType.VALUE).dhtGetSinglePublicKey()
   finally:
     await api.closeConnection(transp)
 
-proc dhtGetValue*(api: DaemonAPI, key: string,
-                  timeout = 0): Future[seq[byte]] {.async.} =
+proc dhtGetValue*(
+    api: DaemonAPI, key: string, timeout = 0
+): Future[seq[byte]] {.async.} =
   ## Get value associated with ``key``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1094,22 +1096,22 @@ proc dhtGetValue*(api: DaemonAPI, key: string,
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestDHTGetValue(key, timeout))
-    withMessage(pb) do:
+    withMessage(pb):
       result = pb.enterDhtMessage(DHTResponseType.VALUE).dhtGetSingleValue()
   finally:
     await api.closeConnection(transp)
 
-proc dhtPutValue*(api: DaemonAPI, key: string, value: seq[byte],
-                  timeout = 0) {.async.} =
+proc dhtPutValue*(
+    api: DaemonAPI, key: string, value: seq[byte], timeout = 0
+) {.async.} =
   ## Associate ``value`` with ``key``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
   ## means no timeout.
   var transp = await api.newConnection()
   try:
-    var pb = await transp.transactMessage(requestDHTPutValue(key, value,
-                                                             timeout))
-    withMessage(pb) do:
+    var pb = await transp.transactMessage(requestDHTPutValue(key, value, timeout))
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
@@ -1122,13 +1124,14 @@ proc dhtProvide*(api: DaemonAPI, cid: Cid, timeout = 0) {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestDHTProvide(cid, timeout))
-    withMessage(pb) do:
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
 
-proc dhtFindPeersConnectedToPeer*(api: DaemonAPI, peer: PeerId,
-                                 timeout = 0): Future[seq[PeerInfo]] {.async.} =
+proc dhtFindPeersConnectedToPeer*(
+    api: DaemonAPI, peer: PeerId, timeout = 0
+): Future[seq[PeerInfo]] {.async.} =
   ## Find peers which are connected to peer with id ``peer``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1138,7 +1141,7 @@ proc dhtFindPeersConnectedToPeer*(api: DaemonAPI, peer: PeerId,
   try:
     let spb = requestDHTFindPeersConnectedToPeer(peer, timeout)
     var pb = await transp.transactMessage(spb)
-    withMessage(pb) do:
+    withMessage(pb):
       discard pb.enterDhtMessage(DHTResponseType.BEGIN)
       while true:
         var message = await transp.recvMessage()
@@ -1152,8 +1155,9 @@ proc dhtFindPeersConnectedToPeer*(api: DaemonAPI, peer: PeerId,
   finally:
     await api.closeConnection(transp)
 
-proc dhtGetClosestPeers*(api: DaemonAPI, key: string,
-                         timeout = 0): Future[seq[PeerId]] {.async.} =
+proc dhtGetClosestPeers*(
+    api: DaemonAPI, key: string, timeout = 0
+): Future[seq[PeerId]] {.async.} =
   ## Get closest peers for ``key``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1163,7 +1167,7 @@ proc dhtGetClosestPeers*(api: DaemonAPI, key: string,
   try:
     let spb = requestDHTGetClosestPeers(key, timeout)
     var pb = await transp.transactMessage(spb)
-    withMessage(pb) do:
+    withMessage(pb):
       discard pb.enterDhtMessage(DHTResponseType.BEGIN)
       while true:
         var message = await transp.recvMessage()
@@ -1177,8 +1181,9 @@ proc dhtGetClosestPeers*(api: DaemonAPI, key: string,
   finally:
     await api.closeConnection(transp)
 
-proc dhtFindProviders*(api: DaemonAPI, cid: Cid, count: uint32,
-                       timeout = 0): Future[seq[PeerInfo]] {.async.} =
+proc dhtFindProviders*(
+    api: DaemonAPI, cid: Cid, count: uint32, timeout = 0
+): Future[seq[PeerInfo]] {.async.} =
   ## Get ``count`` providers for content with id ``cid``.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1188,7 +1193,7 @@ proc dhtFindProviders*(api: DaemonAPI, cid: Cid, count: uint32,
   try:
     let spb = requestDHTFindProviders(cid, count, timeout)
     var pb = await transp.transactMessage(spb)
-    withMessage(pb) do:
+    withMessage(pb):
       discard pb.enterDhtMessage(DHTResponseType.BEGIN)
       while true:
         var message = await transp.recvMessage()
@@ -1202,8 +1207,9 @@ proc dhtFindProviders*(api: DaemonAPI, cid: Cid, count: uint32,
   finally:
     await api.closeConnection(transp)
 
-proc dhtSearchValue*(api: DaemonAPI, key: string,
-                     timeout = 0): Future[seq[seq[byte]]] {.async.} =
+proc dhtSearchValue*(
+    api: DaemonAPI, key: string, timeout = 0
+): Future[seq[seq[byte]]] {.async.} =
   ## Search for value with ``key``, return list of values found.
   ##
   ## You can specify timeout for DHT request with ``timeout`` value. ``0`` value
@@ -1212,7 +1218,7 @@ proc dhtSearchValue*(api: DaemonAPI, key: string,
   var list = newSeq[seq[byte]]()
   try:
     var pb = await transp.transactMessage(requestDHTSearchValue(key, timeout))
-    withMessage(pb) do:
+    withMessage(pb):
       discard pb.enterDhtMessage(DHTResponseType.BEGIN)
       while true:
         var message = await transp.recvMessage()
@@ -1231,7 +1237,7 @@ proc pubsubGetTopics*(api: DaemonAPI): Future[seq[string]] {.async.} =
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestPSGetTopics())
-    withMessage(pb) do:
+    withMessage(pb):
       let innerPb = pb.enterPsMessage()
       var topics = newSeq[string]()
       discard innerPb.getRepeatedField(1, topics)
@@ -1239,14 +1245,13 @@ proc pubsubGetTopics*(api: DaemonAPI): Future[seq[string]] {.async.} =
   finally:
     await api.closeConnection(transp)
 
-proc pubsubListPeers*(api: DaemonAPI,
-                      topic: string): Future[seq[PeerId]] {.async.} =
+proc pubsubListPeers*(api: DaemonAPI, topic: string): Future[seq[PeerId]] {.async.} =
   ## Get list of peers we are connected to and which also subscribed to topic
   ## ``topic``.
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestPSListPeers(topic))
-    withMessage(pb) do:
+    withMessage(pb):
       var peer: PeerId
       let innerPb = pb.enterPsMessage()
       var peers = newSeq[seq[byte]]()
@@ -1255,13 +1260,12 @@ proc pubsubListPeers*(api: DaemonAPI,
   finally:
     await api.closeConnection(transp)
 
-proc pubsubPublish*(api: DaemonAPI, topic: string,
-                    value: seq[byte]) {.async.} =
+proc pubsubPublish*(api: DaemonAPI, topic: string, value: seq[byte]) {.async.} =
   ## Get list of peer identifiers which are subscribed to topic ``topic``.
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestPSPublish(topic, value))
-    withMessage(pb) do:
+    withMessage(pb):
       discard
   finally:
     await api.closeConnection(transp)
@@ -1290,13 +1294,14 @@ proc pubsubLoop(api: DaemonAPI, ticket: PubsubTicket) {.async.} =
       await ticket.transp.join()
       break
 
-proc pubsubSubscribe*(api: DaemonAPI, topic: string,
-                   handler: P2PPubSubCallback): Future[PubsubTicket] {.async.} =
+proc pubsubSubscribe*(
+    api: DaemonAPI, topic: string, handler: P2PPubSubCallback
+): Future[PubsubTicket] {.async: (raises: [CatchableError]).} =
   ## Subscribe to topic ``topic``.
   var transp = await api.newConnection()
   try:
     var pb = await transp.transactMessage(requestPSSubscribe(topic))
-    pb.withMessage() do:
+    pb.withMessage:
       var ticket = new PubsubTicket
       ticket.topic = topic
       ticket.handler = handler
@@ -1314,7 +1319,7 @@ proc shortLog*(pinfo: PeerInfo): string =
   result.add($pinfo.peer.shortLog())
   result.add("' Addresses: [")
   let length = len(pinfo.addresses)
-  for i in 0..<length:
+  for i in 0 ..< length:
     result.add("'")
     result.add($pinfo.addresses[i])
     result.add("'")

libp2p/daemon/transpool.nim

@@ -12,23 +12,24 @@
 ## This module implements Pool of StreamTransport.
 import chronos
 
-const
-  DefaultPoolSize* = 8
-    ## Default pool size
+const DefaultPoolSize* = 8 ## Default pool size
 
 type
   ConnectionFlags = enum
-    None, Busy
+    None
+    Busy
 
   PoolItem = object
     transp*: StreamTransport
     flags*: set[ConnectionFlags]
 
   PoolState = enum
-    Connecting, Connected, Closing, Closed
+    Connecting
+    Connected
+    Closing
+    Closed
 
-  TransportPool* = ref object
-    ## Transports pool object
+  TransportPool* = ref object ## Transports pool object
     transports: seq[PoolItem]
     busyCount: int
     state: PoolState
@@ -45,13 +46,16 @@ proc waitAll[T](futs: seq[Future[T]]): Future[void] =
     dec(counter)
     if counter == 0:
       retFuture.complete()
+
   for fut in futs:
     fut.addCallback(cb)
   return retFuture
 
-proc newPool*(address: TransportAddress, poolsize: int = DefaultPoolSize,
-              bufferSize = DefaultStreamBufferSize,
-             ): Future[TransportPool] {.async.} =
+proc newPool*(
+    address: TransportAddress,
+    poolsize: int = DefaultPoolSize,
+    bufferSize = DefaultStreamBufferSize,
+): Future[TransportPool] {.async.} =
   ## Establish pool of connections to address ``address`` with size
   ## ``poolsize``.
   var pool = new TransportPool
@@ -59,12 +63,12 @@ proc newPool*(address: TransportAddress, poolsize: int = DefaultPoolSize,
   pool.transports = newSeq[PoolItem](poolsize)
   var conns = newSeq[Future[StreamTransport]](poolsize)
   pool.state = Connecting
-  for i in 0..<poolsize:
+  for i in 0 ..< poolsize:
     conns[i] = connect(address, bufferSize)
   # Waiting for all connections to be established.
   await waitAll(conns)
   # Checking connections and preparing pool.
-  for i in 0..<poolsize:
+  for i in 0 ..< poolsize:
     if conns[i].failed:
       raise conns[i].error
     else:
@@ -134,7 +138,7 @@ proc close*(pool: TransportPool) {.async.} =
     await pool.join()
     # Closing all transports
     var pending = newSeq[Future[void]](len(pool.transports))
-    for i in 0..<len(pool.transports):
+    for i in 0 ..< len(pool.transports):
       let transp = pool.transports[i].transp
       transp.close()
       pending[i] = transp.join()

libp2p/debugutils.nim

@@ -27,17 +27,24 @@
 ##   7. Message: required bytes
 import os
 import nimcrypto/utils, stew/endians2
-import protobuf/minprotobuf, stream/connection, protocols/secure/secure,
-       multiaddress, peerid, varint, muxers/mplex/coder
+import
+  protobuf/minprotobuf,
+  stream/connection,
+  protocols/secure/secure,
+  multiaddress,
+  peerid,
+  varint,
+  muxers/mplex/coder
 
-from times import getTime, toUnix, fromUnix, nanosecond, format, Time,
-                  NanosecondRange, initTime
+from times import
+  getTime, toUnix, fromUnix, nanosecond, format, Time, NanosecondRange, initTime
 from strutils import toHex, repeat
 export peerid, multiaddress
 
 type
   FlowDirection* = enum
-    Outgoing, Incoming
+    Outgoing
+    Incoming
 
   ProtoMessage* = object
     timestamp*: uint64
@@ -48,11 +55,10 @@ type
     local*: Opt[MultiAddress]
     remote*: Opt[MultiAddress]
 
-const
-  libp2p_dump_dir* {.strdefine.} = "nim-libp2p"
-    ## default directory where all the dumps will be stored, if the path
-    ## relative it will be created in home directory. You can overload this path
-    ## using ``-d:libp2p_dump_dir=<otherpath>``.
+const libp2p_dump_dir* {.strdefine.} = "nim-libp2p"
+  ## default directory where all the dumps will be stored, if the path
+  ## relative it will be created in home directory. You can overload this path
+  ## using ``-d:libp2p_dump_dir=<otherpath>``.
 
 proc getTimestamp(): uint64 =
   ## This procedure is present because `stdlib.times` missing it.
@@ -65,8 +71,7 @@ proc getTimedate(value: uint64): string =
   let time = initTime(int64(value div 1_000_000_000), value mod 1_000_000_000)
   time.format("yyyy-MM-dd HH:mm:ss'.'fffzzz")
 
-proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
-                  data: openArray[byte]) =
+proc dumpMessage*(conn: SecureConn, direction: FlowDirection, data: openArray[byte]) =
   ## Store unencrypted message ``data`` to dump file, all the metadata will be
   ## extracted from ``conn`` instance.
   var pb = initProtoBuffer(options = {WithVarintLength})
@@ -87,7 +92,7 @@ proc dumpMessage*(conn: SecureConn, direction: FlowDirection,
 
   # This is debugging procedure so it should not generate any exceptions,
   # and we going to return at every possible OS error.
-  if not(dirExists(dirName)):
+  if not (dirExists(dirName)):
     try:
       createDir(dirName)
     except CatchableError:
@@ -153,13 +158,11 @@ iterator messages*(data: seq[byte]): Opt[ProtoMessage] =
   while offset < len(data):
     value = 0
     size = 0
-    let res = PB.getUVarint(data.toOpenArray(offset, len(data) - 1),
-                            size, value)
+    let res = PB.getUVarint(data.toOpenArray(offset, len(data) - 1), size, value)
     if res.isOk():
       if (value > 0'u64) and (value < uint64(len(data) - offset)):
         offset += size
-        yield decodeDumpMessage(data.toOpenArray(offset,
-                                                 offset + int(value) - 1))
+        yield decodeDumpMessage(data.toOpenArray(offset, offset + int(value) - 1))
         # value is previously checked to be less then len(data) which is `int`.
         offset += int(value)
       else:
@@ -179,10 +182,15 @@ proc dumpHex*(pbytes: openArray[byte], groupBy = 1, ascii = true): string =
 
     for k in 0 ..< groupBy:
       let ch = pbytes[offset + k]
-      ascii.add(if ord(ch) > 31 and ord(ch) < 127: char(ch) else: '.')
+      ascii.add(
+        if ord(ch) > 31 and ord(ch) < 127:
+          char(ch)
+        else:
+          '.'
+      )
 
     let item =
-      case groupBy:
+      case groupBy
       of 1:
         toHex(pbytes[offset])
       of 2:
@@ -204,8 +212,7 @@ proc dumpHex*(pbytes: openArray[byte], groupBy = 1, ascii = true): string =
       res.add("\p")
 
   if (offset mod 16) != 0:
-    let spacesCount = ((16 - (offset mod 16)) div groupBy) *
-                        (groupBy * 2 + 1) + 1
+    let spacesCount = ((16 - (offset mod 16)) div groupBy) * (groupBy * 2 + 1) + 1
     res = res & repeat(' ', spacesCount)
     res = res & ascii
 
@@ -233,25 +240,30 @@ proc toString*(msg: ProtoMessage, dump = true): string =
   var res = getTimedate(msg.timestamp)
   let direction =
     case msg.direction
-    of Incoming:
-      " << "
-    of Outgoing:
-      " >> "
-  let address =
-    block:
-      let local = block:
-        msg.local.withValue(loc): "[" & $loc & "]"
-        else: "[LOCAL]"
-      let remote = block:
-        msg.remote.withValue(rem): "[" & $rem & "]"
-        else: "[REMOTE]"
-      local & direction & remote
+    of Incoming: " << "
+    of Outgoing: " >> "
+  let address = block:
+    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 = block:
-    msg.seqID.withValue(seqid): "seqID = " & $seqid & " "
-    else: ""
+    msg.seqID.withValue(seqid):
+      "seqID = " & $seqid & " "
+    else:
+      ""
   let mtype = block:
-    msg.mtype.withValue(typ): "type = " & $typ & " "
-    else: ""
+    msg.mtype.withValue(typ):
+      "type = " & $typ & " "
+    else:
+      ""
   res.add(" ")
   res.add(address)
   res.add(" ")

libp2p/dial.nim

@@ -11,22 +11,20 @@
 
 import chronos
 import stew/results
-import peerid,
-       stream/connection,
-       transports/transport
+import peerid, stream/connection, transports/transport
 
 export results
 
-type
-  Dial* = ref object of RootObj
+type Dial* = ref object of RootObj
 
 method connect*(
-  self: Dial,
-  peerId: PeerId,
-  addrs: seq[MultiAddress],
-  forceDial = false,
-  reuseConnection = true,
-  dir = Direction.Out) {.async, base.} =
+    self: Dial,
+    peerId: PeerId,
+    addrs: seq[MultiAddress],
+    forceDial = false,
+    reuseConnection = true,
+    dir = Direction.Out,
+) {.async, base.} =
   ## connect remote peer without negotiating
   ## a protocol
   ##
@@ -34,18 +32,15 @@ method connect*(
   doAssert(false, "Not implemented!")
 
 method connect*(
-  self: Dial,
-  address: MultiAddress,
-  allowUnknownPeerId = false): Future[PeerId] {.async, base.} =
+    self: Dial, address: MultiAddress, allowUnknownPeerId = false
+): Future[PeerId] {.async, base.} =
   ## Connects to a peer and retrieve its PeerId
 
   doAssert(false, "Not implemented!")
 
 method dial*(
-  self: Dial,
-  peerId: PeerId,
-  protos: seq[string],
-  ): Future[Connection] {.async, base.} =
+    self: Dial, peerId: PeerId, protos: seq[string]
+): Future[Connection] {.async, base.} =
   ## create a protocol stream over an
   ## existing connection
   ##
@@ -53,24 +48,22 @@ method dial*(
   doAssert(false, "Not implemented!")
 
 method dial*(
-  self: Dial,
-  peerId: PeerId,
-  addrs: seq[MultiAddress],
-  protos: seq[string],
-  forceDial = false): Future[Connection] {.async, base.} =
+    self: Dial,
+    peerId: PeerId,
+    addrs: seq[MultiAddress],
+    protos: seq[string],
+    forceDial = false,
+): Future[Connection] {.async, base.} =
   ## create a protocol stream and establish
   ## a connection if one doesn't exist already
   ##
 
   doAssert(false, "Not implemented!")
 
-method addTransport*(
-  self: Dial,
-  transport: Transport) {.base.} =
+method addTransport*(self: Dial, transport: Transport) {.base.} =
   doAssert(false, "Not implemented!")
 
 method tryDial*(
-  self: Dial,
-  peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async, base.} =
+    self: Dial, peerId: PeerId, addrs: seq[MultiAddress]
+): Future[Opt[MultiAddress]] {.async, base.} =
   doAssert(false, "Not implemented!")

libp2p/dialer.nim

@@ -10,23 +10,22 @@
 import std/tables
 
 import stew/results
-import pkg/[chronos,
-            chronicles,
-            metrics]
+import pkg/[chronos, chronicles, metrics]
 
-import dial,
-       peerid,
-       peerinfo,
-       peerstore,
-       multicodec,
-       muxers/muxer,
-       multistream,
-       connmanager,
-       stream/connection,
-       transports/transport,
-       nameresolving/nameresolver,
-       upgrademngrs/upgrade,
-       errors
+import
+  dial,
+  peerid,
+  peerinfo,
+  peerstore,
+  multicodec,
+  muxers/muxer,
+  multistream,
+  connmanager,
+  stream/connection,
+  transports/transport,
+  nameresolving/nameresolver,
+  upgrademngrs/upgrade,
+  errors
 
 export dial, errors, results
 
@@ -49,25 +48,26 @@ type
     nameResolver: NameResolver
 
 proc dialAndUpgrade(
-  self: Dialer,
-  peerId: Opt[PeerId],
-  hostname: string,
-  address: MultiAddress,
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
-
+    self: Dialer,
+    peerId: Opt[PeerId],
+    hostname: string,
+    address: MultiAddress,
+    dir = Direction.Out,
+): Future[Muxer] {.async.} =
   for transport in self.transports: # for each transport
-    if transport.handles(address):   # check if it can dial it
+    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))
+          trace "Dialing canceled",
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           raise exc
         except CatchableError as exc:
-          debug "Dialing failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Dialing failed",
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           libp2p_failed_dials.inc()
           return nil # Try the next address
 
@@ -88,7 +88,8 @@ proc dialAndUpgrade(
           # 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 "Connection upgrade failed", err = exc.msg, peerId = peerId.get(default(PeerId))
+          debug "Connection upgrade failed",
+            description = exc.msg, peerId = peerId.get(default(PeerId))
           if dialed.dir == Direction.Out:
             libp2p_failed_upgrades_outgoing.inc()
           else:
@@ -103,13 +104,12 @@ proc dialAndUpgrade(
   return nil
 
 proc expandDnsAddr(
-  self: Dialer,
-  peerId: Opt[PeerId],
-  address: MultiAddress): Future[seq[(MultiAddress, Opt[PeerId])]] {.async.} =
-
-  if not DNSADDR.matchPartial(address): return @[(address, peerId)]
+    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
+    info "Can't resolve DNSADDR without NameResolver", ma = address
     return @[]
 
   let
@@ -126,18 +126,14 @@ proc expandDnsAddr(
       let
         peerIdBytes = lastPart.protoArgument().tryGet()
         addrPeerId = PeerId.init(peerIdBytes).tryGet()
-      result.add((resolvedAddress[0..^2].tryGet(), Opt.some(addrPeerId)))
+      result.add((resolvedAddress[0 ..^ 2].tryGet(), Opt.some(addrPeerId)))
     else:
       result.add((resolvedAddress, peerId))
 
 proc dialAndUpgrade(
-  self: Dialer,
-  peerId: Opt[PeerId],
-  addrs: seq[MultiAddress],
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
-
-  debug "Dialing peer", peerId = peerId.get(default(PeerId))
+    self: Dialer, peerId: Opt[PeerId], addrs: seq[MultiAddress], dir = Direction.Out
+): Future[Muxer] {.async.} =
+  debug "Dialing peer", peerId = peerId.get(default(PeerId)), addrs
 
   for rawAddress in addrs:
     # resolve potential dnsaddr
@@ -148,8 +144,10 @@ proc dialAndUpgrade(
       let
         hostname = expandedAddress.getHostname()
         resolvedAddresses =
-          if isNil(self.nameResolver): @[expandedAddress]
-          else: await self.nameResolver.resolveMAddress(expandedAddress)
+          if isNil(self.nameResolver):
+            @[expandedAddress]
+          else:
+            await self.nameResolver.resolveMAddress(expandedAddress)
 
       for resolvedAddress in resolvedAddresses:
         result = await self.dialAndUpgrade(addrPeerId, hostname, resolvedAddress, dir)
@@ -165,13 +163,13 @@ proc tryReusingConnection(self: Dialer, peerId: PeerId): Opt[Muxer] =
   return Opt.some(muxer)
 
 proc internalConnect(
-  self: Dialer,
-  peerId: Opt[PeerId],
-  addrs: seq[MultiAddress],
-  forceDial: bool,
-  reuseConnection = true,
-  dir = Direction.Out):
-  Future[Muxer] {.async.} =
+    self: Dialer,
+    peerId: Opt[PeerId],
+    addrs: seq[MultiAddress],
+    forceDial: bool,
+    reuseConnection = true,
+    dir = Direction.Out,
+): Future[Muxer] {.async.} =
   if Opt.some(self.localPeerId) == peerId:
     raise newException(CatchableError, "can't dial self!")
 
@@ -199,8 +197,12 @@ proc internalConnect(
     try:
       self.connManager.storeMuxer(muxed)
       await self.peerStore.identify(muxed)
+      await self.connManager.triggerPeerEvents(
+        muxed.connection.peerId,
+        PeerEvent(kind: PeerEventKind.Identified, initiator: true),
+      )
     except CatchableError as exc:
-      trace "Failed to finish outgoung upgrade", err=exc.msg
+      trace "Failed to finish outgoung upgrade", description = exc.msg
       await muxed.close()
       raise exc
 
@@ -210,12 +212,13 @@ proc internalConnect(
       lock.release()
 
 method connect*(
-  self: Dialer,
-  peerId: PeerId,
-  addrs: seq[MultiAddress],
-  forceDial = false,
-  reuseConnection = true,
-  dir = Direction.Out) {.async.} =
+    self: Dialer,
+    peerId: PeerId,
+    addrs: seq[MultiAddress],
+    forceDial = false,
+    reuseConnection = true,
+    dir = Direction.Out,
+) {.async.} =
   ## connect remote peer without negotiating
   ## a protocol
   ##
@@ -223,32 +226,30 @@ method connect*(
   if self.connManager.connCount(peerId) > 0 and reuseConnection:
     return
 
-  discard await self.internalConnect(Opt.some(peerId), addrs, forceDial, reuseConnection, dir)
+  discard
+    await self.internalConnect(Opt.some(peerId), addrs, forceDial, reuseConnection, dir)
 
 method connect*(
-  self: Dialer,
-  address: MultiAddress,
-  allowUnknownPeerId = false): Future[PeerId] {.async.} =
+    self: Dialer, address: MultiAddress, allowUnknownPeerId = false
+): Future[PeerId] {.async.} =
   ## Connects to a peer and retrieve its PeerId
 
   parseFullAddress(address).toOpt().withValue(fullAddress):
-    return (await self.internalConnect(
-      Opt.some(fullAddress[0]),
-      @[fullAddress[1]],
-      false)).connection.peerId
+    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!")
+    raise newException(
+      DialFailedError, "Address without PeerID and unknown peer id disabled!"
+    )
 
-  return (await self.internalConnect(
-    Opt.none(PeerId),
-    @[address],
-    false)).connection.peerId
+  return
+    (await self.internalConnect(Opt.none(PeerId), @[address], false)).connection.peerId
 
 proc negotiateStream(
-  self: Dialer,
-  conn: Connection,
-  protos: seq[string]): Future[Connection] {.async.} =
+    self: Dialer, conn: Connection, protos: seq[string]
+): Future[Connection] {.async.} =
   trace "Negotiating stream", conn, protos
   let selected = await MultistreamSelect.select(conn, protos)
   if not protos.contains(selected):
@@ -258,9 +259,8 @@ proc negotiateStream(
   return conn
 
 method tryDial*(
-  self: Dialer,
-  peerId: PeerId,
-  addrs: seq[MultiAddress]): Future[Opt[MultiAddress]] {.async.} =
+    self: Dialer, peerId: PeerId, addrs: seq[MultiAddress]
+): Future[Opt[MultiAddress]] {.async.} =
   ## Create a protocol stream in order to check
   ## if a connection is possible.
   ## Doesn't use the Connection Manager to save it.
@@ -279,9 +279,8 @@ method tryDial*(
     raise newException(DialFailedError, exc.msg)
 
 method dial*(
-  self: Dialer,
-  peerId: PeerId,
-  protos: seq[string]): Future[Connection] {.async.} =
+    self: Dialer, peerId: PeerId, protos: seq[string]
+): Future[Connection] {.async.} =
   ## create a protocol stream over an
   ## existing connection
   ##
@@ -294,11 +293,12 @@ method dial*(
   return await self.negotiateStream(stream, protos)
 
 method dial*(
-  self: Dialer,
-  peerId: PeerId,
-  addrs: seq[MultiAddress],
-  protos: seq[string],
-  forceDial = false): Future[Connection] {.async.} =
+    self: Dialer,
+    peerId: PeerId,
+    addrs: seq[MultiAddress],
+    protos: seq[string],
+    forceDial = false,
+): Future[Connection] {.async.} =
   ## create a protocol stream and establish
   ## a connection if one doesn't exist already
   ##
@@ -308,10 +308,10 @@ method dial*(
     stream: Connection
 
   proc cleanup() {.async.} =
-    if not(isNil(stream)):
+    if not (isNil(stream)):
       await stream.closeWithEOF()
 
-    if not(isNil(conn)):
+    if not (isNil(conn)):
       await conn.close()
 
   try:
@@ -321,8 +321,7 @@ method dial*(
     stream = await self.connManager.getStream(conn)
 
     if isNil(stream):
-      raise newException(DialFailedError,
-        "Couldn't get muxed stream")
+      raise newException(DialFailedError, "Couldn't get muxed stream")
 
     return await self.negotiateStream(stream, protos)
   except CancelledError as exc:
@@ -330,7 +329,7 @@ method dial*(
     await cleanup()
     raise exc
   except CatchableError as exc:
-    debug "Error dialing", conn, err = exc.msg
+    debug "Error dialing", conn, description = exc.msg
     await cleanup()
     raise exc
 
@@ -338,15 +337,17 @@ method addTransport*(self: Dialer, t: Transport) =
   self.transports &= t
 
 proc new*(
-  T: type Dialer,
-  localPeerId: PeerId,
-  connManager: ConnManager,
-  peerStore: PeerStore,
-  transports: seq[Transport],
-  nameResolver: NameResolver = nil): Dialer =
-
-  T(localPeerId: localPeerId,
+    T: type Dialer,
+    localPeerId: PeerId,
+    connManager: ConnManager,
+    peerStore: PeerStore,
+    transports: seq[Transport],
+    nameResolver: NameResolver = nil,
+): Dialer =
+  T(
+    localPeerId: localPeerId,
     connManager: connManager,
     transports: transports,
     peerStore: peerStore,
-    nameResolver: nameResolver)
+    nameResolver: nameResolver,
+  )

libp2p/discovery/discoverymngr.nim

@@ -33,12 +33,13 @@ proc ofType*[T](f: BaseAttr, _: type[T]): bool =
 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](
+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)
+      ,
     )
   )
 
@@ -58,7 +59,8 @@ proc `{}`*[T](pa: PeerAttributes, t: typedesc[T]): Opt[T] =
   Opt.none(T)
 
 proc `[]`*[T](pa: PeerAttributes, t: typedesc[T]): T {.raises: [KeyError].} =
-  pa{T}.valueOr: raise newException(KeyError, "Attritute not found")
+  pa{T}.valueOr:
+    raise newException(KeyError, "Attritute not found")
 
 proc match*(pa, candidate: PeerAttributes): bool =
   for f in pa.attributes:
@@ -101,7 +103,7 @@ type
 proc add*(dm: DiscoveryManager, di: DiscoveryInterface) =
   dm.interfaces &= di
 
-  di.onPeerFound = proc (pa: PeerAttributes) =
+  di.onPeerFound = proc(pa: PeerAttributes) =
     for query in dm.queries:
       if query.attr.match(pa):
         try:
@@ -139,8 +141,10 @@ template forEach*(query: DiscoveryQuery, code: untyped) =
   proc forEachInternal(q: DiscoveryQuery) {.async.} =
     while true:
       let peer {.inject.} =
-        try: await q.getPeer()
-        except DiscoveryFinished: return
+        try:
+          await q.getPeer()
+        except DiscoveryFinished:
+          return
       code
 
   asyncSpawn forEachInternal(query)
@@ -148,13 +152,15 @@ template forEach*(query: DiscoveryQuery, code: untyped) =
 proc stop*(query: DiscoveryQuery) =
   query.finished = true
   for r in query.futs:
-    if not r.finished(): r.cancel()
+    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
+    if isNil(i.advertiseLoop):
+      continue
     i.advertiseLoop.cancel()
 
 proc getPeer*(query: DiscoveryQuery): Future[PeerAttributes] {.async.} =

libp2p/discovery/rendezvousinterface.nim

@@ -10,9 +10,7 @@
 {.push raises: [].}
 
 import chronos
-import ./discoverymngr,
-       ../protocols/rendezvous,
-       ../peerid
+import ./discoverymngr, ../protocols/rendezvous, ../peerid
 
 type
   RendezVousInterface* = ref object of DiscoveryInterface
@@ -66,13 +64,15 @@ method advertise*(self: RendezVousInterface) {.async.} =
       try:
         await self.rdv.advertise(toAdv, self.ttl)
       except CatchableError as error:
-        debug "RendezVous advertise error: ", msg = error.msg
+        debug "RendezVous advertise error: ", description = 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 =
+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/errors.nim

@@ -24,23 +24,25 @@ macro checkFutures*[F](futs: seq[F], exclude: untyped = []): untyped =
   let nexclude = exclude.len
   case nexclude
   of 0:
-    quote do:
+    quote:
       for res in `futs`:
         if res.failed:
           let exc = res.readError()
           # We still don't abort but warn
-          debug "A future has failed, enable trace logging for details", error = exc.name
-          trace "Exception message", msg= exc.msg, stack = getStackTrace()
+          debug "A future has failed, enable trace logging for details",
+            error = exc.name
+          trace "Exception message", description = exc.msg, stack = getStackTrace()
   else:
-    quote do:
+    quote:
       for res in `futs`:
         block check:
           if res.failed:
             let exc = res.readError()
-            for i in 0..<`nexclude`:
+            for i in 0 ..< `nexclude`:
               if exc of `exclude`[i]:
-                trace "A future has failed", error=exc.name, msg=exc.msg
+                trace "A future has failed", error = exc.name, description = exc.msg
                 break check
             # We still don't abort but warn
-            debug "A future has failed, enable trace logging for details", error=exc.name
-            trace "Exception details", msg=exc.msg
+            debug "A future has failed, enable trace logging for details",
+              error = exc.name
+            trace "Exception details", description = exc.msg

libp2p/multiaddress.nim

@@ -12,20 +12,32 @@
 {.push raises: [].}
 {.push public.}
 
-import pkg/chronos, chronicles
+import pkg/[chronos, chronicles, results]
 import std/[nativesockets, net, hashes]
 import tables, strutils, sets
-import multicodec, multihash, multibase, transcoder, vbuffer, peerid,
-       protobuf/minprotobuf, errors, utility
-import stew/[base58, base32, endians2, results]
-export results, minprotobuf, vbuffer, utility
+import
+  multicodec,
+  multihash,
+  multibase,
+  transcoder,
+  vbuffer,
+  peerid,
+  protobuf/minprotobuf,
+  errors,
+  utility
+import stew/[base58, base32, endians2]
+export results, vbuffer, errors, utility
 
 logScope:
   topics = "libp2p multiaddress"
 
 type
   MAKind* = enum
-    None, Fixed, Length, Path, Marker
+    None
+    Fixed
+    Length
+    Path
+    Marker
 
   MAProtocol* = object
     mcodec*: MultiCodec
@@ -37,7 +49,9 @@ type
     data: VBuffer
 
   MaPatternOp* = enum
-    Eq, Or, And
+    Eq
+    Or
+    And
 
   MaPattern* = object
     operator*: MaPatternOp
@@ -57,6 +71,9 @@ type
     tcpProtocol
     udpProtocol
 
+func maErr*(msg: string): ref MaError =
+  (ref MaError)(msg: msg)
+
 const
   # These are needed in order to avoid an ambiguity error stemming from
   # some cint constants with the same name defined in the posix modules
@@ -128,17 +145,11 @@ template pathStringToBuffer(s: string, vb: var VBuffer): bool =
 
 template pathBufferToString(vb: var VBuffer, s: var string): bool =
   s = ""
-  if (vb.readSeq(s) > 0) and (len(s) > 0):
-    true
-  else:
-    false
+  if (vb.readSeq(s) > 0) and (len(s) > 0): true else: false
 
 template pathBufferToStringNoSlash(vb: var VBuffer, s: var string): bool =
   s = ""
-  if (vb.readSeq(s) > 0) and (len(s) > 0) and (s.find('/') == -1):
-    true
-  else:
-    false
+  if (vb.readSeq(s) > 0) and (len(s) > 0) and (s.find('/') == -1): true else: false
 
 template pathValidateBuffer(vb: var VBuffer): bool =
   var s = ""
@@ -177,8 +188,7 @@ proc portBtS(vb: var VBuffer, s: var string): bool =
   ## Port number bufferToString() implementation.
   var port: array[2, byte]
   if vb.readArray(port) == 2:
-    let nport =
-      (safeConvert[uint16](port[0]) shl 8) or safeConvert[uint16](port[1])
+    let nport = (safeConvert[uint16](port[0]) shl 8) or safeConvert[uint16](port[1])
     s = $nport
     result = true
 
@@ -238,8 +248,7 @@ proc onionBtS(vb: var VBuffer, s: var string): bool =
   ## ONION address bufferToString() implementation.
   var buf: array[12, byte]
   if vb.readArray(buf) == 12:
-    let nport =
-      (safeConvert[uint16](buf[10]) shl 8) or safeConvert[uint16](buf[11])
+    let nport = (safeConvert[uint16](buf[10]) shl 8) or safeConvert[uint16](buf[11])
     s = Base32Lower.encode(buf.toOpenArray(0, 9))
     s.add(":")
     s.add($nport)
@@ -273,8 +282,7 @@ proc onion3BtS(vb: var VBuffer, s: var string): bool =
   ## ONION address bufferToString() implementation.
   var buf: array[37, byte]
   if vb.readArray(buf) == 37:
-    var nport =
-      (safeConvert[uint16](buf[35]) shl 8) or safeConvert[uint16](buf[36])
+    var nport = (safeConvert[uint16](buf[35]) shl 8) or safeConvert[uint16](buf[36])
     s = Base32Lower.encode(buf.toOpenArray(0, 34))
     s.add(":")
     s.add($nport)
@@ -326,155 +334,65 @@ proc mapAnd*(args: varargs[MaPattern]): MaPattern =
   result.args = @args
 
 const
-  TranscoderIP4* = Transcoder(
-    stringToBuffer: ip4StB,
-    bufferToString: ip4BtS,
-    validateBuffer: ip4VB
-  )
-  TranscoderIP6* = Transcoder(
-    stringToBuffer: ip6StB,
-    bufferToString: ip6BtS,
-    validateBuffer: ip6VB
-  )
+  TranscoderIP4* =
+    Transcoder(stringToBuffer: ip4StB, bufferToString: ip4BtS, validateBuffer: ip4VB)
+  TranscoderIP6* =
+    Transcoder(stringToBuffer: ip6StB, bufferToString: ip6BtS, validateBuffer: ip6VB)
   TranscoderIP6Zone* = Transcoder(
-    stringToBuffer: ip6zoneStB,
-    bufferToString: ip6zoneBtS,
-    validateBuffer: ip6zoneVB
-  )
-  TranscoderUnix* = Transcoder(
-    stringToBuffer: unixStB,
-    bufferToString: unixBtS,
-    validateBuffer: unixVB
-  )
-  TranscoderP2P* = Transcoder(
-    stringToBuffer: p2pStB,
-    bufferToString: p2pBtS,
-    validateBuffer: p2pVB
-  )
-  TranscoderPort* = Transcoder(
-    stringToBuffer: portStB,
-    bufferToString: portBtS,
-    validateBuffer: portVB
+    stringToBuffer: ip6zoneStB, bufferToString: ip6zoneBtS, validateBuffer: ip6zoneVB
   )
+  TranscoderUnix* =
+    Transcoder(stringToBuffer: unixStB, bufferToString: unixBtS, validateBuffer: unixVB)
+  TranscoderP2P* =
+    Transcoder(stringToBuffer: p2pStB, bufferToString: p2pBtS, validateBuffer: p2pVB)
+  TranscoderPort* =
+    Transcoder(stringToBuffer: portStB, bufferToString: portBtS, validateBuffer: portVB)
   TranscoderOnion* = Transcoder(
-    stringToBuffer: onionStB,
-    bufferToString: onionBtS,
-    validateBuffer: onionVB
+    stringToBuffer: onionStB, bufferToString: onionBtS, validateBuffer: onionVB
   )
   TranscoderOnion3* = Transcoder(
-    stringToBuffer: onion3StB,
-    bufferToString: onion3BtS,
-    validateBuffer: onion3VB
-  )
-  TranscoderDNS* = Transcoder(
-    stringToBuffer: dnsStB,
-    bufferToString: dnsBtS,
-    validateBuffer: dnsVB
+    stringToBuffer: onion3StB, bufferToString: onion3BtS, validateBuffer: onion3VB
   )
+  TranscoderDNS* =
+    Transcoder(stringToBuffer: dnsStB, bufferToString: dnsBtS, validateBuffer: dnsVB)
   ProtocolsList = [
+    MAProtocol(mcodec: multiCodec("ip4"), kind: Fixed, size: 4, coder: TranscoderIP4),
+    MAProtocol(mcodec: multiCodec("tcp"), kind: Fixed, size: 2, coder: TranscoderPort),
+    MAProtocol(mcodec: multiCodec("udp"), kind: Fixed, size: 2, coder: TranscoderPort),
+    MAProtocol(mcodec: multiCodec("ip6"), kind: Fixed, size: 16, coder: TranscoderIP6),
+    MAProtocol(mcodec: multiCodec("dccp"), kind: Fixed, size: 2, coder: TranscoderPort),
+    MAProtocol(mcodec: multiCodec("sctp"), kind: Fixed, size: 2, coder: TranscoderPort),
+    MAProtocol(mcodec: multiCodec("udt"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("utp"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("http"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("https"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("quic"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("quic-v1"), kind: Marker, size: 0),
     MAProtocol(
-      mcodec: multiCodec("ip4"), kind: Fixed, size: 4,
-      coder: TranscoderIP4
+      mcodec: multiCodec("ip6zone"), kind: Length, size: 0, coder: TranscoderIP6Zone
     ),
     MAProtocol(
-      mcodec: multiCodec("tcp"), kind: Fixed, size: 2,
-      coder: TranscoderPort
+      mcodec: multiCodec("onion"), kind: Fixed, size: 10, coder: TranscoderOnion
     ),
     MAProtocol(
-      mcodec: multiCodec("udp"), kind: Fixed, size: 2,
-      coder: TranscoderPort
+      mcodec: multiCodec("onion3"), kind: Fixed, size: 37, coder: TranscoderOnion3
     ),
+    MAProtocol(mcodec: multiCodec("ws"), kind: Marker, size: 0),
+    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),
+    MAProtocol(mcodec: multiCodec("p2p"), kind: Length, size: 0, coder: TranscoderP2P),
+    MAProtocol(mcodec: multiCodec("unix"), kind: Path, size: 0, coder: TranscoderUnix),
+    MAProtocol(mcodec: multiCodec("dns"), kind: Length, size: 0, coder: TranscoderDNS),
+    MAProtocol(mcodec: multiCodec("dns4"), kind: Length, size: 0, coder: TranscoderDNS),
+    MAProtocol(mcodec: multiCodec("dns6"), kind: Length, size: 0, coder: TranscoderDNS),
     MAProtocol(
-      mcodec: multiCodec("ip6"), kind: Fixed, size: 16,
-      coder: TranscoderIP6
+      mcodec: multiCodec("dnsaddr"), kind: Length, size: 0, coder: TranscoderDNS
     ),
-    MAProtocol(
-      mcodec: multiCodec("dccp"), kind: Fixed, size: 2,
-      coder: TranscoderPort
-    ),
-    MAProtocol(
-      mcodec: multiCodec("sctp"), kind: Fixed, size: 2,
-      coder: TranscoderPort
-    ),
-    MAProtocol(
-      mcodec: multiCodec("udt"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("utp"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("http"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("https"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("quic"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("quic-v1"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("ip6zone"), kind: Length, size: 0,
-      coder: TranscoderIP6Zone
-    ),
-    MAProtocol(
-      mcodec: multiCodec("onion"), kind: Fixed, size: 10,
-      coder: TranscoderOnion
-    ),
-    MAProtocol(
-      mcodec: multiCodec("onion3"), kind: Fixed, size: 37,
-      coder: TranscoderOnion3
-    ),
-    MAProtocol(
-      mcodec: multiCodec("ws"), kind: Marker, size: 0
-    ),
-    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
-    ),
-    MAProtocol(
-      mcodec: multiCodec("p2p"), kind: Length, size: 0,
-      coder: TranscoderP2P
-    ),
-    MAProtocol(
-      mcodec: multiCodec("unix"), kind: Path, size: 0,
-      coder: TranscoderUnix
-    ),
-    MAProtocol(
-      mcodec: multiCodec("dns"), kind: Length, size: 0,
-      coder: TranscoderDNS
-    ),
-    MAProtocol(
-      mcodec: multiCodec("dns4"), kind: Length, size: 0,
-      coder: TranscoderDNS
-    ),
-    MAProtocol(
-      mcodec: multiCodec("dns6"), kind: Length, size: 0,
-      coder: TranscoderDNS
-    ),
-    MAProtocol(
-      mcodec: multiCodec("dnsaddr"), kind: Length, size: 0,
-      coder: TranscoderDNS
-    ),
-    MAProtocol(
-      mcodec: multiCodec("p2p-circuit"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("p2p-websocket-star"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("p2p-webrtc-star"), kind: Marker, size: 0
-    ),
-    MAProtocol(
-      mcodec: multiCodec("p2p-webrtc-direct"), kind: Marker, size: 0
-    )
+    MAProtocol(mcodec: multiCodec("p2p-circuit"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("p2p-websocket-star"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("p2p-webrtc-star"), kind: Marker, size: 0),
+    MAProtocol(mcodec: multiCodec("p2p-webrtc-direct"), kind: Marker, size: 0),
   ]
 
   DNSANY* = mapEq("dns")
@@ -493,7 +411,12 @@ const
   UDP_IP* = mapAnd(IP, mapEq("udp"))
   UDP* = mapOr(UDP_DNS, UDP_IP)
   UTP* = mapAnd(UDP, mapEq("utp"))
-  QUIC* = mapAnd(UDP, mapEq("quic"))
+  QUIC_IP* = mapAnd(UDP_IP, mapEq("quic"))
+  QUIC_DNS* = mapAnd(UDP_DNS, mapEq("quic"))
+  QUIC* = mapOr(QUIC_DNS, QUIC_IP)
+  QUIC_V1_IP* = mapAnd(UDP_IP, mapEq("quic-v1"))
+  QUIC_V1_DNS* = mapAnd(UDP_DNS, mapEq("quic-v1"))
+  QUIC_V1* = mapOr(QUIC_V1_DNS, QUIC_V1_IP)
   UNIX* = mapEq("unix")
   WS_DNS* = mapAnd(TCP_DNS, mapEq("ws"))
   WS_IP* = mapAnd(TCP_IP, mapEq("ws"))
@@ -517,31 +440,24 @@ const
   IPFS* = mapAnd(Reliable, P2PPattern)
 
   HTTP* = mapOr(
-    mapAnd(TCP, mapEq("http")),
-    mapAnd(IP, mapEq("http")),
-    mapAnd(DNS, mapEq("http"))
+    mapAnd(TCP, mapEq("http")), mapAnd(IP, mapEq("http")), mapAnd(DNS, mapEq("http"))
   )
 
   HTTPS* = mapOr(
-    mapAnd(TCP, mapEq("https")),
-    mapAnd(IP, mapEq("https")),
-    mapAnd(DNS, mapEq("https"))
+    mapAnd(TCP, mapEq("https")), mapAnd(IP, mapEq("https")), mapAnd(DNS, mapEq("https"))
   )
 
   WebRTCDirect* = mapOr(
-    mapAnd(HTTP, mapEq("p2p-webrtc-direct")),
-    mapAnd(HTTPS, mapEq("p2p-webrtc-direct"))
+    mapAnd(HTTP, mapEq("p2p-webrtc-direct")), mapAnd(HTTPS, mapEq("p2p-webrtc-direct"))
   )
 
   CircuitRelay* = mapEq("p2p-circuit")
 
-proc initMultiAddressCodeTable(): Table[MultiCodec,
-                                        MAProtocol] {.compileTime.} =
+proc initMultiAddressCodeTable(): Table[MultiCodec, MAProtocol] {.compileTime.} =
   for item in ProtocolsList:
     result[item.mcodec] = item
 
-const
-  CodeAddresses = initMultiAddressCodeTable()
+const CodeAddresses = initMultiAddressCodeTable()
 
 proc trimRight(s: string, ch: char): string =
   ## Consume trailing characters ``ch`` from string ``s`` and return result.
@@ -551,7 +467,7 @@ proc trimRight(s: string, ch: char): string =
       inc(m)
     else:
       break
-  result = s[0..(s.high - m)]
+  result = s[0 .. (s.high - m)]
 
 proc protoCode*(ma: MultiAddress): MaResult[MultiCodec] =
   ## Returns MultiAddress ``ma`` protocol code.
@@ -579,8 +495,7 @@ proc protoName*(ma: MultiAddress): MaResult[string] =
     else:
       ok($(proto.mcodec))
 
-proc protoArgument*(ma: MultiAddress,
-                    value: var openArray[byte]): MaResult[int] =
+proc protoArgument*(ma: MultiAddress, value: var openArray[byte]): MaResult[int] =
   ## Returns MultiAddress ``ma`` protocol argument value.
   ##
   ## If current MultiAddress do not have argument value, then result will be
@@ -599,7 +514,7 @@ proc protoArgument*(ma: MultiAddress,
       if proto.kind == Fixed:
         res = proto.size
         if len(value) >= res and
-          vb.data.readArray(value.toOpenArray(0, proto.size - 1)) != proto.size:
+            vb.data.readArray(value.toOpenArray(0, proto.size - 1)) != proto.size:
           err("multiaddress: Decoding protocol error")
         else:
           ok(res)
@@ -620,7 +535,7 @@ proc protoAddress*(ma: MultiAddress): MaResult[seq[byte]] =
   ## If current MultiAddress do not have argument value, then result array will
   ## be empty.
   var buffer = newSeq[byte](len(ma.data.buffer))
-  let res = ? protoArgument(ma, buffer)
+  let res = ?protoArgument(ma, buffer)
   buffer.setLen(res)
   ok(buffer)
 
@@ -639,7 +554,8 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
   var res: MultiAddress
   res.data = initVBuffer()
 
-  if index < 0: return err("multiaddress: negative index gived to getPart")
+  if index < 0:
+    return err("multiaddress: negative index gived to getPart")
 
   while offset <= index:
     if vb.data.readVarint(header) == -1:
@@ -648,7 +564,6 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
     let proto = CodeAddresses.getOrDefault(MultiCodec(header))
     if proto.kind == None:
       return err("multiaddress: Unsupported protocol '" & $header & "'")
-
     elif proto.kind == Fixed:
       data.setLen(proto.size)
       if vb.data.readArray(data) != proto.size:
@@ -673,26 +588,29 @@ proc getPart(ma: MultiAddress, index: int): MaResult[MultiAddress] =
     inc(offset)
   ok(res)
 
-proc getParts[U, V](ma: MultiAddress,
-                    slice: HSlice[U, V]): MaResult[MultiAddress] =
+proc getParts[U, V](ma: MultiAddress, slice: HSlice[U, V]): MaResult[MultiAddress] =
   when slice.a is BackwardsIndex or slice.b is BackwardsIndex:
-    let maLength = ? len(ma)
+    let maLength = ?len(ma)
   template normalizeIndex(index): int =
-    when index is BackwardsIndex: maLength - int(index)
-    else: int(index)
+    when index is BackwardsIndex:
+      maLength - int(index)
+    else:
+      int(index)
+
   let
     indexStart = normalizeIndex(slice.a)
     indexEnd = normalizeIndex(slice.b)
   var res: MultiAddress
-  for i in indexStart..indexEnd:
-    ? res.append(? ma[i])
+  for i in indexStart .. indexEnd:
+    ?res.append(?ma[i])
   ok(res)
 
-proc `[]`*(ma: MultiAddress,
-           i: int | BackwardsIndex): MaResult[MultiAddress] {.inline.} =
+proc `[]`*(
+    ma: MultiAddress, i: int | BackwardsIndex
+): MaResult[MultiAddress] {.inline.} =
   ## Returns part with index ``i`` of MultiAddress ``ma``.
   when i is BackwardsIndex:
-    let maLength = ? len(ma)
+    let maLength = ?len(ma)
     ma.getPart(maLength - int(i))
   else:
     ma.getPart(i)
@@ -716,9 +634,7 @@ iterator items*(ma: MultiAddress): MaResult[MultiAddress] =
 
     let proto = CodeAddresses.getOrDefault(MultiCodec(header))
     if proto.kind == None:
-      yield err(MaResult[MultiAddress], "Unsupported protocol '" &
-                $header & "'")
-
+      yield err(MaResult[MultiAddress], "Unsupported protocol '" & $header & "'")
     elif proto.kind == Fixed:
       data.setLen(proto.size)
       if vb.data.readArray(data) != proto.size:
@@ -740,7 +656,8 @@ iterator items*(ma: MultiAddress): MaResult[MultiAddress] =
 proc len*(ma: MultiAddress): MaResult[int] =
   var counter: int
   for part in ma:
-    if part.isErr: return err(part.error)
+    if part.isErr:
+      return err(part.error)
     counter.inc()
   ok(counter)
 
@@ -753,8 +670,7 @@ proc contains*(ma: MultiAddress, codec: MultiCodec): MaResult[bool] {.inline.} =
       return ok(true)
   ok(false)
 
-proc `[]`*(ma: MultiAddress,
-           codec: MultiCodec): MaResult[MultiAddress] {.inline.} =
+proc `[]`*(ma: MultiAddress, codec: MultiCodec): MaResult[MultiAddress] {.inline.} =
   ## Returns partial MultiAddress with MultiCodec ``codec`` and present in
   ## MultiAddress ``ma``.
   for item in ma.items:
@@ -779,13 +695,12 @@ proc toString*(value: MultiAddress): MaResult[string] =
       return err("multiaddress: Unsupported protocol '" & $header & "'")
     if proto.kind in {Fixed, Length, Path}:
       if isNil(proto.coder.bufferToString):
-        return err("multiaddress: Missing protocol '" & $(proto.mcodec) &
-                   "' coder")
+        return err("multiaddress: Missing protocol '" & $(proto.mcodec) & "' coder")
       if not proto.coder.bufferToString(vb.data, part):
         return err("multiaddress: Decoding protocol error")
       parts.add($(proto.mcodec))
       if len(part) > 0 and (proto.kind == Path) and (part[0] == '/'):
-        parts.add(part[1..^1])
+        parts.add(part[1 ..^ 1])
       else:
         parts.add(part)
     elif proto.kind == Marker:
@@ -797,8 +712,10 @@ proc toString*(value: MultiAddress): MaResult[string] =
 proc `$`*(value: MultiAddress): string =
   ## Return string representation of MultiAddress ``value``.
   let s = value.toString()
-  if s.isErr: s.error
-  else: s[]
+  if s.isErr:
+    s.error
+  else:
+    s[]
 
 proc protocols*(value: MultiAddress): MaResult[seq[MultiCodec]] =
   ## Returns list of protocol codecs inside of MultiAddress ``value``.
@@ -815,8 +732,9 @@ proc write*(vb: var VBuffer, ma: MultiAddress) {.inline.} =
   ## Write MultiAddress value ``ma`` to buffer ``vb``.
   vb.writeArray(ma.data.buffer)
 
-proc encode*(mbtype: typedesc[MultiBase], encoding: string,
-             ma: MultiAddress): string {.inline.} =
+proc encode*(
+    mbtype: typedesc[MultiBase], encoding: string, ma: MultiAddress
+): string {.inline.} =
   ## Get MultiBase encoded representation of ``ma`` using encoding
   ## ``encoding``.
   result = MultiBase.encode(encoding, ma.data.buffer)
@@ -843,8 +761,8 @@ proc validate*(ma: MultiAddress): bool =
   result = true
 
 proc init*(
-    mtype: typedesc[MultiAddress], protocol: MultiCodec,
-    value: openArray[byte] = []): MaResult[MultiAddress] =
+    mtype: typedesc[MultiAddress], protocol: MultiCodec, value: openArray[byte] = []
+): MaResult[MultiAddress] =
   ## Initialize MultiAddress object from protocol id ``protocol`` and array
   ## of bytes ``value``.
   let proto = CodeAddresses.getOrDefault(protocol)
@@ -874,19 +792,21 @@ proc init*(
     of None:
       raiseAssert "None checked above"
 
-proc init*(mtype: typedesc[MultiAddress], protocol: MultiCodec,
-           value: PeerId): MaResult[MultiAddress] {.inline.} =
+proc init*(
+    mtype: typedesc[MultiAddress], protocol: MultiCodec, value: PeerId
+): MaResult[MultiAddress] {.inline.} =
   ## Initialize MultiAddress object from protocol id ``protocol`` and peer id
   ## ``value``.
   init(mtype, protocol, value.data)
 
-proc init*(mtype: typedesc[MultiAddress], protocol: MultiCodec,
-           value: int): MaResult[MultiAddress] =
+proc init*(
+    mtype: typedesc[MultiAddress], protocol: MultiCodec, value: int
+): MaResult[MultiAddress] =
   ## Initialize MultiAddress object from protocol id ``protocol`` and integer
   ## ``value``. This procedure can be used to instantiate ``tcp``, ``udp``,
   ## ``dccp`` and ``sctp`` MultiAddresses.
-  var allowed = [multiCodec("tcp"), multiCodec("udp"), multiCodec("dccp"),
-                 multiCodec("sctp")]
+  var allowed =
+    [multiCodec("tcp"), multiCodec("udp"), multiCodec("dccp"), multiCodec("sctp")]
   if protocol notin allowed:
     err("multiaddress: Incorrect protocol for integer value")
   else:
@@ -906,8 +826,7 @@ proc getProtocol(name: string): MAProtocol {.inline.} =
   if mc != InvalidMultiCodec:
     result = CodeAddresses.getOrDefault(mc)
 
-proc init*(mtype: typedesc[MultiAddress],
-           value: string): MaResult[MultiAddress] =
+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!")
@@ -926,8 +845,7 @@ proc init*(mtype: typedesc[MultiAddress],
       else:
         if proto.kind in {Fixed, Length, Path}:
           if isNil(proto.coder.stringToBuffer):
-            return err("multiaddress: Missing protocol '" &
-                        part & "' transcoder")
+            return err("multiaddress: Missing protocol '" & part & "' transcoder")
 
           if offset + 1 >= len(parts):
             return err("multiaddress: Missing protocol '" & part & "' argument")
@@ -936,16 +854,15 @@ proc init*(mtype: typedesc[MultiAddress],
           res.data.write(proto.mcodec)
           let res = proto.coder.stringToBuffer(parts[offset + 1], res.data)
           if not res:
-            return err("multiaddress: Error encoding `" & part & "/" &
-                       parts[offset + 1] & "`")
+            return err(
+              "multiaddress: Error encoding `" & part & "/" & parts[offset + 1] & "`"
+            )
           offset += 2
-
         elif proto.kind == Path:
-          var path = "/" & (parts[(offset + 1)..^1].join("/"))
+          var path = "/" & (parts[(offset + 1) ..^ 1].join("/"))
           res.data.write(proto.mcodec)
           if not proto.coder.stringToBuffer(path, res.data):
-            return err("multiaddress: Error encoding `" & part & "/" &
-                       path & "`")
+            return err("multiaddress: Error encoding `" & part & "/" & path & "`")
 
           break
         elif proto.kind == Marker:
@@ -954,8 +871,9 @@ proc init*(mtype: typedesc[MultiAddress],
     res.data.finish()
     ok(res)
 
-proc init*(mtype: typedesc[MultiAddress],
-           data: openArray[byte]): MaResult[MultiAddress] =
+proc init*(
+    mtype: typedesc[MultiAddress], data: openArray[byte]
+): MaResult[MultiAddress] =
   ## Initialize MultiAddress with array of bytes ``data``.
   if len(data) == 0:
     err("multiaddress: Address must not be empty!")
@@ -973,38 +891,55 @@ proc init*(mtype: typedesc[MultiAddress]): MultiAddress =
   ## Initialize empty MultiAddress.
   result.data = initVBuffer()
 
-proc init*(mtype: typedesc[MultiAddress], address: IpAddress,
-           protocol: IpTransportProtocol, port: Port): MultiAddress =
+proc init*(
+    mtype: typedesc[MultiAddress],
+    address: IpAddress,
+    protocol: IpTransportProtocol,
+    port: Port,
+): MultiAddress =
   var res: MultiAddress
   res.data = initVBuffer()
   let
-    networkProto = case address.family
-      of IpAddressFamily.IPv4: getProtocol("ip4")
-      of IpAddressFamily.IPv6: getProtocol("ip6")
+    networkProto =
+      case address.family
+      of IpAddressFamily.IPv4:
+        getProtocol("ip4")
+      of IpAddressFamily.IPv6:
+        getProtocol("ip6")
 
-    transportProto = case protocol
-      of tcpProtocol: getProtocol("tcp")
-      of udpProtocol: getProtocol("udp")
+    transportProto =
+      case protocol
+      of tcpProtocol:
+        getProtocol("tcp")
+      of udpProtocol:
+        getProtocol("udp")
 
   res.data.write(networkProto.mcodec)
   case address.family
-    of IpAddressFamily.IPv4: res.data.writeArray(address.address_v4)
-    of IpAddressFamily.IPv6: res.data.writeArray(address.address_v6)
+  of IpAddressFamily.IPv4:
+    res.data.writeArray(address.address_v4)
+  of IpAddressFamily.IPv6:
+    res.data.writeArray(address.address_v6)
   res.data.write(transportProto.mcodec)
   res.data.writeArray(toBytesBE(uint16(port)))
   res.data.finish()
   res
 
-proc init*(mtype: typedesc[MultiAddress], address: TransportAddress,
-           protocol = IPPROTO_TCP): MaResult[MultiAddress] =
+proc init*(
+    mtype: typedesc[MultiAddress], address: TransportAddress, protocol = IPPROTO_TCP
+): MaResult[MultiAddress] =
   ## Initialize MultiAddress using chronos.TransportAddress (IPv4/IPv6/Unix)
   ## and protocol information (UDP/TCP).
   var res: MultiAddress
   res.data = initVBuffer()
-  let protoProto = case protocol
-                   of IPPROTO_TCP: getProtocol("tcp")
-                   of IPPROTO_UDP: getProtocol("udp")
-                   else: default(MAProtocol)
+  let protoProto =
+    case protocol
+    of IPPROTO_TCP:
+      getProtocol("tcp")
+    of IPPROTO_UDP:
+      getProtocol("udp")
+    else:
+      default(MAProtocol)
   if protoProto.size == 0:
     return err("multiaddress: protocol should be either TCP or UDP")
   if address.family == AddressFamily.IPv4:
@@ -1043,25 +978,21 @@ proc append*(m1: var MultiAddress, m2: MultiAddress): MaResult[void] =
   else:
     ok()
 
-proc `&`*(m1, m2: MultiAddress): MultiAddress {.
-     raises: [LPError].} =
+proc `&`*(m1, m2: MultiAddress): MultiAddress {.raises: [MaError].} =
   ## Concatenates two addresses ``m1`` and ``m2``, and returns result.
   ##
   ## This procedure performs validation of concatenated result and can raise
   ## exception on error.
-  ##
+  concat(m1, m2).valueOr:
+    raise maErr error
 
-  concat(m1, m2).tryGet()
-
-proc `&=`*(m1: var MultiAddress, m2: MultiAddress) {.
-     raises: [LPError].} =
+proc `&=`*(m1: var MultiAddress, m2: MultiAddress) {.raises: [MaError].} =
   ## Concatenates two addresses ``m1`` and ``m2``.
   ##
   ## This procedure performs validation of concatenated result and can raise
   ## exception on error.
-  ##
-
-  m1.append(m2).tryGet()
+  m1.append(m2).isOkOr:
+    raise maErr error
 
 proc `==`*(m1: var MultiAddress, m2: MultiAddress): bool =
   ## Check of two MultiAddress are equal
@@ -1076,13 +1007,12 @@ proc matchPart(pat: MaPattern, protos: seq[MultiCodec]): MaPatResult =
       let res = a.matchPart(pcs)
       if res.flag:
         #Greedy Or
-        if result.flag == false or
-             result.rem.len > res.rem.len:
+        if result.flag == false or result.rem.len > res.rem.len:
           result = res
   elif pat.operator == And:
     if len(pcs) < len(pat.args):
       return MaPatResult(flag: false, rem: empty)
-    for i in 0..<len(pat.args):
+    for i in 0 ..< len(pat.args):
       let res = pat.args[i].matchPart(pcs)
       if not res.flag:
         return MaPatResult(flag: false, rem: res.rem)
@@ -1092,20 +1022,22 @@ proc matchPart(pat: MaPattern, protos: seq[MultiCodec]): MaPatResult =
     if len(pcs) == 0:
       return MaPatResult(flag: false, rem: empty)
     if pcs[0] == pat.value:
-      return MaPatResult(flag: true, rem: pcs[1..^1])
+      return MaPatResult(flag: true, rem: pcs[1 ..^ 1])
     result = MaPatResult(flag: false, rem: empty)
 
 proc match*(pat: MaPattern, address: MultiAddress): bool =
   ## Match full ``address`` using pattern ``pat`` and return ``true`` if
   ## ``address`` satisfies pattern.
-  let protos = address.protocols().valueOr: return false
+  let 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().valueOr: return false
+  let protos = address.protocols().valueOr:
+    return false
   let res = matchPart(pat, protos)
   res.flag
 
@@ -1127,21 +1059,21 @@ proc bytes*(value: MultiAddress): seq[byte] =
 proc write*(pb: var ProtoBuffer, field: int, value: MultiAddress) {.inline.} =
   write(pb, field, value.data.buffer)
 
-proc getField*(pb: ProtoBuffer, field: int,
-               value: var MultiAddress): ProtoResult[bool] {.
-     inline.} =
+proc getField*(
+    pb: ProtoBuffer, field: int, value: var MultiAddress
+): ProtoResult[bool] {.inline.} =
   var buffer: seq[byte]
-  let res = ? pb.getField(field, buffer)
-  if not(res):
+  let res = ?pb.getField(field, buffer)
+  if not (res):
     ok(false)
   else:
     value = MultiAddress.init(buffer).valueOr:
       return err(ProtoError.IncorrectBlob)
     ok(true)
 
-proc getRepeatedField*(pb: ProtoBuffer, field: int,
-                       value: var seq[MultiAddress]): ProtoResult[bool] {.
-     inline.} =
+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
@@ -1151,8 +1083,8 @@ proc getRepeatedField*(pb: ProtoBuffer, field: int,
   ## returned and value contains the parsed values.
   var items: seq[seq[byte]]
   value.setLen(0)
-  let res = ? pb.getRepeatedField(field, items)
-  if not(res):
+  let res = ?pb.getRepeatedField(field, items)
+  if not (res):
     ok(false)
   else:
     for item in items:

libp2p/multibase.nim

@@ -20,7 +20,12 @@ import stew/[base32, base58, base64, results]
 
 type
   MultiBaseStatus* {.pure.} = enum
-    Error, Success, Overrun, Incorrect, BadCodec, NotSupported
+    Error
+    Success
+    Overrun
+    Incorrect
+    BadCodec
+    NotSupported
 
   MultiBase* = object
 
@@ -29,17 +34,18 @@ type
   MBCodec = object
     code: char
     name: string
-    encr: proc(inbytes: openArray[byte],
-               outbytes: var openArray[char],
-               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: [].}
+    encr: proc(
+      inbytes: openArray[byte], outbytes: var openArray[char], 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: [].}
     encl: MBCodeSize
     decl: MBCodeSize
 
-proc idd(inbytes: openArray[char], outbytes: var openArray[byte],
-         outlen: var int): MultiBaseStatus =
+proc idd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   let length = len(inbytes)
   if length > len(outbytes):
     outlen = length
@@ -49,9 +55,9 @@ proc idd(inbytes: openArray[char], outbytes: var openArray[byte],
     outlen = length
     result = MultiBaseStatus.Success
 
-proc ide(inbytes: openArray[byte],
-         outbytes: var openArray[char],
-         outlen: var int): MultiBaseStatus =
+proc ide(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   let length = len(inbytes)
   if length > len(outbytes):
     outlen = length
@@ -61,31 +67,37 @@ proc ide(inbytes: openArray[byte],
     outlen = length
     result = MultiBaseStatus.Success
 
-proc idel(length: int): int = length
-proc iddl(length: int): int = length
+proc idel(length: int): int =
+  length
 
-proc b16d(inbytes: openArray[char],
-          outbytes: var openArray[byte],
-          outlen: var int): MultiBaseStatus =
+proc iddl(length: int): int =
+  length
+
+proc b16d(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   discard
 
-proc b16e(inbytes: openArray[byte],
-          outbytes: var openArray[char],
-          outlen: var int): MultiBaseStatus =
+proc b16e(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   discard
 
-proc b16ud(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b16ud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   discard
 
-proc b16ue(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b16ue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   discard
 
-proc b16el(length: int): int = length shl 1
-proc b16dl(length: int): int = (length + 1) div 2
+proc b16el(length: int): int =
+  length shl 1
+
+proc b16dl(length: int): int =
+  (length + 1) div 2
 
 proc b32ce(r: Base32Status): MultiBaseStatus {.inline.} =
   result = MultiBaseStatus.Error
@@ -114,218 +126,253 @@ proc b64ce(r: Base64Status): MultiBaseStatus {.inline.} =
   elif r == Base64Status.Success:
     result = MultiBaseStatus.Success
 
-proc b32hd(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b32hd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32Lower.decode(inbytes, outbytes, outlen))
 
-proc b32he(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b32he(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32Lower.encode(inbytes, outbytes, outlen))
 
-proc b32hud(inbytes: openArray[char],
-            outbytes: var openArray[byte],
-            outlen: var int): MultiBaseStatus =
+proc b32hud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32Upper.decode(inbytes, outbytes, outlen))
 
-proc b32hue(inbytes: openArray[byte],
-            outbytes: var openArray[char],
-            outlen: var int): MultiBaseStatus =
+proc b32hue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32Upper.encode(inbytes, outbytes, outlen))
 
-proc b32hpd(inbytes: openArray[char],
-            outbytes: var openArray[byte],
-            outlen: var int): MultiBaseStatus =
+proc b32hpd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32LowerPad.decode(inbytes, outbytes, outlen))
 
-proc b32hpe(inbytes: openArray[byte],
-            outbytes: var openArray[char],
-            outlen: var int): MultiBaseStatus =
+proc b32hpe(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32LowerPad.encode(inbytes, outbytes, outlen))
 
-proc b32hpud(inbytes: openArray[char],
-             outbytes: var openArray[byte],
-             outlen: var int): MultiBaseStatus =
+proc b32hpud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32UpperPad.decode(inbytes, outbytes, outlen))
 
-proc b32hpue(inbytes: openArray[byte],
-             outbytes: var openArray[char],
-             outlen: var int): MultiBaseStatus =
+proc b32hpue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(HexBase32UpperPad.encode(inbytes, outbytes, outlen))
 
-proc b32d(inbytes: openArray[char],
-          outbytes: var openArray[byte],
-          outlen: var int): MultiBaseStatus =
+proc b32d(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32Lower.decode(inbytes, outbytes, outlen))
 
-proc b32e(inbytes: openArray[byte],
-          outbytes: var openArray[char],
-          outlen: var int): MultiBaseStatus =
+proc b32e(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32Lower.encode(inbytes, outbytes, outlen))
 
-proc b32ud(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b32ud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32Upper.decode(inbytes, outbytes, outlen))
 
-proc b32ue(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b32ue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32Upper.encode(inbytes, outbytes, outlen))
 
-proc b32pd(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b32pd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32LowerPad.decode(inbytes, outbytes, outlen))
 
-proc b32pe(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b32pe(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32LowerPad.encode(inbytes, outbytes, outlen))
 
-proc b32pud(inbytes: openArray[char],
-            outbytes: var openArray[byte],
-            outlen: var int): MultiBaseStatus =
+proc b32pud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32UpperPad.decode(inbytes, outbytes, outlen))
 
-proc b32pue(inbytes: openArray[byte],
-            outbytes: var openArray[char],
-            outlen: var int): MultiBaseStatus =
+proc b32pue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b32ce(Base32UpperPad.encode(inbytes, outbytes, outlen))
 
-proc b32el(length: int): int = Base32Lower.encodedLength(length)
-proc b32dl(length: int): int = Base32Lower.decodedLength(length)
-proc b32pel(length: int): int = Base32LowerPad.encodedLength(length)
-proc b32pdl(length: int): int = Base32LowerPad.decodedLength(length)
+proc b32el(length: int): int =
+  Base32Lower.encodedLength(length)
 
-proc b58fd(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b32dl(length: int): int =
+  Base32Lower.decodedLength(length)
+
+proc b32pel(length: int): int =
+  Base32LowerPad.encodedLength(length)
+
+proc b32pdl(length: int): int =
+  Base32LowerPad.decodedLength(length)
+
+proc b58fd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b58ce(FLCBase58.decode(inbytes, outbytes, outlen))
 
-proc b58fe(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b58fe(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b58ce(FLCBase58.encode(inbytes, outbytes, outlen))
 
-proc b58bd(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b58bd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b58ce(BTCBase58.decode(inbytes, outbytes, outlen))
 
-proc b58be(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b58be(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b58ce(BTCBase58.encode(inbytes, outbytes, outlen))
 
-proc b58el(length: int): int = Base58.encodedLength(length)
-proc b58dl(length: int): int = Base58.decodedLength(length)
+proc b58el(length: int): int =
+  Base58.encodedLength(length)
 
-proc b64el(length: int): int = Base64.encodedLength(length)
-proc b64dl(length: int): int = Base64.decodedLength(length)
-proc b64pel(length: int): int = Base64Pad.encodedLength(length)
-proc b64pdl(length: int): int = Base64Pad.decodedLength(length)
+proc b58dl(length: int): int =
+  Base58.decodedLength(length)
 
-proc b64e(inbytes: openArray[byte],
-          outbytes: var openArray[char],
-          outlen: var int): MultiBaseStatus =
+proc b64el(length: int): int =
+  Base64.encodedLength(length)
+
+proc b64dl(length: int): int =
+  Base64.decodedLength(length)
+
+proc b64pel(length: int): int =
+  Base64Pad.encodedLength(length)
+
+proc b64pdl(length: int): int =
+  Base64Pad.decodedLength(length)
+
+proc b64e(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64.encode(inbytes, outbytes, outlen))
 
-proc b64d(inbytes: openArray[char],
-          outbytes: var openArray[byte],
-          outlen: var int): MultiBaseStatus =
+proc b64d(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64.decode(inbytes, outbytes, outlen))
 
-proc b64pe(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b64pe(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64Pad.encode(inbytes, outbytes, outlen))
 
-proc b64pd(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b64pd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64Pad.decode(inbytes, outbytes, outlen))
 
-proc b64ue(inbytes: openArray[byte],
-           outbytes: var openArray[char],
-           outlen: var int): MultiBaseStatus =
+proc b64ue(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64Url.encode(inbytes, outbytes, outlen))
 
-proc b64ud(inbytes: openArray[char],
-           outbytes: var openArray[byte],
-           outlen: var int): MultiBaseStatus =
+proc b64ud(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64Url.decode(inbytes, outbytes, outlen))
 
-proc b64upe(inbytes: openArray[byte],
-          outbytes: var openArray[char],
-          outlen: var int): MultiBaseStatus =
+proc b64upe(
+    inbytes: openArray[byte], outbytes: var openArray[char], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64UrlPad.encode(inbytes, outbytes, outlen))
 
-proc b64upd(inbytes: openArray[char],
-            outbytes: var openArray[byte],
-            outlen: var int): MultiBaseStatus =
+proc b64upd(
+    inbytes: openArray[char], outbytes: var openArray[byte], outlen: var int
+): MultiBaseStatus =
   result = b64ce(Base64UrlPad.decode(inbytes, outbytes, outlen))
 
-const
-  MultiBaseCodecs = [
-    MBCodec(name: "identity", code: chr(0x00),
-      decr: idd, encr: ide, decl: iddl, encl: idel
-    ),
-    MBCodec(name: "base1", code: '1'),
-    MBCodec(name: "base2", code: '0'),
-    MBCodec(name: "base8", code: '7'),
-    MBCodec(name: "base10", code: '9'),
-    MBCodec(name: "base16", code: 'f',
-      decr: b16d, encr: b16e, decl: b16dl, encl: b16el
-    ),
-    MBCodec(name: "base16upper", code: 'F',
-      decr: b16ud, encr: b16ue, decl: b16dl, encl: b16el
-    ),
-    MBCodec(name: "base32hex", code: 'v',
-      decr: b32hd, encr: b32he, decl: b32dl, encl: b32el
-    ),
-    MBCodec(name: "base32hexupper", code: 'V',
-      decr: b32hud, encr: b32hue, decl: b32dl, encl: b32el
-    ),
-    MBCodec(name: "base32hexpad", code: 't',
-      decr: b32hpd, encr: b32hpe, decl: b32pdl, encl: b32pel
-    ),
-    MBCodec(name: "base32hexpadupper", code: 'T',
-      decr: b32hpud, encr: b32hpue, decl: b32pdl, encl: b32pel
-    ),
-    MBCodec(name: "base32", code: 'b',
-      decr: b32d, encr: b32e, decl: b32dl, encl: b32el
-    ),
-    MBCodec(name: "base32upper", code: 'B',
-      decr: b32ud, encr: b32ue, decl: b32dl, encl: b32el
-    ),
-    MBCodec(name: "base32pad", code: 'c',
-      decr: b32pd, encr: b32pe, decl: b32pdl, encl: b32pel
-    ),
-    MBCodec(name: "base32padupper", code: 'C',
-      decr: b32pud, encr: b32pue, decl: b32pdl, encl: b32pel
-    ),
-    MBCodec(name: "base32z", code: 'h'),
-    MBCodec(name: "base58flickr", code: 'Z',
-      decr: b58fd, encr: b58fe, decl: b58dl, encl: b58el
-    ),
-    MBCodec(name: "base58btc", code: 'z',
-      decr: b58bd, encr: b58be, decl: b58dl, encl: b58el
-    ),
-    MBCodec(name: "base64", code: 'm',
-      decr: b64d, encr: b64e, decl: b64dl, encl: b64el
-    ),
-    MBCodec(name: "base64pad", code: 'M',
-      decr: b64pd, encr: b64pe, decl: b64pdl, encl: b64pel
-    ),
-    MBCodec(name: "base64url", code: 'u',
-      decr: b64ud, encr: b64ue, decl: b64dl, encl: b64el
-    ),
-    MBCodec(name: "base64urlpad", code: 'U',
-      decr: b64upd, encr: b64upe, decl: b64pdl, encl: b64pel
-    )
-  ]
+const MultiBaseCodecs = [
+  MBCodec(
+    name: "identity", code: chr(0x00), decr: idd, encr: ide, decl: iddl, encl: idel
+  ),
+  MBCodec(name: "base1", code: '1'),
+  MBCodec(name: "base2", code: '0'),
+  MBCodec(name: "base8", code: '7'),
+  MBCodec(name: "base10", code: '9'),
+  MBCodec(name: "base16", code: 'f', decr: b16d, encr: b16e, decl: b16dl, encl: b16el),
+  MBCodec(
+    name: "base16upper", code: 'F', decr: b16ud, encr: b16ue, decl: b16dl, encl: b16el
+  ),
+  MBCodec(
+    name: "base32hex", code: 'v', decr: b32hd, encr: b32he, decl: b32dl, encl: b32el
+  ),
+  MBCodec(
+    name: "base32hexupper",
+    code: 'V',
+    decr: b32hud,
+    encr: b32hue,
+    decl: b32dl,
+    encl: b32el,
+  ),
+  MBCodec(
+    name: "base32hexpad",
+    code: 't',
+    decr: b32hpd,
+    encr: b32hpe,
+    decl: b32pdl,
+    encl: b32pel,
+  ),
+  MBCodec(
+    name: "base32hexpadupper",
+    code: 'T',
+    decr: b32hpud,
+    encr: b32hpue,
+    decl: b32pdl,
+    encl: b32pel,
+  ),
+  MBCodec(name: "base32", code: 'b', decr: b32d, encr: b32e, decl: b32dl, encl: b32el),
+  MBCodec(
+    name: "base32upper", code: 'B', decr: b32ud, encr: b32ue, decl: b32dl, encl: b32el
+  ),
+  MBCodec(
+    name: "base32pad", code: 'c', decr: b32pd, encr: b32pe, decl: b32pdl, encl: b32pel
+  ),
+  MBCodec(
+    name: "base32padupper",
+    code: 'C',
+    decr: b32pud,
+    encr: b32pue,
+    decl: b32pdl,
+    encl: b32pel,
+  ),
+  MBCodec(name: "base32z", code: 'h'),
+  MBCodec(
+    name: "base58flickr", code: 'Z', decr: b58fd, encr: b58fe, decl: b58dl, encl: b58el
+  ),
+  MBCodec(
+    name: "base58btc", code: 'z', decr: b58bd, encr: b58be, decl: b58dl, encl: b58el
+  ),
+  MBCodec(name: "base64", code: 'm', decr: b64d, encr: b64e, decl: b64dl, encl: b64el),
+  MBCodec(
+    name: "base64pad", code: 'M', decr: b64pd, encr: b64pe, decl: b64pdl, encl: b64pel
+  ),
+  MBCodec(
+    name: "base64url", code: 'u', decr: b64ud, encr: b64ue, decl: b64dl, encl: b64el
+  ),
+  MBCodec(
+    name: "base64urlpad",
+    code: 'U',
+    decr: b64upd,
+    encr: b64upe,
+    decl: b64pdl,
+    encl: b64pel,
+  ),
+]
 
 proc initMultiBaseCodeTable(): Table[char, MBCodec] {.compileTime.} =
   for item in MultiBaseCodecs:
@@ -339,8 +386,7 @@ const
   CodeMultiBases = initMultiBaseCodeTable()
   NameMultiBases = initMultiBaseNameTable()
 
-proc encodedLength*(mbtype: typedesc[MultiBase], encoding: string,
-                    length: int): int =
+proc encodedLength*(mbtype: typedesc[MultiBase], encoding: string, length: int): int =
   ## Return estimated size of buffer to store MultiBase encoded value with
   ## encoding ``encoding`` of length ``length``.
   ##
@@ -355,8 +401,7 @@ proc encodedLength*(mbtype: typedesc[MultiBase], encoding: string,
     else:
       result = mb.encl(length) + 1
 
-proc decodedLength*(mbtype: typedesc[MultiBase], encoding: char,
-                    length: int): int =
+proc decodedLength*(mbtype: typedesc[MultiBase], encoding: char, length: int): int =
   ## Return estimated size of buffer to store MultiBase decoded value with
   ## encoding character ``encoding`` of length ``length``.
   let mb = CodeMultiBases.getOrDefault(encoding)
@@ -368,9 +413,13 @@ proc decodedLength*(mbtype: typedesc[MultiBase], encoding: char,
     else:
       result = mb.decl(length - 1)
 
-proc encode*(mbtype: typedesc[MultiBase], encoding: string,
-             inbytes: openArray[byte], outbytes: var openArray[char],
-             outlen: var int): MultiBaseStatus =
+proc encode*(
+    mbtype: typedesc[MultiBase],
+    encoding: string,
+    inbytes: openArray[byte],
+    outbytes: var openArray[char],
+    outlen: var int,
+): MultiBaseStatus =
   ## Encode array ``inbytes`` using MultiBase encoding scheme ``encoding`` and
   ## store encoded value to ``outbytes``.
   ##
@@ -392,8 +441,7 @@ proc encode*(mbtype: typedesc[MultiBase], encoding: string,
   if isNil(mb.encr) or isNil(mb.encl):
     return MultiBaseStatus.NotSupported
   if len(outbytes) > 1:
-    result = mb.encr(inbytes, outbytes.toOpenArray(1, outbytes.high),
-                     outlen)
+    result = mb.encr(inbytes, outbytes.toOpenArray(1, outbytes.high), outlen)
     if result == MultiBaseStatus.Overrun:
       outlen += 1
     elif result == MultiBaseStatus.Success:
@@ -408,8 +456,12 @@ proc encode*(mbtype: typedesc[MultiBase], encoding: string,
       result = MultiBaseStatus.Overrun
       outlen = mb.encl(len(inbytes)) + 1
 
-proc decode*(mbtype: typedesc[MultiBase], inbytes: openArray[char],
-             outbytes: var openArray[byte], outlen: var int): MultiBaseStatus =
+proc decode*(
+    mbtype: typedesc[MultiBase],
+    inbytes: openArray[char],
+    outbytes: var openArray[byte],
+    outlen: var int,
+): MultiBaseStatus =
   ## Decode array ``inbytes`` using MultiBase encoding and store decoded value
   ## to ``outbytes``.
   ##
@@ -438,8 +490,9 @@ proc decode*(mbtype: typedesc[MultiBase], inbytes: openArray[char],
   else:
     result = mb.decr(inbytes.toOpenArray(1, length - 1), outbytes, outlen)
 
-proc encode*(mbtype: typedesc[MultiBase], encoding: string,
-             inbytes: openArray[byte]): Result[string, string] =
+proc encode*(
+    mbtype: typedesc[MultiBase], encoding: string, inbytes: openArray[byte]
+): Result[string, string] =
   ## Encode array ``inbytes`` using MultiBase encoding scheme ``encoding`` and
   ## return encoded string.
   let length = len(inbytes)
@@ -462,7 +515,9 @@ proc encode*(mbtype: typedesc[MultiBase], encoding: string,
     buffer[0] = mb.code
   ok(buffer)
 
-proc decode*(mbtype: typedesc[MultiBase], inbytes: openArray[char]): Result[seq[byte], string] =
+proc decode*(
+    mbtype: typedesc[MultiBase], inbytes: openArray[char]
+): Result[seq[byte], string] =
   ## Decode MultiBase encoded array ``inbytes`` and return decoded sequence of
   ## bytes.
   let length = len(inbytes)
@@ -479,8 +534,7 @@ proc decode*(mbtype: typedesc[MultiBase], inbytes: openArray[char]): Result[seq[
   else:
     var buffer = newSeq[byte](mb.decl(length - 1))
     var outlen = 0
-    let res = mb.decr(inbytes.toOpenArray(1, length - 1),
-                      buffer, outlen)
+    let res = mb.decr(inbytes.toOpenArray(1, length - 1), buffer, outlen)
     if res != MultiBaseStatus.Success:
       err("multibase: Decoding error [" & $res & "]")
     else:

libp2p/multicodec.nim

@@ -12,7 +12,7 @@
 {.push raises: [].}
 
 import tables, hashes
-import varint, vbuffer
+import vbuffer
 import stew/results
 export results
 
@@ -49,132 +49,325 @@ const MultiCodecList = [
   ("keccak-384", 0x1C),
   ("keccak-512", 0x1D),
   ("murmur3", 0x22),
-  ("blake2b-8", 0xB201), ("blake2b-16", 0xB202), ("blake2b-24", 0xB203),
-  ("blake2b-32", 0xB204), ("blake2b-40", 0xB205), ("blake2b-48", 0xB206),
-  ("blake2b-56", 0xB207), ("blake2b-64", 0xB208), ("blake2b-72", 0xB209),
-  ("blake2b-80", 0xB20A), ("blake2b-88", 0xB20B), ("blake2b-96", 0xB20C),
-  ("blake2b-104", 0xB20D), ("blake2b-112", 0xB20E), ("blake2b-120", 0xB20F),
-  ("blake2b-128", 0xB210), ("blake2b-136", 0xB211), ("blake2b-144", 0xB212),
-  ("blake2b-152", 0xB213), ("blake2b-160", 0xB214), ("blake2b-168", 0xB215),
-  ("blake2b-176", 0xB216), ("blake2b-184", 0xB217), ("blake2b-192", 0xB218),
-  ("blake2b-200", 0xB219), ("blake2b-208", 0xB21A), ("blake2b-216", 0xB21B),
-  ("blake2b-224", 0xB21C), ("blake2b-232", 0xB21D), ("blake2b-240", 0xB21E),
-  ("blake2b-248", 0xB21F), ("blake2b-256", 0xB220), ("blake2b-264", 0xB221),
-  ("blake2b-272", 0xB222), ("blake2b-280", 0xB223), ("blake2b-288", 0xB224),
-  ("blake2b-296", 0xB225), ("blake2b-304", 0xB226), ("blake2b-312", 0xB227),
-  ("blake2b-320", 0xB228), ("blake2b-328", 0xB229), ("blake2b-336", 0xB22A),
-  ("blake2b-344", 0xB22B), ("blake2b-352", 0xB22C), ("blake2b-360", 0xB22D),
-  ("blake2b-368", 0xB22E), ("blake2b-376", 0xB22F), ("blake2b-384", 0xB230),
-  ("blake2b-392", 0xB231), ("blake2b-400", 0xB232), ("blake2b-408", 0xB233),
-  ("blake2b-416", 0xB234), ("blake2b-424", 0xB235), ("blake2b-432", 0xB236),
-  ("blake2b-440", 0xB237), ("blake2b-448", 0xB238), ("blake2b-456", 0xB239),
-  ("blake2b-464", 0xB23A), ("blake2b-472", 0xB23B), ("blake2b-480", 0xB23C),
-  ("blake2b-488", 0xB23D), ("blake2b-496", 0xB23E), ("blake2b-504", 0xB23F),
-  ("blake2b-512", 0xB240), ("blake2s-8", 0xB241), ("blake2s-16", 0xB242),
-  ("blake2s-24", 0xB243), ("blake2s-32", 0xB244), ("blake2s-40", 0xB245),
-  ("blake2s-48", 0xB246), ("blake2s-56", 0xB247), ("blake2s-64", 0xB248),
-  ("blake2s-72", 0xB249), ("blake2s-80", 0xB24A), ("blake2s-88", 0xB24B),
-  ("blake2s-96", 0xB24C), ("blake2s-104", 0xB24D), ("blake2s-112", 0xB24E),
-  ("blake2s-120", 0xB24F), ("blake2s-128", 0xB250), ("blake2s-136", 0xB251),
-  ("blake2s-144", 0xB252), ("blake2s-152", 0xB253), ("blake2s-160", 0xB254),
-  ("blake2s-168", 0xB255), ("blake2s-176", 0xB256), ("blake2s-184", 0xB257),
-  ("blake2s-192", 0xB258), ("blake2s-200", 0xB259), ("blake2s-208", 0xB25A),
-  ("blake2s-216", 0xB25B), ("blake2s-224", 0xB25C), ("blake2s-232", 0xB25D),
-  ("blake2s-240", 0xB25E), ("blake2s-248", 0xB25F), ("blake2s-256", 0xB260),
-  ("skein256-8", 0xB301), ("skein256-16", 0xB302), ("skein256-24", 0xB303),
-  ("skein256-32", 0xB304), ("skein256-40", 0xB305), ("skein256-48", 0xB306),
-  ("skein256-56", 0xB307), ("skein256-64", 0xB308), ("skein256-72", 0xB309),
-  ("skein256-80", 0xB30A), ("skein256-88", 0xB30B), ("skein256-96", 0xB30C),
-  ("skein256-104", 0xB30D), ("skein256-112", 0xB30E), ("skein256-120", 0xB30F),
-  ("skein256-128", 0xB310), ("skein256-136", 0xB311), ("skein256-144", 0xB312),
-  ("skein256-152", 0xB313), ("skein256-160", 0xB314), ("skein256-168", 0xB315),
-  ("skein256-176", 0xB316), ("skein256-184", 0xB317), ("skein256-192", 0xB318),
-  ("skein256-200", 0xB319), ("skein256-208", 0xB31A), ("skein256-216", 0xB31B),
-  ("skein256-224", 0xB31C), ("skein256-232", 0xB31D), ("skein256-240", 0xB31E),
-  ("skein256-248", 0xB31F), ("skein256-256", 0xB320),
-  ("skein512-8", 0xB321), ("skein512-16", 0xB322), ("skein512-24", 0xB323),
-  ("skein512-32", 0xB324), ("skein512-40", 0xB325), ("skein512-48", 0xB326),
-  ("skein512-56", 0xB327), ("skein512-64", 0xB328), ("skein512-72", 0xB329),
-  ("skein512-80", 0xB32A), ("skein512-88", 0xB32B), ("skein512-96", 0xB32C),
-  ("skein512-104", 0xB32D), ("skein512-112", 0xB32E), ("skein512-120", 0xB32F),
-  ("skein512-128", 0xB330), ("skein512-136", 0xB331), ("skein512-144", 0xB332),
-  ("skein512-152", 0xB333), ("skein512-160", 0xB334), ("skein512-168", 0xB335),
-  ("skein512-176", 0xB336), ("skein512-184", 0xB337), ("skein512-192", 0xB338),
-  ("skein512-200", 0xB339), ("skein512-208", 0xB33A), ("skein512-216", 0xB33B),
-  ("skein512-224", 0xB33C), ("skein512-232", 0xB33D), ("skein512-240", 0xB33E),
-  ("skein512-248", 0xB33F), ("skein512-256", 0xB340), ("skein512-264", 0xB341),
-  ("skein512-272", 0xB342), ("skein512-280", 0xB343), ("skein512-288", 0xB344),
-  ("skein512-296", 0xB345), ("skein512-304", 0xB346), ("skein512-312", 0xB347),
-  ("skein512-320", 0xB348), ("skein512-328", 0xB349), ("skein512-336", 0xB34A),
-  ("skein512-344", 0xB34B), ("skein512-352", 0xB34C), ("skein512-360", 0xB34D),
-  ("skein512-368", 0xB34E), ("skein512-376", 0xB34F), ("skein512-384", 0xB350),
-  ("skein512-392", 0xB351), ("skein512-400", 0xB352), ("skein512-408", 0xB353),
-  ("skein512-416", 0xB354), ("skein512-424", 0xB355), ("skein512-432", 0xB356),
-  ("skein512-440", 0xB357), ("skein512-448", 0xB358), ("skein512-456", 0xB359),
-  ("skein512-464", 0xB35A), ("skein512-472", 0xB35B), ("skein512-480", 0xB35C),
-  ("skein512-488", 0xB35D), ("skein512-496", 0xB35E), ("skein512-504", 0xB35F),
-  ("skein512-512", 0xB360), ("skein1024-8", 0xB361), ("skein1024-16", 0xB362),
-  ("skein1024-24", 0xB363), ("skein1024-32", 0xB364), ("skein1024-40", 0xB365),
-  ("skein1024-48", 0xB366), ("skein1024-56", 0xB367), ("skein1024-64", 0xB368),
-  ("skein1024-72", 0xB369), ("skein1024-80", 0xB36A), ("skein1024-88", 0xB36B),
-  ("skein1024-96", 0xB36C), ("skein1024-104", 0xB36D),
-  ("skein1024-112", 0xB36E), ("skein1024-120", 0xB36F),
-  ("skein1024-128", 0xB370), ("skein1024-136", 0xB371),
-  ("skein1024-144", 0xB372), ("skein1024-152", 0xB373),
-  ("skein1024-160", 0xB374), ("skein1024-168", 0xB375),
-  ("skein1024-176", 0xB376), ("skein1024-184", 0xB377),
-  ("skein1024-192", 0xB378), ("skein1024-200", 0xB379),
-  ("skein1024-208", 0xB37A), ("skein1024-216", 0xB37B),
-  ("skein1024-224", 0xB37C), ("skein1024-232", 0xB37D),
-  ("skein1024-240", 0xB37E), ("skein1024-248", 0xB37F),
-  ("skein1024-256", 0xB380), ("skein1024-264", 0xB381),
-  ("skein1024-272", 0xB382), ("skein1024-280", 0xB383),
-  ("skein1024-288", 0xB384), ("skein1024-296", 0xB385),
-  ("skein1024-304", 0xB386), ("skein1024-312", 0xB387),
-  ("skein1024-320", 0xB388), ("skein1024-328", 0xB389),
-  ("skein1024-336", 0xB38A), ("skein1024-344", 0xB38B),
-  ("skein1024-352", 0xB38C), ("skein1024-360", 0xB38D),
-  ("skein1024-368", 0xB38E), ("skein1024-376", 0xB38F),
-  ("skein1024-384", 0xB390), ("skein1024-392", 0xB391),
-  ("skein1024-400", 0xB392), ("skein1024-408", 0xB393),
-  ("skein1024-416", 0xB394), ("skein1024-424", 0xB395),
-  ("skein1024-432", 0xB396), ("skein1024-440", 0xB397),
-  ("skein1024-448", 0xB398), ("skein1024-456", 0xB399),
-  ("skein1024-464", 0xB39A), ("skein1024-472", 0xB39B),
-  ("skein1024-480", 0xB39C), ("skein1024-488", 0xB39D),
-  ("skein1024-496", 0xB39E), ("skein1024-504", 0xB39F),
-  ("skein1024-512", 0xB3A0), ("skein1024-520", 0xB3A1),
-  ("skein1024-528", 0xB3A2), ("skein1024-536", 0xB3A3),
-  ("skein1024-544", 0xB3A4), ("skein1024-552", 0xB3A5),
-  ("skein1024-560", 0xB3A6), ("skein1024-568", 0xB3A7),
-  ("skein1024-576", 0xB3A8), ("skein1024-584", 0xB3A9),
-  ("skein1024-592", 0xB3AA), ("skein1024-600", 0xB3AB),
-  ("skein1024-608", 0xB3AC), ("skein1024-616", 0xB3AD),
-  ("skein1024-624", 0xB3AE), ("skein1024-632", 0xB3AF),
-  ("skein1024-640", 0xB3B0), ("skein1024-648", 0xB3B1),
-  ("skein1024-656", 0xB3B2), ("skein1024-664", 0xB3B3),
-  ("skein1024-672", 0xB3B4), ("skein1024-680", 0xB3B5),
-  ("skein1024-688", 0xB3B6), ("skein1024-696", 0xB3B7),
-  ("skein1024-704", 0xB3B8), ("skein1024-712", 0xB3B9),
-  ("skein1024-720", 0xB3BA), ("skein1024-728", 0xB3BB),
-  ("skein1024-736", 0xB3BC), ("skein1024-744", 0xB3BD),
-  ("skein1024-752", 0xB3BE), ("skein1024-760", 0xB3BF),
-  ("skein1024-768", 0xB3C0), ("skein1024-776", 0xB3C1),
-  ("skein1024-784", 0xB3C2), ("skein1024-792", 0xB3C3),
-  ("skein1024-800", 0xB3C4), ("skein1024-808", 0xB3C5),
-  ("skein1024-816", 0xB3C6), ("skein1024-824", 0xB3C7),
-  ("skein1024-832", 0xB3C8), ("skein1024-840", 0xB3C9),
-  ("skein1024-848", 0xB3CA), ("skein1024-856", 0xB3CB),
-  ("skein1024-864", 0xB3CC), ("skein1024-872", 0xB3CD),
-  ("skein1024-880", 0xB3CE), ("skein1024-888", 0xB3CF),
-  ("skein1024-896", 0xB3D0), ("skein1024-904", 0xB3D1),
-  ("skein1024-912", 0xB3D2), ("skein1024-920", 0xB3D3),
-  ("skein1024-928", 0xB3D4), ("skein1024-936", 0xB3D5),
-  ("skein1024-944", 0xB3D6), ("skein1024-952", 0xB3D7),
-  ("skein1024-960", 0xB3D8), ("skein1024-968", 0xB3D9),
-  ("skein1024-976", 0xB3DA), ("skein1024-984", 0xB3DB),
-  ("skein1024-992", 0xB3DC), ("skein1024-1000", 0xB3DD),
-  ("skein1024-1008", 0xB3DE), ("skein1024-1016", 0xB3DF),
+  ("blake2b-8", 0xB201),
+  ("blake2b-16", 0xB202),
+  ("blake2b-24", 0xB203),
+  ("blake2b-32", 0xB204),
+  ("blake2b-40", 0xB205),
+  ("blake2b-48", 0xB206),
+  ("blake2b-56", 0xB207),
+  ("blake2b-64", 0xB208),
+  ("blake2b-72", 0xB209),
+  ("blake2b-80", 0xB20A),
+  ("blake2b-88", 0xB20B),
+  ("blake2b-96", 0xB20C),
+  ("blake2b-104", 0xB20D),
+  ("blake2b-112", 0xB20E),
+  ("blake2b-120", 0xB20F),
+  ("blake2b-128", 0xB210),
+  ("blake2b-136", 0xB211),
+  ("blake2b-144", 0xB212),
+  ("blake2b-152", 0xB213),
+  ("blake2b-160", 0xB214),
+  ("blake2b-168", 0xB215),
+  ("blake2b-176", 0xB216),
+  ("blake2b-184", 0xB217),
+  ("blake2b-192", 0xB218),
+  ("blake2b-200", 0xB219),
+  ("blake2b-208", 0xB21A),
+  ("blake2b-216", 0xB21B),
+  ("blake2b-224", 0xB21C),
+  ("blake2b-232", 0xB21D),
+  ("blake2b-240", 0xB21E),
+  ("blake2b-248", 0xB21F),
+  ("blake2b-256", 0xB220),
+  ("blake2b-264", 0xB221),
+  ("blake2b-272", 0xB222),
+  ("blake2b-280", 0xB223),
+  ("blake2b-288", 0xB224),
+  ("blake2b-296", 0xB225),
+  ("blake2b-304", 0xB226),
+  ("blake2b-312", 0xB227),
+  ("blake2b-320", 0xB228),
+  ("blake2b-328", 0xB229),
+  ("blake2b-336", 0xB22A),
+  ("blake2b-344", 0xB22B),
+  ("blake2b-352", 0xB22C),
+  ("blake2b-360", 0xB22D),
+  ("blake2b-368", 0xB22E),
+  ("blake2b-376", 0xB22F),
+  ("blake2b-384", 0xB230),
+  ("blake2b-392", 0xB231),
+  ("blake2b-400", 0xB232),
+  ("blake2b-408", 0xB233),
+  ("blake2b-416", 0xB234),
+  ("blake2b-424", 0xB235),
+  ("blake2b-432", 0xB236),
+  ("blake2b-440", 0xB237),
+  ("blake2b-448", 0xB238),
+  ("blake2b-456", 0xB239),
+  ("blake2b-464", 0xB23A),
+  ("blake2b-472", 0xB23B),
+  ("blake2b-480", 0xB23C),
+  ("blake2b-488", 0xB23D),
+  ("blake2b-496", 0xB23E),
+  ("blake2b-504", 0xB23F),
+  ("blake2b-512", 0xB240),
+  ("blake2s-8", 0xB241),
+  ("blake2s-16", 0xB242),
+  ("blake2s-24", 0xB243),
+  ("blake2s-32", 0xB244),
+  ("blake2s-40", 0xB245),
+  ("blake2s-48", 0xB246),
+  ("blake2s-56", 0xB247),
+  ("blake2s-64", 0xB248),
+  ("blake2s-72", 0xB249),
+  ("blake2s-80", 0xB24A),
+  ("blake2s-88", 0xB24B),
+  ("blake2s-96", 0xB24C),
+  ("blake2s-104", 0xB24D),
+  ("blake2s-112", 0xB24E),
+  ("blake2s-120", 0xB24F),
+  ("blake2s-128", 0xB250),
+  ("blake2s-136", 0xB251),
+  ("blake2s-144", 0xB252),
+  ("blake2s-152", 0xB253),
+  ("blake2s-160", 0xB254),
+  ("blake2s-168", 0xB255),
+  ("blake2s-176", 0xB256),
+  ("blake2s-184", 0xB257),
+  ("blake2s-192", 0xB258),
+  ("blake2s-200", 0xB259),
+  ("blake2s-208", 0xB25A),
+  ("blake2s-216", 0xB25B),
+  ("blake2s-224", 0xB25C),
+  ("blake2s-232", 0xB25D),
+  ("blake2s-240", 0xB25E),
+  ("blake2s-248", 0xB25F),
+  ("blake2s-256", 0xB260),
+  ("skein256-8", 0xB301),
+  ("skein256-16", 0xB302),
+  ("skein256-24", 0xB303),
+  ("skein256-32", 0xB304),
+  ("skein256-40", 0xB305),
+  ("skein256-48", 0xB306),
+  ("skein256-56", 0xB307),
+  ("skein256-64", 0xB308),
+  ("skein256-72", 0xB309),
+  ("skein256-80", 0xB30A),
+  ("skein256-88", 0xB30B),
+  ("skein256-96", 0xB30C),
+  ("skein256-104", 0xB30D),
+  ("skein256-112", 0xB30E),
+  ("skein256-120", 0xB30F),
+  ("skein256-128", 0xB310),
+  ("skein256-136", 0xB311),
+  ("skein256-144", 0xB312),
+  ("skein256-152", 0xB313),
+  ("skein256-160", 0xB314),
+  ("skein256-168", 0xB315),
+  ("skein256-176", 0xB316),
+  ("skein256-184", 0xB317),
+  ("skein256-192", 0xB318),
+  ("skein256-200", 0xB319),
+  ("skein256-208", 0xB31A),
+  ("skein256-216", 0xB31B),
+  ("skein256-224", 0xB31C),
+  ("skein256-232", 0xB31D),
+  ("skein256-240", 0xB31E),
+  ("skein256-248", 0xB31F),
+  ("skein256-256", 0xB320),
+  ("skein512-8", 0xB321),
+  ("skein512-16", 0xB322),
+  ("skein512-24", 0xB323),
+  ("skein512-32", 0xB324),
+  ("skein512-40", 0xB325),
+  ("skein512-48", 0xB326),
+  ("skein512-56", 0xB327),
+  ("skein512-64", 0xB328),
+  ("skein512-72", 0xB329),
+  ("skein512-80", 0xB32A),
+  ("skein512-88", 0xB32B),
+  ("skein512-96", 0xB32C),
+  ("skein512-104", 0xB32D),
+  ("skein512-112", 0xB32E),
+  ("skein512-120", 0xB32F),
+  ("skein512-128", 0xB330),
+  ("skein512-136", 0xB331),
+  ("skein512-144", 0xB332),
+  ("skein512-152", 0xB333),
+  ("skein512-160", 0xB334),
+  ("skein512-168", 0xB335),
+  ("skein512-176", 0xB336),
+  ("skein512-184", 0xB337),
+  ("skein512-192", 0xB338),
+  ("skein512-200", 0xB339),
+  ("skein512-208", 0xB33A),
+  ("skein512-216", 0xB33B),
+  ("skein512-224", 0xB33C),
+  ("skein512-232", 0xB33D),
+  ("skein512-240", 0xB33E),
+  ("skein512-248", 0xB33F),
+  ("skein512-256", 0xB340),
+  ("skein512-264", 0xB341),
+  ("skein512-272", 0xB342),
+  ("skein512-280", 0xB343),
+  ("skein512-288", 0xB344),
+  ("skein512-296", 0xB345),
+  ("skein512-304", 0xB346),
+  ("skein512-312", 0xB347),
+  ("skein512-320", 0xB348),
+  ("skein512-328", 0xB349),
+  ("skein512-336", 0xB34A),
+  ("skein512-344", 0xB34B),
+  ("skein512-352", 0xB34C),
+  ("skein512-360", 0xB34D),
+  ("skein512-368", 0xB34E),
+  ("skein512-376", 0xB34F),
+  ("skein512-384", 0xB350),
+  ("skein512-392", 0xB351),
+  ("skein512-400", 0xB352),
+  ("skein512-408", 0xB353),
+  ("skein512-416", 0xB354),
+  ("skein512-424", 0xB355),
+  ("skein512-432", 0xB356),
+  ("skein512-440", 0xB357),
+  ("skein512-448", 0xB358),
+  ("skein512-456", 0xB359),
+  ("skein512-464", 0xB35A),
+  ("skein512-472", 0xB35B),
+  ("skein512-480", 0xB35C),
+  ("skein512-488", 0xB35D),
+  ("skein512-496", 0xB35E),
+  ("skein512-504", 0xB35F),
+  ("skein512-512", 0xB360),
+  ("skein1024-8", 0xB361),
+  ("skein1024-16", 0xB362),
+  ("skein1024-24", 0xB363),
+  ("skein1024-32", 0xB364),
+  ("skein1024-40", 0xB365),
+  ("skein1024-48", 0xB366),
+  ("skein1024-56", 0xB367),
+  ("skein1024-64", 0xB368),
+  ("skein1024-72", 0xB369),
+  ("skein1024-80", 0xB36A),
+  ("skein1024-88", 0xB36B),
+  ("skein1024-96", 0xB36C),
+  ("skein1024-104", 0xB36D),
+  ("skein1024-112", 0xB36E),
+  ("skein1024-120", 0xB36F),
+  ("skein1024-128", 0xB370),
+  ("skein1024-136", 0xB371),
+  ("skein1024-144", 0xB372),
+  ("skein1024-152", 0xB373),
+  ("skein1024-160", 0xB374),
+  ("skein1024-168", 0xB375),
+  ("skein1024-176", 0xB376),
+  ("skein1024-184", 0xB377),
+  ("skein1024-192", 0xB378),
+  ("skein1024-200", 0xB379),
+  ("skein1024-208", 0xB37A),
+  ("skein1024-216", 0xB37B),
+  ("skein1024-224", 0xB37C),
+  ("skein1024-232", 0xB37D),
+  ("skein1024-240", 0xB37E),
+  ("skein1024-248", 0xB37F),
+  ("skein1024-256", 0xB380),
+  ("skein1024-264", 0xB381),
+  ("skein1024-272", 0xB382),
+  ("skein1024-280", 0xB383),
+  ("skein1024-288", 0xB384),
+  ("skein1024-296", 0xB385),
+  ("skein1024-304", 0xB386),
+  ("skein1024-312", 0xB387),
+  ("skein1024-320", 0xB388),
+  ("skein1024-328", 0xB389),
+  ("skein1024-336", 0xB38A),
+  ("skein1024-344", 0xB38B),
+  ("skein1024-352", 0xB38C),
+  ("skein1024-360", 0xB38D),
+  ("skein1024-368", 0xB38E),
+  ("skein1024-376", 0xB38F),
+  ("skein1024-384", 0xB390),
+  ("skein1024-392", 0xB391),
+  ("skein1024-400", 0xB392),
+  ("skein1024-408", 0xB393),
+  ("skein1024-416", 0xB394),
+  ("skein1024-424", 0xB395),
+  ("skein1024-432", 0xB396),
+  ("skein1024-440", 0xB397),
+  ("skein1024-448", 0xB398),
+  ("skein1024-456", 0xB399),
+  ("skein1024-464", 0xB39A),
+  ("skein1024-472", 0xB39B),
+  ("skein1024-480", 0xB39C),
+  ("skein1024-488", 0xB39D),
+  ("skein1024-496", 0xB39E),
+  ("skein1024-504", 0xB39F),
+  ("skein1024-512", 0xB3A0),
+  ("skein1024-520", 0xB3A1),
+  ("skein1024-528", 0xB3A2),
+  ("skein1024-536", 0xB3A3),
+  ("skein1024-544", 0xB3A4),
+  ("skein1024-552", 0xB3A5),
+  ("skein1024-560", 0xB3A6),
+  ("skein1024-568", 0xB3A7),
+  ("skein1024-576", 0xB3A8),
+  ("skein1024-584", 0xB3A9),
+  ("skein1024-592", 0xB3AA),
+  ("skein1024-600", 0xB3AB),
+  ("skein1024-608", 0xB3AC),
+  ("skein1024-616", 0xB3AD),
+  ("skein1024-624", 0xB3AE),
+  ("skein1024-632", 0xB3AF),
+  ("skein1024-640", 0xB3B0),
+  ("skein1024-648", 0xB3B1),
+  ("skein1024-656", 0xB3B2),
+  ("skein1024-664", 0xB3B3),
+  ("skein1024-672", 0xB3B4),
+  ("skein1024-680", 0xB3B5),
+  ("skein1024-688", 0xB3B6),
+  ("skein1024-696", 0xB3B7),
+  ("skein1024-704", 0xB3B8),
+  ("skein1024-712", 0xB3B9),
+  ("skein1024-720", 0xB3BA),
+  ("skein1024-728", 0xB3BB),
+  ("skein1024-736", 0xB3BC),
+  ("skein1024-744", 0xB3BD),
+  ("skein1024-752", 0xB3BE),
+  ("skein1024-760", 0xB3BF),
+  ("skein1024-768", 0xB3C0),
+  ("skein1024-776", 0xB3C1),
+  ("skein1024-784", 0xB3C2),
+  ("skein1024-792", 0xB3C3),
+  ("skein1024-800", 0xB3C4),
+  ("skein1024-808", 0xB3C5),
+  ("skein1024-816", 0xB3C6),
+  ("skein1024-824", 0xB3C7),
+  ("skein1024-832", 0xB3C8),
+  ("skein1024-840", 0xB3C9),
+  ("skein1024-848", 0xB3CA),
+  ("skein1024-856", 0xB3CB),
+  ("skein1024-864", 0xB3CC),
+  ("skein1024-872", 0xB3CD),
+  ("skein1024-880", 0xB3CE),
+  ("skein1024-888", 0xB3CF),
+  ("skein1024-896", 0xB3D0),
+  ("skein1024-904", 0xB3D1),
+  ("skein1024-912", 0xB3D2),
+  ("skein1024-920", 0xB3D3),
+  ("skein1024-928", 0xB3D4),
+  ("skein1024-936", 0xB3D5),
+  ("skein1024-944", 0xB3D6),
+  ("skein1024-952", 0xB3D7),
+  ("skein1024-960", 0xB3D8),
+  ("skein1024-968", 0xB3D9),
+  ("skein1024-976", 0xB3DA),
+  ("skein1024-984", 0xB3DB),
+  ("skein1024-992", 0xB3DC),
+  ("skein1024-1000", 0xB3DD),
+  ("skein1024-1008", 0xB3DE),
+  ("skein1024-1016", 0xB3DF),
   ("skein1024-1024", 0xB3E0),
   # multiaddrs
   ("ip4", 0x04),
@@ -233,7 +426,7 @@ const MultiCodecList = [
   ("dash-tx", 0xF1),
   ("torrent-info", 0x7B),
   ("torrent-file", 0x7C),
-  ("ed25519-pub", 0xED)
+  ("ed25519-pub", 0xED),
 ]
 
 type
@@ -241,8 +434,7 @@ type
   MultiCodecError* = enum
     MultiCodecNotSupported
 
-const
-  InvalidMultiCodec* = MultiCodec(-1)
+const InvalidMultiCodec* = MultiCodec(-1)
 
 proc initMultiCodecNameTable(): Table[string, int] {.compileTime.} =
   for item in MultiCodecList:
@@ -289,10 +481,6 @@ proc `==`*(a, b: MultiCodec): bool =
   ## Returns ``true`` if MultiCodecs ``a`` and ``b`` are equal.
   int(a) == int(b)
 
-proc `!=`*(a, b: MultiCodec): bool =
-  ## Returns ``true`` if MultiCodecs ``a`` and ``b`` are not equal.
-  int(a) != int(b)
-
 proc hash*(m: MultiCodec): Hash {.inline.} =
   ## Hash procedure for tables.
   hash(int(m))

libp2p/multihash.nim

@@ -41,8 +41,9 @@ const
   ErrParseError = "Parse error fromHex"
 
 type
-  MHashCoderProc* = proc(data: openArray[byte],
-                         output: var openArray[byte]) {.nimcall, gcsafe, noSideEffect, raises: [].}
+  MHashCoderProc* = proc(data: openArray[byte], output: var openArray[byte]) {.
+    nimcall, gcsafe, noSideEffect, raises: []
+  .}
   MHash* = object
     mcodec*: MultiCodec
     size*: int
@@ -58,107 +59,152 @@ type
 
 proc identhash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
-    var length = if len(data) > len(output): len(output)
-                 else: len(data)
+    var length =
+      if len(data) > len(output):
+        len(output)
+      else:
+        len(data)
     copyMem(addr output[0], unsafeAddr data[0], length)
 
 proc sha1hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha1.digest(data)
-    var length = if sha1.sizeDigest > len(output): len(output)
-                 else: sha1.sizeDigest
+    var length =
+      if sha1.sizeDigest > len(output):
+        len(output)
+      else:
+        sha1.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc dblsha2_256hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest1 = sha256.digest(data)
     var digest2 = sha256.digest(digest1.data)
-    var length = if sha256.sizeDigest > len(output): len(output)
-                 else: sha256.sizeDigest
+    var length =
+      if sha256.sizeDigest > len(output):
+        len(output)
+      else:
+        sha256.sizeDigest
     copyMem(addr output[0], addr digest2.data[0], length)
 
 proc blake2Bhash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = blake2_512.digest(data)
-    var length = if blake2_512.sizeDigest > len(output): len(output)
-                 else: blake2_512.sizeDigest
+    var length =
+      if blake2_512.sizeDigest > len(output):
+        len(output)
+      else:
+        blake2_512.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc blake2Shash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = blake2_256.digest(data)
-    var length = if blake2_256.sizeDigest > len(output): len(output)
-                 else: blake2_256.sizeDigest
+    var length =
+      if blake2_256.sizeDigest > len(output):
+        len(output)
+      else:
+        blake2_256.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha2_256hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha256.digest(data)
-    var length = if sha256.sizeDigest > len(output): len(output)
-                 else: sha256.sizeDigest
+    var length =
+      if sha256.sizeDigest > len(output):
+        len(output)
+      else:
+        sha256.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha2_512hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha512.digest(data)
-    var length = if sha512.sizeDigest > len(output): len(output)
-                 else: sha512.sizeDigest
+    var length =
+      if sha512.sizeDigest > len(output):
+        len(output)
+      else:
+        sha512.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha3_224hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha3_224.digest(data)
-    var length = if sha3_224.sizeDigest > len(output): len(output)
-                 else: sha3_224.sizeDigest
+    var length =
+      if sha3_224.sizeDigest > len(output):
+        len(output)
+      else:
+        sha3_224.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha3_256hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha3_256.digest(data)
-    var length = if sha3_256.sizeDigest > len(output): len(output)
-                 else: sha3_256.sizeDigest
+    var length =
+      if sha3_256.sizeDigest > len(output):
+        len(output)
+      else:
+        sha3_256.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha3_384hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha3_384.digest(data)
-    var length = if sha3_384.sizeDigest > len(output): len(output)
-                 else: sha3_384.sizeDigest
+    var length =
+      if sha3_384.sizeDigest > len(output):
+        len(output)
+      else:
+        sha3_384.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc sha3_512hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = sha3_512.digest(data)
-    var length = if sha3_512.sizeDigest > len(output): len(output)
-                 else: sha3_512.sizeDigest
+    var length =
+      if sha3_512.sizeDigest > len(output):
+        len(output)
+      else:
+        sha3_512.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc keccak_224hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = keccak224.digest(data)
-    var length = if keccak224.sizeDigest > len(output): len(output)
-                 else: keccak224.sizeDigest
+    var length =
+      if keccak224.sizeDigest > len(output):
+        len(output)
+      else:
+        keccak224.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc keccak_256hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = keccak256.digest(data)
-    var length = if keccak256.sizeDigest > len(output): len(output)
-                 else: keccak256.sizeDigest
+    var length =
+      if keccak256.sizeDigest > len(output):
+        len(output)
+      else:
+        keccak256.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc keccak_384hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = keccak384.digest(data)
-    var length = if keccak384.sizeDigest > len(output): len(output)
-                 else: keccak384.sizeDigest
+    var length =
+      if keccak384.sizeDigest > len(output):
+        len(output)
+      else:
+        keccak384.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc keccak_512hash(data: openArray[byte], output: var openArray[byte]) =
   if len(output) > 0:
     var digest = keccak512.digest(data)
-    var length = if keccak512.sizeDigest > len(output): len(output)
-                 else: keccak512.sizeDigest
+    var length =
+      if keccak512.sizeDigest > len(output):
+        len(output)
+      else:
+        keccak512.sizeDigest
     copyMem(addr output[0], addr digest.data[0], length)
 
 proc shake_128hash(data: openArray[byte], output: var openArray[byte]) =
@@ -179,151 +225,135 @@ proc shake_256hash(data: openArray[byte], output: var openArray[byte]) =
     discard sctx.output(addr output[0], uint(len(output)))
     sctx.clear()
 
-const
-  HashesList = [
-    MHash(mcodec: multiCodec("identity"), size: 0,
-          coder: identhash),
-    MHash(mcodec: multiCodec("sha1"), size: sha1.sizeDigest,
-          coder: sha1hash),
-    MHash(mcodec: multiCodec("dbl-sha2-256"), size: sha256.sizeDigest,
-          coder: dblsha2_256hash
-    ),
-    MHash(mcodec: multiCodec("sha2-256"), size: sha256.sizeDigest,
-          coder: sha2_256hash
-    ),
-    MHash(mcodec: multiCodec("sha2-512"), size: sha512.sizeDigest,
-          coder: sha2_512hash
-    ),
-    MHash(mcodec: multiCodec("sha3-224"), size: sha3_224.sizeDigest,
-          coder: sha3_224hash
-    ),
-    MHash(mcodec: multiCodec("sha3-256"), size: sha3_256.sizeDigest,
-          coder: sha3_256hash
-    ),
-    MHash(mcodec: multiCodec("sha3-384"), size: sha3_384.sizeDigest,
-          coder: sha3_384hash
-    ),
-    MHash(mcodec: multiCodec("sha3-512"), size: sha3_512.sizeDigest,
-          coder: sha3_512hash
-    ),
-    MHash(mcodec: multiCodec("shake-128"), size: 32, coder: shake_128hash),
-    MHash(mcodec: multiCodec("shake-256"), size: 64, coder: shake_256hash),
-    MHash(mcodec: multiCodec("keccak-224"), size: keccak224.sizeDigest,
-          coder: keccak_224hash
-    ),
-    MHash(mcodec: multiCodec("keccak-256"), size: keccak256.sizeDigest,
-          coder: keccak_256hash
-    ),
-    MHash(mcodec: multiCodec("keccak-384"), size: keccak384.sizeDigest,
-          coder: keccak_384hash
-    ),
-    MHash(mcodec: multiCodec("keccak-512"), size: keccak512.sizeDigest,
-          coder: keccak_512hash
-    ),
-    MHash(mcodec: multiCodec("blake2b-8"), size: 1, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-16"), size: 2, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-24"), size: 3, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-32"), size: 4, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-40"), size: 5, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-48"), size: 6, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-56"), size: 7, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-64"), size: 8, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-72"), size: 9, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-80"), size: 10, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-88"), size: 11, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-96"), size: 12, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-104"), size: 13, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-112"), size: 14, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-120"), size: 15, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-128"), size: 16, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-136"), size: 17, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-144"), size: 18, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-152"), size: 19, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-160"), size: 20, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-168"), size: 21, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-176"), size: 22, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-184"), size: 23, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-192"), size: 24, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-200"), size: 25, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-208"), size: 26, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-216"), size: 27, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-224"), size: 28, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-232"), size: 29, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-240"), size: 30, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-248"), size: 31, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-256"), size: 32, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-264"), size: 33, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-272"), size: 34, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-280"), size: 35, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-288"), size: 36, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-296"), size: 37, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-304"), size: 38, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-312"), size: 39, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-320"), size: 40, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-328"), size: 41, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-336"), size: 42, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-344"), size: 43, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-352"), size: 44, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-360"), size: 45, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-368"), size: 46, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-376"), size: 47, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-384"), size: 48, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-392"), size: 49, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-400"), size: 50, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-408"), size: 51, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-416"), size: 52, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-424"), size: 53, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-432"), size: 54, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-440"), size: 55, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-448"), size: 56, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-456"), size: 57, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-464"), size: 58, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-472"), size: 59, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-480"), size: 60, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-488"), size: 61, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-496"), size: 62, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-504"), size: 63, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2b-512"), size: 64, coder: blake2Bhash),
-    MHash(mcodec: multiCodec("blake2s-8"), size: 1, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-16"), size: 2, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-24"), size: 3, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-32"), size: 4, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-40"), size: 5, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-48"), size: 6, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-56"), size: 7, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-64"), size: 8, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-72"), size: 9, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-80"), size: 10, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-88"), size: 11, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-96"), size: 12, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-104"), size: 13, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-112"), size: 14, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-120"), size: 15, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-128"), size: 16, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-136"), size: 17, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-144"), size: 18, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-152"), size: 19, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-160"), size: 20, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-168"), size: 21, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-176"), size: 22, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-184"), size: 23, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-192"), size: 24, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-200"), size: 25, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-208"), size: 26, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-216"), size: 27, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-224"), size: 28, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-232"), size: 29, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-240"), size: 30, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-248"), size: 31, coder: blake2Shash),
-    MHash(mcodec: multiCodec("blake2s-256"), size: 32, coder: blake2Shash)
-  ]
+const HashesList = [
+  MHash(mcodec: multiCodec("identity"), size: 0, coder: identhash),
+  MHash(mcodec: multiCodec("sha1"), size: sha1.sizeDigest, coder: sha1hash),
+  MHash(
+    mcodec: multiCodec("dbl-sha2-256"), size: sha256.sizeDigest, coder: dblsha2_256hash
+  ),
+  MHash(mcodec: multiCodec("sha2-256"), size: sha256.sizeDigest, coder: sha2_256hash),
+  MHash(mcodec: multiCodec("sha2-512"), size: sha512.sizeDigest, coder: sha2_512hash),
+  MHash(mcodec: multiCodec("sha3-224"), size: sha3_224.sizeDigest, coder: sha3_224hash),
+  MHash(mcodec: multiCodec("sha3-256"), size: sha3_256.sizeDigest, coder: sha3_256hash),
+  MHash(mcodec: multiCodec("sha3-384"), size: sha3_384.sizeDigest, coder: sha3_384hash),
+  MHash(mcodec: multiCodec("sha3-512"), size: sha3_512.sizeDigest, coder: sha3_512hash),
+  MHash(mcodec: multiCodec("shake-128"), size: 32, coder: shake_128hash),
+  MHash(mcodec: multiCodec("shake-256"), size: 64, coder: shake_256hash),
+  MHash(
+    mcodec: multiCodec("keccak-224"), size: keccak224.sizeDigest, coder: keccak_224hash
+  ),
+  MHash(
+    mcodec: multiCodec("keccak-256"), size: keccak256.sizeDigest, coder: keccak_256hash
+  ),
+  MHash(
+    mcodec: multiCodec("keccak-384"), size: keccak384.sizeDigest, coder: keccak_384hash
+  ),
+  MHash(
+    mcodec: multiCodec("keccak-512"), size: keccak512.sizeDigest, coder: keccak_512hash
+  ),
+  MHash(mcodec: multiCodec("blake2b-8"), size: 1, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-16"), size: 2, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-24"), size: 3, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-32"), size: 4, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-40"), size: 5, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-48"), size: 6, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-56"), size: 7, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-64"), size: 8, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-72"), size: 9, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-80"), size: 10, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-88"), size: 11, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-96"), size: 12, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-104"), size: 13, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-112"), size: 14, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-120"), size: 15, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-128"), size: 16, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-136"), size: 17, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-144"), size: 18, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-152"), size: 19, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-160"), size: 20, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-168"), size: 21, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-176"), size: 22, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-184"), size: 23, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-192"), size: 24, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-200"), size: 25, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-208"), size: 26, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-216"), size: 27, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-224"), size: 28, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-232"), size: 29, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-240"), size: 30, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-248"), size: 31, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-256"), size: 32, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-264"), size: 33, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-272"), size: 34, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-280"), size: 35, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-288"), size: 36, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-296"), size: 37, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-304"), size: 38, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-312"), size: 39, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-320"), size: 40, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-328"), size: 41, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-336"), size: 42, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-344"), size: 43, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-352"), size: 44, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-360"), size: 45, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-368"), size: 46, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-376"), size: 47, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-384"), size: 48, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-392"), size: 49, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-400"), size: 50, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-408"), size: 51, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-416"), size: 52, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-424"), size: 53, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-432"), size: 54, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-440"), size: 55, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-448"), size: 56, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-456"), size: 57, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-464"), size: 58, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-472"), size: 59, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-480"), size: 60, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-488"), size: 61, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-496"), size: 62, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-504"), size: 63, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2b-512"), size: 64, coder: blake2Bhash),
+  MHash(mcodec: multiCodec("blake2s-8"), size: 1, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-16"), size: 2, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-24"), size: 3, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-32"), size: 4, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-40"), size: 5, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-48"), size: 6, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-56"), size: 7, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-64"), size: 8, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-72"), size: 9, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-80"), size: 10, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-88"), size: 11, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-96"), size: 12, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-104"), size: 13, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-112"), size: 14, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-120"), size: 15, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-128"), size: 16, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-136"), size: 17, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-144"), size: 18, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-152"), size: 19, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-160"), size: 20, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-168"), size: 21, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-176"), size: 22, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-184"), size: 23, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-192"), size: 24, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-200"), size: 25, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-208"), size: 26, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-216"), size: 27, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-224"), size: 28, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-232"), size: 29, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-240"), size: 30, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-248"), size: 31, coder: blake2Shash),
+  MHash(mcodec: multiCodec("blake2s-256"), size: 32, coder: blake2Shash),
+]
 
 proc initMultiHashCodeTable(): Table[MultiCodec, MHash] {.compileTime.} =
   for item in HashesList:
     result[item.mcodec] = item
 
-const
-  CodeHashes = initMultiHashCodeTable()
+const CodeHashes = initMultiHashCodeTable()
 
 proc digestImplWithHash(hash: MHash, data: openArray[byte]): MultiHash =
   var buffer: array[MaxHashSize, byte]
@@ -353,8 +383,9 @@ proc digestImplWithoutHash(hash: MHash, data: openArray[byte]): MultiHash =
   result.data.writeArray(data)
   result.data.finish()
 
-proc digest*(mhtype: typedesc[MultiHash], hashname: string,
-             data: openArray[byte]): MhResult[MultiHash] {.inline.} =
+proc digest*(
+    mhtype: typedesc[MultiHash], hashname: string, data: openArray[byte]
+): MhResult[MultiHash] {.inline.} =
   ## Perform digest calculation using hash algorithm with name ``hashname`` on
   ## data array ``data``.
   let mc = MultiCodec.codec(hashname)
@@ -367,8 +398,9 @@ proc digest*(mhtype: typedesc[MultiHash], hashname: string,
     else:
       ok(digestImplWithHash(hash, data))
 
-proc digest*(mhtype: typedesc[MultiHash], hashcode: int,
-             data: openArray[byte]): MhResult[MultiHash] {.inline.} =
+proc digest*(
+    mhtype: typedesc[MultiHash], hashcode: int, data: openArray[byte]
+): MhResult[MultiHash] {.inline.} =
   ## Perform digest calculation using hash algorithm with code ``hashcode`` on
   ## data array ``data``.
   let hash = CodeHashes.getOrDefault(hashcode)
@@ -377,8 +409,9 @@ proc digest*(mhtype: typedesc[MultiHash], hashcode: int,
   else:
     ok(digestImplWithHash(hash, data))
 
-proc init*[T](mhtype: typedesc[MultiHash], hashname: string,
-                mdigest: MDigest[T]): MhResult[MultiHash] {.inline.} =
+proc init*[T](
+    mhtype: typedesc[MultiHash], hashname: string, mdigest: MDigest[T]
+): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from nimcrypto's `MDigest` object and hash algorithm name
   ## ``hashname``.
   let mc = MultiCodec.codec(hashname)
@@ -393,8 +426,9 @@ proc init*[T](mhtype: typedesc[MultiHash], hashname: string,
     else:
       ok(digestImplWithoutHash(hash, mdigest.data))
 
-proc init*[T](mhtype: typedesc[MultiHash], hashcode: MultiCodec,
-              mdigest: MDigest[T]): MhResult[MultiHash] {.inline.} =
+proc init*[T](
+    mhtype: typedesc[MultiHash], hashcode: MultiCodec, mdigest: MDigest[T]
+): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from nimcrypto's `MDigest` and hash algorithm code
   ## ``hashcode``.
   let hash = CodeHashes.getOrDefault(hashcode)
@@ -405,8 +439,9 @@ proc init*[T](mhtype: typedesc[MultiHash], hashcode: MultiCodec,
   else:
     ok(digestImplWithoutHash(hash, mdigest.data))
 
-proc init*(mhtype: typedesc[MultiHash], hashname: string,
-           bdigest: openArray[byte]): MhResult[MultiHash] {.inline.} =
+proc init*(
+    mhtype: typedesc[MultiHash], hashname: string, bdigest: openArray[byte]
+): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from array of bytes ``bdigest`` and hash algorithm code
   ## ``hashcode``.
   let mc = MultiCodec.codec(hashname)
@@ -421,8 +456,9 @@ proc init*(mhtype: typedesc[MultiHash], hashname: string,
     else:
       ok(digestImplWithoutHash(hash, bdigest))
 
-proc init*(mhtype: typedesc[MultiHash], hashcode: MultiCodec,
-           bdigest: openArray[byte]): MhResult[MultiHash] {.inline.} =
+proc init*(
+    mhtype: typedesc[MultiHash], hashcode: MultiCodec, bdigest: openArray[byte]
+): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from array of bytes ``bdigest`` and hash algorithm code
   ## ``hashcode``.
   let hash = CodeHashes.getOrDefault(hashcode)
@@ -433,8 +469,9 @@ proc init*(mhtype: typedesc[MultiHash], hashcode: MultiCodec,
   else:
     ok(digestImplWithoutHash(hash, bdigest))
 
-proc decode*(mhtype: typedesc[MultiHash], data: openArray[byte],
-             mhash: var MultiHash): MhResult[int] =
+proc decode*(
+    mhtype: typedesc[MultiHash], data: openArray[byte], mhash: var MultiHash
+): MhResult[int] =
   ## Decode MultiHash value from array of bytes ``data``.
   ##
   ## On success decoded MultiHash will be stored into ``mhash`` and number of
@@ -473,9 +510,10 @@ proc decode*(mhtype: typedesc[MultiHash], data: openArray[byte],
   if not vb.isEnough(int(size)):
     return err(ErrDecodeError)
 
-  mhash = ? MultiHash.init(MultiCodec(code),
-                         vb.buffer.toOpenArray(vb.offset,
-                                               vb.offset + int(size) - 1))
+  mhash =
+    ?MultiHash.init(
+      MultiCodec(code), vb.buffer.toOpenArray(vb.offset, vb.offset + int(size) - 1)
+    )
   ok(vb.offset + int(size))
 
 proc validate*(mhtype: typedesc[MultiHash], data: openArray[byte]): bool =
@@ -508,24 +546,24 @@ proc validate*(mhtype: typedesc[MultiHash], data: openArray[byte]): bool =
     return false
   result = true
 
-proc init*(mhtype: typedesc[MultiHash],
-           data: openArray[byte]): MhResult[MultiHash] {.inline.} =
+proc init*(
+    mhtype: typedesc[MultiHash], data: openArray[byte]
+): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from bytes array ``data``.
   var hash: MultiHash
-  discard ? MultiHash.decode(data, hash)
+  discard ?MultiHash.decode(data, hash)
   ok(hash)
 
 proc init*(mhtype: typedesc[MultiHash], data: string): MhResult[MultiHash] {.inline.} =
   ## Create MultiHash from hexadecimal string representation ``data``.
   var hash: MultiHash
   try:
-    discard ? MultiHash.decode(fromHex(data), hash)
+    discard ?MultiHash.decode(fromHex(data), hash)
     ok(hash)
   except ValueError:
     err(ErrParseError)
 
-proc init58*(mhtype: typedesc[MultiHash],
-             data: string): MultiHash {.inline.} =
+proc init58*(mhtype: typedesc[MultiHash], data: string): MultiHash {.inline.} =
   ## Create MultiHash from BASE58 encoded string representation ``data``.
   if MultiHash.decode(Base58.decode(data), result) == -1:
     raise newException(MultihashError, "Incorrect MultiHash binary format")
@@ -538,7 +576,7 @@ proc cmp(a: openArray[byte], b: openArray[byte]): bool {.inline.} =
   while n > 0:
     dec(n)
     diff = int(a[n]) - int(b[n])
-    res = (res and -not(diff)) or diff
+    res = (res and - not (diff)) or diff
   result = (res == 0)
 
 proc `==`*[T](mh: MultiHash, mdigest: MDigest[T]): bool =
@@ -548,8 +586,10 @@ proc `==`*[T](mh: MultiHash, mdigest: MDigest[T]): bool =
     return false
   if len(mdigest.data) != mh.size:
     return false
-  result = cmp(mh.data.buffer.toOpenArray(mh.dpos, mh.dpos + mh.size - 1),
-               mdigest.data.toOpenArray(0, mdigest.data.high))
+  result = cmp(
+    mh.data.buffer.toOpenArray(mh.dpos, mh.dpos + mh.size - 1),
+    mdigest.data.toOpenArray(0, mdigest.data.high),
+  )
 
 proc `==`*[T](mdigest: MDigest[T], mh: MultiHash): bool {.inline.} =
   ## Compares MultiHash with nimcrypto's MDigest[T], returns ``true`` if
@@ -565,8 +605,10 @@ proc `==`*(a: MultiHash, b: MultiHash): bool =
     return false
   if a.size != b.size:
     return false
-  result = cmp(a.data.buffer.toOpenArray(a.dpos, a.dpos + a.size - 1),
-               b.data.buffer.toOpenArray(b.dpos, b.dpos + b.size - 1))
+  result = cmp(
+    a.data.buffer.toOpenArray(a.dpos, a.dpos + a.size - 1),
+    b.data.buffer.toOpenArray(b.dpos, b.dpos + b.size - 1),
+  )
 
 proc hex*(value: MultiHash): string =
   ## Return hexadecimal string representation of MultiHash ``value``.
@@ -578,16 +620,16 @@ proc base58*(value: MultiHash): string =
 
 proc `$`*(mh: MultiHash): string =
   ## Return string representation of MultiHash ``value``.
-  let digest = toHex(mh.data.buffer.toOpenArray(mh.dpos,
-                                                mh.dpos + mh.size - 1))
+  let digest = toHex(mh.data.buffer.toOpenArray(mh.dpos, mh.dpos + mh.size - 1))
   result = $(mh.mcodec) & "/" & digest
 
 proc write*(vb: var VBuffer, mh: MultiHash) {.inline.} =
   ## Write MultiHash value ``mh`` to buffer ``vb``.
   vb.writeArray(mh.data.buffer)
 
-proc encode*(mbtype: typedesc[MultiBase], encoding: string,
-             mh: MultiHash): string {.inline.} =
+proc encode*(
+    mbtype: typedesc[MultiBase], encoding: string, mh: MultiHash
+): string {.inline.} =
   ## Get MultiBase encoded representation of ``mh`` using encoding
   ## ``encoding``.
   result = MultiBase.encode(encoding, mh.data.buffer)

libp2p/multistream.nim

@@ -11,8 +11,7 @@
 
 import std/[strutils, sequtils, tables]
 import chronos, chronicles, stew/byteutils
-import stream/connection,
-       protocols/protocol
+import stream/connection, protocols/protocol
 
 logScope:
   topics = "libp2p multistream"
@@ -25,7 +24,7 @@ const
   Ls = "ls\n"
 
 type
-  Matcher* = proc (proto: string): bool {.gcsafe, raises: [].}
+  Matcher* = proc(proto: string): bool {.gcsafe, raises: [].}
 
   MultiStreamError* = object of LPError
 
@@ -40,23 +39,17 @@ type
     codec*: string
 
 proc new*(T: typedesc[MultistreamSelect]): T =
-  T(
-    codec: Codec,
-  )
+  T(codec: Codec)
 
 template validateSuffix(str: string): untyped =
   if str.endsWith("\n"):
     str.removeSuffix("\n")
   else:
-    raise (ref MultiStreamError)(msg:
-      "MultistreamSelect failed, malformed message")
+    raise (ref MultiStreamError)(msg: "MultistreamSelect failed, malformed message")
 
 proc select*(
-    _: MultistreamSelect | type MultistreamSelect,
-    conn: Connection,
-    proto: seq[string]
-): Future[string] {.async: (raises: [
-    CancelledError, LPStreamError, MultiStreamError]).} =
+    _: MultistreamSelect | type MultistreamSelect, conn: Connection, proto: seq[string]
+): Future[string] {.async: (raises: [CancelledError, LPStreamError, MultiStreamError]).} =
   trace "initiating handshake", conn, codec = Codec
   ## select a remote protocol
   await conn.writeLp(Codec & "\n") # write handshake
@@ -85,7 +78,7 @@ proc select*(
       return proto[0]
     elif proto.len > 1:
       # Try to negotiate alternatives
-      let protos = proto[1..<proto.len()]
+      let protos = proto[1 ..< proto.len()]
       trace "selecting one of several protos", conn, protos = protos
       for p in protos:
         trace "selecting proto", conn, proto = p
@@ -102,28 +95,25 @@ proc select*(
       return ""
 
 proc select*(
-    _: MultistreamSelect | type MultistreamSelect,
-    conn: Connection,
-    proto: string
-): Future[bool] {.async: (raises: [
-    CancelledError, LPStreamError, MultiStreamError]).} =
+    _: MultistreamSelect | type MultistreamSelect, conn: Connection, proto: string
+): Future[bool] {.async: (raises: [CancelledError, LPStreamError, MultiStreamError]).} =
   if proto.len > 0:
     (await MultistreamSelect.select(conn, @[proto])) == proto
   else:
     (await MultistreamSelect.select(conn, @[])) == Codec
 
 proc select*(
-    m: MultistreamSelect,
-    conn: Connection
-): Future[bool] {.async: (raises: [
-    CancelledError, LPStreamError, MultiStreamError], raw: true).} =
+    m: MultistreamSelect, conn: Connection
+): Future[bool] {.
+    async: (raises: [CancelledError, LPStreamError, MultiStreamError], raw: true)
+.} =
   m.select(conn, "")
 
 proc list*(
-    m: MultistreamSelect,
-    conn: Connection
-): Future[seq[string]] {.async: (raises: [
-    CancelledError, LPStreamError, MultiStreamError]).} =
+    m: MultistreamSelect, conn: Connection
+): Future[seq[string]] {.
+    async: (raises: [CancelledError, LPStreamError, MultiStreamError])
+.} =
   ## list remote protos requests on connection
   if not await m.select(conn):
     return
@@ -143,9 +133,8 @@ proc handle*(
     conn: Connection,
     protos: seq[string],
     matchers = newSeq[Matcher](),
-    active: bool = false
-): Future[string] {.async: (raises: [
-    CancelledError, LPStreamError, MultiStreamError]).} =
+    active: bool = false,
+): Future[string] {.async: (raises: [CancelledError, LPStreamError, MultiStreamError]).} =
   trace "Starting multistream negotiation", conn, handshaked = active
   var handshaked = active
   while not conn.atEof:
@@ -153,16 +142,17 @@ proc handle*(
     validateSuffix(ms)
 
     if not handshaked and ms != Codec:
-      debug "expected handshake message", conn, instead=ms
-      raise (ref MultiStreamError)(msg:
-        "MultistreamSelect handling failed, invalid first message")
+      debug "expected handshake message", conn, instead = ms
+      raise (ref MultiStreamError)(
+        msg: "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:
+    case ms
     of "ls":
       trace "handle: listing protos", conn
       #TODO this doens't seem to follow spec, each protocol
@@ -174,8 +164,7 @@ proc handle*(
         await conn.writeLp(Codec & "\n")
         handshaked = true
       else:
-        trace "handle: sending `na` for duplicate handshake while handshaked",
-          conn
+        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
@@ -187,9 +176,8 @@ proc handle*(
       await conn.writeLp(Na)
 
 proc handle*(
-    m: MultistreamSelect,
-    conn: Connection,
-    active: bool = false) {.async: (raises: [CancelledError]).} =
+    m: MultistreamSelect, conn: Connection, active: bool = false
+) {.async: (raises: [CancelledError]).} =
   trace "Starting multistream handler", conn, handshaked = active
   var
     protos: seq[string]
@@ -208,8 +196,7 @@ proc handle*(
 
         var protocolHolder = h
         let maxIncomingStreams = protocolHolder.protocol.maxIncomingStreams
-        if protocolHolder.openedStreams.getOrDefault(conn.peerId) >=
-            maxIncomingStreams:
+        if protocolHolder.openedStreams.getOrDefault(conn.peerId) >= maxIncomingStreams:
           debug "Max streams for protocol reached, blocking new stream",
             conn, protocol = ms, maxIncomingStreams
           return
@@ -225,44 +212,41 @@ proc handle*(
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    trace "Exception in multistream", conn, msg = exc.msg
+    trace "Exception in multistream", conn, description = exc.msg
   finally:
     await conn.close()
 
   trace "Stopped multistream handler", conn
 
-proc addHandler*(m: MultistreamSelect,
-                 codecs: seq[string],
-                 protocol: LPProtocol,
-                 matcher: Matcher = nil) =
+proc addHandler*(
+    m: MultistreamSelect,
+    codecs: seq[string],
+    protocol: LPProtocol,
+    matcher: Matcher = nil,
+) =
   trace "registering protocols", protos = codecs
-  m.handlers.add(HandlerHolder(protos: codecs,
-                               protocol: protocol,
-                               match: matcher))
+  m.handlers.add(HandlerHolder(protos: codecs, protocol: protocol, match: matcher))
 
-proc addHandler*(m: MultistreamSelect,
-                 codec: string,
-                 protocol: LPProtocol,
-                 matcher: Matcher = nil) =
+proc addHandler*(
+    m: MultistreamSelect, codec: string, protocol: LPProtocol, matcher: Matcher = nil
+) =
   addHandler(m, @[codec], protocol, matcher)
 
 proc addHandler*[E](
     m: MultistreamSelect,
     codec: string,
-    handler: LPProtoHandler |
-      proc (
-        conn: Connection,
-        proto: string): InternalRaisesFuture[void, E],
-    matcher: Matcher = nil) =
+    handler:
+      LPProtoHandler |
+      proc(conn: Connection, proto: string): InternalRaisesFuture[void, E],
+    matcher: Matcher = nil,
+) =
   ## helper to allow registering pure handlers
   trace "registering proto handler", proto = codec
   let protocol = new LPProtocol
   protocol.codec = codec
   protocol.handler = handler
 
-  m.handlers.add(HandlerHolder(protos: @[codec],
-                               protocol: protocol,
-                               match: matcher))
+  m.handlers.add(HandlerHolder(protos: @[codec], protocol: protocol, match: matcher))
 
 proc start*(m: MultistreamSelect) {.async: (raises: [CancelledError]).} =
   # Nim 1.6.18: Using `mapIt` results in a seq of `.Raising([])`
@@ -283,7 +267,8 @@ proc start*(m: MultistreamSelect) {.async: (raises: [CancelledError]).} =
       elif fut.completed:
         pending.add m.handlers[i].protocol.stop()
       else:
-        static: doAssert typeof(fut).E is (CancelledError,)
+        static:
+          doAssert typeof(fut).E is (CancelledError,)
     await noCancel allFutures(pending)
     raise exc
 

libp2p/muxers/mplex/coder.nim

@@ -10,29 +10,22 @@
 {.push raises: [].}
 
 import pkg/[chronos, chronicles, stew/byteutils]
-import ../../stream/connection,
-       ../../utility,
-       ../../varint,
-       ../../vbuffer,
-       ../muxer
+import ../../stream/connection, ../../utility, ../../varint, ../../vbuffer, ../muxer
 
 logScope:
   topics = "libp2p mplexcoder"
 
 type
   MessageType* {.pure.} = enum
-    New,
-    MsgIn,
-    MsgOut,
-    CloseIn,
-    CloseOut,
-    ResetIn,
+    New
+    MsgIn
+    MsgOut
+    CloseIn
+    CloseOut
+    ResetIn
     ResetOut
 
-  Msg* = tuple
-    id: uint64
-    msgType: MessageType
-    data: seq[byte]
+  Msg* = tuple[id: uint64, msgType: MessageType, data: seq[byte]]
 
   InvalidMplexMsgType* = object of MuxerError
 
@@ -44,8 +37,7 @@ proc newInvalidMplexMsgType*(): ref InvalidMplexMsgType =
 
 proc readMsg*(
     conn: Connection
-): Future[Msg] {.async: (raises: [
-    CancelledError, LPStreamError, MuxerError]).} =
+): Future[Msg] {.async: (raises: [CancelledError, LPStreamError, MuxerError]).} =
   let header = await conn.readVarint()
   trace "read header varint", varint = header, conn
 
@@ -59,12 +51,8 @@ proc readMsg*(
   return (header shr 3, MessageType(msgType), data)
 
 proc writeMsg*(
-    conn: Connection,
-    id: uint64,
-    msgType: MessageType,
-    data: seq[byte] = @[]
-): Future[void] {.async: (raises: [
-    CancelledError, LPStreamError], raw: true).} =
+    conn: Connection, id: uint64, msgType: MessageType, data: seq[byte] = @[]
+): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   var
     left = data.len
     offset = 0
@@ -72,8 +60,11 @@ proc writeMsg*(
 
   # Split message into length-prefixed chunks
   while left > 0 or data.len == 0:
-    let
-      chunkSize = if left > MaxMsgSize: MaxMsgSize - 64 else: left
+    let chunkSize =
+      if left > MaxMsgSize:
+        MaxMsgSize - 64
+      else:
+        left
 
     buf.writePBVarint(id shl 3 or ord(msgType).uint64)
     buf.writeSeq(data.toOpenArray(offset, offset + chunkSize - 1))
@@ -91,10 +82,6 @@ proc writeMsg*(
   conn.write(buf.buffer)
 
 proc writeMsg*(
-    conn: Connection,
-    id: uint64,
-    msgType: MessageType,
-    data: string
-): Future[void] {.async: (raises: [
-    CancelledError, LPStreamError], raw: true).} =
+    conn: Connection, id: uint64, msgType: MessageType, data: string
+): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   conn.writeMsg(id, msgType, data.toBytes())

libp2p/muxers/mplex/lpchannel.nim

@@ -11,10 +11,8 @@
 
 import std/[oids, strformat]
 import pkg/[chronos, chronicles, metrics]
-import ./coder,
-       ../muxer,
-       ../../stream/[bufferstream, connection, streamseq],
-       ../../peerinfo
+import
+  ./coder, ../muxer, ../../stream/[bufferstream, connection, streamseq], ../../peerinfo
 
 export connection
 
@@ -22,7 +20,8 @@ logScope:
   topics = "libp2p mplexchannel"
 
 when defined(libp2p_mplex_metrics):
-  declareHistogram libp2p_mplex_qlen, "message queue length",
+  declareHistogram libp2p_mplex_qlen,
+    "message queue length",
     buckets = [0.0, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0]
   declareCounter libp2p_mplex_qlenclose, "closed because of max queuelen"
   declareHistogram libp2p_mplex_qtime, "message queuing time"
@@ -43,36 +42,39 @@ when defined(libp2p_network_protocols_metrics):
 ## EOF marker
 
 const
-  MaxWrites = 1024 ##\
+  MaxWrites = 1024
+    ##\
     ## Maximum number of in-flight writes - after this, we disconnect the peer
 
   LPChannelTrackerName* = "LPChannel"
 
-type
-  LPChannel* = ref object of BufferStream
-    id*: uint64                   # channel id
-    name*: string                 # name of the channel (for debugging)
-    conn*: Connection             # wrapped connection used to for writing
-    initiator*: bool              # initiated remotely or locally flag
-    isOpen*: bool                 # has channel been opened
-    closedLocal*: bool            # has channel been closed locally
-    remoteReset*: bool            # has channel been remotely reset
-    localReset*: bool             # has channel been reset locally
-    msgCode*: MessageType         # cached in/out message code
-    closeCode*: MessageType       # cached in/out close code
-    resetCode*: MessageType       # cached in/out reset code
-    writes*: int                  # In-flight writes
+type LPChannel* = ref object of BufferStream
+  id*: uint64 # channel id
+  name*: string # name of the channel (for debugging)
+  conn*: Connection # wrapped connection used to for writing
+  initiator*: bool # initiated remotely or locally flag
+  isOpen*: bool # has channel been opened
+  closedLocal*: bool # has channel been closed locally
+  remoteReset*: bool # has channel been remotely reset
+  localReset*: bool # has channel been reset locally
+  msgCode*: MessageType # cached in/out message code
+  closeCode*: MessageType # cached in/out close code
+  resetCode*: MessageType # cached in/out reset code
+  writes*: int # In-flight writes
 
 func shortLog*(s: LPChannel): auto =
   try:
-    if s == nil: "LPChannel(nil)"
+    if s == nil:
+      "LPChannel(nil)"
     elif s.name != $s.oid and s.name.len > 0:
       &"{shortLog(s.conn.peerId)}:{s.oid}:{s.name}"
-    else: &"{shortLog(s.conn.peerId)}:{s.oid}"
+    else:
+      &"{shortLog(s.conn.peerId)}:{s.oid}"
   except ValueError as exc:
     raiseAssert(exc.msg)
 
-chronicles.formatIt(LPChannel): shortLog(it)
+chronicles.formatIt(LPChannel):
+  shortLog(it)
 
 proc open*(s: LPChannel) {.async: (raises: [CancelledError, LPStreamError]).} =
   trace "Opening channel", s, conn = s.conn
@@ -114,7 +116,7 @@ proc reset*(s: LPChannel) {.async: (raises: []).} =
         trace "sending reset message", s, conn = s.conn
         await noCancel s.conn.writeMsg(s.id, s.resetCode) # write reset
       except LPStreamError as exc:
-        trace "Can't send reset message", s, conn = s.conn, msg = exc.msg
+        trace "Can't send reset message", s, conn = s.conn, description = exc.msg
         await s.conn.close()
 
     asyncSpawn resetMessage()
@@ -143,7 +145,7 @@ method close*(s: LPChannel) {.async: (raises: []).} =
       # It's harmless that close message cannot be sent - the connection is
       # likely down already
       await s.conn.close()
-      trace "Cannot send close message", s, id = s.id, msg = exc.msg
+      trace "Cannot send close message", s, id = s.id, description = exc.msg
 
   await s.closeUnderlying() # maybe already eofed
 
@@ -160,9 +162,7 @@ method initStream*(s: LPChannel) =
   procCall BufferStream(s).initStream()
 
 method readOnce*(
-    s: LPChannel,
-    pbytes: pointer,
-    nbytes: int
+    s: LPChannel, pbytes: pointer, nbytes: int
 ): Future[int] {.async: (raises: [CancelledError, LPStreamError]).} =
   ## Mplex relies on reading being done regularly from every channel, or all
   ## channels are blocked - in particular, this means that reading from one
@@ -180,7 +180,7 @@ method readOnce*(
     let bytes = await procCall BufferStream(s).readOnce(pbytes, nbytes)
     when defined(libp2p_network_protocols_metrics):
       if s.protocol.len > 0:
-        libp2p_protocols_bytes.inc(bytes.int64, labelValues=[s.protocol, "in"])
+        libp2p_protocols_bytes.inc(bytes.int64, labelValues = [s.protocol, "in"])
 
     trace "readOnce", s, bytes
     if bytes == 0:
@@ -196,8 +196,7 @@ method readOnce*(
     raise newLPStreamConnDownError(exc)
 
 proc prepareWrite(
-    s: LPChannel,
-    msg: seq[byte]
+    s: LPChannel, msg: seq[byte]
 ): Future[void] {.async: (raises: [CancelledError, LPStreamError]).} =
   # prepareWrite is the slow path of writing a message - see conditions in
   # write
@@ -215,7 +214,7 @@ proc prepareWrite(
     debug "Closing connection, too many in-flight writes on channel",
       s, conn = s.conn, writes = s.writes
     when defined(libp2p_mplex_metrics):
-        libp2p_mplex_qlenclose.inc()
+      libp2p_mplex_qlenclose.inc()
     await s.reset()
     await s.conn.close()
     return
@@ -228,7 +227,7 @@ proc prepareWrite(
 proc completeWrite(
     s: LPChannel,
     fut: Future[void].Raising([CancelledError, LPStreamError]),
-    msgLen: int
+    msgLen: int,
 ): Future[void] {.async: (raises: [CancelledError, LPStreamError]).} =
   try:
     s.writes += 1
@@ -244,8 +243,7 @@ proc completeWrite(
       if s.protocol.len > 0:
         # This crashes on Nim 2.0.2 with `--mm:orc` during `nimble test`
         # https://github.com/status-im/nim-metrics/issues/79
-        libp2p_protocols_bytes.inc(
-          msgLen.int64, labelValues = [s.protocol, "out"])
+        libp2p_protocols_bytes.inc(msgLen.int64, labelValues = [s.protocol, "out"])
 
     s.activity = true
   except CancelledError as exc:
@@ -258,7 +256,7 @@ proc completeWrite(
   except LPStreamEOFError as exc:
     raise exc
   except LPStreamError as exc:
-    trace "exception in lpchannel write handler", s, msg = exc.msg
+    trace "exception in lpchannel write handler", s, description = exc.msg
     await s.reset()
     await s.conn.close()
     raise newLPStreamConnDownError(exc)
@@ -266,15 +264,12 @@ proc completeWrite(
     s.writes -= 1
 
 method write*(
-    s: LPChannel,
-    msg: seq[byte]
-): Future[void] {.async: (raises: [
-    CancelledError, LPStreamError], raw: true).} =
+    s: LPChannel, msg: seq[byte]
+): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   ## Write to mplex channel - there may be up to MaxWrite concurrent writes
   ## pending after which the peer is disconnected
 
-  let
-    closed = s.closedLocal or s.conn.closed
+  let closed = s.closedLocal or s.conn.closed
 
   let fut =
     if (not closed) and msg.len > 0 and s.writes < MaxWrites and s.isOpen:
@@ -287,7 +282,8 @@ method write*(
 
   s.completeWrite(fut, msg.len)
 
-method getWrapped*(s: LPChannel): Connection = s.conn
+method getWrapped*(s: LPChannel): Connection =
+  s.conn
 
 proc init*(
     L: type LPChannel,
@@ -295,7 +291,8 @@ proc init*(
     conn: Connection,
     initiator: bool,
     name: string = "",
-    timeout: Duration = DefaultChanTimeout): LPChannel =
+    timeout: Duration = DefaultChanTimeout,
+): LPChannel =
   let chann = L(
     id: id,
     name: name,
@@ -306,12 +303,17 @@ proc init*(
     msgCode: if initiator: MessageType.MsgOut else: MessageType.MsgIn,
     closeCode: if initiator: MessageType.CloseOut else: MessageType.CloseIn,
     resetCode: if initiator: MessageType.ResetOut else: MessageType.ResetIn,
-    dir: if initiator: Direction.Out else: Direction.In)
+    dir: if initiator: Direction.Out else: Direction.In,
+  )
 
   chann.initStream()
 
   when chronicles.enabledLogLevel == LogLevel.TRACE:
-    chann.name = if chann.name.len > 0: chann.name else: $chann.oid
+    chann.name =
+      if chann.name.len > 0:
+        chann.name
+      else:
+        $chann.oid
 
   trace "Created new lpchannel", s = chann, id, initiator
 

libp2p/muxers/mplex/mplex.nim

@@ -11,13 +11,14 @@
 
 import tables, sequtils, oids
 import chronos, chronicles, stew/byteutils, metrics
-import ../muxer,
-       ../../stream/connection,
-       ../../stream/bufferstream,
-       ../../utility,
-       ../../peerinfo,
-       ./coder,
-       ./lpchannel
+import
+  ../muxer,
+  ../../stream/connection,
+  ../../stream/bufferstream,
+  ../../utility,
+  ../../peerinfo,
+  ./coder,
+  ./lpchannel
 
 export muxer
 
@@ -26,12 +27,10 @@ logScope:
 
 const MplexCodec* = "/mplex/6.7.0"
 
-const
-  MaxChannelCount = 200
+const MaxChannelCount = 200
 
 when defined(libp2p_expensive_metrics):
-  declareGauge(libp2p_mplex_channels,
-    "mplex channels", labels = ["initiator", "peer"])
+  declareGauge(libp2p_mplex_channels, "mplex channels", labels = ["initiator", "peer"])
 
 type
   InvalidChannelIdError* = object of MuxerError
@@ -48,7 +47,8 @@ type
 func shortLog*(m: Mplex): auto =
   shortLog(m.connection)
 
-chronicles.formatIt(Mplex): shortLog(it)
+chronicles.formatIt(Mplex):
+  shortLog(it)
 
 proc newTooManyChannels(): ref TooManyChannels =
   newException(TooManyChannels, "max allowed channel count exceeded")
@@ -67,31 +67,31 @@ proc cleanupChann(m: Mplex, chann: LPChannel) {.async: (raises: []), inline.} =
     when defined(libp2p_expensive_metrics):
       libp2p_mplex_channels.set(
         m.channels[chann.initiator].len.int64,
-        labelValues = [$chann.initiator, $m.connection.peerId])
+        labelValues = [$chann.initiator, $m.connection.peerId],
+      )
   except CancelledError as exc:
-    warn "Error cleaning up mplex channel", m, chann, msg = exc.msg
+    warn "Error cleaning up mplex channel", m, chann, description = exc.msg
 
 proc newStreamInternal*(
     m: Mplex,
     initiator: bool = true,
     chanId: uint64 = 0,
     name: string = "",
-    timeout: Duration): LPChannel {.gcsafe, raises: [InvalidChannelIdError].} =
+    timeout: Duration,
+): LPChannel {.gcsafe, raises: [InvalidChannelIdError].} =
   ## create new channel/stream
   ##
   let id =
-    if initiator: m.currentId.inc(); m.currentId
-    else: chanId
+    if initiator:
+      m.currentId.inc()
+      m.currentId
+    else:
+      chanId
 
   if id in m.channels[initiator]:
     raise newInvalidChannelIdError()
 
-  result = LPChannel.init(
-    id,
-    m.connection,
-    initiator,
-    name,
-    timeout = timeout)
+  result = LPChannel.init(id, m.connection, initiator, name, timeout = timeout)
 
   result.peerId = m.connection.peerId
   result.observedAddr = m.connection.observedAddr
@@ -108,8 +108,8 @@ proc newStreamInternal*(
 
   when defined(libp2p_expensive_metrics):
     libp2p_mplex_channels.set(
-      m.channels[initiator].len.int64,
-      labelValues = [$initiator, $m.connection.peerId])
+      m.channels[initiator].len.int64, labelValues = [$initiator, $m.connection.peerId]
+    )
 
 proc handleStream(m: Mplex, chann: LPChannel) {.async: (raises: []).} =
   ## call the muxer stream handler for this channel
@@ -146,7 +146,7 @@ method handle*(m: Mplex) {.async: (raises: []).} =
         else:
           if m.channels[false].len > m.maxChannCount - 1:
             warn "too many channels created by remote peer",
-                 allowedMax = MaxChannelCount, m
+              allowedMax = MaxChannelCount, m
             raise newTooManyChannels()
 
           let name = string.fromBytes(data)
@@ -154,7 +154,7 @@ method handle*(m: Mplex) {.async: (raises: []).} =
 
       trace "Processing channel message", m, channel, data = data.shortLog
 
-      case msgType:
+      case msgType
       of MessageType.New:
         trace "created channel", m, channel
 
@@ -162,11 +162,10 @@ method handle*(m: Mplex) {.async: (raises: []).} =
           # Launch handler task
           # All the errors are handled inside `handleStream()` procedure.
           asyncSpawn m.handleStream(channel)
-
       of MessageType.MsgIn, MessageType.MsgOut:
         if data.len > MaxMsgSize:
           warn "attempting to send a packet larger than allowed",
-                allowed = MaxMsgSize, channel
+            allowed = MaxMsgSize, channel
           raise newLPStreamLimitError()
 
         trace "pushing data to channel", m, channel, len = data.len
@@ -175,10 +174,9 @@ method handle*(m: Mplex) {.async: (raises: []).} =
           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.
-
+          trace "pushing data to channel failed",
+            m, channel, len = data.len, description = exc.msg
+          discard # Ignore message, same as if `cleanupChann` had completed.
       of MessageType.CloseIn, MessageType.CloseOut:
         await channel.pushEof()
       of MessageType.ResetIn, MessageType.ResetOut:
@@ -187,11 +185,11 @@ method handle*(m: Mplex) {.async: (raises: []).} =
   except CancelledError:
     debug "Unexpected cancellation in mplex handler", m
   except LPStreamEOFError as exc:
-    trace "Stream EOF", m, msg = exc.msg
+    trace "Stream EOF", m, description = exc.msg
   except LPStreamError as exc:
-    debug "Unexpected stream exception in mplex read loop", m, msg = exc.msg
+    debug "Unexpected stream exception in mplex read loop", m, description = exc.msg
   except MuxerError as exc:
-    debug "Unexpected muxer exception in mplex read loop", m, msg = exc.msg
+    debug "Unexpected muxer exception in mplex read loop", m, description = exc.msg
   finally:
     await m.close()
   trace "Stopped mplex handler", m
@@ -201,19 +199,19 @@ proc new*(
     conn: Connection,
     inTimeout: Duration = DefaultChanTimeout,
     outTimeout: Duration = DefaultChanTimeout,
-    maxChannCount: int = MaxChannelCount): Mplex =
-  M(connection: conn,
+    maxChannCount: int = MaxChannelCount,
+): Mplex =
+  M(
+    connection: conn,
     inChannTimeout: inTimeout,
     outChannTimeout: outTimeout,
     oid: genOid(),
-    maxChannCount: maxChannCount)
+    maxChannCount: maxChannCount,
+  )
 
 method newStream*(
-    m: Mplex,
-    name: string = "",
-    lazy: bool = false
-): Future[Connection] {.async: (raises: [
-    CancelledError, LPStreamError, MuxerError]).} =
+    m: Mplex, name: string = "", lazy: bool = false
+): Future[Connection] {.async: (raises: [CancelledError, LPStreamError, MuxerError]).} =
   let channel = m.newStreamInternal(timeout = m.inChannTimeout)
 
   if not lazy:
@@ -250,5 +248,7 @@ method close*(m: Mplex) {.async: (raises: []).} =
   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)
+  for c in m.channels[false].values:
+    result.add(c)
+  for c in m.channels[true].values:
+    result.add(c)

libp2p/muxers/muxer.nim

@@ -10,14 +10,12 @@
 {.push raises: [].}
 
 import chronos, chronicles
-import ../stream/connection,
-       ../errors
+import ../stream/connection, ../errors
 
 logScope:
   topics = "libp2p muxer"
 
-const
-  DefaultChanTimeout* = 5.minutes
+const DefaultChanTimeout* = 5.minutes
 
 type
   MuxerError* = object of LPError
@@ -32,8 +30,7 @@ type
     connection*: Connection
 
   # user provider proc that returns a constructed Muxer
-  MuxerConstructor* =
-    proc(conn: Connection): Muxer {.gcsafe, closure, raises: [].}
+  MuxerConstructor* = proc(conn: Connection): Muxer {.gcsafe, closure, raises: [].}
 
   # this wraps a creator proc that knows how to make muxers
   MuxerProvider* = object
@@ -41,30 +38,32 @@ type
     codec*: string
 
 func shortLog*(m: Muxer): auto =
-  if m == nil: "nil"
-  else: shortLog(m.connection)
+  if m == nil:
+    "nil"
+  else:
+    shortLog(m.connection)
 
-chronicles.formatIt(Muxer): shortLog(it)
+chronicles.formatIt(Muxer):
+  shortLog(it)
 
 # muxer interface
 method newStream*(
-    m: Muxer,
-    name: string = "",
-    lazy: bool = false
-): Future[Connection] {.base, async: (raises: [
-    CancelledError, LPStreamError, MuxerError], raw: true).} =
+    m: Muxer, name: string = "", lazy: bool = false
+): Future[Connection] {.
+    base, async: (raises: [CancelledError, LPStreamError, MuxerError], raw: true)
+.} =
   raiseAssert("Not implemented!")
 
 method close*(m: Muxer) {.base, async: (raises: []).} =
   if m.connection != nil:
     await m.connection.close()
 
-method handle*(m: Muxer): Future[void] {.base, async: (raises: []).} = discard
+method handle*(m: Muxer): Future[void] {.base, async: (raises: []).} =
+  discard
 
 proc new*(
-    T: typedesc[MuxerProvider],
-    creator: MuxerConstructor,
-    codec: string): T {.gcsafe.} =
+    T: typedesc[MuxerProvider], creator: MuxerConstructor, codec: string
+): T {.gcsafe.} =
   let muxerProvider = T(newMuxer: creator, codec: codec)
   muxerProvider
 

libp2p/muxers/yamux/yamux.nim

@@ -11,8 +11,7 @@
 
 import sequtils, std/[tables]
 import chronos, chronicles, metrics, stew/[endians2, byteutils, objects]
-import ../muxer,
-       ../../stream/connection
+import ../muxer, ../../stream/connection
 
 export muxer
 
@@ -27,14 +26,13 @@ const
   MaxChannelCount = 200
 
 when defined(libp2p_yamux_metrics):
-  declareGauge libp2p_yamux_channels,
-    "yamux channels", labels = ["initiator", "peer"]
+  declareGauge libp2p_yamux_channels, "yamux channels", labels = ["initiator", "peer"]
   declareHistogram libp2p_yamux_send_queue,
-    "message send queue length (in byte)", buckets = [
-      0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
+    "message send queue length (in byte)",
+    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
   declareHistogram libp2p_yamux_recv_queue,
-    "message recv queue length (in byte)", buckets = [
-      0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
+    "message recv queue length (in byte)",
+    buckets = [0.0, 100.0, 250.0, 1000.0, 2000.0, 3200.0, 6400.0, 25600.0, 256000.0]
 
 type
   YamuxError* = object of MuxerError
@@ -52,9 +50,9 @@ type
     Rst
 
   GoAwayStatus = enum
-    NormalTermination = 0x0,
-    ProtocolError = 0x1,
-    InternalError = 0x2,
+    NormalTermination = 0x0
+    ProtocolError = 0x1
+    InternalError = 0x2
 
   YamuxHeader = object
     version: uint8
@@ -65,88 +63,84 @@ type
 
 proc readHeader(
     conn: LPStream
-): Future[YamuxHeader] {.async: (raises: [
-    CancelledError, LPStreamError, MuxerError]).} =
+): Future[YamuxHeader] {.async: (raises: [CancelledError, LPStreamError, MuxerError]).} =
   var buffer: array[12, byte]
   await conn.readExactly(addr buffer[0], 12)
 
   result.version = buffer[0]
-  let flags = fromBytesBE(uint16, buffer[2..3])
-  if not result.msgType.checkedEnumAssign(buffer[1]) or flags notin 0'u16..15'u16:
-     raise newException(YamuxError, "Wrong header")
+  let flags = fromBytesBE(uint16, buffer[2 .. 3])
+  if not result.msgType.checkedEnumAssign(buffer[1]) or flags notin 0'u16 .. 15'u16:
+    raise newException(YamuxError, "Wrong header")
   result.flags = cast[set[MsgFlags]](flags)
-  result.streamId = fromBytesBE(uint32, buffer[4..7])
-  result.length = fromBytesBE(uint32, buffer[8..11])
+  result.streamId = fromBytesBE(uint32, buffer[4 .. 7])
+  result.length = fromBytesBE(uint32, buffer[8 .. 11])
   return result
 
 proc `$`(header: YamuxHeader): string =
-  "{" & $header.msgType & ", " &
-  "{" & header.flags.foldl(if a != "": a & ", " & $b else: $b, "") & "}, " &
-  "streamId: " & $header.streamId & ", " &
-  "length: " & $header.length & "}"
+  "{" & $header.msgType & ", " & "{" &
+    header.flags.foldl(
+      if a != "":
+        a & ", " & $b
+      else:
+        $b
+      ,
+      "",
+    ) & "}, " & "streamId: " & $header.streamId & ", " & "length: " & $header.length &
+    "}"
 
 proc encode(header: YamuxHeader): array[12, byte] =
   result[0] = header.version
   result[1] = uint8(header.msgType)
-  result[2..3] = toBytesBE(uint16(cast[uint8](header.flags))) # workaround https://github.com/nim-lang/Nim/issues/21789
-  result[4..7] = toBytesBE(header.streamId)
-  result[8..11] = toBytesBE(header.length)
+  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)
 
 proc write(
-    conn: LPStream,
-    header: YamuxHeader
-): Future[void] {.async: (raises: [
-    CancelledError, LPStreamError], raw: true).} =
+    conn: LPStream, header: YamuxHeader
+): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   trace "write directly on stream", h = $header
   var buffer = header.encode()
   conn.write(@buffer)
 
 proc ping(T: type[YamuxHeader], flag: MsgFlags, pingData: uint32): T =
-  T(
-    version: YamuxVersion,
-    msgType: MsgType.Ping,
-    flags: {flag},
-    length: pingData
-  )
+  T(version: YamuxVersion, msgType: MsgType.Ping, flags: {flag}, length: pingData)
 
 proc goAway(T: type[YamuxHeader], status: GoAwayStatus): T =
-  T(
-    version: YamuxVersion,
-    msgType: MsgType.GoAway,
-    length: uint32(status)
-  )
+  T(version: YamuxVersion, msgType: MsgType.GoAway, length: uint32(status))
 
 proc data(
     T: type[YamuxHeader],
     streamId: uint32,
     length: uint32 = 0,
-    flags: set[MsgFlags] = {}): T =
+    flags: set[MsgFlags] = {},
+): T =
   T(
     version: YamuxVersion,
     msgType: MsgType.Data,
     length: length,
     flags: flags,
-    streamId: streamId
+    streamId: streamId,
   )
 
 proc windowUpdate(
-    T: type[YamuxHeader],
-    streamId: uint32,
-    delta: uint32,
-    flags: set[MsgFlags] = {}): T =
+    T: type[YamuxHeader], streamId: uint32, delta: uint32, flags: set[MsgFlags] = {}
+): T =
   T(
     version: YamuxVersion,
     msgType: MsgType.WindowUpdate,
     length: delta,
     flags: flags,
-    streamId: streamId
+    streamId: streamId,
   )
 
 type
-  ToSend = tuple
-    data: seq[byte]
-    sent: int
-    fut: Future[void].Raising([CancelledError, LPStreamError])
+  ToSend =
+    tuple[
+      data: seq[byte],
+      sent: int,
+      fut: Future[void].Raising([CancelledError, LPStreamError]),
+    ]
   YamuxChannel* = ref object of Connection
     id: uint32
     recvWindow: int
@@ -161,7 +155,7 @@ type
     recvQueue: seq[byte]
     isReset: bool
     remoteReset: bool
-    closedRemotely: Future[void].Raising([])
+    closedRemotely: AsyncEvent
     closedLocally: bool
     receivedData: AsyncEvent
 
@@ -169,14 +163,23 @@ proc `$`(channel: YamuxChannel): string =
   result = if channel.conn.dir == Out: "=> " else: "<= "
   result &= $channel.id
   var s: seq[string] = @[]
-  if channel.closedRemotely.completed():
+  if channel.closedRemotely.isSet():
     s.add("ClosedRemotely")
   if channel.closedLocally:
     s.add("ClosedLocally")
   if channel.isReset:
     s.add("Reset")
   if s.len > 0:
-    result &= " {" & s.foldl(if a != "": a & ", " & b else: b, "") & "}"
+    result &=
+      " {" &
+      s.foldl(
+        if a != "":
+          a & ", " & b
+        else:
+          b
+        ,
+        "",
+      ) & "}"
 
 proc lengthSendQueue(channel: YamuxChannel): int =
   ## Returns the length of what remains to be sent
@@ -189,16 +192,18 @@ proc lengthSendQueueWithLimit(channel: YamuxChannel): int =
   # For leniency, limit big messages size to the third of maxSendQueueSize
   # This value is arbitrary, it's not in the specs, it permits to store up to
   # 3 big messages if the peer is stalling.
-  channel.sendQueue.foldl(a + min(b.data.len - b.sent, channel.maxSendQueueSize div 3), 0)
+  channel.sendQueue.foldl(
+    a + min(b.data.len - b.sent, channel.maxSendQueueSize div 3), 0
+  )
 
 proc actuallyClose(channel: YamuxChannel) {.async: (raises: []).} =
   if channel.closedLocally and channel.sendQueue.len == 0 and
-     channel.closedRemotely.completed():
+      channel.closedRemotely.isSet():
     await procCall Connection(channel).closeImpl()
 
 proc remoteClosed(channel: YamuxChannel) {.async: (raises: []).} =
-  if not channel.closedRemotely.completed():
-    channel.closedRemotely.complete()
+  if not channel.closedRemotely.isSet():
+    channel.closedRemotely.fire()
     await channel.actuallyClose()
 
 method closeImpl*(channel: YamuxChannel) {.async: (raises: []).} =
@@ -207,12 +212,13 @@ method closeImpl*(channel: YamuxChannel) {.async: (raises: []).} =
     channel.closedLocally = true
 
     if not channel.isReset and channel.sendQueue.len == 0:
-      try: await channel.conn.write(YamuxHeader.data(channel.id, 0, {Fin}))
-      except CancelledError, LPStreamError: discard
+      try:
+        await channel.conn.write(YamuxHeader.data(channel.id, 0, {Fin}))
+      except CancelledError, LPStreamError:
+        discard
     await channel.actuallyClose()
 
-proc reset(
-    channel: YamuxChannel, isLocal: bool = false) {.async: (raises: []).} =
+proc reset(channel: YamuxChannel, isLocal: bool = false) {.async: (raises: []).} =
   # If we reset locally, we want to flush up to a maximum of recvWindow
   # bytes. It's because the peer we're connected to can send us data before
   # it receives the reset.
@@ -228,10 +234,12 @@ proc reset(
   channel.sendWindow = 0
   if not channel.closedLocally:
     if isLocal and not channel.isSending:
-      try: await channel.conn.write(YamuxHeader.data(channel.id, 0, {Rst}))
-      except CancelledError, LPStreamError: discard
+      try:
+        await channel.conn.write(YamuxHeader.data(channel.id, 0, {Rst}))
+      except CancelledError, LPStreamError:
+        discard
     await channel.close()
-  if not channel.closedRemotely.completed():
+  if not channel.closedRemotely.isSet():
     await channel.remoteClosed()
   channel.receivedData.fire()
   if not isLocal:
@@ -251,16 +259,11 @@ proc updateRecvWindow(
 
   let delta = channel.maxRecvWindow - inWindow
   channel.recvWindow.inc(delta)
-  await channel.conn.write(YamuxHeader.windowUpdate(
-    channel.id,
-    delta.uint32
-  ))
+  await channel.conn.write(YamuxHeader.windowUpdate(channel.id, delta.uint32))
   trace "increasing the recvWindow", delta
 
 method readOnce*(
-    channel: YamuxChannel,
-    pbytes: pointer,
-    nbytes: int
+    channel: YamuxChannel, pbytes: pointer, nbytes: int
 ): Future[int] {.async: (raises: [CancelledError, LPStreamError]).} =
   ## Read from a yamux channel
 
@@ -276,19 +279,26 @@ method readOnce*(
     raise newLPStreamRemoteClosedError()
   if channel.recvQueue.len == 0:
     channel.receivedData.clear()
-    try:  # https://github.com/status-im/nim-chronos/issues/516
-      discard await race(channel.closedRemotely, channel.receivedData.wait())
-    except ValueError: raiseAssert("Futures list is not empty")
-    if channel.closedRemotely.completed() and channel.recvQueue.len == 0:
+    let
+      closedRemotelyFut = channel.closedRemotely.wait()
+      receivedDataFut = channel.receivedData.wait()
+    defer:
+      if not closedRemotelyFut.finished():
+        await closedRemotelyFut.cancelAndWait()
+      if not receivedDataFut.finished():
+        await receivedDataFut.cancelAndWait()
+    await closedRemotelyFut or receivedDataFut
+    if channel.closedRemotely.isSet() and channel.recvQueue.len == 0:
       channel.isEof = true
-      return 0 # we return 0 to indicate that the channel is closed for reading from now on
+      return
+        0 # we return 0 to indicate that the channel is closed for reading from now on
 
   let toRead = min(channel.recvQueue.len, nbytes)
 
   var p = cast[ptr UncheckedArray[byte]](pbytes)
-  toOpenArray(p, 0, nbytes - 1)[0..<toRead] =
+  toOpenArray(p, 0, nbytes - 1)[0 ..< toRead] =
     channel.recvQueue.toOpenArray(0, toRead - 1)
-  channel.recvQueue = channel.recvQueue[toRead..^1]
+  channel.recvQueue = channel.recvQueue[toRead ..^ 1]
 
   # We made some room in the recv buffer let the peer know
   await channel.updateRecvWindow()
@@ -296,8 +306,8 @@ method readOnce*(
   return toRead
 
 proc gotDataFromRemote(
-    channel: YamuxChannel,
-    b: seq[byte]) {.async: (raises: [CancelledError, LPStreamError]).} =
+    channel: YamuxChannel, b: seq[byte]
+) {.async: (raises: [CancelledError, LPStreamError]).} =
   channel.recvWindow -= b.len
   channel.recvQueue = channel.recvQueue.concat(b)
   channel.receivedData.fire()
@@ -314,7 +324,8 @@ proc trySend(
   if channel.isSending:
     return
   channel.isSending = true
-  defer: channel.isSending = false
+  defer:
+    channel.isSending = false
 
   while channel.sendQueue.len != 0:
     channel.sendQueue.keepItIf(not (it.fut.cancelled() and it.sent == 0))
@@ -339,15 +350,17 @@ proc trySend(
       trace "last buffer we'll sent on this channel", toSend, bytesAvailable
       header.flags.incl({Fin})
 
-    sendBuffer[0..<12] = header.encode()
+    sendBuffer[0 ..< 12] = header.encode()
 
     var futures: seq[Future[void].Raising([CancelledError, LPStreamError])]
     while inBuffer < toSend:
       # concatenate the different message we try to send into one buffer
       let (data, sent, fut) = channel.sendQueue[0]
       let bufferToSend = min(data.len - sent, toSend - inBuffer)
-      sendBuffer.toOpenArray(12, 12 + toSend - 1)[inBuffer..<(inBuffer+bufferToSend)] =
-        channel.sendQueue[0].data.toOpenArray(sent, sent + bufferToSend - 1)
+
+      sendBuffer.toOpenArray(12, 12 + toSend - 1)[
+        inBuffer ..< (inBuffer + bufferToSend)
+      ] = channel.sendQueue[0].data.toOpenArray(sent, sent + bufferToSend - 1)
       channel.sendQueue[0].sent.inc(bufferToSend)
       if channel.sendQueue[0].sent >= data.len:
         # if every byte of the message is in the buffer, add the write future to the
@@ -378,10 +391,8 @@ proc trySend(
     channel.activity = true
 
 method write*(
-    channel: YamuxChannel,
-    msg: seq[byte]
-): Future[void] {.async: (raises: [
-    CancelledError, LPStreamError], raw: true).} =
+    channel: YamuxChannel, msg: seq[byte]
+): Future[void] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   ## Write to yamux channel
   ##
   result = newFuture[void]("Yamux Send")
@@ -399,37 +410,39 @@ method write*(
     libp2p_yamux_send_queue.observe(channel.lengthSendQueue().int64)
   asyncSpawn channel.trySend()
 
-proc open(
-    channel: YamuxChannel
-) {.async: (raises: [CancelledError, LPStreamError]).} =
+proc open(channel: YamuxChannel) {.async: (raises: [CancelledError, LPStreamError]).} =
   ## Open a yamux channel by sending a window update with Syn or Ack flag
   ##
   if channel.opened:
     trace "Try to open channel twice"
     return
   channel.opened = true
-  await channel.conn.write(YamuxHeader.windowUpdate(
-    channel.id,
-    uint32(max(channel.maxRecvWindow - YamuxDefaultWindowSize, 0)),
-    {if channel.isSrc: Syn else: Ack}))
+  await channel.conn.write(
+    YamuxHeader.windowUpdate(
+      channel.id,
+      uint32(max(channel.maxRecvWindow - YamuxDefaultWindowSize, 0)),
+      {if channel.isSrc: Syn else: Ack},
+    )
+  )
 
-method getWrapped*(channel: YamuxChannel): Connection = channel.conn
+method getWrapped*(channel: YamuxChannel): Connection =
+  channel.conn
 
-type
-  Yamux* = ref object of Muxer
-    channels: Table[uint32, YamuxChannel]
-    flushed: Table[uint32, int]
-    currentId: uint32
-    isClosed: bool
-    maxChannCount: int
-    windowSize: int
-    maxSendQueueSize: int
-    inTimeout: Duration
-    outTimeout: Duration
+type Yamux* = ref object of Muxer
+  channels: Table[uint32, YamuxChannel]
+  flushed: Table[uint32, int]
+  currentId: uint32
+  isClosed: bool
+  maxChannCount: int
+  windowSize: int
+  maxSendQueueSize: int
+  inTimeout: Duration
+  outTimeout: Duration
 
 proc lenBySrc(m: Yamux, isSrc: bool): int =
   for v in m.channels.values():
-    if v.isSrc == isSrc: result += 1
+    if v.isSrc == isSrc:
+      result += 1
 
 proc cleanupChannel(m: Yamux, channel: YamuxChannel) {.async: (raises: []).} =
   try:
@@ -439,30 +452,30 @@ proc cleanupChannel(m: Yamux, channel: YamuxChannel) {.async: (raises: []).} =
   m.channels.del(channel.id)
   when defined(libp2p_yamux_metrics):
     libp2p_yamux_channels.set(
-      m.lenBySrc(channel.isSrc).int64, [$channel.isSrc, $channel.peerId])
+      m.lenBySrc(channel.isSrc).int64, [$channel.isSrc, $channel.peerId]
+    )
   if channel.isReset and channel.recvWindow > 0:
     m.flushed[channel.id] = channel.recvWindow
 
 proc createStream(
-    m: Yamux, id: uint32, isSrc: bool,
-    recvWindow: int, maxSendQueueSize: int): YamuxChannel =
+    m: Yamux, id: uint32, isSrc: bool, recvWindow: int, maxSendQueueSize: int
+): YamuxChannel =
   # During initialization, recvWindow can be larger than maxRecvWindow.
   # This is because the peer we're connected to will always assume
   # that the initial recvWindow is 256k.
   # To solve this contradiction, no updateWindow will be sent until
   # recvWindow is less than maxRecvWindow
-  proc newClosedRemotelyFut(): Future[void] {.async: (raises: [], raw: true).} =
-    newFuture[void]()
   var stream = YamuxChannel(
     id: id,
     maxRecvWindow: recvWindow,
-    recvWindow: if recvWindow > YamuxDefaultWindowSize: recvWindow else: YamuxDefaultWindowSize,
+    recvWindow:
+      if recvWindow > YamuxDefaultWindowSize: recvWindow else: YamuxDefaultWindowSize,
     sendWindow: YamuxDefaultWindowSize,
     maxSendQueueSize: maxSendQueueSize,
     isSrc: isSrc,
     conn: m.connection,
     receivedData: newAsyncEvent(),
-    closedRemotely: newClosedRemotelyFut()
+    closedRemotely: newAsyncEvent(),
   )
   stream.objName = "YamuxStream"
   if isSrc:
@@ -471,10 +484,9 @@ proc createStream(
   else:
     stream.dir = Direction.In
     stream.timeout = m.inTimeout
-  stream.timeoutHandler =
-    proc(): Future[void] {.async: (raises: [], raw: true).} =
-      trace "Idle timeout expired, resetting YamuxChannel"
-      stream.reset(isLocal = true)
+  stream.timeoutHandler = proc(): Future[void] {.async: (raises: [], raw: true).} =
+    trace "Idle timeout expired, resetting YamuxChannel"
+    stream.reset(isLocal = true)
   stream.initStream()
   stream.peerId = m.connection.peerId
   stream.observedAddr = m.connection.observedAddr
@@ -483,7 +495,7 @@ proc createStream(
     stream.shortAgent = m.connection.shortAgent
   m.channels[id] = stream
   asyncSpawn m.cleanupChannel(stream)
-  trace "created channel", id, pid=m.connection.peerId
+  trace "created channel", id, pid = m.connection.peerId
   when defined(libp2p_yamux_metrics):
     libp2p_yamux_channels.set(m.lenBySrc(isSrc).int64, [$isSrc, $stream.peerId])
   return stream
@@ -498,9 +510,12 @@ method close*(m: Yamux) {.async: (raises: []).} =
   let channels = toSeq(m.channels.values())
   for channel in channels:
     await channel.reset(isLocal = true)
-  try: await m.connection.write(YamuxHeader.goAway(NormalTermination))
-  except CancelledError as exc: trace "cancelled sending goAway", msg = exc.msg
-  except LPStreamError as exc: trace "failed to send goAway", msg = exc.msg
+  try:
+    await m.connection.write(YamuxHeader.goAway(NormalTermination))
+  except CancelledError as exc:
+    trace "cancelled sending goAway", description = exc.msg
+  except LPStreamError as exc:
+    trace "failed to send goAway", description = exc.msg
   await m.connection.close()
   trace "Closed yamux"
 
@@ -512,34 +527,40 @@ proc handleStream(m: Yamux, channel: YamuxChannel) {.async: (raises: []).} =
   doAssert(channel.isClosed, "connection not closed by handler!")
 
 method handle*(m: Yamux) {.async: (raises: []).} =
-  trace "Starting yamux handler", pid=m.connection.peerId
+  trace "Starting yamux handler", pid = m.connection.peerId
   try:
     while not m.connection.atEof:
       trace "waiting for header"
       let header = await m.connection.readHeader()
       trace "got message", h = $header
 
-      case header.msgType:
+      case header.msgType
       of Ping:
         if MsgFlags.Syn in header.flags:
           await m.connection.write(YamuxHeader.ping(MsgFlags.Ack, header.length))
       of GoAway:
         var status: GoAwayStatus
-        if status.checkedEnumAssign(header.length): trace "Received go away", status
-        else: trace "Received unexpected error go away"
+        if status.checkedEnumAssign(header.length):
+          trace "Received go away", status
+        else:
+          trace "Received unexpected error go away"
         break
       of Data, WindowUpdate:
         if MsgFlags.Syn in header.flags:
           if header.streamId in m.channels:
-            debug "Trying to create an existing channel, skipping", id=header.streamId
+            debug "Trying to create an existing channel, skipping", id = header.streamId
           else:
             if header.streamId in m.flushed:
               m.flushed.del(header.streamId)
 
             if header.streamId mod 2 == m.currentId mod 2:
-              debug "Peer used our reserved stream id, skipping", id=header.streamId, currentId=m.currentId, peerId=m.connection.peerId
+              debug "Peer used our reserved stream id, skipping",
+                id = header.streamId,
+                currentId = m.currentId,
+                peerId = m.connection.peerId
               raise newException(YamuxError, "Peer used our reserved stream id")
-            let newStream = m.createStream(header.streamId, false, m.windowSize, m.maxSendQueueSize)
+            let newStream =
+              m.createStream(header.streamId, false, m.windowSize, m.maxSendQueueSize)
             if m.channels.len >= m.maxChannCount:
               await newStream.reset()
               continue
@@ -551,23 +572,23 @@ method handle*(m: Yamux) {.async: (raises: []).} =
             if header.msgType == Data:
               flushed[].dec(int(header.length))
               if flushed[] < 0:
-                raise newException(YamuxError,
-                  "Peer exhausted the recvWindow after reset")
+                raise
+                  newException(YamuxError, "Peer exhausted the recvWindow after reset")
               if header.length > 0:
                 var buffer = newSeqUninitialized[byte](header.length)
-                await m.connection.readExactly(
-                  addr buffer[0], int(header.length))
+                await m.connection.readExactly(addr buffer[0], int(header.length))
           do:
-            raise newException(YamuxError,
-              "Unknown stream ID: " & $header.streamId)
+            raise newException(YamuxError, "Unknown stream ID: " & $header.streamId)
           continue
 
         let channel =
           try:
             m.channels[header.streamId]
           except KeyError:
-            raise newException(YamuxError,
-              "Stream was cleaned up before handling data: " & $header.streamId)
+            raise newException(
+              YamuxError,
+              "Stream was cleaned up before handling data: " & $header.streamId,
+            )
 
         if header.msgType == WindowUpdate:
           channel.sendWindow += int(header.length)
@@ -580,7 +601,7 @@ method handle*(m: Yamux) {.async: (raises: []).} =
           if header.length > 0:
             var buffer = newSeqUninitialized[byte](header.length)
             await m.connection.readExactly(addr buffer[0], int(header.length))
-            trace "Msg Rcv", msg=shortLog(buffer)
+            trace "Msg Rcv", description = shortLog(buffer)
             await channel.gotDataFromRemote(buffer)
 
         if MsgFlags.Fin in header.flags:
@@ -590,19 +611,19 @@ method handle*(m: Yamux) {.async: (raises: []).} =
           trace "remote reset channel"
           await channel.reset()
   except CancelledError as exc:
-    debug "Unexpected cancellation in yamux handler", msg = exc.msg
+    debug "Unexpected cancellation in yamux handler", description = exc.msg
   except LPStreamEOFError as exc:
-    trace "Stream EOF", msg = exc.msg
+    trace "Stream EOF", description = exc.msg
   except LPStreamError as exc:
-    debug "Unexpected stream exception in yamux read loop", msg = exc.msg
+    debug "Unexpected stream exception in yamux read loop", description = exc.msg
   except YamuxError as exc:
-    trace "Closing yamux connection", error=exc.msg
+    trace "Closing yamux connection", description = exc.msg
     try:
       await m.connection.write(YamuxHeader.goAway(ProtocolError))
     except CancelledError, LPStreamError:
       discard
   except MuxerError as exc:
-    debug "Unexpected muxer exception in yamux read loop", msg = exc.msg
+    debug "Unexpected muxer exception in yamux read loop", description = exc.msg
     try:
       await m.connection.write(YamuxHeader.goAway(ProtocolError))
     except CancelledError, LPStreamError:
@@ -612,14 +633,12 @@ method handle*(m: Yamux) {.async: (raises: []).} =
   trace "Stopped yamux handler"
 
 method getStreams*(m: Yamux): seq[Connection] =
-  for c in m.channels.values: result.add(c)
+  for c in m.channels.values:
+    result.add(c)
 
 method newStream*(
-    m: Yamux,
-    name: string = "",
-    lazy: bool = false
-): Future[Connection] {.async: (raises: [
-    CancelledError, LPStreamError, MuxerError]).} =
+    m: Yamux, name: string = "", lazy: bool = false
+): Future[Connection] {.async: (raises: [CancelledError, LPStreamError, MuxerError]).} =
   if m.channels.len > m.maxChannCount - 1:
     raise newException(TooManyChannels, "max allowed channel count exceeded")
   let stream = m.createStream(m.currentId, true, m.windowSize, m.maxSendQueueSize)
@@ -629,12 +648,14 @@ method newStream*(
   return stream
 
 proc new*(
-    T: type[Yamux], conn: Connection,
+    T: type[Yamux],
+    conn: Connection,
     maxChannCount: int = MaxChannelCount,
     windowSize: int = YamuxDefaultWindowSize,
     maxSendQueueSize: int = MaxSendQueueSize,
     inTimeout: Duration = 5.minutes,
-    outTimeout: Duration = 5.minutes): T =
+    outTimeout: Duration = 5.minutes,
+): T =
   T(
     connection: conn,
     currentId: if conn.dir == Out: 1 else: 2,
@@ -642,5 +663,5 @@ proc new*(
     windowSize: windowSize,
     maxSendQueueSize: maxSendQueueSize,
     inTimeout: inTimeout,
-    outTimeout: outTimeout
+    outTimeout: outTimeout,
   )

libp2p/nameresolving/dnsresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2023-2024 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -10,20 +10,20 @@
 {.push raises: [].}
 
 import
-  std/[streams, strutils, sets, sequtils],
-  chronos, chronicles, stew/byteutils,
+  std/[streams, sets, sequtils],
+  chronos,
+  chronicles,
+  stew/byteutils,
   dnsclientpkg/[protocol, types],
   ../utility
 
-import
-  nameresolver
+import nameresolver
 
 logScope:
   topics = "libp2p dnsresolver"
 
-type
-  DnsResolver* = ref object of NameResolver
-    nameServers*: seq[TransportAddress]
+type DnsResolver* = ref object of NameResolver
+  nameServers*: seq[TransportAddress]
 
 proc questionToBuf(address: string, kind: QKind): seq[byte] =
   try:
@@ -39,26 +39,33 @@ proc questionToBuf(address: string, kind: QKind): seq[byte] =
 
     var buf = newSeq[byte](dataLen)
     discard requestStream.readData(addr buf[0], dataLen)
-    return buf
-  except CatchableError as exc:
-    info "Failed to created DNS buffer", msg = exc.msg
-    return newSeq[byte](0)
+    buf
+  except IOError as exc:
+    info "Failed to created DNS buffer", description = exc.msg
+    newSeq[byte](0)
+  except OSError as exc:
+    info "Failed to created DNS buffer", description = exc.msg
+    newSeq[byte](0)
+  except ValueError as exc:
+    info "Failed to created DNS buffer", description = exc.msg
+    newSeq[byte](0)
 
 proc getDnsResponse(
-  dnsServer: TransportAddress,
-  address: string,
-  kind: QKind): Future[Response] {.async.} =
-
+    dnsServer: TransportAddress, address: string, kind: QKind
+): Future[Response] {.
+    async: (raises: [CancelledError, IOError, OSError, TransportError, ValueError])
+.} =
   var sendBuf = questionToBuf(address, kind)
 
   if sendBuf.len == 0:
     raise newException(ValueError, "Incorrect DNS query")
 
-  let receivedDataFuture = newFuture[void]()
+  let receivedDataFuture = Future[void].Raising([CancelledError]).init()
 
-  proc datagramDataReceived(transp: DatagramTransport,
-                  raddr: TransportAddress): Future[void] {.async, closure.} =
-      receivedDataFuture.complete()
+  proc datagramDataReceived(
+      transp: DatagramTransport, raddr: TransportAddress
+  ): Future[void] {.async: (raises: []), closure.} =
+    receivedDataFuture.complete()
 
   let sock =
     if dnsServer.family == AddressFamily.IPv6:
@@ -69,29 +76,41 @@ proc getDnsResponse(
   try:
     await sock.sendTo(dnsServer, addr sendBuf[0], sendBuf.len)
 
-    await receivedDataFuture or sleepAsync(5.seconds) #unix default
-
-    if not receivedDataFuture.finished:
+    try:
+      await receivedDataFuture.wait(5.seconds) #unix default
+    except AsyncTimeoutError:
       raise newException(IOError, "DNS server timeout")
 
     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 exceptionToAssert: parseResponse(string.fromBytes(rawResponse))
+    try:
+      parseResponse(string.fromBytes(rawResponse))
+    except IOError as exc:
+      raise exc
+    except OSError as exc:
+      raise exc
+    except ValueError as exc:
+      raise exc
+    except Exception as exc:
+      # Nim 1.6: parseResponse can has a raises: [Exception, ..] because of
+      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+      # it can't actually raise though
+      raiseAssert exc.msg
   finally:
     await sock.closeWait()
 
 method resolveIp*(
-  self: DnsResolver,
-  address: string,
-  port: Port,
-  domain: Domain = Domain.AF_UNSPEC): Future[seq[TransportAddress]] {.async.} =
-
+    self: DnsResolver, address: string, port: Port, domain: Domain = Domain.AF_UNSPEC
+): Future[seq[TransportAddress]] {.
+    async: (raises: [CancelledError, TransportAddressError])
+.} =
   trace "Resolving IP using DNS", address, servers = self.nameServers.mapIt($it), domain
   for _ in 0 ..< self.nameServers.len:
     let server = self.nameServers[0]
-    var responseFutures: seq[Future[Response]]
+    var responseFutures: seq[
+      Future[Response].Raising(
+        [CancelledError, IOError, OSError, TransportError, ValueError]
+      )
+    ]
     if domain == Domain.AF_INET or domain == Domain.AF_UNSPEC:
       responseFutures.add(getDnsResponse(server, address, A))
 
@@ -106,25 +125,32 @@ method resolveIp*(
     var
       resolvedAddresses: OrderedSet[string]
       resolveFailed = false
+    template handleFail(e): untyped =
+      info "Failed to query DNS", address, error = e.msg
+      resolveFailed = true
+      break
+
     for fut in responseFutures:
       try:
         let resp = await fut
         for answer in resp.answers:
-          # 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())
-          )
+          resolvedAddresses.incl(answer.toString())
       except CancelledError as e:
         raise e
       except ValueError as e:
-        info "Invalid DNS query", address, error=e.msg
+        info "Invalid DNS query", address, error = e.msg
         return @[]
-      except CatchableError as e:
-        info "Failed to query DNS", address, error=e.msg
-        resolveFailed = true
-        break
+      except IOError as e:
+        handleFail(e)
+      except OSError as e:
+        handleFail(e)
+      except TransportError as e:
+        handleFail(e)
+      except Exception as e:
+        # Nim 1.6: answer.toString can has a raises: [Exception, ..] because of
+        # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+        # it can't actually raise though
+        raiseAssert e.msg
 
     if resolveFailed:
       self.nameServers.add(self.nameServers[0])
@@ -138,32 +164,40 @@ method resolveIp*(
   return @[]
 
 method resolveTxt*(
-  self: DnsResolver,
-  address: string): Future[seq[string]] {.async.} =
-
+    self: DnsResolver, address: string
+): Future[seq[string]] {.async: (raises: [CancelledError]).} =
   trace "Resolving TXT using DNS", address, servers = self.nameServers.mapIt($it)
   for _ in 0 ..< self.nameServers.len:
     let server = self.nameServers[0]
-    try:
-      # toString can has a raises: [Exception, ..] because of
-      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
-      # it can't actually raise though
-      let response = await getDnsResponse(server, address, TXT)
-      return exceptionToAssert:
-        trace "Got TXT response", server = $server, answer=response.answers.mapIt(it.toString())
-        response.answers.mapIt(it.toString())
-    except CancelledError as e:
-      raise e
-    except CatchableError as e:
-      info "Failed to query DNS", address, error=e.msg
+    template handleFail(e): untyped =
+      info "Failed to query DNS", address, error = e.msg
       self.nameServers.add(self.nameServers[0])
       self.nameServers.delete(0)
       continue
 
+    try:
+      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())
+    except CancelledError as e:
+      raise e
+    except IOError as e:
+      handleFail(e)
+    except OSError as e:
+      handleFail(e)
+    except TransportError as e:
+      handleFail(e)
+    except ValueError as e:
+      handleFail(e)
+    except Exception as e:
+      # Nim 1.6: toString can has a raises: [Exception, ..] because of
+      # https://github.com/nim-lang/Nim/commit/035134de429b5d99c5607c5fae912762bebb6008
+      # it can't actually raise though
+      raiseAssert e.msg
+
   debug "Failed to resolve TXT, returning empty set"
   return @[]
 
-proc new*(
-  T: typedesc[DnsResolver],
-  nameServers: seq[TransportAddress]): T =
+proc new*(T: typedesc[DnsResolver], nameServers: seq[TransportAddress]): T =
   T(nameServers: nameServers)

libp2p/nameresolving/mockresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2023-2024 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,9 +9,7 @@
 
 {.push raises: [].}
 
-import
-  std/tables,
-  chronos, chronicles
+import std/tables, chronos, chronicles
 
 import nameresolver
 
@@ -26,21 +24,26 @@ type MockResolver* = ref object of NameResolver
   ipResponses*: Table[(string, bool), seq[string]]
 
 method resolveIp*(
-  self: MockResolver,
-  address: string,
-  port: Port,
-  domain: Domain = Domain.AF_UNSPEC): Future[seq[TransportAddress]] {.async.} =
+    self: MockResolver, address: string, port: Port, domain: Domain = Domain.AF_UNSPEC
+): Future[seq[TransportAddress]] {.
+    async: (raises: [CancelledError, TransportAddressError])
+.} =
+  var res: seq[TransportAddress]
+
   if domain == Domain.AF_INET or domain == Domain.AF_UNSPEC:
     for resp in self.ipResponses.getOrDefault((address, false)):
-      result.add(initTAddress(resp, port))
+      res.add(initTAddress(resp, port))
 
   if domain == Domain.AF_INET6 or domain == Domain.AF_UNSPEC:
     for resp in self.ipResponses.getOrDefault((address, true)):
-      result.add(initTAddress(resp, port))
+      res.add(initTAddress(resp, port))
+
+  res
 
 method resolveTxt*(
-  self: MockResolver,
-  address: string): Future[seq[string]] {.async.} =
-  return self.txtResponses.getOrDefault(address)
+    self: MockResolver, address: string
+): Future[seq[string]] {.async: (raises: [CancelledError]).} =
+  self.txtResponses.getOrDefault(address)
 
-proc new*(T: typedesc[MockResolver]): T = T()
+proc new*(T: typedesc[MockResolver]): T =
+  T()

libp2p/nameresolving/nameresolver.nim

@@ -1,5 +1,5 @@
 # Nim-LibP2P
-# Copyright (c) 2023 Status Research & Development GmbH
+# Copyright (c) 2023-2024 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -9,74 +9,75 @@
 
 {.push raises: [].}
 
-import std/[sugar, sets, sequtils, strutils]
-import
-  chronos,
-  chronicles,
-  stew/endians2
+import std/[sets, sequtils, strutils]
+import chronos, chronicles, stew/endians2
 import ".."/[multiaddress, multicodec]
 
 logScope:
   topics = "libp2p nameresolver"
 
-type
-  NameResolver* = ref object of RootObj
+type NameResolver* = ref object of RootObj
 
 method resolveTxt*(
-  self: NameResolver,
-  address: string): Future[seq[string]] {.async, base.} =
+    self: NameResolver, address: string
+): Future[seq[string]] {.async: (raises: [CancelledError]), base.} =
   ## Get TXT record
-  ##
-
-  doAssert(false, "Not implemented!")
+  raiseAssert "Not implemented!"
 
 method resolveIp*(
-  self: NameResolver,
-  address: string,
-  port: Port,
-  domain: Domain = Domain.AF_UNSPEC): Future[seq[TransportAddress]] {.async, base.} =
+    self: NameResolver, address: string, port: Port, domain: Domain = Domain.AF_UNSPEC
+): Future[seq[TransportAddress]] {.
+    async: (raises: [CancelledError, TransportAddressError]), base
+.} =
   ## Resolve the specified address
-  ##
-
-  doAssert(false, "Not implemented!")
+  raiseAssert "Not implemented!"
 
 proc getHostname*(ma: MultiAddress): string =
   let
-    firstPart = ma[0].valueOr: return ""
+    firstPart = ma[0].valueOr:
+      return ""
     fpSplitted = ($firstPart).split('/', 2)
-  if fpSplitted.len > 2: fpSplitted[2]
-  else: ""
+  if fpSplitted.len > 2:
+    fpSplitted[2]
+  else:
+    ""
 
 proc resolveOneAddress(
-  self: NameResolver,
-  ma: MultiAddress,
-  domain: Domain = Domain.AF_UNSPEC,
-  prefix = ""): Future[seq[MultiAddress]]
-  {.async.} =
-  #Resolve a single address
+    self: NameResolver, ma: MultiAddress, domain: Domain = Domain.AF_UNSPEC, prefix = ""
+): Future[seq[MultiAddress]] {.
+    async: (raises: [CancelledError, MaError, TransportAddressError])
+.} =
+  # Resolve a single address
+  let portPart = ma[1].valueOr:
+    raise maErr error
   var pbuf: array[2, byte]
-
-  var dnsval = getHostname(ma)
-
-  if ma[1].tryGet().protoArgument(pbuf).tryGet() == 0:
-    raise newException(MaError, "Incorrect port number")
+  let plen = portPart.protoArgument(pbuf).valueOr:
+    raise maErr error
+  if plen == 0:
+    raise maErr "Incorrect port number"
   let
     port = Port(fromBytesBE(uint16, pbuf))
+    dnsval = getHostname(ma)
     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.tryGet()): continue
-        createdAddress &= part.tryGet()
-      createdAddress
+  resolvedAddresses.mapIt:
+    let address = MultiAddress.init(it).valueOr:
+      raise maErr error
+    var createdAddress = address[0].valueOr:
+      raise maErr error
+    for part in ma:
+      let part = part.valueOr:
+        raise maErr error
+      if DNS.match(part):
+        continue
+      createdAddress &= part
+    createdAddress
 
 proc resolveDnsAddr*(
-  self: NameResolver,
-  ma: MultiAddress,
-  depth: int = 0): Future[seq[MultiAddress]] {.async.} =
-
+    self: NameResolver, ma: MultiAddress, depth: int = 0
+): Future[seq[MultiAddress]] {.
+    async: (raises: [CancelledError, MaError, TransportAddressError])
+.} =
   if not DNSADDR.matchPartial(ma):
     return @[ma]
 
@@ -85,52 +86,67 @@ proc resolveDnsAddr*(
     info "Stopping DNSADDR recursion, probably malicious", ma
     return @[]
 
-  var dnsval = getHostname(ma)
-
-  let txt = await self.resolveTxt("_dnsaddr." & dnsval)
+  let
+    dnsval = getHostname(ma)
+    txt = await self.resolveTxt("_dnsaddr." & dnsval)
 
   trace "txt entries", txt
 
-  var result: seq[MultiAddress]
-  for entry in txt:
-    if not entry.startsWith("dnsaddr="): continue
-    let entryValue = MultiAddress.init(entry[8..^1]).tryGet()
+  const codec = multiCodec("p2p")
+  let maCodec = block:
+    let hasCodec = ma.contains(codec).valueOr:
+      raise maErr error
+    if hasCodec:
+      ma[codec]
+    else:
+      (static(default(MaResult[MultiAddress])))
 
-    if entryValue.contains(multiCodec("p2p")).tryGet() and ma.contains(multiCodec("p2p")).tryGet():
-      if entryValue[multiCodec("p2p")] != ma[multiCodec("p2p")]:
-        continue
+  var res: seq[MultiAddress]
+  for entry in txt:
+    if not entry.startsWith("dnsaddr="):
+      continue
+    let
+      entryValue = MultiAddress.init(entry[8 ..^ 1]).valueOr:
+        raise maErr error
+      entryHasCodec = entryValue.contains(multiCodec("p2p")).valueOr:
+        raise maErr error
+    if entryHasCodec and maCodec.isOk and entryValue[codec] != maCodec:
+      continue
 
     let resolved = await self.resolveDnsAddr(entryValue, depth + 1)
     for r in resolved:
-      result.add(r)
+      res.add(r)
 
-  if result.len == 0:
+  if res.len == 0:
     debug "Failed to resolve a DNSADDR", ma
-    return @[]
-  return result
-
+  res
 
 proc resolveMAddress*(
-  self: NameResolver,
-  address: MultiAddress): Future[seq[MultiAddress]] {.async.} =
+    self: NameResolver, address: MultiAddress
+): Future[seq[MultiAddress]] {.
+    async: (raises: [CancelledError, MaError, TransportAddressError])
+.} =
   var res = initOrderedSet[MultiAddress]()
-
   if not DNS.matchPartial(address):
     res.incl(address)
   else:
-    let code = address[0].tryGet().protoCode().tryGet()
-    let seq = case code:
-      of multiCodec("dns"):
-        await self.resolveOneAddress(address)
-      of multiCodec("dns4"):
-        await self.resolveOneAddress(address, Domain.AF_INET)
-      of multiCodec("dns6"):
-        await self.resolveOneAddress(address, Domain.AF_INET6)
-      of multiCodec("dnsaddr"):
-        await self.resolveDnsAddr(address)
-      else:
-        assert false
-        @[address]
-    for ad in seq:
+    let
+      firstPart = address[0].valueOr:
+        raise maErr error
+      code = firstPart.protoCode().valueOr:
+        raise maErr error
+      ads =
+        case code
+        of multiCodec("dns"):
+          await self.resolveOneAddress(address)
+        of multiCodec("dns4"):
+          await self.resolveOneAddress(address, Domain.AF_INET)
+        of multiCodec("dns6"):
+          await self.resolveOneAddress(address, Domain.AF_INET6)
+        of multiCodec("dnsaddr"):
+          await self.resolveDnsAddr(address)
+        else:
+          raise maErr("Unsupported codec " & $code)
+    for ad in ads:
       res.incl(ad)
-  return res.toSeq
+  res.toSeq

libp2p/observedaddrmanager.nim

@@ -20,31 +20,39 @@ type
     maxSize: int
     minCount: int
 
-proc addObservation*(self:ObservedAddrManager, observedAddr: MultiAddress): bool =
+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.del(0)
   self.observedIPsAndPorts.add(observedAddr)
   return true
 
-proc getProtocol(self: ObservedAddrManager, observations: seq[MultiAddress], multiCodec: MultiCodec): Opt[MultiAddress] =
+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
+    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] =
+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
+      observedIp[0].valueOr:
+        continue
   return self.getProtocol(observedIPs, multiCodec)
 
-proc getMostObservedProtoAndPort(self: ObservedAddrManager, multiCodec: MultiCodec): Opt[MultiAddress] =
+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)
 
@@ -58,29 +66,27 @@ proc getMostObservedProtosAndPorts*(self: ObservedAddrManager): seq[MultiAddress
     res.add(ip6)
   return res
 
-proc guessDialableAddr*(
-  self: ObservedAddrManager,
-  ma: MultiAddress): MultiAddress =
+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
+    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
+  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 =
+proc new*(T: typedesc[ObservedAddrManager], maxSize = 10, minCount = 3): T =
   ## Creates a new ObservedAddrManager.
-  return T(
-    observedIPsAndPorts: newSeq[MultiAddress](),
-    maxSize: maxSize,
-    minCount: minCount)
+  return
+    T(observedIPsAndPorts: newSeq[MultiAddress](), maxSize: maxSize, minCount: minCount)

libp2p/peerid.nim

@@ -18,17 +18,18 @@ import
   chronicles,
   nimcrypto/utils,
   utility,
-  ./crypto/crypto, ./multicodec, ./multihash, ./vbuffer,
+  ./crypto/crypto,
+  ./multicodec,
+  ./multihash,
+  ./vbuffer,
   ./protobuf/minprotobuf
 
 export results, utility
 
-const
-  maxInlineKeyLength* = 42
+const maxInlineKeyLength* = 42
 
-type
-  PeerId* = object
-    data*: seq[byte]
+type PeerId* = object
+  data*: seq[byte]
 
 func `$`*(pid: PeerId): string =
   ## Return base58 encoded ``pid`` representation.
@@ -45,7 +46,8 @@ func shortLog*(pid: PeerId): string =
 
   spid
 
-chronicles.formatIt(PeerId): shortLog(it)
+chronicles.formatIt(PeerId):
+  shortLog(it)
 
 func toBytes*(pid: PeerId, data: var openArray[byte]): int =
   ## Store PeerId ``pid`` to array of bytes ``data``.
@@ -78,7 +80,8 @@ func cmp*(a, b: PeerId): int =
   var m = min(len(a.data), len(b.data))
   while i < m:
     result = ord(a.data[i]) - ord(b.data[i])
-    if result != 0: return
+    if result != 0:
+      return
     inc(i)
   result = len(a.data) - len(b.data)
 
@@ -165,18 +168,18 @@ func init*(t: typedesc[PeerId], data: string): Result[PeerId, cstring] =
 
 func init*(t: typedesc[PeerId], pubkey: PublicKey): Result[PeerId, cstring] =
   ## Create new peer id from public key ``pubkey``.
-  var pubraw = ? pubkey.getBytes().orError(
-    cstring("peerid: failed to get bytes from given key"))
+  var pubraw =
+    ?pubkey.getBytes().orError(cstring("peerid: failed to get bytes from given key"))
   var mh: MultiHash
   if len(pubraw) <= maxInlineKeyLength:
-    mh = ? MultiHash.digest("identity", pubraw)
+    mh = ?MultiHash.digest("identity", pubraw)
   else:
-    mh = ? MultiHash.digest("sha2-256", pubraw)
+    mh = ?MultiHash.digest("sha2-256", pubraw)
   ok(PeerId(data: mh.data.buffer))
 
 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")))
+  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.
@@ -201,12 +204,13 @@ func write*(pb: var ProtoBuffer, field: int, pid: PeerId) =
   ## Write PeerId value ``peerid`` to object ``pb`` using ProtoBuf's encoding.
   write(pb, field, pid.data)
 
-func getField*(pb: ProtoBuffer, field: int,
-               pid: var PeerId): ProtoResult[bool] {.inline.} =
+func getField*(
+    pb: ProtoBuffer, field: int, pid: var PeerId
+): ProtoResult[bool] {.inline.} =
   ## Read ``PeerId`` from ProtoBuf's message and validate it
   var buffer: seq[byte]
-  let res = ? pb.getField(field, buffer)
-  if not(res):
+  let res = ?pb.getField(field, buffer)
+  if not (res):
     ok(false)
   else:
     var peerId: PeerId

libp2p/peerinfo.nim

@@ -21,15 +21,18 @@ export peerid, multiaddress, crypto, routing_record, errors, results
 type
   PeerInfoError* = object of LPError
 
-  AddressMapper* =
-    proc(listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]]
-      {.gcsafe, raises: [].}
+  AddressMapper* = proc(listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.
+    gcsafe, raises: []
+  .} ## A proc that expected to resolve the listen addresses into dialable addresses
 
   PeerInfo* {.public.} = ref object
     peerId*: PeerId
     listenAddrs*: seq[MultiAddress]
-    addrs: seq[MultiAddress]
+    ## contains addresses the node listens on, which may include wildcard and private addresses (not directly reachable).
+    addrs*: seq[MultiAddress]
+    ## contains resolved addresses that other peers can use to connect, including public-facing NAT and port-forwarded addresses.
     addressMappers*: seq[AddressMapper]
+    ## contains a list of procs that can be used to resolve the listen addresses into dialable addresses.
     protocols*: seq[string]
     protoVersion*: string
     agentVersion*: string
@@ -46,17 +49,21 @@ func shortLog*(p: PeerInfo): auto =
     protoVersion: p.protoVersion,
     agentVersion: p.agentVersion,
   )
-chronicles.formatIt(PeerInfo): shortLog(it)
+chronicles.formatIt(PeerInfo):
+  shortLog(it)
 
 proc update*(p: PeerInfo) {.async.} =
-  p.addrs = p.listenAddrs
+  # p.addrs.len == 0 overrides addrs only if it is the first time update is being executed or if the field is empty.
+  # p.addressMappers.len == 0 is for when all addressMappers have been removed,
+  # and we wish to have addrs in its initial state, i.e., a copy of listenAddrs.
+  if p.addrs.len == 0 or p.addressMappers.len == 0:
+    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():
+    p.privateKey, PeerRecord.init(p.peerId, p.addrs)
+  ).valueOr:
     info "Can't update the signed peer record"
     return
 
@@ -64,38 +71,35 @@ proc addrs*(p: PeerInfo): seq[MultiAddress] =
   p.addrs
 
 proc fullAddrs*(p: PeerInfo): MaResult[seq[MultiAddress]] =
-  let peerIdPart = ? MultiAddress.init(multiCodec("p2p"), p.peerId.data)
+  let peerIdPart = ?MultiAddress.init(multiCodec("p2p"), p.peerId.data)
   var res: seq[MultiAddress]
   for address in p.addrs:
-    res.add(? concat(address, peerIdPart))
+    res.add(?concat(address, peerIdPart))
   ok(res)
 
 proc parseFullAddress*(ma: MultiAddress): MaResult[(PeerId, MultiAddress)] =
-  let p2pPart = ? ma[^1]
-  if ? p2pPart.protoCode != multiCodec("p2p"):
+  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]
-  )
+  let res =
+    (?PeerId.init(?p2pPart.protoArgument()).orErr("invalid peerid"), ?ma[0 .. ^2])
   ok(res)
 
 proc parseFullAddress*(ma: string | seq[byte]): MaResult[(PeerId, MultiAddress)] =
-  parseFullAddress(? MultiAddress.init(ma))
+  parseFullAddress(?MultiAddress.init(ma))
 
 proc new*(
-  p: typedesc[PeerInfo],
-  key: PrivateKey,
-  listenAddrs: openArray[MultiAddress] = [],
-  protocols: openArray[string] = [],
-  protoVersion: string = "",
-  agentVersion: string = "",
-  addressMappers = newSeq[AddressMapper](),
-  ): PeerInfo
-  {.raises: [LPError].} =
-
-  let pubkey = try:
+    p: typedesc[PeerInfo],
+    key: PrivateKey,
+    listenAddrs: openArray[MultiAddress] = [],
+    protocols: openArray[string] = [],
+    protoVersion: string = "",
+    agentVersion: string = "",
+    addressMappers = newSeq[AddressMapper](),
+): PeerInfo {.raises: [LPError].} =
+  let pubkey =
+    try:
       key.getPublicKey().tryGet()
     except CatchableError:
       raise newException(PeerInfoError, "invalid private key")
@@ -110,7 +114,7 @@ proc new*(
     agentVersion: agentVersion,
     listenAddrs: @listenAddrs,
     protocols: @protocols,
-    addressMappers: addressMappers
+    addressMappers: addressMappers,
   )
 
   return peerInfo

libp2p/peerstore.nim

@@ -29,7 +29,8 @@ import
   ./crypto/crypto,
   ./protocols/identify,
   ./protocols/protocol,
-  ./peerid, ./peerinfo,
+  ./peerid,
+  ./peerinfo,
   ./routing_record,
   ./multiaddress,
   ./stream/connection,
@@ -41,7 +42,6 @@ type
   #################
   # Handler types #
   #################
-
   PeerBookChangeHandler* = proc(peerId: PeerId) {.gcsafe, raises: [].}
 
   #########
@@ -63,37 +63,33 @@ type
   KeyBook* {.public.} = ref object of PeerBook[PublicKey]
 
   AgentBook* {.public.} = ref object of PeerBook[string]
+  LastSeenBook* {.public.} = ref object of PeerBook[Opt[MultiAddress]]
   ProtoVersionBook* {.public.} = ref object of PeerBook[string]
   SPRBook* {.public.} = ref object of PeerBook[Envelope]
 
   ####################
   # Peer store types #
   ####################
-
   PeerStore* {.public.} = ref object
     books: Table[string, BasePeerBook]
     identify: Identify
     capacity*: int
     toClean*: seq[PeerId]
 
-proc new*(T: type PeerStore, identify: Identify, capacity = 1000): PeerStore {.public.} =
-  T(
-    identify: identify,
-    capacity: capacity
-  )
+proc new*(
+    T: type PeerStore, identify: Identify, capacity = 1000
+): PeerStore {.public.} =
+  T(identify: identify, capacity: capacity)
 
 #########################
 # Generic Peer Book API #
 #########################
 
-proc `[]`*[T](peerBook: PeerBook[T],
-             peerId: PeerId): T {.public.} =
+proc `[]`*[T](peerBook: PeerBook[T], peerId: PeerId): T {.public.} =
   ## Get all known metadata of a provided peer, or default(T) if missing
   peerBook.book.getOrDefault(peerId)
 
-proc `[]=`*[T](peerBook: PeerBook[T],
-             peerId: PeerId,
-             entry: T) {.public.} =
+proc `[]=`*[T](peerBook: PeerBook[T], peerId: PeerId, entry: T) {.public.} =
   ## Set metadata for a given peerId.
 
   peerBook.book[peerId] = entry
@@ -102,8 +98,7 @@ proc `[]=`*[T](peerBook: PeerBook[T],
   for handler in peerBook.changeHandlers:
     handler(peerId)
 
-proc del*[T](peerBook: PeerBook[T],
-                peerId: PeerId): bool {.public.} =
+proc del*[T](peerBook: PeerBook[T], peerId: PeerId): bool {.public.} =
   ## Delete the provided peer from the book. Returns whether the peer was in the book
 
   if peerId notin peerBook.book:
@@ -122,7 +117,8 @@ proc addHandler*[T](peerBook: PeerBook[T], handler: PeerBookChangeHandler) {.pub
   ## Adds a callback that will be called everytime the book changes
   peerBook.changeHandlers.add(handler)
 
-proc len*[T](peerBook: PeerBook[T]): int {.public.} = peerBook.book.len
+proc len*[T](peerBook: PeerBook[T]): int {.public.} =
+  peerBook.book.len
 
 ##################
 # Peer Store API #
@@ -145,19 +141,21 @@ proc `[]`*[T](p: PeerStore, typ: type[T]): T {.public.} =
     p.books[name] = result
   return result
 
-proc del*(peerStore: PeerStore,
-             peerId: PeerId) {.public.} =
+proc del*(peerStore: PeerStore, peerId: PeerId) {.public.} =
   ## Delete the provided peer from every book.
   for _, book in peerStore.books:
     book.deletor(peerId)
 
 proc updatePeerInfo*(
-  peerStore: PeerStore,
-  info: IdentifyInfo) =
-
-  if info.addrs.len > 0:
+    peerStore: PeerStore,
+    info: IdentifyInfo,
+    observedAddr: Opt[MultiAddress] = Opt.none(MultiAddress),
+) =
+  if len(info.addrs) > 0:
     peerStore[AddressBook][info.peerId] = info.addrs
 
+  peerStore[LastSeenBook][info.peerId] = observedAddr
+
   info.pubkey.withValue(pubkey):
     peerStore[KeyBook][info.peerId] = pubkey
 
@@ -177,10 +175,7 @@ proc updatePeerInfo*(
   if cleanupPos >= 0:
     peerStore.toClean.delete(cleanupPos)
 
-proc cleanup*(
-  peerStore: PeerStore,
-  peerId: PeerId) =
-
+proc cleanup*(peerStore: PeerStore, peerId: PeerId) =
   if peerStore.capacity == 0:
     peerStore.del(peerId)
     return
@@ -193,10 +188,7 @@ proc cleanup*(
     peerStore.del(peerStore.toClean[0])
     peerStore.toClean.delete(0)
 
-proc identify*(
-  peerStore: PeerStore,
-  muxer: Muxer) {.async.} =
-
+proc identify*(peerStore: PeerStore, muxer: Muxer) {.async.} =
   # new stream for identify
   var stream = await muxer.newStream()
   if stream == nil:
@@ -209,12 +201,13 @@ proc identify*(
       when defined(libp2p_agents_metrics):
         var
           knownAgent = "unknown"
-          shortAgent = info.agentVersion.get("").split("/")[0].safeToLowerAscii().get("")
+          shortAgent =
+            info.agentVersion.get("").split("/")[0].safeToLowerAscii().get("")
         if KnownLibP2PAgentsSeq.contains(shortAgent):
           knownAgent = shortAgent
         muxer.connection.setShortAgent(knownAgent)
 
-      peerStore.updatePeerInfo(info)
+      peerStore.updatePeerInfo(info, stream.observedAddr)
   finally:
     await stream.closeWithEOF()
 

libp2p/protobuf/minprotobuf.nim

@@ -16,31 +16,33 @@ export results, utility
 
 {.push public.}
 
-const MaxMessageSize = 1'u shl 22
-
 type
   ProtoFieldKind* = enum
     ## Protobuf's field types enum
-    Varint, Fixed64, Length, StartGroup, EndGroup, Fixed32
+    Varint
+    Fixed64
+    Length
+    StartGroup
+    EndGroup
+    Fixed32
 
   ProtoFlags* = enum
     ## Protobuf's encoding types
-    WithVarintLength, WithUint32BeLength, WithUint32LeLength
+    WithVarintLength
+    WithUint32BeLength
+    WithUint32LeLength
 
-  ProtoBuffer* = object
-    ## Protobuf's message representation object
+  ProtoBuffer* = object ## Protobuf's message representation object
     options: set[ProtoFlags]
     buffer*: seq[byte]
     offset*: int
     length*: int
-    maxSize*: uint
 
   ProtoHeader* = object
     wire*: ProtoFieldKind
     index*: uint64
 
-  ProtoField* = object
-    ## Protobuf's message field representation object
+  ProtoField* = object ## Protobuf's message field representation object
     index*: int
     case kind*: ProtoFieldKind
     of Varint:
@@ -55,30 +57,32 @@ type
       discard
 
   ProtoError* {.pure.} = enum
-    VarintDecode,
-    MessageIncomplete,
-    BufferOverflow,
-    MessageTooBig,
-    BadWireType,
-    IncorrectBlob,
+    VarintDecode
+    MessageIncomplete
+    BufferOverflow
+    BadWireType
+    IncorrectBlob
     RequiredFieldMissing
 
   ProtoResult*[T] = Result[T, ProtoError]
 
-  ProtoScalar* = uint | uint32 | uint64 | zint | zint32 | zint64 |
-                 hint | hint32 | hint64 | float32 | float64
+  ProtoScalar* =
+    uint | uint32 | uint64 | zint | zint32 | zint64 | hint | hint32 | hint64 | float32 |
+    float64
 
-const
-  SupportedWireTypes* = @[
+const SupportedWireTypes* =
+  @[
     uint64(ProtoFieldKind.Varint),
     uint64(ProtoFieldKind.Fixed64),
     uint64(ProtoFieldKind.Length),
-    uint64(ProtoFieldKind.Fixed32)
+    uint64(ProtoFieldKind.Fixed32),
   ]
 
 template checkFieldNumber*(i: int) =
-  doAssert((i > 0 and i < (1 shl 29)) and not(i >= 19000 and i <= 19999),
-           "Incorrect or reserved field number")
+  doAssert(
+    (i > 0 and i < (1 shl 29)) and not (i >= 19000 and i <= 19999),
+    "Incorrect or reserved field number",
+  )
 
 template getProtoHeader*(index: int, wire: ProtoFieldKind): uint64 =
   ## Get protobuf's field header integer for ``index`` and ``wire``.
@@ -91,11 +95,14 @@ template getProtoHeader*(field: ProtoField): uint64 =
 template toOpenArray*(pb: ProtoBuffer): untyped =
   toOpenArray(pb.buffer, pb.offset, len(pb.buffer) - 1)
 
+template lenu64*(x: untyped): untyped =
+  uint64(len(x))
+
 template isEmpty*(pb: ProtoBuffer): bool =
   len(pb.buffer) - pb.offset <= 0
 
-template isEnough*(pb: ProtoBuffer, length: int): bool =
-  len(pb.buffer) - pb.offset - length >= 0
+template isEnough*(pb: ProtoBuffer, length: uint64): bool =
+  pb.offset <= len(pb.buffer) and length <= uint64(len(pb.buffer) - pb.offset)
 
 template getPtr*(pb: ProtoBuffer): pointer =
   cast[pointer](unsafeAddr pb.buffer[pb.offset])
@@ -114,33 +121,30 @@ proc vsizeof*(field: ProtoField): int {.inline.} =
     vsizeof(getProtoHeader(field)) + sizeof(field.vfloat32)
   of ProtoFieldKind.Length:
     vsizeof(getProtoHeader(field)) + vsizeof(uint64(len(field.vbuffer))) +
-    len(field.vbuffer)
+      len(field.vbuffer)
   else:
     0
 
-proc initProtoBuffer*(data: seq[byte], offset = 0,
-                      options: set[ProtoFlags] = {},
-                      maxSize = MaxMessageSize): ProtoBuffer =
+proc initProtoBuffer*(
+    data: seq[byte], offset = 0, options: set[ProtoFlags] = {}
+): ProtoBuffer =
   ## Initialize ProtoBuffer with shallow copy of ``data``.
   result.buffer = data
   result.offset = offset
   result.options = options
-  result.maxSize = maxSize
 
-proc initProtoBuffer*(data: openArray[byte], offset = 0,
-                      options: set[ProtoFlags] = {},
-                      maxSize = MaxMessageSize): ProtoBuffer =
+proc initProtoBuffer*(
+    data: openArray[byte], offset = 0, options: set[ProtoFlags] = {}
+): ProtoBuffer =
   ## Initialize ProtoBuffer with copy of ``data``.
   result.buffer = @data
   result.offset = offset
   result.options = options
-  result.maxSize = maxSize
 
-proc initProtoBuffer*(options: set[ProtoFlags] = {}, maxSize = MaxMessageSize): ProtoBuffer =
+proc initProtoBuffer*(options: set[ProtoFlags] = {}): 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].
@@ -152,59 +156,53 @@ proc initProtoBuffer*(options: set[ProtoFlags] = {}, maxSize = MaxMessageSize):
     result.buffer.setLen(4)
     result.offset = 4
 
-proc write*[T: ProtoScalar](pb: var ProtoBuffer,
-                            field: int, value: T) =
+proc write*[T: ProtoScalar](pb: var ProtoBuffer, field: int, value: T) =
   checkFieldNumber(field)
   var length = 0
-  when (T is uint64) or (T is uint32) or (T is uint) or
-       (T is zint64) or (T is zint32) or (T is zint) or
-       (T is hint64) or (T is hint32) or (T is hint):
-    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Varint)) +
-                  vsizeof(value)
+  when (T is uint64) or (T is uint32) or (T is uint) or (T is zint64) or (T is zint32) or
+      (T is zint) or (T is hint64) or (T is hint32) or (T is hint):
+    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Varint)) + vsizeof(value)
     let header = ProtoFieldKind.Varint
   elif T is float32:
-    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Fixed32)) +
-                  sizeof(T)
+    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Fixed32)) + sizeof(T)
     let header = ProtoFieldKind.Fixed32
   elif T is float64:
-    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Fixed64)) +
-                  sizeof(T)
+    let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Fixed64)) + sizeof(T)
     let header = ProtoFieldKind.Fixed64
 
   pb.buffer.setLen(len(pb.buffer) + flength)
 
-  let hres = PB.putUVarint(pb.toOpenArray(), length,
-                           getProtoHeader(field, header))
+  let hres = PB.putUVarint(pb.toOpenArray(), length, getProtoHeader(field, header))
   doAssert(hres.isOk())
   pb.offset += length
   when (T is uint64) or (T is uint32) or (T is uint):
     let vres = PB.putUVarint(pb.toOpenArray(), length, value)
     doAssert(vres.isOk())
     pb.offset += length
-  elif (T is zint64) or (T is zint32) or (T is zint) or
-       (T is hint64) or (T is hint32) or (T is hint):
+  elif (T is zint64) or (T is zint32) or (T is zint) or (T is hint64) or (T is hint32) or
+      (T is hint):
     let vres = putSVarint(pb.toOpenArray(), length, value)
     doAssert(vres.isOk())
     pb.offset += length
   elif T is float32:
-    doAssert(pb.isEnough(sizeof(T)))
+    doAssert(pb.isEnough(uint64(sizeof(T))))
     let u32 = cast[uint32](value)
     pb.buffer[pb.offset ..< pb.offset + sizeof(T)] = u32.toBytesLE()
     pb.offset += sizeof(T)
   elif T is float64:
-    doAssert(pb.isEnough(sizeof(T)))
+    doAssert(pb.isEnough(uint64(sizeof(T))))
     let u64 = cast[uint64](value)
     pb.buffer[pb.offset ..< pb.offset + sizeof(T)] = u64.toBytesLE()
     pb.offset += sizeof(T)
 
-proc writePacked*[T: ProtoScalar](pb: var ProtoBuffer, field: int,
-                                  value: openArray[T]) =
+proc writePacked*[T: ProtoScalar](
+    pb: var ProtoBuffer, field: int, value: openArray[T]
+) =
   checkFieldNumber(field)
   var length = 0
   let dlength =
-    when (T is uint64) or (T is uint32) or (T is uint) or
-         (T is zint64) or (T is zint32) or (T is zint) or
-         (T is hint64) or (T is hint32) or (T is hint):
+    when (T is uint64) or (T is uint32) or (T is uint) or (T is zint64) or (T is zint32) or
+        (T is zint) or (T is hint64) or (T is hint32) or (T is hint):
       var res = 0
       for item in value:
         res += vsizeof(item)
@@ -228,40 +226,40 @@ proc writePacked*[T: ProtoScalar](pb: var ProtoBuffer, field: int,
       let vres = PB.putUVarint(pb.toOpenArray(), length, item)
       doAssert(vres.isOk())
       pb.offset += length
-    elif (T is zint64) or (T is zint32) or (T is zint) or
-         (T is hint64) or (T is hint32) or (T is hint):
+    elif (T is zint64) or (T is zint32) or (T is zint) or (T is hint64) or (T is hint32) or
+        (T is hint):
       length = 0
       let vres = PB.putSVarint(pb.toOpenArray(), length, item)
       doAssert(vres.isOk())
       pb.offset += length
     elif T is float32:
-      doAssert(pb.isEnough(sizeof(T)))
+      doAssert(pb.isEnough(uint64(sizeof(T))))
       let u32 = cast[uint32](item)
       pb.buffer[pb.offset ..< pb.offset + sizeof(T)] = u32.toBytesLE()
       pb.offset += sizeof(T)
     elif T is float64:
-      doAssert(pb.isEnough(sizeof(T)))
+      doAssert(pb.isEnough(uint64(sizeof(T))))
       let u64 = cast[uint64](item)
       pb.buffer[pb.offset ..< pb.offset + sizeof(T)] = u64.toBytesLE()
       pb.offset += sizeof(T)
 
-proc write*[T: byte|char](pb: var ProtoBuffer, field: int,
-                          value: openArray[T]) =
+proc write*[T: byte | char](pb: var ProtoBuffer, field: int, value: openArray[T]) =
   checkFieldNumber(field)
   var length = 0
-  let flength = vsizeof(getProtoHeader(field, ProtoFieldKind.Length)) +
-                vsizeof(uint64(len(value))) + len(value)
+  let flength =
+    vsizeof(getProtoHeader(field, ProtoFieldKind.Length)) + vsizeof(uint64(len(value))) +
+    len(value)
   pb.buffer.setLen(len(pb.buffer) + flength)
-  let hres = PB.putUVarint(pb.toOpenArray(), length,
-                           getProtoHeader(field, ProtoFieldKind.Length))
+  let hres = PB.putUVarint(
+    pb.toOpenArray(), length, getProtoHeader(field, ProtoFieldKind.Length)
+  )
   doAssert(hres.isOk())
   pb.offset += length
-  let lres = PB.putUVarint(pb.toOpenArray(), length,
-                           uint64(len(value)))
+  let lres = PB.putUVarint(pb.toOpenArray(), length, uint64(len(value)))
   doAssert(lres.isOk())
   pb.offset += length
   if len(value) > 0:
-    doAssert(pb.isEnough(len(value)))
+    doAssert(pb.isEnough(value.lenu64))
     copyMem(addr pb.buffer[pb.offset], unsafeAddr value[0], len(value))
     pb.offset += len(value)
 
@@ -294,8 +292,7 @@ proc finish*(pb: var ProtoBuffer) =
     doAssert(len(pb.buffer) > 0)
     pb.offset = 0
 
-proc getHeader(data: var ProtoBuffer,
-               header: var ProtoHeader): ProtoResult[void] =
+proc getHeader(data: var ProtoBuffer, header: var ProtoHeader): ProtoResult[void] =
   var length = 0
   var hdr = 0'u64
   if PB.getUVarint(data.toOpenArray(), length, hdr).isOk():
@@ -321,13 +318,13 @@ proc skipValue(data: var ProtoBuffer, header: ProtoHeader): ProtoResult[void] =
     else:
       err(ProtoError.VarintDecode)
   of ProtoFieldKind.Fixed32:
-    if data.isEnough(sizeof(uint32)):
+    if data.isEnough(uint64(sizeof(uint32))):
       data.offset += sizeof(uint32)
       ok()
     else:
       err(ProtoError.VarintDecode)
   of ProtoFieldKind.Fixed64:
-    if data.isEnough(sizeof(uint64)):
+    if data.isEnough(uint64(sizeof(uint64))):
       data.offset += sizeof(uint64)
       ok()
     else:
@@ -337,22 +334,19 @@ 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(data.maxSize):
-        if data.isEnough(int(bsize)):
-          data.offset += int(bsize)
-          ok()
-        else:
-          err(ProtoError.MessageIncomplete)
+      if data.isEnough(bsize):
+        data.offset += int(bsize)
+        ok()
       else:
-        err(ProtoError.MessageTooBig)
+        err(ProtoError.MessageIncomplete)
     else:
       err(ProtoError.VarintDecode)
   of ProtoFieldKind.StartGroup, ProtoFieldKind.EndGroup:
     err(ProtoError.BadWireType)
 
-proc getValue[T: ProtoScalar](data: var ProtoBuffer,
-                              header: ProtoHeader,
-                              outval: var T): ProtoResult[void] =
+proc getValue[T: ProtoScalar](
+    data: var ProtoBuffer, header: ProtoHeader, outval: var T
+): ProtoResult[void] =
   when (T is uint64) or (T is uint32) or (T is uint):
     doAssert(header.wire == ProtoFieldKind.Varint)
     var length = 0
@@ -363,8 +357,8 @@ proc getValue[T: ProtoScalar](data: var ProtoBuffer,
       ok()
     else:
       err(ProtoError.VarintDecode)
-  elif (T is zint64) or (T is zint32) or (T is zint) or
-       (T is hint64) or (T is hint32) or (T is hint):
+  elif (T is zint64) or (T is zint32) or (T is zint) or (T is hint64) or (T is hint32) or
+      (T is hint):
     doAssert(header.wire == ProtoFieldKind.Varint)
     var length = 0
     var value = T(0)
@@ -376,7 +370,7 @@ proc getValue[T: ProtoScalar](data: var ProtoBuffer,
       err(ProtoError.VarintDecode)
   elif T is float32:
     doAssert(header.wire == ProtoFieldKind.Fixed32)
-    if data.isEnough(sizeof(float32)):
+    if data.isEnough(uint64(sizeof(float32))):
       outval = cast[float32](fromBytesLE(uint32, data.toOpenArray()))
       data.offset += sizeof(float32)
       ok()
@@ -384,16 +378,19 @@ proc getValue[T: ProtoScalar](data: var ProtoBuffer,
       err(ProtoError.MessageIncomplete)
   elif T is float64:
     doAssert(header.wire == ProtoFieldKind.Fixed64)
-    if data.isEnough(sizeof(float64)):
+    if data.isEnough(uint64(sizeof(float64))):
       outval = cast[float64](fromBytesLE(uint64, data.toOpenArray()))
       data.offset += sizeof(float64)
       ok()
     else:
       err(ProtoError.MessageIncomplete)
 
-proc getValue[T:byte|char](data: var ProtoBuffer, header: ProtoHeader,
-                           outBytes: var openArray[T],
-                           outLength: var int): ProtoResult[void] =
+proc getValue[T: byte | char](
+    data: var ProtoBuffer,
+    header: ProtoHeader,
+    outBytes: var openArray[T],
+    outLength: var int,
+): ProtoResult[void] =
   doAssert(header.wire == ProtoFieldKind.Length)
   var length = 0
   var bsize = 0'u64
@@ -401,27 +398,25 @@ 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(data.maxSize):
-      if data.isEnough(int(bsize)):
-        outLength = int(bsize)
-        if len(outBytes) >= int(bsize):
-          if bsize > 0'u64:
-            copyMem(addr outBytes[0], addr data.buffer[data.offset], int(bsize))
-          data.offset += int(bsize)
-          ok()
-        else:
-          # Buffer overflow should not be critical failure
-          data.offset += int(bsize)
-          err(ProtoError.BufferOverflow)
+    if data.isEnough(bsize):
+      outLength = int(bsize)
+      if len(outBytes) >= int(bsize):
+        if bsize > 0'u64:
+          copyMem(addr outBytes[0], addr data.buffer[data.offset], int(bsize))
+        data.offset += int(bsize)
+        ok()
       else:
-        err(ProtoError.MessageIncomplete)
+        # Buffer overflow should not be critical failure
+        data.offset += int(bsize)
+        err(ProtoError.BufferOverflow)
     else:
-      err(ProtoError.MessageTooBig)
+      err(ProtoError.MessageIncomplete)
   else:
     err(ProtoError.VarintDecode)
 
-proc getValue[T:seq[byte]|string](data: var ProtoBuffer, header: ProtoHeader,
-                                  outBytes: var T): ProtoResult[void] =
+proc getValue[T: seq[byte] | string](
+    data: var ProtoBuffer, header: ProtoHeader, outBytes: var T
+): ProtoResult[void] =
   doAssert(header.wire == ProtoFieldKind.Length)
   var length = 0
   var bsize = 0'u64
@@ -429,34 +424,31 @@ 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(data.maxSize):
-      if data.isEnough(int(bsize)):
-        outBytes.setLen(bsize)
-        if bsize > 0'u64:
-          copyMem(addr outBytes[0], addr data.buffer[data.offset], int(bsize))
-        data.offset += int(bsize)
-        ok()
-      else:
-        err(ProtoError.MessageIncomplete)
+    if data.isEnough(bsize):
+      outBytes.setLen(bsize)
+      if bsize > 0'u64:
+        copyMem(addr outBytes[0], addr data.buffer[data.offset], int(bsize))
+      data.offset += int(bsize)
+      ok()
     else:
-      err(ProtoError.MessageTooBig)
+      err(ProtoError.MessageIncomplete)
   else:
     err(ProtoError.VarintDecode)
 
-proc getField*[T: ProtoScalar](data: ProtoBuffer, field: int,
-                               output: var T): ProtoResult[bool] =
+proc getField*[T: ProtoScalar](
+    data: ProtoBuffer, field: int, output: var T
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var current: T
   var res = false
   var pb = data
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
-    ? pb.getHeader(header)
+    ?pb.getHeader(header)
     let wireCheck =
-      when (T is uint64) or (T is uint32) or (T is uint) or
-           (T is zint64) or (T is zint32) or (T is zint) or
-           (T is hint64) or (T is hint32) or (T is hint):
+      when (T is uint64) or (T is uint32) or (T is uint) or (T is zint64) or
+          (T is zint32) or (T is zint) or (T is hint64) or (T is hint32) or (T is hint):
         header.wire == ProtoFieldKind.Varint
       elif T is float32:
         header.wire == ProtoFieldKind.Fixed32
@@ -474,9 +466,9 @@ proc getField*[T: ProtoScalar](data: ProtoBuffer, field: int,
       else:
         # We are ignoring wire types different from what we expect, because it
         # is how `protoc` is working.
-        ? pb.skipValue(header)
+        ?pb.skipValue(header)
     else:
-      ? pb.skipValue(header)
+      ?pb.skipValue(header)
 
   if res:
     output = current
@@ -484,16 +476,16 @@ proc getField*[T: ProtoScalar](data: ProtoBuffer, field: int,
   else:
     ok(false)
 
-proc getField*[T: byte|char](data: ProtoBuffer, field: int,
-                             output: var openArray[T],
-                             outlen: var int): ProtoResult[bool] =
+proc getField*[T: byte | char](
+    data: ProtoBuffer, field: int, output: var openArray[T], outlen: var int
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var pb = data
   var res = false
 
   outlen = 0
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
     let hres = pb.getHeader(header)
     if hres.isErr():
@@ -536,13 +528,14 @@ proc getField*[T: byte|char](data: ProtoBuffer, field: int,
   else:
     ok(false)
 
-proc getField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
-                                    output: var T): ProtoResult[bool] =
+proc getField*[T: seq[byte] | string](
+    data: ProtoBuffer, field: int, output: var T
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var res = false
   var pb = data
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
     let hres = pb.getHeader(header)
     if hres.isErr():
@@ -573,29 +566,32 @@ proc getField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
   else:
     ok(false)
 
-proc getField*(pb: ProtoBuffer, field: int,
-               output: var ProtoBuffer): ProtoResult[bool] {.inline.} =
+proc getField*(
+    pb: ProtoBuffer, field: int, output: var ProtoBuffer
+): ProtoResult[bool] {.inline.} =
   var buffer: seq[byte]
-  if ? pb.getField(field, buffer):
+  if ?pb.getField(field, buffer):
     output = initProtoBuffer(buffer)
     ok(true)
   else:
     ok(false)
 
-proc getRequiredField*[T](pb: ProtoBuffer, field: int,
-               output: var T): ProtoResult[void] {.inline.} =
-  if ? pb.getField(field, output):
+proc getRequiredField*[T](
+    pb: ProtoBuffer, field: int, output: var T
+): ProtoResult[void] {.inline.} =
+  if ?pb.getField(field, output):
     ok()
   else:
     err(RequiredFieldMissing)
 
-proc getRepeatedField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
-                                        output: var seq[T]): ProtoResult[bool] =
+proc getRepeatedField*[T: seq[byte] | string](
+    data: ProtoBuffer, field: int, output: var seq[T]
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var pb = data
   output.setLen(0)
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
     let hres = pb.getHeader(header)
     if hres.isErr():
@@ -626,13 +622,14 @@ proc getRepeatedField*[T: seq[byte]|string](data: ProtoBuffer, field: int,
   else:
     ok(false)
 
-proc getRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
-                                       output: var seq[T]): ProtoResult[bool] =
+proc getRepeatedField*[T: ProtoScalar](
+    data: ProtoBuffer, field: int, output: var seq[T]
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var pb = data
   output.setLen(0)
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
     let hres = pb.getHeader(header)
     if hres.isErr():
@@ -640,8 +637,8 @@ proc getRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
       return err(hres.error)
 
     if header.index == uint64(field):
-      if header.wire in {ProtoFieldKind.Varint, ProtoFieldKind.Fixed32,
-                         ProtoFieldKind.Fixed64}:
+      if header.wire in
+          {ProtoFieldKind.Varint, ProtoFieldKind.Fixed32, ProtoFieldKind.Fixed64}:
         var item: T
         let vres = getValue(pb, header, item)
         if vres.isOk():
@@ -665,20 +662,22 @@ proc getRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
   else:
     ok(false)
 
-proc getRequiredRepeatedField*[T](pb: ProtoBuffer, field: int,
-               output: var seq[T]): ProtoResult[void] {.inline.} =
-  if ? pb.getRepeatedField(field, output):
+proc getRequiredRepeatedField*[T](
+    pb: ProtoBuffer, field: int, output: var seq[T]
+): ProtoResult[void] {.inline.} =
+  if ?pb.getRepeatedField(field, output):
     ok()
   else:
     err(RequiredFieldMissing)
 
-proc getPackedRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
-                                        output: var seq[T]): ProtoResult[bool] =
+proc getPackedRepeatedField*[T: ProtoScalar](
+    data: ProtoBuffer, field: int, output: var seq[T]
+): ProtoResult[bool] =
   checkFieldNumber(field)
   var pb = data
   output.setLen(0)
 
-  while not(pb.isEmpty()):
+  while not (pb.isEmpty()):
     var header: ProtoHeader
     let hres = pb.getHeader(header)
     if hres.isErr():
@@ -692,15 +691,15 @@ proc getPackedRepeatedField*[T: ProtoScalar](data: ProtoBuffer, field: int,
         if ares.isOk():
           var pbarr = initProtoBuffer(arritem)
           let itemHeader =
-            when (T is uint64) or (T is uint32) or (T is uint) or
-                 (T is zint64) or (T is zint32) or (T is zint) or
-                 (T is hint64) or (T is hint32) or (T is hint):
+            when (T is uint64) or (T is uint32) or (T is uint) or (T is zint64) or
+                (T is zint32) or (T is zint) or (T is hint64) or (T is hint32) or
+                (T is hint):
               ProtoHeader(wire: ProtoFieldKind.Varint)
             elif T is float32:
               ProtoHeader(wire: ProtoFieldKind.Fixed32)
             elif T is float64:
               ProtoHeader(wire: ProtoFieldKind.Fixed64)
-          while not(pbarr.isEmpty()):
+          while not (pbarr.isEmpty()):
             var item: T
             let vres = getValue(pbarr, itemHeader, item)
             if vres.isOk():

libp2p/protocols/connectivity/autonat/client.nim

@@ -11,28 +11,29 @@
 
 import stew/results
 import chronos, chronicles
-import ../../../switch,
-       ../../../multiaddress,
-       ../../../peerid
+import ../../../switch, ../../../multiaddress, ../../../peerid
 import core
 
 logScope:
   topics = "libp2p autonat"
 
-type
-  AutonatClient* = ref object of RootObj
+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()
+  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].} =
+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):
@@ -47,24 +48,32 @@ method dialMe*(self: AutonatClient, switch: Switch, pid: PeerId, addrs: seq[Mult
       else:
         await switch.dial(pid, addrs, AutonatCodec)
     except CatchableError as err:
-      raise newException(AutonatError, "Unexpected error when dialling: " & err.msg, 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:
+  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
+    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:
+  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(""))
+      raise newException(
+        AutonatUnreachableError, "Peer could not dial us back: " & response.text.get("")
+      )
     else:
-      raise newException(AutonatError, "Bad status " & $response.status & " " & response.text.get(""))
+      raise newException(
+        AutonatError, "Bad status " & $response.status & " " & response.text.get("")
+      )

libp2p/protocols/connectivity/autonat/core.nim

@@ -11,9 +11,8 @@
 
 import stew/[results, objects]
 import chronos, chronicles
-import ../../../multiaddress,
-       ../../../peerid,
-       ../../../errors
+import ../../../multiaddress, ../../../peerid, ../../../errors
+import ../../../protobuf/minprotobuf
 
 logScope:
   topics = "libp2p autonat"
@@ -55,7 +54,9 @@ type
     response*: Opt[AutonatDialResponse]
 
   NetworkReachability* {.pure.} = enum
-    Unknown, NotReachable, Reachable
+    Unknown
+    NotReachable
+    Reachable
 
 proc encode(p: AutonatPeerInfo): ProtoBuffer =
   result = initProtoBuffer()
@@ -103,37 +104,39 @@ proc decode*(_: typedesc[AutonatMsg], buf: seq[byte]): Opt[AutonatMsg] =
 
   let pb = initProtoBuffer(buf)
 
-  if ? pb.getField(1, msgTypeOrd).toOpt() and not checkedEnumAssign(msg.msgType, msgTypeOrd):
+  if ?pb.getField(1, msgTypeOrd).toOpt() and
+      not checkedEnumAssign(msg.msgType, msgTypeOrd):
     return Opt.none(AutonatMsg)
-  if ? pb.getField(2, pbDial).toOpt():
+  if ?pb.getField(2, pbDial).toOpt():
     var
       pbPeerInfo: ProtoBuffer
       dial: AutonatDial
-    let r4 = ? pbDial.getField(1, pbPeerInfo).toOpt()
+    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)
+        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():
+  if ?pb.getField(3, pbResponse).toOpt():
     var
       statusOrd: uint
       text: string
       ma: MultiAddress
       response: AutonatDialResponse
 
-    if ? pbResponse.getField(1, statusOrd).optValue():
+    if ?pbResponse.getField(1, statusOrd).optValue():
       if not checkedEnumAssign(response.status, statusOrd):
         return Opt.none(AutonatMsg)
-    if ? pbResponse.getField(2, text).optValue():
+    if ?pbResponse.getField(2, text).optValue():
       response.text = Opt.some(text)
-    if ? pbResponse.getField(3, ma).optValue():
+    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

@@ -12,13 +12,14 @@
 import std/[sets, sequtils]
 import stew/results
 import chronos, chronicles
-import ../../protocol,
-       ../../../switch,
-       ../../../multiaddress,
-       ../../../multicodec,
-       ../../../peerid,
-       ../../../utils/[semaphore, future],
-       ../../../errors
+import
+  ../../protocol,
+  ../../../switch,
+  ../../../multiaddress,
+  ../../../multicodec,
+  ../../../peerid,
+  ../../../utils/[semaphore, future],
+  ../../../errors
 import core
 
 export core
@@ -26,33 +27,36 @@ export core
 logScope:
   topics = "libp2p autonat"
 
-type
-  Autonat* = ref object of LPProtocol
-    sem: AsyncSemaphore
-    switch*: Switch
-    dialTimeout: Duration
+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()
+  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.} =
+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()
+    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()
+    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.} =
@@ -60,12 +64,15 @@ proc tryDial(autonat: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.asy
   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:
+    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()
+    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)
@@ -77,13 +84,13 @@ proc tryDial(autonat: Autonat, conn: Connection, addrs: seq[MultiAddress]) {.asy
   except CancelledError as exc:
     raise exc
   except AllFuturesFailedError as exc:
-    debug "All dial attempts failed", addrs, exc = exc.msg
+    debug "All dial attempts failed", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "All dial attempts failed")
   except AsyncTimeoutError as exc:
-    debug "Dial timeout", addrs, exc = exc.msg
+    debug "Dial timeout", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "Dial timeout")
   except CatchableError as exc:
-    debug "Unexpected error", addrs, exc = exc.msg
+    debug "Unexpected error", addrs, description = exc.msg
     await conn.sendResponseError(DialError, "Unexpected error")
   finally:
     autonat.sem.release()
@@ -106,7 +113,8 @@ proc handleDial(autonat: Autonat, conn: Connection, msg: AutonatMsg): Future[voi
   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")
+    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):
@@ -115,16 +123,20 @@ proc handleDial(autonat: Autonat, conn: Connection, msg: AutonatMsg): Future[voi
   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
+    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
+          let maEnd = ma[1 ..^ 1].valueOr:
+            continue
           hostIp & maEnd
       )
     except LPError as exc:
@@ -138,8 +150,11 @@ proc handleDial(autonat: Autonat, conn: Connection, msg: AutonatMsg): Future[voi
   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 new*(
+    T: typedesc[Autonat], switch: Switch, semSize: int = 1, dialTimeout = 15.seconds
+): T =
+  let autonat =
+    T(switch: switch, sem: newAsyncSemaphore(semSize), dialTimeout: dialTimeout)
   proc handleStream(conn: Connection, proto: string) {.async.} =
     try:
       let msg = AutonatMsg.decode(await conn.readLp(1024)).valueOr:
@@ -150,7 +165,7 @@ proc new*(T: typedesc[Autonat], switch: Switch, semSize: int = 1, dialTimeout =
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      debug "exception in autonat handler", exc = exc.msg, conn
+      debug "exception in autonat handler", description = exc.msg, conn
     finally:
       trace "exiting autonat handler", conn
       await conn.close()

libp2p/protocols/connectivity/autonat/service.nim

@@ -23,7 +23,11 @@ export core.NetworkReachability
 logScope:
   topics = "libp2p autonatservice"
 
-declarePublicGauge(libp2p_autonat_reachability_confidence, "autonat reachability confidence", labels = ["reachability"])
+declarePublicGauge(
+  libp2p_autonat_reachability_confidence,
+  "autonat reachability confidence",
+  labels = ["reachability"],
+)
 
 type
   AutonatService* = ref object of Service
@@ -44,19 +48,22 @@ type
     dialTimeout: Duration
     enableAddressMapper: bool
 
-  StatusAndConfidenceHandler* = proc (networkReachability: NetworkReachability, confidence: Opt[float]): Future[void]  {.gcsafe, raises: [].}
+  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 =
+    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,
@@ -69,7 +76,8 @@ proc new*(
     maxQueueSize: maxQueueSize,
     minConfidence: minConfidence,
     dialTimeout: dialTimeout,
-    enableAddressMapper: enableAddressMapper)
+    enableAddressMapper: enableAddressMapper,
+  )
 
 proc callHandler(self: AutonatService) {.async.} =
   if not isNil(self.statusAndConfidenceHandler):
@@ -82,8 +90,9 @@ proc hasEnoughIncomingSlots(switch: Switch): bool =
 proc doesPeerHaveIncomingConn(switch: Switch, peerId: PeerId): bool =
   return switch.connManager.selectMuxer(peerId, In) != nil
 
-proc handleAnswer(self: AutonatService, ans: NetworkReachability): Future[bool] {.async.} =
-
+proc handleAnswer(
+    self: AutonatService, ans: NetworkReachability
+): Future[bool] {.async.} =
   if ans == Unknown:
     return
 
@@ -99,17 +108,26 @@ proc handleAnswer(self: AutonatService, ans: NetworkReachability): Future[bool]
   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])
+    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
+  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
+  return
+    self.networkReachability != oldNetworkReachability or
+    self.confidence != oldConfidence
 
-proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[NetworkReachability] {.async.} =
+proc askPeer(
+    self: AutonatService, switch: Switch, peerId: PeerId
+): Future[NetworkReachability] {.async.} =
   logScope:
     peerId = $peerId
 
@@ -117,7 +135,8 @@ proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[Netwo
     return Unknown
 
   if not hasEnoughIncomingSlots(switch):
-    debug "No incoming slots available, not asking peer", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
+    debug "No incoming slots available, not asking peer",
+      incomingSlotsAvailable = switch.connManager.slotsAvailable(In)
     return Unknown
 
   trace "Asking peer for reachability"
@@ -127,13 +146,13 @@ proc askPeer(self: AutonatService, switch: Switch, peerId: PeerId): Future[Netwo
       debug "dialMe answer is reachable"
       Reachable
     except AutonatUnreachableError as error:
-      debug "dialMe answer is not reachable", msg = error.msg
+      debug "dialMe answer is not reachable", description = error.msg
       NotReachable
     except AsyncTimeoutError as error:
-      debug "dialMe timed out", msg = error.msg
+      debug "dialMe timed out", description = error.msg
       Unknown
     except CatchableError as error:
-      debug "dialMe unexpected error", msg = error.msg
+      debug "dialMe unexpected error", description = error.msg
       Unknown
   let hasReachabilityOrConfidenceChanged = await self.handleAnswer(ans)
   if hasReachabilityOrConfidenceChanged:
@@ -150,7 +169,8 @@ proc askConnectedPeers(self: AutonatService, switch: Switch) {.async.} =
     if answersFromPeers >= self.numPeersToAsk:
       break
     if not hasEnoughIncomingSlots(switch):
-      debug "No incoming slots available, not asking peers", incomingSlotsAvailable=switch.connManager.slotsAvailable(In)
+      debug "No incoming slots available, not asking peers",
+        incomingSlotsAvailable = switch.connManager.slotsAvailable(In)
       break
     if (await askPeer(self, switch, peer)) != Unknown:
       answersFromPeers.inc()
@@ -160,10 +180,8 @@ proc schedule(service: AutonatService, switch: Switch, interval: Duration) {.asy
     await service.run(switch)
 
 proc addressMapper(
-  self: AutonatService,
-  peerStore: PeerStore,
-  listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.async.} =
-
+    self: AutonatService, peerStore: PeerStore, listenAddrs: seq[MultiAddress]
+): Future[seq[MultiAddress]] {.async.} =
   if self.networkReachability != NetworkReachability.Reachable:
     return listenAddrs
 
@@ -171,24 +189,32 @@ proc addressMapper(
   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
+      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
+      debug "Error while handling address mapper", description = exc.msg
     addrs.add(processedMA)
   return addrs
 
 method setup*(self: AutonatService, switch: Switch): Future[bool] {.async.} =
-  self.addressMapper = proc (listenAddrs: seq[MultiAddress]): Future[seq[MultiAddress]] {.async.} =
+  self.addressMapper = proc(
+      listenAddrs: seq[MultiAddress]
+  ): Future[seq[MultiAddress]] {.async.} =
     return await addressMapper(self, switch.peerStore, listenAddrs)
 
   info "Setting up AutonatService"
   let hasBeenSetup = await procCall Service(self).setup(switch)
   if hasBeenSetup:
     if self.askNewConnectedPeers:
-      self.newConnectedPeerHandler = proc (peerId: PeerId, event: PeerEvent): Future[void] {.async.} =
+      self.newConnectedPeerHandler = proc(
+          peerId: PeerId, event: PeerEvent
+      ): Future[void] {.async.} =
         discard askPeer(self, switch, peerId)
-      switch.connManager.addPeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
+      switch.connManager.addPeerEventHandler(
+        self.newConnectedPeerHandler, PeerEventKind.Joined
+      )
     self.scheduleInterval.withValue(interval):
       self.scheduleHandle = schedule(self, switch, interval)
     if self.enableAddressMapper:
@@ -207,11 +233,15 @@ method stop*(self: AutonatService, switch: Switch): Future[bool] {.async, public
       self.scheduleHandle.cancel()
       self.scheduleHandle = nil
     if not isNil(self.newConnectedPeerHandler):
-      switch.connManager.removePeerEventHandler(self.newConnectedPeerHandler, PeerEventKind.Joined)
+      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) =
+proc statusAndConfidenceHandler*(
+    self: AutonatService, statusAndConfidenceHandler: StatusAndConfidenceHandler
+) =
   self.statusAndConfidenceHandler = statusAndConfidenceHandler

libp2p/protocols/connectivity/dcutr/client.nim

@@ -15,25 +15,26 @@ import stew/results
 import chronos, chronicles
 
 import core
-import ../../protocol,
-       ../../../stream/connection,
-       ../../../switch,
-       ../../../utils/future
+import
+  ../../protocol, ../../../stream/connection, ../../../switch, ../../../utils/future
 
 export DcutrError
 
-type
-  DcutrClient* = ref object
-    connectTimeout: Duration
-    maxDialableAddrs: int
+type DcutrClient* = ref object
+  connectTimeout: Duration
+  maxDialableAddrs: int
 
 logScope:
   topics = "libp2p dcutrclient"
 
-proc new*(T: typedesc[DcutrClient], connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
+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.} =
+proc startSync*(
+    self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs: seq[MultiAddress]
+) {.async.} =
   logScope:
     peerId = switch.peerInfo.peerId
 
@@ -43,7 +44,8 @@ proc startSync*(self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs:
   try:
     var ourDialableAddrs = getHolePunchableAddrs(addrs)
     if ourDialableAddrs.len == 0:
-      debug "Dcutr initiator has no supported dialable addresses. Aborting Dcutr.", addrs
+      debug "Dcutr initiator has no supported dialable addresses. Aborting Dcutr.",
+        addrs
       return
 
     stream = await switch.dial(remotePeerId, DcutrCodec)
@@ -54,7 +56,8 @@ proc startSync*(self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs:
 
     peerDialableAddrs = getHolePunchableAddrs(connectAnswer.addrs)
     if peerDialableAddrs.len == 0:
-      debug "Dcutr receiver has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectAnswer.addrs
+      debug "Dcutr receiver has no supported dialable addresses to connect to. Aborting Dcutr.",
+        addrs = connectAnswer.addrs
       return
 
     let rttEnd = Moment.now()
@@ -65,25 +68,47 @@ proc startSync*(self: DcutrClient, switch: Switch, remotePeerId: PeerId, addrs:
     await sleepAsync(halfRtt)
 
     if peerDialableAddrs.len > self.maxDialableAddrs:
-        peerDialableAddrs = peerDialableAddrs[0..<self.maxDialableAddrs]
-    var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false, dir = Direction.In))
+      peerDialableAddrs = peerDialableAddrs[0 ..< self.maxDialableAddrs]
+    var futs = peerDialableAddrs.mapIt(
+      switch.connect(
+        stream.peerId,
+        @[it],
+        forceDial = true,
+        reuseConnection = false,
+        dir = Direction.In,
+      )
+    )
     try:
       discard await anyCompleted(futs).wait(self.connectTimeout)
       debug "Dcutr initiator has directly connected to the remote peer."
     finally:
-      for fut in futs: fut.cancel()
+      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)
+    debug "Dcutr initiator could not connect to the remote peer, all connect attempts failed",
+      peerDialableAddrs, description = 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)
+    debug "Dcutr initiator could not connect to the remote peer, all connect attempts timed out",
+      peerDialableAddrs, description = 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)
+    debug "Unexpected error when Dcutr initiator tried to connect to the remote peer",
+      description = 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

@@ -14,14 +14,12 @@ import std/sequtils
 import chronos
 import stew/objects
 
-import ../../../multiaddress,
-       ../../../errors,
-       ../../../stream/connection
+import ../../../multiaddress, ../../../errors, ../../../stream/connection
+import ../../../protobuf/minprotobuf
 
 export multiaddress
 
-const
-  DcutrCodec* = "/libp2p/dcutr"
+const DcutrCodec* = "/libp2p/dcutr"
 
 type
   MsgType* = enum
@@ -56,10 +54,12 @@ proc send*(conn: Connection, msgType: MsgType, addrs: seq[MultiAddress]) {.async
   let pb = DcutrMsg(msgType: msgType, addrs: addrs).encode()
   await conn.writeLp(pb.buffer)
 
-proc getHolePunchableAddrs*(addrs: seq[MultiAddress]): seq[MultiAddress] {.raises: [LPError]} =
+proc getHolePunchableAddrs*(
+    addrs: seq[MultiAddress]
+): seq[MultiAddress] {.raises: [LPError].} =
   var result = newSeq[MultiAddress]()
   for a in addrs:
-      # This is necessary to also accept addrs like /ip4/198.51.100/tcp/1234/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N
-      if [TCP, mapAnd(TCP_DNS, P2PPattern), mapAnd(TCP_IP, P2PPattern)].anyIt(it.match(a)):
-        result.add(a[0..1].tryGet())
+    # This is necessary to also accept addrs like /ip4/198.51.100/tcp/1234/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N
+    if [TCP, mapAnd(TCP_DNS, P2PPattern), mapAnd(TCP_IP, P2PPattern)].anyIt(it.match(a)):
+      result.add(a[0 .. 1].tryGet())
   return result

libp2p/protocols/connectivity/dcutr/server.nim

@@ -14,10 +14,8 @@ import stew/[results, objects]
 import chronos, chronicles
 
 import core
-import ../../protocol,
-       ../../../stream/connection,
-       ../../../switch,
-       ../../../utils/future
+import
+  ../../protocol, ../../../stream/connection, ../../../switch, ../../../utils/future
 
 export chronicles
 
@@ -26,21 +24,28 @@ type Dcutr* = ref object of LPProtocol
 logScope:
   topics = "libp2p dcutr"
 
-proc new*(T: typedesc[Dcutr], switch: Switch, connectTimeout = 15.seconds, maxDialableAddrs = 8): T =
-
+proc new*(
+    T: typedesc[Dcutr],
+    switch: Switch,
+    connectTimeout = 15.seconds,
+    maxDialableAddrs = 8,
+): T =
   proc handleStream(stream: Connection, proto: string) {.async.} =
     var peerDialableAddrs: seq[MultiAddress]
     try:
       let connectMsg = DcutrMsg.decode(await stream.readLp(1024))
       debug "Dcutr receiver received a Connect message.", connectMsg
 
-      var ourAddrs = switch.peerStore.getMostObservedProtosAndPorts() # likely empty when the peer is reachable
+      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))
+        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
+        debug "Dcutr receiver has no supported dialable addresses. Aborting Dcutr.",
+          ourAddrs
         return
 
       await stream.send(MsgType.Connect, ourAddrs)
@@ -50,28 +55,38 @@ proc new*(T: typedesc[Dcutr], switch: Switch, connectTimeout = 15.seconds, maxDi
 
       peerDialableAddrs = getHolePunchableAddrs(connectMsg.addrs)
       if peerDialableAddrs.len == 0:
-        debug "Dcutr initiator has no supported dialable addresses to connect to. Aborting Dcutr.", addrs=connectMsg.addrs
+        debug "Dcutr initiator has no supported dialable addresses to connect to. Aborting Dcutr.",
+          addrs = connectMsg.addrs
         return
 
       if peerDialableAddrs.len > maxDialableAddrs:
-        peerDialableAddrs = peerDialableAddrs[0..<maxDialableAddrs]
-      var futs = peerDialableAddrs.mapIt(switch.connect(stream.peerId, @[it], forceDial = true, reuseConnection = false, dir = Direction.Out))
+        peerDialableAddrs = peerDialableAddrs[0 ..< maxDialableAddrs]
+      var futs = peerDialableAddrs.mapIt(
+        switch.connect(
+          stream.peerId,
+          @[it],
+          forceDial = true,
+          reuseConnection = false,
+          dir = Direction.Out,
+        )
+      )
       try:
         discard await anyCompleted(futs).wait(connectTimeout)
         debug "Dcutr receiver has directly connected to the remote peer."
       finally:
-        for fut in futs: fut.cancel()
+        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
+        "all connect attempts failed", peerDialableAddrs, description = err.msg
     except AsyncTimeoutError as err:
       debug "Dcutr receiver could not connect to the remote peer, " &
-        "all connect attempts timed out", peerDialableAddrs, msg = err.msg
+        "all connect attempts timed out", peerDialableAddrs, description = err.msg
     except CatchableError as err:
       warn "Unexpected error when Dcutr receiver tried to connect " &
-        "to the remote peer", msg = err.msg
+        "to the remote peer", description = err.msg
 
   let self = T()
   self.handler = handleStream

libp2p/protocols/connectivity/relay/client.nim

@@ -11,14 +11,15 @@
 
 import times
 import chronos, chronicles
-import ./relay,
-       ./messages,
-       ./rconn,
-       ./utils,
-       ../../../peerinfo,
-       ../../../switch,
-       ../../../multiaddress,
-       ../../../stream/connection
+import
+  ./relay,
+  ./messages,
+  ./rconn,
+  ./utils,
+  ../../../peerinfo,
+  ../../../switch,
+  ../../../multiaddress,
+  ../../../stream/connection
 
 logScope:
   topics = "libp2p relay relay-client"
@@ -30,26 +31,28 @@ type
   ReservationError* = object of RelayClientError
   RelayV1DialError* = object of RelayClientError
   RelayV2DialError* = object of RelayClientError
-  RelayClientAddConn* = proc(conn: Connection,
-                        duration: uint32,
-                        data: uint64): Future[void] {.gcsafe, raises: [].}
+  RelayClientAddConn* = proc(
+    conn: Connection, duration: uint32, data: uint64
+  ): Future[void] {.gcsafe, raises: [].}
   RelayClient* = ref object of Relay
     onNewConnection*: RelayClientAddConn
     canHop: bool
 
   Rsvp* = object
-    expire*: uint64           # required, Unix expiration time (UTC)
+    expire*: uint64 # required, Unix expiration time (UTC)
     addrs*: seq[MultiAddress] # relay address for reserving peer
-    voucher*: Opt[Voucher]    # optional, reservation voucher
-    limitDuration*: uint32    # seconds
-    limitData*: uint64        # bytes
+    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: Opt.some(code))
   await conn.writeLp(encode(msg).buffer)
 
-proc handleRelayedConnect(cl: RelayClient, conn: Connection, msg: StopMessage) {.async.} =
+proc handleRelayedConnect(
+    cl: RelayClient, conn: Connection, msg: StopMessage
+) {.async.} =
   let
     # TODO: check the go version to see in which way this could fail
     # it's unclear in the spec
@@ -58,9 +61,7 @@ proc handleRelayedConnect(cl: RelayClient, conn: Connection, msg: StopMessage) {
       return
     limitDuration = msg.limit.duration
     limitData = msg.limit.data
-    msg = StopMessage(
-      msgType: StopMessageType.Status,
-      status: Opt.some(Ok))
+    msg = StopMessage(msgType: StopMessageType.Status, status: Opt.some(Ok))
     pb = encode(msg)
 
   trace "incoming relay connection", src
@@ -72,24 +73,28 @@ proc handleRelayedConnect(cl: RelayClient, conn: Connection, msg: StopMessage) {
   await conn.writeLp(pb.buffer)
   # This sound redundant but the callback could, in theory, be set to nil during
   # conn.writeLp so it's safer to double check
-  if cl.onNewConnection != nil: await cl.onNewConnection(conn, limitDuration, limitData)
-  else: await conn.close()
+  if cl.onNewConnection != nil:
+    await cl.onNewConnection(conn, limitDuration, limitData)
+  else:
+    await conn.close()
 
-proc reserve*(cl: RelayClient,
-              peerId: PeerId,
-              addrs: seq[MultiAddress] = @[]): Future[Rsvp] {.async.} =
+proc reserve*(
+    cl: RelayClient, peerId: PeerId, addrs: seq[MultiAddress] = @[]
+): Future[Rsvp] {.async.} =
   let conn = await cl.switch.dial(peerId, addrs, RelayV2HopCodec)
-  defer: await conn.close()
+  defer:
+    await conn.close()
   let
     pb = encode(HopMessage(msgType: HopMessageType.Reserve))
-    msg = try:
-      await conn.writeLp(pb.buffer)
-      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
-    except CancelledError as exc:
-      raise exc
-    except CatchableError as exc:
-      trace "error writing or reading reservation message", exc=exc.msg
-      raise newException(ReservationError, exc.msg)
+    msg =
+      try:
+        await conn.writeLp(pb.buffer)
+        HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
+      except CancelledError as exc:
+        raise exc
+      except CatchableError as exc:
+        trace "error writing or reading reservation message", description = exc.msg
+        raise newException(ReservationError, exc.msg)
 
   if msg.msgType != HopMessageType.Status:
     raise newException(ReservationError, "Unexpected relay response type")
@@ -99,7 +104,7 @@ proc reserve*(cl: RelayClient,
   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:
+      now().utc > reservation.expire.int64.fromUnix.utc:
     raise newException(ReservationError, "Bad expiration date")
   result.expire = reservation.expire
   result.addrs = reservation.addrs
@@ -115,43 +120,49 @@ proc reserve*(cl: RelayClient,
   result.limitData = msg.limit.data
 
 proc dialPeerV1*(
-    cl: RelayClient,
-    conn: Connection,
-    dstPeerId: PeerId,
-    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
+    cl: RelayClient, conn: Connection, dstPeerId: PeerId, dstAddrs: seq[MultiAddress]
+): Future[Connection] {.async.} =
   var
     msg = RelayMessage(
       msgType: Opt.some(RelayType.Hop),
-      srcPeer: Opt.some(RelayPeer(peerId: cl.switch.peerInfo.peerId, addrs: cl.switch.peerInfo.addrs)),
-      dstPeer: Opt.some(RelayPeer(peerId: dstPeerId, addrs: dstAddrs)))
+      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
+  trace "Dial peer", msgSend = msg
 
   try:
     await conn.writeLp(pb.buffer)
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    trace "error writing hop request", exc=exc.msg
+    trace "error writing hop request", description = exc.msg
     raise exc
 
-  let msgRcvFromRelayOpt = try:
-    RelayMessage.decode(await conn.readLp(RelayClientMsgSize))
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error reading stop response", exc=exc.msg
-    await sendStatus(conn, StatusV1.HopCantOpenDstStream)
-    raise exc
+  let msgRcvFromRelayOpt =
+    try:
+      RelayMessage.decode(await conn.readLp(RelayClientMsgSize))
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error reading stop response", description = exc.msg
+      await sendStatus(conn, StatusV1.HopCantOpenDstStream)
+      raise exc
 
   try:
     let msgRcvFromRelay = msgRcvFromRelayOpt.valueOr:
       raise newException(RelayV1DialError, "Hop can't open destination stream")
     if msgRcvFromRelay.msgType.tryGet() != RelayType.Status:
-      raise newException(RelayV1DialError, "Hop can't open destination stream: wrong message type")
+      raise newException(
+        RelayV1DialError, "Hop can't open destination stream: wrong message type"
+      )
     if msgRcvFromRelay.status.tryGet() != StatusV1.Success:
-      raise newException(RelayV1DialError, "Hop can't open destination stream: status failed")
+      raise newException(
+        RelayV1DialError, "Hop can't open destination stream: status failed"
+      )
   except RelayV1DialError as exc:
     await sendStatus(conn, StatusV1.HopCantOpenDstStream)
     raise exc
@@ -164,26 +175,28 @@ proc dialPeerV2*(
     cl: RelayClient,
     conn: RelayConnection,
     dstPeerId: PeerId,
-    dstAddrs: seq[MultiAddress]): Future[Connection] {.async.} =
+    dstAddrs: seq[MultiAddress],
+): Future[Connection] {.async.} =
   let
     p = Peer(peerId: dstPeerId, addrs: dstAddrs)
     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)).tryGet()
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error reading stop response", exc=exc.msg
-    raise newException(RelayV2DialError, exc.msg)
+  let msgRcvFromRelay =
+    try:
+      await conn.writeLp(pb.buffer)
+      HopMessage.decode(await conn.readLp(RelayClientMsgSize)).tryGet()
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error reading stop response", description = exc.msg
+      raise newException(RelayV2DialError, exc.msg)
 
   if msgRcvFromRelay.msgType != HopMessageType.Status:
     raise newException(RelayV2DialError, "Unexpected stop response")
   if msgRcvFromRelay.status.get(UnexpectedMessage) != Ok:
-    trace "Relay stop failed", msg = msgRcvFromRelay.status
+    trace "Relay stop failed", description = msgRcvFromRelay.status
     raise newException(RelayV2DialError, "Relay stop failure")
   conn.limitDuration = msgRcvFromRelay.limit.duration
   conn.limitData = msgRcvFromRelay.limit.data
@@ -198,7 +211,7 @@ proc handleStopStreamV2(cl: RelayClient, conn: Connection) {.async.} =
   if msg.msgType == StopMessageType.Connect:
     await cl.handleRelayedConnect(conn, msg)
   else:
-    trace "Unexpected client / relayv2 handshake", msgType=msg.msgType
+    trace "Unexpected client / relayv2 handshake", msgType = msg.msgType
     await sendStopError(conn, MalformedMessage)
 
 proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async.} =
@@ -223,8 +236,10 @@ proc handleStop(cl: RelayClient, conn: Connection, msg: RelayMessage) {.async.}
   await sendStatus(conn, StatusV1.Success)
   # This sound redundant but the callback could, in theory, be set to nil during
   # sendStatus(Success) so it's safer to double check
-  if cl.onNewConnection != nil: await cl.onNewConnection(conn, 0, 0)
-  else: await conn.close()
+  if cl.onNewConnection != nil:
+    await cl.onNewConnection(conn, 0, 0)
+  else:
+    await conn.close()
 
 proc handleStreamV1(cl: RelayClient, conn: Connection) {.async.} =
   let msg = RelayMessage.decode(await conn.readLp(RelayClientMsgSize)).valueOr:
@@ -236,53 +251,66 @@ proc handleStreamV1(cl: RelayClient, conn: Connection) {.async.} =
     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)
-    of RelayType.Stop: await cl.handleStop(conn, msg)
-    of RelayType.CanHop:
-      if cl.canHop: await sendStatus(conn, StatusV1.Success)
-      else: await sendStatus(conn, StatusV1.HopCantSpeakRelay)
+  case typ
+  of RelayType.Hop:
+    if cl.canHop:
+      await cl.handleHop(conn, msg)
     else:
-      trace "Unexpected relay handshake", msgType=msg.msgType
-      await sendStatus(conn, StatusV1.MalformedMessage)
+      await sendStatus(conn, StatusV1.HopCantSpeakRelay)
+  of RelayType.Stop:
+    await cl.handleStop(conn, msg)
+  of RelayType.CanHop:
+    if cl.canHop:
+      await sendStatus(conn, StatusV1.Success)
+    else:
+      await sendStatus(conn, StatusV1.HopCantSpeakRelay)
+  else:
+    trace "Unexpected relay handshake", msgType = msg.msgType
+    await sendStatus(conn, StatusV1.MalformedMessage)
 
-proc new*(T: typedesc[RelayClient], canHop: bool = false,
-     reservationTTL: times.Duration = DefaultReservationTTL,
-     limitDuration: uint32 = DefaultLimitDuration,
-     limitData: uint64 = DefaultLimitData,
-     heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
-     maxCircuit: int = MaxCircuit,
-     maxCircuitPerPeer: int = MaxCircuitPerPeer,
-     msgSize: int = RelayClientMsgSize,
-     circuitRelayV1: bool = false): T =
-
-  let cl = T(canHop: canHop,
-             reservationTTL: reservationTTL,
-             limit: Limit(duration: limitDuration, data: limitData),
-             heartbeatSleepTime: heartbeatSleepTime,
-             maxCircuit: maxCircuit,
-             maxCircuitPerPeer: maxCircuitPerPeer,
-             msgSize: msgSize,
-             isCircuitRelayV1: circuitRelayV1)
+proc new*(
+    T: typedesc[RelayClient],
+    canHop: bool = false,
+    reservationTTL: times.Duration = DefaultReservationTTL,
+    limitDuration: uint32 = DefaultLimitDuration,
+    limitData: uint64 = DefaultLimitData,
+    heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
+    maxCircuit: int = MaxCircuit,
+    maxCircuitPerPeer: int = MaxCircuitPerPeer,
+    msgSize: int = RelayClientMsgSize,
+    circuitRelayV1: bool = false,
+): T =
+  let cl = T(
+    canHop: canHop,
+    reservationTTL: reservationTTL,
+    limit: Limit(duration: limitDuration, data: limitData),
+    heartbeatSleepTime: heartbeatSleepTime,
+    maxCircuit: maxCircuit,
+    maxCircuitPerPeer: maxCircuitPerPeer,
+    msgSize: msgSize,
+    isCircuitRelayV1: circuitRelayV1,
+  )
   proc handleStream(conn: Connection, proto: string) {.async.} =
     try:
-      case proto:
-      of RelayV1Codec: await cl.handleStreamV1(conn)
-      of RelayV2StopCodec: await cl.handleStopStreamV2(conn)
-      of RelayV2HopCodec: await cl.handleHopStreamV2(conn)
+      case proto
+      of RelayV1Codec:
+        await cl.handleStreamV1(conn)
+      of RelayV2StopCodec:
+        await cl.handleStopStreamV2(conn)
+      of RelayV2HopCodec:
+        await cl.handleHopStreamV2(conn)
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "exception in client handler", exc = exc.msg, conn
+      trace "exception in client handler", description = exc.msg, conn
     finally:
       trace "exiting client handler", conn
       await conn.close()
 
   cl.handler = handleStream
-  cl.codecs = if cl.canHop:
-                @[RelayV1Codec, RelayV2HopCodec, RelayV2StopCodec]
-              else:
-                @[RelayV1Codec, RelayV2StopCodec]
+  cl.codecs =
+    if cl.canHop:
+      @[RelayV1Codec, RelayV2HopCodec, RelayV2StopCodec]
+    else:
+      @[RelayV1Codec, RelayV2StopCodec]
   cl

libp2p/protocols/connectivity/relay/messages.nim

@@ -11,8 +11,8 @@
 
 import macros
 import stew/[objects, results]
-import ../../../peerinfo,
-       ../../../signed_envelope
+import ../../../peerinfo, ../../../signed_envelope
+import ../../../protobuf/minprotobuf
 
 # Circuit Relay V1 Message
 
@@ -87,22 +87,22 @@ proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Opt[RelayMessage] =
 
   let pb = initProtoBuffer(buf)
 
-  if ? pb.getField(1, msgTypeOrd).toOpt():
+  if ?pb.getField(1, msgTypeOrd).toOpt():
     if msgTypeOrd.int notin RelayType:
       return Opt.none(RelayMessage)
     rMsg.msgType = Opt.some(RelayType(msgTypeOrd))
 
-  if ? pb.getField(2, pbSrc).toOpt():
-    discard ? pbSrc.getField(1, src.peerId).toOpt()
-    discard ? pbSrc.getRepeatedField(2, src.addrs).toOpt()
+  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()
+  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():
+  if ?pb.getField(4, statusOrd).toOpt():
     var status: StatusV1
     if not checkedEnumAssign(status, statusOrd):
       return Opt.none(RelayMessage)
@@ -111,19 +111,18 @@ proc decode*(_: typedesc[RelayMessage], buf: seq[byte]): Opt[RelayMessage] =
 
 # Voucher
 
-type
-  Voucher* = object
-    relayPeerId*: PeerId     # peer ID of the relay
-    reservingPeerId*: PeerId # peer ID of the reserving peer
-    expiration*: uint64      # UNIX UTC expiration time for the reservation
+type Voucher* = object
+  relayPeerId*: PeerId # peer ID of the relay
+  reservingPeerId*: PeerId # peer ID of the reserving peer
+  expiration*: uint64 # UNIX UTC expiration time for the reservation
 
 proc decode*(_: typedesc[Voucher], buf: seq[byte]): Result[Voucher, ProtoError] =
   let pb = initProtoBuffer(buf)
   var v = Voucher()
 
-  ? pb.getRequiredField(1, v.relayPeerId)
-  ? pb.getRequiredField(2, v.reservingPeerId)
-  ? pb.getRequiredField(3, v.expiration)
+  ?pb.getRequiredField(1, v.relayPeerId)
+  ?pb.getRequiredField(2, v.reservingPeerId)
+  ?pb.getRequiredField(3, v.expiration)
 
   ok(v)
 
@@ -137,20 +136,23 @@ proc encode*(v: Voucher): seq[byte] =
   pb.finish()
   pb.buffer
 
-proc init*(T: typedesc[Voucher],
-          relayPeerId: PeerId,
-          reservingPeerId: PeerId,
-          expiration: uint64): T =
+proc init*(
+    T: typedesc[Voucher],
+    relayPeerId: PeerId,
+    reservingPeerId: PeerId,
+    expiration: uint64,
+): T =
   T(
-    relayPeerId = relayPeerId,
-    reservingPeerId = reservingPeerId,
-    expiration: expiration
+    relayPeerId = relayPeerId, reservingPeerId = reservingPeerId, expiration: expiration
   )
 
 type SignedVoucher* = SignedPayload[Voucher]
 
-proc payloadDomain*(_: typedesc[Voucher]): string = "libp2p-relay-rsvp"
-proc payloadType*(_: typedesc[Voucher]): seq[byte] = @[ (byte)0x03, (byte)0x02 ]
+proc payloadDomain*(_: typedesc[Voucher]): string =
+  "libp2p-relay-rsvp"
+
+proc payloadType*(_: typedesc[Voucher]): seq[byte] =
+  @[(byte) 0x03, (byte) 0x02]
 
 proc checkValid*(spr: SignedVoucher): Result[void, EnvelopeError] =
   if not spr.data.relayPeerId.match(spr.envelope.publicKey):
@@ -164,13 +166,15 @@ type
   Peer* = object
     peerId*: PeerId
     addrs*: seq[MultiAddress]
+
   Reservation* = object
-    expire*: uint64              # required, Unix expiration time (UTC)
-    addrs*: seq[MultiAddress]    # relay address for reserving peer
-    svoucher*: Opt[seq[byte]]    # optional, reservation voucher
+    expire*: uint64 # required, Unix expiration time (UTC)
+    addrs*: seq[MultiAddress] # relay address for reserving peer
+    svoucher*: Opt[seq[byte]] # optional, reservation voucher
+
   Limit* = object
-    duration*: uint32            # seconds
-    data*: uint64                # bytes
+    duration*: uint32 # seconds
+    data*: uint64 # bytes
 
   StatusV2* = enum
     Ok = 100
@@ -181,10 +185,12 @@ type
     NoReservation = 204
     MalformedMessage = 400
     UnexpectedMessage = 401
+
   HopMessageType* {.pure.} = enum
     Reserve = 0
     Connect = 1
     Status = 2
+
   HopMessage* = object
     msgType*: HopMessageType
     peer*: Opt[Peer]
@@ -214,8 +220,10 @@ proc encode*(msg: HopMessage): ProtoBuffer =
     pb.write(3, rpb.buffer)
   if msg.limit.duration > 0 or msg.limit.data > 0:
     var lpb = initProtoBuffer()
-    if msg.limit.duration > 0: lpb.write(1, msg.limit.duration)
-    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
+    if msg.limit.duration > 0:
+      lpb.write(1, msg.limit.duration)
+    if msg.limit.data > 0:
+      lpb.write(2, msg.limit.data)
     lpb.finish()
     pb.write(4, lpb.buffer)
   msg.status.withValue(status):
@@ -229,35 +237,35 @@ proc decode*(_: typedesc[HopMessage], buf: seq[byte]): Opt[HopMessage] =
   let pb = initProtoBuffer(buf)
 
   var msgTypeOrd: uint32
-  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
+  ?pb.getRequiredField(1, msgTypeOrd).toOpt()
   if not checkedEnumAssign(msg.msgType, msgTypeOrd):
     return Opt.none(HopMessage)
 
   var pbPeer: ProtoBuffer
-  if ? pb.getField(2, pbPeer).toOpt():
+  if ?pb.getField(2, pbPeer).toOpt():
     var peer: Peer
-    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
-    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
+    ?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():
+  if ?pb.getField(3, pbReservation).toOpt():
     var
       svoucher: seq[byte]
       reservation: Reservation
-    if ? pbReservation.getField(3, svoucher).toOpt():
+    if ?pbReservation.getField(3, svoucher).toOpt():
       reservation.svoucher = Opt.some(svoucher)
-    ? pbReservation.getRequiredField(1, reservation.expire).toOpt()
-    discard ? pbReservation.getRepeatedField(2, reservation.addrs).toOpt()
+    ?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()
+  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():
+  if ?pb.getField(5, statusOrd).toOpt():
     var status: StatusV2
     if not checkedEnumAssign(status, statusOrd):
       return Opt.none(HopMessage)
@@ -270,13 +278,13 @@ type
   StopMessageType* {.pure.} = enum
     Connect = 0
     Status = 1
+
   StopMessage* = object
     msgType*: StopMessageType
     peer*: Opt[Peer]
     limit*: Limit
     status*: Opt[StatusV2]
 
-
 proc encode*(msg: StopMessage): ProtoBuffer =
   var pb = initProtoBuffer()
 
@@ -290,8 +298,10 @@ proc encode*(msg: StopMessage): ProtoBuffer =
     pb.write(2, ppb.buffer)
   if msg.limit.duration > 0 or msg.limit.data > 0:
     var lpb = initProtoBuffer()
-    if msg.limit.duration > 0: lpb.write(1, msg.limit.duration)
-    if msg.limit.data > 0: lpb.write(2, msg.limit.data)
+    if msg.limit.duration > 0:
+      lpb.write(1, msg.limit.duration)
+    if msg.limit.data > 0:
+      lpb.write(2, msg.limit.data)
     lpb.finish()
     pb.write(3, lpb.buffer)
   msg.status.withValue(status):
@@ -306,26 +316,25 @@ proc decode*(_: typedesc[StopMessage], buf: seq[byte]): Opt[StopMessage] =
   let pb = initProtoBuffer(buf)
 
   var msgTypeOrd: uint32
-  ? pb.getRequiredField(1, msgTypeOrd).toOpt()
+  ?pb.getRequiredField(1, msgTypeOrd).toOpt()
   if msgTypeOrd.int notin StopMessageType:
     return Opt.none(StopMessage)
   msg.msgType = StopMessageType(msgTypeOrd)
 
-
   var pbPeer: ProtoBuffer
-  if ? pb.getField(2, pbPeer).toOpt():
+  if ?pb.getField(2, pbPeer).toOpt():
     var peer: Peer
-    ? pbPeer.getRequiredField(1, peer.peerId).toOpt()
-    discard ? pbPeer.getRepeatedField(2, peer.addrs).toOpt()
+    ?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()
+  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():
+  if ?pb.getField(4, statusOrd).toOpt():
     var status: StatusV2
     if not checkedEnumAssign(status, statusOrd):
       return Opt.none(StopMessage)

libp2p/protocols/connectivity/relay/rconn.nim

@@ -13,24 +13,20 @@ import chronos
 
 import ../../../stream/connection
 
-type
-  RelayConnection* = ref object of Connection
-    conn*: Connection
-    limitDuration*: uint32
-    limitData*: uint64
-    dataSent*: uint64
+type RelayConnection* = ref object of Connection
+  conn*: Connection
+  limitDuration*: uint32
+  limitData*: uint64
+  dataSent*: uint64
 
 method readOnce*(
-    self: RelayConnection,
-    pbytes: pointer,
-    nbytes: int
+    self: RelayConnection, pbytes: pointer, nbytes: int
 ): Future[int] {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   self.activity = true
   self.conn.readOnce(pbytes, nbytes)
 
 method write*(
-    self: RelayConnection,
-    msg: seq[byte]
+    self: RelayConnection, msg: seq[byte]
 ): Future[void] {.async: (raises: [CancelledError, LPStreamError]).} =
   self.dataSent.inc(msg.len)
   if self.limitData != 0 and self.dataSent > self.limitData:
@@ -43,13 +39,15 @@ method closeImpl*(self: RelayConnection): Future[void] {.async: (raises: []).} =
   await self.conn.close()
   await procCall Connection(self).closeImpl()
 
-method getWrapped*(self: RelayConnection): Connection = self.conn
+method getWrapped*(self: RelayConnection): Connection =
+  self.conn
 
 proc new*(
     T: typedesc[RelayConnection],
     conn: Connection,
     limitDuration: uint32,
-    limitData: uint64): T =
+    limitData: uint64,
+): T =
   let rc = T(conn: conn, limitDuration: limitDuration, limitData: limitData)
   rc.dir = conn.dir
   rc.initStream()
@@ -59,5 +57,6 @@ proc new*(
         await noCancel conn.join().wait(limitDuration.seconds())
       except AsyncTimeoutError:
         await conn.close()
+
     asyncSpawn checkDurationConnection()
   return rc

libp2p/protocols/connectivity/relay/relay.nim

@@ -13,18 +13,19 @@ import sequtils, tables
 
 import chronos, chronicles
 
-import ./messages,
-       ./rconn,
-       ./utils,
-       ../../../peerinfo,
-       ../../../switch,
-       ../../../multiaddress,
-       ../../../multicodec,
-       ../../../stream/connection,
-       ../../../protocols/protocol,
-       ../../../errors,
-       ../../../utils/heartbeat,
-       ../../../signed_envelope
+import
+  ./messages,
+  ./rconn,
+  ./utils,
+  ../../../peerinfo,
+  ../../../switch,
+  ../../../multiaddress,
+  ../../../multicodec,
+  ../../../stream/connection,
+  ../../../protocols/protocol,
+  ../../../errors,
+  ../../../utils/heartbeat,
+  ../../../signed_envelope
 
 # TODO:
 # * Eventually replace std/times by chronos/timer. Currently chronos/timer
@@ -54,47 +55,53 @@ type
 
 # Relay Side
 
-type
-  Relay* = ref object of LPProtocol
-    switch*: Switch
-    peerCount: CountTable[PeerId]
+type Relay* = ref object of LPProtocol
+  switch*: Switch
+  peerCount: CountTable[PeerId]
 
-    # number of reservation (relayv2) + number of connection (relayv1)
-    maxCircuit*: int
+  # number of reservation (relayv2) + number of connection (relayv1)
+  maxCircuit*: int
 
-    maxCircuitPerPeer*: int
-    msgSize*: int
-    # RelayV1
-    isCircuitRelayV1*: bool
-    streamCount: int
-    # RelayV2
-    rsvp: Table[PeerId, DateTime]
-    reservationLoop: Future[void]
-    reservationTTL*: times.Duration
-    heartbeatSleepTime*: uint32
-    limit*: Limit
+  maxCircuitPerPeer*: int
+  msgSize*: int
+  # RelayV1
+  isCircuitRelayV1*: bool
+  streamCount: int
+  # RelayV2
+  rsvp: Table[PeerId, DateTime]
+  reservationLoop: Future[void]
+  reservationTTL*: times.Duration
+  heartbeatSleepTime*: uint32
+  limit*: Limit
 
 # Relay V2
 
 proc createReserveResponse(
-    r: Relay,
-    pid: PeerId,
-    expire: DateTime): Result[HopMessage, CryptoError] =
+    r: Relay, pid: PeerId, expire: DateTime
+): Result[HopMessage, CryptoError] =
   let
     expireUnix = expire.toTime.toUnix.uint64
-    v = Voucher(relayPeerId: r.switch.peerInfo.peerId,
-                  reservingPeerId: pid,
-                  expiration: expireUnix)
-    sv = ? SignedVoucher.init(r.switch.peerInfo.privateKey, v)
-    ma = ? MultiAddress.init("/p2p/" & $r.switch.peerInfo.peerId).orErr(CryptoError.KeyError)
-    rsrv = Reservation(expire: expireUnix,
-                       addrs: r.switch.peerInfo.addrs.mapIt(
-                         ? it.concat(ma).orErr(CryptoError.KeyError)),
-                       svoucher: Opt.some(? sv.encode))
-    msg = HopMessage(msgType: HopMessageType.Status,
-                     reservation: Opt.some(rsrv),
-                     limit: r.limit,
-                     status: Opt.some(Ok))
+    v = Voucher(
+      relayPeerId: r.switch.peerInfo.peerId,
+      reservingPeerId: pid,
+      expiration: expireUnix,
+    )
+    sv = ?SignedVoucher.init(r.switch.peerInfo.privateKey, v)
+    ma =
+      ?MultiAddress.init("/p2p/" & $r.switch.peerInfo.peerId).orErr(
+        CryptoError.KeyError
+      )
+    rsrv = Reservation(
+      expire: expireUnix,
+      addrs: r.switch.peerInfo.addrs.mapIt(?it.concat(ma).orErr(CryptoError.KeyError)),
+      svoucher: Opt.some(?sv.encode),
+    )
+    msg = HopMessage(
+      msgType: HopMessageType.Status,
+      reservation: Opt.some(rsrv),
+      limit: r.limit,
+      status: Opt.some(Ok),
+    )
   return ok(msg)
 
 proc isRelayed*(conn: Connection): bool =
@@ -126,9 +133,7 @@ proc handleReserve(r: Relay, conn: Connection) {.async.} =
   r.rsvp[pid] = expire
   await conn.writeLp(encode(msg).buffer)
 
-proc handleConnect(r: Relay,
-                   connSrc: Connection,
-                   msg: HopMessage) {.async.} =
+proc handleConnect(r: Relay, connSrc: Connection, msg: HopMessage) {.async.} =
   if connSrc.isRelayed():
     trace "connection attempt over relay connection"
     await sendHopStatus(connSrc, PermissionDenied)
@@ -150,44 +155,48 @@ proc handleConnect(r: Relay,
     r.peerCount.inc(src, -1)
     r.peerCount.inc(dst, -1)
 
-  if r.peerCount[src] > r.maxCircuitPerPeer or
-     r.peerCount[dst] > r.maxCircuitPerPeer:
-    trace "too many connections", src = r.peerCount[src],
-                                  dst = r.peerCount[dst],
-                                  max = r.maxCircuitPerPeer
+  if r.peerCount[src] > r.maxCircuitPerPeer or r.peerCount[dst] > r.maxCircuitPerPeer:
+    trace "too many connections",
+      src = r.peerCount[src], dst = r.peerCount[dst], max = r.maxCircuitPerPeer
     await sendHopStatus(connSrc, ResourceLimitExceeded)
     return
 
-  let connDst = try:
-    await r.switch.dial(dst, RelayV2StopCodec)
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error opening relay stream", dst, exc=exc.msg
-    await sendHopStatus(connSrc, ConnectionFailed)
-    return
+  let connDst =
+    try:
+      await r.switch.dial(dst, RelayV2StopCodec)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error opening relay stream", dst, description = exc.msg
+      await sendHopStatus(connSrc, ConnectionFailed)
+      return
   defer:
     await connDst.close()
 
   proc sendStopMsg() {.async.} =
-    let stopMsg = StopMessage(msgType: StopMessageType.Connect,
-                            peer: Opt.some(Peer(peerId: src, addrs: @[])),
-                            limit: r.limit)
+    let stopMsg = StopMessage(
+      msgType: StopMessageType.Connect,
+      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)).valueOr:
       raise newException(SendStopError, "Malformed message")
     if msg.msgType != StopMessageType.Status:
-      raise newException(SendStopError, "Unexpected stop response, not a status message")
+      raise
+        newException(SendStopError, "Unexpected stop response, not a status message")
     if msg.status.get(UnexpectedMessage) != Ok:
       raise newException(SendStopError, "Relay stop failure")
-    await connSrc.writeLp(encode(HopMessage(msgType: HopMessageType.Status,
-                                          status: Opt.some(Ok))).buffer)
+    await connSrc.writeLp(
+      encode(HopMessage(msgType: HopMessageType.Status, status: Opt.some(Ok))).buffer
+    )
+
   try:
     await sendStopMsg()
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    trace "error sending stop message", msg = exc.msg
+    trace "error sending stop message", description = exc.msg
     await sendHopStatus(connSrc, ConnectionFailed)
     return
 
@@ -204,21 +213,25 @@ proc handleHopStreamV2*(r: Relay, conn: Connection) {.async.} =
   let msg = HopMessage.decode(await conn.readLp(r.msgSize)).valueOr:
     await sendHopStatus(conn, MalformedMessage)
     return
-  trace "relayv2 handle stream", msg = msg
-  case msg.msgType:
-  of HopMessageType.Reserve: await r.handleReserve(conn)
-  of HopMessageType.Connect: await r.handleConnect(conn, msg)
+  trace "relayv2 handle stream", hopMsg = msg
+  case msg.msgType
+  of HopMessageType.Reserve:
+    await r.handleReserve(conn)
+  of HopMessageType.Connect:
+    await r.handleConnect(conn, msg)
   else:
-    trace "Unexpected relayv2 handshake", msgType=msg.msgType
+    trace "Unexpected relayv2 handshake", msgType = msg.msgType
     await sendHopStatus(conn, MalformedMessage)
 
 # Relay V1
 
 proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
   r.streamCount.inc()
-  defer: r.streamCount.dec()
+  defer:
+    r.streamCount.dec()
   if r.streamCount + r.rsvp.len() >= r.maxCircuit:
-    trace "refusing connection; too many active circuit", streamCount = r.streamCount, rsvp = r.rsvp.len()
+    trace "refusing connection; too many active circuit",
+      streamCount = r.streamCount, rsvp = r.rsvp.len()
     await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
     return
 
@@ -236,13 +249,14 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
       trace "relay not connected to dst", dst
       return err(StatusV1.HopNoConnToDst)
     ok(msg)
+
   let check = checkMsg()
   if check.isErr:
     await sendStatus(connSrc, check.error())
     return
 
   if r.peerCount[src.peerId] >= r.maxCircuitPerPeer or
-     r.peerCount[dst.peerId] >= r.maxCircuitPerPeer:
+      r.peerCount[dst.peerId] >= r.maxCircuitPerPeer:
     trace "refusing connection; too many connection from src or to dst", src, dst
     await sendStatus(connSrc, StatusV1.HopCantSpeakRelay)
     return
@@ -252,39 +266,41 @@ proc handleHop*(r: Relay, connSrc: Connection, msg: RelayMessage) {.async.} =
     r.peerCount.inc(src.peerId, -1)
     r.peerCount.inc(dst.peerId, -1)
 
-  let connDst = try:
-    await r.switch.dial(dst.peerId, RelayV1Codec)
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error opening relay stream", dst, exc=exc.msg
-    await sendStatus(connSrc, StatusV1.HopCantDialDst)
-    return
+  let connDst =
+    try:
+      await r.switch.dial(dst.peerId, RelayV1Codec)
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error opening relay stream", dst, description = exc.msg
+      await sendStatus(connSrc, StatusV1.HopCantDialDst)
+      return
   defer:
     await connDst.close()
 
   let msgToSend = RelayMessage(
-    msgType: Opt.some(RelayType.Stop),
-    srcPeer: Opt.some(src),
-    dstPeer: Opt.some(dst))
+    msgType: Opt.some(RelayType.Stop), srcPeer: Opt.some(src), dstPeer: Opt.some(dst)
+  )
 
-  let msgRcvFromDstOpt = try:
-    await connDst.writeLp(encode(msgToSend).buffer)
-    RelayMessage.decode(await connDst.readLp(r.msgSize))
-  except CancelledError as exc:
-    raise exc
-  except CatchableError as exc:
-    trace "error writing stop handshake or reading stop response", exc=exc.msg
-    await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
-    return
+  let msgRcvFromDstOpt =
+    try:
+      await connDst.writeLp(encode(msgToSend).buffer)
+      RelayMessage.decode(await connDst.readLp(r.msgSize))
+    except CancelledError as exc:
+      raise exc
+    except CatchableError as exc:
+      trace "error writing stop handshake or reading stop response",
+        description = exc.msg
+      await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
+      return
 
   let msgRcvFromDst = msgRcvFromDstOpt.valueOr:
-    trace "error reading stop response", msg = msgRcvFromDstOpt
+    trace "error reading stop response", response = msgRcvFromDstOpt
     await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
     return
 
   if msgRcvFromDst.msgType.get(RelayType.Stop) != RelayType.Status or
-     msgRcvFromDst.status.get(StatusV1.StopRelayRefused) != StatusV1.Success:
+      msgRcvFromDst.status.get(StatusV1.StopRelayRefused) != StatusV1.Success:
     trace "unexcepted relay stop response", msgRcvFromDst
     await sendStatus(connSrc, StatusV1.HopCantOpenDstStream)
     return
@@ -303,54 +319,67 @@ proc handleStreamV1(r: Relay, conn: Connection) {.async.} =
     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)
-    else:
-      trace "Unexpected relay handshake", msgType=msg.msgType
-      await sendStatus(conn, StatusV1.MalformedMessage)
+  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)
+  else:
+    trace "Unexpected relay handshake", msgType = msg.msgType
+    await sendStatus(conn, StatusV1.MalformedMessage)
 
 proc setup*(r: Relay, switch: Switch) =
   r.switch = switch
   r.switch.addPeerEventHandler(
-    proc (peerId: PeerId, event: PeerEvent) {.async.} =
-      r.rsvp.del(peerId),
-    Left)
+    proc(peerId: PeerId, event: PeerEvent) {.async.} =
+      r.rsvp.del(peerId)
+    ,
+    Left,
+  )
 
-proc new*(T: typedesc[Relay],
-     reservationTTL: times.Duration = DefaultReservationTTL,
-     limitDuration: uint32 = DefaultLimitDuration,
-     limitData: uint64 = DefaultLimitData,
-     heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
-     maxCircuit: int = MaxCircuit,
-     maxCircuitPerPeer: int = MaxCircuitPerPeer,
-     msgSize: int = RelayMsgSize,
-     circuitRelayV1: bool = false): T =
-
-  let r = T(reservationTTL: reservationTTL,
-            limit: Limit(duration: limitDuration, data: limitData),
-            heartbeatSleepTime: heartbeatSleepTime,
-            maxCircuit: maxCircuit,
-            maxCircuitPerPeer: maxCircuitPerPeer,
-            msgSize: msgSize,
-            isCircuitRelayV1: circuitRelayV1)
+proc new*(
+    T: typedesc[Relay],
+    reservationTTL: times.Duration = DefaultReservationTTL,
+    limitDuration: uint32 = DefaultLimitDuration,
+    limitData: uint64 = DefaultLimitData,
+    heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime,
+    maxCircuit: int = MaxCircuit,
+    maxCircuitPerPeer: int = MaxCircuitPerPeer,
+    msgSize: int = RelayMsgSize,
+    circuitRelayV1: bool = false,
+): T =
+  let r = T(
+    reservationTTL: reservationTTL,
+    limit: Limit(duration: limitDuration, data: limitData),
+    heartbeatSleepTime: heartbeatSleepTime,
+    maxCircuit: maxCircuit,
+    maxCircuitPerPeer: maxCircuitPerPeer,
+    msgSize: msgSize,
+    isCircuitRelayV1: circuitRelayV1,
+  )
 
   proc handleStream(conn: Connection, proto: string) {.async.} =
     try:
-      case proto:
-      of RelayV2HopCodec: await r.handleHopStreamV2(conn)
-      of RelayV1Codec: await r.handleStreamV1(conn)
+      case proto
+      of RelayV2HopCodec:
+        await r.handleHopStreamV2(conn)
+      of RelayV1Codec:
+        await r.handleStreamV1(conn)
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      debug "exception in relayv2 handler", exc = exc.msg, conn
+      debug "exception in relayv2 handler", description = exc.msg, conn
     finally:
       trace "exiting relayv2 handler", conn
       await conn.close()
 
-  r.codecs = if r.isCircuitRelayV1: @[RelayV1Codec]
-             else: @[RelayV2HopCodec, RelayV1Codec]
+  r.codecs =
+    if r.isCircuitRelayV1:
+      @[RelayV1Codec]
+    else:
+      @[RelayV2HopCodec, RelayV1Codec]
   r.handler = handleStream
   r
 
@@ -361,9 +390,7 @@ proc deletesReservation(r: Relay) {.async.} =
       if n > r.rsvp[k]:
         r.rsvp.del(k)
 
-method start*(
-    r: Relay
-): Future[void] {.async: (raises: [CancelledError], raw: true).} =
+method start*(r: Relay): Future[void] {.async: (raises: [CancelledError], raw: true).} =
   let fut = newFuture[void]()
   fut.complete()
   if not r.reservationLoop.isNil:

libp2p/protocols/connectivity/relay/rtransport.nim

@@ -13,21 +13,21 @@ import sequtils, strutils
 
 import chronos, chronicles
 
-import ./client,
-       ./rconn,
-       ./utils,
-       ../../../switch,
-       ../../../stream/connection,
-       ../../../transports/transport
+import
+  ./client,
+  ./rconn,
+  ./utils,
+  ../../../switch,
+  ../../../stream/connection,
+  ../../../transports/transport
 
 logScope:
   topics = "libp2p relay relay-transport"
 
-type
-  RelayTransport* = ref object of Transport
-    client*: RelayClient
-    queue: AsyncQueue[Connection]
-    selfRunning: bool
+type RelayTransport* = ref object of Transport
+  client*: RelayClient
+  queue: AsyncQueue[Connection]
+  selfRunning: bool
 
 method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
   if self.selfRunning:
@@ -35,11 +35,10 @@ method start*(self: RelayTransport, ma: seq[MultiAddress]) {.async.} =
     return
 
   self.client.onNewConnection = proc(
-    conn: Connection,
-    duration: uint32 = 0,
-    data: uint64 = 0) {.async.} =
-      await self.queue.addLast(RelayConnection.new(conn, duration, data))
-      await conn.join()
+      conn: Connection, duration: uint32 = 0, data: uint64 = 0
+  ) {.async.} =
+    await self.queue.addLast(RelayConnection.new(conn, duration, data))
+    await conn.join()
   self.selfRunning = true
   await procCall Transport(self).start(ma)
   trace "Starting Relay transport"
@@ -57,7 +56,7 @@ method accept*(self: RelayTransport): Future[Connection] {.async.} =
 proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async.} =
   let
     sma = toSeq(ma.items())
-    relayAddrs = sma[0..sma.len-4].mapIt(it.tryGet()).foldl(a & b)
+    relayAddrs = sma[0 .. sma.len - 4].mapIt(it.tryGet()).foldl(a & b)
   var
     relayPeerId: PeerId
     dstPeerId: PeerId
@@ -68,13 +67,12 @@ proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async.}
   trace "Dial", relayPeerId, dstPeerId
 
   let conn = await self.client.switch.dial(
-    relayPeerId,
-    @[ relayAddrs ],
-    @[ RelayV2HopCodec, RelayV1Codec ])
+    relayPeerId, @[relayAddrs], @[RelayV2HopCodec, RelayV1Codec]
+  )
   conn.dir = Direction.Out
   var rc: RelayConnection
   try:
-    case conn.protocol:
+    case conn.protocol
     of RelayV1Codec:
       return await self.client.dialPeerV1(conn, dstPeerId, @[])
     of RelayV2HopCodec:
@@ -83,14 +81,16 @@ proc dial*(self: RelayTransport, ma: MultiAddress): Future[Connection] {.async.}
   except CancelledError as exc:
     raise exc
   except CatchableError as exc:
-    if not rc.isNil: await rc.close()
+    if not rc.isNil:
+      await rc.close()
     raise exc
 
 method dial*(
-  self: RelayTransport,
-  hostname: string,
-  ma: MultiAddress,
-  peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection] {.async.} =
+    self: RelayTransport,
+    hostname: string,
+    ma: MultiAddress,
+    peerId: Opt[PeerId] = Opt.none(PeerId),
+): Future[Connection] {.async.} =
   peerId.withValue(pid):
     let address = MultiAddress.init($ma & "/p2p/" & $pid).tryGet()
     result = await self.dial(address)

libp2p/protocols/connectivity/relay/utils.nim

@@ -10,8 +10,7 @@
 {.push raises: [].}
 
 import chronos, chronicles
-import ./messages,
-       ../../../stream/connection
+import ./messages, ../../../stream/connection
 
 logScope:
   topics = "libp2p relay relay-utils"
@@ -22,19 +21,16 @@ const
   RelayV2StopCodec* = "/libp2p/circuit/relay/0.2.0/stop"
 
 proc sendStatus*(
-    conn: Connection,
-    code: StatusV1
+    conn: Connection, code: StatusV1
 ) {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   trace "send relay/v1 status", status = $code & "(" & $ord(code) & ")"
   let
-    msg = RelayMessage(
-      msgType: Opt.some(RelayType.Status), status: Opt.some(code))
+    msg = RelayMessage(msgType: Opt.some(RelayType.Status), status: Opt.some(code))
     pb = encode(msg)
   conn.writeLp(pb.buffer)
 
 proc sendHopStatus*(
-    conn: Connection,
-    code: StatusV2
+    conn: Connection, code: StatusV2
 ) {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   trace "send hop relay/v2 status", status = $code & "(" & $ord(code) & ")"
   let
@@ -43,8 +39,7 @@ proc sendHopStatus*(
   conn.writeLp(pb.buffer)
 
 proc sendStopStatus*(
-    conn: Connection,
-    code: StatusV2
+    conn: Connection, code: StatusV2
 ) {.async: (raises: [CancelledError, LPStreamError], raw: true).} =
   trace "send stop relay/v2 status", status = $code & " (" & $ord(code) & ")"
   let
@@ -53,8 +48,8 @@ proc sendStopStatus*(
   conn.writeLp(pb.buffer)
 
 proc bridge*(
-    connSrc: Connection,
-    connDst: Connection) {.async: (raises: [CancelledError]).} =
+    connSrc: Connection, connDst: Connection
+) {.async: (raises: [CancelledError]).} =
   const bufferSize = 4096
   var
     bufSrcToDst: array[bufferSize, byte]
@@ -67,9 +62,10 @@ proc bridge*(
 
   try:
     while not connSrc.closed() and not connDst.closed():
-      try:  # https://github.com/status-im/nim-chronos/issues/516
+      try: # https://github.com/status-im/nim-chronos/issues/516
         discard await race(futSrc, futDst)
-      except ValueError: raiseAssert("Futures list is not empty")
+      except ValueError:
+        raiseAssert("Futures list is not empty")
       if futSrc.finished():
         bufRead = await futSrc
         if bufRead > 0:
@@ -91,7 +87,7 @@ proc bridge*(
       trace "relay src closed connection", src = connSrc.peerId
     if connDst.closed() or connDst.atEof():
       trace "relay dst closed connection", dst = connDst.peerId
-    trace "relay error", exc=exc.msg
+    trace "relay error", description = exc.msg
   trace "end relaying", bytesSentFromSrcToDst, bytesSentFromDstToSrc
   await futSrc.cancelAndWait()
   await futDst.cancelAndWait()

libp2p/protocols/identify.nim

@@ -15,17 +15,18 @@
 import std/[sequtils, options, strutils, sugar]
 import stew/results
 import chronos, chronicles
-import ../protobuf/minprotobuf,
-       ../peerinfo,
-       ../stream/connection,
-       ../peerid,
-       ../crypto/crypto,
-       ../multiaddress,
-       ../multicodec,
-       ../protocols/protocol,
-       ../utility,
-       ../errors,
-       ../observedaddrmanager
+import
+  ../protobuf/minprotobuf,
+  ../peerinfo,
+  ../stream/connection,
+  ../peerid,
+  ../crypto/crypto,
+  ../multiaddress,
+  ../multicodec,
+  ../protocols/protocol,
+  ../utility,
+  ../errors,
+  ../observedaddrmanager
 
 export observedaddrmanager
 
@@ -59,11 +60,9 @@ type
     sendSignedPeerRecord*: bool
     observedAddrManager*: ObservedAddrManager
 
-  IdentifyPushHandler* = proc (
-    peer: PeerId,
-    newInfo: IdentifyInfo):
-    Future[void]
-    {.gcsafe, raises: [], public.}
+  IdentifyPushHandler* = proc(peer: PeerId, newInfo: IdentifyInfo): Future[void] {.
+    gcsafe, raises: [], public
+  .}
 
   IdentifyPush* = ref object of LPProtocol
     identifyHandler: IdentifyPushHandler
@@ -78,11 +77,11 @@ chronicles.expandIt(IdentifyInfo):
   signedPeerRecord =
     # The SPR contains the same data as the identify message
     # would be cumbersome to log
-    if it.signedPeerRecord.isSome(): "Some"
-    else: "None"
+    if it.signedPeerRecord.isSome(): "Some" else: "None"
 
-proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool): ProtoBuffer
-  {.raises: [].} =
+proc encodeMsg(
+    peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: bool
+): ProtoBuffer {.raises: [].} =
   result = initProtoBuffer()
 
   let pkey = peerInfo.publicKey
@@ -96,10 +95,8 @@ proc encodeMsg(peerInfo: PeerInfo, observedAddr: Opt[MultiAddress], sendSpr: boo
     result.write(4, observed.data.buffer)
   let protoVersion = ProtoVersion
   result.write(5, protoVersion)
-  let agentVersion = if peerInfo.agentVersion.len <= 0:
-    AgentVersion
-  else:
-    peerInfo.agentVersion
+  let agentVersion =
+    if peerInfo.agentVersion.len <= 0: AgentVersion else: peerInfo.agentVersion
   result.write(6, agentVersion)
 
   ## Optionally populate signedPeerRecord field.
@@ -120,28 +117,28 @@ proc decodeMsg*(buf: seq[byte]): Opt[IdentifyInfo] =
     signedPeerRecord: SignedPeerRecord
 
   var pb = initProtoBuffer(buf)
-  if ? pb.getField(1, pubkey).toOpt():
+  if ?pb.getField(1, pubkey).toOpt():
     iinfo.pubkey = some(pubkey)
-    if ? pb.getField(8, signedPeerRecord).toOpt() and
-      pubkey == signedPeerRecord.envelope.publicKey:
+    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():
+  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():
+  if ?pb.getField(5, protoVersion).toOpt():
     iinfo.protoVersion = some(protoVersion)
-  if ? pb.getField(6, agentVersion).toOpt():
+  if ?pb.getField(6, agentVersion).toOpt():
     iinfo.agentVersion = some(agentVersion)
 
   Opt.some(iinfo)
 
 proc new*(
-  T: typedesc[Identify],
-  peerInfo: PeerInfo,
-  sendSignedPeerRecord = false,
-  observedAddrManager = ObservedAddrManager.new(),
-  ): T =
+    T: typedesc[Identify],
+    peerInfo: PeerInfo,
+    sendSignedPeerRecord = false,
+    observedAddrManager = ObservedAddrManager.new(),
+): T =
   let identify = T(
     peerInfo: peerInfo,
     sendSignedPeerRecord: sendSignedPeerRecord,
@@ -159,7 +156,7 @@ method init*(p: Identify) =
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "exception in identify handler", exc = exc.msg, conn
+      trace "exception in identify handler", description = exc.msg, conn
     finally:
       trace "exiting identify handler", conn
       await conn.closeWithEOF()
@@ -167,20 +164,23 @@ method init*(p: Identify) =
   p.handler = handle
   p.codec = IdentifyCodec
 
-proc identify*(self: Identify,
-               conn: Connection,
-               remotePeerId: PeerId): Future[IdentifyInfo] {.async.} =
+proc identify*(
+    self: Identify, conn: Connection, remotePeerId: PeerId
+): Future[IdentifyInfo] {.async.} =
   trace "initiating identify", conn
-  var message = await conn.readLp(64*1024)
+  var message = await conn.readLp(64 * 1024)
   if len(message) == 0:
     trace "identify: Empty message received!", conn
     raise newException(IdentityInvalidMsgError, "Empty message received!")
 
-  var info = decodeMsg(message).valueOr: raise newException(IdentityInvalidMsgError, "Incorrect message received!")
+  var info = decodeMsg(message).valueOr:
+    raise newException(IdentityInvalidMsgError, "Incorrect message received!")
   debug "identify: decoded message", conn, info
   let
-    pubkey = info.pubkey.valueOr: raise newException(IdentityInvalidMsgError, "No pubkey in identify")
-    peer = PeerId.init(pubkey).valueOr: raise newException(IdentityInvalidMsgError, $error)
+    pubkey = info.pubkey.valueOr:
+      raise newException(IdentityInvalidMsgError, "No pubkey in identify")
+    peer = PeerId.init(pubkey).valueOr:
+      raise newException(IdentityInvalidMsgError, $error)
 
   if peer != remotePeerId:
     trace "Peer ids don't match", remote = peer, local = remotePeerId
@@ -190,7 +190,8 @@ proc identify*(self: Identify,
   info.observedAddr.withValue(observed):
     # Currently, we use the ObservedAddrManager only to find our dialable external NAT address. Therefore, addresses
     # like "...\p2p-circuit\p2p\..." and "\p2p\..." are not useful to us.
-    if observed.contains(multiCodec("p2p-circuit")).get(false) or P2PPattern.matchPartial(observed):
+    if observed.contains(multiCodec("p2p-circuit")).get(false) or
+        P2PPattern.matchPartial(observed):
       trace "Not adding address to ObservedAddrManager.", observed
     elif not self.observedAddrManager.addObservation(observed):
       trace "Observed address is not valid.", observedAddr = observed
@@ -207,7 +208,7 @@ proc init*(p: IdentifyPush) =
   proc handle(conn: Connection, proto: string) {.async.} =
     trace "handling identify push", conn
     try:
-      var message = await conn.readLp(64*1024)
+      var message = await conn.readLp(64 * 1024)
 
       var identInfo = decodeMsg(message).valueOr:
         raise newException(IdentityInvalidMsgError, "Incorrect message received!")
@@ -225,7 +226,7 @@ proc init*(p: IdentifyPush) =
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      info "exception in identify push handler", exc = exc.msg, conn
+      info "exception in identify push handler", description = exc.msg, conn
     finally:
       trace "exiting identify push handler", conn
       await conn.closeWithEOF()

libp2p/protocols/perf/client.nim

@@ -18,9 +18,12 @@ logScope:
 
 type PerfClient* = ref object of RootObj
 
-proc perf*(_: typedesc[PerfClient], conn: Connection,
-           sizeToWrite: uint64 = 0, sizeToRead: uint64 = 0):
-           Future[Duration] {.async, public.} =
+proc perf*(
+    _: typedesc[PerfClient],
+    conn: Connection,
+    sizeToWrite: uint64 = 0,
+    sizeToRead: uint64 = 0,
+): Future[Duration] {.async, public.} =
   var
     size = sizeToWrite
     buf: array[PerfSize, byte]
@@ -30,7 +33,7 @@ proc perf*(_: typedesc[PerfClient], conn: Connection,
   await conn.write(toSeq(toBytesBE(sizeToRead)))
   while size > 0:
     let toWrite = min(size, PerfSize)
-    await conn.write(buf[0..<toWrite])
+    await conn.write(buf[0 ..< toWrite])
     size -= toWrite
 
   await conn.close()

libp2p/protocols/perf/server.nim

@@ -13,10 +13,7 @@
 
 import chronos, chronicles
 import stew/endians2
-import ./core,
-       ../protocol,
-       ../../stream/connection,
-       ../../utility
+import ./core, ../protocol, ../../stream/connection, ../../utility
 
 export chronicles, connection
 
@@ -47,12 +44,12 @@ proc new*(T: typedesc[Perf]): T {.public.} =
       var buf: array[PerfSize, byte]
       while size > 0:
         let toWrite = min(size, PerfSize)
-        await conn.write(buf[0..<toWrite])
+        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
+      trace "exception in perf handler", description = exc.msg, conn
     await conn.close()
 
   p.handler = handle

libp2p/protocols/ping.nim

@@ -13,15 +13,16 @@
 
 import chronos, chronicles
 import bearssl/rand
-import ../protobuf/minprotobuf,
-       ../peerinfo,
-       ../stream/connection,
-       ../peerid,
-       ../crypto/crypto,
-       ../multiaddress,
-       ../protocols/protocol,
-       ../utility,
-       ../errors
+import
+  ../protobuf/minprotobuf,
+  ../peerinfo,
+  ../stream/connection,
+  ../peerid,
+  ../crypto/crypto,
+  ../multiaddress,
+  ../protocols/protocol,
+  ../utility,
+  ../errors
 
 export chronicles, rand, connection
 
@@ -36,16 +37,15 @@ type
   PingError* = object of LPError
   WrongPingAckError* = object of PingError
 
-  PingHandler* {.public.} = proc (
-    peer: PeerId):
-    Future[void]
-    {.gcsafe, raises: [].}
+  PingHandler* {.public.} = proc(peer: PeerId): Future[void] {.gcsafe, raises: [].}
 
   Ping* = ref object of LPProtocol
     pingHandler*: PingHandler
     rng: ref HmacDrbgContext
 
-proc new*(T: typedesc[Ping], handler: PingHandler = nil, rng: ref HmacDrbgContext = newRng()): T {.public.} =
+proc new*(
+    T: typedesc[Ping], handler: PingHandler = nil, rng: ref HmacDrbgContext = newRng()
+): T {.public.} =
   let ping = Ping(pinghandler: handler, rng: rng)
   ping.init()
   ping
@@ -63,15 +63,12 @@ method init*(p: Ping) =
     except CancelledError as exc:
       raise exc
     except CatchableError as exc:
-      trace "exception in ping handler", exc = exc.msg, conn
+      trace "exception in ping handler", description = exc.msg, conn
 
   p.handler = handle
   p.codec = PingCodec
 
-proc ping*(
-  p: Ping,
-  conn: Connection,
-  ): Future[Duration] {.async, public.} =
+proc ping*(p: Ping, conn: Connection): Future[Duration] {.async, public.} =
   ## Sends ping to `conn`, returns the delay
 
   trace "initiating ping", conn
@@ -93,7 +90,7 @@ proc ping*(
 
   trace "got ping response", conn, responseDur
 
-  for i in 0..<randomBuf.len:
+  for i in 0 ..< randomBuf.len:
     if randomBuf[i] != resultBuf[i]:
       raise newException(WrongPingAckError, "Incorrect ping data from peer!")
 

libp2p/protocols/protocol.nim

@@ -14,24 +14,21 @@ import ../stream/connection
 
 export results
 
-const
-  DefaultMaxIncomingStreams* = 10
+const DefaultMaxIncomingStreams* = 10
 
 type
-  LPProtoHandler* = proc (
-      conn: Connection,
-      proto: string): Future[void] {.async.}
+  LPProtoHandler* = proc(conn: Connection, proto: string): Future[void] {.async.}
 
   LPProtocol* = ref object of RootObj
     codecs*: seq[string]
-    handlerImpl: LPProtoHandler  ## invoked by the protocol negotiator
+    handlerImpl: LPProtoHandler ## invoked by the protocol negotiator
     started*: bool
     maxIncomingStreams: Opt[int]
 
-method init*(p: LPProtocol) {.base, gcsafe.} = discard
+method init*(p: LPProtocol) {.base, gcsafe.} =
+  discard
 
-method start*(
-    p: LPProtocol) {.async: (raises: [CancelledError], raw: true), base.} =
+method start*(p: LPProtocol) {.async: (raises: [CancelledError], raw: true), base.} =
   let fut = newFuture[void]()
   fut.complete()
   p.started = true
@@ -61,8 +58,7 @@ func `codec=`*(p: LPProtocol, codec: string) =
 template `handler`*(p: LPProtocol): LPProtoHandler =
   p.handlerImpl
 
-template `handler`*(
-    p: LPProtocol, conn: Connection, proto: string): Future[void] =
+template `handler`*(p: LPProtocol, conn: Connection, proto: string): Future[void] =
   p.handlerImpl(conn, proto)
 
 func `handler=`*(p: LPProtocol, handler: LPProtoHandler) =
@@ -76,33 +72,37 @@ func `handler=`*(p: LPProtocol, handler: LPProtoHandler) =
 # https://github.com/nim-lang/Nim/issues/23432
 func `handler=`*[E](
     p: LPProtocol,
-    handler: proc (
-      conn: Connection,
-      proto: string): InternalRaisesFuture[void, E]) =
+    handler: proc(conn: Connection, proto: string): InternalRaisesFuture[void, E],
+) =
   proc wrap(conn: Connection, proto: string): Future[void] {.async.} =
     await handler(conn, proto)
+
   p.handlerImpl = wrap
 
 proc new*(
     T: type LPProtocol,
     codecs: seq[string],
     handler: LPProtoHandler,
-    maxIncomingStreams: Opt[int] | int = Opt.none(int)): T =
+    maxIncomingStreams: Opt[int] | int = Opt.none(int),
+): T =
   T(
     codecs: codecs,
     handlerImpl: handler,
     maxIncomingStreams:
-      when maxIncomingStreams is int: Opt.some(maxIncomingStreams)
-      else: maxIncomingStreams
+      when maxIncomingStreams is int:
+        Opt.some(maxIncomingStreams)
+      else:
+        maxIncomingStreams
+    ,
   )
 
 proc new*[E](
     T: type LPProtocol,
     codecs: seq[string],
-    handler: proc (
-      conn: Connection,
-      proto: string): InternalRaisesFuture[void, E],
-    maxIncomingStreams: Opt[int] | int = Opt.none(int)): T =
+    handler: proc(conn: Connection, proto: string): InternalRaisesFuture[void, E],
+    maxIncomingStreams: Opt[int] | int = Opt.none(int),
+): T =
   proc wrap(conn: Connection, proto: string): Future[void] {.async.} =
     await handler(conn, proto)
+
   T.new(codec, wrap, maxIncomingStreams)

libp2p/protocols/pubsub/errors.nim

@@ -3,6 +3,7 @@
 
 import ../../utility
 
-type
-  ValidationResult* {.pure, public.} = enum
-    Accept, Reject, Ignore
+type ValidationResult* {.pure, public.} = enum
+  Accept
+  Reject
+  Ignore

libp2p/protocols/pubsub/floodsub.nim

@@ -11,17 +11,18 @@
 
 import std/[sets, hashes, tables]
 import chronos, chronicles, metrics
-import ./pubsub,
-       ./pubsubpeer,
-       ./timedcache,
-       ./peertable,
-       ./rpc/[message, messages, protobuf],
-       nimcrypto/[hash, sha2],
-       ../../crypto/crypto,
-       ../../stream/connection,
-       ../../peerid,
-       ../../peerinfo,
-       ../../utility
+import
+  ./pubsub,
+  ./pubsubpeer,
+  ./timedcache,
+  ./peertable,
+  ./rpc/[message, messages, protobuf],
+  nimcrypto/[hash, sha2],
+  ../../crypto/crypto,
+  ../../stream/connection,
+  ../../peerid,
+  ../../peerinfo,
+  ../../utility
 
 ## Simple flood-based publishing.
 
@@ -30,17 +31,16 @@ logScope:
 
 const FloodSubCodec* = "/floodsub/1.0.0"
 
-type
-  FloodSub* {.public.} = ref object of PubSub
-    floodsub*: PeerTable      # topic to remote peer map
-    seen*: TimedCache[SaltedId]
-      # Early filter for messages recently observed on the network
-      # We use a salted id because the messages in this cache have not yet
-      # been validated meaning that an attacker has greater control over the
-      # hash key and therefore could poison the table
-    seenSalt*: sha256
-      # The salt in this case is a partially updated SHA256 context pre-seeded
-      # with some random data
+type FloodSub* {.public.} = ref object of PubSub
+  floodsub*: PeerTable # topic to remote peer map
+  seen*: TimedCache[SaltedId]
+    # Early filter for messages recently observed on the network
+    # We use a salted id because the messages in this cache have not yet
+    # been validated meaning that an attacker has greater control over the
+    # hash key and therefore could poison the table
+  seenSalt*: sha256
+    # The salt in this case is a partially updated SHA256 context pre-seeded
+    # with some random data
 
 proc salt*(f: FloodSub, msgId: MessageId): SaltedId =
   var tmp = f.seenSalt
@@ -57,10 +57,7 @@ proc addSeen*(f: FloodSub, saltedId: SaltedId): bool =
 proc firstSeen*(f: FloodSub, saltedId: SaltedId): Moment =
   f.seen.addedAt(saltedId)
 
-proc handleSubscribe(f: FloodSub,
-                     peer: PubSubPeer,
-                     topic: string,
-                     subscribe: bool) =
+proc handleSubscribe(f: FloodSub, peer: PubSubPeer, topic: string, subscribe: bool) =
   logScope:
     peer
     topic
@@ -73,7 +70,8 @@ proc handleSubscribe(f: FloodSub,
     trace "ignoring unknown peer"
     return
 
-  if subscribe and not(isNil(f.subscriptionValidator)) and not(f.subscriptionValidator(topic)):
+  if subscribe and not (isNil(f.subscriptionValidator)) and
+      not (f.subscriptionValidator(topic)):
     # this is a violation, so warn should be in order
     warn "ignoring invalid topic subscription", topic, peer
     return
@@ -103,22 +101,24 @@ method unsubscribePeer*(f: FloodSub, peer: PeerId) =
 
   procCall PubSub(f).unsubscribePeer(peer)
 
-method rpcHandler*(f: FloodSub,
-                   peer: PubSubPeer,
-                   data: seq[byte]) {.async.} =
+method rpcHandler*(
+    f: FloodSub, peer: PubSubPeer, data: seq[byte]
+) {.async: (raises: [CancelledError, PeerMessageDecodeError, PeerRateLimitError]).} =
   var rpcMsg = decodeRpcMsg(data).valueOr:
     debug "failed to decode msg from peer", peer, err = error
-    raise newException(CatchableError, "Peer msg couldn't be decoded")
+    raise newException(PeerMessageDecodeError, "Peer msg couldn't be decoded")
 
-  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
+  trace "decoded msg from peer", peer, payload = rpcMsg.shortLog
   # trigger hooks
   peer.recvObservers(rpcMsg)
 
-  for i in 0..<min(f.topicsHigh, rpcMsg.subscriptions.len):
-    template sub: untyped = rpcMsg.subscriptions[i]
+  for i in 0 ..< min(f.topicsHigh, rpcMsg.subscriptions.len):
+    template sub(): untyped =
+      rpcMsg.subscriptions[i]
+
     f.handleSubscribe(peer, sub.topic, sub.subscribe)
 
-  for msg in rpcMsg.messages:                         # for every message
+  for msg in rpcMsg.messages: # for every message
     let msgIdResult = f.msgIdProvider(msg)
     if msgIdResult.isErr:
       debug "Dropping message due to failed message id generation",
@@ -188,15 +188,13 @@ method init*(f: FloodSub) =
       # This is top-level procedure which will work as separate task, so it
       # do not need to propagate CancelledError.
       trace "Unexpected cancellation in floodsub handler", conn
-    except CatchableError as exc:
-      trace "FloodSub handler leaks an error", exc = exc.msg, conn
 
   f.handler = handler
   f.codec = FloodSubCodec
 
-method publish*(f: FloodSub,
-                topic: string,
-                data: seq[byte]): Future[int] {.async.} =
+method publish*(
+    f: FloodSub, topic: string, data: seq[byte]
+): Future[int] {.async: (raises: [LPError]).} =
   # base returns always 0
   discard await procCall PubSub(f).publish(topic, data)
 
@@ -220,12 +218,10 @@ method publish*(f: FloodSub,
         inc f.msgSeqno
         Message.init(some(f.peerInfo), data, topic, some(f.msgSeqno), f.sign)
     msgId = f.msgIdProvider(msg).valueOr:
-      trace "Error generating message id, skipping publish",
-        error = error
+      trace "Error generating message id, skipping publish", error = error
       return 0
 
-  trace "Created new message",
-    msg = shortLog(msg), peers = peers.len, topic, msgId
+  trace "Created new message", payload = shortLog(msg), peers = peers.len, topic, msgId
 
   if f.addSeen(f.salt(msgId)):
     # custom msgid providers might cause this
@@ -242,8 +238,7 @@ method publish*(f: FloodSub,
 
   return peers.len
 
-method initPubSub*(f: FloodSub)
-  {.raises: [InitializationError].} =
+method initPubSub*(f: FloodSub) {.raises: [InitializationError].} =
   procCall PubSub(f).initPubSub()
   f.seen = TimedCache[SaltedId].init(2.minutes)
   f.seenSalt.init()

libp2p/protocols/pubsub/gossipsub.nim

@@ -14,19 +14,20 @@
 import std/[sets, sequtils]
 import chronos, chronicles, metrics
 import chronos/ratelimit
-import ./pubsub,
-       ./floodsub,
-       ./pubsubpeer,
-       ./peertable,
-       ./mcache,
-       ./timedcache,
-       ./rpc/[messages, message, protobuf],
-       ../protocol,
-       ../../stream/connection,
-       ../../peerinfo,
-       ../../peerid,
-       ../../utility,
-       ../../switch
+import
+  ./pubsub,
+  ./floodsub,
+  ./pubsubpeer,
+  ./peertable,
+  ./mcache,
+  ./timedcache,
+  ./rpc/[messages, message, protobuf],
+  ../protocol,
+  ../../stream/connection,
+  ../../peerinfo,
+  ../../peerid,
+  ../../utility,
+  ../../switch
 
 import stew/results
 export results
@@ -39,95 +40,114 @@ logScope:
   topics = "libp2p gossipsub"
 
 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_invalid_topic_subscription,
+  "number of invalid topic subscriptions that happened",
+)
+declareCounter(
+  libp2p_gossipsub_duplicate_during_validation,
+  "number of duplicates received during message validation",
+)
+declareCounter(
+  libp2p_gossipsub_idontwant_saved_messages, "number of duplicates avoided by idontwant"
+)
+declareCounter(
+  libp2p_gossipsub_saved_bytes,
+  "bytes saved by gossipsub optimizations",
+  labels = ["kind"],
+)
 declareCounter(libp2p_gossipsub_duplicate, "number of duplicates received")
 declareCounter(libp2p_gossipsub_received, "number of messages received (deduplicated)")
 
 when defined(libp2p_expensive_metrics):
-  declareCounter(libp2p_pubsub_received_messages, "number of messages received", labels = ["id", "topic"])
+  declareCounter(
+    libp2p_pubsub_received_messages,
+    "number of messages received",
+    labels = ["id", "topic"],
+  )
 
 proc init*(
-  _: type[GossipSubParams],
-  pruneBackoff = 1.minutes,
-  unsubscribeBackoff = 5.seconds,
-  floodPublish = true,
-  gossipFactor: float64 = 0.25,
-  d = GossipSubD,
-  dLow = GossipSubDlo,
-  dHigh = GossipSubDhi,
-  dScore = GossipSubDlo,
-  dOut = GossipSubDlo - 1, # DLow - 1
-  dLazy = GossipSubD, # Like D,
-  heartbeatInterval = GossipSubHeartbeatInterval,
-  historyLength = GossipSubHistoryLength,
-  historyGossip = GossipSubHistoryGossip,
-  fanoutTTL = GossipSubFanoutTTL,
-  seenTTL = 2.minutes,
-  gossipThreshold = -100.0,
-  publishThreshold = -1000.0,
-  graylistThreshold = -10000.0,
-  opportunisticGraftThreshold = 0.0,
-  decayInterval = 1.seconds,
-  decayToZero = 0.01,
-  retainScore = 2.minutes,
-  appSpecificWeight = 0.0,
-  ipColocationFactorWeight = 0.0,
-  ipColocationFactorThreshold = 1.0,
-  behaviourPenaltyWeight = -1.0,
-  behaviourPenaltyDecay = 0.999,
-  directPeers = initTable[PeerId, seq[MultiAddress]](),
-  disconnectBadPeers = false,
-  enablePX = false,
-  bandwidthEstimatebps = 100_000_000, # 100 Mbps or 12.5 MBps
-  overheadRateLimit = Opt.none(tuple[bytes: int, interval: Duration]),
-  disconnectPeerAboveRateLimit = false,
-  maxNumElementsInNonPriorityQueue = DefaultMaxNumElementsInNonPriorityQueue): GossipSubParams =
-
+    _: type[GossipSubParams],
+    pruneBackoff = 1.minutes,
+    unsubscribeBackoff = 5.seconds,
+    floodPublish = true,
+    gossipFactor: float64 = 0.25,
+    d = GossipSubD,
+    dLow = GossipSubDlo,
+    dHigh = GossipSubDhi,
+    dScore = GossipSubDlo,
+    dOut = GossipSubDlo - 1, # DLow - 1
+    dLazy = GossipSubD, # Like D,
+    heartbeatInterval = GossipSubHeartbeatInterval,
+    historyLength = GossipSubHistoryLength,
+    historyGossip = GossipSubHistoryGossip,
+    fanoutTTL = GossipSubFanoutTTL,
+    seenTTL = 2.minutes,
+    gossipThreshold = -100.0,
+    publishThreshold = -1000.0,
+    graylistThreshold = -10000.0,
+    opportunisticGraftThreshold = 0.0,
+    decayInterval = 1.seconds,
+    decayToZero = 0.01,
+    retainScore = 2.minutes,
+    appSpecificWeight = 0.0,
+    ipColocationFactorWeight = 0.0,
+    ipColocationFactorThreshold = 1.0,
+    behaviourPenaltyWeight = -1.0,
+    behaviourPenaltyDecay = 0.999,
+    directPeers = initTable[PeerId, seq[MultiAddress]](),
+    disconnectBadPeers = false,
+    enablePX = false,
+    bandwidthEstimatebps = 100_000_000, # 100 Mbps or 12.5 MBps
+    overheadRateLimit = Opt.none(tuple[bytes: int, interval: Duration]),
+    disconnectPeerAboveRateLimit = false,
+    maxNumElementsInNonPriorityQueue = DefaultMaxNumElementsInNonPriorityQueue,
+    sendIDontWantOnPublish = false,
+): GossipSubParams =
   GossipSubParams(
-      explicit: true,
-      pruneBackoff: pruneBackoff,
-      unsubscribeBackoff: unsubscribeBackoff,
-      floodPublish: floodPublish,
-      gossipFactor: gossipFactor,
-      d: d,
-      dLow: dLow,
-      dHigh: dHigh,
-      dScore: dScore,
-      dOut: dOut,
-      dLazy: dLazy,
-      heartbeatInterval: heartbeatInterval,
-      historyLength: historyLength,
-      historyGossip: historyGossip,
-      fanoutTTL: fanoutTTL,
-      seenTTL: seenTTL,
-      gossipThreshold: gossipThreshold,
-      publishThreshold: publishThreshold,
-      graylistThreshold: graylistThreshold,
-      opportunisticGraftThreshold: opportunisticGraftThreshold,
-      decayInterval: decayInterval,
-      decayToZero: decayToZero,
-      retainScore: retainScore,
-      appSpecificWeight: appSpecificWeight,
-      ipColocationFactorWeight: ipColocationFactorWeight,
-      ipColocationFactorThreshold: ipColocationFactorThreshold,
-      behaviourPenaltyWeight: behaviourPenaltyWeight,
-      behaviourPenaltyDecay: behaviourPenaltyDecay,
-      directPeers: directPeers,
-      disconnectBadPeers: disconnectBadPeers,
-      enablePX: enablePX,
-      bandwidthEstimatebps: bandwidthEstimatebps,
-      overheadRateLimit: overheadRateLimit,
-      disconnectPeerAboveRateLimit: disconnectPeerAboveRateLimit,
-      maxNumElementsInNonPriorityQueue: maxNumElementsInNonPriorityQueue
-    )
+    explicit: true,
+    pruneBackoff: pruneBackoff,
+    unsubscribeBackoff: unsubscribeBackoff,
+    floodPublish: floodPublish,
+    gossipFactor: gossipFactor,
+    d: d,
+    dLow: dLow,
+    dHigh: dHigh,
+    dScore: dScore,
+    dOut: dOut,
+    dLazy: dLazy,
+    heartbeatInterval: heartbeatInterval,
+    historyLength: historyLength,
+    historyGossip: historyGossip,
+    fanoutTTL: fanoutTTL,
+    seenTTL: seenTTL,
+    gossipThreshold: gossipThreshold,
+    publishThreshold: publishThreshold,
+    graylistThreshold: graylistThreshold,
+    opportunisticGraftThreshold: opportunisticGraftThreshold,
+    decayInterval: decayInterval,
+    decayToZero: decayToZero,
+    retainScore: retainScore,
+    appSpecificWeight: appSpecificWeight,
+    ipColocationFactorWeight: ipColocationFactorWeight,
+    ipColocationFactorThreshold: ipColocationFactorThreshold,
+    behaviourPenaltyWeight: behaviourPenaltyWeight,
+    behaviourPenaltyDecay: behaviourPenaltyDecay,
+    directPeers: directPeers,
+    disconnectBadPeers: disconnectBadPeers,
+    enablePX: enablePX,
+    bandwidthEstimatebps: bandwidthEstimatebps,
+    overheadRateLimit: overheadRateLimit,
+    disconnectPeerAboveRateLimit: disconnectPeerAboveRateLimit,
+    maxNumElementsInNonPriorityQueue: maxNumElementsInNonPriorityQueue,
+    sendIDontWantOnPublish: sendIDontWantOnPublish,
+  )
 
 proc validateParameters*(parameters: GossipSubParams): Result[void, cstring] =
-  if  (parameters.dOut >= parameters.dLow) or
-      (parameters.dOut > (parameters.d div 2)):
-    err("gossipsub: dOut parameter error, Number of outbound connections to keep in the mesh. Must be less than D_lo and at most D/2")
+  if (parameters.dOut >= parameters.dLow) or (parameters.dOut > (parameters.d div 2)):
+    err(
+      "gossipsub: dOut parameter error, Number of outbound connections to keep in the mesh. Must be less than D_lo and at most D/2"
+    )
   elif parameters.gossipThreshold >= 0:
     err("gossipsub: gossipThreshold parameter error, Must be < 0")
   elif parameters.unsubscribeBackoff.seconds <= 0:
@@ -163,17 +183,29 @@ proc validateParameters*(parameters: TopicParams): Result[void, cstring] =
   elif parameters.timeInMeshCap <= 0.0:
     err("gossipsub: timeInMeshCap parameter error, Should be a positive value")
   elif parameters.firstMessageDeliveriesWeight <= 0.0:
-    err("gossipsub: firstMessageDeliveriesWeight parameter error, Should be a positive value")
+    err(
+      "gossipsub: firstMessageDeliveriesWeight parameter error, Should be a positive value"
+    )
   elif parameters.meshMessageDeliveriesWeight >= 0.0:
-    err("gossipsub: meshMessageDeliveriesWeight parameter error, Should be a negative value")
+    err(
+      "gossipsub: meshMessageDeliveriesWeight parameter error, Should be a negative value"
+    )
   elif parameters.meshMessageDeliveriesThreshold <= 0.0:
-    err("gossipsub: meshMessageDeliveriesThreshold parameter error, Should be a positive value")
+    err(
+      "gossipsub: meshMessageDeliveriesThreshold parameter error, Should be a positive value"
+    )
   elif parameters.meshMessageDeliveriesCap < parameters.meshMessageDeliveriesThreshold:
-    err("gossipsub: meshMessageDeliveriesCap parameter error, Should be >= meshMessageDeliveriesThreshold")
+    err(
+      "gossipsub: meshMessageDeliveriesCap parameter error, Should be >= meshMessageDeliveriesThreshold"
+    )
   elif parameters.meshFailurePenaltyWeight >= 0.0:
-    err("gossipsub: meshFailurePenaltyWeight parameter error, Should be a negative value")
+    err(
+      "gossipsub: meshFailurePenaltyWeight parameter error, Should be a negative value"
+    )
   elif parameters.invalidMessageDeliveriesWeight >= 0.0:
-    err("gossipsub: invalidMessageDeliveriesWeight parameter error, Should be a negative value")
+    err(
+      "gossipsub: invalidMessageDeliveriesWeight parameter error, Should be a negative value"
+    )
   else:
     ok()
 
@@ -189,15 +221,14 @@ method init*(g: GossipSub) =
       # This is top-level procedure which will work as separate task, so it
       # do not need to propogate CancelledError.
       trace "Unexpected cancellation in gossipsub handler", conn
-    except CatchableError as exc:
-      trace "GossipSub handler leaks an error", exc = exc.msg, conn
 
   g.handler = handler
-  g.codecs &= GossipSubCodec
+  g.codecs &= GossipSubCodec_12
+  g.codecs &= GossipSubCodec_11
   g.codecs &= GossipSubCodec_10
 
 method onNewPeer*(g: GossipSub, peer: PubSubPeer) =
-  g.withPeerStats(peer.peerId) do (stats: var PeerStats):
+  g.withPeerStats(peer.peerId) do(stats: var PeerStats):
     # Make sure stats and peer information match, even when reloading peer stats
     # from a previous connection
     peer.score = stats.score
@@ -210,7 +241,9 @@ method onNewPeer*(g: GossipSub, peer: PubSubPeer) =
   peer.iHaveBudget = IHavePeerBudget
   peer.pingBudget = PingsPeerBudget
 
-method onPubSubPeerEvent*(p: GossipSub, peer: PubSubPeer, event: PubSubPeerEvent) {.gcsafe.} =
+method onPubSubPeerEvent*(
+    p: GossipSub, peer: PubSubPeer, event: PubSubPeerEvent
+) {.gcsafe.} =
   case event.kind
   of PubSubPeerEventKind.StreamOpened:
     discard
@@ -266,10 +299,7 @@ method unsubscribePeer*(g: GossipSub, peer: PeerId) =
 
   procCall FloodSub(g).unsubscribePeer(peer)
 
-proc handleSubscribe(g: GossipSub,
-                     peer: PubSubPeer,
-                     topic: string,
-                     subscribe: bool) =
+proc handleSubscribe(g: GossipSub, peer: PubSubPeer, topic: string, subscribe: bool) =
   logScope:
     peer
     topic
@@ -283,7 +313,7 @@ proc handleSubscribe(g: GossipSub,
       trace "ignoring unknown peer"
       return
 
-    if not(isNil(g.subscriptionValidator)) and not(g.subscriptionValidator(topic)):
+    if not (isNil(g.subscriptionValidator)) and not (g.subscriptionValidator(topic)):
       # this is a violation, so warn should be in order
       trace "ignoring invalid topic subscription", topic, peer
       libp2p_gossipsub_invalid_topic_subscription.inc()
@@ -328,7 +358,6 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
     isIWantNotEmpty = respControl.iwant.len > 0
 
   if isPruneNotEmpty or isIWantNotEmpty:
-
     if isIWantNotEmpty:
       libp2p_pubsub_broadcast_iwant.inc(respControl.iwant.len.int64)
 
@@ -339,10 +368,8 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
         else:
           libp2p_pubsub_broadcast_prune.inc(labelValues = ["generic"])
 
-    trace "sending control message", msg = shortLog(respControl), peer
-    g.send(
-      peer,
-      RPCMsg(control: some(respControl)), isHighPriority = true)
+    trace "sending control message", payload = shortLog(respControl), peer
+    g.send(peer, RPCMsg(control: some(respControl)), isHighPriority = true)
 
   if messages.len > 0:
     for smsg in messages:
@@ -354,21 +381,71 @@ proc handleControl(g: GossipSub, peer: PubSubPeer, control: ControlMessage) =
 
     # iwant replies have lower priority
     trace "sending iwant reply messages", peer
-    g.send(
-      peer,
-      RPCMsg(messages: messages), isHighPriority = false)
+    g.send(peer, RPCMsg(messages: messages), isHighPriority = false)
 
-proc validateAndRelay(g: GossipSub,
-                      msg: Message,
-                      msgId: MessageId, saltedId: SaltedId,
-                      peer: PubSubPeer) {.async.} =
+proc sendIDontWant(
+    g: GossipSub,
+    msg: Message,
+    msgId: MessageId,
+    peersToSendIDontWant: HashSet[PubSubPeer],
+) =
+  # If the message is "large enough", let the mesh know that we do not want
+  # any more copies of it, regardless if it is valid or not.
+  #
+  # In the case that it is not valid, this leads to some redundancy
+  # (since the other peer should not send us an invalid message regardless),
+  # but the expectation is that this is rare (due to such peers getting
+  # descored) and that the savings from honest peers are greater than the
+  # cost a dishonest peer can incur in short time (since the IDONTWANT is
+  # small).
+
+  # IDONTWANT is only supported by >= GossipSubCodec_12
+  let peers = peersToSendIDontWant.filterIt(
+    it.codec != GossipSubCodec_10 and it.codec != GossipSubCodec_11
+  )
+
+  g.broadcast(
+    peers,
+    RPCMsg(
+      control: some(ControlMessage(idontwant: @[ControlIWant(messageIDs: @[msgId])]))
+    ),
+    isHighPriority = true,
+  )
+
+const iDontWantMessageSizeThreshold* = 512
+
+proc isLargeMessage(msg: Message, msgId: MessageId): bool =
+  msg.data.len > max(iDontWantMessageSizeThreshold, msgId.len * 10)
+
+proc validateAndRelay(
+    g: GossipSub, msg: Message, msgId: MessageId, saltedId: SaltedId, peer: PubSubPeer
+) {.async: (raises: []).} =
   try:
+    template topic(): string =
+      msg.topic
+
+    proc addToSendPeers(toSendPeers: var HashSet[PubSubPeer]) =
+      g.floodsub.withValue(topic, peers):
+        toSendPeers.incl(peers[])
+      g.mesh.withValue(topic, peers):
+        toSendPeers.incl(peers[])
+      g.subscribedDirectPeers.withValue(topic, peers):
+        toSendPeers.incl(peers[])
+      toSendPeers.excl(peer)
+
+    if isLargeMessage(msg, msgId):
+      var peersToSendIDontWant = HashSet[PubSubPeer]()
+      addToSendPeers(peersToSendIDontWant)
+      g.sendIDontWant(msg, msgId, peersToSendIDontWant)
+
     let validation = await g.validate(msg)
 
     var seenPeers: HashSet[PubSubPeer]
     discard g.validationSeen.pop(saltedId, seenPeers)
     libp2p_gossipsub_duplicate_during_validation.inc(seenPeers.len.int64)
-    libp2p_gossipsub_saved_bytes.inc((msg.data.len * seenPeers.len).int64, labelValues = ["validation_duplicate"])
+    libp2p_gossipsub_saved_bytes.inc(
+      (msg.data.len * seenPeers.len).int64, labelValues = ["validation_duplicate"]
+    )
 
     case validation
     of ValidationResult.Reject:
@@ -383,40 +460,35 @@ proc validateAndRelay(g: GossipSub,
     of ValidationResult.Accept:
       discard
 
+    if topic notin g.topics:
+      return # Topic was unsubscribed while validating
+
     # store in cache only after validation
     g.mcache.put(msgId, msg)
 
-    let topic = msg.topic
     g.rewardDelivered(peer, topic, true)
 
+    # trigger hooks
+    peer.validatedObservers(msg, msgId)
+
+    # The send list typically matches the idontwant list from above, but
+    # might differ if validation takes time
     var toSendPeers = HashSet[PubSubPeer]()
-    if topic notin g.topics:
-      return
-
-    g.floodsub.withValue(topic, peers): toSendPeers.incl(peers[])
-    g.mesh.withValue(topic, peers): toSendPeers.incl(peers[])
-    g.subscribedDirectPeers.withValue(topic, peers): toSendPeers.incl(peers[])
-
-    # Don't send it to source peer, or peers that
-    # sent it during validation
-    toSendPeers.excl(peer)
+    addToSendPeers(toSendPeers)
+    # Don't send it to peers that sent it during validation
     toSendPeers.excl(seenPeers)
 
-    # IDontWant is only worth it if the message is substantially
-    # bigger than the messageId
-    if msg.data.len > msgId.len * 10:
-      g.broadcast(toSendPeers, RPCMsg(control: some(ControlMessage(
-          idontwant: @[ControlIWant(messageIDs: @[msgId])]
-        ))), isHighPriority = true)
-
-    for peer in toSendPeers:
-      for heDontWant in peer.heDontWants:
-        if saltedId in heDontWant:
-          seenPeers.incl(peer)
+    proc isMsgInIdontWant(it: PubSubPeer): bool =
+      for iDontWant in it.iDontWants:
+        if saltedId in iDontWant:
           libp2p_gossipsub_idontwant_saved_messages.inc
-          libp2p_gossipsub_saved_bytes.inc(msg.data.len.int64, labelValues = ["idontwant"])
-          break
-    toSendPeers.excl(seenPeers)
+          libp2p_gossipsub_saved_bytes.inc(
+            msg.data.len.int64, labelValues = ["idontwant"]
+          )
+          return true
+      return false
+
+    toSendPeers.exclIfIt(isMsgInIdontWant(it))
 
     # 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
@@ -424,13 +496,19 @@ proc validateAndRelay(g: GossipSub,
     trace "forwarded message to peers", peers = toSendPeers.len, msgId, peer
 
     if g.knownTopics.contains(topic):
-      libp2p_pubsub_messages_rebroadcasted.inc(toSendPeers.len.int64, labelValues = [topic])
+      libp2p_pubsub_messages_rebroadcasted.inc(
+        toSendPeers.len.int64, labelValues = [topic]
+      )
     else:
-      libp2p_pubsub_messages_rebroadcasted.inc(toSendPeers.len.int64, labelValues = ["generic"])
+      libp2p_pubsub_messages_rebroadcasted.inc(
+        toSendPeers.len.int64, labelValues = ["generic"]
+      )
 
     await handleData(g, topic, msg.data)
-  except CatchableError as exc:
-    info "validateAndRelay failed", msg=exc.msg
+  except CancelledError as exc:
+    info "validateAndRelay failed", description = exc.msg
+  except PeerRateLimitError as exc:
+    info "validateAndRelay failed", description = exc.msg
 
 proc dataAndTopicsIdSize(msgs: seq[Message]): int =
   msgs.mapIt(it.data.len + it.topic.len).foldl(a + b, 0)
@@ -445,23 +523,29 @@ proc messageOverhead(g: GossipSub, msg: RPCMsg, msgSize: int): int =
         dataAndTopicsIdSize(msg.messages)
     controlSize = msg.control.withValue(control):
       byteSize(control.ihave) + byteSize(control.iwant)
-    do: # no control message
+    do:
       0
 
   msgSize - payloadSize - controlSize
 
-proc rateLimit*(g: GossipSub, peer: PubSubPeer, overhead: int) {.async.} =
+proc rateLimit*(
+    g: GossipSub, peer: PubSubPeer, overhead: int
+) {.async: (raises: [PeerRateLimitError]).} =
   peer.overheadRateLimitOpt.withValue(overheadRateLimit):
     if not overheadRateLimit.tryConsume(overhead):
-      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, overhead
+      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, overhead
       if g.parameters.disconnectPeerAboveRateLimit:
         await g.disconnectPeer(peer)
-        raise newException(PeerRateLimitError, "Peer disconnected because it's above rate limit.")
+        raise newException(
+          PeerRateLimitError, "Peer disconnected because it's above rate limit."
+        )
 
-method rpcHandler*(g: GossipSub,
-                  peer: PubSubPeer,
-                  data: seq[byte]) {.async.} =
+method rpcHandler*(
+    g: GossipSub, peer: PubSubPeer, data: seq[byte]
+) {.async: (raises: [CancelledError, PeerMessageDecodeError, PeerRateLimitError]).} =
   let msgSize = data.len
   var rpcMsg = decodeRpcMsg(data).valueOr:
     debug "failed to decode msg from peer", peer, err = error
@@ -471,36 +555,42 @@ method rpcHandler*(g: GossipSub,
     # TODO evaluate behaviour penalty values
     peer.behaviourPenalty += 0.1
 
-    raise newException(CatchableError, "Peer msg couldn't be decoded")
+    raise newException(PeerMessageDecodeError, "Peer msg couldn't be decoded")
 
   when defined(libp2p_expensive_metrics):
     for m in rpcMsg.messages:
       libp2p_pubsub_received_messages.inc(labelValues = [$peer.peerId, m.topic])
 
-  trace "decoded msg from peer", peer, msg = rpcMsg.shortLog
+  trace "decoded msg from peer", peer, payload = rpcMsg.shortLog
   await rateLimit(g, peer, g.messageOverhead(rpcMsg, msgSize))
 
   # trigger hooks - these may modify the message
   peer.recvObservers(rpcMsg)
 
-  if rpcMsg.ping.len in 1..<64 and peer.pingBudget > 0:
+  if rpcMsg.ping.len in 1 ..< 64 and peer.pingBudget > 0:
     g.send(peer, RPCMsg(pong: rpcMsg.ping), isHighPriority = true)
     peer.pingBudget.dec
 
-  for i in 0..<min(g.topicsHigh, rpcMsg.subscriptions.len):
-    template sub: untyped = rpcMsg.subscriptions[i]
+  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 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,
-                                                                                size = rpcMsg.subscriptions.len,
-                                                                                limit = g.topicsHigh
+    debug "received an rpc message with an oversized amount of subscriptions",
+      peer, size = rpcMsg.subscriptions.len, limit = g.topicsHigh
     peer.behaviourPenalty += 0.1
 
-  for i in 0..<rpcMsg.messages.len():                         # for every message
-    template msg: untyped = rpcMsg.messages[i]
+  for i in 0 ..< rpcMsg.messages.len(): # for every message
+    template msg(): untyped =
+      rpcMsg.messages[i]
+
+    template topic(): string =
+      msg.topic
+
     let msgIdResult = g.msgIdProvider(msg)
 
     if msgIdResult.isErr:
@@ -512,7 +602,6 @@ method rpcHandler*(g: GossipSub,
     let
       msgId = msgIdResult.get
       msgIdSalted = g.salt(msgId)
-      topic = msg.topic
 
     if g.addSeen(msgIdSalted):
       trace "Dropping already-seen message", msgId = shortLog(msgId), peer
@@ -536,7 +625,8 @@ method rpcHandler*(g: GossipSub,
 
     # avoid processing messages we are not interested in
     if topic notin g.topics:
-      debug "Dropping message of topic without subscription", msgId = shortLog(msgId), peer
+      debug "Dropping message of topic without subscription",
+        msgId = shortLog(msgId), peer
       continue
 
     if (msg.signature.len > 0 or g.verifySignature) and not msg.verify():
@@ -566,7 +656,7 @@ method rpcHandler*(g: GossipSub,
     g.handleControl(peer, rpcMsg.control.unsafeGet())
 
   # Now, check subscription to update the meshes if required
-  for i in 0..<min(g.topicsHigh, rpcMsg.subscriptions.len):
+  for i in 0 ..< min(g.topicsHigh, rpcMsg.subscriptions.len):
     let topic = rpcMsg.subscriptions[i].topic
     if topic in g.topics and g.mesh.peers(topic) < g.parameters.dLow:
       # rebalance but don't update metrics here, we do that only in the heartbeat
@@ -589,11 +679,20 @@ method onTopicSubscription*(g: GossipSub, topic: string, subscribed: bool) =
 
     # Remove peers from the mesh since we're no longer both interested
     # in the topic
-    let msg = RPCMsg(control: some(ControlMessage(
-          prune: @[ControlPrune(
-            topicID: topic,
-            peers: g.peerExchangeList(topic),
-            backoff: g.parameters.unsubscribeBackoff.seconds.uint64)])))
+    let msg = RPCMsg(
+      control: some(
+        ControlMessage(
+          prune:
+            @[
+              ControlPrune(
+                topicID: topic,
+                peers: g.peerExchangeList(topic),
+                backoff: g.parameters.unsubscribeBackoff.seconds.uint64,
+              )
+            ]
+        )
+      )
+    )
     g.broadcast(mpeers, msg, isHighPriority = true)
 
     for peer in mpeers:
@@ -604,9 +703,9 @@ method onTopicSubscription*(g: GossipSub, topic: string, subscribed: bool) =
     # Send unsubscribe (in reverse order to sub/graft)
     procCall PubSub(g).onTopicSubscription(topic, subscribed)
 
-method publish*(g: GossipSub,
-                topic: string,
-                data: seq[byte]): Future[int] {.async.} =
+method publish*(
+    g: GossipSub, topic: string, data: seq[byte]
+): Future[int] {.async: (raises: [LPError]).} =
   logScope:
     topic
 
@@ -635,19 +734,23 @@ method publish*(g: GossipSub,
     let maxPeersToFlood =
       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
+          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)
-        max(g.parameters.heartbeatInterval.milliseconds div msToTransmit, g.parameters.dLow)
+        max(
+          g.parameters.heartbeatInterval.milliseconds div msToTransmit,
+          g.parameters.dLow,
+        )
       else:
         int.high() # unlimited
 
     for peer in g.gossipsub.getOrDefault(topic):
-      if peers.len >= maxPeersToFlood: break
+      if peers.len >= maxPeersToFlood:
+        break
 
       if peer.score >= g.parameters.publishThreshold:
         trace "publish: including flood/high score peer", peer
         peers.incl(peer)
-
   elif peers.len < g.parameters.dLow:
     # not subscribed or bad mesh, send to fanout peers
     # when flood-publishing, fanout won't help since all potential peers have
@@ -660,7 +763,8 @@ method publish*(g: GossipSub,
 
     for fanPeer in fanoutPeers:
       peers.incl(fanPeer)
-      if peers.len > g.parameters.d: break
+      if peers.len > g.parameters.d:
+        break
 
     # Attempting to publish counts as fanout send (even if the message
     # ultimately is not sent)
@@ -668,9 +772,10 @@ method publish*(g: GossipSub,
 
   if peers.len == 0:
     let topicPeers = g.gossipsub.getOrDefault(topic).toSeq()
-    debug "No peers for topic, skipping publish",  peersOnTopic = topicPeers.len,
-                                                   connectedPeers = topicPeers.filterIt(it.connected).len,
-                                                   topic
+    debug "No peers for topic, skipping publish",
+      peersOnTopic = topicPeers.len,
+      connectedPeers = topicPeers.filterIt(it.connected).len,
+      topic
     libp2p_gossipsub_failed_publish.inc()
     return 0
 
@@ -682,14 +787,14 @@ method publish*(g: GossipSub,
         inc g.msgSeqno
         Message.init(some(g.peerInfo), data, topic, some(g.msgSeqno), g.sign)
     msgId = g.msgIdProvider(msg).valueOr:
-      trace "Error generating message id, skipping publish",
-        error = error
+      trace "Error generating message id, skipping publish", error = error
       libp2p_gossipsub_failed_publish.inc()
       return 0
 
-  logScope: msgId = shortLog(msgId)
+  logScope:
+    msgId = shortLog(msgId)
 
-  trace "Created new message", msg = shortLog(msg), peers = peers.len
+  trace "Created new message", payload = shortLog(msg), peers = peers.len
 
   if g.addSeen(g.salt(msgId)):
     # If the message was received or published recently, don't re-publish it -
@@ -700,6 +805,9 @@ method publish*(g: GossipSub,
 
   g.mcache.put(msgId, msg)
 
+  if g.parameters.sendIDontWantOnPublish and isLargeMessage(msg, msgId):
+    g.sendIDontWant(msg, msgId, peers)
+
   g.broadcast(peers, RPCMsg(messages: @[msg]), isHighPriority = true)
 
   if g.knownTopics.contains(topic):
@@ -707,10 +815,12 @@ method publish*(g: GossipSub,
   else:
     libp2p_pubsub_messages_published.inc(peers.len.int64, labelValues = ["generic"])
 
-  trace "Published message to peers", peers=peers.len
+  trace "Published message to peers", peers = peers.len
   return peers.len
 
-proc maintainDirectPeer(g: GossipSub, id: PeerId, addrs: seq[MultiAddress]) {.async.} =
+proc maintainDirectPeer(
+    g: GossipSub, id: PeerId, addrs: seq[MultiAddress]
+) {.async: (raises: [CancelledError]).} =
   if id notin g.peers:
     trace "Attempting to dial a direct peer", peer = id
     if g.switch.isConnected(id):
@@ -724,13 +834,15 @@ proc maintainDirectPeer(g: GossipSub, id: PeerId, addrs: seq[MultiAddress]) {.as
       trace "Direct peer dial canceled"
       raise exc
     except CatchableError as exc:
-      debug "Direct peer error dialing", msg = exc.msg
+      debug "Direct peer error dialing", description = exc.msg
 
-proc addDirectPeer*(g: GossipSub, id: PeerId, addrs: seq[MultiAddress]) {.async.} =
+proc addDirectPeer*(
+    g: GossipSub, id: PeerId, addrs: seq[MultiAddress]
+) {.async: (raises: [CancelledError]).} =
   g.parameters.directPeers[id] = addrs
   await g.maintainDirectPeer(id, addrs)
 
-proc maintainDirectPeers(g: GossipSub) {.async.} =
+proc maintainDirectPeers(g: GossipSub) {.async: (raises: [CancelledError]).} =
   heartbeat "GossipSub DirectPeers", 1.minutes:
     for id, addrs in g.parameters.directPeers:
       await g.addDirectPeer(id, addrs)
@@ -764,14 +876,13 @@ method stop*(g: GossipSub): Future[void] {.async: (raises: [], raw: true).} =
     return fut
 
   # stop heartbeat interval
-  g.directPeersLoop.cancel()
-  g.scoringHeartbeatFut.cancel()
-  g.heartbeatFut.cancel()
+  g.directPeersLoop.cancelSoon()
+  g.scoringHeartbeatFut.cancelSoon()
+  g.heartbeatFut.cancelSoon()
   g.heartbeatFut = nil
   fut
 
-method initPubSub*(g: GossipSub)
-  {.raises: [InitializationError].} =
+method initPubSub*(g: GossipSub) {.raises: [InitializationError].} =
   procCall FloodSub(g).initPubSub()
 
   if not g.parameters.explicit:
@@ -790,10 +901,12 @@ method initPubSub*(g: GossipSub)
 method getOrCreatePeer*(
     g: GossipSub,
     peerId: PeerId,
-    protos: seq[string]): PubSubPeer =
-
-  let peer = procCall PubSub(g).getOrCreatePeer(peerId, protos)
+    protosToDial: seq[string],
+    protoNegotiated: string = "",
+): PubSubPeer =
+  let peer = procCall PubSub(g).getOrCreatePeer(peerId, protosToDial, protoNegotiated)
   g.parameters.overheadRateLimit.withValue(overheadRateLimit):
-    peer.overheadRateLimitOpt = Opt.some(TokenBucket.new(overheadRateLimit.bytes, overheadRateLimit.interval))
+    peer.overheadRateLimitOpt =
+      Opt.some(TokenBucket.new(overheadRateLimit.bytes, overheadRateLimit.interval))
   peer.maxNumElementsInNonPriorityQueue = g.parameters.maxNumElementsInNonPriorityQueue
   return peer