chore_: bump go-waku with filter loop fix (#5909)

* chore_: bump go-waku with filter loop fix

* fix_: correct fleet node for staging fleet

* fix_: use shards for lightclient init

---------

Co-authored-by: Richard Ramos <info@richardramos.me>

config/cli/fleet-status.staging.json

@@ -16,7 +16,7 @@
     "RendezvousNodes": [],
     "WakuNodes": [
       "enrtree://AI4W5N5IFEUIHF5LESUAOSMV6TKWF2MB6GU2YK7PU4TYUGUNOCEPW@boot.staging.status.nodes.status.im",
-			"/dns4/boot-01.do-ams3.shards.staging.status.im/tcp/30303/p2p/16Uiu2HAmEqqio4UR1SWqAc7KY19t6qyDvtmyjreZpzUBJvb4u65R",
+			"/dns4/boot-01.do-ams3.status.staging.status.im/tcp/30303/p2p/16Uiu2HAmQE7FXQc6iZHdBzYfw3qCSDa9dLc1wsBJKoP4aZvztq2d",
       "/dns4/boot-01.gc-us-central1-a.status.staging.status.im/tcp/30303/p2p/16Uiu2HAmGAA54bBTE78MYidSy3P7Q9yAWFNTAEReJYD69VRvtL5r",
       "/dns4/boot-01.ac-cn-hongkong-c.status.staging.status.im/tcp/30303/p2p/16Uiu2HAmNTpGnyZ8W1BK2sXEmgSCNWiyDKgRU3NBR2DXST2HzxRU"
     ],

go.mod

@@ -16,7 +16,7 @@ replace github.com/forPelevin/gomoji => github.com/status-im/gomoji v1.1.3-0.202
 
 replace github.com/mutecomm/go-sqlcipher/v4 v4.4.2 => github.com/status-im/go-sqlcipher/v4 v4.5.4-status.3
 
-replace github.com/libp2p/go-libp2p-pubsub v0.11.0 => github.com/waku-org/go-libp2p-pubsub v0.0.0-20240703191659-2cbb09eac9b5
+replace github.com/libp2p/go-libp2p-pubsub v0.12.0 => github.com/waku-org/go-libp2p-pubsub v0.12.0-gowaku.0.20240823143342-b0f2429ca27f
 
 require (
 	github.com/anacrolix/torrent v1.41.0
@@ -28,7 +28,7 @@ require (
 	github.com/ethereum/go-ethereum v1.10.26
 	github.com/forPelevin/gomoji v1.1.2
 	github.com/golang/protobuf v1.5.3
-	github.com/google/uuid v1.4.0
+	github.com/google/uuid v1.6.0
 	github.com/hashicorp/go-version v1.2.0
 	github.com/imdario/mergo v0.3.12
 	github.com/ipfs/go-cid v0.4.1
@@ -36,11 +36,11 @@ require (
 	github.com/keighl/metabolize v0.0.0-20150915210303-97ab655d4034
 	github.com/kilic/bls12-381 v0.0.0-20200607163746-32e1441c8a9f
 	github.com/lib/pq v1.10.4
-	github.com/libp2p/go-libp2p v0.35.2
+	github.com/libp2p/go-libp2p v0.36.2
-	github.com/libp2p/go-libp2p-pubsub v0.11.0
+	github.com/libp2p/go-libp2p-pubsub v0.12.0
 	github.com/lucasb-eyer/go-colorful v1.0.3
 	github.com/mat/besticon v0.0.0-20210314201728-1579f269edb7
-	github.com/multiformats/go-multiaddr v0.12.4
+	github.com/multiformats/go-multiaddr v0.13.0
 	github.com/multiformats/go-multibase v0.2.0
 	github.com/multiformats/go-multihash v0.2.3
 	github.com/multiformats/go-varint v0.0.7
@@ -49,7 +49,7 @@ require (
 	github.com/oliamb/cutter v0.2.2
 	github.com/pborman/uuid v1.2.0
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/client_golang v1.19.1
+	github.com/prometheus/client_golang v1.20.0
 	github.com/russolsen/transit v0.0.0-20180705123435-0794b4c4505a
 	github.com/status-im/doubleratchet v3.0.0+incompatible
 	github.com/status-im/markdown v0.0.0-20240404192634-b7e33c6ac3d4
@@ -66,9 +66,9 @@ require (
 	github.com/xeipuuv/gojsonschema v1.2.0
 	github.com/zenthangplus/goccm v0.0.0-20211005163543-2f2e522aca15
 	go.uber.org/zap v1.27.0
-	golang.org/x/crypto v0.23.0
+	golang.org/x/crypto v0.26.0
 	golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb
-	google.golang.org/protobuf v1.34.1
+	google.golang.org/protobuf v1.34.2
 	gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
 	gopkg.in/go-playground/validator.v9 v9.31.0
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0
@@ -95,17 +95,17 @@ require (
 	github.com/schollz/peerdiscovery v1.7.0
 	github.com/siphiuel/lc-proxy-wrapper v0.0.0-20230516150924-246507cee8c7
 	github.com/urfave/cli/v2 v2.27.2
-	github.com/waku-org/go-waku v0.8.1-0.20240925210455-69ce0c676ce7
+	github.com/waku-org/go-waku v0.8.1-0.20241004054019-0ed94ce0b1cb
 	github.com/wk8/go-ordered-map/v2 v2.1.7
 	github.com/yeqown/go-qrcode/v2 v2.2.1
 	github.com/yeqown/go-qrcode/writer/standard v1.2.1
 	go.uber.org/mock v0.4.0
 	go.uber.org/multierr v1.11.0
-	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842
+	golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa
-	golang.org/x/net v0.25.0
+	golang.org/x/net v0.28.0
-	golang.org/x/text v0.15.0
+	golang.org/x/text v0.17.0
 	golang.org/x/time v0.5.0
-	golang.org/x/tools v0.21.0
+	golang.org/x/tools v0.24.0
 )
 
 require (
@@ -140,7 +140,7 @@ require (
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect
 	github.com/buger/jsonparser v1.1.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/containerd/cgroups v1.1.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
@@ -150,7 +150,7 @@ require (
 	github.com/docker/go-units v0.5.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
-	github.com/elastic/gosigar v0.14.2 // indirect
+	github.com/elastic/gosigar v0.14.3 // indirect
 	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
 	github.com/flynn/noise v1.1.0 // indirect
 	github.com/francoispqt/gojay v1.2.13 // indirect
@@ -159,7 +159,7 @@ require (
 	github.com/go-playground/locales v0.14.0 // indirect
 	github.com/go-playground/universal-translator v0.18.0 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang-jwt/jwt/v4 v4.3.0 // indirect
@@ -169,7 +169,7 @@ require (
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/btree v1.0.1 // indirect
 	github.com/google/gopacket v1.1.19 // indirect
-	github.com/google/pprof v0.0.0-20240207164012-fb44976bdcd5 // indirect
+	github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 // indirect
 	github.com/gorilla/securecookie v1.1.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
@@ -182,8 +182,8 @@ require (
 	github.com/huin/goupnp v1.3.0 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
-	github.com/klauspost/compress v1.17.8 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
 	github.com/koron/go-ssdp v0.0.4 // indirect
 	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
 	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
@@ -201,7 +201,7 @@ require (
 	github.com/mattn/go-colorable v0.1.8 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.13 // indirect
-	github.com/miekg/dns v1.1.58 // indirect
+	github.com/miekg/dns v1.1.62 // indirect
 	github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b // indirect
 	github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc // indirect
 	github.com/minio/sha256-simd v1.0.1 // indirect
@@ -215,33 +215,34 @@ require (
 	github.com/multiformats/go-multiaddr-fmt v0.1.0 // indirect
 	github.com/multiformats/go-multicodec v0.9.0 // indirect
 	github.com/multiformats/go-multistream v0.5.0 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/onsi/ginkgo/v2 v2.15.0 // indirect
+	github.com/onsi/ginkgo/v2 v2.20.0 // indirect
 	github.com/opencontainers/runtime-spec v1.2.0 // indirect
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
-	github.com/pion/datachannel v1.5.6 // indirect
+	github.com/pion/datachannel v1.5.8 // indirect
-	github.com/pion/dtls/v2 v2.2.11 // indirect
+	github.com/pion/dtls/v2 v2.2.12 // indirect
-	github.com/pion/ice/v2 v2.3.25 // indirect
+	github.com/pion/ice/v2 v2.3.34 // indirect
-	github.com/pion/interceptor v0.1.29 // indirect
+	github.com/pion/interceptor v0.1.30 // indirect
 	github.com/pion/logging v0.2.2 // indirect
 	github.com/pion/mdns v0.0.12 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
 	github.com/pion/rtcp v1.2.14 // indirect
-	github.com/pion/rtp v1.8.6 // indirect
+	github.com/pion/rtp v1.8.9 // indirect
-	github.com/pion/sctp v1.8.16 // indirect
+	github.com/pion/sctp v1.8.33 // indirect
 	github.com/pion/sdp/v3 v3.0.9 // indirect
-	github.com/pion/srtp/v2 v2.0.18 // indirect
+	github.com/pion/srtp/v2 v2.0.20 // indirect
 	github.com/pion/stun v0.6.1 // indirect
-	github.com/pion/transport/v2 v2.2.5 // indirect
+	github.com/pion/transport/v2 v2.2.10 // indirect
 	github.com/pion/turn/v2 v2.1.6 // indirect
-	github.com/pion/webrtc/v3 v3.2.40 // indirect
+	github.com/pion/webrtc/v3 v3.3.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.48.0 // indirect
+	github.com/prometheus/common v0.55.0 // indirect
-	github.com/prometheus/procfs v0.12.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/prometheus/tsdb v0.10.0 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
-	github.com/quic-go/quic-go v0.44.0 // indirect
+	github.com/quic-go/quic-go v0.46.0 // indirect
 	github.com/quic-go/webtransport-go v0.8.0 // indirect
 	github.com/raulk/go-watchdog v1.3.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
@@ -267,6 +268,7 @@ require (
 	github.com/waku-org/go-zerokit-rln-arm v0.0.0-20230916171929-1dd9494ff065 // indirect
 	github.com/waku-org/go-zerokit-rln-x86_64 v0.0.0-20230916171518-2a77c3734dd1 // indirect
 	github.com/wk8/go-ordered-map v1.0.0 // indirect
+	github.com/wlynxg/anet v0.0.4 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
 	github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect
@@ -274,15 +276,15 @@ require (
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	go.etcd.io/bbolt v1.3.6 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
-	go.uber.org/dig v1.17.1 // indirect
+	go.uber.org/dig v1.18.0 // indirect
-	go.uber.org/fx v1.22.1 // indirect
+	go.uber.org/fx v1.22.2 // indirect
-	golang.org/x/mod v0.17.0 // indirect
+	golang.org/x/mod v0.20.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sync v0.8.0 // indirect
-	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/sys v0.24.0 // indirect
-	golang.org/x/term v0.20.0 // indirect
+	golang.org/x/term v0.23.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	lukechampine.com/blake3 v1.2.1 // indirect
+	lukechampine.com/blake3 v1.3.0 // indirect
 	modernc.org/libc v1.11.82 // indirect
 	modernc.org/mathutil v1.4.1 // indirect
 	modernc.org/memory v1.0.5 // indirect

go.sum

@@ -476,8 +476,8 @@ github.com/cespare/cp v1.1.1/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
 github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E=
@@ -733,8 +733,8 @@ github.com/edsrzf/mmap-go v0.0.0-20170320065105-0bce6a688712/go.mod h1:YO35OhQPt
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/elastic/gosigar v0.12.0/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
-github.com/elastic/gosigar v0.14.2 h1:Dg80n8cr90OZ7x+bAax/QjoW/XqTI11RmA79ZwIm9/4=
+github.com/elastic/gosigar v0.14.3 h1:xwkKwPia+hSfg9GqrCUKYdId102m9qTJIIr7egmK/uo=
-github.com/elastic/gosigar v0.14.2/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
+github.com/elastic/gosigar v0.14.3/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 github.com/elazarl/go-bindata-assetfs v1.0.0/go.mod h1:v+YaWX3bdea5J/mo8dSETolEo7R71Vk1u8bnjau5yw4=
 github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
 github.com/elliotchance/orderedmap v1.2.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
@@ -837,8 +837,8 @@ github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTg
 github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.2.1/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.3.0 h1:2y3SDp0ZXuc6/cjLSZ+Q3ir+QB9T/iG5yYRXqsagWSY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.0/go.mod h1:YkVgnZu1ZjjL7xTxrfm/LLZBfkhTqSR1ydtm6jTKKwI=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
@@ -874,8 +874,8 @@ github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/me
 github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
 github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
 github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0=
 github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
 github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg=
@@ -1033,8 +1033,8 @@ github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLe
 github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
 github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20240207164012-fb44976bdcd5 h1:E/LAvt58di64hlYjx7AsNS6C/ysHWYo+2qPCZKTQhRo=
+github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8 h1:FKHo8hFI3A+7w0aUQuYXQ+6EN5stWmeY/AZqtM8xk9k=
-github.com/google/pprof v0.0.0-20240207164012-fb44976bdcd5/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik=
+github.com/google/pprof v0.0.0-20240727154555-813a5fbdbec8/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -1043,8 +1043,8 @@ github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
 github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
@@ -1300,13 +1300,13 @@ github.com/klauspost/compress v1.11.13/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdY
 github.com/klauspost/compress v1.13.1/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
 github.com/klauspost/cpuid v0.0.0-20170728055534-ae7887de9fa5/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.6/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
-github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6/go.mod h1:+ZoRqAPRLkC4NPOvfYeR5KNOrY6TD+/sAC3HXPZgDYg=
 github.com/klauspost/pgzip v1.0.2-0.20170402124221-0bf5dcad4ada/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/klauspost/reedsolomon v1.12.1 h1:NhWgum1efX1x58daOBGCFWcxtEhOhXKKl1HAPQUp03Q=
@@ -1333,6 +1333,7 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kshvakov/clickhouse v1.3.5/go.mod h1:DMzX7FxRymoNkVgizH0DWAL8Cur7wHLgx3MUnGwJqpE=
 github.com/ktrysmt/go-bitbucket v0.6.4/go.mod h1:9u0v3hsd2rqCHRIpbir1oP7F58uo5dq19sBYvuMoyQ4=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
@@ -1357,8 +1358,8 @@ github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6
 github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
 github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFGkx3Q3WM=
 github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro=
-github.com/libp2p/go-libp2p v0.35.2 h1:287oHbuplkrLdAF+syB0n/qDgd50AUBtEODqS0e0HDs=
+github.com/libp2p/go-libp2p v0.36.2 h1:BbqRkDaGC3/5xfaJakLV/BrpjlAuYqSB0lRvtzL3B/U=
-github.com/libp2p/go-libp2p v0.35.2/go.mod h1:RKCDNt30IkFipGL0tl8wQW/3zVWEGFUZo8g2gAKxwjU=
+github.com/libp2p/go-libp2p v0.36.2/go.mod h1:XO3joasRE4Eup8yCTTP/+kX+g92mOgRaadk46LmPhHY=
 github.com/libp2p/go-libp2p-asn-util v0.4.1 h1:xqL7++IKD9TBFMgnLPZR6/6iYhawHKHl950SO9L6n94=
 github.com/libp2p/go-libp2p-asn-util v0.4.1/go.mod h1:d/NI6XZ9qxw67b4e+NgpQexCIiFYJjErASrYW4PFDN8=
 github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA=
@@ -1462,8 +1463,8 @@ github.com/meirf/gopart v0.0.0-20180520194036-37e9492a85a8/go.mod h1:Uz8uoD6o+eQ
 github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
-github.com/miekg/dns v1.1.58 h1:ca2Hdkz+cDg/7eNF6V56jjzuZ4aCAE+DbVkILdQWG/4=
+github.com/miekg/dns v1.1.62 h1:cN8OuEF1/x5Rq6Np+h1epln8OiyPWV+lROx9LxcGgIQ=
-github.com/miekg/dns v1.1.58/go.mod h1:Ypv+3b/KadlvW9vJfXOTf300O4UqaHFzFCuHz+rPkBY=
+github.com/miekg/dns v1.1.62/go.mod h1:mvDlcItzm+br7MToIKqkglaGhlFMHJ9DTNNWONWXbNQ=
 github.com/miekg/pkcs11 v1.0.3/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c h1:bzE/A84HN25pxAuk9Eej1Kz9OUelF97nAc82bDquQI8=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c/go.mod h1:0SQS9kMwD2VsyFEB++InYyBJroV/FRmBgcydeSUcJms=
@@ -1530,8 +1531,8 @@ github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU
 github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4=
 github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y=
 github.com/multiformats/go-multiaddr v0.3.2/go.mod h1:lCKNGP1EQ1eZ35Za2wlqnabm9xQkib3fyB+nZXHLag0=
-github.com/multiformats/go-multiaddr v0.12.4 h1:rrKqpY9h+n80EwhhC/kkcunCZZ7URIF8yN1WEUt2Hvc=
+github.com/multiformats/go-multiaddr v0.13.0 h1:BCBzs61E3AGHcYYTv8dqRH43ZfyrqM8RXVPT8t13tLQ=
-github.com/multiformats/go-multiaddr v0.12.4/go.mod h1:sBXrNzucqkFJhvKOiwwLyqamGa/P5EIXNPLovyhQCII=
+github.com/multiformats/go-multiaddr v0.13.0/go.mod h1:sBXrNzucqkFJhvKOiwwLyqamGa/P5EIXNPLovyhQCII=
 github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A=
 github.com/multiformats/go-multiaddr-dns v0.3.1/go.mod h1:G/245BRQ6FJGmryJCrOuTdB37AMA5AMOVuO6NY3JwTk=
 github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/eQsuaL3/CWe167E=
@@ -1555,6 +1556,7 @@ github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXS
 github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=
 github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mutecomm/go-sqlcipher/v4 v4.4.0/go.mod h1:PyN04SaWalavxRGH9E8ZftG6Ju7rsPrGmQRjrEaVpiY=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -1607,8 +1609,8 @@ github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vv
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
-github.com/onsi/ginkgo/v2 v2.15.0 h1:79HwNRBAZHOEwrczrgSOPy+eFTTlIGELKy5as+ClttY=
+github.com/onsi/ginkgo/v2 v2.20.0 h1:PE84V2mHqoT1sglvHc8ZdQtPcwmvvt29WLEEO3xmdZw=
-github.com/onsi/ginkgo/v2 v2.15.0/go.mod h1:HlxMHtYF57y6Dpf+mc5529KKmSq9h2FpCF+/ZkwUxKM=
+github.com/onsi/ginkgo/v2 v2.20.0/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI=
 github.com/onsi/gomega v0.0.0-20151007035656-2152b45fa28a/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
@@ -1623,8 +1625,8 @@ github.com/onsi/gomega v1.11.0/go.mod h1:azGKhqFUon9Vuj0YmTfLSmx0FUwqXYSTl5re8lQ
 github.com/onsi/gomega v1.15.0/go.mod h1:cIuvLEne0aoVhAgh/O6ac0Op8WWw9H6eYCriF+tEHG0=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro=
-github.com/onsi/gomega v1.30.0 h1:hvMK7xYz4D3HapigLTeGdId/NcfQx1VHMJc60ew99+8=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
-github.com/onsi/gomega v1.30.0/go.mod h1:9sxs+SwGrKI0+PWe4Fxa9tFQQBG5xSsSbMXOI8PPpoQ=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
 github.com/opencontainers/go-digest v0.0.0-20170106003457-a6d0ee40d420/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
 github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
@@ -1692,8 +1694,8 @@ github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi
 github.com/pierrec/lz4/v4 v4.1.8/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pion/datachannel v1.4.21/go.mod h1:oiNyP4gHx2DIwRzX/MFyH0Rz/Gz05OgBlayAI2hAWjg=
 github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ=
-github.com/pion/datachannel v1.5.6 h1:1IxKJntfSlYkpUj8LlYRSWpYiTTC02nUrOE8T3DqGeg=
+github.com/pion/datachannel v1.5.8 h1:ph1P1NsGkazkjrvyMfhRBUAWMxugJjq2HfQifaOoSNo=
-github.com/pion/datachannel v1.5.6/go.mod h1:1eKT6Q85pRnr2mHiWHxJwO50SfZRtWHTsNIVb/NfGW4=
+github.com/pion/datachannel v1.5.8/go.mod h1:PgmdpoaNBLX9HNzNClmdki4DYW5JtI7Yibu8QzbL3tI=
 github.com/pion/dtls/v2 v2.0.1/go.mod h1:uMQkz2W0cSqY00xav7WByQ4Hb+18xeQh2oH2fRezr5U=
 github.com/pion/dtls/v2 v2.0.2/go.mod h1:27PEO3MDdaCfo21heT59/vsdmZc0zMt9wQPcSlLu/1I=
 github.com/pion/dtls/v2 v2.0.4/go.mod h1:qAkFscX0ZHoI1E07RfYPoRw3manThveu+mlTDdOxoGI=
@@ -1702,23 +1704,23 @@ github.com/pion/dtls/v2 v2.0.9/go.mod h1:O0Wr7si/Zj5/EBFlDzDd6UtVxx25CE1r7XM7BQK
 github.com/pion/dtls/v2 v2.1.1/go.mod h1:qG3gA7ZPZemBqpEFqRKyURYdKEwFZQCGb7gv9T3ON3Y=
 github.com/pion/dtls/v2 v2.1.2/go.mod h1:o6+WvyLDAlXF7YiPB/RlskRoeK+/JtuaZa5emwQcWus=
 github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
-github.com/pion/dtls/v2 v2.2.11 h1:9U/dpCYl1ySttROPWJgqWKEylUdT0fXp/xst6JwY5Ks=
+github.com/pion/dtls/v2 v2.2.12 h1:KP7H5/c1EiVAAKUmXyCzPiQe5+bCJrpOeKg/L05dunk=
-github.com/pion/dtls/v2 v2.2.11/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE=
+github.com/pion/dtls/v2 v2.2.12/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE=
 github.com/pion/ice v0.7.18/go.mod h1:+Bvnm3nYC6Nnp7VV6glUkuOfToB/AtMRZpOU8ihuf4c=
 github.com/pion/ice/v2 v2.0.15/go.mod h1:ZIiVGevpgAxF/cXiIVmuIUtCb3Xs4gCzCbXB6+nFkSI=
 github.com/pion/ice/v2 v2.1.7/go.mod h1:kV4EODVD5ux2z8XncbLHIOtcXKtYXVgLVCeVqnpoeP0=
 github.com/pion/ice/v2 v2.1.10/go.mod h1:kV4EODVD5ux2z8XncbLHIOtcXKtYXVgLVCeVqnpoeP0=
 github.com/pion/ice/v2 v2.1.12/go.mod h1:ovgYHUmwYLlRvcCLI67PnQ5YGe+upXZbGgllBDG/ktU=
 github.com/pion/ice/v2 v2.1.20/go.mod h1:hEAldRzBhTtAfvlU1V/2/nLCMvveQWFKPNCop+63/Iw=
-github.com/pion/ice/v2 v2.3.25 h1:M5rJA07dqhi3nobJIg+uPtcVjFECTrhcR3n0ns8kDZs=
+github.com/pion/ice/v2 v2.3.34 h1:Ic1ppYCj4tUOcPAp76U6F3fVrlSw8A9JtRXLqw6BbUM=
-github.com/pion/ice/v2 v2.3.25/go.mod h1:KXJJcZK7E8WzrBEYnV4UtqEZsGeWfHxsNqhVcVvgjxw=
+github.com/pion/ice/v2 v2.3.34/go.mod h1:mBF7lnigdqgtB+YHkaY/Y6s6tsyRyo4u4rPGRuOjUBQ=
 github.com/pion/interceptor v0.0.9/go.mod h1:dHgEP5dtxOTf21MObuBAjJeAayPxLUAZjerGH8Xr07c=
 github.com/pion/interceptor v0.0.12/go.mod h1:qzeuWuD/ZXvPqOnxNcnhWfkCZ2e1kwwslicyyPnhoK4=
 github.com/pion/interceptor v0.0.13/go.mod h1:svsW2QoLHLoGLUr4pDoSopGBEWk8FZwlfxId/OKRKzo=
 github.com/pion/interceptor v0.0.15/go.mod h1:pg3J253eGi5bqyKzA74+ej5Y19ez2jkWANVnF+Z9Dfk=
 github.com/pion/interceptor v0.1.7/go.mod h1:Lh3JSl/cbJ2wP8I3ccrjh1K/deRGRn3UlSPuOTiHb6U=
-github.com/pion/interceptor v0.1.29 h1:39fsnlP1U8gw2JzOFWdfCU82vHvhW9o0rZnZF56wF+M=
+github.com/pion/interceptor v0.1.30 h1:au5rlVHsgmxNi+v/mjOPazbW1SHzfx7/hYOEYQnUcxA=
-github.com/pion/interceptor v0.1.29/go.mod h1:ri+LGNjRUc5xUNtDEPzfdkmSqISixVTBF/z/Zms/6T4=
+github.com/pion/interceptor v0.1.30/go.mod h1:RQuKT5HTdkP2Fi0cuOS5G5WNymTjzXaGF75J4k7z2nc=
 github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
 github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
 github.com/pion/mdns v0.0.4/go.mod h1:R1sL0p50l42S5lJs91oNdUL58nm0QHrhxnSegr++qC0=
@@ -1745,16 +1747,15 @@ github.com/pion/rtp v1.7.0/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko
 github.com/pion/rtp v1.7.2/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
 github.com/pion/rtp v1.7.4/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
 github.com/pion/rtp v1.8.3/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pion/rtp v1.8.6 h1:MTmn/b0aWWsAzux2AmP8WGllusBVw4NPYPVFFd7jUPw=
+github.com/pion/rtp v1.8.9 h1:E2HX740TZKaqdcPmf4pw6ZZuG8u5RlMMt+l3dxeu6Wk=
-github.com/pion/rtp v1.8.6/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
+github.com/pion/rtp v1.8.9/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
 github.com/pion/sctp v1.7.10/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
 github.com/pion/sctp v1.7.11/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
 github.com/pion/sctp v1.7.12/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
 github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
 github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
-github.com/pion/sctp v1.8.13/go.mod h1:YKSgO/bO/6aOMP9LCie1DuD7m+GamiK2yIiPM6vH+GA=
+github.com/pion/sctp v1.8.33 h1:dSE4wX6uTJBcNm8+YlMg7lw1wqyKHggsP5uKbdj+NZw=
-github.com/pion/sctp v1.8.16 h1:PKrMs+o9EMLRvFfXq59WFsC+V8mN1wnKzqrv+3D/gYY=
+github.com/pion/sctp v1.8.33/go.mod h1:beTnqSzewI53KWoG3nqB282oDMGrhNxBdb+JZnkCwRM=
-github.com/pion/sctp v1.8.16/go.mod h1:P6PbDVA++OJMrVNg2AL3XtYHV4uD6dvfyOovCgMs0PE=
 github.com/pion/sdp/v2 v2.4.0/go.mod h1:L2LxrOpSTJbAns244vfPChbciR/ReU1KWfG04OpkR7E=
 github.com/pion/sdp/v3 v3.0.4/go.mod h1:bNiSknmJE0HYBprTHXKPQ3+JjacTv5uap92ueJZKsRk=
 github.com/pion/sdp/v3 v3.0.9 h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY=
@@ -1764,8 +1765,8 @@ github.com/pion/srtp v1.5.2/go.mod h1:NiBff/MSxUwMUwx/fRNyD/xGE+dVvf8BOCeXhjCXZ9
 github.com/pion/srtp/v2 v2.0.1/go.mod h1:c8NWHhhkFf/drmHTAblkdu8++lsISEBBdAuiyxgqIsE=
 github.com/pion/srtp/v2 v2.0.2/go.mod h1:VEyLv4CuxrwGY8cxM+Ng3bmVy8ckz/1t6A0q/msKOw0=
 github.com/pion/srtp/v2 v2.0.5/go.mod h1:8k6AJlal740mrZ6WYxc4Dg6qDqqhxoRG2GSjlUhDF0A=
-github.com/pion/srtp/v2 v2.0.18 h1:vKpAXfawO9RtTRKZJbG4y0v1b11NZxQnxRl85kGuUlo=
+github.com/pion/srtp/v2 v2.0.20 h1:HNNny4s+OUmG280ETrCdgFndp4ufx3/uy85EawYEhTk=
-github.com/pion/srtp/v2 v2.0.18/go.mod h1:0KJQjA99A6/a0DOVTu1PhDSw0CXF2jTkqOoMg3ODqdA=
+github.com/pion/srtp/v2 v2.0.20/go.mod h1:0KJQjA99A6/a0DOVTu1PhDSw0CXF2jTkqOoMg3ODqdA=
 github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
 github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
 github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
@@ -1779,14 +1780,13 @@ github.com/pion/transport v0.12.3/go.mod h1:OViWW9SP2peE/HbwBvARicmAVnesphkNkCVZ
 github.com/pion/transport v0.13.0 h1:KWTA5ZrQogizzYwPEciGtHPLwpAjE91FgXnyu+Hv2uY=
 github.com/pion/transport v0.13.0/go.mod h1:yxm9uXpK9bpBBWkITk13cLo1y5/ur5VQpG22ny6EP7g=
 github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
-github.com/pion/transport/v2 v2.2.2/go.mod h1:OJg3ojoBJopjEeECq2yJdXH9YVrUJ1uQ++NjXLOUorc=
 github.com/pion/transport/v2 v2.2.3/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
 github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v2 v2.2.5 h1:iyi25i/21gQck4hfRhomF6SktmUQjRsRW4WJdhfc3Kc=
+github.com/pion/transport/v2 v2.2.10 h1:ucLBLE8nuxiHfvkFKnkDQRYWYfp8ejf4YBOPfaQpw6Q=
-github.com/pion/transport/v2 v2.2.5/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
+github.com/pion/transport/v2 v2.2.10/go.mod h1:sq1kSLWs+cHW9E+2fJP95QudkzbK7wscs8yYgQToO5E=
 github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0=
-github.com/pion/transport/v3 v3.0.2 h1:r+40RJR25S9w3jbA6/5uEPTzcdn7ncyU44RWCbHkLg4=
+github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
-github.com/pion/transport/v3 v3.0.2/go.mod h1:nIToODoOlb5If2jF9y2Igfx3PFYWfuXi37m0IlWa/D0=
+github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
 github.com/pion/turn/v2 v2.0.4/go.mod h1:1812p4DcGVbYVBTiraUmP50XoKye++AMkbfp+N27mog=
 github.com/pion/turn/v2 v2.0.5/go.mod h1:APg43CFyt/14Uy7heYUOGWdkem/Wu4PhCO/bjyrTqMw=
 github.com/pion/turn/v2 v2.0.6/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
@@ -1800,8 +1800,8 @@ github.com/pion/webrtc/v3 v3.0.11/go.mod h1:WEvXneGTeqNmiR59v5jTsxMc4yXQyOQcRsrd
 github.com/pion/webrtc/v3 v3.0.27/go.mod h1:QpLDmsU5a/a05n230gRtxZRvfHhFzn9ukGUL2x4G5ic=
 github.com/pion/webrtc/v3 v3.0.32/go.mod h1:wX3V5dQQUGCifhT1mYftC2kCrDQX6ZJ3B7Yad0R9JK0=
 github.com/pion/webrtc/v3 v3.1.24-0.20220208053747-94262c1b2b38/go.mod h1:L5S/oAhL0Fzt/rnftVQRrP80/j5jygY7XRZzWwFx6P4=
-github.com/pion/webrtc/v3 v3.2.40 h1:Wtfi6AZMQg+624cvCXUuSmrKWepSB7zfgYDOYqsSOVU=
+github.com/pion/webrtc/v3 v3.3.0 h1:Rf4u6n6U5t5sUxhYPQk/samzU/oDv7jk6BA5hyO2F9I=
-github.com/pion/webrtc/v3 v3.2.40/go.mod h1:M1RAe3TNTD1tzyvqHrbVODfwdPGSXOUo/OgpoGGJqFY=
+github.com/pion/webrtc/v3 v3.3.0/go.mod h1:hVmrDJvwhEertRWObeb1xzulzHGeVUoPlWvxdGzcfU0=
 github.com/pkg/browser v0.0.0-20210706143420-7d21f8c997e2/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
 github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -1829,8 +1829,8 @@ github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
+github.com/prometheus/client_golang v1.20.0 h1:jBzTZ7B099Rg24tny+qngoynol8LtVYlA2bqx3vEloI=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
+github.com/prometheus/client_golang v1.20.0/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
 github.com/prometheus/client_model v0.0.0-20171117100541-99fa1f4be8e5/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
@@ -1854,8 +1854,8 @@ github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16
 github.com/prometheus/common v0.18.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
 github.com/prometheus/common v0.30.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
+github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
+github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
 github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
@@ -1873,15 +1873,15 @@ github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.7.2/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/prometheus/tsdb v0.10.0 h1:If5rVCMTp6W2SiRAQFlbpJNgVlgMEd+U2GZckwK38ic=
 github.com/prometheus/tsdb v0.10.0/go.mod h1:oi49uRhEe9dPUTlS3JRZOwJuVi6tmh10QSgwXEyGCt4=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
-github.com/quic-go/quic-go v0.44.0 h1:So5wOr7jyO4vzL2sd8/pD9Kesciv91zSk8BoFngItQ0=
+github.com/quic-go/quic-go v0.46.0 h1:uuwLClEEyk1DNvchH8uCByQVjo3yKL9opKulExNDs7Y=
-github.com/quic-go/quic-go v0.44.0/go.mod h1:z4cx/9Ny9UtGITIPzmPTXh1ULfOyWh4qGQlpnPcWmek=
+github.com/quic-go/quic-go v0.46.0/go.mod h1:1dLehS7TIR64+vxGR70GDcatWTOtMX2PUtnKsjbTurI=
 github.com/quic-go/webtransport-go v0.8.0 h1:HxSrwun11U+LlmwpgM1kEqIqH90IT4N8auv/cD7QFJg=
 github.com/quic-go/webtransport-go v0.8.0/go.mod h1:N99tjprW432Ut5ONql/aUhSLT0YVSlwHohQsuac9WaM=
 github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk=
@@ -2132,12 +2132,12 @@ github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1
 github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
 github.com/waku-org/go-discover v0.0.0-20240506173252-4912704efdc5 h1:4K3IS97JryAEV8pRXB//qPcg+8bPXl/O+AOLt3FeCKc=
 github.com/waku-org/go-discover v0.0.0-20240506173252-4912704efdc5/go.mod h1:eBHgM6T4EG0RZzxpxKy+rGz/6Dw2Nd8DWxS0lm9ESDw=
-github.com/waku-org/go-libp2p-pubsub v0.0.0-20240703191659-2cbb09eac9b5 h1:9u16Et17jSGWM3mQhlIOZYiG+O+rlX5BsrBumw5flxk=
+github.com/waku-org/go-libp2p-pubsub v0.12.0-gowaku.0.20240823143342-b0f2429ca27f h1:4dQcthDPhxQIY96BFm6Ab2m57+I/z9+FgaYnIER6IfM=
-github.com/waku-org/go-libp2p-pubsub v0.0.0-20240703191659-2cbb09eac9b5/go.mod h1:QEb+hEV9WL9wCiUAnpY29FZR6W3zK8qYlaml8R4q6gQ=
+github.com/waku-org/go-libp2p-pubsub v0.12.0-gowaku.0.20240823143342-b0f2429ca27f/go.mod h1:Oi0zw9aw8/Y5GC99zt+Ef2gYAl+0nZlwdJonDyOz/sE=
 github.com/waku-org/go-libp2p-rendezvous v0.0.0-20240110193335-a67d1cc760a0 h1:R4YYx2QamhBRl/moIxkDCNW+OP7AHbyWLBygDc/xIMo=
 github.com/waku-org/go-libp2p-rendezvous v0.0.0-20240110193335-a67d1cc760a0/go.mod h1:EhZP9fee0DYjKH/IOQvoNSy1tSHp2iZadsHGphcAJgY=
-github.com/waku-org/go-waku v0.8.1-0.20240925210455-69ce0c676ce7 h1:L4fJfQvzmZi7C9oPz8Yr55/ZIpj345YIfciVt+VkO+4=
+github.com/waku-org/go-waku v0.8.1-0.20241004054019-0ed94ce0b1cb h1:E3J49PH9iXpjaOOI/VrEX/VhSk3obKjxVehGEDzZgXI=
-github.com/waku-org/go-waku v0.8.1-0.20240925210455-69ce0c676ce7/go.mod h1:VNbVmh5UYg3vIvhGV4hCw8QEykq3RScDACo2Y2dIFfg=
+github.com/waku-org/go-waku v0.8.1-0.20241004054019-0ed94ce0b1cb/go.mod h1:1BRnyg2mQ2aBNLTBaPq6vEvobzywGykPOhGQFbHGf74=
 github.com/waku-org/go-zerokit-rln v0.1.14-0.20240102145250-fa738c0bdf59 h1:jisj+OCI6QydLtFq3Pyhu49wl9ytPN7oAHjMfepHDrA=
 github.com/waku-org/go-zerokit-rln v0.1.14-0.20240102145250-fa738c0bdf59/go.mod h1:1PdBdPzyTaKt3VnpAHk3zj+r9dXPFOr3IHZP9nFle6E=
 github.com/waku-org/go-zerokit-rln-apple v0.0.0-20230916172309-ee0ee61dde2b h1:KgZVhsLkxsj5gb/FfndSCQu6VYwALrCOgYI3poR95yE=
@@ -2163,6 +2163,9 @@ github.com/wk8/go-ordered-map v1.0.0 h1:BV7z+2PaK8LTSd/mWgY12HyMAo5CEgkHqbkVq2th
 github.com/wk8/go-ordered-map v1.0.0/go.mod h1:9ZIbRunKbuvfPKyBP1SIKLcXNlv74YCOZ3t3VTS6gRk=
 github.com/wk8/go-ordered-map/v2 v2.1.7 h1:aUZ1xBMdbvY8wnNt77qqo4nyT3y0pX4Usat48Vm+hik=
 github.com/wk8/go-ordered-map/v2 v2.1.7/go.mod h1:9Xvgm2mV2kSq2SAm0Y608tBmu8akTzI7c2bz7/G7ZN4=
+github.com/wlynxg/anet v0.0.3/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+github.com/wlynxg/anet v0.0.4 h1:0de1OFQxnNqAu+x2FAKKCVIrnfGKQbs7FQz++tB0+Uw=
+github.com/wlynxg/anet v0.0.4/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
 github.com/xanzy/go-gitlab v0.15.0/go.mod h1:8zdQa/ri1dfn8eS3Ir1SyfvOKlw7WBJ8DVThkpGiXrs=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
 github.com/xdg-go/scram v1.0.2/go.mod h1:1WAq6h33pAW+iRreB34OORO2Nf7qel3VV3fjBj+hCSs=
@@ -2259,10 +2262,10 @@ go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
-go.uber.org/dig v1.17.1 h1:Tga8Lz8PcYNsWsyHMZ1Vm0OQOUaJNDyvPImgbAu9YSc=
+go.uber.org/dig v1.18.0 h1:imUL1UiY0Mg4bqbFfsRQO5G4CGRBec/ZujWTvSVp3pw=
-go.uber.org/dig v1.17.1/go.mod h1:Us0rSJiThwCv2GteUN0Q7OKvU7n5J4dxZ9JKUXozFdE=
+go.uber.org/dig v1.18.0/go.mod h1:Us0rSJiThwCv2GteUN0Q7OKvU7n5J4dxZ9JKUXozFdE=
-go.uber.org/fx v1.22.1 h1:nvvln7mwyT5s1q201YE29V/BFrGor6vMiDNpU/78Mys=
+go.uber.org/fx v1.22.2 h1:iPW+OPxv0G8w75OemJ1RAnTUrF55zOJlXlo1TbJ0Buw=
-go.uber.org/fx v1.22.1/go.mod h1:HT2M7d7RHo+ebKGh9NRcrsrHHfpZ60nW3QRubMRfv48=
+go.uber.org/fx v1.22.2/go.mod h1:o/D9n+2mLP6v1EG+qsdT1O8wKopYAsqZasju97SDFCU=
 go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
@@ -2332,13 +2335,10 @@ golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220331220935-ae2d96664a29/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
 golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
 golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
-golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -2353,8 +2353,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
+golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa h1:ELnwvuAXPNtPk1TJRuGkI9fDTwym6AYBu0qzT8AcHdI=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
+golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa/go.mod h1:akd2r19cwCdwSwWeIdzYQGa/EZZyqcOdwWiwj5L5eKQ=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -2393,8 +2393,8 @@ golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.20.0 h1:utOm6MM3R3dnawAiJgn0y+xvuYRsm1RKM/4giyfDgV0=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180524181706-dfa909b99c79/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -2489,13 +2489,10 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.13.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
 golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
-golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/oauth2 v0.0.0-20180227000427-d7d64896b5ff/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -2532,8 +2529,8 @@ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180224232135-f6cff0780e54/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -2695,13 +2692,10 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
@@ -2711,13 +2705,10 @@ golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
 golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
-golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
-golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -2730,11 +2721,10 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -2835,8 +2825,8 @@ golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.21.0 h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=
+golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24=
-golang.org/x/tools v0.21.0/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ=
 golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -3033,8 +3023,8 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -3145,8 +3135,8 @@ k8s.io/kubernetes v1.13.0/go.mod h1:ocZa8+6APFNC2tX1DZASIbocyYT5jHzqFVsY5aoB7Jk=
 k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
 k8s.io/utils v0.0.0-20210819203725-bdf08cb9a70a/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
 k8s.io/utils v0.0.0-20210930125809-cb0fa318a74b/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
-lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI=
+lukechampine.com/blake3 v1.3.0 h1:sJ3XhFINmHSrYCgl958hscfIa3bw8x4DqMP3u1YvoYE=
-lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k=
+lukechampine.com/blake3 v1.3.0/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k=
 lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
 modernc.org/b v1.0.0/go.mod h1:uZWcZfRj1BpYzfN9JTerzlNUnnPsV9O2ZA8JsRcubNg=
 modernc.org/cc/v3 v3.31.5-0.20210308123301-7a3e9dab9009/go.mod h1:0R6jl1aZlIl2avnYfbfHBS1QB6/f+16mihBObaBC878=

vendor/github.com/cespare/xxhash/v2/README.md

@@ -70,3 +70,5 @@ benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
 - [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
 - [FreeCache](https://github.com/coocood/freecache)
 - [FastCache](https://github.com/VictoriaMetrics/fastcache)
+- [Ristretto](https://github.com/dgraph-io/ristretto)
+- [Badger](https://github.com/dgraph-io/badger)

vendor/github.com/cespare/xxhash/v2/xxhash.go

@@ -19,10 +19,13 @@ const (
 // Store the primes in an array as well.
 //
 // The consts are used when possible in Go code to avoid MOVs but we need a
-// contiguous array of the assembly code.
+// contiguous array for the assembly code.
 var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
 
 // Digest implements hash.Hash64.
+//
+// Note that a zero-valued Digest is not ready to receive writes.
+// Call Reset or create a Digest using New before calling other methods.
 type Digest struct {
 	v1    uint64
 	v2    uint64
@@ -33,19 +36,31 @@ type Digest struct {
 	n     int // how much of mem is used
 }
 
-// New creates a new Digest that computes the 64-bit xxHash algorithm.
+// New creates a new Digest with a zero seed.
 func New() *Digest {
+	return NewWithSeed(0)
+}
+
+// NewWithSeed creates a new Digest with the given seed.
+func NewWithSeed(seed uint64) *Digest {
 	var d Digest
-	d.Reset()
+	d.ResetWithSeed(seed)
 	return &d
 }
 
 // Reset clears the Digest's state so that it can be reused.
+// It uses a seed value of zero.
 func (d *Digest) Reset() {
-	d.v1 = primes[0] + prime2
+	d.ResetWithSeed(0)
-	d.v2 = prime2
+}
-	d.v3 = 0
+
-	d.v4 = -primes[0]
+// ResetWithSeed clears the Digest's state so that it can be reused.
+// It uses the given seed to initialize the state.
+func (d *Digest) ResetWithSeed(seed uint64) {
+	d.v1 = seed + prime1 + prime2
+	d.v2 = seed + prime2
+	d.v3 = seed
+	d.v4 = seed - prime1
 	d.total = 0
 	d.n = 0
 }

vendor/github.com/cespare/xxhash/v2/xxhash_asm.go

@@ -6,7 +6,7 @@
 
 package xxhash
 
-// Sum64 computes the 64-bit xxHash digest of b.
+// Sum64 computes the 64-bit xxHash digest of b with a zero seed.
 //
 //go:noescape
 func Sum64(b []byte) uint64

vendor/github.com/cespare/xxhash/v2/xxhash_other.go

@@ -3,7 +3,7 @@
 
 package xxhash
 
-// Sum64 computes the 64-bit xxHash digest of b.
+// Sum64 computes the 64-bit xxHash digest of b with a zero seed.
 func Sum64(b []byte) uint64 {
 	// A simpler version would be
 	//   d := New()

vendor/github.com/cespare/xxhash/v2/xxhash_safe.go

@@ -5,7 +5,7 @@
 
 package xxhash
 
-// Sum64String computes the 64-bit xxHash digest of s.
+// Sum64String computes the 64-bit xxHash digest of s with a zero seed.
 func Sum64String(s string) uint64 {
 	return Sum64([]byte(s))
 }

vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go

@@ -33,7 +33,7 @@ import (
 //
 // See https://github.com/golang/go/issues/42739 for discussion.
 
-// Sum64String computes the 64-bit xxHash digest of s.
+// Sum64String computes the 64-bit xxHash digest of s with a zero seed.
 // It may be faster than Sum64([]byte(s)) by avoiding a copy.
 func Sum64String(s string) uint64 {
 	b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))

vendor/github.com/elastic/gosigar/CHANGELOG.md

@@ -15,6 +15,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Deprecated
 
+## [0.14.3]
+
+### Fixed
+
+- darwin: Fix checkptr error in `(*Mem).Get` for Go 1.22.
+
 ## [0.14.2]
 
 ### Fixed
@@ -196,7 +202,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed `ProcStatus.PPID` value is wrong on Windows. [#55](https://github.com/elastic/gosigar/pull/55)
 - Fixed `ProcStatus.Username` error on Windows XP [#56](https://github.com/elastic/gosigar/pull/56)
 
-[Unreleased]: https://github.com/elastic/gosigar/compare/v0.14.1...HEAD
+[Unreleased]: https://github.com/elastic/gosigar/compare/v0.14.3...HEAD
+[0.14.3]: https://github.com/elastic/gosigar/releases/tag/v0.14.3
+[0.14.2]: https://github.com/elastic/gosigar/releases/tag/v0.14.2
 [0.14.1]: https://github.com/elastic/gosigar/releases/tag/v0.14.1
 [0.14.0]: https://github.com/elastic/gosigar/releases/tag/v0.14.0
 [0.13.0]: https://github.com/elastic/gosigar/releases/tag/v0.13.0

vendor/github.com/elastic/gosigar/README.md

@@ -1,4 +1,4 @@
-# Go sigar [![Build Status](https://beats-ci.elastic.co/job/Beats/job/gosigar/job/master/badge/icon)](https://beats-ci.elastic.co/job/Beats/job/gosigar/job/master/)
+# Go sigar [![ci](https://github.com/elastic/gosigar/actions/workflows/ci.yml/badge.svg)](https://github.com/elastic/gosigar/actions/workflows/ci.yml)
 
 
 ## Overview

vendor/github.com/elastic/gosigar/sigar_common_darwin.go

@@ -26,6 +26,8 @@ import (
 	"syscall"
 	"time"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 // Get fetches LoadAverage data
@@ -471,21 +473,23 @@ func vmInfo(vmstat *C.vm_statistics_data_t) error {
 
 // generic Sysctl buffer unmarshalling
 func sysctlbyname(name string, data interface{}) (err error) {
-	val, err := syscall.Sysctl(name)
-	if err != nil {
-		return err
-	}
-
-	buf := []byte(val)
-
 	switch v := data.(type) {
 	case *uint64:
-		*v = *(*uint64)(unsafe.Pointer(&buf[0]))
+		res, err := unix.SysctlUint64(name)
-		return
+		if err != nil {
-	}
+			return err
+		}
+		*v = res
+		return nil
+	default:
+		val, err := syscall.Sysctl(name)
+		if err != nil {
+			return err
+		}
 
-	bbuf := bytes.NewBuffer([]byte(val))
+		bbuf := bytes.NewBuffer([]byte(val))
-	return binary.Read(bbuf, binary.LittleEndian, data)
+		return binary.Read(bbuf, binary.LittleEndian, data)
+	}
 }
 
 func taskInfo(pid int, info *C.struct_proc_taskallinfo) error {

vendor/github.com/go-task/slim-sprig/v3/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## Release 3.2.3 (2022-11-29)
+
+### Changed
+
+- Updated docs (thanks @book987 @aJetHorn @neelayu @pellizzetti @apricote @SaigyoujiYuyuko233 @AlekSi)
+- #348: Updated huandu/xstrings which fixed a snake case bug (thanks @yxxhero)
+- #353: Updated masterminds/semver which included bug fixes
+- #354: Updated golang.org/x/crypto which included bug fixes
+
+## Release 3.2.2 (2021-02-04)
+
+This is a re-release of 3.2.1 to satisfy something with the Go module system.
+
+## Release 3.2.1 (2021-02-04)
+
+### Changed
+
+- Upgraded `Masterminds/goutils` to `v1.1.1`. see the [Security Advisory](https://github.com/Masterminds/goutils/security/advisories/GHSA-xg2h-wx96-xgxr)
+
 ## Release 3.2.0 (2020-12-14)
 
 ### Added

vendor/github.com/go-task/slim-sprig/v3/README.md

@@ -1,4 +1,4 @@
-# Slim-Sprig: Template functions for Go templates [![GoDoc](https://godoc.org/github.com/go-task/slim-sprig?status.svg)](https://godoc.org/github.com/go-task/slim-sprig) [![Go Report Card](https://goreportcard.com/badge/github.com/go-task/slim-sprig)](https://goreportcard.com/report/github.com/go-task/slim-sprig)
+# Slim-Sprig: Template functions for Go templates [![Go Reference](https://pkg.go.dev/badge/github.com/go-task/slim-sprig/v3.svg)](https://pkg.go.dev/github.com/go-task/slim-sprig/v3)
 
 Slim-Sprig is a fork of [Sprig](https://github.com/Masterminds/sprig), but with
 all functions that depend on external (non standard library) or crypto packages

vendor/github.com/go-task/slim-sprig/v3/Taskfile.yml

@@ -1,6 +1,6 @@
 # https://taskfile.dev
 
-version: '2'
+version: '3'
 
 tasks:
   default:

vendor/github.com/google/pprof/profile/profile.go

@@ -847,7 +847,7 @@ func (p *Profile) HasFileLines() bool {
 // "[vdso]", [vsyscall]" and some others, see the code.
 func (m *Mapping) Unsymbolizable() bool {
 	name := filepath.Base(m.File)
-	return strings.HasPrefix(name, "[") || strings.HasPrefix(name, "linux-vdso") || strings.HasPrefix(m.File, "/dev/dri/")
+	return strings.HasPrefix(name, "[") || strings.HasPrefix(name, "linux-vdso") || strings.HasPrefix(m.File, "/dev/dri/") || m.File == "//anon"
 }
 
 // Copy makes a fully independent copy of a profile.

vendor/github.com/google/uuid/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.6.0](https://github.com/google/uuid/compare/v1.5.0...v1.6.0) (2024-01-16)
+
+
+### Features
+
+* add Max UUID constant ([#149](https://github.com/google/uuid/issues/149)) ([c58770e](https://github.com/google/uuid/commit/c58770eb495f55fe2ced6284f93c5158a62e53e3))
+
+
+### Bug Fixes
+
+* fix typo in version 7 uuid documentation ([#153](https://github.com/google/uuid/issues/153)) ([016b199](https://github.com/google/uuid/commit/016b199544692f745ffc8867b914129ecb47ef06))
+* Monotonicity in UUIDv7 ([#150](https://github.com/google/uuid/issues/150)) ([a2b2b32](https://github.com/google/uuid/commit/a2b2b32373ff0b1a312b7fdf6d38a977099698a6))
+
+## [1.5.0](https://github.com/google/uuid/compare/v1.4.0...v1.5.0) (2023-12-12)
+
+
+### Features
+
+* Validate UUID without creating new UUID ([#141](https://github.com/google/uuid/issues/141)) ([9ee7366](https://github.com/google/uuid/commit/9ee7366e66c9ad96bab89139418a713dc584ae29))
+
 ## [1.4.0](https://github.com/google/uuid/compare/v1.3.1...v1.4.0) (2023-10-26)
 
 

vendor/github.com/google/uuid/hash.go

@@ -17,6 +17,12 @@ var (
 	NameSpaceOID  = Must(Parse("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
 	NameSpaceX500 = Must(Parse("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
 	Nil           UUID // empty UUID, all zeros
+
+	// The Max UUID is special form of UUID that is specified to have all 128 bits set to 1.
+	Max = UUID{
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	}
 )
 
 // NewHash returns a new UUID derived from the hash of space concatenated with

vendor/github.com/google/uuid/time.go

@@ -108,12 +108,23 @@ func setClockSequence(seq int) {
 }
 
 // Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
-// uuid.  The time is only defined for version 1 and 2 UUIDs.
+// uuid.  The time is only defined for version 1, 2, 6 and 7 UUIDs.
 func (uuid UUID) Time() Time {
-	time := int64(binary.BigEndian.Uint32(uuid[0:4]))
+	var t Time
-	time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
+	switch uuid.Version() {
-	time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
+	case 6:
-	return Time(time)
+		time := binary.BigEndian.Uint64(uuid[:8]) // Ignore uuid[6] version b0110
+		t = Time(time)
+	case 7:
+		time := binary.BigEndian.Uint64(uuid[:8])
+		t = Time((time>>16)*10000 + g1582ns100)
+	default: // forward compatible
+		time := int64(binary.BigEndian.Uint32(uuid[0:4]))
+		time |= int64(binary.BigEndian.Uint16(uuid[4:6])) << 32
+		time |= int64(binary.BigEndian.Uint16(uuid[6:8])&0xfff) << 48
+		t = Time(time)
+	}
+	return t
 }
 
 // ClockSequence returns the clock sequence encoded in uuid.

vendor/github.com/google/uuid/uuid.go

@@ -186,6 +186,59 @@ func Must(uuid UUID, err error) UUID {
 	return uuid
 }
 
+// Validate returns an error if s is not a properly formatted UUID in one of the following formats:
+//   xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+//   urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+//   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+//   {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
+// It returns an error if the format is invalid, otherwise nil.
+func Validate(s string) error {
+	switch len(s) {
+	// Standard UUID format
+	case 36:
+
+	// UUID with "urn:uuid:" prefix
+	case 36 + 9:
+		if !strings.EqualFold(s[:9], "urn:uuid:") {
+			return fmt.Errorf("invalid urn prefix: %q", s[:9])
+		}
+		s = s[9:]
+
+	// UUID enclosed in braces
+	case 36 + 2:
+		if s[0] != '{' || s[len(s)-1] != '}' {
+			return fmt.Errorf("invalid bracketed UUID format")
+		}
+		s = s[1 : len(s)-1]
+
+	// UUID without hyphens
+	case 32:
+		for i := 0; i < len(s); i += 2 {
+			_, ok := xtob(s[i], s[i+1])
+			if !ok {
+				return errors.New("invalid UUID format")
+			}
+		}
+
+	default:
+		return invalidLengthError{len(s)}
+	}
+
+	// Check for standard UUID format
+	if len(s) == 36 {
+		if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+			return errors.New("invalid UUID format")
+		}
+		for _, x := range []int{0, 2, 4, 6, 9, 11, 14, 16, 19, 21, 24, 26, 28, 30, 32, 34} {
+			if _, ok := xtob(s[x], s[x+1]); !ok {
+				return errors.New("invalid UUID format")
+			}
+		}
+	}
+
+	return nil
+}
+
 // String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 // , or "" if uuid is invalid.
 func (uuid UUID) String() string {

vendor/github.com/google/uuid/version6.go

@@ -0,0 +1,56 @@
+// Copyright 2023 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import "encoding/binary"
+
+// UUID version 6 is a field-compatible version of UUIDv1, reordered for improved DB locality.
+// It is expected that UUIDv6 will primarily be used in contexts where there are existing v1 UUIDs.
+// Systems that do not involve legacy UUIDv1 SHOULD consider using UUIDv7 instead.
+//
+// see https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-03#uuidv6
+//
+// NewV6 returns a Version 6 UUID based on the current NodeID and clock
+// sequence, and the current time. If the NodeID has not been set by SetNodeID
+// or SetNodeInterface then it will be set automatically. If the NodeID cannot
+// be set NewV6 set NodeID is random bits automatically . If clock sequence has not been set by
+// SetClockSequence then it will be set automatically. If GetTime fails to
+// return the current NewV6 returns Nil and an error.
+func NewV6() (UUID, error) {
+	var uuid UUID
+	now, seq, err := GetTime()
+	if err != nil {
+		return uuid, err
+	}
+
+	/*
+	    0                   1                   2                   3
+	    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |                           time_high                           |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |           time_mid            |      time_low_and_version     |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |clk_seq_hi_res |  clk_seq_low  |         node (0-1)            |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	   |                         node (2-5)                            |
+	   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	*/
+
+	binary.BigEndian.PutUint64(uuid[0:], uint64(now))
+	binary.BigEndian.PutUint16(uuid[8:], seq)
+
+	uuid[6] = 0x60 | (uuid[6] & 0x0F)
+	uuid[8] = 0x80 | (uuid[8] & 0x3F)
+
+	nodeMu.Lock()
+	if nodeID == zeroID {
+		setNodeInterface("")
+	}
+	copy(uuid[10:], nodeID[:])
+	nodeMu.Unlock()
+
+	return uuid, nil
+}

vendor/github.com/google/uuid/version7.go

@@ -0,0 +1,104 @@
+// Copyright 2023 Google Inc.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package uuid
+
+import (
+	"io"
+)
+
+// UUID version 7 features a time-ordered value field derived from the widely
+// implemented and well known Unix Epoch timestamp source,
+// the number of milliseconds seconds since midnight 1 Jan 1970 UTC, leap seconds excluded.
+// As well as improved entropy characteristics over versions 1 or 6.
+//
+// see https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-03#name-uuid-version-7
+//
+// Implementations SHOULD utilize UUID version 7 over UUID version 1 and 6 if possible.
+//
+// NewV7 returns a Version 7 UUID based on the current time(Unix Epoch).
+// Uses the randomness pool if it was enabled with EnableRandPool.
+// On error, NewV7 returns Nil and an error
+func NewV7() (UUID, error) {
+	uuid, err := NewRandom()
+	if err != nil {
+		return uuid, err
+	}
+	makeV7(uuid[:])
+	return uuid, nil
+}
+
+// NewV7FromReader returns a Version 7 UUID based on the current time(Unix Epoch).
+// it use NewRandomFromReader fill random bits.
+// On error, NewV7FromReader returns Nil and an error.
+func NewV7FromReader(r io.Reader) (UUID, error) {
+	uuid, err := NewRandomFromReader(r)
+	if err != nil {
+		return uuid, err
+	}
+
+	makeV7(uuid[:])
+	return uuid, nil
+}
+
+// makeV7 fill 48 bits time (uuid[0] - uuid[5]), set version b0111 (uuid[6])
+// uuid[8] already has the right version number (Variant is 10)
+// see function NewV7 and NewV7FromReader
+func makeV7(uuid []byte) {
+	/*
+		 0                   1                   2                   3
+		 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		|                           unix_ts_ms                          |
+		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		|          unix_ts_ms           |  ver  |  rand_a (12 bit seq)  |
+		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		|var|                        rand_b                             |
+		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		|                            rand_b                             |
+		+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+	*/
+	_ = uuid[15] // bounds check
+
+	t, s := getV7Time()
+
+	uuid[0] = byte(t >> 40)
+	uuid[1] = byte(t >> 32)
+	uuid[2] = byte(t >> 24)
+	uuid[3] = byte(t >> 16)
+	uuid[4] = byte(t >> 8)
+	uuid[5] = byte(t)
+
+	uuid[6] = 0x70 | (0x0F & byte(s>>8))
+	uuid[7] = byte(s)
+}
+
+// lastV7time is the last time we returned stored as:
+//
+//	52 bits of time in milliseconds since epoch
+//	12 bits of (fractional nanoseconds) >> 8
+var lastV7time int64
+
+const nanoPerMilli = 1000000
+
+// getV7Time returns the time in milliseconds and nanoseconds / 256.
+// The returned (milli << 12 + seq) is guarenteed to be greater than
+// (milli << 12 + seq) returned by any previous call to getV7Time.
+func getV7Time() (milli, seq int64) {
+	timeMu.Lock()
+	defer timeMu.Unlock()
+
+	nano := timeNow().UnixNano()
+	milli = nano / nanoPerMilli
+	// Sequence number is between 0 and 3906 (nanoPerMilli>>8)
+	seq = (nano - milli*nanoPerMilli) >> 8
+	now := milli<<12 + seq
+	if now <= lastV7time {
+		now = lastV7time + 1
+		milli = now >> 12
+		seq = now & 0xfff
+	}
+	lastV7time = now
+	return milli, seq
+}

vendor/github.com/klauspost/compress/zstd/dict.go

@@ -273,6 +273,9 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 		enc.Encode(&block, b)
 		addValues(&remain, block.literals)
 		litTotal += len(block.literals)
+		if len(block.sequences) == 0 {
+			continue
+		}
 		seqs += len(block.sequences)
 		block.genCodes()
 		addHist(&ll, block.coders.llEnc.Histogram())
@@ -286,6 +289,9 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 			if offset == 0 {
 				continue
 			}
+			if int(offset) >= len(o.History) {
+				continue
+			}
 			if offset > 3 {
 				newOffsets[offset-3]++
 			} else {
@@ -336,6 +342,9 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 	if seqs/nUsed < 512 {
 		// Use 512 as minimum.
 		nUsed = seqs / 512
+		if nUsed == 0 {
+			nUsed = 1
+		}
 	}
 	copyHist := func(dst *fseEncoder, src *[256]int) ([]byte, error) {
 		hist := dst.Histogram()
@@ -358,6 +367,28 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 			fakeLength += v
 			hist[i] = uint32(v)
 		}
+
+		// Ensure we aren't trying to represent RLE.
+		if maxCount == fakeLength {
+			for i := range hist {
+				if uint8(i) == maxSym {
+					fakeLength++
+					maxSym++
+					hist[i+1] = 1
+					if maxSym > 1 {
+						break
+					}
+				}
+				if hist[0] == 0 {
+					fakeLength++
+					hist[i] = 1
+					if maxSym > 1 {
+						break
+					}
+				}
+			}
+		}
+
 		dst.HistogramFinished(maxSym, maxCount)
 		dst.reUsed = false
 		dst.useRLE = false

vendor/github.com/klauspost/compress/zstd/internal/xxhash/xxhash_arm64.s

@@ -162,12 +162,12 @@ finalize:
 	MOVD h, ret+24(FP)
 	RET
 
-// func writeBlocks(d *Digest, b []byte) int
+// func writeBlocks(s *Digest, b []byte) int
 TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
 	LDP ·primes+0(SB), (prime1, prime2)
 
 	// Load state. Assume v[1-4] are stored contiguously.
-	MOVD d+0(FP), digest
+	MOVD s+0(FP), digest
 	LDP  0(digest), (v1, v2)
 	LDP  16(digest), (v3, v4)
 

vendor/github.com/klauspost/compress/zstd/matchlen_amd64.s

@@ -5,7 +5,6 @@
 #include "textflag.h"
 
 // func matchLen(a []byte, b []byte) int
-// Requires: BMI
 TEXT ·matchLen(SB), NOSPLIT, $0-56
 	MOVQ a_base+0(FP), AX
 	MOVQ b_base+24(FP), CX
@@ -17,17 +16,16 @@ TEXT ·matchLen(SB), NOSPLIT, $0-56
 	JB   matchlen_match4_standalone
 
 matchlen_loopback_standalone:
-	MOVQ  (AX)(SI*1), BX
+	MOVQ (AX)(SI*1), BX
-	XORQ  (CX)(SI*1), BX
+	XORQ (CX)(SI*1), BX
-	TESTQ BX, BX
+	JZ   matchlen_loop_standalone
-	JZ    matchlen_loop_standalone
 
 #ifdef GOAMD64_v3
 	TZCNTQ BX, BX
 #else
 	BSFQ BX, BX
 #endif
-	SARQ $0x03, BX
+	SHRL $0x03, BX
 	LEAL (SI)(BX*1), SI
 	JMP  gen_match_len_end
 

vendor/github.com/klauspost/cpuid/v2/README.md

@@ -310,6 +310,7 @@ Exit Code 1
 | AVXSLOW            | Indicates the CPU performs 2 128 bit operations instead of one                                                                                                                     |
 | AVXVNNI            | AVX (VEX encoded) VNNI neural network instructions                                                                                                                                 |
 | AVXVNNIINT8        | AVX-VNNI-INT8 instructions                                                                                                                                                         |
+| AVXVNNIINT16       | AVX-VNNI-INT16 instructions                                                                                                                                                        |
 | BHI_CTRL           | Branch History Injection and Intra-mode Branch Target Injection / CVE-2022-0001, CVE-2022-0002 / INTEL-SA-00598                                                                    |
 | BMI1               | Bit Manipulation Instruction Set 1                                                                                                                                                 |
 | BMI2               | Bit Manipulation Instruction Set 2                                                                                                                                                 |

vendor/github.com/klauspost/cpuid/v2/cpuid.go

@@ -104,6 +104,7 @@ const (
 	AVXSLOW                              // Indicates the CPU performs 2 128 bit operations instead of one
 	AVXVNNI                              // AVX (VEX encoded) VNNI neural network instructions
 	AVXVNNIINT8                          // AVX-VNNI-INT8 instructions
+	AVXVNNIINT16                         // AVX-VNNI-INT16 instructions
 	BHI_CTRL                             // Branch History Injection and Intra-mode Branch Target Injection / CVE-2022-0001, CVE-2022-0002 / INTEL-SA-00598
 	BMI1                                 // Bit Manipulation Instruction Set 1
 	BMI2                                 // Bit Manipulation Instruction Set 2
@@ -1242,6 +1243,7 @@ func support() flagSet {
 		// CPUID.(EAX=7, ECX=1).EDX
 		fs.setIf(edx1&(1<<4) != 0, AVXVNNIINT8)
 		fs.setIf(edx1&(1<<5) != 0, AVXNECONVERT)
+		fs.setIf(edx1&(1<<10) != 0, AVXVNNIINT16)
 		fs.setIf(edx1&(1<<14) != 0, PREFETCHI)
 		fs.setIf(edx1&(1<<19) != 0, AVX10)
 		fs.setIf(edx1&(1<<21) != 0, APX_F)

vendor/github.com/klauspost/cpuid/v2/featureid_string.go

@@ -44,194 +44,195 @@ func _() {
 	_ = x[AVXSLOW-34]
 	_ = x[AVXVNNI-35]
 	_ = x[AVXVNNIINT8-36]
-	_ = x[BHI_CTRL-37]
+	_ = x[AVXVNNIINT16-37]
-	_ = x[BMI1-38]
+	_ = x[BHI_CTRL-38]
-	_ = x[BMI2-39]
+	_ = x[BMI1-39]
-	_ = x[CETIBT-40]
+	_ = x[BMI2-40]
-	_ = x[CETSS-41]
+	_ = x[CETIBT-41]
-	_ = x[CLDEMOTE-42]
+	_ = x[CETSS-42]
-	_ = x[CLMUL-43]
+	_ = x[CLDEMOTE-43]
-	_ = x[CLZERO-44]
+	_ = x[CLMUL-44]
-	_ = x[CMOV-45]
+	_ = x[CLZERO-45]
-	_ = x[CMPCCXADD-46]
+	_ = x[CMOV-46]
-	_ = x[CMPSB_SCADBS_SHORT-47]
+	_ = x[CMPCCXADD-47]
-	_ = x[CMPXCHG8-48]
+	_ = x[CMPSB_SCADBS_SHORT-48]
-	_ = x[CPBOOST-49]
+	_ = x[CMPXCHG8-49]
-	_ = x[CPPC-50]
+	_ = x[CPBOOST-50]
-	_ = x[CX16-51]
+	_ = x[CPPC-51]
-	_ = x[EFER_LMSLE_UNS-52]
+	_ = x[CX16-52]
-	_ = x[ENQCMD-53]
+	_ = x[EFER_LMSLE_UNS-53]
-	_ = x[ERMS-54]
+	_ = x[ENQCMD-54]
-	_ = x[F16C-55]
+	_ = x[ERMS-55]
-	_ = x[FLUSH_L1D-56]
+	_ = x[F16C-56]
-	_ = x[FMA3-57]
+	_ = x[FLUSH_L1D-57]
-	_ = x[FMA4-58]
+	_ = x[FMA3-58]
-	_ = x[FP128-59]
+	_ = x[FMA4-59]
-	_ = x[FP256-60]
+	_ = x[FP128-60]
-	_ = x[FSRM-61]
+	_ = x[FP256-61]
-	_ = x[FXSR-62]
+	_ = x[FSRM-62]
-	_ = x[FXSROPT-63]
+	_ = x[FXSR-63]
-	_ = x[GFNI-64]
+	_ = x[FXSROPT-64]
-	_ = x[HLE-65]
+	_ = x[GFNI-65]
-	_ = x[HRESET-66]
+	_ = x[HLE-66]
-	_ = x[HTT-67]
+	_ = x[HRESET-67]
-	_ = x[HWA-68]
+	_ = x[HTT-68]
-	_ = x[HYBRID_CPU-69]
+	_ = x[HWA-69]
-	_ = x[HYPERVISOR-70]
+	_ = x[HYBRID_CPU-70]
-	_ = x[IA32_ARCH_CAP-71]
+	_ = x[HYPERVISOR-71]
-	_ = x[IA32_CORE_CAP-72]
+	_ = x[IA32_ARCH_CAP-72]
-	_ = x[IBPB-73]
+	_ = x[IA32_CORE_CAP-73]
-	_ = x[IBPB_BRTYPE-74]
+	_ = x[IBPB-74]
-	_ = x[IBRS-75]
+	_ = x[IBPB_BRTYPE-75]
-	_ = x[IBRS_PREFERRED-76]
+	_ = x[IBRS-76]
-	_ = x[IBRS_PROVIDES_SMP-77]
+	_ = x[IBRS_PREFERRED-77]
-	_ = x[IBS-78]
+	_ = x[IBRS_PROVIDES_SMP-78]
-	_ = x[IBSBRNTRGT-79]
+	_ = x[IBS-79]
-	_ = x[IBSFETCHSAM-80]
+	_ = x[IBSBRNTRGT-80]
-	_ = x[IBSFFV-81]
+	_ = x[IBSFETCHSAM-81]
-	_ = x[IBSOPCNT-82]
+	_ = x[IBSFFV-82]
-	_ = x[IBSOPCNTEXT-83]
+	_ = x[IBSOPCNT-83]
-	_ = x[IBSOPSAM-84]
+	_ = x[IBSOPCNTEXT-84]
-	_ = x[IBSRDWROPCNT-85]
+	_ = x[IBSOPSAM-85]
-	_ = x[IBSRIPINVALIDCHK-86]
+	_ = x[IBSRDWROPCNT-86]
-	_ = x[IBS_FETCH_CTLX-87]
+	_ = x[IBSRIPINVALIDCHK-87]
-	_ = x[IBS_OPDATA4-88]
+	_ = x[IBS_FETCH_CTLX-88]
-	_ = x[IBS_OPFUSE-89]
+	_ = x[IBS_OPDATA4-89]
-	_ = x[IBS_PREVENTHOST-90]
+	_ = x[IBS_OPFUSE-90]
-	_ = x[IBS_ZEN4-91]
+	_ = x[IBS_PREVENTHOST-91]
-	_ = x[IDPRED_CTRL-92]
+	_ = x[IBS_ZEN4-92]
-	_ = x[INT_WBINVD-93]
+	_ = x[IDPRED_CTRL-93]
-	_ = x[INVLPGB-94]
+	_ = x[INT_WBINVD-94]
-	_ = x[KEYLOCKER-95]
+	_ = x[INVLPGB-95]
-	_ = x[KEYLOCKERW-96]
+	_ = x[KEYLOCKER-96]
-	_ = x[LAHF-97]
+	_ = x[KEYLOCKERW-97]
-	_ = x[LAM-98]
+	_ = x[LAHF-98]
-	_ = x[LBRVIRT-99]
+	_ = x[LAM-99]
-	_ = x[LZCNT-100]
+	_ = x[LBRVIRT-100]
-	_ = x[MCAOVERFLOW-101]
+	_ = x[LZCNT-101]
-	_ = x[MCDT_NO-102]
+	_ = x[MCAOVERFLOW-102]
-	_ = x[MCOMMIT-103]
+	_ = x[MCDT_NO-103]
-	_ = x[MD_CLEAR-104]
+	_ = x[MCOMMIT-104]
-	_ = x[MMX-105]
+	_ = x[MD_CLEAR-105]
-	_ = x[MMXEXT-106]
+	_ = x[MMX-106]
-	_ = x[MOVBE-107]
+	_ = x[MMXEXT-107]
-	_ = x[MOVDIR64B-108]
+	_ = x[MOVBE-108]
-	_ = x[MOVDIRI-109]
+	_ = x[MOVDIR64B-109]
-	_ = x[MOVSB_ZL-110]
+	_ = x[MOVDIRI-110]
-	_ = x[MOVU-111]
+	_ = x[MOVSB_ZL-111]
-	_ = x[MPX-112]
+	_ = x[MOVU-112]
-	_ = x[MSRIRC-113]
+	_ = x[MPX-113]
-	_ = x[MSRLIST-114]
+	_ = x[MSRIRC-114]
-	_ = x[MSR_PAGEFLUSH-115]
+	_ = x[MSRLIST-115]
-	_ = x[NRIPS-116]
+	_ = x[MSR_PAGEFLUSH-116]
-	_ = x[NX-117]
+	_ = x[NRIPS-117]
-	_ = x[OSXSAVE-118]
+	_ = x[NX-118]
-	_ = x[PCONFIG-119]
+	_ = x[OSXSAVE-119]
-	_ = x[POPCNT-120]
+	_ = x[PCONFIG-120]
-	_ = x[PPIN-121]
+	_ = x[POPCNT-121]
-	_ = x[PREFETCHI-122]
+	_ = x[PPIN-122]
-	_ = x[PSFD-123]
+	_ = x[PREFETCHI-123]
-	_ = x[RDPRU-124]
+	_ = x[PSFD-124]
-	_ = x[RDRAND-125]
+	_ = x[RDPRU-125]
-	_ = x[RDSEED-126]
+	_ = x[RDRAND-126]
-	_ = x[RDTSCP-127]
+	_ = x[RDSEED-127]
-	_ = x[RRSBA_CTRL-128]
+	_ = x[RDTSCP-128]
-	_ = x[RTM-129]
+	_ = x[RRSBA_CTRL-129]
-	_ = x[RTM_ALWAYS_ABORT-130]
+	_ = x[RTM-130]
-	_ = x[SBPB-131]
+	_ = x[RTM_ALWAYS_ABORT-131]
-	_ = x[SERIALIZE-132]
+	_ = x[SBPB-132]
-	_ = x[SEV-133]
+	_ = x[SERIALIZE-133]
-	_ = x[SEV_64BIT-134]
+	_ = x[SEV-134]
-	_ = x[SEV_ALTERNATIVE-135]
+	_ = x[SEV_64BIT-135]
-	_ = x[SEV_DEBUGSWAP-136]
+	_ = x[SEV_ALTERNATIVE-136]
-	_ = x[SEV_ES-137]
+	_ = x[SEV_DEBUGSWAP-137]
-	_ = x[SEV_RESTRICTED-138]
+	_ = x[SEV_ES-138]
-	_ = x[SEV_SNP-139]
+	_ = x[SEV_RESTRICTED-139]
-	_ = x[SGX-140]
+	_ = x[SEV_SNP-140]
-	_ = x[SGXLC-141]
+	_ = x[SGX-141]
-	_ = x[SHA-142]
+	_ = x[SGXLC-142]
-	_ = x[SME-143]
+	_ = x[SHA-143]
-	_ = x[SME_COHERENT-144]
+	_ = x[SME-144]
-	_ = x[SPEC_CTRL_SSBD-145]
+	_ = x[SME_COHERENT-145]
-	_ = x[SRBDS_CTRL-146]
+	_ = x[SPEC_CTRL_SSBD-146]
-	_ = x[SRSO_MSR_FIX-147]
+	_ = x[SRBDS_CTRL-147]
-	_ = x[SRSO_NO-148]
+	_ = x[SRSO_MSR_FIX-148]
-	_ = x[SRSO_USER_KERNEL_NO-149]
+	_ = x[SRSO_NO-149]
-	_ = x[SSE-150]
+	_ = x[SRSO_USER_KERNEL_NO-150]
-	_ = x[SSE2-151]
+	_ = x[SSE-151]
-	_ = x[SSE3-152]
+	_ = x[SSE2-152]
-	_ = x[SSE4-153]
+	_ = x[SSE3-153]
-	_ = x[SSE42-154]
+	_ = x[SSE4-154]
-	_ = x[SSE4A-155]
+	_ = x[SSE42-155]
-	_ = x[SSSE3-156]
+	_ = x[SSE4A-156]
-	_ = x[STIBP-157]
+	_ = x[SSSE3-157]
-	_ = x[STIBP_ALWAYSON-158]
+	_ = x[STIBP-158]
-	_ = x[STOSB_SHORT-159]
+	_ = x[STIBP_ALWAYSON-159]
-	_ = x[SUCCOR-160]
+	_ = x[STOSB_SHORT-160]
-	_ = x[SVM-161]
+	_ = x[SUCCOR-161]
-	_ = x[SVMDA-162]
+	_ = x[SVM-162]
-	_ = x[SVMFBASID-163]
+	_ = x[SVMDA-163]
-	_ = x[SVML-164]
+	_ = x[SVMFBASID-164]
-	_ = x[SVMNP-165]
+	_ = x[SVML-165]
-	_ = x[SVMPF-166]
+	_ = x[SVMNP-166]
-	_ = x[SVMPFT-167]
+	_ = x[SVMPF-167]
-	_ = x[SYSCALL-168]
+	_ = x[SVMPFT-168]
-	_ = x[SYSEE-169]
+	_ = x[SYSCALL-169]
-	_ = x[TBM-170]
+	_ = x[SYSEE-170]
-	_ = x[TDX_GUEST-171]
+	_ = x[TBM-171]
-	_ = x[TLB_FLUSH_NESTED-172]
+	_ = x[TDX_GUEST-172]
-	_ = x[TME-173]
+	_ = x[TLB_FLUSH_NESTED-173]
-	_ = x[TOPEXT-174]
+	_ = x[TME-174]
-	_ = x[TSCRATEMSR-175]
+	_ = x[TOPEXT-175]
-	_ = x[TSXLDTRK-176]
+	_ = x[TSCRATEMSR-176]
-	_ = x[VAES-177]
+	_ = x[TSXLDTRK-177]
-	_ = x[VMCBCLEAN-178]
+	_ = x[VAES-178]
-	_ = x[VMPL-179]
+	_ = x[VMCBCLEAN-179]
-	_ = x[VMSA_REGPROT-180]
+	_ = x[VMPL-180]
-	_ = x[VMX-181]
+	_ = x[VMSA_REGPROT-181]
-	_ = x[VPCLMULQDQ-182]
+	_ = x[VMX-182]
-	_ = x[VTE-183]
+	_ = x[VPCLMULQDQ-183]
-	_ = x[WAITPKG-184]
+	_ = x[VTE-184]
-	_ = x[WBNOINVD-185]
+	_ = x[WAITPKG-185]
-	_ = x[WRMSRNS-186]
+	_ = x[WBNOINVD-186]
-	_ = x[X87-187]
+	_ = x[WRMSRNS-187]
-	_ = x[XGETBV1-188]
+	_ = x[X87-188]
-	_ = x[XOP-189]
+	_ = x[XGETBV1-189]
-	_ = x[XSAVE-190]
+	_ = x[XOP-190]
-	_ = x[XSAVEC-191]
+	_ = x[XSAVE-191]
-	_ = x[XSAVEOPT-192]
+	_ = x[XSAVEC-192]
-	_ = x[XSAVES-193]
+	_ = x[XSAVEOPT-193]
-	_ = x[AESARM-194]
+	_ = x[XSAVES-194]
-	_ = x[ARMCPUID-195]
+	_ = x[AESARM-195]
-	_ = x[ASIMD-196]
+	_ = x[ARMCPUID-196]
-	_ = x[ASIMDDP-197]
+	_ = x[ASIMD-197]
-	_ = x[ASIMDHP-198]
+	_ = x[ASIMDDP-198]
-	_ = x[ASIMDRDM-199]
+	_ = x[ASIMDHP-199]
-	_ = x[ATOMICS-200]
+	_ = x[ASIMDRDM-200]
-	_ = x[CRC32-201]
+	_ = x[ATOMICS-201]
-	_ = x[DCPOP-202]
+	_ = x[CRC32-202]
-	_ = x[EVTSTRM-203]
+	_ = x[DCPOP-203]
-	_ = x[FCMA-204]
+	_ = x[EVTSTRM-204]
-	_ = x[FP-205]
+	_ = x[FCMA-205]
-	_ = x[FPHP-206]
+	_ = x[FP-206]
-	_ = x[GPA-207]
+	_ = x[FPHP-207]
-	_ = x[JSCVT-208]
+	_ = x[GPA-208]
-	_ = x[LRCPC-209]
+	_ = x[JSCVT-209]
-	_ = x[PMULL-210]
+	_ = x[LRCPC-210]
-	_ = x[SHA1-211]
+	_ = x[PMULL-211]
-	_ = x[SHA2-212]
+	_ = x[SHA1-212]
-	_ = x[SHA3-213]
+	_ = x[SHA2-213]
-	_ = x[SHA512-214]
+	_ = x[SHA3-214]
-	_ = x[SM3-215]
+	_ = x[SHA512-215]
-	_ = x[SM4-216]
+	_ = x[SM3-216]
-	_ = x[SVE-217]
+	_ = x[SM4-217]
-	_ = x[lastID-218]
+	_ = x[SVE-218]
+	_ = x[lastID-219]
 	_ = x[firstID-0]
 }
 
-const _FeatureID_name = "firstIDADXAESNIAMD3DNOWAMD3DNOWEXTAMXBF16AMXFP16AMXINT8AMXTILEAPX_FAVXAVX10AVX10_128AVX10_256AVX10_512AVX2AVX512BF16AVX512BITALGAVX512BWAVX512CDAVX512DQAVX512ERAVX512FAVX512FP16AVX512IFMAAVX512PFAVX512VBMIAVX512VBMI2AVX512VLAVX512VNNIAVX512VP2INTERSECTAVX512VPOPCNTDQAVXIFMAAVXNECONVERTAVXSLOWAVXVNNIAVXVNNIINT8BHI_CTRLBMI1BMI2CETIBTCETSSCLDEMOTECLMULCLZEROCMOVCMPCCXADDCMPSB_SCADBS_SHORTCMPXCHG8CPBOOSTCPPCCX16EFER_LMSLE_UNSENQCMDERMSF16CFLUSH_L1DFMA3FMA4FP128FP256FSRMFXSRFXSROPTGFNIHLEHRESETHTTHWAHYBRID_CPUHYPERVISORIA32_ARCH_CAPIA32_CORE_CAPIBPBIBPB_BRTYPEIBRSIBRS_PREFERREDIBRS_PROVIDES_SMPIBSIBSBRNTRGTIBSFETCHSAMIBSFFVIBSOPCNTIBSOPCNTEXTIBSOPSAMIBSRDWROPCNTIBSRIPINVALIDCHKIBS_FETCH_CTLXIBS_OPDATA4IBS_OPFUSEIBS_PREVENTHOSTIBS_ZEN4IDPRED_CTRLINT_WBINVDINVLPGBKEYLOCKERKEYLOCKERWLAHFLAMLBRVIRTLZCNTMCAOVERFLOWMCDT_NOMCOMMITMD_CLEARMMXMMXEXTMOVBEMOVDIR64BMOVDIRIMOVSB_ZLMOVUMPXMSRIRCMSRLISTMSR_PAGEFLUSHNRIPSNXOSXSAVEPCONFIGPOPCNTPPINPREFETCHIPSFDRDPRURDRANDRDSEEDRDTSCPRRSBA_CTRLRTMRTM_ALWAYS_ABORTSBPBSERIALIZESEVSEV_64BITSEV_ALTERNATIVESEV_DEBUGSWAPSEV_ESSEV_RESTRICTEDSEV_SNPSGXSGXLCSHASMESME_COHERENTSPEC_CTRL_SSBDSRBDS_CTRLSRSO_MSR_FIXSRSO_NOSRSO_USER_KERNEL_NOSSESSE2SSE3SSE4SSE42SSE4ASSSE3STIBPSTIBP_ALWAYSONSTOSB_SHORTSUCCORSVMSVMDASVMFBASIDSVMLSVMNPSVMPFSVMPFTSYSCALLSYSEETBMTDX_GUESTTLB_FLUSH_NESTEDTMETOPEXTTSCRATEMSRTSXLDTRKVAESVMCBCLEANVMPLVMSA_REGPROTVMXVPCLMULQDQVTEWAITPKGWBNOINVDWRMSRNSX87XGETBV1XOPXSAVEXSAVECXSAVEOPTXSAVESAESARMARMCPUIDASIMDASIMDDPASIMDHPASIMDRDMATOMICSCRC32DCPOPEVTSTRMFCMAFPFPHPGPAJSCVTLRCPCPMULLSHA1SHA2SHA3SHA512SM3SM4SVElastID"
+const _FeatureID_name = "firstIDADXAESNIAMD3DNOWAMD3DNOWEXTAMXBF16AMXFP16AMXINT8AMXTILEAPX_FAVXAVX10AVX10_128AVX10_256AVX10_512AVX2AVX512BF16AVX512BITALGAVX512BWAVX512CDAVX512DQAVX512ERAVX512FAVX512FP16AVX512IFMAAVX512PFAVX512VBMIAVX512VBMI2AVX512VLAVX512VNNIAVX512VP2INTERSECTAVX512VPOPCNTDQAVXIFMAAVXNECONVERTAVXSLOWAVXVNNIAVXVNNIINT8AVXVNNIINT16BHI_CTRLBMI1BMI2CETIBTCETSSCLDEMOTECLMULCLZEROCMOVCMPCCXADDCMPSB_SCADBS_SHORTCMPXCHG8CPBOOSTCPPCCX16EFER_LMSLE_UNSENQCMDERMSF16CFLUSH_L1DFMA3FMA4FP128FP256FSRMFXSRFXSROPTGFNIHLEHRESETHTTHWAHYBRID_CPUHYPERVISORIA32_ARCH_CAPIA32_CORE_CAPIBPBIBPB_BRTYPEIBRSIBRS_PREFERREDIBRS_PROVIDES_SMPIBSIBSBRNTRGTIBSFETCHSAMIBSFFVIBSOPCNTIBSOPCNTEXTIBSOPSAMIBSRDWROPCNTIBSRIPINVALIDCHKIBS_FETCH_CTLXIBS_OPDATA4IBS_OPFUSEIBS_PREVENTHOSTIBS_ZEN4IDPRED_CTRLINT_WBINVDINVLPGBKEYLOCKERKEYLOCKERWLAHFLAMLBRVIRTLZCNTMCAOVERFLOWMCDT_NOMCOMMITMD_CLEARMMXMMXEXTMOVBEMOVDIR64BMOVDIRIMOVSB_ZLMOVUMPXMSRIRCMSRLISTMSR_PAGEFLUSHNRIPSNXOSXSAVEPCONFIGPOPCNTPPINPREFETCHIPSFDRDPRURDRANDRDSEEDRDTSCPRRSBA_CTRLRTMRTM_ALWAYS_ABORTSBPBSERIALIZESEVSEV_64BITSEV_ALTERNATIVESEV_DEBUGSWAPSEV_ESSEV_RESTRICTEDSEV_SNPSGXSGXLCSHASMESME_COHERENTSPEC_CTRL_SSBDSRBDS_CTRLSRSO_MSR_FIXSRSO_NOSRSO_USER_KERNEL_NOSSESSE2SSE3SSE4SSE42SSE4ASSSE3STIBPSTIBP_ALWAYSONSTOSB_SHORTSUCCORSVMSVMDASVMFBASIDSVMLSVMNPSVMPFSVMPFTSYSCALLSYSEETBMTDX_GUESTTLB_FLUSH_NESTEDTMETOPEXTTSCRATEMSRTSXLDTRKVAESVMCBCLEANVMPLVMSA_REGPROTVMXVPCLMULQDQVTEWAITPKGWBNOINVDWRMSRNSX87XGETBV1XOPXSAVEXSAVECXSAVEOPTXSAVESAESARMARMCPUIDASIMDASIMDDPASIMDHPASIMDRDMATOMICSCRC32DCPOPEVTSTRMFCMAFPFPHPGPAJSCVTLRCPCPMULLSHA1SHA2SHA3SHA512SM3SM4SVElastID"
 
-var _FeatureID_index = [...]uint16{0, 7, 10, 15, 23, 34, 41, 48, 55, 62, 67, 70, 75, 84, 93, 102, 106, 116, 128, 136, 144, 152, 160, 167, 177, 187, 195, 205, 216, 224, 234, 252, 267, 274, 286, 293, 300, 311, 319, 323, 327, 333, 338, 346, 351, 357, 361, 370, 388, 396, 403, 407, 411, 425, 431, 435, 439, 448, 452, 456, 461, 466, 470, 474, 481, 485, 488, 494, 497, 500, 510, 520, 533, 546, 550, 561, 565, 579, 596, 599, 609, 620, 626, 634, 645, 653, 665, 681, 695, 706, 716, 731, 739, 750, 760, 767, 776, 786, 790, 793, 800, 805, 816, 823, 830, 838, 841, 847, 852, 861, 868, 876, 880, 883, 889, 896, 909, 914, 916, 923, 930, 936, 940, 949, 953, 958, 964, 970, 976, 986, 989, 1005, 1009, 1018, 1021, 1030, 1045, 1058, 1064, 1078, 1085, 1088, 1093, 1096, 1099, 1111, 1125, 1135, 1147, 1154, 1173, 1176, 1180, 1184, 1188, 1193, 1198, 1203, 1208, 1222, 1233, 1239, 1242, 1247, 1256, 1260, 1265, 1270, 1276, 1283, 1288, 1291, 1300, 1316, 1319, 1325, 1335, 1343, 1347, 1356, 1360, 1372, 1375, 1385, 1388, 1395, 1403, 1410, 1413, 1420, 1423, 1428, 1434, 1442, 1448, 1454, 1462, 1467, 1474, 1481, 1489, 1496, 1501, 1506, 1513, 1517, 1519, 1523, 1526, 1531, 1536, 1541, 1545, 1549, 1553, 1559, 1562, 1565, 1568, 1574}
+var _FeatureID_index = [...]uint16{0, 7, 10, 15, 23, 34, 41, 48, 55, 62, 67, 70, 75, 84, 93, 102, 106, 116, 128, 136, 144, 152, 160, 167, 177, 187, 195, 205, 216, 224, 234, 252, 267, 274, 286, 293, 300, 311, 323, 331, 335, 339, 345, 350, 358, 363, 369, 373, 382, 400, 408, 415, 419, 423, 437, 443, 447, 451, 460, 464, 468, 473, 478, 482, 486, 493, 497, 500, 506, 509, 512, 522, 532, 545, 558, 562, 573, 577, 591, 608, 611, 621, 632, 638, 646, 657, 665, 677, 693, 707, 718, 728, 743, 751, 762, 772, 779, 788, 798, 802, 805, 812, 817, 828, 835, 842, 850, 853, 859, 864, 873, 880, 888, 892, 895, 901, 908, 921, 926, 928, 935, 942, 948, 952, 961, 965, 970, 976, 982, 988, 998, 1001, 1017, 1021, 1030, 1033, 1042, 1057, 1070, 1076, 1090, 1097, 1100, 1105, 1108, 1111, 1123, 1137, 1147, 1159, 1166, 1185, 1188, 1192, 1196, 1200, 1205, 1210, 1215, 1220, 1234, 1245, 1251, 1254, 1259, 1268, 1272, 1277, 1282, 1288, 1295, 1300, 1303, 1312, 1328, 1331, 1337, 1347, 1355, 1359, 1368, 1372, 1384, 1387, 1397, 1400, 1407, 1415, 1422, 1425, 1432, 1435, 1440, 1446, 1454, 1460, 1466, 1474, 1479, 1486, 1493, 1501, 1508, 1513, 1518, 1525, 1529, 1531, 1535, 1538, 1543, 1548, 1553, 1557, 1561, 1565, 1571, 1574, 1577, 1580, 1586}
 
 func (i FeatureID) String() string {
 	if i < 0 || i >= FeatureID(len(_FeatureID_index)-1) {

vendor/github.com/libp2p/go-libp2p-pubsub/backoff.go

@@ -43,7 +43,6 @@ func newBackoff(ctx context.Context, sizeThreshold int, cleanupInterval time.Dur
 		info:        make(map[peer.ID]*backoffHistory),
 	}
 
-	rand.Seed(time.Now().UnixNano()) // used for jitter
 	go b.cleanupLoop(ctx)
 
 	return b

vendor/github.com/libp2p/go-libp2p-pubsub/comm.go

@@ -114,7 +114,7 @@ func (p *PubSub) notifyPeerDead(pid peer.ID) {
 	}
 }
 
-func (p *PubSub) handleNewPeer(ctx context.Context, pid peer.ID, outgoing <-chan *RPC) {
+func (p *PubSub) handleNewPeer(ctx context.Context, pid peer.ID, outgoing *rpcQueue) {
 	s, err := p.host.NewStream(p.ctx, pid, p.rt.Protocols()...)
 	if err != nil {
 		log.Debug("opening new stream to peer: ", err, pid)
@@ -135,7 +135,7 @@ func (p *PubSub) handleNewPeer(ctx context.Context, pid peer.ID, outgoing <-chan
 	}
 }
 
-func (p *PubSub) handleNewPeerWithBackoff(ctx context.Context, pid peer.ID, backoff time.Duration, outgoing <-chan *RPC) {
+func (p *PubSub) handleNewPeerWithBackoff(ctx context.Context, pid peer.ID, backoff time.Duration, outgoing *rpcQueue) {
 	select {
 	case <-time.After(backoff):
 		p.handleNewPeer(ctx, pid, outgoing)
@@ -156,7 +156,7 @@ func (p *PubSub) handlePeerDead(s network.Stream) {
 	p.notifyPeerDead(pid)
 }
 
-func (p *PubSub) handleSendingMessages(ctx context.Context, s network.Stream, outgoing <-chan *RPC) {
+func (p *PubSub) handleSendingMessages(ctx context.Context, s network.Stream, outgoing *rpcQueue) {
 	writeRpc := func(rpc *RPC) error {
 		size := uint64(rpc.Size())
 
@@ -174,20 +174,17 @@ func (p *PubSub) handleSendingMessages(ctx context.Context, s network.Stream, ou
 	}
 
 	defer s.Close()
-	for {
+	for ctx.Err() == nil {
-		select {
+		rpc, err := outgoing.Pop(ctx)
-		case rpc, ok := <-outgoing:
+		if err != nil {
-			if !ok {
+			log.Debugf("popping message from the queue to send to %s: %s", s.Conn().RemotePeer(), err)
-				return
+			return
-			}
+		}
 
-			err := writeRpc(rpc)
+		err = writeRpc(rpc)
-			if err != nil {
+		if err != nil {
-				s.Reset()
+			s.Reset()
-				log.Debugf("writing message to %s: %s", s.Conn().RemotePeer(), err)
+			log.Debugf("writing message to %s: %s", s.Conn().RemotePeer(), err)
-				return
-			}
-		case <-ctx.Done():
 			return
 		}
 	}
@@ -209,15 +206,17 @@ func rpcWithControl(msgs []*pb.Message,
 	ihave []*pb.ControlIHave,
 	iwant []*pb.ControlIWant,
 	graft []*pb.ControlGraft,
-	prune []*pb.ControlPrune) *RPC {
+	prune []*pb.ControlPrune,
+	idontwant []*pb.ControlIDontWant) *RPC {
 	return &RPC{
 		RPC: pb.RPC{
 			Publish: msgs,
 			Control: &pb.ControlMessage{
-				Ihave: ihave,
+				Ihave:     ihave,
-				Iwant: iwant,
+				Iwant:     iwant,
-				Graft: graft,
+				Graft:     graft,
-				Prune: prune,
+				Prune:     prune,
+				Idontwant: idontwant,
 			},
 		},
 	}

vendor/github.com/libp2p/go-libp2p-pubsub/floodsub.go

@@ -71,6 +71,8 @@ func (fs *FloodSubRouter) AcceptFrom(peer.ID) AcceptStatus {
 	return AcceptAll
 }
 
+func (fs *FloodSubRouter) PreValidation([]*Message) {}
+
 func (fs *FloodSubRouter) HandleRPC(rpc *RPC) {}
 
 func (fs *FloodSubRouter) Publish(msg *Message) {
@@ -83,19 +85,19 @@ func (fs *FloodSubRouter) Publish(msg *Message) {
 			continue
 		}
 
-		mch, ok := fs.p.peers[pid]
+		q, ok := fs.p.peers[pid]
 		if !ok {
 			continue
 		}
 
-		select {
+		err := q.Push(out, false)
-		case mch <- out:
+		if err != nil {
-			fs.tracer.SendRPC(out, pid)
-		default:
 			log.Infof("dropping message to peer %s: queue full", pid)
 			fs.tracer.DropRPC(out, pid)
 			// Drop it. The peer is too slow.
+			continue
 		}
+		fs.tracer.SendRPC(out, pid)
 	}
 }
 

vendor/github.com/libp2p/go-libp2p-pubsub/gossipsub.go

@@ -2,7 +2,9 @@ package pubsub
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
+	"io"
 	"math/rand"
 	"sort"
 	"time"
@@ -21,13 +23,19 @@ import (
 
 const (
 	// GossipSubID_v10 is the protocol ID for version 1.0.0 of the GossipSub protocol.
-	// It is advertised along with GossipSubID_v11 for backwards compatibility.
+	// It is advertised along with GossipSubID_v11 and GossipSubID_v12 for backwards compatibility.
 	GossipSubID_v10 = protocol.ID("/meshsub/1.0.0")
 
 	// GossipSubID_v11 is the protocol ID for version 1.1.0 of the GossipSub protocol.
+	// It is advertised along with GossipSubID_v12 for backwards compatibility.
 	// See the spec for details about how v1.1.0 compares to v1.0.0:
 	// https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md
 	GossipSubID_v11 = protocol.ID("/meshsub/1.1.0")
+
+	// GossipSubID_v12 is the protocol ID for version 1.2.0 of the GossipSub protocol.
+	// See the spec for details about how v1.2.0 compares to v1.1.0:
+	// https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.2.md
+	GossipSubID_v12 = protocol.ID("/meshsub/1.2.0")
 )
 
 // Defines the default gossipsub parameters.
@@ -58,9 +66,17 @@ var (
 	GossipSubGraftFloodThreshold              = 10 * time.Second
 	GossipSubMaxIHaveLength                   = 5000
 	GossipSubMaxIHaveMessages                 = 10
+	GossipSubMaxIDontWantMessages             = 1000
 	GossipSubIWantFollowupTime                = 3 * time.Second
+	GossipSubIDontWantMessageThreshold        = 1024 // 1KB
+	GossipSubIDontWantMessageTTL              = 3    // 3 heartbeats
 )
 
+type checksum struct {
+	payload [32]byte
+	length  uint8
+}
+
 // GossipSubParams defines all the gossipsub specific parameters.
 type GossipSubParams struct {
 	// overlay parameters.
@@ -200,10 +216,21 @@ type GossipSubParams struct {
 	// MaxIHaveMessages is the maximum number of IHAVE messages to accept from a peer within a heartbeat.
 	MaxIHaveMessages int
 
+	// MaxIDontWantMessages is the maximum number of IDONTWANT messages to accept from a peer within a heartbeat.
+	MaxIDontWantMessages int
+
 	// Time to wait for a message requested through IWANT following an IHAVE advertisement.
 	// If the message is not received within this window, a broken promise is declared and
 	// the router may apply bahavioural penalties.
 	IWantFollowupTime time.Duration
+
+	// IDONTWANT is only sent for messages larger than the threshold. This should be greater than
+	// D_high * the size of the message id. Otherwise, the attacker can do the amplication attack by sending
+	// small messages while the receiver replies back with larger IDONTWANT messages.
+	IDontWantMessageThreshold int
+
+	// IDONTWANT is cleared when it's older than the TTL.
+	IDontWantMessageTTL int
 }
 
 // NewGossipSub returns a new PubSub object using the default GossipSubRouter as the router.
@@ -222,23 +249,25 @@ func NewGossipSubWithRouter(ctx context.Context, h host.Host, rt PubSubRouter, o
 func DefaultGossipSubRouter(h host.Host) *GossipSubRouter {
 	params := DefaultGossipSubParams()
 	return &GossipSubRouter{
-		peers:     make(map[peer.ID]protocol.ID),
+		peers:        make(map[peer.ID]protocol.ID),
-		mesh:      make(map[string]map[peer.ID]struct{}),
+		mesh:         make(map[string]map[peer.ID]struct{}),
-		fanout:    make(map[string]map[peer.ID]struct{}),
+		fanout:       make(map[string]map[peer.ID]struct{}),
-		lastpub:   make(map[string]int64),
+		lastpub:      make(map[string]int64),
-		gossip:    make(map[peer.ID][]*pb.ControlIHave),
+		gossip:       make(map[peer.ID][]*pb.ControlIHave),
-		control:   make(map[peer.ID]*pb.ControlMessage),
+		control:      make(map[peer.ID]*pb.ControlMessage),
-		backoff:   make(map[string]map[peer.ID]time.Time),
+		backoff:      make(map[string]map[peer.ID]time.Time),
-		peerhave:  make(map[peer.ID]int),
+		peerhave:     make(map[peer.ID]int),
-		iasked:    make(map[peer.ID]int),
+		peerdontwant: make(map[peer.ID]int),
-		outbound:  make(map[peer.ID]bool),
+		unwanted:     make(map[peer.ID]map[checksum]int),
-		connect:   make(chan connectInfo, params.MaxPendingConnections),
+		iasked:       make(map[peer.ID]int),
-		cab:       pstoremem.NewAddrBook(),
+		outbound:     make(map[peer.ID]bool),
-		mcache:    NewMessageCache(params.HistoryGossip, params.HistoryLength),
+		connect:      make(chan connectInfo, params.MaxPendingConnections),
-		protos:    GossipSubDefaultProtocols,
+		cab:          pstoremem.NewAddrBook(),
-		feature:   GossipSubDefaultFeatures,
+		mcache:       NewMessageCache(params.HistoryGossip, params.HistoryLength),
-		tagTracer: newTagTracer(h.ConnManager()),
+		protos:       GossipSubDefaultProtocols,
-		params:    params,
+		feature:      GossipSubDefaultFeatures,
+		tagTracer:    newTagTracer(h.ConnManager()),
+		params:       params,
 	}
 }
 
@@ -272,7 +301,10 @@ func DefaultGossipSubParams() GossipSubParams {
 		GraftFloodThreshold:       GossipSubGraftFloodThreshold,
 		MaxIHaveLength:            GossipSubMaxIHaveLength,
 		MaxIHaveMessages:          GossipSubMaxIHaveMessages,
+		MaxIDontWantMessages:      GossipSubMaxIDontWantMessages,
 		IWantFollowupTime:         GossipSubIWantFollowupTime,
+		IDontWantMessageThreshold: GossipSubIDontWantMessageThreshold,
+		IDontWantMessageTTL:       GossipSubIDontWantMessageTTL,
 		SlowHeartbeatWarning:      0.1,
 	}
 }
@@ -421,20 +453,22 @@ func WithGossipSubParams(cfg GossipSubParams) Option {
 // is the fanout map. Fanout peer lists are expired if we don't publish any
 // messages to their topic for GossipSubFanoutTTL.
 type GossipSubRouter struct {
-	p        *PubSub
+	p            *PubSub
-	peers    map[peer.ID]protocol.ID          // peer protocols
+	peers        map[peer.ID]protocol.ID          // peer protocols
-	direct   map[peer.ID]struct{}             // direct peers
+	direct       map[peer.ID]struct{}             // direct peers
-	mesh     map[string]map[peer.ID]struct{}  // topic meshes
+	mesh         map[string]map[peer.ID]struct{}  // topic meshes
-	fanout   map[string]map[peer.ID]struct{}  // topic fanout
+	fanout       map[string]map[peer.ID]struct{}  // topic fanout
-	lastpub  map[string]int64                 // last publish time for fanout topics
+	lastpub      map[string]int64                 // last publish time for fanout topics
-	gossip   map[peer.ID][]*pb.ControlIHave   // pending gossip
+	gossip       map[peer.ID][]*pb.ControlIHave   // pending gossip
-	control  map[peer.ID]*pb.ControlMessage   // pending control messages
+	control      map[peer.ID]*pb.ControlMessage   // pending control messages
-	peerhave map[peer.ID]int                  // number of IHAVEs received from peer in the last heartbeat
+	peerhave     map[peer.ID]int                  // number of IHAVEs received from peer in the last heartbeat
-	iasked   map[peer.ID]int                  // number of messages we have asked from peer in the last heartbeat
+	peerdontwant map[peer.ID]int                  // number of IDONTWANTs received from peer in the last heartbeat
-	outbound map[peer.ID]bool                 // connection direction cache, marks peers with outbound connections
+	unwanted     map[peer.ID]map[checksum]int     // TTL of the message ids peers don't want
-	backoff  map[string]map[peer.ID]time.Time // prune backoff
+	iasked       map[peer.ID]int                  // number of messages we have asked from peer in the last heartbeat
-	connect  chan connectInfo                 // px connection requests
+	outbound     map[peer.ID]bool                 // connection direction cache, marks peers with outbound connections
-	cab      peerstore.AddrBook
+	backoff      map[string]map[peer.ID]time.Time // prune backoff
+	connect      chan connectInfo                 // px connection requests
+	cab          peerstore.AddrBook
 
 	protos  []protocol.ID
 	feature GossipSubFeatureTest
@@ -543,6 +577,13 @@ func (gs *GossipSubRouter) manageAddrBook() {
 	for {
 		select {
 		case <-gs.p.ctx.Done():
+			cabCloser, ok := gs.cab.(io.Closer)
+			if ok {
+				errClose := cabCloser.Close()
+				if errClose != nil {
+					log.Warnf("failed to close addr book: %v", errClose)
+				}
+			}
 			return
 		case ev := <-sub.Out():
 			switch ev := ev.(type) {
@@ -655,6 +696,36 @@ func (gs *GossipSubRouter) AcceptFrom(p peer.ID) AcceptStatus {
 	return gs.gate.AcceptFrom(p)
 }
 
+// PreValidation sends the IDONTWANT control messages to all the mesh
+// peers. They need to be sent right before the validation because they
+// should be seen by the peers as soon as possible.
+func (gs *GossipSubRouter) PreValidation(msgs []*Message) {
+	tmids := make(map[string][]string)
+	for _, msg := range msgs {
+		if len(msg.GetData()) < gs.params.IDontWantMessageThreshold {
+			continue
+		}
+		topic := msg.GetTopic()
+		tmids[topic] = append(tmids[topic], gs.p.idGen.ID(msg))
+	}
+	for topic, mids := range tmids {
+		if len(mids) == 0 {
+			continue
+		}
+		// shuffle the messages got from the RPC envelope
+		shuffleStrings(mids)
+		// send IDONTWANT to all the mesh peers
+		for p := range gs.mesh[topic] {
+			// send to only peers that support IDONTWANT
+			if gs.feature(GossipSubFeatureIdontwant, gs.peers[p]) {
+				idontwant := []*pb.ControlIDontWant{{MessageIDs: mids}}
+				out := rpcWithControl(nil, nil, nil, nil, nil, idontwant)
+				gs.sendRPC(p, out, true)
+			}
+		}
+	}
+}
+
 func (gs *GossipSubRouter) HandleRPC(rpc *RPC) {
 	ctl := rpc.GetControl()
 	if ctl == nil {
@@ -665,13 +736,14 @@ func (gs *GossipSubRouter) HandleRPC(rpc *RPC) {
 	ihave := gs.handleIWant(rpc.from, ctl)
 	prune := gs.handleGraft(rpc.from, ctl)
 	gs.handlePrune(rpc.from, ctl)
+	gs.handleIDontWant(rpc.from, ctl)
 
 	if len(iwant) == 0 && len(ihave) == 0 && len(prune) == 0 {
 		return
 	}
 
-	out := rpcWithControl(ihave, nil, iwant, nil, prune)
+	out := rpcWithControl(ihave, nil, iwant, nil, prune, nil)
-	gs.sendRPC(rpc.from, out)
+	gs.sendRPC(rpc.from, out, false)
 }
 
 func (gs *GossipSubRouter) handleIHave(p peer.ID, ctl *pb.ControlMessage) []*pb.ControlIWant {
@@ -923,6 +995,26 @@ func (gs *GossipSubRouter) handlePrune(p peer.ID, ctl *pb.ControlMessage) {
 	}
 }
 
+func (gs *GossipSubRouter) handleIDontWant(p peer.ID, ctl *pb.ControlMessage) {
+	if gs.unwanted[p] == nil {
+		gs.unwanted[p] = make(map[checksum]int)
+	}
+
+	// IDONTWANT flood protection
+	if gs.peerdontwant[p] >= gs.params.MaxIDontWantMessages {
+		log.Debugf("IDONWANT: peer %s has advertised too many times (%d) within this heartbeat interval; ignoring", p, gs.peerdontwant[p])
+		return
+	}
+	gs.peerdontwant[p]++
+
+	// Remember all the unwanted message ids
+	for _, idontwant := range ctl.GetIdontwant() {
+		for _, mid := range idontwant.GetMessageIDs() {
+			gs.unwanted[p][computeChecksum(mid)] = gs.params.IDontWantMessageTTL
+		}
+	}
+}
+
 func (gs *GossipSubRouter) addBackoff(p peer.ID, topic string, isUnsubscribe bool) {
 	backoff := gs.params.PruneBackoff
 	if isUnsubscribe {
@@ -1083,6 +1175,12 @@ func (gs *GossipSubRouter) Publish(msg *Message) {
 		}
 
 		for p := range gmap {
+			mid := gs.p.idGen.ID(msg)
+			// Check if it has already received an IDONTWANT for the message.
+			// If so, don't send it to the peer
+			if _, ok := gs.unwanted[p][computeChecksum(mid)]; ok {
+				continue
+			}
 			tosend[p] = struct{}{}
 		}
 	}
@@ -1093,7 +1191,7 @@ func (gs *GossipSubRouter) Publish(msg *Message) {
 			continue
 		}
 
-		gs.sendRPC(pid, out)
+		gs.sendRPC(pid, out, false)
 	}
 }
 
@@ -1178,17 +1276,17 @@ func (gs *GossipSubRouter) Leave(topic string) {
 
 func (gs *GossipSubRouter) sendGraft(p peer.ID, topic string) {
 	graft := []*pb.ControlGraft{{TopicID: &topic}}
-	out := rpcWithControl(nil, nil, nil, graft, nil)
+	out := rpcWithControl(nil, nil, nil, graft, nil, nil)
-	gs.sendRPC(p, out)
+	gs.sendRPC(p, out, false)
 }
 
 func (gs *GossipSubRouter) sendPrune(p peer.ID, topic string, isUnsubscribe bool) {
 	prune := []*pb.ControlPrune{gs.makePrune(p, topic, gs.doPX, isUnsubscribe)}
-	out := rpcWithControl(nil, nil, nil, nil, prune)
+	out := rpcWithControl(nil, nil, nil, nil, prune, nil)
-	gs.sendRPC(p, out)
+	gs.sendRPC(p, out, false)
 }
 
-func (gs *GossipSubRouter) sendRPC(p peer.ID, out *RPC) {
+func (gs *GossipSubRouter) sendRPC(p peer.ID, out *RPC, urgent bool) {
 	// do we own the RPC?
 	own := false
 
@@ -1212,14 +1310,14 @@ func (gs *GossipSubRouter) sendRPC(p peer.ID, out *RPC) {
 		delete(gs.gossip, p)
 	}
 
-	mch, ok := gs.p.peers[p]
+	q, ok := gs.p.peers[p]
 	if !ok {
 		return
 	}
 
 	// If we're below the max message size, go ahead and send
 	if out.Size() < gs.p.maxMessageSize {
-		gs.doSendRPC(out, p, mch)
+		gs.doSendRPC(out, p, q, urgent)
 		return
 	}
 
@@ -1231,7 +1329,7 @@ func (gs *GossipSubRouter) sendRPC(p peer.ID, out *RPC) {
 			gs.doDropRPC(out, p, fmt.Sprintf("Dropping oversized RPC. Size: %d, limit: %d. (Over by %d bytes)", rpc.Size(), gs.p.maxMessageSize, rpc.Size()-gs.p.maxMessageSize))
 			continue
 		}
-		gs.doSendRPC(rpc, p, mch)
+		gs.doSendRPC(rpc, p, q, urgent)
 	}
 }
 
@@ -1245,13 +1343,18 @@ func (gs *GossipSubRouter) doDropRPC(rpc *RPC, p peer.ID, reason string) {
 	}
 }
 
-func (gs *GossipSubRouter) doSendRPC(rpc *RPC, p peer.ID, mch chan *RPC) {
+func (gs *GossipSubRouter) doSendRPC(rpc *RPC, p peer.ID, q *rpcQueue, urgent bool) {
-	select {
+	var err error
-	case mch <- rpc:
+	if urgent {
-		gs.tracer.SendRPC(rpc, p)
+		err = q.UrgentPush(rpc, false)
-	default:
+	} else {
-		gs.doDropRPC(rpc, p, "queue full")
+		err = q.Push(rpc, false)
 	}
+	if err != nil {
+		gs.doDropRPC(rpc, p, "queue full")
+		return
+	}
+	gs.tracer.SendRPC(rpc, p)
 }
 
 // appendOrMergeRPC appends the given RPCs to the slice, merging them if possible.
@@ -1433,6 +1536,9 @@ func (gs *GossipSubRouter) heartbeat() {
 	// clean up iasked counters
 	gs.clearIHaveCounters()
 
+	// clean up IDONTWANT counters
+	gs.clearIDontWantCounters()
+
 	// apply IWANT request penalties
 	gs.applyIwantPenalties()
 
@@ -1685,6 +1791,23 @@ func (gs *GossipSubRouter) clearIHaveCounters() {
 	}
 }
 
+func (gs *GossipSubRouter) clearIDontWantCounters() {
+	if len(gs.peerdontwant) > 0 {
+		// throw away the old map and make a new one
+		gs.peerdontwant = make(map[peer.ID]int)
+	}
+
+	// decrement TTLs of all the IDONTWANTs and delete it from the cache when it reaches zero
+	for _, mids := range gs.unwanted {
+		for mid := range mids {
+			mids[mid]--
+			if mids[mid] == 0 {
+				delete(mids, mid)
+			}
+		}
+	}
+}
+
 func (gs *GossipSubRouter) applyIwantPenalties() {
 	for p, count := range gs.gossipTracer.GetBrokenPromises() {
 		log.Infof("peer %s didn't follow up in %d IWANT requests; adding penalty", p, count)
@@ -1759,8 +1882,8 @@ func (gs *GossipSubRouter) sendGraftPrune(tograft, toprune map[peer.ID][]string,
 			}
 		}
 
-		out := rpcWithControl(nil, nil, nil, graft, prune)
+		out := rpcWithControl(nil, nil, nil, graft, prune, nil)
-		gs.sendRPC(p, out)
+		gs.sendRPC(p, out, false)
 	}
 
 	for p, topics := range toprune {
@@ -1769,8 +1892,8 @@ func (gs *GossipSubRouter) sendGraftPrune(tograft, toprune map[peer.ID][]string,
 			prune = append(prune, gs.makePrune(p, topic, gs.doPX && !noPX[p], false))
 		}
 
-		out := rpcWithControl(nil, nil, nil, nil, prune)
+		out := rpcWithControl(nil, nil, nil, nil, prune, nil)
-		gs.sendRPC(p, out)
+		gs.sendRPC(p, out, false)
 	}
 }
 
@@ -1836,15 +1959,15 @@ func (gs *GossipSubRouter) flush() {
 	// send gossip first, which will also piggyback pending control
 	for p, ihave := range gs.gossip {
 		delete(gs.gossip, p)
-		out := rpcWithControl(nil, ihave, nil, nil, nil)
+		out := rpcWithControl(nil, ihave, nil, nil, nil, nil)
-		gs.sendRPC(p, out)
+		gs.sendRPC(p, out, false)
 	}
 
 	// send the remaining control messages that wasn't merged with gossip
 	for p, ctl := range gs.control {
 		delete(gs.control, p)
-		out := rpcWithControl(nil, nil, nil, ctl.Graft, ctl.Prune)
+		out := rpcWithControl(nil, nil, nil, ctl.Graft, ctl.Prune, nil)
-		gs.sendRPC(p, out)
+		gs.sendRPC(p, out, false)
 	}
 }
 
@@ -1865,9 +1988,10 @@ func (gs *GossipSubRouter) piggybackGossip(p peer.ID, out *RPC, ihave []*pb.Cont
 }
 
 func (gs *GossipSubRouter) pushControl(p peer.ID, ctl *pb.ControlMessage) {
-	// remove IHAVE/IWANT from control message, gossip is not retried
+	// remove IHAVE/IWANT/IDONTWANT from control message, gossip is not retried
 	ctl.Ihave = nil
 	ctl.Iwant = nil
+	ctl.Idontwant = nil
 	if ctl.Graft != nil || ctl.Prune != nil {
 		gs.control[p] = ctl
 	}
@@ -2045,3 +2169,13 @@ func shuffleStrings(lst []string) {
 		lst[i], lst[j] = lst[j], lst[i]
 	}
 }
+
+func computeChecksum(mid string) checksum {
+	var cs checksum
+	if len(mid) > 32 || len(mid) == 0 {
+		cs.payload = sha256.Sum256([]byte(mid))
+	} else {
+		cs.length = uint8(copy(cs.payload[:], mid))
+	}
+	return cs
+}

vendor/github.com/libp2p/go-libp2p-pubsub/gossipsub_feat.go

@@ -18,18 +18,22 @@ const (
 	GossipSubFeatureMesh = iota
 	// Protocol supports Peer eXchange on prune -- gossipsub-v1.1 compatible
 	GossipSubFeaturePX
+	// Protocol supports IDONTWANT -- gossipsub-v1.2 compatible
+	GossipSubFeatureIdontwant
 )
 
 // GossipSubDefaultProtocols is the default gossipsub router protocol list
-var GossipSubDefaultProtocols = []protocol.ID{GossipSubID_v11, GossipSubID_v10, FloodSubID}
+var GossipSubDefaultProtocols = []protocol.ID{GossipSubID_v12, GossipSubID_v11, GossipSubID_v10, FloodSubID}
 
 // GossipSubDefaultFeatures is the feature test function for the default gossipsub protocols
 func GossipSubDefaultFeatures(feat GossipSubFeature, proto protocol.ID) bool {
 	switch feat {
 	case GossipSubFeatureMesh:
-		return proto == GossipSubID_v11 || proto == GossipSubID_v10
+		return proto == GossipSubID_v12 || proto == GossipSubID_v11 || proto == GossipSubID_v10
 	case GossipSubFeaturePX:
-		return proto == GossipSubID_v11
+		return proto == GossipSubID_v12 || proto == GossipSubID_v11
+	case GossipSubFeatureIdontwant:
+		return proto == GossipSubID_v12
 	default:
 		return false
 	}

vendor/github.com/libp2p/go-libp2p-pubsub/notify.go

@@ -1,75 +0,0 @@
-package pubsub
-
-import (
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	ma "github.com/multiformats/go-multiaddr"
-)
-
-var _ network.Notifiee = (*PubSubNotif)(nil)
-
-type PubSubNotif PubSub
-
-func (p *PubSubNotif) OpenedStream(n network.Network, s network.Stream) {
-}
-
-func (p *PubSubNotif) ClosedStream(n network.Network, s network.Stream) {
-}
-
-func (p *PubSubNotif) Connected(n network.Network, c network.Conn) {
-	// ignore transient connections
-	if c.Stat().Limited {
-		return
-	}
-
-	go func() {
-		p.newPeersPrioLk.RLock()
-		p.newPeersMx.Lock()
-		p.newPeersPend[c.RemotePeer()] = struct{}{}
-		p.newPeersMx.Unlock()
-		p.newPeersPrioLk.RUnlock()
-
-		select {
-		case p.newPeers <- struct{}{}:
-		default:
-		}
-	}()
-}
-
-func (p *PubSubNotif) Disconnected(n network.Network, c network.Conn) {
-}
-
-func (p *PubSubNotif) Listen(n network.Network, _ ma.Multiaddr) {
-}
-
-func (p *PubSubNotif) ListenClose(n network.Network, _ ma.Multiaddr) {
-}
-
-func (p *PubSubNotif) Initialize() {
-	isTransient := func(pid peer.ID) bool {
-		for _, c := range p.host.Network().ConnsToPeer(pid) {
-			if !c.Stat().Limited {
-				return false
-			}
-		}
-
-		return true
-	}
-
-	p.newPeersPrioLk.RLock()
-	p.newPeersMx.Lock()
-	for _, pid := range p.host.Network().Peers() {
-		if isTransient(pid) {
-			continue
-		}
-
-		p.newPeersPend[pid] = struct{}{}
-	}
-	p.newPeersMx.Unlock()
-	p.newPeersPrioLk.RUnlock()
-
-	select {
-	case p.newPeers <- struct{}{}:
-	default:
-	}
-}

vendor/github.com/libp2p/go-libp2p-pubsub/pb/rpc.pb.go

@@ -228,13 +228,14 @@ func (m *Message) GetKey() []byte {
 }
 
 type ControlMessage struct {
-	Ihave                []*ControlIHave `protobuf:"bytes,1,rep,name=ihave" json:"ihave,omitempty"`
+	Ihave                []*ControlIHave     `protobuf:"bytes,1,rep,name=ihave" json:"ihave,omitempty"`
-	Iwant                []*ControlIWant `protobuf:"bytes,2,rep,name=iwant" json:"iwant,omitempty"`
+	Iwant                []*ControlIWant     `protobuf:"bytes,2,rep,name=iwant" json:"iwant,omitempty"`
-	Graft                []*ControlGraft `protobuf:"bytes,3,rep,name=graft" json:"graft,omitempty"`
+	Graft                []*ControlGraft     `protobuf:"bytes,3,rep,name=graft" json:"graft,omitempty"`
-	Prune                []*ControlPrune `protobuf:"bytes,4,rep,name=prune" json:"prune,omitempty"`
+	Prune                []*ControlPrune     `protobuf:"bytes,4,rep,name=prune" json:"prune,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	Idontwant            []*ControlIDontWant `protobuf:"bytes,5,rep,name=idontwant" json:"idontwant,omitempty"`
-	XXX_unrecognized     []byte          `json:"-"`
+	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	XXX_unrecognized     []byte              `json:"-"`
+	XXX_sizecache        int32               `json:"-"`
 }
 
 func (m *ControlMessage) Reset()         { *m = ControlMessage{} }
@@ -298,6 +299,13 @@ func (m *ControlMessage) GetPrune() []*ControlPrune {
 	return nil
 }
 
+func (m *ControlMessage) GetIdontwant() []*ControlIDontWant {
+	if m != nil {
+		return m.Idontwant
+	}
+	return nil
+}
+
 type ControlIHave struct {
 	TopicID *string `protobuf:"bytes,1,opt,name=topicID" json:"topicID,omitempty"`
 	// implementors from other languages should use bytes here - go protobuf emits invalid utf8 strings
@@ -512,6 +520,54 @@ func (m *ControlPrune) GetBackoff() uint64 {
 	return 0
 }
 
+type ControlIDontWant struct {
+	// implementors from other languages should use bytes here - go protobuf emits invalid utf8 strings
+	MessageIDs           []string `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ControlIDontWant) Reset()         { *m = ControlIDontWant{} }
+func (m *ControlIDontWant) String() string { return proto.CompactTextString(m) }
+func (*ControlIDontWant) ProtoMessage()    {}
+func (*ControlIDontWant) Descriptor() ([]byte, []int) {
+	return fileDescriptor_77a6da22d6a3feb1, []int{7}
+}
+func (m *ControlIDontWant) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ControlIDontWant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ControlIDontWant.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ControlIDontWant) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ControlIDontWant.Merge(m, src)
+}
+func (m *ControlIDontWant) XXX_Size() int {
+	return m.Size()
+}
+func (m *ControlIDontWant) XXX_DiscardUnknown() {
+	xxx_messageInfo_ControlIDontWant.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ControlIDontWant proto.InternalMessageInfo
+
+func (m *ControlIDontWant) GetMessageIDs() []string {
+	if m != nil {
+		return m.MessageIDs
+	}
+	return nil
+}
+
 type PeerInfo struct {
 	PeerID               []byte   `protobuf:"bytes,1,opt,name=peerID" json:"peerID,omitempty"`
 	SignedPeerRecord     []byte   `protobuf:"bytes,2,opt,name=signedPeerRecord" json:"signedPeerRecord,omitempty"`
@@ -524,7 +580,7 @@ func (m *PeerInfo) Reset()         { *m = PeerInfo{} }
 func (m *PeerInfo) String() string { return proto.CompactTextString(m) }
 func (*PeerInfo) ProtoMessage()    {}
 func (*PeerInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{7}
+	return fileDescriptor_77a6da22d6a3feb1, []int{8}
 }
 func (m *PeerInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -576,43 +632,46 @@ func init() {
 	proto.RegisterType((*ControlIWant)(nil), "pubsub.pb.ControlIWant")
 	proto.RegisterType((*ControlGraft)(nil), "pubsub.pb.ControlGraft")
 	proto.RegisterType((*ControlPrune)(nil), "pubsub.pb.ControlPrune")
+	proto.RegisterType((*ControlIDontWant)(nil), "pubsub.pb.ControlIDontWant")
 	proto.RegisterType((*PeerInfo)(nil), "pubsub.pb.PeerInfo")
 }
 
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 480 bytes of a gzipped FileDescriptorProto
+	// 511 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x8e, 0xd3, 0x3c,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcd, 0x6e, 0x13, 0x31,
-	0x10, 0xc7, 0xe5, 0x6d, 0xbb, 0xd9, 0xcc, 0xe6, 0xfb, 0xb4, 0x32, 0x68, 0x31, 0x08, 0x55, 0x55,
+	0x10, 0xc7, 0xe5, 0x7c, 0x34, 0xdd, 0xe9, 0x82, 0x22, 0x83, 0x8a, 0xf9, 0x50, 0x14, 0xed, 0x29,
-	0x4e, 0x01, 0x41, 0x0e, 0xcb, 0x95, 0x0b, 0xb4, 0x12, 0x9b, 0x03, 0x50, 0x99, 0x03, 0x67, 0x27,
+	0x20, 0xd8, 0x43, 0x38, 0x21, 0x71, 0x81, 0x44, 0xa2, 0x39, 0x00, 0x91, 0x39, 0x70, 0xde, 0xdd,
-	0x75, 0xba, 0xd1, 0x6e, 0x63, 0x63, 0x3b, 0x8b, 0x78, 0x08, 0xde, 0x8b, 0x03, 0x07, 0x1e, 0x01,
+	0x38, 0xe9, 0xaa, 0x8d, 0x6d, 0x6c, 0x6f, 0x11, 0x4f, 0xc0, 0x89, 0xf7, 0xe2, 0xc8, 0x23, 0xa0,
-	0xf5, 0xc6, 0x5b, 0x20, 0x3b, 0x4e, 0x9a, 0xa5, 0x94, 0x9b, 0xe7, 0xef, 0xdf, 0xcc, 0xfc, 0x3d,
+	0xdc, 0x78, 0x0b, 0xe4, 0x59, 0xe7, 0xa3, 0x4d, 0x03, 0x37, 0xcf, 0xf8, 0x37, 0xfe, 0xff, 0x67,
-	0x1e, 0x08, 0x95, 0x2c, 0x52, 0xa9, 0x84, 0x11, 0x38, 0x94, 0x4d, 0xae, 0x9b, 0x3c, 0x95, 0x79,
+	0xc6, 0x10, 0x19, 0x5d, 0xa4, 0xda, 0x28, 0xa7, 0x68, 0xa4, 0xab, 0xdc, 0x56, 0x79, 0xaa, 0xf3,
-	0xfc, 0x0b, 0xc1, 0x88, 0x2e, 0xe7, 0xf8, 0x25, 0xfc, 0xa7, 0x9b, 0x5c, 0x17, 0xaa, 0x92, 0xa6,
+	0xe4, 0x0f, 0x81, 0x26, 0x9f, 0x8e, 0xe8, 0x6b, 0xb8, 0x63, 0xab, 0xdc, 0x16, 0xa6, 0xd4, 0xae,
-	0x12, 0xb5, 0x26, 0x68, 0x36, 0x4a, 0x4e, 0x2f, 0xce, 0xd3, 0x1e, 0x4d, 0xe9, 0x72, 0x9e, 0x7e,
+	0x54, 0xd2, 0x32, 0xd2, 0x6f, 0x0e, 0x4e, 0x86, 0xa7, 0xe9, 0x06, 0x4d, 0xf9, 0x74, 0x94, 0x7e,
-	0x68, 0xf2, 0xf7, 0xd2, 0x68, 0x7a, 0x17, 0xc6, 0xcf, 0x20, 0x90, 0x4d, 0x7e, 0x53, 0xe9, 0x2b,
+	0xaa, 0xf2, 0x8f, 0xda, 0x59, 0x7e, 0x1d, 0xa6, 0xcf, 0xa1, 0xa3, 0xab, 0xfc, 0xb2, 0xb4, 0xe7,
-	0x72, 0xe4, 0xf2, 0xf0, 0x20, 0xef, 0x2d, 0xd7, 0x9a, 0xad, 0x39, 0xed, 0x10, 0xfc, 0x02, 0x82,
+	0xac, 0x81, 0x75, 0x74, 0xa7, 0xee, 0xbd, 0xb0, 0x36, 0x5b, 0x08, 0xbe, 0x46, 0xe8, 0x4b, 0xe8,
-	0x42, 0xd4, 0x46, 0x89, 0x1b, 0x32, 0x9a, 0xa1, 0xe4, 0xf4, 0xe2, 0xe1, 0x80, 0x9e, 0xb7, 0x37,
+	0x14, 0x4a, 0x3a, 0xa3, 0x2e, 0x59, 0xb3, 0x4f, 0x06, 0x27, 0xc3, 0x87, 0x3b, 0xf4, 0xa8, 0xbe,
-	0x7d, 0x92, 0x27, 0x1f, 0xbd, 0x82, 0xc0, 0x37, 0xc7, 0x8f, 0x21, 0xf4, 0xed, 0x73, 0x4e, 0xd0,
+	0xd9, 0x14, 0x05, 0xf2, 0xd1, 0x1b, 0xe8, 0x04, 0x71, 0xfa, 0x04, 0xa2, 0x20, 0x9f, 0x0b, 0x46,
-	0x0c, 0x25, 0x27, 0x74, 0x27, 0x60, 0x02, 0x81, 0x11, 0xb2, 0x2a, 0xaa, 0x15, 0x39, 0x9a, 0xa1,
+	0xfa, 0x64, 0x70, 0xcc, 0xb7, 0x09, 0xca, 0xa0, 0xe3, 0x94, 0x2e, 0x8b, 0x72, 0xc6, 0x1a, 0x7d,
-	0x24, 0xa4, 0x5d, 0x18, 0x7f, 0x45, 0x10, 0xf8, 0xba, 0x18, 0xc3, 0xb8, 0x54, 0x62, 0xe3, 0xd2,
+	0x32, 0x88, 0xf8, 0x3a, 0x4c, 0x7e, 0x10, 0xe8, 0x84, 0x77, 0x29, 0x85, 0xd6, 0xdc, 0xa8, 0x25,
-	0x23, 0xea, 0xce, 0x56, 0x5b, 0x31, 0xc3, 0x5c, 0x5a, 0x44, 0xdd, 0x19, 0xdf, 0x87, 0x89, 0xe6,
+	0x96, 0xc7, 0x1c, 0xcf, 0x3e, 0x37, 0xcb, 0x5c, 0x86, 0x65, 0x31, 0xc7, 0x33, 0xbd, 0x0f, 0x6d,
-	0x9f, 0x6a, 0xe1, 0x9c, 0x46, 0xb4, 0x0d, 0xac, 0xea, 0x8a, 0x92, 0xb1, 0xeb, 0xd0, 0x06, 0xce,
+	0x2b, 0xbe, 0x48, 0x85, 0x4e, 0x63, 0x5e, 0x07, 0x3e, 0x8b, 0x8f, 0xb2, 0x16, 0x2a, 0xd4, 0x01,
-	0x57, 0xb5, 0xae, 0x99, 0x69, 0x14, 0x27, 0x13, 0xc7, 0xef, 0x04, 0x7c, 0x06, 0xa3, 0x6b, 0xfe,
+	0xfa, 0x2a, 0x17, 0x32, 0x73, 0x95, 0x11, 0xac, 0x8d, 0xfc, 0x36, 0x41, 0xbb, 0xd0, 0xbc, 0x10,
-	0x85, 0x1c, 0x3b, 0xdd, 0x1e, 0xe3, 0xef, 0x08, 0xfe, 0xbf, 0xfb, 0x5c, 0xfc, 0x1c, 0x26, 0xd5,
+	0xdf, 0xd8, 0x11, 0xe6, 0xfd, 0x31, 0xf9, 0xde, 0x80, 0xbb, 0xd7, 0xdb, 0xa5, 0x2f, 0xa0, 0x5d,
-	0x15, 0xbb, 0xe5, 0x7e, 0xfc, 0x0f, 0xf6, 0x07, 0x93, 0x5d, 0xb2, 0x5b, 0x4e, 0x5b, 0xca, 0xe1,
+	0x9e, 0x67, 0x57, 0x22, 0x8c, 0xff, 0xc1, 0xfe, 0x60, 0x26, 0x67, 0xd9, 0x95, 0xe0, 0x35, 0x85,
-	0x9f, 0x59, 0x6d, 0xfc, 0xd4, 0xff, 0x86, 0x7f, 0x64, 0xb5, 0xa1, 0x2d, 0x65, 0xf1, 0xb5, 0x62,
+	0xf8, 0xd7, 0x4c, 0xba, 0x30, 0xf5, 0xdb, 0xf0, 0xcf, 0x99, 0x74, 0xbc, 0xa6, 0x3c, 0xbe, 0x30,
-	0xa5, 0x21, 0xa3, 0x43, 0xf8, 0x1b, 0x7b, 0x4d, 0x5b, 0xca, 0xe2, 0x52, 0x35, 0x35, 0x27, 0xe3,
+	0xd9, 0xdc, 0xb1, 0xe6, 0x21, 0xfc, 0x9d, 0xbf, 0xe6, 0x35, 0xe5, 0x71, 0x6d, 0x2a, 0x29, 0x58,
-	0x43, 0xf8, 0xd2, 0x5e, 0xd3, 0x96, 0x8a, 0x2f, 0x21, 0x1a, 0x7a, 0xec, 0x3f, 0x22, 0x5b, 0xb8,
+	0xeb, 0x10, 0x3e, 0xf5, 0xd7, 0xbc, 0xa6, 0xe8, 0x2b, 0x88, 0xca, 0x99, 0x92, 0x0e, 0x0d, 0xb5,
-	0x29, 0x77, 0x1f, 0x91, 0x2d, 0xf0, 0x14, 0x60, 0xd3, 0x3e, 0x38, 0x5b, 0x68, 0xe7, 0x3d, 0xa4,
+	0xb1, 0xe4, 0xf1, 0x2d, 0x86, 0xc6, 0x4a, 0x3a, 0x34, 0xb5, 0xa5, 0x93, 0x33, 0x88, 0x77, 0xdb,
-	0x03, 0x25, 0x4e, 0x77, 0x95, 0xac, 0xfd, 0x3f, 0x78, 0xb4, 0xc7, 0x27, 0x3d, 0xef, 0xfc, 0x1f,
+	0xdb, 0xec, 0x70, 0x32, 0xc6, 0x05, 0xad, 0x77, 0x38, 0x19, 0xd3, 0x1e, 0xc0, 0xb2, 0x9e, 0xd5,
-	0xee, 0x1c, 0x6f, 0x7a, 0xd2, 0x59, 0xff, 0x87, 0xc7, 0x27, 0x30, 0x91, 0x9c, 0x2b, 0xed, 0x47,
+	0x64, 0x6c, 0xb1, 0xed, 0x88, 0xef, 0x64, 0x92, 0x74, 0xfb, 0x92, 0x17, 0xb9, 0xc1, 0x93, 0x3d,
-	0x7b, 0x6f, 0xf0, 0xf8, 0x25, 0xe7, 0x2a, 0xab, 0x4b, 0x41, 0x5b, 0xc2, 0x16, 0xc9, 0x59, 0x71,
+	0x7e, 0xb0, 0xe1, 0xb1, 0xf5, 0xc3, 0xca, 0xc9, 0x72, 0x43, 0x62, 0xd7, 0xff, 0xf0, 0xf8, 0x14,
-	0x2d, 0xca, 0xd2, 0x6d, 0xc9, 0x98, 0x76, 0x61, 0xfc, 0x0e, 0x4e, 0x3a, 0x18, 0x9f, 0xc3, 0xb1,
+	0xda, 0x5a, 0x08, 0x63, 0xc3, 0x56, 0xee, 0xed, 0x0c, 0x61, 0x2a, 0x84, 0x99, 0xc8, 0xb9, 0xe2,
-	0xc5, 0x7d, 0xa7, 0x88, 0xfa, 0x08, 0x3f, 0x85, 0x33, 0xbb, 0x24, 0x7c, 0x65, 0x49, 0xca, 0x0b,
+	0x35, 0xe1, 0x1f, 0xc9, 0xb3, 0xe2, 0x42, 0xcd, 0xe7, 0xf8, 0xc1, 0x5a, 0x7c, 0x1d, 0x26, 0x43,
-	0xa1, 0x56, 0x7e, 0x03, 0xf7, 0xf4, 0xd7, 0xd1, 0xb7, 0xed, 0x14, 0xfd, 0xd8, 0x4e, 0xd1, 0xcf,
+	0xe8, 0xde, 0x9c, 0xd8, 0x7f, 0x9b, 0xf9, 0x00, 0xc7, 0x6b, 0x01, 0x7a, 0x0a, 0x47, 0x5e, 0x22,
-	0xed, 0x14, 0xfd, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xf8, 0xc4, 0x6e, 0xd2, 0x03, 0x00, 0x00,
+	0xb8, 0x8b, 0x79, 0x88, 0xe8, 0x33, 0xe8, 0xfa, 0x3f, 0x29, 0x66, 0x9e, 0xe4, 0xa2, 0x50, 0x66,
+	0x16, 0x3e, 0xfc, 0x5e, 0xfe, 0x6d, 0xfc, 0x73, 0xd5, 0x23, 0xbf, 0x56, 0x3d, 0xf2, 0x7b, 0xd5,
+	0x23, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xba, 0x73, 0x8e, 0xbf, 0x41, 0x04, 0x00, 0x00,
 }
 
 func (m *RPC) Marshal() (dAtA []byte, err error) {
@@ -819,6 +878,20 @@ func (m *ControlMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if len(m.Idontwant) > 0 {
+		for iNdEx := len(m.Idontwant) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Idontwant[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintRpc(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
 	if len(m.Prune) > 0 {
 		for iNdEx := len(m.Prune) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -1044,6 +1117,42 @@ func (m *ControlPrune) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ControlIDontWant) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ControlIDontWant) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ControlIDontWant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.MessageIDs) > 0 {
+		for iNdEx := len(m.MessageIDs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.MessageIDs[iNdEx])
+			copy(dAtA[i:], m.MessageIDs[iNdEx])
+			i = encodeVarintRpc(dAtA, i, uint64(len(m.MessageIDs[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *PeerInfo) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1209,6 +1318,12 @@ func (m *ControlMessage) Size() (n int) {
 			n += 1 + l + sovRpc(uint64(l))
 		}
 	}
+	if len(m.Idontwant) > 0 {
+		for _, e := range m.Idontwant {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -1296,6 +1411,24 @@ func (m *ControlPrune) Size() (n int) {
 	return n
 }
 
+func (m *ControlIDontWant) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.MessageIDs) > 0 {
+		for _, s := range m.MessageIDs {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *PeerInfo) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2001,6 +2134,40 @@ func (m *ControlMessage) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Idontwant", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Idontwant = append(m.Idontwant, &ControlIDontWant{})
+			if err := m.Idontwant[len(m.Idontwant)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRpc(dAtA[iNdEx:])
@@ -2444,6 +2611,89 @@ func (m *ControlPrune) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ControlIDontWant) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ControlIDontWant: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ControlIDontWant: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.MessageIDs = append(m.MessageIDs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *PeerInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

vendor/github.com/libp2p/go-libp2p-pubsub/pb/rpc.proto

@@ -28,6 +28,7 @@ message ControlMessage {
 	repeated ControlIWant iwant = 2;
 	repeated ControlGraft graft = 3;
 	repeated ControlPrune prune = 4;
+	repeated ControlIDontWant idontwant = 5;
 }
 
 message ControlIHave {
@@ -51,7 +52,12 @@ message ControlPrune {
 	optional uint64 backoff = 3;
 }
 
+message ControlIDontWant {
+	// implementors from other languages should use bytes here - go protobuf emits invalid utf8 strings
+	repeated string messageIDs = 1;
+}
+
 message PeerInfo {
 	optional bytes peerID = 1;
 	optional bytes signedPeerRecord = 2;
-}
+}

vendor/github.com/libp2p/go-libp2p-pubsub/pb/trace.pb.go

@@ -1159,13 +1159,14 @@ func (m *TraceEvent_SubMeta) GetTopic() string {
 }
 
 type TraceEvent_ControlMeta struct {
-	Ihave                []*TraceEvent_ControlIHaveMeta `protobuf:"bytes,1,rep,name=ihave" json:"ihave,omitempty"`
+	Ihave                []*TraceEvent_ControlIHaveMeta     `protobuf:"bytes,1,rep,name=ihave" json:"ihave,omitempty"`
-	Iwant                []*TraceEvent_ControlIWantMeta `protobuf:"bytes,2,rep,name=iwant" json:"iwant,omitempty"`
+	Iwant                []*TraceEvent_ControlIWantMeta     `protobuf:"bytes,2,rep,name=iwant" json:"iwant,omitempty"`
-	Graft                []*TraceEvent_ControlGraftMeta `protobuf:"bytes,3,rep,name=graft" json:"graft,omitempty"`
+	Graft                []*TraceEvent_ControlGraftMeta     `protobuf:"bytes,3,rep,name=graft" json:"graft,omitempty"`
-	Prune                []*TraceEvent_ControlPruneMeta `protobuf:"bytes,4,rep,name=prune" json:"prune,omitempty"`
+	Prune                []*TraceEvent_ControlPruneMeta     `protobuf:"bytes,4,rep,name=prune" json:"prune,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
+	Idontwant            []*TraceEvent_ControlIDontWantMeta `protobuf:"bytes,5,rep,name=idontwant" json:"idontwant,omitempty"`
-	XXX_unrecognized     []byte                         `json:"-"`
+	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
-	XXX_sizecache        int32                          `json:"-"`
+	XXX_unrecognized     []byte                             `json:"-"`
+	XXX_sizecache        int32                              `json:"-"`
 }
 
 func (m *TraceEvent_ControlMeta) Reset()         { *m = TraceEvent_ControlMeta{} }
@@ -1229,6 +1230,13 @@ func (m *TraceEvent_ControlMeta) GetPrune() []*TraceEvent_ControlPruneMeta {
 	return nil
 }
 
+func (m *TraceEvent_ControlMeta) GetIdontwant() []*TraceEvent_ControlIDontWantMeta {
+	if m != nil {
+		return m.Idontwant
+	}
+	return nil
+}
+
 type TraceEvent_ControlIHaveMeta struct {
 	Topic                *string  `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"`
 	MessageIDs           [][]byte `protobuf:"bytes,2,rep,name=messageIDs" json:"messageIDs,omitempty"`
@@ -1433,6 +1441,53 @@ func (m *TraceEvent_ControlPruneMeta) GetPeers() [][]byte {
 	return nil
 }
 
+type TraceEvent_ControlIDontWantMeta struct {
+	MessageIDs           [][]byte `protobuf:"bytes,1,rep,name=messageIDs" json:"messageIDs,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TraceEvent_ControlIDontWantMeta) Reset()         { *m = TraceEvent_ControlIDontWantMeta{} }
+func (m *TraceEvent_ControlIDontWantMeta) String() string { return proto.CompactTextString(m) }
+func (*TraceEvent_ControlIDontWantMeta) ProtoMessage()    {}
+func (*TraceEvent_ControlIDontWantMeta) Descriptor() ([]byte, []int) {
+	return fileDescriptor_0571941a1d628a80, []int{0, 21}
+}
+func (m *TraceEvent_ControlIDontWantMeta) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TraceEvent_ControlIDontWantMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TraceEvent_ControlIDontWantMeta.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *TraceEvent_ControlIDontWantMeta) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TraceEvent_ControlIDontWantMeta.Merge(m, src)
+}
+func (m *TraceEvent_ControlIDontWantMeta) XXX_Size() int {
+	return m.Size()
+}
+func (m *TraceEvent_ControlIDontWantMeta) XXX_DiscardUnknown() {
+	xxx_messageInfo_TraceEvent_ControlIDontWantMeta.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TraceEvent_ControlIDontWantMeta proto.InternalMessageInfo
+
+func (m *TraceEvent_ControlIDontWantMeta) GetMessageIDs() [][]byte {
+	if m != nil {
+		return m.MessageIDs
+	}
+	return nil
+}
+
 type TraceEventBatch struct {
 	Batch                []*TraceEvent `protobuf:"bytes,1,rep,name=batch" json:"batch,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
@@ -1504,76 +1559,79 @@ func init() {
 	proto.RegisterType((*TraceEvent_ControlIWantMeta)(nil), "pubsub.pb.TraceEvent.ControlIWantMeta")
 	proto.RegisterType((*TraceEvent_ControlGraftMeta)(nil), "pubsub.pb.TraceEvent.ControlGraftMeta")
 	proto.RegisterType((*TraceEvent_ControlPruneMeta)(nil), "pubsub.pb.TraceEvent.ControlPruneMeta")
+	proto.RegisterType((*TraceEvent_ControlIDontWantMeta)(nil), "pubsub.pb.TraceEvent.ControlIDontWantMeta")
 	proto.RegisterType((*TraceEventBatch)(nil), "pubsub.pb.TraceEventBatch")
 }
 
 func init() { proto.RegisterFile("trace.proto", fileDescriptor_0571941a1d628a80) }
 
 var fileDescriptor_0571941a1d628a80 = []byte{
-	// 999 bytes of a gzipped FileDescriptorProto
+	// 1027 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x51, 0x6f, 0xda, 0x56,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xdf, 0x6e, 0xe2, 0x46,
-	0x14, 0xc7, 0xe7, 0x00, 0x01, 0x0e, 0x84, 0x78, 0x77, 0x6d, 0x65, 0xb1, 0x36, 0x62, 0x59, 0x55,
+	0x14, 0xc6, 0xeb, 0x80, 0x03, 0x1c, 0x08, 0x71, 0xa7, 0xd9, 0xd6, 0x72, 0x77, 0x23, 0x9a, 0xae,
-	0x21, 0x4d, 0x42, 0x6a, 0xa4, 0xa9, 0x0f, 0x6b, 0xab, 0x11, 0xec, 0x26, 0x44, 0x24, 0xb1, 0x0e,
+	0x56, 0xa8, 0x95, 0x90, 0x36, 0x52, 0xbb, 0x17, 0xdd, 0x5d, 0x95, 0x60, 0x6f, 0x42, 0x44, 0x12,
-	0x24, 0x7b, 0xcc, 0x0c, 0xdc, 0x35, 0x8e, 0xc0, 0xb6, 0xec, 0x0b, 0x53, 0x9f, 0xf6, 0xb4, 0xef,
+	0x6b, 0x20, 0xe9, 0x65, 0x6a, 0x60, 0xba, 0x71, 0x04, 0xb6, 0x65, 0x0f, 0x54, 0x7b, 0xd5, 0xd7,
-	0xd6, 0xb7, 0xed, 0x23, 0x54, 0xf9, 0x24, 0xd3, 0xbd, 0xd7, 0x36, 0x36, 0xd8, 0xb4, 0x8b, 0xfa,
+	0xdb, 0xbb, 0xed, 0x23, 0x54, 0x79, 0x92, 0x6a, 0x66, 0xfc, 0x07, 0x83, 0xed, 0xec, 0x46, 0xb9,
-	0xe6, 0x73, 0xf3, 0xff, 0x9d, 0x7b, 0xce, 0xbd, 0xe7, 0x7f, 0x03, 0xd4, 0x98, 0x6f, 0x4d, 0x68,
+	0xf3, 0x19, 0xbe, 0xdf, 0x99, 0x33, 0x67, 0xce, 0x37, 0x02, 0xea, 0xd4, 0xb7, 0x26, 0xa4, 0xe3,
-	0xc7, 0xf3, 0x5d, 0xe6, 0x92, 0xaa, 0xb7, 0x18, 0x07, 0x8b, 0x71, 0xc7, 0x1b, 0x1f, 0x7e, 0x7a,
+	0xf9, 0x2e, 0x75, 0x51, 0xcd, 0x5b, 0x8c, 0x83, 0xc5, 0xb8, 0xe3, 0x8d, 0x0f, 0xee, 0xbe, 0x03,
-	0x02, 0x30, 0xe2, 0x7f, 0x32, 0x96, 0xd4, 0x61, 0xa4, 0x03, 0x45, 0xf6, 0xc1, 0xa3, 0x9a, 0xd2,
+	0x18, 0xb1, 0x9f, 0x8c, 0x25, 0x71, 0x28, 0xea, 0x40, 0x99, 0x7e, 0xf0, 0x88, 0x2a, 0xb5, 0xa4,
-	0x52, 0xda, 0x8d, 0xa3, 0x66, 0x27, 0x16, 0x76, 0x56, 0xa2, 0xce, 0xe8, 0x83, 0x47, 0x51, 0xe8,
+	0x76, 0xf3, 0x50, 0xeb, 0xc4, 0xc2, 0x4e, 0x22, 0xea, 0x8c, 0x3e, 0x78, 0x04, 0x73, 0x1d, 0xfa,
-	0xc8, 0x13, 0xd8, 0xf5, 0x28, 0xf5, 0xfb, 0xba, 0xb6, 0xd3, 0x52, 0xda, 0x75, 0x0c, 0x23, 0xf2,
+	0x16, 0xb6, 0x3d, 0x42, 0xfc, 0xbe, 0xae, 0x6e, 0xb5, 0xa4, 0x76, 0x03, 0x87, 0x11, 0x7a, 0x0a,
-	0x14, 0xaa, 0xcc, 0x9e, 0xd3, 0x80, 0x59, 0x73, 0x4f, 0x2b, 0xb4, 0x94, 0x76, 0x01, 0x57, 0x0b,
+	0x35, 0x6a, 0xcf, 0x49, 0x40, 0xad, 0xb9, 0xa7, 0x96, 0x5a, 0x52, 0xbb, 0x84, 0x93, 0x05, 0x34,
-	0x64, 0x00, 0x0d, 0x6f, 0x31, 0x9e, 0xd9, 0xc1, 0xed, 0x39, 0x0d, 0x02, 0xeb, 0x3d, 0xd5, 0x8a,
+	0x80, 0xa6, 0xb7, 0x18, 0xcf, 0xec, 0xe0, 0xe6, 0x8c, 0x04, 0x81, 0xf5, 0x9e, 0xa8, 0xe5, 0x96,
-	0x2d, 0xa5, 0x5d, 0x3b, 0x7a, 0x9e, 0xbd, 0x9f, 0x99, 0xd2, 0xe2, 0x1a, 0x4b, 0xfa, 0xb0, 0xe7,
+	0xd4, 0xae, 0x1f, 0x3e, 0xcf, 0xde, 0xcf, 0x4c, 0x69, 0xf1, 0x1a, 0x8b, 0xfa, 0xb0, 0xe3, 0x93,
-	0xd3, 0x3b, 0x3a, 0x61, 0x51, 0xb2, 0x92, 0x48, 0xf6, 0x63, 0x76, 0x32, 0x4c, 0x4a, 0x31, 0x4d,
+	0x5b, 0x32, 0xa1, 0x51, 0x32, 0x99, 0x27, 0xfb, 0x31, 0x3b, 0x19, 0x5e, 0x95, 0xe2, 0x34, 0x89,
-	0x12, 0x04, 0x75, 0xba, 0xf0, 0x66, 0xf6, 0xc4, 0x62, 0x34, 0xca, 0xb6, 0x2b, 0xb2, 0xbd, 0xc8,
+	0x30, 0x28, 0xd3, 0x85, 0x37, 0xb3, 0x27, 0x16, 0x25, 0x51, 0xb6, 0x6d, 0x9e, 0xed, 0x45, 0x76,
-	0xce, 0xa6, 0xaf, 0xa9, 0x71, 0x83, 0xe7, 0xcd, 0x4e, 0xe9, 0xcc, 0x5e, 0x52, 0x3f, 0xca, 0x58,
+	0x36, 0x7d, 0x4d, 0x8d, 0x37, 0x78, 0x76, 0xd8, 0x29, 0x99, 0xd9, 0x4b, 0xe2, 0x47, 0x19, 0x2b,
-	0xde, 0xd6, 0xac, 0x9e, 0xd2, 0xe2, 0x1a, 0x4b, 0x5e, 0x41, 0xd9, 0x9a, 0x4e, 0x4d, 0x4a, 0x7d,
+	0x45, 0x87, 0xd5, 0x53, 0x5a, 0xbc, 0xc6, 0xa2, 0x57, 0x50, 0xb1, 0xa6, 0x53, 0x93, 0x10, 0x5f,
-	0xad, 0x22, 0xd2, 0x3c, 0xcb, 0x4e, 0xd3, 0x95, 0x22, 0x8c, 0xd4, 0xe4, 0x57, 0x00, 0x9f, 0xce,
+	0xad, 0xf2, 0x34, 0xcf, 0xb2, 0xd3, 0x74, 0x85, 0x08, 0x47, 0x6a, 0xf4, 0x3b, 0x80, 0x4f, 0xe6,
-	0xdd, 0x25, 0x15, 0x6c, 0x55, 0xb0, 0xad, 0xbc, 0x23, 0x8a, 0x74, 0x98, 0x60, 0xf8, 0xd6, 0x3e,
+	0xee, 0x92, 0x70, 0xb6, 0xc6, 0xd9, 0x56, 0x5e, 0x8b, 0x22, 0x1d, 0x5e, 0x61, 0xd8, 0xd6, 0x3e,
-	0x9d, 0x2c, 0xd1, 0xec, 0x69, 0xb0, 0x6d, 0x6b, 0x94, 0x22, 0x8c, 0xd4, 0x1c, 0x0c, 0xa8, 0x33,
+	0x99, 0x2c, 0xb1, 0xd9, 0x53, 0xa1, 0x68, 0x6b, 0x2c, 0x44, 0x38, 0x52, 0x33, 0x30, 0x20, 0xce,
-	0xe5, 0x60, 0x6d, 0x1b, 0x38, 0x94, 0x22, 0x8c, 0xd4, 0x1c, 0x9c, 0xfa, 0xae, 0xc7, 0xc1, 0xfa,
+	0x94, 0x81, 0xf5, 0x22, 0x70, 0x28, 0x44, 0x38, 0x52, 0x33, 0x70, 0xea, 0xbb, 0x1e, 0x03, 0x1b,
-	0x36, 0x50, 0x97, 0x22, 0x8c, 0xd4, 0x7c, 0x8c, 0xef, 0x5c, 0xdb, 0xd1, 0xf6, 0x04, 0x95, 0x33,
+	0x45, 0xa0, 0x2e, 0x44, 0x38, 0x52, 0xb3, 0x31, 0xbe, 0x75, 0x6d, 0x47, 0xdd, 0xe1, 0x54, 0xce,
-	0xc6, 0x67, 0xae, 0xed, 0xa0, 0xd0, 0x91, 0x97, 0x50, 0x9a, 0x51, 0x6b, 0x49, 0xb5, 0x86, 0x00,
+	0x18, 0x9f, 0xba, 0xb6, 0x83, 0xb9, 0x0e, 0xbd, 0x04, 0x79, 0x46, 0xac, 0x25, 0x51, 0x9b, 0x1c,
-	0xbe, 0xcf, 0x06, 0x06, 0x5c, 0x82, 0x52, 0xc9, 0x91, 0xf7, 0xbe, 0xf5, 0x07, 0xd3, 0xf6, 0xb7,
+	0xf8, 0x3e, 0x1b, 0x18, 0x30, 0x09, 0x16, 0x4a, 0x86, 0xbc, 0xf7, 0xad, 0xbf, 0xa8, 0xba, 0x5b,
-	0x21, 0x27, 0x5c, 0x82, 0x52, 0xc9, 0x11, 0xcf, 0x5f, 0x38, 0x54, 0x53, 0xb7, 0x21, 0x26, 0x97,
+	0x84, 0x1c, 0x33, 0x09, 0x16, 0x4a, 0x86, 0x78, 0xfe, 0xc2, 0x21, 0xaa, 0x52, 0x84, 0x98, 0x4c,
-	0xa0, 0x54, 0x36, 0x75, 0x68, 0xa4, 0xa7, 0x9f, 0x3b, 0x6b, 0x2e, 0x3f, 0xfb, 0xba, 0xb0, 0x69,
+	0x82, 0x85, 0x52, 0xd3, 0xa1, 0x99, 0x9e, 0x7e, 0xe6, 0xac, 0xb9, 0xf8, 0xec, 0xeb, 0xdc, 0xa6,
-	0x1d, 0x57, 0x0b, 0xe4, 0x11, 0x94, 0x98, 0xeb, 0xd9, 0x13, 0x61, 0xc7, 0x2a, 0xca, 0xa0, 0xf9,
+	0x0d, 0x9c, 0x2c, 0xa0, 0x3d, 0x90, 0xa9, 0xeb, 0xd9, 0x13, 0x6e, 0xc7, 0x1a, 0x16, 0x81, 0xf6,
-	0x17, 0xec, 0xa5, 0xc6, 0xfe, 0x33, 0x49, 0x0e, 0xa1, 0xee, 0xd3, 0x09, 0xb5, 0x97, 0x74, 0xfa,
+	0x0f, 0xec, 0xa4, 0xc6, 0xfe, 0x9e, 0x24, 0x07, 0xd0, 0xf0, 0xc9, 0x84, 0xd8, 0x4b, 0x32, 0x7d,
-	0xce, 0x77, 0xe7, 0xa1, 0xb5, 0x53, 0x6b, 0xdc, 0xf8, 0x3e, 0xb5, 0x02, 0xd7, 0x11, 0xee, 0xae,
+	0xe7, 0xbb, 0xf3, 0xd0, 0xda, 0xa9, 0x35, 0x66, 0x7c, 0x9f, 0x58, 0x81, 0xeb, 0x70, 0x77, 0xd7,
-	0x62, 0x18, 0xad, 0x0a, 0x28, 0x26, 0x0b, 0xb8, 0x03, 0x75, 0xdd, 0x29, 0x5f, 0xa1, 0x86, 0x78,
+	0x70, 0x18, 0x25, 0x05, 0x94, 0x57, 0x0b, 0xb8, 0x05, 0x65, 0xdd, 0x29, 0x8f, 0x50, 0x43, 0xbc,
-	0xaf, 0x42, 0x72, 0xaf, 0x5b, 0x68, 0xa4, 0x3d, 0xf4, 0x90, 0x23, 0xdb, 0xd8, 0xbf, 0xb0, 0xb9,
+	0x57, 0x69, 0x75, 0xaf, 0x1b, 0x68, 0xa6, 0x3d, 0xf4, 0x90, 0x96, 0x6d, 0xec, 0x5f, 0xda, 0xdc,
-	0x7f, 0xf3, 0x15, 0x94, 0x43, 0x9b, 0x25, 0xde, 0x41, 0x25, 0xf5, 0x0e, 0x3e, 0xe2, 0x57, 0xee,
+	0x5f, 0x7b, 0x05, 0x95, 0xd0, 0x66, 0x2b, 0xef, 0xa0, 0x94, 0x7a, 0x07, 0xf7, 0xd8, 0x95, 0xbb,
-	0x32, 0x37, 0x4a, 0x2e, 0x82, 0xe6, 0x73, 0x80, 0x95, 0xc7, 0xf2, 0xd8, 0xe6, 0xef, 0x50, 0x0e,
+	0xd4, 0x8d, 0x92, 0xf3, 0x40, 0x7b, 0x0e, 0x90, 0x78, 0x2c, 0x8f, 0xd5, 0xfe, 0x84, 0x4a, 0x68,
-	0xad, 0xb4, 0x51, 0x8d, 0x92, 0x71, 0x1a, 0x2f, 0xa1, 0x38, 0xa7, 0xcc, 0x12, 0x3b, 0xe5, 0x7b,
+	0xa5, 0x8d, 0x6a, 0xa4, 0x8c, 0x6e, 0xbc, 0x84, 0xf2, 0x9c, 0x50, 0x8b, 0xef, 0x94, 0xef, 0x4d,
-	0xd3, 0xec, 0x9d, 0x53, 0x66, 0xa1, 0x90, 0x36, 0x47, 0x50, 0x0e, 0x3d, 0xc7, 0x8b, 0xe0, 0xae,
+	0xb3, 0x77, 0x46, 0xa8, 0x85, 0xb9, 0x54, 0x1b, 0x41, 0x25, 0xf4, 0x1c, 0x2b, 0x82, 0xb9, 0x6e,
-	0x1b, 0xb9, 0x51, 0x11, 0x32, 0x7a, 0x60, 0xd6, 0xd0, 0x90, 0x5f, 0x33, 0xeb, 0x53, 0x28, 0x72,
+	0xe4, 0x46, 0x45, 0x88, 0xe8, 0x81, 0x59, 0x43, 0x43, 0x3e, 0x66, 0xd6, 0xa7, 0x50, 0x66, 0x86,
-	0xc3, 0xae, 0xae, 0x4b, 0x49, 0x5e, 0xfa, 0x33, 0x28, 0x09, 0x77, 0xe6, 0x18, 0xe0, 0x67, 0x28,
+	0x4d, 0xae, 0x4b, 0x5a, 0xbd, 0xf4, 0x67, 0x20, 0x73, 0x77, 0xe6, 0x18, 0xe0, 0x17, 0x90, 0xb9,
-	0x09, 0x27, 0x6e, 0xbb, 0xa7, 0x6c, 0x4c, 0xb8, 0xf1, 0x7f, 0x62, 0x1f, 0x15, 0x28, 0x87, 0xc5,
+	0x13, 0x8b, 0xee, 0x29, 0x1b, 0xe3, 0x6e, 0xfc, 0x42, 0xec, 0xa3, 0x04, 0x95, 0xb0, 0x78, 0xf4,
-	0x93, 0x37, 0x50, 0x09, 0x47, 0x2d, 0xd0, 0x94, 0x56, 0xa1, 0x5d, 0x3b, 0xfa, 0x21, 0xbb, 0xdb,
+	0x06, 0xaa, 0xe1, 0xa8, 0x05, 0xaa, 0xd4, 0x2a, 0xb5, 0xeb, 0x87, 0x3f, 0x64, 0x9f, 0x36, 0x1c,
-	0x70, 0x58, 0x45, 0xc7, 0x31, 0x42, 0xba, 0x50, 0x0f, 0x16, 0xe3, 0x60, 0xe2, 0xdb, 0x1e, 0xb3,
+	0x56, 0x7e, 0xe2, 0x18, 0x41, 0x5d, 0x68, 0x04, 0x8b, 0x71, 0x30, 0xf1, 0x6d, 0x8f, 0xda, 0xae,
-	0x5d, 0x47, 0xdb, 0x11, 0x29, 0xf2, 0xde, 0xcf, 0xc5, 0x58, 0xe0, 0x29, 0x84, 0xfc, 0x02, 0xe5,
+	0xa3, 0x6e, 0xf1, 0x14, 0x79, 0xef, 0xe7, 0x62, 0xcc, 0xf1, 0x14, 0x82, 0x7e, 0x83, 0xca, 0xc4,
-	0x89, 0xeb, 0x30, 0xdf, 0x9d, 0x89, 0x21, 0xce, 0x2d, 0xa0, 0x27, 0x45, 0x22, 0x43, 0x44, 0x34,
+	0x75, 0xa8, 0xef, 0xce, 0xf8, 0x10, 0xe7, 0x16, 0xd0, 0x13, 0x22, 0x9e, 0x21, 0x22, 0xb4, 0x2e,
-	0xbb, 0x50, 0x4b, 0x14, 0xf6, 0xa0, 0xc7, 0xe7, 0x0d, 0x94, 0xc3, 0xc2, 0x38, 0x1e, 0x96, 0x36,
+	0xd4, 0x57, 0x0a, 0x7b, 0xd0, 0xe3, 0xf3, 0x06, 0x2a, 0x61, 0x61, 0x0c, 0x0f, 0x4b, 0x1b, 0x8b,
-	0x96, 0x3f, 0x31, 0x2a, 0xb8, 0x5a, 0xc8, 0xc1, 0xff, 0xde, 0x81, 0x5a, 0xa2, 0x34, 0xf2, 0x1a,
+	0xbf, 0x18, 0x55, 0x9c, 0x2c, 0xe4, 0xe0, 0x9f, 0xb6, 0xa0, 0xbe, 0x52, 0x1a, 0x7a, 0x0d, 0xb2,
-	0x4a, 0xf6, 0x2d, 0x7f, 0xaa, 0xe5, 0x69, 0xbe, 0xd8, 0xda, 0x4c, 0xff, 0xd4, 0x5a, 0xca, 0x23,
+	0x7d, 0xc3, 0x9e, 0x6a, 0xd1, 0xcd, 0x17, 0x85, 0x87, 0xe9, 0x9f, 0x58, 0x4b, 0xd1, 0x52, 0x01,
-	0x95, 0x90, 0xa0, 0xff, 0xb4, 0x1c, 0x16, 0x1e, 0xe4, 0x67, 0xe8, 0xdf, 0x2c, 0x87, 0x85, 0x34,
+	0x71, 0xfa, 0x6f, 0xcb, 0xa1, 0x61, 0x23, 0xef, 0xa1, 0xff, 0xb0, 0x1c, 0x1a, 0xd2, 0x0c, 0x62,
-	0x87, 0x38, 0x2d, 0xdf, 0xfc, 0xc2, 0x17, 0xd0, 0x62, 0xe0, 0x24, 0x2d, 0x9f, 0xff, 0xd7, 0xd1,
+	0xb4, 0x78, 0xf3, 0x4b, 0x9f, 0x41, 0xf3, 0x81, 0x13, 0xb4, 0x78, 0xfe, 0x5f, 0x47, 0xcf, 0x7f,
-	0xf3, 0x5f, 0xfc, 0x02, 0x5a, 0xcc, 0x9d, 0xa4, 0xe5, 0x7f, 0x82, 0x53, 0x50, 0xd7, 0x9b, 0xca,
+	0xf9, 0x33, 0x68, 0x3e, 0x77, 0x82, 0xe6, 0x10, 0x3a, 0x81, 0x9a, 0x3d, 0x75, 0x1d, 0xca, 0xab,
-	0xf6, 0x02, 0x39, 0x00, 0x88, 0xef, 0x24, 0x10, 0x8d, 0xd6, 0x31, 0xb1, 0xd2, 0x3c, 0x5a, 0x65,
+	0x97, 0x79, 0x86, 0x9f, 0x8a, 0xab, 0xd7, 0x5d, 0x87, 0xc6, 0x27, 0x48, 0x60, 0xed, 0x04, 0x94,
-	0x8a, 0x1a, 0x5c, 0x63, 0x94, 0x0d, 0xa6, 0x1d, 0x33, 0x71, 0x5b, 0x39, 0x4e, 0x7c, 0x1b, 0x2b,
+	0xf5, 0xf6, 0x64, 0xbb, 0x0a, 0xed, 0x03, 0xc4, 0xb7, 0x1b, 0xf0, 0x96, 0x35, 0xf0, 0xca, 0x8a,
-	0xe3, 0x16, 0x72, 0xea, 0xe4, 0x6f, 0x23, 0xa5, 0x7e, 0x54, 0xa2, 0x0c, 0x0e, 0xff, 0x51, 0xa0,
+	0x76, 0x98, 0x64, 0x8a, 0x36, 0x5a, 0x63, 0xa4, 0x0d, 0xa6, 0x1d, 0x33, 0x71, 0x83, 0x72, 0x3c,
-	0xc8, 0x7f, 0x60, 0x92, 0xef, 0x60, 0xdf, 0xbc, 0x3a, 0x1e, 0xf4, 0x87, 0xa7, 0x37, 0xe7, 0xc6,
+	0xfd, 0x36, 0x56, 0xc6, 0xcd, 0xc8, 0xa9, 0x93, 0xbd, 0xb2, 0x84, 0xf8, 0x51, 0x89, 0x22, 0xd0,
-	0x70, 0xd8, 0x3d, 0x31, 0xd4, 0x6f, 0x08, 0x81, 0x06, 0x1a, 0x67, 0x46, 0x6f, 0x14, 0xaf, 0x29,
+	0x7e, 0x85, 0xbd, 0xac, 0x56, 0xdc, 0x57, 0xe1, 0xc1, 0x27, 0x09, 0xca, 0xec, 0x2f, 0x2e, 0xfa,
-	0xe4, 0x31, 0x7c, 0xab, 0x5f, 0x99, 0x83, 0x7e, 0xaf, 0x3b, 0x32, 0xe2, 0xe5, 0x1d, 0xce, 0xeb,
+	0x06, 0x76, 0xcd, 0xcb, 0xa3, 0x41, 0x7f, 0x78, 0x72, 0x7d, 0x66, 0x0c, 0x87, 0xdd, 0x63, 0x43,
-	0xc6, 0xa0, 0x7f, 0x6d, 0x60, 0xbc, 0x58, 0x20, 0x75, 0xa8, 0x74, 0x75, 0xfd, 0xc6, 0x34, 0x0c,
+	0xf9, 0x0a, 0x21, 0x68, 0x62, 0xe3, 0xd4, 0xe8, 0x8d, 0xe2, 0x35, 0x09, 0x3d, 0x81, 0xaf, 0xf5,
-	0x54, 0x8b, 0x64, 0x1f, 0x6a, 0x68, 0x9c, 0x5f, 0x5e, 0x1b, 0x72, 0xa1, 0xc4, 0xff, 0x8c, 0x46,
+	0x4b, 0x73, 0xd0, 0xef, 0x75, 0x47, 0x46, 0xbc, 0xbc, 0xc5, 0x78, 0xdd, 0x18, 0xf4, 0xaf, 0x0c,
-	0xef, 0xfa, 0x06, 0xcd, 0x9e, 0xba, 0xcb, 0xa3, 0xa1, 0x71, 0xa1, 0x8b, 0xa8, 0xcc, 0x23, 0x1d,
+	0x1c, 0x2f, 0x96, 0x50, 0x03, 0xaa, 0x5d, 0x5d, 0xbf, 0x36, 0x0d, 0x03, 0x2b, 0x65, 0xb4, 0x0b,
-	0x2f, 0x4d, 0x11, 0x55, 0x48, 0x05, 0x8a, 0x67, 0x97, 0xfd, 0x0b, 0xb5, 0x4a, 0xaa, 0x50, 0x1a,
+	0x75, 0x6c, 0x9c, 0x5d, 0x5c, 0x19, 0x62, 0x41, 0x66, 0x3f, 0x63, 0xa3, 0x77, 0x75, 0x8d, 0xcd,
-	0x18, 0xdd, 0x6b, 0x43, 0x05, 0xfe, 0x79, 0x82, 0xdd, 0x77, 0x23, 0xb5, 0xc6, 0x3f, 0x4d, 0xbc,
+	0x9e, 0xb2, 0xcd, 0xa2, 0xa1, 0x71, 0xae, 0xf3, 0xa8, 0xc2, 0x22, 0x1d, 0x5f, 0x98, 0x3c, 0xaa,
-	0xba, 0x30, 0xd4, 0xfa, 0xe1, 0x5b, 0xd8, 0x5f, 0xdd, 0xef, 0xb1, 0xc5, 0x26, 0xb7, 0xe4, 0x27,
+	0xa2, 0x2a, 0x94, 0x4f, 0x2f, 0xfa, 0xe7, 0x4a, 0x0d, 0xd5, 0x40, 0x1e, 0x18, 0xdd, 0x2b, 0x43,
-	0x28, 0x8d, 0xf9, 0x47, 0x38, 0xc4, 0x8f, 0x33, 0x47, 0x01, 0xa5, 0xe6, 0xb8, 0xfe, 0xf1, 0xfe,
+	0x01, 0xf6, 0x79, 0x8c, 0xbb, 0xef, 0x46, 0x4a, 0x9d, 0x7d, 0x9a, 0xf8, 0xf2, 0xdc, 0x50, 0x1a,
-	0x40, 0xf9, 0xf7, 0xfe, 0x40, 0xf9, 0x74, 0x7f, 0xa0, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xdb,
+	0x07, 0x6f, 0x61, 0x37, 0x99, 0x8f, 0x23, 0x8b, 0x4e, 0x6e, 0xd0, 0xcf, 0x20, 0x8f, 0xd9, 0x47,
-	0x3a, 0x1c, 0xe4, 0xc9, 0x0b, 0x00, 0x00,
+	0x68, 0xa3, 0x27, 0x99, 0xa3, 0x84, 0x85, 0xe6, 0xa8, 0xf1, 0xf1, 0x6e, 0x5f, 0xfa, 0xf7, 0x6e,
+	0x5f, 0xfa, 0xef, 0x6e, 0x5f, 0xfa, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x17, 0x7f, 0xbd, 0x0d, 0x4b,
+	0x0c, 0x00, 0x00,
 }
 
 func (m *TraceEvent) Marshal() (dAtA []byte, err error) {
@@ -2509,6 +2567,20 @@ func (m *TraceEvent_ControlMeta) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if len(m.Idontwant) > 0 {
+		for iNdEx := len(m.Idontwant) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Idontwant[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTrace(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
 	if len(m.Prune) > 0 {
 		for iNdEx := len(m.Prune) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -2724,6 +2796,42 @@ func (m *TraceEvent_ControlPruneMeta) MarshalToSizedBuffer(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }
 
+func (m *TraceEvent_ControlIDontWantMeta) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TraceEvent_ControlIDontWantMeta) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TraceEvent_ControlIDontWantMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.MessageIDs) > 0 {
+		for iNdEx := len(m.MessageIDs) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.MessageIDs[iNdEx])
+			copy(dAtA[i:], m.MessageIDs[iNdEx])
+			i = encodeVarintTrace(dAtA, i, uint64(len(m.MessageIDs[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *TraceEventBatch) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3211,6 +3319,12 @@ func (m *TraceEvent_ControlMeta) Size() (n int) {
 			n += 1 + l + sovTrace(uint64(l))
 		}
 	}
+	if len(m.Idontwant) > 0 {
+		for _, e := range m.Idontwant {
+			l = e.Size()
+			n += 1 + l + sovTrace(uint64(l))
+		}
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -3295,6 +3409,24 @@ func (m *TraceEvent_ControlPruneMeta) Size() (n int) {
 	return n
 }
 
+func (m *TraceEvent_ControlIDontWantMeta) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.MessageIDs) > 0 {
+		for _, b := range m.MessageIDs {
+			l = len(b)
+			n += 1 + l + sovTrace(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *TraceEventBatch) Size() (n int) {
 	if m == nil {
 		return 0
@@ -6032,6 +6164,40 @@ func (m *TraceEvent_ControlMeta) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Idontwant", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTrace
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTrace
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTrace
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Idontwant = append(m.Idontwant, &TraceEvent_ControlIDontWantMeta{})
+			if err := m.Idontwant[len(m.Idontwant)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTrace(dAtA[iNdEx:])
@@ -6453,6 +6619,89 @@ func (m *TraceEvent_ControlPruneMeta) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TraceEvent_ControlIDontWantMeta) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTrace
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ControlIDontWantMeta: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ControlIDontWantMeta: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MessageIDs", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTrace
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTrace
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTrace
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.MessageIDs = append(m.MessageIDs, make([]byte, postIndex-iNdEx))
+			copy(m.MessageIDs[len(m.MessageIDs)-1], dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTrace(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTrace
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *TraceEventBatch) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

vendor/github.com/libp2p/go-libp2p-pubsub/pb/trace.proto

@@ -124,6 +124,7 @@ message TraceEvent {
     repeated ControlIWantMeta iwant = 2;
     repeated ControlGraftMeta graft = 3;
     repeated ControlPruneMeta prune = 4;
+    repeated ControlIDontWantMeta idontwant = 5;
   }
 
   message ControlIHaveMeta {
@@ -143,6 +144,10 @@ message TraceEvent {
     optional string topic = 1;
     repeated bytes peers = 2;
   }
+
+  message ControlIDontWantMeta {
+    repeated bytes messageIDs = 1;
+  }
 }
 
 message TraceEventBatch {

vendor/github.com/libp2p/go-libp2p-pubsub/peer_notify.go

@@ -0,0 +1,112 @@
+package pubsub
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p/core/event"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/protocol"
+)
+
+func (ps *PubSub) watchForNewPeers(ctx context.Context) {
+	// We don't bother subscribing to "connectivity" events because we always run identify after
+	// every new connection.
+	sub, err := ps.host.EventBus().Subscribe([]interface{}{
+		&event.EvtPeerIdentificationCompleted{},
+		&event.EvtPeerProtocolsUpdated{},
+	})
+	if err != nil {
+		log.Errorf("failed to subscribe to peer identification events: %v", err)
+		return
+	}
+	defer sub.Close()
+
+	ps.newPeersPrioLk.RLock()
+	ps.newPeersMx.Lock()
+	for _, pid := range ps.host.Network().Peers() {
+		if ps.host.Network().Connectedness(pid) != network.Connected {
+			continue
+		}
+		ps.newPeersPend[pid] = struct{}{}
+	}
+	ps.newPeersMx.Unlock()
+	ps.newPeersPrioLk.RUnlock()
+
+	select {
+	case ps.newPeers <- struct{}{}:
+	default:
+	}
+
+	var supportsProtocol func(protocol.ID) bool
+	if ps.protoMatchFunc != nil {
+		var supportedProtocols []func(protocol.ID) bool
+		for _, proto := range ps.rt.Protocols() {
+
+			supportedProtocols = append(supportedProtocols, ps.protoMatchFunc(proto))
+		}
+		supportsProtocol = func(proto protocol.ID) bool {
+			for _, fn := range supportedProtocols {
+				if (fn)(proto) {
+					return true
+				}
+			}
+			return false
+		}
+	} else {
+		supportedProtocols := make(map[protocol.ID]struct{})
+		for _, proto := range ps.rt.Protocols() {
+			supportedProtocols[proto] = struct{}{}
+		}
+		supportsProtocol = func(proto protocol.ID) bool {
+			_, ok := supportedProtocols[proto]
+			return ok
+		}
+	}
+
+	for ctx.Err() == nil {
+		var ev any
+		select {
+		case <-ctx.Done():
+			return
+		case ev = <-sub.Out():
+		}
+
+		var protos []protocol.ID
+		var peer peer.ID
+		switch ev := ev.(type) {
+		case event.EvtPeerIdentificationCompleted:
+			peer = ev.Peer
+			protos = ev.Protocols
+		case event.EvtPeerProtocolsUpdated:
+			peer = ev.Peer
+			protos = ev.Added
+		default:
+			continue
+		}
+
+		// We don't bother checking connectivity (connected and non-"limited") here because
+		// we'll check when actually handling the new peer.
+
+		for _, p := range protos {
+			if supportsProtocol(p) {
+				ps.notifyNewPeer(peer)
+				break
+			}
+		}
+	}
+
+}
+
+func (ps *PubSub) notifyNewPeer(peer peer.ID) {
+	ps.newPeersPrioLk.RLock()
+	ps.newPeersMx.Lock()
+	ps.newPeersPend[peer] = struct{}{}
+	ps.newPeersMx.Unlock()
+	ps.newPeersPrioLk.RUnlock()
+
+	select {
+	case ps.newPeers <- struct{}{}:
+	default:
+	}
+}

vendor/github.com/libp2p/go-libp2p-pubsub/pubsub.go

@@ -150,7 +150,7 @@ type PubSub struct {
 	blacklist     Blacklist
 	blacklistPeer chan peer.ID
 
-	peers map[peer.ID]chan *RPC
+	peers map[peer.ID]*rpcQueue
 
 	inboundStreamsMx sync.Mutex
 	inboundStreams   map[peer.ID]network.Stream
@@ -199,11 +199,14 @@ type PubSubRouter interface {
 	// EnoughPeers returns whether the router needs more peers before it's ready to publish new records.
 	// Suggested (if greater than 0) is a suggested number of peers that the router should need.
 	EnoughPeers(topic string, suggested int) bool
-	// AcceptFrom is invoked on any incoming message before pushing it to the validation pipeline
+	// AcceptFrom is invoked on any RPC envelope before pushing it to the validation pipeline
 	// or processing control information.
 	// Allows routers with internal scoring to vet peers before committing any processing resources
 	// to the message and implement an effective graylist and react to validation queue overload.
 	AcceptFrom(peer.ID) AcceptStatus
+	// PreValidation is invoked on messages in the RPC envelope right before pushing it to
+	// the validation pipeline
+	PreValidation([]*Message)
 	// HandleRPC is invoked to process control messages in the RPC envelope.
 	// It is invoked after subscriptions and payload messages have been processed.
 	HandleRPC(*RPC)
@@ -289,7 +292,7 @@ func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option
 		mySubs:                make(map[string]map[*Subscription]struct{}),
 		myRelays:              make(map[string]int),
 		topics:                make(map[string]map[peer.ID]struct{}),
-		peers:                 make(map[peer.ID]chan *RPC),
+		peers:                 make(map[peer.ID]*rpcQueue),
 		inboundStreams:        make(map[peer.ID]network.Stream),
 		blacklist:             NewMapBlacklist(),
 		blacklistPeer:         make(chan peer.ID),
@@ -331,14 +334,12 @@ func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option
 			h.SetStreamHandler(id, ps.handleNewStream)
 		}
 	}
-	h.Network().Notify((*PubSubNotif)(ps))
+	go ps.watchForNewPeers(ctx)
 
 	ps.val.Start(ps)
 
 	go ps.processLoop(ctx)
 
-	(*PubSubNotif)(ps).Initialize()
-
 	return ps, nil
 }
 
@@ -565,8 +566,8 @@ func WithAppSpecificRpcInspector(inspector func(peer.ID, *RPC) error) Option {
 func (p *PubSub) processLoop(ctx context.Context) {
 	defer func() {
 		// Clean up go routines.
-		for _, ch := range p.peers {
+		for _, queue := range p.peers {
-			close(ch)
+			queue.Close()
 		}
 		p.peers = nil
 		p.topics = nil
@@ -581,7 +582,7 @@ func (p *PubSub) processLoop(ctx context.Context) {
 		case s := <-p.newPeerStream:
 			pid := s.Conn().RemotePeer()
 
-			ch, ok := p.peers[pid]
+			q, ok := p.peers[pid]
 			if !ok {
 				log.Warn("new stream for unknown peer: ", pid)
 				s.Reset()
@@ -590,7 +591,7 @@ func (p *PubSub) processLoop(ctx context.Context) {
 
 			if p.blacklist.Contains(pid) {
 				log.Warn("closing stream for blacklisted peer: ", pid)
-				close(ch)
+				q.Close()
 				delete(p.peers, pid)
 				s.Reset()
 				continue
@@ -665,9 +666,9 @@ func (p *PubSub) processLoop(ctx context.Context) {
 			log.Infof("Blacklisting peer %s", pid)
 			p.blacklist.Add(pid)
 
-			ch, ok := p.peers[pid]
+			q, ok := p.peers[pid]
 			if ok {
-				close(ch)
+				q.Close()
 				delete(p.peers, pid)
 				for t, tmap := range p.topics {
 					if _, ok := tmap[pid]; ok {
@@ -698,6 +699,8 @@ func (p *PubSub) handlePendingPeers() {
 	p.newPeersPrioLk.Unlock()
 
 	for pid := range newPeers {
+		// Make sure we have a non-limited connection. We do this late because we may have
+		// disconnected in the meantime.
 		if p.host.Network().Connectedness(pid) != network.Connected {
 			continue
 		}
@@ -712,10 +715,10 @@ func (p *PubSub) handlePendingPeers() {
 			continue
 		}
 
-		messages := make(chan *RPC, p.peerOutboundQueueSize)
+		rpcQueue := newRpcQueue(p.peerOutboundQueueSize)
-		messages <- p.getHelloPacket()
+		rpcQueue.Push(p.getHelloPacket(), true)
-		go p.handleNewPeer(p.ctx, pid, messages)
+		go p.handleNewPeer(p.ctx, pid, rpcQueue)
-		p.peers[pid] = messages
+		p.peers[pid] = rpcQueue
 	}
 }
 
@@ -732,12 +735,12 @@ func (p *PubSub) handleDeadPeers() {
 	p.peerDeadPrioLk.Unlock()
 
 	for pid := range deadPeers {
-		ch, ok := p.peers[pid]
+		q, ok := p.peers[pid]
 		if !ok {
 			continue
 		}
 
-		close(ch)
+		q.Close()
 		delete(p.peers, pid)
 
 		for t, tmap := range p.topics {
@@ -759,10 +762,10 @@ func (p *PubSub) handleDeadPeers() {
 			// still connected, must be a duplicate connection being closed.
 			// we respawn the writer as we need to ensure there is a stream active
 			log.Debugf("peer declared dead but still connected; respawning writer: %s", pid)
-			messages := make(chan *RPC, p.peerOutboundQueueSize)
+			rpcQueue := newRpcQueue(p.peerOutboundQueueSize)
-			messages <- p.getHelloPacket()
+			rpcQueue.Push(p.getHelloPacket(), true)
-			p.peers[pid] = messages
+			p.peers[pid] = rpcQueue
-			go p.handleNewPeerWithBackoff(p.ctx, pid, backoffDelay, messages)
+			go p.handleNewPeerWithBackoff(p.ctx, pid, backoffDelay, rpcQueue)
 		}
 	}
 }
@@ -926,14 +929,14 @@ func (p *PubSub) announce(topic string, sub bool) {
 
 	out := rpcWithSubs(subopt)
 	for pid, peer := range p.peers {
-		select {
+		err := peer.Push(out, false)
-		case peer <- out:
+		if err != nil {
-			p.tracer.SendRPC(out, pid)
-		default:
 			log.Infof("Can't send announce message to peer %s: queue full; scheduling retry", pid)
 			p.tracer.DropRPC(out, pid)
 			go p.announceRetry(pid, topic, sub)
+			continue
 		}
+		p.tracer.SendRPC(out, pid)
 	}
 }
 
@@ -969,14 +972,14 @@ func (p *PubSub) doAnnounceRetry(pid peer.ID, topic string, sub bool) {
 	}
 
 	out := rpcWithSubs(subopt)
-	select {
+	err := peer.Push(out, false)
-	case peer <- out:
+	if err != nil {
-		p.tracer.SendRPC(out, pid)
-	default:
 		log.Infof("Can't send announce message to peer %s: queue full; scheduling retry", pid)
 		p.tracer.DropRPC(out, pid)
 		go p.announceRetry(pid, topic, sub)
+		return
 	}
+	p.tracer.SendRPC(out, pid)
 }
 
 // notifySubs sends a given message to all corresponding subscribers.
@@ -1102,13 +1105,21 @@ func (p *PubSub) handleIncomingRPC(rpc *RPC) {
 		p.tracer.ThrottlePeer(rpc.from)
 
 	case AcceptAll:
+		var toPush []*Message
 		for _, pmsg := range rpc.GetPublish() {
 			if !(p.subscribedToMsg(pmsg) || p.canRelayMsg(pmsg)) {
 				log.Debug("received message in topic we didn't subscribe to; ignoring message")
 				continue
 			}
 
-			p.pushMsg(&Message{pmsg, "", rpc.from, nil, false})
+			msg := &Message{pmsg, "", rpc.from, nil, false}
+			if p.shouldPush(msg) {
+				toPush = append(toPush, msg)
+			}
+		}
+		p.rt.PreValidation(toPush)
+		for _, msg := range toPush {
+			p.pushMsg(msg)
 		}
 	}
 
@@ -1125,27 +1136,28 @@ func DefaultPeerFilter(pid peer.ID, topic string) bool {
 	return true
 }
 
-// pushMsg pushes a message performing validation as necessary
+// shouldPush filters a message before validating and pushing it
-func (p *PubSub) pushMsg(msg *Message) {
+// It returns true if the message can be further validated and pushed
+func (p *PubSub) shouldPush(msg *Message) bool {
 	src := msg.ReceivedFrom
 	// reject messages from blacklisted peers
 	if p.blacklist.Contains(src) {
 		log.Debugf("dropping message from blacklisted peer %s", src)
 		p.tracer.RejectMessage(msg, RejectBlacklstedPeer)
-		return
+		return false
 	}
 
 	// even if they are forwarded by good peers
 	if p.blacklist.Contains(msg.GetFrom()) {
 		log.Debugf("dropping message from blacklisted source %s", src)
 		p.tracer.RejectMessage(msg, RejectBlacklistedSource)
-		return
+		return false
 	}
 
 	err := p.checkSigningPolicy(msg)
 	if err != nil {
 		log.Debugf("dropping message from %s: %s", src, err)
-		return
+		return false
 	}
 
 	// reject messages claiming to be from ourselves but not locally published
@@ -1153,16 +1165,24 @@ func (p *PubSub) pushMsg(msg *Message) {
 	if peer.ID(msg.GetFrom()) == self && src != self {
 		log.Debugf("dropping message claiming to be from self but forwarded from %s", src)
 		p.tracer.RejectMessage(msg, RejectSelfOrigin)
-		return
+		return false
 	}
 
 	// have we already seen and validated this message?
 	id := p.idGen.ID(msg)
 	if p.seenMessage(id) {
 		p.tracer.DuplicateMessage(msg)
-		return
+		return false
 	}
 
+	return true
+}
+
+// pushMsg pushes a message performing validation as necessary
+func (p *PubSub) pushMsg(msg *Message) {
+	src := msg.ReceivedFrom
+	id := p.idGen.ID(msg)
+
 	if !p.val.Push(src, msg) {
 		return
 	}

vendor/github.com/libp2p/go-libp2p-pubsub/randomsub.go

@@ -94,6 +94,8 @@ func (rs *RandomSubRouter) AcceptFrom(peer.ID) AcceptStatus {
 	return AcceptAll
 }
 
+func (rs *RandomSubRouter) PreValidation([]*Message) {}
+
 func (rs *RandomSubRouter) HandleRPC(rpc *RPC) {}
 
 func (rs *RandomSubRouter) Publish(msg *Message) {
@@ -144,18 +146,18 @@ func (rs *RandomSubRouter) Publish(msg *Message) {
 
 	out := rpcWithMessages(msg.Message)
 	for p := range tosend {
-		mch, ok := rs.p.peers[p]
+		q, ok := rs.p.peers[p]
 		if !ok {
 			continue
 		}
 
-		select {
+		err := q.Push(out, false)
-		case mch <- out:
+		if err != nil {
-			rs.tracer.SendRPC(out, p)
-		default:
 			log.Infof("dropping message to peer %s: queue full", p)
 			rs.tracer.DropRPC(out, p)
+			continue
 		}
+		rs.tracer.SendRPC(out, p)
 	}
 }
 

vendor/github.com/libp2p/go-libp2p-pubsub/rpc_queue.go

@@ -0,0 +1,147 @@
+package pubsub
+
+import (
+	"context"
+	"errors"
+	"sync"
+)
+
+var (
+	ErrQueueCancelled    = errors.New("rpc queue operation cancelled")
+	ErrQueueClosed       = errors.New("rpc queue closed")
+	ErrQueueFull         = errors.New("rpc queue full")
+	ErrQueuePushOnClosed = errors.New("push on closed rpc queue")
+)
+
+type priorityQueue struct {
+	normal   []*RPC
+	priority []*RPC
+}
+
+func (q *priorityQueue) Len() int {
+	return len(q.normal) + len(q.priority)
+}
+
+func (q *priorityQueue) NormalPush(rpc *RPC) {
+	q.normal = append(q.normal, rpc)
+}
+
+func (q *priorityQueue) PriorityPush(rpc *RPC) {
+	q.priority = append(q.priority, rpc)
+}
+
+func (q *priorityQueue) Pop() *RPC {
+	var rpc *RPC
+
+	if len(q.priority) > 0 {
+		rpc = q.priority[0]
+		q.priority[0] = nil
+		q.priority = q.priority[1:]
+	} else if len(q.normal) > 0 {
+		rpc = q.normal[0]
+		q.normal[0] = nil
+		q.normal = q.normal[1:]
+	}
+
+	return rpc
+}
+
+type rpcQueue struct {
+	dataAvailable  sync.Cond
+	spaceAvailable sync.Cond
+	// Mutex used to access queue
+	queueMu sync.Mutex
+	queue   priorityQueue
+
+	closed  bool
+	maxSize int
+}
+
+func newRpcQueue(maxSize int) *rpcQueue {
+	q := &rpcQueue{maxSize: maxSize}
+	q.dataAvailable.L = &q.queueMu
+	q.spaceAvailable.L = &q.queueMu
+	return q
+}
+
+func (q *rpcQueue) Push(rpc *RPC, block bool) error {
+	return q.push(rpc, false, block)
+}
+
+func (q *rpcQueue) UrgentPush(rpc *RPC, block bool) error {
+	return q.push(rpc, true, block)
+}
+
+func (q *rpcQueue) push(rpc *RPC, urgent bool, block bool) error {
+	q.queueMu.Lock()
+	defer q.queueMu.Unlock()
+
+	if q.closed {
+		panic(ErrQueuePushOnClosed)
+	}
+
+	for q.queue.Len() == q.maxSize {
+		if block {
+			q.spaceAvailable.Wait()
+			// It can receive a signal because the queue is closed.
+			if q.closed {
+				panic(ErrQueuePushOnClosed)
+			}
+		} else {
+			return ErrQueueFull
+		}
+	}
+	if urgent {
+		q.queue.PriorityPush(rpc)
+	} else {
+		q.queue.NormalPush(rpc)
+	}
+
+	q.dataAvailable.Signal()
+	return nil
+}
+
+// Note that, when the queue is empty and there are two blocked Pop calls, it
+// doesn't mean that the first Pop will get the item from the next Push. The
+// second Pop will probably get it instead.
+func (q *rpcQueue) Pop(ctx context.Context) (*RPC, error) {
+	q.queueMu.Lock()
+	defer q.queueMu.Unlock()
+
+	if q.closed {
+		return nil, ErrQueueClosed
+	}
+
+	unregisterAfterFunc := context.AfterFunc(ctx, func() {
+		// Wake up all the waiting routines. The only routine that correponds
+		// to this Pop call will return from the function. Note that this can
+		// be expensive, if there are too many waiting routines.
+		q.dataAvailable.Broadcast()
+	})
+	defer unregisterAfterFunc()
+
+	for q.queue.Len() == 0 {
+		select {
+		case <-ctx.Done():
+			return nil, ErrQueueCancelled
+		default:
+		}
+		q.dataAvailable.Wait()
+		// It can receive a signal because the queue is closed.
+		if q.closed {
+			return nil, ErrQueueClosed
+		}
+	}
+	rpc := q.queue.Pop()
+	q.spaceAvailable.Signal()
+	return rpc, nil
+}
+
+func (q *rpcQueue) Close() {
+	q.queueMu.Lock()
+	defer q.queueMu.Unlock()
+
+	q.closed = true
+	q.dataAvailable.Broadcast()
+	q.spaceAvailable.Broadcast()
+}

vendor/github.com/libp2p/go-libp2p-pubsub/timecache/time_cache.go

@@ -2,12 +2,8 @@ package timecache
 
 import (
 	"time"
-
-	logger "github.com/ipfs/go-log/v2"
 )
 
-var log = logger.Logger("pubsub/timecache")
-
 // Stategy is the TimeCache expiration strategy to use.
 type Strategy uint8
 

vendor/github.com/libp2p/go-libp2p-pubsub/trace.go

@@ -402,11 +402,23 @@ func (t *pubsubTracer) traceRPCMeta(rpc *RPC) *pb.TraceEvent_RPCMeta {
 			})
 		}
 
+		var idontwant []*pb.TraceEvent_ControlIDontWantMeta
+		for _, ctl := range rpc.Control.Idontwant {
+			var mids [][]byte
+			for _, mid := range ctl.MessageIDs {
+				mids = append(mids, []byte(mid))
+			}
+			idontwant = append(idontwant, &pb.TraceEvent_ControlIDontWantMeta{
+				MessageIDs: mids,
+			})
+		}
+
 		rpcMeta.Control = &pb.TraceEvent_ControlMeta{
-			Ihave: ihave,
+			Ihave:     ihave,
-			Iwant: iwant,
+			Iwant:     iwant,
-			Graft: graft,
+			Graft:     graft,
-			Prune: prune,
+			Prune:     prune,
+			Idontwant: idontwant,
 		}
 	}
 

vendor/github.com/libp2p/go-libp2p-pubsub/tracer.go

@@ -17,6 +17,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/peerstore"
 	"github.com/libp2p/go-libp2p/core/protocol"
 
+	//lint:ignore SA1019 "github.com/libp2p/go-msgio/protoio" is deprecated
 	"github.com/libp2p/go-msgio/protoio"
 )
 

vendor/github.com/libp2p/go-libp2p-pubsub/version.json

@@ -0,0 +1,3 @@
+{
+  "version": "v0.11.0"
+}

vendor/github.com/libp2p/go-libp2p/README.md

@@ -99,10 +99,12 @@ Some notable users of go-libp2p are:
 - [Status go](https://github.com/status-im/status-go) - Status bindings for go-ethereum, built by [Status.im](https://status.im/)
 - [Flow](https://github.com/onflow/flow-go) - A blockchain built to support games, apps, and digital assets built by [Dapper Labs](https://www.dapperlabs.com/)
 - [Swarm Bee](https://github.com/ethersphere/bee) - A client for connecting to the [Swarm network](https://www.ethswarm.org/)
-- [Elrond Go](https://github.com/multiversx/mx-chain-go) - The Go implementation of the the Elrond network protocol
+- [MultiversX Node](https://github.com/multiversx/mx-chain-go) - The Go implementation of the MultiversX network protocol
 - [Sonr](https://github.com/sonr-io/sonr) - A platform to integrate DID Documents, WebAuthn, and IPFS and manage digital identity and assets.
 - [EdgeVPN](https://github.com/mudler/edgevpn) - A decentralized, immutable, portable VPN and reverse proxy over p2p.
 - [Kairos](https://github.com/kairos-io/kairos) - A Kubernetes-focused, Cloud Native Linux meta-distribution.
 - [Oasis Core](https://github.com/oasisprotocol/oasis-core) - The consensus and runtime layers of the [Oasis protocol](https://oasisprotocol.org/).
+- [Spacemesh](https://github.com/spacemeshos/go-spacemesh/) - The Go implementation of the [Spacemesh protocol](https://spacemesh.io/), a novel layer one blockchain
+- [Tau](https://github.com/taubyte/tau/) - Open source distributed Platform as a Service (PaaS)
 
 Please open a pull request if you want your project (min. 250 GitHub stars) to be added here.

vendor/github.com/libp2p/go-libp2p/config/config.go

@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"errors"
 	"fmt"
+	"net"
 	"time"
 
 	"github.com/libp2p/go-libp2p/core/connmgr"
@@ -24,6 +25,7 @@ import (
 	"github.com/libp2p/go-libp2p/p2p/host/autonat"
 	"github.com/libp2p/go-libp2p/p2p/host/autorelay"
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+	blankhost "github.com/libp2p/go-libp2p/p2p/host/blank"
 	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
 	"github.com/libp2p/go-libp2p/p2p/host/peerstore/pstoremem"
 	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
@@ -34,10 +36,12 @@ import (
 	relayv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
 	"github.com/libp2p/go-libp2p/p2p/protocol/holepunch"
 	"github.com/libp2p/go-libp2p/p2p/transport/quicreuse"
+	libp2pwebrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc"
 	"github.com/prometheus/client_golang/prometheus"
 
 	ma "github.com/multiformats/go-multiaddr"
 	madns "github.com/multiformats/go-multiaddr-dns"
+	manet "github.com/multiformats/go-multiaddr/net"
 	"github.com/quic-go/quic-go"
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxevent"
@@ -131,6 +135,13 @@ type Config struct {
 	SwarmOpts []swarm.Option
 
 	DisableIdentifyAddressDiscovery bool
+
+	EnableAutoNATv2 bool
+
+	UDPBlackHoleSuccessCounter        *swarm.BlackHoleSuccessCounter
+	CustomUDPBlackHoleSuccessCounter  bool
+	IPv6BlackHoleSuccessCounter       *swarm.BlackHoleSuccessCounter
+	CustomIPv6BlackHoleSuccessCounter bool
 }
 
 func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swarm, error) {
@@ -165,7 +176,10 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 		return nil, err
 	}
 
-	opts := cfg.SwarmOpts
+	opts := append(cfg.SwarmOpts,
+		swarm.WithUDPBlackHoleSuccessCounter(cfg.UDPBlackHoleSuccessCounter),
+		swarm.WithIPv6BlackHoleSuccessCounter(cfg.IPv6BlackHoleSuccessCounter),
+	)
 	if cfg.Reporter != nil {
 		opts = append(opts, swarm.WithMetrics(cfg.Reporter))
 	}
@@ -193,6 +207,77 @@ func (cfg *Config) makeSwarm(eventBus event.Bus, enableMetrics bool) (*swarm.Swa
 	return swarm.NewSwarm(pid, cfg.Peerstore, eventBus, opts...)
 }
 
+func (cfg *Config) makeAutoNATV2Host() (host.Host, error) {
+	autonatPrivKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+	ps, err := pstoremem.NewPeerstore()
+	if err != nil {
+		return nil, err
+	}
+
+	autoNatCfg := Config{
+		Transports:                  cfg.Transports,
+		Muxers:                      cfg.Muxers,
+		SecurityTransports:          cfg.SecurityTransports,
+		Insecure:                    cfg.Insecure,
+		PSK:                         cfg.PSK,
+		ConnectionGater:             cfg.ConnectionGater,
+		Reporter:                    cfg.Reporter,
+		PeerKey:                     autonatPrivKey,
+		Peerstore:                   ps,
+		DialRanker:                  swarm.NoDelayDialRanker,
+		UDPBlackHoleSuccessCounter:  cfg.UDPBlackHoleSuccessCounter,
+		IPv6BlackHoleSuccessCounter: cfg.IPv6BlackHoleSuccessCounter,
+		ResourceManager:             cfg.ResourceManager,
+		SwarmOpts: []swarm.Option{
+			// Don't update black hole state for failed autonat dials
+			swarm.WithReadOnlyBlackHoleDetector(),
+		},
+	}
+	fxopts, err := autoNatCfg.addTransports()
+	if err != nil {
+		return nil, err
+	}
+	var dialerHost host.Host
+	fxopts = append(fxopts,
+		fx.Provide(eventbus.NewBus),
+		fx.Provide(func(lifecycle fx.Lifecycle, b event.Bus) (*swarm.Swarm, error) {
+			lifecycle.Append(fx.Hook{
+				OnStop: func(context.Context) error {
+					return ps.Close()
+				}})
+			sw, err := autoNatCfg.makeSwarm(b, false)
+			return sw, err
+		}),
+		fx.Provide(func(sw *swarm.Swarm) *blankhost.BlankHost {
+			return blankhost.NewBlankHost(sw)
+		}),
+		fx.Provide(func(bh *blankhost.BlankHost) host.Host {
+			return bh
+		}),
+		fx.Provide(func() crypto.PrivKey { return autonatPrivKey }),
+		fx.Provide(func(bh host.Host) peer.ID { return bh.ID() }),
+		fx.Invoke(func(bh *blankhost.BlankHost) {
+			dialerHost = bh
+		}),
+	)
+	app := fx.New(fxopts...)
+	if err := app.Err(); err != nil {
+		return nil, err
+	}
+	err = app.Start(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	go func() {
+		<-dialerHost.Network().(*swarm.Swarm).Done()
+		app.Stop(context.Background())
+	}()
+	return dialerHost, nil
+}
+
 func (cfg *Config) addTransports() ([]fx.Option, error) {
 	fxopts := []fx.Option{
 		fx.WithLogger(func() fxevent.Logger { return getFXLogger() }),
@@ -202,6 +287,29 @@ func (cfg *Config) addTransports() ([]fx.Option, error) {
 		fx.Provide(func() pnet.PSK { return cfg.PSK }),
 		fx.Provide(func() network.ResourceManager { return cfg.ResourceManager }),
 		fx.Provide(func() *madns.Resolver { return cfg.MultiaddrResolver }),
+		fx.Provide(func(cm *quicreuse.ConnManager, sw *swarm.Swarm) libp2pwebrtc.ListenUDPFn {
+			hasQuicAddrPortFor := func(network string, laddr *net.UDPAddr) bool {
+				quicAddrPorts := map[string]struct{}{}
+				for _, addr := range sw.ListenAddresses() {
+					if _, err := addr.ValueForProtocol(ma.P_QUIC_V1); err == nil {
+						netw, addr, err := manet.DialArgs(addr)
+						if err != nil {
+							return false
+						}
+						quicAddrPorts[netw+"_"+addr] = struct{}{}
+					}
+				}
+				_, ok := quicAddrPorts[network+"_"+laddr.String()]
+				return ok
+			}
+
+			return func(network string, laddr *net.UDPAddr) (net.PacketConn, error) {
+				if hasQuicAddrPortFor(network, laddr) {
+					return cm.SharedNonQUICPacketConn(network, laddr)
+				}
+				return net.ListenUDP(network, laddr)
+			}
+		}),
 	}
 	fxopts = append(fxopts, cfg.Transports...)
 	if cfg.Insecure {
@@ -260,8 +368,12 @@ func (cfg *Config) addTransports() ([]fx.Option, error) {
 		fxopts = append(fxopts, cfg.QUICReuse...)
 	} else {
 		fxopts = append(fxopts,
-			fx.Provide(func(key quic.StatelessResetKey, tokenGenerator quic.TokenGeneratorKey, _ *swarm.Swarm, lifecycle fx.Lifecycle) (*quicreuse.ConnManager, error) {
+			fx.Provide(func(key quic.StatelessResetKey, tokenGenerator quic.TokenGeneratorKey, lifecycle fx.Lifecycle) (*quicreuse.ConnManager, error) {
-				cm, err := quicreuse.NewConnManager(key, tokenGenerator)
+				var opts []quicreuse.Option
+				if !cfg.DisableMetrics {
+					opts = append(opts, quicreuse.EnableMetrics(cfg.PrometheusRegisterer))
+				}
+				cm, err := quicreuse.NewConnManager(key, tokenGenerator, opts...)
 				if err != nil {
 					return nil, err
 				}
@@ -291,6 +403,14 @@ func (cfg *Config) addTransports() ([]fx.Option, error) {
 }
 
 func (cfg *Config) newBasicHost(swrm *swarm.Swarm, eventBus event.Bus) (*bhost.BasicHost, error) {
+	var autonatv2Dialer host.Host
+	if cfg.EnableAutoNATv2 {
+		ah, err := cfg.makeAutoNATV2Host()
+		if err != nil {
+			return nil, err
+		}
+		autonatv2Dialer = ah
+	}
 	h, err := bhost.NewHost(swrm, &bhost.HostOpts{
 		EventBus:                        eventBus,
 		ConnManager:                     cfg.ConnManager,
@@ -306,6 +426,8 @@ func (cfg *Config) newBasicHost(swrm *swarm.Swarm, eventBus event.Bus) (*bhost.B
 		EnableMetrics:                   !cfg.DisableMetrics,
 		PrometheusRegisterer:            cfg.PrometheusRegisterer,
 		DisableIdentifyAddressDiscovery: cfg.DisableIdentifyAddressDiscovery,
+		EnableAutoNATv2:                 cfg.EnableAutoNATv2,
+		AutoNATv2Dialer:                 autonatv2Dialer,
 	})
 	if err != nil {
 		return nil, err
@@ -315,9 +437,9 @@ func (cfg *Config) newBasicHost(swrm *swarm.Swarm, eventBus event.Bus) (*bhost.B
 		// addresses by default.
 		//
 		// TODO: We shouldn't be doing this here.
-		oldFactory := h.AddrsFactory
+		originalAddrFactory := h.AddrsFactory
 		h.AddrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr {
-			return oldFactory(autorelay.Filter(addrs))
+			return originalAddrFactory(autorelay.Filter(addrs))
 		}
 	}
 	return h, nil
@@ -347,18 +469,17 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		fx.Provide(func() event.Bus {
 			return eventbus.NewBus(eventbus.WithMetricsTracer(eventbus.NewMetricsTracer(eventbus.WithRegisterer(cfg.PrometheusRegisterer))))
 		}),
-		fx.Provide(func(eventBus event.Bus, lifecycle fx.Lifecycle) (*swarm.Swarm, error) {
+		fx.Provide(func() crypto.PrivKey {
-			sw, err := cfg.makeSwarm(eventBus, !cfg.DisableMetrics)
+			return cfg.PeerKey
-			if err != nil {
-				return nil, err
-			}
-			lifecycle.Append(fx.StopHook(sw.Close))
-			return sw, nil
 		}),
 		// Make sure the swarm constructor depends on the quicreuse.ConnManager.
 		// That way, the ConnManager will be started before the swarm, and more importantly,
 		// the swarm will be stopped before the ConnManager.
-		fx.Decorate(func(sw *swarm.Swarm, _ *quicreuse.ConnManager, lifecycle fx.Lifecycle) *swarm.Swarm {
+		fx.Provide(func(eventBus event.Bus, _ *quicreuse.ConnManager, lifecycle fx.Lifecycle) (*swarm.Swarm, error) {
+			sw, err := cfg.makeSwarm(eventBus, !cfg.DisableMetrics)
+			if err != nil {
+				return nil, err
+			}
 			lifecycle.Append(fx.Hook{
 				OnStart: func(context.Context) error {
 					// TODO: This method succeeds if listening on one address succeeds. We
@@ -369,14 +490,13 @@ func (cfg *Config) NewNode() (host.Host, error) {
 					return sw.Close()
 				},
 			})
-			return sw
+			return sw, nil
 		}),
 		fx.Provide(cfg.newBasicHost),
 		fx.Provide(func(bh *bhost.BasicHost) host.Host {
 			return bh
 		}),
 		fx.Provide(func(h *swarm.Swarm) peer.ID { return h.LocalPeer() }),
-		fx.Provide(func(h *swarm.Swarm) crypto.PrivKey { return h.Peerstore().PrivKey(h.LocalPeer()) }),
 	}
 	transportOpts, err := cfg.addTransports()
 	if err != nil {
@@ -394,26 +514,36 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		)
 	}
 
-	// Note: h.AddrsFactory may be changed by relayFinder, but non-relay version is
+	// originalAddrFactory is the AddrFactory before it's modified by autorelay
-	// used by AutoNAT below.
+	// we need this for checking reachability via autonat
-	if cfg.EnableAutoRelay {
+	originalAddrFactory := func(addrs []ma.Multiaddr) []ma.Multiaddr {
-		if !cfg.DisableMetrics {
+		return addrs
-			mt := autorelay.WithMetricsTracer(
+	}
-				autorelay.NewMetricsTracer(autorelay.WithRegisterer(cfg.PrometheusRegisterer)))
+
-			mtOpts := []autorelay.Option{mt}
+	// enable autorelay
-			cfg.AutoRelayOpts = append(mtOpts, cfg.AutoRelayOpts...)
+	fxopts = append(fxopts,
-		}
+		fx.Invoke(func(h *bhost.BasicHost) {
-		fxopts = append(fxopts,
+			originalAddrFactory = h.AddrsFactory
-			fx.Invoke(func(h *bhost.BasicHost, lifecycle fx.Lifecycle) (*autorelay.AutoRelay, error) {
+		}),
+		fx.Invoke(func(h *bhost.BasicHost, lifecycle fx.Lifecycle) error {
+			if cfg.EnableAutoRelay {
+				if !cfg.DisableMetrics {
+					mt := autorelay.WithMetricsTracer(
+						autorelay.NewMetricsTracer(autorelay.WithRegisterer(cfg.PrometheusRegisterer)))
+					mtOpts := []autorelay.Option{mt}
+					cfg.AutoRelayOpts = append(mtOpts, cfg.AutoRelayOpts...)
+				}
+
 				ar, err := autorelay.NewAutoRelay(h, cfg.AutoRelayOpts...)
 				if err != nil {
-					return nil, err
+					return err
 				}
 				lifecycle.Append(fx.StartStopHook(ar.Start, ar.Close))
-				return ar, nil
+				return nil
-			}),
+			}
-		)
+			return nil
-	}
+		}),
+	)
 
 	var bh *bhost.BasicHost
 	fxopts = append(fxopts, fx.Invoke(func(bho *bhost.BasicHost) { bh = bho }))
@@ -431,7 +561,7 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		return nil, err
 	}
 
-	if err := cfg.addAutoNAT(bh); err != nil {
+	if err := cfg.addAutoNAT(bh, originalAddrFactory); err != nil {
 		app.Stop(context.Background())
 		if cfg.Routing != nil {
 			rh.Close()
@@ -447,8 +577,7 @@ func (cfg *Config) NewNode() (host.Host, error) {
 	return &closableBasicHost{App: app, BasicHost: bh}, nil
 }
 
-func (cfg *Config) addAutoNAT(h *bhost.BasicHost) error {
+func (cfg *Config) addAutoNAT(h *bhost.BasicHost, addrF AddrsFactory) error {
-	addrF := h.AddrsFactory
 	autonatOpts := []autonat.Option{
 		autonat.UsingAddresses(func() []ma.Multiaddr {
 			return addrF(h.AllAddrs())
@@ -487,10 +616,10 @@ func (cfg *Config) addAutoNAT(h *bhost.BasicHost) error {
 			PeerKey:            autonatPrivKey,
 			Peerstore:          ps,
 			DialRanker:         swarm.NoDelayDialRanker,
+			ResourceManager:    cfg.ResourceManager,
 			SwarmOpts: []swarm.Option{
-				// It is better to disable black hole detection and just attempt a dial for autonat
+				swarm.WithUDPBlackHoleSuccessCounter(nil),
-				swarm.WithUDPBlackHoleConfig(false, 0, 0),
+				swarm.WithIPv6BlackHoleSuccessCounter(nil),
-				swarm.WithIPv6BlackHoleConfig(false, 0, 0),
 			},
 		}
 

vendor/github.com/libp2p/go-libp2p/core/crypto/pb/crypto.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/crypto.proto
 
 package pb
@@ -229,7 +229,7 @@ func file_pb_crypto_proto_rawDescGZIP() []byte {
 
 var file_pb_crypto_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
 var file_pb_crypto_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_pb_crypto_proto_goTypes = []interface{}{
+var file_pb_crypto_proto_goTypes = []any{
 	(KeyType)(0),       // 0: crypto.pb.KeyType
 	(*PublicKey)(nil),  // 1: crypto.pb.PublicKey
 	(*PrivateKey)(nil), // 2: crypto.pb.PrivateKey
@@ -250,7 +250,7 @@ func file_pb_crypto_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_crypto_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_crypto_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*PublicKey); i {
 			case 0:
 				return &v.state
@@ -262,7 +262,7 @@ func file_pb_crypto_proto_init() {
 				return nil
 			}
 		}
-		file_pb_crypto_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_crypto_proto_msgTypes[1].Exporter = func(v any, i int) any {
 			switch v := v.(*PrivateKey); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/core/network/network.go

@@ -194,6 +194,9 @@ type Dialer interface {
 	// Notify/StopNotify register and unregister a notifiee for signals
 	Notify(Notifiee)
 	StopNotify(Notifiee)
+
+	// CanDial returns whether the dialer can dial peer p at addr
+	CanDial(p peer.ID, addr ma.Multiaddr) bool
 }
 
 // AddrDelay provides an address along with the delay after which the address

vendor/github.com/libp2p/go-libp2p/core/peer/pb/peer_record.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/peer_record.proto
 
 package pb
@@ -174,7 +174,7 @@ func file_pb_peer_record_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_peer_record_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_pb_peer_record_proto_goTypes = []interface{}{
+var file_pb_peer_record_proto_goTypes = []any{
 	(*PeerRecord)(nil),             // 0: peer.pb.PeerRecord
 	(*PeerRecord_AddressInfo)(nil), // 1: peer.pb.PeerRecord.AddressInfo
 }
@@ -193,7 +193,7 @@ func file_pb_peer_record_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_peer_record_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_peer_record_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*PeerRecord); i {
 			case 0:
 				return &v.state
@@ -205,7 +205,7 @@ func file_pb_peer_record_proto_init() {
 				return nil
 			}
 		}
-		file_pb_peer_record_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_peer_record_proto_msgTypes[1].Exporter = func(v any, i int) any {
 			switch v := v.(*PeerRecord_AddressInfo); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/core/record/pb/envelope.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/envelope.proto
 
 package pb
@@ -139,7 +139,7 @@ func file_pb_envelope_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_envelope_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pb_envelope_proto_goTypes = []interface{}{
+var file_pb_envelope_proto_goTypes = []any{
 	(*Envelope)(nil),     // 0: record.pb.Envelope
 	(*pb.PublicKey)(nil), // 1: crypto.pb.PublicKey
 }
@@ -158,7 +158,7 @@ func file_pb_envelope_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_envelope_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_envelope_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*Envelope); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/core/sec/insecure/pb/plaintext.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/plaintext.proto
 
 package pb
@@ -103,7 +103,7 @@ func file_pb_plaintext_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_plaintext_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pb_plaintext_proto_goTypes = []interface{}{
+var file_pb_plaintext_proto_goTypes = []any{
 	(*Exchange)(nil),     // 0: plaintext.pb.Exchange
 	(*pb.PublicKey)(nil), // 1: crypto.pb.PublicKey
 }
@@ -122,7 +122,7 @@ func file_pb_plaintext_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_plaintext_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_plaintext_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*Exchange); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/defaults.go

@@ -10,10 +10,12 @@ import (
 	rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager"
 	"github.com/libp2p/go-libp2p/p2p/muxer/yamux"
 	"github.com/libp2p/go-libp2p/p2p/net/connmgr"
+	"github.com/libp2p/go-libp2p/p2p/net/swarm"
 	"github.com/libp2p/go-libp2p/p2p/security/noise"
 	tls "github.com/libp2p/go-libp2p/p2p/security/tls"
 	quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
 	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
+	libp2pwebrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc"
 	ws "github.com/libp2p/go-libp2p/p2p/transport/websocket"
 	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
 	"github.com/prometheus/client_golang/prometheus"
@@ -46,6 +48,7 @@ var DefaultTransports = ChainOptions(
 	Transport(quic.NewTransport),
 	Transport(ws.New),
 	Transport(webtransport.New),
+	Transport(libp2pwebrtc.New),
 )
 
 // DefaultPrivateTransports are the default libp2p transports when a PSK is supplied.
@@ -81,9 +84,11 @@ var DefaultListenAddrs = func(cfg *Config) error {
 		"/ip4/0.0.0.0/tcp/0",
 		"/ip4/0.0.0.0/udp/0/quic-v1",
 		"/ip4/0.0.0.0/udp/0/quic-v1/webtransport",
+		"/ip4/0.0.0.0/udp/0/webrtc-direct",
 		"/ip6/::/tcp/0",
 		"/ip6/::/udp/0/quic-v1",
 		"/ip6/::/udp/0/quic-v1/webtransport",
+		"/ip6/::/udp/0/webrtc-direct",
 	}
 	listenAddrs := make([]multiaddr.Multiaddr, 0, len(addrs))
 	for _, s := range addrs {
@@ -133,6 +138,18 @@ var DefaultPrometheusRegisterer = func(cfg *Config) error {
 	return cfg.Apply(PrometheusRegisterer(prometheus.DefaultRegisterer))
 }
 
+var defaultUDPBlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if UDP dials are blocked, all dials will
+	// fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(UDPBlackHoleSuccessCounter(&swarm.BlackHoleSuccessCounter{N: 100, MinSuccesses: 5, Name: "UDP"}))
+}
+
+var defaultIPv6BlackHoleDetector = func(cfg *Config) error {
+	// A black hole is a binary property. On a network if there is no IPv6 connectivity, all
+	// dials will fail. So a low success rate of 5 out 100 dials is good enough.
+	return cfg.Apply(IPv6BlackHoleSuccessCounter(&swarm.BlackHoleSuccessCounter{N: 100, MinSuccesses: 5, Name: "IPv6"}))
+}
+
 // Complete list of default options and when to fallback on them.
 //
 // Please *DON'T* specify default options any other way. Putting this all here
@@ -189,6 +206,18 @@ var defaults = []struct {
 		fallback: func(cfg *Config) bool { return !cfg.DisableMetrics && cfg.PrometheusRegisterer == nil },
 		opt:      DefaultPrometheusRegisterer,
 	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomUDPBlackHoleSuccessCounter && cfg.UDPBlackHoleSuccessCounter == nil
+		},
+		opt: defaultUDPBlackHoleDetector,
+	},
+	{
+		fallback: func(cfg *Config) bool {
+			return !cfg.CustomIPv6BlackHoleSuccessCounter && cfg.IPv6BlackHoleSuccessCounter == nil
+		},
+		opt: defaultIPv6BlackHoleDetector,
+	},
 }
 
 // Defaults configures libp2p to use the default options. Can be combined with

vendor/github.com/libp2p/go-libp2p/options.go

@@ -609,3 +609,29 @@ func DisableIdentifyAddressDiscovery() Option {
 		return nil
 	}
 }
+
+// EnableAutoNATv2 enables autonat v2
+func EnableAutoNATv2() Option {
+	return func(cfg *Config) error {
+		cfg.EnableAutoNATv2 = true
+		return nil
+	}
+}
+
+// UDPBlackHoleSuccessCounter configures libp2p to use f as the black hole filter for UDP addrs
+func UDPBlackHoleSuccessCounter(f *swarm.BlackHoleSuccessCounter) Option {
+	return func(cfg *Config) error {
+		cfg.UDPBlackHoleSuccessCounter = f
+		cfg.CustomUDPBlackHoleSuccessCounter = true
+		return nil
+	}
+}
+
+// IPv6BlackHoleSuccessCounter configures libp2p to use f as the black hole filter for IPv6 addrs
+func IPv6BlackHoleSuccessCounter(f *swarm.BlackHoleSuccessCounter) Option {
+	return func(cfg *Config) error {
+		cfg.IPv6BlackHoleSuccessCounter = f
+		cfg.CustomIPv6BlackHoleSuccessCounter = true
+		return nil
+	}
+}

vendor/github.com/libp2p/go-libp2p/p2p/host/autonat/pb/autonat.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/autonat.proto
 
 package pb
@@ -426,7 +426,7 @@ func file_pb_autonat_proto_rawDescGZIP() []byte {
 
 var file_pb_autonat_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
 var file_pb_autonat_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
-var file_pb_autonat_proto_goTypes = []interface{}{
+var file_pb_autonat_proto_goTypes = []any{
 	(Message_MessageType)(0),     // 0: autonat.pb.Message.MessageType
 	(Message_ResponseStatus)(0),  // 1: autonat.pb.Message.ResponseStatus
 	(*Message)(nil),              // 2: autonat.pb.Message
@@ -453,7 +453,7 @@ func file_pb_autonat_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_autonat_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_autonat_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*Message); i {
 			case 0:
 				return &v.state
@@ -465,7 +465,7 @@ func file_pb_autonat_proto_init() {
 				return nil
 			}
 		}
-		file_pb_autonat_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_autonat_proto_msgTypes[1].Exporter = func(v any, i int) any {
 			switch v := v.(*Message_PeerInfo); i {
 			case 0:
 				return &v.state
@@ -477,7 +477,7 @@ func file_pb_autonat_proto_init() {
 				return nil
 			}
 		}
-		file_pb_autonat_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_autonat_proto_msgTypes[2].Exporter = func(v any, i int) any {
 			switch v := v.(*Message_Dial); i {
 			case 0:
 				return &v.state
@@ -489,7 +489,7 @@ func file_pb_autonat_proto_init() {
 				return nil
 			}
 		}
-		file_pb_autonat_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_autonat_proto_msgTypes[3].Exporter = func(v any, i int) any {
 			switch v := v.(*Message_DialResponse); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/p2p/host/basic/basic_host.go

@@ -24,6 +24,7 @@ import (
 	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
 	"github.com/libp2p/go-libp2p/p2p/host/pstoremanager"
 	"github.com/libp2p/go-libp2p/p2p/host/relaysvc"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2"
 	relayv2 "github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/relay"
 	"github.com/libp2p/go-libp2p/p2p/protocol/holepunch"
 	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
@@ -105,6 +106,8 @@ type BasicHost struct {
 	caBook                  peerstore.CertifiedAddrBook
 
 	autoNat autonat.AutoNAT
+
+	autonatv2 *autonatv2.AutoNAT
 }
 
 var _ host.Host = (*BasicHost)(nil)
@@ -167,6 +170,8 @@ type HostOpts struct {
 
 	// DisableIdentifyAddressDiscovery disables address discovery using peer provided observed addresses in identify
 	DisableIdentifyAddressDiscovery bool
+	EnableAutoNATv2                 bool
+	AutoNATv2Dialer                 host.Host
 }
 
 // NewHost constructs a new *BasicHost and activates it by attaching its stream and connection handlers to the given inet.Network.
@@ -279,6 +284,20 @@ func NewHost(n network.Network, opts *HostOpts) (*BasicHost, error) {
 	if opts.AddrsFactory != nil {
 		h.AddrsFactory = opts.AddrsFactory
 	}
+	// This is a terrible hack.
+	// We want to use this AddrsFactory for autonat. Wrapping AddrsFactory here ensures
+	// that autonat receives addresses with the correct certhashes.
+	//
+	// This logic cannot be in Addrs method as autonat cannot use the Addrs method directly.
+	// The autorelay package updates AddrsFactory to only provide p2p-circuit addresses when
+	// reachability is Private.
+	//
+	// Wrapping it here allows us to provide the wrapped AddrsFactory to autonat before
+	// autorelay updates it.
+	addrFactory := h.AddrsFactory
+	h.AddrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr {
+		return h.addCertHashes(addrFactory(addrs))
+	}
 
 	if opts.NATManager != nil {
 		h.natmgr = opts.NATManager(n)
@@ -310,6 +329,17 @@ func NewHost(n network.Network, opts *HostOpts) (*BasicHost, error) {
 		h.pings = ping.NewPingService(h)
 	}
 
+	if opts.EnableAutoNATv2 {
+		var mt autonatv2.MetricsTracer
+		if opts.EnableMetrics {
+			mt = autonatv2.NewMetricsTracer(opts.PrometheusRegisterer)
+		}
+		h.autonatv2, err = autonatv2.New(h, opts.AutoNATv2Dialer, autonatv2.WithMetricsTracer(mt))
+		if err != nil {
+			return nil, fmt.Errorf("failed to create autonatv2: %w", err)
+		}
+	}
+
 	n.SetStreamHandler(h.newStreamHandler)
 
 	// register to be notified when the network's listen addrs change,
@@ -398,6 +428,12 @@ func (h *BasicHost) Start() {
 	h.psManager.Start()
 	h.refCount.Add(1)
 	h.ids.Start()
+	if h.autonatv2 != nil {
+		err := h.autonatv2.Start()
+		if err != nil {
+			log.Errorf("autonat v2 failed to start: %s", err)
+		}
+	}
 	go h.background()
 }
 
@@ -640,7 +676,7 @@ func (h *BasicHost) RemoveStreamHandler(pid protocol.ID) {
 // header with given protocol.ID. If there is no connection to p, attempts
 // to create one. If ProtocolID is "", writes no header.
 // (Thread-safe)
-func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.ID) (network.Stream, error) {
+func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.ID) (str network.Stream, strErr error) {
 	// If the caller wants to prevent the host from dialing, it should use the NoDial option.
 	if nodial, _ := network.GetNoDial(ctx); !nodial {
 		err := h.Connect(ctx, peer.AddrInfo{ID: p})
@@ -658,6 +694,11 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
 		}
 		return nil, fmt.Errorf("failed to open stream: %w", err)
 	}
+	defer func() {
+		if strErr != nil && s != nil {
+			s.Reset()
+		}
+	}()
 
 	// Wait for any in-progress identifies on the connection to finish. This
 	// is faster than negotiating.
@@ -667,13 +708,11 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
 	select {
 	case <-h.ids.IdentifyWait(s.Conn()):
 	case <-ctx.Done():
-		_ = s.Reset()
 		return nil, fmt.Errorf("identify failed to complete: %w", ctx.Err())
 	}
 
 	pref, err := h.preferredProtocol(p, pids)
 	if err != nil {
-		_ = s.Reset()
 		return nil, err
 	}
 
@@ -698,7 +737,6 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
 	select {
 	case err = <-errCh:
 		if err != nil {
-			s.Reset()
 			return nil, fmt.Errorf("failed to negotiate protocol: %w", err)
 		}
 	case <-ctx.Done():
@@ -708,8 +746,10 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
 		return nil, fmt.Errorf("failed to negotiate protocol: %w", ctx.Err())
 	}
 
-	s.SetProtocol(selected)
+	if err := s.SetProtocol(selected); err != nil {
-	h.Peerstore().AddProtocols(p, selected)
+		return nil, err
+	}
+	_ = h.Peerstore().AddProtocols(p, selected) // adding the protocol to the peerstore isn't critical
 	return s, nil
 }
 
@@ -778,47 +818,13 @@ func (h *BasicHost) ConnManager() connmgr.ConnManager {
 // Addrs returns listening addresses that are safe to announce to the network.
 // The output is the same as AllAddrs, but processed by AddrsFactory.
 func (h *BasicHost) Addrs() []ma.Multiaddr {
-	// This is a temporary workaround/hack that fixes #2233. Once we have a
+	// We don't need to append certhashes here, the user provided addrsFactory was
-	// proper address pipeline, rework this. See the issue for more context.
+	// wrapped with addCertHashes in the constructor.
-	type transportForListeninger interface {
-		TransportForListening(a ma.Multiaddr) transport.Transport
-	}
-
-	type addCertHasher interface {
-		AddCertHashes(m ma.Multiaddr) (ma.Multiaddr, bool)
-	}
-
 	addrs := h.AddrsFactory(h.AllAddrs())
-
+	// Make a copy. Consumers can modify the slice elements
-	s, ok := h.Network().(transportForListeninger)
+	res := make([]ma.Multiaddr, len(addrs))
-	if !ok {
+	copy(res, addrs)
-		return addrs
+	return res
-	}
-
-	// Copy addrs slice since we'll be modifying it.
-	addrsOld := addrs
-	addrs = make([]ma.Multiaddr, len(addrsOld))
-	copy(addrs, addrsOld)
-
-	for i, addr := range addrs {
-		wtOK, wtN := libp2pwebtransport.IsWebtransportMultiaddr(addr)
-		webrtcOK, webrtcN := libp2pwebrtc.IsWebRTCDirectMultiaddr(addr)
-		if (wtOK && wtN == 0) || (webrtcOK && webrtcN == 0) {
-			t := s.TransportForListening(addr)
-			tpt, ok := t.(addCertHasher)
-			if !ok {
-				continue
-			}
-			addrWithCerthash, added := tpt.AddCertHashes(addr)
-			if !added {
-				log.Debugf("Couldn't add certhashes to multiaddr: %s", addr)
-				continue
-			}
-			addrs[i] = addrWithCerthash
-		}
-	}
-
-	return addrs
 }
 
 // NormalizeMultiaddr returns a multiaddr suitable for equality checks.
@@ -838,8 +844,9 @@ func (h *BasicHost) NormalizeMultiaddr(addr ma.Multiaddr) ma.Multiaddr {
 	return addr
 }
 
-// AllAddrs returns all the addresses of BasicHost at this moment in time.
+// AllAddrs returns all the addresses the host is listening on except circuit addresses.
-// It's ok to not include addresses if they're not available to be used now.
+// The output has webtransport addresses inferred from quic addresses.
+// All the addresses have the correct
 func (h *BasicHost) AllAddrs() []ma.Multiaddr {
 	listenAddrs := h.Network().ListenAddresses()
 	if len(listenAddrs) == 0 {
@@ -932,82 +939,48 @@ func (h *BasicHost) AllAddrs() []ma.Multiaddr {
 		finalAddrs = append(finalAddrs, observedAddrs...)
 	}
 	finalAddrs = ma.Unique(finalAddrs)
-	finalAddrs = inferWebtransportAddrsFromQuic(finalAddrs)
-
 	return finalAddrs
 }
 
-var wtComponent = ma.StringCast("/webtransport")
+func (h *BasicHost) addCertHashes(addrs []ma.Multiaddr) []ma.Multiaddr {
-
+	// This is a temporary workaround/hack that fixes #2233. Once we have a
-// inferWebtransportAddrsFromQuic infers more webtransport addresses from QUIC addresses.
+	// proper address pipeline, rework this. See the issue for more context.
-// This is useful when we discover our public QUIC address, but haven't discovered our public WebTransport addrs.
+	type transportForListeninger interface {
-// If we see that we are listening on the same port for QUIC and WebTransport,
+		TransportForListening(a ma.Multiaddr) transport.Transport
-// we can be pretty sure that the WebTransport addr will be reachable if the
-// QUIC one is.
-// We assume the input is deduped.
-func inferWebtransportAddrsFromQuic(in []ma.Multiaddr) []ma.Multiaddr {
-	// We need to check if we are listening on the same ip+port for QUIC and WebTransport.
-	// If not, there's nothing to do since we can't infer anything.
-
-	// Count the number of QUIC addrs, this will let us allocate just once at the beginning.
-	quicAddrCount := 0
-	for _, addr := range in {
-		if _, lastComponent := ma.SplitLast(addr); lastComponent.Protocol().Code == ma.P_QUIC_V1 {
-			quicAddrCount++
-		}
-	}
-	quicOrWebtransportAddrs := make(map[string]struct{}, quicAddrCount)
-	webtransportAddrs := make(map[string]struct{}, quicAddrCount)
-	foundSameListeningAddr := false
-	for _, addr := range in {
-		isWebtransport, numCertHashes := libp2pwebtransport.IsWebtransportMultiaddr(addr)
-		if isWebtransport {
-			for i := 0; i < numCertHashes; i++ {
-				// Remove certhashes
-				addr, _ = ma.SplitLast(addr)
-			}
-			webtransportAddrs[string(addr.Bytes())] = struct{}{}
-			// Remove webtransport component, now it's a multiaddr that ends in /quic-v1
-			addr, _ = ma.SplitLast(addr)
-		}
-
-		if _, lastComponent := ma.SplitLast(addr); lastComponent.Protocol().Code == ma.P_QUIC_V1 {
-			bytes := addr.Bytes()
-			if _, ok := quicOrWebtransportAddrs[string(bytes)]; ok {
-				foundSameListeningAddr = true
-			} else {
-				quicOrWebtransportAddrs[string(bytes)] = struct{}{}
-			}
-		}
 	}
 
-	if !foundSameListeningAddr {
+	type addCertHasher interface {
-		return in
+		AddCertHashes(m ma.Multiaddr) (ma.Multiaddr, bool)
 	}
 
-	if len(webtransportAddrs) == 0 {
+	s, ok := h.Network().(transportForListeninger)
-		// No webtransport addresses, we aren't listening on any webtransport
+	if !ok {
-		// address, so we shouldn't add any.
+		return addrs
-		return in
 	}
 
-	out := make([]ma.Multiaddr, 0, len(in)+(quicAddrCount-len(webtransportAddrs)))
+	// Copy addrs slice since we'll be modifying it.
-	for _, addr := range in {
+	addrsOld := addrs
-		// Add all the original addresses
+	addrs = make([]ma.Multiaddr, len(addrsOld))
-		out = append(out, addr)
+	copy(addrs, addrsOld)
-		if _, lastComponent := ma.SplitLast(addr); lastComponent.Protocol().Code == ma.P_QUIC_V1 {
+
-			// Convert quic to webtransport
+	for i, addr := range addrs {
-			addr = addr.Encapsulate(wtComponent)
+		wtOK, wtN := libp2pwebtransport.IsWebtransportMultiaddr(addr)
-			if _, ok := webtransportAddrs[string(addr.Bytes())]; ok {
+		webrtcOK, webrtcN := libp2pwebrtc.IsWebRTCDirectMultiaddr(addr)
-				// We already have this address
+		if (wtOK && wtN == 0) || (webrtcOK && webrtcN == 0) {
+			t := s.TransportForListening(addr)
+			tpt, ok := t.(addCertHasher)
+			if !ok {
 				continue
 			}
-			// Add the new inferred address
+			addrWithCerthash, added := tpt.AddCertHashes(addr)
-			out = append(out, addr)
+			if !added {
+				log.Debugf("Couldn't add certhashes to multiaddr: %s", addr)
+				continue
+			}
+			addrs[i] = addrWithCerthash
 		}
 	}
-
+	return addrs
-	return out
 }
 
 func trimHostAddrList(addrs []ma.Multiaddr, maxSize int) []ma.Multiaddr {
@@ -1100,10 +1073,17 @@ func (h *BasicHost) Close() error {
 		if h.hps != nil {
 			h.hps.Close()
 		}
+		if h.autonatv2 != nil {
+			h.autonatv2.Close()
+		}
 
 		_ = h.emitters.evtLocalProtocolsUpdated.Close()
 		_ = h.emitters.evtLocalAddrsUpdated.Close()
 
+		if err := h.network.Close(); err != nil {
+			log.Errorf("swarm close failed: %v", err)
+		}
+
 		h.psManager.Close()
 		if h.Peerstore() != nil {
 			h.Peerstore().Close()

vendor/github.com/libp2p/go-libp2p/p2p/host/blank/blank.go

@@ -0,0 +1,233 @@
+package blankhost
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/libp2p/go-libp2p/core/connmgr"
+	"github.com/libp2p/go-libp2p/core/event"
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/peerstore"
+	"github.com/libp2p/go-libp2p/core/protocol"
+	"github.com/libp2p/go-libp2p/core/record"
+	"github.com/libp2p/go-libp2p/p2p/host/eventbus"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	ma "github.com/multiformats/go-multiaddr"
+	mstream "github.com/multiformats/go-multistream"
+)
+
+var log = logging.Logger("blankhost")
+
+// BlankHost is the thinnest implementation of the host.Host interface
+type BlankHost struct {
+	n        network.Network
+	mux      *mstream.MultistreamMuxer[protocol.ID]
+	cmgr     connmgr.ConnManager
+	eventbus event.Bus
+	emitters struct {
+		evtLocalProtocolsUpdated event.Emitter
+	}
+}
+
+type config struct {
+	cmgr     connmgr.ConnManager
+	eventBus event.Bus
+}
+
+type Option = func(cfg *config)
+
+func WithConnectionManager(cmgr connmgr.ConnManager) Option {
+	return func(cfg *config) {
+		cfg.cmgr = cmgr
+	}
+}
+
+func WithEventBus(eventBus event.Bus) Option {
+	return func(cfg *config) {
+		cfg.eventBus = eventBus
+	}
+}
+
+func NewBlankHost(n network.Network, options ...Option) *BlankHost {
+	cfg := config{
+		cmgr: &connmgr.NullConnMgr{},
+	}
+	for _, opt := range options {
+		opt(&cfg)
+	}
+
+	bh := &BlankHost{
+		n:        n,
+		cmgr:     cfg.cmgr,
+		mux:      mstream.NewMultistreamMuxer[protocol.ID](),
+		eventbus: cfg.eventBus,
+	}
+	if bh.eventbus == nil {
+		bh.eventbus = eventbus.NewBus(eventbus.WithMetricsTracer(eventbus.NewMetricsTracer()))
+	}
+
+	// subscribe the connection manager to network notifications (has no effect with NullConnMgr)
+	n.Notify(bh.cmgr.Notifee())
+
+	var err error
+	if bh.emitters.evtLocalProtocolsUpdated, err = bh.eventbus.Emitter(&event.EvtLocalProtocolsUpdated{}); err != nil {
+		return nil
+	}
+
+	n.SetStreamHandler(bh.newStreamHandler)
+
+	// persist a signed peer record for self to the peerstore.
+	if err := bh.initSignedRecord(); err != nil {
+		log.Errorf("error creating blank host, err=%s", err)
+		return nil
+	}
+
+	return bh
+}
+
+func (bh *BlankHost) initSignedRecord() error {
+	cab, ok := peerstore.GetCertifiedAddrBook(bh.n.Peerstore())
+	if !ok {
+		log.Error("peerstore does not support signed records")
+		return errors.New("peerstore does not support signed records")
+	}
+	rec := peer.PeerRecordFromAddrInfo(peer.AddrInfo{ID: bh.ID(), Addrs: bh.Addrs()})
+	ev, err := record.Seal(rec, bh.Peerstore().PrivKey(bh.ID()))
+	if err != nil {
+		log.Errorf("failed to create signed record for self, err=%s", err)
+		return fmt.Errorf("failed to create signed record for self, err=%s", err)
+	}
+	_, err = cab.ConsumePeerRecord(ev, peerstore.PermanentAddrTTL)
+	if err != nil {
+		log.Errorf("failed to persist signed record to peerstore,err=%s", err)
+		return fmt.Errorf("failed to persist signed record for self, err=%s", err)
+	}
+	return err
+}
+
+var _ host.Host = (*BlankHost)(nil)
+
+func (bh *BlankHost) Addrs() []ma.Multiaddr {
+	addrs, err := bh.n.InterfaceListenAddresses()
+	if err != nil {
+		log.Debug("error retrieving network interface addrs: ", err)
+		return nil
+	}
+
+	return addrs
+}
+
+func (bh *BlankHost) Close() error {
+	return bh.n.Close()
+}
+
+func (bh *BlankHost) Connect(ctx context.Context, ai peer.AddrInfo) error {
+	// absorb addresses into peerstore
+	bh.Peerstore().AddAddrs(ai.ID, ai.Addrs, peerstore.TempAddrTTL)
+
+	cs := bh.n.ConnsToPeer(ai.ID)
+	if len(cs) > 0 {
+		return nil
+	}
+
+	_, err := bh.Network().DialPeer(ctx, ai.ID)
+	if err != nil {
+		return fmt.Errorf("failed to dial: %w", err)
+	}
+	return err
+}
+
+func (bh *BlankHost) Peerstore() peerstore.Peerstore {
+	return bh.n.Peerstore()
+}
+
+func (bh *BlankHost) ID() peer.ID {
+	return bh.n.LocalPeer()
+}
+
+func (bh *BlankHost) NewStream(ctx context.Context, p peer.ID, protos ...protocol.ID) (network.Stream, error) {
+	s, err := bh.n.NewStream(ctx, p)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open stream: %w", err)
+	}
+
+	selected, err := mstream.SelectOneOf(protos, s)
+	if err != nil {
+		s.Reset()
+		return nil, fmt.Errorf("failed to negotiate protocol: %w", err)
+	}
+
+	s.SetProtocol(selected)
+	bh.Peerstore().AddProtocols(p, selected)
+
+	return s, nil
+}
+
+func (bh *BlankHost) RemoveStreamHandler(pid protocol.ID) {
+	bh.Mux().RemoveHandler(pid)
+	bh.emitters.evtLocalProtocolsUpdated.Emit(event.EvtLocalProtocolsUpdated{
+		Removed: []protocol.ID{pid},
+	})
+}
+
+func (bh *BlankHost) SetStreamHandler(pid protocol.ID, handler network.StreamHandler) {
+	bh.Mux().AddHandler(pid, func(p protocol.ID, rwc io.ReadWriteCloser) error {
+		is := rwc.(network.Stream)
+		is.SetProtocol(p)
+		handler(is)
+		return nil
+	})
+	bh.emitters.evtLocalProtocolsUpdated.Emit(event.EvtLocalProtocolsUpdated{
+		Added: []protocol.ID{pid},
+	})
+}
+
+func (bh *BlankHost) SetStreamHandlerMatch(pid protocol.ID, m func(protocol.ID) bool, handler network.StreamHandler) {
+	bh.Mux().AddHandlerWithFunc(pid, m, func(p protocol.ID, rwc io.ReadWriteCloser) error {
+		is := rwc.(network.Stream)
+		is.SetProtocol(p)
+		handler(is)
+		return nil
+	})
+	bh.emitters.evtLocalProtocolsUpdated.Emit(event.EvtLocalProtocolsUpdated{
+		Added: []protocol.ID{pid},
+	})
+}
+
+// newStreamHandler is the remote-opened stream handler for network.Network
+func (bh *BlankHost) newStreamHandler(s network.Stream) {
+	protoID, handle, err := bh.Mux().Negotiate(s)
+	if err != nil {
+		log.Infow("protocol negotiation failed", "error", err)
+		s.Reset()
+		return
+	}
+
+	s.SetProtocol(protoID)
+
+	handle(protoID, s)
+}
+
+// TODO: i'm not sure this really needs to be here
+func (bh *BlankHost) Mux() protocol.Switch {
+	return bh.mux
+}
+
+// TODO: also not sure this fits... Might be better ways around this (leaky abstractions)
+func (bh *BlankHost) Network() network.Network {
+	return bh.n
+}
+
+func (bh *BlankHost) ConnManager() connmgr.ConnManager {
+	return bh.cmgr
+}
+
+func (bh *BlankHost) EventBus() event.Bus {
+	return bh.eventbus
+}

vendor/github.com/libp2p/go-libp2p/p2p/metricshelper/conn.go

@@ -5,6 +5,9 @@ import ma "github.com/multiformats/go-multiaddr"
 var transports = [...]int{ma.P_CIRCUIT, ma.P_WEBRTC, ma.P_WEBRTC_DIRECT, ma.P_WEBTRANSPORT, ma.P_QUIC, ma.P_QUIC_V1, ma.P_WSS, ma.P_WS, ma.P_TCP}
 
 func GetTransport(a ma.Multiaddr) string {
+	if a == nil {
+		return "other"
+	}
 	for _, t := range transports {
 		if _, err := a.ValueForProtocol(t); err == nil {
 			return ma.ProtocolWithCode(t).Name
@@ -15,15 +18,17 @@ func GetTransport(a ma.Multiaddr) string {
 
 func GetIPVersion(addr ma.Multiaddr) string {
 	version := "unknown"
+	if addr == nil {
+		return version
+	}
 	ma.ForEach(addr, func(c ma.Component) bool {
-		if c.Protocol().Code == ma.P_IP4 {
+		switch c.Protocol().Code {
+		case ma.P_IP4, ma.P_DNS4:
 			version = "ip4"
-			return false
+		case ma.P_IP6, ma.P_DNS6:
-		} else if c.Protocol().Code == ma.P_IP6 {
 			version = "ip6"
-			return false
 		}
-		return true
+		return false
 	})
 	return version
 }

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/black_hole_detector.go

@@ -29,35 +29,26 @@ func (st blackHoleState) String() string {
 	}
 }
 
-type blackHoleResult int
+// BlackHoleSuccessCounter provides black hole filtering for dials. This filter should be used in concert
-
+// with a UDP or IPv6 address filter to detect UDP or IPv6 black hole. In a black holed environment,
-const (
+// dial requests are refused Requests are blocked if the number of successes in the last N dials is
-	blackHoleResultAllowed blackHoleResult = iota
+// less than MinSuccesses.
-	blackHoleResultProbing
+// If a request succeeds in Blocked state, the filter state is reset and N subsequent requests are
-	blackHoleResultBlocked
+// allowed before reevaluating black hole state. Dials cancelled when some other concurrent dial
-)
+// succeeded are counted as failures. A sufficiently large N prevents false negatives in such cases.
-
+type BlackHoleSuccessCounter struct {
-// blackHoleFilter provides black hole filtering for dials. This filter should be used in
+	// N is
-// concert with a UDP of IPv6 address filter to detect UDP or IPv6 black hole. In a black
+	// 1. The minimum number of completed dials required before evaluating black hole state
-// holed environments dial requests are blocked and only periodic probes to check the
+	// 2. the minimum number of requests after which we probe the state of the black hole in
-// state of the black hole are allowed.
+	// blocked state
-//
+	N int
-// Requests are blocked if the number of successes in the last n dials is less than
+	// MinSuccesses is the minimum number of Success required in the last n dials
-// minSuccesses. If a request succeeds in Blocked state, the filter state is reset and n
-// subsequent requests are allowed before reevaluating black hole state. Dials cancelled
-// when some other concurrent dial succeeded are counted as failures. A sufficiently large
-// n prevents false negatives in such cases.
-type blackHoleFilter struct {
-	// n serves the dual purpose of being the minimum number of requests after which we
-	// probe the state of the black hole in blocked state and the minimum number of
-	// completed dials required before evaluating black hole state.
-	n int
-	// minSuccesses is the minimum number of Success required in the last n dials
 	// to consider we are not blocked.
-	minSuccesses int
+	MinSuccesses int
-	// name for the detector.
+	// Name for the detector.
-	name string
+	Name string
 
+	mu sync.Mutex
 	// requests counts number of dial requests to peers. We handle request at a peer
 	// level and record results at individual address dial level.
 	requests int
@@ -67,22 +58,19 @@ type blackHoleFilter struct {
 	successes int
 	// state is the current state of the detector
 	state blackHoleState
-
-	mu            sync.Mutex
-	metricsTracer MetricsTracer
 }
 
-// RecordResult records the outcome of a dial. A successful dial will change the state
+// RecordResult records the outcome of a dial. A successful dial in Blocked state will change the
-// of the filter to Allowed. A failed dial only blocks subsequent requests if the success
+// state of the filter to Probing. A failed dial only blocks subsequent requests if the success
 // fraction over the last n outcomes is less than the minSuccessFraction of the filter.
-func (b *blackHoleFilter) RecordResult(success bool) {
+func (b *BlackHoleSuccessCounter) RecordResult(success bool) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	if b.state == blackHoleStateBlocked && success {
 		// If the call succeeds in a blocked state we reset to allowed.
 		// This is better than slowly accumulating values till we cross the minSuccessFraction
-		// threshold since a blackhole is a binary property.
+		// threshold since a black hole is a binary property.
 		b.reset()
 		return
 	}
@@ -92,7 +80,7 @@ func (b *blackHoleFilter) RecordResult(success bool) {
 	}
 	b.dialResults = append(b.dialResults, success)
 
-	if len(b.dialResults) > b.n {
+	if len(b.dialResults) > b.N {
 		if b.dialResults[0] {
 			b.successes--
 		}
@@ -100,58 +88,68 @@ func (b *blackHoleFilter) RecordResult(success bool) {
 	}
 
 	b.updateState()
-	b.trackMetrics()
 }
 
 // HandleRequest returns the result of applying the black hole filter for the request.
-func (b *blackHoleFilter) HandleRequest() blackHoleResult {
+func (b *BlackHoleSuccessCounter) HandleRequest() blackHoleState {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	b.requests++
 
-	b.trackMetrics()
-
 	if b.state == blackHoleStateAllowed {
-		return blackHoleResultAllowed
+		return blackHoleStateAllowed
-	} else if b.state == blackHoleStateProbing || b.requests%b.n == 0 {
+	} else if b.state == blackHoleStateProbing || b.requests%b.N == 0 {
-		return blackHoleResultProbing
+		return blackHoleStateProbing
 	} else {
-		return blackHoleResultBlocked
+		return blackHoleStateBlocked
 	}
 }
 
-func (b *blackHoleFilter) reset() {
+func (b *BlackHoleSuccessCounter) reset() {
 	b.successes = 0
 	b.dialResults = b.dialResults[:0]
 	b.requests = 0
 	b.updateState()
 }
 
-func (b *blackHoleFilter) updateState() {
+func (b *BlackHoleSuccessCounter) updateState() {
 	st := b.state
 
-	if len(b.dialResults) < b.n {
+	if len(b.dialResults) < b.N {
 		b.state = blackHoleStateProbing
-	} else if b.successes >= b.minSuccesses {
+	} else if b.successes >= b.MinSuccesses {
 		b.state = blackHoleStateAllowed
 	} else {
 		b.state = blackHoleStateBlocked
 	}
 
 	if st != b.state {
-		log.Debugf("%s blackHoleDetector state changed from %s to %s", b.name, st, b.state)
+		log.Debugf("%s blackHoleDetector state changed from %s to %s", b.Name, st, b.state)
 	}
 }
 
-func (b *blackHoleFilter) trackMetrics() {
+func (b *BlackHoleSuccessCounter) State() blackHoleState {
-	if b.metricsTracer == nil {
+	b.mu.Lock()
-		return
+	defer b.mu.Unlock()
-	}
 
-	nextRequestAllowedAfter := 0
+	return b.state
+}
+
+type blackHoleInfo struct {
+	name            string
+	state           blackHoleState
+	nextProbeAfter  int
+	successFraction float64
+}
+
+func (b *BlackHoleSuccessCounter) info() blackHoleInfo {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	nextProbeAfter := 0
 	if b.state == blackHoleStateBlocked {
-		nextRequestAllowedAfter = b.n - (b.requests % b.n)
+		nextProbeAfter = b.N - (b.requests % b.N)
 	}
 
 	successFraction := 0.0
@@ -159,22 +157,27 @@ func (b *blackHoleFilter) trackMetrics() {
 		successFraction = float64(b.successes) / float64(len(b.dialResults))
 	}
 
-	b.metricsTracer.UpdatedBlackHoleFilterState(
+	return blackHoleInfo{
-		b.name,
+		name:            b.Name,
-		b.state,
+		state:           b.state,
-		nextRequestAllowedAfter,
+		nextProbeAfter:  nextProbeAfter,
-		successFraction,
+		successFraction: successFraction,
-	)
+	}
 }
 
-// blackHoleDetector provides UDP and IPv6 black hole detection using a `blackHoleFilter`
+// blackHoleDetector provides UDP and IPv6 black hole detection using a `BlackHoleSuccessCounter` for each.
-// for each. For details of the black hole detection logic see `blackHoleFilter`.
+// For details of the black hole detection logic see `BlackHoleSuccessCounter`.
+// In Read Only mode, detector doesn't update the state of underlying filters and refuses requests
+// when black hole state is unknown. This is useful for Swarms made specifically for services like
+// AutoNAT where we care about accurately reporting the reachability of a peer.
 //
-// black hole filtering is done at a peer dial level to ensure that periodic probes to
+// Black hole filtering is done at a peer dial level to ensure that periodic probes to detect change
-// detect change of the black hole state are actually dialed and are not skipped
+// of the black hole state are actually dialed and are not skipped because of dial prioritisation
-// because of dial prioritisation logic.
+// logic.
 type blackHoleDetector struct {
-	udp, ipv6 *blackHoleFilter
+	udp, ipv6 *BlackHoleSuccessCounter
+	mt        MetricsTracer
+	readOnly  bool
 }
 
 // FilterAddrs filters the peer's addresses removing black holed addresses
@@ -192,14 +195,16 @@ func (d *blackHoleDetector) FilterAddrs(addrs []ma.Multiaddr) (valid []ma.Multia
 		}
 	}
 
-	udpRes := blackHoleResultAllowed
+	udpRes := blackHoleStateAllowed
 	if d.udp != nil && hasUDP {
-		udpRes = d.udp.HandleRequest()
+		udpRes = d.getFilterState(d.udp)
+		d.trackMetrics(d.udp)
 	}
 
-	ipv6Res := blackHoleResultAllowed
+	ipv6Res := blackHoleStateAllowed
 	if d.ipv6 != nil && hasIPv6 {
-		ipv6Res = d.ipv6.HandleRequest()
+		ipv6Res = d.getFilterState(d.ipv6)
+		d.trackMetrics(d.ipv6)
 	}
 
 	blackHoled = make([]ma.Multiaddr, 0, len(addrs))
@@ -210,19 +215,19 @@ func (d *blackHoleDetector) FilterAddrs(addrs []ma.Multiaddr) (valid []ma.Multia
 				return true
 			}
 			// allow all UDP addresses while probing irrespective of IPv6 black hole state
-			if udpRes == blackHoleResultProbing && isProtocolAddr(a, ma.P_UDP) {
+			if udpRes == blackHoleStateProbing && isProtocolAddr(a, ma.P_UDP) {
 				return true
 			}
 			// allow all IPv6 addresses while probing irrespective of UDP black hole state
-			if ipv6Res == blackHoleResultProbing && isProtocolAddr(a, ma.P_IP6) {
+			if ipv6Res == blackHoleStateProbing && isProtocolAddr(a, ma.P_IP6) {
 				return true
 			}
 
-			if udpRes == blackHoleResultBlocked && isProtocolAddr(a, ma.P_UDP) {
+			if udpRes == blackHoleStateBlocked && isProtocolAddr(a, ma.P_UDP) {
 				blackHoled = append(blackHoled, a)
 				return false
 			}
-			if ipv6Res == blackHoleResultBlocked && isProtocolAddr(a, ma.P_IP6) {
+			if ipv6Res == blackHoleStateBlocked && isProtocolAddr(a, ma.P_IP6) {
 				blackHoled = append(blackHoled, a)
 				return false
 			}
@@ -231,49 +236,36 @@ func (d *blackHoleDetector) FilterAddrs(addrs []ma.Multiaddr) (valid []ma.Multia
 	), blackHoled
 }
 
-// RecordResult updates the state of the relevant `blackHoleFilter`s for addr
+// RecordResult updates the state of the relevant BlackHoleSuccessCounters for addr
 func (d *blackHoleDetector) RecordResult(addr ma.Multiaddr, success bool) {
-	if !manet.IsPublicAddr(addr) {
+	if d.readOnly || !manet.IsPublicAddr(addr) {
 		return
 	}
 	if d.udp != nil && isProtocolAddr(addr, ma.P_UDP) {
 		d.udp.RecordResult(success)
+		d.trackMetrics(d.udp)
 	}
 	if d.ipv6 != nil && isProtocolAddr(addr, ma.P_IP6) {
 		d.ipv6.RecordResult(success)
+		d.trackMetrics(d.ipv6)
 	}
 }
 
-// blackHoleConfig is the config used for black hole detection
+func (d *blackHoleDetector) getFilterState(f *BlackHoleSuccessCounter) blackHoleState {
-type blackHoleConfig struct {
+	if d.readOnly {
-	// Enabled enables black hole detection
+		if f.State() != blackHoleStateAllowed {
-	Enabled bool
+			return blackHoleStateBlocked
-	// N is the size of the sliding window used to evaluate black hole state
-	N int
-	// MinSuccesses is the minimum number of successes out of N required to not
-	// block requests
-	MinSuccesses int
-}
-
-func newBlackHoleDetector(udpConfig, ipv6Config blackHoleConfig, mt MetricsTracer) *blackHoleDetector {
-	d := &blackHoleDetector{}
-
-	if udpConfig.Enabled {
-		d.udp = &blackHoleFilter{
-			n:             udpConfig.N,
-			minSuccesses:  udpConfig.MinSuccesses,
-			name:          "UDP",
-			metricsTracer: mt,
 		}
+		return blackHoleStateAllowed
 	}
-
+	return f.HandleRequest()
-	if ipv6Config.Enabled {
+}
-		d.ipv6 = &blackHoleFilter{
+
-			n:             ipv6Config.N,
+func (d *blackHoleDetector) trackMetrics(f *BlackHoleSuccessCounter) {
-			minSuccesses:  ipv6Config.MinSuccesses,
+	if d.readOnly || d.mt == nil {
-			name:          "IPv6",
+		return
-			metricsTracer: mt,
+	}
-		}
+	// Track metrics only in non readOnly state
-	}
+	info := f.info()
-	return d
+	d.mt.UpdatedBlackHoleSuccessCounter(info.name, info.state, info.nextProbeAfter, info.successFraction)
 }

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/dial_worker.go

@@ -254,7 +254,7 @@ loop:
 						if simConnect, _, _ := network.GetSimultaneousConnect(ad.ctx); !simConnect {
 							ad.ctx = network.WithSimultaneousConnect(ad.ctx, isClient, reason)
 							// update the element in dq to use the simultaneous connect delay.
-							dq.Add(network.AddrDelay{
+							dq.UpdateOrAdd(network.AddrDelay{
 								Addr:  ad.addr,
 								Delay: addrDelay[string(ad.addr.Bytes())],
 							})
@@ -436,12 +436,31 @@ type dialQueue struct {
 
 // newDialQueue returns a new dialQueue
 func newDialQueue() *dialQueue {
-	return &dialQueue{q: make([]network.AddrDelay, 0, 16)}
+	return &dialQueue{
+		q: make([]network.AddrDelay, 0, 16),
+	}
 }
 
-// Add adds adelay to the queue. If another element exists in the queue with
+// Add adds a new element to the dialQueue. To update an element use UpdateOrAdd.
-// the same address, it replaces that element.
 func (dq *dialQueue) Add(adelay network.AddrDelay) {
+	for i := dq.Len() - 1; i >= 0; i-- {
+		if dq.q[i].Delay <= adelay.Delay {
+			// insert at pos i+1
+			dq.q = append(dq.q, network.AddrDelay{}) // extend the slice
+			copy(dq.q[i+2:], dq.q[i+1:])
+			dq.q[i+1] = adelay
+			return
+		}
+	}
+	// insert at position 0
+	dq.q = append(dq.q, network.AddrDelay{}) // extend the slice
+	copy(dq.q[1:], dq.q[0:])
+	dq.q[0] = adelay
+}
+
+// UpdateOrAdd updates the elements with address adelay.Addr to the new delay
+// Useful when hole punching
+func (dq *dialQueue) UpdateOrAdd(adelay network.AddrDelay) {
 	for i := 0; i < dq.Len(); i++ {
 		if dq.q[i].Addr.Equal(adelay.Addr) {
 			if dq.q[i].Delay == adelay.Delay {
@@ -451,19 +470,9 @@ func (dq *dialQueue) Add(adelay network.AddrDelay) {
 			// remove the element
 			copy(dq.q[i:], dq.q[i+1:])
 			dq.q = dq.q[:len(dq.q)-1]
-			break
 		}
 	}
-
+	dq.Add(adelay)
-	for i := 0; i < dq.Len(); i++ {
-		if dq.q[i].Delay > adelay.Delay {
-			dq.q = append(dq.q, network.AddrDelay{}) // extend the slice
-			copy(dq.q[i+1:], dq.q[i:])
-			dq.q[i] = adelay
-			return
-		}
-	}
-	dq.q = append(dq.q, adelay)
 }
 
 // NextBatch returns all the elements in the queue with the highest priority

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/swarm.go

@@ -32,6 +32,8 @@ const (
 	// This includes the time between dialing the raw network connection,
 	// protocol selection as well the handshake, if applicable.
 	defaultDialTimeoutLocal = 5 * time.Second
+
+	defaultNewStreamTimeout = 15 * time.Second
 )
 
 var log = logging.Logger("swarm2")
@@ -112,22 +114,33 @@ func WithDialRanker(d network.DialRanker) Option {
 	}
 }
 
-// WithUDPBlackHoleConfig configures swarm to use c as the config for UDP black hole detection
+// WithUDPBlackHoleSuccessCounter configures swarm to use the provided config for UDP black hole detection
 // n is the size of the sliding window used to evaluate black hole state
 // min is the minimum number of successes out of n required to not block requests
-func WithUDPBlackHoleConfig(enabled bool, n, min int) Option {
+func WithUDPBlackHoleSuccessCounter(f *BlackHoleSuccessCounter) Option {
 	return func(s *Swarm) error {
-		s.udpBlackHoleConfig = blackHoleConfig{Enabled: enabled, N: n, MinSuccesses: min}
+		s.udpBHF = f
 		return nil
 	}
 }
 
-// WithIPv6BlackHoleConfig configures swarm to use c as the config for IPv6 black hole detection
+// WithIPv6BlackHoleSuccessCounter configures swarm to use the provided config for IPv6 black hole detection
 // n is the size of the sliding window used to evaluate black hole state
 // min is the minimum number of successes out of n required to not block requests
-func WithIPv6BlackHoleConfig(enabled bool, n, min int) Option {
+func WithIPv6BlackHoleSuccessCounter(f *BlackHoleSuccessCounter) Option {
 	return func(s *Swarm) error {
-		s.ipv6BlackHoleConfig = blackHoleConfig{Enabled: enabled, N: n, MinSuccesses: min}
+		s.ipv6BHF = f
+		return nil
+	}
+}
+
+// WithReadOnlyBlackHoleDetector configures the swarm to use the black hole detector in
+// read only mode. In Read Only mode dial requests are refused in unknown state and
+// no updates to the detector state are made. This is useful for services like AutoNAT that
+// care about accurately providing reachability info.
+func WithReadOnlyBlackHoleDetector() Option {
+	return func(s *Swarm) error {
+		s.readOnlyBHD = true
 		return nil
 	}
 }
@@ -203,10 +216,11 @@ type Swarm struct {
 
 	dialRanker network.DialRanker
 
-	udpBlackHoleConfig        blackHoleConfig
-	ipv6BlackHoleConfig       blackHoleConfig
-	bhd                       *blackHoleDetector
 	connectednessEventEmitter *connectednessEventEmitter
+	udpBHF                    *BlackHoleSuccessCounter
+	ipv6BHF                   *BlackHoleSuccessCounter
+	bhd                       *blackHoleDetector
+	readOnlyBHD               bool
 }
 
 // NewSwarm constructs a Swarm.
@@ -230,8 +244,8 @@ func NewSwarm(local peer.ID, peers peerstore.Peerstore, eventBus event.Bus, opts
 		// A black hole is a binary property. On a network if UDP dials are blocked or there is
 		// no IPv6 connectivity, all dials will fail. So a low success rate of 5 out 100 dials
 		// is good enough.
-		udpBlackHoleConfig:  blackHoleConfig{Enabled: true, N: 100, MinSuccesses: 5},
+		udpBHF:  &BlackHoleSuccessCounter{N: 100, MinSuccesses: 5, Name: "UDP"},
-		ipv6BlackHoleConfig: blackHoleConfig{Enabled: true, N: 100, MinSuccesses: 5},
+		ipv6BHF: &BlackHoleSuccessCounter{N: 100, MinSuccesses: 5, Name: "IPv6"},
 	}
 
 	s.conns.m = make(map[peer.ID][]*Conn)
@@ -255,7 +269,12 @@ func NewSwarm(local peer.ID, peers peerstore.Peerstore, eventBus event.Bus, opts
 	s.limiter = newDialLimiter(s.dialAddr)
 	s.backf.init(s.ctx)
 
-	s.bhd = newBlackHoleDetector(s.udpBlackHoleConfig, s.ipv6BlackHoleConfig, s.metricsTracer)
+	s.bhd = &blackHoleDetector{
+		udp:      s.udpBHF,
+		ipv6:     s.ipv6BHF,
+		mt:       s.metricsTracer,
+		readOnly: s.readOnlyBHD,
+	}
 	return s, nil
 }
 

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/swarm_conn.go

@@ -209,9 +209,18 @@ func (c *Conn) NewStream(ctx context.Context) (network.Stream, error) {
 		return nil, err
 	}
 
+	if _, ok := ctx.Deadline(); !ok {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, defaultNewStreamTimeout)
+		defer cancel()
+	}
+
 	s, err := c.openAndAddStream(ctx, scope)
 	if err != nil {
 		scope.Done()
+		if errors.Is(err, context.DeadlineExceeded) {
+			err = fmt.Errorf("timed out: %w", err)
+		}
 		return nil, err
 	}
 	return s, nil

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/swarm_dial.go

@@ -416,6 +416,11 @@ func (s *Swarm) dialNextAddr(ctx context.Context, p peer.ID, addr ma.Multiaddr,
 	return nil
 }
 
+func (s *Swarm) CanDial(p peer.ID, addr ma.Multiaddr) bool {
+	dialable, _ := s.filterKnownUndialables(p, []ma.Multiaddr{addr})
+	return len(dialable) > 0
+}
+
 func (s *Swarm) nonProxyAddr(addr ma.Multiaddr) bool {
 	t := s.TransportForDialing(addr)
 	return !t.Proxy()

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/swarm_listen.go

@@ -3,6 +3,7 @@ package swarm
 import (
 	"errors"
 	"fmt"
+	"slices"
 	"time"
 
 	"github.com/libp2p/go-libp2p/core/canonicallog"
@@ -12,13 +13,44 @@ import (
 	ma "github.com/multiformats/go-multiaddr"
 )
 
+type OrderedListener interface {
+	// Transports optionally implement this interface to indicate the relative
+	// ordering that listeners should be setup. Some transports may optionally
+	// make use of other listeners if they are setup. e.g. WebRTC may reuse the
+	// same UDP port as QUIC, but only when QUIC is setup first.
+	// lower values are setup first.
+	ListenOrder() int
+}
+
 // Listen sets up listeners for all of the given addresses.
 // It returns as long as we successfully listen on at least *one* address.
 func (s *Swarm) Listen(addrs ...ma.Multiaddr) error {
 	errs := make([]error, len(addrs))
 	var succeeded int
-	for i, a := range addrs {
+
-		if err := s.AddListenAddr(a); err != nil {
+	type addrAndListener struct {
+		addr ma.Multiaddr
+		lTpt transport.Transport
+	}
+	sortedAddrsAndTpts := make([]addrAndListener, 0, len(addrs))
+	for _, a := range addrs {
+		t := s.TransportForListening(a)
+		sortedAddrsAndTpts = append(sortedAddrsAndTpts, addrAndListener{addr: a, lTpt: t})
+	}
+	slices.SortFunc(sortedAddrsAndTpts, func(a, b addrAndListener) int {
+		aOrder := 0
+		bOrder := 0
+		if l, ok := a.lTpt.(OrderedListener); ok {
+			aOrder = l.ListenOrder()
+		}
+		if l, ok := b.lTpt.(OrderedListener); ok {
+			bOrder = l.ListenOrder()
+		}
+		return aOrder - bOrder
+	})
+
+	for i, a := range sortedAddrsAndTpts {
+		if err := s.AddListenAddr(a.addr); err != nil {
 			errs[i] = err
 		} else {
 			succeeded++
@@ -27,11 +59,11 @@ func (s *Swarm) Listen(addrs ...ma.Multiaddr) error {
 
 	for i, e := range errs {
 		if e != nil {
-			log.Warnw("listening failed", "on", addrs[i], "error", errs[i])
+			log.Warnw("listening failed", "on", sortedAddrsAndTpts[i].addr, "error", errs[i])
 		}
 	}
 
-	if succeeded == 0 && len(addrs) > 0 {
+	if succeeded == 0 && len(sortedAddrsAndTpts) > 0 {
 		return fmt.Errorf("failed to listen on any addresses: %s", errs)
 	}
 

vendor/github.com/libp2p/go-libp2p/p2p/net/swarm/swarm_metrics.go

@@ -85,7 +85,7 @@ var (
 			Buckets:   []float64{0.001, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.75, 1, 2},
 		},
 	)
-	blackHoleFilterState = prometheus.NewGaugeVec(
+	blackHoleSuccessCounterState = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Namespace: metricNamespace,
 			Name:      "black_hole_filter_state",
@@ -93,7 +93,7 @@ var (
 		},
 		[]string{"name"},
 	)
-	blackHoleFilterSuccessFraction = prometheus.NewGaugeVec(
+	blackHoleSuccessCounterSuccessFraction = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Namespace: metricNamespace,
 			Name:      "black_hole_filter_success_fraction",
@@ -101,7 +101,7 @@ var (
 		},
 		[]string{"name"},
 	)
-	blackHoleFilterNextRequestAllowedAfter = prometheus.NewGaugeVec(
+	blackHoleSuccessCounterNextRequestAllowedAfter = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Namespace: metricNamespace,
 			Name:      "black_hole_filter_next_request_allowed_after",
@@ -118,9 +118,9 @@ var (
 		connHandshakeLatency,
 		dialsPerPeer,
 		dialRankingDelay,
-		blackHoleFilterSuccessFraction,
+		blackHoleSuccessCounterSuccessFraction,
-		blackHoleFilterState,
+		blackHoleSuccessCounterState,
-		blackHoleFilterNextRequestAllowedAfter,
+		blackHoleSuccessCounterNextRequestAllowedAfter,
 	}
 )
 
@@ -131,7 +131,7 @@ type MetricsTracer interface {
 	FailedDialing(ma.Multiaddr, error, error)
 	DialCompleted(success bool, totalDials int)
 	DialRankingDelay(d time.Duration)
-	UpdatedBlackHoleFilterState(name string, state blackHoleState, nextProbeAfter int, successFraction float64)
+	UpdatedBlackHoleSuccessCounter(name string, state blackHoleState, nextProbeAfter int, successFraction float64)
 }
 
 type metricsTracer struct{}
@@ -274,14 +274,14 @@ func (m *metricsTracer) DialRankingDelay(d time.Duration) {
 	dialRankingDelay.Observe(d.Seconds())
 }
 
-func (m *metricsTracer) UpdatedBlackHoleFilterState(name string, state blackHoleState,
+func (m *metricsTracer) UpdatedBlackHoleSuccessCounter(name string, state blackHoleState,
 	nextProbeAfter int, successFraction float64) {
 	tags := metricshelper.GetStringSlice()
 	defer metricshelper.PutStringSlice(tags)
 
 	*tags = append(*tags, name)
 
-	blackHoleFilterState.WithLabelValues(*tags...).Set(float64(state))
+	blackHoleSuccessCounterState.WithLabelValues(*tags...).Set(float64(state))
-	blackHoleFilterSuccessFraction.WithLabelValues(*tags...).Set(successFraction)
+	blackHoleSuccessCounterSuccessFraction.WithLabelValues(*tags...).Set(successFraction)
-	blackHoleFilterNextRequestAllowedAfter.WithLabelValues(*tags...).Set(float64(nextProbeAfter))
+	blackHoleSuccessCounterNextRequestAllowedAfter.WithLabelValues(*tags...).Set(float64(nextProbeAfter))
 }

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/autonat.go

@@ -0,0 +1,236 @@
+package autonatv2
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/libp2p/go-libp2p/core/event"
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr/net"
+	"golang.org/x/exp/rand"
+	"golang.org/x/exp/slices"
+)
+
+//go:generate protoc --go_out=. --go_opt=Mpb/autonatv2.proto=./pb pb/autonatv2.proto
+
+const (
+	ServiceName      = "libp2p.autonatv2"
+	DialBackProtocol = "/libp2p/autonat/2/dial-back"
+	DialProtocol     = "/libp2p/autonat/2/dial-request"
+
+	maxMsgSize            = 8192
+	streamTimeout         = time.Minute
+	dialBackStreamTimeout = 5 * time.Second
+	dialBackDialTimeout   = 30 * time.Second
+	dialBackMaxMsgSize    = 1024
+	minHandshakeSizeBytes = 30_000 // for amplification attack prevention
+	maxHandshakeSizeBytes = 100_000
+	// maxPeerAddresses is the number of addresses in a dial request the server
+	// will inspect, rest are ignored.
+	maxPeerAddresses = 50
+)
+
+var (
+	ErrNoValidPeers = errors.New("no valid peers for autonat v2")
+	ErrDialRefused  = errors.New("dial refused")
+
+	log = logging.Logger("autonatv2")
+)
+
+// Request is the request to verify reachability of a single address
+type Request struct {
+	// Addr is the multiaddr to verify
+	Addr ma.Multiaddr
+	// SendDialData indicates whether to send dial data if the server requests it for Addr
+	SendDialData bool
+}
+
+// Result is the result of the CheckReachability call
+type Result struct {
+	// Addr is the dialed address
+	Addr ma.Multiaddr
+	// Reachability of the dialed address
+	Reachability network.Reachability
+	// Status is the outcome of the dialback
+	Status pb.DialStatus
+}
+
+// AutoNAT implements the AutoNAT v2 client and server.
+// Users can check reachability for their addresses using the CheckReachability method.
+// The server provides amplification attack prevention and rate limiting.
+type AutoNAT struct {
+	host host.Host
+
+	// for cleanly closing
+	ctx    context.Context
+	cancel context.CancelFunc
+	wg     sync.WaitGroup
+
+	srv *server
+	cli *client
+
+	mx    sync.Mutex
+	peers *peersMap
+	// allowPrivateAddrs enables using private and localhost addresses for reachability checks.
+	// This is only useful for testing.
+	allowPrivateAddrs bool
+}
+
+// New returns a new AutoNAT instance.
+// host and dialerHost should have the same dialing capabilities. In case the host doesn't support
+// a transport, dial back requests for address for that transport will be ignored.
+func New(host host.Host, dialerHost host.Host, opts ...AutoNATOption) (*AutoNAT, error) {
+	s := defaultSettings()
+	for _, o := range opts {
+		if err := o(s); err != nil {
+			return nil, fmt.Errorf("failed to apply option: %w", err)
+		}
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	an := &AutoNAT{
+		host:              host,
+		ctx:               ctx,
+		cancel:            cancel,
+		srv:               newServer(host, dialerHost, s),
+		cli:               newClient(host),
+		allowPrivateAddrs: s.allowPrivateAddrs,
+		peers:             newPeersMap(),
+	}
+	return an, nil
+}
+
+func (an *AutoNAT) background(sub event.Subscription) {
+	for {
+		select {
+		case <-an.ctx.Done():
+			sub.Close()
+			an.wg.Done()
+			return
+		case e := <-sub.Out():
+			switch evt := e.(type) {
+			case event.EvtPeerProtocolsUpdated:
+				an.updatePeer(evt.Peer)
+			case event.EvtPeerConnectednessChanged:
+				an.updatePeer(evt.Peer)
+			case event.EvtPeerIdentificationCompleted:
+				an.updatePeer(evt.Peer)
+			}
+		}
+	}
+}
+
+func (an *AutoNAT) Start() error {
+	// Listen on event.EvtPeerProtocolsUpdated, event.EvtPeerConnectednessChanged
+	// event.EvtPeerIdentificationCompleted to maintain our set of autonat supporting peers.
+	sub, err := an.host.EventBus().Subscribe([]interface{}{
+		new(event.EvtPeerProtocolsUpdated),
+		new(event.EvtPeerConnectednessChanged),
+		new(event.EvtPeerIdentificationCompleted),
+	})
+	if err != nil {
+		return fmt.Errorf("event subscription failed: %w", err)
+	}
+	an.cli.Start()
+	an.srv.Start()
+
+	an.wg.Add(1)
+	go an.background(sub)
+	return nil
+}
+
+func (an *AutoNAT) Close() {
+	an.cancel()
+	an.wg.Wait()
+	an.srv.Close()
+	an.cli.Close()
+	an.peers = nil
+}
+
+// GetReachability makes a single dial request for checking reachability for requested addresses
+func (an *AutoNAT) GetReachability(ctx context.Context, reqs []Request) (Result, error) {
+	if !an.allowPrivateAddrs {
+		for _, r := range reqs {
+			if !manet.IsPublicAddr(r.Addr) {
+				return Result{}, fmt.Errorf("private address cannot be verified by autonatv2: %s", r.Addr)
+			}
+		}
+	}
+	an.mx.Lock()
+	p := an.peers.GetRand()
+	an.mx.Unlock()
+	if p == "" {
+		return Result{}, ErrNoValidPeers
+	}
+
+	res, err := an.cli.GetReachability(ctx, p, reqs)
+	if err != nil {
+		log.Debugf("reachability check with %s failed, err: %s", p, err)
+		return Result{}, fmt.Errorf("reachability check with %s failed: %w", p, err)
+	}
+	log.Debugf("reachability check with %s successful", p)
+	return res, nil
+}
+
+func (an *AutoNAT) updatePeer(p peer.ID) {
+	an.mx.Lock()
+	defer an.mx.Unlock()
+
+	// There are no ordering gurantees between identify and swarm events. Check peerstore
+	// and swarm for the current state
+	protos, err := an.host.Peerstore().SupportsProtocols(p, DialProtocol)
+	connectedness := an.host.Network().Connectedness(p)
+	if err == nil && slices.Contains(protos, DialProtocol) && connectedness == network.Connected {
+		an.peers.Put(p)
+	} else {
+		an.peers.Delete(p)
+	}
+}
+
+// peersMap provides random access to a set of peers. This is useful when the map iteration order is
+// not sufficiently random.
+type peersMap struct {
+	peerIdx map[peer.ID]int
+	peers   []peer.ID
+}
+
+func newPeersMap() *peersMap {
+	return &peersMap{
+		peerIdx: make(map[peer.ID]int),
+		peers:   make([]peer.ID, 0),
+	}
+}
+
+func (p *peersMap) GetRand() peer.ID {
+	if len(p.peers) == 0 {
+		return ""
+	}
+	return p.peers[rand.Intn(len(p.peers))]
+}
+
+func (p *peersMap) Put(pid peer.ID) {
+	if _, ok := p.peerIdx[pid]; ok {
+		return
+	}
+	p.peers = append(p.peers, pid)
+	p.peerIdx[pid] = len(p.peers) - 1
+}
+
+func (p *peersMap) Delete(pid peer.ID) {
+	idx, ok := p.peerIdx[pid]
+	if !ok {
+		return
+	}
+	p.peers[idx] = p.peers[len(p.peers)-1]
+	p.peerIdx[p.peers[idx]] = idx
+	p.peers = p.peers[:len(p.peers)-1]
+	delete(p.peerIdx, pid)
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/client.go

@@ -0,0 +1,342 @@
+package autonatv2
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb"
+	"github.com/libp2p/go-msgio/pbio"
+	ma "github.com/multiformats/go-multiaddr"
+	"golang.org/x/exp/rand"
+)
+
+//go:generate protoc --go_out=. --go_opt=Mpb/autonatv2.proto=./pb pb/autonatv2.proto
+
+// client implements the client for making dial requests for AutoNAT v2. It verifies successful
+// dials and provides an option to send data for dial requests.
+type client struct {
+	host               host.Host
+	dialData           []byte
+	normalizeMultiaddr func(ma.Multiaddr) ma.Multiaddr
+
+	mu sync.Mutex
+	// dialBackQueues maps nonce to the channel for providing the local multiaddr of the connection
+	// the nonce was received on
+	dialBackQueues map[uint64]chan ma.Multiaddr
+}
+
+type normalizeMultiaddrer interface {
+	NormalizeMultiaddr(ma.Multiaddr) ma.Multiaddr
+}
+
+func newClient(h host.Host) *client {
+	normalizeMultiaddr := func(a ma.Multiaddr) ma.Multiaddr { return a }
+	if hn, ok := h.(normalizeMultiaddrer); ok {
+		normalizeMultiaddr = hn.NormalizeMultiaddr
+	}
+	return &client{
+		host:               h,
+		dialData:           make([]byte, 4000),
+		normalizeMultiaddr: normalizeMultiaddr,
+		dialBackQueues:     make(map[uint64]chan ma.Multiaddr),
+	}
+}
+
+func (ac *client) Start() {
+	ac.host.SetStreamHandler(DialBackProtocol, ac.handleDialBack)
+}
+
+func (ac *client) Close() {
+	ac.host.RemoveStreamHandler(DialBackProtocol)
+}
+
+// GetReachability verifies address reachability with a AutoNAT v2 server p.
+func (ac *client) GetReachability(ctx context.Context, p peer.ID, reqs []Request) (Result, error) {
+	ctx, cancel := context.WithTimeout(ctx, streamTimeout)
+	defer cancel()
+
+	s, err := ac.host.NewStream(ctx, p, DialProtocol)
+	if err != nil {
+		return Result{}, fmt.Errorf("open %s stream failed: %w", DialProtocol, err)
+	}
+
+	if err := s.Scope().SetService(ServiceName); err != nil {
+		s.Reset()
+		return Result{}, fmt.Errorf("attach stream %s to service %s failed: %w", DialProtocol, ServiceName, err)
+	}
+
+	if err := s.Scope().ReserveMemory(maxMsgSize, network.ReservationPriorityAlways); err != nil {
+		s.Reset()
+		return Result{}, fmt.Errorf("failed to reserve memory for stream %s: %w", DialProtocol, err)
+	}
+	defer s.Scope().ReleaseMemory(maxMsgSize)
+
+	s.SetDeadline(time.Now().Add(streamTimeout))
+	defer s.Close()
+
+	nonce := rand.Uint64()
+	ch := make(chan ma.Multiaddr, 1)
+	ac.mu.Lock()
+	ac.dialBackQueues[nonce] = ch
+	ac.mu.Unlock()
+	defer func() {
+		ac.mu.Lock()
+		delete(ac.dialBackQueues, nonce)
+		ac.mu.Unlock()
+	}()
+
+	msg := newDialRequest(reqs, nonce)
+	w := pbio.NewDelimitedWriter(s)
+	if err := w.WriteMsg(&msg); err != nil {
+		s.Reset()
+		return Result{}, fmt.Errorf("dial request write failed: %w", err)
+	}
+
+	r := pbio.NewDelimitedReader(s, maxMsgSize)
+	if err := r.ReadMsg(&msg); err != nil {
+		s.Reset()
+		return Result{}, fmt.Errorf("dial msg read failed: %w", err)
+	}
+
+	switch {
+	case msg.GetDialResponse() != nil:
+		break
+	// provide dial data if appropriate
+	case msg.GetDialDataRequest() != nil:
+		if err := ac.validateDialDataRequest(reqs, &msg); err != nil {
+			s.Reset()
+			return Result{}, fmt.Errorf("invalid dial data request: %w", err)
+		}
+		// dial data request is valid and we want to send data
+		if err := sendDialData(ac.dialData, int(msg.GetDialDataRequest().GetNumBytes()), w, &msg); err != nil {
+			s.Reset()
+			return Result{}, fmt.Errorf("dial data send failed: %w", err)
+		}
+		if err := r.ReadMsg(&msg); err != nil {
+			s.Reset()
+			return Result{}, fmt.Errorf("dial response read failed: %w", err)
+		}
+		if msg.GetDialResponse() == nil {
+			s.Reset()
+			return Result{}, fmt.Errorf("invalid response type: %T", msg.Msg)
+		}
+	default:
+		s.Reset()
+		return Result{}, fmt.Errorf("invalid msg type: %T", msg.Msg)
+	}
+
+	resp := msg.GetDialResponse()
+	if resp.GetStatus() != pb.DialResponse_OK {
+		// E_DIAL_REFUSED has implication for deciding future address verificiation priorities
+		// wrap a distinct error for convenient errors.Is usage
+		if resp.GetStatus() == pb.DialResponse_E_DIAL_REFUSED {
+			return Result{}, fmt.Errorf("dial request failed: %w", ErrDialRefused)
+		}
+		return Result{}, fmt.Errorf("dial request failed: response status %d %s", resp.GetStatus(),
+			pb.DialResponse_ResponseStatus_name[int32(resp.GetStatus())])
+	}
+	if resp.GetDialStatus() == pb.DialStatus_UNUSED {
+		return Result{}, fmt.Errorf("invalid response: invalid dial status UNUSED")
+	}
+	if int(resp.AddrIdx) >= len(reqs) {
+		return Result{}, fmt.Errorf("invalid response: addr index out of range: %d [0-%d)", resp.AddrIdx, len(reqs))
+	}
+
+	// wait for nonce from the server
+	var dialBackAddr ma.Multiaddr
+	if resp.GetDialStatus() == pb.DialStatus_OK {
+		timer := time.NewTimer(dialBackStreamTimeout)
+		select {
+		case at := <-ch:
+			dialBackAddr = at
+		case <-ctx.Done():
+		case <-timer.C:
+		}
+		timer.Stop()
+	}
+	return ac.newResult(resp, reqs, dialBackAddr)
+}
+
+func (ac *client) validateDialDataRequest(reqs []Request, msg *pb.Message) error {
+	idx := int(msg.GetDialDataRequest().AddrIdx)
+	if idx >= len(reqs) { // invalid address index
+		return fmt.Errorf("addr index out of range: %d [0-%d)", idx, len(reqs))
+	}
+	if msg.GetDialDataRequest().NumBytes > maxHandshakeSizeBytes { // data request is too high
+		return fmt.Errorf("requested data too high: %d", msg.GetDialDataRequest().NumBytes)
+	}
+	if !reqs[idx].SendDialData { // low priority addr
+		return fmt.Errorf("low priority addr: %s index %d", reqs[idx].Addr, idx)
+	}
+	return nil
+}
+
+func (ac *client) newResult(resp *pb.DialResponse, reqs []Request, dialBackAddr ma.Multiaddr) (Result, error) {
+	idx := int(resp.AddrIdx)
+	addr := reqs[idx].Addr
+
+	var rch network.Reachability
+	switch resp.DialStatus {
+	case pb.DialStatus_OK:
+		if !ac.areAddrsConsistent(dialBackAddr, addr) {
+			// the server is misinforming us about the address it successfully dialed
+			// either we received no dialback or the address on the dialback is inconsistent with
+			// what the server is telling us
+			return Result{}, fmt.Errorf("invalid response: dialBackAddr: %s, respAddr: %s", dialBackAddr, addr)
+		}
+		rch = network.ReachabilityPublic
+	case pb.DialStatus_E_DIAL_ERROR:
+		rch = network.ReachabilityPrivate
+	case pb.DialStatus_E_DIAL_BACK_ERROR:
+		if ac.areAddrsConsistent(dialBackAddr, addr) {
+			// We received the dial back but the server claims the dial back errored.
+			// As long as we received the correct nonce in dial back it is safe to assume
+			// that we are public.
+			rch = network.ReachabilityPublic
+		} else {
+			rch = network.ReachabilityUnknown
+		}
+	default:
+		// Unexpected response code. Discard the response and fail.
+		log.Warnf("invalid status code received in response for addr %s: %d", addr, resp.DialStatus)
+		return Result{}, fmt.Errorf("invalid response: invalid status code for addr %s: %d", addr, resp.DialStatus)
+	}
+
+	return Result{
+		Addr:         addr,
+		Reachability: rch,
+		Status:       resp.DialStatus,
+	}, nil
+}
+
+func sendDialData(dialData []byte, numBytes int, w pbio.Writer, msg *pb.Message) (err error) {
+	ddResp := &pb.DialDataResponse{Data: dialData}
+	*msg = pb.Message{
+		Msg: &pb.Message_DialDataResponse{
+			DialDataResponse: ddResp,
+		},
+	}
+	for remain := numBytes; remain > 0; {
+		if remain < len(ddResp.Data) {
+			ddResp.Data = ddResp.Data[:remain]
+		}
+		if err := w.WriteMsg(msg); err != nil {
+			return fmt.Errorf("write failed: %w", err)
+		}
+		remain -= len(dialData)
+	}
+	return nil
+}
+
+func newDialRequest(reqs []Request, nonce uint64) pb.Message {
+	addrbs := make([][]byte, len(reqs))
+	for i, r := range reqs {
+		addrbs[i] = r.Addr.Bytes()
+	}
+	return pb.Message{
+		Msg: &pb.Message_DialRequest{
+			DialRequest: &pb.DialRequest{
+				Addrs: addrbs,
+				Nonce: nonce,
+			},
+		},
+	}
+}
+
+// handleDialBack receives the nonce on the dial-back stream
+func (ac *client) handleDialBack(s network.Stream) {
+	if err := s.Scope().SetService(ServiceName); err != nil {
+		log.Debugf("failed to attach stream to service %s: %w", ServiceName, err)
+		s.Reset()
+		return
+	}
+
+	if err := s.Scope().ReserveMemory(dialBackMaxMsgSize, network.ReservationPriorityAlways); err != nil {
+		log.Debugf("failed to reserve memory for stream %s: %w", DialBackProtocol, err)
+		s.Reset()
+		return
+	}
+	defer s.Scope().ReleaseMemory(dialBackMaxMsgSize)
+
+	s.SetDeadline(time.Now().Add(dialBackStreamTimeout))
+	defer s.Close()
+
+	r := pbio.NewDelimitedReader(s, dialBackMaxMsgSize)
+	var msg pb.DialBack
+	if err := r.ReadMsg(&msg); err != nil {
+		log.Debugf("failed to read dialback msg from %s: %s", s.Conn().RemotePeer(), err)
+		s.Reset()
+		return
+	}
+	nonce := msg.GetNonce()
+
+	ac.mu.Lock()
+	ch := ac.dialBackQueues[nonce]
+	ac.mu.Unlock()
+	if ch == nil {
+		log.Debugf("dialback received with invalid nonce: localAdds: %s peer: %s nonce: %d", s.Conn().LocalMultiaddr(), s.Conn().RemotePeer(), nonce)
+		s.Reset()
+		return
+	}
+	select {
+	case ch <- s.Conn().LocalMultiaddr():
+	default:
+		log.Debugf("multiple dialbacks received: localAddr: %s peer: %s", s.Conn().LocalMultiaddr(), s.Conn().RemotePeer())
+		s.Reset()
+		return
+	}
+	w := pbio.NewDelimitedWriter(s)
+	res := pb.DialBackResponse{}
+	if err := w.WriteMsg(&res); err != nil {
+		log.Debugf("failed to write dialback response: %s", err)
+		s.Reset()
+	}
+}
+
+func (ac *client) areAddrsConsistent(connLocalAddr, dialedAddr ma.Multiaddr) bool {
+	if connLocalAddr == nil || dialedAddr == nil {
+		return false
+	}
+	connLocalAddr = ac.normalizeMultiaddr(connLocalAddr)
+	dialedAddr = ac.normalizeMultiaddr(dialedAddr)
+
+	localProtos := connLocalAddr.Protocols()
+	externalProtos := dialedAddr.Protocols()
+	if len(localProtos) != len(externalProtos) {
+		return false
+	}
+	for i := 0; i < len(localProtos); i++ {
+		if i == 0 {
+			switch externalProtos[i].Code {
+			case ma.P_DNS, ma.P_DNSADDR:
+				if localProtos[i].Code == ma.P_IP4 || localProtos[i].Code == ma.P_IP6 {
+					continue
+				}
+				return false
+			case ma.P_DNS4:
+				if localProtos[i].Code == ma.P_IP4 {
+					continue
+				}
+				return false
+			case ma.P_DNS6:
+				if localProtos[i].Code == ma.P_IP6 {
+					continue
+				}
+				return false
+			}
+			if localProtos[i].Code != externalProtos[i].Code {
+				return false
+			}
+		} else {
+			if localProtos[i].Code != externalProtos[i].Code {
+				return false
+			}
+		}
+	}
+	return true
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/metrics.go

@@ -0,0 +1,97 @@
+package autonatv2
+
+import (
+	"github.com/libp2p/go-libp2p/p2p/metricshelper"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type MetricsTracer interface {
+	CompletedRequest(EventDialRequestCompleted)
+}
+
+const metricNamespace = "libp2p_autonatv2"
+
+var (
+	requestsCompleted = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Namespace: metricNamespace,
+			Name:      "requests_completed_total",
+			Help:      "Requests Completed",
+		},
+		[]string{"server_error", "response_status", "dial_status", "dial_data_required", "ip_or_dns_version", "transport"},
+	)
+)
+
+type metricsTracer struct {
+}
+
+func NewMetricsTracer(reg prometheus.Registerer) MetricsTracer {
+	metricshelper.RegisterCollectors(reg, requestsCompleted)
+	return &metricsTracer{}
+}
+
+func (m *metricsTracer) CompletedRequest(e EventDialRequestCompleted) {
+	labels := metricshelper.GetStringSlice()
+	defer metricshelper.PutStringSlice(labels)
+
+	errStr := getErrString(e.Error)
+
+	dialData := "false"
+	if e.DialDataRequired {
+		dialData = "true"
+	}
+
+	var ip, transport string
+	if e.DialedAddr != nil {
+		ip = getIPOrDNSVersion(e.DialedAddr)
+		transport = metricshelper.GetTransport(e.DialedAddr)
+	}
+
+	*labels = append(*labels,
+		errStr,
+		pb.DialResponse_ResponseStatus_name[int32(e.ResponseStatus)],
+		pb.DialStatus_name[int32(e.DialStatus)],
+		dialData,
+		ip,
+		transport,
+	)
+	requestsCompleted.WithLabelValues(*labels...).Inc()
+}
+
+func getIPOrDNSVersion(a ma.Multiaddr) string {
+	if a == nil {
+		return ""
+	}
+	res := "unknown"
+	ma.ForEach(a, func(c ma.Component) bool {
+		switch c.Protocol().Code {
+		case ma.P_IP4:
+			res = "ip4"
+		case ma.P_IP6:
+			res = "ip6"
+		case ma.P_DNS, ma.P_DNSADDR:
+			res = "dns"
+		case ma.P_DNS4:
+			res = "dns4"
+		case ma.P_DNS6:
+			res = "dns6"
+		}
+		return false
+	})
+	return res
+}
+
+func getErrString(e error) string {
+	var errStr string
+	switch e {
+	case nil:
+		errStr = "nil"
+	case errBadRequest, errDialDataRefused, errResourceLimitExceeded:
+		errStr = e.Error()
+	default:
+		errStr = "other"
+	}
+	return errStr
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/msg_reader.go

@@ -0,0 +1,38 @@
+package autonatv2
+
+import (
+	"io"
+
+	"github.com/multiformats/go-varint"
+)
+
+// msgReader reads a varint prefixed message from R without any buffering
+type msgReader struct {
+	R   io.Reader
+	Buf []byte
+}
+
+func (m *msgReader) ReadByte() (byte, error) {
+	buf := m.Buf[:1]
+	_, err := m.R.Read(buf)
+	return buf[0], err
+}
+
+func (m *msgReader) ReadMsg() ([]byte, error) {
+	sz, err := varint.ReadUvarint(m)
+	if err != nil {
+		return nil, err
+	}
+	if sz > uint64(len(m.Buf)) {
+		return nil, io.ErrShortBuffer
+	}
+	n := 0
+	for n < int(sz) {
+		nr, err := m.R.Read(m.Buf[n:sz])
+		if err != nil {
+			return nil, err
+		}
+		n += nr
+	}
+	return m.Buf[:sz], nil
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/options.go

@@ -0,0 +1,64 @@
+package autonatv2
+
+import "time"
+
+// autoNATSettings is used to configure AutoNAT
+type autoNATSettings struct {
+	allowPrivateAddrs                    bool
+	serverRPM                            int
+	serverPerPeerRPM                     int
+	serverDialDataRPM                    int
+	dataRequestPolicy                    dataRequestPolicyFunc
+	now                                  func() time.Time
+	amplificatonAttackPreventionDialWait time.Duration
+	metricsTracer                        MetricsTracer
+}
+
+func defaultSettings() *autoNATSettings {
+	return &autoNATSettings{
+		allowPrivateAddrs:                    false,
+		serverRPM:                            60, // 1 every second
+		serverPerPeerRPM:                     12, // 1 every 5 seconds
+		serverDialDataRPM:                    12, // 1 every 5 seconds
+		dataRequestPolicy:                    amplificationAttackPrevention,
+		amplificatonAttackPreventionDialWait: 3 * time.Second,
+		now:                                  time.Now,
+	}
+}
+
+type AutoNATOption func(s *autoNATSettings) error
+
+func WithServerRateLimit(rpm, perPeerRPM, dialDataRPM int) AutoNATOption {
+	return func(s *autoNATSettings) error {
+		s.serverRPM = rpm
+		s.serverPerPeerRPM = perPeerRPM
+		s.serverDialDataRPM = dialDataRPM
+		return nil
+	}
+}
+
+func WithMetricsTracer(m MetricsTracer) AutoNATOption {
+	return func(s *autoNATSettings) error {
+		s.metricsTracer = m
+		return nil
+	}
+}
+
+func withDataRequestPolicy(drp dataRequestPolicyFunc) AutoNATOption {
+	return func(s *autoNATSettings) error {
+		s.dataRequestPolicy = drp
+		return nil
+	}
+}
+
+func allowPrivateAddrs(s *autoNATSettings) error {
+	s.allowPrivateAddrs = true
+	return nil
+}
+
+func withAmplificationAttackPreventionDialWait(d time.Duration) AutoNATOption {
+	return func(s *autoNATSettings) error {
+		s.amplificatonAttackPreventionDialWait = d
+		return nil
+	}
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb/autonatv2.pb.go

@@ -0,0 +1,818 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.34.2
+// 	protoc        v5.27.2
+// source: pb/autonatv2.proto
+
+package pb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type DialStatus int32
+
+const (
+	DialStatus_UNUSED            DialStatus = 0
+	DialStatus_E_DIAL_ERROR      DialStatus = 100
+	DialStatus_E_DIAL_BACK_ERROR DialStatus = 101
+	DialStatus_OK                DialStatus = 200
+)
+
+// Enum value maps for DialStatus.
+var (
+	DialStatus_name = map[int32]string{
+		0:   "UNUSED",
+		100: "E_DIAL_ERROR",
+		101: "E_DIAL_BACK_ERROR",
+		200: "OK",
+	}
+	DialStatus_value = map[string]int32{
+		"UNUSED":            0,
+		"E_DIAL_ERROR":      100,
+		"E_DIAL_BACK_ERROR": 101,
+		"OK":                200,
+	}
+)
+
+func (x DialStatus) Enum() *DialStatus {
+	p := new(DialStatus)
+	*p = x
+	return p
+}
+
+func (x DialStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DialStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_pb_autonatv2_proto_enumTypes[0].Descriptor()
+}
+
+func (DialStatus) Type() protoreflect.EnumType {
+	return &file_pb_autonatv2_proto_enumTypes[0]
+}
+
+func (x DialStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DialStatus.Descriptor instead.
+func (DialStatus) EnumDescriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{0}
+}
+
+type DialResponse_ResponseStatus int32
+
+const (
+	DialResponse_E_INTERNAL_ERROR   DialResponse_ResponseStatus = 0
+	DialResponse_E_REQUEST_REJECTED DialResponse_ResponseStatus = 100
+	DialResponse_E_DIAL_REFUSED     DialResponse_ResponseStatus = 101
+	DialResponse_OK                 DialResponse_ResponseStatus = 200
+)
+
+// Enum value maps for DialResponse_ResponseStatus.
+var (
+	DialResponse_ResponseStatus_name = map[int32]string{
+		0:   "E_INTERNAL_ERROR",
+		100: "E_REQUEST_REJECTED",
+		101: "E_DIAL_REFUSED",
+		200: "OK",
+	}
+	DialResponse_ResponseStatus_value = map[string]int32{
+		"E_INTERNAL_ERROR":   0,
+		"E_REQUEST_REJECTED": 100,
+		"E_DIAL_REFUSED":     101,
+		"OK":                 200,
+	}
+)
+
+func (x DialResponse_ResponseStatus) Enum() *DialResponse_ResponseStatus {
+	p := new(DialResponse_ResponseStatus)
+	*p = x
+	return p
+}
+
+func (x DialResponse_ResponseStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DialResponse_ResponseStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_pb_autonatv2_proto_enumTypes[1].Descriptor()
+}
+
+func (DialResponse_ResponseStatus) Type() protoreflect.EnumType {
+	return &file_pb_autonatv2_proto_enumTypes[1]
+}
+
+func (x DialResponse_ResponseStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DialResponse_ResponseStatus.Descriptor instead.
+func (DialResponse_ResponseStatus) EnumDescriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{3, 0}
+}
+
+type DialBackResponse_DialBackStatus int32
+
+const (
+	DialBackResponse_OK DialBackResponse_DialBackStatus = 0
+)
+
+// Enum value maps for DialBackResponse_DialBackStatus.
+var (
+	DialBackResponse_DialBackStatus_name = map[int32]string{
+		0: "OK",
+	}
+	DialBackResponse_DialBackStatus_value = map[string]int32{
+		"OK": 0,
+	}
+)
+
+func (x DialBackResponse_DialBackStatus) Enum() *DialBackResponse_DialBackStatus {
+	p := new(DialBackResponse_DialBackStatus)
+	*p = x
+	return p
+}
+
+func (x DialBackResponse_DialBackStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (DialBackResponse_DialBackStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_pb_autonatv2_proto_enumTypes[2].Descriptor()
+}
+
+func (DialBackResponse_DialBackStatus) Type() protoreflect.EnumType {
+	return &file_pb_autonatv2_proto_enumTypes[2]
+}
+
+func (x DialBackResponse_DialBackStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use DialBackResponse_DialBackStatus.Descriptor instead.
+func (DialBackResponse_DialBackStatus) EnumDescriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{6, 0}
+}
+
+type Message struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to Msg:
+	//
+	//	*Message_DialRequest
+	//	*Message_DialResponse
+	//	*Message_DialDataRequest
+	//	*Message_DialDataResponse
+	Msg isMessage_Msg `protobuf_oneof:"msg"`
+}
+
+func (x *Message) Reset() {
+	*x = Message{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Message) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Message) ProtoMessage() {}
+
+func (x *Message) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Message.ProtoReflect.Descriptor instead.
+func (*Message) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{0}
+}
+
+func (m *Message) GetMsg() isMessage_Msg {
+	if m != nil {
+		return m.Msg
+	}
+	return nil
+}
+
+func (x *Message) GetDialRequest() *DialRequest {
+	if x, ok := x.GetMsg().(*Message_DialRequest); ok {
+		return x.DialRequest
+	}
+	return nil
+}
+
+func (x *Message) GetDialResponse() *DialResponse {
+	if x, ok := x.GetMsg().(*Message_DialResponse); ok {
+		return x.DialResponse
+	}
+	return nil
+}
+
+func (x *Message) GetDialDataRequest() *DialDataRequest {
+	if x, ok := x.GetMsg().(*Message_DialDataRequest); ok {
+		return x.DialDataRequest
+	}
+	return nil
+}
+
+func (x *Message) GetDialDataResponse() *DialDataResponse {
+	if x, ok := x.GetMsg().(*Message_DialDataResponse); ok {
+		return x.DialDataResponse
+	}
+	return nil
+}
+
+type isMessage_Msg interface {
+	isMessage_Msg()
+}
+
+type Message_DialRequest struct {
+	DialRequest *DialRequest `protobuf:"bytes,1,opt,name=dialRequest,proto3,oneof"`
+}
+
+type Message_DialResponse struct {
+	DialResponse *DialResponse `protobuf:"bytes,2,opt,name=dialResponse,proto3,oneof"`
+}
+
+type Message_DialDataRequest struct {
+	DialDataRequest *DialDataRequest `protobuf:"bytes,3,opt,name=dialDataRequest,proto3,oneof"`
+}
+
+type Message_DialDataResponse struct {
+	DialDataResponse *DialDataResponse `protobuf:"bytes,4,opt,name=dialDataResponse,proto3,oneof"`
+}
+
+func (*Message_DialRequest) isMessage_Msg() {}
+
+func (*Message_DialResponse) isMessage_Msg() {}
+
+func (*Message_DialDataRequest) isMessage_Msg() {}
+
+func (*Message_DialDataResponse) isMessage_Msg() {}
+
+type DialRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Addrs [][]byte `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
+	Nonce uint64   `protobuf:"fixed64,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
+}
+
+func (x *DialRequest) Reset() {
+	*x = DialRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialRequest) ProtoMessage() {}
+
+func (x *DialRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialRequest.ProtoReflect.Descriptor instead.
+func (*DialRequest) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *DialRequest) GetAddrs() [][]byte {
+	if x != nil {
+		return x.Addrs
+	}
+	return nil
+}
+
+func (x *DialRequest) GetNonce() uint64 {
+	if x != nil {
+		return x.Nonce
+	}
+	return 0
+}
+
+type DialDataRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	AddrIdx  uint32 `protobuf:"varint,1,opt,name=addrIdx,proto3" json:"addrIdx,omitempty"`
+	NumBytes uint64 `protobuf:"varint,2,opt,name=numBytes,proto3" json:"numBytes,omitempty"`
+}
+
+func (x *DialDataRequest) Reset() {
+	*x = DialDataRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialDataRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialDataRequest) ProtoMessage() {}
+
+func (x *DialDataRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialDataRequest.ProtoReflect.Descriptor instead.
+func (*DialDataRequest) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *DialDataRequest) GetAddrIdx() uint32 {
+	if x != nil {
+		return x.AddrIdx
+	}
+	return 0
+}
+
+func (x *DialDataRequest) GetNumBytes() uint64 {
+	if x != nil {
+		return x.NumBytes
+	}
+	return 0
+}
+
+type DialResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Status     DialResponse_ResponseStatus `protobuf:"varint,1,opt,name=status,proto3,enum=autonatv2.pb.DialResponse_ResponseStatus" json:"status,omitempty"`
+	AddrIdx    uint32                      `protobuf:"varint,2,opt,name=addrIdx,proto3" json:"addrIdx,omitempty"`
+	DialStatus DialStatus                  `protobuf:"varint,3,opt,name=dialStatus,proto3,enum=autonatv2.pb.DialStatus" json:"dialStatus,omitempty"`
+}
+
+func (x *DialResponse) Reset() {
+	*x = DialResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialResponse) ProtoMessage() {}
+
+func (x *DialResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialResponse.ProtoReflect.Descriptor instead.
+func (*DialResponse) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *DialResponse) GetStatus() DialResponse_ResponseStatus {
+	if x != nil {
+		return x.Status
+	}
+	return DialResponse_E_INTERNAL_ERROR
+}
+
+func (x *DialResponse) GetAddrIdx() uint32 {
+	if x != nil {
+		return x.AddrIdx
+	}
+	return 0
+}
+
+func (x *DialResponse) GetDialStatus() DialStatus {
+	if x != nil {
+		return x.DialStatus
+	}
+	return DialStatus_UNUSED
+}
+
+type DialDataResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *DialDataResponse) Reset() {
+	*x = DialDataResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialDataResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialDataResponse) ProtoMessage() {}
+
+func (x *DialDataResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialDataResponse.ProtoReflect.Descriptor instead.
+func (*DialDataResponse) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *DialDataResponse) GetData() []byte {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
+type DialBack struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Nonce uint64 `protobuf:"fixed64,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
+}
+
+func (x *DialBack) Reset() {
+	*x = DialBack{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialBack) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialBack) ProtoMessage() {}
+
+func (x *DialBack) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialBack.ProtoReflect.Descriptor instead.
+func (*DialBack) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *DialBack) GetNonce() uint64 {
+	if x != nil {
+		return x.Nonce
+	}
+	return 0
+}
+
+type DialBackResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Status DialBackResponse_DialBackStatus `protobuf:"varint,1,opt,name=status,proto3,enum=autonatv2.pb.DialBackResponse_DialBackStatus" json:"status,omitempty"`
+}
+
+func (x *DialBackResponse) Reset() {
+	*x = DialBackResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_pb_autonatv2_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DialBackResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DialBackResponse) ProtoMessage() {}
+
+func (x *DialBackResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_pb_autonatv2_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DialBackResponse.ProtoReflect.Descriptor instead.
+func (*DialBackResponse) Descriptor() ([]byte, []int) {
+	return file_pb_autonatv2_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *DialBackResponse) GetStatus() DialBackResponse_DialBackStatus {
+	if x != nil {
+		return x.Status
+	}
+	return DialBackResponse_OK
+}
+
+var File_pb_autonatv2_proto protoreflect.FileDescriptor
+
+var file_pb_autonatv2_proto_rawDesc = []byte{
+	0x0a, 0x12, 0x70, 0x62, 0x2f, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32, 0x2e,
+	0x70, 0x62, 0x22, 0xaa, 0x02, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3d,
+	0x0a, 0x0b, 0x64, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32, 0x2e,
+	0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00,
+	0x52, 0x0b, 0x64, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x40, 0x0a,
+	0x0c, 0x64, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32, 0x2e,
+	0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48,
+	0x00, 0x52, 0x0c, 0x64, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x49, 0x0a, 0x0f, 0x64, 0x69, 0x61, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e,
+	0x61, 0x74, 0x76, 0x32, 0x2e, 0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x44, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0f, 0x64, 0x69, 0x61, 0x6c, 0x44,
+	0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4c, 0x0a, 0x10, 0x64, 0x69,
+	0x61, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32,
+	0x2e, 0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x10, 0x64, 0x69, 0x61, 0x6c, 0x44, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x05, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x22,
+	0x39, 0x0a, 0x0b, 0x44, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14,
+	0x0a, 0x05, 0x61, 0x64, 0x64, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x05, 0x61,
+	0x64, 0x64, 0x72, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x06, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x22, 0x47, 0x0a, 0x0f, 0x44, 0x69,
+	0x61, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a,
+	0x07, 0x61, 0x64, 0x64, 0x72, 0x49, 0x64, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07,
+	0x61, 0x64, 0x64, 0x72, 0x49, 0x64, 0x78, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x42, 0x79,
+	0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6e, 0x75, 0x6d, 0x42, 0x79,
+	0x74, 0x65, 0x73, 0x22, 0x82, 0x02, 0x0a, 0x0c, 0x44, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76, 0x32,
+	0x2e, 0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
+	0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x49,
+	0x64, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x49, 0x64,
+	0x78, 0x12, 0x38, 0x0a, 0x0a, 0x64, 0x69, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74, 0x76,
+	0x32, 0x2e, 0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52,
+	0x0a, 0x64, 0x69, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5b, 0x0a, 0x0e, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x14, 0x0a,
+	0x10, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f,
+	0x52, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54,
+	0x5f, 0x52, 0x45, 0x4a, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x64, 0x12, 0x12, 0x0a, 0x0e, 0x45,
+	0x5f, 0x44, 0x49, 0x41, 0x4c, 0x5f, 0x52, 0x45, 0x46, 0x55, 0x53, 0x45, 0x44, 0x10, 0x65, 0x12,
+	0x07, 0x0a, 0x02, 0x4f, 0x4b, 0x10, 0xc8, 0x01, 0x22, 0x26, 0x0a, 0x10, 0x44, 0x69, 0x61, 0x6c,
+	0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04,
+	0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61,
+	0x22, 0x20, 0x0a, 0x08, 0x44, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x12, 0x14, 0x0a, 0x05,
+	0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x06, 0x52, 0x05, 0x6e, 0x6f, 0x6e,
+	0x63, 0x65, 0x22, 0x73, 0x0a, 0x10, 0x44, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2d, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x6e, 0x61, 0x74,
+	0x76, 0x32, 0x2e, 0x70, 0x62, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x53,
+	0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x18, 0x0a,
+	0x0e, 0x44, 0x69, 0x61, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12,
+	0x06, 0x0a, 0x02, 0x4f, 0x4b, 0x10, 0x00, 0x2a, 0x4a, 0x0a, 0x0a, 0x44, 0x69, 0x61, 0x6c, 0x53,
+	0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0a, 0x0a, 0x06, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x10,
+	0x00, 0x12, 0x10, 0x0a, 0x0c, 0x45, 0x5f, 0x44, 0x49, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f,
+	0x52, 0x10, 0x64, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x5f, 0x44, 0x49, 0x41, 0x4c, 0x5f, 0x42, 0x41,
+	0x43, 0x4b, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x65, 0x12, 0x07, 0x0a, 0x02, 0x4f, 0x4b,
+	0x10, 0xc8, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_pb_autonatv2_proto_rawDescOnce sync.Once
+	file_pb_autonatv2_proto_rawDescData = file_pb_autonatv2_proto_rawDesc
+)
+
+func file_pb_autonatv2_proto_rawDescGZIP() []byte {
+	file_pb_autonatv2_proto_rawDescOnce.Do(func() {
+		file_pb_autonatv2_proto_rawDescData = protoimpl.X.CompressGZIP(file_pb_autonatv2_proto_rawDescData)
+	})
+	return file_pb_autonatv2_proto_rawDescData
+}
+
+var file_pb_autonatv2_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_pb_autonatv2_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
+var file_pb_autonatv2_proto_goTypes = []any{
+	(DialStatus)(0),                      // 0: autonatv2.pb.DialStatus
+	(DialResponse_ResponseStatus)(0),     // 1: autonatv2.pb.DialResponse.ResponseStatus
+	(DialBackResponse_DialBackStatus)(0), // 2: autonatv2.pb.DialBackResponse.DialBackStatus
+	(*Message)(nil),                      // 3: autonatv2.pb.Message
+	(*DialRequest)(nil),                  // 4: autonatv2.pb.DialRequest
+	(*DialDataRequest)(nil),              // 5: autonatv2.pb.DialDataRequest
+	(*DialResponse)(nil),                 // 6: autonatv2.pb.DialResponse
+	(*DialDataResponse)(nil),             // 7: autonatv2.pb.DialDataResponse
+	(*DialBack)(nil),                     // 8: autonatv2.pb.DialBack
+	(*DialBackResponse)(nil),             // 9: autonatv2.pb.DialBackResponse
+}
+var file_pb_autonatv2_proto_depIdxs = []int32{
+	4, // 0: autonatv2.pb.Message.dialRequest:type_name -> autonatv2.pb.DialRequest
+	6, // 1: autonatv2.pb.Message.dialResponse:type_name -> autonatv2.pb.DialResponse
+	5, // 2: autonatv2.pb.Message.dialDataRequest:type_name -> autonatv2.pb.DialDataRequest
+	7, // 3: autonatv2.pb.Message.dialDataResponse:type_name -> autonatv2.pb.DialDataResponse
+	1, // 4: autonatv2.pb.DialResponse.status:type_name -> autonatv2.pb.DialResponse.ResponseStatus
+	0, // 5: autonatv2.pb.DialResponse.dialStatus:type_name -> autonatv2.pb.DialStatus
+	2, // 6: autonatv2.pb.DialBackResponse.status:type_name -> autonatv2.pb.DialBackResponse.DialBackStatus
+	7, // [7:7] is the sub-list for method output_type
+	7, // [7:7] is the sub-list for method input_type
+	7, // [7:7] is the sub-list for extension type_name
+	7, // [7:7] is the sub-list for extension extendee
+	0, // [0:7] is the sub-list for field type_name
+}
+
+func init() { file_pb_autonatv2_proto_init() }
+func file_pb_autonatv2_proto_init() {
+	if File_pb_autonatv2_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_pb_autonatv2_proto_msgTypes[0].Exporter = func(v any, i int) any {
+			switch v := v.(*Message); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[1].Exporter = func(v any, i int) any {
+			switch v := v.(*DialRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[2].Exporter = func(v any, i int) any {
+			switch v := v.(*DialDataRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[3].Exporter = func(v any, i int) any {
+			switch v := v.(*DialResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[4].Exporter = func(v any, i int) any {
+			switch v := v.(*DialDataResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[5].Exporter = func(v any, i int) any {
+			switch v := v.(*DialBack); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_pb_autonatv2_proto_msgTypes[6].Exporter = func(v any, i int) any {
+			switch v := v.(*DialBackResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	file_pb_autonatv2_proto_msgTypes[0].OneofWrappers = []any{
+		(*Message_DialRequest)(nil),
+		(*Message_DialResponse)(nil),
+		(*Message_DialDataRequest)(nil),
+		(*Message_DialDataResponse)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_pb_autonatv2_proto_rawDesc,
+			NumEnums:      3,
+			NumMessages:   7,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_pb_autonatv2_proto_goTypes,
+		DependencyIndexes: file_pb_autonatv2_proto_depIdxs,
+		EnumInfos:         file_pb_autonatv2_proto_enumTypes,
+		MessageInfos:      file_pb_autonatv2_proto_msgTypes,
+	}.Build()
+	File_pb_autonatv2_proto = out.File
+	file_pb_autonatv2_proto_rawDesc = nil
+	file_pb_autonatv2_proto_goTypes = nil
+	file_pb_autonatv2_proto_depIdxs = nil
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb/autonatv2.proto

@@ -0,0 +1,64 @@
+syntax = "proto3";
+
+package autonatv2.pb;
+
+message Message {
+    oneof msg {
+        DialRequest dialRequest   = 1;
+        DialResponse dialResponse = 2;
+        DialDataRequest dialDataRequest = 3;
+        DialDataResponse dialDataResponse = 4;
+    }
+}
+
+message DialRequest {
+    repeated bytes addrs = 1;
+    fixed64 nonce = 2;
+}
+
+
+message DialDataRequest {
+    uint32 addrIdx = 1;
+    uint64 numBytes = 2;
+}
+
+
+enum DialStatus {
+    UNUSED            = 0;
+    E_DIAL_ERROR      = 100;
+    E_DIAL_BACK_ERROR = 101;
+    OK                = 200;
+}
+
+
+message DialResponse {
+    enum ResponseStatus {
+        E_INTERNAL_ERROR   = 0;
+        E_REQUEST_REJECTED = 100; 
+        E_DIAL_REFUSED     = 101;
+        OK  = 200; 
+    }
+
+    ResponseStatus status = 1;
+    uint32 addrIdx        = 2; 
+    DialStatus dialStatus = 3;
+}
+
+
+message DialDataResponse {
+    bytes data = 1;
+}
+
+
+message DialBack {
+    fixed64 nonce = 1;
+}
+
+
+message DialBackResponse {
+    enum DialBackStatus {
+        OK = 0;
+    }
+
+    DialBackStatus status = 1;
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/server.go

@@ -0,0 +1,509 @@
+package autonatv2
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"sync"
+	"time"
+
+	pool "github.com/libp2p/go-buffer-pool"
+	"github.com/libp2p/go-libp2p/core/host"
+	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/peerstore"
+	"github.com/libp2p/go-libp2p/p2p/protocol/autonatv2/pb"
+	"github.com/libp2p/go-msgio/pbio"
+
+	"math/rand"
+
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr/net"
+)
+
+var (
+	errResourceLimitExceeded = errors.New("resource limit exceeded")
+	errBadRequest            = errors.New("bad request")
+	errDialDataRefused       = errors.New("dial data refused")
+)
+
+type dataRequestPolicyFunc = func(s network.Stream, dialAddr ma.Multiaddr) bool
+
+type EventDialRequestCompleted struct {
+	Error            error
+	ResponseStatus   pb.DialResponse_ResponseStatus
+	DialStatus       pb.DialStatus
+	DialDataRequired bool
+	DialedAddr       ma.Multiaddr
+}
+
+// server implements the AutoNATv2 server.
+// It can ask client to provide dial data before attempting the requested dial.
+// It rate limits requests on a global level, per peer level and on whether the request requires dial data.
+type server struct {
+	host       host.Host
+	dialerHost host.Host
+	limiter    *rateLimiter
+
+	// dialDataRequestPolicy is used to determine whether dialing the address requires receiving
+	// dial data. It is set to amplification attack prevention by default.
+	dialDataRequestPolicy                dataRequestPolicyFunc
+	amplificatonAttackPreventionDialWait time.Duration
+	metricsTracer                        MetricsTracer
+
+	// for tests
+	now               func() time.Time
+	allowPrivateAddrs bool
+}
+
+func newServer(host, dialer host.Host, s *autoNATSettings) *server {
+	return &server{
+		dialerHost:                           dialer,
+		host:                                 host,
+		dialDataRequestPolicy:                s.dataRequestPolicy,
+		amplificatonAttackPreventionDialWait: s.amplificatonAttackPreventionDialWait,
+		allowPrivateAddrs:                    s.allowPrivateAddrs,
+		limiter: &rateLimiter{
+			RPM:         s.serverRPM,
+			PerPeerRPM:  s.serverPerPeerRPM,
+			DialDataRPM: s.serverDialDataRPM,
+			now:         s.now,
+		},
+		now:           s.now,
+		metricsTracer: s.metricsTracer,
+	}
+}
+
+// Enable attaches the stream handler to the host.
+func (as *server) Start() {
+	as.host.SetStreamHandler(DialProtocol, as.handleDialRequest)
+}
+
+func (as *server) Close() {
+	as.host.RemoveStreamHandler(DialProtocol)
+	as.dialerHost.Close()
+	as.limiter.Close()
+}
+
+// handleDialRequest is the dial-request protocol stream handler
+func (as *server) handleDialRequest(s network.Stream) {
+	evt := as.serveDialRequest(s)
+	log.Debugf("completed dial-request from %s, response status: %s, dial status: %s, err: %s",
+		s.Conn().RemotePeer(), evt.ResponseStatus, evt.DialStatus, evt.Error)
+	if as.metricsTracer != nil {
+		as.metricsTracer.CompletedRequest(evt)
+	}
+}
+
+func (as *server) serveDialRequest(s network.Stream) EventDialRequestCompleted {
+	if err := s.Scope().SetService(ServiceName); err != nil {
+		s.Reset()
+		log.Debugf("failed to attach stream to %s service: %w", ServiceName, err)
+		return EventDialRequestCompleted{
+			Error: errors.New("failed to attach stream to autonat-v2"),
+		}
+	}
+
+	if err := s.Scope().ReserveMemory(maxMsgSize, network.ReservationPriorityAlways); err != nil {
+		s.Reset()
+		log.Debugf("failed to reserve memory for stream %s: %w", DialProtocol, err)
+		return EventDialRequestCompleted{Error: errResourceLimitExceeded}
+	}
+	defer s.Scope().ReleaseMemory(maxMsgSize)
+
+	deadline := as.now().Add(streamTimeout)
+	ctx, cancel := context.WithDeadline(context.Background(), deadline)
+	defer cancel()
+	s.SetDeadline(as.now().Add(streamTimeout))
+	defer s.Close()
+
+	p := s.Conn().RemotePeer()
+
+	var msg pb.Message
+	w := pbio.NewDelimitedWriter(s)
+	// Check for rate limit before parsing the request
+	if !as.limiter.Accept(p) {
+		msg = pb.Message{
+			Msg: &pb.Message_DialResponse{
+				DialResponse: &pb.DialResponse{
+					Status: pb.DialResponse_E_REQUEST_REJECTED,
+				},
+			},
+		}
+		if err := w.WriteMsg(&msg); err != nil {
+			s.Reset()
+			log.Debugf("failed to write request rejected response to %s: %s", p, err)
+			return EventDialRequestCompleted{
+				ResponseStatus: pb.DialResponse_E_REQUEST_REJECTED,
+				Error:          fmt.Errorf("write failed: %w", err),
+			}
+		}
+		log.Debugf("rejected request from %s: rate limit exceeded", p)
+		return EventDialRequestCompleted{ResponseStatus: pb.DialResponse_E_REQUEST_REJECTED}
+	}
+	defer as.limiter.CompleteRequest(p)
+
+	r := pbio.NewDelimitedReader(s, maxMsgSize)
+	if err := r.ReadMsg(&msg); err != nil {
+		s.Reset()
+		log.Debugf("failed to read request from %s: %s", p, err)
+		return EventDialRequestCompleted{Error: fmt.Errorf("read failed: %w", err)}
+	}
+	if msg.GetDialRequest() == nil {
+		s.Reset()
+		log.Debugf("invalid message type from %s: %T expected: DialRequest", p, msg.Msg)
+		return EventDialRequestCompleted{Error: errBadRequest}
+	}
+
+	// parse peer's addresses
+	var dialAddr ma.Multiaddr
+	var addrIdx int
+	for i, ab := range msg.GetDialRequest().GetAddrs() {
+		if i >= maxPeerAddresses {
+			break
+		}
+		a, err := ma.NewMultiaddrBytes(ab)
+		if err != nil {
+			continue
+		}
+		if !as.allowPrivateAddrs && !manet.IsPublicAddr(a) {
+			continue
+		}
+		if !as.dialerHost.Network().CanDial(p, a) {
+			continue
+		}
+		dialAddr = a
+		addrIdx = i
+		break
+	}
+	// No dialable address
+	if dialAddr == nil {
+		msg = pb.Message{
+			Msg: &pb.Message_DialResponse{
+				DialResponse: &pb.DialResponse{
+					Status: pb.DialResponse_E_DIAL_REFUSED,
+				},
+			},
+		}
+		if err := w.WriteMsg(&msg); err != nil {
+			s.Reset()
+			log.Debugf("failed to write dial refused response to %s: %s", p, err)
+			return EventDialRequestCompleted{
+				ResponseStatus: pb.DialResponse_E_DIAL_REFUSED,
+				Error:          fmt.Errorf("write failed: %w", err),
+			}
+		}
+		return EventDialRequestCompleted{
+			ResponseStatus: pb.DialResponse_E_DIAL_REFUSED,
+		}
+	}
+
+	nonce := msg.GetDialRequest().Nonce
+
+	isDialDataRequired := as.dialDataRequestPolicy(s, dialAddr)
+	if isDialDataRequired && !as.limiter.AcceptDialDataRequest(p) {
+		msg = pb.Message{
+			Msg: &pb.Message_DialResponse{
+				DialResponse: &pb.DialResponse{
+					Status: pb.DialResponse_E_REQUEST_REJECTED,
+				},
+			},
+		}
+		if err := w.WriteMsg(&msg); err != nil {
+			s.Reset()
+			log.Debugf("failed to write request rejected response to %s: %s", p, err)
+			return EventDialRequestCompleted{
+				ResponseStatus:   pb.DialResponse_E_REQUEST_REJECTED,
+				Error:            fmt.Errorf("write failed: %w", err),
+				DialDataRequired: true,
+			}
+		}
+		log.Debugf("rejected request from %s: rate limit exceeded", p)
+		return EventDialRequestCompleted{
+			ResponseStatus:   pb.DialResponse_E_REQUEST_REJECTED,
+			DialDataRequired: true,
+		}
+	}
+
+	if isDialDataRequired {
+		if err := getDialData(w, s, &msg, addrIdx); err != nil {
+			s.Reset()
+			log.Debugf("%s refused dial data request: %s", p, err)
+			return EventDialRequestCompleted{
+				Error:            errDialDataRefused,
+				DialDataRequired: true,
+				DialedAddr:       dialAddr,
+			}
+		}
+		// wait for a bit to prevent thundering herd style attacks on a victim
+		waitTime := time.Duration(rand.Intn(int(as.amplificatonAttackPreventionDialWait) + 1)) // the range is [0, n)
+		t := time.NewTimer(waitTime)
+		defer t.Stop()
+		select {
+		case <-ctx.Done():
+			s.Reset()
+			log.Debugf("rejecting request without dialing: %s %p ", p, ctx.Err())
+			return EventDialRequestCompleted{Error: ctx.Err(), DialDataRequired: true, DialedAddr: dialAddr}
+		case <-t.C:
+		}
+	}
+
+	dialStatus := as.dialBack(ctx, s.Conn().RemotePeer(), dialAddr, nonce)
+	msg = pb.Message{
+		Msg: &pb.Message_DialResponse{
+			DialResponse: &pb.DialResponse{
+				Status:     pb.DialResponse_OK,
+				DialStatus: dialStatus,
+				AddrIdx:    uint32(addrIdx),
+			},
+		},
+	}
+	if err := w.WriteMsg(&msg); err != nil {
+		s.Reset()
+		log.Debugf("failed to write response to %s: %s", p, err)
+		return EventDialRequestCompleted{
+			ResponseStatus:   pb.DialResponse_OK,
+			DialStatus:       dialStatus,
+			Error:            fmt.Errorf("write failed: %w", err),
+			DialDataRequired: isDialDataRequired,
+			DialedAddr:       dialAddr,
+		}
+	}
+	return EventDialRequestCompleted{
+		ResponseStatus:   pb.DialResponse_OK,
+		DialStatus:       dialStatus,
+		Error:            nil,
+		DialDataRequired: isDialDataRequired,
+		DialedAddr:       dialAddr,
+	}
+}
+
+// getDialData gets data from the client for dialing the address
+func getDialData(w pbio.Writer, s network.Stream, msg *pb.Message, addrIdx int) error {
+	numBytes := minHandshakeSizeBytes + rand.Intn(maxHandshakeSizeBytes-minHandshakeSizeBytes)
+	*msg = pb.Message{
+		Msg: &pb.Message_DialDataRequest{
+			DialDataRequest: &pb.DialDataRequest{
+				AddrIdx:  uint32(addrIdx),
+				NumBytes: uint64(numBytes),
+			},
+		},
+	}
+	if err := w.WriteMsg(msg); err != nil {
+		return fmt.Errorf("dial data write: %w", err)
+	}
+	// pbio.Reader that we used so far on this stream is buffered. But at this point
+	// there is nothing unread on the stream. So it is safe to use the raw stream to
+	// read, reducing allocations.
+	return readDialData(numBytes, s)
+}
+
+func readDialData(numBytes int, r io.Reader) error {
+	mr := &msgReader{R: r, Buf: pool.Get(maxMsgSize)}
+	defer pool.Put(mr.Buf)
+	for remain := numBytes; remain > 0; {
+		msg, err := mr.ReadMsg()
+		if err != nil {
+			return fmt.Errorf("dial data read: %w", err)
+		}
+		// protobuf format is:
+		// (oneof dialDataResponse:<fieldTag><len varint>)(dial data:<fieldTag><len varint><bytes>)
+		bytesLen := len(msg)
+		bytesLen -= 2 // fieldTag + varint first byte
+		if bytesLen > 127 {
+			bytesLen -= 1 // varint second byte
+		}
+		bytesLen -= 2 // second fieldTag + varint first byte
+		if bytesLen > 127 {
+			bytesLen -= 1 // varint second byte
+		}
+		if bytesLen > 0 {
+			remain -= bytesLen
+		}
+		// Check if the peer is not sending too little data forcing us to just do a lot of compute
+		if bytesLen < 100 && remain > 0 {
+			return fmt.Errorf("dial data msg too small: %d", bytesLen)
+		}
+	}
+	return nil
+}
+
+func (as *server) dialBack(ctx context.Context, p peer.ID, addr ma.Multiaddr, nonce uint64) pb.DialStatus {
+	ctx, cancel := context.WithTimeout(ctx, dialBackDialTimeout)
+	ctx = network.WithForceDirectDial(ctx, "autonatv2")
+	as.dialerHost.Peerstore().AddAddr(p, addr, peerstore.TempAddrTTL)
+	defer func() {
+		cancel()
+		as.dialerHost.Network().ClosePeer(p)
+		as.dialerHost.Peerstore().ClearAddrs(p)
+		as.dialerHost.Peerstore().RemovePeer(p)
+	}()
+
+	err := as.dialerHost.Connect(ctx, peer.AddrInfo{ID: p})
+	if err != nil {
+		return pb.DialStatus_E_DIAL_ERROR
+	}
+
+	s, err := as.dialerHost.NewStream(ctx, p, DialBackProtocol)
+	if err != nil {
+		return pb.DialStatus_E_DIAL_BACK_ERROR
+	}
+
+	defer s.Close()
+	s.SetDeadline(as.now().Add(dialBackStreamTimeout))
+
+	w := pbio.NewDelimitedWriter(s)
+	if err := w.WriteMsg(&pb.DialBack{Nonce: nonce}); err != nil {
+		s.Reset()
+		return pb.DialStatus_E_DIAL_BACK_ERROR
+	}
+
+	// Since the underlying connection is on a separate dialer, it'll be closed after this
+	// function returns. Connection close will drop all the queued writes. To ensure message
+	// delivery, do a CloseWrite and read a byte from the stream. The peer actually sends a
+	// response of type DialBackResponse but we only care about the fact that the DialBack
+	// message has reached the peer. So we ignore that message on the read side.
+	s.CloseWrite()
+	s.SetDeadline(as.now().Add(5 * time.Second)) // 5 is a magic number
+	b := make([]byte, 1)                         // Read 1 byte here because 0 len reads are free to return (0, nil) immediately
+	s.Read(b)
+
+	return pb.DialStatus_OK
+}
+
+// rateLimiter implements a sliding window rate limit of requests per minute. It allows 1 concurrent request
+// per peer. It rate limits requests globally, at a peer level and depending on whether it requires dial data.
+type rateLimiter struct {
+	// PerPeerRPM is the rate limit per peer
+	PerPeerRPM int
+	// RPM is the global rate limit
+	RPM int
+	// DialDataRPM is the rate limit for requests that require dial data
+	DialDataRPM int
+
+	mu           sync.Mutex
+	closed       bool
+	reqs         []entry
+	peerReqs     map[peer.ID][]time.Time
+	dialDataReqs []time.Time
+	// ongoingReqs tracks in progress requests. This is used to disallow multiple concurrent requests by the
+	// same peer
+	// TODO: Should we allow a few concurrent requests per peer?
+	ongoingReqs map[peer.ID]struct{}
+
+	now func() time.Time // for tests
+}
+
+type entry struct {
+	PeerID peer.ID
+	Time   time.Time
+}
+
+func (r *rateLimiter) Accept(p peer.ID) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.closed {
+		return false
+	}
+	if r.peerReqs == nil {
+		r.peerReqs = make(map[peer.ID][]time.Time)
+		r.ongoingReqs = make(map[peer.ID]struct{})
+	}
+
+	nw := r.now()
+	r.cleanup(nw)
+
+	if _, ok := r.ongoingReqs[p]; ok {
+		return false
+	}
+	if len(r.reqs) >= r.RPM || len(r.peerReqs[p]) >= r.PerPeerRPM {
+		return false
+	}
+
+	r.ongoingReqs[p] = struct{}{}
+	r.reqs = append(r.reqs, entry{PeerID: p, Time: nw})
+	r.peerReqs[p] = append(r.peerReqs[p], nw)
+	return true
+}
+
+func (r *rateLimiter) AcceptDialDataRequest(p peer.ID) bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.closed {
+		return false
+	}
+	if r.peerReqs == nil {
+		r.peerReqs = make(map[peer.ID][]time.Time)
+		r.ongoingReqs = make(map[peer.ID]struct{})
+	}
+	nw := r.now()
+	r.cleanup(nw)
+	if len(r.dialDataReqs) >= r.DialDataRPM {
+		return false
+	}
+	r.dialDataReqs = append(r.dialDataReqs, nw)
+	return true
+}
+
+// cleanup removes stale requests.
+//
+// This is fast enough in rate limited cases and the state is small enough to
+// clean up quickly when blocking requests.
+func (r *rateLimiter) cleanup(now time.Time) {
+	idx := len(r.reqs)
+	for i, e := range r.reqs {
+		if now.Sub(e.Time) >= time.Minute {
+			pi := len(r.peerReqs[e.PeerID])
+			for j, t := range r.peerReqs[e.PeerID] {
+				if now.Sub(t) < time.Minute {
+					pi = j
+					break
+				}
+			}
+			r.peerReqs[e.PeerID] = r.peerReqs[e.PeerID][pi:]
+			if len(r.peerReqs[e.PeerID]) == 0 {
+				delete(r.peerReqs, e.PeerID)
+			}
+		} else {
+			idx = i
+			break
+		}
+	}
+	r.reqs = r.reqs[idx:]
+
+	idx = len(r.dialDataReqs)
+	for i, t := range r.dialDataReqs {
+		if now.Sub(t) < time.Minute {
+			idx = i
+			break
+		}
+	}
+	r.dialDataReqs = r.dialDataReqs[idx:]
+}
+
+func (r *rateLimiter) CompleteRequest(p peer.ID) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	delete(r.ongoingReqs, p)
+}
+
+func (r *rateLimiter) Close() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.closed = true
+	r.peerReqs = nil
+	r.ongoingReqs = nil
+	r.dialDataReqs = nil
+}
+
+// amplificationAttackPrevention is a dialDataRequestPolicy which requests data when the peer's observed
+// IP address is different from the dial back IP address
+func amplificationAttackPrevention(s network.Stream, dialAddr ma.Multiaddr) bool {
+	connIP, err := manet.ToIP(s.Conn().RemoteMultiaddr())
+	if err != nil {
+		return true
+	}
+	dialIP, _ := manet.ToIP(s.Conn().LocalMultiaddr()) // must be an IP multiaddr
+	return !connIP.Equal(dialIP)
+}

vendor/github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb/circuit.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/circuit.proto
 
 package pb
@@ -606,7 +606,7 @@ func file_pb_circuit_proto_rawDescGZIP() []byte {
 
 var file_pb_circuit_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
 var file_pb_circuit_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
-var file_pb_circuit_proto_goTypes = []interface{}{
+var file_pb_circuit_proto_goTypes = []any{
 	(Status)(0),           // 0: circuit.pb.Status
 	(HopMessage_Type)(0),  // 1: circuit.pb.HopMessage.Type
 	(StopMessage_Type)(0), // 2: circuit.pb.StopMessage.Type
@@ -639,7 +639,7 @@ func file_pb_circuit_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_circuit_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_circuit_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*HopMessage); i {
 			case 0:
 				return &v.state
@@ -651,7 +651,7 @@ func file_pb_circuit_proto_init() {
 				return nil
 			}
 		}
-		file_pb_circuit_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_circuit_proto_msgTypes[1].Exporter = func(v any, i int) any {
 			switch v := v.(*StopMessage); i {
 			case 0:
 				return &v.state
@@ -663,7 +663,7 @@ func file_pb_circuit_proto_init() {
 				return nil
 			}
 		}
-		file_pb_circuit_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_circuit_proto_msgTypes[2].Exporter = func(v any, i int) any {
 			switch v := v.(*Peer); i {
 			case 0:
 				return &v.state
@@ -675,7 +675,7 @@ func file_pb_circuit_proto_init() {
 				return nil
 			}
 		}
-		file_pb_circuit_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_circuit_proto_msgTypes[3].Exporter = func(v any, i int) any {
 			switch v := v.(*Reservation); i {
 			case 0:
 				return &v.state
@@ -687,7 +687,7 @@ func file_pb_circuit_proto_init() {
 				return nil
 			}
 		}
-		file_pb_circuit_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_circuit_proto_msgTypes[4].Exporter = func(v any, i int) any {
 			switch v := v.(*Limit); i {
 			case 0:
 				return &v.state
@@ -700,11 +700,11 @@ func file_pb_circuit_proto_init() {
 			}
 		}
 	}
-	file_pb_circuit_proto_msgTypes[0].OneofWrappers = []interface{}{}
+	file_pb_circuit_proto_msgTypes[0].OneofWrappers = []any{}
-	file_pb_circuit_proto_msgTypes[1].OneofWrappers = []interface{}{}
+	file_pb_circuit_proto_msgTypes[1].OneofWrappers = []any{}
-	file_pb_circuit_proto_msgTypes[2].OneofWrappers = []interface{}{}
+	file_pb_circuit_proto_msgTypes[2].OneofWrappers = []any{}
-	file_pb_circuit_proto_msgTypes[3].OneofWrappers = []interface{}{}
+	file_pb_circuit_proto_msgTypes[3].OneofWrappers = []any{}
-	file_pb_circuit_proto_msgTypes[4].OneofWrappers = []interface{}{}
+	file_pb_circuit_proto_msgTypes[4].OneofWrappers = []any{}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{

vendor/github.com/libp2p/go-libp2p/p2p/protocol/circuitv2/pb/voucher.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/voucher.proto
 
 package pb
@@ -115,7 +115,7 @@ func file_pb_voucher_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_voucher_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pb_voucher_proto_goTypes = []interface{}{
+var file_pb_voucher_proto_goTypes = []any{
 	(*ReservationVoucher)(nil), // 0: circuit.pb.ReservationVoucher
 }
 var file_pb_voucher_proto_depIdxs = []int32{
@@ -132,7 +132,7 @@ func file_pb_voucher_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_voucher_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_voucher_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*ReservationVoucher); i {
 			case 0:
 				return &v.state
@@ -145,7 +145,7 @@ func file_pb_voucher_proto_init() {
 			}
 		}
 	}
-	file_pb_voucher_proto_msgTypes[0].OneofWrappers = []interface{}{}
+	file_pb_voucher_proto_msgTypes[0].OneofWrappers = []any{}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{

vendor/github.com/libp2p/go-libp2p/p2p/protocol/holepunch/pb/holepunch.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/holepunch.proto
 
 package pb
@@ -161,7 +161,7 @@ func file_pb_holepunch_proto_rawDescGZIP() []byte {
 
 var file_pb_holepunch_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
 var file_pb_holepunch_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pb_holepunch_proto_goTypes = []interface{}{
+var file_pb_holepunch_proto_goTypes = []any{
 	(HolePunch_Type)(0), // 0: holepunch.pb.HolePunch.Type
 	(*HolePunch)(nil),   // 1: holepunch.pb.HolePunch
 }
@@ -180,7 +180,7 @@ func file_pb_holepunch_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_holepunch_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_holepunch_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*HolePunch); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/obsaddr.go

@@ -213,6 +213,48 @@ func (o *ObservedAddrManager) AddrsFor(addr ma.Multiaddr) (addrs []ma.Multiaddr)
 	return res
 }
 
+// appendInferredAddrs infers the external address of other transports that
+// share the local thin waist with a transport that we have do observations for.
+//
+// e.g. If we have observations for a QUIC address on port 9000, and we are
+// listening on the same interface and port 9000 for WebTransport, we can infer
+// the external WebTransport address.
+func (o *ObservedAddrManager) appendInferredAddrs(twToObserverSets map[string][]*observerSet, addrs []ma.Multiaddr) []ma.Multiaddr {
+	if twToObserverSets == nil {
+		twToObserverSets = make(map[string][]*observerSet)
+		for localTWStr := range o.externalAddrs {
+			twToObserverSets[localTWStr] = append(twToObserverSets[localTWStr], o.getTopExternalAddrs(localTWStr)...)
+		}
+	}
+	lAddrs, err := o.interfaceListenAddrs()
+	if err != nil {
+		log.Warnw("failed to get interface resolved listen addrs. Using just the listen addrs", "error", err)
+		lAddrs = nil
+	}
+	lAddrs = append(lAddrs, o.listenAddrs()...)
+	seenTWs := make(map[string]struct{})
+	for _, a := range lAddrs {
+		if _, ok := o.localAddrs[string(a.Bytes())]; ok {
+			// We already have this address in the list
+			continue
+		}
+		if _, ok := seenTWs[string(a.Bytes())]; ok {
+			// We've already added this
+			continue
+		}
+		seenTWs[string(a.Bytes())] = struct{}{}
+		a = o.normalize(a)
+		t, err := thinWaistForm(a)
+		if err != nil {
+			continue
+		}
+		for _, s := range twToObserverSets[string(t.TW.Bytes())] {
+			addrs = append(addrs, s.cacheMultiaddr(t.Rest))
+		}
+	}
+	return addrs
+}
+
 // Addrs return all activated observed addresses
 func (o *ObservedAddrManager) Addrs() []ma.Multiaddr {
 	o.mu.RLock()
@@ -228,6 +270,8 @@ func (o *ObservedAddrManager) Addrs() []ma.Multiaddr {
 			addrs = append(addrs, s.cacheMultiaddr(t.Rest))
 		}
 	}
+
+	addrs = o.appendInferredAddrs(m, addrs)
 	return addrs
 }
 

vendor/github.com/libp2p/go-libp2p/p2p/protocol/identify/pb/identify.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/identify.proto
 
 package pb
@@ -168,7 +168,7 @@ func file_pb_identify_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_identify_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pb_identify_proto_goTypes = []interface{}{
+var file_pb_identify_proto_goTypes = []any{
 	(*Identify)(nil), // 0: identify.pb.Identify
 }
 var file_pb_identify_proto_depIdxs = []int32{
@@ -185,7 +185,7 @@ func file_pb_identify_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_identify_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_identify_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*Identify); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/p2p/protocol/ping/ping.go

@@ -20,8 +20,9 @@ import (
 var log = logging.Logger("ping")
 
 const (
-	PingSize    = 32
+	PingSize     = 32
-	pingTimeout = time.Second * 60
+	pingTimeout  = 10 * time.Second
+	pingDuration = 30 * time.Second
 
 	ID = "/ipfs/ping/1.0.0"
 
@@ -52,6 +53,8 @@ func (p *PingService) PingHandler(s network.Stream) {
 	}
 	defer s.Scope().ReleaseMemory(PingSize)
 
+	s.SetDeadline(time.Now().Add(pingDuration))
+
 	buf := pool.Get(PingSize)
 	defer pool.Put(buf)
 

vendor/github.com/libp2p/go-libp2p/p2p/security/noise/pb/payload.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.30.0
+// 	protoc-gen-go v1.34.2
-// 	protoc        v3.21.12
+// 	protoc        v5.27.2
 // source: pb/payload.proto
 
 package pb
@@ -174,7 +174,7 @@ func file_pb_payload_proto_rawDescGZIP() []byte {
 }
 
 var file_pb_payload_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
-var file_pb_payload_proto_goTypes = []interface{}{
+var file_pb_payload_proto_goTypes = []any{
 	(*NoiseExtensions)(nil),       // 0: pb.NoiseExtensions
 	(*NoiseHandshakePayload)(nil), // 1: pb.NoiseHandshakePayload
 }
@@ -193,7 +193,7 @@ func file_pb_payload_proto_init() {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_pb_payload_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_payload_proto_msgTypes[0].Exporter = func(v any, i int) any {
 			switch v := v.(*NoiseExtensions); i {
 			case 0:
 				return &v.state
@@ -205,7 +205,7 @@ func file_pb_payload_proto_init() {
 				return nil
 			}
 		}
-		file_pb_payload_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_pb_payload_proto_msgTypes[1].Exporter = func(v any, i int) any {
 			switch v := v.(*NoiseHandshakePayload); i {
 			case 0:
 				return &v.state

vendor/github.com/libp2p/go-libp2p/p2p/transport/quic/transport.go

@@ -26,6 +26,8 @@ import (
 	"github.com/quic-go/quic-go"
 )
 
+const ListenOrder = 1
+
 var log = logging.Logger("quic-transport")
 
 var ErrHolePunching = errors.New("hole punching attempted; no active dial")
@@ -103,6 +105,10 @@ func NewTransport(key ic.PrivKey, connManager *quicreuse.ConnManager, psk pnet.P
 	}, nil
 }
 
+func (t *transport) ListenOrder() int {
+	return ListenOrder
+}
+
 // Dial dials a new QUIC connection
 func (t *transport) Dial(ctx context.Context, raddr ma.Multiaddr, p peer.ID) (_c tpt.CapableConn, _err error) {
 	if ok, isClient, _ := network.GetSimultaneousConnect(ctx); ok && !isClient {

vendor/github.com/libp2p/go-libp2p/p2p/transport/quicreuse/connmgr.go

@@ -9,15 +9,19 @@ import (
 
 	ma "github.com/multiformats/go-multiaddr"
 	manet "github.com/multiformats/go-multiaddr/net"
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/quic-go/quic-go"
 	quiclogging "github.com/quic-go/quic-go/logging"
+	quicmetrics "github.com/quic-go/quic-go/metrics"
 )
 
 type ConnManager struct {
 	reuseUDP4       *reuse
 	reuseUDP6       *reuse
 	enableReuseport bool
-	enableMetrics   bool
+
+	enableMetrics bool
+	registerer    prometheus.Registerer
 
 	serverConfig *quic.Config
 	clientConfig *quic.Config
@@ -40,6 +44,7 @@ func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.Toke
 		quicListeners:   make(map[string]quicListenerEntry),
 		srk:             statelessResetKey,
 		tokenKey:        tokenKey,
+		registerer:      prometheus.DefaultRegisterer,
 	}
 	for _, o := range opts {
 		if err := o(cm); err != nil {
@@ -48,14 +53,7 @@ func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.Toke
 	}
 
 	quicConf := quicConfig.Clone()
-
+	quicConf.Tracer = cm.getTracer()
-	quicConf.Tracer = func(ctx context.Context, p quiclogging.Perspective, ci quic.ConnectionID) *quiclogging.ConnectionTracer {
-		var tracer *quiclogging.ConnectionTracer
-		if qlogTracerDir != "" {
-			tracer = qloggerForDir(qlogTracerDir, p, ci)
-		}
-		return tracer
-	}
 	serverConfig := quicConf.Clone()
 
 	cm.clientConfig = quicConf
@@ -67,6 +65,31 @@ func NewConnManager(statelessResetKey quic.StatelessResetKey, tokenKey quic.Toke
 	return cm, nil
 }
 
+func (c *ConnManager) getTracer() func(context.Context, quiclogging.Perspective, quic.ConnectionID) *quiclogging.ConnectionTracer {
+	return func(ctx context.Context, p quiclogging.Perspective, ci quic.ConnectionID) *quiclogging.ConnectionTracer {
+		var promTracer *quiclogging.ConnectionTracer
+		if c.enableMetrics {
+			switch p {
+			case quiclogging.PerspectiveClient:
+				promTracer = quicmetrics.NewClientConnectionTracerWithRegisterer(c.registerer)
+			case quiclogging.PerspectiveServer:
+				promTracer = quicmetrics.NewServerConnectionTracerWithRegisterer(c.registerer)
+			default:
+				log.Error("invalid logging perspective: %s", p)
+			}
+		}
+		var tracer *quiclogging.ConnectionTracer
+		if qlogTracerDir != "" {
+			tracer = qloggerForDir(qlogTracerDir, p, ci)
+			if promTracer != nil {
+				tracer = quiclogging.NewMultiplexedConnectionTracer(promTracer,
+					tracer)
+			}
+		}
+		return tracer
+	}
+}
+
 func (c *ConnManager) getReuse(network string) (*reuse, error) {
 	switch network {
 	case "udp4":
@@ -131,6 +154,28 @@ func (c *ConnManager) onListenerClosed(key string) {
 	}
 }
 
+func (c *ConnManager) SharedNonQUICPacketConn(network string, laddr *net.UDPAddr) (net.PacketConn, error) {
+	c.quicListenersMu.Lock()
+	defer c.quicListenersMu.Unlock()
+	key := laddr.String()
+	entry, ok := c.quicListeners[key]
+	if !ok {
+		return nil, errors.New("expected to be able to share with a QUIC listener, but no QUIC listener found. The QUIC listener should start first")
+	}
+	t := entry.ln.transport
+	if t, ok := t.(*refcountedTransport); ok {
+		t.IncreaseCount()
+		ctx, cancel := context.WithCancel(context.Background())
+		return &nonQUICPacketConn{
+			ctx:             ctx,
+			ctxCancel:       cancel,
+			owningTransport: t,
+			tr:              &t.Transport,
+		}, nil
+	}
+	return nil, errors.New("expected to be able to share with a QUIC listener, but the QUIC listener is not using a refcountedTransport. `DisableReuseport` should not be set")
+}
+
 func (c *ConnManager) transportForListen(network string, laddr *net.UDPAddr) (refCountedQuicTransport, error) {
 	if c.enableReuseport {
 		reuse, err := c.getReuse(network)