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

IdentifyError = object of LPError

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

IdentifyNoPubKeyError = object of IdentifyError

IdentifyPush = ref object of LPProtocol
  identifyHandler: IdentifyPushHandler

IdentifyPushHandler = proc (peer: PeerId; newInfo: IdentifyInfo): Future[void] {.
    ...gcsafe, raises: [], 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): Future[
    IdentifyInfo] {.stackTrace: false, ...raises: [], gcsafe, raises: [],
                    raises: [], tags: [RootEffect].}

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

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): Future[void] {.
    public(), stackTrace: false, ...raises: [], gcsafe, raises: [], raises: [],
    tags: [RootEffect].}

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

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