Implementation: Replace mplex with yamux as default multiplexer in py-libp2p

[seetadev]

@luca and @paschal533 : Great work and wonderful contribution. Please continue research and development discussion on yamux + mplex at this web page.

Kindly keep the PR page for code commits and refinement. Appreciate your great initiative and progress.

[seetadev]

@pacrob , @luca and @paschal533 : Wish to share that I was reviewing the multiplexer development by zig-libp2p team, who are also engineering yamux at this juncture.

They have organized the project from an interop perspective: please visit zen-eth/zig-libp2p#10

Further, they have 3 sub-issues:

• Impl yamux frame codec zen-eth/zig-libp2p#14

• Impl yamux session zen-eth/zig-libp2p#15

• Impl yamux stream zen-eth/zig-libp2p#16

@paschal533 and @luca: You might find this organization of sub-modules useful from a maintainability perspective. Wish to share about it.

[paschal533]

Hi @acul71, about the Noise protocol question, I get where you're coming from. I added it as the primary security option because I think it's the right direction for us.
Noise is basically becoming the standard across the libp2p ecosystem, and we'd need to implement it eventually anyway. It gives us better performance than SECIO (faster handshakes, less overhead), and has stronger security properties.

I studied Rust-libp2p to implement Yamux. Rust-libp2p uses Noise as its primary security transport, with SecIO maintained for legacy compatibility. For py-libp2p, Noise is the recommended choice due to its modern design, interoperability, performance, and alignment with the libp2p ecosystem's future. This is the reason why I used Noise for Py-libp2p Yamux. I apologies for not keeping you in sync. I thought Noise has already been implemented in Py-libp2p. However since you have started working on Noise integration, I think we should take it up as a side quest later :)

[acul71]

Manu just wrote me to keep the noise stuff in the yamux PR. Please talk to Manu before doing anything.
Anyway we need to implement the mechanism for selecting Yamux or Mplex Via code parameters (Not env var)

[seetadev]

@paschal533 and @acul71 : Awesome contribution and collaboration on yamux.

Wish to share that I discussed about inclusion of noise in yamux with maintainers of other key libp2p modules including nim-libp2p.

Please do include noise (code commit) earlier shared by @acul71 in yamux. It would help establish secure communication and prevent us from the recent cyber attacks happening in P2P systems.

@paschal533 : Thank you for mentioning about the issue on noise too. That is a separate effort and is a libp2p platform specific contribution :) Appreciate your contribution and support.

[paschal533]

Ok @seetadev. thank you for the feedback and update. We will continue with the Noise. I will include Noise commit code by @acul71 ASAP.

[paschal533]

Manu just wrote me to keep the noise stuff in the yamux PR. Please talk to Manu before doing anything. Anyway we need to implement the mechanism for selecting Yamux or Mplex Via code parameters (Not env var)

Okay Luca, I'm actively working on the mechanism for selecting Yamux or Mplex Via code parameters. I will push my update by tomorrow. I will also write a doc on how to use it.

[acul71]

Also I was thinking about tests, if make sense to run (some ?) existing tests of other modules with Yamux selected and with Mplex selected

[paschal533]

Hi @acul71 and @seetadev, I wrote this test for switching from one stream_muxer to another (Yamux and Mplex)

import logging

import pytest
import trio

from libp2p import (
    MUXER_MPLEX,
    MUXER_YAMUX,
    create_mplex_muxer_option,
    create_yamux_muxer_option,
    new_host,
    set_default_muxer,
)

# Enable logging for debugging
logging.basicConfig(level=logging.DEBUG)


# Fixture to create hosts with a specified muxer preference
@pytest.fixture
async def host_pair(muxer_preference=None, muxer_opt=None):
    """Create a pair of connected hosts with the given muxer settings."""
    host_a = new_host(muxer_preference=muxer_preference, muxer_opt=muxer_opt)
    host_b = new_host(muxer_preference=muxer_preference, muxer_opt=muxer_opt)

    # Start both hosts
    await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
    await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

    # Connect hosts with a timeout
    listen_addrs_a = host_a.get_addrs()
    with trio.move_on_after(5):  # 5 second timeout
        await host_b.connect(host_a.get_id(), listen_addrs_a)

    yield host_a, host_b

    # Cleanup
    try:
        await host_a.close()
    except Exception as e:
        logging.warning(f"Error closing host_a: {e}")

    try:
        await host_b.close()
    except Exception as e:
        logging.warning(f"Error closing host_b: {e}")


