Identify = ref object of LPProtocol
  peerInfo*: PeerInfo
  sendSignedPeerRecord*: bool
  observedAddrManager*: ObservedAddrManager

IdentifyError = object of LPError

IdentifyInfo {.public.} = object
  pubkey*: Opt[PublicKey]
  peerId*: PeerId
  addrs*: seq[MultiAddress]
  observedAddr*: Opt[MultiAddress]
  protoVersion*: Opt[string]
  agentVersion*: Opt[string]
  protos*: seq[string]
  signedPeerRecord*: Opt[Envelope]

IdentifyNoPubKeyError = object of IdentifyError

IdentifyPush = ref object of LPProtocol
  identifyHandler: IdentifyPushHandler

IdentifyPushHandler = proc (peer: PeerId; newInfo: IdentifyInfo): Future[void] {.
    async: (...raises: [CancelledError]), public.}

IdentityInvalidMsgError = object of IdentifyError

IdentityNoMatchError = object of IdentifyError

AgentVersion = "nim-libp2p/0.0.1"

IdentifyCodec = "/ipfs/id/1.0.0"

IdentifyPushCodec = "/ipfs/id/push/1.0.0"

ProtoVersion = "ipfs/0.1.0"

proc decodeMsg(buf: seq[byte]): Opt[IdentifyInfo] {....raises: [],
    tags: [RootEffect, WriteIOEffect, TimeEffect].}

proc identify(self: Identify; conn: Connection; remotePeerId: PeerId): InternalRaisesFuture[
    IdentifyInfo, (CancelledError, IdentifyError, LPStreamError)] {.
    stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

proc init(p: IdentifyPush) {....raises: [], tags: [].}

proc new(T: typedesc[Identify]; peerInfo: PeerInfo;
         sendSignedPeerRecord = false;
         observedAddrManager = ObservedAddrManager.new()): T:type {....raises: [].}

proc new(T: typedesc[IdentifyPush]; handler: IdentifyPushHandler = nil): T:type {.
    public, ...raises: [].}

proc push(p: IdentifyPush; peerInfo: PeerInfo; conn: Connection): InternalRaisesFuture[
    void, (CancelledError, LPStreamError)] {.public(), stackTrace: false,
    ...raises: [], gcsafe, raises: [], raises: [], tags: [RootEffect].}

method init(p: Identify) {....raises: [], tags: [].}

template expandItIMPL(record: auto; it_name: static string; it: IdentifyInfo)