Class P2PSwitch

constructor

• new P2PSwitch(node: NodeLike): P2PSwitch

  Parameters

  • node: NodeLike

  Returns P2PSwitch

Readonlyconfig

StaticisInstance

addManualPeer

• addManualPeer(peer: P2PPeer, schedule?: boolean): void

  Add a manual peer to initiate peering process

  The switch will periodically reach out to this peer to build its peer database

  Parameters

  • peer: P2PPeer
  • schedule: boolean = true

  Returns void

DeserializeP2PConnection

• DeserializeP2PConnection(connString: string): Promise<undefined | P2PConnection>

  Parameters

  • connString: string

  Returns Promise<undefined | P2PConnection>

peers

• peers(options?: GetPeersOptions): Promise<P2PPeer[]>

  Get a list of known peers

  Parameters

  • Optionaloptions: GetPeersOptions

  Returns Promise<P2PPeer[]>

recvMessageFromPeer

• recvMessageFromPeer(
      from: P2PConnection,
      messageBuffer: ArrayBuffer | Buffer,
  ): Promise<boolean>

  Receive a message from a connection

  This message will get sent to our local node, which may then rebroadcast it

  Parameters

  • from: P2PConnection
  • messageBuffer: ArrayBuffer | Buffer

  Returns Promise<boolean>

registerConnection

• registerConnection(conn: P2PConnection): Promise<void>

  Parameters

  • conn: P2PConnection

  Returns Promise<void>

selfPeer

• selfPeer(): Promise<null | P2PPeer>

  Our own peer information

  Returns Promise<null | P2PPeer>

sendMessage

• sendMessage(
      to:
          | null
          | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>
          | P2PPeer
          | P2PConnection,
      id: string,
      type: string,
      data: any,
      ttl?: number,
      exclude?: (string | P2PConnection)[],
      skipConnectToPeers?: boolean,
  ): Promise<boolean>

  Send a message to one or more peers

  If they are already connected that connection will be re-used, otherwise a new connection will be established.

  If "to" is null then it will be sent to a sampling of peers

  Parameters

  • to:
        | null
        | Account<ECDSA_SECP256K1 | ED25519 | ECDSA_SECP256R1>
        | P2PPeer
        | P2PConnection

    Where to send the message
  • id: string

    Unique message identifier
  • type: string

    Message type
  • data: any

    Message data, must be serializable to JSON
  • Optionalttl: number

    Maximum number of hops to pass through
  • Optionalexclude: (string | P2PConnection)[]

    List of connections to exclude (e.g., because we got the message from that connection) if "to" is null
  • skipConnectToPeers: boolean = false

    Skip creating new connections to send to, only connected clients will be sent the message

  Returns Promise<boolean>

  If the message could be delivered to at least one peer

stats

• stats(): Promise<P2PSwitchStatistics>

  Returns Promise<P2PSwitchStatistics>

stop

• stop(): Promise<void>

  Stop this switch

  Returns Promise<void>

unregisterConnection

• unregisterConnection(conn: P2PConnection): Promise<void>

  Parameters

  • conn: P2PConnection

  Returns Promise<void>

wait

• wait(): Promise<void>

  Handle any waiting that needs to be done

  Returns Promise<void>

StaticparseJSONMessage

• parseJSONMessage(
      messageBuffer: ArrayBuffer | Buffer,
  ): JSONMessage | { reason: string; valid: false }

  Parameters

  • messageBuffer: ArrayBuffer | Buffer

  Returns JSONMessage | { reason: string; valid: false }

StaticRegisterP2PConnectionDeserializer

• RegisterP2PConnectionDeserializer(
      type: string,
      deserializer: DeserializerCallback,
  ): void

  Parameters

  • type: string
  • deserializer: DeserializerCallback

  Returns void