@pytest.mark.parametrize("muxer_preference", [MUXER_YAMUX, MUXER_MPLEX])
async def test_multiplexer_preference_parameter(muxer_preference):
    """Test that muxer_preference parameter works correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        host_a = new_host(muxer_preference=muxer_preference)
        host_b = new_host(muxer_preference=muxer_preference)

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type
            if muxer_preference == MUXER_YAMUX:
                assert "YamuxStream" in stream.__class__.__name__
            else:
                assert "MplexStream" in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")


@pytest.mark.parametrize(
    "muxer_option_func,expected_stream_class",
    [
        (create_yamux_muxer_option, "YamuxStream"),
        (create_mplex_muxer_option, "MplexStream"),
    ],
)
async def test_explicit_muxer_options(muxer_option_func, expected_stream_class):
    """Test that explicit muxer options work correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        # Create hosts with specified muxer options
        muxer_opt = muxer_option_func()
        host_a = new_host(muxer_opt=muxer_opt)
        host_b = new_host(muxer_opt=muxer_opt)

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type
            assert expected_stream_class in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")


@pytest.mark.parametrize("global_default", [MUXER_YAMUX, MUXER_MPLEX])
async def test_global_default_muxer(global_default):
    """Test that global default muxer setting works correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        # Set global default
        set_default_muxer(global_default)

        # Create hosts with default settings
        host_a = new_host()
        host_b = new_host()

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type based on global default
            if global_default == MUXER_YAMUX:
                assert "YamuxStream" in stream.__class__.__name__
            else:
                assert "MplexStream" in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")

Which required me to modify the test/conftest.py file a bit, From this:

import pytest


@pytest.fixture
def security_protocol():
    return None

To This:

import pytest

from tests.utils.factories import (
    HostFactory,
)

# Register the pytest-trio plugin
pytest_plugins = ["pytest_trio"]


@pytest.fixture
def security_protocol():
    return None


@pytest.fixture
def num_hosts():
    return 3


@pytest.fixture
async def hosts(num_hosts, security_protocol, nursery):
    async with HostFactory.create_batch_and_listen(
        num_hosts, security_protocol=security_protocol
    ) as _hosts:
        yield _hosts


# Explicitly configure pytest to use trio for async tests
@pytest.hookimpl(trylast=True)
def pytest_collection_modifyitems(config, items):
    """
    Add the 'trio' marker to async tests if they don't already have an async marker.
    """
    for item in items:
        if isinstance(item, pytest.Function) and asyncio_or_trio_test(item):
            # If it's an async test but
            # doesn't have any async marker yet, add trio marker
            if not any(
                marker.name in ["trio", "asyncio"] for marker in item.own_markers
            ):
                item.add_marker(pytest.mark.trio)


def asyncio_or_trio_test(item):
    """Check if a test item is an async test function."""
    if not hasattr(item.obj, "__code__"):
        return False
    return item.obj.__code__.co_flags & 0x80  # 0x80 is the flag for coroutine functions

And that's what is causing the conflict on the PR. This change is neccesary for the tests/core/stream_muxer/test_multiplexer_selection.py to work, otherwise the tests will just skip. How do I resolve this?

Meanwhile, I want to change the tests/conftest.py file back to this:

import pytest


@pytest.fixture
def security_protocol():
    return None

to resolve the conflict first, however tests/core/stream_muxer/test_multiplexer_selection.py will be skipping for now.

[acul71]

to resolve the conflict first, however tests/core/stream_muxer/test_multiplexer_selection.py will be skipping for now.

Hi @paschal533
You can use pytest-trio that should be already installed (see setup.py )
All you need to do is add a

@pytest.mark.trio

decorator to all the async test functions in the file.

tests/core/stream_muxer/test_multiplexer_selection.py

import logging

import pytest
import trio

from libp2p import (
    MUXER_MPLEX,
    MUXER_YAMUX,
    create_mplex_muxer_option,
    create_yamux_muxer_option,
    new_host,
    set_default_muxer,
)

# Enable logging for debugging
logging.basicConfig(level=logging.DEBUG)


# Fixture to create hosts with a specified muxer preference
@pytest.fixture
async def host_pair(muxer_preference=None, muxer_opt=None):
    """Create a pair of connected hosts with the given muxer settings."""
    host_a = new_host(muxer_preference=muxer_preference, muxer_opt=muxer_opt)
    host_b = new_host(muxer_preference=muxer_preference, muxer_opt=muxer_opt)

    # Start both hosts
    await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
    await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

    # Connect hosts with a timeout
    listen_addrs_a = host_a.get_addrs()
    with trio.move_on_after(5):  # 5 second timeout
        await host_b.connect(host_a.get_id(), listen_addrs_a)

    yield host_a, host_b

    # Cleanup
    try:
        await host_a.close()
    except Exception as e:
        logging.warning(f"Error closing host_a: {e}")

    try:
        await host_b.close()
    except Exception as e:
        logging.warning(f"Error closing host_b: {e}")


@pytest.mark.trio
@pytest.mark.parametrize("muxer_preference", [MUXER_YAMUX, MUXER_MPLEX])
async def test_multiplexer_preference_parameter(muxer_preference):
    """Test that muxer_preference parameter works correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        host_a = new_host(muxer_preference=muxer_preference)
        host_b = new_host(muxer_preference=muxer_preference)

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type
            if muxer_preference == MUXER_YAMUX:
                assert "YamuxStream" in stream.__class__.__name__
            else:
                assert "MplexStream" in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")


