Index

Modules: libp2p, libp2p/autotls/acme/api, libp2p/autotls/acme/client, libp2p/autotls/acme/utils, libp2p/autotls/service, libp2p/autotls/utils, libp2p/builders, libp2p/cid, libp2p/connmanager, libp2p/crypto/chacha20poly1305, libp2p/crypto/crypto, libp2p/crypto/curve25519, libp2p/crypto/ecnist, libp2p/crypto/ed25519/constants, libp2p/crypto/ed25519/ed25519, libp2p/crypto/hkdf, libp2p/crypto/minasn1, libp2p/crypto/rsa, libp2p/crypto/secp, libp2p/dial, libp2p/dialer, libp2p/errors, libp2p/multiaddress, libp2p/multibase, libp2p/multicodec, libp2p/multihash, libp2p/multistream, libp2p/muxers/mplex/coder, libp2p/muxers/mplex/lpchannel, libp2p/muxers/mplex/mplex, libp2p/muxers/muxer, libp2p/muxers/yamux/yamux, libp2p/nameresolving/nameresolver, libp2p/observedaddrmanager, libp2p/peerid, libp2p/peeridauth/client, libp2p/peerinfo, libp2p/peerstore, libp2p/protobuf/minprotobuf, libp2p/protocols/connectivity/autonat/server, libp2p/protocols/connectivity/autonat/types, libp2p/protocols/connectivity/autonatv2/client, libp2p/protocols/connectivity/autonatv2/server, libp2p/protocols/connectivity/autonatv2/service, libp2p/protocols/connectivity/autonatv2/types, libp2p/protocols/connectivity/autonatv2/utils, libp2p/protocols/connectivity/relay/client, libp2p/protocols/connectivity/relay/messages, libp2p/protocols/connectivity/relay/rconn, libp2p/protocols/connectivity/relay/relay, libp2p/protocols/connectivity/relay/rtransport, libp2p/protocols/connectivity/relay/utils, libp2p/protocols/identify, libp2p/protocols/kademlia, libp2p/protocols/kademlia/find, libp2p/protocols/kademlia/get, libp2p/protocols/kademlia/lookupstate, libp2p/protocols/kademlia/ping, libp2p/protocols/kademlia/protobuf, libp2p/protocols/kademlia/provider, libp2p/protocols/kademlia/put, libp2p/protocols/kademlia/routingtable, libp2p/protocols/kademlia/types, libp2p/protocols/ping, libp2p/protocols/protocol, libp2p/protocols/pubsub, libp2p/protocols/pubsub/bandwidth, libp2p/protocols/pubsub/errors, libp2p/protocols/pubsub/floodsub, libp2p/protocols/pubsub/gossipsub, libp2p/protocols/pubsub/gossipsub/behavior, libp2p/protocols/pubsub/gossipsub/preamblestore, libp2p/protocols/pubsub/gossipsub/scoring, libp2p/protocols/pubsub/gossipsub/types, libp2p/protocols/pubsub/mcache, libp2p/protocols/pubsub/peertable, libp2p/protocols/pubsub/pubsub, libp2p/protocols/pubsub/pubsubpeer, libp2p/protocols/pubsub/rpc/message, libp2p/protocols/pubsub/rpc/messages, libp2p/protocols/pubsub/rpc/protobuf, libp2p/protocols/pubsub/timedcache, libp2p/protocols/rendezvous, libp2p/protocols/rendezvous/protobuf, libp2p/protocols/rendezvous/rendezvous, libp2p/protocols/secure/noise, libp2p/protocols/secure/secure, libp2p/routing_record, libp2p/services/wildcardresolverservice, libp2p/signed_envelope, libp2p/stream/bridgestream, libp2p/stream/bufferstream, libp2p/stream/chronosstream, libp2p/stream/connection, libp2p/stream/lpstream, libp2p/switch, libp2p/transcoder, libp2p/transports/memorymanager, libp2p/transports/memorytransport, libp2p/transports/quictransport, libp2p/transports/tcptransport, libp2p/transports/tls/certificate, libp2p/transports/tls/certificate_ffi, libp2p/transports/transport, libp2p/transports/wstransport, libp2p/upgrademngrs/muxedupgrade, libp2p/upgrademngrs/upgrade, libp2p/utility, libp2p/utils/bytesview, libp2p/utils/future, libp2p/utils/heartbeat, libp2p/utils/ipaddr, libp2p/utils/offsettedseq, libp2p/utils/semaphore, libp2p/utils/sequninit, libp2p/utils/zeroqueue, libp2p/varint, libp2p/vbuffer, libp2p/wire.

API symbols

`$`:

• cid: proc `$`(cid: Cid): string
• crypto: proc `$`(key: PrivateKey | PublicKey): string
• crypto: proc `$`(sig: Signature): string
• ecnist: proc `$`(seckey: EcPrivateKey): string
• ecnist: proc `$`(pubkey: EcPublicKey): string
• ecnist: proc `$`(sig: EcSignature): string
• ed25519: proc `$`(key: EdPrivateKey): string
• ed25519: proc `$`(key: EdPublicKey): string
• ed25519: proc `$`(sig: EdSignature): string
• minasn1: proc `$`(buffer: Asn1Buffer): string
• minasn1: proc `$`(field: Asn1Field): string
• rsa: proc `$`(key: RsaPrivateKey): string
• rsa: proc `$`(key: RsaPublicKey): string
• rsa: proc `$`(sig: RsaSignature): string
• secp: proc `$`(key: SkKeyPair): string
• secp: proc `$`(key: SkPrivateKey): string
• secp: proc `$`(key: SkPublicKey): string
• secp: proc `$`(key: SkSignature): string
• multiaddress: proc `$`(pat: MaPattern): string
• multiaddress: proc `$`(value: MultiAddress): string
• multicodec: proc `$`(mc: MultiCodec): string
• multihash: proc `$`(mh: MultiHash): string
• observedaddrmanager: proc `$`(self: ObservedAddrManager): string
• peerid: proc `$`(pid: PeerId): string
• routingtable: proc `$`(rt: RoutingTable): string
• peertable: proc `$`(table: PeerTable): string
• pubsubpeer: proc `$`(p: PubSubPeer): string
• vbuffer: proc `$`(vb: VBuffer): string

`&=`:

• multiaddress: proc `&=`(m1: var MultiAddress; m2: MultiAddress)

`&`:

• multiaddress: proc `&`(m1, m2: MultiAddress): MultiAddress

`<=`:

• peerid: template `<=`(a, b: PeerId): bool
• types: proc `<=`(a, b: XorDistance): bool

`<`:

• peerid: template `<`(a, b: PeerId): bool
• provider: proc `<`(a: ProviderRecord; b: chronos.Moment): bool
• provider: proc `<`(a, b: ProviderRecord): bool
• types: proc `<`(a, b: XorDistance): bool

`==`:

• cid: proc `==`(a: Cid; b: Cid): bool
• crypto: proc `==`(key1, key2: PrivateKey): bool
• crypto: proc `==`(key1, key2: PublicKey): bool
• ecnist: proc `==`(seckey1, seckey2: EcPrivateKey): bool
• ecnist: proc `==`(pubkey1, pubkey2: EcPublicKey): bool
• ecnist: proc `==`(a, b: EcSignature): bool
• ed25519: proc `==`(eda, edb: EdPrivateKey): bool
• ed25519: proc `==`(eda, edb: EdPublicKey): bool
• ed25519: proc `==`(eda, edb: EdSignature): bool
• minasn1: proc `==`(field: Asn1Field; data: openArray[byte]): bool
• rsa: proc `==`(a, b: RsaPrivateKey): bool
• rsa: proc `==`(a, b: RsaPublicKey): bool
• rsa: proc `==`(a, b: RsaSignature): bool
• secp: proc `==`(a, b: SkKeyPair): bool
• secp: proc `==`(a, b: SkPrivateKey): bool
• secp: proc `==`(a, b: SkPublicKey): bool
• secp: proc `==`(a, b: SkSignature): bool
• multiaddress: proc `==`(m1: var MultiAddress; m2: MultiAddress): bool
• multicodec: proc `==`(mc: MultiCodec; code: int): bool
• multicodec: proc `==`(a, b: MultiCodec): bool
• multicodec: proc `==`(mc: MultiCodec; name: string): bool
• multihash: proc `==`[T](mdigest: MDigest[T]; mh: MultiHash): bool
• multihash: proc `==`[T](mh: MultiHash; mdigest: MDigest[T]): bool
• multihash: proc `==`(a: MultiHash; b: MultiHash): bool
• peerid: template `==`(a, b: PeerId): bool
• types: proc `==`(a, b: AutonatV2Msg): bool
• provider: proc `==`(a, b: ProviderRecord): bool
• pubsubpeer: proc `==`(a, b: PubSubPeer): bool
• timedcache: proc `==`[E](a, b: TimedEntry[E]): bool

`>=`:

• peerid: template `>=`(a, b: PeerId): bool

`>`:

• peerid: template `>`(a, b: PeerId): bool

`[]=`:

• peerstore: proc `[]=`[T](peerBook: PeerBook[T]; peerId: PeerId; entry: T)
• preamblestore: proc `[]=`(ps: var PreambleStore; msgId: MessageId; entry: PreambleInfo)

`[]`:

• multiaddress: proc `[]`(ma: MultiAddress; i: int | BackwardsIndex): MaResult[MultiAddress]
• multiaddress: proc `[]`(ma: MultiAddress; slice: HSlice): MaResult[MultiAddress]
• multiaddress: proc `[]`(ma: MultiAddress; codec: MultiCodec): MaResult[MultiAddress]
• peerstore: proc `[]`[T](peerBook: PeerBook[T]; peerId: PeerId): T
• peerstore: proc `[]`[T](p: PeerStore; typ: type[T]): T
• provider: proc `[]`(pr: ProviderRecords; i: int): ProviderRecord
• preamblestore: proc `[]`(ps: var PreambleStore; msgId: MessageId): PreambleInfo
• offsettedseq: proc `[]`[T](o: var OffsettedSeq[T]; index: int): var T

accept:

