@libp2p/memory 0.0.0 → 1.0.0-05d559f54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/memory",
-  "version": "0.0.0",
+  "version": "1.0.0-05d559f54",
   "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",
@@ -12,7 +12,8 @@
     "url": "https://github.com/libp2p/js-libp2p/issues"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "type": "module",
   "types": "./dist/src/index.d.ts",
@@ -50,7 +51,7 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/interface": "^2.2.0",
+    "@libp2p/interface": "2.2.0-05d559f54",
     "@multiformats/multiaddr": "^12.2.3",
     "@multiformats/multiaddr-matcher": "^1.5.0",
     "@types/sinon": "^17.0.3",
@@ -61,11 +62,11 @@
     "uint8arraylist": "^2.4.8"
   },
   "devDependencies": {
-    "@libp2p/crypto": "^5.0.6",
-    "@libp2p/interface-compliance-tests": "^6.1.8",
-    "@libp2p/logger": "^5.1.3",
-    "@libp2p/peer-id": "^5.0.7",
-    "aegir": "^44.0.1"
+    "@libp2p/logger": "5.1.3-05d559f54",
+    "@libp2p/peer-id": "5.0.7-05d559f54",
+    "aegir": "^44.0.1",
+    "sinon": "^19.0.2",
+    "sinon-ts": "^2.0.0"
   },
   "browser": {
     "./dist/src/tcp.js": "./dist/src/tcp.browser.js"

package/src/connections.ts

@@ -47,7 +47,7 @@ import { multiaddr } from '@multiformats/multiaddr'
 import delay from 'delay'
 import map from 'it-map'
 import { pushable } from 'it-pushable'
-import type { MemoryTransportComponents } from './index.js'
+import type { MemoryTransportComponents, MemoryTransportInit } from './index.js'
 import type { MultiaddrConnection, PeerId } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -57,7 +57,7 @@ interface MemoryConnectionHandler {
   (maConn: MultiaddrConnection): void
 }
 
-interface MemoryConnectionInit {
+interface MemoryConnectionInit extends MemoryTransportInit {
   onConnection: MemoryConnectionHandler
   address: string
 }
@@ -66,13 +66,13 @@ export class MemoryConnection {
   private readonly components: MemoryTransportComponents
   private readonly init: MemoryConnectionInit
   private readonly connections: Set<MultiaddrConnection>
-  private latency: number
+  private readonly latency: number
 
   constructor (components: MemoryTransportComponents, init: MemoryConnectionInit) {
     this.components = components
     this.init = init
     this.connections = new Set()
-    this.latency = 0
+    this.latency = init.latency ?? 0
   }
 
   async dial (dialingPeerId: PeerId): Promise<MultiaddrConnection> {
@@ -83,7 +83,10 @@ export class MemoryConnection {
     const dialer: MultiaddrConnection = {
       source: (async function * () {
         yield * map(listenerPushable, async buf => {
-          await delay(self.latency)
+          if (self.latency > 0) {
+            await delay(self.latency)
+          }
+
           return buf
         })
       })(),
@@ -120,7 +123,10 @@ export class MemoryConnection {
     const listener: MultiaddrConnection = {
       source: (async function * () {
         yield * map(dialerPushable, async buf => {
-          await delay(self.latency)
+          if (self.latency > 0) {
+            await delay(self.latency)
+          }
+
           return buf
         })
       })(),
@@ -169,8 +175,4 @@ export class MemoryConnection {
       maConn.abort(new ConnectionFailedError('Memory Connection closed'))
     })
   }
-
-  setLatency (ms: number): void {
-    this.latency = ms
-  }
 }

package/src/index.ts

@@ -53,6 +53,13 @@ export interface MemoryTransportComponents {
 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 {

package/src/listener.ts

@@ -40,6 +40,24 @@
  *
  * // 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'
@@ -77,6 +95,7 @@ export class MemoryTransportListener extends TypedEventEmitter<ListenerEvents> i
     }
 
     this.connection = new MemoryConnection(this.components, {
+      ...this.init,
       onConnection: this.onConnection.bind(this),
       address
     })
@@ -100,12 +119,6 @@ export class MemoryTransportListener extends TypedEventEmitter<ListenerEvents> i
       ...this.init.upgraderOptions,
       signal
     })
-      .then(connection => {
-        this.init.handler?.(connection)
-        this.safeDispatchEvent('connection', {
-          detail: connection
-        })
-      })
       .catch(err => {
         maConn.abort(err)
       })

package/src/memory.ts

@@ -1,47 +1,3 @@
-/**
- * @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, serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { Memory } from '@multiformats/multiaddr-matcher'
 import { connections } from './connections.js'