libp2p 0.46.21 → 1.0.0-06e6d235f

package/src/identify/pb/message.ts

@@ -1,126 +0,0 @@
-/* eslint-disable import/export */
-/* eslint-disable complexity */
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-
-import { encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface Identify {
-  protocolVersion?: string
-  agentVersion?: string
-  publicKey?: Uint8Array
-  listenAddrs: Uint8Array[]
-  observedAddr?: Uint8Array
-  protocols: string[]
-  signedPeerRecord?: Uint8Array
-}
-
-export namespace Identify {
-  let _codec: Codec<Identify>
-
-  export const codec = (): Codec<Identify> => {
-    if (_codec == null) {
-      _codec = message<Identify>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.protocolVersion != null) {
-          w.uint32(42)
-          w.string(obj.protocolVersion)
-        }
-
-        if (obj.agentVersion != null) {
-          w.uint32(50)
-          w.string(obj.agentVersion)
-        }
-
-        if (obj.publicKey != null) {
-          w.uint32(10)
-          w.bytes(obj.publicKey)
-        }
-
-        if (obj.listenAddrs != null) {
-          for (const value of obj.listenAddrs) {
-            w.uint32(18)
-            w.bytes(value)
-          }
-        }
-
-        if (obj.observedAddr != null) {
-          w.uint32(34)
-          w.bytes(obj.observedAddr)
-        }
-
-        if (obj.protocols != null) {
-          for (const value of obj.protocols) {
-            w.uint32(26)
-            w.string(value)
-          }
-        }
-
-        if (obj.signedPeerRecord != null) {
-          w.uint32(66)
-          w.bytes(obj.signedPeerRecord)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length) => {
-        const obj: any = {
-          listenAddrs: [],
-          protocols: []
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 5:
-              obj.protocolVersion = reader.string()
-              break
-            case 6:
-              obj.agentVersion = reader.string()
-              break
-            case 1:
-              obj.publicKey = reader.bytes()
-              break
-            case 2:
-              obj.listenAddrs.push(reader.bytes())
-              break
-            case 4:
-              obj.observedAddr = reader.bytes()
-              break
-            case 3:
-              obj.protocols.push(reader.string())
-              break
-            case 8:
-              obj.signedPeerRecord = reader.bytes()
-              break
-            default:
-              reader.skipType(tag & 7)
-              break
-          }
-        }
-
-        return obj
-      })
-    }
-
-    return _codec
-  }
-
-  export const encode = (obj: Partial<Identify>): Uint8Array => {
-    return encodeMessage(obj, Identify.codec())
-  }
-
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Identify => {
-    return decodeMessage(buf, Identify.codec())
-  }
-}

package/src/insecure/index.ts

@@ -1,138 +0,0 @@
-/**
- * @packageDocumentation
- *
- * A connection encrypter that does no connection encryption.
- *
- * This should not be used in production should be used for research purposes only.
- *
- * @example
- *
- * ```typescript
- * import { createLibp2p } from 'libp2p'
- * import { plaintext } from 'libp2p/insecure'
- *
- * // Create a Uint8Array and write the swarm key to it
- * const swarmKey = new Uint8Array(95)
- * generateKey(swarmKey)
- *
- * const node = await createLibp2p({
- *   // ...other options
- *   connectionEncryption: [plaintext()]
- * })
- * ```
- */
-
-import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
-import { handshake } from 'it-handshake'
-import * as lp from 'it-length-prefixed'
-import map from 'it-map'
-import { Exchange, KeyType } from './pb/proto.js'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface/connection-encrypter'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Duplex, Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-const log = logger('libp2p:plaintext')
-const PROTOCOL = '/plaintext/2.0.0'
-
-function lpEncodeExchange (exchange: Exchange): Uint8ArrayList {
-  const pb = Exchange.encode(exchange)
-
-  return lp.encode.single(pb)
-}
-
-/**
- * Encrypt connection
- */
-async function encrypt (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
-  const shake = handshake(conn)
-
-  let type = KeyType.RSA
-
-  if (localId.type === 'Ed25519') {
-    type = KeyType.Ed25519
-  } else if (localId.type === 'secp256k1') {
-    type = KeyType.Secp256k1
-  }
-
-  // Encode the public key and write it to the remote peer
-  shake.write(
-    lpEncodeExchange({
-      id: localId.toBytes(),
-      pubkey: {
-        Type: type,
-        Data: localId.publicKey ?? new Uint8Array(0)
-      }
-    }).subarray()
-  )
-
-  log('write pubkey exchange to peer %p', remoteId)
-
-  // Get the Exchange message
-  const response = (await lp.decode.fromReader(shake.reader).next()).value
-
-  if (response == null) {
-    throw new Error('Did not read response')
-  }
-
-  const id = Exchange.decode(response)
-  log('read pubkey exchange from peer %p', remoteId)
-
-  let peerId
-  try {
-    if (id.pubkey == null) {
-      throw new Error('Public key missing')
-    }
-
-    if (id.pubkey.Data.length === 0) {
-      throw new Error('Public key data too short')
-    }
-
-    if (id.id == null) {
-      throw new Error('Remote id missing')
-    }
-
-    peerId = await peerIdFromKeys(id.pubkey.Data)
-
-    if (!peerId.equals(peerIdFromBytes(id.id))) {
-      throw new Error('Public key did not match id')
-    }
-  } catch (err: any) {
-    log.error(err)
-    throw new InvalidCryptoExchangeError('Remote did not provide its public key')
-  }
-
-  if (remoteId != null && !peerId.equals(remoteId)) {
-    throw new UnexpectedPeerError()
-  }
-
-  log('plaintext key exchange completed successfully with peer %p', peerId)
-
-  shake.rest()
-
-  return {
-    conn: {
-      sink: shake.stream.sink,
-      source: map(shake.stream.source, (buf) => buf.subarray())
-    },
-    remotePeer: peerId
-  }
-}
-
-class Plaintext implements ConnectionEncrypter {
-  public protocol: string = PROTOCOL
-
-  async secureInbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
-    return encrypt(localId, conn, remoteId)
-  }
-
-  async secureOutbound (localId: PeerId, conn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, remoteId?: PeerId): Promise<SecuredConnection> {
-    return encrypt(localId, conn, remoteId)
-  }
-}
-
-export function plaintext (): () => ConnectionEncrypter {
-  return () => new Plaintext()
-}

