From 06df5997985c830cbfc2624c89baea941ff5e323 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Thu, 1 Sep 2022 05:22:13 -0400 Subject: [PATCH 1/7] update intro and merge what is libp2p + edits --- content/introduction/_index.md | 181 +++++++++++++++++++++---- content/introduction/what-is-libp2p.md | 88 ------------ 2 files changed, 154 insertions(+), 115 deletions(-) delete mode 100644 content/introduction/what-is-libp2p.md diff --git a/content/introduction/_index.md b/content/introduction/_index.md index 7e6a18ba..de49e0bc 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -1,60 +1,187 @@ --- -title: Introduction +title: "Introduction" weight: 1 pre: ' ' --- -Welcome to the libp2p documentation portal! Whether you’re just learning how to build peer-to-peer systems with libp2p, want to dive into peer-to-peer concepts and solutions, or are looking for detailed reference information, this is the place to start. +Welcome to the official libp2p documentation hub! -## Overview +Whether you’re just starting to dive into peer-to-peer concepts and +solutions, learning how to build peer-to-peer systems with libp2p, or +are looking for detailed reference information, this is the place to +start. -Head over to [What is libp2p?](/introduction/what-is-libp2p/) for an introduction to the basics of libp2p and an overview of the problems it addresses. +## What is libp2p? +libp2p is a modular system of *protocols*, *specifications* and *libraries* +that enable the development of peer-to-peer network applications. -## Tutorials +**The networking protocol of web3** -If you want to dive in, check out our collection of [tutorials](/tutorials/), which will help guide you through your explorations of libp2p. +Because of libp2p's peer-to-peer and distributed architecture, most of the +needs and considerations that the current web was built on no longer apply. +Moving from a location-addressed system to a peer-to-peer, content-addressed +system presents many challenges. The internet, such as it is, with firewalls +and NATs, was designed to [securely] provide data by relying on trust assumptions, +Clients must trust the service providers they connect to and the data they provide, +despite servers needing to verify their identity using certificate authorities. -## Examples +## Peer-to-peer basics -If you want to get a feel for what's possible with libp2p, or just want to see some idiomatic usage, check out the [examples](/examples/). Each libp2p implementation maintains a set of working example projects that can illustrate key concepts and use cases. +Let's start with what a peer-to-peer network application is: -## Reference +A [peer-to-peer network][definition_p2p] is one in which the participants +(referred to as [peers][definition_peer]) communicate directly with one another +on a relative "equal footing". This does not mean that all peers are identical +as some may have different roles in the overall network. However, one of the +defining characteristics of a peer-to-peer network is that the network does not +require a privileged set of "servers" which behave completely differently from +their "clients", as is the case in the predominant +[client / server model][definition_client_server]. -### Specifications & Planning +Because the definition of peer-to-peer networking is quite broad, many different +kinds of systems have been built that all fall under the umbrella of "peer-to-peer". +The most culturally prominent examples are likely file-sharing networks like BitTorrent, +and, more recently, the proliferation of blockchain networks that communicate in a +peer-to-peer fashion. -While libp2p has several implementations, it is fundamentally a set of protocols for peer identity, discover, routing, transport and more. +### What problems can libp2p solve? -See the [specifications section](/reference/specs/) for details. +While peer-to-peer networks have many advantages over the client-server model, +there are unique challenges that require careful thought and practice to overcome. -### Implementations +libp2p lets all users preserve their network identity, overcome network censorship, +and communicate over different transfer protocols. -At the core of libp2p is a set of [specifications](/reference/specs/), which together form the definition for what libp2p is in the abstract and what makes a "correct" libp2p implementation. Today, implementations of libp2p exist in several languages, with varying degrees of completeness. The most complete implementations are in [Go](/reference/go/), [JavaScript](/reference/js/), and [Rust](https://github.com/libp2p/rust-libp2p). +In overcoming these challenges while building [IPFS](https://ipfs.io), +we took care to build our solutions in a modular, composable way into what is +now libp2p. Although libp2p grew out of IPFS, it is not dependent on IPFS, and +today, [many projects][built_with_libp2p] use libp2p as their networking layer. -In addition to the implementations above, the libp2p community is actively working on implementations in [python](https://github.com/libp2p/py-libp2p) and [the JVM via Kotlin](https://github.com/web3j/libp2p). Please check the project pages for each implementation to see its status and current state of completeness. +Together, we can leverage our collective experience and solve these foundational +problems in a way that benefits an entire ecosystem of developers and a world of users. +Here, we'll briefly outline the main problem areas that libp2p attempts to address. +This is an ever-growing space, so don't be surprised if things change over time. +If you notice something missing or have other ideas for improving this documentation, +please [reach out to let us know][help_improve_docs]. -## Community +### Data transmission -Get in touch with other members of the libp2p community who are building tools and applications with libp2p! You can ask questions, discuss new ideas, or get support for problems at [libp2p discussion forums](https://discuss.libp2p.io/), but you can also [hop on IRC](/community/irc/) for a quick chat. +The transport layer is at the foundation of libp2p, which is responsible for +the actual transmission and receipt of data from one peer to another. There are many +ways to send data across networks in use today, with more in development and still more yet +to be designed. -See the other links in the community section for more information about meetings, events, apps people are building, and more. +libp2p provides a simple [interface](https://github.com/libp2p/js-libp2p-interfaces) +that can be adapted to support existing and future protocols, allowing libp2p applications +to operate in many different runtime and networking environments. -Information about contributing to libp2p and about other software projects in the community are also hosted here. +### Peer identity +Knowing who you're talking to is key to secure and reliable communication in a world +with billions of networked devices. libp2p uses +[public key cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography) +as the basis of peer identity, which serves two complementary purposes. -### Get Involved +1. It gives each peer a globally unique "name", in the form of a + [PeerId][definition_peerid]. +2. The `PeerId` allows anyone to retrieve the public key for the identified + peer, which enables secure communication between peers. -libp2p is an open-source community project. While [Protocol Labs](https://protocol.ai) is able to sponsor some of the work around it, much of the design, code, and effort is contributed by volunteers and community members like you. If you’re interested in helping improve libp2p, check the [contributing](/contributing/) guide to get started. +### Secure communication -If you are diving in to contribute new code, make sure you check both the [contribution guidelines](https://github.com/libp2p/community/blob/master/CONTRIBUTE.md) and the style guide for your language ([Go](https://github.com/ipfs/community/blob/master/CONTRIBUTING_GO.md), [JavaScript](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md)). +We must be able to send and receive data between peers securely, +where we can trust the [identity](#peer-identity) of the peer we're +communicating with no third party can read our conversation or alter it in flight. +libp2p supports *upgrading* a connection provided by a [transport protocol](#transport) +into a securely encrypted channel. The process is flexible and supports multiple +methods of encrypting communication. -### Related Projects +libp2p currently supports [TLS 1.3](https://www.ietf.org/blog/tls13/) and +[Noise](https://noiseprotocol.org/), though not every language implementation of +libp2p supports both of these. -libp2p began as part of the [IPFS](https://ipfs.io) project, and is still an essential component of IPFS. As such, libp2p composes well with the abstractions and tools provided by other projects in the IPFS "family". Check their individual sites for specific information and references: +> (Older versions of libp2p may support a +> [deprecated](https://blog.ipfs.io/2020-08-07-deprecating-secio/) protocol called SECIO; +> all projects should switch to TLS 1.3 or Noise instead.) -- [IPFS](https://libp2p.io) is the InterPlanetary File System, which uses libp2p as its networking layer. +### Peer routing + +When you want to send a message to another peer, you need two key pieces +of information: their [PeerId][definition_peerid], and a way to locate them +on the network to open a connection. + +There are many cases where we only have the `PeerId` for the peer we want to +contact, and we need a way to discover their network address. Peer routing is +the process of discovering peer addresses by leveraging the knowledge of other +peers. + +In a peer routing system, a peer can either give us the address we need if they +have it, or else send our inquiry to another peer who's more likely to have the +answer. As we contact more and more peers, we not only increase our chances of +finding the peer we're looking for, we build a more complete view of the network +in our own routing tables, which enables us to answer routing queries from others. + +The current stable implementation of peer routing in libp2p uses a +[distributed hash table][definition_dht] to iteratively route requests closer +to the desired `PeerId` using the [Kademlia][wiki_kademlia] routing algorithm. + +### Content discovery + +In some systems, we care less about who we're speaking with than what they can offer us. +For example, we may want some specific piece of data, but we don't care who we get it from +since we can verify its integrity. + +libp2p provides a [content routing interface][interface_content_routing] for this +purpose, with the primary stable implementation using the same +[Kademlia][wiki_kademlia]-based DHT as used in peer routing. + +### Peer messaging + +Sending messages to other peers is at the heart of most peer-to-peer systems, +and pubsub (short for publish/subscribe) is an instrumental pattern for sending +a message to groups of interested receivers. + +libp2p defines a [pubsub interface][interface_pubsub] for sending messages to all +peers subscribed to a given "topic". The interface currently has two stable +implementations; `floodsub` uses a very simple but inefficient "network flooding" +strategy, and [gossipsub](https://github.com/libp2p/specs/tree/master/pubsub/gossipsub) +defines an extensible gossip protocol. There is also active development in progress on +[episub](https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/episub.md), an +extended `gossipsub` that is optimized for single source multicast and scenarios with a +few fixed sources broadcasting to a large number of clients in a topic. + +Head over to [What is libp2p?](/introduction/what-is-libp2p/) for an introduction to +the basics of libp2p and an overview of the problems it addresses. + +## Related projects + +libp2p began as part of the [IPFS](https://ipfs.io) project and is still an +essential component of IPFS. As such, libp2p composes well with the abstractions +and tools provided by other projects in the IPFS "family". Check their sites for +specific information and references: + +- [IPFS](https://libp2p.io) is the InterPlanetary File System, which uses libp2p as + its networking layer. - [Multiformats](https://multiformats.io) is a variety of *self-describing* data formats. -- [IPLD](https://ipld.io) is a set of tools for describing links between content-addressed data, like IPFS files, Git commits, or Ethereum blocks. -- [The Permissive License Stack](https://protocol.ai/blog/announcing-the-permissive-license-stack) is a licensing strategy for software development that embraces open-source values. +- [IPLD](https://ipld.io) is a set of tools for describing links between content-addressed + data, like IPFS files, Git commits, or Ethereum blocks. +- [The Permissive License Stack](https://protocol.ai/blog/announcing-the-permissive-license-stack) + is a licensing strategy for software development that embraces open-source values. + +[glossary]: {{< ref "/reference/glossary.md" >}} +[definition_dht]: {{< ref "/reference/glossary.md#dht" >}} +[definition_p2p]: {{< ref "/reference/glossary.md#p2p" >}} +[definition_peer]: {{< ref "/reference/glossary.md#peer" >}} +[definition_peerid]: {{< ref "/reference/glossary.md#peerid" >}} +[definition_secio]: {{< ref "/reference/glossary.md#secio" >}} +[definition_muiltiaddress]: {{< ref "/reference/glossary.md#multiaddr" >}} +[definition_client_server]: {{< ref "/reference/glossary.md#client-server" >}} + +[interface_content_routing]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/content-routing +[interface_pubsub]: https://github.com/libp2p/specs/tree/master/pubsub +[built_with_libp2p]: https://discuss.libp2p.io/c/ecosystem-community +[help_improve_docs]: https://github.com/libp2p/docs/issues +[wiki_kademlia]: https://en.wikipedia.org/wiki/Kademlia diff --git a/content/introduction/what-is-libp2p.md b/content/introduction/what-is-libp2p.md deleted file mode 100644 index 337fb346..00000000 --- a/content/introduction/what-is-libp2p.md +++ /dev/null @@ -1,88 +0,0 @@ ---- -title: "What is libp2p?" -weight: 2 ---- - -Moving from a location-addressed system to a peer-to-peer, content-addressed system presents many challenges. The internet as it is, with firewalls and NATs, was designed to [securely] provide data. There are also trust assumptions, as clients must trust the central servers they connect to and the data they provide, despite these servers verifying their identity using certificate authorities. - -libp2p is a modular system of *protocols*, *specifications* and *libraries* that enable the development of peer-to-peer network applications. Because of the way libp2p's architecture, most of the needs and considerations that the current web was built on no longer apply. - -See the [Glossary][glossary] to understand the basic building blocks for understanding libp2p. - - -## Peer-to-peer basics - - Let's start with what a _peer-to-peer network application_ is: - -_A [peer-to-peer network][definition_p2p] is one in which the participants (referred to as [peers][definition_peer]) communicate directly with one another on a relative "equal footing". This does not mean that all peers are identical; some may have different roles in the overall network. However, one of the defining characteristics of a peer-to-peer network is that the network does not require a privileged set of "servers" which behave completely differently from their "clients", as is the case in the predominant [client / server model][definition_client_server]._ - -Because the definition of peer-to-peer networking is quite broad, many different kinds of systems have been built that all fall under the umbrella of "peer-to-peer". The most culturally prominent examples are likely the file sharing networks like bittorrent, and, more recently, the proliferation of blockchain networks that communicate in a peer-to-peer fashion. - -## What problems can libp2p solve? - -While peer-to-peer networks have many advantages over the client-server model, there are unique challenges that require careful thought and practice to overcome. - -libp2p lets you preserve your network identity, overcome network censorship, and communicate over different transfer protocols. - -In our process of overcoming these challenges while building [IPFS](https://ipfs.io), we took care to build our solutions in a modular, composable way, into what is now libp2p. Although libp2p grew out of IPFS, it does not dependant on IPFS, and today, [many projects][built_with_libp2p] use libp2p as their networking layer. Together, we can leverage our collective experience and solve these foundational problems in a way that benefits an entire ecosystem of developers and a world of users. - - - -Here we'll briefly outline the main problem areas that are addressed by libp2p. This is an ever-growing space, so don't be surprised if things change over time. If you notice something missing or have other ideas for improving this documentation, please [reach out to let us know][help_improve_docs]. - - - -### Transport - -At the foundation of libp2p is the transport layer, which is responsible for the actual transmission and receipt of data from one peer to another. There are many ways to send data across networks in use today, with more in development and still more yet to be designed. libp2p provides a simple [interface](https://github.com/libp2p/js-libp2p-interfaces) that can be adapted to support existing and future protocols, allowing libp2p applications to operate in many different runtime and networking environments. - -### Identity - -In a world with billions of networked devices, knowing who you're talking to is key to secure and reliable communication. libp2p uses [public key cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography) as the basis of peer identity, which serves two complementary purposes. First, it gives each peer a globally unique "name", in the form of a [PeerId][definition_peerid]. Second, the `PeerId` allows anyone to retrieve the public key for the identified peer, which enables secure communication between peers. - -### Security - -It's essential that we are able to send and receive data between peers *securely*, meaning that we can trust the [identity](#identity) of the peer we're communicating with and that no third-party can read our conversation or alter it in-flight. - -libp2p supports "upgrading" a connection provided by a [transport](#transport) into a securely encrypted channel. The process is flexible, and can support multiple methods of encrypting communication. libp2p currently supports [TLS 1.3](https://www.ietf.org/blog/tls13/) and [Noise](https://noiseprotocol.org/), though not every language implementation of libp2p supports both of these. (Older versions of libp2p may support a [deprecated](https://blog.ipfs.io/2020-08-07-deprecating-secio/) protocol called SECIO; all projects should switch to TLS 1.3 or Noise instead.) - -### Peer Routing - -When you want to send a message to another peer, you need two key pieces of information: their [PeerId][definition_peerid], and a way to locate them on the network to open a connection. - -There are many cases where we only have the `PeerId` for the peer we want to contact, and we need a way to discover their network address. Peer routing is the process of discovering peer addresses by leveraging the knowledge of other peers. - -In a peer routing system, a peer can either give us the address we need if they have it, or else send our inquiry to another peer who's more likely to have the answer. As we contact more and more peers, we not only increase our chances of finding the peer we're looking for, we build a more complete view of the network in our own routing tables, which enables us to answer routing queries from others. - -The current stable implementation of peer routing in libp2p uses a [distributed hash table][definition_dht] to iteratively route requests closer to the desired `PeerId` using the [Kademlia][wiki_kademlia] routing algorithm. - - -### Content Discovery - -In some systems, we care less about who we're speaking with than we do about what they can offer us. For example, we may want some specific piece of data, but we don't care who we get it from since we're able to verify its integrity. - -libp2p provides a [content routing interface][interface_content_routing] for this purpose, with the primary stable implementation using the same [Kademlia][wiki_kademlia]-based DHT as used in peer routing. - -### Messaging / PubSub - -Sending messages to other peers is at the heart of most peer-to-peer systems, and pubsub (short for publish / subscribe) is a very useful pattern for sending a message to groups of interested receivers. - -libp2p defines a [pubsub interface][interface_pubsub] for sending messages to all peers subscribed to a given "topic". The interface currently has two stable implementations; `floodsub` uses a very simple but inefficient "network flooding" strategy, and [gossipsub](https://github.com/libp2p/specs/tree/master/pubsub/gossipsub) defines an extensible gossip protocol. There is also active development in progress on [episub](https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/episub.md), an extended `gossipsub` that is optimized for single source multicast and scenarios with a few fixed sources broadcasting to a large number of clients in a topic. - -[glossary]: {{< ref "/reference/glossary.md" >}} -[definition_dht]: {{< ref "/reference/glossary.md#dht" >}} -[definition_p2p]: {{< ref "/reference/glossary.md#p2p" >}} -[definition_peer]: {{< ref "/reference/glossary.md#peer" >}} -[definition_peerid]: {{< ref "/reference/glossary.md#peerid" >}} -[definition_secio]: {{< ref "/reference/glossary.md#secio" >}} -[definition_muiltiaddress]: {{< ref "/reference/glossary.md#multiaddr" >}} -[definition_client_server]: {{< ref "/reference/glossary.md#client-server" >}} - -[interface_content_routing]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/content-routing -[interface_pubsub]: https://github.com/libp2p/specs/tree/master/pubsub - - -[built_with_libp2p]: https://discuss.libp2p.io/c/ecosystem-community -[help_improve_docs]: https://github.com/libp2p/docs/issues - -[wiki_kademlia]: https://en.wikipedia.org/wiki/Kademlia From e6aafde579864eb8e5f382e98002b0abec755d30 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Thu, 1 Sep 2022 05:22:43 -0400 Subject: [PATCH 2/7] move community info to own section --- content/community/_index.md | 11 +++++++++++ content/concepts/_index.md | 4 ++-- content/contributing/_index.md | 5 +---- content/reference/_index.md | 19 +++++++++++++++++++ 4 files changed, 33 insertions(+), 6 deletions(-) create mode 100644 content/community/_index.md diff --git a/content/community/_index.md b/content/community/_index.md new file mode 100644 index 00000000..33ec44d6 --- /dev/null +++ b/content/community/_index.md @@ -0,0 +1,11 @@ +--- +title: "Community" +weight: 10 +pre: ' ' +--- + +Get in touch with other members of the libp2p community who are building tools and applications with libp2p! You can ask questions, discuss new ideas, or get support for problems at [libp2p discussion forums](https://discuss.libp2p.io/), but you can also [hop on IRC](/community/irc/) for a quick chat. + +See the other links in the community section for more information about meetings, events, apps people are building, and more. + +Information about contributing to libp2p and about other software projects in the community are also hosted here. diff --git a/content/concepts/_index.md b/content/concepts/_index.md index d7ae8ce7..de391551 100644 --- a/content/concepts/_index.md +++ b/content/concepts/_index.md @@ -1,6 +1,6 @@ --- -title: "Concepts" -weight: 4 +title: "Core Components" +weight: 2 pre: ' ' --- diff --git a/content/contributing/_index.md b/content/contributing/_index.md index fda1e9e6..80be193d 100644 --- a/content/contributing/_index.md +++ b/content/contributing/_index.md @@ -1,5 +1,5 @@ --- -title: Contributing +title: "Get Involved" weight: 10 pre: ' ' --- @@ -9,9 +9,7 @@ of things we need help with and how you can get started. Even if what you want to do is not listed here, we probably accept contributions for it! If you're unsure, please open a issue. - ## Areas of contribution - - [Areas of contribution](#areas-of-contribution) - [Code](#code) - [Documentation](#documentation) @@ -24,7 +22,6 @@ unsure, please open a issue. - [Protocol Design](#protocol-design) - [Research](#research) - ### Code libp2p and its sister-projects are *big,* with lots of code written in diff --git a/content/reference/_index.md b/content/reference/_index.md index 728c81d4..6143f038 100644 --- a/content/reference/_index.md +++ b/content/reference/_index.md @@ -6,4 +6,23 @@ pre: ' ' This section contains in-depth reference material, including a [glossary](/reference/glossary/) with definitions of libp2p terminology. +### Specifications & Planning + +While libp2p has several implementations, it is fundamentally a set of protocols for +peer identity, discover, routing, transport and more. + +See the [specifications section](/reference/specs/) for details. + +### Implementations + +At the core of libp2p is a set of [specifications](/reference/specs/), which together +form the definition for what libp2p is in the abstract and what makes a "correct" libp2p +implementation. Today, implementations of libp2p exist in several languages, with varying degrees +of completeness. The most complete implementations are in [Go](/reference/go/), +[JavaScript](/reference/js/), and [Rust](https://github.com/libp2p/rust-libp2p). + +In addition to the implementations above, the libp2p community is actively working on +implementations in [python](https://github.com/libp2p/py-libp2p) and [the JVM via Kotlin](https://github.com/web3j/libp2p). Please check the project pages for each implementation to see its status and current +state of completeness. + Please help make this section more complete by [filing an issue](https://github.com/libp2p/docs/issues/new). From 099c62526472a0131deeb46aec79ec39ad83405f Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Tue, 6 Sep 2022 04:52:23 -0400 Subject: [PATCH 3/7] address PR feedback --- content/introduction/_index.md | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/content/introduction/_index.md b/content/introduction/_index.md index de49e0bc..8dc89950 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -20,11 +20,11 @@ that enable the development of peer-to-peer network applications. Because of libp2p's peer-to-peer and distributed architecture, most of the needs and considerations that the current web was built on no longer apply. -Moving from a location-addressed system to a peer-to-peer, content-addressed -system presents many challenges. The internet, such as it is, with firewalls -and NATs, was designed to [securely] provide data by relying on trust assumptions, -Clients must trust the service providers they connect to and the data they provide, -despite servers needing to verify their identity using certificate authorities. +The internet, such as it is, with firewalls and NATs, was designed to [securely] +provide data by relying on trust assumptions. There are many distributed +peer-to-peer network models with different challenges and tradeoffs that try +to improve on the way we network. Libp2p aims to be a modular, general-purpose +toolkit for any peer-to-peer application. ## Peer-to-peer basics @@ -91,17 +91,18 @@ as the basis of peer identity, which serves two complementary purposes. ### Secure communication -We must be able to send and receive data between peers securely, -where we can trust the [identity](#peer-identity) of the peer we're -communicating with no third party can read our conversation or alter it in flight. +There needs to be a method to securely send and receive data between peers, +where peers are able to trust the [identity](#peer-identity) of the peer they're +communicating with while ensuring that no external entity can access or tamper with +the communication. -libp2p supports *upgrading* a connection provided by a [transport protocol](#transport) -into a securely encrypted channel. The process is flexible and supports multiple -methods of encrypting communication. +All libp2p connections are encrypted and authenticated. Some [transport protocol](#transport) +protocols are encrypted at the transport layer (e.g. QUIC). For other protocols, libp2p runs +a cryptographic handshake on top of an unencrypted connection (e.g. TCP). -libp2p currently supports [TLS 1.3](https://www.ietf.org/blog/tls13/) and -[Noise](https://noiseprotocol.org/), though not every language implementation of -libp2p supports both of these. +For secure communication channels, libp2p currently supports +[TLS 1.3](https://www.ietf.org/blog/tls13/) and [Noise](https://noiseprotocol.org/), +though not every language implementation of libp2p supports both of these. > (Older versions of libp2p may support a > [deprecated](https://blog.ipfs.io/2020-08-07-deprecating-secio/) protocol called SECIO; From f8e76cd235986711494bae88c1e2bdccee247936 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Tue, 6 Sep 2022 04:53:21 -0400 Subject: [PATCH 4/7] Apply suggestions from code review Co-authored-by: Marten Seemann --- content/introduction/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/introduction/_index.md b/content/introduction/_index.md index 8dc89950..5da08f95 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -51,7 +51,7 @@ While peer-to-peer networks have many advantages over the client-server model, there are unique challenges that require careful thought and practice to overcome. libp2p lets all users preserve their network identity, overcome network censorship, -and communicate over different transfer protocols. +and communicate over different transport protocols. In overcoming these challenges while building [IPFS](https://ipfs.io), we took care to build our solutions in a modular, composable way into what is From 78c6274ea0e47b331faa4dfd742bb40e32ea2285 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Tue, 6 Sep 2022 19:05:25 -0400 Subject: [PATCH 5/7] generalize ref to js interface to specs --- content/introduction/_index.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/content/introduction/_index.md b/content/introduction/_index.md index 5da08f95..d667b90f 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -73,7 +73,7 @@ the actual transmission and receipt of data from one peer to another. There are ways to send data across networks in use today, with more in development and still more yet to be designed. -libp2p provides a simple [interface](https://github.com/libp2p/js-libp2p-interfaces) +libp2p provides a list of specifications [specifcations](https://github.com/libp2p/specs) that can be adapted to support existing and future protocols, allowing libp2p applications to operate in many different runtime and networking environments. @@ -135,7 +135,7 @@ In some systems, we care less about who we're speaking with than what they can o For example, we may want some specific piece of data, but we don't care who we get it from since we can verify its integrity. -libp2p provides a [content routing interface][interface_content_routing] for this +libp2p provides a [content routing specification][spec_content_routing] for this purpose, with the primary stable implementation using the same [Kademlia][wiki_kademlia]-based DHT as used in peer routing. @@ -145,8 +145,8 @@ Sending messages to other peers is at the heart of most peer-to-peer systems, and pubsub (short for publish/subscribe) is an instrumental pattern for sending a message to groups of interested receivers. -libp2p defines a [pubsub interface][interface_pubsub] for sending messages to all -peers subscribed to a given "topic". The interface currently has two stable +libp2p defines a [pubsub specification][spec_pubsub] for sending messages to all +peers subscribed to a given "topic". The specification currently has two stable implementations; `floodsub` uses a very simple but inefficient "network flooding" strategy, and [gossipsub](https://github.com/libp2p/specs/tree/master/pubsub/gossipsub) defines an extensible gossip protocol. There is also active development in progress on @@ -181,8 +181,8 @@ specific information and references: [definition_muiltiaddress]: {{< ref "/reference/glossary.md#multiaddr" >}} [definition_client_server]: {{< ref "/reference/glossary.md#client-server" >}} -[interface_content_routing]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/content-routing -[interface_pubsub]: https://github.com/libp2p/specs/tree/master/pubsub +[spec_content_routing]: https://github.com/libp2p/specs/blob/master/kad-dht/README.md +[spec_pubsub]: https://github.com/libp2p/specs/blob/master/pubsub/README.md [built_with_libp2p]: https://discuss.libp2p.io/c/ecosystem-community [help_improve_docs]: https://github.com/libp2p/docs/issues [wiki_kademlia]: https://en.wikipedia.org/wiki/Kademlia From f0225606214db8f816c5b90e8e48ad2584b7a489 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Wed, 7 Sep 2022 03:13:46 -0400 Subject: [PATCH 6/7] Apply suggestions from code review Co-authored-by: Marten Seemann --- content/introduction/_index.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/introduction/_index.md b/content/introduction/_index.md index d667b90f..7ec8a40d 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -16,7 +16,7 @@ start. libp2p is a modular system of *protocols*, *specifications* and *libraries* that enable the development of peer-to-peer network applications. -**The networking protocol of web3** +**A p2p networking stack** Because of libp2p's peer-to-peer and distributed architecture, most of the needs and considerations that the current web was built on no longer apply. @@ -69,7 +69,7 @@ please [reach out to let us know][help_improve_docs]. ### Data transmission The transport layer is at the foundation of libp2p, which is responsible for -the actual transmission and receipt of data from one peer to another. There are many +transmitting and receiving bytes between two peers. There are many ways to send data across networks in use today, with more in development and still more yet to be designed. From ebacc309051555f1f149707e46674099927ad513 Mon Sep 17 00:00:00 2001 From: Danny Salman Date: Wed, 7 Sep 2022 03:17:58 -0400 Subject: [PATCH 7/7] clarify transports --- content/introduction/_index.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/content/introduction/_index.md b/content/introduction/_index.md index 7ec8a40d..d81f99c5 100644 --- a/content/introduction/_index.md +++ b/content/introduction/_index.md @@ -70,10 +70,11 @@ please [reach out to let us know][help_improve_docs]. The transport layer is at the foundation of libp2p, which is responsible for transmitting and receiving bytes between two peers. There are many -ways to send data across networks in use today, with more in development and still more yet +ways to send data across networks in use today, including TCP, QUIC, WebSocket, +WebTransport and WebRTC, with some still in development and others still yet to be designed. -libp2p provides a list of specifications [specifcations](https://github.com/libp2p/specs) +libp2p also provides a list of specifications [specifcations](https://github.com/libp2p/specs) that can be adapted to support existing and future protocols, allowing libp2p applications to operate in many different runtime and networking environments.