Class Transport<T, K, S>Abstract

constructor

• new Transport<
      T extends PeerInfo = PeerInfo,
      K extends
      
              | TRANSPORT_P2P_PEERS_DAPP
              | TRANSPORT_P2P_PEERS_WALLET
              | TRANSPORT_POSTMESSAGE_PEERS_DAPP
              | TRANSPORT_POSTMESSAGE_PEERS_WALLET
              | TRANSPORT_WALLETCONNECT_PEERS_DAPP = any,
      S extends CommunicationClient = any,
  >(
      name: string,
      client: S,
      peerManager: PeerManager<K>,
  ): Transport<T, K, S>

  Type Parameters

  • T extends PeerInfo = PeerInfo
  • K extends
        | TRANSPORT_P2P_PEERS_DAPP
        | TRANSPORT_P2P_PEERS_WALLET
        | TRANSPORT_POSTMESSAGE_PEERS_DAPP
        | TRANSPORT_POSTMESSAGE_PEERS_WALLET
        | TRANSPORT_WALLETCONNECT_PEERS_DAPP = any
  • S extends CommunicationClient = any

  Parameters

  • name: string
  • client: S
  • peerManager: PeerManager<K>

  Returns Transport<T, K, S>

Readonlytype

connectionStatus

• get connectionStatus(): TransportStatus

  Return the status of the connection

  Returns TransportStatus

addListener

• addListener(
      listener: (message: unknown, connectionInfo: ConnectionContext) => void,
  ): Promise<void>

  Add a listener to be called when a new message is received

  Parameters

  • listener: (message: unknown, connectionInfo: ConnectionContext) => void

    The listener that will be registered

  Returns Promise<void>

addPeer

• addPeer(newPeer: T, _sendPairingResponse?: boolean): Promise<void>

  Parameters

  • newPeer: T
  • _sendPairingResponse: boolean = true

  Returns Promise<void>

connect

• connect(): Promise<void>

  Connect the transport

  Returns Promise<void>

disconnect

• disconnect(): Promise<void>

  Disconnect the transport

  Returns Promise<void>

getPeers

• getPeers(): Promise<T[]>

  Returns Promise<T[]>

Abstractlisten

• listen(publicKey: string): Promise<void>

  Parameters

  • publicKey: string

  Returns Promise<void>

removeAllPeers

• removeAllPeers(): Promise<void>

  Returns Promise<void>

removeListener

• removeListener(
      listener: (message: string, connectionInfo: ConnectionContext) => void,
  ): Promise<void>

  Remove a listener

  Parameters

  • listener: (message: string, connectionInfo: ConnectionContext) => void

  Returns Promise<void>

removePeer

• removePeer(peerToBeRemoved: T): Promise<void>

  Parameters

  • peerToBeRemoved: T

  Returns Promise<void>

send

• send(message: string, peer?: PeerInfo): Promise<void>

  Send a message through the transport

  Parameters

  • message: string

    The message to send
  • Optionalpeer: PeerInfo

  Returns Promise<void>

setEventHandler

• setEventHandler(event: ClientEvents, fun: Function): void

  Parameters

  • event: ClientEvents
  • fun: Function

  Returns void

StaticisAvailable

• isAvailable(): Promise<boolean>

  Returns a promise that resolves to true if the transport is available, false if it is not

  Returns Promise<boolean>