@pytest.mark.trio
@pytest.mark.parametrize(
    "muxer_option_func,expected_stream_class",
    [
        (create_yamux_muxer_option, "YamuxStream"),
        (create_mplex_muxer_option, "MplexStream"),
    ],
)
async def test_explicit_muxer_options(muxer_option_func, expected_stream_class):
    """Test that explicit muxer options work correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        # Create hosts with specified muxer options
        muxer_opt = muxer_option_func()
        host_a = new_host(muxer_opt=muxer_opt)
        host_b = new_host(muxer_opt=muxer_opt)

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type
            assert expected_stream_class in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")


@pytest.mark.trio
@pytest.mark.parametrize("global_default", [MUXER_YAMUX, MUXER_MPLEX])
async def test_global_default_muxer(global_default):
    """Test that global default muxer setting works correctly."""
    # Set a timeout for the entire test
    with trio.move_on_after(10):
        # Set global default
        set_default_muxer(global_default)

        # Create hosts with default settings
        host_a = new_host()
        host_b = new_host()

        try:
            # Start both hosts
            await host_a.get_network().listen("/ip4/127.0.0.1/tcp/0")
            await host_b.get_network().listen("/ip4/127.0.0.1/tcp/0")

            # Connect hosts with timeout
            listen_addrs_a = host_a.get_addrs()
            with trio.move_on_after(5):  # 5 second timeout
                await host_b.connect(host_a.get_id(), listen_addrs_a)

            # Check if connection was established
            connections = host_b.get_network().connections
            assert len(connections) > 0, "Connection not established"

            # Get the first connection
            conn = list(connections.values())[0]
            muxed_conn = conn.muxed_conn

            # Define a simple echo protocol
            ECHO_PROTOCOL = "/echo/1.0.0"

            # Setup echo handler on host_a
            async def echo_handler(stream):
                try:
                    data = await stream.read(1024)
                    await stream.write(data)
                    await stream.close()
                except Exception as e:
                    print(f"Error in echo handler: {e}")

            host_a.set_stream_handler(ECHO_PROTOCOL, echo_handler)

            # Open a stream with timeout
            with trio.move_on_after(5):
                stream = await muxed_conn.open_stream(ECHO_PROTOCOL)

            # Check stream type based on global default
            if global_default == MUXER_YAMUX:
                assert "YamuxStream" in stream.__class__.__name__
            else:
                assert "MplexStream" in stream.__class__.__name__

            # Close the stream
            await stream.close()

        finally:
            # Close hosts with error handling
            try:
                await host_a.close()
            except Exception as e:
                logging.warning(f"Error closing host_a: {e}")

            try:
                await host_b.close()
            except Exception as e:
                logging.warning(f"Error closing host_b: {e}")

pytest -v tests/core/stream_muxer/test_multiplexer_selection.py
========================================================================================================== test session starts ===========================================================================================================
platform linux -- Python 3.13.3, pytest-8.3.4, pluggy-1.5.0 -- /home/luca/Informatica/Learning/PNL_Launchpad_Curriculum/Libp2p/py-libp2p-fork/venv/bin/python
cachedir: .pytest_cache
rootdir: /home/luca/Informatica/Learning/PNL_Launchpad_Curriculum/Libp2p/py-libp2p-fork
configfile: pyproject.toml
plugins: xdist-3.6.1, Faker-35.0.0, trio-0.8.0, anyio-1.4.0
collected 6 items                                                                                                                                                                                                                        

tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[YAMUX] PASSED                                                                                                                         [ 16%]
tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[MPLEX] PASSED                                                                                                                         [ 33%]
tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_yamux_muxer_option-YamuxStream] PASSED                                                                                                   [ 50%]
tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_mplex_muxer_option-MplexStream] PASSED                                                                                                   [ 66%]
tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[YAMUX] PASSED                                                                                                                                     [ 83%]
tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[MPLEX] PASSED                                                                                                                                     [100%]

========================================================================================================== slowest 50 durations ==========================================================================================================
10.01s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[MPLEX]
10.01s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_mplex_muxer_option-MplexStream]
10.01s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_yamux_muxer_option-YamuxStream]
10.01s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[YAMUX]
10.01s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[MPLEX]
10.00s call     tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[YAMUX]
0.01s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[YAMUX]
0.00s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_yamux_muxer_option-YamuxStream]
0.00s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_mplex_muxer_option-MplexStream]
0.00s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[MPLEX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[MPLEX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[MPLEX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[YAMUX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_yamux_muxer_option-YamuxStream]
0.00s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_global_default_muxer[YAMUX]
0.00s setup    tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[MPLEX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_multiplexer_preference_parameter[YAMUX]
0.00s teardown tests/core/stream_muxer/test_multiplexer_selection.py::test_explicit_muxer_options[create_mplex_muxer_option-MplexStream]
====================================================================================================== 6 passed in 60.09s (0:01:00) ======================================================================================================

[paschal533]

Thank you @acul71

[seetadev]

@acul71 and @paschal533 : Great, lets try and arrive at a good conclusion on yamux + mplex dependency issues by today or tomorrow. Will ask devs working on rust-libp2p to test your PR in their code base too.

[acul71]

@acul71 and @paschal533 : Great, lets try and arrive at a good conclusion on yamux + mplex dependency issues by today or tomorrow. Will ask devs working on rust-libp2p to test your PR in their code base too.

I did some test "by hand" and the "talking" between py-libp2p and rust-libp2p, js-libp2p is failing. @paschal533 merge as soon as possible, cause this PR will be only the first step, but many fix will be needed

[paschal533]

On it at the moment 🚀

[seetadev]

@paschal533 : Thank you for sharing. Could you please discuss with @acul71 today. We have fully replace asyncio with trio. So, having its support available within yamux and mplex is necessary.

Please touch base with @pacrob for his suggestions and feedback too. We received his guidance and support on using trio in important py-libp2p PRs.

[acul71]

@paschal533 : Thank you for sharing. Could you please discuss with @acul71 today. We have fully replace asyncio with trio. So, having its support available within yamux and mplex is necessary.

Please touch base with @pacrob for his suggestions and feedback too. We received his guidance and support on using trio in important py-libp2p PRs.

See #582 (reply in thread)