• rtransport: method accept(self: RelayTransport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• memorymanager: proc accept(self: memoryConnManager; address: string): MemoryListener
• memorymanager: proc accept(self: MemoryListener): Future[Connection]
• memorytransport: method accept(self: MemoryTransport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• quictransport: method accept(self: QuicTransport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• tcptransport: method accept(self: TcpTransport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• transport: method accept(self: Transport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• wstransport: method accept(self: WsTransport): InternalRaisesFuture[Connection, (TransportError, CancelledError)]

ACMEApi:

• api: type ACMEApi

ACMEAuthorizationsResponse:

• api: object ACMEAuthorizationsResponse

ACMECertificate:

• api: object ACMECertificate

ACMECertificateResponse:

• api: object ACMECertificateResponse

ACMEChallenge:

• api: object ACMEChallenge

ACMEChallengeCheck:

• api: ACMECheckKind.ACMEChallengeCheck

ACMEChallengeResponse:

• api: object ACMEChallengeResponse

ACMEChallengeResponseWrapper:

• api: object ACMEChallengeResponseWrapper

ACMEChallengeStatus:

• api: enum ACMEChallengeStatus

ACMEChallengeToken:

• api: type ACMEChallengeToken

ACMEChallengeType:

• api: enum ACMEChallengeType

ACMECheckKind:

• api: enum ACMECheckKind

ACMECheckResponse:

• api: object ACMECheckResponse

ACMEClient:

• client: type ACMEClient

ACMECompletedResponse:

• api: object ACMECompletedResponse

ACMEDirectory:

• api: object ACMEDirectory

ACMEError:

• utils: object ACMEError

ACMEFinalizeResponse:

• api: object ACMEFinalizeResponse

ACMEOrderCheck:

• api: ACMECheckKind.ACMEOrderCheck

ACMEOrderResponse:

• api: object ACMEOrderResponse

ACMEOrderStatus:

• api: enum ACMEOrderStatus

ACMERegisterRequest:

• api: object ACMERegisterRequest

ACMERegisterResponse:

• api: object ACMERegisterResponse

add:

• offsettedseq: proc add[T](o: var OffsettedSeq[T]; v: T)

addCapped:

• scoring: proc addCapped[T](stat: var T; diff, cap: T)

addConnEventHandler:

• connmanager: proc addConnEventHandler(c: ConnManager; handler: ConnEventHandler; kind: ConnEventKind)
• switch: proc addConnEventHandler(s: Switch; handler: ConnEventHandler; kind: ConnEventKind)

addDirectPeer:

• gossipsub: proc addDirectPeer(g: GossipSub; id: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[ void, (CancelledError,)]

addedAt:

• timedcache: proc addedAt[K](t: var TimedCache[K]; k: K): Moment

addHandler:

• multistream: proc addHandler(m: MultistreamSelect; codecs: seq[string]; protocol: LPProtocol; matcher: Matcher = nil)
• multistream: proc addHandler[E](m: MultistreamSelect; codec: string; handler: LPProtoHandler | proc (conn: Connection; proto: string): InternalRaisesFuture[void, E]; matcher: Matcher = nil)
• multistream: proc addHandler(m: MultistreamSelect; codec: string; protocol: LPProtocol; matcher: Matcher = nil)
• peerstore: proc addHandler[T](peerBook: PeerBook[T]; handler: PeerBookChangeHandler)

addObservation:

• observedaddrmanager: proc addObservation(self: ObservedAddrManager; observedAddr: MultiAddress): bool

addObserver:

• pubsub: proc addObserver(p: PubSub; observer: PubSubObserver)

addPeer:

• peertable: proc addPeer(table: var PeerTable; topic: string; peer: PubSubPeer): bool

addPeerEventHandler:

• connmanager: proc addPeerEventHandler(c: ConnManager; handler: PeerEventHandler; kind: PeerEventKind)
• switch: proc addPeerEventHandler(s: Switch; handler: PeerEventHandler; kind: PeerEventKind)

addPossiblePeerToQuery:

• preamblestore: proc addPossiblePeerToQuery(ps: var PreambleStore; msgId: MessageId; peer: PubSubPeer)

addProvider:

• protobuf: MessageType.addProvider
• provider: proc addProvider(kad: KadDHT; cid: Cid): InternalRaisesFuture[void, (CancelledError,)]

AddressBook:

• peerstore: type AddressBook

AddressInfo:

• routing_record: object AddressInfo

AddressLimit:

• types: const AddressLimit

AddressMapper:

• peerinfo: type AddressMapper

AddrIdx:

• types: type AddrIdx

addrs:

• peerinfo: proc addrs(p: PeerInfo): seq[MultiAddress]

addSeen:

• floodsub: proc addSeen(f: FloodSub; saltedId: SaltedId): bool

addTransport:

• dial: method addTransport(self: Dial; transport: Transport)
• dialer: method addTransport(self: Dialer; t: Transport)
• switch: method addTransport(s: Switch; t: Transport)

addValidator:

• pubsub: method addValidator(p: PubSub; topic: varargs[string]; hook: ValidatorHandler)

advertise:

• rendezvous: proc advertise[E](rdv: GenericRendezVous[E]; ns: string; ttl: Duration; peers: seq[PeerId]; sprBuff: seq[byte]): InternalRaisesFuture[void, (CancelledError, AdvertiseError)]
• rendezvous: proc advertise[E](rdv: GenericRendezVous[E]; ns: string; customPeerRecord: E; ttl: Duration; peers: seq[PeerId]): InternalRaisesFuture[void, (CancelledError, AdvertiseError)]
• rendezvous: method advertise(rdv: RendezVous; ns: string; ttl: Opt[Duration] = Opt.none(Duration)): InternalRaisesFuture[ void, (CancelledError, AdvertiseError)]

AdvertiseError:

• rendezvous: object AdvertiseError

AgentBook:

• peerstore: type AgentBook

AgentVersion:

• identify: const AgentVersion

all:

• offsettedseq: proc all[T](o: OffsettedSeq[T]; pred: proc (x: T): bool): bool

AllFuturesFailedError:

• future: object AllFuturesFailedError

AlreadyExpectingConnectionError:

• connmanager: object AlreadyExpectingConnectionError

And:

• multiaddress: MaPatternOp.And

any:

• offsettedseq: proc any[T](o: OffsettedSeq[T]; pred: proc (x: T): bool): bool

anyCompleted:

• future: proc anyCompleted[T](futs: seq[T]): InternalRaisesFuture[T, (AllFuturesFailedError, CancelledError)]

append:

• multiaddress: proc append(m1: var MultiAddress; m2: MultiAddress): MaResult[void]

apply:

• offsettedseq: proc apply[T](o: OffsettedSeq[T]; op: proc (x: T))
• offsettedseq: proc apply[T](o: OffsettedSeq[T]; op: proc (x: T): T)
• offsettedseq: proc apply[T](o: OffsettedSeq[T]; op: proc (x: var T))

areAddrsConsistent:

• multiaddress: proc areAddrsConsistent(a, b: MultiAddress): bool

asAutonatV2Response:

• utils: proc asAutonatV2Response(self: DialResponse; testAddrs: seq[MultiAddress]): AutonatV2Response

Asn1Buffer:

• minasn1: object Asn1Buffer

Asn1Class:

• minasn1: enum Asn1Class

Asn1Composite:

• minasn1: object Asn1Composite

asn1EncodeBitString:

• minasn1: proc asn1EncodeBitString(dest: var openArray[byte]; value: openArray[byte]; bits = 0): int

asn1EncodeBoolean:

• minasn1: proc asn1EncodeBoolean(dest: var openArray[byte]; value: bool): int

asn1EncodeComposite:

• minasn1: proc asn1EncodeComposite(dest: var openArray[byte]; value: Asn1Composite): int

asn1EncodeContextTag:

• minasn1: proc asn1EncodeContextTag(dest: var openArray[byte]; value: openArray[byte]; tag: int): int

asn1EncodeInteger:

• minasn1: proc asn1EncodeInteger(dest: var openArray[byte]; value: openArray[byte]): int
• minasn1: proc asn1EncodeInteger[T: SomeUnsignedInt](dest: var openArray[byte]; value: T): int

asn1EncodeLength:

• minasn1: proc asn1EncodeLength(dest: var openArray[byte]; length: uint64): int

asn1EncodeNull:

• minasn1: proc asn1EncodeNull(dest: var openArray[byte]): int

asn1EncodeOctetString:

• minasn1: proc asn1EncodeOctetString(dest: var openArray[byte]; value: openArray[byte]): int

asn1EncodeOid:

• minasn1: proc asn1EncodeOid(dest: var openArray[byte]; value: openArray[byte]): int

asn1EncodeSequence:

• minasn1: proc asn1EncodeSequence(dest: var openArray[byte]; value: openArray[byte]): int

Asn1Error:

• minasn1: enum Asn1Error

Asn1False:

• minasn1: const Asn1False

Asn1Field:

• minasn1: object Asn1Field

Asn1Null:

• minasn1: const Asn1Null

Asn1OidEcPublicKey:

• minasn1: const Asn1OidEcPublicKey

Asn1OidRsaEncryption:

• minasn1: const Asn1OidRsaEncryption

Asn1OidSecp256k1:

• minasn1: const Asn1OidSecp256k1

Asn1OidSecp256r1:

• minasn1: const Asn1OidSecp256r1

Asn1OidSecp384r1:

• minasn1: const Asn1OidSecp384r1

Asn1OidSecp521r1:

• minasn1: const Asn1OidSecp521r1

Asn1Result:

• minasn1: type Asn1Result

Asn1Tag:

• minasn1: enum Asn1Tag

Asn1True:

• minasn1: const Asn1True

asNetworkReachability:

• utils: proc asNetworkReachability(self: DialResponse): NetworkReachability

atEof:

• bufferstream: method atEof(s: BufferStream): bool
• chronosstream: method atEof(s: ChronosStream): bool
• lpstream: method atEof(s: LPStream): bool

Authorization:

• api: type Authorization

Autonat:

• server: type Autonat

AutonatCodec:

• types: const AutonatCodec

AutonatDial:

• types: object AutonatDial

AutonatDialResponse:

• types: object AutonatDialResponse

AutonatError:

• types: object AutonatError

AutonatMsg:

• types: object AutonatMsg

AutonatPeerInfo:

• types: object AutonatPeerInfo

AutonatUnreachableError:

• types: object AutonatUnreachableError

AutonatV2:

• server: type AutonatV2

AutonatV2Client:

• client: type AutonatV2Client

AutonatV2Codec:

• types: enum AutonatV2Codec

AutonatV2Config:

• server: object AutonatV2Config

AutonatV2Error:

• types: object AutonatV2Error

AutonatV2Msg:

• types: object AutonatV2Msg

AutonatV2MsgLpSize:

• types: const AutonatV2MsgLpSize

AutonatV2Response:

• types: object AutonatV2Response

AutonatV2Service:

• service: type AutonatV2Service

AutonatV2ServiceConfig:

• service: object AutonatV2ServiceConfig

AutoTLSBroker:

• service: const AutoTLSBroker

AutotlsCert:

• service: type AutotlsCert

AutotlsConfig:

• service: type AutotlsConfig

AutoTLSDNSServer:

• service: const AutoTLSDNSServer

AutoTLSError:

• utils: object AutoTLSError

AutotlsService:

• service: type AutotlsService

BackoffSlackTime:

• types: const BackoffSlackTime

BackoffTable:

• types: type BackoffTable

BadRequest:

• types: ResponseStatus.BadRequest

BandwidthTracking:

• bandwidth: type BandwidthTracking

base58:

• cid: proc base58(cid: Cid): string
• multihash: proc base58(value: MultiHash): string

BasePrecomp:

• constants: const BasePrecomp

BearerToken:

• client: object BearerToken

bioToSeq:

• certificate_ffi: proc bioToSeq(bio: ptr BIO): Result[seq[byte], CertError]

BiPrecomp:

• constants: const BiPrecomp

bootstrap:

• kademlia: proc bootstrap(kad: KadDHT): InternalRaisesFuture[void, (CancelledError,)]

bootstrapNode:

• kademlia: proc bootstrapNode(kad: KadDHT; peerId: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[ void, (CancelledError,)]

bridge:

• utils: proc bridge(connSrc: Connection; connDst: Connection): InternalRaisesFuture[void, (CancelledError,)]

bridgedConnections:

• bridgestream: proc bridgedConnections(closeTogether: bool = true; dirA = Direction.In; dirB = Direction.In): (BridgeStream, BridgeStream)

BridgeStream:

• bridgestream: type BridgeStream

broadcast:

• pubsub: proc broadcast(p: PubSub; sendPeers: auto; msg: RPCMsg; isHighPriority: bool; useCustomConn: bool = false)

Bucket:

• types: object Bucket

bucketIndex:

• routingtable: proc bucketIndex(selfId, key: Key; hasher: Opt[XorDHasher]): int

BufferStream:

• bufferstream: type BufferStream

BufferStreamTrackerName:

• bufferstream: const BufferStreamTrackerName

build:

• builders: proc build(b: SwitchBuilder): Switch

byScore:

• scoring: proc byScore(x, y: PubSubPeer): int

bytes:

• multiaddress: proc bytes(value: MultiAddress): seq[byte]

byteSize:

• messages: proc byteSize(msg: Message): int
• messages: proc byteSize(rpc: RPCMsg): int
• messages: proc byteSize(ihaves: seq[ControlIHave]): int
• messages: proc byteSize(imreceivings: seq[ControlIMReceiving]): int
• messages: proc byteSize(iwants: seq[ControlIWant]): int
• messages: proc byteSize(preambles: seq[ControlPreamble]): int
• messages: proc byteSize(msgs: seq[Message]): int

BytesView:

• bytesview: object BytesView

CacheEntry:

• mcache: object CacheEntry

calculateReceiveTimeMs:

• bandwidth: proc calculateReceiveTimeMs(msgLen: int64; dataRate: int64 = InitialRate): int64

canAskIWant:

• pubsubpeer: proc canAskIWant(p: PubSubPeer; msgId: MessageId): bool

canConnect:

• protobuf: ConnectionType.canConnect

CandidatePeers:

• types: type CandidatePeers

cannotConnect:

• protobuf: ConnectionType.cannotConnect

capLen:

• utility: proc capLen[T](s: var seq[T]; length: Natural)

CertError:

• certificate_ffi: type CertError

CERT_ERROR_ASN1_ENCODE:

• certificate_ffi: const CERT_ERROR_ASN1_ENCODE

CERT_ERROR_ASN1_OCTET:

• certificate_ffi: const CERT_ERROR_ASN1_OCTET

CERT_ERROR_ASN1_TIME_GEN:

• certificate_ffi: const CERT_ERROR_ASN1_TIME_GEN

CERT_ERROR_BIGNUM_CONV:

• certificate_ffi: const CERT_ERROR_BIGNUM_CONV

CERT_ERROR_BIGNUM_GEN:

• certificate_ffi: const CERT_ERROR_BIGNUM_GEN

CERT_ERROR_BIO_GEN:

• certificate_ffi: const CERT_ERROR_BIO_GEN

CERT_ERROR_BIO_WRITE:

• certificate_ffi: const CERT_ERROR_BIO_WRITE

CERT_ERROR_CERT_GEN:

• certificate_ffi: const CERT_ERROR_CERT_GEN

CERT_ERROR_CN_EMPTY:

• certificate_ffi: const CERT_ERROR_CN_EMPTY

CERT_ERROR_CN_EMPTY_LABEL:

• certificate_ffi: const CERT_ERROR_CN_EMPTY_LABEL

CERT_ERROR_CN_LABEL_TOO_LONG:

• certificate_ffi: const CERT_ERROR_CN_LABEL_TOO_LONG

CERT_ERROR_CN_TOO_LONG:

• certificate_ffi: const CERT_ERROR_CN_TOO_LONG

CERT_ERROR_DECODE_SEQUENCE:

• certificate_ffi: const CERT_ERROR_DECODE_SEQUENCE

CERT_ERROR_DRBG_CONFIG:

• certificate_ffi: const CERT_ERROR_DRBG_CONFIG

CERT_ERROR_DRBG_INIT:

• certificate_ffi: const CERT_ERROR_DRBG_INIT

CERT_ERROR_DRBG_SEED:

• certificate_ffi: const CERT_ERROR_DRBG_SEED

CERT_ERROR_ECKEY_GEN:

• certificate_ffi: const CERT_ERROR_ECKEY_GEN

CERT_ERROR_ENCODING:

• certificate_ffi: const CERT_ERROR_ENCODING

CERT_ERROR_EVP_PKEY_EC_KEY:

• certificate_ffi: const CERT_ERROR_EVP_PKEY_EC_KEY

CERT_ERROR_EXTENSION_ADD:

• certificate_ffi: const CERT_ERROR_EXTENSION_ADD

CERT_ERROR_EXTENSION_DATA:

• certificate_ffi: const CERT_ERROR_EXTENSION_DATA

CERT_ERROR_EXTENSION_GEN:

• certificate_ffi: const CERT_ERROR_EXTENSION_GEN

CERT_ERROR_EXTENSION_GET:

• certificate_ffi: const CERT_ERROR_EXTENSION_GET

CERT_ERROR_EXTENSION_NOT_FOUND:

• certificate_ffi: const CERT_ERROR_EXTENSION_NOT_FOUND

CERT_ERROR_INIT_KEYGEN:

• certificate_ffi: const CERT_ERROR_INIT_KEYGEN

CERT_ERROR_KEY_GEN:

• certificate_ffi: const CERT_ERROR_KEY_GEN

CERT_ERROR_MEMORY:

• certificate_ffi: const CERT_ERROR_MEMORY

CERT_ERROR_NID:

• certificate_ffi: const CERT_ERROR_NID

CERT_ERROR_NO_PUBKEY:

• certificate_ffi: const CERT_ERROR_NO_PUBKEY

CERT_ERROR_NOT_ENOUGH_SEQ_ELEMS:

• certificate_ffi: const CERT_ERROR_NOT_ENOUGH_SEQ_ELEMS

CERT_ERROR_NOT_OCTET_STR:

• certificate_ffi: const CERT_ERROR_NOT_OCTET_STR

CERT_ERROR_NULL_PARAM:

• certificate_ffi: const CERT_ERROR_NULL_PARAM

CERT_ERROR_PARSE:

• certificate_ffi: const CERT_ERROR_PARSE

CERT_ERROR_PUBKEY_DER_CONV:

• certificate_ffi: const CERT_ERROR_PUBKEY_DER_CONV

CERT_ERROR_PUBKEY_DER_LEN:

• certificate_ffi: const CERT_ERROR_PUBKEY_DER_LEN

CERT_ERROR_PUBKEY_GET:

• certificate_ffi: const CERT_ERROR_PUBKEY_GET

CERT_ERROR_PUBKEY_SET:

• certificate_ffi: const CERT_ERROR_PUBKEY_SET

CERT_ERROR_RAND:

• certificate_ffi: const CERT_ERROR_RAND

CERT_ERROR_SERIAL_WRITE:

• certificate_ffi: const CERT_ERROR_SERIAL_WRITE

CERT_ERROR_SET_CURVE:

• certificate_ffi: const CERT_ERROR_SET_CURVE

CERT_ERROR_SET_KEY:

• certificate_ffi: const CERT_ERROR_SET_KEY

CERT_ERROR_SIGN:

• certificate_ffi: const CERT_ERROR_SIGN

CERT_ERROR_VALIDITY_PERIOD:

• certificate_ffi: const CERT_ERROR_VALIDITY_PERIOD

CERT_ERROR_X509_CN:

• certificate_ffi: const CERT_ERROR_X509_CN

CERT_ERROR_X509_ISSUER:

• certificate_ffi: const CERT_ERROR_X509_ISSUER

CERT_ERROR_X509_NAME:

• certificate_ffi: const CERT_ERROR_X509_NAME

CERT_ERROR_X509_READ:

• certificate_ffi: const CERT_ERROR_X509_READ

CERT_ERROR_X509_REQ_DER:

• certificate_ffi: const CERT_ERROR_X509_REQ_DER

CERT_ERROR_X509_REQ_GEN:

• certificate_ffi: const CERT_ERROR_X509_REQ_GEN

CERT_ERROR_X509_SAN:

• certificate_ffi: const CERT_ERROR_X509_SAN

CERT_ERROR_X509_SUBJECT:

• certificate_ffi: const CERT_ERROR_X509_SUBJECT

CERT_ERROR_X509_VER:

• certificate_ffi: const CERT_ERROR_X509_VER

CERT_FORMAT_DER:

• certificate_ffi: cert_format_t.CERT_FORMAT_DER

CERT_FORMAT_PEM:

• certificate_ffi: cert_format_t.CERT_FORMAT_PEM

cert_format_t:

• certificate_ffi: enum cert_format_t

cert_free_key:

• certificate_ffi: proc cert_free_key(key: CertificateKey): void

cert_generate:

• certificate_ffi: proc cert_generate(key: CertificateKey; signature: seq[byte]; ident_pubk: seq[byte]; cn: string; validFrom: cstring; validTo: cstring; format: cert_format_t): Result[seq[byte], CertError]

cert_generate_key:

• certificate_ffi: proc cert_generate_key(): Result[CertificateKey, CertError]

CertificateCreationError:

• certificate: object CertificateCreationError

CertificateKey:

• certificate_ffi: object CertificateKey

CertificateParsingError:

• certificate: object CertificateParsingError

CertificatePubKeySerializationError:

• certificate: object CertificatePubKeySerializationError

CertificateX509:

• certificate: object CertificateX509

cert_new_key_t:

• certificate_ffi: proc cert_new_key_t(seckey: seq[byte]): Result[CertificateKey, CertError]

cert_parse:

• certificate_ffi: proc cert_parse(cert: seq[byte]; format: cert_format_t): Result[ParsedCertificate, CertError]

cert_serialize_privk:

• certificate_ffi: proc cert_serialize_privk(key: CertificateKey; format: cert_format_t): Result[ seq[byte], CertError]

cert_serialize_pubk:

• certificate_ffi: proc cert_serialize_pubk(key: CertificateKey; format: cert_format_t): Result[ seq[byte], CertError]

cert_signing_req:

• certificate_ffi: proc cert_signing_req(cn: string; key: CertificateKey): Result[seq[byte], CertError]

ChaChaPoly:

• chacha20poly1305: object ChaChaPoly

ChaChaPolyKey:

• chacha20poly1305: type ChaChaPolyKey

ChaChaPolyNonce:

• chacha20poly1305: type ChaChaPolyNonce

ChaChaPolyTag:

• chacha20poly1305: type ChaChaPolyTag

checkFieldNumber:

• minprotobuf: template checkFieldNumber(i: int)

checkFutures:

• errors: macro checkFutures[F](futs: seq[F]; exclude: untyped = []): untyped

checkPeerRecord:

• rendezvous: proc checkPeerRecord(_: PeerRecord; spr: seq[byte]; peerId: PeerId): Result[void, string]

checkScalar:

• ed25519: proc checkScalar(scalar: openArray[byte]): uint32

checkSignature:

• client: proc checkSignature(serverSig: PeerIDAuthSignature; serverPublicKey: PublicKey; challengeServer: PeerIDAuthChallenge; clientPublicKey: PublicKey; hostname: string): bool

checkValid:

• messages: proc checkValid(spr: SignedVoucher): Result[void, EnvelopeError]
• routing_record: proc checkValid(spr: SignedPeerRecord): Result[void, EnvelopeError]

ChronosStream:

• chronosstream: type ChronosStream

ChronosStreamTrackerName:

• chronosstream: const ChronosStreamTrackerName

Cid:

• cid: object Cid

CidError:

• cid: enum CidError

CIDv0:

• cid: CidVersion.CIDv0

CIDv1:

• cid: CidVersion.CIDv1

CidVersion:

• cid: enum CidVersion

CIDvIncorrect:

• cid: CidVersion.CIDvIncorrect

CIDvReserved:

• cid: CidVersion.CIDvReserved

CircuitRelay:

• multiaddress: const CircuitRelay

cleanup:

• peerstore: proc cleanup(peerStore: PeerStore; peerId: PeerId)

clear:

• ecnist: proc clear[T: EcPKI | EcKeyPair](pki: var T)
• ed25519: proc clear(pair: var EdKeyPair)
• ed25519: proc clear(key: var EdPrivateKey)
• ed25519: proc clear(key: var EdPublicKey)
• ed25519: proc clear(sig: var EdSignature)
• rsa: proc clear[T: RsaPKI | RsaKeyPair](pki: var T)
• secp: proc clear(key: var SkPrivateKey)
• zeroqueue: proc clear(q: var ZeroQueue)

close:

• connmanager: proc close(c: ConnManager): InternalRaisesFuture[void, (CancelledError,)]
• lpchannel: method close(s: LPChannel): InternalRaisesFuture[void, void]
• mplex: method close(m: Mplex): InternalRaisesFuture[void, void]
• muxer: method close(m: Muxer): InternalRaisesFuture[void, void]
• yamux: method close(m: Yamux): InternalRaisesFuture[void, void]
• client: proc close(self: PeerIDAuthClient): InternalRaisesFuture[void, (CancelledError,)]
• lpstream: method close(s: LPStream): InternalRaisesFuture[void, void]
• memorymanager: proc close(self: MemoryListener)
• quictransport: method close(m: QuicMuxer): InternalRaisesFuture[void, void]
• quictransport: method close(session: QuicSession): InternalRaisesFuture[void, void]

closed:

• lpchannel: method closed(s: LPChannel): bool
• chronosstream: method closed(s: ChronosStream): bool
• lpstream: method closed(s: LPStream): bool
• quictransport: method closed(session: QuicSession): bool

closeImpl:

• yamux: method closeImpl(channel: YamuxChannel): InternalRaisesFuture[void, void]
• rconn: method closeImpl(self: RelayConnection): InternalRaisesFuture[void, void]
• noise: method closeImpl(s: NoiseConnection): InternalRaisesFuture[void, void]
• secure: method closeImpl(s: SecureConn): InternalRaisesFuture[void, void]
• bridgestream: method closeImpl(s: BridgeStream): InternalRaisesFuture[void, void]
• bufferstream: method closeImpl(s: BufferStream): InternalRaisesFuture[void, void]
• chronosstream: method closeImpl(s: ChronosStream): InternalRaisesFuture[void, void]
• connection: method closeImpl(s: Connection): InternalRaisesFuture[void, void]
• lpstream: method closeImpl(s: LPStream): InternalRaisesFuture[void, void]
• quictransport: method closeImpl(stream: QuicStream): InternalRaisesFuture[void, void]
• wstransport: method closeImpl(s: WsStream): InternalRaisesFuture[void, void]

closeWithEOF:

• lpstream: proc closeWithEOF(s: LPStream): InternalRaisesFuture[void, void]

closeWrite:

• lpchannel: method closeWrite(s: LPChannel): InternalRaisesFuture[void, void]
• yamux: method closeWrite(channel: YamuxChannel): InternalRaisesFuture[void, void]
• chronosstream: method closeWrite(s: ChronosStream): InternalRaisesFuture[void, void]
• connection: method closeWrite(s: Connection): InternalRaisesFuture[void, void]
• quictransport: method closeWrite(stream: QuicStream): InternalRaisesFuture[void, void]

cmp:

• peerid: proc cmp(a, b: PeerId): int
• types: proc cmp(a, b: XorDistance): int

code:

• minasn1: proc code(tag: Asn1Tag): byte

codec:

• multicodec: proc codec(mt: typedesc[MultiCodec]; code: int): MultiCodec
• multicodec: proc codec(mt: typedesc[MultiCodec]; name: string): MultiCodec
• protocol: proc codec(p: LPProtocol): string

codec=:

• protocol: proc codec=(p: LPProtocol; codec: string)

collectCompleted:

• utility: proc collectCompleted[T, E](futs: seq[InternalRaisesFuture[T, E]]; timeout: chronos.Duration): InternalRaisesFuture[seq[T], (CancelledError,)]

compilesOr:

• utility: template compilesOr(a, b: untyped): untyped

concat:

• multiaddress: proc concat(m1, m2: MultiAddress): MaResult[MultiAddress]

ConcurrentUpgrades:

• switch: const ConcurrentUpgrades

connCount:

• connmanager: proc connCount(c: ConnManager; peerId: PeerId): int

connect:

• dial: method connect(self: Dial; address: MultiAddress; allowUnknownPeerId = false): InternalRaisesFuture[ PeerId, (DialFailedError, CancelledError)]
• dial: method connect(self: Dial; peerId: PeerId; addrs: seq[MultiAddress]; forceDial = false; reuseConnection = true; dir = Direction.Out): InternalRaisesFuture[void, (DialFailedError, CancelledError)]
• dialer: method connect(self: Dialer; address: MultiAddress; allowUnknownPeerId = false): InternalRaisesFuture[ PeerId, (DialFailedError, CancelledError)]
• dialer: method connect(self: Dialer; peerId: PeerId; addrs: seq[MultiAddress]; forceDial = false; reuseConnection = true; dir = Direction.Out): InternalRaisesFuture[ void, (DialFailedError, CancelledError)]
• pubsubpeer: proc connect(p: PubSubPeer)
• switch: method connect(s: Switch; address: MultiAddress; allowUnknownPeerId = false): InternalRaisesFuture[ PeerId, (DialFailedError, CancelledError)]
• switch: method connect(s: Switch; peerId: PeerId; addrs: seq[MultiAddress]; forceDial = false; reuseConnection = true; dir = Direction.Out): InternalRaisesFuture[void, (DialFailedError, CancelledError)]
• wire: proc connect(ma: MultiAddress; bufferSize = DefaultStreamBufferSize; child: StreamTransport = nil; flags = default(set[SocketFlags]); localAddress: Opt[MultiAddress] = Opt.none(MultiAddress)): InternalRaisesFuture[ StreamTransport, (MaInvalidAddress, TransportError, CancelledError, LPError)]

connected:

• protobuf: ConnectionType.connected
• pubsubpeer: proc connected(p: PubSubPeer): bool

connectedPeers:

• connmanager: proc connectedPeers(c: ConnManager; dir: Direction): seq[PeerId]
• switch: proc connectedPeers(s: Switch; dir: Direction): seq[PeerId]

Connection:

• connection: type Connection

ConnectionFailed:

• messages: StatusV2.ConnectionFailed

ConnectionSlot:

• connmanager: object ConnectionSlot

ConnectionTrackerName:

• connection: const ConnectionTrackerName

ConnectionType:

• protobuf: enum ConnectionType

ConnEvent:

• connmanager: object ConnEvent

ConnEventHandler:

• connmanager: type ConnEventHandler

ConnEventKind:

• connmanager: enum ConnEventKind

connHandler:

• tcptransport: proc connHandler(self: TcpTransport; client: StreamTransport; observedAddr: Opt[MultiAddress]; localAddr: Opt[MultiAddress]; dir: Direction): Connection

ConnManager:

• connmanager: type ConnManager

consume:

• bytesview: proc consume(v: var BytesView; n: int)

consumeTo:

• zeroqueue: proc consumeTo(q: var ZeroQueue; pbytes: pointer; nbytes: int): int

contains:

• connmanager: proc contains(c: ConnManager; muxer: Muxer): bool
• connmanager: proc contains(c: ConnManager; peerId: PeerId): bool
• multiaddress: proc contains(ma: MultiAddress; codec: MultiCodec): MaResult[bool]
• peerstore: proc contains[T](peerBook: PeerBook[T]; peerId: PeerId): bool
• mcache: proc contains(c: MCache; msgId: MessageId): bool
• timedcache: proc contains[K](t: TimedCache[K]; k: K): bool

contentType:

• cid: proc contentType(cid: Cid): Result[MultiCodec, CidError]

ControlGraft:

• messages: object ControlGraft

ControlIHave:

• messages: object ControlIHave

ControlIMReceiving:

• messages: object ControlIMReceiving

ControlIWant:

• messages: object ControlIWant

ControlMessage:

• messages: object ControlMessage

ControlPreamble:

• messages: object ControlPreamble

ControlPrune:

• messages: object ControlPrune

Cookie:

• protobuf: object Cookie

copy:

• ecnist: proc copy[T: EcPKI](src: T): T
• ecnist: proc copy[T: EcPKI](dst: var T; src: T): bool
• rsa: proc copy[T: RsaPKI](key: T): T

count:

• offsettedseq: proc count[T](o: OffsettedSeq[T]; x: T): int

countLeadingZeroBits:

• types: proc countLeadingZeroBits(b: byte): int

countRegister:

• rendezvous: proc countRegister[E](rdv: GenericRendezVous[E]; peerId: PeerId): int

createStreamServer:

• wire: proc createStreamServer[T](ma: MultiAddress; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = 100; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil): StreamServer
• wire: proc createStreamServer[T](ma: MultiAddress; cbproc: StreamCallback; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = 100; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil): StreamServer

CryptoError:

• crypto: enum CryptoError

CryptoResult:

• crypto: type CryptoResult

Curve25519:

• curve25519: object Curve25519

Curve25519Error:

• curve25519: enum Curve25519Error

Curve25519Key:

• curve25519: type Curve25519Key

Curve25519KeySize:

• curve25519: const Curve25519KeySize

CurveOrder:

• constants: const CurveOrder

Curver25519GenError:

• curve25519: Curve25519Error.Curver25519GenError

CustomConnCreationProc:

• pubsubpeer: type CustomConnCreationProc

CustomConnectionCallbacks:

• pubsubpeer: object CustomConnectionCallbacks

CustomPeerSelectionProc:

• pubsubpeer: type CustomPeerSelectionProc

D2Const:

• constants: const D2Const

data:

• multiaddress: proc data(ma: MultiAddress): VBuffer
• bytesview: template data(v: BytesView): openArray[byte]

DConst:

• constants: const DConst

decode:

• multibase: proc decode(mbtype: typedesc[MultiBase]; inbytes: openArray[char]): Result[seq[byte], string]
• multibase: proc decode(mbtype: typedesc[MultiBase]; inbytes: openArray[char]; outbytes: var openArray[byte]; outlen: var int): MultiBaseStatus
• multihash: proc decode(mhtype: typedesc[MultiHash]; data: openArray[byte]; mhash: var MultiHash): MhResult[ int]
• types: proc decode(_: typedesc[AutonatMsg]; buf: seq[byte]): Opt[AutonatMsg]
• types: proc decode(T: typedesc[AutonatV2Msg]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialBack]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialBackResponse]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialDataRequest]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialDataResponse]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialRequest]; pb: ProtoBuffer): Opt[T]
• types: proc decode(T: typedesc[DialResponse]; pb: ProtoBuffer): Opt[T]
• messages: proc decode(_: typedesc[HopMessage]; buf: seq[byte]): Opt[HopMessage]
• messages: proc decode(_: typedesc[RelayMessage]; buf: seq[byte]): Opt[RelayMessage]
• messages: proc decode(_: typedesc[StopMessage]; buf: seq[byte]): Opt[StopMessage]
• messages: proc decode(_: typedesc[Voucher]; buf: seq[byte]): Result[Voucher, ProtoError]
• protobuf: proc decode(T: type Message; pb: ProtoBuffer): ProtoResult[T]
• protobuf: proc decode(T: type Message; buf: seq[byte]): ProtoResult[T]
• protobuf: proc decode(T: type Peer; pb: ProtoBuffer): ProtoResult[T]
• protobuf: proc decode(T: type Record; pb: ProtoBuffer): ProtoResult[T]
• protobuf: proc decode(_: typedesc[Cookie]; buf: seq[byte]): Opt[Cookie]
• protobuf: proc decode(_: typedesc[Discover]; buf: seq[byte]): Opt[Discover]
• protobuf: proc decode(_: typedesc[DiscoverResponse]; buf: seq[byte]): Opt[DiscoverResponse]
• protobuf: proc decode(_: typedesc[Message]; buf: seq[byte]): Opt[Message]
• protobuf: proc decode(_: typedesc[Register]; buf: seq[byte]): Opt[Register]
• protobuf: proc decode(_: typedesc[RegisterResponse]; buf: seq[byte]): Opt[RegisterResponse]
• protobuf: proc decode(_: typedesc[Unregister]; buf: seq[byte]): Opt[Unregister]
• routing_record: proc decode(T: typedesc[PeerRecord]; buffer: seq[byte]): Result[PeerRecord, ProtoError]
• signed_envelope: proc decode(T: typedesc[Envelope]; buf: seq[byte]; domain: string): Result[Envelope, EnvelopeError]
• signed_envelope: proc decode[T](_: typedesc[SignedPayload[T]]; buffer: seq[byte]): Result[ SignedPayload[T], EnvelopeError]

decodeControl:

• protobuf: proc decodeControl(pb: ProtoBuffer): ProtoResult[Option[ControlMessage]]

decodedLength:

• multibase: proc decodedLength(mbtype: typedesc[MultiBase]; encoding: char; length: int): int

decodeGraft:

• protobuf: proc decodeGraft(pb: ProtoBuffer): ProtoResult[ControlGraft]

decodeIHave:

• protobuf: proc decodeIHave(pb: ProtoBuffer): ProtoResult[ControlIHave]

decodeIMReceiving:

• protobuf: proc decodeIMReceiving(pb: ProtoBuffer): ProtoResult[ControlIMReceiving]

decodeIWant:

• protobuf: proc decodeIWant(pb: ProtoBuffer): ProtoResult[ControlIWant]

decodeMessage:

• protobuf: proc decodeMessage(pb: ProtoBuffer): ProtoResult[Message]

decodeMessages:

• protobuf: proc decodeMessages(pb: ProtoBuffer): ProtoResult[seq[Message]]

decodeMsg:

• identify: proc decodeMsg(buf: seq[byte]): Opt[IdentifyInfo]

decodePeerInfoMsg:

• protobuf: proc decodePeerInfoMsg(pb: ProtoBuffer): ProtoResult[PeerInfoMsg]

decodePreamble:

• protobuf: proc decodePreamble(pb: ProtoBuffer): ProtoResult[ControlPreamble]

decodePrune:

• protobuf: proc decodePrune(pb: ProtoBuffer): ProtoResult[ControlPrune]

decodeRpcMsg:

• protobuf: proc decodeRpcMsg(msg: seq[byte]): ProtoResult[RPCMsg]

decodeSubscription:

• protobuf: proc decodeSubscription(pb: ProtoBuffer): ProtoResult[SubOpts]

decodeSubscriptions:

• protobuf: proc decodeSubscriptions(pb: ProtoBuffer): ProtoResult[seq[SubOpts]]

decrypt:

• chacha20poly1305: proc decrypt(_: type[ChaChaPoly]; key: ChaChaPolyKey; nonce: ChaChaPolyNonce; tag: var ChaChaPolyTag; data: var openArray[byte]; aad: openArray[byte])

DefaultAlpha:

• types: const DefaultAlpha

DefaultAmplificationAttackDialTimeout:

• types: const DefaultAmplificationAttackDialTimeout

DefaultBucketRefreshTime:

• types: const DefaultBucketRefreshTime

DefaultChanTimeout:

• muxer: const DefaultChanTimeout

DefaultCleanupProvidersInterval:

• types: const DefaultCleanupProvidersInterval

DefaultConnectionTimeout:

• connection: const DefaultConnectionTimeout

DefaultDialBackTimeout:

• client: const DefaultDialBackTimeout

DefaultDialDataSize:

• types: const DefaultDialDataSize

DefaultDialTimeout:

• types: const DefaultDialTimeout

DefaultDnsServers:

• service: const DefaultDnsServers

DefaultEntrySelector:

• types: type DefaultEntrySelector

DefaultEntryValidator:

• types: type DefaultEntryValidator

DefaultHeartbeatSleepTime:

• relay: const DefaultHeartbeatSleepTime

DefaultKeySize:

• rsa: const DefaultKeySize

DefaultLimitData:

• relay: const DefaultLimitData

DefaultLimitDuration:

• relay: const DefaultLimitDuration

DefaultMaxBuckets:

• types: const DefaultMaxBuckets

DefaultMaxIncomingStreams:

• protocol: const DefaultMaxIncomingStreams

DefaultMaxNumElementsInNonPriorityQueue:

• pubsubpeer: const DefaultMaxNumElementsInNonPriorityQueue

defaultMsgIdProvider:

• message: proc defaultMsgIdProvider(m: Message): Result[MessageId, ValidationResult]

DefaultProvidedKeyCapacity:

• types: const DefaultProvidedKeyCapacity

DefaultProviderExpirationInterval:

• types: const DefaultProviderExpirationInterval

DefaultProviderRecordCapacity:

• types: const DefaultProviderRecordCapacity

DefaultPublicExponent:

• rsa: const DefaultPublicExponent

DefaultQuorum:

• types: const DefaultQuorum

DefaultRenewBufferTime:

• service: const DefaultRenewBufferTime

DefaultRenewCheckTime:

• service: const DefaultRenewCheckTime

DefaultReplication:

• types: const DefaultReplication

DefaultRepublishInterval:

• types: const DefaultRepublishInterval

DefaultReservationTTL:

• relay: const DefaultReservationTTL

DefaultRetries:

• types: const DefaultRetries

DefaultTimeout:

• types: const DefaultTimeout

del:

• peerstore: proc del[T](peerBook: PeerBook[T]; peerId: PeerId): bool
• peerstore: proc del(peerStore: PeerStore; peerId: PeerId)
• provider: proc del(pk: ProvidedKeys; c: Cid)
• provider: proc del(pr: ProviderRecords; index: Natural)
• preamblestore: proc del(ps: var PreambleStore; msgId: MessageId)
• timedcache: proc del[K](t: var TimedCache[K]; key: K): Opt[TimedEntry[K]]

deletesRegister:

• rendezvous: proc deletesRegister[E](rdv: GenericRendezVous[E]; interval = 1.minutes): InternalRaisesFuture[ void, (CancelledError,)]

DER:

• certificate: EncodingFormat.DER

Dial:

• dial: type Dial

dial:

• dial: method dial(self: Dial; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): InternalRaisesFuture[Connection, (DialFailedError, CancelledError)]
• dial: method dial(self: Dial; peerId: PeerId; protos: seq[string]): InternalRaisesFuture[ Connection, (DialFailedError, CancelledError)]
• dialer: method dial(self: Dialer; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): InternalRaisesFuture[Connection, (DialFailedError, CancelledError)]
• dialer: method dial(self: Dialer; peerId: PeerId; protos: seq[string]): InternalRaisesFuture[ Connection, (DialFailedError, CancelledError)]

Dial:

• types: MsgType.Dial

dial:

• rtransport: proc dial(self: RelayTransport; ma: MultiAddress): InternalRaisesFuture[Connection, (RelayDialError, CancelledError)]
• rtransport: method dial(self: RelayTransport; hostname: string; ma: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• switch: proc dial(s: Switch; peerId: PeerId; addrs: seq[MultiAddress]; proto: string): InternalRaisesFuture[ Connection, (DialFailedError, CancelledError)]
• switch: proc dial(s: Switch; peerId: PeerId; proto: string): InternalRaisesFuture[Connection, (DialFailedError, CancelledError)]
• switch: method dial(s: Switch; peerId: PeerId; addrs: seq[MultiAddress]; protos: seq[string]; forceDial = false): InternalRaisesFuture[Connection, (DialFailedError, CancelledError)]
• switch: method dial(s: Switch; peerId: PeerId; protos: seq[string]): InternalRaisesFuture[ Connection, (DialFailedError, CancelledError)]
• memorymanager: proc dial(self: memoryConnManager; address: string): MemoryListener
• memorymanager: proc dial(self: MemoryListener): Future[Connection]
• memorytransport: proc dial(self: MemoryTransport; ma: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• memorytransport: method dial(self: MemoryTransport; hostname: string; ma: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• quictransport: method dial(self: QuicTransport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• tcptransport: method dial(self: TcpTransport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• transport: proc dial(self: Transport; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): Future[Connection]
• transport: method dial(self: Transport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]
• wstransport: method dial(self: WsTransport; hostname: string; address: MultiAddress; peerId: Opt[PeerId] = Opt.none(PeerId)): InternalRaisesFuture[Connection, (TransportError, CancelledError)]

dialAndUpgrade:

• dial: method dialAndUpgrade(self: Dial; peerId: Opt[PeerId]; addrs: seq[MultiAddress]; dir = Direction.Out): InternalRaisesFuture[Muxer, (CancelledError, MaError, TransportAddressError, LPError)]
• dial: method dialAndUpgrade(self: Dial; peerId: Opt[PeerId]; hostname: string; addrs: MultiAddress; dir = Direction.Out): InternalRaisesFuture[ Muxer, (CancelledError,)]
• dialer: method dialAndUpgrade(self: Dialer; peerId: Opt[PeerId]; addrs: seq[MultiAddress]; dir = Direction.Out): InternalRaisesFuture[Muxer, (CancelledError, MaError, TransportAddressError, LPError)]
• dialer: method dialAndUpgrade(self: Dialer; peerId: Opt[PeerId]; hostname: string; addrs: MultiAddress; dir = Direction.Out): InternalRaisesFuture[ Muxer, (CancelledError,)]

DialBack:

• types: object DialBack

DialBackLpSize:

• types: const DialBackLpSize

DialBackResponse:

• types: object DialBackResponse

DialBackStatus:

• types: enum DialBackStatus

DialDataRequest:

• types: object DialDataRequest

DialDataResponse:

• types: object DialDataResponse

DialDataResponseLpSize:

• types: const DialDataResponseLpSize

Dialer:

• dialer: type Dialer

DialError:

• types: ResponseStatus.DialError

DialFailedError:

• dial: object DialFailedError

dialPeerV1:

• client: proc dialPeerV1(cl: RelayClient; conn: Connection; dstPeerId: PeerId; dstAddrs: seq[MultiAddress]): InternalRaisesFuture[Connection, (CancelledError, RelayV1DialError)]

dialPeerV2:

• client: proc dialPeerV2(cl: RelayClient; conn: RelayConnection; dstPeerId: PeerId; dstAddrs: seq[MultiAddress]): InternalRaisesFuture[Connection, (RelayV2DialError, CancelledError)]

DialRefused:

• types: ResponseStatus.DialRefused

DialRequest:

• types: object DialRequest

DialResponse:

• types: MsgType.DialResponse
• types: object DialResponse

DialStatus:

• types: enum DialStatus

digest:

• multihash: proc digest(mhtype: typedesc[MultiHash]; mcodec: MultiCodec; data: openArray[byte]): MhResult[ MultiHash]
• multihash: proc digest(mhtype: typedesc[MultiHash]; hashname: string; data: openArray[byte]): MhResult[ MultiHash]

DigestSheme:

• crypto: enum DigestSheme

digestSize:

• multihash: proc digestSize(codec: MultiCodec): MhResult[int]
• multihash: proc digestSize(hashname: string): MhResult[int]

Direction:

• lpstream: enum Direction

disconnect:

• switch: proc disconnect(s: Switch; peerId: PeerId): InternalRaisesFuture[void, (CancelledError,)]

disconnectIfBadScorePeer:

• scoring: proc disconnectIfBadScorePeer(g: GossipSub; peer: PubSubPeer; score: float64)

disconnectPeer:

• scoring: proc disconnectPeer(g: GossipSub; peer: PubSubPeer): InternalRaisesFuture[void, void]

Discover:

• protobuf: object Discover

discover:

• rendezvous: proc discover[E](rdv: GenericRendezVous[E]; conn: Connection; d: Discover): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]

DiscoverResponse:

• protobuf: object DiscoverResponse

dispatchGetProviders:

• provider: proc dispatchGetProviders(switch: Switch; peer: PeerId; key: Key): InternalRaisesFuture[ (HashSet[Provider], seq[Peer]), (CancelledError, DialFailedError, LPStreamError)]

dispatchPutVal:

• put: proc dispatchPutVal(switch: Switch; peer: PeerId; key: Key; value: seq[byte]): InternalRaisesFuture[ void, (CancelledError, DialFailedError, LPStreamError)]

DNS:

• multiaddress: const DNS

DNS4:

• multiaddress: const DNS4

DNS6:

• multiaddress: const DNS6

DNSADDR:

• multiaddress: const DNSADDR

DNSANY:

• multiaddress: const DNSANY

DNS_OR_IP:

• multiaddress: const DNS_OR_IP

Domain:

• api: type Domain

DropConn:

• pubsubpeer: type DropConn

dropFanoutPeers:

• behavior: proc dropFanoutPeers(g: GossipSub)

dropPeer:

• connmanager: proc dropPeer(c: ConnManager; peerId: PeerId): InternalRaisesFuture[void, (CancelledError,)]

dummyPrivateProc:

• libp2p: proc dummyPrivateProc()

EcCurveKind:

• ecnist: enum EcCurveKind

ECDHEScheme:

• ecnist: type ECDHEScheme

ECDSA:

• crypto: PKScheme.ECDSA

EcError:

• ecnist: enum EcError

EcKeyGenError:

• ecnist: EcError.EcKeyGenError

EcKeyIncorrectError:

• ecnist: EcError.EcKeyIncorrectError

EcKeyPair:

• ecnist: object EcKeyPair

EcPKI:

• ecnist: type EcPKI

EcPrivateKey:

• ecnist: type EcPrivateKey

EcPublicKey:

• ecnist: type EcPublicKey

EcPublicKeyError:

• ecnist: EcError.EcPublicKeyError

EcResult:

• ecnist: type EcResult

EcRngError:

• ecnist: EcError.EcRngError

EcSignature:

• ecnist: type EcSignature

EcSignatureError:

• ecnist: EcError.EcSignatureError

EcSupportedCurvesCint:

• ecnist: const EcSupportedCurvesCint

Ed25519:

• crypto: PKScheme.Ed25519

EdError:

• ed25519: enum EdError

EdIncorrectError:

• ed25519: EdError.EdIncorrectError

EdKeyPair:

• ed25519: object EdKeyPair

EdPrivateKey:

• ed25519: object EdPrivateKey

EdPrivateKeySize:

• ed25519: const EdPrivateKeySize

EdPublicKey:

• ed25519: object EdPublicKey

EdPublicKeySize:

• ed25519: const EdPublicKeySize

EdSignature:

• ed25519: object EdSignature

EdSignatureSize:

• ed25519: const EdSignatureSize

encode:

• multiaddress: proc encode(mbtype: typedesc[MultiBase]; encoding: string; ma: MultiAddress): string
• multibase: proc encode(mbtype: typedesc[MultiBase]; encoding: string; inbytes: openArray[byte]): Result[ string, string]
• multibase: proc encode(mbtype: typedesc[MultiBase]; encoding: string; inbytes: openArray[byte]; outbytes: var openArray[char]; outlen: var int): MultiBaseStatus
• multihash: proc encode(mbtype: typedesc[MultiBase]; encoding: string; mh: MultiHash): string
• types: proc encode(d: AutonatDial): ProtoBuffer
• types: proc encode(r: AutonatDialResponse): ProtoBuffer
• types: proc encode(msg: AutonatMsg): ProtoBuffer
• types: proc encode(msg: AutonatV2Msg): ProtoBuffer
• types: proc encode(dialBack: DialBack): ProtoBuffer
• types: proc encode(dialBackResp: DialBackResponse): ProtoBuffer
• types: proc encode(dialDataReq: DialDataRequest): ProtoBuffer
• types: proc encode(dialDataResp: DialDataResponse): ProtoBuffer
• types: proc encode(dialReq: DialRequest): ProtoBuffer
• types: proc encode(dialResp: DialResponse): ProtoBuffer
• messages: proc encode(msg: HopMessage): ProtoBuffer
• messages: proc encode(msg: RelayMessage): ProtoBuffer
• messages: proc encode(msg: StopMessage): ProtoBuffer
• messages: proc encode(v: Voucher): seq[byte]
• protobuf: proc encode(msg: Message): ProtoBuffer
• protobuf: proc encode(peer: Peer): ProtoBuffer
• protobuf: proc encode(record: Record): ProtoBuffer
• protobuf: proc encode(c: Cookie): ProtoBuffer
• protobuf: proc encode(d: Discover): ProtoBuffer
• protobuf: proc encode(dr: DiscoverResponse): ProtoBuffer
• protobuf: proc encode(msg: Message): ProtoBuffer
• protobuf: proc encode(r: Register): ProtoBuffer
• protobuf: proc encode(rr: RegisterResponse): ProtoBuffer
• protobuf: proc encode(u: Unregister): ProtoBuffer
• routing_record: proc encode(record: PeerRecord): seq[byte]
• signed_envelope: proc encode(env: Envelope): Result[seq[byte], CryptoError]
• signed_envelope: proc encode[T](msg: SignedPayload[T]): Result[seq[byte], CryptoError]

encodedLength:

• multibase: proc encodedLength(mbtype: typedesc[MultiBase]; encoding: string; length: int): int

encodeMessage:

• protobuf: proc encodeMessage(msg: Message; anonymize: bool): seq[byte]

encodeRpcMsg:

• protobuf: proc encodeRpcMsg(msg: RPCMsg; anonymize: bool): seq[byte]

encodeVarint:

• varint: proc encodeVarint(vtype: typedesc[LP]; value: LPSomeVarint): VarintResult[seq[byte]]
• varint: proc encodeVarint(vtype: typedesc[PB]; value: PBSomeVarint): VarintResult[seq[byte]]

EncodingFormat:

• certificate: enum EncodingFormat

encrypt:

• chacha20poly1305: proc encrypt(_: type[ChaChaPoly]; key: ChaChaPolyKey; nonce: ChaChaPolyNonce; tag: var ChaChaPolyTag; data: var openArray[byte]; aad: openArray[byte])

EndGroup:

• minprotobuf: ProtoFieldKind.EndGroup

EntryRecord:

• types: object EntryRecord

EntrySelector:

• types: type EntrySelector

EntryValidator:

• types: type EntryValidator

Envelope:

• signed_envelope: object Envelope

EnvelopeError:

• signed_envelope: enum EnvelopeError

EnvelopeFieldMissing:

• signed_envelope: EnvelopeError.EnvelopeFieldMissing

EnvelopeInvalidProtobuf:

• signed_envelope: EnvelopeError.EnvelopeInvalidProtobuf

EnvelopeInvalidSignature:

• signed_envelope: EnvelopeError.EnvelopeInvalidSignature

EnvelopeWrongType:

• signed_envelope: EnvelopeError.EnvelopeWrongType

Eof:

• lpstream: const Eof

ephemeral:

• ecnist: proc ephemeral(scheme: ECDHEScheme; rng: var HmacDrbgContext): EcResult[EcKeyPair]
• ecnist: proc ephemeral(scheme: string; rng: var HmacDrbgContext): EcResult[EcKeyPair]

Eq:

• multiaddress: MaPatternOp.Eq

exclIfIt:

• utility: template exclIfIt[T](set: var HashSet[T]; condition: untyped)

expandAddrs:

• peerinfo: proc expandAddrs(p: PeerInfo): InternalRaisesFuture[seq[MultiAddress], (CancelledError,)]

expandItIMPL:

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

expectConnection:

• connmanager: proc expectConnection(c: ConnManager; p: PeerId; dir: Direction): InternalRaisesFuture[ Muxer, (AlreadyExpectingConnectionError, CancelledError)]

expire:

• timedcache: proc expire(t: var TimedCache; now: Moment = Moment.now())

ExponentialMovingAverage:

• bandwidth: type ExponentialMovingAverage

extend:

• minasn1: proc extend[T: Asn1Buffer | Asn1Composite](abc: var T; length: int)

extractPublicKey:

• peerid: proc extractPublicKey(pid: PeerId; pubkey: var PublicKey): bool

Fe:

• constants: type Fe

filterIt:

• utility: template filterIt[T](set: HashSet[T]; condition: untyped): HashSet[T]

find:

• provider: proc find(pr: ProviderRecords; record: ProviderRecord): int

findClosest:

• routingtable: proc findClosest(rtable: RoutingTable; targetId: Key; count: int): seq[Key]

findClosestPeerIds:

• routingtable: proc findClosestPeerIds(rtable: RoutingTable; targetId: Key; count: int): seq[PeerId]

findClosestPeers:

• find: proc findClosestPeers(kad: KadDHT; target: Key): seq[Peer]

findNode:

• find: proc findNode(kad: KadDHT; targetId: Key): InternalRaisesFuture[seq[PeerId], (CancelledError,)]
• protobuf: MessageType.findNode

findObservedIPAddr:

• server: proc findObservedIPAddr(conn: Connection; req: DialRequest): InternalRaisesFuture[ Opt[MultiAddress], (CancelledError, LPStreamError)]

findPeer:

• find: proc findPeer(kad: KadDHT; peer: PeerId): InternalRaisesFuture[ Result[PeerInfo, string], (CancelledError,)]

finish:

• minasn1: proc finish[T: Asn1Buffer | Asn1Composite](abc: var T)
• minprotobuf: proc finish(pb: var ProtoBuffer)
• vbuffer: proc finish(vb: var VBuffer)

firstSeen:

• floodsub: proc firstSeen(f: FloodSub; saltedId: SaltedId): Moment

Fixed:

• multiaddress: MAKind.Fixed

Fixed32:

• minprotobuf: ProtoFieldKind.Fixed32

Fixed64:

• minprotobuf: ProtoFieldKind.Fixed64

FloodSub:

• floodsub: type FloodSub

FloodSubCodec:

• floodsub: const FloodSubCodec

flushIf:

• offsettedseq: proc flushIf[T](o: OffsettedSeq[T]; pred: proc (x: T): bool)

flushIfIt:

• offsettedseq: template flushIfIt(o, pred: untyped)

formatItIMPL:

• lpchannel: template formatItIMPL(it: LPChannel): auto
• mplex: template formatItIMPL(it: Mplex): auto
• muxer: template formatItIMPL(it: Muxer): auto
• peerid: template formatItIMPL(it: Opt[PeerId]): auto
• peerid: template formatItIMPL(it: PeerId): auto
• peerinfo: template formatItIMPL(it: PeerInfo): auto
• types: template formatItIMPL(it: Key): auto
• pubsubpeer: template formatItIMPL(it: PubSubPeer): auto
• noise: template formatItIMPL(it: NoiseConnection): auto
• secure: template formatItIMPL(it: SecureConn): auto
• bufferstream: template formatItIMPL(it: BufferStream): auto
• chronosstream: template formatItIMPL(it: ChronosStream): auto
• connection: template formatItIMPL(it: Connection): auto
• lpstream: template formatItIMPL(it: LPStream): auto

fullAddrs:

• peerinfo: proc fullAddrs(p: PeerInfo): MaResult[seq[MultiAddress]]

GeCached:

• constants: object GeCached

generateX509:

• certificate: proc generateX509(identityKeyPair: KeyPair; validFrom: Time = fromUnix(157813200); validTo: Time = fromUnix(67090165200'i64); encodingFormat: EncodingFormat = EncodingFormat.DER): CertificateX509

GenericRendezVous:

• rendezvous: type GenericRendezVous

GeP1P1:

• constants: object GeP1P1

GeP2:

• constants: object GeP2

GeP3:

• constants: object GeP3

GePrecomp:

• constants: object GePrecomp

get:

• client: method get(self: PeerIDAuthClient; uri: Uri): InternalRaisesFuture[PeerIDAuthResponse, (PeerIDAuthError, HttpError, CancelledError)]
• types: proc get(self: LocalTable; key: Key): Opt[EntryRecord]
• mcache: proc get(c: MCache; msgId: MessageId): Opt[Message]

getAgent:

• pubsubpeer: proc getAgent(peer: PubSubPeer): string

getArray:

• rsa: template getArray(bs, os, ls: untyped): untyped

getBuffer:

• minasn1: proc getBuffer(field: Asn1Field): Asn1Buffer

getBytes:

• crypto: proc getBytes(key: PrivateKey): CryptoResult[seq[byte]]
• crypto: proc getBytes(key: PublicKey): CryptoResult[seq[byte]]
• crypto: proc getBytes(sig: Signature): seq[byte]
• curve25519: proc getBytes(key: Curve25519Key): seq[byte]
• ecnist: proc getBytes(seckey: EcPrivateKey): EcResult[seq[byte]]
• ecnist: proc getBytes(pubkey: EcPublicKey): EcResult[seq[byte]]
• ecnist: proc getBytes(sig: EcSignature): EcResult[seq[byte]]
• ed25519: proc getBytes(key: EdPrivateKey): seq[byte]
• ed25519: proc getBytes(key: EdPublicKey): seq[byte]
• ed25519: proc getBytes(sig: EdSignature): seq[byte]
• rsa: proc getBytes(key: RsaPrivateKey): RsaResult[seq[byte]]
• rsa: proc getBytes(key: RsaPublicKey): RsaResult[seq[byte]]
• rsa: proc getBytes(sig: RsaSignature): RsaResult[seq[byte]]
• secp: proc getBytes(key: SkPrivateKey): seq[byte]
• secp: proc getBytes(key: SkPublicKey): seq[byte]
• secp: proc getBytes(sig: SkSignature): seq[byte]
• peerid: template getBytes(pid: PeerId): seq[byte]

GetConn:

• pubsubpeer: type GetConn

GetConnDialError:

• pubsubpeer: object GetConnDialError

getConnections:

• connmanager: proc getConnections(c: ConnManager): Table[PeerId, seq[Muxer]]

getField:

• crypto: proc getField(pb: ProtoBuffer; field: int; value: var Signature): ProtoResult[bool]
• crypto: proc getField[T: PublicKey | PrivateKey](pb: ProtoBuffer; field: int; value: var T): ProtoResult[ bool]
• multiaddress: proc getField(pb: ProtoBuffer; field: int; value: var MultiAddress): ProtoResult[bool]
• peerid: proc getField(pb: ProtoBuffer; field: int; pid: var PeerId): ProtoResult[bool]
• minprotobuf: proc getField[T: byte | char](data: ProtoBuffer; field: int; output: var openArray[T]; outlen: var int): ProtoResult[ bool]
• minprotobuf: proc getField(pb: ProtoBuffer; field: int; output: var ProtoBuffer): ProtoResult[bool]
• minprotobuf: proc getField[T: ProtoScalar](data: ProtoBuffer; field: int; output: var T): ProtoResult[ bool]
• minprotobuf: proc getField[T: seq[byte] | string](data: ProtoBuffer; field: int; output: var T): ProtoResult[ bool]
• signed_envelope: proc getField(pb: ProtoBuffer; field: int; value: var Envelope; domain: string): ProtoResult[ bool]
• signed_envelope: proc getField[T](pb: ProtoBuffer; field: int; value: var SignedPayload[T]): ProtoResult[ bool]

getGossipPeers:

• behavior: proc getGossipPeers(g: GossipSub): Table[PubSubPeer, ControlMessage]

getHostname:

• nameresolver: proc getHostname(ma: MultiAddress): string

getIncomingSlot:

• connmanager: proc getIncomingSlot(c: ConnManager): InternalRaisesFuture[ConnectionSlot, (CancelledError,)]

getInstance:

• memorymanager: proc getInstance(): memoryConnManager

getLen:

• minprotobuf: template getLen(pb: ProtoBuffer): int

getLocalAddress:

• wire: proc getLocalAddress(sock: AsyncFD): TransportAddress

getMostObservedProtosAndPorts:

• observedaddrmanager: proc getMostObservedProtosAndPorts(self: ObservedAddrManager): seq[MultiAddress]
• peerstore: proc getMostObservedProtosAndPorts(self: PeerStore): seq[MultiAddress]

getOrCreatePeer:

• gossipsub: method getOrCreatePeer(g: GossipSub; peerId: PeerId; protosToDial: seq[string]; protoNegotiated: string = ""): PubSubPeer
• pubsub: method getOrCreatePeer(p: PubSub; peerId: PeerId; protosToDial: seq[string]; protoNegotiated: string = ""): PubSubPeer

getOrder:

• crypto: proc getOrder(remotePubkey, localNonce: openArray[byte]; localPubkey, remoteNonce: openArray[byte]): CryptoResult[int]

getOutgoingSlot:

• connmanager: proc getOutgoingSlot(c: ConnManager; forceDial = false): ConnectionSlot

getPackedRepeatedField:

• minprotobuf: proc getPackedRepeatedField[T: ProtoScalar](data: ProtoBuffer; field: int; output: var seq[T]): ProtoResult[bool]

getPart:

• multiaddress: proc getPart(ma: MultiAddress; codec: MultiCodec): MaResult[MultiAddress]

getPrivateKeyLength:

• ecnist: template getPrivateKeyLength(curve: EcCurveKind): int

getProtocolArgument:

• wildcardresolverservice: proc getProtocolArgument(ma: MultiAddress; codec: MultiCodec): MaResult[seq[byte]]

getProtoHeader:

• minprotobuf: template getProtoHeader(index: int; wire: ProtoFieldKind): uint64
• minprotobuf: template getProtoHeader(field: ProtoField): uint64

getProviders:

• protobuf: MessageType.getProviders
• provider: proc getProviders(kad: KadDHT; key: Key): InternalRaisesFuture[HashSet[Provider], (LPStreamError, DialFailedError, CancelledError)]

getPtr:

• minasn1: template getPtr(field: untyped): pointer
• minprotobuf: template getPtr(pb: ProtoBuffer): pointer

getPublicIPAddress:

• ipaddr: proc getPublicIPAddress(): IpAddress

getPublicKey:

• crypto: proc getPublicKey(key: PrivateKey): CryptoResult[PublicKey]
• ecnist: proc getPublicKey(seckey: EcPrivateKey): EcResult[EcPublicKey]
• ed25519: proc getPublicKey(key: EdPrivateKey): EdPublicKey
• rsa: proc getPublicKey(key: RsaPrivateKey): RsaPublicKey
• secp: proc getPublicKey(key: SkPrivateKey): SkPublicKey

getPublicKeyLength:

• ecnist: template getPublicKeyLength(curve: EcCurveKind): int

getRawBytes:

• crypto: proc getRawBytes(key: PrivateKey | PublicKey): CryptoResult[seq[byte]]
• ecnist: proc getRawBytes(seckey: EcPrivateKey): EcResult[seq[byte]]
• ecnist: proc getRawBytes(pubkey: EcPublicKey): EcResult[seq[byte]]
• ecnist: proc getRawBytes(sig: EcSignature): EcResult[seq[byte]]

getRepeatedField:

• multiaddress: proc getRepeatedField(pb: ProtoBuffer; field: int; value: var seq[MultiAddress]): ProtoResult[ bool]
• minprotobuf: proc getRepeatedField[T: seq[byte] | string](data: ProtoBuffer; field: int; output: var seq[T]): ProtoResult[bool]
• minprotobuf: proc getRepeatedField[T: ProtoScalar](data: ProtoBuffer; field: int; output: var seq[T]): ProtoResult[bool]

getRequiredField:

• minprotobuf: proc getRequiredField[T](pb: ProtoBuffer; field: int; output: var T): ProtoResult[ void]

getRequiredRepeatedField:

• minprotobuf: proc getRequiredRepeatedField[T](pb: ProtoBuffer; field: int; output: var seq[T]): ProtoResult[ void]

getSecret:

• ecnist: proc getSecret(pubkey: EcPublicKey; seckey: EcPrivateKey): seq[byte]

getStream:

• connmanager: proc getStream(c: ConnManager; muxer: Muxer): InternalRaisesFuture[Connection, (LPStreamError, MuxerError, CancelledError)]
• connmanager: proc getStream(c: ConnManager; peerId: PeerId): InternalRaisesFuture[Connection, (LPStreamError, MuxerError, CancelledError)]
• connmanager: proc getStream(c: ConnManager; peerId: PeerId; dir: Direction): InternalRaisesFuture[ Connection, (LPStreamError, MuxerError, CancelledError)]

getStreams:

• mplex: method getStreams(m: Mplex): seq[Connection]
• muxer: method getStreams(m: Muxer): seq[Connection]
• yamux: method getStreams(m: Yamux): seq[Connection]

getSVarint:

• varint: proc getSVarint(pbytes: openArray[byte]; outsize: var int; outval: var (PBZigVarint | PBSomeSVarint)): VarintResult[void]

getUVarint:

• varint: proc getUVarint[T: PB | LP](vtype: typedesc[T]; pbytes: openArray[byte]; outlen: var int; outval: var SomeUVarint): VarintResult[ void]

getValue:

• get: proc getValue(kad: KadDHT; key: Key; quorumOverride: Opt[int] = Opt.none(int)): InternalRaisesFuture[ Result[EntryRecord, string], (CancelledError,)]
• protobuf: MessageType.getValue

getVarint:

• varint: proc getVarint[T: PB | LP](vtype: typedesc[T]; pbytes: openArray[byte]; nbytes: var int; value: var SomeVarint): VarintResult[void]

getWrapped:

• lpchannel: method getWrapped(s: LPChannel): Connection
• yamux: method getWrapped(channel: YamuxChannel): Connection
• rconn: method getWrapped(self: RelayConnection): Connection
• secure: method getWrapped(s: SecureConn): Connection
• bridgestream: method getWrapped(s: BridgeStream): Connection
• chronosstream: method getWrapped(s: ChronosStream): Connection
• connection: method getWrapped(s: Connection): Connection
• quictransport: method getWrapped(self: QuicSession): P2PConnection
• quictransport: method getWrapped(self: QuicStream): P2PConnection
• wstransport: method getWrapped(s: WsStream): Connection

goffset:

• crypto: template goffset(secret, id, o: untyped): untyped

GossipBackoffPeriod:

• types: const GossipBackoffPeriod

GossipSub:

• types: type GossipSub

GossipSubCodec_10:

• types: const GossipSubCodec_10

GossipSubCodec_11:

• types: const GossipSubCodec_11

GossipSubCodec_12:

• types: const GossipSubCodec_12

GossipSubCodec_14:

• types: const GossipSubCodec_14

GossipSubD:

• types: const GossipSubD

GossipSubDhi:

• types: const GossipSubDhi

GossipSubDlo:

• types: const GossipSubDlo

GossipSubFanoutTTL:

• types: const GossipSubFanoutTTL

GossipSubHeartbeatInterval:

• types: const GossipSubHeartbeatInterval

GossipSubHistoryGossip:

• types: const GossipSubHistoryGossip

GossipSubHistoryLength:

• types: const GossipSubHistoryLength

GossipSubParams:

• types: object GossipSubParams

grafted:

• behavior: proc grafted(g: GossipSub; p: PubSubPeer; topic: string)

guessDialableAddr:

• observedaddrmanager: proc guessDialableAddr(self: ObservedAddrManager; ma: MultiAddress): MultiAddress
• peerstore: proc guessDialableAddr(self: PeerStore; ma: MultiAddress): MultiAddress

handle:

• multistream: proc handle(m: MultistreamSelect; conn: Connection; active: bool = false): InternalRaisesFuture[ void, (CancelledError,)]
• multistream: proc handle(_: type MultistreamSelect; conn: Connection; protos: seq[string]; matchers = newSeq[Matcher](); active: bool = false): InternalRaisesFuture[ string, (CancelledError, LPStreamError, MultiStreamError)]
• mplex: method handle(m: Mplex): InternalRaisesFuture[void, void]
• muxer: method handle(m: Muxer): InternalRaisesFuture[void, void]
• yamux: method handle(m: Yamux): InternalRaisesFuture[void, void]
• quictransport: method handle(m: QuicMuxer): InternalRaisesFuture[void, void]

handleAddProvider:

• provider: proc handleAddProvider(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleBackingOff:

• behavior: proc handleBackingOff(t: var BackoffTable; topic: string)

handleConn:

• pubsub: method handleConn(p: PubSub; conn: Connection; proto: string): InternalRaisesFuture[ void, (CancelledError,)]

handleData:

• pubsub: proc handleData(p: PubSub; topic: string; data: seq[byte]): InternalRaisesFuture[ void, void]

handleDialDataRequest:

• client: proc handleDialDataRequest(conn: Connection; req: DialDataRequest): InternalRaisesFuture[ DialResponse, (CancelledError, AutonatV2Error, LPStreamError)]

handleFindNode:

• find: proc handleFindNode(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleGetProviders:

• provider: proc handleGetProviders(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleGetValue:

• get: proc handleGetValue(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handleGraft:

• behavior: proc handleGraft(g: GossipSub; peer: PubSubPeer; grafts: seq[ControlGraft]): seq[ ControlPrune]

handleHop:

• relay: proc handleHop(r: Relay; connSrc: Connection; msg: RelayMessage): InternalRaisesFuture[ void, (CancelledError,)]

handleHopStreamV2:

• relay: proc handleHopStreamV2(r: Relay; conn: Connection): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

handleIDontWant:

• behavior: proc handleIDontWant(g: GossipSub; peer: PubSubPeer; iDontWants: seq[ControlIWant])

handleIHave:

• behavior: proc handleIHave(g: GossipSub; peer: PubSubPeer; ihaves: seq[ControlIHave]): ControlIWant

handleIWant:

• behavior: proc handleIWant(g: GossipSub; peer: PubSubPeer; iwants: seq[ControlIWant]): tuple[ messages: seq[Message], ids: seq[MessageId]]

handlePing:

• ping: proc handlePing(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handlePrune:

• behavior: proc handlePrune(g: GossipSub; peer: PubSubPeer; prunes: seq[ControlPrune])

handlePutValue:

• put: proc handlePutValue(kad: KadDHT; conn: Connection; msg: Message): InternalRaisesFuture[ void, (CancelledError,)]

handler:

• protocol: template handler(p: LPProtocol): LPProtoHandler
• protocol: template handler(p: LPProtocol; conn: Connection; proto: string): Future[void]

handler=:

• protocol: proc handler=(p: LPProtocol; handler: LPProtoHandler)

HandlerHolder:

• multistream: type HandlerHolder

handles:

• rtransport: method handles(self: RelayTransport; ma: MultiAddress): bool
• memorytransport: method handles(self: MemoryTransport; ma: MultiAddress): bool
• quictransport: method handles(transport: QuicTransport; address: MultiAddress): bool
• tcptransport: method handles(t: TcpTransport; address: MultiAddress): bool
• transport: method handles(self: Transport; address: MultiAddress): bool
• wstransport: method handles(t: WsTransport; address: MultiAddress): bool

handshake:

• noise: method handshake(p: Noise; conn: Connection; initiator: bool; peerId: Opt[PeerId]): InternalRaisesFuture[ SecureConn, (CancelledError, LPStreamError)]
• secure: method handshake(s: Secure; conn: Connection; initiator: bool; peerId: Opt[PeerId]): InternalRaisesFuture[ SecureConn, (CancelledError, LPStreamError)]

hash:

• cid: proc hash(cid: Cid): Hash
• multiaddress: proc hash(a: MultiAddress): Hash
• multicodec: proc hash(m: MultiCodec): Hash
• peerid: template hash(pid: PeerId): Hash
• pubsubpeer: proc hash(p: PubSubPeer): Hash
• timedcache: proc hash(a: TimedEntry): Hash
• connection: proc hash(p: Connection): Hash

HashError:

• crypto: CryptoError.HashError

hasKey:

• provider: proc hasKey(pk: ProvidedKeys; c: Cid): bool
• preamblestore: proc hasKey(ps: var PreambleStore; msgId: MessageId): bool

hasObservers:

• pubsubpeer: proc hasObservers(p: PubSubPeer): bool

hasPeer:

• peertable: proc hasPeer(table: PeerTable; topic: string; peer: PubSubPeer): bool

hasPeerId:

• peertable: proc hasPeerId(t: PeerTable; topic: string; peerId: PeerId): bool

hasPublicIPAddress:

• ipaddr: proc hasPublicIPAddress(): bool

hasPublicKey:

• peerid: proc hasPublicKey(pid: PeerId): bool

hasSeen:

• floodsub: proc hasSeen(f: FloodSub; saltedId: SaltedId): bool

hasSendConn:

• pubsubpeer: proc hasSendConn(p: PubSubPeer): bool

heartbeat:

• behavior: proc heartbeat(g: GossipSub): InternalRaisesFuture[void, (CancelledError,)]
• heartbeat: template heartbeat(name: string; interval: Duration; body: untyped): untyped

hex:

• cid: proc hex(cid: Cid): string
• multiaddress: proc hex(value: MultiAddress): string
• multihash: proc hex(value: MultiHash): string
• peerid: proc hex(pid: PeerId): string

high:

• offsettedseq: proc high[T](o: OffsettedSeq[T]): int
• vbuffer: proc high(vb: VBuffer): int

hint:

• varint: type hint

hint32:

• varint: type hint32

hint64:

• varint: type hint64

hkdf:

• hkdf: proc hkdf[T: sha256; len: static int](_: type[T]; salt, ikm, info: openArray[byte]; outputs: var openArray[HkdfResult[len]])

HkdfResult:

• hkdf: type HkdfResult

HopMessage:

• messages: object HopMessage

HopMessageType:

• messages: enum HopMessageType

HTTP:

• multiaddress: const HTTP

HttpCreated:

• service: const HttpCreated

HttpOk:

• service: const HttpOk

HTTPResponse:

• api: object HTTPResponse

HTTPS:

• multiaddress: const HTTPS

identify:

• peerstore: proc identify(peerStore: PeerStore; muxer: Muxer): InternalRaisesFuture[void, ( CancelledError, IdentityNoMatchError, IdentityInvalidMsgError, MultiStreamError, LPStreamError, MuxerError)]

Identify:

• identify: type Identify

identify:

• identify: proc identify(self: Identify; conn: Connection; remotePeerId: PeerId): InternalRaisesFuture[ IdentifyInfo, (IdentityInvalidMsgError, IdentityNoMatchError, LPStreamError, CancelledError)]

IdentifyCodec:

• identify: const IdentifyCodec

IdentifyError:

• identify: object IdentifyError

IdentifyInfo:

• identify: object IdentifyInfo

IdentifyNoPubKeyError:

• identify: object IdentifyNoPubKeyError

IdentifyPush:

• identify: type IdentifyPush

IdentifyPushCodec:

• identify: const IdentifyPushCodec

IdentifyPushHandler:

• identify: type IdentifyPushHandler

IdentityInvalidMsgError:

• identify: object IdentityInvalidMsgError

IdentityNoMatchError:

• identify: object IdentityNoMatchError

IdentityPubKeySerializationError:

• certificate: object IdentityPubKeySerializationError

IdentitySigningError:

• certificate: object IdentitySigningError

IdLength:

• types: const IdLength

IDontWantMaxCount:

• types: const IDontWantMaxCount

iDontWantMessageSizeThreshold:

• gossipsub: const iDontWantMessageSizeThreshold

IHaveMaxLength:

• types: const IHaveMaxLength

IHavePeerBudget:

• types: const IHavePeerBudget

includeFile:

• utility: macro includeFile(file: static[string]): untyped

init:

• cid: proc init(ctype: typedesc[Cid]; version: CidVersion; content: MultiCodec; hash: MultiHash): Result[Cid, CidError]
• cid: proc init[T: char | byte](ctype: typedesc[Cid]; data: openArray[T]): Result[Cid, CidError]
• crypto: proc init(key: var PrivateKey; data: openArray[byte]): bool
• crypto: proc init(key: var PublicKey; data: openArray[byte]): bool
• crypto: proc init(sig: var Signature; data: openArray[byte]): bool
• crypto: proc init(sig: var Signature; data: string): bool
• crypto: proc init[T: PrivateKey | PublicKey](key: var T; data: string): bool
• crypto: proc init(t: typedesc[PrivateKey]; key: rsa.RsaPrivateKey): PrivateKey
• crypto: proc init(t: typedesc[PrivateKey]; key: ecnist.EcPrivateKey): PrivateKey
• crypto: proc init(t: typedesc[PrivateKey]; key: EdPrivateKey): PrivateKey
• crypto: proc init(t: typedesc[PrivateKey]; data: openArray[byte]): CryptoResult[PrivateKey]
• crypto: proc init(t: typedesc[PrivateKey]; key: SkPrivateKey): PrivateKey
• crypto: proc init(t: typedesc[PrivateKey]; data: string): CryptoResult[PrivateKey]
• crypto: proc init(t: typedesc[PublicKey]; key: rsa.RsaPublicKey): PublicKey
• crypto: proc init(t: typedesc[PublicKey]; key: ecnist.EcPublicKey): PublicKey
• crypto: proc init(t: typedesc[PublicKey]; key: EdPublicKey): PublicKey
• crypto: proc init(t: typedesc[PublicKey]; data: openArray[byte]): CryptoResult[PublicKey]
• crypto: proc init(t: typedesc[PublicKey]; key: SkPublicKey): PublicKey
• crypto: proc init(t: typedesc[PublicKey]; data: string): CryptoResult[PublicKey]
• crypto: proc init(t: typedesc[Signature]; data: openArray[byte]): CryptoResult[Signature]
• crypto: proc init(t: typedesc[Signature]; data: string): CryptoResult[Signature]
• ecnist: proc init(key: var EcPrivateKey; data: openArray[byte]): Result[void, Asn1Error]
• ecnist: proc init(pubkey: var EcPublicKey; data: openArray[byte]): Result[void, Asn1Error]
• ecnist: proc init(sig: var EcSignature; data: openArray[byte]): Result[void, Asn1Error]
• ecnist: proc init[T: EcPKI](sospk: var T; data: string): Result[void, Asn1Error]
• ecnist: proc init(t: typedesc[EcPrivateKey]; data: openArray[byte]): EcResult[EcPrivateKey]
• ecnist: proc init(t: typedesc[EcPublicKey]; data: openArray[byte]): EcResult[EcPublicKey]
• ecnist: proc init(t: typedesc[EcSignature]; data: openArray[byte]): EcResult[EcSignature]
• ecnist: proc init[T: EcPKI](t: typedesc[T]; data: string): EcResult[T]
• ed25519: proc init(key: var EdPrivateKey; data: openArray[byte]): bool
• ed25519: proc init(key: var EdPrivateKey; data: string): bool
• ed25519: proc init(key: var EdPublicKey; data: openArray[byte]): bool
• ed25519: proc init(key: var EdPublicKey; data: string): bool
• ed25519: proc init(sig: var EdSignature; data: openArray[byte]): bool
• ed25519: proc init(sig: var EdSignature; data: string): bool
• ed25519: proc init(t: typedesc[EdPrivateKey]; data: openArray[byte]): Result[EdPrivateKey, EdError]
• ed25519: proc init(t: typedesc[EdPrivateKey]; data: string): Result[EdPrivateKey, EdError]
• ed25519: proc init(t: typedesc[EdPublicKey]; data: openArray[byte]): Result[EdPublicKey, EdError]
• ed25519: proc init(t: typedesc[EdPublicKey]; data: string): Result[EdPublicKey, EdError]
• ed25519: proc init(t: typedesc[EdSignature]; data: openArray[byte]): Result[EdSignature, EdError]
• ed25519: proc init(t: typedesc[EdSignature]; data: string): Result[EdSignature, EdError]
• minasn1: proc init(t: typedesc[Asn1Buffer]): Asn1Buffer
• minasn1: proc init(t: typedesc[Asn1Buffer]; data: openArray[byte]): Asn1Buffer
• minasn1: proc init(t: typedesc[Asn1Buffer]; data: string): Asn1Buffer
• minasn1: proc init(t: typedesc[Asn1Composite]; tag: Asn1Tag): Asn1Composite
• minasn1: proc init(t: typedesc[Asn1Composite]; idx: int): Asn1Composite
• rsa: proc init(key: var RsaPrivateKey; data: openArray[byte]): Result[void, Asn1Error]
• rsa: proc init(key: var RsaPublicKey; data: openArray[byte]): Result[void, Asn1Error]
• rsa: proc init(sig: var RsaSignature; data: openArray[byte]): Result[void, Asn1Error]
• rsa: proc init[T: RsaPKI](sospk: var T; data: string): Result[void, Asn1Error]
• rsa: proc init(t: typedesc[RsaPrivateKey]; data: openArray[byte]): RsaResult[RsaPrivateKey]
• rsa: proc init(t: typedesc[RsaPublicKey]; data: openArray[byte]): RsaResult[RsaPublicKey]
• rsa: proc init(t: typedesc[RsaSignature]; data: openArray[byte]): RsaResult[RsaSignature]
• rsa: proc init[T: RsaPKI](t: typedesc[T]; data: string): T
• secp: proc init(key: var SkPrivateKey; data: openArray[byte]): SkResult[void]
• secp: proc init(key: var SkPrivateKey; data: string): SkResult[void]
• secp: proc init(key: var SkPublicKey; data: openArray[byte]): SkResult[void]
• secp: proc init(key: var SkPublicKey; data: string): SkResult[void]
• secp: proc init(sig: var SkSignature; data: openArray[byte]): SkResult[void]
• secp: proc init(sig: var SkSignature; data: string): SkResult[void]
• secp: proc init(t: typedesc[SkPrivateKey]; data: openArray[byte]): SkResult[SkPrivateKey]
• secp: proc init(t: typedesc[SkPrivateKey]; data: string): SkResult[SkPrivateKey]
• secp: proc init(t: typedesc[SkPublicKey]; data: openArray[byte]): SkResult[SkPublicKey]
• secp: proc init(t: typedesc[SkPublicKey]; data: string): SkResult[SkPublicKey]
• secp: proc init(t: typedesc[SkSignature]; data: openArray[byte]): SkResult[SkSignature]
• secp: proc init(t: typedesc[SkSignature]; data: string): SkResult[SkSignature]
• multiaddress: proc init(mtype: typedesc[MultiAddress]): MultiAddress
• multiaddress: proc init(mtype: typedesc[MultiAddress]; address: IpAddress; protocol: IpTransportProtocol; port: Port): MultiAddress
• multiaddress: proc init(mtype: typedesc[MultiAddress]; protocol: MultiCodec; value: int): MaResult[ MultiAddress]
• multiaddress: proc init(mtype: typedesc[MultiAddress]; protocol: MultiCodec; value: openArray[byte] = []): MaResult[MultiAddress]
• multiaddress: proc init(mtype: typedesc[MultiAddress]; protocol: MultiCodec; value: PeerId): MaResult[ MultiAddress]
• multiaddress: proc init(mtype: typedesc[MultiAddress]; data: openArray[byte]): MaResult[ MultiAddress]
• multiaddress: proc init(mtype: typedesc[MultiAddress]; value: string): MaResult[MultiAddress]
• multiaddress: proc init(mtype: typedesc[MultiAddress]; address: TransportAddress; protocol = IPPROTO_TCP): MaResult[MultiAddress]
• multihash: proc init[T](mhtype: typedesc[MultiHash]; hashcode: MultiCodec; mdigest: MDigest[T]): MhResult[ MultiHash]
• multihash: proc init(mhtype: typedesc[MultiHash]; hashcode: MultiCodec; bdigest: openArray[byte]): MhResult[ MultiHash]
• multihash: proc init(mhtype: typedesc[MultiHash]; data: openArray[byte]): MhResult[MultiHash]
• multihash: proc init(mhtype: typedesc[MultiHash]; data: string): MhResult[MultiHash]
• multihash: proc init[T](mhtype: typedesc[MultiHash]; hashname: string; mdigest: MDigest[T]): MhResult[ MultiHash]
• multihash: proc init(mhtype: typedesc[MultiHash]; hashname: string; bdigest: openArray[byte]): MhResult[ MultiHash]
• lpchannel: proc init(L: type LPChannel; id: uint64; conn: Connection; initiator: bool; name: string = ""; timeout: Duration = DefaultChanTimeout): LPChannel
• peerid: proc init(pid: var PeerId; data: openArray[byte]): bool
• peerid: proc init(pid: var PeerId; data: string): bool
• peerid: proc init(t: typedesc[PeerId]; data: openArray[byte]): Result[PeerId, cstring]
• peerid: proc init(t: typedesc[PeerId]; seckey: PrivateKey): Result[PeerId, cstring]
• peerid: proc init(t: typedesc[PeerId]; pubkey: PublicKey): Result[PeerId, cstring]
• peerid: proc init(t: typedesc[PeerId]; data: string): Result[PeerId, cstring]
• messages: proc init(T: typedesc[Voucher]; relayPeerId: PeerId; reservingPeerId: PeerId; expiration: uint64): T:type
• identify: proc init(p: IdentifyPush)
• identify: method init(p: Identify)
• lookupstate: proc init(T: type LookupState; targetId: Key; initialPeers: seq[PeerId]; alpha: int; replication: int; hasher: Opt[XorDHasher]): T:type
• types: proc init(T: typedesc[EntryRecord]; value: Key; time: Opt[TimeStamp]): EntryRecord
• ping: method init(p: Ping)
• protocol: method init(p: LPProtocol)
• bandwidth: proc init(T: type[BandwidthTracking]; alpha: float = DefaultAlpha): T:type
• bandwidth: proc init(T: type[ExponentialMovingAverage]; alpha: float = DefaultAlpha): T:type
• floodsub: method init(f: FloodSub)
• gossipsub: proc init(_: type[GossipSubParams]; pruneBackoff = 1.minutes; unsubscribeBackoff = 5.seconds; floodPublish = true; gossipFactor: float64 = 0.25; d = GossipSubD; dLow = GossipSubDlo; dHigh = GossipSubDhi; dScore = GossipSubDlo; dOut = 4 - 1; dLazy = GossipSubD; heartbeatInterval = GossipSubHeartbeatInterval; historyLength = GossipSubHistoryLength; historyGossip = GossipSubHistoryGossip; fanoutTTL = GossipSubFanoutTTL; seenTTL = 2.minutes; gossipThreshold = -100.0; publishThreshold = -1000.0; graylistThreshold = -10000.0; opportunisticGraftThreshold = 0.0; decayInterval = 1.seconds; decayToZero = 0.01; retainScore = 2.minutes; appSpecificWeight = 0.0; ipColocationFactorWeight = 0.0; ipColocationFactorThreshold = 1.0; behaviourPenaltyWeight = -1.0; behaviourPenaltyDecay = 0.999; directPeers = initTable[PeerId, seq[MultiAddress]](); disconnectBadPeers = false; enablePX = false; bandwidthEstimatebps = 100000000; overheadRateLimit = Opt.none(tuple[bytes: int, interval: Duration]); disconnectPeerAboveRateLimit = false; maxNumElementsInNonPriorityQueue = DefaultMaxNumElementsInNonPriorityQueue; sendIDontWantOnPublish = false): GossipSubParams
• gossipsub: method init(g: GossipSub)
• preamblestore: proc init(T: typedesc[PeerSet]): T:type
• preamblestore: proc init(T: typedesc[PreambleInfo]; preamble: ControlPreamble; sender: PubSubPeer; startsAt: Moment; expiresAt: Moment): T:type
• preamblestore: proc init(T: typedesc[PreambleStore]): T:type
• scoring: proc init(_: type[TopicParams]): TopicParams
• mcache: proc init(T: type MCache; window, history: Natural): T:type
• pubsub: proc init[PubParams: object | bool](P: typedesc[PubSub]; switch: Switch; triggerSelf: bool = false; anonymize: bool = false; verifySignature: bool = true; sign: bool = true; msgIdProvider: MsgIdProvider = defaultMsgIdProvider; subscriptionValidator: SubscriptionValidator = nil; maxMessageSize: int = 1024 * 1024; rng: ref HmacDrbgContext = newRng(); parameters: PubParams = false; customConnCallbacks: Option[CustomConnectionCallbacks] = none( CustomConnectionCallbacks)): P:type
• message: proc init(T: type Message; peer: Option[PeerInfo]; data: seq[byte]; topic: string; seqno: Option[uint64]; sign: bool = true): Message
• message: proc init(T: type Message; peerId: PeerId; data: seq[byte]; topic: string; seqno: Option[uint64]): Message
• timedcache: proc init[K](T: type TimedCache[K]; timeout: Duration = Timeout; maxSize: int = 0): T:type
• noise: method init(p: Noise)
• secure: method init(s: Secure)
• routing_record: proc init(T: typedesc[PeerRecord]; peerId: PeerId; addresses: seq[MultiAddress]; seqNo = toUnix(getTime()).uint64): T:type
• signed_envelope: proc init(T: typedesc[Envelope]; privateKey: PrivateKey; payloadType: seq[byte]; payload: seq[byte]; domain: string): Result[Envelope, CryptoError]
• signed_envelope: proc init[T](_: typedesc[SignedPayload[T]]; privateKey: PrivateKey; data: T): Result[ SignedPayload[T], CryptoError]
• chronosstream: proc init(C: type ChronosStream; client: StreamTransport; dir: Direction; timeout = DefaultChronosStreamTimeout; observedAddr: Opt[MultiAddress]; localAddr: Opt[MultiAddress]): ChronosStream
• bytesview: proc init(t: typedesc[BytesView]; data: sink seq[byte]): BytesView

init58:

• multihash: proc init58(mhtype: typedesc[MultiHash]; data: string): MultiHash

InitializationError:

• pubsub: object InitializationError

initialize:

• transport: proc initialize(self: Transport)

initOffsettedSeq:

• offsettedseq: proc initOffsettedSeq[T](offset: int = 0): OffsettedSeq[T]

initProtoBuffer:

• minprotobuf: proc initProtoBuffer(data: openArray[byte]; offset = 0; options: set[ProtoFlags] = {}): ProtoBuffer
• minprotobuf: proc initProtoBuffer(data: seq[byte]; offset = 0; options: set[ProtoFlags] = {}): ProtoBuffer
• minprotobuf: proc initProtoBuffer(options: set[ProtoFlags] = {}): ProtoBuffer

initPubSub:

• floodsub: method initPubSub(f: FloodSub)
• gossipsub: method initPubSub(g: GossipSub)
• pubsub: method initPubSub(p: PubSub)

initRaw:

• ecnist: proc initRaw(key: var EcPrivateKey; data: openArray[byte]): bool
• ecnist: proc initRaw(pubkey: var EcPublicKey; data: openArray[byte]): bool
• ecnist: proc initRaw(sig: var EcSignature; data: openArray[byte]): bool
• ecnist: proc initRaw[T: EcPKI](sospk: var T; data: string): bool
• ecnist: proc initRaw(t: typedesc[EcPrivateKey]; data: openArray[byte]): EcResult[EcPrivateKey]
• ecnist: proc initRaw(t: typedesc[EcPublicKey]; data: openArray[byte]): EcResult[EcPublicKey]
• ecnist: proc initRaw(t: typedesc[EcSignature]; data: openArray[byte]): EcResult[EcSignature]
• ecnist: proc initRaw[T: EcPKI](t: typedesc[T]; data: string): T

initStream:

• lpchannel: method initStream(s: LPChannel)
• secure: method initStream(s: SecureConn)
• bufferstream: method initStream(s: BufferStream)
• chronosstream: method initStream(s: ChronosStream)
• connection: method initStream(s: Connection)
• lpstream: method initStream(s: LPStream)
• wstransport: method initStream(s: WsStream)

initTAddress:

• wire: proc initTAddress(ma: MultiAddress): MaResult[TransportAddress]

initVBuffer:

• vbuffer: proc initVBuffer(): VBuffer
• vbuffer: proc initVBuffer(data: openArray[byte]; offset = 0): VBuffer
• vbuffer: proc initVBuffer(data: seq[byte]; offset = 0): VBuffer

insert:

• routingtable: proc insert(rtable: var RoutingTable; nodeId: Key): bool
• routingtable: proc insert(rtable: var RoutingTable; peerId: PeerId): bool
• types: proc insert(self: var LocalTable; key: Key; value: sink seq[byte]; time: TimeStamp)
• preamblestore: proc insert(ps: var PreambleStore; msgId: MessageId; info: PreambleInfo)

InternalError:

• types: ResponseStatus.InternalError
• protobuf: ResponseStatus.InternalError

intoChaChaPolyKey:

• chacha20poly1305: proc intoChaChaPolyKey(s: openArray[byte]): ChaChaPolyKey

intoChaChaPolyNonce:

• chacha20poly1305: proc intoChaChaPolyNonce(s: openArray[byte]): ChaChaPolyNonce

intoChaChaPolyTag:

• chacha20poly1305: proc intoChaChaPolyTag(s: openArray[byte]): ChaChaPolyTag

intoCurve25519Key:

• curve25519: proc intoCurve25519Key(s: openArray[byte]): Curve25519Key

InvalidChannelIdError:

• mplex: object InvalidChannelIdError

InvalidCookie:

• protobuf: ResponseStatus.InvalidCookie

InvalidMplexMsgType:

• coder: object InvalidMplexMsgType

InvalidMultiCodec:

• multicodec: const InvalidMultiCodec

InvalidNamespace:

• protobuf: ResponseStatus.InvalidNamespace

InvalidSignedPeerRecord:

• protobuf: ResponseStatus.InvalidSignedPeerRecord

InvalidTTL:

• protobuf: ResponseStatus.InvalidTTL

InvalidVarintError:

• lpstream: object InvalidVarintError

IP:

• multiaddress: const IP

IP4:

• multiaddress: const IP4

IP6:

• multiaddress: const IP6

ipAddrMatches:

• ipaddr: proc ipAddrMatches(lookup: MultiAddress; addrs: seq[MultiAddress]; ip4: bool = true): bool

IPFS:

• multiaddress: const IPFS

ipSupport:

• ipaddr: proc ipSupport(addrs: seq[MultiAddress]): (bool, bool)

IpTransportProtocol:

• multiaddress: enum IpTransportProtocol

isConnected:

• switch: proc isConnected(s: Switch; peerId: PeerId): bool

isEmpty:

• minasn1: template isEmpty(ab: Asn1Buffer): bool
• multiaddress: proc isEmpty(ma: MultiAddress): bool
• minprotobuf: template isEmpty(pb: ProtoBuffer): bool
• zeroqueue: proc isEmpty(q: ZeroQueue): bool
• vbuffer: template isEmpty(vb: VBuffer): bool

isEnough:

• minasn1: template isEnough(ab: Asn1Buffer; length: int64): bool
• minprotobuf: template isEnough(pb: ProtoBuffer; length: uint64): bool
• vbuffer: template isEnough(vb: VBuffer; length: int): bool

isFull:

• provider: proc isFull(pk: ProvidedKeys): bool
• provider: proc isFull(pr: ProviderRecords): bool

isIPv4:

• ipaddr: proc isIPv4(ip: IpAddress): bool

isIPv6:

• ipaddr: proc isIPv6(ip: IpAddress): bool

isPrivate:

• ipaddr: proc isPrivate(ip: IpAddress): bool
• ipaddr: proc isPrivate(ip: string): bool

isPublic:

• ipaddr: proc isPublic(ip: IpAddress): bool
• ipaddr: proc isPublic(ip: string): bool

isPublicMA:

• wire: proc isPublicMA(ma: MultiAddress): bool

isReachable:

• types: proc isReachable(self: NetworkReachability): bool

isRelayed:

• relay: proc isRelayed(conn: Connection): bool

isStale:

• routingtable: proc isStale(bucket: Bucket): bool

isValid:

• types: method isValid(self: DefaultEntryValidator; key: Key; record: EntryRecord): bool
• types: method isValid(self: EntryValidator; key: Key; record: EntryRecord): bool

items:

• multiaddress: iterator items(ma: MultiAddress): MaResult[MultiAddress]
• offsettedseq: iterator items[T](o: OffsettedSeq[T]): T

iv:

• crypto: proc iv(secret: Secret; id: int): seq[byte]

ivOpenArray:

• crypto: template ivOpenArray(secret: Secret; id: int): untyped

join:

• lpstream: method join(s: LPStream): InternalRaisesFuture[void, (CancelledError,)]

KadCodec:

• types: const KadCodec

KadDHT:

• types: type KadDHT

KadDHTConfig:

• types: type KadDHTConfig

key:

• crypto: proc key(secret: Secret; id: int): seq[byte]

Key:

• types: type Key

KeyAuthorization:

• client: type KeyAuthorization

KeyBook:

• peerstore: type KeyBook

KeyError:

• crypto: CryptoError.KeyError

KeyGenerationError:

• certificate: object KeyGenerationError

keyOpenArray:

• crypto: template keyOpenArray(secret: Secret; id: int): untyped

KeyPair:

• crypto: object KeyPair

Kid:

• api: type Kid

KnownLibP2PTopics:

• pubsub: const KnownLibP2PTopics

KnownLibP2PTopicsSeq:

• pubsub: const KnownLibP2PTopicsSeq

LastSeenBook:

• peerstore: type LastSeenBook

leadingZeros:

• types: proc leadingZeros(dist: XorDistance): int

len:

• minasn1: proc len(field: Asn1Field): int
• minasn1: proc len[T: Asn1Buffer | Asn1Composite](abc: T): int
• multiaddress: proc len(ma: MultiAddress): MaResult[int]
• peerid: template len(pid: PeerId): int
• peerstore: proc len[T](peerBook: PeerBook[T]): int
• provider: proc len(pk: ProvidedKeys): int
• provider: proc len(pr: ProviderRecords): int
• preamblestore: proc len(ps: var PreambleStore): int
• bufferstream: proc len(s: BufferStream): int
• bytesview: proc len(v: BytesView): int
• zeroqueue: proc len(q: ZeroQueue): int64
• vbuffer: proc len(vb: VBuffer): int

Length:

• multiaddress: MAKind.Length
• minprotobuf: ProtoFieldKind.Length

lenu64:

• minprotobuf: template lenu64(x: untyped): untyped

LetsEncryptURL:

• api: const LetsEncryptURL

LetsEncryptURLStaging:

• api: const LetsEncryptURLStaging

libp2p_autonat_v2_reachability_confidence:

• service: type libp2p_autonat_v2_reachability_confidence

libp2p_contentids_exts:

• cid: const libp2p_contentids_exts

libp2p_failed_upgrades_incoming:

• upgrade: type libp2p_failed_upgrades_incoming

libp2p_failed_upgrades_outgoing:

• upgrade: type libp2p_failed_upgrades_outgoing

libp2p_gossipsub_peers_rate_limit_hits:

• scoring: type libp2p_gossipsub_peers_rate_limit_hits

libp2p_multiaddress_exts:

• multiaddress: const libp2p_multiaddress_exts

libp2p_multibase_exts:

• multibase: const libp2p_multibase_exts

libp2p_multicodec_exts:

• multicodec: const libp2p_multicodec_exts

libp2p_multihash_exts:

• multihash: const libp2p_multihash_exts

libp2p_network_bytes:

• connection: type libp2p_network_bytes

libp2p_pki_schemes:

• crypto: const libp2p_pki_schemes

libp2p_pubsub_broadcast_graft:

• pubsub: type libp2p_pubsub_broadcast_graft

libp2p_pubsub_broadcast_ihave:

• pubsub: type libp2p_pubsub_broadcast_ihave

libp2p_pubsub_broadcast_iwant:

• pubsub: type libp2p_pubsub_broadcast_iwant

libp2p_pubsub_broadcast_messages:

• pubsub: type libp2p_pubsub_broadcast_messages

libp2p_pubsub_broadcast_prune:

• pubsub: type libp2p_pubsub_broadcast_prune

libp2p_pubsub_broadcast_subscriptions:

• pubsub: type libp2p_pubsub_broadcast_subscriptions

libp2p_pubsub_broadcast_unsubscriptions:

• pubsub: type libp2p_pubsub_broadcast_unsubscriptions

libp2p_pubsub_messages_published:

• pubsub: type libp2p_pubsub_messages_published

libp2p_pubsub_messages_rebroadcasted:

• pubsub: type libp2p_pubsub_messages_rebroadcasted

libp2p_pubsub_received_graft:

• pubsub: type libp2p_pubsub_received_graft

libp2p_pubsub_received_ihave:

• pubsub: type libp2p_pubsub_received_ihave

libp2p_pubsub_received_iwant:

• pubsub: type libp2p_pubsub_received_iwant

libp2p_pubsub_received_messages:

• pubsub: type libp2p_pubsub_received_messages

libp2p_pubsub_received_prune:

• pubsub: type libp2p_pubsub_received_prune

libp2p_pubsub_received_subscriptions:

• pubsub: type libp2p_pubsub_received_subscriptions

libp2p_pubsub_received_unsubscriptions:

• pubsub: type libp2p_pubsub_received_unsubscriptions

Limit:

• messages: object Limit

list:

• multistream: proc list(m: MultistreamSelect; conn: Connection): InternalRaisesFuture[seq[string], (CancelledError, LPStreamError, MultiStreamError)]

LocalTable:

• types: type LocalTable

LookupNode:

• lookupstate: object LookupNode

LookupState:

• lookupstate: object LookupState

low:

• offsettedseq: proc low[T](o: OffsettedSeq[T]): int

LP:

• varint: object LP

LPChannel:

• lpchannel: type LPChannel

LPChannelTrackerName:

• lpchannel: const LPChannelTrackerName

LPError:

• errors: object LPError

LPProtocol:

• protocol: type LPProtocol

LPProtoHandler:

• protocol: type LPProtoHandler

LPSomeUVarint:

• varint: type LPSomeUVarint

LPSomeVarint:

• varint: type LPSomeVarint

LPStream:

• lpstream: type LPStream

LPStreamClosedError:

• lpstream: object LPStreamClosedError

LPStreamConnDownError:

• lpstream: object LPStreamConnDownError

LPStreamEOFError:

• lpstream: object LPStreamEOFError

LPStreamError:

• lpstream: object LPStreamError

LPStreamIncompleteError:

• lpstream: object LPStreamIncompleteError

LPStreamLimitError:

• lpstream: object LPStreamLimitError

LPStreamRemoteClosedError:

• lpstream: object LPStreamRemoteClosedError

LPStreamResetError:

• lpstream: object LPStreamResetError

LPStreamTrackerName:

• lpstream: const LPStreamTrackerName

mac:

• crypto: proc mac(secret: Secret; id: int): seq[byte]

macOpenArray:

• crypto: template macOpenArray(secret: Secret; id: int): untyped

maErr:

• multiaddress: proc maErr(msg: string): ref MaError

MaError:

• multiaddress: object MaError

MaInvalidAddress:

• multiaddress: object MaInvalidAddress

MAKind:

• multiaddress: enum MAKind

MalformedMessage:

• messages: StatusV2.MalformedMessage

manageExpiredProviders:

• provider: proc manageExpiredProviders(kad: KadDHT): InternalRaisesFuture[void, (CancelledError,)]

manageRepublishProvidedKeys:

• provider: proc manageRepublishProvidedKeys(kad: KadDHT): InternalRaisesFuture[void, (CancelledError,)]

mapAnd:

• multiaddress: proc mapAnd(args: varargs[MaPattern]): MaPattern

MaPatResult:

• multiaddress: object MaPatResult

MaPattern:

• multiaddress: object MaPattern

MaPatternOp:

• multiaddress: enum MaPatternOp

mapEq:

• multiaddress: proc mapEq(codec: string): MaPattern

mapOr:

• multiaddress: proc mapOr(args: varargs[MaPattern]): MaPattern

MAProtocol:

• multiaddress: object MAProtocol

MaResult:

• multiaddress: type MaResult

Marker:

• multiaddress: MAKind.Marker

markFailed:

• lookupstate: proc markFailed(state: var LookupState; peerId: PeerId)

markPending:

• lookupstate: proc markPending(state: var LookupState; peerId: PeerId)

match:

• multiaddress: proc match(pat: MaPattern; address: MultiAddress): bool
• peerid: proc match(pid: PeerId; seckey: PrivateKey): bool
• peerid: proc match(pid: PeerId; pubkey: PublicKey): bool

Matcher:

• multistream: type Matcher

matchPartial:

• multiaddress: proc matchPartial(pat: MaPattern; address: MultiAddress): bool

MaxAcceptedDialDataRequest:

• client: const MaxAcceptedDialDataRequest

MaxChannelCount:

• yamux: const MaxChannelCount

MaxCircuit:

• relay: const MaxCircuit

MaxCircuitPerPeer:

• relay: const MaxCircuitPerPeer

MaxConnections:

• connmanager: const MaxConnections

MaxConnectionsPerPeer:

• connmanager: const MaxConnectionsPerPeer

MaxDialDataResponsePayload:

• client: const MaxDialDataResponsePayload

MaxHashSize:

• multihash: const MaxHashSize

MaximumDuration:

• rendezvous: const MaximumDuration

maxIncomingStreams:

• protocol: proc maxIncomingStreams(p: LPProtocol): int

maxIncomingStreams=:

• protocol: proc maxIncomingStreams=(p: LPProtocol; val: int)

maxInlineKeyLength:

• peerid: const maxInlineKeyLength

MaxMsgSize:

• coder: const MaxMsgSize
• types: const MaxMsgSize

MaxOpportunisticGraftPeers:

• types: const MaxOpportunisticGraftPeers

MaxSizeError:

• lpstream: object MaxSizeError

MBSTRING_ASC:

• certificate_ffi: const MBSTRING_ASC

MBSTRING_BMP:

• certificate_ffi: const MBSTRING_BMP

MBSTRING_FLAG:

• certificate_ffi: const MBSTRING_FLAG

MBSTRING_UNIV:

• certificate_ffi: const MBSTRING_UNIV

MBSTRING_UTF8:

• certificate_ffi: const MBSTRING_UTF8

MCache:

• mcache: object MCache

Memory:

• multiaddress: const Memory

MemoryAutoAddress:

• builders: const MemoryAutoAddress
• memorytransport: const MemoryAutoAddress

MemoryListener:

• memorymanager: object MemoryListener

MemoryTransport:

• memorytransport: type MemoryTransport

MemoryTransportAcceptStopped:

• memorymanager: object MemoryTransportAcceptStopped

MemoryTransportError:

• memorymanager: object MemoryTransportError

MeshMetrics:

• types: object MeshMetrics

Message:

• protobuf: object Message
• messages: object Message
• protobuf: object Message

MessageId:

• messages: type MessageId

MessageType:

• coder: enum MessageType
• protobuf: enum MessageType
• protobuf: enum MessageType

mhash:

• cid: proc mhash(cid: Cid): Result[MultiHash, CidError]

MHash:

• multihash: object MHash

MHashCoderProc:

• multihash: type MHashCoderProc

MhResult:

• multihash: type MhResult

MinimumAcceptedDuration:

• rendezvous: const MinimumAcceptedDuration

MinimumDuration:

• rendezvous: const MinimumDuration

MinKeySize:

• rsa: const MinKeySize

mount:

• switch: proc mount[T: LPProtocol](s: Switch; proto: T; matcher: Matcher = nil)

Mplex:

• mplex: type Mplex

MplexCodec:

• mplex: const MplexCodec

Msg:

• coder: tuple Msg

MsgIdProvider:

• pubsub: type MsgIdProvider

MsgType:

• types: enum MsgType
• types: enum MsgType

mul:

• curve25519: proc mul(_: type[Curve25519]; point: var Curve25519Key; multiplier: Curve25519Key)

MultiAddress:

• multiaddress: object MultiAddress

MultiBase:

• multibase: object MultiBase

MultiBaseStatus:

• multibase: enum MultiBaseStatus

MultiCodec:

• multicodec: type MultiCodec

multiCodec:

• multicodec: proc multiCodec(code: int): MultiCodec
• multicodec: proc multiCodec(name: string): MultiCodec

MultiCodecError:

• multicodec: enum MultiCodecError

MultiCodecNotSupported:

• multicodec: MultiCodecError.MultiCodecNotSupported

MultiHash:

• multihash: object MultiHash

MultiStreamError:

• multistream: object MultiStreamError

MultistreamSelect:

• multistream: type MultistreamSelect

MuxedUpgrade:

• muxedupgrade: type MuxedUpgrade

Muxer:

• muxer: type Muxer

MuxerConstructor:

• muxer: type MuxerConstructor

MuxerError:

• muxer: object MuxerError

MuxerHandler:

• muxer: type MuxerHandler

MuxerProvider:

• muxer: object MuxerProvider

NameResolver:

• nameresolver: type NameResolver

negotiateStream:

• dial: method negotiateStream(self: Dial; conn: Connection; protos: seq[string]): InternalRaisesFuture[ Connection, (CatchableError,)]
• dialer: method negotiateStream(self: Dialer; conn: Connection; protos: seq[string]): InternalRaisesFuture[ Connection, (CatchableError,)]

NetworkInterfaceProvider:

• wildcardresolverservice: type NetworkInterfaceProvider

NetworkReachability:

• types: enum NetworkReachability

new:

• builders: proc new(T: type[SwitchBuilder]): T:type
• connmanager: proc new(C: type ConnManager; maxConnsPerPeer = MaxConnectionsPerPeer; maxConnections = MaxConnections; maxIn = -1; maxOut = -1): ConnManager
• dialer: proc new(T: type Dialer; localPeerId: PeerId; connManager: ConnManager; peerStore: PeerStore; transports: seq[Transport]; nameResolver: NameResolver = nil): Dialer
• multistream: proc new(T: typedesc[MultistreamSelect]): T:type
• mplex: proc new(M: type Mplex; conn: Connection; inTimeout: Duration = DefaultChanTimeout; outTimeout: Duration = DefaultChanTimeout; maxChannCount: int = MaxChannelCount): Mplex
• muxer: proc new(T: typedesc[MuxerProvider]; creator: MuxerConstructor; codec: string): T:type
• yamux: proc new(T: type[Yamux]; conn: Connection; maxChannCount: int = MaxChannelCount; windowSize: int = YamuxDefaultWindowSize; maxSendQueueSize: int = MaxSendQueueSize; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes): T:type
• observedaddrmanager: proc new(T: typedesc[ObservedAddrManager]; maxSize = 10; minCount = 3): T:type
• client: proc new(T: typedesc[PeerIDAuthClient]; rng: ref HmacDrbgContext = newRng()): PeerIDAuthClient
• peerinfo: proc new(p: typedesc[PeerInfo]; key: PrivateKey; listenAddrs: openArray[MultiAddress] = []; protocols: openArray[string] = []; protoVersion: string = ""; agentVersion: string = ""; addressMappers = newSeq[AddressMapper]()): PeerInfo
• peerstore: proc new(T: type PeerStore; identify: Identify; capacity = 1000): PeerStore
• server: proc new(T: typedesc[Autonat]; switch: Switch; semSize: int = 1; dialTimeout = 15.seconds): T:type
• client: proc new(T: typedesc[AutonatV2Client]; rng: ref HmacDrbgContext; dialBackTimeout: Duration = DefaultDialBackTimeout): T:type
• server: proc new(T: typedesc[AutonatV2]; switch: Switch; config: AutonatV2Config = AutonatV2Config.new()): T:type
• server: proc new(T: typedesc[AutonatV2Config]; dialTimeout: Duration = DefaultDialTimeout; dialDataSize: uint64 = DefaultDialDataSize; amplificationAttackTimeout: Duration = DefaultAmplificationAttackDialTimeout; allowPrivateAddresses: bool = false): T:type
• service: proc new(T: typedesc[AutonatV2Service]; rng: ref HmacDrbgContext; client: AutonatV2Client = AutonatV2Client.new(); config: AutonatV2ServiceConfig = AutonatV2ServiceConfig.new()): T:type
• service: proc new(T: typedesc[AutonatV2ServiceConfig]; scheduleInterval: Opt[Duration] = noneDuration; askNewConnectedPeers = true; numPeersToAsk: int = 5; maxQueueSize: int = 10; minConfidence: float = 0.3; enableAddressMapper = true): T:type
• client: 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
• rconn: proc new(T: typedesc[RelayConnection]; conn: Connection; limitDuration: uint32; limitData: uint64): T:type
• relay: proc new(T: typedesc[Relay]; reservationTTL: times.Duration = DefaultReservationTTL; limitDuration: uint32 = DefaultLimitDuration; limitData: uint64 = DefaultLimitData; heartbeatSleepTime: uint32 = DefaultHeartbeatSleepTime; maxCircuit: int = MaxCircuit; maxCircuitPerPeer: int = MaxCircuitPerPeer; msgSize: int = RelayMsgSize; circuitRelayV1: bool = false): T:type
• rtransport: proc new(T: typedesc[RelayTransport]; cl: RelayClient; upgrader: Upgrade): T:type
• identify: proc new(T: typedesc[Identify]; peerInfo: PeerInfo; sendSignedPeerRecord = false; observedAddrManager = ObservedAddrManager.new()): T:type
• identify: proc new(T: typedesc[IdentifyPush]; handler: IdentifyPushHandler = nil): T:type
• kademlia: proc new(T: typedesc[KadDHT]; switch: Switch; bootstrapNodes: seq[(PeerId, seq[MultiAddress])] = @[]; config: KadDHTConfig = KadDHTConfig.new(); rng: ref HmacDrbgContext = newRng(); client: bool = false; codec: string = KadCodec): T:type
• routingtable: proc new(T: typedesc[RoutingTable]; selfId: Key; config: RoutingTableConfig = RoutingTableConfig.new()): T:type
• routingtable: proc new(T: typedesc[RoutingTableConfig]; replication = DefaultReplication; hasher: Opt[XorDHasher] = NoneHasher; maxBuckets: int = DefaultMaxBuckets): T:type
• types: proc new(T: typedesc[KadDHTConfig]; validator: EntryValidator = DefaultEntryValidator(); selector: EntrySelector = DefaultEntrySelector(); timeout: chronos.Duration = DefaultTimeout; bucketRefreshTime: chronos.Duration = DefaultBucketRefreshTime; retries: int = DefaultRetries; replication: int = DefaultReplication; alpha: int = DefaultAlpha; quorum: int = DefaultQuorum; providerRecordCapacity = DefaultProviderRecordCapacity; providedKeyCapacity = DefaultProvidedKeyCapacity; republishProvidedKeysInterval: chronos.Duration = DefaultRepublishInterval; cleanupProvidersInterval: chronos.Duration = DefaultCleanupProvidersInterval; providerExpirationInterval: chronos.Duration = DefaultProviderExpirationInterval): T:type
• types: proc new(T: typedesc[ProviderManager]; providerRecordCapacity: int; providedKeyCapacity: int): T:type
• ping: proc new(T: typedesc[Ping]; handler: PingHandler = nil; rng: ref HmacDrbgContext = newRng()): T:type
• protocol: proc new(T: type LPProtocol; codecs: seq[string]; handler: LPProtoHandler; maxIncomingStreams: Opt[int] | int = Opt.none(int)): T:type
• pubsubpeer: proc new(T: typedesc[PubSubPeer]; peerId: PeerId; getConn: GetConn; onEvent: OnEvent; codec: string; maxMessageSize: int; maxNumElementsInNonPriorityQueue: int = DefaultMaxNumElementsInNonPriorityQueue; overheadRateLimitOpt: Opt[TokenBucket] = Opt.none(TokenBucket); customConnCallbacks: Option[CustomConnectionCallbacks] = none( CustomConnectionCallbacks)): T:type
• rendezvous: proc new(T: typedesc[RendezVous]; rng: ref HmacDrbgContext = newRng(); minDuration = MinimumDuration; maxDuration = MaximumDuration): T:type
• rendezvous: proc new(T: typedesc[RendezVous]; rng: ref HmacDrbgContext = newRng(); minDuration = MinimumDuration; maxDuration = MaximumDuration; codec: string): T:type
• rendezvous: proc new(T: typedesc[RendezVous]; switch: Switch; rng: ref HmacDrbgContext = newRng(); minDuration = MinimumDuration; maxDuration = MaximumDuration): T:type
• noise: proc new(T: typedesc[Noise]; rng: ref HmacDrbgContext; privateKey: PrivateKey; outgoing: bool = true; commonPrologue: seq[byte] = @[]): T:type
• secure: proc new(T: type SecureConn; conn: Connection; peerId: PeerId; observedAddr: Opt[MultiAddress]; localAddr: Opt[MultiAddress]; timeout: Duration = DefaultConnectionTimeout): T:type
• wildcardresolverservice: proc new(T: typedesc[WildcardAddressResolverService]; networkInterfaceProvider: NetworkInterfaceProvider = getAddresses): T:type
• bufferstream: proc new(T: typedesc[BufferStream]; timeout: Duration = DefaultConnectionTimeout): T:type
• connection: proc new(C: type Connection; peerId: PeerId; dir: Direction; observedAddr: Opt[MultiAddress] = Opt.none(MultiAddress); localAddr: Opt[MultiAddress] = Opt.none(MultiAddress); timeout: Duration = DefaultConnectionTimeout; timeoutHandler: TimeoutHandler = nil): Connection
• memorytransport: proc new(T: typedesc[MemoryTransport]; upgrade: Upgrade = Upgrade(); rng: ref HmacDrbgContext = newRng()): T:type
• quictransport: proc new(_: type QuicMuxer; conn: P2PConnection; peerId: Opt[PeerId] = Opt.none(PeerId)): QuicMuxer
• quictransport: proc new(_: type QuicTransport; u: Upgrade; privateKey: PrivateKey): QuicTransport
• quictransport: proc new(_: type QuicTransport; u: Upgrade; privateKey: PrivateKey; certGenerator: CertGenerator): QuicTransport
• tcptransport: proc new(T: typedesc[TcpTransport]; flags: set[ServerFlags] = {}; upgrade: Upgrade; connectionsTimeout = 10.minutes): T:type
• wstransport: proc new(T: typedesc[WsTransport]; upgrade: Upgrade; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; rng: ref HmacDrbgContext = nil; handshakeTimeout = DefaultHeadersTimeout): T:type
• wstransport: proc new(T: typedesc[WsTransport]; upgrade: Upgrade; tlsPrivateKey: TLSPrivateKey; tlsCertificate: TLSCertificate; autotls: Opt[AutotlsService]; tlsFlags: set[TLSFlags] = {}; flags: set[ServerFlags] = {}; factories: openArray[ExtFactory] = []; rng: ref HmacDrbgContext = nil; handshakeTimeout = DefaultHeadersTimeout): T:type
• wstransport: proc new(T: type WsStream; session: WSSession; dir: Direction; observedAddr: Opt[MultiAddress]; localAddr: Opt[MultiAddress]; timeout = 10.minutes): T:type
• muxedupgrade: proc new(T: type MuxedUpgrade; muxers: seq[MuxerProvider]; secureManagers: openArray[Secure] = []; ms: MultistreamSelect): T:type

newInvalidMplexMsgType:

• coder: proc newInvalidMplexMsgType(): ref InvalidMplexMsgType

newLPStreamClosedError:

• lpstream: proc newLPStreamClosedError(): ref LPStreamClosedError

newLPStreamConnDownError:

• lpstream: proc newLPStreamConnDownError(parentException: ref Exception = nil): ref LPStreamConnDownError

newLPStreamEOFError:

• lpstream: proc newLPStreamEOFError(): ref LPStreamEOFError

newLPStreamIncompleteError:

• lpstream: proc newLPStreamIncompleteError(): ref LPStreamIncompleteError

newLPStreamLimitError:

• lpstream: proc newLPStreamLimitError(): ref LPStreamLimitError

newLPStreamRemoteClosedError:

• lpstream: proc newLPStreamRemoteClosedError(): ref LPStreamRemoteClosedError

newLPStreamResetError:

• lpstream: proc newLPStreamResetError(): ref LPStreamResetError

newRng:

• crypto: proc newRng(): ref HmacDrbgContext

newStandardSwitch:

• builders: proc newStandardSwitch(privKey = Opt.none(PrivateKey); addrs: MultiAddress | seq[MultiAddress] = newSeq[MultiAddress](); transport: TransportType = TransportType.TCP; transportFlags: set[ServerFlags] = {}; rng = newRng(); secureManagers: openArray[SecureProtocol] = [SecureProtocol.Noise]; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes; maxConnections = MaxConnections; maxIn = -1; maxOut = -1; maxConnsPerPeer = MaxConnectionsPerPeer; nameResolver = Opt.none(NameResolver); sendSignedPeerRecord = false; peerStoreCapacity = 1000): Switch

newStandardSwitchBuilder:

• builders: proc newStandardSwitchBuilder(privKey = Opt.none(PrivateKey); addrs: MultiAddress | seq[MultiAddress] = newSeq[MultiAddress](); transport: TransportType = TransportType.TCP; transportFlags: set[ServerFlags] = {}; rng = newRng(); secureManagers: openArray[SecureProtocol] = [SecureProtocol.Noise]; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes; maxConnections = MaxConnections; maxIn = -1; maxOut = -1; maxConnsPerPeer = MaxConnectionsPerPeer; nameResolver = Opt.none(NameResolver); sendSignedPeerRecord = false; peerStoreCapacity = 1000): SwitchBuilder

newStream:

• mplex: method newStream(m: Mplex; name: string = ""; lazy: bool = false): InternalRaisesFuture[ Connection, (CancelledError, LPStreamError, MuxerError)]
• muxer: method newStream(m: Muxer; name: string = ""; lazy: bool = false): InternalRaisesFuture[ Connection, (CancelledError, LPStreamError, MuxerError)]
• yamux: method newStream(m: Yamux; name: string = ""; lazy: bool = false): InternalRaisesFuture[ Connection, (CancelledError, LPStreamError, MuxerError)]
• quictransport: method newStream(m: QuicMuxer; name: string = ""; lazy: bool = false): InternalRaisesFuture[ P2PConnection, (CancelledError, LPStreamError, MuxerError)]

newStreamInternal:

• mplex: proc newStreamInternal(m: Mplex; initiator: bool = true; chanId: uint64 = 0; name: string = ""; timeout: Duration): LPChannel

newSwitch:

• switch: proc newSwitch(peerInfo: PeerInfo; transports: seq[Transport]; secureManagers: openArray[Secure] = []; connManager: ConnManager; ms: MultistreamSelect; peerStore: PeerStore; nameResolver: NameResolver = nil; services = newSeq[Service]()): Switch

newTransportClosedError:

• transport: proc newTransportClosedError(parent: ref Exception = nil): ref TransportError

NodeEntry:

• types: object NodeEntry

Noise:

• noise: type Noise

NoiseCodec:

• noise: const NoiseCodec

NoiseConnection:

• noise: type NoiseConnection

NoiseDecryptTagError:

• noise: object NoiseDecryptTagError

NoiseError:

• noise: object NoiseError

NoiseHandshakeError:

• noise: object NoiseHandshakeError

NoiseNonceMaxError:

• noise: object NoiseNonceMaxError

NoiseOversizedPayloadError:

• noise: object NoiseOversizedPayloadError

Nonce:

• api: type Nonce
• types: type Nonce

None:

• multiaddress: MAKind.None

noOpHasher:

• types: proc noOpHasher(input: seq[byte]): array[IdLength, byte]

NoReservation:

• messages: StatusV2.NoReservation

NotAuthorized:

• protobuf: ResponseStatus.NotAuthorized

notConnected:

• protobuf: ConnectionType.notConnected

NumBytes:

• types: type NumBytes

ObservedAddrManager:

• observedaddrmanager: type ObservedAddrManager

OffsettedSeq:

• offsettedseq: object OffsettedSeq

Ok:

• types: ResponseStatus.Ok
• messages: StatusV2.Ok
• protobuf: ResponseStatus.Ok

oldestPeer:

• routingtable: proc oldestPeer(bucket: Bucket): (NodeEntry, int)

OnEvent:

• pubsubpeer: type OnEvent

OngoingReceivesStore:

• types: type OngoingReceivesStore

Onion3:

• multiaddress: const Onion3

onNewPeer:

• gossipsub: method onNewPeer(g: GossipSub; peer: PubSubPeer)

onPubSubPeerEvent:

• gossipsub: method onPubSubPeerEvent(p: GossipSub; peer: PubSubPeer; event: PubSubPeerEvent)
• pubsub: method onPubSubPeerEvent(p: PubSub; peer: PubSubPeer; event: PubSubPeerEvent)

onTopicSubscription:

• gossipsub: method onTopicSubscription(g: GossipSub; topic: string; subscribed: bool)
• pubsub: method onTopicSubscription(p: PubSub; topic: string; subscribed: bool)

open:

• lpchannel: proc open(s: LPChannel): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

Or:

• multiaddress: MaPatternOp.Or

orError:

• cid: template orError(exp: untyped; err: untyped): untyped
• crypto: template orError(exp: untyped; err: untyped): untyped

outbound:

• pubsubpeer: proc outbound(p: PubSubPeer): bool

outboundPeers:

• peertable: proc outboundPeers(table: PeerTable; topic: string): int

P2pCertificate:

• certificate: object P2pCertificate

P2pExtension:

• certificate: object P2pExtension

P2PPattern:

• multiaddress: const P2PPattern

parse:

• certificate: proc parse(certificateDer: seq[byte]): P2pCertificate

parseCertTime:

• certificate: proc parseCertTime(certTime: string): Time

parseFullAddress:

• peerinfo: proc parseFullAddress(ma: string | seq[byte]): MaResult[(PeerId, MultiAddress)]
• peerinfo: proc parseFullAddress(ma: MultiAddress): MaResult[(PeerId, MultiAddress)]

Path:

• multiaddress: MAKind.Path

payload:

• signed_envelope: proc payload(env: Envelope): seq[byte]

payloadDomain:

• messages: proc payloadDomain(_: typedesc[Voucher]): string
• routing_record: proc payloadDomain(T: typedesc[PeerRecord]): string

payloadType:

• messages: proc payloadType(_: typedesc[Voucher]): seq[byte]
• routing_record: proc payloadType(T: typedesc[PeerRecord]): seq[byte]

PB:

• varint: object PB

PBSomeSVarint:

• varint: type PBSomeSVarint

PBSomeUVarint:

• varint: type PBSomeUVarint

PBSomeVarint:

• varint: type PBSomeVarint

PBZigVarint:

• varint: type PBZigVarint

peekArray:

• vbuffer: proc peekArray[T: char | byte](vb: var VBuffer; value: var openArray[T]): int

peekSeq:

• vbuffer: proc peekSeq[T: string | seq[byte]](vb: var VBuffer; value: var T): int

peekVarint:

• vbuffer: proc peekVarint(vb: var VBuffer; value: var LPSomeUVarint): int

Peer:

• messages: object Peer
• protobuf: object Peer

PeerBook:

• peerstore: type PeerBook

PeerBookChangeHandler:

• peerstore: type PeerBookChangeHandler

PeerEvent:

• connmanager: object PeerEvent

PeerEventHandler:

• connmanager: type PeerEventHandler

PeerEventKind:

• connmanager: enum PeerEventKind

peerExchangeList:

• behavior: proc peerExchangeList(g: GossipSub; topic: string): seq[PeerInfoMsg]

PeerId:

• peerid: object PeerId

peerId:

• certificate: proc peerId(cert: P2pCertificate): PeerId

PeerIDAuthAuthenticationResponse:

• client: object PeerIDAuthAuthenticationResponse

PeerIDAuthAuthorizationResponse:

• client: object PeerIDAuthAuthorizationResponse

PeerIDAuthChallenge:

• client: type PeerIDAuthChallenge

PeerIDAuthClient:

• client: type PeerIDAuthClient

PeerIDAuthError:

• client: object PeerIDAuthError

PeerIDAuthOpaque:

• client: type PeerIDAuthOpaque

PeerIDAuthPrefix:

• client: const PeerIDAuthPrefix

PeerIDAuthResponse:

• client: object PeerIDAuthResponse

PeerIDAuthSignature:

• client: type PeerIDAuthSignature

PeerInfo:

• peerinfo: type PeerInfo

PeerInfoError:

• peerinfo: object PeerInfoError

PeerInfoMsg:

• messages: object PeerInfoMsg

PeerMessageDecodeError:

• pubsub: object PeerMessageDecodeError

PeerRateLimitError:

• pubsubpeer: object PeerRateLimitError

PeerRecord:

• routing_record: object PeerRecord

PeerRecordValidator:

• rendezvous: type PeerRecordValidator

peers:

• peertable: proc peers(table: PeerTable; topic: string): int

PeerSet:

• types: object PeerSet

PeerStats:

• types: object PeerStats

PeerStore:

• peerstore: type PeerStore

PeerTable:

• peertable: type PeerTable

PEM:

• certificate: EncodingFormat.PEM

PermissionDenied:

• messages: StatusV2.PermissionDenied

ping:

• ping: proc ping(kad: KadDHT; peerId: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[ bool, (CancelledError, DialFailedError, ValueError, LPStreamError)]
• protobuf: MessageType.ping

Ping:

• ping: type Ping

ping:

• ping: proc ping(p: Ping; conn: Connection): InternalRaisesFuture[Duration, (CancelledError, LPStreamError, WrongPingAckError)]

PingCodec:

• ping: const PingCodec

PingError:

• ping: object PingError

PingHandler:

• ping: type PingHandler

PingsPeerBudget:

• types: const PingsPeerBudget

PKScheme:

• crypto: enum PKScheme

pop:

• provider: proc pop(pr: ProviderRecords): ProviderRecord

popChunkSeq:

• zeroqueue: proc popChunkSeq(q: var ZeroQueue; count: int): seq[byte]

popExpired:

• preamblestore: proc popExpired(ps: var PreambleStore; now: Moment): Option[PreambleInfo]

possiblePeersToQuery:

• preamblestore: proc possiblePeersToQuery(preamble: PreambleInfo): seq[PeerId]

post:

• client: method post(self: PeerIDAuthClient; uri: Uri; payload: string; authHeader: string): InternalRaisesFuture[ PeerIDAuthResponse, (HttpError, CancelledError)]

PreambleInfo:

• types: type PreambleInfo

PreamblePeerBudget:

• types: const PreamblePeerBudget

PreambleStore:

• types: object PreambleStore

PrivateKey:

• crypto: object PrivateKey

protoAddress:

• multiaddress: proc protoAddress(ma: MultiAddress): MaResult[seq[byte]]

protoArgument:

• multiaddress: proc protoArgument(ma: MultiAddress): MaResult[seq[byte]]
• multiaddress: proc protoArgument(ma: MultiAddress; value: var openArray[byte]): MaResult[int]

ProtoBook:

• peerstore: type ProtoBook

ProtoBuffer:

• minprotobuf: object ProtoBuffer

protoCode:

• multiaddress: proc protoCode(ma: MultiAddress): MaResult[MultiCodec]

protocols:

• multiaddress: proc protocols(value: MultiAddress): MaResult[seq[MultiCodec]]

ProtoError:

• minprotobuf: enum ProtoError

ProtoField:

• minprotobuf: object ProtoField

ProtoFieldKind:

• minprotobuf: enum ProtoFieldKind

ProtoFlags:

• minprotobuf: enum ProtoFlags

ProtoHeader:

• minprotobuf: object ProtoHeader

protoName:

• multiaddress: proc protoName(ma: MultiAddress): MaResult[string]

ProtoResult:

• minprotobuf: type ProtoResult

ProtoScalar:

• minprotobuf: type ProtoScalar

ProtoVersion:

• identify: const ProtoVersion

ProtoVersionBook:

• peerstore: type ProtoVersionBook

ProvidedKeys:

• types: type ProvidedKeys

Provider:

• types: type Provider

ProviderManager:

• types: type ProviderManager

ProviderRecord:

• types: object ProviderRecord

ProviderRecords:

• types: type ProviderRecords

pruned:

• behavior: proc pruned(g: GossipSub; p: PubSubPeer; topic: string; setBackoff: bool = true; backoff = none(Duration))

pubkey:

• rsa: proc pubkey(pair: RsaKeyPair): RsaPublicKey
• secp: template pubkey(v: SkKeyPair): SkPublicKey

PubKey256Length:

• ecnist: const PubKey256Length

PubKey384Length:

• ecnist: const PubKey384Length

PubKey521Length:

• ecnist: const PubKey521Length

pubkeyBytes:

• client: proc pubkeyBytes(pubkey: PublicKey): seq[byte]

public:

• curve25519: proc public(private: Curve25519Key): Curve25519Key
• utility: template public()

PublicKey:

• crypto: object PublicKey

publicKey:

• certificate: proc publicKey(cert: P2pCertificate): PublicKey

publish:

• floodsub: method publish(f: FloodSub; topic: string; data: seq[byte]; publishParams: Option[PublishParams] = none(PublishParams)): InternalRaisesFuture[ int, void]
• gossipsub: method publish(g: GossipSub; topic: string; data: seq[byte]; publishParams: Option[PublishParams] = none(PublishParams)): InternalRaisesFuture[ int, void]
• pubsub: method publish(p: PubSub; topic: string; data: seq[byte]; publishParams: Option[PublishParams] = none(PublishParams)): InternalRaisesFuture[ int, void]

PublishParams:

• pubsub: object PublishParams

PubSub:

• pubsub: type PubSub

PubSubObserver:

• pubsubpeer: type PubSubObserver

PubSubPeer:

• pubsubpeer: type PubSubPeer

PubSubPeerEvent:

• pubsubpeer: object PubSubPeerEvent

PubSubPeerEventKind:

• pubsubpeer: enum PubSubPeerEventKind

PullOperation:

• types: const PullOperation

punishInvalidMessage:

• scoring: proc punishInvalidMessage(g: GossipSub; peer: PubSubPeer; msg: Message): InternalRaisesFuture[ void, (PeerRateLimitError,)]

push:

• identify: proc push(p: IdentifyPush; peerInfo: PeerInfo; conn: Connection): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]
• provider: proc push(pr: ProviderRecords; record: ProviderRecord)
• zeroqueue: proc push(q: var ZeroQueue; b: sink seq[byte])

pushData:

• bufferstream: method pushData(s: BufferStream; data: sink seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

pushEof:

• bufferstream: method pushEof(s: BufferStream): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

put:

• mcache: proc put(c: var MCache; msgId: MessageId; msg: Message)
• timedcache: proc put[K](t: var TimedCache[K]; k: K; now = Moment.now()): bool

putSVarint:

• varint: proc putSVarint(pbytes: var openArray[byte]; outsize: var int; outval: (PBZigVarint | PBSomeSVarint)): VarintResult[void]

putUVarint:

• varint: proc putUVarint[T: PB | LP](vtype: typedesc[T]; pbytes: var openArray[byte]; outlen: var int; outval: SomeUVarint): VarintResult[void]

putValue:

• protobuf: MessageType.putValue
• put: proc putValue(kad: KadDHT; key: Key; value: seq[byte]): InternalRaisesFuture[ Result[void, string], (CancelledError,)]

putVarint:

• varint: proc putVarint[T: PB | LP](vtype: typedesc[T]; pbytes: var openArray[byte]; nbytes: var int; value: SomeVarint): VarintResult[void]

QUIC:

• multiaddress: const QUIC

QUIC_DNS:

• multiaddress: const QUIC_DNS

QUIC_IP:

• multiaddress: const QUIC_IP

QuicMuxer:

• quictransport: type QuicMuxer

QuicSession:

• quictransport: type QuicSession

QuicStream:

• quictransport: type QuicStream

QuicTransport:

• quictransport: type QuicTransport

QuicTransportAcceptStopped:

• quictransport: object QuicTransportAcceptStopped

QuicTransportDialError:

• quictransport: object QuicTransportDialError

QuicTransportError:

• quictransport: object QuicTransportError

QUIC_V1:

• multiaddress: const QUIC_V1

QUIC_V1_DNS:

• multiaddress: const QUIC_V1_DNS

QUIC_V1_IP:

• multiaddress: const QUIC_V1_IP

random:

• crypto: proc random(T: typedesc[KeyPair]; rng: var HmacDrbgContext; bits = RsaDefaultKeySize): CryptoResult[ KeyPair]
• crypto: proc random(T: typedesc[KeyPair]; scheme: PKScheme; rng: var HmacDrbgContext; bits = RsaDefaultKeySize): CryptoResult[KeyPair]
• crypto: proc random(T: typedesc[PrivateKey]; rng: var HmacDrbgContext; bits = RsaDefaultKeySize): CryptoResult[PrivateKey]
• crypto: proc random(T: typedesc[PrivateKey]; scheme: PKScheme; rng: var HmacDrbgContext; bits = RsaDefaultKeySize): CryptoResult[PrivateKey]
• curve25519: proc random(_: type[Curve25519Key]; rng: var HmacDrbgContext): Curve25519Key
• ecnist: proc random(T: typedesc[EcKeyPair]; kind: EcCurveKind; rng: var HmacDrbgContext): EcResult[ T]
• ecnist: proc random(T: typedesc[EcPrivateKey]; kind: EcCurveKind; rng: var HmacDrbgContext): EcResult[ EcPrivateKey]
• ed25519: proc random(t: typedesc[EdKeyPair]; rng: var HmacDrbgContext): EdKeyPair
• ed25519: proc random(t: typedesc[EdPrivateKey]; rng: var HmacDrbgContext): EdPrivateKey
• rsa: proc random[T: RsaKP](t: typedesc[T]; rng: var HmacDrbgContext; bits = DefaultKeySize; pubexp = DefaultPublicExponent): RsaResult[ T]
• secp: proc random(t: typedesc[SkKeyPair]; rng: var HmacDrbgContext): SkKeyPair
• secp: proc random(t: typedesc[SkPrivateKey]; rng: var HmacDrbgContext): SkPrivateKey
• peerid: proc random(t: typedesc[PeerId]; rng = newRng()): Result[PeerId, cstring]

randomKeyInBucketRange:

• routingtable: proc randomKeyInBucketRange(selfId: Key; bucketIndex: int; rng: ref HmacDrbgContext): Key

rateLimit:

• gossipsub: proc rateLimit(g: GossipSub; peer: PubSubPeer; overhead: int): InternalRaisesFuture[ void, (PeerRateLimitError,)]

read:

• minasn1: proc read(ab: var Asn1Buffer): Asn1Result[Asn1Field]

readArray:

• vbuffer: proc readArray[T: char | byte](vb: var VBuffer; value: var openArray[T]): int

readExactly:

• lpstream: method readExactly(s: LPStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]

readLine:

• lpstream: method readLine(s: LPStream; limit = 0; sep = "\r "): InternalRaisesFuture[string, (CancelledError, LPStreamError)]

readLp:

• lpstream: method readLp(s: LPStream; maxSize: int): InternalRaisesFuture[seq[byte], (CancelledError, LPStreamError)]

readMessage:

• noise: method readMessage(sconn: NoiseConnection): InternalRaisesFuture[seq[byte], (CancelledError, LPStreamError)]
• secure: method readMessage(c: SecureConn): InternalRaisesFuture[seq[byte], (CancelledError, LPStreamError)]

readMsg:

• coder: proc readMsg(conn: Connection): InternalRaisesFuture[Msg, (CancelledError, LPStreamError, MuxerError)]

readOnce:

• lpchannel: method readOnce(s: LPChannel; pbytes: pointer; nbytes: int): InternalRaisesFuture[int, (CancelledError, LPStreamError)]
• yamux: method readOnce(channel: YamuxChannel; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, LPStreamError)]
• rconn: method readOnce(self: RelayConnection; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, LPStreamError)]
• secure: method readOnce(s: SecureConn; pbytes: pointer; nbytes: int): InternalRaisesFuture[int, (CancelledError, LPStreamError)]
• bufferstream: method readOnce(s: BufferStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, LPStreamError)]
• chronosstream: method readOnce(s: ChronosStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, LPStreamError)]
• lpstream: method readOnce(s: LPStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[int, (CancelledError, LPStreamError)]
• quictransport: method readOnce(stream: QuicStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, LPStreamError)]
• wstransport: method readOnce(s: WsStream; pbytes: pointer; nbytes: int): InternalRaisesFuture[int, (CancelledError, LPStreamError)]

readSeq:

• vbuffer: proc readSeq[T: string | seq[byte]](vb: var VBuffer; value: var T): int

readVarint:

• lpstream: method readVarint(conn: LPStream): InternalRaisesFuture[uint64, (CancelledError, LPStreamError)]
• vbuffer: proc readVarint(vb: var VBuffer; value: var LPSomeUVarint): int

rebalanceMesh:

• behavior: proc rebalanceMesh(g: GossipSub; topic: string; metrics: ptr MeshMetrics = nil)

ReceivedTable:

• types: type ReceivedTable

Record:

• protobuf: object Record

recvObservers:

• pubsubpeer: proc recvObservers(p: PubSubPeer; msg: var RPCMsg)

Register:

• protobuf: object Register

register:

• rendezvous: proc register[E](rdv: GenericRendezVous[E]; conn: Connection; r: Register; peerRecord: E): Future[void]

RegisteredData:

• rendezvous: object RegisteredData

RegisterResponse:

• protobuf: object RegisterResponse

RegistrationLimitPerPeer:

• rendezvous: const RegistrationLimitPerPeer

Relay:

• relay: type Relay

RelayClient:

• client: type RelayClient

RelayClientAddConn:

• client: type RelayClientAddConn

RelayClientError:

• client: object RelayClientError

RelayConnection:

• rconn: type RelayConnection

RelayDialError:

• client: object RelayDialError

RelayMessage:

• messages: object RelayMessage

RelayMsgSize:

• relay: const RelayMsgSize

RelayPeer:

• messages: object RelayPeer

RelayTransport:

• rtransport: type RelayTransport

RelayType:

• messages: enum RelayType

RelayV1Codec:

• utils: const RelayV1Codec

RelayV1DialError:

• client: object RelayV1DialError

RelayV2DialError:

• client: object RelayV2DialError

RelayV2Error:

• relay: object RelayV2Error

RelayV2HopCodec:

• utils: const RelayV2HopCodec

RelayV2StopCodec:

• utils: const RelayV2StopCodec

release:

• connmanager: proc release(cs: ConnectionSlot)

Reliable:

• multiaddress: const Reliable

removeConnEventHandler:

• connmanager: proc removeConnEventHandler(c: ConnManager; handler: ConnEventHandler; kind: ConnEventKind)
• switch: proc removeConnEventHandler(s: Switch; handler: ConnEventHandler; kind: ConnEventKind)

removeObserver:

• pubsub: proc removeObserver(p: PubSub; observer: PubSubObserver)

removePeer:

• peertable: proc removePeer(table: var PeerTable; topic: string; peer: PubSubPeer)

removePeerEventHandler:

• connmanager: proc removePeerEventHandler(c: ConnManager; handler: PeerEventHandler; kind: PeerEventKind)
• switch: proc removePeerEventHandler(s: Switch; handler: PeerEventHandler; kind: PeerEventKind)

removeValidator:

• pubsub: method removeValidator(p: PubSub; topic: varargs[string]; hook: ValidatorHandler)

RendezVous:

• rendezvous: type RendezVous

RendezVousCodec:

• rendezvous: const RendezVousCodec

RendezVousError:

• rendezvous: object RendezVousError

replenishFanout:

• behavior: proc replenishFanout(g: GossipSub; topic: string)

repr:

• cid: proc repr(cid: Cid): string

request:

• rendezvous: proc request[E](rdv: GenericRendezVous[E]; ns: Opt[string]; lt: Opt[int]; peersOpt: Opt[seq[PeerId]]): InternalRaisesFuture[seq[E], (LPError, CancelledError)]

requestAuthentication:

• client: proc requestAuthentication(self: PeerIDAuthClient; uri: Uri): InternalRaisesFuture[ PeerIDAuthAuthenticationResponse, (PeerIDAuthError, CancelledError)]

requestAuthorization:

• client: proc requestAuthorization(self: PeerIDAuthClient; peerInfo: PeerInfo; uri: Uri; challengeClient: PeerIDAuthChallenge; challengeServer: PeerIDAuthChallenge; serverPubkey: PublicKey; opaque: PeerIDAuthOpaque; payload: auto): InternalRaisesFuture[ PeerIDAuthAuthorizationResponse, (PeerIDAuthError, CancelledError)]

requestLocally:

• rendezvous: proc requestLocally[E](rdv: GenericRendezVous[E]; ns: string): seq[E]

Reservation:

• messages: object Reservation

ReservationError:

• client: object ReservationError

ReservationRefused:

• messages: StatusV2.ReservationRefused

reserve:

• client: proc reserve(cl: RelayClient; peerId: PeerId; addrs: seq[MultiAddress] = @[]): InternalRaisesFuture[ Rsvp, (ReservationError, DialFailedError, CancelledError)]

reset:

• lpchannel: proc reset(s: LPChannel): InternalRaisesFuture[void, void]

resolveDnsAddr:

• nameresolver: proc resolveDnsAddr(self: NameResolver; ma: MultiAddress; depth: int = 0): InternalRaisesFuture[ seq[MultiAddress], (CancelledError, MaError, TransportAddressError)]

resolveIp:

• nameresolver: method resolveIp(self: NameResolver; address: string; port: Port; domain: Domain = Domain.AF_UNSPEC): InternalRaisesFuture[ seq[TransportAddress], (CancelledError, TransportAddressError)]

resolveMAddress:

• nameresolver: proc resolveMAddress(self: NameResolver; address: MultiAddress): InternalRaisesFuture[ seq[MultiAddress], (CancelledError, MaError, TransportAddressError)]

resolveTxt:

• nameresolver: method resolveTxt(self: NameResolver; address: string): InternalRaisesFuture[ seq[string], (CancelledError,)]

ResourceLimitExceeded:

• messages: StatusV2.ResourceLimitExceeded

ResponseStatus:

• types: enum ResponseStatus
• types: enum ResponseStatus
• protobuf: enum ResponseStatus

rewardDelivered:

• scoring: proc rewardDelivered(g: GossipSub; peer: PubSubPeer; topic: string; first: bool; delay = ZeroDuration)

RoutingRecordsHandler:

• types: type RoutingRecordsHandler

RoutingRecordsPair:

• types: tuple RoutingRecordsPair

RoutingTable:

• types: type RoutingTable

RoutingTableConfig:

• types: type RoutingTableConfig

rpcHandler:

• floodsub: method rpcHandler(f: FloodSub; peer: PubSubPeer; data: sink seq[byte]): InternalRaisesFuture[ void, (CancelledError, PeerMessageDecodeError, PeerRateLimitError)]
• gossipsub: method rpcHandler(g: GossipSub; peer: PubSubPeer; data: sink seq[byte]): InternalRaisesFuture[ void, (CancelledError, PeerMessageDecodeError, PeerRateLimitError)]
• pubsub: method rpcHandler(p: PubSub; peer: PubSubPeer; data: sink seq[byte]): InternalRaisesFuture[ void, (CancelledError, PeerMessageDecodeError, PeerRateLimitError)]

RPCHandler:

• pubsubpeer: type RPCHandler

RpcMessageQueue:

• pubsubpeer: type RpcMessageQueue

RPCMsg:

• messages: object RPCMsg

RSA:

• crypto: PKScheme.RSA

RsaDefaultKeySize:

• crypto: const RsaDefaultKeySize

RsaError:

• rsa: enum RsaError

RsaGenError:

• rsa: RsaError.RsaGenError

RsaKeyIncorrectError:

• rsa: RsaError.RsaKeyIncorrectError

RsaKeyPair:

• rsa: type RsaKeyPair

RsaKP:

• rsa: type RsaKP

RsaLowSecurityError:

• rsa: RsaError.RsaLowSecurityError

RsaOidSha1:

• rsa: const RsaOidSha1

RsaOidSha224:

• rsa: const RsaOidSha224

RsaOidSha256:

• rsa: const RsaOidSha256

RsaOidSha384:

• rsa: const RsaOidSha384

RsaOidSha512:

• rsa: const RsaOidSha512

RsaPKI:

• rsa: type RsaPKI

RsaPrivateKey:

• rsa: type RsaPrivateKey

RsaPublicKey:

• rsa: type RsaPublicKey

RsaResult:

• rsa: type RsaResult

RsaSignature:

• rsa: type RsaSignature

RsaSignatureError:

• rsa: RsaError.RsaSignatureError

Rsvp:

• client: object Rsvp

RTRANSPMA:

• wire: const RTRANSPMA

run:

• service: method run(self: AutonatV2Service; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]
• wildcardresolverservice: method run(self: WildcardAddressResolverService; switch: Switch): InternalRaisesFuture[ void, (CancelledError,)]
• switch: method run(self: Service; switch: Switch): InternalRaisesFuture[void, (CancelledError,)]

runHandleLoop:

• pubsubpeer: proc runHandleLoop(p: PubSubPeer; conn: Connection): InternalRaisesFuture[void, (CancelledError,)]

safeClose:

• transport: template safeClose(stream: untyped)

safeCloseWait:

• transport: template safeCloseWait(stream: untyped)

safeConvert:

• utility: proc safeConvert[T: SomeInteger](value: SomeOrdinal): T

salt:

• floodsub: proc salt(f: FloodSub; msgId: MessageId): SaltedId

SaltedId:

• messages: object SaltedId

save:

• rendezvous: proc save[E](rdv: GenericRendezVous[E]; ns: string; peerId: PeerId; r: Register; update: bool = true)

scalarMul:

• ecnist: proc scalarMul(pub: EcPublicKey; sec: EcPrivateKey): EcPublicKey

SchemeError:

• crypto: CryptoError.SchemeError

scoringHeartbeat:

• scoring: proc scoringHeartbeat(g: GossipSub): InternalRaisesFuture[void, (CancelledError,)]

seckey:

• rsa: proc seckey(pair: RsaKeyPair): RsaPrivateKey
• secp: template seckey(v: SkKeyPair): SkPrivateKey

SecKey256Length:

• ecnist: const SecKey256Length

SecKey384Length:

• ecnist: const SecKey384Length

SecKey521Length:

• ecnist: const SecKey521Length

Secp256k1:

• crypto: PKScheme.Secp256k1

Secp256r1:

• ecnist: EcCurveKind.Secp256r1

Secp384r1:

• ecnist: EcCurveKind.Secp384r1

Secp521r1:

• ecnist: EcCurveKind.Secp521r1

Secret:

• crypto: object Secret

Secret256Length:

• ecnist: const Secret256Length

Secret384Length:

• ecnist: const Secret384Length

Secret521Length:

• ecnist: const Secret521Length

Secure:

• secure: type Secure

secure:

• secure: method secure(s: Secure; conn: Connection; peerId: Opt[PeerId]): InternalRaisesFuture[ Connection, (CancelledError, LPStreamError)]
• wstransport: proc secure(self: WsTransport): bool
• upgrade: proc secure(self: Upgrade; conn: Connection; peerId: Opt[PeerId]): InternalRaisesFuture[ Connection, (CancelledError, LPError)]

SecureConn:

• secure: type SecureConn

SecureConnTrackerName:

• secure: const SecureConnTrackerName

SecureProtocol:

• builders: enum SecureProtocol

select:

• multistream: proc select(_: MultistreamSelect | type MultistreamSelect; conn: Connection; proto: seq[string]): InternalRaisesFuture[string, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: proc select(_: MultistreamSelect | type MultistreamSelect; conn: Connection; proto: string): InternalRaisesFuture[bool, (CancelledError, LPStreamError, MultiStreamError)]
• multistream: proc select(m: MultistreamSelect; conn: Connection): InternalRaisesFuture[bool, (CancelledError, LPStreamError, MultiStreamError)]
• types: method select(self: DefaultEntrySelector; key: Key; records: seq[EntryRecord]): Result[ int, string]
• types: method select(self: EntrySelector; key: Key; records: seq[EntryRecord]): Result[int, string]

selectAlphaPeers:

• lookupstate: proc selectAlphaPeers(state: LookupState): seq[PeerId]

selectBest:

• crypto: proc selectBest(order: int; p1, p2: string): string

selectClosestK:

• lookupstate: proc selectClosestK(state: LookupState): seq[PeerId]

selectMuxer:

• connmanager: proc selectMuxer(c: ConnManager; peerId: PeerId): Muxer
• connmanager: proc selectMuxer(c: ConnManager; peerId: PeerId; dir: Direction): Muxer

SemaphoreDefaultSize:

• rendezvous: const SemaphoreDefaultSize

send:

• client: proc send(self: PeerIDAuthClient; uri: Uri; peerInfo: PeerInfo; payload: auto; bearer: Opt[BearerToken] = Opt.none(BearerToken)): InternalRaisesFuture[ (BearerToken, PeerIDAuthResponse), (PeerIDAuthError, CancelledError)]
• pubsub: proc send(p: PubSub; peer: PubSubPeer; msg: RPCMsg; isHighPriority: bool; useCustomConn: bool = false)
• pubsubpeer: proc send(p: PubSubPeer; msg: RPCMsg; anonymize: bool; isHighPriority: bool; useCustomConn: bool = false)

sendDialRequest:

• client: method sendDialRequest(self: AutonatV2Client; pid: PeerId; testAddrs: seq[MultiAddress]): InternalRaisesFuture[ AutonatV2Response, (AutonatV2Error, CancelledError, DialFailedError, LPStreamError)]

sendDiscoverResponse:

• rendezvous: proc sendDiscoverResponse(conn: Connection; s: seq[Register]; cookie: Cookie): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]

sendDiscoverResponseError:

• rendezvous: proc sendDiscoverResponseError(conn: Connection; status: ResponseStatus; text: string = ""): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

sendEncoded:

• pubsubpeer: proc sendEncoded(p: PubSubPeer; msg: seq[byte]; isHighPriority: bool; useCustomConn: bool = false): Future[void]

sendFindNode:

• find: proc sendFindNode(kad: KadDHT; peerId: PeerId; addrs: seq[MultiAddress]; targetId: Key): InternalRaisesFuture[Message, (CancelledError, DialFailedError, ValueError, LPStreamError)]

sendHopStatus:

• utils: proc sendHopStatus(conn: Connection; code: StatusV2): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

sendRegisterResponse:

• rendezvous: proc sendRegisterResponse(conn: Connection; ttl: uint64): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

sendRegisterResponseError:

• rendezvous: proc sendRegisterResponseError(conn: Connection; status: ResponseStatus; text: string = ""): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

sendStatus:

• utils: proc sendStatus(conn: Connection; code: StatusV1): InternalRaisesFuture[void, (CancelledError,)]

sendStopStatus:

• utils: proc sendStopStatus(conn: Connection; code: StatusV2): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

sendSubs:

• pubsub: proc sendSubs(p: PubSub; peer: PubSubPeer; topics: openArray[string]; subscribe: bool)

SeqPeerBook:

• peerstore: type SeqPeerBook

Service:

• switch: type Service

setMaxRecvWindow:

• yamux: proc setMaxRecvWindow(channel: YamuxChannel; maxRecvWindow: int)

setStatusAndConfidenceHandler:

• service: proc setStatusAndConfidenceHandler(self: AutonatV2Service; statusAndConfidenceHandler: StatusAndConfidenceHandler)

setup:

• client: proc setup(self: AutonatV2Client; switch: Switch)
• service: method setup(self: AutonatV2Service; switch: Switch): InternalRaisesFuture[bool, (CancelledError,)]
• relay: proc setup(r: Relay; switch: Switch)
• rendezvous: proc setup[E](rdv: GenericRendezVous[E]; switch: Switch)
• wildcardresolverservice: method setup(self: WildcardAddressResolverService; switch: Switch): InternalRaisesFuture[ bool, (CancelledError,)]
• switch: method setup(self: Service; switch: Switch): InternalRaisesFuture[bool, (CancelledError,)]

Sha256:

• crypto: DigestSheme.Sha256

Sha512:

• crypto: DigestSheme.Sha512

shift:

• mcache: proc shift(c: var MCache)

shortLog:

• crypto: proc shortLog(key: PrivateKey | PublicKey): string
• lpchannel: proc shortLog(s: LPChannel): auto
• mplex: proc shortLog(m: Mplex): auto
• muxer: proc shortLog(m: Muxer): auto
• peerid: proc shortLog(pid: Opt[PeerId]): string
• peerid: proc shortLog(pid: PeerId): string
• peerinfo: proc shortLog(p: PeerInfo): auto
• types: proc shortLog(k: Key): string
• pubsubpeer: proc shortLog(p: PubSubPeer): string
• messages: proc shortLog(s: ControlGraft): auto
• messages: proc shortLog(s: ControlIHave): auto
• messages: proc shortLog(s: ControlIMReceiving): auto
• messages: proc shortLog(s: ControlIWant): auto
• messages: proc shortLog(c: ControlMessage): auto
• messages: proc shortLog(s: ControlPreamble): auto
• messages: proc shortLog(s: ControlPrune): auto
• messages: proc shortLog(msg: Message): auto
• messages: proc shortLog(m: RPCMsg): auto
• noise: proc shortLog(conn: NoiseConnection): auto
• secure: proc shortLog(conn: SecureConn): auto
• bufferstream: proc shortLog(s: BufferStream): auto
• chronosstream: proc shortLog(conn: ChronosStream): auto
• connection: proc shortLog(conn: Connection): string
• lpstream: proc shortLog(s: LPStream): auto
• utility: proc shortLog(item: openArray[byte]): string
• utility: proc shortLog(item: string): string

shuffle:

• crypto: proc shuffle[T](rng: ref HmacDrbgContext; x: var openArray[T])

Sig256Length:

• ecnist: const Sig256Length

Sig384Length:

• ecnist: const Sig384Length

Sig521Length:

• ecnist: const Sig521Length

SigError:

• crypto: CryptoError.SigError

sign:

• crypto: proc sign(key: PrivateKey; data: openArray[byte]): CryptoResult[Signature]
• ecnist: proc sign[T: byte | char](seckey: EcPrivateKey; message: openArray[T]): EcResult[ EcSignature]
• ed25519: proc sign[T: byte | char](key: EdPrivateKey; message: openArray[T]): EdSignature
• rsa: proc sign[T: byte | char](key: RsaPrivateKey; message: openArray[T]): RsaResult[ RsaSignature]
• secp: proc sign[T: byte | char](key: SkPrivateKey; msg: openArray[T]): SkSignature
• message: proc sign(msg: Message; privateKey: PrivateKey): CryptoResult[seq[byte]]

Signature:

• crypto: object Signature

SignedPayload:

• signed_envelope: object SignedPayload

SignedPeerRecord:

• routing_record: type SignedPeerRecord

SignedVoucher:

• messages: type SignedVoucher

SkKeyPair:

• secp: type SkKeyPair

SkPrivateKey:

• secp: type SkPrivateKey

SkPublicKey:

• secp: type SkPublicKey

SkRawPrivateKeySize:

• secp: const SkRawPrivateKeySize

SkRawPublicKeySize:

• secp: const SkRawPublicKeySize

SkRawSignatureSize:

• secp: const SkRawSignatureSize

SkSignature:

• secp: type SkSignature

slotsAvailable:

• connmanager: proc slotsAvailable(c: ConnManager; dir: Direction): int

SomeUVarint:

• varint: type SomeUVarint

SomeVarint:

• varint: type SomeVarint

SPRBook:

• peerstore: type SPRBook

SqrTm1:

• constants: const SqrTm1

start:

• multistream: proc start(m: MultistreamSelect): InternalRaisesFuture[void, (CancelledError,)]
• relay: method start(r: Relay): InternalRaisesFuture[void, (CancelledError,)]
• rtransport: method start(self: RelayTransport; ma: seq[MultiAddress]): InternalRaisesFuture[void, (LPError, TransportError, CancelledError)]
• kademlia: method start(kad: KadDHT): InternalRaisesFuture[void, (CancelledError,)]
• protocol: method start(p: LPProtocol): InternalRaisesFuture[void, (CancelledError,)]
• gossipsub: method start(g: GossipSub): InternalRaisesFuture[void, (CancelledError,)]
• rendezvous: method start[E](rdv: GenericRendezVous[E]): InternalRaisesFuture[void, (CancelledError,)]
• switch: proc start(s: Switch): InternalRaisesFuture[void, (CancelledError, LPError)]
• memorytransport: method start(self: MemoryTransport; addrs: seq[MultiAddress]): InternalRaisesFuture[ void, (LPError, TransportError, CancelledError)]
• quictransport: method start(self: QuicTransport; addrs: seq[MultiAddress]): InternalRaisesFuture[void, (LPError, TransportError, CancelledError)]
• tcptransport: method start(self: TcpTransport; addrs: seq[MultiAddress]): InternalRaisesFuture[void, (LPError, TransportError, CancelledError)]
• transport: method start(self: Transport; addrs: seq[MultiAddress]): InternalRaisesFuture[void, (LPError, TransportError, CancelledError)]
• wstransport: method start(self: WsTransport; addrs: seq[MultiAddress]): InternalRaisesFuture[void, (LPError, TransportError, CancelledError)]

StartGroup:

• minprotobuf: ProtoFieldKind.StartGroup

startProviding:

• provider: proc startProviding(kad: KadDHT; c: Cid): InternalRaisesFuture[void, (CancelledError,)]

StatusAndConfidenceHandler:

• service: type StatusAndConfidenceHandler

StatusV1:

• messages: enum StatusV1

StatusV2:

• messages: enum StatusV2

stop:

• multistream: proc stop(m: MultistreamSelect): InternalRaisesFuture[void, void]
• service: method stop(self: AutonatV2Service; switch: Switch): InternalRaisesFuture[bool, (CancelledError,)]
• relay: method stop(r: Relay): InternalRaisesFuture[void, void]
• rtransport: method stop(self: RelayTransport): InternalRaisesFuture[void, void]
• kademlia: method stop(kad: KadDHT): InternalRaisesFuture[void, void]
• protocol: method stop(p: LPProtocol): InternalRaisesFuture[void, void]
• gossipsub: method stop(g: GossipSub): InternalRaisesFuture[void, void]
• rendezvous: method stop[E](rdv: GenericRendezVous[E]): InternalRaisesFuture[void, void]
• wildcardresolverservice: method stop(self: WildcardAddressResolverService; switch: Switch): InternalRaisesFuture[ bool, (CancelledError,)]
• switch: proc stop(s: Switch): InternalRaisesFuture[void, (CancelledError,)]
• switch: method stop(self: Service; switch: Switch): InternalRaisesFuture[bool, (CancelledError,)]
• memorytransport: method stop(self: MemoryTransport): InternalRaisesFuture[void, void]
• quictransport: method stop(transport: QuicTransport): InternalRaisesFuture[void, void]
• tcptransport: method stop(self: TcpTransport): InternalRaisesFuture[void, void]
• transport: method stop(self: Transport): InternalRaisesFuture[void, void]
• wstransport: method stop(self: WsTransport): InternalRaisesFuture[void, void]

StopMessage:

• messages: object StopMessage

StopMessageType:

• messages: enum StopMessageType

stopProviding:

• provider: proc stopProviding(kad: KadDHT; c: Cid)

stopSendNonPriorityTask:

• pubsubpeer: proc stopSendNonPriorityTask(p: PubSubPeer)

storeMuxer:

• connmanager: proc storeMuxer(c: ConnManager; muxer: Muxer)

StreamHandler:

• muxer: type StreamHandler

StreamTracker:

• lpstream: type StreamTracker

stretchKeys:

• crypto: proc stretchKeys(cipherType: string; hashType: string; sharedSecret: seq[byte]): Secret

SubOpts:

• messages: object SubOpts

subscribe:

• pubsub: proc subscribe(p: PubSub; topic: string; handler: TopicHandler)

subscribePeer:

• pubsub: method subscribePeer(p: PubSub; peer: PeerId)

SubscriptionValidator:

• pubsub: type SubscriptionValidator

supported:

• crypto: template supported(scheme: PKScheme): bool

SupportedSchemes:

• crypto: const SupportedSchemes

SupportedSchemesInt:

• crypto: const SupportedSchemesInt

SupportedWireTypes:

• minprotobuf: const SupportedWireTypes

Switch:

• switch: type Switch

SwitchBuilder:

• builders: type SwitchBuilder

TCP:

• multiaddress: const TCP

TCP_DNS:

• multiaddress: const TCP_DNS

TCP_IP:

• multiaddress: const TCP_IP

TcpOnion3:

• multiaddress: const TcpOnion3

tcpProtocol:

• multiaddress: IpTransportProtocol.tcpProtocol

TcpTransport:

• tcptransport: type TcpTransport

TcpTransportError:

• tcptransport: object TcpTransportError

TcpTransportTrackerName:

• tcptransport: const TcpTransportTrackerName

TimedCache:

• timedcache: object TimedCache

TimedEntry:

• timedcache: type TimedEntry

Timeout:

• timedcache: const Timeout

TimeoutHandler:

• connection: type TimeoutHandler

TimeStamp:

• types: type TimeStamp

TLSCertificateError:

• certificate: object TLSCertificateError

TLS_WS:

• multiaddress: const TLS_WS

toBytes:

• crypto: proc toBytes(key: PrivateKey; data: var openArray[byte]): CryptoResult[int]
• crypto: proc toBytes(key: PublicKey; data: var openArray[byte]): CryptoResult[int]
• crypto: proc toBytes(sig: Signature; data: var openArray[byte]): int
• ecnist: proc toBytes(seckey: EcPrivateKey; data: var openArray[byte]): EcResult[int]
• ecnist: proc toBytes(pubkey: EcPublicKey; data: var openArray[byte]): EcResult[int]
• ecnist: proc toBytes(sig: EcSignature; data: var openArray[byte]): EcResult[int]
• ed25519: proc toBytes(key: EdPrivateKey; data: var openArray[byte]): int
• ed25519: proc toBytes(key: EdPublicKey; data: var openArray[byte]): int
• ed25519: proc toBytes(sig: EdSignature; data: var openArray[byte]): int
• rsa: proc toBytes(key: RsaPrivateKey; data: var openArray[byte]): RsaResult[int]
• rsa: proc toBytes(key: RsaPublicKey; data: var openArray[byte]): RsaResult[int]
• rsa: proc toBytes(sig: RsaSignature; data: var openArray[byte]): RsaResult[int]
• secp: proc toBytes(key: SkPrivateKey; data: var openArray[byte]): SkResult[int]
• secp: proc toBytes(key: SkPublicKey; data: var openArray[byte]): SkResult[int]
• secp: proc toBytes(sig: SkSignature; data: var openArray[byte]): int
• peerid: proc toBytes(pid: PeerId; data: var openArray[byte]): int
• varint: template toBytes(vtype: typedesc[PB]; value: PBSomeVarint): auto

toChunks:

• utility: proc toChunks[T](data: seq[T]; size: int): seq[seq[T]]

toCid:

• types: proc toCid(k: Key): Cid

toException:

• errors: proc toException(e: cstring): ref LPError
• errors: proc toException(e: string): ref LPError

toFullAddress:

• peerinfo: proc toFullAddress(peerId: PeerId; ma: MultiAddress): MaResult[MultiAddress]

toKey:

• types: proc toKey(c: Cid): Key
• types: proc toKey(mh: MultiHash): Key
• types: proc toKey(p: PeerId): Key

TooManyChannels:

• muxer: object TooManyChannels

TooManyConnectionsError:

• connmanager: object TooManyConnectionsError

toOpenArray:

• minasn1: template toOpenArray(ab: Asn1Buffer): untyped
• minasn1: template toOpenArray(ac: Asn1Composite): untyped
• minasn1: template toOpenArray(af: Asn1Field): untyped
• minprotobuf: template toOpenArray(pb: ProtoBuffer): untyped
• bytesview: template toOpenArray(v: BytesView; b, e: int): openArray[byte]

toOpt:

• utility: template toOpt[T, E](self: Result[T, E]): Opt[T]

toPeer:

• types: proc toPeer(k: Key; switch: Switch): Result[Peer, string]
• types: proc toPeer(peerInfo: PeerInfo): Peer

toPeerId:

• types: proc toPeerId(k: Key): Result[PeerId, string]

toPeerIds:

• types: proc toPeerIds(peers: seq[Peer]): seq[PeerId]

TopicHandler:

• pubsub: type TopicHandler

TopicInfo:

• types: object TopicInfo

TopicPair:

• pubsub: tuple TopicPair

TopicParams:

• types: object TopicParams

toRawBytes:

• crypto: proc toRawBytes(key: PrivateKey | PublicKey; data: var openArray[byte]): CryptoResult[ int]
• ecnist: proc toRawBytes(seckey: EcPrivateKey; data: var openArray[byte]): EcResult[int]
• ecnist: proc toRawBytes(pubkey: EcPublicKey; data: var openArray[byte]): EcResult[int]
• ecnist: proc toRawBytes(sig: EcSignature; data: var openArray[byte]): int

toSecret:

• ecnist: proc toSecret(pubkey: EcPublicKey; seckey: EcPrivateKey; data: var openArray[byte]): int

toString:

• multiaddress: proc toString(value: MultiAddress): MaResult[string]

trackConnection:

• connmanager: proc trackConnection(cs: ConnectionSlot; conn: Connection)

trackMuxer:

• connmanager: proc trackMuxer(cs: ConnectionSlot; mux: Muxer)

Transcoder:

• transcoder: object Transcoder

TranscoderDNS:

• multiaddress: const TranscoderDNS

TranscoderIP4:

• multiaddress: const TranscoderIP4

TranscoderIP6:

• multiaddress: const TranscoderIP6

TranscoderIP6Zone:

• multiaddress: const TranscoderIP6Zone

TranscoderMemory:

• multiaddress: const TranscoderMemory

TranscoderOnion:

• multiaddress: const TranscoderOnion

TranscoderOnion3:

• multiaddress: const TranscoderOnion3

TranscoderP2P:

• multiaddress: const TranscoderP2P

TranscoderPort:

• multiaddress: const TranscoderPort

TranscoderUnix:

• multiaddress: const TranscoderUnix

TRANSPMA:

• wire: const TRANSPMA

Transport:

• transport: type Transport

TransportBuilder:

• builders: type TransportBuilder

TransportClosedError:

• transport: object TransportClosedError

TransportConfig:

• builders: type TransportConfig

TransportDialError:

• transport: object TransportDialError

TransportError:

• transport: object TransportError

TransportInvalidAddrError:

• transport: object TransportInvalidAddrError

TransportProvider:

• builders: type TransportProvider

TransportType:

• builders: enum TransportType

triggerConnEvent:

• connmanager: proc triggerConnEvent(c: ConnManager; peerId: PeerId; event: ConnEvent): InternalRaisesFuture[ void, (CancelledError,)]

triggerPeerEvents:

• connmanager: proc triggerPeerEvents(c: ConnManager; peerId: PeerId; event: PeerEvent): InternalRaisesFuture[ void, (CancelledError,)]

tryDial:

• dial: method tryDial(self: Dial; peerId: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[ Opt[MultiAddress], (DialFailedError, CancelledError)]
• dialer: method tryDial(self: Dialer; peerId: PeerId; addrs: seq[MultiAddress]): InternalRaisesFuture[ Opt[MultiAddress], (DialFailedError, CancelledError)]

UDP:

• multiaddress: const UDP

UDP_DNS:

• multiaddress: const UDP_DNS

UDP_IP:

• multiaddress: const UDP_IP

udpProtocol:

• multiaddress: IpTransportProtocol.udpProtocol

Unavailable:

• protobuf: ResponseStatus.Unavailable

UnexpectedMessage:

• messages: StatusV2.UnexpectedMessage

UNIX:

• multiaddress: const UNIX

Unregister:

• protobuf: object Unregister

unregister:

• rendezvous: proc unregister[E](rdv: GenericRendezVous[E]; conn: Connection; u: Unregister)

Unreliable:

• multiaddress: const Unreliable

unsubscribe:

• pubsub: proc unsubscribe(p: PubSub; topics: openArray[TopicPair])
• pubsub: proc unsubscribe(p: PubSub; topic: string; handler: TopicHandler)
• rendezvous: proc unsubscribe[E](rdv: GenericRendezVous[E]; ns: string): InternalRaisesFuture[ void, (RendezVousError, CancelledError)]
• rendezvous: proc unsubscribe[E](rdv: GenericRendezVous[E]; ns: string; peerIds: seq[PeerId]): InternalRaisesFuture[ void, (RendezVousError, CancelledError)]

unsubscribeAll:

• pubsub: proc unsubscribeAll(p: PubSub; topic: string)

unsubscribeLocally:

• rendezvous: proc unsubscribeLocally[E](rdv: GenericRendezVous[E]; ns: string)

unsubscribePeer:

• floodsub: method unsubscribePeer(f: FloodSub; peer: PeerId)
• gossipsub: method unsubscribePeer(g: GossipSub; peer: PeerId)
• pubsub: method unsubscribePeer(p: PubSub; peerId: PeerId)

update:

• peerinfo: proc update(p: PeerInfo): InternalRaisesFuture[void, (CancelledError,)]
• bandwidth: proc update(e: var ExponentialMovingAverage; startAt: Moment; bytes: int)

updateMetrics:

• pubsub: proc updateMetrics(p: PubSub; rpcMsg: RPCMsg)

updatePeerInfo:

• peerstore: proc updatePeerInfo(peerStore: PeerStore; info: IdentifyInfo; observedAddr: Opt[MultiAddress] = Opt.none(MultiAddress))

updateScores:

• scoring: proc updateScores(g: GossipSub)

updateShortlist:

• lookupstate: proc updateShortlist(state: var LookupState; msg: Message; onInsert: proc (p: PeerInfo) {.gcsafe, raises: [].}; hasher: Opt[XorDHasher])

upgrade:

• quictransport: method upgrade(self: QuicTransport; conn: P2PConnection; peerId: Opt[PeerId]): InternalRaisesFuture[ Muxer, (CancelledError, LPError)]
• transport: method upgrade(self: Transport; conn: Connection; peerId: Opt[PeerId]): InternalRaisesFuture[ Muxer, (CancelledError, LPError)]
• muxedupgrade: method upgrade(self: MuxedUpgrade; conn: Connection; peerId: Opt[PeerId]): InternalRaisesFuture[ Muxer, (CancelledError, LPError)]

Upgrade:

• upgrade: type Upgrade

upgrade:

• upgrade: method upgrade(self: Upgrade; conn: Connection; peerId: Opt[PeerId]): InternalRaisesFuture[ Muxer, (CancelledError, LPError)]

UpgradeError:

• switch: object UpgradeError

UpgradeFailedError:

• upgrade: object UpgradeFailedError

UTP:

• multiaddress: const UTP

validate:

• cid: proc validate(ctype: typedesc[Cid]; data: openArray[byte]): bool
• multiaddress: proc validate(ma: MultiAddress): bool
• multihash: proc validate(mhtype: typedesc[MultiHash]; data: openArray[byte]): bool
• peerid: proc validate(pid: PeerId): bool
• pubsub: method validate(p: PubSub; message: Message): InternalRaisesFuture[ValidationResult, (CancelledError,)]

validatedObservers:

• pubsubpeer: proc validatedObservers(p: PubSubPeer; msg: Message; msgId: MessageId)

validateParameters:

• gossipsub: proc validateParameters(parameters: GossipSubParams): Result[void, cstring]
• gossipsub: proc validateParameters(parameters: TopicParams): Result[void, cstring]

ValidationResult:

• errors: enum ValidationResult

ValidationSeenTable:

• types: type ValidationSeenTable

ValidatorHandler:

• pubsub: type ValidatorHandler

value:

• bandwidth: proc value(e: var ExponentialMovingAverage): float

valueOr:

• utility: template valueOr[T](self: Option[T]; body: untyped): untyped

Varint:

• minprotobuf: ProtoFieldKind.Varint

VarintError:

• varint: enum VarintError

VarintResult:

• varint: type VarintResult

VBuffer:

• vbuffer: object VBuffer

verify:

• crypto: proc verify(sig: Signature; message: openArray[byte]; key: PublicKey): bool
• ecnist: proc verify[T: byte | char](sig: EcSignature; message: openArray[T]; pubkey: EcPublicKey): bool
• ed25519: proc verify[T: byte | char](sig: EdSignature; message: openArray[T]; key: EdPublicKey): bool
• rsa: proc verify[T: byte | char](sig: RsaSignature; message: openArray[T]; pubkey: RsaPublicKey): bool
• secp: proc verify[T: byte | char](sig: SkSignature; msg: openArray[T]; key: SkPublicKey): bool
• message: proc verify(m: Message): bool
• certificate: proc verify(self: P2pCertificate): bool

version:

• cid: proc version(cid: Cid): CidVersion

Voucher:

• messages: object Voucher

vsizeof:

• minprotobuf: proc vsizeof(field: ProtoField): int
• varint: proc vsizeof(x: SomeVarint): int

waitForService:

• utility: proc waitForService(host: string; port: Port; retries: int = 20; delay: chronos.Duration = 500.milliseconds): Future[bool]

WebRTCDirect:

• multiaddress: const WebRTCDirect

WebSockets:

• multiaddress: const WebSockets

WebSockets_DNS:

• multiaddress: const WebSockets_DNS

WebSockets_IP:

• multiaddress: const WebSockets_IP

WildcardAddressResolverService:

• wildcardresolverservice: type WildcardAddressResolverService

window:

• mcache: proc window(c: MCache; topic: string): HashSet[MessageId]

withAddress:

• builders: proc withAddress(b: SwitchBuilder; address: MultiAddress; enableWildcardResolver: bool = true): SwitchBuilder

withAddresses:

• builders: proc withAddresses(b: SwitchBuilder; addresses: seq[MultiAddress]; enableWildcardResolver: bool = true): SwitchBuilder

withAgentVersion:

• builders: proc withAgentVersion(b: SwitchBuilder; agentVersion: string): SwitchBuilder

withAutonat:

• builders: proc withAutonat(b: SwitchBuilder): SwitchBuilder

withAutonatV2:

• builders: proc withAutonatV2(b: SwitchBuilder; serviceConfig = AutonatV2ServiceConfig.new()): SwitchBuilder

withAutonatV2Server:

• builders: proc withAutonatV2Server(b: SwitchBuilder; config: AutonatV2Config = AutonatV2Config.new()): SwitchBuilder

withCircuitRelay:

• builders: proc withCircuitRelay(b: SwitchBuilder; r: Relay = Relay.new()): SwitchBuilder

withKademlia:

• builders: proc withKademlia(b: SwitchBuilder; bootstrapNodes: seq[(PeerId, seq[MultiAddress])] = @[]; config: KadDHTConfig = KadDHTConfig.new()): SwitchBuilder

withMaxConnections:

• builders: proc withMaxConnections(b: SwitchBuilder; maxConnections: int): SwitchBuilder

withMaxConnsPerPeer:

• builders: proc withMaxConnsPerPeer(b: SwitchBuilder; maxConnsPerPeer: int): SwitchBuilder

withMaxIn:

• builders: proc withMaxIn(b: SwitchBuilder; maxIn: int): SwitchBuilder

withMaxOut:

• builders: proc withMaxOut(b: SwitchBuilder; maxOut: int): SwitchBuilder

withMemoryTransport:

• builders: proc withMemoryTransport(b: SwitchBuilder): SwitchBuilder

withMplex:

• builders: proc withMplex(b: SwitchBuilder; inTimeout = 5.minutes; outTimeout = 5.minutes; maxChannCount = 200): SwitchBuilder

withNameResolver:

• builders: proc withNameResolver(b: SwitchBuilder; nameResolver: NameResolver): SwitchBuilder

withNoise:

• builders: proc withNoise(b: SwitchBuilder): SwitchBuilder

withObservedAddrManager:

• builders: proc withObservedAddrManager(b: SwitchBuilder; observedAddrManager: ObservedAddrManager): SwitchBuilder

withPeerStats:

• scoring: proc withPeerStats(g: GossipSub; peerId: PeerId; action: proc (stats: var PeerStats) {.gcsafe, raises: [].})

withPeerStore:

• builders: proc withPeerStore(b: SwitchBuilder; capacity: int): SwitchBuilder

withPrivateKey:

• builders: proc withPrivateKey(b: SwitchBuilder; privateKey: PrivateKey): SwitchBuilder

withProtoVersion:

• builders: proc withProtoVersion(b: SwitchBuilder; protoVersion: string): SwitchBuilder

withQuicTransport:

• builders: proc withQuicTransport(b: SwitchBuilder): SwitchBuilder

withRendezVous:

• builders: proc withRendezVous(b: SwitchBuilder; rdv: RendezVous): SwitchBuilder

withRng:

• builders: proc withRng(b: SwitchBuilder; rng: ref HmacDrbgContext): SwitchBuilder

withServices:

• builders: proc withServices(b: SwitchBuilder; services: seq[Service]): SwitchBuilder

withSignedPeerRecord:

• builders: proc withSignedPeerRecord(b: SwitchBuilder; sendIt = true): SwitchBuilder

withSubs:

• messages: proc withSubs(T: type RPCMsg; topics: openArray[string]; subscribe: bool): T:type

withTcpTransport:

• builders: proc withTcpTransport(b: SwitchBuilder; flags: set[ServerFlags] = {}): SwitchBuilder

withTransport:

• builders: proc withTransport(b: SwitchBuilder; prov: TransportBuilder): SwitchBuilder
• builders: proc withTransport(b: SwitchBuilder; prov: TransportProvider): SwitchBuilder

WithUint32BeLength:

• minprotobuf: ProtoFlags.WithUint32BeLength

WithUint32LeLength:

• minprotobuf: ProtoFlags.WithUint32LeLength

withValue:

• preamblestore: template withValue(ps: var PreambleStore; key: MessageId; value, body: untyped)
• utility: macro withValue[T](self: Opt[T] | Option[T]; value, body, elseStmt: untyped): untyped
• utility: template withValue[T](self: Opt[T] | Option[T]; value, body: untyped): untyped
• utility: template withValue[T, E](self: Result[T, E]; value, body: untyped): untyped

WithVarintLength:

• minprotobuf: ProtoFlags.WithVarintLength

withWsTransport:

• builders: proc withWsTransport(b: SwitchBuilder; tlsPrivateKey: TLSPrivateKey = nil; tlsCertificate: TLSCertificate = nil; tlsFlags: set[TLSFlags] = {}; flags: set[ServerFlags] = {}): SwitchBuilder

withYamux:

• builders: proc withYamux(b: SwitchBuilder; maxChannCount: int = MaxChannelCount; windowSize: int = YamuxDefaultWindowSize; inTimeout: Duration = 5.minutes; outTimeout: Duration = 5.minutes): SwitchBuilder

write:

• cid: proc write(vb: var VBuffer; cid: Cid)
• crypto: proc write(pb: var ProtoBuffer; field: int; sig: Signature)
• crypto: proc write[T: PublicKey | PrivateKey](pb: var ProtoBuffer; field: int; key: T)
• crypto: proc write(vb: var VBuffer; seckey: PrivateKey)
• crypto: proc write(vb: var VBuffer; sig: PrivateKey)
• crypto: proc write(vb: var VBuffer; pubkey: PublicKey)
• minasn1: proc write[T: Asn1Buffer | Asn1Composite](abc: var T; value: Asn1Composite)
• minasn1: proc write[T: Asn1Buffer | Asn1Composite](abc: var T; tag: Asn1Tag)
• minasn1: proc write[T: Asn1Buffer | Asn1Composite](abc: var T; tag: Asn1Tag; value: openArray[byte]; bits = 0)
• minasn1: proc write[T: Asn1Buffer | Asn1Composite](abc: var T; value: bool)
• minasn1: proc write[T: Asn1Buffer | Asn1Composite](abc: var T; value: uint64)
• multiaddress: proc write(pb: var ProtoBuffer; field: int; value: MultiAddress)
• multiaddress: proc write(vb: var VBuffer; ma: MultiAddress)
• multicodec: proc write(vb: var VBuffer; mc: MultiCodec)
• multihash: proc write(vb: var VBuffer; mh: MultiHash)
• lpchannel: method write(s: LPChannel; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• yamux: method write(channel: YamuxChannel; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• peerid: proc write(pb: var ProtoBuffer; field: int; pid: PeerId)
• peerid: proc write(vb: var VBuffer; pid: PeerId)
• minprotobuf: proc write[T: byte | char](pb: var ProtoBuffer; field: int; value: openArray[T])
• minprotobuf: proc write(pb: var ProtoBuffer; field: int; value: ProtoBuffer)
• minprotobuf: proc write[T: ProtoScalar](pb: var ProtoBuffer; field: int; value: T)
• rconn: method write(self: RelayConnection; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• protobuf: proc write(pb: var ProtoBuffer; field: int; value: Record)
• protobuf: proc write(pb: var ProtoBuffer; field: int; graft: ControlGraft)
• protobuf: proc write(pb: var ProtoBuffer; field: int; ihave: ControlIHave)
• protobuf: proc write(pb: var ProtoBuffer; field: int; imreceiving: ControlIMReceiving)
• protobuf: proc write(pb: var ProtoBuffer; field: int; iwant: ControlIWant)
• protobuf: proc write(pb: var ProtoBuffer; field: int; control: ControlMessage)
• protobuf: proc write(pb: var ProtoBuffer; field: int; preamble: ControlPreamble)
• protobuf: proc write(pb: var ProtoBuffer; field: int; prune: ControlPrune)
• protobuf: proc write(pb: var ProtoBuffer; field: int; msg: Message; anonymize: bool)
• protobuf: proc write(pb: var ProtoBuffer; field: int; infoMsg: PeerInfoMsg)
• protobuf: proc write(pb: var ProtoBuffer; field: int; subs: SubOpts)
• noise: method write(sconn: NoiseConnection; message: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• signed_envelope: proc write(pb: var ProtoBuffer; field: int; env: Envelope): Result[void, CryptoError]
• bridgestream: method write(s: BridgeStream; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• chronosstream: method write(s: ChronosStream; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• lpstream: proc write(s: LPStream; msg: string): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• lpstream: method write(s: LPStream; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• quictransport: method write(stream: QuicStream; bytes: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• wstransport: method write(s: WsStream; msg: seq[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

writeArray:

• vbuffer: proc writeArray[T: byte | char](vb: var VBuffer; value: openArray[T])

writeLp:

• lpstream: method writeLp(s: LPStream; msg: openArray[byte]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• lpstream: method writeLp(s: LPStream; msg: string): InternalRaisesFuture[void, (CancelledError, LPStreamError)]

writeLPVarint:

• vbuffer: proc writeLPVarint(vb: var VBuffer; value: LPSomeUVarint)

writeMsg:

• coder: proc writeMsg(conn: Connection; id: uint64; msgType: MessageType; data: seq[byte] = @[]): InternalRaisesFuture[void, (CancelledError, LPStreamError)]
• coder: proc writeMsg(conn: Connection; id: uint64; msgType: MessageType; data: string): InternalRaisesFuture[ void, (CancelledError, LPStreamError)]

writeOpt:

• protobuf: proc writeOpt[T](pb: var ProtoBuffer; field: int; opt: Opt[T])

writePacked:

• minprotobuf: proc writePacked[T: ProtoScalar](pb: var ProtoBuffer; field: int; value: openArray[T])

writePBVarint:

• vbuffer: proc writePBVarint(vb: var VBuffer; value: PBSomeUVarint)

writeSeq:

• vbuffer: proc writeSeq[T: byte | char](vb: var VBuffer; value: openArray[T])

writeVarint:

• vbuffer: proc writeVarint(vb: var VBuffer; value: LPSomeUVarint)

WrongPingAckError:

• ping: object WrongPingAckError

WS:

• multiaddress: const WS

WS_DNS:

• multiaddress: const WS_DNS

WS_IP:

• multiaddress: const WS_IP

WSS:

• multiaddress: const WSS

WSS_DNS:

• multiaddress: const WSS_DNS

WSS_IP:

• multiaddress: const WSS_IP

WsTransport:

• wstransport: type WsTransport

WsTransportError:

• wstransport: object WsTransportError

XorDHasher:

• types: type XorDHasher

XorDistance:

• types: type XorDistance

xorDistance:

• types: proc xorDistance(a, b: Key; hasher: Opt[XorDHasher]): XorDistance
• types: proc xorDistance(a: Key; b: PeerId; hasher: Opt[XorDHasher]): XorDistance
• types: proc xorDistance(a: PeerId; b: Key; hasher: Opt[XorDHasher]): XorDistance
• types: proc xorDistance(a, b: PeerId; hasher: Opt[XorDHasher]): XorDistance

Yamux:

• yamux: type Yamux

YamuxChannel:

• yamux: type YamuxChannel

YamuxCodec:

• yamux: const YamuxCodec

YamuxDefaultWindowSize:

• yamux: const YamuxDefaultWindowSize

YamuxError:

• yamux: object YamuxError

ZeroFe:

• constants: const ZeroFe

ZeroQueue:

• zeroqueue: object ZeroQueue

zint:

• varint: type zint

zint32:

• varint: type zint32

zint64:

• varint: type zint64