@libp2p/memory 0.0.0-02f285fc8

package/dist/src/listener.js

@@ -0,0 +1,124 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/)
+ * that operates in-memory only.
+ *
+ * This is intended for testing and can only be used to connect two libp2p nodes
+ * that are running in the same process.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/memory/node-a'
+ *     ]
+ *   },
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/memory/node-a')
+ *
+ * // dial the listener, timing out after 10s
+ * const connection = await dialer.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ *
+ * @example Simulating slow connections
+ *
+ * A `latency` argument can be passed to the factory. Each byte array that
+ * passes through the transport will be delayed by this many ms.
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory({
+ *       latency: 100
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+import { ListenError, TypedEventEmitter } from '@libp2p/interface';
+import { multiaddr } from '@multiformats/multiaddr';
+import { nanoid } from 'nanoid';
+import { MemoryConnection, connections } from './connections.js';
+export class MemoryTransportListener extends TypedEventEmitter {
+    listenAddr;
+    connection;
+    components;
+    init;
+    constructor(components, init) {
+        super();
+        this.components = components;
+        this.init = init;
+    }
+    async listen(ma) {
+        const [[, value]] = ma.stringTuples();
+        const address = `/memory/${value ?? nanoid()}`;
+        if (value != null && connections.has(address)) {
+            throw new ListenError(`Memory address ${address} already in use`);
+        }
+        this.connection = new MemoryConnection(this.components, {
+            ...this.init,
+            onConnection: this.onConnection.bind(this),
+            address
+        });
+        this.listenAddr = multiaddr(address);
+        connections.set(address, this.connection);
+        queueMicrotask(() => {
+            this.safeDispatchEvent('listening');
+        });
+    }
+    onConnection(maConn) {
+        let signal;
+        if (this.init.inboundUpgradeTimeout != null) {
+            signal = AbortSignal.timeout(this.init.inboundUpgradeTimeout);
+        }
+        this.init.upgrader.upgradeInbound(maConn, {
+            ...this.init.upgraderOptions,
+            signal
+        })
+            .catch(err => {
+            maConn.abort(err);
+        });
+    }
+    getAddrs() {
+        if (this.listenAddr == null) {
+            return [];
+        }
+        return [
+            this.listenAddr
+        ];
+    }
+    async close() {
+        this.connection?.close();
+        if (this.listenAddr != null) {
+            connections.delete(this.listenAddr.toString());
+        }
+        queueMicrotask(() => {
+            this.safeDispatchEvent('close');
+        });
+    }
+}
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAShE,MAAM,OAAO,uBAAwB,SAAQ,iBAAiC;IACpE,UAAU,CAAY;IACtB,UAAU,CAAmB;IACpB,UAAU,CAA2B;IACrC,IAAI,CAA6B;IAElD,YAAa,UAAqC,EAAE,IAAiC;QACnF,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,KAAK,CAAC,MAAM,CAAE,EAAa;QACzB,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,YAAY,EAAE,CAAA;QAErC,MAAM,OAAO,GAAG,WAAW,KAAK,IAAI,MAAM,EAAE,EAAE,CAAA;QAE9C,IAAI,KAAK,IAAI,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,WAAW,CAAC,kBAAkB,OAAO,iBAAiB,CAAC,CAAA;QACnE,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,UAAU,EAAE;YACtD,GAAG,IAAI,CAAC,IAAI;YACZ,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;YAC1C,OAAO;SACR,CAAC,CAAA;QACF,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;QAEpC,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;QAEzC,cAAc,CAAC,GAAG,EAAE;YAClB,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAA;QACrC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,YAAY,CAAE,MAA2B;QACvC,IAAI,MAA+B,CAAA;QAEnC,IAAI,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,EAAE,CAAC;YAC5C,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAA;QAC/D,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE;YACxC,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe;YAC5B,MAAM;SACP,CAAC;aACC,KAAK,CAAC,GAAG,CAAC,EAAE;YACX,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACnB,CAAC,CAAC,CAAA;IACN,CAAC;IAED,QAAQ;QACN,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC5B,OAAO,EAAE,CAAA;QACX,CAAC;QAED,OAAO;YACL,IAAI,CAAC,UAAU;SAChB,CAAA;IACH,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,CAAA;QAExB,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;YAC5B,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAA;QAChD,CAAC;QAED,cAAc,CAAC,GAAG,EAAE;YAClB,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;QACjC,CAAC,CAAC,CAAA;IACJ,CAAC;CACF"}

package/dist/src/memory.d.ts

@@ -0,0 +1,22 @@
+import { serviceCapabilities, transportSymbol } from '@libp2p/interface';
+import type { MemoryTransportComponents, MemoryTransportInit } from './index.js';
+import type { Connection, Transport, Listener, CreateListenerOptions, DialTransportOptions } from '@libp2p/interface';
+import type { Multiaddr } from '@multiformats/multiaddr';
+export declare class MemoryTransport implements Transport {
+    private readonly components;
+    private readonly init;
+    constructor(components: MemoryTransportComponents, init?: MemoryTransportInit);
+    readonly [transportSymbol] = true;
+    readonly [Symbol.toStringTag] = "@libp2p/memory";
+    readonly [serviceCapabilities]: string[];
+    dial(ma: Multiaddr, options: DialTransportOptions): Promise<Connection>;
+    /**
+     * 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: CreateListenerOptions): Listener;
+    listenFilter(multiaddrs: Multiaddr[]): Multiaddr[];
+    dialFilter(multiaddrs: Multiaddr[]): Multiaddr[];
+}
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAI/F,OAAO,KAAK,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AACrH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2B;IACtD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;gBAE7B,UAAU,EAAE,yBAAyB,EAAE,IAAI,GAAE,mBAAwB;IAKlF,QAAQ,CAAC,CAAC,eAAe,CAAC,QAAO;IAEjC,QAAQ,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,oBAAmB;IAEhD,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAEvC;IAEK,IAAI,CAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwB9E;;;;OAIG;IACH,cAAc,CAAE,OAAO,EAAE,qBAAqB,GAAG,QAAQ;IAOzD,YAAY,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE;IAInD,UAAU,CAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE;CAGlD"}

package/dist/src/memory.js

@@ -0,0 +1,54 @@
+import { ConnectionFailedError, serviceCapabilities, transportSymbol } from '@libp2p/interface';
+import { Memory } from '@multiformats/multiaddr-matcher';
+import { connections } from './connections.js';
+import { MemoryTransportListener } from './listener.js';
+export class MemoryTransport {
+    components;
+    init;
+    constructor(components, init = {}) {
+        this.components = components;
+        this.init = init;
+    }
+    [transportSymbol] = true;
+    [Symbol.toStringTag] = '@libp2p/memory';
+    [serviceCapabilities] = [
+        '@libp2p/transport'
+    ];
+    async dial(ma, options) {
+        options.signal?.throwIfAborted();
+        const memoryConnection = connections.get(`${ma.getPeerId() == null ? ma : ma.decapsulate('/p2p')}`);
+        if (memoryConnection == null) {
+            throw new ConnectionFailedError(`No memory listener found at ${ma}`);
+        }
+        const maConn = await memoryConnection.dial(this.components.peerId);
+        try {
+            options.signal?.throwIfAborted();
+            return await options.upgrader.upgradeOutbound(maConn, {
+                ...options,
+                ...this.init.upgraderOptions
+            });
+        }
+        catch (err) {
+            maConn.abort(err);
+            throw err;
+        }
+    }
+    /**
+     * 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 new MemoryTransportListener(this.components, {
+            ...options,
+            ...this.init
+        });
+    }
+    listenFilter(multiaddrs) {
+        return multiaddrs.filter(ma => Memory.exactMatch(ma));
+    }
+    dialFilter(multiaddrs) {
+        return this.listenFilter(multiaddrs);
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/src/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC/F,OAAO,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAKvD,MAAM,OAAO,eAAe;IACT,UAAU,CAA2B;IACrC,IAAI,CAAqB;IAE1C,YAAa,UAAqC,EAAE,OAA4B,EAAE;QAChF,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAEQ,CAAC,eAAe,CAAC,GAAG,IAAI,CAAA;IAExB,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,gBAAgB,CAAA;IAEvC,CAAC,mBAAmB,CAAC,GAAa;QACzC,mBAAmB;KACpB,CAAA;IAED,KAAK,CAAC,IAAI,CAAE,EAAa,EAAE,OAA6B;QACtD,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;QAEhC,MAAM,gBAAgB,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QAEnG,IAAI,gBAAgB,IAAI,IAAI,EAAE,CAAC;YAC7B,MAAM,IAAI,qBAAqB,CAAC,+BAA+B,EAAE,EAAE,CAAC,CAAA;QACtE,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QAElE,IAAI,CAAC;YACH,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;YAEhC,OAAO,MAAM,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,MAAM,EAAE;gBACpD,GAAG,OAAO;gBACV,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe;aAC7B,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACjB,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAE,OAA8B;QAC5C,OAAO,IAAI,uBAAuB,CAAC,IAAI,CAAC,UAAU,EAAE;YAClD,GAAG,OAAO;YACV,GAAG,IAAI,CAAC,IAAI;SACb,CAAC,CAAA;IACJ,CAAC;IAED,YAAY,CAAE,UAAuB;QACnC,OAAO,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAA;IACvD,CAAC;IAED,UAAU,CAAE,UAAuB;QACjC,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAA;IACtC,CAAC;CACF"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@libp2p/memory",
+  "version": "0.0.0-02f285fc8",
+  "description": "A memory transport for libp2p",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-tcp#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": {
+    "clean": "aegir clean",
+    "lint": "aegir lint",
+    "dep-check": "aegir dep-check",
+    "doc-check": "aegir doc-check",
+    "build": "aegir build",
+    "test": "aegir test -t node -t electron-main",
+    "test:chrome": "aegir test -t browser -f ./dist/test/browser.js --cov",
+    "test:chrome-webworker": "aegir test -t webworker -f ./dist/test/browser.js",
+    "test:firefox": "aegir test -t browser -f ./dist/test/browser.js -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -f ./dist/test/browser.js -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
+    "test:electron-main": "aegir test -t electron-main"
+  },
+  "dependencies": {
+    "@libp2p/interface": "2.2.0-02f285fc8",
+    "@multiformats/multiaddr": "^12.2.3",
+    "@multiformats/multiaddr-matcher": "^1.5.0",
+    "@types/sinon": "^17.0.3",
+    "delay": "^6.0.0",
+    "it-map": "^3.1.1",
+    "it-pushable": "^3.2.3",
+    "nanoid": "^5.0.8",
+    "uint8arraylist": "^2.4.8"
+  },
+  "devDependencies": {
+    "@libp2p/logger": "5.1.3-02f285fc8",
+    "@libp2p/peer-id": "5.0.7-02f285fc8",
+    "aegir": "^44.0.1",
+    "sinon": "^19.0.2",
+    "sinon-ts": "^2.0.0"
+  },
+  "browser": {
+    "./dist/src/tcp.js": "./dist/src/tcp.browser.js"
+  },
+  "sideEffects": false
+}

package/src/connections.ts

@@ -0,0 +1,178 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/)
+ * that operates in-memory only.
+ *
+ * This is intended for testing and can only be used to connect two libp2p nodes
+ * that are running in the same process.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/memory/node-a'
+ *     ]
+ *   },
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/memory/node-a')
+ *
+ * // dial the listener, timing out after 10s
+ * const connection = await dialer.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ */
+
+import { ConnectionFailedError } from '@libp2p/interface'
+import { multiaddr } from '@multiformats/multiaddr'
+import delay from 'delay'
+import map from 'it-map'
+import { pushable } from 'it-pushable'
+import type { MemoryTransportComponents, MemoryTransportInit } from './index.js'
+import type { MultiaddrConnection, PeerId } from '@libp2p/interface'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export const connections = new Map<string, MemoryConnection>()
+
+interface MemoryConnectionHandler {
+  (maConn: MultiaddrConnection): void
+}
+
+interface MemoryConnectionInit extends MemoryTransportInit {
+  onConnection: MemoryConnectionHandler
+  address: string
+}
+
+export class MemoryConnection {
+  private readonly components: MemoryTransportComponents
+  private readonly init: MemoryConnectionInit
+  private readonly connections: Set<MultiaddrConnection>
+  private readonly latency: number
+
+  constructor (components: MemoryTransportComponents, init: MemoryConnectionInit) {
+    this.components = components
+    this.init = init
+    this.connections = new Set()
+    this.latency = init.latency ?? 0
+  }
+
+  async dial (dialingPeerId: PeerId): Promise<MultiaddrConnection> {
+    const dialerPushable = pushable<Uint8Array | Uint8ArrayList>()
+    const listenerPushable = pushable<Uint8Array | Uint8ArrayList>()
+    const self = this
+
+    const dialer: MultiaddrConnection = {
+      source: (async function * () {
+        yield * map(listenerPushable, async buf => {
+          if (self.latency > 0) {
+            await delay(self.latency)
+          }
+
+          return buf
+        })
+      })(),
+      sink: async (source) => {
+        for await (const buf of source) {
+          dialerPushable.push(buf)
+        }
+      },
+      close: async () => {
+        dialerPushable.end()
+        this.connections.delete(dialer)
+        dialer.timeline.close = Date.now()
+
+        listenerPushable.end()
+        this.connections.delete(listener)
+        listener.timeline.close = Date.now()
+      },
+      abort: (err) => {
+        dialerPushable.end(err)
+        this.connections.delete(dialer)
+        dialer.timeline.close = Date.now()
+
+        listenerPushable.end(err)
+        this.connections.delete(listener)
+        listener.timeline.close = Date.now()
+      },
+      timeline: {
+        open: Date.now()
+      },
+      remoteAddr: multiaddr(`${this.init.address}/p2p/${this.components.peerId}`),
+      log: this.components.logger.forComponent(`libp2p:memory:outgoing:${1}`)
+    }
+
+    const listener: MultiaddrConnection = {
+      source: (async function * () {
+        yield * map(dialerPushable, async buf => {
+          if (self.latency > 0) {
+            await delay(self.latency)
+          }
+
+          return buf
+        })
+      })(),
+      sink: async (source) => {
+        for await (const buf of source) {
+          listenerPushable.push(buf)
+        }
+      },
+      close: async () => {
+        listenerPushable.end()
+        this.connections.delete(listener)
+        listener.timeline.close = Date.now()
+
+        dialerPushable.end()
+        this.connections.delete(dialer)
+        dialer.timeline.close = Date.now()
+      },
+      abort: (err) => {
+        listenerPushable.end(err)
+        this.connections.delete(listener)
+        listener.timeline.close = Date.now()
+
+        dialerPushable.end(err)
+        this.connections.delete(dialer)
+        dialer.timeline.close = Date.now()
+      },
+      timeline: {
+        open: Date.now()
+      },
+      remoteAddr: multiaddr(`${this.init.address}-outgoing/p2p/${dialingPeerId}`),
+      log: this.components.logger.forComponent(`libp2p:memory:outgoing:${1}`)
+    }
+
+    this.connections.add(dialer)
+    this.connections.add(listener)
+
+    await delay(this.latency)
+
+    this.init.onConnection(listener)
+
+    return dialer
+  }
+
+  close (): void {
+    [...this.connections].forEach(maConn => {
+      maConn.abort(new ConnectionFailedError('Memory Connection closed'))
+    })
+  }
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/)
+ * that operates in-memory only.
+ *
+ * This is intended for testing and can only be used to connect two libp2p nodes
+ * that are running in the same process.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/memory/address-a'
+ *     ]
+ *   },
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/memory/address-a')
+ *
+ * // dial the listener, timing out after 10s
+ * const connection = await dialer.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ */
+
+import { MemoryTransport } from './memory.js'
+import type { Transport, ComponentLogger, UpgraderOptions, PeerId } from '@libp2p/interface'
+
+export interface MemoryTransportComponents {
+  peerId: PeerId
+  logger: ComponentLogger
+}
+
+export interface MemoryTransportInit {
+  upgraderOptions?: UpgraderOptions
+  inboundUpgradeTimeout?: number
+
+  /**
+   * Add this much latency in ms to every buffer sent over the transport
+   *
+   * @default 0
+   */
+  latency?: number
+}
+
+export function memory (init?: MemoryTransportInit): (components: MemoryTransportComponents) => Transport {
+  return (components) => {
+    return new MemoryTransport(components, init)
+  }
+}

package/src/listener.ts

@@ -0,0 +1,148 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/)
+ * that operates in-memory only.
+ *
+ * This is intended for testing and can only be used to connect two libp2p nodes
+ * that are running in the same process.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/memory/node-a'
+ *     ]
+ *   },
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/memory/node-a')
+ *
+ * // dial the listener, timing out after 10s
+ * const connection = await dialer.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ *
+ * @example Simulating slow connections
+ *
+ * A `latency` argument can be passed to the factory. Each byte array that
+ * passes through the transport will be delayed by this many ms.
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { memory } from '@libp2p/memory'
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     memory({
+ *       latency: 100
+ *     })
+ *   ]
+ * })
+ * ```
+ */
+
+import { ListenError, TypedEventEmitter } from '@libp2p/interface'
+import { multiaddr } from '@multiformats/multiaddr'
+import { nanoid } from 'nanoid'
+import { MemoryConnection, connections } from './connections.js'
+import type { MemoryTransportComponents, MemoryTransportInit } from './index.js'
+import type { Listener, CreateListenerOptions, ListenerEvents, MultiaddrConnection, UpgraderOptions } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface MemoryTransportListenerInit extends CreateListenerOptions, MemoryTransportInit {
+  upgraderOptions?: UpgraderOptions
+}
+
+export class MemoryTransportListener extends TypedEventEmitter<ListenerEvents> implements Listener {
+  private listenAddr?: Multiaddr
+  private connection?: MemoryConnection
+  private readonly components: MemoryTransportComponents
+  private readonly init: MemoryTransportListenerInit
+
+  constructor (components: MemoryTransportComponents, init: MemoryTransportListenerInit) {
+    super()
+
+    this.components = components
+    this.init = init
+  }
+
+  async listen (ma: Multiaddr): Promise<void> {
+    const [[, value]] = ma.stringTuples()
+
+    const address = `/memory/${value ?? nanoid()}`
+
+    if (value != null && connections.has(address)) {
+      throw new ListenError(`Memory address ${address} already in use`)
+    }
+
+    this.connection = new MemoryConnection(this.components, {
+      ...this.init,
+      onConnection: this.onConnection.bind(this),
+      address
+    })
+    this.listenAddr = multiaddr(address)
+
+    connections.set(address, this.connection)
+
+    queueMicrotask(() => {
+      this.safeDispatchEvent('listening')
+    })
+  }
+
+  onConnection (maConn: MultiaddrConnection): void {
+    let signal: AbortSignal | undefined
+
+    if (this.init.inboundUpgradeTimeout != null) {
+      signal = AbortSignal.timeout(this.init.inboundUpgradeTimeout)
+    }
+
+    this.init.upgrader.upgradeInbound(maConn, {
+      ...this.init.upgraderOptions,
+      signal
+    })
+      .catch(err => {
+        maConn.abort(err)
+      })
+  }
+
+  getAddrs (): Multiaddr[] {
+    if (this.listenAddr == null) {
+      return []
+    }
+
+    return [
+      this.listenAddr
+    ]
+  }
+
+  async close (): Promise<void> {
+    this.connection?.close()
+
+    if (this.listenAddr != null) {
+      connections.delete(this.listenAddr.toString())
+    }
+
+    queueMicrotask(() => {
+      this.safeDispatchEvent('close')
+    })
+  }
+}