@libp2p/perf 1.1.15-78db573f9 → 1.1.15-8b82e68e8

package/dist/src/main.js

@@ -0,0 +1,107 @@
+import { noise } from '@chainsafe/libp2p-noise';
+import { yamux } from '@chainsafe/libp2p-yamux';
+import { unmarshalPrivateKey } from '@libp2p/crypto/keys';
+import { createFromPrivKey } from '@libp2p/peer-id-factory';
+import { tcp } from '@libp2p/tcp';
+import { multiaddr } from '@multiformats/multiaddr';
+import { createLibp2p } from 'libp2p';
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { defaultInit, perfService } from '../src/index.js';
+const argv = yargs(hideBin(process.argv))
+    .options({
+    'run-server': {
+        type: 'boolean',
+        demandOption: true,
+        default: false,
+        description: 'Whether to run as a server'
+    },
+    'server-address': {
+        type: 'string',
+        demandOption: false,
+        description: 'Server IP address',
+        default: ''
+    },
+    transport: {
+        type: 'string',
+        demandOption: false,
+        description: 'Transport to use',
+        default: 'tcp'
+    },
+    'upload-bytes': {
+        type: 'number',
+        demandOption: false,
+        description: 'Number of bytes to upload',
+        default: 0
+    },
+    'download-bytes': {
+        type: 'number',
+        demandOption: false,
+        description: 'Number of bytes to download',
+        default: 0
+    }
+})
+    .command('help', 'Print usage information', yargs.help)
+    .parseSync();
+export async function main(runServer, serverIpAddress, transport, uploadBytes, downloadBytes) {
+    const listenAddrs = [];
+    const { host, port } = splitHostPort(serverIpAddress);
+    // #TODO: right now we only support tcp
+    const tcpMultiaddr = multiaddr(`/ip4/${host}/tcp/${port}`);
+    const config = {
+        transports: [tcp()],
+        streamMuxers: [yamux()],
+        connectionEncryption: [
+            noise()
+        ],
+        services: {
+            perf: perfService(defaultInit)
+        }
+    };
+    const testPrivKey = 'CAASpgkwggSiAgEAAoIBAQC2SKo/HMFZeBml1AF3XijzrxrfQXdJzjePBZAbdxqKR1Mc6juRHXij6HXYPjlAk01BhF1S3Ll4Lwi0cAHhggf457sMg55UWyeGKeUv0ucgvCpBwlR5cQ020i0MgzjPWOLWq1rtvSbNcAi2ZEVn6+Q2EcHo3wUvWRtLeKz+DZSZfw2PEDC+DGPJPl7f8g7zl56YymmmzH9liZLNrzg/qidokUv5u1pdGrcpLuPNeTODk0cqKB+OUbuKj9GShYECCEjaybJDl9276oalL9ghBtSeEv20kugatTvYy590wFlJkkvyl+nPxIH0EEYMKK9XRWlu9XYnoSfboiwcv8M3SlsjAgMBAAECggEAZtju/bcKvKFPz0mkHiaJcpycy9STKphorpCT83srBVQi59CdFU6Mj+aL/xt0kCPMVigJw8P3/YCEJ9J+rS8BsoWE+xWUEsJvtXoT7vzPHaAtM3ci1HZd302Mz1+GgS8Epdx+7F5p80XAFLDUnELzOzKftvWGZmWfSeDnslwVONkL/1VAzwKy7Ce6hk4SxRE7l2NE2OklSHOzCGU1f78ZzVYKSnS5Ag9YrGjOAmTOXDbKNKN/qIorAQ1bovzGoCwx3iGIatQKFOxyVCyO1PsJYT7JO+kZbhBWRRE+L7l+ppPER9bdLFxs1t5CrKc078h+wuUr05S1P1JjXk68pk3+kQKBgQDeK8AR11373Mzib6uzpjGzgNRMzdYNuExWjxyxAzz53NAR7zrPHvXvfIqjDScLJ4NcRO2TddhXAfZoOPVH5k4PJHKLBPKuXZpWlookCAyENY7+Pd55S8r+a+MusrMagYNljb5WbVTgN8cgdpim9lbbIFlpN6SZaVjLQL3J8TWH6wKBgQDSChzItkqWX11CNstJ9zJyUE20I7LrpyBJNgG1gtvz3ZMUQCn3PxxHtQzN9n1P0mSSYs+jBKPuoSyYLt1wwe10/lpgL4rkKWU3/m1Myt0tveJ9WcqHh6tzcAbb/fXpUFT/o4SWDimWkPkuCb+8j//2yiXk0a/T2f36zKMuZvujqQKBgC6B7BAQDG2H2B/ijofp12ejJU36nL98gAZyqOfpLJ+FeMz4TlBDQ+phIMhnHXA5UkdDapQ+zA3SrFk+6yGk9Vw4Hf46B+82SvOrSbmnMa+PYqKYIvUzR4gg34rL/7AhwnbEyD5hXq4dHwMNsIDq+l2elPjwm/U9V0gdAl2+r50HAoGALtsKqMvhv8HucAMBPrLikhXP/8um8mMKFMrzfqZ+otxfHzlhI0L08Bo3jQrb0Z7ByNY6M8epOmbCKADsbWcVre/AAY0ZkuSZK/CaOXNX/AhMKmKJh8qAOPRY02LIJRBCpfS4czEdnfUhYV/TYiFNnKRj57PPYZdTzUsxa/yVTmECgYBr7slQEjb5Onn5mZnGDh+72BxLNdgwBkhO0OCdpdISqk0F0Pxby22DFOKXZEpiyI9XYP1C8wPiJsShGm2yEwBPWXnrrZNWczaVuCbXHrZkWQogBDG3HGXNdU4MAWCyiYlyinIBpPpoAJZSzpGLmWbMWh28+RJS6AQX6KHrK1o2uw==';
+    const encoded = uint8ArrayFromString(testPrivKey, 'base64pad');
+    const privateKey = await unmarshalPrivateKey(encoded);
+    const peerId = await createFromPrivKey(privateKey);
+    const tcpMultiaddrAddress = `${tcpMultiaddr.toString()}/p2p/${peerId.toString()}`;
+    if (runServer) {
+        listenAddrs.push(tcpMultiaddrAddress);
+        Object.assign(config, {
+            peerId,
+            addresses: {
+                listen: listenAddrs
+            }
+        });
+    }
+    const node = await createLibp2p(config);
+    await node.start();
+    const startTime = Date.now();
+    if (!runServer) {
+        const connection = await node.dial(multiaddr(tcpMultiaddrAddress));
+        const duration = await node.services.perf.measurePerformance(startTime, connection, BigInt(uploadBytes), BigInt(downloadBytes));
+        // Output latency to stdout in seconds
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify({ latency: duration / 1000 }));
+        await node.stop();
+    }
+}
+function splitHostPort(address) {
+    try {
+        const parts = address.split(':');
+        const host = parts[0];
+        const port = parts[1];
+        return {
+            host,
+            port
+        };
+    }
+    catch (error) {
+        throw Error('Invalid server address');
+    }
+}
+main(argv['run-server'], argv['server-address'], argv.transport, argv['upload-bytes'], argv['download-bytes']).catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/src/main.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/perf",
-  "version": "1.1.15-78db573f9",
+  "version": "1.1.15-8b82e68e8",
   "description": "Implementation of Perf Protocol",
   "author": "@maschad / @marcopolo",
   "license": "Apache-2.0 OR MIT",
