@libp2p/echo 0.0.0-cad9cf007

package/LICENSE

@@ -0,0 +1,4 @@
+This project is dual licensed under MIT and Apache-2.0.
+
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0

package/README.md

@@ -0,0 +1,94 @@
+# @libp2p/echo
+
+[![libp2p.io](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![Discuss](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg?style=flat-square)](https://discuss.libp2p.io)
+[![codecov](https://img.shields.io/codecov/c/github/libp2p/js-libp2p.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p)
+[![CI](https://img.shields.io/github/actions/workflow/status/libp2p/js-libp2p/main.yml?branch=main\&style=flat-square)](https://github.com/libp2p/js-libp2p/actions/workflows/main.yml?query=branch%3Amain)
+
+> Implementation of an Echo protocol
+
+# About
+
+<!--
+
+!IMPORTANT!
+
+Everything in this README between "# About" and "# Install" is automatically
+generated and will be overwritten the next time the doc generator is run.
+
+To make changes to this section, please update the @packageDocumentation section
+of src/index.js or src/index.ts
+
+To experiment with formatting, please run "npm run docs" from the root of this
+repo and examine the changes made.
+
+-->
+
+An implementation of a simple Echo protocol.
+
+Any data received by the receiver will be sent back to the sender.
+
+## Example
+
+```TypeScript
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { echo } from '@libp2p/echo'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { createLibp2p } from 'libp2p'
+
+const receiver = await createLibp2p({
+  addresses: {
+    listen: ['/ip4/0.0.0.0/tcp/0']
+  },
+  connectionEncryption: [noise()],
+  streamMuxers: [yamux()],
+  services: {
+    echo: echo()
+  }
+})
+
+const sender = await createLibp2p({
+  addresses: {
+    listen: ['/ip4/0.0.0.0/tcp/0']
+  },
+  connectionEncryption: [noise()],
+  streamMuxers: [yamux()],
+  services: {
+    echo: echo()
+  }
+})
+
+const stream = await sender.dialProtocol(receiver.getMultiaddrs(), sender.services.echo.protocol)
+
+// write/read stream
+```
+
+# Install
+
+```console
+$ npm i @libp2p/echo
+```
+
+## Browser `<script>` tag
+
+Loading this module through a script tag will make it's exports available as `Libp2pEcho` in the global namespace.
+
+```html
+<script src="https://unpkg.com/@libp2p/echo/dist/index.min.js"></script>
+```
+
+# API Docs
+
+- <https://libp2p.github.io/js-libp2p/modules/_libp2p_echo.html>
+
+# License
+
+Licensed under either of
+
+- Apache 2.0, ([LICENSE-APACHE](LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT ([LICENSE-MIT](LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
+
+# Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

package/dist/index.min.js

@@ -0,0 +1,3 @@
+(function (root, factory) {(typeof module === 'object' && module.exports) ? module.exports = factory() : root.Libp2PEcho = factory()}(typeof self !== 'undefined' ? self : this, function () {
+"use strict";var Libp2PEcho=(()=>{var x=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var V=(r,e)=>{for(var t in e)x(r,t,{get:e[t],enumerable:!0})},B=(r,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of T(e))!j.call(r,s)&&s!==t&&x(r,s,{get:()=>e[s],enumerable:!(n=C(e,s))||n.enumerable});return r};var D=r=>B(x({},"__esModule",{value:!0}),r);var H={};V(H,{echo:()=>G});function d(){let r={};return r.promise=new Promise((e,t)=>{r.resolve=e,r.reject=t}),r}var p=class{buffer;mask;top;btm;next;constructor(e){if(!(e>0)||e-1&e)throw new Error("Max size for a FixedFIFO should be a power of two");this.buffer=new Array(e),this.mask=e-1,this.top=0,this.btm=0,this.next=null}push(e){return this.buffer[this.top]!==void 0?!1:(this.buffer[this.top]=e,this.top=this.top+1&this.mask,!0)}shift(){let e=this.buffer[this.btm];if(e!==void 0)return this.buffer[this.btm]=void 0,this.btm=this.btm+1&this.mask,e}isEmpty(){return this.buffer[this.btm]===void 0}},c=class{size;hwm;head;tail;constructor(e={}){this.hwm=e.splitLimit??16,this.head=new p(this.hwm),this.tail=this.head,this.size=0}calculateSize(e){return e?.byteLength!=null?e.byteLength:1}push(e){if(e?.value!=null&&(this.size+=this.calculateSize(e.value)),!this.head.push(e)){let t=this.head;this.head=t.next=new p(2*this.head.buffer.length),this.head.push(e)}}shift(){let e=this.tail.shift();if(e===void 0&&this.tail.next!=null){let t=this.tail.next;this.tail.next=null,this.tail=t,e=this.tail.shift()}return e?.value!=null&&(this.size-=this.calculateSize(e.value)),e}isEmpty(){return this.head.isEmpty()}};var g=class extends Error{type;code;constructor(e,t){super(e??"The operation was aborted"),this.type="aborted",this.code=t??"ABORT_ERR"}};function m(r={}){return U(t=>{let n=t.shift();if(n==null)return{done:!0};if(n.error!=null)throw n.error;return{done:n.done===!0,value:n.value}},r)}function U(r,e){e=e??{};let t=e.onEnd,n=new c,s,i,l,y=d(),z=async()=>{try{return n.isEmpty()?l?{done:!0}:await new Promise((o,u)=>{i=f=>{i=null,n.push(f);try{o(r(n))}catch(h){u(h)}return s}}):r(n)}finally{n.isEmpty()&&queueMicrotask(()=>{y.resolve(),y=d()})}},v=o=>i!=null?i(o):(n.push(o),s),R=o=>(n=new c,i!=null?i({error:o}):(n.push({error:o}),s)),O=o=>{if(l)return s;if(e?.objectMode!==!0&&o?.byteLength==null)throw new Error("objectMode was not true but tried to push non-Uint8Array value");return v({done:!1,value:o})},w=o=>l?s:(l=!0,o!=null?R(o):v({done:!0})),_=()=>(n=new c,w(),{done:!0}),A=o=>(w(o),{done:!0});if(s={[Symbol.asyncIterator](){return this},next:z,return:_,throw:A,push:O,end:w,get readableLength(){return n.size},onEmpty:async o=>{let u=o?.signal;if(u?.throwIfAborted(),n.isEmpty())return;let f,h;u!=null&&(f=new Promise((J,M)=>{h=()=>{M(new g)},u.addEventListener("abort",h)}));try{await Promise.race([y.promise,f])}finally{h!=null&&u!=null&&u?.removeEventListener("abort",h)}}},t==null)return s;let a=s;return s={[Symbol.asyncIterator](){return this},next(){return a.next()},throw(o){return a.throw(o),t!=null&&(t(o),t=void 0),{done:!0}},return(){return a.return(),t!=null&&(t(),t=void 0),{done:!0}},push:O,end(o){return a.end(o),t!=null&&(t(o),t=void 0),s},get readableLength(){return a.readableLength},onEmpty:o=>a.onEmpty(o)},s}function q(r){return r[Symbol.asyncIterator]!=null}function F(...r){let e=[];for(let t of r)q(t)||e.push(t);return e.length===r.length?function*(){for(let t of e)yield*t}():async function*(){let t=m({objectMode:!0});Promise.resolve().then(async()=>{try{await Promise.all(r.map(async n=>{for await(let s of n)t.push(s)})),t.end()}catch(n){t.end(n)}}),yield*t}()}var S=F;function I(r,...e){if(r==null)throw new Error("Empty pipeline");if(E(r)){let n=r;r=()=>n.source}else if(P(r)||L(r)){let n=r;r=()=>n}let t=[r,...e];if(t.length>1&&E(t[t.length-1])&&(t[t.length-1]=t[t.length-1].sink),t.length>2)for(let n=1;n<t.length-1;n++)E(t[n])&&(t[n]=$(t[n]));return W(...t)}var W=(...r)=>{let e;for(;r.length>0;)e=r.shift()(e);return e},L=r=>r?.[Symbol.asyncIterator]!=null,P=r=>r?.[Symbol.iterator]!=null,E=r=>r==null?!1:r.sink!=null&&r.source!=null,$=r=>e=>{let t=r.sink(e);if(t?.then!=null){let n=m({objectMode:!0});t.then(()=>{n.end()},l=>{n.end(l)});let s,i=r.source;if(L(i))s=async function*(){yield*i,n.end()};else if(P(i))s=function*(){yield*i,n.end()};else throw new Error("Unknown duplex source type - must be Iterable or AsyncIterable");return S(n,s())}return r.source};var k="1.0.0",N="echo";var b=class{protocol;components;started;init;log;constructor(e,t={}){this.log=e.logger.forComponent("libp2p:echo"),this.started=!1,this.components=e,this.protocol=`/${[t.protocolPrefix,N,k].filter(Boolean).join("/")}`,this.init=t}async start(){await this.components.registrar.handle(this.protocol,({stream:e})=>{I(e,e).catch(t=>{this.log.error("error piping stream",t)})},{maxInboundStreams:this.init.maxInboundStreams,maxOutboundStreams:this.init.maxOutboundStreams}),this.started=!0}async stop(){await this.components.registrar.unhandle(this.protocol),this.started=!1}isStarted(){return this.started}};function G(r={}){return e=>new b(e,r)}return D(H);})();
+return Libp2PEcho}));

package/dist/src/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PROTOCOL_VERSION = "1.0.0";
+export declare const PROTOCOL_NAME = "echo";
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,UAAU,CAAA;AACvC,eAAO,MAAM,aAAa,SAAS,CAAA"}

package/dist/src/constants.js

@@ -0,0 +1,3 @@
+export const PROTOCOL_VERSION = '1.0.0';
+export const PROTOCOL_NAME = 'echo';
+//# sourceMappingURL=constants.js.map

package/dist/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAA;AACvC,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAA"}

package/dist/src/echo.d.ts

@@ -0,0 +1,17 @@
+import type { Echo as EchoInterface, EchoComponents, EchoInit } from './index.js';
+import type { Startable } from '@libp2p/interface';
+/**
+ * A simple echo stream, any data received will be sent back to the sender
+ */
+export declare class Echo implements Startable, EchoInterface {
+    readonly protocol: string;
+    private readonly components;
+    private started;
+    private readonly init;
+    private readonly log;
+    constructor(components: EchoComponents, init?: EchoInit);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isStarted(): boolean;
+}
+//# sourceMappingURL=echo.d.ts.map

package/dist/src/echo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echo.d.ts","sourceRoot":"","sources":["../../src/echo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,IAAI,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACjF,OAAO,KAAK,EAAU,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE1D;;GAEG;AACH,qBAAa,IAAK,YAAW,SAAS,EAAE,aAAa;IACnD,SAAgB,QAAQ,EAAE,MAAM,CAAA;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;gBAEf,UAAU,EAAE,cAAc,EAAE,IAAI,GAAE,QAAa;IAQtD,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;IAavB,IAAI,IAAK,OAAO,CAAC,IAAI,CAAC;IAK5B,SAAS,IAAK,OAAO;CAGtB"}

package/dist/src/echo.js

@@ -0,0 +1,39 @@
+import { pipe } from 'it-pipe';
+import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js';
+/**
+ * A simple echo stream, any data received will be sent back to the sender
+ */
+export class Echo {
+    protocol;
+    components;
+    started;
+    init;
+    log;
+    constructor(components, init = {}) {
+        this.log = components.logger.forComponent('libp2p:echo');
+        this.started = false;
+        this.components = components;
+        this.protocol = `/${[init.protocolPrefix, PROTOCOL_NAME, PROTOCOL_VERSION].filter(Boolean).join('/')}`;
+        this.init = init;
+    }
+    async start() {
+        await this.components.registrar.handle(this.protocol, ({ stream }) => {
+            void pipe(stream, stream)
+                .catch((err) => {
+                this.log.error('error piping stream', err);
+            });
+        }, {
+            maxInboundStreams: this.init.maxInboundStreams,
+            maxOutboundStreams: this.init.maxOutboundStreams
+        });
+        this.started = true;
+    }
+    async stop() {
+        await this.components.registrar.unhandle(this.protocol);
+        this.started = false;
+    }
+    isStarted() {
+        return this.started;
+    }
+}
+//# sourceMappingURL=echo.js.map

package/dist/src/echo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"echo.js","sourceRoot":"","sources":["../../src/echo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAIhE;;GAEG;AACH,MAAM,OAAO,IAAI;IACC,QAAQ,CAAQ;IACf,UAAU,CAAgB;IACnC,OAAO,CAAS;IACP,IAAI,CAAU;IACd,GAAG,CAAQ;IAE5B,YAAa,UAA0B,EAAE,OAAiB,EAAE;QAC1D,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,aAAa,CAAC,CAAA;QACxD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;QACpB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAA;QACtG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE;YACnE,KAAK,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;iBACtB,KAAK,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAClB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,qBAAqB,EAAE,GAAG,CAAC,CAAA;YAC5C,CAAC,CAAC,CAAA;QACN,CAAC,EAAE;YACD,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB;YAC9C,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,kBAAkB;SACjD,CAAC,CAAA;QACF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;IACrB,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACvD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAA;IACtB,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF"}

package/dist/src/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @packageDocumentation
+ *
+ * An implementation of a simple Echo protocol.
+ *
+ * Any data received by the receiver will be sent back to the sender.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { echo } from '@libp2p/echo'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const receiver = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const sender = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const stream = await sender.dialProtocol(receiver.getMultiaddrs(), sender.services.echo.protocol)
+ *
+ * // write/read stream
+ * ```
+ */
+import type { ComponentLogger } from '@libp2p/interface';
+import type { ConnectionManager, Registrar } from '@libp2p/interface-internal';
+export interface EchoInit {
+    protocolPrefix?: string;
+    maxInboundStreams?: number;
+    maxOutboundStreams?: number;
+}
+export interface EchoComponents {
+    registrar: Registrar;
+    connectionManager: ConnectionManager;
+    logger: ComponentLogger;
+}
+export interface Echo {
+    protocol: string;
+}
+export declare function echo(init?: EchoInit): (components: EchoComponents) => Echo;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE9E,MAAM,WAAW,QAAQ;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAA;IACpB,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,MAAM,WAAW,IAAI;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,IAAI,CAAE,IAAI,GAAE,QAAa,GAAG,CAAC,UAAU,EAAE,cAAc,KAAK,IAAI,CAE/E"}

package/dist/src/index.js

@@ -0,0 +1,48 @@
+/**
+ * @packageDocumentation
+ *
+ * An implementation of a simple Echo protocol.
+ *
+ * Any data received by the receiver will be sent back to the sender.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { echo } from '@libp2p/echo'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const receiver = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const sender = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const stream = await sender.dialProtocol(receiver.getMultiaddrs(), sender.services.echo.protocol)
+ *
+ * // write/read stream
+ * ```
+ */
+import { Echo as EchoClass } from './echo.js';
+export function echo(init = {}) {
+    return (components) => new EchoClass(components, init);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,WAAW,CAAA;AAoB7C,MAAM,UAAU,IAAI,CAAE,OAAiB,EAAE;IACvC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,IAAI,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;AACxD,CAAC"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@libp2p/echo",
+  "version": "0.0.0-cad9cf007",
+  "description": "Implementation of an Echo protocol",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/protocol-echo#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "project": true,
+      "sourceType": "module"
+    }
+  },
+  "scripts": {
+    "start": "node dist/src/main.js",
+    "build": "aegir build",
+    "test": "aegir test",
+    "clean": "aegir clean",
+    "generate": "protons ./src/pb/index.proto",
+    "lint": "aegir lint",
+    "test:chrome": "aegir test -t browser --cov",
+    "test:chrome-webworker": "aegir test -t webworker",
+    "test:firefox": "aegir test -t browser -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
+    "dep-check": "aegir dep-check",
+    "doc-check": "aegir doc-check"
+  },
+  "dependencies": {
+    "@libp2p/interface": "1.1.4-cad9cf007",
+    "@libp2p/interface-internal": "1.0.9-cad9cf007",
+    "it-pipe": "^3.0.1"
+  },
+  "devDependencies": {
+    "@libp2p/logger": "4.0.7-cad9cf007",
+    "aegir": "^42.2.4",
+    "it-all": "^3.0.4",
+    "it-pair": "^2.0.6",
+    "sinon": "^17.0.1",
+    "sinon-ts": "^2.0.0",
+    "uint8arraylist": "^2.4.8"
+  },
+  "sideEffects": false
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const PROTOCOL_VERSION = '1.0.0'
+export const PROTOCOL_NAME = 'echo'

package/src/echo.ts

@@ -0,0 +1,45 @@
+import { pipe } from 'it-pipe'
+import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
+import type { Echo as EchoInterface, EchoComponents, EchoInit } from './index.js'
+import type { Logger, Startable } from '@libp2p/interface'
+
+/**
+ * A simple echo stream, any data received will be sent back to the sender
+ */
+export class Echo implements Startable, EchoInterface {
+  public readonly protocol: string
+  private readonly components: EchoComponents
+  private started: boolean
+  private readonly init: EchoInit
+  private readonly log: Logger
+
+  constructor (components: EchoComponents, init: EchoInit = {}) {
+    this.log = components.logger.forComponent('libp2p:echo')
+    this.started = false
+    this.components = components
+    this.protocol = `/${[init.protocolPrefix, PROTOCOL_NAME, PROTOCOL_VERSION].filter(Boolean).join('/')}`
+    this.init = init
+  }
+
+  async start (): Promise<void> {
+    await this.components.registrar.handle(this.protocol, ({ stream }) => {
+      void pipe(stream, stream)
+        .catch((err: any) => {
+          this.log.error('error piping stream', err)
+        })
+    }, {
+      maxInboundStreams: this.init.maxInboundStreams,
+      maxOutboundStreams: this.init.maxOutboundStreams
+    })
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await this.components.registrar.unhandle(this.protocol)
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+/**
+ * @packageDocumentation
+ *
+ * An implementation of a simple Echo protocol.
+ *
+ * Any data received by the receiver will be sent back to the sender.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { echo } from '@libp2p/echo'
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const receiver = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const sender = await createLibp2p({
+ *   addresses: {
+ *     listen: ['/ip4/0.0.0.0/tcp/0']
+ *   },
+ *   connectionEncryption: [noise()],
+ *   streamMuxers: [yamux()],
+ *   services: {
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * const stream = await sender.dialProtocol(receiver.getMultiaddrs(), sender.services.echo.protocol)
+ *
+ * // write/read stream
+ * ```
+ */
+
+import { Echo as EchoClass } from './echo.js'
+import type { ComponentLogger } from '@libp2p/interface'
+import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
+
+export interface EchoInit {
+  protocolPrefix?: string
+  maxInboundStreams?: number
+  maxOutboundStreams?: number
+}
+
+export interface EchoComponents {
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  logger: ComponentLogger
+}
+
+export interface Echo {
+  protocol: string
+}
+
+export function echo (init: EchoInit = {}): (components: EchoComponents) => Echo {
+  return (components) => new EchoClass(components, init)
+}