@libp2p/floodsub 10.1.46-6059227cb → 10.1.46-8484de8a2

package/src/peer-streams.ts

@@ -1,200 +0,0 @@
-import { AbortError } from '@libp2p/interface'
-import { pipe } from '@libp2p/utils'
-import * as lp from 'it-length-prefixed'
-import { pushable } from 'it-pushable'
-import { TypedEventEmitter } from 'main-event'
-import { pEvent } from 'p-event'
-import { Uint8ArrayList } from 'uint8arraylist'
-import type { PeerStreamEvents } from './index.ts'
-import type { ComponentLogger, Logger, Stream, PeerId } from '@libp2p/interface'
-import type { DecoderOptions as LpDecoderOptions } from 'it-length-prefixed'
-import type { Pushable } from 'it-pushable'
-
-export interface PeerStreamsInit {
-  id: PeerId
-  protocol: string
-}
-
-export interface PeerStreamsComponents {
-  logger: ComponentLogger
-}
-
-export interface DecoderOptions extends LpDecoderOptions {
-  // other custom options we might want for `attachInboundStream`
-}
-
-/**
- * Thin wrapper around a peer's inbound / outbound pubsub streams
- */
-export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
-  public readonly id: PeerId
-  public readonly protocol: string
-  /**
-   * Write stream - it's preferable to use the write method
-   */
-  public outboundStream?: Pushable<Uint8ArrayList>
-  /**
-   * Read stream
-   */
-  public inboundStream?: AsyncIterable<Uint8ArrayList>
-  /**
-   * The raw outbound stream, as retrieved from conn.newStream
-   */
-  private _rawOutboundStream?: Stream
-  /**
-   * The raw inbound stream, as retrieved from the callback from libp2p.handle
-   */
-  private _rawInboundStream?: Stream
-  /**
-   * An AbortController for controlled shutdown of the inbound stream
-   */
-  private readonly _inboundAbortController: AbortController
-  private closed: boolean
-  private readonly log: Logger
-
-  constructor (components: PeerStreamsComponents, init: PeerStreamsInit) {
-    super()
-
-    this.log = components.logger.forComponent('libp2p-pubsub:peer-streams')
-    this.id = init.id
-    this.protocol = init.protocol
-
-    this._inboundAbortController = new AbortController()
-    this.closed = false
-  }
-
-  /**
-   * Do we have a connection to read from?
-   */
-  get isReadable (): boolean {
-    return Boolean(this.inboundStream)
-  }
-
-  /**
-   * Do we have a connection to write on?
-   */
-  get isWritable (): boolean {
-    return Boolean(this.outboundStream)
-  }
-
-  /**
-   * Send a message to this peer.
-   * Throws if there is no `stream` to write to available.
-   */
-  write (data: Uint8Array | Uint8ArrayList): void {
-    if (this.outboundStream == null) {
-      const id = this.id.toString()
-      throw new Error('No writable connection to ' + id)
-    }
-
-    this.outboundStream.push(data instanceof Uint8Array ? new Uint8ArrayList(data) : data)
-  }
-
-  /**
-   * Attach a raw inbound stream and setup a read stream
-   */
-  attachInboundStream (stream: Stream, decoderOptions?: DecoderOptions): AsyncIterable<Uint8ArrayList> {
-    const abortListener = (): void => {
-      stream.abort(new AbortError())
-    }
-
-    this._inboundAbortController.signal.addEventListener('abort', abortListener, {
-      once: true
-    })
-
-    // Create and attach a new inbound stream
-    // The inbound stream is:
-    // - abortable, set to only return on abort, rather than throw
-    // - transformed with length-prefix transform
-    this._rawInboundStream = stream
-    this.inboundStream = pipe(
-      this._rawInboundStream,
-      (source) => lp.decode(source, decoderOptions)
-    )
-
-    this.dispatchEvent(new CustomEvent('stream:inbound'))
-    return this.inboundStream
-  }
-
-  /**
-   * Attach a raw outbound stream and setup a write stream
-   */
-  async attachOutboundStream (stream: Stream): Promise<Pushable<Uint8ArrayList>> {
-    // If an outbound stream already exists, gently close it
-    const _prevStream = this.outboundStream
-    if (this.outboundStream != null) {
-      // End the stream without emitting a close event
-      this.outboundStream.end()
-    }
-
-    this._rawOutboundStream = stream
-    this.outboundStream = pushable<Uint8ArrayList>({
-      onEnd: (shouldEmit) => {
-        // close writable side of the stream if it exists
-        this._rawOutboundStream?.close()
-          .catch(err => {
-            this.log('error closing outbound stream', err)
-          })
-
-        this._rawOutboundStream = undefined
-        this.outboundStream = undefined
-        if (shouldEmit != null) {
-          this.dispatchEvent(new CustomEvent('close'))
-        }
-      }
-    })
-
-    pipe(
-      this.outboundStream,
-      (source) => lp.encode(source),
-      async (source) => {
-        for await (const buf of source) {
-          const sendMore = stream.send(buf)
-
-          if (sendMore === false) {
-            await pEvent(stream, 'drain', {
-              rejectionEvents: [
-                'close'
-              ]
-            })
-          }
-        }
-      }
-    ).catch((err: Error) => {
-      this.log.error(err)
-    })
-
-    // Only emit if the connection is new
-    if (_prevStream == null) {
-      this.dispatchEvent(new CustomEvent('stream:outbound'))
-    }
-
-    return this.outboundStream
-  }
-
-  /**
-   * Closes the open connection to peer
-   */
-  close (): void {
-    if (this.closed) {
-      return
-    }
-
-    this.closed = true
-
-    // End the outbound stream
-    if (this.outboundStream != null) {
-      this.outboundStream.end()
-    }
-    // End the inbound stream
-    if (this.inboundStream != null) {
-      this._inboundAbortController.abort()
-    }
-
-    this._rawOutboundStream = undefined
-    this.outboundStream = undefined
-    this._rawInboundStream = undefined
-    this.inboundStream = undefined
-    this.dispatchEvent(new CustomEvent('close'))
-  }
-}