@@ -48,17 +48,22 @@
     "renderResults": "node dist/src/renderResults.js"
   },
   "dependencies": {
-    "@libp2p/interface": "0.1.5-78db573f9",
-    "@libp2p/interface-internal": "0.1.8-78db573f9",
-    "@libp2p/logger": "3.0.5-78db573f9",
-    "@multiformats/multiaddr": "^12.1.10",
-    "it-pushable": "^3.2.1"
+    "@chainsafe/libp2p-noise": "^13.0.0",
+    "@chainsafe/libp2p-yamux": "^5.0.0",
+    "@libp2p/crypto": "2.0.7-8b82e68e8",
+    "@libp2p/interface": "0.1.5-8b82e68e8",
+    "@libp2p/interface-compliance-tests": "4.1.3-8b82e68e8",
+    "@libp2p/interface-internal": "0.1.8-8b82e68e8",
+    "@libp2p/interfaces": "3.3.2",
+    "@libp2p/logger": "3.0.5-8b82e68e8",
+    "@libp2p/peer-id-factory": "3.0.7-8b82e68e8",
+    "@libp2p/tcp": "8.0.11-8b82e68e8",
+    "@multiformats/multiaddr": "^12.1.5",
+    "libp2p": "0.46.18-8b82e68e8",
+    "uint8arrays": "^4.0.6",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@libp2p/interface-compliance-tests": "4.1.3-78db573f9",
-    "aegir": "^41.0.2",
-    "it-last": "^3.0.3",
-    "it-pair": "^2.0.6",
-    "sinon-ts": "^2.0.0"
+    "aegir": "^41.0.2"
   }
 }

