@libp2p/tcp 0.0.0 → 1.0.3

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,130 @@
+# js-libp2p-tcp <!-- omit in toc -->
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai)
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
+[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
+[![](https://img.shields.io/codecov/c/github/libp2p/js-libp2p-tcp.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-tcp)
+[![Build Status](https://github.com/libp2p/js-libp2p-tcp/actions/workflows/js-test-and-release.yml/badge.svg?branch=main)](https://github.com/libp2p/js-libp2p-tcp/actions/workflows/js-test-and-release.yml)
+[![Dependency Status](https://david-dm.org/libp2p/js-libp2p-tcp.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-tcp)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+
+[![](https://raw.githubusercontent.com/libp2p/js-libp2p-interfaces/master/src/transport/img/badge.png)](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/transport)
+[![](https://raw.githubusercontent.com/libp2p/js-libp2p-interfaces/master/src/connection/img/badge.png)](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/connection)
+
+> JavaScript implementation of the TCP module for libp2p. It exposes the [interface-transport](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/transport) for dial/listen. `libp2p-tcp` is a very thin shim that adds support for dialing to a `multiaddr`. This small shim will enable libp2p to use other transports.
+
+## Table of Contents <!-- omit in toc -->
+
+- [Install](#install)
+  - [npm](#npm)
+- [Usage](#usage)
+- [API](#api)
+  - [Transport](#transport)
+  - [Connection](#connection)
+- [Contribute](#contribute)
+- [Contribute](#contribute-1)
+- [License](#license)
+  - [Contribution](#contribution)
+
+## Install
+
+### npm
+
+```sh
+> npm install @libp2p/tcp
+```
+
+## Usage
+
+```js
+import { TCP } from '@libp2p/tcp'
+import { Multiaddr } from '@multiformats/multiaddr'
+import pipe from 'it-pipe'
+import { collect } from 'streaming-iterables'
+
+// A simple upgrader that just returns the MultiaddrConnection
+const upgrader = {
+  upgradeInbound: maConn => maConn,
+  upgradeOutbound: maConn => maConn
+}
+
+const tcp = new TCP({ upgrader })
+
+const listener = tcp.createListener({}, (socket) => {
+  console.log('new connection opened')
+  pipe(
+    ['hello'],
+    socket
+  )
+})
+
+const addr = multiaddr('/ip4/127.0.0.1/tcp/9090')
+await listener.listen(addr)
+console.log('listening')
+
+const socket = await tcp.dial(addr)
+const values = await pipe(
+  socket,
+  collect
+)
+console.log(`Value: ${values.toString()}`)
+
+// Close connection after reading
+await listener.close()
+```
+
+Outputs:
+
+```sh
+listening
+new connection opened
+Value: hello
+```
+
+## API
+
+### Transport
+
+[![](https://raw.githubusercontent.com/libp2p/js-libp2p-interfaces/master/src/transport/img/badge.png)](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/transport)
+
+`libp2p-tcp` accepts TCP addresses as both IPFS and non IPFS encapsulated addresses, i.e:
+
+`/ip4/127.0.0.1/tcp/4001`
+`/ip4/127.0.0.1/tcp/4001/ipfs/QmHash`
+
+(both for dialing and listening)
+
+### Connection
+
+[![](https://raw.githubusercontent.com/libp2p/js-libp2p-interfaces/master/src/connection/img/badge.png)](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/connection)
+
+## Contribute
+
+Contributions are welcome! The libp2p implementation in JavaScript is a work in progress. As such, there's a few things you can do right now to help out:
+
+- [Check out the existing issues](//github.com/libp2p/js-libp2p-tcp/issues).
+- **Perform code reviews**.
+- **Add tests**. There can never be enough tests.
+
+Please be aware that all interactions related to libp2p are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## Contribute
+
+The libp2p implementation in JavaScript is a work in progress. As such, there are a few things you can do right now to help out:
+
+ - Go through the modules and **check out existing issues**. This is especially useful for modules in active development. Some knowledge of IPFS/libp2p may be required, as well as the infrastructure behind it - for instance, you may need to read up on p2p and more complex operations like muxing to be able to help technically.
+ - **Perform code reviews**. More eyes will help a) speed the project along b) ensure quality and c) reduce possible future bugs.
+
+## 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/src/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CODE_P2P = 421;
+export declare const CODE_CIRCUIT = 290;
+export declare const CLOSE_TIMEOUT = 2000;
+//# 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":"AACA,eAAO,MAAM,QAAQ,MAAM,CAAA;AAC3B,eAAO,MAAM,YAAY,MAAM,CAAA;AAG/B,eAAO,MAAM,aAAa,OAAO,CAAA"}

package/dist/src/constants.js

@@ -0,0 +1,6 @@
+// p2p multi-address code
+export const CODE_P2P = 421;
+export const CODE_CIRCUIT = 290;
+// Time to wait for a connection to close gracefully before destroying it manually
+export const CLOSE_TIMEOUT = 2000;
+//# 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,yBAAyB;AACzB,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAA;AAC3B,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,CAAA;AAE/B,kFAAkF;AAClF,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAA"}

package/dist/src/index.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import net from 'net';
+import type { Transport, Upgrader, ListenerOptions } from '@libp2p/interfaces/transport';
+import type { Multiaddr } from '@multiformats/multiaddr';
+/**
+ * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+ * @typedef {import('libp2p-interfaces/src/transport/types').Upgrader} Upgrader
+ * @typedef {import('libp2p-interfaces/src/transport/types').Listener} Listener
+ * @typedef {import('net').Socket} Socket
+ */
+interface TCPOptions {
+    upgrader: Upgrader;
+}
+interface DialOptions {
+    signal?: AbortSignal;
+}
+export declare class TCP implements Transport<DialOptions, ListenerOptions> {
+    private readonly _upgrader;
+    constructor(options: TCPOptions);
+    dial(ma: Multiaddr, options?: DialOptions): Promise<import("@libp2p/interfaces/dist/src/connection").Connection>;
+    _connect(ma: Multiaddr, options?: DialOptions): Promise<net.Socket>;
+    /**
+     * Creates a TCP listener. The provided `handler` function will be called
+     * anytime a new incoming Connection has been successfully upgraded via
+     * `upgrader.upgradeInbound`.
+     */
+    createListener(options?: ListenerOptions): import("@libp2p/interfaces/transport").Listener;
+    /**
+     * Takes a list of `Multiaddr`s and returns only valid TCP addresses
+     */
+    filter(multiaddrs: Multiaddr[]): Multiaddr[];
+}
+export {};
+//# 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,OAAO,GAAG,MAAM,KAAK,CAAA;AASrB,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;AACxF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAKxD;;;;;;GAMG;AAEH,UAAU,UAAU;IAClB,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED,UAAU,WAAW;IACnB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED,qBAAa,GAAI,YAAW,SAAS,CAAC,WAAW,EAAE,eAAe,CAAC;IACjE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;gBAEvB,OAAO,EAAE,UAAU;IAU1B,IAAI,CAAE,EAAE,EAAE,SAAS,EAAE,OAAO,GAAE,WAAgB;IAe9C,QAAQ,CAAE,EAAE,EAAE,SAAS,EAAE,OAAO,GAAE,WAAgB;IA+DxD;;;;OAIG;IACH,cAAc,CAAE,OAAO,GAAE,eAAoB;IAI7C;;OAEG;IACH,MAAM,CAAE,UAAU,EAAE,SAAS,EAAE;CAWhC"}

package/dist/src/index.js

@@ -0,0 +1,100 @@
+import net from 'net';
+import * as mafmt from '@multiformats/mafmt';
+import errCode from 'err-code';
+import debug from 'debug';
+import { toMultiaddrConnection } from './socket-to-conn.js';
+import { createListener } from './listener.js';
+import { multiaddrToNetConfig } from './utils.js';
+import { AbortError } from 'abortable-iterator';
+import { CODE_CIRCUIT, CODE_P2P } from './constants.js';
+const log = debug('libp2p:tcp');
+export class TCP {
+    constructor(options) {
+        const { upgrader } = options;
+        if (upgrader == null) {
+            throw new Error('An upgrader must be provided. See https://github.com/libp2p/interface-transport#upgrader.');
+        }
+        this._upgrader = upgrader;
+    }
+    async dial(ma, options = {}) {
+        const socket = await this._connect(ma, options);
+        // Avoid uncaught errors caused by unstable connections
+        socket.on('error', err => {
+            log('socket error', err);
+        });
+        const maConn = toMultiaddrConnection(socket, { remoteAddr: ma, signal: options.signal });
+        log('new outbound connection %s', maConn.remoteAddr);
+        const conn = await this._upgrader.upgradeOutbound(maConn);
+        log('outbound connection %s upgraded', maConn.remoteAddr);
+        return conn;
+    }
+    async _connect(ma, options = {}) {
+        if (options.signal?.aborted === true) {
+            throw new AbortError();
+        }
+        return await new Promise((resolve, reject) => {
+            const start = Date.now();
+            const cOpts = multiaddrToNetConfig(ma);
+            log('dialing %j', cOpts);
+            const rawSocket = net.connect(cOpts);
+            const onError = (err) => {
+                err.message = `connection error ${cOpts.host}:${cOpts.port}: ${err.message}`;
+                done(err);
+            };
+            const onTimeout = () => {
+                log('connection timeout %s:%s', cOpts.host, cOpts.port);
+                const err = errCode(new Error(`connection timeout after ${Date.now() - start}ms`), 'ERR_CONNECT_TIMEOUT');
+                // Note: this will result in onError() being called
+                rawSocket.emit('error', err);
+            };
+            const onConnect = () => {
+                log('connection opened %j', cOpts);
+                done();
+            };
+            const onAbort = () => {
+                log('connection aborted %j', cOpts);
+                rawSocket.destroy();
+                done(new AbortError());
+            };
+            const done = (err) => {
+                rawSocket.removeListener('error', onError);
+                rawSocket.removeListener('timeout', onTimeout);
+                rawSocket.removeListener('connect', onConnect);
+                if (options.signal != null) {
+                    options.signal.removeEventListener('abort', onAbort);
+                }
+                if (err != null) {
+                    return reject(err);
+                }
+                resolve(rawSocket);
+            };
+            rawSocket.on('error', onError);
+            rawSocket.on('timeout', onTimeout);
+            rawSocket.on('connect', onConnect);
+            if (options.signal != null) {
+                options.signal.addEventListener('abort', onAbort);
+            }
+        });
+    }
+    /**
+     * Creates a TCP listener. The provided `handler` function will be called
+     * anytime a new incoming Connection has been successfully upgraded via
+     * `upgrader.upgradeInbound`.
+     */
+    createListener(options = {}) {
+        return createListener({ upgrader: this._upgrader, ...options });
+    }
+    /**
+     * Takes a list of `Multiaddr`s and returns only valid TCP addresses
+     */
+    filter(multiaddrs) {
+        multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs];
+        return multiaddrs.filter(ma => {
+            if (ma.protoCodes().includes(CODE_CIRCUIT)) {
+                return false;
+            }
+            return mafmt.TCP.matches(ma.decapsulateCode(CODE_P2P));
+        });
+    }
+}
+//# 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":"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"}

package/dist/src/listener.d.ts

@@ -0,0 +1,12 @@
+import type { Connection } from '@libp2p/interfaces/connection';
+import type { Upgrader, Listener } from '@libp2p/interfaces/transport';
+interface Context {
+    handler?: (conn: Connection) => void;
+    upgrader: Upgrader;
+}
+/**
+ * Create listener
+ */
+export declare function createListener(context: Context): Listener;
+export {};
+//# sourceMappingURL=listener.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../src/listener.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAuB,QAAQ,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAuB3F,UAAU,OAAO;IACf,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAA;IACpC,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAE,OAAO,EAAE,OAAO,YAsH/C"}

package/dist/src/listener.js

@@ -0,0 +1,130 @@
+import net from 'net';
+import { EventEmitter } from 'events';
+import debug from 'debug';
+import { toMultiaddrConnection } from './socket-to-conn.js';
+import { CODE_P2P } from './constants.js';
+import { getMultiaddrs, multiaddrToNetConfig } from './utils.js';
+const log = Object.assign(debug('libp2p:tcp:listener'), { error: debug('libp2p:tcp:listener:error') });
+/**
+ * Attempts to close the given maConn. If a failure occurs, it will be logged
+ */
+async function attemptClose(maConn) {
+    try {
+        await maConn.close();
+    }
+    catch (err) {
+        log.error('an error occurred closing the connection', err);
+    }
+}
+/**
+ * Create listener
+ */
+export function createListener(context) {
+    const { handler, upgrader } = context;
+    let peerId;
+    let listeningAddr;
+    const server = Object.assign(net.createServer(socket => {
+        // Avoid uncaught errors caused by unstable connections
+        socket.on('error', err => {
+            log('socket error', err);
+        });
+        let maConn;
+        try {
+            maConn = toMultiaddrConnection(socket, { listeningAddr });
+        }
+        catch (err) {
+            log.error('inbound connection failed', err);
+            return;
+        }
+        log('new inbound connection %s', maConn.remoteAddr);
+        try {
+            upgrader.upgradeInbound(maConn)
+                .then((conn) => {
+                log('inbound connection %s upgraded', maConn.remoteAddr);
+                trackConn(server, maConn, socket);
+                if (handler != null) {
+                    handler(conn);
+                }
+                listener.emit('connection', conn);
+            })
+                .catch(async (err) => {
+                log.error('inbound connection failed', err);
+                await attemptClose(maConn);
+            })
+                .catch(err => {
+                log.error('closing inbound connection failed', err);
+            });
+        }
+        catch (err) {
+            log.error('inbound connection failed', err);
+            attemptClose(maConn)
+                .catch(err => {
+                log.error('closing inbound connection failed', err);
+            });
+        }
+    }), 
+    // Keep track of open connections to destroy in case of timeout
+    { __connections: [] });
+    const listener = Object.assign(new EventEmitter(), {
+        getAddrs: () => {
+            let addrs = [];
+            const address = server.address();
+            if (address == null) {
+                throw new Error('Listener is not ready yet');
+            }
+            if (typeof address === 'string') {
+                throw new Error('Incorrect server address type');
+            }
+            // Because TCP will only return the IPv6 version
+            // we need to capture from the passed multiaddr
+            if (listeningAddr.toString().startsWith('/ip4')) {
+                addrs = addrs.concat(getMultiaddrs('ip4', address.address, address.port));
+            }
+            else if (address.family === 'IPv6') {
+                addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port));
+            }
+            return addrs.map(ma => peerId != null ? ma.encapsulate(`/p2p/${peerId}`) : ma);
+        },
+        listen: async (ma) => {
+            listeningAddr = ma;
+            peerId = ma.getPeerId();
+            if (peerId == null) {
+                listeningAddr = ma.decapsulateCode(CODE_P2P);
+            }
+            return await new Promise((resolve, reject) => {
+                const options = multiaddrToNetConfig(listeningAddr);
+                server.listen(options, (err) => {
+                    if (err != null) {
+                        return reject(err);
+                    }
+                    log('Listening on %s', server.address());
+                    resolve();
+                });
+            });
+        },
+        close: async () => {
+            if (!server.listening) {
+                return;
+            }
+            await Promise.all([
+                server.__connections.map(async (maConn) => await attemptClose(maConn))
+            ]);
+            await new Promise((resolve, reject) => {
+                server.close(err => (err != null) ? reject(err) : resolve());
+            });
+        }
+    });
+    server
+        .on('listening', () => listener.emit('listening'))
+        .on('error', err => listener.emit('error', err))
+        .on('close', () => listener.emit('close'));
+    return listener;
+}
+function trackConn(server, maConn, socket) {
+    server.__connections.push(maConn);
+    const untrackConn = () => {
+        server.__connections = server.__connections.filter(c => c !== maConn);
+    };
+    socket.once('close', untrackConn);
+}
+//# sourceMappingURL=listener.js.map

package/dist/src/listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.js","sourceRoot":"","sources":["../../src/listener.ts"],"names":[],"mappings":"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"}

package/dist/src/socket-to-conn.d.ts

@@ -0,0 +1,16 @@
+import type { Socket } from 'net';
+import type { Multiaddr } from '@multiformats/multiaddr';
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport';
+interface ToConnectionOptions {
+    listeningAddr?: Multiaddr;
+    remoteAddr?: Multiaddr;
+    localAddr?: Multiaddr;
+    signal?: AbortSignal;
+}
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export declare const toMultiaddrConnection: (socket: Socket, options?: ToConnectionOptions | undefined) => MultiaddrConnection;
+export {};
+//# sourceMappingURL=socket-to-conn.d.ts.map

package/dist/src/socket-to-conn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-to-conn.d.ts","sourceRoot":"","sources":["../../src/socket-to-conn.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAIvE,UAAU,mBAAmB;IAC3B,aAAa,CAAC,EAAE,SAAS,CAAA;IACzB,UAAU,CAAC,EAAE,SAAS,CAAA;IACtB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,WAAY,MAAM,mEAmGnD,CAAA"}

package/dist/src/socket-to-conn.js

@@ -0,0 +1,94 @@
+import { abortableSource } from 'abortable-iterator';
+import debug from 'debug';
+// @ts-expect-error no types
+import toIterable from 'stream-to-it';
+import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr';
+import { CLOSE_TIMEOUT } from './constants.js';
+const log = debug('libp2p:tcp:socket');
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (socket, options) => {
+    options = options ?? {};
+    // Check if we are connected on a unix path
+    if (options.listeningAddr?.getPath() != null) {
+        options.remoteAddr = options.listeningAddr;
+    }
+    if (options.remoteAddr?.getPath() != null) {
+        options.localAddr = options.remoteAddr;
+    }
+    const { sink, source } = toIterable.duplex(socket);
+    const maConn = {
+        async sink(source) {
+            if ((options?.signal) != null) {
+                source = abortableSource(source, options.signal);
+            }
+            try {
+                await sink((async function* () {
+                    for await (const chunk of source) {
+                        // Convert BufferList to Buffer
+                        // Sink in StreamMuxer define argument as Uint8Array so chunk type infers as number which can't be sliced
+                        yield Buffer.isBuffer(chunk) ? chunk : chunk.slice();
+                    }
+                })());
+            }
+            catch (err) {
+                // If aborted we can safely ignore
+                if (err.type !== 'aborted') {
+                    // If the source errored the socket will already have been destroyed by
+                    // toIterable.duplex(). If the socket errored it will already be
+                    // destroyed. There's nothing to do here except log the error & return.
+                    log(err);
+                }
+            }
+        },
+        // Missing Type for "abortable"
+        source: (options.signal != null) ? abortableSource(source, options.signal) : source,
+        // If the remote address was passed, use it - it may have the peer ID encapsulated
+        remoteAddr: options.remoteAddr ?? toMultiaddr(socket.remoteAddress ?? '', socket.remotePort ?? ''),
+        timeline: { open: Date.now() },
+        async close() {
+            if (socket.destroyed)
+                return;
+            return await new Promise((resolve, reject) => {
+                const start = Date.now();
+                // Attempt to end the socket. If it takes longer to close than the
+                // timeout, destroy it manually.
+                const timeout = setTimeout(() => {
+                    const { host, port } = maConn.remoteAddr.toOptions();
+                    log('timeout closing socket to %s:%s after %dms, destroying it manually', host, port, Date.now() - start);
+                    if (socket.destroyed) {
+                        log('%s:%s is already destroyed', host, port);
+                    }
+                    else {
+                        socket.destroy();
+                    }
+                    resolve();
+                }, CLOSE_TIMEOUT).unref();
+                socket.once('close', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                socket.end((err) => {
+                    clearTimeout(timeout);
+                    maConn.timeline.close = Date.now();
+                    if (err != null) {
+                        return reject(err);
+                    }
+                    resolve();
+                });
+            });
+        }
+    };
+    socket.once('close', () => {
+        // In instances where `close` was not explicitly called,
+        // such as an iterable stream ending, ensure we have set the close
+        // timeline
+        if (maConn.timeline.close == null) {
+            maConn.timeline.close = Date.now();
+        }
+    });
+    return maConn;
+};
+//# sourceMappingURL=socket-to-conn.js.map

package/dist/src/socket-to-conn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-to-conn.js","sourceRoot":"","sources":["../../src/socket-to-conn.ts"],"names":[],"mappings":"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"}

package/dist/src/utils.d.ts

@@ -0,0 +1,5 @@
+import { Multiaddr } from '@multiformats/multiaddr';
+export declare function multiaddrToNetConfig(addr: Multiaddr): import("@multiformats/multiaddr").MultiaddrObject;
+export declare function getMultiaddrs(proto: 'ip4' | 'ip6', ip: string, port: number): Multiaddr[];
+export declare function isAnyAddr(ip: string): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAKnD,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,SAAS,qDAWpD;AAED,wBAAgB,aAAa,CAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAG5E;AAED,wBAAgB,SAAS,CAAE,EAAE,EAAE,MAAM,WAEpC"}

package/dist/src/utils.js

@@ -0,0 +1,35 @@
+import { Multiaddr } from '@multiformats/multiaddr';
+import os from 'os';
+const ProtoFamily = { ip4: 'IPv4', ip6: 'IPv6' };
+export function multiaddrToNetConfig(addr) {
+    const listenPath = addr.getPath();
+    // unix socket listening
+    if (listenPath != null) {
+        // TCP should not return unix socket else need to refactor listener which accepts connection options object
+        throw new Error('Unix Sockets are not supported by the TCP transport');
+    }
+    // tcp listening
+    return addr.toOptions();
+}
+export function getMultiaddrs(proto, ip, port) {
+    const toMa = (ip) => new Multiaddr(`/${proto}/${ip}/tcp/${port}`);
+    return (isAnyAddr(ip) ? getNetworkAddrs(ProtoFamily[proto]) : [ip]).map(toMa);
+}
+export function isAnyAddr(ip) {
+    return ['0.0.0.0', '::'].includes(ip);
+}
+const networks = os.networkInterfaces();
+function getNetworkAddrs(family) {
+    const addresses = [];
+    for (const [, netAddrs] of Object.entries(networks)) {
+        if (netAddrs != null) {
+            for (const netAddr of netAddrs) {
+                if (netAddr.family === family) {
+                    addresses.push(netAddr.address);
+                }
+            }
+        }
+    }
+    return addresses;
+}
+//# sourceMappingURL=utils.js.map

package/dist/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,MAAM,WAAW,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,CAAA;AAEhD,MAAM,UAAU,oBAAoB,CAAE,IAAe;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;IAEjC,wBAAwB;IACxB,IAAI,UAAU,IAAI,IAAI,EAAE;QACtB,2GAA2G;QAC3G,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAA;KACvE;IAED,gBAAgB;IAChB,OAAO,IAAI,CAAC,SAAS,EAAE,CAAA;AACzB,CAAC;AAED,MAAM,UAAU,aAAa,CAAE,KAAoB,EAAE,EAAU,EAAE,IAAY;IAC3E,MAAM,IAAI,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAA;IACzE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AAC/E,CAAC;AAED,MAAM,UAAU,SAAS,CAAE,EAAU;IACnC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;AACvC,CAAC;AAED,MAAM,QAAQ,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAA;AAEvC,SAAS,eAAe,CAAE,MAAc;IACtC,MAAM,SAAS,GAAG,EAAE,CAAA;IAEpB,KAAK,MAAM,CAAC,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QACnD,IAAI,QAAQ,IAAI,IAAI,EAAE;YACpB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;gBAC9B,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,EAAE;oBAC7B,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;iBAChC;aACF;SACF;KACF;IAED,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/package.json

@@ -1,7 +1,157 @@
 {
   "name": "@libp2p/tcp",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "license": "(Apache-2.0 OR MIT)"
+  "version": "1.0.3",
+  "description": "Node.js implementation of the TCP module that libp2p uses, which implements the interface-connection and interface-transport interfaces",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p-tcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p-tcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-tcp/issues"
+  },
+  "keywords": [
+    "IPFS",
+    "TCP",
+    "libp2p",
+    "network",
+    "p2p",
+    "peer",
+    "peer-to-peer"
+  ],
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist/src",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    }
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
+  "scripts": {
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check dist/src/**/*.js dist/test/**/*.js",
+    "build": "tsc",
+    "pretest": "npm run build",
+    "test": "aegir test -f ./dist/test",
+    "test:node": "npm run test -- -t node --cov",
+    "test:electron-main": "npm run test -- -t electron-main",
+    "release": "semantic-release"
+  },
+  "dependencies": {
+    "@libp2p/utils": "^1.0.1",
+    "@multiformats/mafmt": "^11.0.0",
+    "@multiformats/multiaddr": "^10.1.1",
+    "abortable-iterator": "^4.0.2",
+    "debug": "^4.3.1",
+    "err-code": "^3.0.1",
+    "stream-to-it": "^0.2.2"
+  },
+  "devDependencies": {
+    "@libp2p/interface-compliance-tests": "^1.0.1",
+    "@libp2p/interfaces": "^1.0.0",
+    "@types/debug": "^4.1.5",
+    "@types/mocha": "^9.0.0",
+    "aegir": "^36.1.3",
+    "it-pipe": "^2.0.3",
+    "sinon": "^13.0.0",
+    "streaming-iterables": "^6.0.0",
+    "uint8arrays": "^3.0.0"
+  }
 }

package/src/constants.ts

@@ -0,0 +1,6 @@
+// p2p multi-address code
+export const CODE_P2P = 421
+export const CODE_CIRCUIT = 290
+
+// Time to wait for a connection to close gracefully before destroying it manually
+export const CLOSE_TIMEOUT = 2000

package/src/index.ts

@@ -0,0 +1,146 @@
+import net from 'net'
+import * as mafmt from '@multiformats/mafmt'
+import errCode from 'err-code'
+import debug from 'debug'
+import { toMultiaddrConnection } from './socket-to-conn.js'
+import { createListener } from './listener.js'
+import { multiaddrToNetConfig } from './utils.js'
+import { AbortError } from 'abortable-iterator'
+import { CODE_CIRCUIT, CODE_P2P } from './constants.js'
+import type { Transport, Upgrader, ListenerOptions } from '@libp2p/interfaces/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Socket } from 'net'
+
+const log = debug('libp2p:tcp')
+
+/**
+ * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+ * @typedef {import('libp2p-interfaces/src/transport/types').Upgrader} Upgrader
+ * @typedef {import('libp2p-interfaces/src/transport/types').Listener} Listener
+ * @typedef {import('net').Socket} Socket
+ */
+
+interface TCPOptions {
+  upgrader: Upgrader
+}
+
+interface DialOptions {
+  signal?: AbortSignal
+}
+
+export class TCP implements Transport<DialOptions, ListenerOptions> {
+  private readonly _upgrader: Upgrader
+
+  constructor (options: TCPOptions) {
+    const { upgrader } = options
+
+    if (upgrader == null) {
+      throw new Error('An upgrader must be provided. See https://github.com/libp2p/interface-transport#upgrader.')
+    }
+
+    this._upgrader = upgrader
+  }
+
+  async dial (ma: Multiaddr, options: DialOptions = {}) {
+    const socket = await this._connect(ma, options)
+
+    // Avoid uncaught errors caused by unstable connections
+    socket.on('error', err => {
+      log('socket error', err)
+    })
+
+    const maConn = toMultiaddrConnection(socket, { remoteAddr: ma, signal: options.signal })
+    log('new outbound connection %s', maConn.remoteAddr)
+    const conn = await this._upgrader.upgradeOutbound(maConn)
+    log('outbound connection %s upgraded', maConn.remoteAddr)
+    return conn
+  }
+
+  async _connect (ma: Multiaddr, options: DialOptions = {}) {
+    if (options.signal?.aborted === true) {
+      throw new AbortError()
+    }
+
+    return await new Promise<Socket>((resolve, reject) => {
+      const start = Date.now()
+      const cOpts = multiaddrToNetConfig(ma)
+
+      log('dialing %j', cOpts)
+      const rawSocket = net.connect(cOpts)
+
+      const onError = (err: Error) => {
+        err.message = `connection error ${cOpts.host}:${cOpts.port}: ${err.message}`
+
+        done(err)
+      }
+
+      const onTimeout = () => {
+        log('connection timeout %s:%s', cOpts.host, cOpts.port)
+
+        const err = errCode(new Error(`connection timeout after ${Date.now() - start}ms`), 'ERR_CONNECT_TIMEOUT')
+        // Note: this will result in onError() being called
+        rawSocket.emit('error', err)
+      }
+
+      const onConnect = () => {
+        log('connection opened %j', cOpts)
+        done()
+      }
+
+      const onAbort = () => {
+        log('connection aborted %j', cOpts)
+        rawSocket.destroy()
+        done(new AbortError())
+      }
+
+      const done = (err?: any) => {
+        rawSocket.removeListener('error', onError)
+        rawSocket.removeListener('timeout', onTimeout)
+        rawSocket.removeListener('connect', onConnect)
+
+        if (options.signal != null) {
+          options.signal.removeEventListener('abort', onAbort)
+        }
+
+        if (err != null) {
+          return reject(err)
+        }
+
+        resolve(rawSocket)
+      }
+
+      rawSocket.on('error', onError)
+      rawSocket.on('timeout', onTimeout)
+      rawSocket.on('connect', onConnect)
+
+      if (options.signal != null) {
+        options.signal.addEventListener('abort', onAbort)
+      }
+    })
+  }
+
+  /**
+   * Creates a TCP listener. The provided `handler` function will be called
+   * anytime a new incoming Connection has been successfully upgraded via
+   * `upgrader.upgradeInbound`.
+   */
+  createListener (options: ListenerOptions = {}) {
+    return createListener({ upgrader: this._upgrader, ...options })
+  }
+
+  /**
+   * Takes a list of `Multiaddr`s and returns only valid TCP addresses
+   */
+  filter (multiaddrs: Multiaddr[]) {
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter(ma => {
+      if (ma.protoCodes().includes(CODE_CIRCUIT)) {
+        return false
+      }
+
+      return mafmt.TCP.matches(ma.decapsulateCode(CODE_P2P))
+    })
+  }
+}

package/src/listener.ts

@@ -0,0 +1,170 @@
+import net from 'net'
+import { EventEmitter } from 'events'
+import debug from 'debug'
+import { toMultiaddrConnection } from './socket-to-conn.js'
+import { CODE_P2P } from './constants.js'
+import {
+  getMultiaddrs,
+  multiaddrToNetConfig
+} from './utils.js'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { MultiaddrConnection, Upgrader, Listener } from '@libp2p/interfaces/transport'
+import type { Server } from 'net'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+const log = Object.assign(
+  debug('libp2p:tcp:listener'),
+  { error: debug('libp2p:tcp:listener:error') })
+
+interface ServerWithMultiaddrConnections extends Server {
+  __connections: MultiaddrConnection[]
+}
+
+/**
+ * Attempts to close the given maConn. If a failure occurs, it will be logged
+ */
+async function attemptClose (maConn: MultiaddrConnection) {
+  try {
+    await maConn.close()
+  } catch (err) {
+    log.error('an error occurred closing the connection', err)
+  }
+}
+
+interface Context {
+  handler?: (conn: Connection) => void
+  upgrader: Upgrader
+}
+
+/**
+ * Create listener
+ */
+export function createListener (context: Context) {
+  const {
+    handler, upgrader
+  } = context
+
+  let peerId: string | null
+  let listeningAddr: Multiaddr
+
+  const server: ServerWithMultiaddrConnections = Object.assign(net.createServer(socket => {
+    // Avoid uncaught errors caused by unstable connections
+    socket.on('error', err => {
+      log('socket error', err)
+    })
+
+    let maConn: MultiaddrConnection
+    try {
+      maConn = toMultiaddrConnection(socket, { listeningAddr })
+    } catch (err) {
+      log.error('inbound connection failed', err)
+      return
+    }
+
+    log('new inbound connection %s', maConn.remoteAddr)
+    try {
+      upgrader.upgradeInbound(maConn)
+        .then((conn) => {
+          log('inbound connection %s upgraded', maConn.remoteAddr)
+          trackConn(server, maConn, socket)
+
+          if (handler != null) {
+            handler(conn)
+          }
+
+          listener.emit('connection', conn)
+        })
+        .catch(async err => {
+          log.error('inbound connection failed', err)
+
+          await attemptClose(maConn)
+        })
+        .catch(err => {
+          log.error('closing inbound connection failed', err)
+        })
+    } catch (err) {
+      log.error('inbound connection failed', err)
+
+      attemptClose(maConn)
+        .catch(err => {
+          log.error('closing inbound connection failed', err)
+        })
+    }
+  }),
+  // Keep track of open connections to destroy in case of timeout
+  { __connections: [] })
+
+  const listener: Listener = Object.assign(new EventEmitter(), {
+    getAddrs: () => {
+      let addrs: Multiaddr[] = []
+      const address = server.address()
+
+      if (address == null) {
+        throw new Error('Listener is not ready yet')
+      }
+
+      if (typeof address === 'string') {
+        throw new Error('Incorrect server address type')
+      }
+
+      // Because TCP will only return the IPv6 version
+      // we need to capture from the passed multiaddr
+      if (listeningAddr.toString().startsWith('/ip4')) {
+        addrs = addrs.concat(getMultiaddrs('ip4', address.address, address.port))
+      } else if (address.family === 'IPv6') {
+        addrs = addrs.concat(getMultiaddrs('ip6', address.address, address.port))
+      }
+
+      return addrs.map(ma => peerId != null ? ma.encapsulate(`/p2p/${peerId}`) : ma)
+    },
+    listen: async (ma: Multiaddr) => {
+      listeningAddr = ma
+      peerId = ma.getPeerId()
+
+      if (peerId == null) {
+        listeningAddr = ma.decapsulateCode(CODE_P2P)
+      }
+
+      return await new Promise<void>((resolve, reject) => {
+        const options = multiaddrToNetConfig(listeningAddr)
+        server.listen(options, (err?: any) => {
+          if (err != null) {
+            return reject(err)
+          }
+          log('Listening on %s', server.address())
+          resolve()
+        })
+      })
+    },
+    close: async () => {
+      if (!server.listening) {
+        return
+      }
+
+      await Promise.all([
+        server.__connections.map(async maConn => await attemptClose(maConn))
+      ])
+
+      await new Promise<void>((resolve, reject) => {
+        server.close(err => (err != null) ? reject(err) : resolve())
+      })
+    }
+  })
+
+  server
+    .on('listening', () => listener.emit('listening'))
+    .on('error', err => listener.emit('error', err))
+    .on('close', () => listener.emit('close'))
+
+  return listener
+}
+
+function trackConn (server: ServerWithMultiaddrConnections, maConn: MultiaddrConnection, socket: net.Socket) {
+  server.__connections.push(maConn)
+
+  const untrackConn = () => {
+    server.__connections = server.__connections.filter(c => c !== maConn)
+  }
+
+  socket.once('close', untrackConn)
+}

package/src/socket-to-conn.ts

@@ -0,0 +1,123 @@
+import { abortableSource } from 'abortable-iterator'
+import debug from 'debug'
+// @ts-expect-error no types
+import toIterable from 'stream-to-it'
+import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
+import { CLOSE_TIMEOUT } from './constants.js'
+import type { Socket } from 'net'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+
+const log = debug('libp2p:tcp:socket')
+
+interface ToConnectionOptions {
+  listeningAddr?: Multiaddr
+  remoteAddr?: Multiaddr
+  localAddr?: Multiaddr
+  signal?: AbortSignal
+}
+
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (socket: Socket, options?: ToConnectionOptions) => {
+  options = options ?? {}
+
+  // Check if we are connected on a unix path
+  if (options.listeningAddr?.getPath() != null) {
+    options.remoteAddr = options.listeningAddr
+  }
+
+  if (options.remoteAddr?.getPath() != null) {
+    options.localAddr = options.remoteAddr
+  }
+
+  const { sink, source } = toIterable.duplex(socket)
+
+  const maConn: MultiaddrConnection = {
+    async sink (source) {
+      if ((options?.signal) != null) {
+        source = abortableSource(source, options.signal)
+      }
+
+      try {
+        await sink((async function * () {
+          for await (const chunk of source) {
+            // Convert BufferList to Buffer
+            // Sink in StreamMuxer define argument as Uint8Array so chunk type infers as number which can't be sliced
+            yield Buffer.isBuffer(chunk) ? chunk : chunk.slice()
+          }
+        })())
+      } catch (err: any) {
+        // If aborted we can safely ignore
+        if (err.type !== 'aborted') {
+          // If the source errored the socket will already have been destroyed by
+          // toIterable.duplex(). If the socket errored it will already be
+          // destroyed. There's nothing to do here except log the error & return.
+          log(err)
+        }
+      }
+    },
+
+    // Missing Type for "abortable"
+    source: (options.signal != null) ? abortableSource(source, options.signal) : source,
+
+    // If the remote address was passed, use it - it may have the peer ID encapsulated
+    remoteAddr: options.remoteAddr ?? toMultiaddr(socket.remoteAddress ?? '', socket.remotePort ?? ''),
+
+    timeline: { open: Date.now() },
+
+    async close () {
+      if (socket.destroyed) return
+
+      return await new Promise((resolve, reject) => {
+        const start = Date.now()
+
+        // Attempt to end the socket. If it takes longer to close than the
+        // timeout, destroy it manually.
+        const timeout = setTimeout(() => {
+          const { host, port } = maConn.remoteAddr.toOptions()
+          log(
+            'timeout closing socket to %s:%s after %dms, destroying it manually',
+            host,
+            port,
+            Date.now() - start
+          )
+
+          if (socket.destroyed) {
+            log('%s:%s is already destroyed', host, port)
+          } else {
+            socket.destroy()
+          }
+
+          resolve()
+        }, CLOSE_TIMEOUT).unref()
+
+        socket.once('close', () => {
+          clearTimeout(timeout)
+          resolve()
+        })
+        socket.end((err?: Error & { code?: string }) => {
+          clearTimeout(timeout)
+          maConn.timeline.close = Date.now()
+          if (err != null) {
+            return reject(err)
+          }
+          resolve()
+        })
+      })
+    }
+  }
+
+  socket.once('close', () => {
+    // In instances where `close` was not explicitly called,
+    // such as an iterable stream ending, ensure we have set the close
+    // timeline
+    if (maConn.timeline.close == null) {
+      maConn.timeline.close = Date.now()
+    }
+  })
+
+  return maConn
+}

package/src/utils.ts

@@ -0,0 +1,44 @@
+import { Multiaddr } from '@multiformats/multiaddr'
+import os from 'os'
+
+const ProtoFamily = { ip4: 'IPv4', ip6: 'IPv6' }
+
+export function multiaddrToNetConfig (addr: Multiaddr) {
+  const listenPath = addr.getPath()
+
+  // unix socket listening
+  if (listenPath != null) {
+    // TCP should not return unix socket else need to refactor listener which accepts connection options object
+    throw new Error('Unix Sockets are not supported by the TCP transport')
+  }
+
+  // tcp listening
+  return addr.toOptions()
+}
+
+export function getMultiaddrs (proto: 'ip4' | 'ip6', ip: string, port: number) {
+  const toMa = (ip: string) => new Multiaddr(`/${proto}/${ip}/tcp/${port}`)
+  return (isAnyAddr(ip) ? getNetworkAddrs(ProtoFamily[proto]) : [ip]).map(toMa)
+}
+
+export function isAnyAddr (ip: string) {
+  return ['0.0.0.0', '::'].includes(ip)
+}
+
+const networks = os.networkInterfaces()
+
+function getNetworkAddrs (family: string) {
+  const addresses = []
+
+  for (const [, netAddrs] of Object.entries(networks)) {
+    if (netAddrs != null) {
+      for (const netAddr of netAddrs) {
+        if (netAddr.family === family) {
+          addresses.push(netAddr.address)
+        }
+      }
+    }
+  }
+
+  return addresses
+}