package/src/sign.ts

@@ -1,93 +0,0 @@
-import { peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toRpcMessage } from './utils.js'
-import type { PubSubRPCMessage } from './floodsub.ts'
-import type { SignedMessage } from './index.ts'
-import type { PeerId, PrivateKey, PublicKey } from '@libp2p/interface'
-
-export const SignPrefix = uint8ArrayFromString('libp2p-pubsub:')
-
-/**
- * Signs the provided message with the given `peerId`
- */
-export async function signMessage (privateKey: PrivateKey, message: { from: PeerId, topic: string, data: Uint8Array, sequenceNumber: bigint }, encode: (rpc: PubSubRPCMessage) => Uint8Array): Promise<SignedMessage> {
-  // @ts-expect-error signature field is missing, added below
-  const outputMessage: SignedMessage = {
-    type: 'signed',
-    topic: message.topic,
-    data: message.data,
-    sequenceNumber: message.sequenceNumber,
-    from: peerIdFromPrivateKey(privateKey)
-  }
-
-  // Get the message in bytes, and prepend with the pubsub prefix
-  const bytes = uint8ArrayConcat([
-    SignPrefix,
-    encode(toRpcMessage(outputMessage)).subarray()
-  ])
-
-  outputMessage.signature = await privateKey.sign(bytes)
-  outputMessage.key = privateKey.publicKey
-
-  return outputMessage
-}
-
-/**
- * Verifies the signature of the given message
- */
-export async function verifySignature (message: SignedMessage, encode: (rpc: PubSubRPCMessage) => Uint8Array): Promise<boolean> {
-  if (message.type !== 'signed') {
-    throw new Error('Message type must be "signed" to be verified')
-  }
-
-  if (message.signature == null) {
-    throw new Error('Message must contain a signature to be verified')
-  }
-
-  if (message.from == null) {
-    throw new Error('Message must contain a from property to be verified')
-  }
-
-  // Get message sans the signature
-  const bytes = uint8ArrayConcat([
-    SignPrefix,
-    encode({
-      ...toRpcMessage(message),
-      signature: undefined,
-      key: undefined
-    }).subarray()
-  ])
-
-  // Get the public key
-  const pubKey = messagePublicKey(message)
-
-  // verify the base message
-  return pubKey.verify(bytes, message.signature)
-}
-
-/**
- * Returns the PublicKey associated with the given message.
- * If no valid PublicKey can be retrieved an error will be returned.
- */
-export function messagePublicKey (message: SignedMessage): PublicKey {
-  if (message.type !== 'signed') {
-    throw new Error('Message type must be "signed" to have a public key')
-  }
-
-  // should be available in the from property of the message (peer id)
-  if (message.from == null) {
-    throw new Error('Could not get the public key from the originator id')
-  }
-
-  if (message.key != null) {
-    return message.key
-  }
-
-  if (message.from.publicKey != null) {
-    return message.from.publicKey
-  }
-
-  // We couldn't validate pubkey is from the originator, error
-  throw new Error('Could not get the public key from the originator id')
-}

package/src/utils.ts