package/src/constants.ts

@@ -1,5 +1,2 @@
 export const PROTOCOL_NAME = '/perf/1.0.0'
-export const WRITE_BLOCK_SIZE = 64 << 10
-export const MAX_INBOUND_STREAMS = 1
-export const MAX_OUTBOUND_STREAMS = 1
-export const RUN_ON_TRANSIENT_CONNECTION = false
+export const WRITE_BLOCK_SIZE = BigInt(64 << 10)

package/src/index.ts

@@ -1,95 +1,71 @@
 /**
  * @packageDocumentation
  *
- * The {@link PerfService} implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
+ * The `performanceService` implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which is used to measure performance within and across libp2p implementations
+ * addresses.
  *
  * @example
  *
  * ```typescript
- * import { noise } from '@chainsafe/libp2p-noise'
- * import { yamux } from '@chainsafe/libp2p-yamux'
- * import { mplex } from '@libp2p/mplex'
- * import { tcp } from '@libp2p/tcp'
- * import { createLibp2p, type Libp2p } from 'libp2p'
- * import { plaintext } from 'libp2p/insecure'
- * import { perfService, type PerfService } from '@libp2p/perf'
+ * import { createLibp2p } from 'libp2p'
+ * import { perfService } from '@libp2p/perf'
  *
- * const ONE_MEG = 1024 * 1024
- * const UPLOAD_BYTES = ONE_MEG * 1024
- * const DOWNLOAD_BYTES = ONE_MEG * 1024
+ * const node = await createLibp2p({
+ *   service: [
+ *     perfService()
+ *   ]
+ * })
+ * ```
+ *
+ * The `measurePerformance` function can be used to measure the latency and throughput of a connection.
+ * server.  This will not work in browsers.
  *
- * async function createNode (): Promise<Libp2p<{ perf: PerfService }>> {
- *   return createLibp2p({
- *     addresses: {
- *       listen: [
- *         '/ip4/0.0.0.0/tcp/0'
- *       ]
- *     },
- *     transports: [
- *       tcp()
- *     ],
- *     connectionEncryption: [
- *       noise(), plaintext()
- *     ],
- *     streamMuxers: [
- *       yamux(), mplex()
- *     ],
- *     services: {
- *       perf: perfService()
- *     }
- *   })
- * }
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { perfService } from 'libp2p/perf'
  *
- * const libp2p1 = await createNode()
- * const libp2p2 = await createNode()
+ * const node = await createLibp2p({
+ *   services: [
+ *     perf: perfService()
+ *   ]
+ * })
  *
- * for await (const output of libp2p1.services.perf.measurePerformance(libp2p2.getMultiaddrs()[0], UPLOAD_BYTES, DOWNLOAD_BYTES)) {
- *   console.info(output)
- * }
+ * const connection = await node.dial(multiaddr(multiaddrAddress))
+ *
+ * const startTime = Date.now()
+ *
+ * await node.services.perf.measurePerformance(startTime, connection, BigInt(uploadBytes), BigInt(downloadBytes))
  *
- * await libp2p1.stop()
- * await libp2p2.stop()
  * ```
  */
 
