feat: Add Windows compatibility using coincurve

.github/workflows/tox.yml

@@ -41,3 +41,29 @@ jobs:
           python -m pip install tox
       - run: |
           python -m tox run -r
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        python-version: ['3.11']  # Using a stable Python version for Windows testing
+        toxenv: [core, wheel]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install tox
+      - name: Test with tox
+        shell: bash
+        run: |
+          if [[ "${{ matrix.toxenv }}" == "wheel" ]]; then
+            python -m tox run -e windows-wheel
+          else
+            python -m tox run -e py311-${{ matrix.toxenv }}
+          fi

libp2p/crypto/ecc.py

@@ -1,11 +1,4 @@
-from fastecdsa import (
+import sys
-    keys,
-    point,
-)
-from fastecdsa import curve as curve_types
-from fastecdsa.encoding.sec1 import (
-    SEC1Encoder,
-)
 
 from libp2p.crypto.keys import (
     KeyPair,
@@ -14,67 +7,126 @@ from libp2p.crypto.keys import (
     PublicKey,
 )
 
+if sys.platform != "win32":
+    from fastecdsa import (
+        keys,
+        point,
+    )
+    from fastecdsa import curve as curve_types
+    from fastecdsa.encoding.sec1 import (
+        SEC1Encoder,
+    )
+else:
+    from coincurve import PrivateKey as CPrivateKey
+    from coincurve import PublicKey as CPublicKey
 
-def infer_local_type(curve: str) -> curve_types.Curve:
+
+def infer_local_type(curve: str) -> object:
     """
-    Convert a ``str`` representation of some elliptic curve to a
+    Convert a str representation of some elliptic curve to a
     representation understood by the backend of this module.
     """
-    if curve == "P-256":
+    if curve != "P-256":
+        raise NotImplementedError("Only P-256 curve is supported")
+
+    if sys.platform != "win32":
         return curve_types.P256
-    else:
+    return "P-256"  # coincurve only supports P-256
-        raise NotImplementedError()
 
 
-class ECCPublicKey(PublicKey):
+if sys.platform != "win32":
-    def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
-        self.impl = impl
-        self.curve = curve
 
-    def to_bytes(self) -> bytes:
+    class ECCPublicKey(PublicKey):
-        return SEC1Encoder.encode_public_key(self.impl, compressed=False)
+        def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
+            self.impl = impl
+            self.curve = curve
 
-    @classmethod
+        def to_bytes(self) -> bytes:
-    def from_bytes(cls, data: bytes, curve: str) -> "ECCPublicKey":
+            return SEC1Encoder.encode_public_key(self.impl, compressed=False)
-        curve_type = infer_local_type(curve)
-        public_key_impl = SEC1Encoder.decode_public_key(data, curve_type)
-        return cls(public_key_impl, curve_type)
 
-    def get_type(self) -> KeyType:
+        @classmethod
-        return KeyType.ECC_P256
+        def from_bytes(cls, data: bytes, curve: str) -> "ECCPublicKey":
+            curve_type = infer_local_type(curve)
+            public_key_impl = SEC1Encoder.decode_public_key(data, curve_type)
+            return cls(public_key_impl, curve_type)
 
-    def verify(self, data: bytes, signature: bytes) -> bool:
+        def get_type(self) -> KeyType:
-        raise NotImplementedError()
+            return KeyType.ECC_P256
 
+        def verify(self, data: bytes, signature: bytes) -> bool:
+            raise NotImplementedError()
 
-class ECCPrivateKey(PrivateKey):
+    class ECCPrivateKey(PrivateKey):
-    def __init__(self, impl: int, curve: curve_types.Curve) -> None:
+        def __init__(self, impl: int, curve: curve_types.Curve) -> None:
-        self.impl = impl
+            self.impl = impl
-        self.curve = curve
+            self.curve = curve
 
-    @classmethod
+        @classmethod
-    def new(cls, curve: str) -> "ECCPrivateKey":
+        def new(cls, curve: str) -> "ECCPrivateKey":
-        curve_type = infer_local_type(curve)
+            curve_type = infer_local_type(curve)
-        private_key_impl = keys.gen_private_key(curve_type)
+            private_key_impl = keys.gen_private_key(curve_type)
-        return cls(private_key_impl, curve_type)
+            return cls(private_key_impl, curve_type)
 
-    def to_bytes(self) -> bytes:
+        def to_bytes(self) -> bytes:
-        return keys.export_key(self.impl, self.curve)
+            return keys.export_key(self.impl, self.curve)
 
-    def get_type(self) -> KeyType:
+        def get_type(self) -> KeyType:
-        return KeyType.ECC_P256
+            return KeyType.ECC_P256
 
-    def sign(self, data: bytes) -> bytes:
+        def sign(self, data: bytes) -> bytes:
-        raise NotImplementedError()
+            raise NotImplementedError()
 
-    def get_public_key(self) -> PublicKey:
+        def get_public_key(self) -> PublicKey:
-        public_key_impl = keys.get_public_key(self.impl, self.curve)
+            public_key_impl = keys.get_public_key(self.impl, self.curve)
-        return ECCPublicKey(public_key_impl, self.curve)
+            return ECCPublicKey(public_key_impl, self.curve)
+
+else:
+
+    class ECCPublicKey(PublicKey):
+        def __init__(self, impl: CPublicKey, curve: str) -> None:
+            self.impl = impl
+            self.curve = curve
+
+        def to_bytes(self) -> bytes:
+            return self.impl.format(compressed=False)
+
+        @classmethod
+        def from_bytes(cls, data: bytes, curve: str) -> "ECCPublicKey":
+            curve_type = infer_local_type(curve)
+            return cls(CPublicKey(data), curve_type)  # type: ignore[arg-type]
+
+        def get_type(self) -> KeyType:
+            return KeyType.ECC_P256
+
+        def verify(self, data: bytes, signature: bytes) -> bool:
+            raise NotImplementedError()
+
+    class ECCPrivateKey(PrivateKey):
+        def __init__(self, impl: CPrivateKey, curve: str) -> None:
+            self.impl = impl
+            self.curve = curve
+
+        @classmethod
+        def new(cls, curve: str) -> "ECCPrivateKey":
+            curve_type = infer_local_type(curve)
+            return cls(CPrivateKey(), curve_type)  # type: ignore[arg-type]
+
+        def to_bytes(self) -> bytes:
+            return self.impl.secret
+
+        def get_type(self) -> KeyType:
+            return KeyType.ECC_P256
+
+        def sign(self, data: bytes) -> bytes:
+            raise NotImplementedError()
+
+        def get_public_key(self) -> PublicKey:
+            return ECCPublicKey(self.impl.public_key, self.curve)
 
 
 def create_new_key_pair(curve: str) -> KeyPair:
     """
-    Return a new ECC keypair with the requested ``curve`` type, e.g.
+    Return a new ECC keypair with the requested curve type, e.g.
     "P-256".
     """
     private_key = ECCPrivateKey.new(curve)

libp2p/crypto/key_exchange.py

@@ -1,11 +1,26 @@
+import sys
 from typing import (
     Callable,
     cast,
 )
 
-from fastecdsa.encoding import (
+if sys.platform != "win32":
-    util,
+    from fastecdsa.encoding import (
-)
+        util,
+    )
+
+    int_bytelen = util.int_bytelen
+else:
+    from math import (
+        ceil,
+        log2,
+    )
+
+    def int_bytelen(n: int) -> int:
+        if n == 0:
+            return 1
+        return ceil(log2(abs(n) + 1) / 8)
+
 
 from libp2p.crypto.ecc import (
     ECCPrivateKey,
@@ -18,8 +33,6 @@ from libp2p.crypto.keys import (
 
 SharedKeyGenerator = Callable[[bytes], bytes]
 
-int_bytelen = util.int_bytelen
-
 
 def create_ephemeral_key_pair(curve_type: str) -> tuple[PublicKey, SharedKeyGenerator]:
     """Facilitates ECDH key exchange."""
@@ -32,9 +45,15 @@ def create_ephemeral_key_pair(curve_type: str) -> tuple[PublicKey, SharedKeyGene
         private_key = cast(ECCPrivateKey, key_pair.private_key)
 
         remote_point = ECCPublicKey.from_bytes(serialized_remote_public_key, curve_type)
-        secret_point = remote_point.impl * private_key.impl
+
-        secret_x_coordinate = secret_point.x
+        if sys.platform != "win32":
-        byte_size = int_bytelen(secret_x_coordinate)
+            secret_point = remote_point.impl * private_key.impl
-        return secret_x_coordinate.to_bytes(byte_size, byteorder="big")
+            secret_x_coordinate = secret_point.x
+            byte_size = int_bytelen(secret_x_coordinate)
+            return secret_x_coordinate.to_bytes(byte_size, byteorder="big")
+        else:
+            # Windows implementation using coincurve
+            shared_key = private_key.impl.ecdh(remote_point.impl.public_key)
+            return shared_key
 
     return key_pair.public_key, _key_exchange

newsfragments/498.docs.rst

@@ -0,0 +1 @@
+Updates ``Feature Breakdown`` in ``README`` to more closely match the list of standard modules.

newsfragments/507.bugfix.rst

@@ -0,0 +1 @@
+Added Windows compatibility by using coincurve instead of fastecdsa on Windows platforms

newsfragments/513.bugfix.rst

@@ -0,0 +1 @@
+Fixed import path in the examples to use updated `net_stream` module path, resolving ModuleNotFoundError when running the examples.

newsfragments/522.internal.rst

@@ -0,0 +1 @@
+Fixes broken CI lint run, bumps ``pre-commit-hooks`` version to ``5.0.0`` and ``mdformat`` to ``0.7.22``.

setup.py

@@ -1,11 +1,19 @@
 #!/usr/bin/env python
-import os
+import sys
 
 from setuptools import (
     find_packages,
     setup,
 )
 
+description = "libp2p: The Python implementation of the libp2p networking stack"
+
+# Platform-specific dependencies
+if sys.platform == "win32":
+    crypto_requires = []  # We'll use coincurve instead of fastecdsa on Windows
+else:
+    crypto_requires = ["fastecdsa==1.7.5"]
+
 extras_require = {
     "dev": [
         "build>=0.9.0",
@@ -35,23 +43,11 @@ extras_require["dev"] = (
     extras_require["dev"] + extras_require["docs"] + extras_require["test"]
 )
 
-fastecdsa = [
+try:
-    # No official fastecdsa==1.7.4,1.7.5 wheels for Windows, using a pypi package that includes
+    with open("./README.md", encoding="utf-8") as readme:
-    # the original library, but also windows-built wheels (32+64-bit) on those versions.
+        long_description = readme.read()
-    # Fixme: Remove section when fastecdsa has released a windows-compatible wheel
+except FileNotFoundError:
-    #  (specifically: both win32 and win_amd64 targets)
+    long_description = description
-    #  See the following issues for more information;
-    #  https://github.com/libp2p/py-libp2p/issues/363
-    #  https://github.com/AntonKueltz/fastecdsa/issues/11
-    "fastecdsa-any==1.7.5;sys_platform=='win32'",
-    # Wheels are provided for these platforms, or compiling one is minimally frustrating in a
-    # default python installation.
-    "fastecdsa==1.7.5;sys_platform!='win32'",
-]
-
-with open("./README.md") as readme:
-    long_description = readme.read()
-
 
 install_requires = [
     "base58>=1.0.3",
@@ -70,19 +66,14 @@ install_requires = [
     "trio>=0.26.0",
 ]
 
-
+# Add platform-specific dependencies
-# NOTE: Some dependencies break RTD builds. We can not install system dependencies on the
+install_requires.extend(crypto_requires)
-# RTD system so we have to exclude these dependencies when we are in an RTD environment.
-readthedocs_is_building = os.environ.get("READTHEDOCS", False)
-if not readthedocs_is_building:
-    install_requires.extend(fastecdsa)
-
 
 setup(
     name="libp2p",
     # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process.
     version="0.2.3",
-    description="""libp2p: The Python implementation of the libp2p networking stack""",
+    description=description,
     long_description=long_description,
     long_description_content_type="text/markdown",
     author="The Ethereum Foundation",
@@ -111,7 +102,7 @@ setup(
         "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
     ],
-    platforms=["unix", "linux", "osx"],
+    platforms=["unix", "linux", "osx", "win32"],
     entry_points={
         "console_scripts": [
             "chat-demo=examples.chat.chat:main",