Sync p2p code with go-ethereum to fix netrestrict issues in v5 discovery

.github/workflows/lint.yml

@@ -38,9 +38,5 @@ jobs:
         with:
           go-version: '1.25'
 
-      - name: Install golangci-lint
-        uses: golangci/golangci-lint-action@v9
-        with:
-          version: 'v2.8.0'
-
+      - run: go tool golangci-lint version
       - run: make lint

Makefile

@@ -60,6 +60,7 @@ ifeq ($(CGO_CXXFLAGS),)
 	CGO_CXXFLAGS += -g
 	CGO_CXXFLAGS += -O2
 endif
+export CGO_CXXFLAGS
 
 BUILD_TAGS =
 
@@ -83,9 +84,9 @@ GO_BUILD_ENV = GOARCH=${GOARCH} ${CPU_ARCH} CGO_CFLAGS="$(CGO_CFLAGS)" CGO_LDFLA
 GOBUILD = $(GO_BUILD_ENV) $(GO) build $(GO_RELEASE_FLAGS) $(GO_FLAGS) -tags $(BUILD_TAGS)
 DLV_GO_FLAGS := -gcflags='all="-N -l" -trimpath=false'
 GO_BUILD_DEBUG = $(GO_BUILD_ENV) CGO_CFLAGS="$(CGO_CFLAGS) -DMDBX_DEBUG=1" $(GO) build $(DLV_GO_FLAGS) $(GO_FLAGS) -tags $(BUILD_TAGS),debug
-GOTEST = $(GO_BUILD_ENV) CGO_CXXFLAGS="$(CGO_CXXFLAGS)" GODEBUG=cgocheck=0 GOTRACEBACK=1 GOEXPERIMENT=synctest $(GO) test $(GO_FLAGS) ./...
+GOTEST = $(GO_BUILD_ENV) GODEBUG=cgocheck=0 GOTRACEBACK=1 GOEXPERIMENT=synctest $(GO) test $(GO_FLAGS) ./...
 
-GOINSTALL = CGO_CXXFLAGS="$(CGO_CXXFLAGS)" go install -trimpath
+GOINSTALL = go install -trimpath
 
 OS = $(shell uname -s)
 ARCH = $(shell uname -m)
@@ -335,17 +336,13 @@ kurtosis-cleanup:
 	@echo "-----------------------------------\n"
 	kurtosis enclave rm -f makefile-kurtosis-testnet
 
-## lint-deps:                         install lint dependencies
-lint-deps:
-	@./tools/golangci_lint.sh --install-deps
-
 ## lintci:                            run golangci-lint linters
 lintci:
-	@CGO_CXXFLAGS="$(CGO_CXXFLAGS)" ./tools/golangci_lint.sh
+	@GOEXPERIMENT=synctest go tool golangci-lint run
 
 ## lint:                              run all linters
-lint: 
-	@./tools/golangci_lint.sh
+lint:
+	@GOEXPERIMENT=synctest go tool golangci-lint run
 	@./tools/mod_tidy_check.sh
 
 ## tidy:                              `go mod tidy`

cl/p2p/p2p_localnode.go