@@ -1,157 +0,0 @@
-import { randomBytes } from '@libp2p/crypto'
-import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
-import { InvalidMessageError } from '@libp2p/interface'
-import { peerIdFromMultihash, peerIdFromPublicKey } from '@libp2p/peer-id'
-import * as Digest from 'multiformats/hashes/digest'
-import { sha256 } from 'multiformats/hashes/sha2'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import type { PubSubRPCMessage } from './floodsub.ts'
-import type { Message } from './index.ts'
-import type { PublicKey } from '@libp2p/interface'
-
-/**
- * Generate a random sequence number
- */
-export function randomSeqno (): bigint {
-  return BigInt(`0x${uint8ArrayToString(randomBytes(8), 'base16')}`)
-}
-
-/**
- * Generate a message id, based on the `key` and `seqno`
- */
-export const msgId = (key: PublicKey, seqno: bigint): Uint8Array => {
-  const seqnoBytes = uint8ArrayFromString(seqno.toString(16).padStart(16, '0'), 'base16')
-  const keyBytes = publicKeyToProtobuf(key)
-
-  const msgId = new Uint8Array(keyBytes.byteLength + seqnoBytes.length)
-  msgId.set(keyBytes, 0)
-  msgId.set(seqnoBytes, keyBytes.byteLength)
-
-  return msgId
-}
-
-/**
- * Generate a message id, based on message `data`
- */
-export const noSignMsgId = (data: Uint8Array): Uint8Array | Promise<Uint8Array> => {
-  return sha256.encode(data)
-}
-
-/**
- * Check if any member of the first set is also a member
- * of the second set
- */
-export const anyMatch = (a: Set<number> | number[], b: Set<number> | number[]): boolean => {
-  let bHas
-  if (Array.isArray(b)) {
-    bHas = (val: number) => b.includes(val)
-  } else {
-    bHas = (val: number) => b.has(val)
-  }
-
-  for (const val of a) {
-    if (bHas(val)) {
-      return true
-    }
-  }
-
-  return false
-}
-
-/**
- * Make everything an array
- */
-export const ensureArray = function <T> (maybeArray: T | T[]): T[] {
-  if (!Array.isArray(maybeArray)) {
-    return [maybeArray]
-  }
-
-  return maybeArray
-}
-
-const isSigned = async (message: PubSubRPCMessage): Promise<boolean> => {
-  if ((message.sequenceNumber == null) || (message.from == null) || (message.signature == null)) {
-    return false
-  }
-  // if a public key is present in the `from` field, the message should be signed
-  const fromID = peerIdFromMultihash(Digest.decode(message.from))
-  if (fromID.publicKey != null) {
-    return true
-  }
-
-  if (message.key != null) {
-    const signingKey = message.key
-    const signingID = peerIdFromPublicKey(publicKeyFromProtobuf(signingKey))
-
-    return signingID.equals(fromID)
-  }
-
-  return false
-}
-
-export const toMessage = async (message: PubSubRPCMessage): Promise<Message> => {
-  if (message.from == null) {
-    throw new InvalidMessageError('RPC message was missing from')
-  }
-
-  if (!await isSigned(message)) {
-    return {
-      type: 'unsigned',
-      topic: message.topic ?? '',
-      data: message.data ?? new Uint8Array(0)
-    }
-  }
-
-  const from = peerIdFromMultihash(Digest.decode(message.from))
-  const key = message.key ?? from.publicKey
-
-  if (key == null) {
-    throw new InvalidMessageError('RPC message was missing public key')
-  }
-
-  const msg: Message = {
-    type: 'signed',
-    from,
-    topic: message.topic ?? '',
-    sequenceNumber: bigIntFromBytes(message.sequenceNumber ?? new Uint8Array(0)),
-    data: message.data ?? new Uint8Array(0),
-    signature: message.signature ?? new Uint8Array(0),
-    key: key instanceof Uint8Array ? publicKeyFromProtobuf(key) : key
-  }
-
-  return msg
-}
-
-export const toRpcMessage = (message: Message): PubSubRPCMessage => {
-  if (message.type === 'signed') {
-    return {
-      from: message.from.toMultihash().bytes,
-      data: message.data,
-      sequenceNumber: bigIntToBytes(message.sequenceNumber),
-      topic: message.topic,
-      signature: message.signature,
-
-      key: message.key ? publicKeyToProtobuf(message.key) : undefined
-    }
-  }
-
-  return {
-    data: message.data,
-    topic: message.topic
-  }
-}
-
-export const bigIntToBytes = (num: bigint): Uint8Array => {
-  let str = num.toString(16)
-
-  if (str.length % 2 !== 0) {
-    str = `0${str}`
-  }
-
-  return uint8ArrayFromString(str, 'base16')
-}
-
-export const bigIntFromBytes = (num: Uint8Array): bigint => {
-  return BigInt(`0x${uint8ArrayToString(num, 'base16')}`)
-}