-import { PerfService as PerfServiceClass } from './perf-service.js'
-import type { AbortOptions } from '@libp2p/interface'
+import { logger } from '@libp2p/logger'
+import { PROTOCOL_NAME, WRITE_BLOCK_SIZE } from './constants.js'
+import type { Connection } from '@libp2p/interface/connection'
+import type { Startable } from '@libp2p/interface/startable'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
-import type { Registrar } from '@libp2p/interface-internal/registrar'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export interface PerfOptions extends AbortOptions {
-  /**
-   * By default measuring perf should include the time it takes to establish a
-   * connection, so a new connection will be opened for every performance run.
-   *
-   * To override this and re-use an existing connection if one is present, pass
-   * `true` here. (default: false)
-   */
-  reuseExistingConnection?: boolean
-}
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
 
-export interface PerfService {
-  measurePerformance(multiaddr: Multiaddr, sendBytes: number, recvBytes: number, options?: PerfOptions): AsyncGenerator<PerfOutput>
+const log = logger('libp2p:perf')
+
+export const defaultInit: PerfServiceInit = {
+  protocolName: '/perf/1.0.0',
+  writeBlockSize: BigInt(64 << 10)
 }
 
-export interface PerfOutput {
-  type: 'intermediary' | 'final'
-  timeSeconds: number
-  uploadBytes: number
-  downloadBytes: number
+export interface PerfService {
+  measurePerformance(startTime: number, connection: Connection, sendBytes: bigint, recvBytes: bigint, options?: AbortOptions): Promise<number>
 }
 
 export interface PerfServiceInit {
   protocolName?: string
   maxInboundStreams?: number
   maxOutboundStreams?: number
-  runOnTransientConnection?: boolean
-
-  /**
-   * Data sent/received will be sent in chunks of this size (default: 64KiB)
-   */
-  writeBlockSize?: number
+  timeout?: number
+  writeBlockSize?: bigint
 }
 
 export interface PerfServiceComponents {
@@ -97,6 +73,122 @@ export interface PerfServiceComponents {
   connectionManager: ConnectionManager
 }
 
+class DefaultPerfService implements Startable, PerfService {
+  public readonly protocol: string
+  private readonly components: PerfServiceComponents
+  private started: boolean
+  private readonly databuf: ArrayBuffer
+  private readonly writeBlockSize: bigint
+
+  constructor (components: PerfServiceComponents, init: PerfServiceInit) {
+    this.components = components
+    this.started = false
+    this.protocol = init.protocolName ?? PROTOCOL_NAME
+    this.writeBlockSize = init.writeBlockSize ?? WRITE_BLOCK_SIZE
+    this.databuf = new ArrayBuffer(Number(init.writeBlockSize))
+  }
+
+  async start (): Promise<void> {
+    await this.components.registrar.handle(this.protocol, (data: IncomingStreamData) => {
+      void this.handleMessage(data).catch((err) => {
+        log.error('error handling perf protocol message', err)
+      })
+    })
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    await this.components.registrar.unhandle(this.protocol)
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async handleMessage (data: IncomingStreamData): Promise<void> {
+    const { stream } = data
+
+    const writeBlockSize = this.writeBlockSize
+
+    let bytesToSendBack: bigint | null = null
+
+    for await (const buf of stream.source) {
+      if (bytesToSendBack === null) {
+        bytesToSendBack = BigInt(buf.getBigUint64(0, false))
+      }
+      // Ingest all the bufs and wait for the read side to close
+    }
+
+    const uint8Buf = new Uint8Array(this.databuf)
+
+    if (bytesToSendBack === null) {
+      throw new Error('bytesToSendBack was not set')
+    }
+
+    await stream.sink(async function * () {
+      while (bytesToSendBack > 0n) {
+        let toSend: bigint = writeBlockSize
+        if (toSend > bytesToSendBack) {
+          toSend = bytesToSendBack
+        }
+        bytesToSendBack = bytesToSendBack - toSend
+        yield uint8Buf.subarray(0, Number(toSend))
+      }
+    }())
+  }
+
+  async measurePerformance (startTime: number, connection: Connection, sendBytes: bigint, recvBytes: bigint, options: AbortOptions = {}): Promise<number> {
+    log('opening stream on protocol %s to %p', this.protocol, connection.remotePeer)
+
+    const uint8Buf = new Uint8Array(this.databuf)
+
+    const writeBlockSize = this.writeBlockSize
+
+    const stream = await connection.newStream([this.protocol], options)
+
+    // Convert sendBytes to uint64 big endian buffer
+    const view = new DataView(this.databuf)
+    view.setBigInt64(0, recvBytes, false)
+
+    log('sending %i bytes to %p', sendBytes, connection.remotePeer)
+    try {
+      await stream.sink((async function * () {
+        // Send the number of bytes to receive
+        yield uint8Buf.subarray(0, 8)
+        // Send the number of bytes to send
+        while (sendBytes > 0n) {
+          let toSend: bigint = writeBlockSize
+          if (toSend > sendBytes) {
+            toSend = sendBytes
+          }
+          sendBytes = sendBytes - toSend
+          yield uint8Buf.subarray(0, Number(toSend))
+        }
+      })())
+
+      // Read the received bytes
+      let actualRecvdBytes = BigInt(0)
+      for await (const buf of stream.source) {
+        actualRecvdBytes += BigInt(buf.length)
+      }
+
+      if (actualRecvdBytes !== recvBytes) {
+        throw new Error(`Expected to receive ${recvBytes} bytes, but received ${actualRecvdBytes}`)
+      }
+    } catch (err) {
+      log('error sending %i bytes to %p: %s', sendBytes, connection.remotePeer, err)
+      throw err
+    } finally {
+      log('performed %s to %p', this.protocol, connection.remotePeer)
+      await stream.close()
+    }
+
+    // Return the latency
+    return Date.now() - startTime
+  }
+}
+
 export function perfService (init: PerfServiceInit = {}): (components: PerfServiceComponents) => PerfService {
-  return (components) => new PerfServiceClass(components, init)
+  return (components) => new DefaultPerfService(components, init)
 }

package/src/main.ts

@@ -0,0 +1,118 @@
+import { noise } from '@chainsafe/libp2p-noise'
+import { yamux } from '@chainsafe/libp2p-yamux'
+import { unmarshalPrivateKey } from '@libp2p/crypto/keys'
+import { createFromPrivKey } from '@libp2p/peer-id-factory'
+import { tcp } from '@libp2p/tcp'
+import { multiaddr } from '@multiformats/multiaddr'
+import { createLibp2p } from 'libp2p'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+import { defaultInit, perfService } from '../src/index.js'
+
+const argv = yargs(hideBin(process.argv))
+  .options({
+    'run-server': {
+      type: 'boolean',
+      demandOption: true,
+      default: false,
+      description: 'Whether to run as a server'
+    },
+    'server-address': {
+      type: 'string',
+      demandOption: false,
+      description: 'Server IP address',
+      default: ''
+    },
+    transport: {
+      type: 'string',
+      demandOption: false,
+      description: 'Transport to use',
+      default: 'tcp'
+    },
+    'upload-bytes': {
+      type: 'number',
+      demandOption: false,
+      description: 'Number of bytes to upload',
+      default: 0
+    },
+    'download-bytes': {
+      type: 'number',
+      demandOption: false,
+      description: 'Number of bytes to download',
+      default: 0
+    }
+  })
+  .command('help', 'Print usage information', yargs.help)
+  .parseSync()
+
+export async function main (runServer: boolean, serverIpAddress: string, transport: string, uploadBytes: number, downloadBytes: number): Promise<void> {
+  const listenAddrs: string[] = []
+
+  const { host, port } = splitHostPort(serverIpAddress)
+  // #TODO: right now we only support tcp
+  const tcpMultiaddr = multiaddr(`/ip4/${host}/tcp/${port}`)
+
+  const config = {
+    transports: [tcp()],
+    streamMuxers: [yamux()],
+    connectionEncryption: [
+      noise()
+    ],
+    services: {
+      perf: perfService(defaultInit)
+    }
+  }
+
+  const testPrivKey = 'CAASpgkwggSiAgEAAoIBAQC2SKo/HMFZeBml1AF3XijzrxrfQXdJzjePBZAbdxqKR1Mc6juRHXij6HXYPjlAk01BhF1S3Ll4Lwi0cAHhggf457sMg55UWyeGKeUv0ucgvCpBwlR5cQ020i0MgzjPWOLWq1rtvSbNcAi2ZEVn6+Q2EcHo3wUvWRtLeKz+DZSZfw2PEDC+DGPJPl7f8g7zl56YymmmzH9liZLNrzg/qidokUv5u1pdGrcpLuPNeTODk0cqKB+OUbuKj9GShYECCEjaybJDl9276oalL9ghBtSeEv20kugatTvYy590wFlJkkvyl+nPxIH0EEYMKK9XRWlu9XYnoSfboiwcv8M3SlsjAgMBAAECggEAZtju/bcKvKFPz0mkHiaJcpycy9STKphorpCT83srBVQi59CdFU6Mj+aL/xt0kCPMVigJw8P3/YCEJ9J+rS8BsoWE+xWUEsJvtXoT7vzPHaAtM3ci1HZd302Mz1+GgS8Epdx+7F5p80XAFLDUnELzOzKftvWGZmWfSeDnslwVONkL/1VAzwKy7Ce6hk4SxRE7l2NE2OklSHOzCGU1f78ZzVYKSnS5Ag9YrGjOAmTOXDbKNKN/qIorAQ1bovzGoCwx3iGIatQKFOxyVCyO1PsJYT7JO+kZbhBWRRE+L7l+ppPER9bdLFxs1t5CrKc078h+wuUr05S1P1JjXk68pk3+kQKBgQDeK8AR11373Mzib6uzpjGzgNRMzdYNuExWjxyxAzz53NAR7zrPHvXvfIqjDScLJ4NcRO2TddhXAfZoOPVH5k4PJHKLBPKuXZpWlookCAyENY7+Pd55S8r+a+MusrMagYNljb5WbVTgN8cgdpim9lbbIFlpN6SZaVjLQL3J8TWH6wKBgQDSChzItkqWX11CNstJ9zJyUE20I7LrpyBJNgG1gtvz3ZMUQCn3PxxHtQzN9n1P0mSSYs+jBKPuoSyYLt1wwe10/lpgL4rkKWU3/m1Myt0tveJ9WcqHh6tzcAbb/fXpUFT/o4SWDimWkPkuCb+8j//2yiXk0a/T2f36zKMuZvujqQKBgC6B7BAQDG2H2B/ijofp12ejJU36nL98gAZyqOfpLJ+FeMz4TlBDQ+phIMhnHXA5UkdDapQ+zA3SrFk+6yGk9Vw4Hf46B+82SvOrSbmnMa+PYqKYIvUzR4gg34rL/7AhwnbEyD5hXq4dHwMNsIDq+l2elPjwm/U9V0gdAl2+r50HAoGALtsKqMvhv8HucAMBPrLikhXP/8um8mMKFMrzfqZ+otxfHzlhI0L08Bo3jQrb0Z7ByNY6M8epOmbCKADsbWcVre/AAY0ZkuSZK/CaOXNX/AhMKmKJh8qAOPRY02LIJRBCpfS4czEdnfUhYV/TYiFNnKRj57PPYZdTzUsxa/yVTmECgYBr7slQEjb5Onn5mZnGDh+72BxLNdgwBkhO0OCdpdISqk0F0Pxby22DFOKXZEpiyI9XYP1C8wPiJsShGm2yEwBPWXnrrZNWczaVuCbXHrZkWQogBDG3HGXNdU4MAWCyiYlyinIBpPpoAJZSzpGLmWbMWh28+RJS6AQX6KHrK1o2uw=='
+  const encoded = uint8ArrayFromString(testPrivKey, 'base64pad')
+  const privateKey = await unmarshalPrivateKey(encoded)
+  const peerId = await createFromPrivKey(privateKey)
+  const tcpMultiaddrAddress = `${tcpMultiaddr.toString()}/p2p/${peerId.toString()}`
+
+  if (runServer) {
+    listenAddrs.push(tcpMultiaddrAddress)
+
+    Object.assign(config, {
+      peerId,
+      addresses: {
+        listen: listenAddrs
+      }
+    })
+  }
+
+  const node = await createLibp2p(config)
+
+  await node.start()
+
+  const startTime = Date.now()
+
+  if (!runServer) {
+    const connection = await node.dial(multiaddr(tcpMultiaddrAddress))
+    const duration = await node.services.perf.measurePerformance(startTime, connection, BigInt(uploadBytes), BigInt(downloadBytes))
+    // Output latency to stdout in seconds
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ latency: duration / 1000 }))
+    await node.stop()
+  }
+}
+
+function splitHostPort (address: string): { host: string, port?: string } {
+  try {
+    const parts = address.split(':')
+    const host = parts[0]
+    const port = parts[1]
+    return {
+      host,
+      port
+    }
+  } catch (error) {
+    throw Error('Invalid server address')
+  }
+}
+
+main(argv['run-server'], argv['server-address'], argv.transport, argv['upload-bytes'], argv['download-bytes']).catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error(err)
+  process.exit(1)
+})