@@ -20,11 +20,11 @@ func newLocalNode(
 	tmpDir string,
 	logger log.Logger,
 ) (*enode.LocalNode, error) {
-	db, err := enode.OpenDB(ctx, "", tmpDir, logger)
+	db, err := enode.OpenDBEx(ctx, "", tmpDir, logger)
 	if err != nil {
 		return nil, fmt.Errorf("could not open node's peer database: %w", err)
 	}
-	localNode := enode.NewLocalNode(db, privKey, logger)
+	localNode := enode.NewLocalNode(db, privKey)
 
 	ipEntry := enr.IP(ipAddr)
 	udpEntry := enr.UDP(udpPort)
@@ -75,7 +75,7 @@ func NewUDPv5Listener(ctx context.Context, cfg *P2PConfig, discCfg discover.Conf
 	}
 
 	// Start stream handlers
-	net, err := discover.ListenV5(ctx, "any", conn, localNode, discCfg)
+	net, err := discover.ListenV5(conn, localNode, discCfg)
 	if err != nil {
 		return nil, err
 	}

cl/sentinel/handlers/heartbeats_test.go

@@ -59,11 +59,11 @@ func newkey() *ecdsa.PrivateKey {
 }
 
 func testLocalNode() *enode.LocalNode {
-	db, err := enode.OpenDB(context.TODO(), "", "", log.Root())
+	db, err := enode.OpenDBEx(context.TODO(), "", "", log.Root())
 	if err != nil {
 		panic(err)
 	}
-	ln := enode.NewLocalNode(db, newkey(), log.Root())
+	ln := enode.NewLocalNode(db, newkey())
 	ln.Set(enr.WithEntry("attnets", attnetsTestVal))
 	ln.Set(enr.WithEntry("syncnets", syncnetsTestVal))
 	return ln

cmd/bootnode/main.go

@@ -122,22 +122,22 @@ func main() {
 	ctx, cancel := common.RootContext()
 	defer cancel()
 
-	db, err := enode.OpenDB(ctx, "" /* path */, "" /* tmpDir */, logger)
+	db, err := enode.OpenDBEx(ctx, "" /* path */, "" /* tmpDir */, logger)
 	if err != nil {
 		panic(err)
 	}
-	ln := enode.NewLocalNode(db, nodeKey, logger)
+	ln := enode.NewLocalNode(db, nodeKey)
 	cfg := discover.Config{
 		PrivateKey:  nodeKey,
 		NetRestrict: restrictList,
 	}
 
 	if *runv5 {
-		if _, err := discover.ListenV5(ctx, "any", conn, ln, cfg); err != nil {
+		if _, err := discover.ListenV5(conn, ln, cfg); err != nil {
 			utils.Fatalf("%v", err)
 		}
 	} else {
-		if _, err := discover.ListenUDP(ctx, "any", conn, ln, cfg); err != nil {
+		if _, err := discover.ListenUDP(conn, ln, cfg); err != nil {
 			utils.Fatalf("%v", err)
 		}
 	}

cmd/integration/commands/commitment.go

@@ -673,7 +673,7 @@ func benchHistoryLookup(ctx context.Context, logger log.Logger) error {
 
 // benchSnapshotsHistoryLookup benchmarks history lookups across snapshot files
 func benchSnapshotsHistoryLookup(ctx context.Context, tx kv.TemporalTx, historyFiles []dbstate.VisibleFile, compactKey []byte, samplePct float64, rng *rand.Rand, logger log.Logger) ([]HistoryBenchStats, error) {
-	var allFileStats []HistoryBenchStats
+	allFileStats := make([]HistoryBenchStats, 0, len(historyFiles))
 
 	for _, f := range historyFiles {
 		fpath := f.Fullpath()

cmd/utils/flags.go

@@ -44,12 +44,12 @@ import (
 	"github.com/erigontech/erigon/common"
 	libkzg "github.com/erigontech/erigon/common/crypto/kzg"
 	"github.com/erigontech/erigon/common/log/v3"
-	"github.com/erigontech/erigon/common/metrics"
 	"github.com/erigontech/erigon/db/datadir"
 	"github.com/erigontech/erigon/db/downloader/downloadercfg"
 	"github.com/erigontech/erigon/db/snapcfg"
 	"github.com/erigontech/erigon/db/state/statecfg"
 	"github.com/erigontech/erigon/db/version"
+	"github.com/erigontech/erigon/diagnostics/metrics"
 	"github.com/erigontech/erigon/execution/builder/buildercfg"
 	"github.com/erigontech/erigon/execution/chain/networkname"
 	chainspec "github.com/erigontech/erigon/execution/chain/spec"

common/crypto/crypto.go

@@ -58,6 +58,15 @@ var (
 
 var errInvalidPubkey = errors.New("invalid secp256k1 public key")
 
+// EllipticCurve contains curve operations.
+type EllipticCurve interface {
+	elliptic.Curve
+
+	// Point marshaling/unmarshaing.
+	Marshal(x, y *big.Int) []byte
+	Unmarshal(data []byte) (x, y *big.Int)
+}
+
 // KeccakState wraps sha3.state. In addition to the usual hash methods, it also supports
 // Read to get a variable amount of data from the hash state. Read is faster than Sum
 // because it doesn't copy the internal state, but also modifies the internal state.
@@ -204,6 +213,16 @@ func MarshalPubkey(pubkey *ecdsa.PublicKey) []byte {
 	return keyBytes[1:]
 }
 
+// FromECDSAPub converts a secp256k1 public key to bytes.
+// Note: it does not use the curve from pub, instead it always
+// encodes using secp256k1.
+func FromECDSAPub(pub *ecdsa.PublicKey) []byte {
+	if pub == nil || pub.X == nil || pub.Y == nil {
+		return nil
+	}
+	return S256().Marshal(pub.X, pub.Y)
+}
+
 // HexToECDSA parses a secp256k1 private key.
 func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error) {
 	b, err := hex.DecodeString(hexkey)

common/crypto/signature_cgo.go

@@ -92,6 +92,6 @@ func CompressPubkey(pubkey *ecdsa.PublicKey) []byte {
 }
 
 // S256 returns an instance of the secp256k1 curve.
-func S256() elliptic.Curve {
+func S256() EllipticCurve {
 	return secp256k1.S256()
 }