AddConn = proc (conn: Connection): Future[void] {....gcsafe, raises: [Defect].}

Relay = ref object of LPProtocol
  switch*: Switch
  peerId: PeerId
  dialer: Dial
  canHop: bool
  streamCount: int
  hopCount: CountTable[PeerId]
  addConn: AddConn
  maxCircuit*: int
  maxCircuitPerPeer*: int
  msgSize*: int

RelayError = object of LPError

RelayMessage = object
  msgType*: Option[RelayType]
  srcPeer*: Option[RelayPeer]
  dstPeer*: Option[RelayPeer]
  status*: Option[RelayStatus]

RelayPeer = object
  peerId*: PeerId
  addrs*: seq[MultiAddress]

RelayStatus = enum
  Success = 100, HopSrcAddrTooLong = 220, HopDstAddrTooLong = 221,
  HopSrcMultiaddrInvalid = 250, HopDstMultiaddrInvalid = 251,
  HopNoConnToDst = 260, HopCantDialDst = 261, HopCantOpenDstStream = 262,
  HopCantSpeakRelay = 270, HopCantRelayToSelf = 280, StopSrcAddrTooLong = 320,
  StopDstAddrTooLong = 321, StopSrcMultiaddrInvalid = 350,
  StopDstMultiaddrInvalid = 351, StopRelayRefused = 390, MalformedMessage = 400

RelayTransport = ref object of Transport
  relay*: Relay
  queue: AsyncQueue[Connection]
  relayRunning: bool

RelayType = enum
  Hop = 1, Stop = 2, Status = 3, CanHop = 4

MaxCircuit = 1024

MaxCircuitPerPeer = 64

MsgSize = 4096

RelayCodec = "/libp2p/circuit/relay/0.1.0"

proc decodeMsg(buf: seq[byte]): Option[RelayMessage] {....raises: [Defect],
    tags: [RootEffect].}

proc dial(self: RelayTransport; ma: MultiAddress): Future[Connection] {....gcsafe,
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

proc encodeMsg(msg: RelayMessage): ProtoBuffer {....raises: [Defect], tags: [].}

proc new(T: typedesc[Relay]; switch: Switch; canHop: bool): T:type {.
    ...raises: [Defect].}

proc new(T: typedesc[RelayTransport]; relay: Relay; upgrader: Upgrade): T:type {.
    ...raises: [Defect].}

proc sendStatus(conn: Connection; code: RelayStatus): Future[void] {....gcsafe,
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

method accept(self: RelayTransport): Future[Connection] {....gcsafe,
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

method dial(self: RelayTransport; hostname: string; address: MultiAddress): Future[
    Connection] {....gcsafe, stackTrace: false, ...gcsafe, raises: [Defect],
                  raises: [Defect], tags: [RootEffect].}

method handles(self: RelayTransport; ma: MultiAddress): bool {....gcsafe,
    raises: [Defect], tags: [].}

method init(r: Relay) {....raises: [Defect], tags: [].}

method start(self: RelayTransport; ma: seq[MultiAddress]): Future[void] {.
    stackTrace: false, ...gcsafe, raises: [Defect], raises: [Defect],
    tags: [RootEffect].}

method stop(self: RelayTransport): Future[void] {....gcsafe, stackTrace: false,
    ...gcsafe, raises: [Defect], raises: [Defect], tags: [RootEffect].}