package/src/insecure/pb/proto.proto

@@ -1,18 +0,0 @@
-syntax = "proto3";
-
-message Exchange {
-  optional bytes id = 1;
-  optional PublicKey pubkey = 2;
-}
-
-enum KeyType {
-  RSA = 0;
-  Ed25519 = 1;
-  Secp256k1 = 2;
-  ECDSA = 3;
-}
-
-message PublicKey {
-  KeyType Type = 1;
-  bytes Data = 2;
-}

package/src/insecure/pb/proto.ts

@@ -1,161 +0,0 @@
-/* eslint-disable import/export */
-/* eslint-disable complexity */
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-
-import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-export interface Exchange {
-  id?: Uint8Array
-  pubkey?: PublicKey
-}
-
-export namespace Exchange {
-  let _codec: Codec<Exchange>
-
-  export const codec = (): Codec<Exchange> => {
-    if (_codec == null) {
-      _codec = message<Exchange>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.id != null) {
-          w.uint32(10)
-          w.bytes(obj.id)
-        }
-
-        if (obj.pubkey != null) {
-          w.uint32(18)
-          PublicKey.codec().encode(obj.pubkey, w)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length) => {
-        const obj: any = {}
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1:
-              obj.id = reader.bytes()
-              break
-            case 2:
-              obj.pubkey = PublicKey.codec().decode(reader, reader.uint32())
-              break
-            default:
-              reader.skipType(tag & 7)
-              break
-          }
-        }
-
-        return obj
-      })
-    }
-
-    return _codec
-  }
-
-  export const encode = (obj: Partial<Exchange>): Uint8Array => {
-    return encodeMessage(obj, Exchange.codec())
-  }
-
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Exchange => {
-    return decodeMessage(buf, Exchange.codec())
-  }
-}
-
-export enum KeyType {
-  RSA = 'RSA',
-  Ed25519 = 'Ed25519',
-  Secp256k1 = 'Secp256k1',
-  ECDSA = 'ECDSA'
-}
-
-enum __KeyTypeValues {
-  RSA = 0,
-  Ed25519 = 1,
-  Secp256k1 = 2,
-  ECDSA = 3
-}
-
-export namespace KeyType {
-  export const codec = (): Codec<KeyType> => {
-    return enumeration<KeyType>(__KeyTypeValues)
-  }
-}
-export interface PublicKey {
-  Type: KeyType
-  Data: Uint8Array
-}
-
-export namespace PublicKey {
-  let _codec: Codec<PublicKey>
-
-  export const codec = (): Codec<PublicKey> => {
-    if (_codec == null) {
-      _codec = message<PublicKey>((obj, w, opts = {}) => {
-        if (opts.lengthDelimited !== false) {
-          w.fork()
-        }
-
-        if (obj.Type != null && __KeyTypeValues[obj.Type] !== 0) {
-          w.uint32(8)
-          KeyType.codec().encode(obj.Type, w)
-        }
-
-        if ((obj.Data != null && obj.Data.byteLength > 0)) {
-          w.uint32(18)
-          w.bytes(obj.Data)
-        }
-
-        if (opts.lengthDelimited !== false) {
-          w.ldelim()
-        }
-      }, (reader, length) => {
-        const obj: any = {
-          Type: KeyType.RSA,
-          Data: new Uint8Array(0)
-        }
-
-        const end = length == null ? reader.len : reader.pos + length
-
-        while (reader.pos < end) {
-          const tag = reader.uint32()
-
-          switch (tag >>> 3) {
-            case 1:
-              obj.Type = KeyType.codec().decode(reader)
-              break
-            case 2:
-              obj.Data = reader.bytes()
-              break
-            default:
-              reader.skipType(tag & 7)
-              break
-          }
-        }
-
-        return obj
-      })
-    }
-
-    return _codec
-  }
-
-  export const encode = (obj: Partial<PublicKey>): Uint8Array => {
-    return encodeMessage(obj, PublicKey.codec())
-  }
-
-  export const decode = (buf: Uint8Array | Uint8ArrayList): PublicKey => {
-    return decodeMessage(buf, PublicKey.codec())
-  }
-}

