libp2p 0.2.3__tar.gz → 0.2.4__tar.gz

{libp2p-0.2.3/libp2p.egg-info → libp2p-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libp2p
-Version: 0.2.3
+Version: 0.2.4
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation
@@ -10,6 +10,7 @@ Keywords: libp2p p2p
 Platform: unix
 Platform: linux
 Platform: osx
+Platform: win32
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -39,8 +40,7 @@ Requires-Dist: pynacl>=1.3.0
 Requires-Dist: rpcudp>=3.0.0
 Requires-Dist: trio-typing>=0.0.4
 Requires-Dist: trio>=0.26.0
-Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
-Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
+Requires-Dist: fastecdsa==1.7.5
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
 Requires-Dist: bump_my_version>=0.19.0; extra == "dev"

libp2p-0.2.4/libp2p/crypto/ecc.py

@@ -0,0 +1,134 @@
+import sys
+
+from libp2p.crypto.keys import (
+    KeyPair,
+    KeyType,
+    PrivateKey,
+    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) -> object:
+    """
+    Convert a str representation of some elliptic curve to a
+    representation understood by the backend of this module.
+    """
+    if curve != "P-256":
+        raise NotImplementedError("Only P-256 curve is supported")
+
+    if sys.platform != "win32":
+        return curve_types.P256
+    return "P-256"  # coincurve only supports P-256
+
+
+if sys.platform != "win32":
+
+    class ECCPublicKey(PublicKey):
+        def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
+            self.impl = impl
+            self.curve = curve
+
+        def to_bytes(self) -> bytes:
+            return SEC1Encoder.encode_public_key(self.impl, compressed=False)
+
+        @classmethod
+        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 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: int, curve: curve_types.Curve) -> None:
+            self.impl = impl
+            self.curve = curve
+
+        @classmethod
+        def new(cls, curve: str) -> "ECCPrivateKey":
+            curve_type = infer_local_type(curve)
+            private_key_impl = keys.gen_private_key(curve_type)
+            return cls(private_key_impl, curve_type)
+
+        def to_bytes(self) -> bytes:
+            return keys.export_key(self.impl, self.curve)
+
+        def get_type(self) -> KeyType:
+            return KeyType.ECC_P256
+
+        def sign(self, data: bytes) -> bytes:
+            raise NotImplementedError()
+
+        def get_public_key(self) -> PublicKey:
+            public_key_impl = keys.get_public_key(self.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.
+    "P-256".
+    """
+    private_key = ECCPrivateKey.new(curve)
+    public_key = private_key.get_public_key()
+    return KeyPair(private_key, public_key)

libp2p-0.2.4/libp2p/crypto/key_exchange.py

@@ -0,0 +1,59 @@
+import sys
+from typing import (
+    Callable,
+    cast,
+)
+
+if sys.platform != "win32":
+    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,
+    ECCPublicKey,
+    create_new_key_pair,
+)
+from libp2p.crypto.keys import (
+    PublicKey,
+)
+
+SharedKeyGenerator = Callable[[bytes], bytes]
+
+
+def create_ephemeral_key_pair(curve_type: str) -> tuple[PublicKey, SharedKeyGenerator]:
+    """Facilitates ECDH key exchange."""
+    if curve_type != "P-256":
+        raise NotImplementedError()
+
+    key_pair = create_new_key_pair(curve_type)
+
+    def _key_exchange(serialized_remote_public_key: bytes) -> bytes:
+        private_key = cast(ECCPrivateKey, key_pair.private_key)
+
+        remote_point = ECCPublicKey.from_bytes(serialized_remote_public_key, curve_type)
+
+        if sys.platform != "win32":
+            secret_point = remote_point.impl * private_key.impl
+            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

{libp2p-0.2.3 → libp2p-0.2.4/libp2p.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libp2p
-Version: 0.2.3
+Version: 0.2.4
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation
@@ -10,6 +10,7 @@ Keywords: libp2p p2p
 Platform: unix
 Platform: linux
 Platform: osx
+Platform: win32
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -39,8 +40,7 @@ Requires-Dist: pynacl>=1.3.0
 Requires-Dist: rpcudp>=3.0.0
 Requires-Dist: trio-typing>=0.0.4
 Requires-Dist: trio>=0.26.0
-Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
-Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
+Requires-Dist: fastecdsa==1.7.5
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
 Requires-Dist: bump_my_version>=0.19.0; extra == "dev"

{libp2p-0.2.3 → libp2p-0.2.4}/libp2p.egg-info/requires.txt

@@ -11,16 +11,11 @@ pynacl>=1.3.0
 rpcudp>=3.0.0
 trio-typing>=0.0.4
 trio>=0.26.0
+fastecdsa==1.7.5
 
 [:python_version < "3.11"]
 exceptiongroup>=1.2.0
 
-[:sys_platform != "win32"]
-fastecdsa==1.7.5
-
-[:sys_platform == "win32"]
-fastecdsa-any==1.7.5
-
 [dev]
 build>=0.9.0
 bump_my_version>=0.19.0

{libp2p-0.2.3 → libp2p-0.2.4}/pyproject.toml

@@ -127,7 +127,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "0.2.3"
+current_version = "0.2.4"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{libp2p-0.2.3 → libp2p-0.2.4}/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 = [
-    # No official fastecdsa==1.7.4,1.7.5 wheels for Windows, using a pypi package that includes
-    # the original library, but also windows-built wheels (32+64-bit) on those versions.
-    # Fixme: Remove section when fastecdsa has released a windows-compatible wheel
-    #  (specifically: both win32 and win_amd64 targets)
-    #  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()
-
+try:
+    with open("./README.md", encoding="utf-8") as readme:
+        long_description = readme.read()
+except FileNotFoundError:
+    long_description = description
 
 install_requires = [
     "base58>=1.0.3",
@@ -70,19 +66,14 @@ install_requires = [
     "trio>=0.26.0",
 ]
 
-
-# NOTE: Some dependencies break RTD builds. We can not install system dependencies on the
-# 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)
-
+# Add platform-specific dependencies
+install_requires.extend(crypto_requires)
 
 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""",
+    version="0.2.4",
+    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",

libp2p-0.2.3/libp2p/crypto/ecc.py

@@ -1,82 +0,0 @@
-from fastecdsa import (
-    keys,
-    point,
-)
-from fastecdsa import curve as curve_types
-from fastecdsa.encoding.sec1 import (
-    SEC1Encoder,
-)
-
-from libp2p.crypto.keys import (
-    KeyPair,
-    KeyType,
-    PrivateKey,
-    PublicKey,
-)
-
-
-def infer_local_type(curve: str) -> curve_types.Curve:
-    """
-    Convert a ``str`` representation of some elliptic curve to a
-    representation understood by the backend of this module.
-    """
-    if curve == "P-256":
-        return curve_types.P256
-    else:
-        raise NotImplementedError()
-
-
-class ECCPublicKey(PublicKey):
-    def __init__(self, impl: point.Point, curve: curve_types.Curve) -> None:
-        self.impl = impl
-        self.curve = curve
-
-    def to_bytes(self) -> bytes:
-        return SEC1Encoder.encode_public_key(self.impl, compressed=False)
-
-    @classmethod
-    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 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: int, curve: curve_types.Curve) -> None:
-        self.impl = impl
-        self.curve = curve
-
-    @classmethod
-    def new(cls, curve: str) -> "ECCPrivateKey":
-        curve_type = infer_local_type(curve)
-        private_key_impl = keys.gen_private_key(curve_type)
-        return cls(private_key_impl, curve_type)
-
-    def to_bytes(self) -> bytes:
-        return keys.export_key(self.impl, self.curve)
-
-    def get_type(self) -> KeyType:
-        return KeyType.ECC_P256
-
-    def sign(self, data: bytes) -> bytes:
-        raise NotImplementedError()
-
-    def get_public_key(self) -> PublicKey:
-        public_key_impl = keys.get_public_key(self.impl, self.curve)
-        return ECCPublicKey(public_key_impl, self.curve)
-
-
-def create_new_key_pair(curve: str) -> KeyPair:
-    """
-    Return a new ECC keypair with the requested ``curve`` type, e.g.
-    "P-256".
-    """
-    private_key = ECCPrivateKey.new(curve)
-    public_key = private_key.get_public_key()
-    return KeyPair(private_key, public_key)

libp2p-0.2.3/libp2p/crypto/key_exchange.py

@@ -1,40 +0,0 @@
-from typing import (
-    Callable,
-    cast,
-)
-
-from fastecdsa.encoding import (
-    util,
-)
-
-from libp2p.crypto.ecc import (
-    ECCPrivateKey,
-    ECCPublicKey,
-    create_new_key_pair,
-)
-from libp2p.crypto.keys import (
-    PublicKey,
-)
-
-SharedKeyGenerator = Callable[[bytes], bytes]
-
-int_bytelen = util.int_bytelen
-
-
-def create_ephemeral_key_pair(curve_type: str) -> tuple[PublicKey, SharedKeyGenerator]:
-    """Facilitates ECDH key exchange."""
-    if curve_type != "P-256":
-        raise NotImplementedError()
-
-    key_pair = create_new_key_pair(curve_type)
-
-    def _key_exchange(serialized_remote_public_key: bytes) -> bytes:
-        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
-        byte_size = int_bytelen(secret_x_coordinate)
-        return secret_x_coordinate.to_bytes(byte_size, byteorder="big")
-
-    return key_pair.public_key, _key_exchange