package/dist/src/perf-service.d.ts

@@ -1,21 +0,0 @@
-import type { PerfOptions, PerfOutput, PerfServiceComponents, PerfServiceInit, PerfService as PerfServiceInterface } from './index.js';
-import type { Startable } from '@libp2p/interface/startable';
-import type { IncomingStreamData } from '@libp2p/interface-internal/registrar';
-import type { Multiaddr } from '@multiformats/multiaddr';
-export declare class PerfService implements Startable, PerfServiceInterface {
-    readonly protocol: string;
-    private readonly components;
-    private started;
-    private readonly databuf;
-    private readonly writeBlockSize;
-    private readonly maxInboundStreams;
-    private readonly maxOutboundStreams;
-    private readonly runOnTransientConnection;
-    constructor(components: PerfServiceComponents, init?: PerfServiceInit);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    isStarted(): boolean;
-    handleMessage(data: IncomingStreamData): Promise<void>;
-    measurePerformance(ma: Multiaddr, sendBytes: number, receiveBytes: number, options?: PerfOptions): AsyncGenerator<PerfOutput>;
-}
-//# sourceMappingURL=perf-service.d.ts.map

package/dist/src/perf-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"perf-service.d.ts","sourceRoot":"","sources":["../../src/perf-service.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,qBAAqB,EAAE,eAAe,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACtI,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAA;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,qBAAa,WAAY,YAAW,SAAS,EAAE,oBAAoB;IACjE,SAAgB,QAAQ,EAAE,MAAM,CAAA;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuB;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAQ;IAC3C,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAS;gBAErC,UAAU,EAAE,qBAAqB,EAAE,IAAI,GAAE,eAAoB;IAWpE,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;IAavB,IAAI,IAAK,OAAO,CAAC,IAAI,CAAC;IAK5B,SAAS,IAAK,OAAO;IAIf,aAAa,CAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCrD,kBAAkB,CAAE,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,WAAgB,GAAG,cAAc,CAAC,UAAU,CAAC;CAmH3I"}