package/src/ping/constants.ts

@@ -1,15 +0,0 @@
-export const PROTOCOL = '/ipfs/ping/1.0.0'
-export const PING_LENGTH = 32
-export const PROTOCOL_VERSION = '1.0.0'
-export const PROTOCOL_NAME = 'ping'
-export const PROTOCOL_PREFIX = 'ipfs'
-export const TIMEOUT = 10000
-
-// See https://github.com/libp2p/specs/blob/d4b5fb0152a6bb86cfd9ea/ping/ping.md?plain=1#L38-L43
-// The dialing peer MUST NOT keep more than one outbound stream for the ping protocol per peer.
-// The listening peer SHOULD accept at most two streams per peer since cross-stream behavior is
-// non-linear and stream writes occur asynchronously. The listening peer may perceive the
-// dialing peer closing and opening the wrong streams (for instance, closing stream B and
-// opening stream A even though the dialing peer is opening stream B and closing stream A).
-export const MAX_INBOUND_STREAMS = 2
-export const MAX_OUTBOUND_STREAMS = 1

package/src/ping/index.ts

@@ -1,170 +0,0 @@
-import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import first from 'it-first'
-import { pipe } from 'it-pipe'
-import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { codes } from '../errors.js'
-import { PROTOCOL_PREFIX, PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION, TIMEOUT, MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS } from './constants.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { Stream } from '@libp2p/interface/connection'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Startable } from '@libp2p/interface/startable'
-import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-const log = logger('libp2p:ping')
-
-export interface PingService {
-  ping(peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<number>
-}
-
-export interface PingServiceInit {
-  protocolPrefix?: string
-  maxInboundStreams?: number
-  maxOutboundStreams?: number
-  runOnTransientConnection?: boolean
-
-  /**
-   * How long we should wait for a ping response
-   */
-  timeout?: number
-}
-
-export interface PingServiceComponents {
-  registrar: Registrar
-  connectionManager: ConnectionManager
-}
-
-class DefaultPingService implements Startable, PingService {
-  public readonly protocol: string
-  private readonly components: PingServiceComponents
-  private started: boolean
-  private readonly timeout: number
-  private readonly maxInboundStreams: number
-  private readonly maxOutboundStreams: number
-  private readonly runOnTransientConnection: boolean
-
-  constructor (components: PingServiceComponents, init: PingServiceInit) {
-    this.components = components
-    this.started = false
-    this.protocol = `/${init.protocolPrefix ?? PROTOCOL_PREFIX}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-    this.timeout = init.timeout ?? TIMEOUT
-    this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
-    this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
-    this.runOnTransientConnection = init.runOnTransientConnection ?? true
-  }
-
-  async start (): Promise<void> {
-    await this.components.registrar.handle(this.protocol, this.handleMessage, {
-      maxInboundStreams: this.maxInboundStreams,
-      maxOutboundStreams: this.maxOutboundStreams,
-      runOnTransientConnection: this.runOnTransientConnection
-    })
-    this.started = true
-  }
-
-  async stop (): Promise<void> {
-    await this.components.registrar.unhandle(this.protocol)
-    this.started = false
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  /**
-   * A handler to register with Libp2p to process ping messages
-   */
-  handleMessage (data: IncomingStreamData): void {
-    log('incoming ping from %p', data.connection.remotePeer)
-
-    const { stream } = data
-    const start = Date.now()
-
-    void pipe(stream, stream)
-      .catch(err => {
-        log.error('incoming ping from %p failed with error', data.connection.remotePeer, err)
-      })
-      .finally(() => {
-        const ms = Date.now() - start
-
-        log('incoming ping from %p complete in %dms', data.connection.remotePeer, ms)
-      })
-  }
-
-  /**
-   * Ping a given peer and wait for its response, getting the operation latency.
-   *
-   * @param {PeerId|Multiaddr} peer
-   * @returns {Promise<number>}
-   */
-  async ping (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<number> {
-    log('pinging %p', peer)
-
-    const start = Date.now()
-    const data = randomBytes(PING_LENGTH)
-    const connection = await this.components.connectionManager.openConnection(peer, options)
-    let stream: Stream | undefined
-    let onAbort = (): void => {}
-
-    if (options.signal == null) {
-      const signal = AbortSignal.timeout(this.timeout)
-
-      options = {
-        ...options,
-        signal
-      }
-    }
-
-    try {
-      stream = await connection.newStream(this.protocol, {
-        ...options,
-        runOnTransientConnection: this.runOnTransientConnection
-      })
-
-      onAbort = () => {
-        stream?.abort(new CodeError('ping timeout', codes.ERR_TIMEOUT))
-      }
-
-      // make stream abortable
-      options.signal?.addEventListener('abort', onAbort, { once: true })
-
-      const result = await pipe(
-        [data],
-        stream,
-        async (source) => first(source)
-      )
-
-      const ms = Date.now() - start
-
-      if (result == null) {
-        throw new CodeError(`Did not receive a ping ack after ${ms}ms`, codes.ERR_WRONG_PING_ACK)
-      }
-
-      if (!uint8ArrayEquals(data, result.subarray())) {
-        throw new CodeError(`Received wrong ping ack after ${ms}ms`, codes.ERR_WRONG_PING_ACK)
-      }
-
-      log('ping %p complete in %dms', connection.remotePeer, ms)
-
-      return ms
-    } catch (err: any) {
-      log.error('error while pinging %p', connection.remotePeer, err)
-
-      stream?.abort(err)
-
-      throw err
-    } finally {
-      options.signal?.removeEventListener('abort', onAbort)
-      if (stream != null) {
-        await stream.close()
-      }
-    }
-  }
-}
-
-export function pingService (init: PingServiceInit = {}): (components: PingServiceComponents) => PingService {
-  return (components) => new DefaultPingService(components, init)
-}

package/src/pnet/README.md

@@ -1,68 +0,0 @@
-js-libp2p-pnet <!-- omit in toc -->
-==================
-
-> Connection protection management for libp2p leveraging PSK encryption via XSalsa20.
-
-**Note**: git history prior to merging into js-libp2p can be found in the original repository, https://github.com/libp2p/js-libp2p-pnet.
-
-## Table of Contents <!-- omit in toc -->
-
-- [Usage](#usage)
-- [Private Shared Keys](#private-shared-keys)
-- [PSK Generation](#psk-generation)
-    - [From a module using libp2p](#from-a-module-using-libp2p)
-    - [Programmatically](#programmatically)
-
-## Usage
-
-```js
-import { createLibp2p } from 'libp2p'
-import { preSharedKey, generateKey } from 'libp2p/pnet'
-
-// Create a Uint8Array and write the swarm key to it
-const swarmKey = new Uint8Array(95)
-generateKey(swarmKey)
-
-const node = await createLibp2p({
-  // ...other options
-  connectionProtector: preSharedKey({
-    psk: swarmKey
-  })
-})
-```
-
-## Private Shared Keys
-
-Private Shared Keys are expected to be in the following format:
-
-```
-/key/swarm/psk/1.0.0/
-/base16/
-dffb7e3135399a8b1612b2aaca1c36a3a8ac2cd0cca51ceeb2ced87d308cac6d
-```
-
-## PSK Generation
-
-A utility method has been created to generate a key for your private network. You can
-use one of the methods below to generate your key.
-
-#### From a module using libp2p
-
-If you have a module locally that depends on libp2p, you can run the following from
-that project, assuming the node_modules are installed.
-
-```console
-node -e "import('libp2p/pnet').then(({ generateKey }) => generateKey(process.stdout))" > swarm.key
-```
-
-#### Programmatically
-
-```js
-import fs from 'fs'
-import { generateKey } from 'libp2p/pnet'
-
-const swarmKey = new Uint8Array(95)
-generateKey(swarmKey)
-
-fs.writeFileSync('swarm.key', swarmKey)
-```