RelayClient = ref object of Relay
  onNewConnection*: RelayClientAddConn
  canHop: bool

RelayClientAddConn = proc (conn: Connection; duration: uint32; data: uint64): Future[
    void] {.async: (...raises: []).}

RelayClientError = object of LPError

RelayV1DialError = object of RelayClientError

RelayV2DialError = object of RelayClientError

ReservationError = object of RelayClientError

Rsvp = object
  expire*: uint64
  addrs*: seq[MultiAddress]
  voucher*: Opt[Voucher]
  limitDuration*: uint32
  limitData*: uint64

proc dialPeerV1(cl: RelayClient; conn: Connection; dstPeerId: PeerId;
                dstAddrs: seq[MultiAddress]): InternalRaisesFuture[Connection,
    (CancelledError, LPStreamError, RelayV1DialError)] {.stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

proc dialPeerV2(cl: RelayClient; conn: RelayConnection; dstPeerId: PeerId;
                dstAddrs: seq[MultiAddress]): InternalRaisesFuture[Connection,
    (CancelledError, RelayV2DialError)] {.stackTrace: false, ...raises: [], gcsafe,
    raises: [], raises: [], tags: [RootEffect].}

proc new(T: typedesc[RelayClient]; canHop: bool = false;
         reservationTTL: times.Duration = DefaultReservationTTL;
         limitDuration: uint32 = DefaultLimitDuration;
         limitData: uint64 = DefaultLimitData;
         heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime;
         maxCircuit: int = MaxCircuit;
         maxCircuitPerPeer: int = MaxCircuitPerPeer;
         msgSize: int = RelayClientMsgSize; circuitRelayV1: bool = false): T:type {.
    ...raises: [].}

proc reserve(cl: RelayClient; peerId: PeerId; addrs: seq[MultiAddress] = @[]): InternalRaisesFuture[
    Rsvp, (CancelledError, LPError)] {.stackTrace: false, ...raises: [], gcsafe,
                                       raises: [], raises: [],
                                       tags: [RootEffect].}