libp2p 0.1.4__tar.gz → 0.2.0__tar.gz

libp2p-0.2.0/LICENSE-APACHE

@@ -0,0 +1,7 @@
+Copyright (c) 2018 Zixuan Zhang
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

libp2p-0.2.0/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Zixuan Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libp2p-0.2.0/MANIFEST.in

@@ -0,0 +1,13 @@
+include LICENSE-APACHE
+include LICENSE-MIT
+include README.md
+
+recursive-include scripts *
+recursive-include tests *
+
+global-include *.pyi
+
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+prune .tox
+prune venv*

libp2p-0.2.0/PKG-INFO

@@ -0,0 +1,218 @@
+Metadata-Version: 2.1
+Name: libp2p
+Version: 0.2.0
+Summary: libp2p: The Python implementation of the libp2p networking stack
+Home-page: https://github.com/libp2p/py-libp2p
+Author: The Ethereum Foundation
+Author-email: snakecharmers@ethereum.org
+License: MIT/APACHE2.0
+Keywords: libp2p p2p
+Platform: unix
+Platform: linux
+Platform: osx
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE-APACHE
+License-File: LICENSE-MIT
+Requires-Dist: base58>=1.0.3
+Requires-Dist: coincurve>=10.0.0
+Requires-Dist: exceptiongroup>=1.2.0; python_version < "3.11"
+Requires-Dist: lru-dict>=1.1.6
+Requires-Dist: multiaddr>=0.0.9
+Requires-Dist: mypy-protobuf>=3.0.0
+Requires-Dist: noiseprotocol>=0.3.0
+Requires-Dist: protobuf>=5.27.0
+Requires-Dist: pycryptodome>=3.9.2
+Requires-Dist: pymultihash>=0.8.2
+Requires-Dist: pynacl>=1.3.0
+Requires-Dist: rpcudp>=3.0.0
+Requires-Dist: trio-typing>=0.0.4
+Requires-Dist: trio>=0.15.0
+Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
+Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
+Provides-Extra: dev
+Requires-Dist: build>=0.9.0; extra == "dev"
+Requires-Dist: bump-my-version>=0.5.3; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: mypy==1.10.0; extra == "dev"
+Requires-Dist: pre-commit>=3.4.0; extra == "dev"
+Requires-Dist: tox>=4.0.0; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: sphinx>=6.0.0; extra == "dev"
+Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
+Requires-Dist: towncrier<22,>=21; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-xdist>=2.4.0; extra == "dev"
+Requires-Dist: pytest-trio>=0.5.2; extra == "dev"
+Requires-Dist: factory-boy<3.0.0,>=2.12.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.0.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
+Requires-Dist: towncrier<22,>=21; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-xdist>=2.4.0; extra == "test"
+Requires-Dist: pytest-trio>=0.5.2; extra == "test"
+Requires-Dist: factory-boy<3.0.0,>=2.12.0; extra == "test"
+
+# py-libp2p
+
+[![Join the chat at https://gitter.im/py-libp2p/Lobby](https://badges.gitter.im/py-libp2p/Lobby.png)](https://gitter.im/py-libp2p/Lobby)
+[![Build Status](https://circleci.com/gh/libp2p/py-libp2p.svg?style=shield)](https://circleci.com/gh/libp2p/py-libp2p)
+[![PyPI version](https://badge.fury.io/py/libp2p.svg)](https://badge.fury.io/py/libp2p)
+[![Python versions](https://img.shields.io/pypi/pyversions/libp2p.svg)](https://pypi.python.org/pypi/libp2p)
+[![Docs build](https://readthedocs.org/projects/py-libp2p/badge/?version=latest)](http://py-libp2p.readthedocs.io/en/latest/?badge=latest)
+[![Freenode](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg)](https://webchat.freenode.net/?channels=%23libp2p)
+[![Matrix](https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg)](https://riot.permaweb.io/#/room/#libp2p:permaweb.io)
+[![Discord](https://img.shields.io/discord/475789330380488707?color=blueviolet&label=discord)](https://discord.gg/66KBrm2)
+
+<h1 align="center">
+  <a href="https://libp2p.io/"><img width="250" src="https://github.com/libp2p/py-libp2p/blob/main/assets/py-libp2p-logo.png?raw=true" alt="py-libp2p hex logo" /></a>
+</h1>
+
+## WARNING
+
+py-libp2p is an experimental and work-in-progress repo under development. We do not yet recommend using py-libp2p in production environments.
+Right now, `tests_interop` are turned off for CI, and a number of `tests` are failing. WIP.
+
+The Python implementation of the libp2p networking stack
+
+Read more in the [documentation on ReadTheDocs](https://py-libp2p.readthedocs.io/). [View the release notes](https://py-libp2p.readthedocs.io/en/latest/release_notes.html).
+
+## Maintainers
+
+Currently maintained by [@pacrob](https://github.com/pacrob) and [@dhuseby](https://github.com/dhuseby), looking for assistance!
+
+Note that tests/core/test_libp2p/test_libp2p.py contains an end-to-end messaging test between two libp2p hosts, which is the bulk of our proof of concept.
+
+## Feature Breakdown
+
+py-libp2p aims for conformity with [the standard libp2p modules](https://github.com/libp2p/libp2p/blob/master/REQUIREMENTS.md#libp2p-modules-implementations). Below is a breakdown of the modules we have developed, are developing, and may develop in the future.
+
+> Legend: :green_apple: Done   :lemon: In Progress   :tomato: Missing   :chestnut: Not planned
+
+| libp2p Node  |    Status     |
+| ------------ | :-----------: |
+| **`libp2p`** | :green_apple: |
+
+| Identify Protocol | Status  |
+| ----------------- | :-----: |
+| **`Identify`**    | :lemon: |
+
+| Transport Protocols |    Status     |
+| ------------------- | :-----------: |
+| **`TCP`**           | :green_apple: |
+| **`UDP`**           |   :tomato:    |
+| **`WebSockets`**    |  :chestnut:   |
+| **`UTP`**           |  :chestnut:   |
+| **`WebRTC`**        |  :chestnut:   |
+| **`SCTP`**          |  :chestnut:   |
+| **`Tor`**           |  :chestnut:   |
+| **`i2p`**           |  :chestnut:   |
+| **`cjdns`**         |  :chestnut:   |
+| **`Bluetooth LE`**  |  :chestnut:   |
+| **`Audio TP`**      |  :chestnut:   |
+| **`Zerotier`**      |  :chestnut:   |
+| **`QUIC`**          |  :chestnut:   |
+
+| Stream Muxers    |    Status     |
+| ---------------- | :-----------: |
+| **`multiplex`**  | :green_apple: |
+| **`yamux`**      |   :tomato:    |
+| **`benchmarks`** |  :chestnut:   |
+| **`muxado`**     |  :chestnut:   |
+| **`spdystream`** |  :chestnut:   |
+| **`spdy`**       |  :chestnut:   |
+| **`http2`**      |  :chestnut:   |
+| **`QUIC`**       |  :chestnut:   |
+
+| Protocol Muxers   |    Status     |
+| ----------------- | :-----------: |
+| **`multiselect`** | :green_apple: |
+
+| Switch (Swarm)     |    Status     |
+| ------------------ | :-----------: |
+| **`Switch`**       | :green_apple: |
+| **`Dialer stack`** | :green_apple: |
+
+| Peer Discovery       |   Status   |
+| -------------------- | :--------: |
+| **`bootstrap list`** |  :tomato:  |
+| **`Kademlia DHT`**   | :chestnut: |
+| **`mDNS`**           | :chestnut: |
+| **`PEX`**            | :chestnut: |
+| **`DNS`**            | :chestnut: |
+
+| Content Routing    |    Status     |
+| ------------------ | :-----------: |
+| **`Kademlia DHT`** |  :chestnut:   |
+| **`floodsub`**     | :green_apple: |
+| **`gossipsub`**    | :green_apple: |
+| **`PHT`**          |  :chestnut:   |
+
+| Peer Routing       |    Status     |
+| ------------------ | :-----------: |
+| **`Kademlia DHT`** |  :chestnut:   |
+| **`floodsub`**     | :green_apple: |
+| **`gossipsub`**    | :green_apple: |
+| **`PHT`**          |  :chestnut:   |
+
+| NAT Traversal            |   Status   |
+| ------------------------ | :--------: |
+| **`nat-pmp`**            | :chestnut: |
+| **`upnp`**               | :chestnut: |
+| **`ext addr discovery`** | :chestnut: |
+| **`STUN-like`**          | :chestnut: |
+| **`line-switch relay`**  | :chestnut: |
+| **`pkt-switch relay`**   | :chestnut: |
+
+| Exchange         |   Status   |
+| ---------------- | :--------: |
+| **`HTTP`**       | :chestnut: |
+| **`Bitswap`**    | :chestnut: |
+| **`Bittorrent`** | :chestnut: |
+
+| Consensus      |   Status   |
+| -------------- | :--------: |
+| **`Paxos`**    | :chestnut: |
+| **`Raft`**     | :chestnut: |
+| **`PBTF`**     | :chestnut: |
+| **`Nakamoto`** | :chestnut: |
+
+## Explanation of Basic Two Node Communication
+
+### Core Concepts
+
+_(non-normative, useful for team notes, not a reference)_
+
+Several components of the libp2p stack take part when establishing a connection between two nodes:
+
+1. **Host**: a node in the libp2p network.
+1. **Connection**: the layer 3 connection between two nodes in a libp2p network.
+1. **Transport**: the component that creates a _Connection_, e.g. TCP, UDP, QUIC, etc.
+1. **Streams**: an abstraction on top of a _Connection_ representing parallel conversations about different matters, each of which is identified by a protocol ID. Multiple streams are layered on top of a _Connection_ via the _Multiplexer_.
+1. **Multiplexer**: a component that is responsible for wrapping messages sent on a stream with an envelope that identifies the stream they pertain to, normally via an ID. The multiplexer on the other unwraps the message and routes it internally based on the stream identification.
+1. **Secure channel**: optionally establishes a secure, encrypted, and authenticated channel over the _Connection_.
+1. **Upgrader**: a component that takes a raw layer 3 connection returned by the _Transport_, and performs the security and multiplexing negotiation to set up a secure, multiplexed channel on top of which _Streams_ can be opened.
+
+### Communication between two hosts X and Y
+
+_(non-normative, useful for team notes, not a reference)_
+
+**Initiate the connection**: A host is simply a node in the libp2p network that is able to communicate with other nodes in the network. In order for X and Y to communicate with one another, one of the hosts must initiate the connection.  Let's say that X is going to initiate the connection. X will first open a connection to Y. This connection is where all of the actual communication will take place.
+
+**Communication over one connection with multiple protocols**: X and Y can communicate over the same connection using different protocols and the multiplexer will appropriately route messages for a given protocol to a particular handler function for that protocol, which allows for each host to handle different protocols with separate functions. Furthermore, we can use multiple streams for a given protocol that allow for the same protocol and same underlying connection to be used for communication about separate topics between nodes X and Y.
+
+**Why use multiple streams?**: The purpose of using the same connection for multiple streams to communicate over is to avoid the overhead of having multiple connections between X and Y. In order for X and Y to differentiate between messages on different streams and different protocols, a multiplexer is used to encode the messages when a message will be sent and decode a message when a message is received. The multiplexer encodes the message by adding a header to the beginning of any message to be sent that contains the stream id (along with some other info). Then, the message is sent across the raw connection and the receiving host will use its multiplexer to decode the message, i.e. determine which stream id the message should be routed to.

libp2p-0.2.0/README.md

@@ -0,0 +1,149 @@
+# py-libp2p
+
+[![Join the chat at https://gitter.im/py-libp2p/Lobby](https://badges.gitter.im/py-libp2p/Lobby.png)](https://gitter.im/py-libp2p/Lobby)
+[![Build Status](https://circleci.com/gh/libp2p/py-libp2p.svg?style=shield)](https://circleci.com/gh/libp2p/py-libp2p)
+[![PyPI version](https://badge.fury.io/py/libp2p.svg)](https://badge.fury.io/py/libp2p)
+[![Python versions](https://img.shields.io/pypi/pyversions/libp2p.svg)](https://pypi.python.org/pypi/libp2p)
+[![Docs build](https://readthedocs.org/projects/py-libp2p/badge/?version=latest)](http://py-libp2p.readthedocs.io/en/latest/?badge=latest)
+[![Freenode](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg)](https://webchat.freenode.net/?channels=%23libp2p)
+[![Matrix](https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg)](https://riot.permaweb.io/#/room/#libp2p:permaweb.io)
+[![Discord](https://img.shields.io/discord/475789330380488707?color=blueviolet&label=discord)](https://discord.gg/66KBrm2)
+
+<h1 align="center">
+  <a href="https://libp2p.io/"><img width="250" src="https://github.com/libp2p/py-libp2p/blob/main/assets/py-libp2p-logo.png?raw=true" alt="py-libp2p hex logo" /></a>
+</h1>
+
+## WARNING
+
+py-libp2p is an experimental and work-in-progress repo under development. We do not yet recommend using py-libp2p in production environments.
+Right now, `tests_interop` are turned off for CI, and a number of `tests` are failing. WIP.
+
+The Python implementation of the libp2p networking stack
+
+Read more in the [documentation on ReadTheDocs](https://py-libp2p.readthedocs.io/). [View the release notes](https://py-libp2p.readthedocs.io/en/latest/release_notes.html).
+
+## Maintainers
+
+Currently maintained by [@pacrob](https://github.com/pacrob) and [@dhuseby](https://github.com/dhuseby), looking for assistance!
+
+Note that tests/core/test_libp2p/test_libp2p.py contains an end-to-end messaging test between two libp2p hosts, which is the bulk of our proof of concept.
+
+## Feature Breakdown
+
+py-libp2p aims for conformity with [the standard libp2p modules](https://github.com/libp2p/libp2p/blob/master/REQUIREMENTS.md#libp2p-modules-implementations). Below is a breakdown of the modules we have developed, are developing, and may develop in the future.
+
+> Legend: :green_apple: Done   :lemon: In Progress   :tomato: Missing   :chestnut: Not planned
+
+| libp2p Node  |    Status     |
+| ------------ | :-----------: |
+| **`libp2p`** | :green_apple: |
+
+| Identify Protocol | Status  |
+| ----------------- | :-----: |
+| **`Identify`**    | :lemon: |
+
+| Transport Protocols |    Status     |
+| ------------------- | :-----------: |
+| **`TCP`**           | :green_apple: |
+| **`UDP`**           |   :tomato:    |
+| **`WebSockets`**    |  :chestnut:   |
+| **`UTP`**           |  :chestnut:   |
+| **`WebRTC`**        |  :chestnut:   |
+| **`SCTP`**          |  :chestnut:   |
+| **`Tor`**           |  :chestnut:   |
+| **`i2p`**           |  :chestnut:   |
+| **`cjdns`**         |  :chestnut:   |
+| **`Bluetooth LE`**  |  :chestnut:   |
+| **`Audio TP`**      |  :chestnut:   |
+| **`Zerotier`**      |  :chestnut:   |
+| **`QUIC`**          |  :chestnut:   |
+
+| Stream Muxers    |    Status     |
+| ---------------- | :-----------: |
+| **`multiplex`**  | :green_apple: |
+| **`yamux`**      |   :tomato:    |
+| **`benchmarks`** |  :chestnut:   |
+| **`muxado`**     |  :chestnut:   |
+| **`spdystream`** |  :chestnut:   |
+| **`spdy`**       |  :chestnut:   |
+| **`http2`**      |  :chestnut:   |
+| **`QUIC`**       |  :chestnut:   |
+
+| Protocol Muxers   |    Status     |
+| ----------------- | :-----------: |
+| **`multiselect`** | :green_apple: |
+
+| Switch (Swarm)     |    Status     |
+| ------------------ | :-----------: |
+| **`Switch`**       | :green_apple: |
+| **`Dialer stack`** | :green_apple: |
+
+| Peer Discovery       |   Status   |
+| -------------------- | :--------: |
+| **`bootstrap list`** |  :tomato:  |
+| **`Kademlia DHT`**   | :chestnut: |
+| **`mDNS`**           | :chestnut: |
+| **`PEX`**            | :chestnut: |
+| **`DNS`**            | :chestnut: |
+
+| Content Routing    |    Status     |
+| ------------------ | :-----------: |
+| **`Kademlia DHT`** |  :chestnut:   |
+| **`floodsub`**     | :green_apple: |
+| **`gossipsub`**    | :green_apple: |
+| **`PHT`**          |  :chestnut:   |
+
+| Peer Routing       |    Status     |
+| ------------------ | :-----------: |
+| **`Kademlia DHT`** |  :chestnut:   |
+| **`floodsub`**     | :green_apple: |
+| **`gossipsub`**    | :green_apple: |
+| **`PHT`**          |  :chestnut:   |
+
+| NAT Traversal            |   Status   |
+| ------------------------ | :--------: |
+| **`nat-pmp`**            | :chestnut: |
+| **`upnp`**               | :chestnut: |
+| **`ext addr discovery`** | :chestnut: |
+| **`STUN-like`**          | :chestnut: |
+| **`line-switch relay`**  | :chestnut: |
+| **`pkt-switch relay`**   | :chestnut: |
+
+| Exchange         |   Status   |
+| ---------------- | :--------: |
+| **`HTTP`**       | :chestnut: |
+| **`Bitswap`**    | :chestnut: |
+| **`Bittorrent`** | :chestnut: |
+
+| Consensus      |   Status   |
+| -------------- | :--------: |
+| **`Paxos`**    | :chestnut: |
+| **`Raft`**     | :chestnut: |
+| **`PBTF`**     | :chestnut: |
+| **`Nakamoto`** | :chestnut: |
+
+## Explanation of Basic Two Node Communication
+
+### Core Concepts
+
+_(non-normative, useful for team notes, not a reference)_
+
+Several components of the libp2p stack take part when establishing a connection between two nodes:
+
+1. **Host**: a node in the libp2p network.
+1. **Connection**: the layer 3 connection between two nodes in a libp2p network.
+1. **Transport**: the component that creates a _Connection_, e.g. TCP, UDP, QUIC, etc.
+1. **Streams**: an abstraction on top of a _Connection_ representing parallel conversations about different matters, each of which is identified by a protocol ID. Multiple streams are layered on top of a _Connection_ via the _Multiplexer_.
+1. **Multiplexer**: a component that is responsible for wrapping messages sent on a stream with an envelope that identifies the stream they pertain to, normally via an ID. The multiplexer on the other unwraps the message and routes it internally based on the stream identification.
+1. **Secure channel**: optionally establishes a secure, encrypted, and authenticated channel over the _Connection_.
+1. **Upgrader**: a component that takes a raw layer 3 connection returned by the _Transport_, and performs the security and multiplexing negotiation to set up a secure, multiplexed channel on top of which _Streams_ can be opened.
+
+### Communication between two hosts X and Y
+
+_(non-normative, useful for team notes, not a reference)_
+
+**Initiate the connection**: A host is simply a node in the libp2p network that is able to communicate with other nodes in the network. In order for X and Y to communicate with one another, one of the hosts must initiate the connection.  Let's say that X is going to initiate the connection. X will first open a connection to Y. This connection is where all of the actual communication will take place.
+
+**Communication over one connection with multiple protocols**: X and Y can communicate over the same connection using different protocols and the multiplexer will appropriately route messages for a given protocol to a particular handler function for that protocol, which allows for each host to handle different protocols with separate functions. Furthermore, we can use multiple streams for a given protocol that allow for the same protocol and same underlying connection to be used for communication about separate topics between nodes X and Y.
+
+**Why use multiple streams?**: The purpose of using the same connection for multiple streams to communicate over is to avoid the overhead of having multiple connections between X and Y. In order for X and Y to differentiate between messages on different streams and different protocols, a multiplexer is used to encode the messages when a message will be sent and decode a message when a message is received. The multiplexer encodes the message by adding a header to the beginning of any message to be sent that contains the stream id (along with some other info). Then, the message is sent across the raw connection and the receiving host will use its multiplexer to decode the message, i.e. determine which stream id the message should be routed to.

libp2p-0.2.0/examples/chat/chat.py

@@ -0,0 +1,111 @@
+import argparse
+import sys
+
+import multiaddr
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.network.stream.net_stream_interface import (
+    INetStream,
+)
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+from libp2p.typing import (
+    TProtocol,
+)
+
+PROTOCOL_ID = TProtocol("/chat/1.0.0")
+MAX_READ_LEN = 2**32 - 1
+
+
+async def read_data(stream: INetStream) -> None:
+    while True:
+        read_bytes = await stream.read(MAX_READ_LEN)
+        if read_bytes is not None:
+            read_string = read_bytes.decode()
+            if read_string != "\n":
+                # Green console colour: 	\x1b[32m
+                # Reset console colour: 	\x1b[0m
+                print("\x1b[32m %s\x1b[0m " % read_string, end="")
+
+
+async def write_data(stream: INetStream) -> None:
+    async_f = trio.wrap_file(sys.stdin)
+    while True:
+        line = await async_f.readline()
+        await stream.write(line.encode())
+
+
+async def run(port: int, destination: str) -> None:
+    localhost_ip = "127.0.0.1"
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+    host = new_host()
+    async with host.run(listen_addrs=[listen_addr]), trio.open_nursery() as nursery:
+        if not destination:  # its the server
+
+            async def stream_handler(stream: INetStream) -> None:
+                nursery.start_soon(read_data, stream)
+                nursery.start_soon(write_data, stream)
+
+            host.set_stream_handler(PROTOCOL_ID, stream_handler)
+
+            print(
+                "Run this from the same folder in another console:\n\n"
+                f"python chat.py -p {int(port) + 1} "
+                f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
+            )
+            print("Waiting for incoming connection...")
+
+        else:  # its the client
+            maddr = multiaddr.Multiaddr(destination)
+            info = info_from_p2p_addr(maddr)
+            # Associate the peer with local ip address
+            await host.connect(info)
+            # Start a stream with the destination.
+            # Multiaddress of the destination peer is fetched from the peerstore
+            # using 'peerId'.
+            stream = await host.new_stream(info.peer_id, [PROTOCOL_ID])
+
+            nursery.start_soon(read_data, stream)
+            nursery.start_soon(write_data, stream)
+            print(f"Connected to peer {info.addrs[0]}")
+
+        await trio.sleep_forever()
+
+
+def main() -> None:
+    description = """
+    This program demonstrates a simple p2p chat application using libp2p.
+    To use it, first run 'python ./chat -p <PORT>', where <PORT> is the port number.
+    Then, run another host with 'python ./chat -p <ANOTHER_PORT> -d <DESTINATION>',
+    where <DESTINATION> is the multiaddress of the previous listener host.
+    """
+    example_maddr = (
+        "/ip4/127.0.0.1/tcp/8000/p2p/QmQn4SwGkDZKkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
+    )
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "-p", "--port", default=8000, type=int, help="source port number"
+    )
+    parser.add_argument(
+        "-d",
+        "--destination",
+        type=str,
+        help=f"destination multiaddr string, e.g. {example_maddr}",
+    )
+    args = parser.parse_args()
+
+    if not args.port:
+        raise RuntimeError("was not able to determine a local port")
+
+    try:
+        trio.run(run, *(args.port, args.destination))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

libp2p-0.2.0/examples/echo/echo.py

@@ -0,0 +1,124 @@
+import argparse
+
+import multiaddr
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.crypto.secp256k1 import (
+    create_new_key_pair,
+)
+from libp2p.network.stream.net_stream_interface import (
+    INetStream,
+)
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+from libp2p.typing import (
+    TProtocol,
+)
+
+PROTOCOL_ID = TProtocol("/echo/1.0.0")
+
+
+async def _echo_stream_handler(stream: INetStream) -> None:
+    # Wait until EOF
+    msg = await stream.read()
+    await stream.write(msg)
+    await stream.close()
+
+
+async def run(port: int, destination: str, seed: int = None) -> None:
+    localhost_ip = "127.0.0.1"
+    listen_addr = multiaddr.Multiaddr(f"/ip4/0.0.0.0/tcp/{port}")
+
+    if seed:
+        import random
+
+        random.seed(seed)
+        secret_number = random.getrandbits(32 * 8)
+        secret = secret_number.to_bytes(length=32, byteorder="big")
+    else:
+        import secrets
+
+        secret = secrets.token_bytes(32)
+
+    host = new_host(key_pair=create_new_key_pair(secret))
+    async with host.run(listen_addrs=[listen_addr]):
+        print(f"I am {host.get_id().to_string()}")
+
+        if not destination:  # its the server
+            host.set_stream_handler(PROTOCOL_ID, _echo_stream_handler)
+
+            print(
+                "Run this from the same folder in another console:\n\n"
+                f"python echo.py -p {int(port) + 1} "
+                f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
+            )
+            print("Waiting for incoming connections...")
+            await trio.sleep_forever()
+
+        else:  # its the client
+            maddr = multiaddr.Multiaddr(destination)
+            info = info_from_p2p_addr(maddr)
+            # Associate the peer with local ip address
+            await host.connect(info)
+
+            # Start a stream with the destination.
+            # Multiaddress of the destination peer is fetched from the peerstore
+            # using 'peerId'.
+            stream = await host.new_stream(info.peer_id, [PROTOCOL_ID])
+
+            msg = b"hi, there!\n"
+
+            await stream.write(msg)
+            # Notify the other side about EOF
+            await stream.close()
+            response = await stream.read()
+
+            print(f"Sent: {msg.decode('utf-8')}")
+            print(f"Got: {response.decode('utf-8')}")
+
+
+def main() -> None:
+    description = """
+    This program demonstrates a simple echo protocol where a peer listens for
+    connections and copies back any input received on a stream.
+
+    To use it, first run 'python ./echo -p <PORT>', where <PORT> is the port number.
+    Then, run another host with 'python ./chat -p <ANOTHER_PORT> -d <DESTINATION>',
+    where <DESTINATION> is the multiaddress of the previous listener host.
+    """
+    example_maddr = (
+        "/ip4/127.0.0.1/tcp/8000/p2p/QmQn4SwGkDZKkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
+    )
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "-p", "--port", default=8000, type=int, help="source port number"
+    )
+    parser.add_argument(
+        "-d",
+        "--destination",
+        type=str,
+        help=f"destination multiaddr string, e.g. {example_maddr}",
+    )
+    parser.add_argument(
+        "-s",
+        "--seed",
+        type=int,
+        help="provide a seed to the random number generator (e.g. to fix peer IDs across runs)",  # noqa: E501
+    )
+    args = parser.parse_args()
+
+    if not args.port:
+        raise RuntimeError("was not able to determine a local port")
+
+    try:
+        trio.run(run, args.port, args.destination, args.seed)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()